/*

 * 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.

 */

/*

 * yan:

 * This table looks like C header because

 * (1) I use actual headers to make it;

 * (2) syntax is nicely highlighted in my editor.

 * Processed will be all lines started with 0x; 0x0000-started lines will

 * be skipped though.

 * Also java code will be copied to a resulting file.

 *

 * 0x0000 unicode means here either there's no equivalent to a keysym

 * or we just skip it from the table for now because i.e. we'll never use

 * the conversion in our workflow.

 *

 */

tojava /*

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

tojava  *

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

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

tojava  * published by the Free Software Foundation.  Oracle designates this

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

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

tojava  *

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

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

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

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

tojava  * accompanied this code).

tojava  *

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

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

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

tojava  *

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

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

tojava  * questions.

tojava  */

tojava

tojava package sun.awt.X11;

tojava import java.util.Hashtable;

tojava import sun.misc.Unsafe;

tojava

tojava import sun.util.logging.PlatformLogger;

tojava

tojava public class XKeysym {

tojava

tojava     public static void main( String args[] ) {

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

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

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

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

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

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

tojava     }

tojava

tojava     private XKeysym() {}

tojava

tojava     static class Keysym2JavaKeycode  {

tojava         int jkeycode;

tojava         int keyLocation;

tojava         int getJavaKeycode() {

tojava             return jkeycode;

tojava         }

tojava         int getKeyLocation() {

tojava             return keyLocation;

tojava         }

tojava         Keysym2JavaKeycode(int jk, int loc) {

tojava             jkeycode = jk;

tojava             keyLocation = loc;

tojava         }

tojava     };

tojava     private static Unsafe unsafe = XlibWrapper.unsafe;

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

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

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

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

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

tojava     // from XWindow.c altogether.

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

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

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

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

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

tojava                                                                 java.awt.event.KeyEvent.KEY_LOCATION_STANDARD);

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

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

tojava

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

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

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

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

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

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

tojava                     ks &= 0x1F;

tojava                 }

tojava             }

tojava             return (char)ks;

tojava         }

tojava

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

tojava          */

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

tojava           return (char)(ks & 0x00ffffff);

tojava

tojava         Character ch = keysym2UCSHash.get(ks);

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

tojava     }

tojava     static long xkeycode2keysym_noxkb(XKeyEvent ev, int ndx) {

tojava         XToolkit.awtLock();

tojava         try {

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

tojava         } finally {

tojava             XToolkit.awtUnlock();

tojava         }

tojava     }

tojava     static long xkeycode2keysym_xkb(XKeyEvent ev, int ndx) {

tojava         XToolkit.awtLock();

tojava         try {

tojava             int mods = ev.get_state();

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

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

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

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

tojava                 mods ^= XConstants.ShiftMask;

tojava             }

tojava             long kbdDesc = XToolkit.getXKBKbdDesc();

tojava             if( kbdDesc != 0 ) {

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

tojava                        mods, XlibWrapper.iarg1, XlibWrapper.larg3);

tojava             }else{

tojava                 // xkb resources already gone

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

tojava                 return 0;

tojava             }

tojava             //XXX unconsumed modifiers?

tojava             return Native.getLong(XlibWrapper.larg3);

tojava         } finally {

tojava             XToolkit.awtUnlock();

tojava         }

tojava     }

tojava     static long xkeycode2keysym(XKeyEvent ev, int ndx) {

tojava         XToolkit.awtLock();

tojava         try {

tojava             if (XToolkit.canUseXKBCalls()) {

tojava                 return xkeycode2keysym_xkb(ev, ndx);

tojava             }else{

tojava                 return xkeycode2keysym_noxkb(ev, ndx);

tojava             }

tojava         } finally {

tojava             XToolkit.awtUnlock();

tojava         }

tojava     }

tojava     static long xkeycode2primary_keysym(XKeyEvent ev) {

tojava         return xkeycode2keysym(ev, 0);

tojava     }

