InputManager.java

Go to the documentation of this file.

// (C) 2003 by Dominique Unruh. GPL

import java.util.*;
import java.io.*;
import java.net.*;
import java.util.zip.*;
import java.lang.reflect.*;

public class InputManager {
    public static final int SOURCE_KEYBOARD = 1;
    public static final int SOURCE_GUI = 2;
    public static final int SOURCE_CLIPBOARD = 3;
    public static final int SOURCE_FILE = 4;

    public static final int KEY_BACKSPACE = -1;

    public static final String INPUT_BREAK = "\uFFFF{{BREAK}}";
    public static final String INPUT_BACKSPACE = "\uFFFF{{BACKSPACE}}";

    public static final int DOCUMENTATION_COLS = 3;
    public static final int CONTINUATIONS_LENGTH = 300;

    public static class StringReplacement extends InputReplacement {
        String string;
        String tempReplacement;
        String replacement;
        String cont[];
        public StringReplacement(String _string, String _repl) {
            string = _string; tempReplacement = replacement = _repl; };
        public StringReplacement(String _string, String _tr, String _fr) {
            string = _string; tempReplacement = _tr; replacement = _fr; };
        public String getReplacement(String input) { return tempReplacement; };
        public String getFinalReplacement(String input) {
            return replacement; };
        public String getInputInfo() { return string; };
        public String[] isContinuationOf(String input) {
            if (string.startsWith(input) && !string.equals(input)) {
                if (cont==null) cont = new String[]{string};
                return cont;
            }
            return null; };
        public String replacesPrefixOf(String input) {
            if (input.startsWith(string))
                return string;
            return null;
        }
    }
    public class SwitchReplacement extends StringReplacement {
        public static final int ON = 1;
        public static final int OFF = 2;
        int state;
        int targetGroup;
        public SwitchReplacement(String s, int target, int st) {
            super(s,null);
            targetGroup = target;
            state = st; }
        public String getReplacement(String input) { return string; };
        public String getFinalReplacement(String input) {
            Group g = getGroup(targetGroup);
            try {
                switch (state) {
                case ON: g.activate(); break;
                case OFF: g.deactivate(); break;
                default: return "!!! internal error, group state "+
                             state+" !!!";
                }
            } catch (Exception e) {
                e.printStackTrace();
                imContext.showMessage
                    ("Could not switch state of input method "+
                     g.getFullName()+":\n"+e);
            }
            return "";
        }
        public String getReplacementInfo() { 
            String name = getGroup(targetGroup).getScreenName();
            switch (state) {
            case ON: return "enable "+name;
            case OFF: return "disable "+name;
            default: throw new RuntimeException();
            }
        }
    }

    static class Group implements Documentation {
        private String name = null;
        private int index;
        private String description = "no description available";
        private URL source = null;
        private boolean hidden = false;
        private String screenName = null;

        private boolean active = false;
        private URL url = null;
        private InputManager inputManager = null;

        boolean isHidden() { return hidden; };
        void setHidden(boolean h) { hidden = h; };

        String getName() { return name; };
        String getScreenName() {
            if (screenName!=null) return screenName;
            return name; };
        String getFullName() {
            if (screenName!=null && !screenName.equals(name)) 
                return screenName+" ("+name+")";
            return name; }
        public String getFullDocuName() {
            return "input method "+getFullName(); };
        void setScreenName(String sn) { screenName = sn; };
        void load() throws IOException {
            URL _url = url;
            try {
                if (url!=null) {
                    inputManager.imContext.showMessage
                        ("Autoloading input method "+getFullName());
                    url = null;
                    inputManager.loadConfig(_url);
                    _url = null;
                }
            } finally {
                url = _url;
            }
        }
        public void setSourceURL(URL s) { source = s; };
        public URL getSourceURL() { return source; };
        public void activate() throws IOException {
            if (!hidden && inputManager.singleInputMethod) 
                inputManager.deselectNonHiddenGroups();
            load();
            active = true;
            inputManager.lastActivatedGroup = this;
            if (!hidden)
                inputManager.imContext.groupStateChanged(name,active);
        }
        public Group(InputManager im, String n, int i) {
            im.newGroups = true;
            inputManager = im; name = n; index = i; };
        public void deactivate() { 
            active = false; 
            if (!hidden)
                inputManager.imContext.groupStateChanged(name,active);
        };
        public boolean isActive() { return active; };
        public void autoloadURL(URL _url) { url = _url; };
        public void setDescription(String descr) { description = descr; };
        public String getDescription() throws IOException {
            load(); return description; };
        public String getDocumentation() throws IOException {
            StringBuffer docu = new StringBuffer();
            docu.append("<html><head>\n");
            docu.append("<meta http-equiv=\"content-type\" content=\"text/html; charset=utf-8\">\n");
            docu.append("<link rel=stylesheet type=text/css href=international_input.css>\n");
            String title = "Input method “"+getScreenName()+
                "” - Documentation";
            docu.append("<title>");
            docu.append(HTMLEscapeSB(title,true));
            docu.append("</title>\n</head><body><h1>");
            docu.append(title);
            docu.append("</h1>\n");
            docu.append(getDescription());
            URL source = getSourceURL();
            if (source!=null) {
                docu.append("<p><b><a href=\""); docu.append(source);
                docu.append("\" type=\"text/plain\" charset=\"utf-8\">[Source]</a></b>");
            }
            docu.append("<p><h3>All mappings:</h3><p><center><table cellpadding=5 border=1 rules=rows frame=box><tr>\n");
            int rplsize = inputManager.replacements.size();
            int count = 0;
            for (int i=0; i<DOCUMENTATION_COLS; i++) {
                if (i>0) docu.append("<th>&nbsp;.&nbsp;.&nbsp;.&nbsp;.&nbsp;.&nbsp;.&nbsp;.&nbsp;.&nbsp;</th>");
                docu.append("<th>Input</th><th>Output</th>");
            }
            for (int i=0; i<rplsize; i++) {
                InputReplacement rpl = 
                    (InputReplacement)inputManager.replacements.elementAt(i);
                if (rpl.group!=index) continue;
                if (count%DOCUMENTATION_COLS==0) docu.append("</tr>\n<tr>");
                else docu.append("</td><td>");
                docu.append("<td><tt>");
                docu.append(HTMLEscapeSB(rpl.getInputInfo(),true));
                docu.append("</tt></td><td class=replacement>"); 
                docu.append(HTMLEscapeSB(prefixNSM(rpl.getReplacementInfo()),true));
                docu.append("</td>");
                count++;
            }
            docu.append("</tr></table></center>\n");
            docu.append("</body></html>\n");
            return docu.toString();
        }
    }
    public static class WebPage implements Documentation {
        public static class Token {
            public static final int SOURCE_WORD = 1;
            public static final int SOURCE_CONST = 2;

