Initial revision

source/org/thdl/tib/input/Jskad.java

@@ -0,0 +1,942 @@
+/*
+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.io.*;
+import java.net.URL;
+import java.awt.*;
+import java.awt.event.*;
+
+import java.awt.print.*;
+import javax.swing.plaf.basic.*;
+
+import javax.swing.*;
+import javax.swing.event.*;
+import javax.swing.text.*;
+import javax.swing.text.rtf.*;
+
+import org.thdl.tib.text.*;
+
+/**
+* A simple Tibetan text editor. Jskad editors lack most of the
+* functionality of a word-processor, but they do provide
+* multiple keyboard input methods, as well as 
+* conversion routines to go back and forth between Extended
+* Wylie and TibetanMachineWeb.
+* <p>
+* Jskad embeds {@link DuffPane DuffPane}, which is the editing
+* window where the keyboard logic and most functionality is housed.
+* <p>
+* Depending on the object passed to the constructor,
+* a Jskad object can be used in either an application or an
+* applet.
+* @author Edward Garrett, Tibetan and Himalayan Digital Library
+* @version 1.0
+*/
+public class Jskad extends JPanel implements DocumentListener {
+	private RTFEditorKit rtfEditor;
+	private String fontName = "";
+	private JComboBox fontFamilies, fontSizes;
+	private JFileChooser fileChooser;
+	private javax.swing.filechooser.FileFilter rtfFilter;
+	private javax.swing.filechooser.FileFilter txtFilter;
+	private int fontSize = 0;
+	private Object parentObject = null;
+	private static int numberOfTibsRTFOpen = 0;
+	private static int x_size;
+	private static int y_size;
+	private TibetanKeyboard sambhota1Keyboard = null, duff1Keyboard = null, duff2Keyboard = null;
+
+/**
+* The text editing window which this Jskad object embeds.
+*/
+	public DuffPane dp;
+/**
+* Has the document been saved since it was last changed?
+*/
+	public boolean hasChanged = false;
+
+/**
+* The filename, if any, associated with this instance of Jskad.
+*/
+	public String fileName = null;
+
+/**
+* @param parent the object that embeds this instance of Jskad.
+* Supported objects include JFrames and JApplets. If the parent
+* is a JApplet then the File menu is omitted from the menu bar.
+*/
+	public Jskad(final Object parent) {
+		parentObject = parent;
+		numberOfTibsRTFOpen++;
+		JMenuBar menuBar = new JMenuBar();
+
+		if (parentObject instanceof JFrame || parentObject instanceof JInternalFrame) {
+			fileChooser = new JFileChooser();
+			rtfFilter = new RTFFilter();
+			txtFilter = new TXTFilter();
+			fileChooser.addChoosableFileFilter(rtfFilter);
+
+			JMenu fileMenu = new JMenu("File");
+
+			JMenuItem newItem = new JMenuItem("New");
+//			newItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_N,2)); //Ctrl-n
+			newItem.addActionListener(new ActionListener() {
+				public void actionPerformed(ActionEvent e) {
+					newFile();
+				}
+			});
+			fileMenu.add(newItem);
+
+			JMenuItem openItem = new JMenuItem("Open");
+//			openItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O,2)); //Ctrl-o
+			openItem.addActionListener(new ActionListener() {
+				public void actionPerformed(ActionEvent e) {
+					openFile();
+				}
+			});
+			fileMenu.add(openItem);
+
+			if (parentObject instanceof JFrame) {
+				JMenuItem closeItem = new JMenuItem("Close");	
+				closeItem.addActionListener(new ActionListener() {
+					public void actionPerformed(ActionEvent e) {
+						if (!hasChanged || hasChanged && checkSave()) {
+							numberOfTibsRTFOpen--;
+
+							if (numberOfTibsRTFOpen == 0)
+								System.exit(0);
+							else {
+								final JFrame parentFrame = (JFrame)parentObject;
+								parentFrame.dispose();
+							}
+						}
+					}
+				});
+				fileMenu.add(closeItem);
+			}
+
+			JMenuItem saveItem = new JMenuItem("Save");
+//			saveItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S,2)); //Ctrl-s
+			saveItem.addActionListener(new ActionListener() {
+				public void actionPerformed(ActionEvent e) {
+					if (fileName == null)
+						saveAsFile();
+					else
+						saveFile();
+				}
+
+			});
+			fileMenu.addSeparator();
+			fileMenu.add(saveItem);
+
+			JMenuItem saveAsItem = new JMenuItem("Save as");
+			saveAsItem.addActionListener(new ActionListener() {
+				public void actionPerformed(ActionEvent e) {
+					saveAsFile();
+				}
+			});
+			fileMenu.add(saveAsItem);
+
+			JMenuItem printItem = new JMenuItem("Print");
+			printItem.addActionListener(new ActionListener() {
+				public void actionPerformed(ActionEvent e) {
+					PrintDuffPane printer = new PrintDuffPane(Jskad.this, dp);
+					printer.preview();
+				}
+			});
+			fileMenu.addSeparator();
+			fileMenu.add(printItem);
+
+			menuBar.add(fileMenu);
+		}
+
+		JMenu editMenu = new JMenu("Edit");
+
+		if (parentObject instanceof JFrame || parentObject instanceof JInternalFrame) {
+			JMenuItem cutItem = new JMenuItem("Cut");
+			cutItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_X,2)); //Ctrl-x
+			cutItem.addActionListener(new ActionListener() {
+				public void actionPerformed(ActionEvent e) {
+					cutSelection();					
+				}
+			});
+			editMenu.add(cutItem);
+
+			JMenuItem copyItem = new JMenuItem("Copy");
+			copyItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_C,2)); //Ctrl-c
+			copyItem.addActionListener(new ActionListener() {
+				public void actionPerformed(ActionEvent e) {
+					copySelection();
+				}
+			});
+			editMenu.add(copyItem);
+
+			JMenuItem pasteItem = new JMenuItem("Paste");
+			pasteItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_V,2)); //Ctrl-v
+			pasteItem.addActionListener(new ActionListener() {
+				public void actionPerformed(ActionEvent e) {
+					pasteSelection();
+				}
+			});
+			editMenu.add(pasteItem);
+			editMenu.addSeparator();
+
+			JMenuItem selectallItem = new JMenuItem("Select All");
+			selectallItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_A,2)); //Ctrl-a
+			selectallItem.addActionListener(new ActionListener() {
+				public void actionPerformed(ActionEvent e) {
+					dp.setSelectionStart(0);
+					dp.setSelectionEnd(dp.getDocument().getLength());
+				}
+			});
+			editMenu.add(selectallItem);
+		}
+
+		JMenuItem preferencesItem = new JMenuItem("Preferences");
+		preferencesItem.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				getPreferences();
+			}
+		});
+		editMenu.addSeparator();
+		editMenu.add(preferencesItem);
+
+		menuBar.add(editMenu);
+
+		JMenu toolsMenu = new JMenu("Tools");
+
+		JMenuItem TMWWylieItem = new JMenuItem("Convert Tibetan to Wylie");
+		TMWWylieItem.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				toWylie();
+			}
+		});
+		toolsMenu.add(TMWWylieItem);
+
+		JMenuItem wylieTMWItem = new JMenuItem("Convert Wylie to Tibetan");
+		wylieTMWItem.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				toTibetan();
+			}
+		});
+		toolsMenu.add(wylieTMWItem);
+
+		if (parentObject instanceof JFrame || parentObject instanceof JInternalFrame) {
+			JMenuItem importItem = new JMenuItem("Import Wylie as Tibetan");
+			importItem.addActionListener(new ActionListener() {
+				public void actionPerformed(ActionEvent e) {
+					importWylie();
+				}
+			});
+			toolsMenu.addSeparator();
+			toolsMenu.add(importItem);
+		}
+
+		menuBar.add(toolsMenu);
+
+		JMenu infoMenu = new JMenu("Info");
+
+		JMenuItem aboutItem = new JMenuItem("About");
+		aboutItem.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				JOptionPane.showMessageDialog(Jskad.this,
+					"Copyright 2001 Tibetan and Himalayan Digital Library\n"+
+					"Programmed by Edward Garrett\n\n"+
+					"This software is protected by the terms of the\n"+
+					"THDL Open Community License, Version 1.0.\n"+
+					"It uses Tibetan Computer Company (http://www.tibet.dk/tcc/)\n"+
+					"fonts created by Tony Duff and made available by the\n"+
+					"Trace Foundation (http://trace.org/). Jskad also includes\n"+
+					"software written and copyrighted by Wildcrest Associates\n"+
+					"(http://www.wildcrest.com).\n\n"+
+					"For more information, or to download the source code\n"+
+					"for Jskad, see our web site:\n"+
+					"     http://www.thdl.org/",
+					"About Jskad 1.0",
+					JOptionPane.PLAIN_MESSAGE);
+			}
+		});
+		infoMenu.add(aboutItem);
+
+		menuBar.add(infoMenu);
+
+		JToolBar toolBar = new JToolBar();
+		toolBar.setBorder(null);
+		toolBar.addSeparator();
+		toolBar.add(new JLabel("Input mode:"));
+		toolBar.addSeparator();
+
+		String[] input_modes = {"Tibetan","Roman"};
+		final JComboBox inputmethods = new JComboBox(input_modes);
+		inputmethods.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				switch (inputmethods.getSelectedIndex()) {
+					case 0: //Tibetan
+						if (dp.isRomanMode())
+							dp.toggleLanguage();
+						break;
+
+					case 1: //Roman
+						if (!dp.isRomanMode() && dp.isRomanEnabled())
+							dp.toggleLanguage();
+						break;
+				}
+			}
+		});
+
+
+		toolBar.add(inputmethods);
+		toolBar.add(Box.createHorizontalGlue());
+
+		toolBar.add(new JLabel("Keyboard:"));
+		toolBar.addSeparator();
+
+		String[] keyboard_options = {"Extended Wylie","TCC Keyboard #1","TCC Keyboard #2","Sambhota Keymap One"};
+		final JComboBox keyboards = new JComboBox(keyboard_options);
+		keyboards.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				switch (keyboards.getSelectedIndex()) {
+					case 0: //Extended Wylie
+						installKeyboard("wylie");
+						break;
+
+					case 1: //TCC 1
+						if (duff1Keyboard == null)
+							duff1Keyboard = installKeyboard("tcc1");
+						else
+							dp.registerKeyboard(duff1Keyboard);
+						break;
+
+					case 2: //TCC 2
+						if (duff2Keyboard == null)
+							duff2Keyboard = installKeyboard("tcc2");
+						else
+							dp.registerKeyboard(duff2Keyboard);
+						break;
+
+					case 3: //Sambhota
+						if (sambhota1Keyboard == null)
+							sambhota1Keyboard = installKeyboard("sambhota1");
+						else
+							dp.registerKeyboard(sambhota1Keyboard);
+						break;
+				}
+			}
+		});
+		toolBar.add(keyboards);
+		toolBar.add(Box.createHorizontalGlue());
+
+		rtfEditor = new RTFEditorKit();
+		dp = new DuffPane(rtfEditor);
+		JScrollPane sp = new JScrollPane(dp, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
+		dp.getDocument().addDocumentListener(this);
+
+		if (parentObject instanceof JFrame) {
+			final JFrame parentFrame = (JFrame)parentObject;
+			parentFrame.setJMenuBar(menuBar);
+			parentFrame.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
+			parentFrame.addWindowListener(new WindowAdapter () {
+				public void windowClosing (WindowEvent e) {
+					if (!hasChanged || hasChanged && checkSave()) {
+						numberOfTibsRTFOpen--;
+						if (numberOfTibsRTFOpen == 0)
+							System.exit(0);
+						else
+							parentFrame.dispose();
+					}
+				}
+			});
+		}
+
+		else if (parentObject instanceof JInternalFrame) {
+			final JInternalFrame parentFrame = (JInternalFrame)parentObject;
+			parentFrame.setJMenuBar(menuBar);
+		}
+
+		else if (parentObject instanceof JApplet) {
+			JApplet parentApplet = (JApplet)parentObject;
+			parentApplet.setJMenuBar(menuBar);
+			dp.disableCutAndPaste();
+		}
+
+		setLayout(new BorderLayout());
+		add("North", toolBar);
+		add("Center", sp);
+	}
+
+	private void getPreferences() {
+		GraphicsEnvironment genv = GraphicsEnvironment.getLocalGraphicsEnvironment();
+		String[] fontNames = genv.getAvailableFontFamilyNames();
+
+		JPanel tibetanPanel;
+		JComboBox tibetanFontSizes;
+
+		tibetanPanel = new JPanel();
+		tibetanPanel.setBorder(BorderFactory.createTitledBorder("Set Tibetan Font Size"));
+		tibetanFontSizes = new JComboBox(new String[] {"8","10","12","14","16","18","20","22","24","26","28","30","32","34","36","48","72"});
+		tibetanFontSizes.setMaximumSize(tibetanFontSizes.getPreferredSize());
+		tibetanFontSizes.setSelectedItem(String.valueOf(dp.getTibetanFontSize()));
+		tibetanFontSizes.setEditable(true);
+		tibetanPanel.add(tibetanFontSizes);
+
+		JPanel romanPanel;
+		JComboBox romanFontFamilies;
+		JComboBox romanFontSizes;
+
+		romanPanel = new JPanel();
+		romanPanel.setBorder(BorderFactory.createTitledBorder("Set non-Tibetan Font and Size"));
+		romanFontFamilies = new JComboBox(fontNames);
+		romanFontFamilies.setMaximumSize(romanFontFamilies.getPreferredSize());
+		romanFontFamilies.setSelectedItem(dp.getRomanFontFamily());
+		romanFontFamilies.setEditable(true);
+		romanFontSizes = new JComboBox(new String[] {"8","10","12","14","16","18","20","22","24","26","28","30","32","34","36","48","72"});
+		romanFontSizes.setMaximumSize(romanFontSizes.getPreferredSize());
+		romanFontSizes.setSelectedItem(String.valueOf(dp.getRomanFontSize()));
+		romanFontSizes.setEditable(true);
+		romanPanel.setLayout(new GridLayout(1,2));
+		romanPanel.add(romanFontFamilies);
+		romanPanel.add(romanFontSizes);
+
+		JPanel preferencesPanel = new JPanel();
+		preferencesPanel.setLayout(new GridLayout(2,1));
+		preferencesPanel.add(tibetanPanel);
+		preferencesPanel.add(romanPanel);
+
+		JOptionPane pane = new JOptionPane(preferencesPanel);
+		JDialog dialog = pane.createDialog(this, "Preferences");
+		dialog.show();
+
+		int size;
+		try {
+			size = Integer.parseInt(tibetanFontSizes.getSelectedItem().toString());
+		}
+		catch (NumberFormatException ne) {
+			size = dp.getTibetanFontSize();
+		}
+		dp.setTibetanFontSize(size);
+
+		String font = romanFontFamilies.getSelectedItem().toString();
+		try {
+			size = Integer.parseInt(romanFontSizes.getSelectedItem().toString());
+		}
+		catch (NumberFormatException ne) {
+			size = dp.getRomanFontSize();
+		}
+		dp.setRomanAttributeSet(font, size);
+	}
+
+	private void newFile() {
+		if (dp.getDocument().getLength()>0 && parentObject instanceof JFrame) {
+			JFrame parentFrame = (JFrame)parentObject;
+			JFrame newFrame = new JFrame("Jskad");
+			Point point = parentFrame.getLocationOnScreen();
+			newFrame.setSize(parentFrame.getSize().width, parentFrame.getSize().height);
+			newFrame.setLocation(point.x+50, point.y+50);
+			newFrame.getContentPane().add(new Jskad(newFrame));
+			newFrame.setVisible(true);
+		}
+		else {
+			if (parentObject instanceof JFrame) {
+				JFrame parentFrame = (JFrame)parentObject;
+				parentFrame.setTitle("Jskad");
+			}
+			else if (parentObject instanceof JInternalFrame) {
+				JInternalFrame parentFrame = (JInternalFrame)parentObject;
+				parentFrame.setTitle("Jskad");
+			}
+			dp.newDocument();
+			dp.getDocument().addDocumentListener(Jskad.this);
+			hasChanged = false;
+		}
+	}
+
+	private void openFile() {
+		fileChooser = new JFileChooser();
+		fileChooser.addChoosableFileFilter(rtfFilter);
+
+		if (dp.getDocument().getLength()>0 && parentObject instanceof JFrame) {
+			setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
+
+			if (fileChooser.showOpenDialog(this) != JFileChooser.APPROVE_OPTION) {
+				setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
+				return;
+			}
+
+			final File fileChosen = fileChooser.getSelectedFile();
+			final String f_name = fileChosen.getAbsolutePath();
+
+			try {
+				JFrame parentFrame = (JFrame)parentObject;
+				InputStream in = new FileInputStream(fileChosen);
+				JFrame newFrame = new JFrame(f_name);
+				Point point = parentFrame.getLocationOnScreen();
+				newFrame.setSize(x_size, y_size);
+				newFrame.setLocation(point.x+50, point.y+50);
+				Jskad newRTF = new Jskad(newFrame);
+				newFrame.getContentPane().add(newRTF);
+				rtfEditor.read(in, newRTF.dp.getDocument(), 0);
+				newRTF.dp.getDocument().addDocumentListener(newRTF);
+				in.close();
+				newFrame.setTitle(f_name);
+				newRTF.fileName = f_name;
+				newRTF.hasChanged = false;
+				newRTF.dp.getCaret().setDot(0);
+				newFrame.setVisible(true);
+			}
+			catch (FileNotFoundException fnfe) {
+			}
+			catch (IOException ioe) {
+			}
+			catch (BadLocationException ble) {
+			}
+		}
+		else {
+			setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
+
+			if (fileChooser.showOpenDialog(this) != JFileChooser.APPROVE_OPTION) {
+				setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
+				return;
+			}
+
+			final File fileChosen = fileChooser.getSelectedFile();
+			final String f_name = fileChosen.getAbsolutePath();
+
+			try {
+				InputStream in = new FileInputStream(fileChosen);
+				dp.newDocument();
+				rtfEditor.read(in, dp.getDocument(), 0);
+				in.close();
+				dp.getCaret().setDot(0);
+				dp.getDocument().addDocumentListener(Jskad.this);
+				hasChanged = false;
+				fileName = f_name;
+
+				if (parentObject instanceof JFrame) {
+					JFrame parentFrame = (JFrame)parentObject;
+					parentFrame.setTitle(fileName);
+				}
+				else if (parentObject instanceof JInternalFrame) {
+					JInternalFrame parentFrame = (JInternalFrame)parentObject;
+					parentFrame.setTitle(fileName);
+				}
+			}
+			catch (FileNotFoundException fnfe) {
+			}
+			catch (IOException ioe) {
+			}
+			catch (BadLocationException ble) {
+			}
+		}
+		setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
+	}
+
+	private void saveFile() {
+		String s = getSave(fileName);
+		if (null != s) {
+			if (parentObject instanceof JFrame) {
+				JFrame parentFrame = (JFrame)parentObject;
+				parentFrame.setTitle(s);
+				fileName = s;
+			}
+			else if (parentObject instanceof JInternalFrame) {
+				JInternalFrame parentFrame = (JInternalFrame)parentObject;
+				parentFrame.setTitle(s);
+				fileName = s;
+			}
+		}
+	}
+
+	private void saveAsFile() {
+		String s = getSaveAs();
+		if (null != s) {
+			if (parentObject instanceof JFrame) {
+				JFrame parentFrame = (JFrame)parentObject;
+				parentFrame.setTitle(s);
+				fileName = s;
+			}
+			else if (parentObject instanceof JInternalFrame) {
+				JInternalFrame parentFrame = (JInternalFrame)parentObject;
+				parentFrame.setTitle(s);
+				fileName = s;
+			}
+		}
+	}
+
+	private boolean checkSave() {
+		int saveFirst = JOptionPane.showConfirmDialog(this, "Do you want to save your changes?", "Please select", JOptionPane.YES_NO_CANCEL_OPTION);
+
+		switch (saveFirst) {
+			case JOptionPane.NO_OPTION: //don't save but do continue
+				return true;
+
+			case JOptionPane.YES_OPTION: //save and continue
+				if (fileName == null)
+					saveAsFile();
+				else
+					saveFile();
+				return true;
+
+			default:
+				return false;
+		}
+	}
+
+	private String getSave(String f_name) {
+		File fileChosen = new File(f_name);
+
+		try {
+			OutputStream out = new FileOutputStream(fileChosen);
+			rtfEditor.write(out, dp.getDocument(), 0, dp.getDocument().getLength());
+			out.close();
+			hasChanged = false;
+		}
+		catch (Exception exception) {
+			exception.printStackTrace();
+			return null;
+		}
+
+		return f_name;
+	}
+
+	private String getSaveAs() {
+		setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
+
+		if (fileName == null)
+			fileChooser.setSelectedFile(null);
+		else
+			fileChooser.setSelectedFile(new File(fileName));
+
+		if (fileChooser.showSaveDialog(this) != JFileChooser.APPROVE_OPTION) {
+			setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
+			return null;
+		}
+
+		File fileChosen = fileChooser.getSelectedFile();
+		String fileName = fileChosen.getAbsolutePath();
+		int i = fileName.lastIndexOf('.');
+
+		if (i < 0)
+			fileName += ".rtf";
+		else
+			fileName = fileName.substring(0, i) + ".rtf";
+
+		getSave(fileName);
+
+		fileChooser.rescanCurrentDirectory();
+		setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
+		return fileName;
+	}
+
+	private void cutSelection() {
+		dp.copy(dp.getSelectionStart(), dp.getSelectionEnd(), true);
+	}
+
+	private void copySelection() {
+		dp.copy(dp.getSelectionStart(), dp.getSelectionEnd(), false);
+	}
+
+	private void pasteSelection() {
+		dp.paste(dp.getCaret().getDot());
+	}
+
+	private void toTibetan() {
+		Jskad.this.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
+		dp.toTibetanMachineWeb();
+		Jskad.this.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
+	}
+
+	private void toWylie() {
+		Jskad.this.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
+		dp.toWylie(dp.getSelectionStart(), dp.getSelectionEnd());
+		Jskad.this.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
+	}
+
+	private void importWylie() {
+		fileChooser.removeChoosableFileFilter(rtfFilter);
+		fileChooser.addChoosableFileFilter(txtFilter);
+
+		if (fileChooser.showDialog(Jskad.this, "Import Wylie") != JFileChooser.APPROVE_OPTION) {
+			setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
+			fileChooser.removeChoosableFileFilter(txtFilter);
+			fileChooser.addChoosableFileFilter(rtfFilter);
+			return;
+		}
+
+		File txt_fileChosen = fileChooser.getSelectedFile();
+		fileChooser.rescanCurrentDirectory();
+		setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
+		fileChooser.removeChoosableFileFilter(txtFilter);
+		fileChooser.addChoosableFileFilter(rtfFilter);
+
+		if (fileChooser.showDialog(Jskad.this, "Save as Tibetan") != JFileChooser.APPROVE_OPTION) {
+			setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
+			return;
+		}
+
+		File rtf_fileChosen = fileChooser.getSelectedFile();
+		fileChooser.rescanCurrentDirectory();
+		setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
+		String rtf_fileName = rtf_fileChosen.getAbsolutePath();
+		int i = rtf_fileName.lastIndexOf('.');
+
+		if (i < 0)
+			rtf_fileName += ".rtf";
+		else
+			rtf_fileName = fileName.substring(0, i) + ".rtf";
+
+		try {
+			BufferedReader in = new BufferedReader(new FileReader(txt_fileChosen));
+			DuffPane dp2 = new DuffPane();
+
+			try {
+				String val = in.readLine();
+
+				while (val != null) {
+					dp2.toTibetanMachineWeb(val + "\n", dp2.getCaret().getDot());
+					val = in.readLine();
+				}
+
+				TibetanDocument t_doc = (TibetanDocument)dp2.getDocument();
+				t_doc.writeRTFOutputStream(new FileOutputStream(new File(rtf_fileName)));
+			}
+			catch (IOException ioe) {
+				System.out.println("problem reading or writing file");
+			}
+		}
+		catch (FileNotFoundException fnfe) {
+			System.out.println("problem reading file");
+		}
+	}
+
+	private TibetanKeyboard installKeyboard(String name) {
+		TibetanKeyboard tk = null;
+
+		if (!name.equalsIgnoreCase("wylie")) {
+			URL keyboard_url = null;
+
+			if (name.equalsIgnoreCase("sambhota1"))
+				keyboard_url = TibetanMachineWeb.class.getResource("sambhota_keyboard_1.ini");
+
+			else if (name.equalsIgnoreCase("tcc1"))
+				keyboard_url = TibetanMachineWeb.class.getResource("tcc_keyboard_1.ini");
+
+			else if (name.equalsIgnoreCase("tcc2"))
+				keyboard_url = TibetanMachineWeb.class.getResource("tcc_keyboard_2.ini");
+
+			if (null != keyboard_url) {
+				try {
+					tk = new TibetanKeyboard(keyboard_url);
+				}
+				catch (TibetanKeyboard.InvalidKeyboardException ike) {
+					System.out.println("invalid keyboard file or file not found");
+					return null;
+				}
+			}
+			else
+				return null;
+		}
+
+		dp.registerKeyboard(tk);
+		return tk;
+	}
+
+/**
+* Allows use of Jskad as dependent JFrame.
+* Once you've called this method, users will
+* be able to close Jskad without shutting
+* down your superordinate application.
+*/
+	public void makeDependent() {
+		numberOfTibsRTFOpen++;
+	}
+
+/**
+* Fills the editing pane with content. If the
+* editing pane already has content, this method does nothing.
+*
+* @param wylie the string of wylie you want to
+* put in the editing pane
+*/
+	public void setContent(String wylie) {
+		if (dp.getDocument().getLength() > 0)
+			return;
+
+		dp.newDocument();
+		dp.toTibetanMachineWeb(wylie, 0);
+	}
+
+/**
+* Enables typing of Roman (non-Tibetan) text along
+* with Tibetan.
+*/
+	public void enableRoman() {
+		dp.enableRoman();
+	}
+
+/**
+* Disables typing of Roman (non-Tibetan) text.
+*/
+	public void disableRoman() {
+		dp.disableRoman();
+	}
+
+/*
+	private void showAttributes(int pos) {
+		dp.skipUpdate = true;
+
+		AttributeSet attr = dp.getDocument().getCharacterElement(pos).getAttributes();
+		String name = StyleConstants.getFontFamily(attr);
+
+		if (!fontName.equals(name)) {
+			fontName = name;
+			fontFamilies.setSelectedItem(name);
+		}
+		int size = StyleConstants.getFontSize(attr);
+		if (fontSize != size) {
+			fontSize = size;
+			fontSizes.setSelectedItem(Integer.toString(fontSize));
+		}
+
+		dp.skipUpdate = false;
+	}
+*/
+
+/**
+* Required for implementations of DocumentListener.
+* Does nothing.
+*/
+	public void changedUpdate(DocumentEvent de) {
+	}
+
+/**
+* Required for implementations of DocumentListener.
+* Informs the object that a change in the document
+* has occurred.
+*
+* @param de a DocumentEvent
+*/
+	public void insertUpdate(DocumentEvent de) {
+		hasChanged = true;
+	}
+
+/**
+* Required for implementations of DocumentListener.
+* Informs the object that a change in the document
+* has occurred.
+*
+* @param de a DocumentEvent
+*/
+	public void removeUpdate(DocumentEvent de) {
+		hasChanged = true;
+	}
+
+	private class RTFFilter extends javax.swing.filechooser.FileFilter {
+		// Accept all directories and all RTF files.
+
+		public boolean accept(File f) {
+			if (f.isDirectory()) {
+				return true;
+			}
+
+			String fName = f.getName();
+			int i = fName.lastIndexOf('.');
+
+			if (i < 0)
+				return false;
+
+			else {
+				String ext = fName.substring(i+1).toLowerCase();
+
+				if (ext.equals("rtf"))
+					return true;
+				else
+					return false;
+			}
+		}
+    
+		//the description of this filter
+		public String getDescription() {
+			return "Rich Text Format (.rtf)";
+		}
+	}
+
+	private class TXTFilter extends javax.swing.filechooser.FileFilter {
+		// Accept all directories and all TXT files.
+
+		public boolean accept(File f) {
+			if (f.isDirectory()) {
+				return true;
+			}
+
+			String fName = f.getName();
+			int i = fName.lastIndexOf('.');
+
+			if (i < 0)
+				return false;
+
+			else {
+				String ext = fName.substring(i+1).toLowerCase();
+
+				if (ext.equals("txt"))
+					return true;
+				else
+					return false;
+			}
+		}
+    
+		//the description of this filter
+		public String getDescription() {
+			return "Text file (.txt)";
+		}
+	}
+
+/**
+* Runs Jskad.
+* System output, including errors, is redirected to jskad.log.
+* If you discover a bug, please send us an email, making sure
+* to include the jskad.log file as an attachment.
+*/
+	public static void main(String[] args) {
+/*
+		try {
+			PrintStream ps = new PrintStream(new FileOutputStream("jskad.log"));
+			System.setErr(ps);
+			System.setOut(ps);
+		}
+		catch (Exception e) {
+		}	
+*/
+
+		try {
+			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
+		}
+		catch (Exception e) {
+		}
+
+		JFrame f = new JFrame("Jskad");
+		Dimension d = f.getToolkit().getScreenSize();
+		x_size = d.width/4*3;
+		y_size = d.height/4*3;
+		f.setSize(x_size, y_size);
+		f.setLocation(d.width/8, d.height/8);
+		f.getContentPane().add(new Jskad(f));
+		f.setVisible(true);
+	}
+}