tojava     public static boolean isKPEvent( XKeyEvent ev )

tojava     {

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

tojava         // Otherwise, it is [1].

tojava         int ndx = XToolkit.isXsunKPBehavior() &&

tojava                   ! XToolkit.isXKBenabled() ? 2 : 1;

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

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

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

tojava         XToolkit.awtLock();

tojava         try {

tojava             return (XlibWrapper.IsKeypadKey(

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

tojava                    XlibWrapper.IsKeypadKey(

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

tojava         } finally {

tojava             XToolkit.awtUnlock();

tojava         }

tojava     }

tojava     /**

tojava         Return uppercase keysym correspondent to a given keysym.

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

tojava     */

tojava     public static long getUppercaseAlphabetic( long keysym ) {

tojava         long lc = -1;

tojava         long uc = -1;

tojava         Long stored =  uppercaseHash.get(keysym);

tojava         if (stored != null ) {

tojava             return stored.longValue();

tojava         }

tojava         XToolkit.awtLock();

tojava         try {

tojava             XlibWrapper.XConvertCase(keysym, keysym_lowercase, keysym_uppercase);

tojava             lc = Native.getLong(keysym_lowercase);

tojava             uc = Native.getLong(keysym_uppercase);

tojava             if (lc == uc) {

tojava                 //not applicable

tojava                 uc = -1;

tojava             }

tojava             uppercaseHash.put(keysym, uc);

tojava         } finally {

tojava             XToolkit.awtUnlock();

tojava         }

tojava         return uc;

tojava     }

tojava     /**

tojava         Get a keypad keysym derived from a keycode.

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

tojava     */

tojava     private static long getKeypadKeysym( XKeyEvent ev ) {

tojava         int ndx = 0;

tojava         long keysym = XConstants.NoSymbol;

tojava         if( XToolkit.isXsunKPBehavior() &&

tojava             ! XToolkit.isXKBenabled() ) {

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

tojava                 ndx = 3;

tojava                 keysym = xkeycode2keysym(ev, ndx);

tojava             } else {

tojava                 ndx = 2;

tojava                 keysym = xkeycode2keysym(ev, ndx);

tojava             }

tojava         } else {

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

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

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

tojava                 ndx = 0;

tojava                 keysym = xkeycode2keysym(ev, ndx);

tojava             } else {

tojava                 ndx = 1;

tojava                 keysym = xkeycode2keysym(ev, ndx);

tojava             }

tojava         }

tojava         return keysym;

tojava     }

tojava

tojava     /**

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

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

tojava     */

tojava     static Keysym2JavaKeycode getJavaKeycode( long keysym ) {

tojava         if(keysym == XKeySymConstants.XK_Mode_switch){

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

tojava            if( XToolkit.isKanaKeyboard() ) {

tojava                return kanaLock;

tojava            }

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

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

tojava            if( XToolkit.isSunKeyboard() ) {

tojava                keysym = XKeySymConstants.SunXK_Stop;

tojava            }

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

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

tojava            if( XToolkit.isSunKeyboard() ) {

tojava                keysym = XKeySymConstants.SunXK_Again;

tojava            }

tojava         }

tojava

tojava         return  keysym2JavaKeycodeHash.get( keysym );

tojava     }

tojava     /**

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

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

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

tojava     */

tojava     static Keysym2JavaKeycode getJavaKeycode( XKeyEvent ev ) {

tojava         // get from keysym2JavaKeycodeHash.

tojava         long keysym = XConstants.NoSymbol;

tojava         int ndx = 0;

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

tojava              isKPEvent(ev)) {

tojava             keysym = getKeypadKeysym( ev );

tojava         } else {

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

tojava             ndx = 0;

tojava             keysym = xkeycode2keysym(ev, ndx);

tojava         }

tojava

tojava         Keysym2JavaKeycode jkc = getJavaKeycode( keysym );

tojava         return jkc;

tojava     }

tojava     static int getJavaKeycodeOnly( XKeyEvent ev ) {

tojava         Keysym2JavaKeycode jkc = getJavaKeycode( ev );

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

tojava     }