            public static final int MODE_NORMAL = 1;
            public static final int MODE_EXAMPLE = 2;
            public static final int MODE_HIGHLIGHT = 3;

            public static final int ENCODE_URL = 1;
            public static final int ENCODE_DEC = 2;
            public static final int ENCODE_HEX = 3;
            String name;
            int source;
            int encoding = ENCODE_URL;
            String string; // For SOURCE_CONST
            String charset = "utf-8";
            public Token(String _name) { 
                name = _name; source = SOURCE_WORD; };
            public void setConst(String _str) {
                source = SOURCE_CONST; string = _str; };
            public void setCharset(String cs) {
                charset = cs; };
            public void setEncoding(int mode) {
                encoding = mode; };
            public String getName() { return name; };
            private String getRawReplacement(String word, int mode) {
                if (mode==MODE_HIGHLIGHT)
                    return "<span class=webpage-url-token>"+
                        HTMLEscapeSB(name,false)+"</span>";
                switch (source) {
                case SOURCE_CONST: return string;
                case SOURCE_WORD: return word;
                default: throw new RuntimeException
                             ("Internal error: Unknown source "+source);
                }
            };
            public String getReplacement(String word, int mode) {
                String repl = getRawReplacement(word,mode);
                switch (mode) {
                case MODE_NORMAL:
                case MODE_EXAMPLE:
                    switch (encoding) {
                    case ENCODE_URL:
                        return urlEncode(repl,charset).toString();
                    case ENCODE_HEX:
                    case ENCODE_DEC:
                        if (repl.length()==0) return "";
                        return Integer.toString(repl.charAt(0),encoding==ENCODE_HEX?16:10);
                    default:
                        throw new RuntimeException
                            ("Internal error: Unknown encoding "+source);
                    }
                case MODE_HIGHLIGHT:
                    return repl;
                default: throw new RuntimeException
                             ("Internal error: Unknown mode "+source);
                }
            };
            public String getDocumentationPart() {
                StringBuffer docu = new StringBuffer();
                docu.append("<span class=webpage-token>");
                docu.append(HTMLEscapeSB(name,false));
                docu.append("</span> ");
                // describe source
                switch (source) {
                case SOURCE_CONST: 
                    docu.append("has constant value \"<span class=webpage-token-value>");
                    docu.append(HTMLEscapeSB(string,true));
                    docu.append("</span>\"");
                    break;
                case SOURCE_WORD:
                    docu.append("is replaced by the selection");
                    break;
                default:
                    docu.append("<b>has unknown source "+source+"!!!!!");
                    break;
                }
                // describe charset
                switch (encoding) {
                case ENCODE_URL:
                    docu.append(", and is ").append(HTMLEscapeSB(charset,false));
                    docu.append(" encoded");
                    break;
                case ENCODE_DEC:
                    docu.append(", the first character's code position in decimal is inserted in the URL");
                    break;
                case ENCODE_HEX:
                    docu.append(", the first character's code position in hex is inserted in the URL");
                    break;
                }
                docu.append(".");
                return docu.toString();
            }
        };
        private String name;
        private String shortName;
        private String url;
        private boolean needsTopFrame = false;
        private LinkedList tokens = new LinkedList();
        private String description = "no description available";
        private URL source = null;
        public WebPage(String _name, String _url) {
            name = _name; url = _url; };
        public String getName() { return name; };
        public String getFullDocuName() { 
            return "web page \""+getName()+"\""; };
        public void addToken(Token token) {
            tokens.add(token); };
        public String getShortName() {
            if (shortName!=null) return shortName;
            return name; };
        public void setShortName(String sn) { shortName = sn; };
        public boolean getNeedsTopFrame() { return needsTopFrame; };
        public void setNeedsTopFrame(boolean tf) {
            needsTopFrame = tf; };
        public String getToolTipText() { return url; };
        public URL run(String word) throws MalformedURLException {
            return new URL(replaceTokens(word,Token.MODE_NORMAL)); };
        public String replaceTokens(String word, int mode) {
            StringBuffer u = new StringBuffer(url);
            int fromIndex = 0;
            while (true) {
                String u2 = new String(u);
                int pos = u2.length();
                Token tok = null;
                for (ListIterator e = tokens.listIterator();
                     e.hasNext();) {
                    Token thistok = (Token)e.next();
                    int thispos = u2.indexOf(thistok.getName(),fromIndex);
                    if (thispos==-1) continue;
                    if (pos>thispos) { pos = thispos; tok = thistok; };
                }
                if (tok==null) break;
                String repl = tok.getReplacement(word,mode);
                u.replace(pos,pos+tok.getName().length(),repl);
                fromIndex = pos+repl.length();
            }
            return u.toString();
        }
        public String getDocumentation() {
            StringBuffer docu = new StringBuffer();
            docu.append("<html><head>\n");
            docu.append("<meta http-equiv=\"content-type\" content=\"text/html; charset=utf-8\">\n");
            docu.append("<link rel=stylesheet type=text/css href=international_input.css>\n");
            String title = "Web page “"+getName()+"” - Documentation";
            docu.append("<title>");
            docu.append(HTMLEscapeSB(title,true));
            docu.append("</title>\n</head><body><h1>");
            docu.append(title);
            docu.append("</h1>\n");
            docu.append(getDescription());
            URL source = getSourceURL();
            if (source!=null) {
                docu.append("<p><b><a href=\""); docu.append(source);
                docu.append("\" type=\"text/plain\" charset=\"utf-8\">[Source]</a></b>\n");
            }
            String htmlURL = replaceTokens("test",Token.MODE_HIGHLIGHT);
            String testURL = replaceTokens("test",Token.MODE_EXAMPLE);
            docu.append("<p>URL: <a class=webpage-url href=\"");
            docu.append(testURL).append("\">").append(htmlURL);
            docu.append("</a>\n");
            docu.append("<p><ul>\n");
            for (ListIterator e = tokens.listIterator();
                 e.hasNext();) {
                Token tok = (Token)e.next();
                docu.append("<li>");
                docu.append(tok.getDocumentationPart());
            }
            docu.append("</ul>");
            docu.append("</body></html>\n");
            return docu.toString();
        }
        public String getDescription() {
            return description; }
        public void setDescription(String d) {
            description = d; };
        public void setSourceURL(URL s) { source = s; };
        public URL getSourceURL() { return source; };
        public boolean equals(Object a) {
            if (a==null) return false;
            if (a==this) return true;
            if (!(a instanceof WebPage)) return false;
            WebPage aa = (WebPage)a;
            if (!name.equals(aa.name)) return false;
            if (!url.equals(aa.url)) return false;
            return true;
        };
    }