source/org/thdl/tib/input/Jskad2JavaScript.java

@@ -0,0 +1,82 @@
+/*
+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.applet.Applet;
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import org.thdl.tib.text.*;
+import netscape.javascript.JSObject;
+
+/**
+* A version of Jskad which can be embedded into
+* a web page as an applet. It includes all of the functionality
+* of the application version of Jskad, minus the File menu.
+* In other words, it is not possible to open, save, and print
+* from this applet.
+* @author Edward Garrett, Tibetan and Himalayan Digital Library
+* @version 1.0
+*/
+public class Jskad2JavaScript extends JApplet {
+/**
+* the {@link Jskad Jskad} used by this applet
+*/
+	public Jskad jskad;
+
+	public void init() {
+		try {
+			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
+		}
+		catch (Exception e) {
+		}
+		setContentPane(makeContentPane());
+	}
+
+	private Container makeContentPane() {
+		JPanel panel = new JPanel(new BorderLayout());
+		jskad = new Jskad(this);
+		panel.add("Center", jskad);
+		JButton submit = new JButton("Submit");
+		submit.addActionListener(new ActionListener()
+		{
+			public void actionPerformed(ActionEvent e)
+			{
+				try {
+					TibetanDocument t_doc = (TibetanDocument)jskad.dp.getDocument();
+					String wylie = t_doc.getWylie();
+					Object[] args = {wylie};
+					JSObject.getWindow(Jskad2JavaScript.this).call("settext", args);
+				} catch (Exception ex) {
+				}
+			}
+		});
+		panel.add("South", submit);
+		return panel;
+	}
+
+	public void start() {
+	}
+
+	public void stop() {
+	}
+
+	public void destroy() {
+	}
+}

