/*
*******************************************************************************
* Copyright (C) 1996-2008, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.dev.demo.translit;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import java.text.CharacterIterator;
import com.ibm.icu.dev.test.util.Differ;
import com.ibm.icu.lang.*;
import com.ibm.icu.text.*;
import java.io.*;
/**
* A frame that allows the user to experiment with keyboard
* transliteration. This class has a main() method so it can be run
* as an application. The frame contains an editable text component
* and uses keyboard transliteration to process keyboard events.
*
* <p>Copyright (c) IBM Corporation 1999. All rights reserved.
*
* @author Alan Liu
*/
public class Demo extends Frame {
/**
* For serialization
*/
private static final long serialVersionUID = 1L;
static final boolean DEBUG = false;
static final String START_TEXT = "(cut,\u03BA\u03C5\u03C4,\u05D0,\u30AF\u30C8,\u4E80,\u091A\u0941\u0924\u094D)";
Transliterator translit = null;
String fontName = "Arial Unicode MS";
int fontSize = 18;
/*
boolean compound = false;
Transliterator[] compoundTranslit = new Transliterator[MAX_COMPOUND];
static final int MAX_COMPOUND = 128;
int compoundCount = 0;
*/
TransliteratingTextComponent text = null;
Menu translitMenu;
CheckboxMenuItem translitItem;
CheckboxMenuItem noTranslitItem;
static final String NO_TRANSLITERATOR = "None";
//private static final String COPYRIGHT =
// "\u00A9 IBM Corporation 1999. All rights reserved.";
public static void main(String[] args) {
Frame f = new Demo(600, 200);
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
com.ibm.icu.dev.demo.impl.DemoApplet.demoFrameClosed();
// System.exit(0);
}
});
f.setVisible(true);
com.ibm.icu.dev.demo.impl.DemoApplet.demoFrameOpened();
}
public Demo(int width, int height) {
super("Transliteration Demo");
initMenus();
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
handleClose();
}
});
text = new TransliteratingTextComponent();
Font font = new Font(fontName, Font.PLAIN, fontSize);
text.setFont(font);
text.setSize(width, height);
text.setVisible(true);
text.setText(START_TEXT);
add(text);
setSize(width, height);
setTransliterator("Latin-Greek", null);
}
private void initMenus() {
MenuBar mbar;
Menu menu;
MenuItem mitem;
//CheckboxMenuItem citem;
setMenuBar(mbar = new MenuBar());
mbar.add(menu = new Menu("File"));
menu.add(mitem = new MenuItem("Quit"));
mitem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
handleClose();
}
});
/*
final ItemListener setTransliteratorListener = new ItemListener() {
public void itemStateChanged(ItemEvent e) {
CheckboxMenuItem item = (CheckboxMenuItem) e.getSource();
if (e.getStateChange() == ItemEvent.DESELECTED) {
// Don't let the current transliterator be deselected.
// Just reselect it.
item.setState(true);
} else if (compound) {
// Adding an item to a compound transliterator
handleAddToCompound(item.getLabel());
} else if (item != translitItem) {
// Deselect previous choice. Don't need to call
// setState(true) on new choice.
translitItem.setState(false);
translitItem = item;
handleSetTransliterator(item.getLabel());
}
}
};
*/
/*
translitMenu.add(translitItem = noTranslitItem =
new CheckboxMenuItem(NO_TRANSLITERATOR, true));
noTranslitItem.addItemListener(new ItemListener() {
public void itemStateChanged(ItemEvent e) {
// Can't uncheck None -- any action here sets None to true
setNoTransliterator();
}
});
translitMenu.addSeparator();
*/
/*
translitMenu.add(citem = new CheckboxMenuItem("Compound"));
citem.addItemListener(new ItemListener() {
public void itemStateChanged(ItemEvent e) {
CheckboxMenuItem item = (CheckboxMenuItem) e.getSource();
if (e.getStateChange() == ItemEvent.DESELECTED) {
// If compound gets deselected, then select NONE
setNoTransliterator();
} else if (!compound) {
// Switching from non-compound to compound
translitItem.setState(false);
translitItem = item;
translit = null;
compound = true;
compoundCount = 0;
for (int i=0; i<MAX_COMPOUND; ++i) {
compoundTranslit[i] = null;
}
}
}
});
translitMenu.addSeparator();
*/
/*
for (Enumeration e=getSystemTransliteratorNames().elements();
e.hasMoreElements(); ) {
String s = (String) e.nextElement();
translitMenu.add(citem = new CheckboxMenuItem(s));
citem.addItemListener(setTransliteratorListener);
}
*/
Menu fontMenu = new Menu("Font");
String[] fonts = GraphicsEnvironment.getLocalGraphicsEnvironment().getAvailableFontFamilyNames();
for (int i = 0; i < fonts.length; ++i) {
MenuItem mItem = new MenuItem(fonts[i]);
mItem.addActionListener(new FontActionListener(fonts[i]));
fontMenu.add(mItem);
}
mbar.add(fontMenu);
Menu sizeMenu = new Menu("Size");
int[] sizes = {9, 10, 12, 14, 18, 24, 36, 48, 72};
for (int i = 0; i < sizes.length; ++i) {
MenuItem mItem = new MenuItem("" + sizes[i]);
mItem.addActionListener(new SizeActionListener(sizes[i]));
sizeMenu.add(mItem);
}
mbar.add(sizeMenu);
translit = null;
mbar.add(translitMenu = new Menu("Transliterator"));
translitMenu.add(convertSelectionItem = new MenuItem("Transliterate",
new MenuShortcut(KeyEvent.VK_K)));
convertSelectionItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
handleBatchTransliterate(translit);
}
});
translitMenu.add(swapSelectionItem = new MenuItem("Reverse",
new MenuShortcut(KeyEvent.VK_S)));
swapSelectionItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Transliterator inv;
try {
inv = translit.getInverse();
} catch (Exception x) {
inv = Transliterator.getInstance("null");
}
setTransliterator(inv.getID(), null);
}
});
translitMenu.add(convertTypingItem = new MenuItem("No Typing Conversion",
new MenuShortcut(KeyEvent.VK_T)));
convertTypingItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (!transliterateTyping) {
text.setTransliterator(translit);
convertTypingItem.setLabel("No Typing Conversion");
} else {
text.flush();
text.setTransliterator(null);
convertTypingItem.setLabel("Convert Typing");
}
transliterateTyping = !transliterateTyping;
}
});
translitMenu.add(historyMenu = new Menu("Recent"));
helpDialog = new InfoDialog(this, "Simple Demo", "Instructions",
"CTL A, X, C, V have customary meanings.\n"
+ "Arrow keys, delete and backspace work.\n"
+ "To get a character from its control point, type the hex, then hit CTL Q"
);
helpDialog.getArea().setEditable(false);
Menu helpMenu;
mbar.add(helpMenu = new Menu("Extras"));
helpMenu.add(mitem = new MenuItem("Help"));
mitem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
helpDialog.show();
}
});
hexDialog = new InfoDialog(this, "Hex Entry", "Use U+..., \\u..., \\x{...}, or &#x...;",
"\\u00E1"
);
Button button = new Button("Insert");
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String hexValue = hexDialog.getArea().getText();
text.insertText(fromHex.transliterate(hexValue));
}
});
hexDialog.getBottom().add(button);
helpMenu.add(mitem = new MenuItem("Hex...",
new MenuShortcut(KeyEvent.VK_H)));
mitem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
hexDialog.show();
}
});
// Compound Transliterator
compoundDialog = new InfoDialog(this, "Compound Transliterator", "",
"[^\\u0000-\\u00FF] hex"
);
button = new Button("Set");
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String compound = "";
try {
compound = compoundDialog.getArea().getText();
setTransliterator(compound, null);
} catch (RuntimeException ex) {
compoundDialog.getArea().setText(compound + "\n" + ex.getMessage());
}
}
});
compoundDialog.getBottom().add(button);
translitMenu.add(mitem = new MenuItem("Multiple...",
new MenuShortcut(KeyEvent.VK_M)));
mitem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
compoundDialog.show();
}
});
// RuleBased Transliterator
rulesDialog = new InfoDialog(this, "Rule-Based Transliterator", "",
"([A-Z]) > &Hex($1) &Name($1);\r\n"
+ "&Hex-Any($1) < ('\\' [uU] [a-fA-F0-9]*);\r\n"
+ "&Name-Any($1) < ('{' [^\\}]* '}');"
);
button = new Button("Set");
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String compound = "";
try {
compound = rulesDialog.getArea().getText();
String id = ruleId.getText();
setTransliterator(compound, id);
} catch (RuntimeException ex) {
rulesDialog.getArea().setText(compound + "\n#" + ex.getMessage());
}
}
});
rulesDialog.getBottom().add(button);
ruleId = new TextField("test1", 20);
Label temp = new Label(" Name:");
rulesDialog.getBottom().add(temp);
rulesDialog.getBottom().add(ruleId);
translitMenu.add(mitem = new MenuItem("From Rules...",
new MenuShortcut(KeyEvent.VK_R)));
mitem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
rulesDialog.show();
}
});
translitMenu.add(mitem = new MenuItem("From File...",
new MenuShortcut(KeyEvent.VK_F)));
mitem.addActionListener(new FileListener(this, RULE_FILE));
translitMenu.add(mitem = new MenuItem("Test File..."));
mitem.addActionListener(new FileListener(this, TEST_FILE));
// Flesh out the menu with the installed transliterators
translitMenu.addSeparator();
Iterator sources = add(new TreeSet(), Transliterator.getAvailableSources()).iterator();
while(sources.hasNext()) {
String source = (String) sources.next();
Iterator targets = add(new TreeSet(), Transliterator.getAvailableTargets(source)).iterator();
Menu targetMenu = new Menu(source);
while(targets.hasNext()) {
String target = (String) targets.next();
Set variantSet = add(new TreeSet(), Transliterator.getAvailableVariants(source, target));
if (variantSet.size() < 2) {
mitem = new MenuItem(target);
mitem.addActionListener(new TransliterationListener(source + "-" + target));
targetMenu.add(mitem);
} else {
Iterator variants = variantSet.iterator();
Menu variantMenu = new Menu(target);
while(variants.hasNext()) {
String variant = (String) variants.next();
String menuName = variant.length() == 0 ? "<default>" : variant;
//System.out.println("<" + source + "-" + target + "/" + variant + ">, <" + menuName + ">");
mitem = new MenuItem(menuName);
mitem.addActionListener(new TransliterationListener(source + "-" + target + "/" + variant));
variantMenu.add(mitem);
}
targetMenu.add(variantMenu);
}
}
translitMenu.add(targetMenu);
}
}
static final int RULE_FILE = 0, TEST_FILE = 1;
//
static class FileListener implements ActionListener {
Demo frame;
int choice;
FileListener(Demo frame, int choice) {
this.frame = frame;
this.choice = choice;
}
public void actionPerformed(ActionEvent e) {
String id = frame.translit.getID();
int slashPos = id.indexOf('/');
String variant = "";
if (slashPos >= 0) {
variant = "_" + id.substring(slashPos+1);
id = id.substring(0, slashPos);
}
FileDialog fileDialog = new FileDialog(frame, "Input File");
fileDialog.setFile("Test_" + id + ".txt");
fileDialog.show();
String fileName = fileDialog.getFile();
String fileDirectory = fileDialog.getDirectory();
if (fileName != null) {
try {
File f = new File(fileDirectory, fileName);
if (choice == RULE_FILE) {
// read stuff into buffer
StringBuffer buffer = new StringBuffer();
FileInputStream fis = new FileInputStream(f);
InputStreamReader isr = new InputStreamReader(fis, "UTF8");
BufferedReader br = new BufferedReader(isr, 32*1024);
while (true) {
String line = br.readLine();
if (line == null) break;
if (line.length() > 0 && line.charAt(0) == '\uFEFF') line = line.substring(1); // strip BOM
buffer.append('\n');
buffer.append(line);
}
br.close();
// Transform file name into id
if (fileName.startsWith("Transliterator_")) {
fileName = fileName.substring("Transliterator_".length());
}
int pos = fileName.indexOf('_');
if (pos < 0) {
id = fileName;
} else {
id = fileName.substring(0, pos) + "-";
int pos2 = fileName.indexOf('_', pos+1);
if (pos2 < 0) {
id += fileName.substring(pos+1);
} else {
id += fileName.substring(pos+1, pos2) + "/" + fileName.substring(pos2 + 1);
}
}
pos = id.lastIndexOf('.');
if (pos >= 0) id = id.substring(0, pos);
// Now set
frame.setTransliterator(buffer.toString(), id);
} else if (choice == TEST_FILE) {
genTestFile(f, frame.translit, variant);
}
} catch (Exception e2) {
e2.printStackTrace();
System.out.println("Problem opening/reading: " + fileDirectory + ", " + fileName);
}
}
fileDialog.dispose();
}
}
boolean transliterateTyping = true;
Transliterator fromHex = Transliterator.getInstance("Hex-Any");
InfoDialog helpDialog;
InfoDialog hexDialog;
InfoDialog compoundDialog;
InfoDialog rulesDialog;
TextField ruleId;
MenuItem convertSelectionItem = null;
MenuItem swapSelectionItem = null;
MenuItem convertTypingItem = null;
Menu historyMenu;
Map historyMap = new HashMap();
Set historySet = new TreeSet(new Comparator() {
public int compare(Object a, Object b) {
MenuItem aa = (MenuItem)a;
MenuItem bb = (MenuItem)b;
return aa.getLabel().compareTo(bb.getLabel());
}
});
// ADD Factory since otherwise getInverse blows out
static class DummyFactory implements Transliterator.Factory {
static DummyFactory singleton = new DummyFactory();
static HashMap m = new HashMap();
// Since Transliterators are immutable, we don't have to clone on set & get
static void add(String ID, Transliterator t) {
m.put(ID, t);
System.out.println("Registering: " + ID + ", " + t.toRules(true));
Transliterator.registerFactory(ID, singleton);
}
public Transliterator getInstance(String ID) {
return (Transliterator) m.get(ID);
}
}
static void printBreaks(int num, String testSource, BreakIterator brkItr) {
String result = "";
int lastPos = 0;
while (true) {
int pos = brkItr.next();
if (pos == BreakIterator.DONE) break;
result += testSource.substring(lastPos, pos) + "&";
lastPos = pos;
System.out.println(pos);
}
System.out.println("Test" + num + ": " + result);
}
static void printIteration(int num, String testSource, CharacterIterator ci) {
String result = "";
while (true) {
char ch = ci.next();
if (ch == CharacterIterator.DONE) break;
result += ch + "(" + ci.getIndex() + ")";
}
System.out.println("Test" + num + ": " + result);
}
static void printSources() {
String[] list = {"Latin-ThaiLogical", "ThaiLogical-Latin", "Thai-ThaiLogical", "ThaiLogical-Thai"};
UnicodeSet all = new UnicodeSet();
for (int i = 0; i < list.length; ++i) {
Transliterator tr = Transliterator.getInstance(list[i]);
UnicodeSet src = tr.getSourceSet();
System.out.println(list[i] + ": " + src.toPattern(true));
all.addAll(src);
}
System.out.println("All: " + all.toPattern(true));
UnicodeSet rem = new UnicodeSet("[[:latin:][:thai:]]");
System.out.println("missing from [:latin:][:thai:]: " + all.removeAll(rem).toPattern(true));
}
// 200E;LEFT-TO-RIGHT MARK;Cf;0;L;;;;;N;;;;;
static Transliterator title = Transliterator.getInstance("title");
static String hexAndNameRules = " ([:c:]) > \\u200E &hex/unicode($1) ' ( ) ' &name($1) \\u200E ' ';"
+ "([:mark:]) > \\u200E &hex/unicode($1) ' ( ' \\u200E \u25CC $1 \\u200E ' ) ' &name($1) \\u200E ' ';"
+ "(.) > \\u200E &hex/unicode($1) ' ( ' \\u200E $1 \\u200E ' ) ' &name($1) ' ' \\u200E;";
static Transliterator hexAndName = Transliterator.createFromRules("any-hexAndName",
hexAndNameRules, Transliterator.FORWARD);
//static Transliterator upper = Transliterator.getInstance("upper");
static final byte NONE = 0, TITLEWORD = 1, TITLELINE = 2;
static void genTestFile(File sourceFile, Transliterator translit, String variant) {
try {
System.out.println("Reading: " + sourceFile.getCanonicalPath());
BufferedReader in = new BufferedReader(
new InputStreamReader(
new FileInputStream(sourceFile), "UTF-8"));
String targetFile = sourceFile.getCanonicalPath();
int dotPos = targetFile.lastIndexOf('.');
if (dotPos >= 0) targetFile = targetFile.substring(0,dotPos);
targetFile += variant;
File outFile = new File(targetFile + ".html");
System.out.println("Writing: " + outFile.getCanonicalPath());
PrintWriter out = new PrintWriter(
new BufferedWriter(
new OutputStreamWriter(
new FileOutputStream(outFile), "UTF-8")));
String direction = "";
String id = translit.getID();
if (id.indexOf("Arabic") >= 0 || id.indexOf("Hebrew") >= 0) {
direction = " direction: rtl;";
}
boolean testRoundTrip = true;
boolean generateSets = true;
if (id.startsWith("Han-") || id.startsWith("ja-")) {
testRoundTrip = false;
generateSets = false;
}
out.println("<head><meta http-equiv='Content-Type' content='text/html; charset=utf-8'>");
out.println("<style><!--");
out.println("td, th { vertical-align: top; border: 1px solid black }");
out.println("td.s { background-color: #EEEEEE;" + direction + " }");
out.println("td.r { background-color: #CCCCCC;" + direction + " }");
out.println("td.n { background-color: #FFFFCC; }");
out.println("td.title { border: 0px solid black}");
out.println("span.d { background-color: #FF6666 }");
out.println("span.r { background-color: #66FF66 }");
out.println("body { font-family: 'Arial Unicode MS', 'Lucida Sans Unicode', Arial, sans-serif; margin: 5 }");
out.println("--></style>");
out.println("<title>" + id + " Transliteration Check</title></head>");
out.println("<body bgcolor='#FFFFFF'><p>See <a href='Test_Instructions.html'>Test_Instructions.html</a> for details.</p>");
out.println("<table>");
//out.println("<tr><th width='33%'>Thai</th><th width='33%'>Latin</th><th width='33%'>Thai</th></tr>");
Transliterator tl = translit;
Transliterator lt = tl.getInverse();
Transliterator ltFilter = tl.getInverse();
ltFilter.setFilter(new UnicodeSet("[:^Lu:]"));
Transliterator tlFilter = lt.getInverse();
tlFilter.setFilter(new UnicodeSet("[:^Lu:]"));
//Transliterator.getInstance("[:^Lu:]" + lt.getID());
BreakIterator sentenceBreak = BreakIterator.getSentenceInstance();
byte titleSetting = TITLELINE;
//boolean upperfilter = false;
boolean first = true;
while (true) {
String line = in.readLine();
if (line == null) break;
line = line.trim();
if (line.length() == 0) continue;
if (line.charAt(0) == '\uFEFF') line = line.substring(1); // remove BOM
if (line.charAt(0) == '#') continue; // comments
if (line.equals("@TITLECASE@")) {
titleSetting = TITLEWORD;
out.println("<tr><td colspan='2' class='title'><b>Names</b></td></tr>");
continue;
} else if (line.equals("@UPPERFILTER@")) {
//upperfilter = true;
continue;
} else if (line.startsWith("@SET")) {
UnicodeSet s = new UnicodeSet(line.substring(4).trim());
out.println("<tr><td colspan='2' class='title'><b>Characters</b></td></tr>");
UnicodeSetIterator it = new UnicodeSetIterator(s);
while (it.next()) {
addSentenceToTable(out, it.codepoint != UnicodeSetIterator.IS_STRING
? UTF16.valueOf(it.codepoint)
: it.string,
NONE, true, testRoundTrip, first, tl, lt);
}
continue;
}
sentenceBreak.setText(line);
int start = 0;
while (true) {
int end = sentenceBreak.next();
if (end == BreakIterator.DONE) break;
String coreSentence = line.substring(start, end);
//System.out.println("Core: " + hex.transliterate(coreSentence));
end = start;
int oldPos = 0;
while (oldPos < coreSentence.length()) {
// hack, because sentence doesn't seem to be working right
int pos = coreSentence.indexOf(". ", oldPos);
if (pos < 0) pos = coreSentence.length(); else pos = pos+2;
int pos2 = coreSentence.indexOf('\u3002', oldPos);
if (pos2 < 0) pos2 = coreSentence.length(); else pos2 = pos2 + 1;
if (pos > pos2) pos = pos2;
String sentence = coreSentence.substring(oldPos, pos).trim();
//System.out.println("Sentence: " + hex.transliterate(coreSentence));
oldPos = pos;
addSentenceToTable(out, sentence,
titleSetting, false, testRoundTrip, first, tl, lt);
first = false;
}
}
}
out.println("</table></body>");
out.close();
// Now write the source/target sets
if (generateSets) {
outFile = new File(targetFile + "_Sets.html");
System.out.println("Writing: " + outFile.getCanonicalPath());
out = new PrintWriter(
new BufferedWriter(
new OutputStreamWriter(
new FileOutputStream(outFile), "UTF-8")));
out.println("<head><meta http-equiv='Content-Type' content='text/html; charset=utf-8'>");
out.println("<style><!--");
out.println("body { font-family: 'Arial Unicode MS', 'Lucida Sans Unicode', Arial, sans-serif; margin: 5 }");
out.println("--></style>");
out.println("<title>" + id + " Transliteration Sets</title></head>");
out.println("<body bgcolor='#FFFFFF'>");
int dashPos = id.indexOf('-');
int slashPos = id.indexOf('/');
if (slashPos < 0) slashPos = id.length();
UnicodeSet sourceSuper = null;
try {
String temp = id.substring(0,dashPos);
if (temp.equals("ja")) sourceSuper = new UnicodeSet("[[:Han:][:hiragana:][:katakana:]]");
else sourceSuper = new UnicodeSet("[[:" + temp + ":][:Mn:][:Me:]]");
} catch (Exception e) {}
UnicodeSet targetSuper = null;
try {
targetSuper = new UnicodeSet("[[:" + id.substring(dashPos+1, slashPos) + ":][:Mn:][:Me:]]");
} catch (Exception e) {}
int nfdStyle = CLOSE_CASE | CLOSE_FLATTEN | CLOSE_CANONICAL;
int nfkdStyle = nfdStyle | CLOSE_COMPATIBILITY;
out.println("<ul>");
out.println("<p><b>None</b></p>");
showSets(out, translit, lt, null, null, 0);
out.println("<p><b>NFD</b></p>");
showSets(out, translit, lt, sourceSuper, targetSuper, nfdStyle);
out.println("<p><b>NFKD</b></p>");
showSets(out, translit, lt, sourceSuper, targetSuper, nfkdStyle);
out.println("</ul></body>");
out.close();
}
System.out.println("Done Writing");
} catch (Exception e) {
e.printStackTrace();
}
}
static void addSentenceToTable(PrintWriter out, String sentence,
byte titleSetting, boolean addName, boolean testRoundTrip, boolean first,
Transliterator tl, Transliterator lt) {
if (sentence.length() == 0) return; // skip empty lines
String originalShow = sentence;
String latin;
latin = tl.transliterate(saveAscii.transliterate(sentence));
String latinShow = latin;
if (titleSetting == TITLEWORD) {
latinShow = title.transliterate(latin);
} else if (titleSetting == TITLELINE) {
latinShow = titlecaseFirstWord(latinShow);
}
latinShow = restoreAscii.transliterate(latinShow);
String reverse;
reverse = restoreAscii.transliterate(lt.transliterate(latin));
String NFKDSentence = Normalizer.normalize(sentence, Normalizer.NFKD);
String NFKDLatin = Normalizer.normalize(latin, Normalizer.NFKD);
String NFKDReverse = Normalizer.normalize(reverse, Normalizer.NFKD);
if (latinShow.length() == 0) {
latinShow = "<i>empty</i>";
} else if (NFKDSentence.equals(NFKDLatin)) {
latinShow = "<span class='r'>" + latinShow + "</span>";
}
String reverseShow = reverse;
if (testRoundTrip && !NFKDReverse.equals(NFKDSentence)) {
int minLen = reverse.length();
if (minLen > sentence.length()) minLen = sentence.length();
int i;
for (i = 0; i < minLen; ++i) {
if (reverse.charAt(i) != sentence.charAt(i)) break;
}
//originalShow = sentence.substring(0,i) + "<span class='d'>" + sentence.substring(i) + "</span>";
reverseShow = reverseShow.length() == 0
? "<i>empty</i>"
//: reverse.substring(0,i) + "<span class='d'>" + reverse.substring(i) + "</span>";
: showDifference(sentence, reverse);
out.println("<tr><td class='s'" + (first ? " width='50%'>" : ">") + originalShow
+ "</td><td rowSpan='2'>" + latinShow
+ "</td></tr><tr><td class='r'>" + reverseShow
+ "</td></tr>");
} else {
out.println("<tr><td class='s'" + (first ? " width='50%'>" : ">") + originalShow
+ "</td><td>" + latinShow
+ "</td></tr>");
}
if (addName) {
latinShow = hexAndName.transliterate(latin);
if (latinShow.length() == 0) latinShow = "<i>empty</i>";
originalShow = hexAndName.transliterate(sentence);
if (originalShow.length() == 0) originalShow = "<i>empty</i>";
out.println("<tr><td class='n'>" + originalShow
+ "</td><td class='n'>" + latinShow
+ "</td></tr>");
}
out.println("<tr><td></td></tr>");
}
static String showDifference(String as, String bs) {
Differ differ = new Differ(300, 3);
StringBuffer out = new StringBuffer();
int max = as.length();
if (max < bs.length()) max = bs.length();
for (int j = 0; j <= max; ++j) {
if (j < as.length()) differ.addA(as.substring(j, j+1));
if (j < bs.length()) differ.addB(bs.substring(j, j+1));
differ.checkMatch(j == max);
if (differ.getACount() != 0 || differ.getBCount() != 0) {
out.append("...");
if (differ.getACount() != 0) {
out.append("<span class='r'>");
for (int i = 0; i < differ.getACount(); ++i) {
out.append(differ.getA(i));
}
out.append("</span>");
}
if (differ.getBCount() != 0) {
out.append("<span class='d'>");
for (int i = 0; i < differ.getBCount(); ++i) {
out.append(differ.getB(i));
}
out.append("</span>");
}
out.append("...");
}
}
return out.toString();
}
static void showSets(PrintWriter out, Transliterator translit, Transliterator inverse,
UnicodeSet sourceSuper, UnicodeSet targetSuper, int options) {
out.println("<li>Source Set:<ul><li>" + toPattern(closeUnicodeSet(translit.getSourceSet(), options), sourceSuper) + "</li></ul></li>");
out.println("<li>Reverse Target Set:<ul><li>" + toPattern(closeUnicodeSet(inverse.getTargetSet(), options), sourceSuper) + "</li></ul></li>");
out.println("<li>Target Set:<ul><li>" + toPattern(closeUnicodeSet(translit.getTargetSet(), options), targetSuper) + "</li></ul></li>");
out.println("<li>Reverse Source Set:<ul><li>" + toPattern(closeUnicodeSet(inverse.getSourceSet(), options), targetSuper) + "</li></ul></li>");
}
static final int CLOSE_CASE = 1, CLOSE_FLATTEN = 2, CLOSE_CANONICAL = 4, CLOSE_COMPATIBILITY = 8;
static UnicodeSet closeUnicodeSet(UnicodeSet source, int options) {
if (options == 0) return source;
UnicodeSetIterator it = new UnicodeSetIterator(source);
UnicodeSet additions = new UnicodeSet(); // to avoid messing up iterator
UnicodeSet removals = new UnicodeSet(); // to avoid messing up iterator
String base;
int cp;
// Add all case equivalents
if ((options & CLOSE_CASE) != 0) {
while (it.next()) {
cp = it.codepoint;
if (cp == UnicodeSetIterator.IS_STRING) continue;
int type = UCharacter.getType(cp);
if (type == Character.UPPERCASE_LETTER || type == Character.LOWERCASE_LETTER || type == Character.TITLECASE_LETTER) {
additions.add(UCharacter.toLowerCase(UTF16.valueOf(cp)));
additions.add(UCharacter.toUpperCase(UTF16.valueOf(cp)));
}
}
source.addAll(additions);
}
// Add the canonical closure of all strings and characters in source
if ((options & CLOSE_CANONICAL) != 0) {
it.reset();
additions.clear();
CanonicalIterator ci = new CanonicalIterator(".");
while (it.next()) {
if (it.codepoint == UnicodeSetIterator.IS_STRING) base = it.string;
else base = UTF16.valueOf(it.codepoint);
ci.setSource(base);
while (true) {
String trial = ci.next();
if (trial == null) break;
if (trial.equals(base)) continue;
additions.add(trial);
}
}
source.addAll(additions);
}
// flatten strings
if ((options & CLOSE_FLATTEN) != 0) {
it.reset();
additions.clear();
while (it.next()) {
if (it.codepoint != UnicodeSetIterator.IS_STRING) continue;
additions.addAll(it.string);
removals.add(it.string);
//System.out.println("flattening '" + hex.transliterate(it.string) + "'");
}
source.addAll(additions);
source.removeAll(removals);
}
// Now add decompositions of characters in source
if ((options & CLOSE_COMPATIBILITY) != 0) {
it.reset(source);
additions.clear();
while (it.next()) {
if (it.codepoint == UnicodeSetIterator.IS_STRING) base = it.string;
else base = UTF16.valueOf(it.codepoint);
if (Normalizer.isNormalized(base, Normalizer.NFKD,0)) continue;
String decomp = Normalizer.normalize(base, Normalizer.NFKD);
additions.add(decomp);
}
source.addAll(additions);
// Now add any other character that decomposes to a character in source
for (cp = 0; cp < 0x10FFFF; ++cp) {
if (!UCharacter.isDefined(cp)) continue;
if (Normalizer.isNormalized(cp, Normalizer.NFKD,0)) continue;
if (source.contains(cp)) continue;
String decomp = Normalizer.normalize(cp, Normalizer.NFKD);
if (source.containsAll(decomp)) {
// System.out.println("Adding: " + Integer.toString(cp,16) + " " + UCharacter.getName(cp));
source.add(cp);
}
}
}
return source;
}
static String toPattern(UnicodeSet source, UnicodeSet superset) {
if (superset != null) {
source.removeAll(superset);
return "[" + superset.toPattern(true) + " " + source.toPattern(true) + "]";
}
return source.toPattern(true);
}
static BreakIterator bi = BreakIterator.getWordInstance();
static String titlecaseFirstWord(String line) {
// search for first word with letters. If the first letter is lower, then titlecase it.
bi.setText(line);
int start = 0;
while (true) {
int end = bi.next();
if (end == BreakIterator.DONE) break;
int firstLetterType = getFirstLetterType(line, start, end);
if (firstLetterType != Character.UNASSIGNED) {
if (firstLetterType != Character.LOWERCASE_LETTER) break;
line = line.substring(0, start)
+ UCharacter.toTitleCase(line.substring(start, end), bi)
+ line.substring(end);
break;
}
end = start;
}
return line;
}
static final int LETTER_MASK =
(1<<Character.UPPERCASE_LETTER)
| (1<<Character.LOWERCASE_LETTER)
| (1<<Character.TITLECASE_LETTER)
| (1<<Character.MODIFIER_LETTER)
| (1<<Character.OTHER_LETTER)
;
static int getFirstLetterType(String line, int start, int end) {
int cp;
for (int i = start; i < end; i += UTF16.getCharCount(cp)) {
cp = UTF16.charAt(line, i);
int type = UCharacter.getType(cp);
if (((1<<type) & LETTER_MASK) != 0) return type;
}
return Character.UNASSIGNED;
}
static void printNames(UnicodeSet s, String targetFile) {
try {
File outFile = new File(targetFile);
System.out.println("Writing: " + outFile.getCanonicalPath());
PrintWriter out = new PrintWriter(
new BufferedWriter(
new OutputStreamWriter(
new FileOutputStream(outFile), "UTF-8")));
UnicodeSet main = new UnicodeSet();
UnicodeSet others = new UnicodeSet();
UnicodeSetIterator it = new UnicodeSetIterator(s);
while (it.next()) {
if (!UCharacter.isDefined(it.codepoint)) continue;
if (!Normalizer.isNormalized(it.codepoint, Normalizer.NFD,0)) {
String decomp = Normalizer.normalize(it.codepoint, Normalizer.NFD);
others.addAll(decomp);
continue;
}
out.println(" " + UTF16.valueOf(it.codepoint) + " <> XXX # " + UCharacter.getName(it.codepoint));
main.add(it.codepoint);
}
if (others.size() != 0) {
out.println("Decomposed characters found above: ");
others.removeAll(main);
it.reset(others);
while (it.next()) {
out.println(" " + UTF16.valueOf(it.codepoint) + " <> XXX # " + UCharacter.getName(it.codepoint));
}
}
out.close();
System.out.println("Done Writing");
} catch (Exception e) {
e.printStackTrace();
}
}
static Transliterator hex = Transliterator.getInstance("[^\\u0020-\\u007E] hex");
static final String saveRules =
"A <> \uEA41; B <> \uEA42; C <> \uEA43; D <> \uEA44; E <> \uEA45; F <> \uEA46; G <> \uEA47; H <> \uEA48; I <> \uEA49; "
+ "J <> \uEA4A; K <> \uEA4B; L <> \uEA4C; M <> \uEA4D; N <> \uEA4E; O <> \uEA4F; P <> \uEA50; Q <> \uEA51; R <> \uEA52; "
+ "S <> \uEA53; T <> \uEA54; U <> \uEA55; V <> \uEA56; W <> \uEA57; X <> \uEA58; Y <> \uEA59; Z <> \uEA5A; "
+ "a <> \uEA61; b <> \uEA62; c <> \uEA63; d <> \uEA64; e <> \uEA65; f <> \uEA66; g <> \uEA67; h <> \uEA68; i <> \uEA69; "
+ "j <> \uEA6A; k <> \uEA6B; l <> \uEA6C; m <> \uEA6D; n <> \uEA6E; o <> \uEA6F; p <> \uEA70; q <> \uEA71; r <> \uEA72; "
+ "s <> \uEA73; t <> \uEA74; u <> \uEA75; v <> \uEA76; w <> \uEA77; x <> \uEA78; y <> \uEA79; z <> \uEA7A;";
static Transliterator saveAscii = Transliterator.createFromRules("ascii-saved", saveRules, Transliterator.FORWARD);
static Transliterator restoreAscii = Transliterator.createFromRules("ascii-saved", saveRules, Transliterator.REVERSE);
static {
if (false) {
for (char i = 'A'; i <= 'z'; ++i) {
System.out.print(i + " <> " + hex.transliterate(String.valueOf((char)(0xEA00 + i))) + "; ");
}
UnicodeSet x = new UnicodeSet("[[:^ccc=0:]&[:^ccc=230:]]");
x = x.complement();
x = x.complement();
System.out.println("Test: " + x.toPattern(true));
Transliterator y = Transliterator.createFromRules("xxx", "$notAbove = [[:^ccc=0:]&[:^ccc=230:]]; u ($notAbove*) \u0308 > XXX | $1; ", Transliterator.FORWARD);
String[] testList = {"u\u0308", "u\u0316\u0308", "u\u0308\u0316", "u\u0301\u0308", "u\u0308\u0301"};
for (int i = 0; i < testList.length; ++i) {
String yy = y.transliterate(testList[i]);
System.out.println(hex.transliterate(testList[i]) + " => " + hex.transliterate(yy));
}
//printNames(new UnicodeSet("[\u0600-\u06FF]"), "Arabic-Latin.txt");
/*
BreakTransliterator.register();
BreakTransliterator testTrans = new BreakTransliterator("Any-XXX", null, null, "$");
String testSource = "The Quick: Brown fox--jumped.";
BreakIterator bi = testTrans.getBreakIterator();
bi.setText(new StringCharacterIterator(testSource));
printBreaks(0, testSource, bi);
//bi.setText(UCharacterIterator.getInstance(testSource));
//printBreaks(1, testSource, bi);
printIteration(2, testSource, new StringCharacterIterator(testSource));
//printIteration(3, testSource, UCharacterIterator.getInstance(testSource));
String test = testTrans.transliterate(testSource);
System.out.println("Test3: " + test);
DummyFactory.add(testTrans.getID(), testTrans);
*/
// AnyTransliterator.ScriptRunIterator.registerAnyToScript();
AnyTransliterator at = new AnyTransliterator("Greek", null);
at.transliterate("(cat,\u03b1,\u0915)");
DummyFactory.add(at.getID(), at);
at = new AnyTransliterator("Devanagari", null);
at.transliterate("(cat,\u03b1,\u0915)");
DummyFactory.add(at.getID(), at);
at = new AnyTransliterator("Latin", null);
at.transliterate("(cat,\u03b1,\u0915)");
DummyFactory.add(at.getID(), at);
DummyFactory.add("Any-gif", Transliterator.createFromRules("gif", "'\\'u(..)(..) > '<img src=\"http://www.unicode.org/gifs/24/' $1 '/U' $1$2 '.gif\">';", Transliterator.FORWARD));
DummyFactory.add("gif-Any", Transliterator.getInstance("Any-Null"));
DummyFactory.add("Any-RemoveCurly", Transliterator.createFromRules("RemoveCurly", "[\\{\\}] > ;", Transliterator.FORWARD));
DummyFactory.add("RemoveCurly-Any", Transliterator.getInstance("Any-Null"));
System.out.println("Trying &hex");
Transliterator t = Transliterator.createFromRules("hex2", "(.) > &hex($1);", Transliterator.FORWARD);
System.out.println("Registering");
DummyFactory.add("Any-hex2", t);
System.out.println("Trying &gif");
t = Transliterator.createFromRules("gif2", "(.) > &any-gif($1);", Transliterator.FORWARD);
System.out.println("Registering");
DummyFactory.add("Any-gif2", t);
}
}
void setTransliterator(String name, String id) {
if (DEBUG) System.out.println("Got: " + name);
if (id == null) {
translit = Transliterator.getInstance(name);
} else {
String reverseId = "";
int pos = id.indexOf('-');
if (pos < 0) {
reverseId = id + "-Any";
id = "Any-" + id;
} else {
int pos2 = id.indexOf("/", pos);
if (pos2 < 0) {
reverseId = id.substring(pos+1) + "-" + id.substring(0,pos);
} else {
reverseId = id.substring(pos+1, pos2) + "-" + id.substring(0,pos) + id.substring(pos2);
}
}
translit = Transliterator.createFromRules(id, name, Transliterator.FORWARD);
if (DEBUG) {
System.out.println("***Forward Rules");
System.out.println(translit.toRules(true));
System.out.println("***Source Set");
System.out.println(translit.getSourceSet().toPattern(true));
}
System.out.println("***Target Set");
UnicodeSet target = translit.getTargetSet();
System.out.println(target.toPattern(true));
UnicodeSet rest = new UnicodeSet("[a-z]").removeAll(target);
System.out.println("***ASCII - Target Set");
System.out.println(rest.toPattern(true));
DummyFactory.add(id, translit);
Transliterator translit2 = Transliterator.createFromRules(reverseId, name, Transliterator.REVERSE);
if (DEBUG) {
System.out.println("***Backward Rules");
System.out.println(translit2.toRules(true));
}
DummyFactory.add(reverseId, translit2);
Transliterator rev = translit.getInverse();
if (DEBUG) System.out.println("***Inverse Rules");
if (DEBUG) System.out.println(rev.toRules(true));
}
text.flush();
text.setTransliterator(translit);
convertSelectionItem.setLabel(Transliterator.getDisplayName(translit.getID()));
addHistory(translit);
Transliterator inv;
try {
inv = translit.getInverse();
} catch (Exception ex) {
inv = null;
}
if (inv != null) {
addHistory(inv);
swapSelectionItem.setEnabled(true);
} else {
swapSelectionItem.setEnabled(false);
}
System.out.println("Set transliterator: " + translit.getID()
+ (inv != null ? " and " + inv.getID() : ""));
}
void addHistory(Transliterator trans) {
String name = trans.getID();
MenuItem cmi = (MenuItem) historyMap.get(name);
if (cmi == null) {
cmi = new MenuItem(Transliterator.getDisplayName(name));
cmi.addActionListener(new TransliterationListener(name));
historyMap.put(name, cmi);
historySet.add(cmi);
historyMenu.removeAll();
Iterator it = historySet.iterator();
while (it.hasNext()) {
historyMenu.add((MenuItem)it.next());
}
}
}
class TransliterationListener implements ActionListener, ItemListener {
String name;
public TransliterationListener(String name) {
this.name = name;
}
public void actionPerformed(ActionEvent e) {
setTransliterator(name, null);
}
public void itemStateChanged(ItemEvent e) {
if (e.getStateChange() == ItemEvent.SELECTED) {
setTransliterator(name, null);
} else {
setTransliterator("Any-Null", null);
}
}
}
class FontActionListener implements ActionListener {
String name;
public FontActionListener(String name) {
this.name = name;
}
public void actionPerformed(ActionEvent e) {
if (DEBUG) System.out.println("Font: " + name);
fontName = name;
text.setFont(new Font(fontName, Font.PLAIN, fontSize));
}
}
class SizeActionListener implements ActionListener {
int size;
public SizeActionListener(int size) {
this.size = size;
}
public void actionPerformed(ActionEvent e) {
if (DEBUG) System.out.println("Size: " + size);
fontSize = size;
text.setFont(new Font(fontName, Font.PLAIN, fontSize));
}
}
Set add(Set s, Enumeration enumeration) {
while(enumeration.hasMoreElements()) {
s.add(enumeration.nextElement());
}
return s;
}
/**
* Get a sorted list of the system transliterators.
*/
/*
private static Vector getSystemTransliteratorNames() {
Vector v = new Vector();
for (Enumeration e=Transliterator.getAvailableIDs();
e.hasMoreElements(); ) {
v.addElement(e.nextElement());
}
// Insertion sort, O(n^2) acceptable for small n
for (int i=0; i<(v.size()-1); ++i) {
String a = (String) v.elementAt(i);
for (int j=i+1; j<v.size(); ++j) {
String b = (String) v.elementAt(j);
if (a.compareTo(b) > 0) {
v.setElementAt(b, i);
v.setElementAt(a, j);
a = b;
}
}
}
return v;
}
*/
/*
private void setNoTransliterator() {
translitItem = noTranslitItem;
noTranslitItem.setState(true);
handleSetTransliterator(noTranslitItem.getLabel());
compound = false;
for (int i=0; i<translitMenu.getItemCount(); ++i) {
MenuItem it = translitMenu.getItem(i);
if (it != noTranslitItem && it instanceof CheckboxMenuItem) {
((CheckboxMenuItem) it).setState(false);
}
}
}
*/
/*
private void handleAddToCompound(String name) {
if (compoundCount < MAX_COMPOUND) {
compoundTranslit[compoundCount] = decodeTranslitItem(name);
++compoundCount;
Transliterator t[] = new Transliterator[compoundCount];
System.arraycopy(compoundTranslit, 0, t, 0, compoundCount);
translit = new CompoundTransliterator(t);
text.setTransliterator(translit);
}
}
*/
/*
private void handleSetTransliterator(String name) {
translit = decodeTranslitItem(name);
text.setTransliterator(translit);
}
*/
/**
* Decode a menu item that looks like <translit name>.
*/
/*
private static Transliterator decodeTranslitItem(String name) {
return (name.equals(NO_TRANSLITERATOR))
? null : Transliterator.getInstance(name);
}
*/
private void handleBatchTransliterate(Transliterator trans) {
if (trans == null) {
return;
}
int start = text.getSelectionStart();
int end = text.getSelectionEnd();
ReplaceableString s =
new ReplaceableString(text.getText().substring(start, end));
StringBuffer log = null;
if (DEBUG) {
log = new StringBuffer();
log.append('"' + s.toString() + "\" (start " + start +
", end " + end + ") -> \"");
}
trans.transliterate(s);
String str = s.toString();
if (DEBUG) {
log.append(str + "\"");
System.out.println("Batch " + trans.getID() + ": " + log.toString());
}
text.replaceRange(str, start, end);
text.select(start, start + str.length());
}
private void handleClose() {
helpDialog.dispose();
dispose();
}
/*
class InfoDialog extends Dialog {
protected Button button;
protected TextArea area;
protected Dialog me;
protected Panel bottom;
public TextArea getArea() {
return area;
}
public Panel getBottom() {
return bottom;
}
InfoDialog(Frame parent, String title, String label, String message) {
super(parent, title, false);
me = this;
this.setLayout(new BorderLayout());
if (label.length() != 0) {
this.add("North", new Label(label));
}
area = new TextArea(message, 8, 80, TextArea.SCROLLBARS_VERTICAL_ONLY);
this.add("Center", area);
button = new Button("Hide");
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
me.hide();
}
});
bottom = new Panel();
bottom.setLayout(new FlowLayout(FlowLayout.CENTER, 0, 0));
bottom.add(button);
this.add("South", bottom);
this.pack();
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
me.hide();
}
});
}
}
*/
}