src/com/ibm/icu/dev/tool/ime/translit/TransliteratorInputMethod.java - external/github.com/unicode-org/icu - Git at Google

 /*
  *******************************************************************************
  * Copyright (C) 2004, International Business Machines Corporation and         *
  * others. All Rights Reserved.                                                *
  *******************************************************************************
  */

 package com.ibm.icu.dev.tool.ime.translit;

 import java.awt.AWTEvent;
 import java.awt.Color;
 import java.awt.Component;
 import java.awt.Dimension;
 import java.awt.Point;
 import java.awt.Rectangle;
 import java.awt.Toolkit;
 import java.awt.Window;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.awt.event.InputEvent;
 import java.awt.event.InputMethodEvent;
 import java.awt.event.KeyEvent;
 import java.awt.event.MouseEvent;
 import java.awt.font.TextAttribute;
 import java.awt.font.TextHitInfo;
 import java.awt.im.InputMethodHighlight;
 import java.awt.im.spi.InputMethod;
 import java.awt.im.spi.InputMethodContext;
 import java.text.AttributedString;
 import java.util.Comparator;
 import java.util.Enumeration;
 import java.util.Locale;
 import java.util.MissingResourceException;
 import java.util.ResourceBundle;
 import java.util.TreeSet;

 import javax.swing.JComboBox;
 import javax.swing.JLabel;
 import javax.swing.JList;
 import javax.swing.ListCellRenderer;

 import com.ibm.icu.impl.Utility;
 import com.ibm.icu.lang.UCharacter;
 import com.ibm.icu.text.Collator;
 import com.ibm.icu.text.ReplaceableString;
 import com.ibm.icu.text.Transliterator;

 public class TransliteratorInputMethod implements InputMethod {

     private static boolean usesAttachedIME() {
     // we're in the ext directory so permissions are not an issue
     String os = System.getProperty("os.name");
     if (os != null) {
         return os.indexOf("Windows") == -1;
     }
     return false;
     }

     // true if Solaris style; false if PC style, assume Apple uses PC style for now
     private static final boolean attachedStatusWindow = usesAttachedIME();

     // the shared status window
     private static Window statusWindow;

     // current or last owner
     private static TransliteratorInputMethod statusWindowOwner;

     // cache location limits for attached
     private static Rectangle attachedLimits;

     // convenience of access, to reflect the current state
     private static JComboBox choices;

     //
     // per-instance state
     //

     // if we're attached, the status window follows the client window
     private Point attachedLocation;

     private static int gid;

     private int id = gid++;

     InputMethodContext imc;
     private boolean enabled = true;

     private int selectedIndex = -1; // index in JComboBox corresponding to our transliterator
     private Transliterator transliterator;
     private int desiredContext;
     private StringBuffer buffer;
     private ReplaceableString replaceableText;
     private Transliterator.Position index;

     // debugging
     private static boolean TRACE_EVENT = false;
     private static boolean TRACE_MESSAGES = false;
     private static boolean TRACE_BUFFER = false;

     public TransliteratorInputMethod() {
     if (TRACE_MESSAGES) dumpStatus("<constructor>");

         buffer = new StringBuffer();
         replaceableText = new ReplaceableString(buffer);
     index = new Transliterator.Position();
     }

     public void dumpStatus(String msg) {
     System.out.println("(" + this + ") " + msg);
     }

     public void setInputMethodContext(InputMethodContext context) {
     initStatusWindow(context);

     imc = context;
     imc.enableClientWindowNotification(this, attachedStatusWindow);
     }

     private static void initStatusWindow(InputMethodContext context) {
     if (statusWindow == null) {
         String title;
             try {
         ResourceBundle rb = ResourceBundle.getBundle("com.ibm.icu.dev.tool.ime.translit.Transliterator");
                 title = rb.getString("title");
             }
             catch (MissingResourceException m) {
         System.out.println("Transliterator resources missing: " + m);
                 title = "Transliterator Input Method";
             }

             Window sw = context.createInputMethodWindow(title, false);

         // get all the ICU Transliterators
         Enumeration e = Transliterator.getAvailableIDs();
         TreeSet types = new TreeSet(new LabelComparator());

         while(e.hasMoreElements()) {
         String id = (String) e.nextElement();
         String name = Transliterator.getDisplayName(id);
         JLabel label = new JLabel(name);
         label.setName(id);
         types.add(label);
         }

         // add the transliterators to the combo box

         choices = new JComboBox(types.toArray());

         choices.setEditable(false);
         choices.setSelectedIndex(0);
         choices.setRenderer(new NameRenderer());
         choices.setActionCommand("transliterator");

         choices.addActionListener(new ActionListener() {
             public void actionPerformed(ActionEvent e) {
             if (statusWindowOwner != null) {
                 statusWindowOwner.statusWindowAction(e);
             }
             }
         });

         sw.add(choices);
         sw.pack();

         Dimension sd = Toolkit.getDefaultToolkit().getScreenSize();
         Dimension wd = sw.getSize();
         if (attachedStatusWindow) {
         attachedLimits = new Rectangle(0, 0, sd.width - wd.width, sd.height - wd.height);
         } else {
         sw.setLocation(sd.width - wd.width,
                    sd.height - wd.height - 25);
         }

         synchronized (TransliteratorInputMethod.class) {
         if (statusWindow == null) {
             statusWindow = sw;
         }
         }
     }
     }

     private void statusWindowAction(ActionEvent e) {
     if (TRACE_MESSAGES) dumpStatus(">>status window action");
     JComboBox cb = (JComboBox)e.getSource();
     int si = cb.getSelectedIndex();
     if (si != selectedIndex) { // otherwise, we don't need to change
         if (TRACE_MESSAGES) dumpStatus("status window action oldIndex: " + selectedIndex + " newIndex: " + si);

         selectedIndex = si;

         JLabel item = (JLabel)cb.getSelectedItem();

         // construct the actual transliterator
         // commit any text that may be present first
         commitAll();

         transliterator = Transliterator.getInstance(item.getName());
         desiredContext = transliterator.getMaximumContextLength();

         reset();
     }
     if (TRACE_MESSAGES) dumpStatus("<<status window action");
     }

     // java has no pin to rectangle function?
     private static void pin(Point p, Rectangle r) {
     if (p.x < r.x) { p.x = r.x; } else if (p.x > r.x + r.width) { p.x = r.x + r.width; }
     if (p.y < r.y) { p.y = r.y; } else if (p.y > r.y + r.height) { p.y = r.y + r.height; }
     }

     public void notifyClientWindowChange(Rectangle location) {
     if (TRACE_MESSAGES) dumpStatus(">>notify client window change: " + location);
     synchronized (TransliteratorInputMethod.class) {
         if (statusWindowOwner == this) {
         if (location == null) {
             statusWindow.setVisible(false);
         } else {
             attachedLocation = new Point(location.x, location.y + location.height);
             pin(attachedLocation, attachedLimits);
             statusWindow.setLocation(attachedLocation);
             statusWindow.setVisible(true);
         }
         }
     }
     if (TRACE_MESSAGES) dumpStatus("<<notify client window change: " + location);
     }

     public void activate() {
     if (TRACE_MESSAGES) dumpStatus(">>activate");

         synchronized (TransliteratorInputMethod.class) {
         if (statusWindowOwner != this) {
         if (TRACE_MESSAGES) dumpStatus("setStatusWindowOwner from: " + statusWindowOwner + " to: " + this);

         statusWindowOwner = this;
         if (attachedStatusWindow && attachedLocation != null) { // will be null before first change notification
             statusWindow.setLocation(attachedLocation);
         }
         choices.setSelectedIndex(selectedIndex == -1 ? choices.getSelectedIndex() : selectedIndex);
         }

         choices.setForeground(Color.BLACK);
         statusWindow.setVisible(true);
     }
     if (TRACE_MESSAGES) dumpStatus("<<activate");
     }

     public void deactivate(boolean isTemporary) {
     if (TRACE_MESSAGES) dumpStatus(">>deactivate" + (isTemporary ? " (temporary)" : ""));
     if (!isTemporary) {
         synchronized(TransliteratorInputMethod.class) {
         choices.setForeground(Color.LIGHT_GRAY);
         }
     }
     if (TRACE_MESSAGES) dumpStatus("<<deactivate" + (isTemporary ? " (temporary)" : ""));
     }

     public void hideWindows() {
     if (TRACE_MESSAGES) dumpStatus(">>hideWindows");
     synchronized (TransliteratorInputMethod.class) {
         if (statusWindowOwner == this) {
         if (TRACE_MESSAGES) dumpStatus("hiding");
         statusWindow.setVisible(false);
         }
     }
     if (TRACE_MESSAGES) dumpStatus("<<hideWindows");
     }

     public boolean setLocale(Locale locale) {
         return false;
     }

     public Locale getLocale() {
         return Locale.getDefault();
     }

     public void setCharacterSubsets(Character.Subset[] subsets) {
     }

     public void reconvert() {
     throw new UnsupportedOperationException();
     }

     public void removeNotify() {
     if (TRACE_MESSAGES) dumpStatus("**removeNotify");
     }

     public void endComposition() {
     commitAll();
     }

     public void dispose() {
     if (TRACE_MESSAGES) dumpStatus("**dispose");
     }

     public Object getControlObject() {
         return null;
     }

     public void setCompositionEnabled(boolean enable) {
     enabled = enable;
     }

     public boolean isCompositionEnabled() {
     return enabled;
     }

     // debugging
     private String eventInfo(AWTEvent event) {
     String info = event.toString();
     StringBuffer buf = new StringBuffer();
     int index1 = info.indexOf("[");
     int index2 = info.indexOf(",", index1);
     buf.append(info.substring(index1+1, index2));

     index1 = info.indexOf("] on ");
     index2 = info.indexOf("[", index1);
     if (index2 != -1) {
         int index3 = info.lastIndexOf(".", index2);
         if (index3 < index1 + 4) {
         index3 = index1 + 4;
         }
         buf.append(" on ");
         buf.append(info.substring(index3+1, index2));
     }
     return buf.toString();
     }

     public void dispatchEvent(AWTEvent event) {
     final int MODIFIERS =
         InputEvent.CTRL_MASK |
         InputEvent.META_MASK |
         InputEvent.ALT_MASK |
         InputEvent.ALT_GRAPH_MASK;

     switch (event.getID()) {
     case MouseEvent.MOUSE_PRESSED:
         if (enabled) {
         if (TRACE_EVENT) System.out.println("TIM: " + eventInfo(event));
         // we'll get this even if the user is scrolling, can we rely on the component?
         // commitAll(); // don't allow even clicks within our own edit area
         }
         break;

     case KeyEvent.KEY_TYPED: {
         if (enabled) {
         KeyEvent ke = (KeyEvent)event;
         if (TRACE_EVENT) System.out.println("TIM: " + eventInfo(ke));
         if ((ke.getModifiers() & MODIFIERS) != 0) {
             commitAll(); // assume a command, let it go through
         } else {
             if (handleTyped(ke.getKeyChar())) {
             ke.consume();
             }
         }
         }
     } break;

     case KeyEvent.KEY_PRESSED: {
         if (enabled) {
         KeyEvent ke = (KeyEvent)event;
         if (TRACE_EVENT) System.out.println("TIM: " + eventInfo(ke));
         if (handlePressed(ke.getKeyCode())) {
             ke.consume();
         }
         }
     } break;

     case KeyEvent.KEY_RELEASED: {
         // this won't autorepeat, which is better for toggle actions
         KeyEvent ke = (KeyEvent)event;
         if (ke.getKeyCode() == KeyEvent.VK_SPACE && ke.isControlDown()) {
         setCompositionEnabled(!enabled);
         }
     } break;

     default:
         break;
     }
     }

     /** Wipe clean */
     private void reset() {
     buffer.delete(0, buffer.length());
     index.contextStart = index.contextLimit = index.start = index.limit = 0;
     }

     // committed}context-composed|composed
     //          ^       ^        ^
     //         cc     start    ctxLim

     private void traceBuffer(String msg, int cc, int off) {
     if (TRACE_BUFFER) System.out.println(Utility.escape(msg + ": '" + buffer.substring(0, cc) + '}' +
                buffer.substring(cc, index.start) + '-' +
                buffer.substring(index.start, index.contextLimit) + '|' +
                buffer.substring(index.contextLimit) + '\''));
     }

     private void update(boolean flush) {
     int len = buffer.length();
     String text = buffer.toString();
     AttributedString as = new AttributedString(text);

     int cc, off;
     if (flush) {
         off = index.contextLimit - len; // will be negative
         cc = index.start = index.limit = index.contextLimit = len;
     } else {
         cc = index.start > desiredContext ? index.start - desiredContext : 0;
         off = index.contextLimit - cc;
     }

     if (index.start < len) {
         as.addAttribute(TextAttribute.INPUT_METHOD_HIGHLIGHT,
                 InputMethodHighlight.SELECTED_RAW_TEXT_HIGHLIGHT,
                 index.start, len);
     }

     imc.dispatchInputMethodEvent(InputMethodEvent.INPUT_METHOD_TEXT_CHANGED,
                      as.getIterator(),
                      cc,
                      TextHitInfo.leading(off),
                      null);

     traceBuffer("update", cc, off);

     if (cc > 0) {
         buffer.delete(0, cc);
         index.start -= cc;
         index.limit -= cc;
         index.contextLimit -= cc;
     }
     }

     private void updateCaret() {
     imc.dispatchInputMethodEvent(InputMethodEvent.CARET_POSITION_CHANGED,
                      null,
                      0,
                      TextHitInfo.leading(index.contextLimit),
                      null);
     traceBuffer("updateCaret", 0, index.contextLimit);
     }

     private void caretToStart() {
     if (index.contextLimit > index.start) {
         index.contextLimit = index.limit = index.start;
         updateCaret();
     }
     }

     private void caretToLimit() {
     if (index.contextLimit < buffer.length()) {
         index.contextLimit = index.limit = buffer.length();
         updateCaret();
     }
     }

     private boolean caretTowardsStart() {
     int bufpos = index.contextLimit;
     if (bufpos > index.start) {
         --bufpos;
         if (bufpos > index.start &&
         UCharacter.isLowSurrogate(buffer.charAt(bufpos)) &&
         UCharacter.isHighSurrogate(buffer.charAt(bufpos-1))) {
         --bufpos;
         }
         index.contextLimit = index.limit = bufpos;
         updateCaret();
         return true;
     }
     return commitAll();
     }

     private boolean caretTowardsLimit() {
     int bufpos = index.contextLimit;
     if (bufpos < buffer.length()) {
         ++bufpos;
         if (bufpos < buffer.length() &&
         UCharacter.isLowSurrogate(buffer.charAt(bufpos)) &&
         UCharacter.isHighSurrogate(buffer.charAt(bufpos-1))) {
         ++bufpos;
         }
         index.contextLimit = index.limit = bufpos;
         updateCaret();
         return true;
     }
     return commitAll();
     }

     private boolean canBackspace() {
     return index.contextLimit > 0;
     }

     private boolean backspace() {
     int bufpos = index.contextLimit;
     if (bufpos > 0) {
         int limit = bufpos;
         --bufpos;
         if (bufpos > 0 &&
         UCharacter.isLowSurrogate(buffer.charAt(bufpos)) &&
         UCharacter.isHighSurrogate(buffer.charAt(bufpos-1))) {
         --bufpos;
         }
         if (bufpos < index.start) {
         index.start = bufpos;
         }
         index.contextLimit = index.limit = bufpos;
         doDelete(bufpos, limit);
         return true;
     }
     return false;
     }

     private boolean canDelete() {
     return index.contextLimit < buffer.length();
     }

     private boolean delete() {
     int bufpos = index.contextLimit;
     if (bufpos < buffer.length()) {
         int limit = bufpos + 1;
         if (limit < buffer.length() &&
         UCharacter.isHighSurrogate(buffer.charAt(limit-1)) &&
         UCharacter.isLowSurrogate(buffer.charAt(limit))) {
         ++limit;
         }
         doDelete(bufpos, limit);
         return true;
     }
     return false;
     }

     private void doDelete(int start, int limit) {
     buffer.delete(start, limit);
     update(false);
     }

     private boolean commitAll() {
     if (buffer.length() > 0) {
         boolean atStart = index.start == index.contextLimit;
         boolean didConvert = buffer.length() > index.start;
         index.contextLimit = index.limit = buffer.length();
         transliterator.finishTransliteration(replaceableText, index);
         if (atStart) {
         index.start = index.limit = index.contextLimit = 0;
         }
         update(true);
         return didConvert;
     }
     return false;
     }

     private void clearAll() {
     int len = buffer.length();
     if (len > 0) {
         if (len > index.start) {
         buffer.delete(index.start, len);
         }
         update(true);
     }
     }

     private boolean insert(char c) {
     transliterator.transliterate(replaceableText, index, c);
     update(false);
     return true;
     }

     private boolean editing() {
     return buffer.length() > 0;
     }

     /**
      * The big problem is that from release to release swing changes how it
      * handles some characters like tab and backspace.  Sometimes it handles
      * them as keyTyped events, and sometimes it handles them as keyPressed
      * events.  If you want to allow the event to go through so swing handles
      * it, you have to allow one or the other to go through.  If you don't want
      * the event to go through so you can handle it, you have to stop the
      * event both places.
      * @return whether the character was handled
      */
     private boolean handleTyped(char ch) {
     if (enabled) {
         switch (ch) {
         case '\b': if (editing()) return backspace(); break;
         case '\t': if (editing()) { return commitAll(); } break;
         case '\u001b': if (editing()) { clearAll(); return true; } break;
         case '\u007f': if (editing()) return delete(); break;
         default: return insert(ch);
         }
     }
     return false;
     }

     /**
      * Handle keyPressed events.
      */
     private boolean handlePressed(int code) {
     if (enabled && editing()) {
         switch (code) {
         case KeyEvent.VK_PAGE_UP:
         case KeyEvent.VK_UP:
         case KeyEvent.VK_KP_UP:
         case KeyEvent.VK_HOME:
         caretToStart(); return true;
         case KeyEvent.VK_PAGE_DOWN:
         case KeyEvent.VK_DOWN:
         case KeyEvent.VK_KP_DOWN:
         case KeyEvent.VK_END:
         caretToLimit(); return true;
         case KeyEvent.VK_LEFT:
         case KeyEvent.VK_KP_LEFT:
         return caretTowardsStart();
         case KeyEvent.VK_RIGHT:
         case KeyEvent.VK_KP_RIGHT:
         return caretTowardsLimit();
         case KeyEvent.VK_BACK_SPACE:
         return canBackspace(); // unfortunately, in 1.5 swing handles this in keyPressed instead of keyTyped
         case KeyEvent.VK_DELETE:
         return canDelete(); // this too?
         case KeyEvent.VK_TAB:
         case KeyEvent.VK_ENTER:
         return commitAll(); // so we'll never handle VK_TAB in keyTyped

         case KeyEvent.VK_SHIFT:
         case KeyEvent.VK_CONTROL:
         case KeyEvent.VK_ALT:
         return false; // ignore these unless a key typed event gets generated
         default:
         // by default, let editor handle it, and we'll assume that it will tell us
         // to endComposition if it does anything funky with, e.g., function keys.
         return false;
         }
     }
     return false;
     }

     public String toString() {
     final String[] names = {
         "alice", "bill", "carrie", "doug", "elena", "frank", "gertie", "howie", "ingrid", "john"
     };

     if (id < names.length) {
         return names[id];
     } else {
         return names[id] + "-" + (id/names.length);
     }
     }
 }

 class NameRenderer extends JLabel implements ListCellRenderer {

     public Component getListCellRendererComponent(
         JList list,
         Object value,
         int index,
         boolean isSelected,
         boolean cellHasFocus) {

         String s = ((JLabel)value).getText();
         setText(s);

         if (isSelected) {
             setBackground(list.getSelectionBackground());
             setForeground(list.getSelectionForeground());
         } else {
             setBackground(list.getBackground());
             setForeground(list.getForeground());
         }

         setEnabled(list.isEnabled());
         setFont(list.getFont());
         setOpaque(true);
         return this;
     }
 }

 class LabelComparator implements Comparator {
     public int compare(Object obj1, Object obj2) {
         Collator collator = Collator.getInstance();
         return collator.compare(((JLabel)obj1).getText(), ((JLabel)obj2).getText());
     }

     public boolean equals(Object obj1) {
         return this.equals(obj1);
     }
 }
	/*
	*******************************************************************************
	* Copyright (C) 2004, International Business Machines Corporation and *
	* others. All Rights Reserved. *
	*******************************************************************************
	*/

	package com.ibm.icu.dev.tool.ime.translit;

	import java.awt.AWTEvent;
	import java.awt.Color;
	import java.awt.Component;
	import java.awt.Dimension;
	import java.awt.Point;
	import java.awt.Rectangle;
	import java.awt.Toolkit;
	import java.awt.Window;
	import java.awt.event.ActionEvent;
	import java.awt.event.ActionListener;
	import java.awt.event.InputEvent;
	import java.awt.event.InputMethodEvent;
	import java.awt.event.KeyEvent;
	import java.awt.event.MouseEvent;
	import java.awt.font.TextAttribute;
	import java.awt.font.TextHitInfo;
	import java.awt.im.InputMethodHighlight;
	import java.awt.im.spi.InputMethod;
	import java.awt.im.spi.InputMethodContext;
	import java.text.AttributedString;
	import java.util.Comparator;
	import java.util.Enumeration;
	import java.util.Locale;
	import java.util.MissingResourceException;
	import java.util.ResourceBundle;
	import java.util.TreeSet;

	import javax.swing.JComboBox;
	import javax.swing.JLabel;
	import javax.swing.JList;
	import javax.swing.ListCellRenderer;

	import com.ibm.icu.impl.Utility;
	import com.ibm.icu.lang.UCharacter;
	import com.ibm.icu.text.Collator;
	import com.ibm.icu.text.ReplaceableString;
	import com.ibm.icu.text.Transliterator;

	public class TransliteratorInputMethod implements InputMethod {

	private static boolean usesAttachedIME() {
	// we're in the ext directory so permissions are not an issue
	String os = System.getProperty("os.name");
	if (os != null) {
	return os.indexOf("Windows") == -1;
	}
	return false;
	}

	// true if Solaris style; false if PC style, assume Apple uses PC style for now
	private static final boolean attachedStatusWindow = usesAttachedIME();

	// the shared status window
	private static Window statusWindow;

	// current or last owner
	private static TransliteratorInputMethod statusWindowOwner;

	// cache location limits for attached
	private static Rectangle attachedLimits;

	// convenience of access, to reflect the current state
	private static JComboBox choices;

	//
	// per-instance state
	//

	// if we're attached, the status window follows the client window
	private Point attachedLocation;

	private static int gid;

	private int id = gid++;

	InputMethodContext imc;
	private boolean enabled = true;

	private int selectedIndex = -1; // index in JComboBox corresponding to our transliterator
	private Transliterator transliterator;
	private int desiredContext;
	private StringBuffer buffer;
	private ReplaceableString replaceableText;
	private Transliterator.Position index;

	// debugging
	private static boolean TRACE_EVENT = false;
	private static boolean TRACE_MESSAGES = false;
	private static boolean TRACE_BUFFER = false;

	public TransliteratorInputMethod() {
	if (TRACE_MESSAGES) dumpStatus("<constructor>");

	buffer = new StringBuffer();
	replaceableText = new ReplaceableString(buffer);
	index = new Transliterator.Position();
	}

	public void dumpStatus(String msg) {
	System.out.println("(" + this + ") " + msg);
	}

	public void setInputMethodContext(InputMethodContext context) {
	initStatusWindow(context);

	imc = context;
	imc.enableClientWindowNotification(this, attachedStatusWindow);
	}

	private static void initStatusWindow(InputMethodContext context) {
	if (statusWindow == null) {
	String title;
	try {
	ResourceBundle rb = ResourceBundle.getBundle("com.ibm.icu.dev.tool.ime.translit.Transliterator");
	title = rb.getString("title");
	}
	catch (MissingResourceException m) {
	System.out.println("Transliterator resources missing: " + m);
	title = "Transliterator Input Method";
	}

	Window sw = context.createInputMethodWindow(title, false);

	// get all the ICU Transliterators
	Enumeration e = Transliterator.getAvailableIDs();
	TreeSet types = new TreeSet(new LabelComparator());

	while(e.hasMoreElements()) {
	String id = (String) e.nextElement();
	String name = Transliterator.getDisplayName(id);
	JLabel label = new JLabel(name);
	label.setName(id);
	types.add(label);
	}

	// add the transliterators to the combo box

	choices = new JComboBox(types.toArray());

	choices.setEditable(false);
	choices.setSelectedIndex(0);
	choices.setRenderer(new NameRenderer());
	choices.setActionCommand("transliterator");

	choices.addActionListener(new ActionListener() {
	public void actionPerformed(ActionEvent e) {
	if (statusWindowOwner != null) {
	statusWindowOwner.statusWindowAction(e);
	}
	}
	});

	sw.add(choices);
	sw.pack();

	Dimension sd = Toolkit.getDefaultToolkit().getScreenSize();
	Dimension wd = sw.getSize();
	if (attachedStatusWindow) {
	attachedLimits = new Rectangle(0, 0, sd.width - wd.width, sd.height - wd.height);
	} else {
	sw.setLocation(sd.width - wd.width,
	sd.height - wd.height - 25);
	}

	synchronized (TransliteratorInputMethod.class) {
	if (statusWindow == null) {
	statusWindow = sw;
	}
	}
	}
	}

	private void statusWindowAction(ActionEvent e) {
	if (TRACE_MESSAGES) dumpStatus(">>status window action");
	JComboBox cb = (JComboBox)e.getSource();
	int si = cb.getSelectedIndex();
	if (si != selectedIndex) { // otherwise, we don't need to change
	if (TRACE_MESSAGES) dumpStatus("status window action oldIndex: " + selectedIndex + " newIndex: " + si);

	selectedIndex = si;

	JLabel item = (JLabel)cb.getSelectedItem();

	// construct the actual transliterator
	// commit any text that may be present first
	commitAll();

	transliterator = Transliterator.getInstance(item.getName());
	desiredContext = transliterator.getMaximumContextLength();

	reset();
	}
	if (TRACE_MESSAGES) dumpStatus("<<status window action");
	}

	// java has no pin to rectangle function?
	private static void pin(Point p, Rectangle r) {
	if (p.x < r.x) { p.x = r.x; } else if (p.x > r.x + r.width) { p.x = r.x + r.width; }
	if (p.y < r.y) { p.y = r.y; } else if (p.y > r.y + r.height) { p.y = r.y + r.height; }
	}

	public void notifyClientWindowChange(Rectangle location) {
	if (TRACE_MESSAGES) dumpStatus(">>notify client window change: " + location);
	synchronized (TransliteratorInputMethod.class) {
	if (statusWindowOwner == this) {
	if (location == null) {
	statusWindow.setVisible(false);
	} else {
	attachedLocation = new Point(location.x, location.y + location.height);
	pin(attachedLocation, attachedLimits);
	statusWindow.setLocation(attachedLocation);
	statusWindow.setVisible(true);
	}
	}
	}
	if (TRACE_MESSAGES) dumpStatus("<<notify client window change: " + location);
	}

	public void activate() {
	if (TRACE_MESSAGES) dumpStatus(">>activate");

	synchronized (TransliteratorInputMethod.class) {
	if (statusWindowOwner != this) {
	if (TRACE_MESSAGES) dumpStatus("setStatusWindowOwner from: " + statusWindowOwner + " to: " + this);

	statusWindowOwner = this;
	if (attachedStatusWindow && attachedLocation != null) { // will be null before first change notification
	statusWindow.setLocation(attachedLocation);
	}
	choices.setSelectedIndex(selectedIndex == -1 ? choices.getSelectedIndex() : selectedIndex);
	}

	choices.setForeground(Color.BLACK);
	statusWindow.setVisible(true);
	}
	if (TRACE_MESSAGES) dumpStatus("<<activate");
	}

	public void deactivate(boolean isTemporary) {
	if (TRACE_MESSAGES) dumpStatus(">>deactivate" + (isTemporary ? " (temporary)" : ""));
	if (!isTemporary) {
	synchronized(TransliteratorInputMethod.class) {
	choices.setForeground(Color.LIGHT_GRAY);
	}
	}
	if (TRACE_MESSAGES) dumpStatus("<<deactivate" + (isTemporary ? " (temporary)" : ""));
	}

	public void hideWindows() {
	if (TRACE_MESSAGES) dumpStatus(">>hideWindows");
	synchronized (TransliteratorInputMethod.class) {
	if (statusWindowOwner == this) {
	if (TRACE_MESSAGES) dumpStatus("hiding");
	statusWindow.setVisible(false);
	}
	}
	if (TRACE_MESSAGES) dumpStatus("<<hideWindows");
	}

	public boolean setLocale(Locale locale) {
	return false;
	}

	public Locale getLocale() {
	return Locale.getDefault();
	}

	public void setCharacterSubsets(Character.Subset[] subsets) {
	}

	public void reconvert() {
	throw new UnsupportedOperationException();
	}

	public void removeNotify() {
	if (TRACE_MESSAGES) dumpStatus("**removeNotify");
	}

	public void endComposition() {
	commitAll();
	}

	public void dispose() {
	if (TRACE_MESSAGES) dumpStatus("**dispose");
	}

	public Object getControlObject() {
	return null;
	}

	public void setCompositionEnabled(boolean enable) {
	enabled = enable;
	}

	public boolean isCompositionEnabled() {
	return enabled;
	}

	// debugging
	private String eventInfo(AWTEvent event) {
	String info = event.toString();
	StringBuffer buf = new StringBuffer();
	int index1 = info.indexOf("[");
	int index2 = info.indexOf(",", index1);
	buf.append(info.substring(index1+1, index2));

	index1 = info.indexOf("] on ");
	index2 = info.indexOf("[", index1);
	if (index2 != -1) {
	int index3 = info.lastIndexOf(".", index2);
	if (index3 < index1 + 4) {
	index3 = index1 + 4;
	}
	buf.append(" on ");
	buf.append(info.substring(index3+1, index2));
	}
	return buf.toString();
	}

	public void dispatchEvent(AWTEvent event) {
	final int MODIFIERS =
	InputEvent.CTRL_MASK \|
	InputEvent.META_MASK \|
	InputEvent.ALT_MASK \|
	InputEvent.ALT_GRAPH_MASK;

	switch (event.getID()) {
	case MouseEvent.MOUSE_PRESSED:
	if (enabled) {
	if (TRACE_EVENT) System.out.println("TIM: " + eventInfo(event));
	// we'll get this even if the user is scrolling, can we rely on the component?
	// commitAll(); // don't allow even clicks within our own edit area
	}
	break;

	case KeyEvent.KEY_TYPED: {
	if (enabled) {
	KeyEvent ke = (KeyEvent)event;
	if (TRACE_EVENT) System.out.println("TIM: " + eventInfo(ke));
	if ((ke.getModifiers() & MODIFIERS) != 0) {
	commitAll(); // assume a command, let it go through
	} else {
	if (handleTyped(ke.getKeyChar())) {
	ke.consume();
	}
	}
	}
	} break;

	case KeyEvent.KEY_PRESSED: {
	if (enabled) {
	KeyEvent ke = (KeyEvent)event;
	if (TRACE_EVENT) System.out.println("TIM: " + eventInfo(ke));
	if (handlePressed(ke.getKeyCode())) {
	ke.consume();
	}
	}
	} break;

	case KeyEvent.KEY_RELEASED: {
	// this won't autorepeat, which is better for toggle actions
	KeyEvent ke = (KeyEvent)event;
	if (ke.getKeyCode() == KeyEvent.VK_SPACE && ke.isControlDown()) {
	setCompositionEnabled(!enabled);
	}
	} break;

	default:
	break;
	}
	}

	/** Wipe clean */
	private void reset() {
	buffer.delete(0, buffer.length());
	index.contextStart = index.contextLimit = index.start = index.limit = 0;
	}

	// committed}context-composed\|composed
	// ^ ^ ^
	// cc start ctxLim

	private void traceBuffer(String msg, int cc, int off) {
	if (TRACE_BUFFER) System.out.println(Utility.escape(msg + ": '" + buffer.substring(0, cc) + '}' +
	buffer.substring(cc, index.start) + '-' +
	buffer.substring(index.start, index.contextLimit) + '\|' +
	buffer.substring(index.contextLimit) + '\''));
	}

	private void update(boolean flush) {
	int len = buffer.length();
	String text = buffer.toString();
	AttributedString as = new AttributedString(text);

	int cc, off;
	if (flush) {
	off = index.contextLimit - len; // will be negative
	cc = index.start = index.limit = index.contextLimit = len;
	} else {
	cc = index.start > desiredContext ? index.start - desiredContext : 0;
	off = index.contextLimit - cc;
	}

	if (index.start < len) {
	as.addAttribute(TextAttribute.INPUT_METHOD_HIGHLIGHT,
	InputMethodHighlight.SELECTED_RAW_TEXT_HIGHLIGHT,
	index.start, len);
	}

	imc.dispatchInputMethodEvent(InputMethodEvent.INPUT_METHOD_TEXT_CHANGED,
	as.getIterator(),
	cc,
	TextHitInfo.leading(off),
	null);

	traceBuffer("update", cc, off);

	if (cc > 0) {
	buffer.delete(0, cc);
	index.start -= cc;
	index.limit -= cc;
	index.contextLimit -= cc;
	}
	}

	private void updateCaret() {
	imc.dispatchInputMethodEvent(InputMethodEvent.CARET_POSITION_CHANGED,
	null,
	0,
	TextHitInfo.leading(index.contextLimit),
	null);
	traceBuffer("updateCaret", 0, index.contextLimit);
	}

	private void caretToStart() {
	if (index.contextLimit > index.start) {
	index.contextLimit = index.limit = index.start;
	updateCaret();
	}
	}

	private void caretToLimit() {
	if (index.contextLimit < buffer.length()) {
	index.contextLimit = index.limit = buffer.length();
	updateCaret();
	}
	}

	private boolean caretTowardsStart() {
	int bufpos = index.contextLimit;
	if (bufpos > index.start) {
	--bufpos;
	if (bufpos > index.start &&
	UCharacter.isLowSurrogate(buffer.charAt(bufpos)) &&
	UCharacter.isHighSurrogate(buffer.charAt(bufpos-1))) {
	--bufpos;
	}
	index.contextLimit = index.limit = bufpos;
	updateCaret();
	return true;
	}
	return commitAll();
	}

	private boolean caretTowardsLimit() {
	int bufpos = index.contextLimit;
	if (bufpos < buffer.length()) {
	++bufpos;
	if (bufpos < buffer.length() &&
	UCharacter.isLowSurrogate(buffer.charAt(bufpos)) &&
	UCharacter.isHighSurrogate(buffer.charAt(bufpos-1))) {
	++bufpos;
	}
	index.contextLimit = index.limit = bufpos;
	updateCaret();
	return true;
	}
	return commitAll();
	}

	private boolean canBackspace() {
	return index.contextLimit > 0;
	}

	private boolean backspace() {
	int bufpos = index.contextLimit;
	if (bufpos > 0) {
	int limit = bufpos;
	--bufpos;
	if (bufpos > 0 &&
	UCharacter.isLowSurrogate(buffer.charAt(bufpos)) &&
	UCharacter.isHighSurrogate(buffer.charAt(bufpos-1))) {
	--bufpos;
	}
	if (bufpos < index.start) {
	index.start = bufpos;
	}
	index.contextLimit = index.limit = bufpos;
	doDelete(bufpos, limit);
	return true;
	}
	return false;
	}

	private boolean canDelete() {
	return index.contextLimit < buffer.length();
	}

	private boolean delete() {
	int bufpos = index.contextLimit;
	if (bufpos < buffer.length()) {
	int limit = bufpos + 1;
	if (limit < buffer.length() &&
	UCharacter.isHighSurrogate(buffer.charAt(limit-1)) &&
	UCharacter.isLowSurrogate(buffer.charAt(limit))) {
	++limit;
	}
	doDelete(bufpos, limit);
	return true;
	}
	return false;
	}

	private void doDelete(int start, int limit) {
	buffer.delete(start, limit);
	update(false);
	}

	private boolean commitAll() {
	if (buffer.length() > 0) {
	boolean atStart = index.start == index.contextLimit;
	boolean didConvert = buffer.length() > index.start;
	index.contextLimit = index.limit = buffer.length();
	transliterator.finishTransliteration(replaceableText, index);
	if (atStart) {
	index.start = index.limit = index.contextLimit = 0;
	}
	update(true);
	return didConvert;
	}
	return false;
	}

	private void clearAll() {
	int len = buffer.length();
	if (len > 0) {
	if (len > index.start) {
	buffer.delete(index.start, len);
	}
	update(true);
	}
	}

	private boolean insert(char c) {
	transliterator.transliterate(replaceableText, index, c);
	update(false);
	return true;
	}

	private boolean editing() {
	return buffer.length() > 0;
	}

	/**
	* The big problem is that from release to release swing changes how it
	* handles some characters like tab and backspace. Sometimes it handles
	* them as keyTyped events, and sometimes it handles them as keyPressed
	* events. If you want to allow the event to go through so swing handles
	* it, you have to allow one or the other to go through. If you don't want
	* the event to go through so you can handle it, you have to stop the
	* event both places.
	* @return whether the character was handled
	*/
	private boolean handleTyped(char ch) {
	if (enabled) {
	switch (ch) {
	case '\b': if (editing()) return backspace(); break;
	case '\t': if (editing()) { return commitAll(); } break;
	case '\u001b': if (editing()) { clearAll(); return true; } break;
	case '\u007f': if (editing()) return delete(); break;
	default: return insert(ch);
	}
	}
	return false;
	}

	/**
	* Handle keyPressed events.
	*/
	private boolean handlePressed(int code) {
	if (enabled && editing()) {
	switch (code) {
	case KeyEvent.VK_PAGE_UP:
	case KeyEvent.VK_UP:
	case KeyEvent.VK_KP_UP:
	case KeyEvent.VK_HOME:
	caretToStart(); return true;
	case KeyEvent.VK_PAGE_DOWN:
	case KeyEvent.VK_DOWN:
	case KeyEvent.VK_KP_DOWN:
	case KeyEvent.VK_END:
	caretToLimit(); return true;
	case KeyEvent.VK_LEFT:
	case KeyEvent.VK_KP_LEFT:
	return caretTowardsStart();
	case KeyEvent.VK_RIGHT:
	case KeyEvent.VK_KP_RIGHT:
	return caretTowardsLimit();
	case KeyEvent.VK_BACK_SPACE:
	return canBackspace(); // unfortunately, in 1.5 swing handles this in keyPressed instead of keyTyped
	case KeyEvent.VK_DELETE:
	return canDelete(); // this too?
	case KeyEvent.VK_TAB:
	case KeyEvent.VK_ENTER:
	return commitAll(); // so we'll never handle VK_TAB in keyTyped

	case KeyEvent.VK_SHIFT:
	case KeyEvent.VK_CONTROL:
	case KeyEvent.VK_ALT:
	return false; // ignore these unless a key typed event gets generated
	default:
	// by default, let editor handle it, and we'll assume that it will tell us
	// to endComposition if it does anything funky with, e.g., function keys.
	return false;
	}
	}
	return false;
	}

	public String toString() {
	final String[] names = {
	"alice", "bill", "carrie", "doug", "elena", "frank", "gertie", "howie", "ingrid", "john"
	};

	if (id < names.length) {
	return names[id];
	} else {
	return names[id] + "-" + (id/names.length);
	}
	}
	}

	class NameRenderer extends JLabel implements ListCellRenderer {

	public Component getListCellRendererComponent(
	JList list,
	Object value,
	int index,
	boolean isSelected,
	boolean cellHasFocus) {

	String s = ((JLabel)value).getText();
	setText(s);

	if (isSelected) {
	setBackground(list.getSelectionBackground());
	setForeground(list.getSelectionForeground());
	} else {
	setBackground(list.getBackground());
	setForeground(list.getForeground());
	}

	setEnabled(list.isEnabled());
	setFont(list.getFont());
	setOpaque(true);
	return this;
	}
	}

	class LabelComparator implements Comparator {
	public int compare(Object obj1, Object obj2) {
	Collator collator = Collator.getInstance();
	return collator.compare(((JLabel)obj1).getText(), ((JLabel)obj2).getText());
	}

	public boolean equals(Object obj1) {
	return this.equals(obj1);
	}
	}