    Vector replacements = new Vector();
    Vector groups = new Vector();
    Vector webPages = new Vector();
    InputViewer viewer = null;
    String temporaryOutput = null;
    String temporaryInput = null;
    Group lastActivatedGroup = null;
    InternationalInputContext iiContext = null;
    InputManagerContext imContext = null;
    boolean newGroups = false;
    boolean singleInputMethod = true;

    Group getGroup(int index) {
        return (Group)groups.get(index); };
    Group getGroup(String name) {
        if (name==null)
            throw new IllegalArgumentException
                ("Group name is null");
        for (Enumeration e = groups.elements();
             e.hasMoreElements();) {
            Group g = (Group)e.nextElement();
            if (g.name.equals(name)) return g;
        }
        Group g = new Group(this,name,groups.size());
        groups.add(g);
        return g;
    }

    public void activateGroup(String name) throws IOException {
        getGroup(name).activate();
    }

    public void deactivateGroup(String name) throws IOException {
        getGroup(name).deactivate();
    }

    public String getLastActivatedGroupName() {
        if (lastActivatedGroup==null) return null;
        return lastActivatedGroup.name;
    }

    public void setViewer(InputViewer _viewer) {
        viewer = _viewer; };

    static String prefixNSM(String str) {
        if (str.length()==0) return str;
        char c = str.charAt(0);
        try {
            if (Normalizer.isCombining(c))
                return "◌"+str;
        } catch (IOException e) {
            e.printStackTrace(); }
        return str;
    }
    
    public static StringBuffer HTMLEscapeSB(String str, boolean br) {
        StringBuffer res = new StringBuffer();
        int len = str.length();
        for (int i=0; i<len; i++) {
            char c = str.charAt(i);
            switch (c) {
            case '&': res.append("&amp;"); break;
            case '<': res.append("&lt;"); break;
            case '>': res.append("&gt;"); break;
            case '\n': res.append(br?"<br>":"\n"); break;
            default: res.append(c);
            }
        }
        return res;
    }

    public void inputChar(int source, char chr) {
        input(source,charToString(chr));
    }