tojava     /**

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

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

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

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

tojava      * but will be someway compatible with old releases.

tojava      */

tojava     static int getLegacyJavaKeycodeOnly( XKeyEvent ev ) {

tojava         long keysym = XConstants.NoSymbol;

tojava         int ndx = 0;

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

tojava              isKPEvent(ev)) {

tojava             keysym = getKeypadKeysym( ev );

tojava         } else {

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

tojava             ndx = 0;

tojava             keysym = xkeycode2keysym_noxkb(ev, ndx);

tojava         }

tojava         Keysym2JavaKeycode jkc = getJavaKeycode( keysym );

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

tojava     }

tojava     static long javaKeycode2Keysym( int jkey ) {

tojava         Long ks = javaKeycode2KeysymHash.get( jkey );

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

tojava     }

tojava     /**

tojava         Return keysym derived from a keycode and modifiers.

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

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

tojava                         MIT X Consortium Standard

tojava                         X Version 11, Release 6

tojava                         Ch. 12.7

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

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

tojava     */

tojava     static long getKeysym( XKeyEvent ev ) {

tojava         long keysym = XConstants.NoSymbol;

tojava         long uppercaseKeysym = XConstants.NoSymbol;

tojava         int  ndx = 0;

tojava         boolean getUppercase = false;

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

tojava              isKPEvent(ev)) {

tojava             keysym = getKeypadKeysym( ev );

tojava         } else {

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

tojava             //

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

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

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

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

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

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

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

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

tojava                     ndx = 0;

tojava                     getUppercase = false;

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

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

tojava                     ndx = 0;

tojava                     getUppercase = true;

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

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

tojava                     ndx = 1;

tojava                     getUppercase = false;

tojava                 }

tojava             } else { // shift on

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

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

tojava                     ndx = 1;

tojava                     getUppercase = true;

tojava                 } else {

tojava                     ndx = 1;

tojava                     getUppercase = false;

tojava                 }

tojava             }

tojava             keysym = xkeycode2keysym(ev, ndx);

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

tojava                 keysym = uppercaseKeysym;

tojava             }

tojava         }

tojava         return keysym;

tojava     }

tojava

