![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gtk-keyboard.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [The Machine Emulator] / tme / host / gtk|
Return to gtk-keyboard.c CVS log | Up to [The Machine Emulator] / tme / host / gtk |
1.1 ! root 1: /* $Id: gtk-keyboard.c,v 1.6 2003/10/16 02:48:23 fredette Exp $ */ ! 2: ! 3: /* host/gtk/gtk-keyboard.c - GTK keyboard support: */ ! 4: ! 5: /* ! 6: * Copyright (c) 2003 Matt Fredette ! 7: * All rights reserved. ! 8: * ! 9: * Redistribution and use in source and binary forms, with or without ! 10: * modification, are permitted provided that the following conditions ! 11: * are met: ! 12: * 1. Redistributions of source code must retain the above copyright ! 13: * notice, this list of conditions and the following disclaimer. ! 14: * 2. Redistributions in binary form must reproduce the above copyright ! 15: * notice, this list of conditions and the following disclaimer in the ! 16: * documentation and/or other materials provided with the distribution. ! 17: * 3. All advertising materials mentioning features or use of this software ! 18: * must display the following acknowledgement: ! 19: * This product includes software developed by Matt Fredette. ! 20: * 4. The name of the author may not be used to endorse or promote products ! 21: * derived from this software without specific prior written permission. ! 22: * ! 23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR ! 24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED ! 25: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE ! 26: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, ! 27: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ! 28: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR ! 29: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ! 31: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ! 32: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ! 33: * POSSIBILITY OF SUCH DAMAGE. ! 34: */ ! 35: ! 36: #include <tme/common.h> ! 37: _TME_RCSID("$Id: gtk-keyboard.c,v 1.6 2003/10/16 02:48:23 fredette Exp $"); ! 38: ! 39: /* includes: */ ! 40: #include "gtk-display.h" ! 41: #include <gdk/gdkkeysyms.h> ! 42: ! 43: /* macros: */ ! 44: ! 45: /* types: */ ! 46: ! 47: /* a GTK keysym: */ ! 48: struct tme_gtk_keysym { ! 49: ! 50: /* the type of this keysym. this is either ! 51: TME_KEYBOARD_LOOKUP_FLAG_OK_DIRECT or ! 52: TME_KEYBOARD_LOOKUP_FLAG_OK_ALLOC, depending on whether or not ! 53: the keysym needed to be allocated: */ ! 54: int tme_gtk_keysym_type; ! 55: ! 56: /* the keysym itself: */ ! 57: tme_keyboard_keyval_t tme_gtk_keysym_keysym; ! 58: }; ! 59: ! 60: /* if X11 support is present: */ ! 61: #ifndef X_DISPLAY_MISSING ! 62: ! 63: /* includes: */ ! 64: #include <gdk/gdkx.h> ! 65: #include <X11/Xlib.h> ! 66: ! 67: #if TME_KEYBOARD_EVENT_TIME_UNDEF != CurrentTime ! 68: #error "TME_KEYBOARD_EVENT_TIME_UNDEF and CurrentTime disagree" ! 69: #endif ! 70: ! 71: /* the X11 half of keyboard initialization: */ ! 72: static void ! 73: _tme_gtk_keyboard_x11_new(struct tme_gtk_display *display) ! 74: { ! 75: struct tme_keyboard_buffer *buffer; ! 76: XModifierKeymap *modifier_keymap; ! 77: int x_modifier, modifier; ! 78: int keycode_to_modifier[(1 << (sizeof(KeyCode) * 8))]; ! 79: tme_keyboard_keyval_t *modifier_keysyms[TME_KEYBOARD_MODIFIER_MAX + 1]; ! 80: int modifier_keysyms_count[TME_KEYBOARD_MODIFIER_MAX + 1]; ! 81: int keycode_min, keycode_max, keycode, keycode_i; ! 82: int keymap_width, keysym_i, keysym_j; ! 83: KeySym *keymap, keysym, keysym_cases[2]; ! 84: const char *string; ! 85: struct tme_gtk_keysym *gtk_keysym; ! 86: int rc; ! 87: ! 88: /* get the keyboard buffer: */ ! 89: buffer = display->tme_gtk_display_keyboard_buffer; ! 90: ! 91: /* note all keycodes that are attached to modifiers: */ ! 92: for (keycode = 0; ! 93: keycode < (int) TME_ARRAY_ELS(keycode_to_modifier); ! 94: keycode++) { ! 95: keycode_to_modifier[keycode] = TME_KEYBOARD_MODIFIER_NONE; ! 96: } ! 97: modifier_keymap = XGetModifierMapping(GDK_DISPLAY()); ! 98: for (x_modifier = 0; ! 99: x_modifier < 8; ! 100: x_modifier++) { ! 101: ! 102: /* turn this X modifier into a tme modifier: */ ! 103: switch (x_modifier) { ! 104: case ShiftMapIndex: modifier = TME_KEYBOARD_MODIFIER_SHIFT ; break; ! 105: case LockMapIndex: modifier = TME_KEYBOARD_MODIFIER_LOCK ; break; ! 106: case ControlMapIndex: modifier = TME_KEYBOARD_MODIFIER_CONTROL ; break; ! 107: case Mod1MapIndex: modifier = TME_KEYBOARD_MODIFIER_MOD1 ; break; ! 108: case Mod2MapIndex: modifier = TME_KEYBOARD_MODIFIER_MOD2 ; break; ! 109: case Mod3MapIndex: modifier = TME_KEYBOARD_MODIFIER_MOD3 ; break; ! 110: case Mod4MapIndex: modifier = TME_KEYBOARD_MODIFIER_MOD4 ; break; ! 111: default: assert (FALSE); ! 112: case Mod5MapIndex: modifier = TME_KEYBOARD_MODIFIER_MOD5 ; break; ! 113: } ! 114: ! 115: /* note all keycodes that are attached to this modifier: */ ! 116: for (keycode_i = 0; ! 117: keycode_i < modifier_keymap->max_keypermod; ! 118: keycode_i++) { ! 119: keycode = *(modifier_keymap->modifiermap ! 120: + (x_modifier * modifier_keymap->max_keypermod) ! 121: + keycode_i); ! 122: if (keycode != 0) { ! 123: keycode_to_modifier[keycode] = modifier; ! 124: } ! 125: } ! 126: } ! 127: XFreeModifiermap(modifier_keymap); ! 128: ! 129: /* get the keycode range: */ ! 130: XDisplayKeycodes(GDK_DISPLAY(), &keycode_min, &keycode_max); ! 131: ! 132: /* get the keyboard mapping: */ ! 133: keymap = XGetKeyboardMapping(GDK_DISPLAY(), ! 134: keycode_min, ! 135: (keycode_max - keycode_min) + 1, ! 136: &keymap_width); ! 137: ! 138: /* initialize the lists of modifiers to keysyms: */ ! 139: memset (modifier_keysyms_count, 0, sizeof(modifier_keysyms_count)); ! 140: ! 141: /* loop over the keycodes in the keyboard mapping: */ ! 142: for (keycode = keycode_min; ! 143: keycode <= keycode_max; ! 144: keycode++) { ! 145: ! 146: /* if this keycode is attached to a modifier, we will take the ! 147: first keysym that this keycode maps to as the keysym attached ! 148: to the modifier: */ ! 149: modifier = keycode_to_modifier[keycode]; ! 150: ! 151: /* loop over the keysyms that this keycode can map to: */ ! 152: for (keysym_i = 0; ! 153: keysym_i < keymap_width; ! 154: keysym_i++) { ! 155: ! 156: /* get this keysym: */ ! 157: keysym = *(keymap ! 158: + ((keycode - keycode_min) ! 159: * keymap_width) ! 160: + keysym_i); ! 161: ! 162: /* ignore NoSymbol: */ ! 163: if (keysym == NoSymbol) { ! 164: continue; ! 165: } ! 166: ! 167: /* get the upper- and lowercase versions of this keysym. if ! 168: this keysym has no case, this sets both keysym_cases[] values ! 169: to keysym: */ ! 170: XConvertCase(keysym, &keysym_cases[0], &keysym_cases[1]); ! 171: ! 172: for (keysym_j = 0; ! 173: keysym_j < (int) TME_ARRAY_ELS(keysym_cases); ! 174: keysym_j++) { ! 175: keysym = keysym_cases[keysym_j]; ! 176: ! 177: /* ignore any keysym that doesn't have a string ! 178: name that GDK knows as the same keysym: */ ! 179: if ((string = XKeysymToString(keysym)) == NULL ! 180: || gdk_keyval_from_name(string) != keysym) { ! 181: continue; ! 182: } ! 183: ! 184: /* skip this keysym if it's already known: */ ! 185: if (tme_hash_lookup(display->tme_gtk_display_keyboard_keysyms, ! 186: (tme_hash_data_t) string) ! 187: != (tme_hash_data_t) NULL) { ! 188: ! 189: /* if there is a keycode associated with this keysym, ! 190: remove it if it's different from this keycode: */ ! 191: if (tme_hash_lookup(display->tme_gtk_display_keyboard_keysym_to_keycode, ! 192: (tme_hash_data_t) keysym) ! 193: != (tme_hash_data_t) keycode) { ! 194: tme_hash_remove(display->tme_gtk_display_keyboard_keysym_to_keycode, ! 195: (tme_hash_data_t) keysym); ! 196: } ! 197: ! 198: continue; ! 199: } ! 200: ! 201: /* if this keysym is attached to a modifier: */ ! 202: if (modifier != TME_KEYBOARD_MODIFIER_NONE) { ! 203: ! 204: /* grow the modifier to keysyms list for this modifier. ! 205: this list always has an extra entry in it, for the ! 206: TME_KEYBOARD_KEYVAL_UNDEF that will terminate the list: */ ! 207: if (modifier_keysyms_count[modifier] == 0) { ! 208: modifier_keysyms[modifier] ! 209: = tme_new(tme_keyboard_keyval_t, 2); ! 210: } ! 211: else { ! 212: modifier_keysyms[modifier] ! 213: = tme_renew(tme_keyboard_keyval_t, ! 214: modifier_keysyms[modifier], ! 215: modifier_keysyms_count[modifier] + 2); ! 216: } ! 217: ! 218: /* store this modifier keysym: */ ! 219: modifier_keysyms[modifier][modifier_keysyms_count[modifier]] ! 220: = keysym; ! 221: modifier_keysyms_count[modifier]++; ! 222: ! 223: /* if this is a modifier that locks, tell the keyboard ! 224: buffer so that it can unlock it: */ ! 225: /* XXX if this X server *doesn't* give these keysyms ! 226: locking behavior, we must *not* unlock them, because ! 227: inferring the extra transitions would be wrong: */ ! 228: /* XXX we shouldn't attach them to the modifier either - ! 229: because the keyboard buffer input stage zero top half ! 230: assumes that keysyms attached to modifiers that it knows ! 231: about all have locking behavior. this is a feature bug ! 232: in the keyboard buffer: */ ! 233: if (!strcmp(string, "Caps_Lock") ! 234: || !strcmp(string, "Shift_Lock") ! 235: || !strcmp(string, "Num_Lock")) { ! 236: rc = tme_keyboard_buffer_in_mode(buffer, ! 237: keysym, ! 238: TME_KEYBOARD_MODE_UNLOCK); ! 239: assert (rc == TME_OK); ! 240: } ! 241: ! 242: /* don't attach more than one keysym per keycode to ! 243: this modifier: */ ! 244: modifier = TME_KEYBOARD_MODIFIER_NONE; ! 245: } ! 246: ! 247: /* remember that this keysym can be generated directly: */ ! 248: gtk_keysym = tme_new0(struct tme_gtk_keysym, 1); ! 249: gtk_keysym->tme_gtk_keysym_type ! 250: = TME_KEYBOARD_LOOKUP_FLAG_OK_DIRECT; ! 251: gtk_keysym->tme_gtk_keysym_keysym ! 252: = keysym; ! 253: tme_hash_insert(display->tme_gtk_display_keyboard_keysyms, ! 254: (tme_hash_data_t) string, ! 255: (tme_hash_data_t) gtk_keysym); ! 256: tme_hash_insert(display->tme_gtk_display_keyboard_keysym_to_keycode, ! 257: (tme_hash_data_t) keysym, ! 258: (tme_hash_data_t) keycode); ! 259: } ! 260: } ! 261: } ! 262: ! 263: /* free the keyboard mapping: */ ! 264: XFree(keymap); ! 265: ! 266: /* add in the modifiers information: */ ! 267: for (modifier = 0; ! 268: modifier < TME_KEYBOARD_MODIFIER_MAX; ! 269: modifier++) { ! 270: if (modifier_keysyms_count[modifier] > 0) { ! 271: modifier_keysyms[modifier][modifier_keysyms_count[modifier]] ! 272: = TME_KEYBOARD_KEYVAL_UNDEF; ! 273: rc = tme_keyboard_buffer_in_modifier(buffer, ! 274: modifier, ! 275: modifier_keysyms[modifier]); ! 276: assert (rc == TME_OK); ! 277: tme_free(modifier_keysyms[modifier]); ! 278: } ! 279: } ! 280: } ! 281: ! 282: #endif /* !X_DISPLAY_MISSING */ ! 283: ! 284: #if 1 ! 285: /* this is used for debugging only: */ ! 286: const char *_tme_gtk_keyboard_keyval_name _TME_P((tme_keyboard_keyval_t)); ! 287: const char * ! 288: _tme_gtk_keyboard_keyval_name(tme_keyboard_keyval_t keyval) ! 289: { ! 290: return (gdk_keyval_name(keyval)); ! 291: } ! 292: #endif ! 293: ! 294: /* this is a GTK callback for a key press or release event: */ ! 295: static int ! 296: _tme_gtk_keyboard_key_event(GtkWidget *widget, ! 297: GdkEvent *gdk_event_raw, ! 298: struct tme_gtk_screen *screen) ! 299: { ! 300: struct tme_gtk_display *display; ! 301: GdkEventKey *gdk_event; ! 302: struct tme_keyboard_event tme_event; ! 303: int was_empty; ! 304: int new_callouts; ! 305: int rc; ! 306: ! 307: /* make a tme event from this gdk event: */ ! 308: gdk_event = &gdk_event_raw->key; ! 309: tme_event.tme_keyboard_event_type ! 310: = (gdk_event->type == GDK_KEY_PRESS ! 311: ? TME_KEYBOARD_EVENT_PRESS ! 312: : TME_KEYBOARD_EVENT_RELEASE); ! 313: tme_event.tme_keyboard_event_modifiers ! 314: = gdk_event->state; ! 315: tme_event.tme_keyboard_event_keyval ! 316: = gdk_event->keyval; ! 317: tme_event.tme_keyboard_event_time ! 318: = gdk_event->time; ! 319: ! 320: /* assume that we won't need any new callouts: */ ! 321: new_callouts = 0; ! 322: ! 323: /* recover our data structure: */ ! 324: display = screen->tme_gtk_screen_display; ! 325: ! 326: /* lock the mutex: */ ! 327: tme_mutex_lock(&display->tme_gtk_display_mutex); ! 328: ! 329: /* if this is a press of the mouse mode off key, turn mouse mode off ! 330: and return now: */ ! 331: if (gdk_event->type == GDK_KEY_PRESS ! 332: && (gdk_event->keyval ! 333: == screen->tme_gtk_screen_mouse_keyval)) { ! 334: _tme_gtk_mouse_mode_off(screen, ! 335: gdk_event->time); ! 336: ! 337: /* unlock the mutex: */ ! 338: tme_mutex_unlock(&display->tme_gtk_display_mutex); ! 339: ! 340: return (TRUE); ! 341: } ! 342: ! 343: /* get any keycode associated with this keysym: */ ! 344: tme_event.tme_keyboard_event_keycode ! 345: = ((tme_keyboard_keyval_t) ! 346: tme_hash_lookup(display->tme_gtk_display_keyboard_keysym_to_keycode, ! 347: (tme_hash_data_t) tme_event.tme_keyboard_event_keyval)); ! 348: ! 349: /* remember if the keyboard buffer was empty: */ ! 350: was_empty ! 351: = tme_keyboard_buffer_is_empty(display->tme_gtk_display_keyboard_buffer); ! 352: ! 353: /* add this tme event to the keyboard buffer: */ ! 354: rc = tme_keyboard_buffer_copyin(display->tme_gtk_display_keyboard_buffer, ! 355: &tme_event); ! 356: assert (rc == TME_OK); ! 357: ! 358: /* if the keyboard buffer was empty and now it isn't, ! 359: call out the keyboard controls: */ ! 360: if (was_empty ! 361: && !tme_keyboard_buffer_is_empty(display->tme_gtk_display_keyboard_buffer)) { ! 362: new_callouts |= TME_GTK_DISPLAY_CALLOUT_KEYBOARD_CTRL; ! 363: } ! 364: ! 365: /* run any callouts: */ ! 366: _tme_gtk_display_callout(display, new_callouts); ! 367: ! 368: /* unlock the mutex: */ ! 369: tme_mutex_unlock(&display->tme_gtk_display_mutex); ! 370: ! 371: return (TRUE); ! 372: } ! 373: ! 374: /* this is called to look up a keysym: */ ! 375: static tme_keyboard_keyval_t ! 376: _tme_gtk_keyboard_lookup(struct tme_keyboard_connection *conn_keyboard, ! 377: const struct tme_keyboard_lookup *lookup) ! 378: { ! 379: struct tme_gtk_display *display; ! 380: struct tme_gtk_keysym *keysym; ! 381: struct tme_gtk_keysym_bad **_keysym_bad, *keysym_bad; ! 382: char *string; ! 383: guint _keysym; ! 384: ! 385: /* recover our data structure: */ ! 386: display = conn_keyboard ! 387: ->tme_keyboard_connection.tme_connection_element->tme_element_private; ! 388: ! 389: /* lock the mutex: */ ! 390: tme_mutex_lock(&display->tme_gtk_display_mutex); ! 391: ! 392: /* if this is the "no more lookups" call, log complaints about all ! 393: keysyms that we were asked to look up, but have no way of ! 394: generating: */ ! 395: if (lookup == NULL) { ! 396: for (; display->tme_gtk_display_keyboard_keysyms_bad != NULL; ) { ! 397: keysym_bad ! 398: = display->tme_gtk_display_keyboard_keysyms_bad; ! 399: ! 400: /* log the complaint: */ ! 401: tme_log(&display->tme_gtk_display_element->tme_element_log_handle, 0, ENOENT, ! 402: (&display->tme_gtk_display_element->tme_element_log_handle, ! 403: _("cannot generate keysym '%s' directly%s"), ! 404: keysym_bad->tme_gtk_keysym_bad_string, ! 405: (keysym_bad->tme_keysym_bad_flags ! 406: != TME_KEYBOARD_LOOKUP_FLAG_OK_DIRECT ! 407: ? "" ! 408: : _(", or through a macro")))); ! 409: ! 410: /* free this record: */ ! 411: display->tme_gtk_display_keyboard_keysyms_bad ! 412: = keysym_bad->tme_gtk_keysym_bad_next; ! 413: tme_free(keysym_bad->tme_gtk_keysym_bad_string); ! 414: tme_free(keysym_bad->tme_gtk_keysym_bad_context); ! 415: tme_free(keysym_bad); ! 416: } ! 417: ! 418: /* unlock the mutex: */ ! 419: tme_mutex_unlock(&display->tme_gtk_display_mutex); ! 420: ! 421: return (TME_OK); ! 422: } ! 423: ! 424: /* if this lookup has context, find any existing bad keysym record ! 425: with the same context: */ ! 426: _keysym_bad = NULL; ! 427: keysym_bad = NULL; ! 428: if (lookup->tme_keyboard_lookup_context_length > 0) { ! 429: for (_keysym_bad ! 430: = &display->tme_gtk_display_keyboard_keysyms_bad; ! 431: (keysym_bad = *_keysym_bad) != NULL; ! 432: _keysym_bad ! 433: = &keysym_bad->tme_gtk_keysym_bad_next) { ! 434: ! 435: /* stop if this bad keysym record has this context: */ ! 436: if ((keysym_bad->tme_gtk_keysym_bad_context_length ! 437: == lookup->tme_keyboard_lookup_context_length) ! 438: && !memcmp(keysym_bad->tme_gtk_keysym_bad_context, ! 439: lookup->tme_keyboard_lookup_context, ! 440: lookup->tme_keyboard_lookup_context_length)) { ! 441: break; ! 442: } ! 443: } ! 444: } ! 445: ! 446: /* look up this keysym: */ ! 447: keysym ! 448: = ((struct tme_gtk_keysym *) ! 449: tme_hash_lookup(display->tme_gtk_display_keyboard_keysyms, ! 450: (tme_hash_data_t) lookup->tme_keyboard_lookup_string)); ! 451: ! 452: /* if the lookup failed and we're allowed to allocate this keysym: */ ! 453: if (keysym == NULL ! 454: && (lookup->tme_keyboard_lookup_flags ! 455: & TME_KEYBOARD_LOOKUP_FLAG_OK_ALLOC_NOW)) { ! 456: ! 457: /* duplicate the lookup string: */ ! 458: string = tme_strdup(lookup->tme_keyboard_lookup_string); ! 459: ! 460: /* create the new keysym: */ ! 461: keysym = tme_new(struct tme_gtk_keysym, 1); ! 462: keysym->tme_gtk_keysym_type ! 463: = TME_KEYBOARD_LOOKUP_FLAG_OK_ALLOC; ! 464: ! 465: /* if GDK knows a keysym for this name: */ ! 466: keysym->tme_gtk_keysym_keysym ! 467: = gdk_keyval_from_name(string); ! 468: ! 469: /* if GDK doesn't know a keysym for this name, else find an ! 470: unused keysym: */ ! 471: if (keysym->tme_gtk_keysym_keysym ! 472: == GDK_VoidSymbol) { ! 473: ! 474: /* loop until we have an unused keysym that isn't also ! 475: TME_KEYBOARD_KEYVAL_UNDEF, or until we have exhausted the ! 476: GDK keysym space: */ ! 477: for (_keysym = 0;; ) { ! 478: if (_keysym != TME_KEYBOARD_KEYVAL_UNDEF ! 479: && gdk_keyval_name(_keysym) == NULL) { ! 480: break; ! 481: } ! 482: if (++_keysym == 0) { ! 483: abort(); ! 484: } ! 485: } ! 486: ! 487: /* use this new keysym: */ ! 488: keysym->tme_gtk_keysym_keysym ! 489: = _keysym; ! 490: } ! 491: ! 492: /* add this newly allocated keysym: */ ! 493: tme_hash_insert(display->tme_gtk_display_keyboard_keysyms, ! 494: (tme_hash_data_t) string, ! 495: (tme_hash_data_t) keysym); ! 496: } ! 497: ! 498: /* if the lookup failed or didn't give the right kind of keysym: */ ! 499: if (keysym == NULL ! 500: || !(keysym->tme_gtk_keysym_type ! 501: & lookup->tme_keyboard_lookup_flags)) { ! 502: ! 503: /* if this lookup has context, and no bad keysym record ! 504: exists for this context, create a new one: */ ! 505: if (lookup->tme_keyboard_lookup_context_length > 0 ! 506: && keysym_bad == NULL) { ! 507: ! 508: /* create the new bad keysym record: */ ! 509: keysym_bad = tme_new0(struct tme_gtk_keysym_bad, 1); ! 510: keysym_bad->tme_gtk_keysym_bad_next ! 511: = display->tme_gtk_display_keyboard_keysyms_bad; ! 512: keysym_bad->tme_gtk_keysym_bad_string ! 513: = tme_strdup(lookup->tme_keyboard_lookup_string); ! 514: keysym_bad->tme_keysym_bad_flags ! 515: = lookup->tme_keyboard_lookup_flags; ! 516: keysym_bad->tme_gtk_keysym_bad_context_length ! 517: = lookup->tme_keyboard_lookup_context_length; ! 518: keysym_bad->tme_gtk_keysym_bad_context ! 519: = tme_dup(tme_uint8_t, ! 520: lookup->tme_keyboard_lookup_context, ! 521: lookup->tme_keyboard_lookup_context_length); ! 522: ! 523: /* link in the new bad keysym record: */ ! 524: display->tme_gtk_display_keyboard_keysyms_bad ! 525: = keysym_bad; ! 526: } ! 527: ! 528: /* unlock the mutex: */ ! 529: tme_mutex_unlock(&display->tme_gtk_display_mutex); ! 530: ! 531: /* return failure: */ ! 532: return (TME_KEYBOARD_KEYVAL_UNDEF); ! 533: } ! 534: ! 535: /* otherwise, this lookup succeeded. if a bad keysym record existed ! 536: for this context, forget it - this successful lookup forgives ! 537: that earlier failure: */ ! 538: if (keysym_bad != NULL) { ! 539: *_keysym_bad = keysym_bad->tme_gtk_keysym_bad_next; ! 540: tme_free(keysym_bad->tme_gtk_keysym_bad_context); ! 541: tme_free(keysym_bad); ! 542: } ! 543: ! 544: /* unlock the mutex: */ ! 545: tme_mutex_unlock(&display->tme_gtk_display_mutex); ! 546: ! 547: return (keysym->tme_gtk_keysym_keysym); ! 548: } ! 549: ! 550: /* this is called when the keyboard controls change: */ ! 551: static int ! 552: _tme_gtk_keyboard_ctrl(struct tme_keyboard_connection *conn_keyboard, ! 553: unsigned int ctrl) ! 554: { ! 555: struct tme_gtk_display *display; ! 556: ! 557: /* recover our data structure: */ ! 558: display = conn_keyboard ! 559: ->tme_keyboard_connection.tme_connection_element->tme_element_private; ! 560: ! 561: /* ring the bell: */ ! 562: if (ctrl & TME_KEYBOARD_CTRL_BELL) { ! 563: gdk_beep(); ! 564: } ! 565: ! 566: return (TME_OK); ! 567: } ! 568: ! 569: /* this is called to read the keyboard: */ ! 570: static int ! 571: _tme_gtk_keyboard_read(struct tme_keyboard_connection *conn_keyboard, ! 572: struct tme_keyboard_event *event) ! 573: { ! 574: struct tme_gtk_display *display; ! 575: int rc; ! 576: ! 577: /* recover our data structure: */ ! 578: display = conn_keyboard ! 579: ->tme_keyboard_connection.tme_connection_element->tme_element_private; ! 580: ! 581: /* lock the mutex: */ ! 582: tme_mutex_lock(&display->tme_gtk_display_mutex); ! 583: ! 584: /* copy an event out of the keyboard buffer: */ ! 585: rc = tme_keyboard_buffer_copyout(display->tme_gtk_display_keyboard_buffer, ! 586: event); ! 587: ! 588: /* unlock the mutex: */ ! 589: tme_mutex_unlock(&display->tme_gtk_display_mutex); ! 590: ! 591: return (rc); ! 592: } ! 593: ! 594: /* this breaks a keyboard connection: */ ! 595: static int ! 596: _tme_gtk_keyboard_connection_break(struct tme_connection *conn, unsigned int state) ! 597: { ! 598: abort(); ! 599: } ! 600: ! 601: /* this makes a new keyboard connection: */ ! 602: static int ! 603: _tme_gtk_keyboard_connection_make(struct tme_connection *conn, ! 604: unsigned int state) ! 605: { ! 606: struct tme_gtk_display *display; ! 607: ! 608: /* recover our data structure: */ ! 609: display = conn->tme_connection_element->tme_element_private; ! 610: ! 611: /* both sides must be keyboard connections: */ ! 612: assert(conn->tme_connection_type ! 613: == TME_CONNECTION_KEYBOARD); ! 614: assert(conn->tme_connection_other->tme_connection_type ! 615: == TME_CONNECTION_KEYBOARD); ! 616: ! 617: /* we are always set up to answer calls across the connection, so we ! 618: only have to do work when the connection has gone full, namely ! 619: taking the other side of the connection: */ ! 620: if (state == TME_CONNECTION_FULL) { ! 621: ! 622: /* save our connection: */ ! 623: tme_mutex_lock(&display->tme_gtk_display_mutex); ! 624: display->tme_gtk_display_keyboard_connection ! 625: = (struct tme_keyboard_connection *) conn->tme_connection_other; ! 626: tme_mutex_unlock(&display->tme_gtk_display_mutex); ! 627: } ! 628: ! 629: return (TME_OK); ! 630: } ! 631: ! 632: /* this scores a keyboard connection: */ ! 633: static int ! 634: _tme_gtk_keyboard_connection_score(struct tme_connection *conn, ! 635: unsigned int *_score) ! 636: { ! 637: struct tme_keyboard_connection *conn_keyboard; ! 638: ! 639: /* both sides must be keyboard connections: */ ! 640: assert(conn->tme_connection_type == TME_CONNECTION_KEYBOARD); ! 641: assert(conn->tme_connection_other->tme_connection_type == TME_CONNECTION_KEYBOARD); ! 642: ! 643: /* the other side cannot be a real keyboard: */ ! 644: conn_keyboard ! 645: = (struct tme_keyboard_connection *) conn->tme_connection_other; ! 646: *_score = (conn_keyboard->tme_keyboard_connection_read == NULL ! 647: && conn_keyboard->tme_keyboard_connection_lookup == NULL); ! 648: return (TME_OK); ! 649: } ! 650: ! 651: /* this makes a new connection side for a GTK keyboard: */ ! 652: int ! 653: _tme_gtk_keyboard_connections_new(struct tme_gtk_display *display, ! 654: struct tme_connection **_conns) ! 655: { ! 656: struct tme_keyboard_connection *conn_keyboard; ! 657: struct tme_connection *conn; ! 658: ! 659: /* if we don't have a keyboard connection yet: */ ! 660: if (display->tme_gtk_display_keyboard_connection == NULL) { ! 661: ! 662: /* create our side of a keyboard connection: */ ! 663: conn_keyboard = tme_new0(struct tme_keyboard_connection, 1); ! 664: conn = &conn_keyboard->tme_keyboard_connection; ! 665: ! 666: /* fill in the generic connection: */ ! 667: conn->tme_connection_next = *_conns; ! 668: conn->tme_connection_type = TME_CONNECTION_KEYBOARD; ! 669: conn->tme_connection_score = _tme_gtk_keyboard_connection_score; ! 670: conn->tme_connection_make = _tme_gtk_keyboard_connection_make; ! 671: conn->tme_connection_break = _tme_gtk_keyboard_connection_break; ! 672: ! 673: /* fill in the keyboard connection: */ ! 674: conn_keyboard->tme_keyboard_connection_ctrl = _tme_gtk_keyboard_ctrl; ! 675: conn_keyboard->tme_keyboard_connection_read = _tme_gtk_keyboard_read; ! 676: conn_keyboard->tme_keyboard_connection_lookup = _tme_gtk_keyboard_lookup; ! 677: ! 678: /* return the connection side possibility: */ ! 679: *_conns = conn; ! 680: } ! 681: ! 682: /* done: */ ! 683: return (TME_OK); ! 684: } ! 685: ! 686: /* this attaches the GTK keyboard to a new screen: */ ! 687: void ! 688: _tme_gtk_keyboard_attach(struct tme_gtk_screen *screen) ! 689: { ! 690: ! 691: /* make sure the event box for the framebuffer gets enter, key_press ! 692: and key_release events. we have to add these latter two events ! 693: to both the event box widget itself, and the top-level window, ! 694: since GTK 1.x appears to not select KeyRelease events at the ! 695: top-level: */ ! 696: gtk_widget_add_events(screen->tme_gtk_screen_event_box, ! 697: GDK_ENTER_NOTIFY_MASK ! 698: | GDK_KEY_PRESS_MASK ! 699: | GDK_KEY_RELEASE_MASK); ! 700: gtk_widget_add_events (gtk_widget_get_toplevel(screen->tme_gtk_screen_event_box), ! 701: GDK_KEY_PRESS_MASK ! 702: | GDK_KEY_RELEASE_MASK); ! 703: ! 704: /* set a signal handler for these events: */ ! 705: gtk_signal_connect(GTK_OBJECT(screen->tme_gtk_screen_event_box), ! 706: "enter_notify_event", ! 707: GTK_SIGNAL_FUNC(_tme_gtk_display_enter_focus), ! 708: NULL); ! 709: gtk_signal_connect(GTK_OBJECT(screen->tme_gtk_screen_event_box), ! 710: "key_press_event", ! 711: GTK_SIGNAL_FUNC(_tme_gtk_keyboard_key_event), ! 712: screen); ! 713: gtk_signal_connect(GTK_OBJECT(screen->tme_gtk_screen_event_box), ! 714: "key_release_event", ! 715: GTK_SIGNAL_FUNC(_tme_gtk_keyboard_key_event), ! 716: screen); ! 717: ! 718: /* the event box can focus, and have it grab the focus now: */ ! 719: GTK_WIDGET_SET_FLAGS(screen->tme_gtk_screen_event_box, GTK_CAN_FOCUS); ! 720: gtk_widget_grab_focus(screen->tme_gtk_screen_event_box); ! 721: } ! 722: ! 723: /* this initializes keyboard part of the display: */ ! 724: void ! 725: _tme_gtk_keyboard_new(struct tme_gtk_display *display) ! 726: { ! 727: ! 728: /* we have no keyboard connection: */ ! 729: display->tme_gtk_display_keyboard_connection = NULL; ! 730: ! 731: /* allocate the keyboard buffer: */ ! 732: display->tme_gtk_display_keyboard_buffer ! 733: = tme_keyboard_buffer_new(1024); ! 734: display->tme_gtk_display_keyboard_buffer->tme_keyboard_buffer_log_handle ! 735: = &display->tme_gtk_display_element->tme_element_log_handle; ! 736: ! 737: /* allocate the keysyms hash: */ ! 738: display->tme_gtk_display_keyboard_keysyms ! 739: = tme_hash_new(tme_string_hash, ! 740: tme_string_compare, ! 741: (tme_hash_data_t) 0); ! 742: ! 743: /* allocate the keysym-to-keycode hash: */ ! 744: display->tme_gtk_display_keyboard_keysym_to_keycode ! 745: = tme_hash_new(tme_direct_hash, ! 746: tme_direct_compare, ! 747: (tme_hash_data_t) TME_KEYBOARD_KEYVAL_UNDEF); ! 748: ! 749: /* there are no bad keysyms: */ ! 750: display->tme_gtk_display_keyboard_keysyms_bad = NULL; ! 751: ! 752: /* initialize the input stages of the keyboard buffer. this needs ! 753: information that we can't get from GTK or GDK, like which keysyms ! 754: are attached to which modifiers, and which keysyms can be ! 755: generated by the keyboard: */ ! 756: #ifndef X_DISPLAY_MISSING ! 757: if (TRUE) { ! 758: _tme_gtk_keyboard_x11_new(display); ! 759: } ! 760: #endif /* !X_DISPLAY_MISSING */ ! 761: else { ! 762: abort(); ! 763: } ! 764: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.