    public void input(int source, String str) {
        //System.out.println("Input("+source+"): "+str);
        if (str.equals(INPUT_BREAK)) { //  || str.equals("\007")
            viewer.removeTemporary();
            while (makeOutput(true));
            //if (temporaryOutput!=null) viewer.addFinal(temporaryOutput);
            if (temporaryOutput!=null)
                throw new RuntimeException
                    ("Internal error: makeOutput(true) did not clear temporaryOutput");
            if (temporaryInput!=null) 
                throw new RuntimeException
                    ("Internal error: makeOutput(true) did not clear temporaryInput");
        } else if (str.equals(INPUT_BACKSPACE)) {
            //System.out.println("bs");
            viewer.removeTemporary();
            if (temporaryInput!=null) {
                if (temporaryInput.length()>1)
                    temporaryInput = 
                        temporaryInput.substring(0,temporaryInput.length()-1);
                else temporaryInput = null;
                while (makeOutput(false));
                if (temporaryOutput!=null)
                    viewer.addTemporary(temporaryOutput);
            } else
                viewer.specialKey(KEY_BACKSPACE);
        } else {
            viewer.removeTemporary();
            if (temporaryInput==null) temporaryInput = "";
            temporaryInput += str;
            while (makeOutput(false));
            if (temporaryOutput!=null)
                viewer.addTemporary(temporaryOutput);
        }
    };

    public InputManager(InputManagerContext _context) 
        throws IOException {
        imContext = _context;
        iiContext = imContext.getInternationalInputContext();
        getGroup("default").setHidden(true);
        getGroup("default").activate();
    }

    boolean makeOutput(boolean finished) {
        boolean changed = false;
        if (temporaryInput==null) {
            temporaryOutput = null; return changed; }

        InputReplacement longestRpl = null;
        String longestPfx = "";
        boolean strIsPfx = false;
        int rplsize = replacements.size();
        StringBuffer continuations = null;
        boolean needContinuations = !finished;
        for (int i=0; i<rplsize; i++) {
            InputReplacement rpl = (InputReplacement)replacements.elementAt(i);
            if (!getGroup(rpl.group).isActive()) continue;

            String pfx = rpl.replacesPrefixOf(temporaryInput);
            // temporaryInput.startsWith(rpl.string)
            if (pfx != null && 
                pfx.length() > longestPfx.length()) {
                longestRpl = rpl; longestPfx = pfx; }

            if (needContinuations) {
                String cont[] = rpl.isContinuationOf(temporaryInput);
                // rpl.string.startsWith(temporaryInput)
                if (cont!=null) {
                    for (int j=0; j<cont.length; j++)
                        if (continuations==null ||
                            continuations.length()<=CONTINUATIONS_LENGTH) {
                            if (continuations!=null) 
                                continuations.append(", ");
                            else continuations = new StringBuffer();
                            continuations.append(cont[j]);
                        } else needContinuations = false;
                    strIsPfx = true;
                }
            }
        }

        if (continuations!=null && continuations.length()>CONTINUATIONS_LENGTH)
            continuations = 
                new StringBuffer(continuations.substring
                                 (0,CONTINUATIONS_LENGTH)
                                 +"...");

        try {
            if (continuations!=null)
                iiContext.showInfo(continuations.toString(),false);
            else
                iiContext.showInfo("",false);
        } catch (UnsupportedOperationException e) {};

        String finalOut = null;
        if (longestRpl!=null && strIsPfx) {
            temporaryOutput = longestRpl.getReplacement(temporaryInput)+
                temporaryInput.substring(longestPfx.length());
        } else if (longestRpl!=null && !strIsPfx) {
            int len = longestPfx.length();
            if (len==0) 
                throw new RuntimeException
                    ("internal error: longestPfx.length()==0");
            finalOut = longestRpl.getFinalReplacement(temporaryInput);
            temporaryInput = temporaryOutput = temporaryInput.substring(len);
            changed = true;
        } else if (longestRpl==null && strIsPfx) {
            temporaryOutput = temporaryInput;
        } else if (longestRpl==null && !strIsPfx) {
            finalOut = temporaryInput.substring(0,1);
            temporaryInput = temporaryOutput = temporaryInput.substring(1);
            changed = true;
        }

        if (finalOut!=null) {
            viewer.addFinal(finalOut);
        }
        if (temporaryOutput!=null && temporaryOutput.length()==0)
            temporaryOutput = null;
        if (temporaryInput!=null && temporaryInput.length()==0)
            temporaryInput = null;

        System.out.println("final="+finalOut+"  temp-out="+temporaryOutput+
                           "  temp-in="+temporaryInput);
        return changed;
    }
    
    String charToString(int c) {
        if (c<0)
            throw new IllegalArgumentException
                ("chars need positive values, not "+c);
        char cc[] = { (char)c };
        return new String(cc);
    }

    public static URL makeProxyURL(URL base, URL url) {
        try {
            return new URL(base,"proxy/xxx?"+url);
        } catch (MalformedURLException e) {
            throw new RuntimeException("Internal error");
        }
    }

    InputStream openURL(URL url) throws IOException {
        //System.out.println("openURL("+url+")");
        try {
            return url.openStream();
        } catch (SecurityException e) {
            URL proxy = makeProxyURL(iiContext.getDocumentBase(),url);
            System.out.println("Security restriction. Using proxy "+proxy);
            return proxy.openStream();
        }
    }

    public void loadConfigString(String str) throws IOException {
        loadConfig_native
            (new StringReader
             ("#!/bin/sh international-input-config\n"+str),
             new URL(iiContext.getDocumentBase(),"no-source.html"));
    }

