home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tkisrc04.zip / tk / os2 / tkOS2Key.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-08-07  |  7.8 KB  |  361 lines
  1. /* 
  2.  * tkOS2Key.c --
  3.  *
  4.  *    This file contains X emulation routines for keyboard related
  5.  *    functions.
  6.  *
  7.  * Copyright (c) 1996-1997 Illya Vaes
  8.  * Copyright (c) 1995 Sun Microsystems, Inc.
  9.  *
  10.  * See the file "license.terms" for information on usage and redistribution
  11.  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  12.  */
  13.  
  14.  
  15. #include "tkOS2Int.h"
  16.  
  17. typedef struct {
  18.     unsigned int keycode;
  19.     KeySym keysym;
  20. } Keys;
  21.  
  22. static Keys keymap[] = {
  23.     {VK_BREAK, XK_Cancel},
  24.     {VK_BACKSPACE, XK_BackSpace},
  25.     {VK_TAB, XK_Tab},
  26.     {VK_CLEAR, XK_Clear},
  27.     {VK_NEWLINE, XK_Return},
  28.     {VK_ENTER, XK_Return},
  29.     {VK_SHIFT, XK_Shift_L},
  30.     {VK_CTRL, XK_Control_L},
  31.     /*
  32.     {VK_MENU, XK_Alt_L},
  33.     */
  34.     {VK_ALT, XK_Alt_L},
  35.     /*
  36.     {VK_MENU, XK_Alt_R},
  37.     */
  38.     {VK_ALTGRAF, XK_Alt_R},
  39.     {VK_PAUSE, XK_Pause},
  40.     {VK_CAPSLOCK, XK_Caps_Lock},
  41.     {VK_ESC, XK_Escape},
  42.     {VK_SPACE, XK_space},
  43.     {VK_PAGEUP, XK_Prior},
  44.     {VK_PAGEDOWN, XK_Next},
  45.     {VK_END, XK_End},
  46.     {VK_HOME, XK_Home},
  47.     {VK_LEFT, XK_Left},
  48.     {VK_UP, XK_Up},
  49.     {VK_RIGHT, XK_Right},
  50.     {VK_DOWN, XK_Down},
  51. /*    {0, XK_Select}, */
  52.     {VK_PRINTSCRN, XK_Print},
  53. /*    {0, XK_Execute}, */
  54.     {VK_INSERT, XK_Insert},
  55.     {VK_DELETE, XK_Delete},
  56. /*    {0, XK_Help}, */
  57.     {VK_F1, XK_F1},
  58.     {VK_F2, XK_F2},
  59.     {VK_F3, XK_F3},
  60.     {VK_F4, XK_F4},
  61.     {VK_F5, XK_F5},
  62.     {VK_F6, XK_F6},
  63.     {VK_F7, XK_F7},
  64.     {VK_F8, XK_F8},
  65.     {VK_F9, XK_F9},
  66.     {VK_F10, XK_F10},
  67.     {VK_F11, XK_F11},
  68.     {VK_F12, XK_F12},
  69.     {VK_F13, XK_F13},
  70.     {VK_F14, XK_F14},
  71.     {VK_F15, XK_F15},
  72.     {VK_F16, XK_F16},
  73.     {VK_F17, XK_F17},
  74.     {VK_F18, XK_F18},
  75.     {VK_F19, XK_F19},
  76.     {VK_F20, XK_F20},
  77.     {VK_F21, XK_F21},
  78.     {VK_F22, XK_F22},
  79.     {VK_F23, XK_F23},
  80.     {VK_F24, XK_F24},
  81.     {VK_NUMLOCK, XK_Num_Lock}, 
  82.     {VK_SCRLLOCK, XK_Scroll_Lock},
  83.     {0, NoSymbol}
  84. };
  85.  
  86.  
  87. /*
  88.  *----------------------------------------------------------------------
  89.  *
  90.  * XLookupString --
  91.  *
  92.  *    Retrieve the string equivalent for the given keyboard event.
  93.  *
  94.  * Results:
  95.  *    Returns the number of characters stored in buffer_return.
  96.  *
  97.  * Side effects:
  98.  *    Retrieves the characters stored in the event and inserts them
  99.  *    into buffer_return.
  100.  *
  101.  *----------------------------------------------------------------------
  102.  */
  103.  
  104. int
  105. XLookupString(event_struct, buffer_return, bytes_buffer, keysym_return,
  106.     status_in_out)
  107.     XKeyEvent* event_struct;
  108.     char* buffer_return;
  109.     int bytes_buffer;
  110.     KeySym* keysym_return;
  111.     XComposeStatus* status_in_out;
  112. {
  113.     int i, limit;
  114.  
  115. #ifdef DEBUG
  116.     printf("XLookupString\n");
  117. #endif
  118.  
  119.     if ((event_struct->nchars <= 0) || (buffer_return == NULL)) {
  120.     return 0;
  121.     }
  122.     limit = (event_struct->nchars < bytes_buffer) ? event_struct->nchars :
  123.     bytes_buffer;
  124.  
  125.     for (i = 0; i < limit; i++) {
  126.     buffer_return[i] = event_struct->trans_chars[i];
  127.     }
  128.  
  129.     if (keysym_return != NULL) {
  130.     *keysym_return = NoSymbol;
  131.     }
  132.     return i;
  133. }
  134.  
  135. /*
  136.  *----------------------------------------------------------------------
  137.  *
  138.  * XKeycodeToKeysym --
  139.  *
  140.  *    Translate from a system-dependent keycode to a
  141.  *    system-independent keysym.
  142.  *
  143.  * Results:
  144.  *    Returns the translated keysym, or NoSymbol on failure.
  145.  *
  146.  * Side effects:
  147.  *    None.
  148.  *
  149.  *----------------------------------------------------------------------
  150.  */
  151.  
  152. KeySym
  153. XKeycodeToKeysym(display, keycode, index)
  154.     Display* display;
  155.     unsigned int keycode;
  156.     int index;
  157. {
  158.     Keys* key;
  159.     BYTE keys[256];
  160.     int result;
  161.  
  162.     memset(keys, 0, 256);
  163.     if (index & 0x02) {
  164.     keys[VK_NUMLOCK] = 1;
  165.     }
  166.     if (index & 0x01) {
  167.     keys[VK_SHIFT] = 0x80;
  168.     }
  169.     result = keycode > 32 && keycode < 255;
  170.  
  171.     /*
  172.      * Keycode mapped to a valid Latin-1 character.  Since the keysyms
  173.      * for alphanumeric characters map onto Latin-1, we just return it.
  174.      */
  175.  
  176.     if (result == 1 && keycode >= 0x20) {
  177. #ifdef DEBUG
  178.         printf("XKeycodeToKeysym returning char %x (%c)\n", keycode, keycode);
  179. #endif
  180.     return (KeySym) keycode;
  181.     }
  182.  
  183.     /*
  184.      * Keycode is a non-alphanumeric key, so we have to do the lookup.
  185.      */
  186.  
  187.     for (key = keymap; key->keycode != 0; key++) {
  188.     if (key->keycode == keycode) {
  189. #ifdef DEBUG
  190.             printf("XKeycodeToKeysym keycode %x -> keysym %x\n", keycode,
  191.                    key->keysym);
  192. #endif
  193.         return key->keysym;
  194.     }
  195.     }
  196.  
  197.     return NoSymbol;
  198. }
  199.  
  200. /*
  201.  *----------------------------------------------------------------------
  202.  *
  203.  * XKeysymToKeycode --
  204.  *
  205.  *    Translate a keysym back into a keycode.
  206.  *
  207.  * Results:
  208.  *    Returns the keycode that would generate the specified keysym.
  209.  *
  210.  * Side effects:
  211.  *    None.
  212.  *
  213.  *----------------------------------------------------------------------
  214.  */
  215.  
  216. KeyCode
  217. XKeysymToKeycode(display, keysym)
  218.     Display* display;
  219.     KeySym keysym;
  220. {
  221.     Keys* key;
  222.     SHORT result;
  223.  
  224. #ifdef DEBUG
  225.     printf("XKeysymToKeycode\n");
  226. #endif
  227.  
  228.     if (keysym >= 0x20) {
  229. /*
  230.     result = VkKeyScan(keysym);
  231. */
  232. result= (SHORT)keysym;
  233.     if (result != -1) {
  234.         return (KeyCode) (result & 0xff);
  235.     }
  236.     }
  237.  
  238.     /*
  239.      * Couldn't map the character to a virtual keycode, so do a
  240.      * table lookup.
  241.      */
  242.  
  243.     for (key = keymap; key->keycode != 0; key++) {
  244.     if (key->keysym == keysym) {
  245.         return key->keycode;
  246.     }
  247.     }
  248.     return 0;
  249. }
  250.  
  251. /*
  252.  *----------------------------------------------------------------------
  253.  *
  254.  * XGetModifierMapping --
  255.  *
  256.  *    Fetch the current keycodes used as modifiers.
  257.  *
  258.  * Results:
  259.  *    Returns a new modifier map.
  260.  *
  261.  * Side effects:
  262.  *    Allocates a new modifier map data structure.
  263.  *
  264.  *----------------------------------------------------------------------
  265.  */
  266.  
  267. XModifierKeymap    *
  268. XGetModifierMapping(display)
  269.     Display* display;
  270. {
  271.     XModifierKeymap *map = (XModifierKeymap *)ckalloc(sizeof(XModifierKeymap));
  272.  
  273. #ifdef DEBUG
  274.     printf("XGetModifierMapping\n");
  275. #endif
  276.  
  277.     map->max_keypermod = 1;
  278.     map->modifiermap = (KeyCode *) ckalloc(sizeof(KeyCode)*8);
  279.     map->modifiermap[ShiftMapIndex] = VK_SHIFT;
  280.     map->modifiermap[LockMapIndex] = VK_CAPSLOCK;
  281.     map->modifiermap[ControlMapIndex] = VK_CTRL;
  282.     map->modifiermap[Mod1MapIndex] = VK_NUMLOCK;
  283.     map->modifiermap[Mod2MapIndex] = VK_MENU;
  284.     map->modifiermap[Mod3MapIndex] = VK_SCRLLOCK;
  285.     map->modifiermap[Mod4MapIndex] = 0;
  286.     map->modifiermap[Mod5MapIndex] = 0;
  287.     return map;
  288. }
  289.  
  290. /*
  291.  *----------------------------------------------------------------------
  292.  *
  293.  * XFreeModifiermap --
  294.  *
  295.  *    Deallocate a modifier map that was created by
  296.  *    XGetModifierMapping.
  297.  *
  298.  * Results:
  299.  *    None.
  300.  *
  301.  * Side effects:
  302.  *    Frees the datastructure referenced by modmap.
  303.  *
  304.  *----------------------------------------------------------------------
  305.  */
  306.  
  307. void
  308. XFreeModifiermap(modmap)
  309.     XModifierKeymap* modmap;
  310. {
  311.     ckfree((char *) modmap->modifiermap);
  312.     ckfree((char *) modmap);
  313. }
  314.  
  315. /*
  316.  *----------------------------------------------------------------------
  317.  *
  318.  * XStringToKeysym --
  319.  *
  320.  *    Translate a keysym name to the matching keysym. 
  321.  *
  322.  * Results:
  323.  *    Returns the keysym.  Since this is already handled by
  324.  *    Tk's StringToKeysym function, we just return NoSymbol.
  325.  *
  326.  * Side effects:
  327.  *    None.
  328.  *
  329.  *----------------------------------------------------------------------
  330.  */
  331.  
  332. KeySym
  333. XStringToKeysym(string)
  334.     _Xconst char *string;
  335. {
  336.     return NoSymbol;
  337. }
  338.  
  339. /*
  340.  *----------------------------------------------------------------------
  341.  *
  342.  * XKeysymToString --
  343.  *
  344.  *    Convert a keysym to character form.
  345.  *
  346.  * Results:
  347.  *    Returns NULL, since Tk will have handled this already.
  348.  *
  349.  * Side effects:
  350.  *    None.
  351.  *
  352.  *----------------------------------------------------------------------
  353.  */
  354.  
  355. char *
  356. XKeysymToString(keysym)
  357.     KeySym keysym;
  358. {
  359.     return NULL;
  360. }
  361.