Initial revision

source/org/thdl/tib/text/DuffCode.java

@@ -0,0 +1,165 @@
+/*
+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.text;
+
+import java.util.StringTokenizer;
+
+/**
+* A wrapper for the primitive data types
+* that combine to represent a Tibetan glyph in the
+* TibetanMachineWeb family of fonts.
+*
+* A DuffCode consists of a font number, a character, and
+* a character number. A font identification and a character 
+* (or character number) are sufficient to uniquely identify
+* any TibetanMachineWeb glyph.
+* @author Edward Garrett, Tibetan and Himalayan Digital Library
+* @version 1.0
+*/
+
+public class DuffCode {
+/**
+* the font number in which this glyph can be found,
+* from 1 (TibetanMachineWeb) to 10 (TibetanMachineWeb9).
+*/
+	public int fontNum;
+/**
+* the character value of this glyph
+*/
+	public char character;
+/**
+* the character value of this glyph, as an integer
+*/
+	public int charNum;
+
+/**
+* Called by {@link TibetanMachineWeb} to generate
+* DuffCodes from the 'tibwn.ini' initialization file.
+* This constructor expects to receive a string such as "1,33" or "33,1",
+* i.e. a sequence of two numbers separated by a comma. These numbers
+* represent a character: one number is its identifying font number, 
+* and the other is the ASCII code of the character.
+* 
+* @param s the string to parse
+* @param leftToRight should be true if the first number is the font number,
+* false if the second number is the font number
+*/
+	public DuffCode(String s, boolean leftToRight) {
+		StringTokenizer st = new StringTokenizer(s,",");
+
+		try {
+			String val1 = st.nextToken();
+			String val2 = st.nextToken();
+
+			Integer num1 = new Integer(val1);
+			Integer num2 = new Integer(val2);
+
+			if (leftToRight) {
+				fontNum = num1.intValue();
+				charNum = num2.intValue();
+				character = (char)charNum;
+			}
+			else {
+				fontNum = num2.intValue();
+				charNum = num1.intValue();
+				character = (char)charNum;
+			}						
+		}
+		catch (NumberFormatException e) {
+		}
+	}
+
+/**
+* Called to create DuffCodes on the fly
+* from an identifying font number and an ASCII character.
+* 
+* @param font the identifying number of the font
+* @param ch a character
+*/
+	public DuffCode(int font, char ch) {
+		fontNum = font;
+		character = ch;
+		charNum = (int)ch;
+	}
+
+/**
+* Gets the font number of this glyph.
+* @return the identifying font number for this DuffCode
+*/
+	public int getFontNum() {
+		return fontNum;
+	}
+
+/**
+* Gets the character for this glyph, as an integer.
+* @return the identifying character, converted to an
+* integer, for this DuffCode
+*/
+	public int getCharNum() {
+		return charNum;
+	}
+
+/**
+* Gets the character for this glyph.
+* @return the identifying character for this DuffCode
+*/
+	public char getCharacter() {
+		return character;
+	}
+
+/**
+* Assigns a hashcode based on the font number and character for this glyph.
+* The hashcode for a DuffCode with font=1 and character='c'
+* is defined as the hash code of the string '1-c'.
+*
+* @return the hash code for this object
+*/
+	public int hashCode() {
+		StringBuffer sb = new StringBuffer();
+		sb.append(new Integer(fontNum).toString());
+		sb.append('-');
+		sb.append(character);
+		String s = sb.toString();
+		return s.hashCode();
+	}
+
+/**
+* Evaluates two DuffCodes as equal iff their
+* font numbers and characters are identical.
+*
+* @param o the object (DuffCode) you want to compare
+* @return true if this object is equal to o, false if not
+*/
+	public boolean equals(Object o) {
+		if (o instanceof DuffCode) {
+			DuffCode dc = (DuffCode)o;
+
+			if (fontNum == dc.fontNum && charNum == dc.charNum)
+				return true;
+		}
+		return false;
+	}
+
+/**
+* @return a string representation of this object
+*/
+	public String toString() {
+		return "fontNum="+fontNum+";charNum="+charNum+";character="+new Character(character).toString();
+	}
+}

source/org/thdl/tib/text/InvalidWylieException.java

@@ -0,0 +1,62 @@
+/*
+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.text;
+
+/**
+* Thrown whenever
+* a process runs into invalid Extended Wylie. This is usually thrown
+* while converting Wylie to
+* TibetanMachineWeb when the converter runs into invalid Wylie.
+* @author Edward Garrett, Tibetan and Himalayan Digital Library
+* @version 1.0
+*/
+public class InvalidWylieException extends Exception {
+	private String wylie;
+	private int offset;	
+
+/**
+* Creates an InvalidWylieException.
+* @param s a string of Wylie text
+* @param i the offset where problems for the process began
+*/
+	public InvalidWylieException(String s, int i) {
+		wylie = s;
+		offset = i;
+	}
+
+/**
+* Gets the character that caused the problem.
+* @return the character believed to be the problem for the process
+*/
+	public char getCulprit() {
+		return wylie.charAt(offset);
+	}
+
+/**
+* Gets the character that caused the problem, in context.
+* @return the string of text including and following the character
+* believed to be the problem for the process
+*/
+	public String getCulpritInContext() {
+		if (wylie.length() < offset+5)
+			return wylie.substring(offset, wylie.length());
+		else
+			return wylie.substring(offset, offset+5);
+	}
+}