    public void loadConfig(URL url) throws IOException {
        //System.out.println("InputManager::loadConfig("+url+")");
        imContext.showMessage("Loading config file "+url);
        InputStream inputStream = null;
        String lcPath = url.toString().toLowerCase();
        if (lcPath.endsWith(".gz")) {
            lcPath = lcPath.substring(0,lcPath.length()-3);
            try {
                inputStream = new GZIPInputStream(openURL(url));
            } catch (FileNotFoundException e) {
                String ustr = url.toString();
                url = new URL(ustr.substring(0,ustr.length()-3));
                inputStream = openURL(url);
            }
        } else
            inputStream = openURL(url);

        if (lcPath.endsWith(".inp")) {
            System.out.println("Loading "+url+" as native config file.");
            loadConfig_native(new InputStreamReader(inputStream,"utf-8"),url);
        } else if (lcPath.endsWith(".my")) {
            System.out.println("Loading "+url+" as Yudit .my file");
            loadConfig_yudit(inputStream,url,null);
            //                       new OutputStreamWriter
            //       (new FileOutputStream("/dev/stdout"),"utf-8"));
        } else {
            throw new FileFormatException("File "+url+" does not have a recognisable file name extension (should be .inp/.inp.gz/.my/.my.gz)");
        }
    }

    public void loadConfig_yudit(InputStream inputStream, URL url, 
                                 Writer _converted)
        throws IOException {
        DataInputStream in = new DataInputStream(new BufferedInputStream(inputStream));
        PrintWriter converted = null;
        if (_converted!=null) converted = new PrintWriter(_converted,true);
        byte buff[] = new byte[256];

        // Magic
        in.readFully(buff,0,16);
        String str = new String(buff,0,16,"us-ascii");
        //System.out.println("Magic = ["+str+"]");
        if (!str.equals("YUDIT-NtoN  1.0\000"))
            throw new FileFormatException
                ("YUDIT file must start with \"YUDIT-NtoN  1.0\\000\"");

        // alias name
        in.readFully(buff,0,32);
        String name = yudit_cutCString(new String(buff,0,32,"us-ascii"));
        //System.out.println("Alias = ["+name+"]");
        name = name.toLowerCase();
        if (name.endsWith(".kmap"))
            name = name.substring(0,name.length()-5);
        else if (name.endsWith(".my"))
            name = name.substring(0,name.length()-3);
        else if (name.endsWith(".mys"))
            name = name.substring(0,name.length()-4);
        name = "y."+name;

        // Comment
        int len = in.readInt();
        if (buff.length<len) buff = new byte[len+100];
        in.readFully(buff,0,len);
        String comment = 
            yudit_cutCString(new String(buff,0,len,"us-ascii"));
        //System.out.println("Comment = ["+comment+"]");

        String docHead = "Imported Yudit <tt>.my</tt> file.";
        if (comment.length()>0)
            comment = docHead+"<p>Original comment:<br><pre>\n"+
                HTMLEscapeSB(comment,false)+"</pre>";
        else
            comment = docHead;
        if (converted!=null) {
            converted.println("#!/bin/sh international-input-config");
            converted.println("=GROUP");
            converted.println(name);
            converted.println("on");
            converted.println("=DESCRIPTION");
            converted.println(comment);
            converted.println("###\n");
        }
        Group group = getGroup(name);
        group.setDescription(comment);
        group.setSourceURL(url);
        group.activate();

        // Map type
        in.skipBytes(4);

        // Map size
        int mapSize = in.readInt();
        //System.out.println("Maps: "+mapSize);

        int maps[] = new int[mapSize+1];
        for (int i=0; i<=mapSize; i++) {
            maps[i] = in.readInt(); 
            //System.out.println("maps["+i+"] = "+
            //                 Integer.toHexString(maps[i]));
        }

        int mapOffset = 0;
        int numDecodeMaps = 0;
        for (int map=0; map<=mapSize; map++) {
            if (mapOffset<maps[map]) {
                in.skipBytes(maps[map]-mapOffset);
                mapOffset = maps[map]; }
            if (map==mapSize) break;
            // alias name
            in.readFully(buff,0,32); mapOffset+=32;
            str = yudit_cutCString(new String(buff,0,32,"us-ascii"));
            //System.out.println("Alias("+map+") = ["+str+"]");
            // Comment
            len = in.readInt(); mapOffset+=4;
            if (buff.length<len) buff = new byte[len+100];
            in.readFully(buff,0,len); mapOffset+=len;
            str = yudit_cutCString(new String(buff,0,len,"us-ascii"));
            //System.out.println("Comment("+map+") = ["+str+"]");
            // Decode
            int t = in.readUnsignedByte(); mapOffset++;
            boolean decode = ((t&1)==0);
            //System.out.println("Decode("+map+") = "+decode);
            if (!decode)
                continue;
            if (++numDecodeMaps>1) {
                throw new UnsupportedOperationException
                    ("Multipart maps not supported"); }

            // sizes
            int inputByteSize = 1<<in.readUnsignedByte();
            int outputByteSize = 1<<in.readUnsignedByte();
            int inputByteLen = 1<<in.readUnsignedByte();
            int outputByteLen = 1<<in.readUnsignedByte();
            mapOffset+=4;
            //System.out.println("IS OS IL OL: "+inputByteSize+" "+
            //outputByteSize+" "+inputByteLen+" "+
            //outputByteLen);

            // state machine, spare
            in.skipBytes(8); mapOffset+=8;

            // codeSize + codes
            int codeSize = in.readInt(); mapOffset+=4;
            int codes[] = new int[codeSize+1];
            for (int i=0; i<=codeSize; i++) {
                codes[i] = in.readInt(); mapOffset+=4;
                //System.out.println("codes["+i+"] = "+
                //                 Integer.toHexString(codes[i]));
            }

            int codeOffset = 0;
            for (int code=0; code<=codeSize; code++) {
                if (codeOffset<codes[code]) {
                    in.skipBytes(codes[code]-codeOffset);
                    mapOffset += codes[code]-codeOffset;
                    codeOffset = codes[code]; }
                if (code==codeSize) break;

                // key size, sub size
                int keySize = yudit_readNByte(in,inputByteLen);
                int subSize = yudit_readNByte(in,inputByteLen);
                mapOffset += 2*inputByteLen;
                codeOffset += 2*inputByteLen;
                //System.out.println("keySize: "+keySize);
                //System.out.println("subSize: "+subSize);
                if (keySize==0) {
                    System.out.println("keySize == 0, ignoring.");
                    continue; }

                // key
                if (buff.length<keySize) buff = new byte[keySize+100];
                in.readFully(buff,0,keySize);
                mapOffset += keySize; codeOffset += keySize;
                String key = yudit_parseString(buff,keySize,inputByteSize);
                if (key==null) continue;

                // result size
                int resultSize = yudit_readNByte(in,outputByteLen);
                mapOffset += outputByteLen; codeOffset += outputByteLen;
                //System.out.println("resultSize: "+resultSize);

                // result
                if (buff.length<resultSize) 
                    buff = new byte[resultSize+100];
                in.readFully(buff,0,resultSize);
                mapOffset += resultSize; codeOffset += resultSize;
                String result = yudit_parseString(buff,resultSize,
                                                  outputByteSize);
                if (result==null) continue;
                //System.out.println(key+" => "+result);

                if (subSize!=keySize) {
                    System.out.println(key+" => "+result+
                                       " has subSize!=keySize ("+
                                       subSize+"!="+keySize+")");
                    continue; }
                
                if (converted!=null) {
                    if (key.indexOf('\n')!=-1 ||
                        result.indexOf('\n')!=-1)
                        throw new UnsupportedOperationException
                            ("Cannot produce =REPLACE-NL");
                    converted.println("=REPLACE");
                    converted.println(key);
                    converted.println(result);
                }
                StringReplacement newrpl = 
                    new StringReplacement(key,result);
                newrpl.group = group.index;
                replacements.addElement(newrpl);
            }
        }
        
        if (numDecodeMaps<1)
            throw new FileFormatException("No decode maps");
        //      throw new UnsupportedOperationException("Yudit .my files not yet supported");
        if (converted!=null) converted.flush();
        }