tojava     static {

/***********************************************************

Copyright 1987, 1994, 1998  The Open Group

Permission to use, copy, modify, distribute, and sell this software and its

documentation for any purpose is hereby granted without fee, provided that

the above copyright notice appear in all copies and that both that

copyright notice and this permission notice appear in supporting

documentation.

The above copyright notice and this permission notice shall be included

in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR

OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

OTHER DEALINGS IN THE SOFTWARE.

Except as contained in this notice, the name of The Open Group shall

not be used in advertising or otherwise to promote the sale, use or

other dealings in this Software without prior written authorization

from The Open Group.

Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts

                        All Rights Reserved

Permission to use, copy, modify, and distribute this software and its

documentation for any purpose and without fee is hereby granted,

provided that the above copyright notice appear in all copies and that

both that copyright notice and this permission notice appear in

supporting documentation, and that the name of Digital not be

used in advertising or publicity pertaining to distribution of the

software without specific, written prior permission.

DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING

ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL

DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR

ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,

ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS

SOFTWARE.

******************************************************************/

/*

 * TTY Functions, cleverly chosen to map to ascii, for convenience of

 * programming, but could have been arbitrary (at the cost of lookup

 * tables in client code.

 */

0x0008 #define XK_BackSpace        0xFF08    /* back space, back char */

0x0009 #define XK_Tab            0xFF09

0x000a #define XK_Linefeed        0xFF0A    /* Linefeed, LF */

0x000b #define XK_Clear        0xFF0B

/*XXX map to 0a instead of 0d - why? for some good reason I hope */

0x000a #define XK_Return        0xFF0D    /* Return, enter */

0x0000 #define XK_Pause        0xFF13    /* Pause, hold */

0x0000 #define XK_Scroll_Lock        0xFF14

0x0000 #define XK_Sys_Req        0xFF15

0x001B #define XK_Escape        0xFF1B

0x007F #define XK_Delete        0xFFFF    /* Delete, rubout */

/* International & multi-key character composition */

0x0000 #define XK_Multi_key        0xFF20  /* Multi-key character compose */

0x0000 #define XK_Codeinput        0xFF37

0x0000 #define XK_SingleCandidate    0xFF3C

0x0000 #define XK_MultipleCandidate    0xFF3D

0x0000 #define XK_PreviousCandidate    0xFF3E

/* Japanese keyboard support */

0x0000 #define XK_Kanji        0xFF21    /* Kanji, Kanji convert */

0x0000 #define XK_Muhenkan        0xFF22  /* Cancel Conversion */

0x0000 #define XK_Henkan_Mode        0xFF23  /* Start/Stop Conversion */

0x0000 #define XK_Henkan        0xFF23  /* Alias for Henkan_Mode */

0x0000 #define XK_Romaji        0xFF24  /* to Romaji */

0x0000 #define XK_Hiragana        0xFF25  /* to Hiragana */

0x0000 #define XK_Katakana        0xFF26  /* to Katakana */

0x0000 #define XK_Hiragana_Katakana    0xFF27  /* Hiragana/Katakana toggle */

0x0000 #define XK_Zenkaku        0xFF28  /* to Zenkaku */

0x0000 #define XK_Hankaku        0xFF29  /* to Hankaku */

0x0000 #define XK_Zenkaku_Hankaku    0xFF2A  /* Zenkaku/Hankaku toggle */

0x0000 #define XK_Touroku        0xFF2B  /* Add to Dictionary */

0x0000 #define XK_Massyo        0xFF2C  /* Delete from Dictionary */

0x0000 #define XK_Kana_Lock        0xFF2D  /* Kana Lock */

0x0000 #define XK_Kana_Shift        0xFF2E  /* Kana Shift */

0x0000 #define XK_Eisu_Shift        0xFF2F  /* Alphanumeric Shift */

0x0000 #define XK_Eisu_toggle        0xFF30  /* Alphanumeric toggle */

0x0000 #define XK_Kanji_Bangou        0xFF37  /* Codeinput */

0x0000 #define XK_Zen_Koho        0xFF3D    /* Multiple/All Candidate(s) */

0x0000 #define XK_Mae_Koho        0xFF3E    /* Previous Candidate */

/* Cursor control & motion */

0x0000 #define XK_Home            0xFF50

0x0000 #define XK_Left            0xFF51    /* Move left, left arrow */

0x0000 #define XK_Up            0xFF52    /* Move up, up arrow */

0x0000 #define XK_Right        0xFF53    /* Move right, right arrow */

0x0000 #define XK_Down            0xFF54    /* Move down, down arrow */

0x0000 #define XK_Prior        0xFF55    /* Prior, previous */

0x0000 #define XK_Page_Up        0xFF55

0x0000 #define XK_Next            0xFF56    /* Next */

0x0000 #define XK_Page_Down        0xFF56

0x0000 #define XK_End            0xFF57    /* EOL */

0x0000 #define XK_Begin        0xFF58    /* BOL */

/* Misc Functions */

0x0000 #define XK_Select        0xFF60    /* Select, mark */

0x0000 #define XK_Print        0xFF61

0x0000 #define XK_Execute        0xFF62    /* Execute, run, do */

0x0000 #define XK_Insert        0xFF63    /* Insert, insert here */

0x0000 #define XK_Undo            0xFF65    /* Undo, oops */

0x0000 #define XK_Redo            0xFF66    /* redo, again */

0x0000 #define XK_Menu            0xFF67

0x0000 #define XK_Find            0xFF68    /* Find, search */

0x0000 #define XK_Cancel        0xFF69    /* Cancel, stop, abort, exit */

0x0000 #define XK_Help            0xFF6A    /* Help */