source/org/thdl/tib/text/TibetanHTML.java

@@ -0,0 +1,144 @@
+package org.thdl.tib.text;
+
+public class TibetanHTML {
+	static String[] styleNames =
+		{"tmw","tmw1","tmw2","tmw3","tmw4","tmw5","tmw6","tmw7","tmw8","tmw9"};
+
+	public static String getStyles(String fontSize) {
+		return	".tmw {font: "+fontSize+"pt TibetanMachineWeb}\n"+
+				".tmw1 {font: "+fontSize+"pt TibetanMachineWeb1}\n"+
+				".tmw2 {font: "+fontSize+"pt TibetanMachineWeb2}\n"+
+				".tmw3 {font: "+fontSize+"pt TibetanMachineWeb3}\n"+
+				".tmw4 {font: "+fontSize+"pt TibetanMachineWeb4}\n"+
+				".tmw5 {font: "+fontSize+"pt TibetanMachineWeb5}\n"+
+				".tmw6 {font: "+fontSize+"pt TibetanMachineWeb6}\n"+
+				".tmw7 {font: "+fontSize+"pt TibetanMachineWeb7}\n"+
+				".tmw8 {font: "+fontSize+"pt TibetanMachineWeb8}\n"+
+				".tmw9 {font: "+fontSize+"pt TibetanMachineWeb9}\n";
+	}
+
+
+	public static String getHTML(String wylie) {
+		try {
+			return getHTML(TibetanDocument.getTibetanMachineWeb(wylie));
+		}
+		catch (InvalidWylieException ive) {
+			return null;
+		}
+	}
+
+	public static String getHTML(TibetanDocument.DuffData[] duffData) {
+		String[] styleNames =
+			{"tmw","tmw1","tmw2","tmw3","tmw4","tmw5","tmw6","tmw7","tmw8","tmw9"};
+
+		StringBuffer htmlBuffer = new StringBuffer();
+		htmlBuffer.append("<nobr>");
+
+		for (int i=0; i<duffData.length; i++) {
+			char[] c = duffData[i].text.toCharArray();
+			for (int k=0; k<c.length; k++) {
+				htmlBuffer.append("<span class=\"");
+				htmlBuffer.append(styleNames[duffData[i].font-1]);
+				htmlBuffer.append("\">");
+
+				switch (c[k]) {
+					case '"':
+						htmlBuffer.append("&quot");
+						break;
+					case '<':
+						htmlBuffer.append("&lt");
+						break;
+					case '>':
+						htmlBuffer.append("&gt");
+						break;
+					case '&':
+						htmlBuffer.append("&amp");
+						break;
+					default:
+						htmlBuffer.append(c[k]);
+						break;
+				}
+
+				htmlBuffer.append("</span>");
+				if (c[k] < 32) //must be formatting, like carriage return or tab
+					htmlBuffer.append("<br>");
+
+				else {
+					String wylie = TibetanMachineWeb.getWylieForGlyph(duffData[i].font, c[k]);
+					if (TibetanMachineWeb.isWyliePunc(wylie))
+						htmlBuffer.append("<wbr>");
+				}
+			}
+		}
+
+		htmlBuffer.append("</nobr>");
+		return htmlBuffer.toString();
+	}
+}
+
+
+
+//import org.apache.xerces.dom.DOMImplementationImpl;
+//import org.w3c.dom.*;
+
+/*
+	public static Node getHTML(String wylie) {
+		try {
+			return getHTML(TibetanDocument.getTibetanMachineWeb(wylie));
+		}
+		catch (InvalidWylieException ive) {
+			return null;
+		}
+	}
+
+	public static Node getHTML(TibetanDocument.DuffData[] duffData) {
+		try {
+			DOMImplementationImpl impl = new DOMImplementationImpl();
+			Document doc = impl.createDocument(null, "root", null);
+//			DocumentFragment frag = doc.createDocumentFragment()
+
+
+			Element nobr = doc.createElement("nobr");
+//			frag.appendChild(nobr);
+
+			for (int i=0; i<duffData.length; i++) {
+				char[] c = duffData[i].text.toCharArray();
+				for (int k=0; k<c.length; k++) {
+					Element span = doc.createElement("span");
+					span.setAttribute("class", styleNames[duffData[i].font-1]);
+//					Text tib = doc.createTextNode(String.valueOf(c[k]));
+//					span.appendChild(tib);
+					nobr.appendChild(span);
+
+					String wylie = TibetanMachineWeb.getWylieForGlyph(duffData[i].font, c[k]);
+					if (TibetanMachineWeb.isWyliePunc(wylie)) {
+						Element wbr = doc.createElement("wbr");
+						nobr.appendChild(wbr);
+					}
+				}
+			}
+
+//doc.appendChild(nobr);
+return nobr;
+
+//			return frag;
+		}
+		catch (DOMException dome) {
+switch (dome.code) {
+
+case DOMException.HIERARCHY_REQUEST_ERR:
+System.out.println("hierarchy error!!");
+break;
+
+case DOMException.WRONG_DOCUMENT_ERR:
+System.out.println("wrong doc error!!");
+break;
+
+case DOMException.NO_MODIFICATION_ALLOWED_ERR:
+System.out.println("no mod allowed error!!");
+break;
+}
+			return null;
+		}
+	}
+*/