    private static String yudit_parseString(byte bytes[], int len, 
                                            int width) {
        StringBuffer str = new StringBuffer();
        switch (width) {
        case 1: 
            for (int i=0; i<len; i++) {
                str.append((char)(bytes[i]&0xff)); }
            break;
        case 2:
            for (int i=0; i<len; i+=2) {
                str.append((char)((bytes[i]&0xff)<<8 | (bytes[i+1]&0xff)));
            }
            break;
        case 4:
            System.out.println("start");
            for (int i=0; i<len; i+=4) {
                long cp = ((long)(bytes[i]&0xff))<<24 | ((long)(bytes[i+1]&0xff))<<16 |
                    ((long)(bytes[i+2]&0xff))<<8 | ((long)(bytes[i+3]&0xff));
                if (cp<0 || cp>0xFFFF) {
                    //System.out.println
                    //("String contains U+"+Long.toHexString(cp)+
                    //", which is not supported by Java, creating surrogates.");

                    // Create surrogate pair, since Java does not support >= U+10000
                    str.append((char)(((cp-0x10000)>>10)+0xD800));
                    str.append((char)((cp&0x3FF)+0xDC00));
                } else
                        str.append((char)cp);
            }
            break;
        default: 
            throw new IllegalArgumentException
                ("yudit_parseString only supports lens 1/2/4, not "+width);
        }
        return str.toString();
    }
    private static int yudit_readNByte(DataInputStream in, int num)
        throws IOException {
        switch (num) {
        case 1: return in.readUnsignedByte();
        case 2: return in.readUnsignedShort();
        case 4: return in.readInt();
        default:
            throw new IllegalArgumentException
                ("yudit_readNByte only supports len 1/2/4, not "+num);
        }
    }
    private static String yudit_cutCString(String str) {
        return yudit_cutCString(str,'\000');
    }
    private static String yudit_cutCString(String str, char cut) {
        int pos = str.indexOf(cut);
        if (pos==-1) return str;
        return str.substring(0,pos);
    }

