1376 lines
42 KiB
Java
1376 lines
42 KiB
Java
/*
|
|
The contents of this file are subject to the THDL Open Community License
|
|
Version 1.0 (the "License"); you may not use this file except in compliance
|
|
with the License. You may obtain a copy of the License on the THDL web site
|
|
(http://www.thdl.org/).
|
|
|
|
Software distributed under the License is distributed on an "AS IS" basis,
|
|
WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
|
|
License for the specific terms governing rights and limitations under the
|
|
License.
|
|
|
|
The Initial Developer of this software is the Tibetan and Himalayan Digital
|
|
Library (THDL). Portions created by the THDL are Copyright 2001 THDL.
|
|
All Rights Reserved.
|
|
|
|
Contributor(s): ______________________________________.
|
|
*/
|
|
|
|
package org.thdl.tib.input;
|
|
|
|
import java.util.*;
|
|
import java.awt.*;
|
|
import java.awt.datatransfer.*;
|
|
import java.awt.font.*;
|
|
import java.awt.event.*;
|
|
import javax.swing.*;
|
|
import javax.swing.text.*;
|
|
import java.lang.*;
|
|
import org.thdl.tib.text.*;
|
|
|
|
/**
|
|
* Enables input of Tibetan text
|
|
* using Tibetan Computer Company's free cross-platform TibetanMachineWeb fonts.
|
|
* Two modes of text entry are allowed. In Tibetan mode, keystrokes are intercepted
|
|
* and reinterpreted according to the Tibetan keyboard installed. The result, of
|
|
* course, is Tibetan text, in the TibetanMachineWeb encoding. In Roman mode,
|
|
* keystrokes are not intercepted, and the font defaults to a Roman or user-defined font.
|
|
* @author Edward Garrett, Tibetan and Himalayan Digital Library
|
|
* @version 1.0
|
|
*/
|
|
public class DuffPane extends JTextPane implements KeyListener, FocusListener {
|
|
/*
|
|
* A central part of the Tibetan keyboard. As keys are typed, they are
|
|
* added to charList if they constitute a valid Wylie character. charList
|
|
* is added to in this manner until the user types punctuation, a vowel,
|
|
* or some action or function key. Later, when glyphs are printed to the
|
|
* screen, the {@link #newGlyphList glyphList}) is computed on the basis
|
|
* of charList.
|
|
*/
|
|
private java.util.LinkedList charList;
|
|
/*
|
|
* This field holds a copy of the last {@link #newGlyphList}.
|
|
* Then, when a key is pressed, {@link #charList} is updated, a new
|
|
* newGlyphList is computed, and the newGlyphList is compared against
|
|
* this field. The text on the screen is then modified to reflect
|
|
* the new newGlyphList.
|
|
*/
|
|
private java.util.List oldGlyphList;
|
|
/*
|
|
* A central component of the Tibetan input method. While {@link #charList charList}
|
|
* keeps track of the characters that have been entered, it does not organize them
|
|
* correctly into the proper glyphs. For example, charList might have four characters
|
|
* in it, 'b', 's', 'g', and 'r', but it does not know that they should be drawn as
|
|
* two glyphs, 'b' and 's-g-r'. newGlyphList is a list of glyphs
|
|
* ({@link thdl.tibetan.text.DuffCode DuffCodes}) which is formed by
|
|
* @link #recomputeGlyphs(boolean areStacksOnRight, boolean definitelyTibetan, boolean definitelySanskrit) recomputeGlyphs},
|
|
* which constructs an optimal arrangement of glyphs from the charList.
|
|
*/
|
|
private java.util.List newGlyphList;
|
|
/*
|
|
* This field keeps track of what is currently being typed, to account
|
|
* for characters (such as Wylie 'tsh') which correspond to more than one
|
|
* keystroke in the keyboard. It is cleared or readjusted when it is clear
|
|
* that the user has moved on to a different character. For example, after the
|
|
* user types 'khr', holdCurrent will contain only 'r', since 'khr' is not
|
|
* a valid character.
|
|
*/
|
|
private StringBuffer holdCurrent;
|
|
/*
|
|
* This field says whether or not the character atop {@link #charList} has
|
|
* been finalized, and therefore whether subsequent keystrokes are
|
|
* allowed to displace this character. For example, if 'k' is at the top
|
|
* of charList, and isTopHypothesis is true, then typing 'h' would replace
|
|
* 'k' with 'kh'. On the other hand, were isTopHypothesis false, then typing
|
|
* 'h' would add 'h' to the top of charList instead.
|
|
*/
|
|
private boolean isTopHypothesis;
|
|
/*
|
|
* Is the user in the process of typing a vowel?
|
|
*/
|
|
private boolean isTypingVowel;
|
|
/*
|
|
* Is it definitely the case that the user is typing Tibetan, rather than
|
|
* Sanskrit?
|
|
*/
|
|
private boolean isDefinitelyTibetan;
|
|
/*
|
|
* According to the active keyboard, what value is
|
|
* {@link #isDefinitelyTibetan} assigned by default when the
|
|
* keyboard is initialized by {@link #initKeyboard() initKeyboard}?
|
|
*/
|
|
private boolean isDefinitelyTibetan_default;
|
|
/*
|
|
* According to the active keyboard, what value should
|
|
* be assigned to {@link #isDefinitelyTibetan} if the
|
|
* user has initiated a stack by typing a stack key?
|
|
* For example, in the Wylie keyboard, there is a Sanskrit
|
|
* stacking key ('+'), but no Tibetan stacking key.
|
|
* Therefore, if the user is stacking with '+', this field
|
|
* should be false, since what the user is typing must
|
|
* be Sanskrit, not Tibetan.
|
|
*/
|
|
private boolean isDefinitelyTibetan_withStackKey;
|
|
/*
|
|
* Is it definitely the case that the user is typing Sanskrit
|
|
* (e.g. a Sanskrit stack), rather than Tibetan?
|
|
*/
|
|
private boolean isDefinitelySanskrit;
|
|
/*
|
|
* According to the active keyboard, what value is
|
|
* {@link #isDefinitelySanskrit} assigned by default when the
|
|
* keyboard is initialized by {@link #initKeyboard() initKeyboard}?
|
|
*/
|
|
private boolean isDefinitelySanskrit_default;
|
|
/*
|
|
* According to the active keyboard, what value should
|
|
* be assigned to {@link #isDefinitelySanskrit} if the
|
|
* user has initiated a stack by typing a stack key?
|
|
* For example, in the Wylie keyboard, there is a Sanskrit
|
|
* stacking key ('+'), but no Tibetan stacking key.
|
|
* Therefore, if the user is stacking with '+', this field
|
|
* should be true, since what the user is typing must
|
|
* be Sanskrit, not Tibetan.
|
|
*/
|
|
private boolean isDefinitelySanskrit_withStackKey;
|
|
/*
|
|
* Is consonant stacking allowed at the moment? In the Wylie
|
|
* keyboard, consonant stacking is usually on, since stacking
|
|
* is automatic. However, in the TCC and Sambhota keyboards,
|
|
* stacking is off by default, since you can only stack when
|
|
* you've pressed a stacking key.
|
|
*/
|
|
private boolean isStackingOn;
|
|
/*
|
|
* According to the active keyboard, is stacking on by
|
|
* default or not, assuming no stack key has been pressed?
|
|
*/
|
|
private boolean isStackingOn_default;
|
|
/*
|
|
* Automatic stacking in Wylie is from right to left. For
|
|
* example, if the user types 'brg', the resulting glyph
|
|
* sequence is 'b' plus 'rg', not 'br' plus 'g'. If
|
|
* stacking results from the use of a stack key,
|
|
* it is from left to right.
|
|
*/
|
|
private boolean isStackingRightToLeft;
|
|
/*
|
|
* If the character last displayed was a vowel,
|
|
* how many glyphs is the vowel composed of?
|
|
* (Some vowels, such as Wylie 'I', consist of
|
|
* two glyphs.)
|
|
*/
|
|
private int numberOfGlyphsForLastVowel;
|
|
/*
|
|
* used for tracking changes in Wylie to TMW conversion
|
|
*/
|
|
private int lastStart;
|
|
/*
|
|
* is the user in Tibetan typing mode? this is true
|
|
* by default
|
|
*/
|
|
private boolean isTibetan = true;
|
|
/*
|
|
* is the user allowed to type non-Tibetan? this is true
|
|
* by default
|
|
*/
|
|
private boolean isRomanEnabled = true;
|
|
/*
|
|
* The document displayed by this object.
|
|
*/
|
|
private TibetanDocument doc;
|
|
/*
|
|
* The caret of {@link #doc}, used to keep track of the
|
|
* current entry/edit/deletion position.
|
|
*/
|
|
private Caret caret;
|
|
private StyledEditorKit editorKit;
|
|
private StyleContext styleContext;
|
|
private Style rootStyle;
|
|
private boolean skipUpdate = false;
|
|
private boolean isCutAndPasteEnabled = true;
|
|
|
|
private String romanFontFamily;
|
|
private int romanFontSize;
|
|
private MutableAttributeSet romanAttributeSet;
|
|
|
|
public DuffPane() {
|
|
this(new StyledEditorKit());
|
|
}
|
|
|
|
public DuffPane(TibetanKeyboard keyboard) {
|
|
this(new StyledEditorKit(), keyboard);
|
|
}
|
|
|
|
public DuffPane(java.net.URL keyboardURL) {
|
|
this(new StyledEditorKit(), keyboardURL);
|
|
}
|
|
|
|
public DuffPane(StyledEditorKit styledEditorKit) {
|
|
setupKeyboard();
|
|
setupEditor(styledEditorKit);
|
|
}
|
|
|
|
public DuffPane(StyledEditorKit styledEditorKit, TibetanKeyboard keyboard) {
|
|
TibetanMachineWeb.setKeyboard(keyboard);
|
|
setupKeyboard();
|
|
setupEditor(styledEditorKit);
|
|
}
|
|
|
|
public DuffPane(StyledEditorKit styledEditorKit, java.net.URL keyboardURL) {
|
|
TibetanMachineWeb.setKeyboard(keyboardURL);
|
|
setupKeyboard();
|
|
setupEditor(styledEditorKit);
|
|
}
|
|
|
|
/**
|
|
* This method sets up the editor, assigns fonts and point sizes,
|
|
* sets the document, the caret, and adds key and focus listeners.
|
|
*
|
|
* @param sek the StyledEditorKit for the editing window
|
|
*/
|
|
private void setupEditor(StyledEditorKit sek) {
|
|
romanFontFamily = "Serif";
|
|
romanFontSize = 14;
|
|
setRomanAttributeSet(romanFontFamily, romanFontSize);
|
|
|
|
editorKit = sek;
|
|
setEditorKit(editorKit);
|
|
styleContext = new StyleContext();
|
|
|
|
Style defaultStyle = styleContext.getStyle(StyleContext.DEFAULT_STYLE);
|
|
rootStyle = styleContext.addStyle("RootStyle", defaultStyle);
|
|
StyleConstants.setFontFamily(rootStyle, "TibetanMachineWeb");
|
|
StyleConstants.setFontSize(rootStyle, 36);
|
|
setLogicalStyle(rootStyle);
|
|
|
|
newDocument();
|
|
caret = getCaret();
|
|
|
|
addKeyListener(this);
|
|
addFocusListener(this);
|
|
}
|
|
|
|
/**
|
|
* This method sets up the Tibetan keyboard. Initially it is called
|
|
* by the constructor, but it is also called internally whenever
|
|
* the active keyboard is changed. It first sets various values with
|
|
* respect to stacking, and concerning the differences between
|
|
* Tibetan and Sanskrit; and then it initializes the input method.
|
|
*/
|
|
private void setupKeyboard() {
|
|
if (TibetanMachineWeb.hasTibetanStackingKey()) {
|
|
if (TibetanMachineWeb.hasSanskritStackingKey()) {
|
|
isDefinitelyTibetan_default = false;
|
|
isDefinitelySanskrit_default = false;
|
|
isStackingOn_default = false;
|
|
isDefinitelyTibetan_withStackKey = false;
|
|
isDefinitelySanskrit_withStackKey = false;
|
|
}
|
|
else {
|
|
isDefinitelyTibetan_default = false;
|
|
isDefinitelySanskrit_default = true;
|
|
isStackingOn_default = true;
|
|
isDefinitelyTibetan_withStackKey = true;
|
|
isDefinitelySanskrit_withStackKey = false;
|
|
}
|
|
}
|
|
else {
|
|
if (TibetanMachineWeb.hasSanskritStackingKey()) {
|
|
isDefinitelyTibetan_default = true;
|
|
isDefinitelySanskrit_default = false;
|
|
isStackingOn_default = true;
|
|
isDefinitelyTibetan_withStackKey = false;
|
|
isDefinitelySanskrit_withStackKey = true;
|
|
}
|
|
else { //no stacking key at all
|
|
isDefinitelyTibetan_default = false;
|
|
isDefinitelySanskrit_default = false;
|
|
isStackingOn_default = true;
|
|
}
|
|
}
|
|
charList = new LinkedList();
|
|
oldGlyphList = new ArrayList();
|
|
newGlyphList = new ArrayList();
|
|
initKeyboard();
|
|
}
|
|
|
|
/**
|
|
* Registers the Extended Wylie keyboard, and sets it as
|
|
* the active keyboard.
|
|
* Unpredictable behavior will result
|
|
* if you set the keyboard in {@link org.thdl.tib.text.TibetanMachineWeb TibetanMachineWeb}
|
|
* but don't register it here.
|
|
*/
|
|
public void registerKeyboard() {
|
|
TibetanKeyboard tk = null;
|
|
registerKeyboard(tk);
|
|
}
|
|
|
|
/**
|
|
* Registers a keyboard, and sets it as
|
|
* the active keyboard. * Unpredictable behavior will result
|
|
* if you set the keyboard in {@link org.thdl.tib.text.TibetanMachineWeb TibetanMachineWeb}
|
|
* but don't register it in here.
|
|
* @param keyboardURL the URL of the keyboard you want to install
|
|
*/
|
|
public void registerKeyboard(java.net.URL keyboardURL) {
|
|
TibetanMachineWeb.setKeyboard(keyboardURL);
|
|
setupKeyboard();
|
|
}
|
|
|
|
/**
|
|
* Registers a keyboard, and sets it as
|
|
* the active keyboard.
|
|
* Unpredictable behavior will result
|
|
* if you set the keyboard in {@link org.thdl.tib.text.TibetanMachineWeb TibetanMachineWeb}
|
|
* but don't register it in here.
|
|
* @param keyboard the keyboard you want to install
|
|
*/
|
|
public void registerKeyboard(TibetanKeyboard keyboard) {
|
|
TibetanMachineWeb.setKeyboard(keyboard);
|
|
setupKeyboard();
|
|
}
|
|
|
|
/**
|
|
* Clears the current document.
|
|
*/
|
|
public void newDocument() {
|
|
doc = new TibetanDocument(styleContext);
|
|
doc.setTibetanFontSize(36);
|
|
setDocument(doc);
|
|
setLogicalStyle(rootStyle);
|
|
}
|
|
|
|
/**
|
|
* Initializes the keyboard input interpreter, setting all properties
|
|
* back to their default states. This method is called whenever an action
|
|
* or function key is pressed, and also whenever the user types punctuation
|
|
* or a vowel. It is not called when the user is typing characters that
|
|
* could be part of a stack, or require manipulation of glyphs - e.g.
|
|
* backspacing, redrawing, etc.
|
|
*/
|
|
public void initKeyboard() {
|
|
charList.clear();
|
|
oldGlyphList.clear();
|
|
holdCurrent = new StringBuffer();
|
|
isTopHypothesis = false;
|
|
isTypingVowel = false;
|
|
numberOfGlyphsForLastVowel = 0;
|
|
|
|
//for keyboard
|
|
isStackingOn = isStackingOn_default;
|
|
isStackingRightToLeft = true;
|
|
isDefinitelyTibetan = isDefinitelyTibetan_default;
|
|
isDefinitelySanskrit = isDefinitelySanskrit_default;
|
|
}
|
|
|
|
/**
|
|
* Enables typing of Roman (non-Tibetan) text along
|
|
* with Tibetan.
|
|
*/
|
|
public void enableRoman() {
|
|
isRomanEnabled = true;
|
|
}
|
|
|
|
/**
|
|
* Disables typing of Roman (non-Tibetan) text.
|
|
*/
|
|
public void disableRoman() {
|
|
isRomanEnabled = false;
|
|
}
|
|
|
|
/**
|
|
* Checks to see if Roman input is enabled.
|
|
* @return true if so, false if not
|
|
*/
|
|
public boolean isRomanEnabled() {
|
|
return isRomanEnabled;
|
|
}
|
|
|
|
/**
|
|
* Checks to see if currently in Roman input mode.
|
|
* @return true if so, false if not
|
|
*/
|
|
public boolean isRomanMode() {
|
|
return !isTibetan;
|
|
}
|
|
|
|
/**
|
|
* Toggles between Tibetan and Roman input modes.
|
|
* Does nothing if Roman input is disabled.
|
|
* @see #enableRoman()
|
|
* @see #disableRoman()
|
|
*/
|
|
public void toggleLanguage() {
|
|
if (isTibetan && isRomanEnabled)
|
|
isTibetan = false;
|
|
else
|
|
isTibetan = true;
|
|
}
|
|
|
|
/**
|
|
* Inserts Roman text into this object's document,
|
|
* at the position of the caret.
|
|
* @param attr the attributes for the text to insert
|
|
* @param s the string of text to insert
|
|
*/
|
|
public void append(String s, MutableAttributeSet attr) {
|
|
append(caret.getDot(), s, attr);
|
|
}
|
|
|
|
/**
|
|
* Inserts Roman text into this object's document.
|
|
* @param offset the position at which to insert text
|
|
* @param attr the attributes for the text to insert
|
|
* @param s the string of text to insert
|
|
*/
|
|
public void append(int offset, String s, MutableAttributeSet attr) {
|
|
try {
|
|
doc.insertString(offset, s, attr);
|
|
}
|
|
catch (BadLocationException ble) {
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Changes the default font size for Tibetan text entry mode.
|
|
*
|
|
* @param size a point size
|
|
*/
|
|
public void setTibetanFontSize(int size) {
|
|
if (size > 0)
|
|
doc.setTibetanFontSize(size);
|
|
}
|
|
|
|
/**
|
|
* Gets the current point size for Tibetan text.
|
|
* @return the current default font size for Tibetan
|
|
* text entry mode
|
|
*/
|
|
public int getTibetanFontSize() {
|
|
return doc.getTibetanFontSize();
|
|
}
|
|
|
|
/**
|
|
* Changes the default font and font size for
|
|
* non-Tibetan (Roman) text entry mode.
|
|
*
|
|
* @param font a font name
|
|
* @param size a point size
|
|
*/
|
|
public void setRomanAttributeSet(String font, int size) {
|
|
romanAttributeSet = new SimpleAttributeSet();
|
|
StyleConstants.setFontFamily(romanAttributeSet, font);
|
|
StyleConstants.setFontSize(romanAttributeSet, size);
|
|
}
|
|
|
|
/**
|
|
* Gets the current point size for non-Tibetan text.
|
|
* @return the current default font size for non-Tibetan
|
|
* (Roman) text entry mode
|
|
*/
|
|
public int getRomanFontSize() {
|
|
return romanFontSize;
|
|
}
|
|
|
|
/**
|
|
* Gets the current font used for non-Tibetan text.
|
|
* @return the current default font for non-Tibetan
|
|
* (Roman) text entry mode
|
|
*/
|
|
public String getRomanFontFamily() {
|
|
return romanFontFamily;
|
|
}
|
|
|
|
/**
|
|
* Backspace and remove k elements from the current caret position.
|
|
*
|
|
* @param k the number of glyphs to remove by backspace
|
|
*/
|
|
private void backSpace(int k) {
|
|
try {
|
|
doc.remove(caret.getDot()-k, k);
|
|
}
|
|
catch (BadLocationException ble) {
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Takes an old glyph list, which should be the currently visible set of glyphs preceding the cursor, and
|
|
* then tries to redraw the glyphs in light of the newly acquired keyboard input (which led to a revised
|
|
* 'new' glyph list). For example, the old glyph list might contain 'l' and 'n', because the user had typed
|
|
* 'ln' in Extended Wylie mode. This is what you'd see on the screen. But assume that the new glyph list
|
|
* contains the stacked glyph 'l-ng', because the user has just finished typing 'lng'. This method
|
|
* compares the glyphs, then figures out whether or not backspacing is necessary, and draws whatever characters
|
|
* need to be drawn.
|
|
* For example, suppose that oldGlyphList contains the two glyphs 'l' and 'n', and newGlyphList contains a single glyph, 'lng'.
|
|
* In this case, redrawGlyphs will be instructed to backspace over both 'l' and 'n', and then insert 'lng'.
|
|
*/
|
|
private java.util.List redrawGlyphs(java.util.List oldGlyphList, java.util.List newGlyphList) {
|
|
if (newGlyphList.isEmpty())
|
|
return newGlyphList;
|
|
|
|
Iterator newIter = newGlyphList.iterator();
|
|
DuffCode newDc = (DuffCode)newIter.next();
|
|
|
|
int oldGlyphCount = oldGlyphList.size();
|
|
int newGlyphCount = newGlyphList.size();
|
|
int beginDifference = -1; //at what point does the new glyph list begin to differ from the old one?
|
|
int k=0;
|
|
|
|
if (oldGlyphCount!=0) {
|
|
int smallerGlyphCount;
|
|
DuffCode oldDc;
|
|
|
|
if (oldGlyphCount < newGlyphCount)
|
|
smallerGlyphCount = oldGlyphCount;
|
|
else
|
|
smallerGlyphCount = newGlyphCount;
|
|
|
|
Iterator oldIter = oldGlyphList.iterator();
|
|
|
|
for (; k<smallerGlyphCount; k++) {
|
|
oldDc = (DuffCode)oldIter.next();
|
|
|
|
if (!oldDc.equals(newDc)) {
|
|
beginDifference = k;
|
|
break;
|
|
}
|
|
if (newIter.hasNext())
|
|
newDc = (DuffCode)newIter.next();
|
|
}
|
|
|
|
if (beginDifference == -1)
|
|
beginDifference = smallerGlyphCount;
|
|
|
|
if (beginDifference == newGlyphCount) {
|
|
if (oldGlyphCount > newGlyphCount)
|
|
backSpace(oldGlyphCount-newGlyphCount); //deals with 'pd+m' problem
|
|
|
|
return newGlyphList; //there is no difference between new and old glyph lists
|
|
}
|
|
}
|
|
|
|
if (beginDifference != -1)
|
|
backSpace(oldGlyphCount - beginDifference);
|
|
|
|
java.util.List sublist = newGlyphList.subList(k, newGlyphCount);
|
|
TibetanDocument.DuffData[] dd = TibetanDocument.convertGlyphs(sublist);
|
|
doc.insertDuff(caret.getDot(), dd);
|
|
return newGlyphList;
|
|
}
|
|
|
|
/**
|
|
* Tries to insert the vowel v at the position of the caret.
|
|
* This method must deal with various issues, such as: can the preceding
|
|
* glyph take a vowel? If not, then what? If the preceding glyph can be
|
|
* followed by a vowel, then the method has to figure out what vowel
|
|
* glyph to affix, which may depend on the immediately preceding glyph,
|
|
* but may depend on other factors as well. For example, when affixing
|
|
* gigu to the consonantal stack "k'" (ie k plus achung), the value of
|
|
* the gigu will depend on "k", not "'".
|
|
*
|
|
* @param v the vowel (in Wylie) you want to insert
|
|
*/
|
|
private void putVowel(String v) {
|
|
if (caret.getDot()==0) {
|
|
if (!TibetanMachineWeb.isAChenRequiredBeforeVowel())
|
|
printAChenWithVowel(v);
|
|
|
|
return;
|
|
}
|
|
|
|
AttributeSet attr = doc.getCharacterElement(caret.getDot()-1).getAttributes();
|
|
String fontName = StyleConstants.getFontFamily(attr);
|
|
int fontNum;
|
|
|
|
if (0 != (fontNum = TibetanMachineWeb.getTMWFontNumber(fontName))) {
|
|
try {
|
|
char c2 = doc.getText(caret.getDot()-1, 1).charAt(0);
|
|
int k = (int)c2;
|
|
if (k<32 || k>126) { //if previous character is formatting or some other non-character
|
|
if (!TibetanMachineWeb.isAChenRequiredBeforeVowel())
|
|
printAChenWithVowel(v);
|
|
|
|
return;
|
|
}
|
|
|
|
String wylie = TibetanMachineWeb.getWylieForGlyph(fontNum, k);
|
|
if (TibetanMachineWeb.isWyliePunc(wylie)) {
|
|
if (charList.isEmpty() && !TibetanMachineWeb.isAChenRequiredBeforeVowel()) {
|
|
printAChenWithVowel(v);
|
|
return;
|
|
}
|
|
}
|
|
|
|
DuffCode dc_1 = null;
|
|
DuffCode dc_2 = new DuffCode(fontNum, c2);
|
|
|
|
if (caret.getDot() > 2) {
|
|
attr = doc.getCharacterElement(caret.getDot()-2).getAttributes();
|
|
fontName = StyleConstants.getFontFamily(attr);
|
|
if (0 != (fontNum = TibetanMachineWeb.getTMWFontNumber(fontName))) {
|
|
c2 = doc.getText(caret.getDot()-2, 1).charAt(0);
|
|
dc_1 = new DuffCode(fontNum, c2);
|
|
}
|
|
}
|
|
|
|
java.util.List before_vowel = new ArrayList();
|
|
if (null != dc_1)
|
|
before_vowel.add(dc_1);
|
|
|
|
before_vowel.add(dc_2);
|
|
java.util.List after_vowel = TibetanDocument.getVowel(dc_1, dc_2, v);
|
|
redrawGlyphs(before_vowel, after_vowel);
|
|
}
|
|
catch(BadLocationException ble) {
|
|
System.out.println("no--can't insert here");
|
|
}
|
|
}
|
|
else { //0 font means not Tibetan font, so begin new Tibetan font section
|
|
if (!TibetanMachineWeb.isAChenRequiredBeforeVowel())
|
|
printAChenWithVowel(v);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prints ACHEN together with the vowel v. When using the Wylie
|
|
* keyboard, or any other keyboard in which {@link thdl.tibetan.text.TibetanMachineWeb#isAChenRequiredBeforeVowel() isAChenRequiredBeforeVowel()}
|
|
* is false, this method is called frequently.
|
|
*
|
|
* @param v the vowel (in Wylie) which you want to print with ACHEN
|
|
*/
|
|
private void printAChenWithVowel(String v) {
|
|
DuffCode[] dc_array = (DuffCode[])TibetanMachineWeb.getTibHash().get(TibetanMachineWeb.ACHEN);
|
|
DuffCode dc = dc_array[TibetanMachineWeb.TMW];
|
|
java.util.List achenlist = TibetanDocument.getVowel(dc,v);
|
|
TibetanDocument.DuffData[] dd = TibetanDocument.convertGlyphs(achenlist);
|
|
doc.insertDuff(caret.getDot(), dd);
|
|
}
|
|
|
|
/**
|
|
* Puts a bindu/anusvara at the current caret position.
|
|
* In the TibetanMachineWeb font, top vowels (like gigu,
|
|
* drengbu, etc.) are merged together with bindu in a
|
|
* single glyph. This method deals with the problem of
|
|
* correctly displaying a bindu given this complication.
|
|
*/
|
|
private void putBindu() {
|
|
special_bindu_block: {
|
|
if (caret.getDot()==0)
|
|
break special_bindu_block;
|
|
|
|
AttributeSet attr = doc.getCharacterElement(caret.getDot()-1).getAttributes();
|
|
String fontName = StyleConstants.getFontFamily(attr);
|
|
int fontNum;
|
|
|
|
if (0 == (fontNum = TibetanMachineWeb.getTMWFontNumber(fontName)))
|
|
break special_bindu_block;
|
|
|
|
try {
|
|
char c2 = doc.getText(caret.getDot()-1, 1).charAt(0);
|
|
int k = (int)c2;
|
|
if (k<32 || k>126) //if previous character is formatting or some other non-character
|
|
break special_bindu_block;
|
|
|
|
String wylie = TibetanMachineWeb.getWylieForGlyph(fontNum, k);
|
|
if (!TibetanMachineWeb.isWylieVowel(wylie))
|
|
break special_bindu_block;
|
|
|
|
DuffCode dc = new DuffCode(fontNum, c2);
|
|
java.util.List beforecaret = new ArrayList();
|
|
beforecaret.add(dc);
|
|
java.util.List bindulist = TibetanDocument.getBindu(dc);
|
|
redrawGlyphs(beforecaret, bindulist);
|
|
initKeyboard();
|
|
return;
|
|
}
|
|
catch(BadLocationException ble) {
|
|
System.out.println("no--can't do this bindu maneuver");
|
|
}
|
|
}
|
|
|
|
TibetanDocument.DuffData[] dd = TibetanDocument.convertGlyphs(TibetanDocument.getBindu(null));
|
|
doc.insertDuff(caret.getDot(), dd);
|
|
initKeyboard();
|
|
}
|
|
|
|
/**
|
|
* Required by implementations of the
|
|
* {@link java.awt.event.FocusListener FocusListener} interface,
|
|
* this method simply initializes the keyboard whenever this
|
|
* object gains focus.
|
|
*
|
|
* @param e a FocusEvent
|
|
*/
|
|
public void focusGained(FocusEvent e) {
|
|
}
|
|
|
|
/**
|
|
* Required by implementations of the
|
|
* {@link java.awt.event.FocusListener FocusListener} interface,
|
|
* this method does nothing.
|
|
*
|
|
* @param e a FocusEvent
|
|
*/
|
|
public void focusLost(FocusEvent e) {
|
|
initKeyboard();
|
|
}
|
|
|
|
/**
|
|
* Cuts or copies the specified portion of this object's document
|
|
* to the system clipboard. What is cut/copied is Wylie text -
|
|
* so, if you cut/copy a region of TibetanMachineWeb, it first converts
|
|
* it to Wylie before putting it on the clipboard. If the user
|
|
* tries to cut/copy non-TibetanMachineWeb, only the text preceding the
|
|
* first non-TibetanMachineWeb character is cut/copied.
|
|
* @param start the begin offset of the copy
|
|
* @param end the end offset of the copy
|
|
* @param remove this should be true if the operation is 'cut',
|
|
* false if it is 'copy'
|
|
*/
|
|
public void copy(int start, int end, boolean remove) {
|
|
if (start < end) {
|
|
java.util.List dcs = new ArrayList();
|
|
|
|
try {
|
|
AttributeSet attr;
|
|
String fontName;
|
|
int fontNum;
|
|
DuffCode dc;
|
|
char ch;
|
|
|
|
int i = start;
|
|
|
|
while (i < end+1) {
|
|
attr = doc.getCharacterElement(i).getAttributes();
|
|
fontName = StyleConstants.getFontFamily(attr);
|
|
|
|
if ((0 == (fontNum = TibetanMachineWeb.getTMWFontNumber(fontName))) || i==end) {
|
|
if (i != start) {
|
|
DuffCode[] dc_array = new DuffCode[0];
|
|
dc_array = (DuffCode[])dcs.toArray(dc_array);
|
|
StringSelection data = new StringSelection(TibetanDocument.getWylie(dc_array));
|
|
Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
|
|
clipboard.setContents(data, data);
|
|
if (remove) {
|
|
doc.remove(start, i-start);
|
|
setSelectionEnd(start);
|
|
}
|
|
else {
|
|
setSelectionStart(start);
|
|
setSelectionEnd(i);
|
|
}
|
|
return;
|
|
}
|
|
else {
|
|
setSelectionEnd(start);
|
|
return;
|
|
}
|
|
}
|
|
else {
|
|
ch = doc.getText(i,1).charAt(0);
|
|
dc = new DuffCode(fontNum, ch);
|
|
dcs.add(dc);
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
catch (BadLocationException ble) {
|
|
ble.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Pastes the contents of the system clipboard into this object's
|
|
* document, at the specified position. The only kind of
|
|
* text accepted from the clipboard is Wylie text.
|
|
* This Wylie is converted and pasted into the document as
|
|
* TibetanMachineWeb. If the text to paste is invalid Wylie,
|
|
* then it will not be pasted, and instead an error message will
|
|
* appear.
|
|
* @param offset the position in the document you want to paste to
|
|
*/
|
|
public void paste(int offset) {
|
|
Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
|
|
Transferable data = clipboard.getContents(this);
|
|
|
|
String s = null;
|
|
try {
|
|
s = (String)(data.getTransferData(DataFlavor.stringFlavor));
|
|
}
|
|
catch (Exception e) {
|
|
s = data.toString();
|
|
}
|
|
|
|
if (s != null)
|
|
toTibetanMachineWeb(s, offset);
|
|
}
|
|
|
|
/**
|
|
* Enables cutting and pasting of Tibetan text.
|
|
*/
|
|
public void enableCutAndPaste() {
|
|
isCutAndPasteEnabled = true;
|
|
}
|
|
|
|
/**
|
|
* Disables cutting and pasting of Tibetan text.
|
|
* Cut and paste must be disabled if Jskad's
|
|
* parent is an applet, because it violates the
|
|
* Java security sandbox to cut and paste from an
|
|
* applet to the system clipboard.
|
|
*/
|
|
public void disableCutAndPaste() {
|
|
isCutAndPasteEnabled = false;
|
|
}
|
|
|
|
/**
|
|
* This method is required as part of the
|
|
* implementation of the KeyListener
|
|
* interface.
|
|
*
|
|
* Basically this method only handles action keys -
|
|
* Escape, Ctrl-c, Ctrl-x, etc, and TAB and ENTER.
|
|
* Other keystrokes are handled by keyTyped.
|
|
*/
|
|
public void keyPressed(KeyEvent e) {
|
|
if (e.isActionKey())
|
|
initKeyboard();
|
|
|
|
int code = e.getKeyCode();
|
|
|
|
switch (code) {
|
|
case KeyEvent.VK_ESCAPE:
|
|
e.consume();
|
|
initKeyboard();
|
|
// toggleLanguage();
|
|
break;
|
|
|
|
case KeyEvent.VK_A:
|
|
if (e.isControlDown() && isCutAndPasteEnabled) {
|
|
e.consume();
|
|
setSelectionStart(0);
|
|
setSelectionEnd(doc.getLength());
|
|
}
|
|
break;
|
|
|
|
case KeyEvent.VK_C:
|
|
if (e.isControlDown() && isCutAndPasteEnabled) {
|
|
e.consume();
|
|
copy(getSelectionStart(), getSelectionEnd(), false);
|
|
}
|
|
break;
|
|
|
|
case KeyEvent.VK_X:
|
|
if (e.isControlDown() && isCutAndPasteEnabled) {
|
|
e.consume();
|
|
copy(getSelectionStart(), getSelectionEnd(), true);
|
|
}
|
|
break;
|
|
|
|
case KeyEvent.VK_V:
|
|
if (e.isControlDown() && isCutAndPasteEnabled) {
|
|
e.consume();
|
|
paste(caret.getDot());
|
|
}
|
|
break;
|
|
|
|
case KeyEvent.VK_TAB:
|
|
e.consume();
|
|
initKeyboard();
|
|
if (isTibetan)
|
|
doc.appendDuff(caret.getDot()," ",TibetanMachineWeb.getAttributeSet(1));
|
|
else
|
|
append(" ", romanAttributeSet);
|
|
break;
|
|
|
|
case KeyEvent.VK_ENTER:
|
|
e.consume();
|
|
initKeyboard();
|
|
if (isTibetan)
|
|
doc.appendDuff(caret.getDot(),"\n",TibetanMachineWeb.getAttributeSet(1));
|
|
else
|
|
append("\n", romanAttributeSet);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Required of implementations of the Key Listener interface,
|
|
* this method does (almost) nothing.
|
|
*
|
|
* @param e the KeyEvent
|
|
*/
|
|
public void keyReleased(KeyEvent e) {
|
|
/*
|
|
* Apparently it works best to check for backspace
|
|
* and init the keyboard here in key released
|
|
* though i don't really know why...
|
|
*/
|
|
int code = e.getKeyCode();
|
|
|
|
if (code == KeyEvent.VK_BACK_SPACE)
|
|
initKeyboard();
|
|
}
|
|
|
|
/**
|
|
* Required of implementations of the KeyListener interface,
|
|
* this method handles the pressing of non-control and non-action keys. If the user
|
|
* is in Tibetan typing mode, then the KeyEvent
|
|
* e is consumed, and passed on to {@link #processTibetan(KeyEvent e)}, which
|
|
* contains the meat of the keyboard logic. If the user is in English mode, then
|
|
* {@link #append(String s, MutableAttributeSet attr) append} is called.
|
|
*
|
|
* @param e a KeyEvent
|
|
*/
|
|
public void keyTyped(KeyEvent e) {
|
|
e.consume();
|
|
|
|
if (isTibetan)
|
|
processTibetan(e);
|
|
else {
|
|
if (e.isControlDown() || e.isAltDown())
|
|
return;
|
|
|
|
char c = e.getKeyChar();
|
|
|
|
switch (c) {
|
|
case KeyEvent.VK_TAB:
|
|
case KeyEvent.VK_ENTER:
|
|
case KeyEvent.VK_ESCAPE:
|
|
break;
|
|
|
|
case KeyEvent.VK_BACK_SPACE:
|
|
backSpace(1);
|
|
break;
|
|
|
|
default:
|
|
append(String.valueOf(c), romanAttributeSet);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Interprets a key typed during Tibetan input mode.
|
|
* This method keeps track of which characters the user has and is typing,
|
|
* and also of whether or not the user is in stacking
|
|
* mode. Most of the keyboard logic can be found here.
|
|
*
|
|
* @param e a KeyEvent
|
|
*/
|
|
public void processTibetan(KeyEvent e) {
|
|
char c = e.getKeyChar();
|
|
|
|
int start = getSelectionStart();
|
|
int end = getSelectionEnd();
|
|
boolean shouldIBackSpace = true;
|
|
|
|
if (e.isControlDown() || e.isAltDown())
|
|
return;
|
|
|
|
if (start != end) {
|
|
if (e.getKeyCode() != KeyEvent.VK_ESCAPE) {
|
|
try {
|
|
initKeyboard();
|
|
doc.remove(start, end-start);
|
|
shouldIBackSpace = false;
|
|
}
|
|
catch (BadLocationException ble) {
|
|
}
|
|
}
|
|
}
|
|
|
|
key_block:
|
|
{
|
|
|
|
if (TibetanMachineWeb.hasDisambiguatingKey())
|
|
if (c == TibetanMachineWeb.getDisambiguatingKey()) {
|
|
initKeyboard();
|
|
break key_block;
|
|
};
|
|
|
|
if (TibetanMachineWeb.hasSanskritStackingKey() || TibetanMachineWeb.hasTibetanStackingKey()) {
|
|
if (c == TibetanMachineWeb.getStackingKey()) {
|
|
if (TibetanMachineWeb.isStackingMedial()) {
|
|
int size = charList.size();
|
|
|
|
if (size == 0)
|
|
initKeyboard();
|
|
|
|
else if (size > 1 && isStackingRightToLeft) {
|
|
String s = (String)charList.removeLast();
|
|
newGlyphList = TibetanDocument.getGlyphs(charList, isStackingRightToLeft, isDefinitelyTibetan, isDefinitelySanskrit);
|
|
oldGlyphList = redrawGlyphs(oldGlyphList, newGlyphList);
|
|
initKeyboard();
|
|
charList.add(s);
|
|
newGlyphList = TibetanDocument.getGlyphs(charList, isStackingRightToLeft, isDefinitelyTibetan, isDefinitelySanskrit);
|
|
oldGlyphList = redrawGlyphs(oldGlyphList, newGlyphList);
|
|
holdCurrent = new StringBuffer();
|
|
isTopHypothesis = false;
|
|
isStackingOn = true;
|
|
isStackingRightToLeft = false;
|
|
isDefinitelyTibetan = isDefinitelyTibetan_withStackKey;
|
|
isDefinitelySanskrit = isDefinitelySanskrit_withStackKey;
|
|
}
|
|
else {
|
|
holdCurrent = new StringBuffer();
|
|
isTopHypothesis = false;
|
|
isStackingOn = true;
|
|
isStackingRightToLeft = false;
|
|
isDefinitelyTibetan = isDefinitelyTibetan_withStackKey;
|
|
isDefinitelySanskrit = isDefinitelySanskrit_withStackKey;
|
|
}
|
|
break key_block;
|
|
}
|
|
else { //stacking must be pre/post
|
|
if (!isStackingOn || (isStackingOn && isDefinitelyTibetan==isDefinitelyTibetan_default)) {
|
|
initKeyboard();
|
|
isStackingOn = true;
|
|
isStackingRightToLeft = false;
|
|
isDefinitelyTibetan = isDefinitelyTibetan_withStackKey;
|
|
isDefinitelySanskrit = isDefinitelySanskrit_withStackKey;
|
|
}
|
|
else {try {
|
|
char ch = doc.getText(caret.getDot()-1, 1).charAt(0);
|
|
AttributeSet attr = doc.getCharacterElement(caret.getDot()-1).getAttributes();
|
|
String fontName = StyleConstants.getFontFamily(attr);
|
|
int fontNum = TibetanMachineWeb.getTMWFontNumber(fontName);
|
|
|
|
if (0 == fontNum) {
|
|
initKeyboard();
|
|
isStackingOn = true;
|
|
isStackingRightToLeft = false;
|
|
isDefinitelyTibetan = isDefinitelyTibetan_withStackKey;
|
|
isDefinitelySanskrit = isDefinitelySanskrit_withStackKey;
|
|
}
|
|
else {
|
|
initKeyboard();
|
|
DuffCode dc = new DuffCode(fontNum, ch);
|
|
|
|
if (!TibetanMachineWeb.isStack(dc) && !TibetanMachineWeb.isSanskritStack(dc)) {
|
|
isStackingOn = true;
|
|
isStackingRightToLeft = false;
|
|
isDefinitelyTibetan = isDefinitelyTibetan_withStackKey;
|
|
isDefinitelySanskrit = isDefinitelySanskrit_withStackKey;
|
|
}
|
|
}
|
|
}
|
|
catch (BadLocationException ble) {
|
|
initKeyboard();
|
|
}}
|
|
break key_block;
|
|
}
|
|
}
|
|
}
|
|
|
|
switch (c) {
|
|
case KeyEvent.VK_TAB:
|
|
case KeyEvent.VK_ENTER:
|
|
case KeyEvent.VK_ESCAPE:
|
|
initKeyboard();
|
|
break;
|
|
|
|
case KeyEvent.VK_BACK_SPACE:
|
|
if (shouldIBackSpace) {
|
|
backSpace(1);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
String val = String.valueOf(c);
|
|
|
|
if (TibetanMachineWeb.isPunc(val)) { //punctuation
|
|
val = TibetanMachineWeb.getWylieForPunc(val);
|
|
|
|
if (val.charAt(0) == TibetanMachineWeb.BINDU)
|
|
putBindu();
|
|
|
|
else {
|
|
DuffCode puncDc = TibetanMachineWeb.getGlyph(val);
|
|
MutableAttributeSet mas = TibetanMachineWeb.getAttributeSet(puncDc.getFontNum());
|
|
doc.appendDuff(caret.getDot(), String.valueOf(puncDc.getCharacter()), mas);
|
|
}
|
|
|
|
initKeyboard();
|
|
return;
|
|
}
|
|
|
|
if (charList.size()==0) { //add current character to charList if possible
|
|
holdCurrent.append(c);
|
|
String s = holdCurrent.toString();
|
|
|
|
if (TibetanMachineWeb.isVowel(s)) {
|
|
s = TibetanMachineWeb.getWylieForVowel(s);
|
|
|
|
if (isTypingVowel) //note: this takes care of multiple keystroke vowels like 'ai'
|
|
backSpace(numberOfGlyphsForLastVowel);
|
|
|
|
putVowel(s);
|
|
isTypingVowel = true;
|
|
}
|
|
else {
|
|
if (isTypingVowel) {
|
|
isTypingVowel = false;
|
|
s = String.valueOf(c);
|
|
holdCurrent = new StringBuffer(s);
|
|
}
|
|
|
|
if (TibetanMachineWeb.isVowel(s)) {
|
|
s = TibetanMachineWeb.getWylieForVowel(s);
|
|
putVowel(s);
|
|
isTypingVowel = true;
|
|
}
|
|
|
|
else if (TibetanMachineWeb.isChar(s)) {
|
|
s = TibetanMachineWeb.getWylieForChar(s);
|
|
charList.add(s);
|
|
isTopHypothesis = true;
|
|
newGlyphList = TibetanDocument.getGlyphs(charList, isStackingRightToLeft, isDefinitelyTibetan, isDefinitelySanskrit);
|
|
oldGlyphList = redrawGlyphs(oldGlyphList, newGlyphList);
|
|
}
|
|
else
|
|
isTopHypothesis = false;
|
|
}
|
|
}
|
|
else { //there is already a character in charList
|
|
holdCurrent.append(c);
|
|
String s = holdCurrent.toString();
|
|
|
|
if (TibetanMachineWeb.isVowel(s)) { //the holding string is a vowel
|
|
s = TibetanMachineWeb.getWylieForVowel(s);
|
|
initKeyboard();
|
|
isTypingVowel = true;
|
|
putVowel(s);
|
|
}
|
|
else if (TibetanMachineWeb.isChar(s)) { //the holding string is a character
|
|
String s2 = TibetanMachineWeb.getWylieForChar(s);
|
|
|
|
if (isTopHypothesis) {
|
|
if (TibetanMachineWeb.isAChungConsonant() && isStackingOn && charList.size()>1 && s2.equals(TibetanMachineWeb.ACHUNG)) {
|
|
charList.removeLast();
|
|
newGlyphList = TibetanDocument.getGlyphs(charList, isStackingRightToLeft, isDefinitelyTibetan, isDefinitelySanskrit);
|
|
oldGlyphList = redrawGlyphs(oldGlyphList, newGlyphList);
|
|
putVowel(TibetanMachineWeb.A_VOWEL);
|
|
initKeyboard();
|
|
break key_block;
|
|
}
|
|
charList.set(charList.size()-1, s2);
|
|
newGlyphList = TibetanDocument.getGlyphs(charList, isStackingRightToLeft, isDefinitelyTibetan, isDefinitelySanskrit);
|
|
oldGlyphList = redrawGlyphs(oldGlyphList, newGlyphList);
|
|
}
|
|
else {
|
|
if (!isStackingOn) {
|
|
initKeyboard();
|
|
holdCurrent = new StringBuffer(s);
|
|
}
|
|
else if (TibetanMachineWeb.isAChungConsonant() && s2.equals(TibetanMachineWeb.ACHUNG)) {
|
|
putVowel(TibetanMachineWeb.A_VOWEL);
|
|
initKeyboard();
|
|
break key_block;
|
|
}
|
|
|
|
charList.add(s2);
|
|
isTopHypothesis = true;
|
|
newGlyphList = TibetanDocument.getGlyphs(charList, isStackingRightToLeft, isDefinitelyTibetan, isDefinitelySanskrit);
|
|
oldGlyphList = redrawGlyphs(oldGlyphList, newGlyphList);
|
|
}
|
|
}
|
|
else { //the holding string is not a character
|
|
if (isTopHypothesis) { //finalize top character and add new hypothesis to top
|
|
holdCurrent = new StringBuffer();
|
|
holdCurrent.append(c);
|
|
s = holdCurrent.toString();
|
|
|
|
if (TibetanMachineWeb.isVowel(s)) {
|
|
String s2 = TibetanMachineWeb.getWylieForVowel(s);
|
|
putVowel(s2);
|
|
initKeyboard();
|
|
isTypingVowel = true;
|
|
holdCurrent = new StringBuffer(s);
|
|
}
|
|
else {
|
|
if (TibetanMachineWeb.isStackingMedial() && !isStackingRightToLeft)
|
|
initKeyboard();
|
|
|
|
if (TibetanMachineWeb.isChar(s)) {
|
|
String s2 = TibetanMachineWeb.getWylieForChar(s);
|
|
|
|
if (!isStackingOn)
|
|
initKeyboard();
|
|
|
|
else if (TibetanMachineWeb.isAChungConsonant() && s2.equals(TibetanMachineWeb.ACHUNG)) {
|
|
putVowel(TibetanMachineWeb.A_VOWEL);
|
|
initKeyboard();
|
|
break key_block;
|
|
}
|
|
|
|
charList.add(s2);
|
|
newGlyphList = TibetanDocument.getGlyphs(charList, isStackingRightToLeft, isDefinitelyTibetan, isDefinitelySanskrit);
|
|
oldGlyphList = redrawGlyphs(oldGlyphList, newGlyphList);
|
|
}
|
|
else {
|
|
holdCurrent = new StringBuffer(s);
|
|
isTopHypothesis = false;
|
|
}
|
|
}
|
|
}
|
|
else { //top char is just a guess! just keep it in holdCurrent
|
|
}
|
|
}
|
|
}
|
|
} //end switch
|
|
} //end key_block
|
|
}
|
|
|
|
/**
|
|
* Converts the entire document to Extended Wylie.
|
|
*/
|
|
public void toWylie() {
|
|
int start = getSelectionStart();
|
|
int end = getSelectionEnd();
|
|
|
|
toWylie(start, end);
|
|
}
|
|
|
|
/**
|
|
* Converts the specified portion
|
|
* of this object's document to Extended Wylie.
|
|
*
|
|
* @param start the point from which to begin converting to Wylie
|
|
* @param end the point at which to stop converting to Wylie
|
|
*/
|
|
public void toWylie(int start, int end) {
|
|
if (start == end)
|
|
return;
|
|
|
|
DuffCode[] dc_array;
|
|
AttributeSet attr;
|
|
String fontName;
|
|
Position endPos;
|
|
int fontNum;
|
|
DuffCode dc;
|
|
char ch;
|
|
int i;
|
|
|
|
java.util.List dcs = new ArrayList();
|
|
|
|
try {
|
|
endPos = doc.createPosition(end);
|
|
i = start;
|
|
|
|
while (i < endPos.getOffset()+1) {
|
|
attr = doc.getCharacterElement(i).getAttributes();
|
|
fontName = StyleConstants.getFontFamily(attr);
|
|
|
|
if ((0 == (fontNum = TibetanMachineWeb.getTMWFontNumber(fontName))) || i==endPos.getOffset()) {
|
|
if (i != start) {
|
|
dc_array = new DuffCode[0];
|
|
dc_array = (DuffCode[])dcs.toArray(dc_array);
|
|
doc.remove(start, i-start);
|
|
append(start, TibetanDocument.getWylie(dc_array), romanAttributeSet);
|
|
dcs.clear();
|
|
}
|
|
start = i+1;
|
|
}
|
|
else {
|
|
ch = doc.getText(i,1).charAt(0);
|
|
dc = new DuffCode(fontNum, ch);
|
|
dcs.add(dc);
|
|
}
|
|
|
|
i++;
|
|
}
|
|
}
|
|
catch (BadLocationException ble) {
|
|
ble.printStackTrace();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Converts a string of Extended Wylie to TibetanMachineWeb, and
|
|
* inserts it at the specified position.
|
|
*
|
|
* @param wylie the string of Wylie to convert
|
|
* @param offset the position at which to insert the conversion
|
|
*/
|
|
public void toTibetanMachineWeb(String wylie, int offset) {
|
|
try {
|
|
TibetanDocument.DuffData[] dd = TibetanDocument.getTibetanMachineWeb(wylie);
|
|
doc.insertDuff(offset, dd);
|
|
}
|
|
catch (InvalidWylieException iwe) {
|
|
JOptionPane.showMessageDialog(this,
|
|
"The Wylie you are trying to convert is invalid, " +
|
|
"beginning from:\n " + iwe.getCulpritInContext() + "\n" +
|
|
"The culprit is probably the character '"+iwe.getCulprit()+"'.");
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Converts the currently selected text from Extended Wylie to TibetanMachineWeb.
|
|
*/
|
|
public void toTibetanMachineWeb() {
|
|
int start = getSelectionStart();
|
|
int end = getSelectionEnd();
|
|
|
|
toTibetanMachineWeb(start, end);
|
|
}
|
|
|
|
/**
|
|
* Converts a stretch of text from Extended Wylie to TibetanMachineWeb.
|
|
* @param start the begin point for the conversion
|
|
* @param end the end point for the conversion
|
|
*/
|
|
public void toTibetanMachineWeb(int start, int end) {
|
|
if (start == end)
|
|
return;
|
|
|
|
StringBuffer sb;
|
|
AttributeSet attr;
|
|
String fontName;
|
|
int fontNum;
|
|
Position endPos;
|
|
int i;
|
|
|
|
try {
|
|
sb = new StringBuffer();
|
|
endPos = doc.createPosition(end);
|
|
i = start;
|
|
|
|
while (i < endPos.getOffset()+1) {
|
|
attr = doc.getCharacterElement(i).getAttributes();
|
|
fontName = StyleConstants.getFontFamily(attr);
|
|
|
|
if ((0 != (fontNum = TibetanMachineWeb.getTMWFontNumber(fontName))) || i==endPos.getOffset()) {
|
|
if (i != start) {
|
|
try {
|
|
TibetanDocument.DuffData[] duffdata = TibetanDocument.getTibetanMachineWeb(sb.toString());
|
|
doc.remove(start, i-start);
|
|
doc.insertDuff(start, duffdata);
|
|
}
|
|
catch (InvalidWylieException iwe) {
|
|
JOptionPane.showMessageDialog(this,
|
|
"The Wylie you are trying to convert is invalid, " +
|
|
"beginning from:\n " + iwe.getCulpritInContext() +
|
|
"\nThe culprit is probably the character '" +
|
|
iwe.getCulprit() + "'.");
|
|
return;
|
|
}
|
|
}
|
|
start = i+1;
|
|
}
|
|
else
|
|
sb.append(doc.getText(i, 1));
|
|
|
|
i++;
|
|
}
|
|
}
|
|
catch (BadLocationException ble) {
|
|
ble.printStackTrace();
|
|
}
|
|
}
|
|
}
|