source/org/thdl/tib/text/TibetanKeyboard.java

@@ -0,0 +1,391 @@
+/*
+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.text;
+
+import java.util.*;
+import java.io.*;
+import java.lang.*;
+import java.net.URL;
+
+/**
+* An alternate (non-Extended Wylie) keyboard input
+* method. A keyboard URL is passed to its constructor. This URL
+* must follow a particular format, and include particular subparts.
+* For example, the keyboard URL must specify values for various
+* input parameters, as well as correspondences for the Wylie
+* characters this keyboard allows the user to input. For an example,
+* see the file 'sambhota_keyboard.ini' found in the same
+* directory as this class.
+* <p>
+* It is normative practice for a null keyboard to be
+* interpreted as the default Wylie keyboard.
+* A non-null keyboard defines a transformation of the default
+* Wylie keyboard, setting new values for each Wylie value, as
+* well as (re-)defining various parameters.
+* 
+* @author Edward Garrett, Tibetan and Himalayan Digital Library
+* @version 1.0
+*/
+public class TibetanKeyboard {
+	private boolean hasDisambiguatingKey;
+	private char disambiguatingKey;
+	private boolean hasSanskritStackingKey;
+	private boolean hasTibetanStackingKey;
+	private boolean isStackingMedial;
+	private char stackingKey;
+	private boolean isAChenRequiredBeforeVowel;
+	private boolean isAChungConsonant;
+	private boolean hasAVowel;
+	private Map charMap;
+	private Map vowelMap;
+	private Map puncMap;
+	private int command;
+	private final int NO_COMMAND = 0;
+	private final int PARAMETERS = 1;
+	private final int CHARACTERS = 2;
+	private final int VOWELS = 3;
+	private final int PUNCTUATION = 4;
+
+/**
+* A generic Exception to indicate an invalid keyboard.
+*/
+	public class InvalidKeyboardException extends Exception {
+	}
+
+/**
+* Opens the URL specified by the parameter,
+* and tries to construct a keyboard from it. If the file is
+* missing, or is invalid, an InvalidKeyboardException is
+* thrown.
+*
+* @param url the URL of the keyboard
+* @throws InvalidKeyboardException a valid keyboard cannot be
+* constructed from this URL
+*/
+	public TibetanKeyboard(URL url) throws InvalidKeyboardException {
+		try {
+			InputStreamReader isr = new InputStreamReader(url.openStream());
+			BufferedReader in = new BufferedReader(isr);
+
+			System.out.println("reading "+url.toString());
+			String line;
+
+			charMap = new HashMap();
+			vowelMap = new HashMap();
+			puncMap = new HashMap();
+
+			command = NO_COMMAND;
+
+			boolean bool;
+
+			while ((line = in.readLine()) != null) {
+
+				if (line.startsWith("<?")) { //line is command
+					if (line.equalsIgnoreCase("<?parameters?>"))
+						command = PARAMETERS;
+
+					else if (line.equalsIgnoreCase("<?characters?>"))
+						command = CHARACTERS;
+
+					else if (line.equalsIgnoreCase("<?vowels?>"))
+						command = VOWELS;
+
+					else if (line.equalsIgnoreCase("<?punctuation?>"))
+						command = PUNCTUATION;
+				}
+				else if (line.equals("")) //empty string
+					;
+
+				else {
+					StringTokenizer st = new StringTokenizer(line,"=");
+					String left = null, right = null;
+
+					if (st.hasMoreTokens())
+						left = st.nextToken();
+
+					if (st.hasMoreTokens())
+						right = st.nextToken();
+
+					switch (command) {
+						case NO_COMMAND:
+								break;
+
+						case PARAMETERS:
+								if (left == null)
+									throw new InvalidKeyboardException();
+
+								if (right == null)
+									break;
+
+								if (left.equals("stack key")) {
+									stackingKey = right.charAt(0);
+									break;
+								}
+
+								if (left.equals("disambiguating key")) {
+									disambiguatingKey = right.charAt(0);
+									break;
+								}
+
+								bool = new Boolean(right).booleanValue();
+
+								if (left.equalsIgnoreCase("has sanskrit stacking"))
+									hasSanskritStackingKey = bool;
+
+								if (left.equalsIgnoreCase("has tibetan stacking"))
+									hasTibetanStackingKey = bool;
+
+								if (left.equalsIgnoreCase("is stacking medial"))
+									isStackingMedial = bool;
+
+								if (left.equalsIgnoreCase("has disambiguating key"))
+									hasDisambiguatingKey = bool;
+
+								if (left.equalsIgnoreCase("needs achen before vowels"))
+									isAChenRequiredBeforeVowel = bool;
+
+								if (left.equalsIgnoreCase("has 'a' vowel"))
+									hasAVowel = bool;
+
+								if (left.equalsIgnoreCase("is achung consonant"))
+									isAChungConsonant = bool;
+
+								break;
+
+						case CHARACTERS:
+								if (left == null)
+									throw new InvalidKeyboardException();
+
+								if (right == null)
+									break;
+
+								charMap.put(right, left);
+								break;
+
+						case VOWELS:
+								if (left == null)
+									throw new InvalidKeyboardException();
+
+								if (right == null)
+									break;
+
+								vowelMap.put(right, left);
+								break;
+
+						case PUNCTUATION:
+								if (left == null)
+									throw new InvalidKeyboardException();
+
+								if (right == null)
+									break;
+
+								puncMap.put(right, left);
+								break;
+					}
+				}
+			}
+		}
+		catch (Exception e) {
+			throw new InvalidKeyboardException();
+		}
+	}
+
+/**
+* Does this keyboard have a disambiguating key?
+* @return true if this keyboard has a disambiguating key, e.g.
+* the period in Wylie 'g.y' vs. Wylie 'gy', false otherwise
+*/
+	public boolean hasDisambiguatingKey() {
+		return hasDisambiguatingKey;
+	}
+
+/**
+* Gets the disambiguating key for this keyboard.
+* @return the disambiguating key, assuming this keyboard has one
+*/
+	public char getDisambiguatingKey() {
+		return disambiguatingKey;
+	}
+
+/**
+* Does this keyboard require a stacking key for Sanskrit stacks?
+* @return true if this keyboard requires a
+* stacking key for Sanskrit stacks
+*/
+	public boolean hasSanskritStackingKey() {
+		return hasSanskritStackingKey;
+	}
+
+/**
+* Does this keyboard require a stacking key for Tibetan stacks?
+* @return true if this keyboard requires a
+* stacking key for Tibetan stacks
+*/
+	public boolean hasTibetanStackingKey() {
+		return hasTibetanStackingKey;
+	}
+
+/**
+* Is stacking medial?
+* @return true if this keyboard has stacking, and
+* if that stacking is medial rather than pre/post.
+* In other words, if you want a stack consisting
+* of the (Wylie) characters 's', 'g', and 'r', and
+* if the stack key is '+', then if you get the 
+* stack by typing 's+g+r', then this method returns
+* true. If you get it by typing '+sgr' or '+sgr+',
+* then the method returns false.
+*/
+	public boolean isStackingMedial() {
+		return isStackingMedial;
+	}
+
+/**
+* Gets the stacking key.
+* @return the stacking key, if there is one
+*/
+	public char getStackingKey() {
+		return stackingKey;
+	}
+
+/**
+* Must achen be typed first if you want achen plus a vowel?
+* @return true if it is necessary in this keyboard to
+* type achen plus a vowel to get achen plus a vowel,
+* or if you can (as in Wylie), simply type the vowel,
+* and then automatically get achen plus the vowel,
+* assuming there is no preceding consonant.
+*/
+	public boolean isAChenRequiredBeforeVowel() {
+		return isAChenRequiredBeforeVowel;
+	}
+
+/**
+* Is achung treated as an ordinary consonant?
+* @return true if achung is counted as a consonant,
+* and thus treated as stackable like any other
+* consonant; false if achung is treated as a vowel,
+* as in Wylie.
+*/
+	public boolean isAChungConsonant() {
+		return isAChungConsonant;
+	}
+
+/**
+* Does the keyboard have a key for the invisible 'a' vowel?
+* @return true if this keyboard has a keystroke
+* sequence for the invisible Wylie vowel 'a', false
+* if there is no way to type this invisible vowel.
+*/
+	public boolean hasAVowel() {
+		return hasAVowel;
+	}
+
+/**
+* Decides whether or not a string is a character in this keyboard.
+* @return true if the parameter is a character
+* in this keyboard. This method checks to see
+* if the passed string has been mapped to a
+* Wylie character - if not, then it returns false.
+*
+* @param s the possible character
+*/
+	public boolean isChar(String s) {
+		if (charMap.containsKey(s))
+			return true;
+		else
+			return false;
+	}
+/**
+* Gets the Extended Wylie corresponding to this character.
+* @return the Wylie value corresponding to this
+* parameter, assuming it is in fact a character
+* in this keyboard; if not, returns null.
+*
+* @param the possible character
+*/
+	public String getWylieForChar(String s) {
+		if (!charMap.containsKey(s))
+			return null;
+
+		return (String)charMap.get(s);
+	}
+
+/**
+* Decides whether or not a string is a punctuation mark in this keyboard?
+* @return true if the parameter is punctuation
+* in this keyboard. This method checks to see if the
+* passed string has been mapped to Wylie punctuation -
+* if not, then it returns false.
+*
+* @param s the possible punctuation
+*/
+	public boolean isPunc(String s) {
+		if (puncMap.containsKey(s))
+			return true;
+		else
+			return false;
+	}
+
+/**
+* Gets the Extended Wylie corresponding to this punctuation.
+* @return the Wylie value corresponding to this
+* parameter, assuming it is in fact punctuation
+* in this keyboard; if not, returns null.
+*
+* @param s the possible punctuation
+*/
+	public String getWylieForPunc(String s) {
+		if (!puncMap.containsKey(s))
+			return null;
+
+		return (String)puncMap.get(s);
+	}
+
+/**
+* Decides whether or not the string is a vowel in this keyboard. 
+* @return true if the parameter is a vowel
+* in this keyboard. This method checks to see if the
+* passed string has been mapped to a Wylie vowel -
+* if not, then it returns false.
+*
+* @param s the possible vowel
+*/
+	public boolean isVowel(String s) {
+		if (vowelMap.containsKey(s))
+			return true;
+		else
+			return false;
+	}
+
+/**
+* Gets the Extended Wylie corresponding to this vowel.
+* @return the Wylie value corresponding to this
+* parameter, assuming it is in fact a vowel
+* in this keyboard; if not, returns null.
+*
+* @param the possible vowel
+*/
+	public String getWylieForVowel(String s) {
+		if (!vowelMap.containsKey(s))
+			return null;
+
+		return (String)vowelMap.get(s);
+	}
+}