    public void loadConfig_native(Reader inputReader, URL url)
        throws IOException {
        BufferedReader input = 
            new BufferedReader(inputReader);
        boolean newWebPages = false;
        String line;
        line = input.readLine();
        if (line==null ||
            !line.startsWith("#!/bin/sh international-input-config"))
            throw new FileFormatException
                ("Config file does not start with \n"+
                 "     \"#!/bin/sh international-input-config\", but with \n     \""+
                 line+"\".");
        int groupIndex = getGroup("default").index;
        while ((line=input.readLine())!=null) {
            if (line.equals("=REPLACE") || 
                line.equals("=REPLACE-NL") ||
                line.equals("=REPLACE-EXT") ||
                line.equals("=REPLACE-EXT-NL")) {
                String string = input.readLine();
                String by = input.readLine();
                String finalBy = null;
                if (line.equals("=REPLACE-EXT") || 
                    line.equals("=REPLACE-EXT-NL")) {
                    finalBy = input.readLine();
                    if (finalBy==null)
                        throw new FileFormatException
                            ("=REPLACE-EXT not followed by three lines");
                } else finalBy = by;
                if (line.equals("=REPLACE-NL") ||
                    line.equals("=REPLACE-EXT-NL")) {
                    String nl = input.readLine();
                    if (nl==null || nl.length()!=1)
                        throw new FileFormatException
                            ("=REPLACE-NL needs one char string as arg 3");
                    char c = nl.charAt(0);
                    string = string.replace(c,'\n');
                    by = by.replace(c,'\n');
                    finalBy = finalBy.replace(c,'\n');
                }
                if (string==null || by==null) 
                    throw new FileFormatException
                        ("=REPLACE not followed by two lines");
                StringReplacement newrpl = 
                    new StringReplacement(string,by,finalBy);
                newrpl.group = groupIndex;
                replacements.addElement(newrpl);
            } else if (line.equals("=GROUP")) {
                String groupName = input.readLine();
                String state = input.readLine();
                if (state==null)
                    throw new FileFormatException
                        ("=GROUP must be followed by two lines.");
                Group group = getGroup(groupName);
                group.setSourceURL(url);
                groupIndex = group.index;
                if (state.equals("on")) {
                    group.activate();
                } else if (state.equals("hidden")) {
                    group.setHidden(true);
                    group.activate();
                } else if (state.equals("off")) {
                    group.deactivate();
                } else {
                    throw new FileFormatException
                        ("Invalid group state "+state+" for group "+group.getName());
                }
            } else if (line.equals("=SWITCH")) {
                String string = input.readLine();
                String group = input.readLine();
                String stateName = input.readLine();
                int state;
                if (stateName.equals("on")) {
                    state = SwitchReplacement.ON;
                } else if (stateName.equals("on")) {
                    state = SwitchReplacement.ON;
                } else if (stateName.equals("off")) {
                    state = SwitchReplacement.OFF;
                } else {
                    throw new FileFormatException
                        ("Bad state argument to =SWITCH: "+stateName);
                }
                SwitchReplacement newrpl =
                    new SwitchReplacement
                    (string,getGroup(group).index,state);
                newrpl.group = groupIndex;
                replacements.addElement(newrpl);
            } else if (line.equals("=AUTOLOAD")) {
                String group = input.readLine();
                String alurl = input.readLine();
                if (alurl==null)
                    throw new FileFormatException
                        ("=AUTOLOAD not followed by two lines");
                getGroup(group).autoloadURL(new URL(url,alurl));
            } else if (line.equals("=DESCRIPTION")) {
                String descr = "";
                while (true) {
                    String l = input.readLine();
                    if (l==null)
                        throw new FileFormatException("=DESCRIPTION ended by EOF");
                    if (l.equals("###")) break;
                    descr += l+"\n";
                    getGroup(groupIndex).setDescription(descr);
                }
                //} else if (line.equals("=HIDE")) {
                //getGroup(groupIndex).setHidden(true);
            } else if (line.equals("=NAME")) {
                String name = input.readLine();
                String screenName = input.readLine();
                if (screenName==null)
                    throw new FileFormatException
                        ("=NAME not followed by two lines");
                getGroup(name).setScreenName(screenName);
            } else if (line.equals("=JAVAREPLACE")) {
                InputReplacement newrpl = 
                    (InputReplacement)PluginLoader.load
                    (InputReplacement.class,url,input);
                newrpl.group = groupIndex;
                replacements.add(newrpl);
            } else if (line.equals("=WEBPAGE")) {
                loadConfig_native_webpage(input,url);
                newWebPages = true;
            } else if (line.equals("") || line.charAt(0)=='#') {
            } else {
                throw new FileFormatException
                    ("Unknown config command "+line);
            }
        }
        System.out.println("Done.");
        if (newGroups) {
            createIMMenu(); newGroups = false;
        }
        if (newWebPages) {
            createWebPageMenu(); newWebPages = false;
        }
    }