source/org/thdl/tib/input/Jskad4JavaScript.java

@@ -0,0 +1,90 @@
+/*
+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.applet.Applet;
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import org.thdl.tib.text.*;
+
+/**
+* A version of Jskad which can be embedded into
+* a web page as an applet. It includes all of the functionality
+* of the application version of Jskad, minus the File menu.
+* In other words, it is not possible to open, save, and print
+* from this applet.
+* @author Edward Garrett, Tibetan and Himalayan Digital Library
+* @version 1.0
+*/
+public class Jskad4JavaScript extends JApplet {
+/**
+* the {@link Jskad Jskad} used by this applet
+*/
+	public Jskad jskad;
+
+	public void init() {
+		try {
+			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
+		}
+		catch (Exception e) {
+		}
+		setContentPane(makeContentPane());
+		String wylie = getParameter("Wylie");
+		if (null != wylie)
+			setWylie(wylie);
+	}
+
+	private Container makeContentPane() {
+		jskad = new Jskad(this);
+		jskad.dp.disableRoman();
+		return jskad;
+	}
+
+	public void start() {
+	}
+
+	public void stop() {
+	}
+
+	public void destroy() {
+	}
+
+	public void setWylie(String wylie) {
+		try {
+			TibetanDocument.DuffData[] dd = TibetanDocument.getTibetanMachineWeb(wylie);
+			TibetanDocument t_doc = (TibetanDocument)jskad.dp.getDocument();
+			if (t_doc.getLength() > 0)
+				jskad.dp.newDocument();
+			TibetanDocument.DuffData[] duffdata = TibetanDocument.getTibetanMachineWeb(wylie);
+			t_doc.insertDuff(0, duffdata);
+		}
+		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()+"'.");
+		}
+	}
+
+	public String getWylie() {
+		TibetanDocument t_doc = (TibetanDocument)jskad.dp.getDocument();
+		return t_doc.getWylie();
+	}
+}

