// This is a generated file: do not edit! Edit keysym2ucs.h if necessary.

/*

 * Copyright (c) 2005, 2009, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package sun.awt.X11;

import java.util.Hashtable;

import sun.misc.Unsafe;

import sun.util.logging.PlatformLogger;

public class XKeysym {

    public static void main( String args[] ) {

       System.out.println( "Cyrillc zhe:"+convertKeysym(0x06d6, 0));

       System.out.println( "Arabic sheen:"+convertKeysym(0x05d4, 0));

       System.out.println( "Latin a breve:"+convertKeysym(0x01e3, 0));

       System.out.println( "Latin f:"+convertKeysym(0x066, 0));

       System.out.println( "Backspace:"+Integer.toHexString(convertKeysym(0xff08, 0)));

       System.out.println( "Ctrl+f:"+Integer.toHexString(convertKeysym(0x066, XConstants.ControlMask)));

    }

    private XKeysym() {}

    static class Keysym2JavaKeycode  {

        int jkeycode;

        int keyLocation;

        int getJavaKeycode() {

            return jkeycode;

        }

        int getKeyLocation() {

            return keyLocation;

        }

        Keysym2JavaKeycode(int jk, int loc) {

            jkeycode = jk;

            keyLocation = loc;

        }

    };

    private static Unsafe unsafe = XlibWrapper.unsafe;

    static Hashtable<Long, Keysym2JavaKeycode>  keysym2JavaKeycodeHash = new Hashtable<Long, Keysym2JavaKeycode>();

    static Hashtable<Long, Character> keysym2UCSHash = new Hashtable<Long, Character>();

    static Hashtable<Long, Long> uppercaseHash = new Hashtable<Long, Long>();

    // TODO: or not to do: add reverse lookup javakeycode2keysym,

    // for robot only it seems to me. After that, we can remove lookup table

    // from XWindow.c altogether.

    // Another use for reverse lookup: query keyboard state, for some keys.

    static Hashtable<Integer, Long> javaKeycode2KeysymHash = new Hashtable<Integer, Long>();

    static long keysym_lowercase = unsafe.allocateMemory(Native.getLongSize());

    static long keysym_uppercase = unsafe.allocateMemory(Native.getLongSize());

    static Keysym2JavaKeycode kanaLock = new Keysym2JavaKeycode(java.awt.event.KeyEvent.VK_KANA_LOCK,

                                                                java.awt.event.KeyEvent.KEY_LOCATION_STANDARD);

    private static PlatformLogger keyEventLog = PlatformLogger.getLogger("sun.awt.X11.kye.XKeysym");

    public static char convertKeysym( long ks, int state ) {

        /* First check for Latin-1 characters (1:1 mapping) */

        if ((ks >= 0x0020 && ks <= 0x007e) ||

            (ks >= 0x00a0 && ks <= 0x00ff)) {

            if( (state & XConstants.ControlMask) != 0 ) {

                if ((ks >= 'A' && ks <= ']') || (ks == '_') ||

                    (ks >= 'a' && ks <='z')) {

                    ks &= 0x1F;

                }

            }

            return (char)ks;

        }

        /* XXX: Also check for directly encoded 24-bit UCS characters:

         */

        if ((ks & 0xff000000) == 0x01000000)

          return (char)(ks & 0x00ffffff);

        Character ch = keysym2UCSHash.get(ks);

        return ch == null ? (char)0 : ch.charValue();

    }

    static long xkeycode2keysym_noxkb(XKeyEvent ev, int ndx) {

        XToolkit.awtLock();

        try {

            return XlibWrapper.XKeycodeToKeysym(ev.get_display(), ev.get_keycode(), ndx);

        } finally {

            XToolkit.awtUnlock();

        }

    }

    static long xkeycode2keysym_xkb(XKeyEvent ev, int ndx) {

        XToolkit.awtLock();

        try {

            int mods = ev.get_state();

            if ((ndx == 0) && ((mods & XConstants.ShiftMask) != 0)) {

                // I don't know all possible meanings of 'ndx' in case of XKB

                // and don't want to speculate. But this particular case

                // clearly means that caller needs a so called primary keysym.

                mods ^= XConstants.ShiftMask;

            }

            long kbdDesc = XToolkit.getXKBKbdDesc();

            if( kbdDesc != 0 ) {

                XlibWrapper.XkbTranslateKeyCode(kbdDesc, ev.get_keycode(),

                       mods, XlibWrapper.iarg1, XlibWrapper.larg3);

            }else{

                // xkb resources already gone

                keyEventLog.fine("Thread race: Toolkit shutdown before the end of a key event processing.");

                return 0;

            }

            //XXX unconsumed modifiers?

            return Native.getLong(XlibWrapper.larg3);

        } finally {

            XToolkit.awtUnlock();

        }

    }

    static long xkeycode2keysym(XKeyEvent ev, int ndx) {

        XToolkit.awtLock();

        try {

            if (XToolkit.canUseXKBCalls()) {

                return xkeycode2keysym_xkb(ev, ndx);

            }else{

                return xkeycode2keysym_noxkb(ev, ndx);

            }

        } finally {

            XToolkit.awtUnlock();

        }

    }

    static long xkeycode2primary_keysym(XKeyEvent ev) {

        return xkeycode2keysym(ev, 0);

    }

    public static boolean isKPEvent( XKeyEvent ev )

    {

        // Xsun without XKB uses keysymarray[2] keysym to determine if it is KP event.

        // Otherwise, it is [1].

        int ndx = XToolkit.isXsunKPBehavior() &&

                  ! XToolkit.isXKBenabled() ? 2 : 1;

        // Even if XKB is enabled, we have another problem: some symbol tables (e.g. cz) force

        // a regular comma instead of KP_comma for a decimal separator. Result is,

        // bugs like 6454041. So, we will try for keypadness  a keysym with ndx==0 as well.

        XToolkit.awtLock();

        try {

            return (XlibWrapper.IsKeypadKey(

                XlibWrapper.XKeycodeToKeysym(ev.get_display(), ev.get_keycode(), ndx ) ) ||

                   XlibWrapper.IsKeypadKey(

                XlibWrapper.XKeycodeToKeysym(ev.get_display(), ev.get_keycode(), 0 ) ));

        } finally {

            XToolkit.awtUnlock();

        }

    }

    /**

        Return uppercase keysym correspondent to a given keysym.

        If input keysym does not belong to any lower/uppercase pair, return -1.

    */

    public static long getUppercaseAlphabetic( long keysym ) {

        long lc = -1;

        long uc = -1;

        Long stored =  uppercaseHash.get(keysym);

        if (stored != null ) {

            return stored.longValue();

        }

        XToolkit.awtLock();

        try {

            XlibWrapper.XConvertCase(keysym, keysym_lowercase, keysym_uppercase);

            lc = Native.getLong(keysym_lowercase);

            uc = Native.getLong(keysym_uppercase);

            if (lc == uc) {

                //not applicable

                uc = -1;

            }

            uppercaseHash.put(keysym, uc);

        } finally {

            XToolkit.awtUnlock();

        }

        return uc;

    }

    /**

        Get a keypad keysym derived from a keycode.

        I do not check if this is a keypad event, I just presume it.

    */

    private static long getKeypadKeysym( XKeyEvent ev ) {

        int ndx = 0;

        long keysym = XConstants.NoSymbol;

        if( XToolkit.isXsunKPBehavior() &&

            ! XToolkit.isXKBenabled() ) {

            if( (ev.get_state() & XConstants.ShiftMask) != 0 ) { // shift modifier is on

                ndx = 3;

                keysym = xkeycode2keysym(ev, ndx);

            } else {

                ndx = 2;

                keysym = xkeycode2keysym(ev, ndx);

            }

        } else {

            if( (ev.get_state() & XConstants.ShiftMask) != 0 || // shift modifier is on

                ((ev.get_state() & XConstants.LockMask) != 0 && // lock modifier is on

                 (XToolkit.modLockIsShiftLock != 0)) ) {     // it is interpreted as ShiftLock

                ndx = 0;

                keysym = xkeycode2keysym(ev, ndx);

            } else {

                ndx = 1;

                keysym = xkeycode2keysym(ev, ndx);

            }

        }

        return keysym;

    }

    /**

        Return java.awt.KeyEvent constant meaning (Java) keycode, derived from X keysym.

        Some keysyms maps to more than one keycode, these would require extra processing.

    */

    static Keysym2JavaKeycode getJavaKeycode( long keysym ) {

        if(keysym == XKeySymConstants.XK_Mode_switch){

           /* XK_Mode_switch on solaris maps either to VK_ALT_GRAPH (default) or VK_KANA_LOCK */

           if( XToolkit.isKanaKeyboard() ) {

               return kanaLock;

           }

        }else if(keysym == XKeySymConstants.XK_L1){

           /* if it is Sun keyboard, trick hash to return VK_STOP else VK_F11 (default) */

           if( XToolkit.isSunKeyboard() ) {

               keysym = XKeySymConstants.SunXK_Stop;

           }

        }else if(keysym == XKeySymConstants.XK_L2) {

           /* if it is Sun keyboard, trick hash to return VK_AGAIN else VK_F12 (default) */

           if( XToolkit.isSunKeyboard() ) {

               keysym = XKeySymConstants.SunXK_Again;

           }

        }

        return  keysym2JavaKeycodeHash.get( keysym );

    }

    /**

        Return java.awt.KeyEvent constant meaning (Java) keycode, derived from X Window KeyEvent.

        Algorithm is, extract via XKeycodeToKeysym  a proper keysym according to Xlib spec rules and

        err exceptions, then search a java keycode in a table.

    */

    static Keysym2JavaKeycode getJavaKeycode( XKeyEvent ev ) {

        // get from keysym2JavaKeycodeHash.

        long keysym = XConstants.NoSymbol;

        int ndx = 0;

        if( (ev.get_state() & XToolkit.numLockMask) != 0 &&

             isKPEvent(ev)) {

            keysym = getKeypadKeysym( ev );

        } else {

            // we only need primary-layer keysym to derive a java keycode.

            ndx = 0;

            keysym = xkeycode2keysym(ev, ndx);

        }

        Keysym2JavaKeycode jkc = getJavaKeycode( keysym );

        return jkc;

    }

    static int getJavaKeycodeOnly( XKeyEvent ev ) {

        Keysym2JavaKeycode jkc = getJavaKeycode( ev );

        return jkc == null ? java.awt.event.KeyEvent.VK_UNDEFINED : jkc.getJavaKeycode();

    }

    /**

     * Return an integer java keycode apprx as it was before extending keycodes range.

     * This call would ignore for instance XKB and process whatever is on the bottom

     * of keysym stack. Result will not depend on actual locale, will differ between

     * dual/multiple keyboard setup systems (e.g. English+Russian vs French+Russian)

     * but will be someway compatible with old releases.

     */

    static int getLegacyJavaKeycodeOnly( XKeyEvent ev ) {

        long keysym = XConstants.NoSymbol;

        int ndx = 0;

        if( (ev.get_state() & XToolkit.numLockMask) != 0 &&

             isKPEvent(ev)) {

            keysym = getKeypadKeysym( ev );

        } else {

            // we only need primary-layer keysym to derive a java keycode.

            ndx = 0;

            keysym = xkeycode2keysym_noxkb(ev, ndx);

        }

        Keysym2JavaKeycode jkc = getJavaKeycode( keysym );

        return jkc == null ? java.awt.event.KeyEvent.VK_UNDEFINED : jkc.getJavaKeycode();

    }

    static long javaKeycode2Keysym( int jkey ) {

        Long ks = javaKeycode2KeysymHash.get( jkey );

        return  (ks == null ? 0 : ks.longValue());

    }

    /**

        Return keysym derived from a keycode and modifiers.

        Usually an input method does this. However non-system input methods (e.g. Java IMs) do not.

        For rules, see "Xlib - C Language X Interface",

                        MIT X Consortium Standard

                        X Version 11, Release 6

                        Ch. 12.7

        XXX TODO: or maybe not to do: process Mode Lock and therefore

        not only 0-th and 1-st but 2-nd and 3-rd keysyms for a keystroke.

    */

    static long getKeysym( XKeyEvent ev ) {

        long keysym = XConstants.NoSymbol;

        long uppercaseKeysym = XConstants.NoSymbol;

        int  ndx = 0;

        boolean getUppercase = false;

        if ((ev.get_state() & XToolkit.numLockMask) != 0 &&

             isKPEvent(ev)) {

            keysym = getKeypadKeysym( ev );

        } else {

            // XXX: at this point, anything in keysym[23] is ignored.

            //

            // Shift & Lock are off ===> ndx = 0;

            // Shift off & Lock on & Lock is CapsLock ===> ndx = 0;

            //       if keysym[ndx] is lowecase alphabetic, then corresp. uppercase used.

            // Shift on & Lock on & Lock is CapsLock ===> ndx == 1;

            //       if keysym[ndx] is lowecase alphabetic, then corresp. uppercase used.

            // Shift on || (Lock on & Lock is ShiftLock) ===> ndx = 1.

            if ((ev.get_state() & XConstants.ShiftMask) == 0) {     // shift is off

                if ((ev.get_state() & XConstants.LockMask) == 0 ) {  // lock is off

                    ndx = 0;

                    getUppercase = false;

                } else if ((ev.get_state() & XConstants.LockMask) != 0 && // lock is on

                     (XToolkit.modLockIsShiftLock == 0)) { // lock is capslock

                    ndx = 0;

                    getUppercase = true;

                } else if ((ev.get_state() & XConstants.LockMask) != 0 && // lock is on

                     (XToolkit.modLockIsShiftLock != 0)) { // lock is shift lock

                    ndx = 1;

                    getUppercase = false;

                }

            } else { // shift on

                if ((ev.get_state() & XConstants.LockMask) != 0 && // lock is on

                     (XToolkit.modLockIsShiftLock == 0)) { // lock is capslock

                    ndx = 1;

                    getUppercase = true;

                } else {

                    ndx = 1;

                    getUppercase = false;

                }

            }

            keysym = xkeycode2keysym(ev, ndx);

            if (getUppercase && (uppercaseKeysym =  getUppercaseAlphabetic( keysym )) != -1) {

                keysym = uppercaseKeysym;

            }

        }

        return keysym;

    }

    static {

        keysym2UCSHash.put( (long)0xFF08, (char)0x0008); // XK_BackSpace --> <control>

        keysym2UCSHash.put( (long)0xFF09, (char)0x0009); // XK_Tab --> <control>

        keysym2UCSHash.put( (long)0xFF0A, (char)0x000a); // XK_Linefeed --> <control>

        keysym2UCSHash.put( (long)0xFF0B, (char)0x000b); // XK_Clear --> <control>

        keysym2UCSHash.put( (long)0xFF0D, (char)0x000a); // XK_Return --> <control>

        keysym2UCSHash.put( (long)0xFF1B, (char)0x001B); // XK_Escape --> <control>

        keysym2UCSHash.put( (long)0xFFFF, (char)0x007F); // XK_Delete --> <control>

        keysym2UCSHash.put( (long)0xFF80, (char)0x0020); // XK_KP_Space --> SPACE

        keysym2UCSHash.put( (long)0xFF89, (char)0x0009); // XK_KP_Tab --> <control>

        keysym2UCSHash.put( (long)0xFF8D, (char)0x000A); // XK_KP_Enter --> <control>

        keysym2UCSHash.put( (long)0xFF9F, (char)0x007F); // XK_KP_Delete --> <control>

        keysym2UCSHash.put( (long)0xFFBD, (char)0x003d); // XK_KP_Equal --> EQUALS SIGN

        keysym2UCSHash.put( (long)0xFFAA, (char)0x002a); // XK_KP_Multiply --> ASTERISK

        keysym2UCSHash.put( (long)0xFFAB, (char)0x002b); // XK_KP_Add --> PLUS SIGN

        keysym2UCSHash.put( (long)0xFFAC, (char)0x002c); // XK_KP_Separator --> COMMA

        keysym2UCSHash.put( (long)0xFFAD, (char)0x002d); // XK_KP_Subtract --> HYPHEN-MINUS

        keysym2UCSHash.put( (long)0xFFAE, (char)0x002e); // XK_KP_Decimal --> FULL STOP

        keysym2UCSHash.put( (long)0xFFAF, (char)0x002f); // XK_KP_Divide --> SOLIDUS

        keysym2UCSHash.put( (long)0xFFB0, (char)0x0030); // XK_KP_0 --> DIGIT ZERO

        keysym2UCSHash.put( (long)0xFFB1, (char)0x0031); // XK_KP_1 --> DIGIT ONE

        keysym2UCSHash.put( (long)0xFFB2, (char)0x0032); // XK_KP_2 --> DIGIT TWO

        keysym2UCSHash.put( (long)0xFFB3, (char)0x0033); // XK_KP_3 --> DIGIT THREE

        keysym2UCSHash.put( (long)0xFFB4, (char)0x0034); // XK_KP_4 --> DIGIT FOUR

        keysym2UCSHash.put( (long)0xFFB5, (char)0x0035); // XK_KP_5 --> DIGIT FIVE

        keysym2UCSHash.put( (long)0xFFB6, (char)0x0036); // XK_KP_6 --> DIGIT SIX

        keysym2UCSHash.put( (long)0xFFB7, (char)0x0037); // XK_KP_7 --> DIGIT SEVEN

        keysym2UCSHash.put( (long)0xFFB8, (char)0x0038); // XK_KP_8 --> DIGIT EIGHT

        keysym2UCSHash.put( (long)0xFFB9, (char)0x0039); // XK_KP_9 --> DIGIT NINE

        keysym2UCSHash.put( (long)0xFE20, (char)0x0009); // XK_ISO_Left_Tab --> <control>

        keysym2UCSHash.put( (long)0x1a1, (char)0x0104); // XK_Aogonek --> LATIN CAPITAL LETTER A WITH OGONEK

        keysym2UCSHash.put( (long)0x1a2, (char)0x02d8); // XK_breve --> BREVE

        keysym2UCSHash.put( (long)0x1a3, (char)0x0141); // XK_Lstroke --> LATIN CAPITAL LETTER L WITH STROKE

        keysym2UCSHash.put( (long)0x1a5, (char)0x013d); // XK_Lcaron --> LATIN CAPITAL LETTER L WITH CARON

        keysym2UCSHash.put( (long)0x1a6, (char)0x015a); // XK_Sacute --> LATIN CAPITAL LETTER S WITH ACUTE

        keysym2UCSHash.put( (long)0x1a9, (char)0x0160); // XK_Scaron --> LATIN CAPITAL LETTER S WITH CARON

        keysym2UCSHash.put( (long)0x1aa, (char)0x015e); // XK_Scedilla --> LATIN CAPITAL LETTER S WITH CEDILLA

        keysym2UCSHash.put( (long)0x1ab, (char)0x0164); // XK_Tcaron --> LATIN CAPITAL LETTER T WITH CARON

        keysym2UCSHash.put( (long)0x1ac, (char)0x0179); // XK_Zacute --> LATIN CAPITAL LETTER Z WITH ACUTE

        keysym2UCSHash.put( (long)0x1ae, (char)0x017d); // XK_Zcaron --> LATIN CAPITAL LETTER Z WITH CARON

        keysym2UCSHash.put( (long)0x1af, (char)0x017b); // XK_Zabovedot --> LATIN CAPITAL LETTER Z WITH DOT ABOVE

        keysym2UCSHash.put( (long)0x1b1, (char)0x0105); // XK_aogonek --> LATIN SMALL LETTER A WITH OGONEK

        keysym2UCSHash.put( (long)0x1b2, (char)0x02db); // XK_ogonek --> OGONEK

        keysym2UCSHash.put( (long)0x1b3, (char)0x0142); // XK_lstroke --> LATIN SMALL LETTER L WITH STROKE

        keysym2UCSHash.put( (long)0x1b5, (char)0x013e); // XK_lcaron --> LATIN SMALL LETTER L WITH CARON

        keysym2UCSHash.put( (long)0x1b6, (char)0x015b); // XK_sacute --> LATIN SMALL LETTER S WITH ACUTE

        keysym2UCSHash.put( (long)0x1b7, (char)0x02c7); // XK_caron --> CARON

        keysym2UCSHash.put( (long)0x1b9, (char)0x0161); // XK_scaron --> LATIN SMALL LETTER S WITH CARON

        keysym2UCSHash.put( (long)0x1ba, (char)0x015f); // XK_scedilla --> LATIN SMALL LETTER S WITH CEDILLA

        keysym2UCSHash.put( (long)0x1bb, (char)0x0165); // XK_tcaron --> LATIN SMALL LETTER T WITH CARON

        keysym2UCSHash.put( (long)0x1bc, (char)0x017a); // XK_zacute --> LATIN SMALL LETTER Z WITH ACUTE

        keysym2UCSHash.put( (long)0x1bd, (char)0x02dd); // XK_doubleacute --> DOUBLE ACUTE ACCENT

        keysym2UCSHash.put( (long)0x1be, (char)0x017e); // XK_zcaron --> LATIN SMALL LETTER Z WITH CARON

        keysym2UCSHash.put( (long)0x1bf, (char)0x017c); // XK_zabovedot --> LATIN SMALL LETTER Z WITH DOT ABOVE

        keysym2UCSHash.put( (long)0x1c0, (char)0x0154); // XK_Racute --> LATIN CAPITAL LETTER R WITH ACUTE

        keysym2UCSHash.put( (long)0x1c3, (char)0x0102); // XK_Abreve --> LATIN CAPITAL LETTER A WITH BREVE

        keysym2UCSHash.put( (long)0x1c5, (char)0x0139); // XK_Lacute --> LATIN CAPITAL LETTER L WITH ACUTE

        keysym2UCSHash.put( (long)0x1c6, (char)0x0106); // XK_Cacute --> LATIN CAPITAL LETTER C WITH ACUTE

        keysym2UCSHash.put( (long)0x1c8, (char)0x010c); // XK_Ccaron --> LATIN CAPITAL LETTER C WITH CARON

        keysym2UCSHash.put( (long)0x1ca, (char)0x0118); // XK_Eogonek --> LATIN CAPITAL LETTER E WITH OGONEK

        keysym2UCSHash.put( (long)0x1cc, (char)0x011a); // XK_Ecaron --> LATIN CAPITAL LETTER E WITH CARON

        keysym2UCSHash.put( (long)0x1cf, (char)0x010e); // XK_Dcaron --> LATIN CAPITAL LETTER D WITH CARON

        keysym2UCSHash.put( (long)0x1d0, (char)0x0110); // XK_Dstroke --> LATIN CAPITAL LETTER D WITH STROKE

        keysym2UCSHash.put( (long)0x1d1, (char)0x0143); // XK_Nacute --> LATIN CAPITAL LETTER N WITH ACUTE

        keysym2UCSHash.put( (long)0x1d2, (char)0x0147); // XK_Ncaron --> LATIN CAPITAL LETTER N WITH CARON

        keysym2UCSHash.put( (long)0x1d5, (char)0x0150); // XK_Odoubleacute --> LATIN CAPITAL LETTER O WITH DOUBLE ACUTE

        keysym2UCSHash.put( (long)0x1d8, (char)0x0158); // XK_Rcaron --> LATIN CAPITAL LETTER R WITH CARON

        keysym2UCSHash.put( (long)0x1d9, (char)0x016e); // XK_Uring --> LATIN CAPITAL LETTER U WITH RING ABOVE

        keysym2UCSHash.put( (long)0x1db, (char)0x0170); // XK_Udoubleacute --> LATIN CAPITAL LETTER U WITH DOUBLE ACUTE

        keysym2UCSHash.put( (long)0x1de, (char)0x0162); // XK_Tcedilla --> LATIN CAPITAL LETTER T WITH CEDILLA

        keysym2UCSHash.put( (long)0x1e0, (char)0x0155); // XK_racute --> LATIN SMALL LETTER R WITH ACUTE

        keysym2UCSHash.put( (long)0x1e3, (char)0x0103); // XK_abreve --> LATIN SMALL LETTER A WITH BREVE

        keysym2UCSHash.put( (long)0x1e5, (char)0x013a); // XK_lacute --> LATIN SMALL LETTER L WITH ACUTE

        keysym2UCSHash.put( (long)0x1e6, (char)0x0107); // XK_cacute --> LATIN SMALL LETTER C WITH ACUTE

        keysym2UCSHash.put( (long)0x1e8, (char)0x010d); // XK_ccaron --> LATIN SMALL LETTER C WITH CARON

        keysym2UCSHash.put( (long)0x1ea, (char)0x0119); // XK_eogonek --> LATIN SMALL LETTER E WITH OGONEK

        keysym2UCSHash.put( (long)0x1ec, (char)0x011b); // XK_ecaron --> LATIN SMALL LETTER E WITH CARON

        keysym2UCSHash.put( (long)0x1ef, (char)0x010f); // XK_dcaron --> LATIN SMALL LETTER D WITH CARON

        keysym2UCSHash.put( (long)0x1f0, (char)0x0111); // XK_dstroke --> LATIN SMALL LETTER D WITH STROKE

        keysym2UCSHash.put( (long)0x1f1, (char)0x0144); // XK_nacute --> LATIN SMALL LETTER N WITH ACUTE

        keysym2UCSHash.put( (long)0x1f2, (char)0x0148); // XK_ncaron --> LATIN SMALL LETTER N WITH CARON

        keysym2UCSHash.put( (long)0x1f5, (char)0x0151); // XK_odoubleacute --> LATIN SMALL LETTER O WITH DOUBLE ACUTE

        keysym2UCSHash.put( (long)0x1fb, (char)0x0171); // XK_udoubleacute --> LATIN SMALL LETTER U WITH DOUBLE ACUTE

        keysym2UCSHash.put( (long)0x1f8, (char)0x0159); // XK_rcaron --> LATIN SMALL LETTER R WITH CARON

        keysym2UCSHash.put( (long)0x1f9, (char)0x016f); // XK_uring --> LATIN SMALL LETTER U WITH RING ABOVE

        keysym2UCSHash.put( (long)0x1fe, (char)0x0163); // XK_tcedilla --> LATIN SMALL LETTER T WITH CEDILLA

        keysym2UCSHash.put( (long)0x1ff, (char)0x02d9); // XK_abovedot --> DOT ABOVE

        keysym2UCSHash.put( (long)0x2a1, (char)0x0126); // XK_Hstroke --> LATIN CAPITAL LETTER H WITH STROKE

        keysym2UCSHash.put( (long)0x2a6, (char)0x0124); // XK_Hcircumflex --> LATIN CAPITAL LETTER H WITH CIRCUMFLEX

        keysym2UCSHash.put( (long)0x2a9, (char)0x0130); // XK_Iabovedot --> LATIN CAPITAL LETTER I WITH DOT ABOVE

        keysym2UCSHash.put( (long)0x2ab, (char)0x011e); // XK_Gbreve --> LATIN CAPITAL LETTER G WITH BREVE

        keysym2UCSHash.put( (long)0x2ac, (char)0x0134); // XK_Jcircumflex --> LATIN CAPITAL LETTER J WITH CIRCUMFLEX

        keysym2UCSHash.put( (long)0x2b1, (char)0x0127); // XK_hstroke --> LATIN SMALL LETTER H WITH STROKE

        keysym2UCSHash.put( (long)0x2b6, (char)0x0125); // XK_hcircumflex --> LATIN SMALL LETTER H WITH CIRCUMFLEX

        keysym2UCSHash.put( (long)0x2b9, (char)0x0131); // XK_idotless --> LATIN SMALL LETTER DOTLESS I

        keysym2UCSHash.put( (long)0x2bb, (char)0x011f); // XK_gbreve --> LATIN SMALL LETTER G WITH BREVE

        keysym2UCSHash.put( (long)0x2bc, (char)0x0135); // XK_jcircumflex --> LATIN SMALL LETTER J WITH CIRCUMFLEX

        keysym2UCSHash.put( (long)0x2c5, (char)0x010a); // XK_Cabovedot --> LATIN CAPITAL LETTER C WITH DOT ABOVE

        keysym2UCSHash.put( (long)0x2c6, (char)0x0108); // XK_Ccircumflex --> LATIN CAPITAL LETTER C WITH CIRCUMFLEX

        keysym2UCSHash.put( (long)0x2d5, (char)0x0120); // XK_Gabovedot --> LATIN CAPITAL LETTER G WITH DOT ABOVE

        keysym2UCSHash.put( (long)0x2d8, (char)0x011c); // XK_Gcircumflex --> LATIN CAPITAL LETTER G WITH CIRCUMFLEX

        keysym2UCSHash.put( (long)0x2dd, (char)0x016c); // XK_Ubreve --> LATIN CAPITAL LETTER U WITH BREVE

        keysym2UCSHash.put( (long)0x2de, (char)0x015c); // XK_Scircumflex --> LATIN CAPITAL LETTER S WITH CIRCUMFLEX

        keysym2UCSHash.put( (long)0x2e5, (char)0x010b); // XK_cabovedot --> LATIN SMALL LETTER C WITH DOT ABOVE

        keysym2UCSHash.put( (long)0x2e6, (char)0x0109); // XK_ccircumflex --> LATIN SMALL LETTER C WITH CIRCUMFLEX

        keysym2UCSHash.put( (long)0x2f5, (char)0x0121); // XK_gabovedot --> LATIN SMALL LETTER G WITH DOT ABOVE

        keysym2UCSHash.put( (long)0x2f8, (char)0x011d); // XK_gcircumflex --> LATIN SMALL LETTER G WITH CIRCUMFLEX

        keysym2UCSHash.put( (long)0x2fd, (char)0x016d); // XK_ubreve --> LATIN SMALL LETTER U WITH BREVE

        keysym2UCSHash.put( (long)0x2fe, (char)0x015d); // XK_scircumflex --> LATIN SMALL LETTER S WITH CIRCUMFLEX

        keysym2UCSHash.put( (long)0x3a2, (char)0x0138); // XK_kra --> LATIN SMALL LETTER KRA

        keysym2UCSHash.put( (long)0x3a3, (char)0x0156); // XK_Rcedilla --> LATIN CAPITAL LETTER R WITH CEDILLA

        keysym2UCSHash.put( (long)0x3a5, (char)0x0128); // XK_Itilde --> LATIN CAPITAL LETTER I WITH TILDE

        keysym2UCSHash.put( (long)0x3a6, (char)0x013b); // XK_Lcedilla --> LATIN CAPITAL LETTER L WITH CEDILLA

        keysym2UCSHash.put( (long)0x3aa, (char)0x0112); // XK_Emacron --> LATIN CAPITAL LETTER E WITH MACRON

        keysym2UCSHash.put( (long)0x3ab, (char)0x0122); // XK_Gcedilla --> LATIN CAPITAL LETTER G WITH CEDILLA

        keysym2UCSHash.put( (long)0x3ac, (char)0x0166); // XK_Tslash --> LATIN CAPITAL LETTER T WITH STROKE

        keysym2UCSHash.put( (long)0x3b3, (char)0x0157); // XK_rcedilla --> LATIN SMALL LETTER R WITH CEDILLA

        keysym2UCSHash.put( (long)0x3b5, (char)0x0129); // XK_itilde --> LATIN SMALL LETTER I WITH TILDE

        keysym2UCSHash.put( (long)0x3b6, (char)0x013c); // XK_lcedilla --> LATIN SMALL LETTER L WITH CEDILLA

        keysym2UCSHash.put( (long)0x3ba, (char)0x0113); // XK_emacron --> LATIN SMALL LETTER E WITH MACRON

        keysym2UCSHash.put( (long)0x3bb, (char)0x0123); // XK_gcedilla --> LATIN SMALL LETTER G WITH CEDILLA

        keysym2UCSHash.put( (long)0x3bc, (char)0x0167); // XK_tslash --> LATIN SMALL LETTER T WITH STROKE

        keysym2UCSHash.put( (long)0x3bd, (char)0x014a); // XK_ENG --> LATIN CAPITAL LETTER ENG

        keysym2UCSHash.put( (long)0x3bf, (char)0x014b); // XK_eng --> LATIN SMALL LETTER ENG

        keysym2UCSHash.put( (long)0x3c0, (char)0x0100); // XK_Amacron --> LATIN CAPITAL LETTER A WITH MACRON

        keysym2UCSHash.put( (long)0x3c7, (char)0x012e); // XK_Iogonek --> LATIN CAPITAL LETTER I WITH OGONEK

        keysym2UCSHash.put( (long)0x3cc, (char)0x0116); // XK_Eabovedot --> LATIN CAPITAL LETTER E WITH DOT ABOVE

        keysym2UCSHash.put( (long)0x3cf, (char)0x012a); // XK_Imacron --> LATIN CAPITAL LETTER I WITH MACRON

        keysym2UCSHash.put( (long)0x3d1, (char)0x0145); // XK_Ncedilla --> LATIN CAPITAL LETTER N WITH CEDILLA

        keysym2UCSHash.put( (long)0x3d2, (char)0x014c); // XK_Omacron --> LATIN CAPITAL LETTER O WITH MACRON

        keysym2UCSHash.put( (long)0x3d3, (char)0x0136); // XK_Kcedilla --> LATIN CAPITAL LETTER K WITH CEDILLA

        keysym2UCSHash.put( (long)0x3d9, (char)0x0172); // XK_Uogonek --> LATIN CAPITAL LETTER U WITH OGONEK

        keysym2UCSHash.put( (long)0x3dd, (char)0x0168); // XK_Utilde --> LATIN CAPITAL LETTER U WITH TILDE

        keysym2UCSHash.put( (long)0x3de, (char)0x016a); // XK_Umacron --> LATIN CAPITAL LETTER U WITH MACRON

        keysym2UCSHash.put( (long)0x3e0, (char)0x0101); // XK_amacron --> LATIN SMALL LETTER A WITH MACRON

        keysym2UCSHash.put( (long)0x3e7, (char)0x012f); // XK_iogonek --> LATIN SMALL LETTER I WITH OGONEK

        keysym2UCSHash.put( (long)0x3ec, (char)0x0117); // XK_eabovedot --> LATIN SMALL LETTER E WITH DOT ABOVE

        keysym2UCSHash.put( (long)0x3ef, (char)0x012b); // XK_imacron --> LATIN SMALL LETTER I WITH MACRON

        keysym2UCSHash.put( (long)0x3f1, (char)0x0146); // XK_ncedilla --> LATIN SMALL LETTER N WITH CEDILLA

        keysym2UCSHash.put( (long)0x3f2, (char)0x014d); // XK_omacron --> LATIN SMALL LETTER O WITH MACRON

        keysym2UCSHash.put( (long)0x3f3, (char)0x0137); // XK_kcedilla --> LATIN SMALL LETTER K WITH CEDILLA

        keysym2UCSHash.put( (long)0x3f9, (char)0x0173); // XK_uogonek --> LATIN SMALL LETTER U WITH OGONEK

        keysym2UCSHash.put( (long)0x3fd, (char)0x0169); // XK_utilde --> LATIN SMALL LETTER U WITH TILDE

        keysym2UCSHash.put( (long)0x3fe, (char)0x016b); // XK_umacron --> LATIN SMALL LETTER U WITH MACRON

        keysym2UCSHash.put( (long)0x12a1, (char)0x1e02); // XK_Babovedot --> LATIN CAPITAL LETTER B WITH DOT ABOVE

        keysym2UCSHash.put( (long)0x12a2, (char)0x1e03); // XK_babovedot --> LATIN SMALL LETTER B WITH DOT ABOVE

        keysym2UCSHash.put( (long)0x12a6, (char)0x1e0a); // XK_Dabovedot --> LATIN CAPITAL LETTER D WITH DOT ABOVE

        keysym2UCSHash.put( (long)0x12a8, (char)0x1e80); // XK_Wgrave --> LATIN CAPITAL LETTER W WITH GRAVE

        keysym2UCSHash.put( (long)0x12aa, (char)0x1e82); // XK_Wacute --> LATIN CAPITAL LETTER W WITH ACUTE

        keysym2UCSHash.put( (long)0x12ab, (char)0x1e0b); // XK_dabovedot --> LATIN SMALL LETTER D WITH DOT ABOVE

        keysym2UCSHash.put( (long)0x12ac, (char)0x1ef2); // XK_Ygrave --> LATIN CAPITAL LETTER Y WITH GRAVE

        keysym2UCSHash.put( (long)0x12b0, (char)0x1e1e); // XK_Fabovedot --> LATIN CAPITAL LETTER F WITH DOT ABOVE

        keysym2UCSHash.put( (long)0x12b1, (char)0x1e1f); // XK_fabovedot --> LATIN SMALL LETTER F WITH DOT ABOVE

        keysym2UCSHash.put( (long)0x12b4, (char)0x1e40); // XK_Mabovedot --> LATIN CAPITAL LETTER M WITH DOT ABOVE

        keysym2UCSHash.put( (long)0x12b5, (char)0x1e41); // XK_mabovedot --> LATIN SMALL LETTER M WITH DOT ABOVE

        keysym2UCSHash.put( (long)0x12b7, (char)0x1e56); // XK_Pabovedot --> LATIN CAPITAL LETTER P WITH DOT ABOVE

        keysym2UCSHash.put( (long)0x12b8, (char)0x1e81); // XK_wgrave --> LATIN SMALL LETTER W WITH GRAVE

        keysym2UCSHash.put( (long)0x12b9, (char)0x1e57); // XK_pabovedot --> LATIN SMALL LETTER P WITH DOT ABOVE

        keysym2UCSHash.put( (long)0x12ba, (char)0x1e83); // XK_wacute --> LATIN SMALL LETTER W WITH ACUTE

        keysym2UCSHash.put( (long)0x12bb, (char)0x1e60); // XK_Sabovedot --> LATIN CAPITAL LETTER S WITH DOT ABOVE

        keysym2UCSHash.put( (long)0x12bc, (char)0x1ef3); // XK_ygrave --> LATIN SMALL LETTER Y WITH GRAVE

        keysym2UCSHash.put( (long)0x12bd, (char)0x1e84); // XK_Wdiaeresis --> LATIN CAPITAL LETTER W WITH DIAERESIS

        keysym2UCSHash.put( (long)0x12be, (char)0x1e85); // XK_wdiaeresis --> LATIN SMALL LETTER W WITH DIAERESIS

        keysym2UCSHash.put( (long)0x12bf, (char)0x1e61); // XK_sabovedot --> LATIN SMALL LETTER S WITH DOT ABOVE

        keysym2UCSHash.put( (long)0x12d0, (char)0x017); // XK_Wcircumflex -->

        keysym2UCSHash.put( (long)0x12d7, (char)0x1e6a); // XK_Tabovedot --> LATIN CAPITAL LETTER T WITH DOT ABOVE

        keysym2UCSHash.put( (long)0x12de, (char)0x0176); // XK_Ycircumflex --> LATIN CAPITAL LETTER Y WITH CIRCUMFLEX