    void loadConfig_native_webpage(BufferedReader input,
                                   URL source) throws IOException {
        String name = input.readLine();
        String url = input.readLine();
        if (url==null)
            throw new FileFormatException
                ("=WEBPAGE not followed by name/url (two lines)");
        WebPage webpage = new WebPage(name,url);
        webpage.setSourceURL(source);
        WebPage.Token token = null;
        while (true) {
            String command = input.readLine();
            if (command==null)
                throw new FileFormatException("=WEBPAGE ended by EOF");
            else if (command.equals(":TOKEN")) {
                String tokname = input.readLine();
                if (tokname==null)
                    throw new FileFormatException
                        (":TOKEN (in =WEBPAGE) not "+
                         "followed by a line (token's name)");
                if (token!=null) webpage.addToken(token);
                token = new WebPage.Token(tokname);
            } else if (command.equals("###")) {
                if (token!=null) webpage.addToken(token);
                break;
            } else if (command.equals(":CONST")) {
                if (token==null)
                    throw new FileFormatException
                        (":CONST (in =WEBPAGE) must be preceded by a :TOKEN");
                String str = input.readLine();
                if (str==null)
                    throw new FileFormatException
                        (":CONST (in =WEBPAGE) not followed by a line");
                token.setConst(str);
            } else if (command.equals(":ENCODING")) {
                if (token==null) 
                    throw new FileFormatException
                        (":ENCODING (in =WEBPAGE) must be preceded by a :TOKEN");
                String enc = input.readLine();
                if (enc==null)
                    throw new FileFormatException
                        (":ENCODING (in =WEBPAGE) not followed by a line");
                if (enc.equals("hex"))
                    token.setEncoding(WebPage.Token.ENCODE_HEX);
                else if (enc.equals("dec"))
                    token.setEncoding(WebPage.Token.ENCODE_DEC);
                else if (enc.equals("url"))
                    token.setEncoding(WebPage.Token.ENCODE_URL);
                else
                    throw new FileFormatException
                        (":ENCODING (in =WEBPAGE) followed by invalid encoding "+enc);
            } else if (command.equals(":CHARSET")) {
                if (token==null) 
                    throw new FileFormatException
                        (":CHARSET (in =WEBPAGE) must be preceded by a :TOKEN");
                String cs = input.readLine();
                if (cs==null)
                    throw new FileFormatException
                        (":CHARSET (in =WEBPAGE) not followed by a line");
                token.setCharset(cs);
            } else if (command.equals(":SHORTNAME")) {
                String sn = input.readLine();
                if (sn==null)
                    throw new FileFormatException
                        (":SHORTNAME (in =WEBPAGE) not followed by a line");
                webpage.setShortName(sn);
            } else if (command.equals(":TOPFRAME")) {
                webpage.setNeedsTopFrame(true);
            } else if (command.equals(":DESCRIPTION")) {
                String descr = "";
                while (true) {
                    String l = input.readLine();
                    if (l==null)
                        throw new FileFormatException(":DESCRIPTION (in =WEBPAGE) ended by EOF");
                    if (l.equals(":###")) break;
                    descr += l+"\n";
                    if (token!=null)
                        throw new FileFormatException
                            (":DESCRIPTION (in =WEBPAGE) must come prior to any :TOKEN");
                    webpage.setDescription(descr);
                }
            } else {
                throw new FileFormatException
                    ("Unknown webpage parameter "+command);
            }
        }
        if (!webPages.contains(webpage))
            webPages.add(webpage);
    }

    void createWebPageMenu() {
        //WebPage wp[] = (InputManager.WebPage[])webPages.toArray();
        int numWP = webPages.size();
        WebPage wp[] = new WebPage[numWP];
        for (int i=0; i<numWP; i++)
            wp[i] = (WebPage)webPages.elementAt(i);
        imContext.createWebPageMenu(wp);
    }

    void createIMMenu() {
        String im[] = new String[groups.size()];
        int size = groups.size();
        for (int i=0; i<size; i++) {
            Group g = (Group)groups.elementAt(i);
            if (!g.isHidden()) {
                im[i] = g.getName();
            }
        }
        imContext.createIMMenu(im);
    }

    public boolean isInputMethodActive(String name) {
        return getGroup(name).isActive();
    }
    public String getInputMethodScreenName(String name) {
        return getGroup(name).getScreenName();
    }

    public void deselectNonHiddenGroups() {
        for (Enumeration e = groups.elements();
             e.hasMoreElements();) {
            Group g = (Group)e.nextElement();
            if (!g.isHidden() && g.isActive())
                g.deactivate();
        }
    }

    public boolean getSingleInputMethod() { return singleInputMethod; };
    public void setSingleInputMethod(boolean on) throws IOException {
        singleInputMethod = on;
        if (on) {
            Group last = lastActivatedGroup;
            if (!last.isActive()) last = null;
            deselectNonHiddenGroups();
            if (last!=null) last.activate();
        }
    }

    public static StringBuffer urlEncode(String string) {
        return urlEncode(string,"utf-8"); };
    public static final char hexDigits[] = {
        '0','1','2','3','4','5','6','7',
        '8','9','A','B','C','D','E','F' };
    public static StringBuffer urlEncode(String string, String charset) {
        byte str[];
        try { 
            str = string.getBytes(charset);
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException("Internal error: "+e);
        }
        StringBuffer res = new StringBuffer();
        for (int i=0; i<str.length; i++) {
            int code = str[i]&0xFF;
            if (code >= 'A' && code <= 'Z') {
                res.append((char)code);
            } else if (code >= 'a' && code <= 'z') {
                res.append((char)code);
            } else if (code >= '0' && code <= '9') {
                res.append((char)code);
            } else switch (code) {
            case '!': case '#': case '$': case '\'': case '(': case ')': case '*':
            case ',': case '-': case '.': case '/': case ':': case ';':
            case '<': case '=': case '>': case '@': case '[': case ']': case '^':
            case '_': case '`': case '\\': case '{': case '|': case '}': case '~':
                res.append((char)code); break;
            default:
                res.append('%');
                res.append(hexDigits[code>>4]);
                res.append(hexDigits[code&0xF]);
            }
        }
        return res;
    }
}

---