source/org/thdl/tib/input/JskadApplet.java

@@ -0,0 +1,63 @@
+/*
+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.applet.Applet;
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+
+/**
+* A version of Jskad which can be embedded into
+* a web page as an applet. It includes all of the functionality
+* of the application version of Jskad, minus the File menu.
+* In other words, it is not possible to open, save, and print
+* from this applet.
+* @author Edward Garrett, Tibetan and Himalayan Digital Library
+* @version 1.0
+*/
+public class JskadApplet extends JApplet {
+/**
+* the {@link Jskad Jskad} used by this applet
+*/
+	public Jskad jskad;
+
+	public void init() {
+		try {
+			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
+		}
+		catch (Exception e) {
+		}
+		setContentPane(makeContentPane());
+	}
+
+	private Container makeContentPane() {
+		jskad = new Jskad(this);
+		return jskad;
+	}
+
+	public void start() {
+	}
+
+	public void stop() {
+	}
+
+	public void destroy() {
+	}
+}

source/org/thdl/tib/input/JskadConversionTool.java

@@ -0,0 +1,87 @@
+/*
+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.applet.Applet;
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import org.thdl.tib.text.*;
+import netscape.javascript.JSObject;
+
+/**
+* A version of Jskad which can be embedded into
+* a web page as an applet. It includes all of the functionality
+* of the application version of Jskad, minus the File menu.
+* In other words, it is not possible to open, save, and print
+* from this applet.
+* @author Edward Garrett, Tibetan and Himalayan Digital Library
+* @version 1.0
+*/
+public class JskadConversionTool extends JApplet {
+/**
+* the {@link Jskad Jskad} used by this applet
+*/
+	public Jskad jskad;
+
+	public void init() {
+		try {
+			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
+		}
+		catch (Exception e) {
+		}
+		setContentPane(makeContentPane());
+	}
+
+	private Container makeContentPane() {
+		JPanel panel = new JPanel(new BorderLayout());
+		jskad = new Jskad(this);
+		panel.add("Center", jskad);
+		JButton submit = new JButton("Submit");
+		submit.addActionListener(new ActionListener()
+		{
+			public void actionPerformed(ActionEvent e)
+			{
+				try {
+					TibetanDocument t_doc = (TibetanDocument)jskad.dp.getDocument();
+					String wylie = t_doc.getWylie();
+					String html = "<HTML>\n<HEAD>\n<STYLE>\n";
+					html += TibetanHTML.getStyles("28");
+					html += "</STYLE>\n</HEAD>\n<BODY>\n";
+					html += TibetanHTML.getHTML(wylie);
+					html += "\n</BODY>\n</HTML>";
+					Object[] args = {wylie, html};
+					JSObject.getWindow(JskadConversionTool.this).call("setdata", args);
+				} catch (Exception ex) {
+				}
+			}
+		});
+		panel.add("South", submit);
+		return panel;
+	}
+
+	public void start() {
+	}
+
+	public void stop() {
+	}
+
+	public void destroy() {
+	}
+}