source/org/thdl/tib/text/TibetanQTText.java

@@ -0,0 +1,171 @@
+package org.thdl.tib.text;
+
+import java.util.*;
+import org.w3c.dom.*;
+
+public class TibetanQTText {
+	private static String tibFontSize = "28";
+	private Map lines;
+	private Map times;
+	int id;
+
+	public TibetanQTText() {
+		lines = new HashMap();
+		times = new TreeMap();
+		id = 0;
+	}
+
+	public void addLine(String wylie, String t1, String t2) {
+		id++;
+		String lineID = String.valueOf(id);
+		lines.put(lineID, wylie);
+
+		try {
+			Float startTime = new Float(t1);
+			if (!times.containsKey(startTime))
+				times.put(startTime, lineID+",");
+			else {
+				String val = (String)times.get(startTime);
+				val += lineID+",";
+				times.put(startTime, val);
+			}
+
+			Float stopTime = new Float(t2);
+			if (!times.containsKey(stopTime))
+				times.put(stopTime, lineID+",");
+			else {
+				String val = (String)times.get(stopTime);
+				val += lineID+",";
+				times.put(stopTime, val);
+			}
+		}
+		catch (NumberFormatException nfe) {
+		}
+
+	}
+
+	public void organizeLines() {
+		List line_list = new ArrayList();
+
+		Iterator iter = times.keySet().iterator();
+		while (iter.hasNext()) {
+			Float this_time = (Float)iter.next();
+			String these_lines = (String)times.get(this_time);
+
+			StringTokenizer sTok = new StringTokenizer(these_lines,",");
+			while (sTok.hasMoreTokens()) {
+				String lineID = sTok.nextToken();
+				if (line_list.contains(lineID))
+					line_list.remove(lineID);
+				else
+					line_list.add(lineID);
+			}
+
+			StringBuffer sb = new StringBuffer();
+			Iterator line_list_iter = line_list.iterator();
+			while (line_list_iter.hasNext()) {
+				String lineID = (String)line_list_iter.next();
+				sb.append(lineID);
+				sb.append(',');
+			}
+
+			times.put(this_time, sb.toString());
+		}
+	} 
+
+	public String getQTTextForLines() {
+		StringBuffer sb = new StringBuffer();
+
+		Iterator iter = times.keySet().iterator();
+		while (iter.hasNext()) {
+			Float this_time = (Float)iter.next();
+			sb.append(getQTTimeTag(String.valueOf(this_time)));
+			String these_lines = (String)times.get(this_time);
+
+			StringTokenizer sTok = new StringTokenizer(these_lines,",");
+			while (sTok.hasMoreTokens()) {
+				String lineID = sTok.nextToken();
+				String wylie = (String)lines.get(lineID);
+				sb.append(getQTText(wylie));
+				sb.append('\n');
+			}
+		}
+
+		return sb.toString();
+	}
+
+	public static String getQTHeader() {
+		return "{QTtext}{plain}{anti-alias:off}{size:28}{justify:left}{timeScale:1000}{width:320}{height:120}{timeStamps:absolute}{language:0}{textEncoding:0}\n";
+	}
+
+	public static String getQTTimeTag(String t) {
+		StringBuffer sb = new StringBuffer();
+		sb.append('[');
+		sb.append(t);
+		sb.append(']');
+		return sb.toString();
+	}
+
+	public static String getQTText(String wylie) {
+		try {
+			return getQTText(TibetanDocument.getTibetanMachineWeb(wylie));
+		}
+		catch (InvalidWylieException ive) {
+			return null;
+		}
+	}
+
+	public static String getQTText(TibetanDocument.DuffData[] duffData) {
+		StringBuffer qtBuffer = new StringBuffer();
+		qtBuffer.append("{size:" + tibFontSize + "}");
+
+		for (int i=0; i<duffData.length; i++) {
+			qtBuffer.append("{font:" + TibetanMachineWeb.tmwFontNames[duffData[i].font] + "}");
+			qtBuffer.append(duffData[i].text);
+		}
+
+		return qtBuffer.toString();
+	}
+}
+
+/*
+	public void addLine(NodeList nodes) {
+
+
+		Element line = (Element)nodes.item(0);
+Node wylie_node = line.getFirstChild();		
+//		NodeList wylie_nodes = line.getElementsByTagName("wylie");
+
+//		Node wylie_node = wylie_nodes.item(0);
+		Node wylie_text = wylie_node.getFirstChild();
+System.out.println(wylie_text.getNodeName());
+//		String wylie = wylie_text.getNodeValue();
+		id++;
+		String lineID = String.valueOf(id);
+		lines.put(lineID, wylie);
+
+		NodeList audio_nodes = line.getElementsByTagName("AUDIO");
+		Element audio_element = (Element)audio_nodes.item(0);
+		try {
+			Integer startTime = Integer.valueOf(audio_element.getAttribute("begin"));
+			if (!times.containsKey(startTime))
+				times.put(startTime, lineID+",");
+			else {
+				String val = (String)times.get(startTime);
+				val += lineID+",";
+				times.put(startTime, val);
+			}
+
+			Integer stopTime = Integer.valueOf(audio_element.getAttribute("end"));
+			if (!times.containsKey(stopTime))
+				times.put(stopTime, lineID+",");
+			else {
+				String val = (String)times.get(stopTime);
+				val += lineID+",";
+				times.put(stopTime, val);
+			}
+		}
+		catch (NumberFormatException nfe) {
+		}
+	}
+*/

