diff options
Diffstat (limited to 'carbon/tkMacOSXKeyboard.c')
| -rw-r--r-- | carbon/tkMacOSXKeyboard.c | 842 |
1 files changed, 842 insertions, 0 deletions
diff --git a/carbon/tkMacOSXKeyboard.c b/carbon/tkMacOSXKeyboard.c new file mode 100644 index 0000000..0d2bd21 --- /dev/null +++ b/carbon/tkMacOSXKeyboard.c @@ -0,0 +1,842 @@ +/* + * tkMacOSXKeyboard.c -- + * + * Routines to support keyboard events on the Macintosh. + * + * Copyright (c) 1995-1997 Sun Microsystems, Inc. + * Copyright 2001, Apple Computer, Inc. + * Copyright (c) 2005-2007 Daniel A. Steffen <das@users.sourceforge.net> + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * RCS: @(#) $Id: tkMacOSXKeyboard.c,v 1.1 2009/06/26 01:42:47 das Exp $ + */ + +#include "tkMacOSXInt.h" +#include "tkMacOSXEvent.h" /* for TkMacOSXKeycodeToUnicode() + * FIXME: That function should probably move + * here. */ + +/* + * A couple of simple definitions to make code a bit more self-explaining. + * + * For the assignments of Mod1==meta==command and Mod2==alt==option, see also + * tkMacOSXMouseEvent.c. + */ + +#define LATIN1_MAX 255 +#define MAC_KEYCODE_MAX 0x7F +#define MAC_KEYCODE_MASK 0x7F +#define COMMAND_MASK Mod1Mask +#define OPTION_MASK Mod2Mask + + +/* + * Tables enumerating the special keys defined on Mac keyboards. These are + * necessary for correct keysym mappings for all keys where the keysyms are + * not identical with their ASCII or Latin-1 code points. + */ + +typedef struct { + int keycode; /* Macintosh keycode. */ + KeySym keysym; /* X windows keysym. */ +} KeyInfo; + +/* + * Notes on keyArray: + * + * 0x34, XK_Return - Powerbooks use this and some keymaps define it. + * + * 0x4C, XK_Return - XFree86 and Apple's X11 call this one XK_KP_Enter. + * + * 0x47, XK_Clear - This key is NumLock when used on PCs, but Mac + * applications don't use it like that, nor does Apple's X11. + * + * All other keycodes are taken from the published ADB keyboard layouts. + */ + +static KeyInfo keyArray[] = { + {0x24, XK_Return}, + {0x30, XK_Tab}, + {0x33, XK_BackSpace}, + {0x34, XK_Return}, + {0x35, XK_Escape}, + + {0x47, XK_Clear}, + {0x4C, XK_KP_Enter}, + + {0x72, XK_Help}, + {0x73, XK_Home}, + {0x74, XK_Page_Up}, + {0x75, XK_Delete}, + {0x77, XK_End}, + {0x79, XK_Page_Down}, + + {0x7B, XK_Left}, + {0x7C, XK_Right}, + {0x7D, XK_Down}, + {0x7E, XK_Up}, + + {0, 0} +}; + +static KeyInfo virtualkeyArray[] = { + {122, XK_F1}, + {120, XK_F2}, + {99, XK_F3}, + {118, XK_F4}, + {96, XK_F5}, + {97, XK_F6}, + {98, XK_F7}, + {100, XK_F8}, + {101, XK_F9}, + {109, XK_F10}, + {103, XK_F11}, + {111, XK_F12}, + {105, XK_F13}, + {107, XK_F14}, + {113, XK_F15}, + {0, 0} +}; + +static int initialized = 0; +static Tcl_HashTable keycodeTable; /* keyArray hashed by keycode value. */ +static Tcl_HashTable vkeyTable; /* virtualkeyArray hashed by virtual + * keycode value. */ + +static int latin1Table[LATIN1_MAX+1]; /* Reverse mapping table for + * controls, ASCII and Latin-1. */ + +/* + * Prototypes for static functions used in this file. + */ + +static void InitKeyMaps (void); +static void InitLatin1Table(Display *display); +static int XKeysymToMacKeycode(Display *display, KeySym keysym); + + +/* + *---------------------------------------------------------------------- + * + * InitKeyMaps -- + * + * Creates hash tables used by some of the functions in this file. + * + * FIXME: As keycodes are defined to be in the limited range 0-127, it + * would be easier and more efficient to use directly initialized plain + * arrays and drop this function. + * + * Results: + * None. + * + * Side effects: + * Allocates memory & creates some hash tables. + * + *---------------------------------------------------------------------- + */ + +static void +InitKeyMaps(void) +{ + Tcl_HashEntry *hPtr; + KeyInfo *kPtr; + int dummy; + + Tcl_InitHashTable(&keycodeTable, TCL_ONE_WORD_KEYS); + for (kPtr = keyArray; kPtr->keycode != 0; kPtr++) { + hPtr = Tcl_CreateHashEntry(&keycodeTable, (char *) kPtr->keycode, + &dummy); + Tcl_SetHashValue(hPtr, kPtr->keysym); + } + Tcl_InitHashTable(&vkeyTable, TCL_ONE_WORD_KEYS); + for (kPtr = virtualkeyArray; kPtr->keycode != 0; kPtr++) { + hPtr = Tcl_CreateHashEntry(&vkeyTable, (char *) kPtr->keycode, + &dummy); + Tcl_SetHashValue(hPtr, kPtr->keysym); + } + initialized = 1; +} + +/* + *---------------------------------------------------------------------- + * + * InitLatin1Table -- + * + * Creates a simple table to be used for mapping from keysyms to keycodes. + * Always needs to be called before using latin1Table, because the + * keyboard layout may have changed, and than the table must be + * re-computed. + * + * Results: + * None. + * + * Side effects: + * Sets the global latin1Table. + * + *---------------------------------------------------------------------- + */ + +static void +InitLatin1Table( + Display *display) +{ + static Boolean latin1_initialized = false; + static SInt16 lastKeyLayoutID = -1; + + SInt16 keyScript; + SInt16 keyLayoutID; + + keyScript = GetScriptManagerVariable(smKeyScript); + keyLayoutID = GetScriptVariable(keyScript,smScriptKeys); + + if (!latin1_initialized || (lastKeyLayoutID != keyLayoutID)) { + int keycode; + KeySym keysym; + int state; + int modifiers; + + latin1_initialized = true; + lastKeyLayoutID = keyLayoutID; + + memset(latin1Table, 0, sizeof(latin1Table)); + + /* + * In the common X11 implementations, a keymap has four columns + * "plain", "Shift", "Mode_switch" and "Mode_switch + Shift". We don't + * use "Mode_switch", but we use "Option" instead. (This is similar to + * Apple's X11 implementation, where "Mode_switch" is used as an alias + * for "Option".) + * + * So here we go through all 4 columns of the keymap and find all + * Latin-1 compatible keycodes. We go through the columns back-to-front + * from the more exotic columns to the more simple, so that simple + * keycode-modifier combinations are preferred in the resulting table. + */ + + for (state = 3; state >= 0; state--) { + modifiers = 0; + if (state & 1) { + modifiers |= shiftKey; + } + if (state & 2) { + modifiers |= optionKey; + } + + for (keycode = 0; keycode <= MAC_KEYCODE_MAX; keycode++) { + keysym = XKeycodeToKeysym(display,keycode<<16,state); + if (keysym <= LATIN1_MAX) { + latin1Table[keysym] = keycode | modifiers; + } + } + } + } +} + +/* + *---------------------------------------------------------------------- + * + * XKeycodeToKeysym -- + * + * Translate from a system-dependent keycode to a system-independent + * keysym. + * + * Results: + * Returns the translated keysym, or NoSymbol on failure. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +KeySym +XKeycodeToKeysym( + Display* display, + KeyCode keycode, + int index) +{ + register Tcl_HashEntry *hPtr; + int newKeycode; + UniChar newChar; + + (void) display; /*unused*/ + + if (!initialized) { + InitKeyMaps(); + } + + /* + * When determining what keysym to produce we first check to see if the key + * is a function key. We then check to see if the character is another + * non-printing key. Finally, we return the key syms for all ASCII and + * Latin-1 chars. + */ + + newKeycode = keycode >> 16; + + if ((keycode & 0xFFFF) == 0x10) { + hPtr = Tcl_FindHashEntry(&vkeyTable, (char *) newKeycode); + if (hPtr != NULL) { + return (KeySym) Tcl_GetHashValue(hPtr); + } + } + hPtr = Tcl_FindHashEntry(&keycodeTable, (char *) newKeycode); + if (hPtr != NULL) { + return (KeySym) Tcl_GetHashValue(hPtr); + } + + /* + * Add in the Mac modifier flags for shift and option. + */ + + if (index & 1) { + newKeycode |= shiftKey; + } + if (index & 2) { + newKeycode |= optionKey; + } + + newChar = 0; + TkMacOSXKeycodeToUnicode(&newChar, 1, kEventRawKeyDown, + newKeycode & 0x00FF, newKeycode & 0xFF00, NULL); + + /* + * X11 keysyms are identical to Unicode for ASCII and Latin-1. Give up for + * other characters for now. + */ + + if ((newChar >= XK_space) && (newChar <= LATIN1_MAX)) { + return newChar; + } + + return NoSymbol; +} + +/* + *---------------------------------------------------------------------- + * + * TkpGetString -- + * + * Retrieve the string equivalent for the given keyboard event. + * + * Results: + * Returns the UTF string. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +char * +TkpGetString( + TkWindow *winPtr, /* Window where event occurred: Needed to get + * input context. */ + XEvent *eventPtr, /* X keyboard event. */ + Tcl_DString *dsPtr) /* Uninitialized or empty string to hold + * result. */ +{ + (void) winPtr; /*unused*/ + Tcl_DStringInit(dsPtr); + return Tcl_DStringAppend(dsPtr, eventPtr->xkey.trans_chars, -1); +} + +/* + *---------------------------------------------------------------------- + * + * XGetModifierMapping -- + * + * Fetch the current keycodes used as modifiers. + * + * Results: + * Returns a new modifier map. + * + * Side effects: + * Allocates a new modifier map data structure. + * + *---------------------------------------------------------------------- + */ + +XModifierKeymap * +XGetModifierMapping( + Display *display) +{ + XModifierKeymap *modmap; + + (void) display; /*unused*/ + + /* + * MacOSX doesn't use the key codes for the modifiers for anything, and we + * don't generate them either. So there is no modifier map. + */ + + modmap = (XModifierKeymap *) ckalloc(sizeof(XModifierKeymap)); + modmap->max_keypermod = 0; + modmap->modifiermap = NULL; + return modmap; +} + +/* + *---------------------------------------------------------------------- + * + * XFreeModifiermap -- + * + * Deallocate a modifier map that was created by XGetModifierMapping. + * + * Results: + * None. + * + * Side effects: + * Frees the datastructure referenced by modmap. + * + *---------------------------------------------------------------------- + */ + +void +XFreeModifiermap( + XModifierKeymap *modmap) +{ + if (modmap->modifiermap != NULL) { + ckfree((char *) modmap->modifiermap); + } + ckfree((char *) modmap); +} + +/* + *---------------------------------------------------------------------- + * + * XKeysymToString, XStringToKeysym -- + * + * These X window functions map keysyms to strings & strings to keysyms. + * However, Tk already does this for the most common keysyms. Therefore, + * these functions only need to support keysyms that will be specific to + * the Macintosh. Currently, there are none. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +char * +XKeysymToString( + KeySym keysym) +{ + return NULL; +} + +KeySym +XStringToKeysym( + const char* string) +{ + return NoSymbol; +} + +/* + *---------------------------------------------------------------------- + * + * XKeysymToMacKeycode -- + * + * An internal function like XKeysymToKeycode but only generating the Mac + * specific keycode plus the modifiers Shift and Option. + * + * Results: + * A Mac keycode with the actual keycode in the low byte and Mac-style + * modifier bits in the high byte. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +static int +XKeysymToMacKeycode( + Display *display, + KeySym keysym) +{ + KeyInfo *kPtr; + + if (keysym <= LATIN1_MAX) { + /* + * Handle keysyms in the Latin-1 range where keysym and Unicode + * character code point are the same. + */ + + InitLatin1Table(display); + return latin1Table[keysym]; + } + + /* + * Handle special keys from our exception tables. Don't mind if this is + * slow, neither the test suite nor [event generate] need to be optimized + * (we hope). + */ + + for (kPtr = keyArray; kPtr->keycode != 0; kPtr++) { + if (kPtr->keysym == keysym) { + return kPtr->keycode; + } + } + for (kPtr = virtualkeyArray; kPtr->keycode != 0; kPtr++) { + if (kPtr->keysym == keysym) { + return kPtr->keycode; + } + } + + /* + * For other keysyms (not Latin-1 and not special keys), we'd need a + * generic keysym-to-unicode table. We don't have that, so we give up here. + */ + + return 0; +} + +/* + *---------------------------------------------------------------------- + * + * XKeysymToKeycode -- + * + * The function XKeysymToKeycode takes an X11 keysym and converts it into + * a Mac keycode. It is in the stubs table for compatibility but not used + * anywhere in the core. + * + * Results: + * A 32 bit keycode with the the mac keycode (without modifiers) in the + * higher 16 bits of the keycode and the ASCII or Latin-1 code in the + * lower 8 bits of the keycode. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +KeyCode +XKeysymToKeycode( + Display* display, + KeySym keysym) +{ + int macKeycode = XKeysymToMacKeycode(display, keysym); + KeyCode result; + + /* + * See also TkpSetKeycodeAndState. The 0x0010 magic is used in + * XKeycodeToKeysym. For special keys like XK_Return the lower 8 bits of + * the keysym are usually a related ASCII control code. + */ + + if ((keysym >= XK_F1) && (keysym <= XK_F35)) { + result = 0x0010; + } else { + result = 0x00FF & keysym; + } + result |= (macKeycode & MAC_KEYCODE_MASK) << 16; + + return result; +} + +/* +NB: Keep this commented code for a moment for reference. + + if ((keysym >= XK_space) && (XK_asciitilde)) { + if (keysym == 'a') { + virtualKeyCode = 0x00; + } else if (keysym == 'b' || keysym == 'B') { + virtualKeyCode = 0x0B; + } else if (keysym == 'c') { + virtualKeyCode = 0x08; + } else if (keysym == 'x' || keysym == 'X') { + virtualKeyCode = 0x07; + } else if (keysym == 'z') { + virtualKeyCode = 0x06; + } else if (keysym == ' ') { + virtualKeyCode = 0x31; + } else if (keysym == XK_Return) { + virtualKeyCode = 0x24; + keysym = '\r'; + } + keycode = keysym + (virtualKeyCode <<16); + } + + return keycode; +*/ + +/* + *---------------------------------------------------------------------- + * + * TkpSetKeycodeAndState -- + * + * The function TkpSetKeycodeAndState takes a keysym and fills in the + * appropriate members of an XEvent. It is similar to XKeysymToKeycode, + * but it also sets the modifier mask in the XEvent. It is used by [event + * generate] and it is in the stubs table. + * + * Results: + * Fills an XEvent, sets the member xkey.keycode with a keycode + * formatted the same as XKeysymToKeycode and the member xkey.state with + * the modifiers implied by the keysym. Also fills in xkey.trans_chars, + * so that the actual characters can be retrieved later. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +TkpSetKeycodeAndState( + Tk_Window tkwin, + KeySym keysym, + XEvent *eventPtr) +{ + if (keysym == NoSymbol) { + eventPtr->xkey.keycode = 0; + } else { + Display *display = Tk_Display(tkwin); + int macKeycode = XKeysymToMacKeycode(display, keysym); + + /* + * See also XKeysymToKeycode. + */ + + if ((keysym >= XK_F1) && (keysym <= XK_F35)) { + eventPtr->xkey.keycode = 0x0010; + } else { + eventPtr->xkey.keycode = 0x00FF & keysym; + } + eventPtr->xkey.keycode |= (macKeycode & MAC_KEYCODE_MASK) << 16; + + if (shiftKey & macKeycode) { + eventPtr->xkey.state |= ShiftMask; + } + if (optionKey & macKeycode) { + eventPtr->xkey.state |= OPTION_MASK; + } + + if (keysym <= LATIN1_MAX) { + int done = Tcl_UniCharToUtf(keysym, eventPtr->xkey.trans_chars); + + eventPtr->xkey.trans_chars[done] = 0; + } else { + eventPtr->xkey.trans_chars[0] = 0; + } + } +} + +/* + *---------------------------------------------------------------------- + * + * TkpGetKeySym -- + * + * Given an X KeyPress or KeyRelease event, map the keycode in the event + * into a keysym. + * + * Results: + * The return value is the keysym corresponding to eventPtr, or NoSymbol + * if no matching keysym could be found. + * + * Side effects: + * In the first call for a given display, keycode-to-keysym maps get + * loaded. + * + *---------------------------------------------------------------------- + */ + +KeySym +TkpGetKeySym( + TkDisplay *dispPtr, /* Display in which to map keycode. */ + XEvent *eventPtr) /* Description of X event. */ +{ + KeySym sym; + int index; + + /* + * Refresh the mapping information if it's stale. + */ + + if (dispPtr->bindInfoStale) { + TkpInitKeymapInfo(dispPtr); + } + + /* + * Handle pure modifier keys specially. We use -1 as a signal for + * this. + */ + + if (eventPtr->xany.send_event == -1) { + int modifier = eventPtr->xkey.keycode; + + if (modifier == cmdKey) { + return XK_Meta_L; + } else if (modifier == shiftKey) { + return XK_Shift_L; + } else if (modifier == alphaLock) { + return XK_Caps_Lock; + } else if (modifier == optionKey) { + return XK_Alt_L; + } else if (modifier == controlKey) { + return XK_Control_L; + } else if (modifier == kEventKeyModifierNumLockMask) { + return XK_Num_Lock; + } else if (modifier == kEventKeyModifierFnMask) { + return XK_Super_L; + } else if (modifier == rightShiftKey) { + return XK_Shift_R; + } else if (modifier == rightOptionKey) { + return XK_Alt_R; + } else if (modifier == rightControlKey) { + return XK_Control_R; + } else { + /* + * If we get here, we probably need to implement something new. + */ + + return NoSymbol; + } + } + + /* + * Figure out which of the four slots in the keymap vector to use for this + * key. Refer to Xlib documentation for more info on how this computation + * works. (Note: We use "Option" in keymap columns 2 and 3 where other + * implementations have "Mode_switch".) + */ + + index = 0; + + /* + * We want Option key combinations to use their base chars as keysyms, so + * we ignore the option modifier here. + */ + +#if 0 + if (eventPtr->xkey.state & OPTION_MASK) { + index |= 2; + } +#endif + + if ((eventPtr->xkey.state & ShiftMask) + || (/* (dispPtr->lockUsage != LU_IGNORE) + && */ (eventPtr->xkey.state & LockMask))) { + index |= 1; + } + + /* + * First try of the actual translation. + */ + + sym = XKeycodeToKeysym(dispPtr->display, eventPtr->xkey.keycode, index); + + /* + * Special handling: If the key was shifted because of Lock, but lock is + * only caps lock, not shift lock, and the shifted keysym isn't upper-case + * alphabetic, then switch back to the unshifted keysym. + */ + + if ((index & 1) && !(eventPtr->xkey.state & ShiftMask) + /*&& (dispPtr->lockUsage == LU_CAPS)*/ ) { + /* + * FIXME: Keysyms are only identical to Unicode for ASCII and Latin-1, + * so we can't use Tcl_UniCharIsUpper() for keysyms outside that range. + * This may be a serious problem here. + */ + + if ((sym == NoSymbol) || (sym > LATIN1_MAX) + || !Tcl_UniCharIsUpper(sym)) { + index &= ~1; + sym = XKeycodeToKeysym(dispPtr->display, eventPtr->xkey.keycode, + index); + } + } + + /* + * Another bit of special handling: If this is a shifted key and there is + * no keysym defined, then use the keysym for the unshifted key. + */ + + if ((index & 1) && (sym == NoSymbol)) { + sym = XKeycodeToKeysym(dispPtr->display, eventPtr->xkey.keycode, + index & ~1); + } + return sym; +} + +/* + *-------------------------------------------------------------- + * + * TkpInitKeymapInfo -- + * + * This procedure is invoked to scan keymap information to recompute stuff + * that's important for binding, such as the modifier key (if any) that + * corresponds to the "Mode_switch" keysym. + * + * Results: + * None. + * + * Side effects: + * Keymap-related information in dispPtr is updated. + * + *-------------------------------------------------------------- + */ + +void +TkpInitKeymapInfo( + TkDisplay *dispPtr) /* Display for which to recompute keymap + * information. */ +{ + dispPtr->bindInfoStale = 0; + + /* + * Behaviours that are variable on X11 are defined constant on MacOSX. + * lockUsage is only used above in TkpGetKeySym(), nowhere else currently. + * There is no offical "Mode_switch" key. + */ + + dispPtr->lockUsage = LU_CAPS; + dispPtr->modeModMask = 0; + +#if 0 + /* + * With this, <Alt> and <Meta> become synonyms for <Command> and <Option> + * in bindings like they are (and always have been) in the keysyms that + * are reported by KeyPress events. But the init scripts like text.tcl + * have some disabling bindings for <Meta>, so we don't want this without + * some changes in those scripts. See also bug #700311. + */ + + dispPtr->altModMask = OPTION_MASK; + dispPtr->metaModMask = COMMAND_MASK; +#else + dispPtr->altModMask = 0; + dispPtr->metaModMask = 0; +#endif + + /* + * MacOSX doesn't use the keycodes for the modifiers for anything, and we + * don't generate them either (the keycodes actually given in the simulated + * modifier events are bogus). So there is no modifier map. If we ever want + * to simulate real modifier keycodes, the list will be constant in the + * Carbon implementation. + */ + + if (dispPtr->modKeyCodes != NULL) { + ckfree((char *) dispPtr->modKeyCodes); + } + dispPtr->numModKeyCodes = 0; + dispPtr->modKeyCodes = NULL; +} + +/* + * Local Variables: + * mode: c + * c-basic-offset: 4 + * fill-column: 79 + * coding: utf-8 + * End: + */ |