source/org/thdl/tib/input/JskadLight.java

@@ -0,0 +1,72 @@
+/*
+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.applet.Applet;
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+
+/**
+* Another version of Jskad which can be embedded into
+* a web page as an applet. It is called 'Light' because it
+* has no menu bar.
+* @author Edward Garrett, Tibetan and Himalayan Digital Library
+* @version 1.0
+*/
+public class JskadLight extends JApplet {
+/**
+* the scroll pane that embeds the editor
+*/
+	public JScrollPane scroll;
+/**
+* the panel that embeds the scroll pane
+*/
+	public JPanel panel;
+/**
+* the editing window
+*/
+	public DuffPane pane;
+
+	public void init() {
+		try {
+			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
+		}
+		catch (Exception e) {
+		}
+		setContentPane(makeContentPane());
+	}
+
+	private Container makeContentPane() {
+		panel = new JPanel(new GridLayout(1,1));
+		pane = new DuffPane();
+		scroll = new JScrollPane(pane, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
+		panel.add(scroll);
+		return panel;
+	}
+
+	public void start() {
+	}
+
+	public void stop() {
+	}
+
+	public void destroy() {
+	}
+}

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

@@ -0,0 +1,35 @@
+<!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 inputting Tibetan text.
+<p>
+Designed for use with the Tibetan Computer
+Company's free cross-platform TibetanMachineWeb fonts, this package
+contains methods for inputting Tibetan using various keyboard
+input methods, including true Wylie-based input, as well as
+user-defined keyboards.
+<p>
+The package includes a simple Tibetan text editor, Jskad,
+which can be run as an local application or embedded in a
+web page. Jskad supports a wide range of functions, including
+conversion back and forth between TibetanMachineWeb and
+Extended Wylie.
+<p>
+<h2>Related Documentation</h2>
+@see org.thdl.tib.text
+</body>
+</html>

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=*
+`=`
+&=$