source/org/thdl/tib/text/TibetanQTText2.java

@@ -0,0 +1,171 @@
+package org.thdl.tib.text;
+
+import java.util.*;
+import org.w3c.dom.*;
+
+public class TibetanQTText2 {
+	private static String tibFontSize = "28";
+	private Map lines;
+	private Map times;
+	int id;
+
+	public TibetanQTText2() {
+		lines = new HashMap();
+		times = new TreeMap();
+		id = 0;
+	}
+
+	public void addLine(String wylie, String t1, String t2) {
+		id++;
+		String lineID = String.valueOf(id);
+		lines.put(lineID, wylie);
+
+		try {
+			Float startTime = new Float(t1);
+			if (!times.containsKey(startTime))
+				times.put(startTime, lineID+",");
+			else {
+				String val = (String)times.get(startTime);
+				val += lineID+",";
+				times.put(startTime, val);
+			}
+
+			Float stopTime = new Float(t2);
+			if (!times.containsKey(stopTime))
+				times.put(stopTime, lineID+",");
+			else {
+				String val = (String)times.get(stopTime);
+				val += lineID+",";
+				times.put(stopTime, val);
+			}
+		}
+		catch (NumberFormatException nfe) {
+		}
+
+	}
+
+	public void organizeLines() {
+		List line_list = new ArrayList();
+
+		Iterator iter = times.keySet().iterator();
+		while (iter.hasNext()) {
+			Float this_time = (Float)iter.next();
+			String these_lines = (String)times.get(this_time);
+
+			StringTokenizer sTok = new StringTokenizer(these_lines,",");
+			while (sTok.hasMoreTokens()) {
+				String lineID = sTok.nextToken();
+				if (line_list.contains(lineID))
+					line_list.remove(lineID);
+				else
+					line_list.add(lineID);
+			}
+
+			StringBuffer sb = new StringBuffer();
+			Iterator line_list_iter = line_list.iterator();
+			while (line_list_iter.hasNext()) {
+				String lineID = (String)line_list_iter.next();
+				sb.append(lineID);
+				sb.append(',');
+			}
+
+			times.put(this_time, sb.toString());
+		}
+	} 
+
+	public String getQTTextForLines() {
+		StringBuffer sb = new StringBuffer();
+
+		Iterator iter = times.keySet().iterator();
+		while (iter.hasNext()) {
+			Float this_time = (Float)iter.next();
+			sb.append(getQTTimeTag(String.valueOf(this_time)));
+			String these_lines = (String)times.get(this_time);
+
+			StringTokenizer sTok = new StringTokenizer(these_lines,",");
+			while (sTok.hasMoreTokens()) {
+				String lineID = sTok.nextToken();
+				String wylie = (String)lines.get(lineID);
+				sb.append(getQTText(wylie));
+				sb.append('\n');
+			}
+		}
+
+		return sb.toString();
+	}
+
+	public static String getQTHeader() {
+		return "{QTtext}{plain}{anti-alias:off}{size:28}{justify:left}{timeScale:1000}{width:320}{height:120}{timeStamps:absolute}{language:0}{textEncoding:0}\n";
+	}
+
+	public static String getQTTimeTag(String t) {
+		StringBuffer sb = new StringBuffer();
+		sb.append('[');
+		sb.append(t);
+		sb.append(']');
+		return sb.toString();
+	}
+
+	public static String getQTText(String wylie) {
+		try {
+			return getQTText(TibetanDocument.getTibetanMachineWeb(wylie));
+		}
+		catch (InvalidWylieException ive) {
+			return null;
+		}
+	}
+
+	public static String getQTText(TibetanDocument.DuffData[] duffData) {
+		StringBuffer qtBuffer = new StringBuffer();
+		qtBuffer.append("{size:" + tibFontSize + "}");
+
+		for (int i=0; i<duffData.length; i++) {
+			qtBuffer.append("{font:" + TibetanMachineWeb.tmwFontNames[duffData[i].font] + "}");
+			qtBuffer.append(duffData[i].text);
+		}
+
+		return qtBuffer.toString();
+	}
+}
+
+/*
+	public void addLine(NodeList nodes) {
+
+
+		Element line = (Element)nodes.item(0);
+Node wylie_node = line.getFirstChild();		
+//		NodeList wylie_nodes = line.getElementsByTagName("wylie");
+
+//		Node wylie_node = wylie_nodes.item(0);
+		Node wylie_text = wylie_node.getFirstChild();
+System.out.println(wylie_text.getNodeName());
+//		String wylie = wylie_text.getNodeValue();
+		id++;
+		String lineID = String.valueOf(id);
+		lines.put(lineID, wylie);
+
+		NodeList audio_nodes = line.getElementsByTagName("AUDIO");
+		Element audio_element = (Element)audio_nodes.item(0);
+		try {
+			Integer startTime = Integer.valueOf(audio_element.getAttribute("begin"));
+			if (!times.containsKey(startTime))
+				times.put(startTime, lineID+",");
+			else {
+				String val = (String)times.get(startTime);
+				val += lineID+",";
+				times.put(startTime, val);
+			}
+
+			Integer stopTime = Integer.valueOf(audio_element.getAttribute("end"));
+			if (!times.containsKey(stopTime))
+				times.put(stopTime, lineID+",");
+			else {
+				String val = (String)times.get(stopTime);
+				val += lineID+",";
+				times.put(stopTime, val);
+			}
+		}
+		catch (NumberFormatException nfe) {
+		}
+	}
+*/

