InternationalInput.java

Go to the documentation of this file.

// (C) 2003 by Dominique Unruh. GPL

import java.awt.event.*;
import java.awt.*;
import java.util.*;
import javax.swing.*;
import java.io.*;
import java.net.*;
import javax.swing.event.*;
import javax.swing.text.*;
import java.awt.datatransfer.*;
import java.awt.font.*;
import java.awt.geom.*;
import java.awt.print.*;

class IITextArea extends JTextPane
    implements KeyListener, InputViewer {

    InputManager inputManager = null;
    String temporaryInput = "";
    int tempStart = -1, tempEnd;
    Keymap keymap;
    InternationalInputContext context = null;
    InternationalInput internationalInput = null;
    SimpleAttributeSet tempStyle;
    StyledDocument document = (StyledDocument)getDocument();    

    public void addFinal(String input) {
        if (tempStart != -1)
            throw new IllegalStateException
                ("addFinal called while there was temporary input "+
                 temporaryInput);
        //System.out.println("addFinal("+input+")");
        internationalInput.noCaretCheck = true;
        if (getSelectionStart()!=getSelectionEnd())
            replaceSelection("");
        if (internationalInput.lastCaret>getText().length())
            internationalInput.lastCaret = getText().length();
        insert(input,internationalInput.lastCaret);
        int normalizeStart = internationalInput.lastCaret;
        try {
            normalizeStart = internationalInput.normalize
                (normalizeStart,getCaretPosition());
        } catch (BadLocationException e) {
            e.printStackTrace();
            throw new RuntimeException("Internal error: "+e);
        }
        internationalInput.lastCaret = getCaretPosition();

        try {
            internationalInput.iconify(normalizeStart,internationalInput.lastCaret);
        } catch (BadLocationException e) {
            e.printStackTrace();
            throw new RuntimeException("Internal error: "+e);
        }

        if (internationalInput.autoSetFont) internationalInput.autoSetFont(input,true);
        
        // Test. REMOVE
        //DefaultStyledDocument d = (DefaultStyledDocument)document;
        Element e = document.getParagraphElement(getCaretPosition());
        System.out.print("Paragraph: "+e);
        AttributeSet a = e.getAttributes();
        while (a!=null) {
            System.out.println("===");
            for (Enumeration en = a.getAttributeNames();
                 en.hasMoreElements();) {
                Object name = en.nextElement();
                System.out.println(name+" = "+a.getAttribute(name));
            }
            a = a.getResolveParent();
        }

        internationalInput.noCaretCheck = false;
    }

    // emulation of JTextArea
    public void insert(String txt, int pos) {
        setCaretPosition(pos);
        replaceSelection(txt); };

    // emulation of JTextArea
    public void replaceRange(String txt, int start, int end) {
        setSelectionStart(start);
        setSelectionEnd(end);
        replaceSelection(txt);
    }

    public void addTemporary(String input) {
        if (tempStart != -1)
            throw new IllegalStateException
                ("addTemporary called while there was temporary input "+
                 temporaryInput);
        //System.out.println("addTemporary("+input+")");
        internationalInput.noCaretCheck = true;
        if (getSelectionStart()!=getSelectionEnd())
            replaceSelection("");
        //input = "["+input+"]";
        if (internationalInput.lastCaret>getText().length())
            internationalInput.lastCaret = getText().length();
        try {
            document.insertString(internationalInput.lastCaret,input,tempStyle);
        } catch (BadLocationException e) {
            throw new RuntimeException(e.toString());
        }
        temporaryInput = input;
        tempStart = internationalInput.lastCaret;
        internationalInput.lastCaret = tempEnd = tempStart+input.length();
        setCaretPosition(internationalInput.lastCaret);
        internationalInput.noCaretCheck = false;
        if (internationalInput.autoSetFont) internationalInput.autoSetFont(temporaryInput,true);
    }

    public void removeTemporary() {
        if (tempStart == -1) return;
        //System.out.println("removeTemporary()");
        internationalInput.noCaretCheck = true;
        if (tempStart > tempEnd)
            throw new IllegalArgumentException
                ("tempStart > tempEnd");
        try {
            replaceRange("",tempStart,tempEnd);
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        }
        internationalInput.lastCaret = tempStart;
        tempStart = -1;
        internationalInput.noCaretCheck = false;
    }

    public IITextArea(InputManager _inputManager, 
                      InternationalInputContext _context,
                      InternationalInput _internationalInput) {
        inputManager = _inputManager;
        internationalInput = _internationalInput;
        context = _context;
        addKeyListener(this);
        //setLineWrap(true);
        //setWrapStyleWord(true);
        keymap = addKeymap("IITextArea-keymap",null);
        keymap.setDefaultAction(new AbstractAction() {
            public void actionPerformed(ActionEvent e) {
                internationalInput.keyStroke(e);
            }});
        tempStyle = new SimpleAttributeSet();
        StyleConstants.setForeground(tempStyle, Color.blue);
        setKeymap(keymap);
    }

    public void specialKey(int key) {
        switch (key) {
        case InputManager.KEY_BACKSPACE:
            int car = getCaretPosition();
            if (getSelectionStart()!=getSelectionEnd())
                replaceSelection("");
            else if (car>0) {
                try {
                    String str = document.getText(car-1,1);
                    if (car>=2 && Normalizer.isLowSurrogate(str.charAt(0))) {
                        str = document.getText(car-2,1);
                        if (Normalizer.isHighSurrogate(str.charAt(0)))
                            replaceRange("",car-2,car);
                        else 
                            replaceRange("",car-1,car);
                    }
                    else
                        replaceRange("",car-1,car);
                } catch (BadLocationException e) {
                    e.printStackTrace();
                    throw new RuntimeException
                        ("Internal error: "+e);
                }
            }
            internationalInput.lastCaret = getCaretPosition();
            break;
        default:
            throw new IllegalArgumentException("Unknown special key "+key);
        }
    }

    public void keyPressed(KeyEvent e) {
        /* Todo.doActions(); */
        int c = e.getKeyCode();
        if (c==KeyEvent.VK_ENTER || c==KeyEvent.VK_BACK_SPACE)
            e.consume();
        internationalInput.checkCaret();
    };
    public void keyReleased(KeyEvent e) {
        internationalInput.checkCaret();
    };
    public void keyTyped(KeyEvent e) {
        internationalInput.checkCaret();
        if (e.getKeyChar()=='\b')
            { e.consume(); internationalInput.backSpace(); };
    };
}

public class InternationalInput extends JPanel 
    implements InputManagerContext, MouseListener,
               KeyListener {
    public static final int MIN_FONT_SIZE = 10;
    public static final int MAX_FONT_SIZE = 40;
    public static final int FONT_SIZE_STEPPING = 2;
    public static final int DEFAULT_FONT_SIZE = 14;

    // Global variables
    InputManager inputManager;
    IITextArea inputField;
    JScrollPane scrollPane;
    boolean disableButtons = false;
    JPanel buttons;
    JPanel fKeyPanel;
    LinkedList fkeys = new LinkedList();
    InternationalInputContext context = null;
    Properties properties = null;
    String fonts[] = null;
    JMenuItem fontMenuItems[] = null;
    JMenuItem fontSizeMenuItems[] = null;
    JButton noFontItem = new JButton();
    JButton noSizeItem = new JButton();
    JMenu inputMethodMenu = null;
    JCheckBoxMenuItem inputMethodMenuItems[] = null;
    String inputMethodMenuItemNames[] = null;
    JMenu webPageMenu = null;
    Clipboard clipboard = null;
    boolean noSystemClipboard = false;
    Documentation currentDocumentation = 
        new Documentation() {
            public String getFullDocuName() { return "nothing"; }
            public String getDocumentation() { 
                return "<html><head><title>Nothing activated.</title></head><body>"+
                    "<h1>Nothing activated</h1>Please activate something (e.g. an input method) "+
                    "before trying to access its documentation.</body></html>"; }};
    int fontSize = InternationalInput.DEFAULT_FONT_SIZE;
    boolean autoSetFont = false;
    boolean noCaretCheck = false;
    int lastCaret = 0;
    FileChooser fileChooser = null;
    File currentFile = null;
    PrinterJob printerJob = null;
    PageFormat pageFormat = null;
    JFrame previewFrame = null;

    interface FKey {
        AbstractButton getComponent();
        void setKey(String key);
        boolean isValid();
    }
    public static String fKeyCombineString(String key, String name) {
        return "<html><font face=sansserif size=-1><b>"+key+"</b> "+name;
    }
    class WebPageFKey implements FKey {
        JButton button;
        InputManager.WebPage webpage;
        public void init() {
            if (button!=null) return;
            button = new JButton("uninitialized");
            button.addActionListener(new ActionListener() {
                    public void actionPerformed(ActionEvent e) {
                        callWebPage(webpage);
                        inputField.requestFocus();
                    }});
            button.setToolTipText(webpage.getName());
            button.setBorderPainted(false);
            button.setMargin(new Insets(0,0,0,0));
            button.setFont(button.getFont().deriveFont(Font.PLAIN));
        }
        public boolean isValid() { return true; };
        public WebPageFKey(InputManager.WebPage wp) {
            webpage = wp; }
        public AbstractButton getComponent() {
            return button; }
        public void setKey(String key) {
            if (button==null) init();
            button.setText(fKeyCombineString(key,webpage.getShortName()));
        }
        public boolean equals(Object a) {
            if (!(a instanceof WebPageFKey)) return false;
            if (webpage != ((WebPageFKey)a).webpage) return false;
            return true;
        }
    }
    class GroupFKey implements FKey {
        JCheckBox button;
        String name;
        String screenName;
        public void init() {
            if (button!=null) return;
            button = new JCheckBox("uninitialized",
                                   inputManager.isInputMethodActive(name));
            screenName = inputManager.getInputMethodScreenName(name);
            button.addActionListener(new ActionListener() {
                    public void actionPerformed(ActionEvent e) {
                        try {
                            breakComposition();
                            if (button.isSelected()) {
                                inputManager.activateGroup(name);
                                //currentDocumentation = 
                                //inputManager.getGroup(name);
                            } else
                                inputManager.deactivateGroup(name);
                        } catch (IOException ex) {
                            ex.printStackTrace();
                            showMessage("Could not activate "+name+": "+ex.toString());
                        }
                        inputField.requestFocus();
                    }});
            button.setMargin(new Insets(0,0,0,0));
            button.setFont(button.getFont().deriveFont(Font.PLAIN));
        }
        public boolean isValid() {
            if (button==null) init();
            boolean newState = inputManager.isInputMethodActive(name);
            if (newState!=button.isSelected())
                button.setSelected(newState);
            return !inputManager.getGroup(name).isHidden();
        };
        public GroupFKey(String _name) {
            name = _name; }
        public AbstractButton getComponent() {
            return button; }
        public void setKey(String key) {
            if (button==null) init();
            button.setText(fKeyCombineString(key,screenName));
        }
        public boolean equals(Object a) {
            if (!(a instanceof GroupFKey)) return false;
            if (!name.equals(((GroupFKey)a).name)) return false;
            return true;
        }
    }

    public InternationalInput(InternationalInputContext _context) {
        context = _context;
        try {
            inputManager = new InputManager(this);
        } catch (IOException e) {
            throw new RuntimeException(e.getMessage());
        }

        setLayout(new BorderLayout());

        inputField = new IITextArea(inputManager,context,this);
        inputManager.setViewer(inputField);
        scrollPane = new JScrollPane();
        scrollPane.setViewportView(inputField);
        add("Center",scrollPane);

        /* // Buttons not needed.
        JButton copybutton = new JButton("Copy");
        copybutton.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    copyText(false);
                    inputField.requestFocus();
                    System.out.println("Copy: "+inputField.getSelected());
                }});
        JButton clearbutton = new JButton("Clear");
        clearbutton.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    inputField.clearText();
                    inputField.requestFocus();
                }});
        buttons = new JPanel();
        buttons.add(copybutton);
        buttons.add(clearbutton);
        if (!disableButtons) add("South",buttons);
        else buttons = null;
        */

        fKeyPanel = new JPanel();
        //fKeyPanel.setLayout(new FlowLayout(FlowLayout.LEFT,0,0));
        fKeyPanel.setLayout(new VerticalFlowLayout(FlowLayout.LEFT,0,0));
        //fKeyPanel.setLayout(new GridLayout(4,3));
        add("South",fKeyPanel);

        initMenu();
        applyProperties();

        updateFKeys();

        //addMouseMotionListener(this);
        //addMouseListener(this);
        //addFocusListener(this);
        addKeyListener(this);
        //inputField.addMouseMotionListener(this);
        inputField.addMouseListener(this);
        //inputField.addFocusListener(this);
        inputField.addKeyListener(this);

        //RepaintManager.currentManager(this).setDoubleBufferingEnabled(false);
        //setDebugGraphicsOptions(DebugGraphics.LOG_OPTION);
    }

    // F1 not supported in IE
    public static final String fKeyNames[] = {
        "F2", "F3", "F4", "F5", "F6", 
        "F7", "F8", "F9", "F10", "F11", "F12" };
    public static final int fKeyCodes[] = {
        KeyEvent.VK_F2, KeyEvent.VK_F3, KeyEvent.VK_F4,
        KeyEvent.VK_F5, KeyEvent.VK_F6, KeyEvent.VK_F7, KeyEvent.VK_F8,
        KeyEvent.VK_F9, KeyEvent.VK_F10, KeyEvent.VK_F11, KeyEvent.VK_F12,
    };
    public void updateFKeys() {
        if (fKeyPanel==null) return;
        fKeyPanel.removeAll();
        int keyNum = 0;
        boolean empty = true;
        for (ListIterator it = fkeys.listIterator();
             it.hasNext();) {
            FKey fkey = (FKey)it.next();
            if (!fkey.isValid()) { it.remove(); continue; };
            if (keyNum < fKeyNames.length) fkey.setKey(fKeyNames[keyNum]);
            else fkey.setKey("");
            AbstractButton button = fkey.getComponent();
            if (keyNum < fKeyCodes.length)
                button.setMnemonic(fKeyCodes[keyNum]);
            else button.setMnemonic(KeyEvent.VK_UNDEFINED);
            fKeyPanel.add(button);
            keyNum++; empty = false;
        }
        fKeyPanel.setVisible(!empty);
        repaint(getBounds());
        //System.out.println("fKeyPanel, pref "+fKeyPanel.getPreferredSize());
        //System.out.println("fKeyPanel, min "+fKeyPanel.getMinimumSize());
    }

    boolean checkFKeyHotKey(int code) {
        int num = 0;
        ListIterator it = fkeys.listIterator();
        while (it.hasNext() && num < fKeyCodes.length) {
            FKey fkey = (FKey)it.next();
            if (fKeyCodes[num]==code) {
                fkey.getComponent().doClick();
                return true;
            }
            num++;
        }
        return false;
    }

    public void addFKey(FKey fkey) {
        int num = 0;
        for (ListIterator it = fkeys.listIterator();
             it.hasNext(); num++)
            if (fkey.equals(it.next())) return;
        if (num>fKeyCodes.length-1 || num>fKeyNames.length-1)
            fkeys.removeFirst();
        fkeys.add(fkey);
        updateFKeys();
        revalidate();
    }

    public InternationalInputContext getInternationalInputContext() {
        return context; };

    public void showMessage(String msg) {
        System.out.println(msg);
        try {
            context.showInfo(msg, true);
        } catch (UnsupportedOperationException e) {};
    }

    public void createIMMenu(String im[]) {
        inputMethodMenuItems = new JCheckBoxMenuItem[im.length];
        inputMethodMenuItemNames = new String[im.length];
        HashMap groups = new HashMap(im.length);
        JMenu imMenus[] = new JMenu[27];
        char h[] = new char[1];
        boolean createSubMenus = (im.length>27);

        inputMethodMenu.removeAll();

        // Input method->None
        JMenuItem clearMenu = new JMenuItem("None (0)");
        clearMenu.setMnemonic(KeyEvent.VK_0);
        clearMenu.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    inputManager.deselectNonHiddenGroups();
                }});
        inputMethodMenu.add(clearMenu);

        // Input method->single
        JCheckBoxMenuItem singleMenuItem = new JCheckBoxMenuItem
            ("Single (1)",inputManager.getSingleInputMethod());
        singleMenuItem.setMnemonic(KeyEvent.VK_1);
        singleMenuItem.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    JCheckBoxMenuItem item =
                        (JCheckBoxMenuItem)(e.getSource());
                    try {
                        inputManager.setSingleInputMethod(item.isSelected());
                    } catch (IOException ex) {
                        showMessage(ex.toString()); ex.printStackTrace(); }
                }});
        inputMethodMenu.add(singleMenuItem);
        inputMethodMenu.add(new JSeparator());

        for (int i=0; i<im.length; i++) {
            if (im[i]==null) continue;
            String screenName = inputManager.getInputMethodScreenName(im[i]);
            JCheckBoxMenuItem menuItem = new JCheckBoxMenuItem(screenName);

            inputMethodMenuItemNames[i] = im[i];
            inputMethodMenuItems[i] = menuItem;
            menuItem.addActionListener((new ActionListener() {
                    String name = null;
                    ActionListener init(String n) { name = n; return this; };
                    public void actionPerformed(ActionEvent e) {
                        try {
                            JCheckBoxMenuItem m = (JCheckBoxMenuItem)e.getSource();
                            breakComposition();
                            if (m.isSelected()) {
                                inputManager.activateGroup(name);
                                //currentDocumentation = 
                                //inputManager.getGroup(name);
                            } else
                                inputManager.deactivateGroup(name);
                        } catch (IOException ex) {
                            ex.printStackTrace();
                            showMessage("Could not activate "+name+": "+ex.toString());
                        }
                    }}).init(im[i]));

            String groupName = screenName.replaceFirst("\\s*[\\(-/].*","");
            JMenu container = (JMenu)groups.get(groupName);
            if (container == null) {
                container = new JMenu(groupName);
                groups.put(groupName,container);
            }
            container.add(menuItem);
        }

        Iterator it=groups.values().iterator();
        while (it.hasNext()) {
            JMenuItem menuItem = (JMenu)it.next();
            if (menuItem == null) continue;
            if (((JMenu)menuItem).getItemCount()==1)
                menuItem = ((JMenu)menuItem).getItem(0);
            if (createSubMenus) {
                h[0] = menuItem.getText().charAt(0);
                int num;
                String name;
                if (h[0] >= 'A' && h[0] <= 'Z') {
                    num = h[0]-'A';
                    name = new String(h)+"...";
                } else if (h[0] >= 'a' && h[0] <= 'z') {
                    num = h[0]-'a';
                    h[0] += 'A'-'a';
                    name = new String(h)+"...";
                } else {
                    num = 26;
                    name = "others (*)";
                }
                if (imMenus[num]==null)
                    imMenus[num] = new JMenu(name);
                imMenus[num].add(menuItem);
            } else {
                inputMethodMenu.add(menuItem);
            }
        }


        if (createSubMenus) {
            for (int i=0; i<27; i++) {
                if (imMenus[i]==null) continue;
                if (imMenus[i].getItemCount()==1) {
                    JMenuItem sub = imMenus[i].getItem(0);
                    sub.setMnemonic((i<26)?('A'+i):'*');
                    inputMethodMenu.add(sub);
                } else {
                    imMenus[i].setMnemonic((i<26)?('A'+i):'*');
                    mnemonifyMenu(imMenus[i],true);
                    inputMethodMenu.add(imMenus[i]);
                }
            };
        } else
            mnemonifyMenu(inputMethodMenu,false);
        updateIMMenu();
    };

    public void createWebPageMenu(InputManager.WebPage wp[]) {
        JMenuItem webPageMenuItems[] = new JMenuItem[wp.length];
        //webPageMenuItemNames = new String[wp.length];
        JMenu wpMenus[] = new JMenu[27];
        char h[] = new char[1];
        boolean createSubMenus = (wp.length>20);

        webPageMenu.removeAll();

        for (int i=0; i<wp.length; i++) {
            if (wp[i]==null) continue;
            String screenName = wp[i].getName();
            JMenuItem menuItem = new JMenuItem(screenName);

            webPageMenuItems[i] = menuItem;
            menuItem.addActionListener((new ActionListener() {
                    InputManager.WebPage wp;
                    ActionListener init(InputManager.WebPage _wp) { 
                        wp=_wp; return this; };
                    public void actionPerformed(ActionEvent e) {
                        addFKey(new WebPageFKey(wp));
                        callWebPage(wp);
                    }}).init(wp[i]));
            // Leads to Gfx-Errors
            //menuItem.setToolTipText(wp[i].getToolTipText());
            
            if (createSubMenus) {
                h[0] = screenName.charAt(0);
                int num;
                String name;
                if (h[0] >= 'A' && h[0] <= 'Z') {
                    num = h[0]-'A';
                    name = new String(h)+"...";
                } else if (h[0] >= 'a' && h[0] <= 'z') {
                    num = h[0]-'a';
                    h[0] += 'A'-'a';
                    name = new String(h)+"...";
                } else {
                    num = 26;
                    name = "others (*)";
                }
                if (wpMenus[num]==null)
                    wpMenus[num] = new JMenu(name);
                wpMenus[num].add(menuItem);
            } else {
                webPageMenu.add(menuItem);
            }
        }
        if (createSubMenus) {
            for (int i=0; i<27; i++) {
                if (wpMenus[i]==null) continue;
                wpMenus[i].setMnemonic((i<26)?('A'+i):'*');
                mnemonifyMenu(wpMenus[i],true);
                webPageMenu.add(wpMenus[i]);
            };
        } else
            mnemonifyMenu(webPageMenu,false);
    };

    public void groupStateChanged(String name, boolean active) {
        FKey fkey = new GroupFKey(name);
        if (active) currentDocumentation = inputManager.getGroup(name);
        addFKey(fkey);
        updateFKeys();
        updateIMMenu();
    }

    public void updateIMMenu() {
        if (inputMethodMenuItems==null) return;
        for (int i=0; i<inputMethodMenuItems.length; i++) {
            JCheckBoxMenuItem item = inputMethodMenuItems[i];
            if (item==null) continue;
            String name = inputMethodMenuItemNames[i];
            item.setSelected(inputManager.isInputMethodActive(name));
        }
    }

    void applyProperties() {
        try {
            properties = context.getProperties(new String[] { "config", "font", "text" });
        } catch (UnsupportedOperationException e) {
            properties = new Properties();
        }

        String paramConfig = properties.getProperty("config","config.inp.gz");
        try {
            URL configURL;
            try {
                configURL = new URL(context.getDocumentBase(),paramConfig);
            } catch (UnsupportedOperationException e) {
                configURL = new URL(paramConfig);
            };
            inputManager.loadConfig(configURL);
        } catch (Exception e) {
            e.printStackTrace();
            showMessage("While trying to load initial config file "+
                        paramConfig+":\n"+e);
        }

        String defaultFont = properties.getProperty
            ("font","Arial Unicode MS, Code2000, Bitstream Cyberbit");
        if (defaultFont!=null) {
            String fontList = defaultFont;
            boolean fontLoaded = false;
            StringBuffer errors = new StringBuffer();
            while (fontList!=null && !fontLoaded) {
                String font;
                int index = fontList.indexOf(',');
                if (index==-1) {
                    font = fontList.trim();
                    fontList = null;
                } else {
                    font = fontList.substring(0,index).trim();
                    fontList = fontList.substring(index+1).trim();
                }
                //System.out.println("["+font+"] ["+fontList+"]");
                try {
                    setInputFont(font);
                    fontLoaded = true;
                } catch (RuntimeException e) {
                    errors.append(e.getMessage());
                    errors.append('\n');
                }
            }
            if (!fontLoaded) {
                System.out.println("Could not load default font "+
                                   defaultFont+":");
                System.out.print(errors); }
        }

        String initialText = properties.getProperty("text");
        if (initialText!=null) {
            inputField.setText(initialText);
        }
    }

    public static void mnemonifyMenu(JMenu menu, boolean override) {
        final int maxCharCode = 127;
        Component components[] = menu.getMenuComponents();
        //System.out.println(menu);
        HashSet usedMnemonics = new HashSet();
        if (!override) {
            for (int i=0; i<components.length; i++) {
                if (!(components[i] instanceof JMenuItem)) continue;
                JMenuItem item = (JMenuItem)components[i];
                int mnemonic = item.getMnemonic();
                if (mnemonic==KeyEvent.VK_UNDEFINED) continue;
                usedMnemonics.add(new Integer(mnemonic));
            }
        }
        for (int i=0; i<components.length; i++) {
            //System.out.println(components[i]);
            if (!(components[i] instanceof JMenuItem)) continue;
            JMenuItem item = (JMenuItem)components[i];
            if (item instanceof JMenu) mnemonifyMenu((JMenu)item,override);
            if (!override && item.getMnemonic()!=KeyEvent.VK_UNDEFINED) 
                continue;
            String text = item.getText().toUpperCase();
            int strLen = text.length();
            for (int j=0; j<=strLen; j++) {
                if (j==strLen) {
                    item.setMnemonic(KeyEvent.VK_UNDEFINED); break; }
                char c = text.charAt(j);
                if (c<=maxCharCode) {
                    item.setMnemonic(c);
                    int mnemonic = item.getMnemonic();
                    if (!usedMnemonics.contains(new Integer(mnemonic))) {
                        usedMnemonics.add(new Integer(mnemonic));
                        break;
                    }
                }
            }
        }
    }

    final static int PERMISSION_READ = 1;
    final static int PERMISSION_WRITE = 2;
    final static int PERMISSION_PRINT = 3;
    final static int PERMISSION_EXIT = 4;
    boolean checkPossiblePermission(int permission) {
        SecurityManager securityManager;
        switch (permission) {
        case PERMISSION_READ:
            File roots[] = File.listRoots();
            return (roots!=null && roots.length>0);
        case PERMISSION_WRITE:
            securityManager = System.getSecurityManager();
            if (securityManager==null) return true;;
            roots = File.listRoots();
            if (roots!=null) {
                for (int i=0; i<roots.length; i++) {
                    try {
                        securityManager.checkWrite(roots[i].toString());
                        return true;
                    } catch (SecurityException e) {};
                }
            }
            return false;
        case PERMISSION_PRINT:
            // Checking leads to a box asking the user.
            // Therefore we omit this test and assume permission.
            return true;
            /*try {
              securityManager = System.getSecurityManager();
              if (securityManager != null) securityManager.checkPrintJobAccess();
              return true;
              } catch (SecurityException e) {};
              return false;*/
        case PERMISSION_EXIT:
            try {
                securityManager = System.getSecurityManager();
                if (securityManager != null) securityManager.checkExit(0);
                return true;
            } catch (SecurityException e) {};
            return false;
        default:
            throw new IllegalArgumentException
                ("Internal Error: Unknown permission "+permission);
        }
    }

    void initMenu() {
        SecurityManager securityManager = System.getSecurityManager();
        JMenuBar menuBar = new JMenuBar();
        JMenuItem menuItem = null;
        JMenu subMenu = null;
        JMenu menu = null;

        menu = new JMenu("File");
        menu.setMnemonic(KeyEvent.VK_F);
        boolean emptyMenu = true;

        // File->Open...
        if (checkPossiblePermission(PERMISSION_READ)) {
            menuItem = new JMenuItem("Open...");
            menuItem.setMnemonic(KeyEvent.VK_O);
            menuItem.addActionListener(new ActionListener() {
                    public void actionPerformed(ActionEvent e) {
                        try {
                            initFileChooser(); fileChooser.setSelectedFile(currentFile);
                            if (fileChooser.showDialog(FileChooser.MODE_OPEN)
                                == JFileChooser.APPROVE_OPTION)
                                openFile(fileChooser.getSelectedFile(),
                                         fileChooser.getEncoding(),
                                         fileChooser.getOptionInsert(),
                                         fileChooser.getOptionAsInput());
                        } catch (Exception ex) {
                            ex.printStackTrace();
                            showMessage("Could not open file: "+ex); }
                    }});
            menu.add(menuItem);

            emptyMenu = false;
        }
            
        if (checkPossiblePermission(PERMISSION_WRITE)) {
            // File->Save as...
            menuItem = new JMenuItem("Save as...");
            menuItem.setMnemonic(KeyEvent.VK_A);
            menuItem.addActionListener(new ActionListener() {
                    public void actionPerformed(ActionEvent e) {
                        try {
                            initFileChooser(); fileChooser.setSelectedFile(currentFile);
                            if (fileChooser.showDialog(FileChooser.MODE_SAVE)
                                == JFileChooser.APPROVE_OPTION)
                                saveFile(fileChooser.getSelectedFile(),
                                         fileChooser.getEncoding(),
                                         fileChooser.getOptionSaveSelection());
                        } catch (Exception ex) {
                            ex.printStackTrace();
                            showMessage("Could not open file: "+ex); }
                    }});
            menu.add(menuItem);
            emptyMenu = false;
        }

        if (checkPossiblePermission(PERMISSION_READ)) {
            // File->Load config
            menuItem = new JMenuItem("Load config...");
            menuItem.setMnemonic('l');
            menuItem.addActionListener(new ActionListener() {
                    public void actionPerformed(ActionEvent e) {
                        try {
                            initFileChooser(); fileChooser.setSelectedFile(null);
                            if (fileChooser.showDialog(FileChooser.MODE_LOAD)
                                == JFileChooser.APPROVE_OPTION)
                                loadConfig(fileChooser.getSelectedFile());
                        } catch (Exception ex) {
                            ex.printStackTrace();
                            showMessage("Could not open file: "+ex); }
                    }});
            menu.add(menuItem);
            emptyMenu = false;
        }

        if (checkPossiblePermission(PERMISSION_PRINT)) {
            if (!emptyMenu) menu.add(new JSeparator());

            // File->Print
            menuItem = new JMenuItem("Print...");
            menuItem.setMnemonic('p');
            menuItem.addActionListener(new ActionListener() {
                    public void actionPerformed(ActionEvent e) {
                        try {
                            if (printerJob==null) {
                                printerJob = PrinterJob.getPrinterJob();
                                pageFormat = printerJob.defaultPage(); }

                            PrintableText job = 
                                new PrintableText(getSelected(),
                                                  inputField.getFont());
                            printerJob.setPrintable(job,pageFormat);
                            if (printerJob.printDialog()) {
                                printerJob.print();
                            }
                        } catch (Exception ex) {
                            ex.printStackTrace();
                            showMessage("Could not print: "+ex);
                        }
                    }});
            menu.add(menuItem);

            // File->Page setup...
            menuItem = new JMenuItem("Page setup...");
            menuItem.setMnemonic('u');
            menuItem.addActionListener(new ActionListener() {
                    public void actionPerformed(ActionEvent e) {
                        try {
                            if (printerJob==null) {
                                printerJob = PrinterJob.getPrinterJob();
                                pageFormat = printerJob.defaultPage(); }
                            pageFormat = printerJob.pageDialog(pageFormat);
                        } catch (Exception ex) {
                            ex.printStackTrace();
                            showMessage("Could not change page format: "+ex);
                        }
                    }});
            menu.add(menuItem);

            // File->Page setup...
            menuItem = new JMenuItem("Print preview");
            menuItem.setMnemonic('v');
            menuItem.addActionListener(new ActionListener() {
                    public void actionPerformed(ActionEvent e) {
                        try {
                            if (printerJob==null) {
                                printerJob = PrinterJob.getPrinterJob();
                                pageFormat = printerJob.defaultPage(); }
                            PrintableText job = 
                                new PrintableText(getSelected(),
                                                  inputField.getFont());
                            previewFrame = job.showPreview(previewFrame,pageFormat);
                        } catch (Exception ex) {
                            ex.printStackTrace();
                            showMessage("Could not show print preview: "+ex);
                        }
                    }});
            menu.add(menuItem);

            emptyMenu = false;
        }
        
        boolean mayExit = true;
        try {
            mayExit = context.isExitAllowed();
        } catch (UnsupportedOperationException e) {};
        if (mayExit &&
            checkPossiblePermission(PERMISSION_EXIT)) {
            // File->Exit
            if (!emptyMenu) menu.add(new JSeparator());
            menuItem = new JMenuItem("Exit");
            menuItem.setMnemonic(KeyEvent.VK_X);
            menuItem.addActionListener(new ActionListener() {
                    public void actionPerformed(ActionEvent e) {
                        try {
                            System.exit(0);
                        } catch (Exception ex) {
                            ex.printStackTrace();
                            showMessage("Could not open file: "+ex); }
                    }});
            menu.add(menuItem);
            emptyMenu = false;
        }
        
        // File
        if (!emptyMenu) menuBar.add(menu);

        menu = new JMenu("Edit");
        menu.setMnemonic(KeyEvent.VK_E);
        menuBar.add(menu);

        // Edit->Copy
        menuItem = new JMenuItem("Copy");
        menuItem.setMnemonic(KeyEvent.VK_C);
        menuItem.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    copyText(false);
                }});
        menu.add(menuItem);

        // Edit->Paste
        menuItem = new JMenuItem("Paste");
        menuItem.setMnemonic(KeyEvent.VK_P);
        menuItem.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    pasteText(false);
                }});
        menu.add(menuItem);

        // Edit->Paste as input
        menuItem = new JMenuItem("Paste as input");
        menuItem.setMnemonic(KeyEvent.VK_I);
        menuItem.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    pasteText(true);
                }});
        menu.add(menuItem);

        // Edit->Clear
        menuItem = new JMenuItem("Clear");
        menuItem.setMnemonic(KeyEvent.VK_L);
        menuItem.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    clearText();
                }});
        menu.add(menuItem);

        inputMethodMenu = new JMenu("Input method");
        inputMethodMenu.setMnemonic(KeyEvent.VK_I);
        menuBar.add(inputMethodMenu);

        webPageMenu = new JMenu("Web page");
        webPageMenu.setMnemonic(KeyEvent.VK_W);
        menuBar.add(webPageMenu);

        menu = new JMenu("Font");
        menu.setMnemonic(KeyEvent.VK_O);
        menuBar.add(menu);
        
        // Font->Select best
        menuItem = new JMenuItem("Select best (!)");
        menuItem.setMnemonic('!');
        menuItem.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    String name = autoSetFont(getSelected(),false);
                    String info;
                    if (name==null) {
                        info = "Font not changed ("+
                            inputField.getFont().getFamily()+")";
                    } else {
                        info = "Font changed to "+name;
                    }
                    showMessage(info);
                }});
        menu.add(menuItem);

        // Font->Auto select
        menuItem = new JCheckBoxMenuItem("Auto select (@)",false);
        menuItem.setMnemonic('@');
        menuItem.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    JCheckBoxMenuItem item = (JCheckBoxMenuItem)e.getSource();
                    setAutoSetFont(item.isSelected());
                }});
        menu.add(menuItem);

        // Font->Font Viewer
        subMenu = new JMenu("Font Viewer (?)");
        subMenu.setMnemonic('?');
        menu.add(subMenu);

        // Font->Font Viewer->All fonts (sample)
        menuItem = new JMenuItem("All fonts (sample)");
        menuItem.setMnemonic('a');
        menuItem.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    new FontViewer().showSample(getSelected());
                }});
        subMenu.add(menuItem);

        // Font->Font Viewer->Current font (repertoire)
        menuItem = new JMenuItem("Current font (repertoire)");
        menuItem.setMnemonic('c');
        menuItem.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    new FontViewer().showFont
                        (inputField.getFont().getFamily());
                }});
        subMenu.add(menuItem);

        // Font->Size
        subMenu = new JMenu("Size (=)");
        subMenu.setMnemonic('=');
        menu.add(subMenu);

        // Font->Size->Larger
        menuItem = new JMenuItem("Larger");
        menuItem.setMnemonic(KeyEvent.VK_L);
        menuItem.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    setFontSize(getFontSize()+FONT_SIZE_STEPPING);
                }});
        subMenu.add(menuItem);
        
        // Font->Size->Smaller
        menuItem = new JMenuItem("Smaller");
        menuItem.setMnemonic(KeyEvent.VK_S);
        menuItem.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    int size = getFontSize()-FONT_SIZE_STEPPING;
                    if (size<=0) size = 1;
                    setFontSize(size);
                }});
        subMenu.add(menuItem);

        subMenu.add(new JSeparator());

        // Font->Size->n
        ButtonGroup buttonGroup = new ButtonGroup();
        fontSizeMenuItems = new JMenuItem[MAX_FONT_SIZE+1];
        for (int i=MIN_FONT_SIZE; i<=MAX_FONT_SIZE; i+=FONT_SIZE_STEPPING) {
            menuItem = new JRadioButtonMenuItem(""+i);
            subMenu.add(menuItem);
            buttonGroup.add(menuItem);
            menuItem.addActionListener((new ActionListener() {
                    int size = 0;
                    ActionListener setSize(int s) { size = s; return this; };
                    public void actionPerformed(ActionEvent e) {
                        setFontSize(size);
                    }}).setSize(i));
            fontSizeMenuItems[i] = menuItem;
        }
        buttonGroup.add(noSizeItem);

        menu.add(new JSeparator());

        char h[] = new char[1];
        JMenu fontMenus[] = new JMenu[27];
        buttonGroup = new ButtonGroup();
        fonts = getAvailableFontFamilyNames();
        fontMenuItems = new JMenuItem[fonts.length];
        for (int i=0; i<fonts.length; i++) {
            if (fonts[i].length()==0) continue;
            menuItem = new JRadioButtonMenuItem(fonts[i]);
            buttonGroup.add(menuItem);
            menuItem.setActionCommand(fonts[i]);
            menuItem.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    try {
                        setInputFont(e.getActionCommand());
                        showMessage("Font changed to "+
                                    e.getActionCommand());
                    } catch (IllegalArgumentException e1) {
                        showMessage("Font not changed: "+e1.getMessage());
                    }
                }});
            h[0] = fonts[i].charAt(0);
            int num;
            String name;
            if (h[0] >= 'A' && h[0] <= 'Z') {
                num = h[0]-'A';
                name = new String(h)+"...";
            } else if (h[0] >= 'a' && h[0] <= 'z') {
                num = h[0]-'a';
                h[0] += 'A'-'a';
                name = new String(h)+"...";
            } else {
                num = 26;
                name = "others (*)";
            }
            if (fontMenus[num]==null)
                fontMenus[num] = new JMenu(name);
            fontMenus[num].add(menuItem);
            fontMenuItems[i] = menuItem;
        }
        for (int i=0; i<27; i++) {
            if (fontMenus[i]==null) continue;
            fontMenus[i].setMnemonic((i<26)?('A'+i):'*');

            mnemonifyMenu(fontMenus[i],true);
            menu.add(fontMenus[i]);
        };
        buttonGroup.add(noFontItem);

        menuBar.add(Box.createHorizontalGlue());
        menu = new JMenu("Help");
        menu.setMnemonic(KeyEvent.VK_H);        
        menuBar.add(menu);

        // Help->General
        menuItem = new JMenuItem("General");
        menuItem.setMnemonic(KeyEvent.VK_G);
        menuItem.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    showHelp();
                }});
        menu.add(menuItem);

        // Help->Current object
        menuItem = new JMenuItem("Current object");
        menuItem.setMnemonic('c');
        menuItem.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    showCurrentDocumentation();
                }});
        menu.add(menuItem);

        try {
            context.addMenuBar(menuBar);
        } catch (UnsupportedOperationException e) {
            System.out.println("Cannot add menu bar: "+e.getMessage()); }
    }

    String[] getAvailableFontFamilyNames() {
        Font fonts[] = GraphicsEnvironment.getLocalGraphicsEnvironment().getAllFonts();
        TreeSet set = new TreeSet();
        for (int i=0; i<fonts.length; i++) {
            String fam = fonts[i].getFamily();
            if (fam.endsWith(".bold")) continue;
            if (fam.endsWith(".bolditalic")) continue;
            if (fam.endsWith(".italic")) continue;
            set.add(fonts[i].getFamily());
        }
        String fn[] = new String[set.size()];
        Iterator it=set.iterator();
        for (int i=0; it.hasNext(); i++) {
            fn[i] = (String)it.next();
            //System.out.println(fn[i]);
        }
        return fn;
    }

    void initFileChooser() {
        if (fileChooser==null) {
            fileChooser = new FileChooser(this);
            fileChooser.setCurrentDirectory(new File("."));
        }
    }

    void selectSizeItem(int size) {
        AbstractButton item = null;
        if (size<fontSizeMenuItems.length)
            item = fontSizeMenuItems[size];
        if (item==null) item = noSizeItem;
        item.setSelected(true);
    }

    void selectFontItem(String name) {
        for (int i=0; i<fonts.length; i++) {
            if (fonts[i]==null || fontMenuItems[i]==null ||
                !fonts[i].equals(name)) continue;
            fontMenuItems[i].setSelected(true);
            return;
        }
        noFontItem.setSelected(true);
    }

    void showHelp() {
        try {
            context.showDocument
                (new URL(context.getDocumentBase(),"documentation.html"),false);
        } catch (Exception e1) {
            showMessage("Could not display help: "+e1);
            e1.printStackTrace();
        }
    }

    public void loadConfig(String config) {
        try {
            inputManager.loadConfig(new URL(context.getDocumentBase(),config));
        } catch (Exception e) {
            showMessage("Loading of "+config+" failed:\n"+e);
            e.printStackTrace();
        }
    }

    public void loadConfig(File config) {
        try {
            inputManager.loadConfig(config.toURL());
        } catch (Exception e) {
            showMessage("Loading of "+config+" failed:\n"+e);
            e.printStackTrace();
        }
    }

    public void loadConfigString(String config) throws IOException {
        System.out.println("InternationalInput::loadConfigString("+config+")");
        try {
            inputManager.loadConfigString(config);
        } catch (Exception e) {
            showMessage("Executing config string failed:\n"+e);
        }
    }

    public String getSelected() {
        breakComposition();
        String text = inputField.getSelectedText();
        if (text==null) text = inputField.getText();
        try {
            if (text!=null)
                text = Normalizer.normalize(Normalizer.C,text);
        } catch (IOException e) {
            showMessage("Normalization not possible: "+e);
            e.printStackTrace();
        }
        return text;
    }

    public boolean hasSelection() {
        return (inputField.getSelectionStart()!=inputField.getSelectionEnd());
    }

    /* * Returns, whether content has changed since last call to mirror().
     * @see #mirror()
     * @see InternationalInputApp#hasChangedSinceMirror()
    public boolean hasChangedSinceMirror() {
        return true;
    } */

    /* * Returns content of the input field. 
     * The composition is not interrupted.
     * @see InternationalInputApp#mirror()
    public String mirror() {
        return inputField.getText();
    } */
    public void noButtons() {
        disableButtons = true;
        if (buttons==null) return;
        remove(buttons);
        buttons = null;
        revalidate();
    }
    public String getDocumentation(String group) {
        try {
            return inputManager.getGroup(group).getDocumentation();
        } catch (IOException e) {
            e.printStackTrace();
            return "Could not load documentation for "+group;
        }
    }

    public String getCurrentDocumentation() {
        try {
            return currentDocumentation.getDocumentation();
        } catch (Exception e) {
            e.printStackTrace();
            showMessage("Could not load documentation for "+
                        currentDocumentation.getFullDocuName()+": "+e);
            return "Could not load documentation for "+
                currentDocumentation.getFullDocuName()+": "+e;
        }
    }

    public void showCurrentDocumentation() {
        try {
            context.showDocumentFromString
                (currentDocumentation.getDocumentation());
        } catch (Exception e) {
            e.printStackTrace();
            showMessage("Could not show documentation for "+
                        currentDocumentation.getFullDocuName()+": "+e);
        }
    }

    /* 
    /* public String getScreenName(String group) {
        return inputManager.getInputMethodScreenName(group);
        } */
    /* 
    /*public String lastActivatedGroup() {
        return inputManager.getLastActivatedGroupName();
        }*/

    public void ready() {
        inputField.requestFocus();
        setFontSize(DEFAULT_FONT_SIZE);
    }


    public void mouseExited(MouseEvent e) { checkCaret(); };
    public void mouseEntered(MouseEvent e) { checkCaret(); };
    public void mouseClicked(MouseEvent e) { checkCaret(); };
    public void mousePressed(MouseEvent e) { checkCaret(); };
    public void mouseReleased(MouseEvent e) { checkCaret(); };

    //public void focusGained(FocusEvent e) { /* Todo.doActions(); */ };
    //public void focusLost(FocusEvent e) { /* Todo.doActions(); */ };

    public void textWindow(String text) {
        try {
            URL url;
            try {
                url = new URL(context.getDocumentBase(),
                              "reflect/"+InputManager.urlEncode(text));
            } catch (MalformedURLException e) {
                e.printStackTrace();
                throw new RuntimeException(e.getMessage());
            }
            System.out.println("Text: "+text);
            System.out.println("URL: "+url);
            context.showDocument(url,false);
        } catch (UnsupportedOperationException e) {
            showMessage("Copying impossible: "+e.getMessage());
        }
    }
    private void initClipboard() {
        if (noSystemClipboard) return;

        try {
            clipboard = getToolkit().getSystemClipboard();
        } catch (SecurityException e) {
            noSystemClipboard = true;
            clipboard = new Clipboard("local");
        }
    }
    public String copyText(boolean dontUseTextWindow) {
        initClipboard();
        String text = getSelected();
        clipboard.setContents(new StringSelection(text),null);
        if (noSystemClipboard && !dontUseTextWindow) textWindow(text);
        return text;
    }
    public void setClipboardContent(String data) {
        initClipboard();
        clipboard.setContents(new StringSelection(data),null);
    }

    public void pasteText(boolean temporary) {
        initClipboard();
        String text;
        Transferable data = clipboard.getContents(clipboard);
        if (data==null) {
            showMessage(noSystemClipboard?
                        "Local clipboard is empty (system clipboard not accessible)":
                        "Clipboard is empty");
            return; }

        try {
            text = (String)data.getTransferData
                (DataFlavor.stringFlavor);
        } catch (UnsupportedFlavorException ee) {
            showMessage("Clipboard not readable: "+ee);
            return;
        } catch (IOException ee) {
            showMessage("Clipboard not readable: "+ee);
            return;
        }
        
        if (temporary) {
            inputManager.input(InputManager.SOURCE_CLIPBOARD,
                               text);
        } else {
            breakComposition();
            inputField.addFinal(text);
        }
    }

    public void keyTyped(KeyEvent e) {};
    public void keyPressed(KeyEvent e) {};
    public void keyReleased(KeyEvent e) {
        if (checkFKeyHotKey(e.getKeyCode()))
            e.consume();
        if (e.getKeyCode()==KeyEvent.VK_F1) {
            showHelp(); e.consume(); }
    };
    public void breakComposition() {
        inputManager.input(InputManager.SOURCE_KEYBOARD,
                           InputManager.INPUT_BREAK);
    }
    void callWebPage(InputManager.WebPage webpage) {
        try {
            currentDocumentation = webpage;
            URL result = webpage.run(getSelected());
            System.out.println("Webpage: "+result);
            context.showDocument(result,webpage.getNeedsTopFrame());
        } catch (Exception ex) {
            showMessage("Could not create URL: "+ex);
            ex.printStackTrace();
        }
    }

    public String autoSetFont(String str, boolean lazy) {
        Font current = getFont();
        if (str==null) str = "";
        int upto = current.canDisplayUpTo(str.replace('\n',' '));
        boolean canDisplayStr = (upto == -1 || upto == str.length());
        //System.out.println(upto+" "+str.length());
        if (canDisplayStr && lazy) return null;
        String content = inputField.getText();
        upto = current.canDisplayUpTo(content.replace('\n',' '));
        boolean canDisplayContent = (upto == -1 || upto == content.length());
        if (canDisplayStr && canDisplayContent) return null;

        System.out.println("autoSetFont("+str+","+lazy+") searches...");
        String[] fontNames = GraphicsEnvironment.getLocalGraphicsEnvironment().
            getAvailableFontFamilyNames();
        //int fontSize = current.getSize();
        Font[] fonts = new Font[fontNames.length];
        FontRenderContext frc =
            ((Graphics2D)getGraphics()).getFontRenderContext();
        for (int i=0; i<fontNames.length; i++) {
            if (fontNames[i]==null || fontNames[i].length()==0) continue;
            fonts[i] = new Font(fontNames[i],Font.PLAIN,fontSize);
            Rectangle2D rect = fonts[i].getStringBounds(content,frc);
            //System.out.println(fontNames[i]+": "+rect);
            if (rect.getWidth() < 1 || rect.getHeight() < 1) fonts[i] = null;
        }
        int best0 = -1, best1 = -1, best2 = 0;
        String best = current.getFamily();
        //System.out.println("curr: "+best);
        for (int fontnum=0; fontnum<fonts.length; fontnum++) {
            Font font = fonts[fontnum];
            if (font==null) continue;
            int q0 = 0, q1 = 0, q2 = 0;
            if (font.getFamily().equals(current.getFamily())) q2 = 1;
            for (int i=0; i<str.length(); i++) {
                char c = str.charAt(i);
                if (c!=' ' && c!='\t' && c!='\n')
                    if (font.canDisplay(c)) q0++; };
            for (int i=0; i<content.length(); i++) {
                char c = content.charAt(i);
                if (c!=' ' && c!='\t' && c!='\n')
                    if (font.canDisplay(c)) q1++; };
            if (q0>best0 || 
                (q0==best0 && (q1>best1 || 
                               (q1==best1 && q2>best2)))) {
                best = font.getFamily();
                best0 = q0; best1 = q1; best2 = q2;
            }
        }
        //      System.out.println("BEST: "+best);
        if (best.equals(current.getFamily())) return null;
        setInputFont(best);
        return best;
    }

    public void setAutoSetFont(boolean on) {
        autoSetFont = on;
        if (autoSetFont) autoSetFont(inputField.temporaryInput,true);
    }
    public void setFontSize(int size) {
        fontSize = size;
        inputField.setFont(inputField.getFont().deriveFont(Font.PLAIN,size));
        selectSizeItem(size);
    };

    public int getFontSize() {
        return fontSize; };

    public void setInputFont(String fontName) {
        Font oldFont = inputField.getFont();
        Font newFont = new Font(fontName,Font.PLAIN,fontSize);
        if (!newFont.getFamily().equals(fontName)) {
            selectFontItem(oldFont.getFamily());
            throw new IllegalArgumentException
                ("No such font: "+fontName); }
        System.out.println("New font: "+newFont);
        inputField.setFont(newFont);
        selectFontItem(fontName);
    }

    public void clearText() {
        inputManager.input(InputManager.SOURCE_GUI,
                           InputManager.INPUT_BREAK);
        try {
            inputField.document.remove
                (0,inputField.document.getLength());
        } catch (BadLocationException e) {
            inputField.setText(""); 
        }
    };

    private static final Hashtable iconify_iconHash = new Hashtable();
    Icon iconify_getIcon(int cp) {
        //System.out.println("iconify_getStyle("+Integer.toHexString(cp).toUpperCase()+")");
        Icon icon = 
            (Icon)iconify_iconHash.get(new Integer(cp));
        if (icon!=null) return icon;
        String name;
        switch (cp) {
        case 0x1B: name = "ESC"; break;
        case 0x200E: name = "LRM"; break;
        case 0x200F: name = "RLM"; break;
        case 0x200B: name = "ZWSP"; break;
        case 0x200C: name = "ZWNJ"; break;
        case 0x200D: name = "ZWJ"; break;
        case 0x2028: name = "LSEP"; break;
        case 0x2029: name = "PSEP"; break;
        case 0x202A: name = "LRE"; break;
        case 0x202B: name = "RLE"; break;
        case 0x202C: name = "PDF"; break;
        case 0x202D: name = "LRO"; break;
        case 0x202E: name = "RLO"; break;
        case 0xFFFD: name = "?"; break;
            
        default:
            name = "U+"+Integer.toHexString(cp).toUpperCase();
        }

        icon = new TextIcon(name,this,new Color(165,42,42));
        iconify_iconHash.put(new Integer(cp),icon);
        return icon;
    }


    /*
    private static final Hashtable iconify_styleHash = new Hashtable();
    SimpleAttributeSet iconify_getStyle(int cp) {
        //System.out.println("iconify_getStyle("+Integer.toHexString(cp).toUpperCase()+")");
        SimpleAttributeSet style = 
            (SimpleAttributeSet)iconify_styleHash.get(new Integer(cp));
        if (style!=null) return style;
        String name;
        switch (cp) {
        case 0x200E: name = "LRM"; break;
        case 0x200F: name = "RLM"; break;
        case 0x200B: name = "ZWSP"; break;
        case 0x200C: name = "ZWNJ"; break;
        case 0x200D: name = "ZWJ"; break;
        case 0x2028: name = "LSEP"; break;
        case 0x2029: name = "PSEP"; break;
        case 0x202A: name = "LRE"; break;
        case 0x202B: name = "RLE"; break;
        case 0x202C: name = "PDF"; break;
        case 0x202D: name = "LRO"; break;
        case 0x202E: name = "RLO"; break;
        case 0xFFFD: name = "?"; break;
            
        default:
            name = "U+"+Integer.toHexString(cp).toUpperCase();
        }
        style = new SimpleAttributeSet();
        StyleConstants.setIcon
            (style,
             new TextIcon(name,this,new Color(165,42,42))
             );
        iconify_styleHash.put(new Integer(cp),style);
        return style;
    }
    */

    public void keyStroke(ActionEvent e) {
        checkCaret();
        String stroke = e.getActionCommand();
        char c = '\000';
        if (stroke.length()==1) c = stroke.charAt(0);
        switch (c+'A'-1) {
            // Passing: ^J = ENTER
        case 'A': case 'B': case 'C': case 'D': case 'E':
        case 'F': case 'H': case 'I': case 'K':
        case 'L': case 'M': case 'N': case 'O': case 'P':
        case 'Q': case 'R': case 'S': case 'T': case 'U':
        case 'V': case 'W': case 'X': case 'Z':
            System.out.println("^"+(char)(c+'A'-1)+" pressed, ignoring.");
            return;
        case 'G':
            stroke = InputManager.INPUT_BREAK;
            break;
        default: 
            switch (c) {
            case  '\377': // DEL
                System.out.println("DEL pressed, ignoring.");
                return;
            }
        }
        inputManager.input(InputManager.SOURCE_KEYBOARD,stroke);
    }
    public void backSpace() {
        inputManager.input(InputManager.SOURCE_KEYBOARD,
                           InputManager.INPUT_BACKSPACE);
    }

    void normalize() {
        try {
            normalize(0,inputField.getText().length());
        } catch (BadLocationException e) {
            e.printStackTrace();
            throw new RuntimeException("Internal error: "+e);
        }}
    
    int normalize(int from, int upto) throws BadLocationException {
        try {
            String preCaret = inputField.getText(0,upto);
            //System.out.println("String: "+preCaret);
            StringBuffer target = new StringBuffer();
            from = Normalizer.normalize(Normalizer.C,preCaret,from,upto,target);
            //System.out.println("Normal: "+normal);
            if (target.length()!=0)
                inputField.replaceRange(target.toString(),from,upto);
        } catch (IOException e) {
            System.out.println("Normalization not possible: "+e);
        }
        return from;
    }


    void iconify() {
        try {
            iconify(0,inputField.document.getLength());
        } catch (BadLocationException e) {
            e.printStackTrace();
            throw new RuntimeException("Internal error: "+e);
        }
    };

    int iconify_tempColor = 0;
    void iconify(int from, int upto) throws BadLocationException {
        //System.out.println("iconify("+from+","+upto+")");
        int len = upto-from;
        String str = inputField.document.getText(from,len);
        SimpleAttributeSet noStyle = new SimpleAttributeSet();
        StringBuffer normalText = new StringBuffer();
        int doneUpto = 0;
        try {
            inputField.document.remove(from,len);
        } catch (BadLocationException e) {
            e.printStackTrace(); return; }
        for (int i=0; i<len; i++) {
            char c = str.charAt(i);
            boolean isControl = false;
            //System.out.println("Type of "+Integer.toHexString(c).toUpperCase()
            //                   +" is "+Character.getType(c));
            switch (Character.getType(c)) {
            case Character.CONTROL:
            case Character.FORMAT:
            case Character.LINE_SEPARATOR:
            case Character.SPACE_SEPARATOR:
            case Character.PARAGRAPH_SEPARATOR:
                //case Character.SURROGATE:
                isControl = true;
            }
            switch (c) {
            case '\n': case ' ':
                isControl = false; break;
            case 0xFFFD:
                isControl = true; break;
            }
            if (isControl) {
                try {
                    inputField.document.insertString(from+doneUpto,normalText.toString(),noStyle);
                    normalText.setLength(0); doneUpto = i+1;
                    //inputField.document.insertString(from+i,""+c,iconify_getStyle(c));        
                    SimpleAttributeSet style = new SimpleAttributeSet();
                    StyleConstants.setIcon(style,iconify_getIcon(c));
                    // Hack: Otherwise styles will be identical 
                    // and thus give adjoining identical icons will collapse:
                    StyleConstants.setForeground
                        (style,new Color(iconify_tempColor++));
                    inputField.document.insertString(from+i,""+c,style);
        } catch (BadLocationException e) {
                    e.printStackTrace(); }
            } else {
                normalText.append(c);
            }
        }
        try {
            inputField.document.insertString(from+doneUpto,normalText.toString(),noStyle);
        } catch (BadLocationException e) {
            e.printStackTrace(); }
    }


    void checkCaret() {
        if (noCaretCheck) return;
        noCaretCheck = true;
        int newCaret = inputField.getCaretPosition();
        if (newCaret != lastCaret) 
            inputManager.input(InputManager.SOURCE_KEYBOARD,
                               InputManager.INPUT_BREAK);
        if (newCaret>inputField.getText().length())
            newCaret = inputField.getText().length();
        if (newCaret!=inputField.getCaretPosition())
            inputField.setCaretPosition(newCaret);
        lastCaret = newCaret;
        noCaretCheck = false;
    }

    void saveFile(File file, String encoding, boolean selection) {
        Writer writer = null;
        currentFile = file;
        try {
            inputManager.input(InputManager.SOURCE_GUI,
                               InputManager.INPUT_BREAK);
            writer = 
                new OutputStreamWriter(new FileOutputStream(file),encoding);
            String text = selection?getSelected():inputField.getText();
            writer.write(text);
            writer.close();
            showMessage("File "+file+" written.");
            try { context.setTitleInfo(file.getName()); }
            catch (UnsupportedOperationException e) {};
        } catch (IOException e) {
            e.printStackTrace();
            showMessage("Could not write to "+file+": "+e);
            try { if (writer!=null) writer.close(); }
            catch (IOException e1) {};
        }
    }

    void openFile(File file, String encoding, boolean insert, boolean temporary) {
        Reader reader = null;
        currentFile = file;
        try {
            reader = 
                new InputStreamReader(new FileInputStream(file),encoding);
            if (!temporary) inputManager.input(InputManager.SOURCE_GUI,
                                               InputManager.INPUT_BREAK);
            if (!insert) clearText();
            char buff[] = new char[4096];
            while (true) {
                int numread = reader.read(buff);

                if (numread==-1) break;
        
                String sbuff = new String(buff,0,numread);
                if (temporary) {
                    inputManager.input(InputManager.SOURCE_FILE,sbuff);
                } else {
                    breakComposition();
                    inputField.addFinal(sbuff);
                }
            }
            reader.close();
            showMessage("File "+file+" loaded.");
            try { context.setTitleInfo(file.getName()); }
            catch (UnsupportedOperationException e) {};
        } catch (IOException e) {
            e.printStackTrace();
            showMessage("Could not read from "+file+": "+e);
            try { if (reader!=null) reader.close(); }
            catch (IOException e1) {};
        }
    }
}

---