source/org/thdl/tib/text/package.html

@@ -0,0 +1,38 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
+<html>
+<head>
+<!--
+
+  @(#)package.html
+
+  Copyright 2001 Tibetan and Himalayan Digital Library
+
+  This software is the confidential and proprietary information of
+  the Tibetan and Himalayan Digital Library. You shall use such
+  information only in accordance with the terms of the license
+  agreement you entered into with the THDL.
+
+-->
+</head>
+<body bgcolor="white">
+
+Provides classes and methods for dealing with Tibetan text.
+<p>
+Designed for use with the Tibetan Computer
+Company's free cross-platform TibetanMachineWeb fonts, this package
+contains methods for getting the Extended Wylie
+correspondences for each TibetanMachineWeb glyph, and for
+convert back and forth between Extended
+Wylie and TibetanMachineWeb.
+<p>
+This package provides a variety of ways to store TibetanMachineWeb data,
+and includes methods to aid programmers who want to convert from
+Extended Wylie to HTML or other formats.
+<p>
+Here, you can also find methods for installing and managing Tibetan
+keyboards. Four keyboards have been provided in this release,
+but users may also create their own keyboards.
+<h2>Related Documentation</h2>
+@see org.thdl.tib.input
+</body>
+</html>

source/org/thdl/tib/text/sambhota_keyboard_1.ini

@@ -0,0 +1,112 @@
+Sambhota Keymap One
+
+<?parameters?>
+has sanskrit stacking=true
+has tibetan stacking=true
+is stacking medial=false
+stack key=f
+has disambiguating key=false
+disambiguating key=
+needs achen before vowels=true
+has 'a' vowel=true
+is achung consonant=true
+
+<?characters?>
+k=k
+kh=K
+g=g
+ng=G
+c=c
+ch=C
+j=j
+ny=N
+t=t
+th=T
+d=d
+n=n
+p=p
+ph=P
+b=b
+m=m
+ts=x
+tsh=X
+dz=D
+w=w
+zh=Z
+z=z
+'='
+y=y
+r=r
+l=l
+sh=S
+s=s
+h=h
+a=A
+T=q
+Th=Q
+D=v
+N=V
+Sh=B
+0=0
+1=1
+2=2
+3=3
+4=4
+5=5
+6=6
+7=7
+8=8
+9=9
+<0=
+<1=
+<2=
+<3=
+<4=
+<5=
+<6=
+<7=
+<8=
+<9=
+>0=
+>1=
+>2=
+>3=
+>4=
+>5=
+>6=
+>7=
+>8=
+>9=
+
+<?vowels?>
+a=a
+i=i
+u=u
+e=e
+o=o
+I=
+U=
+ai=E
+au=O
+A=
+-i=I
+-I=
+
+<?punctuation?>
+_=.
+ = 
+/=,
+|=-
+!=
+:=;
+;=
+@=#
+#=$
+$=
+%=
+(=(
+)=)
+H=:
+M=&
+`=%
+&=@

source/org/thdl/tib/text/tcc_keyboard_1.ini

@@ -0,0 +1,115 @@
+Tibetan Computer Company Keyboard #1
+
+Apparently the same as the Tibkey keyboard except:
+- 'h' is a pre-post stack key, not a medial stack key
+
+<?parameters?>
+has sanskrit stacking=true
+has tibetan stacking=true
+is stacking medial=false
+stack key=h
+has disambiguating key=false
+disambiguating key=
+needs achen before vowels=true
+has 'a' vowel=false
+is achung consonant=true
+
+<?characters?>
+k=q
+kh=w
+g=e
+ng=r
+c=t
+ch=y
+j=u
+ny=i
+t=o
+th=p
+d=[
+n=]
+p=a
+ph=s
+b=d
+m=f
+ts=k
+tsh=l
+dz=;
+w='
+zh=z
+z=x
+'=c
+y=v
+r=m
+l=,
+sh=.
+s=/
+h=>
+a=?
+T=Q
+Th=W
+D=E
+N=R
+Sh=T
+0=0
+1=1
+2=2
+3=3
+4=4
+5=5
+6=6
+7=7
+8=8
+9=9
+<0=
+<1=
+<2=
+<3=
+<4=
+<5=
+<6=
+<7=
+<8=
+<9=
+>0=
+>1=
+>2=
+>3=
+>4=
+>5=
+>6=
+>7=
+>8=
+>9=
+
+<?vowels?>
+a=
+i=g
+u=j
+e=b
+o=n
+I=
+U=
+ai=B
+au=N
+A=
+-i=G
+-I=
+
+<?punctuation?>
+_=
+ = 
+/=\
+|=+
+!=|
+:=%
+;=
+@=!
+#=@
+$=
+%=
+(=(
+)=)
+H=:
+M=*
+`=`
+&=$

source/org/thdl/tib/text/tcc_keyboard_2.ini

@@ -0,0 +1,112 @@
+Tibetan Computer Company Keyboard #2
+
+<?parameters?>
+has sanskrit stacking=true
+has tibetan stacking=true
+is stacking medial=false
+stack key=a
+has disambiguating key=false
+disambiguating key=
+needs achen before vowels=true
+has 'a' vowel=false
+is achung consonant=true
+
+<?characters?>
+k=q
+kh=w
+g=s
+ng=e
+c=b
+ch=n
+j=m
+ny=,
+t=o
+th=p
+d=j
+n=k
+p=r
+ph=/
+b=d
+m=f
+ts=;
+tsh='
+dz=[
+w=]
+zh=z
+z=x
+'=c
+y=g
+r=h
+l=v
+sh=.
+s=l
+h=G
+a=H
+T=O
+Th=P
+D=J
+N=K
+Sh=>
+0=0
+1=1
+2=2
+3=3
+4=4
+5=5
+6=6
+7=7
+8=8
+9=9
+<0=
+<1=
+<2=
+<3=
+<4=
+<5=
+<6=
+<7=
+<8=
+<9=
+>0=
+>1=
+>2=
+>3=
+>4=
+>5=
+>6=
+>7=
+>8=
+>9=
+
+<?vowels?>
+a=
+i=t
+u=u
+e=y
+o=i
+I=
+U=
+ai=Y
+au=I
+A=
+-i=T
+-I=
+
+<?punctuation?>
+_=
+ = 
+/=\
+|=+
+!=|
+:=%
+;=
+@=!
+#=@
+$=
+%=
+(=(
+)=)
+H=:
+M=*
+`=`
+&=$