/* xkeycaps, Copyright (c) 1991, 1992, 1993, 1996 * Jamie Zawinski * * 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. No representations are made about the suitability of this * software for any purpose. It is provided "as is" without express or * implied warranty. */ #include #include "KbdWidgetP.h" #include "KeyWidgetP.h" #include "xkeycaps.h" static void highlight_key P((KeyWidget widget)); static void dehighlight_key P((KeyWidget widget)); static void mouse_highlight_key P((KeyWidget widget)); static void mouse_dehighlight_key P((KeyWidget widget)); static void simulate_key_event P((KeyWidget widget, int down_p)); /* The goal of the mouse-tracking code in the following functions is for the mouse with a button down to be just like your finger on the keyboard: so long as a button is down, the key under it is depressed. If the mouse moves to another key without the button going up first, the previous key is released and the new key is depressed. When a ButtonDown event comes in, the server gives you an implicit grab of the mouse so that you will get the corresponding ButtonUp event no matter what happens to focus or mouse-position in the meantime. This is good, and totally necessary to our purposes. But, we want to be able to track the mouse while the button is down. Initially, I did this by selecting EnterNotify/LeaveNotify events on the child windows, but those aren't generated while the parent window has a grab. So instead, the parent window gets PointerMotion events, and looks at the "child" window that the mouse is over to notice the crossings. This loses slightly in that if you click down on the A key and move quickly over to the L key, we won't necessarily notice that *all* of the intervening keys went down; only the ones that we happened to get motion events for. Others down/up pairs may be compressed out of existence. */ static KeyWidget #ifdef __STDC__ parse_key_action_args (char *name, XEvent *event, char **argv, int argc, KeyboardWidget widget, int *mouse_p_ret) #else /* ! __STDC__ */ parse_key_action_args (name, event, argv, argc, widget, mouse_p_ret) char *name; XEvent *event; char **argv; int argc; KeyboardWidget widget; int *mouse_p_ret; #endif /* ! __STDC__ */ { KeyWidget key = 0; int mouse_p = 0; int mod_p = 0; int track_p = 0; int highlighted_p = 0; char *key_desc = 0; int orig_argc = argc; for (; argc > 0; argc--) { if (string_equal (argv[argc-1], "ifmod")) mod_p = 1; else if (string_equal (argv[argc-1], "unlessmod")) mod_p = -1; else if (string_equal (argv[argc-1], "iftracking")) track_p = 1; else if (string_equal (argv[argc-1], "unlesstracking")) track_p = -1; else if (string_equal (argv[argc-1], "ifhighlighted")) highlighted_p = 1; else if (string_equal (argv[argc-1], "unlesshighlighted")) highlighted_p = -1; else if (key_desc) fprintf (stderr, "%s: too many args (%d) passed to %s action\n", progname, orig_argc, name); else key_desc = argv[argc-1]; } if (key_desc && string_equal (key_desc, "mouse")) key = widget->keyboard.key_under_mouse, mouse_p = 1; else if (key_desc && string_equal (key_desc, "highlighted")) key = widget->keyboard.mouse_highlighted_key, mouse_p = 1; else if (key_desc && string_equal (key_desc, "displayed")) key = widget->keyboard.documented_key, mouse_p = 1; else if (key_desc) fprintf (stderr, "%s: unrecognised arg to %s: %s\n", progname, name, key_desc); else if (event->xany.type == ButtonPress || event->xany.type == ButtonRelease || event->xany.type == MotionNotify) key = widget->keyboard.key_under_mouse, mouse_p = 1; else if (event->xany.type == KeyPress || event->xany.type == KeyRelease) key = keycode_to_key (widget, event->xkey.keycode); else fprintf (stderr, "%s: %d isn't a key or button press or release in %s\n", progname, event->xany.type, name); if (mod_p != 0) { if (!key) return 0; if (mod_p == 1 && !key->key.modifier_bits) return 0; if (mod_p == -1 && key->key.modifier_bits) return 0; } if (track_p == 1 && !widget->keyboard.tracking_key) return 0; if (track_p == -1 && widget->keyboard.tracking_key) return 0; if (highlighted_p == 1 && key != widget->keyboard.mouse_highlighted_key) return 0; if (highlighted_p == -1 && key == widget->keyboard.mouse_highlighted_key) return 0; if (mouse_p_ret) *mouse_p_ret = mouse_p; return key; } void #ifdef __STDC__ highlight_key_action (Widget ww, XEvent *event, String *argv, Cardinal *argc) #else /* ! __STDC__ */ highlight_key_action (ww, event, argv, argc) Widget ww; XEvent *event; String *argv; Cardinal *argc; #endif /* ! __STDC__ */ { KeyboardWidget widget = (KeyboardWidget) ww; int mouse_p; KeyWidget key = parse_key_action_args ("HighlightKey", event, argv, *argc, widget, &mouse_p); if (! key) return; if (mouse_p) mouse_highlight_key (key); else highlight_key (key); } void #ifdef __STDC__ unhighlight_key_action (Widget ww, XEvent *event, String *argv, Cardinal *argc) #else /* ! __STDC__ */ unhighlight_key_action (ww, event, argv, argc) Widget ww; XEvent *event; String *argv; Cardinal *argc; #endif /* ! __STDC__ */ { KeyboardWidget widget = (KeyboardWidget) ww; int mouse_p; KeyWidget key = parse_key_action_args ("UnhighlightKey", event, argv, *argc, widget, &mouse_p); if (! key) return; if (mouse_p) mouse_dehighlight_key (key); else dehighlight_key (key); } void #ifdef __STDC__ toggle_key_action (Widget ww, XEvent *event, String *argv, Cardinal *argc) #else /* ! __STDC__ */ toggle_key_action (ww, event, argv, argc) Widget ww; XEvent *event; String *argv; Cardinal *argc; #endif /* ! __STDC__ */ { KeyboardWidget widget = (KeyboardWidget) ww; int mouse_p; KeyWidget key = parse_key_action_args ("ToggleKey", event, argv, *argc, widget, &mouse_p); if (! key) return; if (mouse_p) { if (key->key.mouse_highlighted) mouse_dehighlight_key (key); else mouse_highlight_key (key); } else { if (key->key.key_highlighted) dehighlight_key (key); else highlight_key (key); } } void #ifdef __STDC__ simulate_KeyPress_action (Widget ww, XEvent *event, String *argv, Cardinal *argc) #else /* ! __STDC__ */ simulate_KeyPress_action (ww, event, argv, argc) Widget ww; XEvent *event; String *argv; Cardinal *argc; #endif /* ! __STDC__ */ { KeyboardWidget widget = (KeyboardWidget) ww; KeyWidget key = parse_key_action_args ("SimulateKeyPress", event, argv, *argc, widget, 0); if (key) simulate_key_event (key, 1); } void #ifdef __STDC__ simulate_KeyRelease_action (Widget ww, XEvent *event, String *argv, Cardinal *argc) #else /* ! __STDC__ */ simulate_KeyRelease_action (ww, event, argv, argc) Widget ww; XEvent *event; String *argv; Cardinal *argc; #endif /* ! __STDC__ */ { KeyboardWidget widget = (KeyboardWidget) ww; KeyWidget key = parse_key_action_args ("SimulateKeyRelease", event, argv, *argc, widget, 0); if (key) simulate_key_event (key, 0); } void #ifdef __STDC__ describe_key_action (Widget ww, XEvent *event, String *argv, Cardinal *argc) #else /* ! __STDC__ */ describe_key_action (ww, event, argv, argc) Widget ww; XEvent *event; String *argv; Cardinal *argc; #endif /* ! __STDC__ */ { KeyboardWidget widget = (KeyboardWidget) ww; KeyWidget key = parse_key_action_args ("DescribeKey", event, argv, *argc, widget, 0); if (! key) return; /* If the event invoking this is a KeyPress or KeyRelease, and the key in question is a modifier key, don't do the optimization of not redisplaying because we're already displaying that key. This is so that the "DescribeKey(displayed)" action can be bound to KeyDown and KeyUp, and will change the display when modifier keys are pressed and released. */ if ((event->xany.type == KeyPress || event->xany.type == KeyRelease) && (widget->keyboard.modifier_vector [event->xkey.keycode / 8] & (1 << (event->xkey.keycode % 8)))) widget->keyboard.documented_key = 0; if (key != widget->keyboard.documented_key) { describe_key (key); widget->keyboard.documented_key = key; } } void #ifdef __STDC__ track_key_action (Widget ww, XEvent *event, String *argv, Cardinal *argc) #else /* ! __STDC__ */ track_key_action (ww, event, argv, argc) Widget ww; XEvent *event; String *argv; Cardinal *argc; #endif /* ! __STDC__ */ { KeyboardWidget widget = (KeyboardWidget) ww; KeyWidget key = parse_key_action_args ("TrackKey", event, argv, *argc, widget, 0); if (!key) return; if (event->xany.type != ButtonPress && event->xany.type != ButtonRelease) { fprintf (stderr, "%s: TrackKey action invoked on a non-button event\n", progname); return; } widget->keyboard.tracking_key |= (1 << (event->xbutton.button - 1)); } void #ifdef __STDC__ untrack_key_action (Widget ww, XEvent *event, String *argv, Cardinal *argc) #else /* ! __STDC__ */ untrack_key_action (ww, event, argv, argc) Widget ww; XEvent *event; String *argv; Cardinal *argc; #endif /* ! __STDC__ */ { KeyboardWidget widget = (KeyboardWidget) ww; parse_key_action_args ("UntrackKey", event, argv, *argc, widget, 0); if (event->xany.type != ButtonPress && event->xany.type != ButtonRelease) { fprintf (stderr, "%s: UntrackKey action invoked on a non-button event\n", progname); return; } /* widget->keyboard.tracking_key &= ~(1 << (event->xbutton.button - 1)); */ widget->keyboard.tracking_key = 0; } void #ifdef __STDC__ key_menu_pre_popup_hook (Widget menu, XtPointer client_data, XtPointer call_data) #else /* ! __STDC__ */ key_menu_pre_popup_hook (menu, client_data, call_data) Widget menu; XtPointer client_data, call_data; #endif /* ! __STDC__ */ { KeyboardWidget widget = (KeyboardWidget) client_data; KeyWidget key = widget->keyboard.key_under_mouse; Arg av[10]; int ac = 0; char buf1 [255]; /* so that the "!=" test in SimpleMenu succeeds... */ char buf2 [255]; static int toggle = 0; char *b = (toggle ? buf1 : buf2); message (widget, ""); /* clear the message area */ if (key) { toggle = !toggle; sprintf (b, " Key %s (0x%02X) ", key->key.key_name, key->key.keycode); XtSetArg (av[ac], XtNlabel, b); ac++; } else XtSetArg (av[ac], XtNlabel, "-- No Key --"), ac++; XtSetValues (menu, av, ac); sensitize_menu (widget, menu, (key ? True : False)); } /* This is called before every action is invoked. It does two things: it keeps the variable key_under_mouse up to date, and, if in TrackKey mode, it simulates ButtonPress and ButtonRelease events when the mouse moves from one key to another. */ void #ifdef __STDC__ keyboard_track_motion_hook (Widget action_widget, XtPointer client_data, String action_name, XEvent *event, String *ac, Cardinal *av) #else /* ! __STDC__ */ keyboard_track_motion_hook (action_widget, client_data, action_name, event, ac, av) Widget action_widget; XtPointer client_data; String action_name; XEvent *event; String *ac; Cardinal *av; #endif /* ! __STDC__ */ { if (action_widget != (Widget) client_data) /* not the KeyboardWidget */ return; if (event->xany.type != MotionNotify) return; { KeyboardWidget widget = (KeyboardWidget) action_widget; Display *dpy = XtDisplay (widget); KeyWidget last_key_under_mouse = widget->keyboard.key_under_mouse; Window root, child; int root_x, root_y, x, y; unsigned int mask; /* This call to XQueryPointer is just to tell the server that it's ok to start sending motion events again. When MotionHintMask is used, we only get one MotionNotify event until something interesting happens again. */ XQueryPointer (dpy, XtWindow (widget), &root, &child, &root_x, &root_y, &x, &y, &mask); widget->keyboard.key_under_mouse = window_to_key (dpy, child); if (widget->keyboard.tracking_key && widget->keyboard.key_under_mouse && widget->keyboard.key_under_mouse != last_key_under_mouse && !widget->keyboard.key_under_mouse->key.modifier_bits) /* If we're in tracking-mode and the mouse has entered a key that it wasn't within before, then simulate a ButtonUp event on the key the mouse was last over, and then simulate a ButtonDown event on the key the mouse is over now. But don't do that if the key the mouse is over now is a modifier key, because that breaks the "ifmod" arguments to actions. We simulate these events so that the correct sets of actions get invoked. Remember that the user may have changed the actions. */ { XEvent sim_event; /* Put back a ButtonDown event for the current key first. */ sim_event.xany.type = ButtonPress; sim_event.xbutton.send_event = 1; sim_event.xbutton.display = dpy; sim_event.xbutton.window = XtWindow (widget); /* the KeyboardWidget */ sim_event.xbutton.root = event->xmotion.root; sim_event.xbutton.subwindow = (widget->keyboard.key_under_mouse ? XtWindow (widget->keyboard.key_under_mouse) : 0); sim_event.xbutton.time = event->xmotion.time; sim_event.xbutton.x = event->xmotion.x; sim_event.xbutton.y = event->xmotion.y; sim_event.xbutton.x_root = event->xmotion.x_root; sim_event.xbutton.y_root = event->xmotion.y_root; sim_event.xbutton.state = event->xmotion.state; sim_event.xbutton.button = widget->keyboard.tracking_key; sim_event.xbutton.same_screen = 1; XPutBackEvent (dpy, &sim_event); /* Now put back a ButtonUp event for the previous key. We do it in this order because we're pushing on the front. */ sim_event.xany.type = ButtonRelease; sim_event.xbutton.subwindow = (last_key_under_mouse ? XtWindow (last_key_under_mouse) : 0); sim_event.xbutton.x = (last_key_under_mouse ? last_key_under_mouse->core.x : 0); sim_event.xbutton.y = (last_key_under_mouse ? last_key_under_mouse->core.y : 0); sim_event.xbutton.x_root = -1; /* This is hard, blow it off. */ sim_event.xbutton.y_root = -1; XPutBackEvent (dpy, &sim_event); } } } static unsigned long simulated_modifier_state = 0; static unsigned long real_modifier_state = 0; #define key_highlighted_p(KEY) \ (((KEY)->key.mouse_highlighted > 0) || ((KEY)->key.key_highlighted > 0)) static void #ifdef __STDC__ mouse_highlight_key (KeyWidget widget) #else /* ! __STDC__ */ mouse_highlight_key (widget) KeyWidget widget; #endif /* ! __STDC__ */ { KeyboardWidget keyboard = (KeyboardWidget) widget->core.parent; if (!key_highlighted_p (widget)) { KeyHighlight (widget); #if 0 printf (" simulated: 0x%02x | 0x%02x = 0x%02x\n", simulated_modifier_state, widget->key.modifier_bits, simulated_modifier_state | widget->key.modifier_bits); #endif simulated_modifier_state |= widget->key.modifier_bits; widget->key.mouse_highlighted++; keyboard->keyboard.mouse_highlighted_key = widget; } } static void #ifdef __STDC__ mouse_dehighlight_key (KeyWidget widget) #else /* ! __STDC__ */ mouse_dehighlight_key (widget) KeyWidget widget; #endif /* ! __STDC__ */ { KeyboardWidget keyboard = (KeyboardWidget) widget->core.parent; widget->key.mouse_highlighted--; if (key_highlighted_p (widget)) return; if (widget->key.mouse_highlighted < 0) { printf ("%s: ERROR: more ButtonUps than ButtonDowns on \"%s\"\n", progname, widget->key.key_name); widget->key.mouse_highlighted = 0; } KeyDehighlight (widget); keyboard->keyboard.mouse_highlighted_key = 0; #if 0 printf (" simulated: 0x%02x & ~0x%02x = 0x%02x\n", simulated_modifier_state, widget->key.modifier_bits, simulated_modifier_state & ~widget->key.modifier_bits); #endif simulated_modifier_state &= ~widget->key.modifier_bits; } static void #ifdef __STDC__ highlight_key (KeyWidget widget) #else /* ! __STDC__ */ highlight_key (widget) KeyWidget widget; #endif /* ! __STDC__ */ { KeyboardWidget keyboard = (KeyboardWidget) widget->core.parent; /* printf ("%s: KeyPress %s\n", progname, widget->key.key_name);*/ if (!key_highlighted_p (widget)) { KeyHighlight (widget); #if 0 printf (" real : 0x%02x | 0x%02x = 0x%02x\n", real_modifier_state, widget->key.modifier_bits, real_modifier_state | widget->key.modifier_bits); #endif real_modifier_state |= widget->key.modifier_bits; } if (widget->key.key_highlighted) /* We really shouldn't ever see more than one KeyPress on a given keycode without an intervening KeyRelease, but we can if the keyboard focus moves away from our window between the KeyPress and KeyRelease. Cope with this by not incrementing the key-press-count to >1. This could also happen if two keys on the keyboard had the same keycode, which would make for a terribly bogus keyboard. */ printf ("%s: ERROR: more KeyPresses than KeyReleases on \"%s\"\n", progname, widget->key.key_name); else widget->key.key_highlighted++; keyboard->keyboard.key_state_vector [widget->key.keycode / 8] |= (1 << (widget->key.keycode % 8)); } static void #ifdef __STDC__ dehighlight_key (KeyWidget widget) #else /* ! __STDC__ */ dehighlight_key (widget) KeyWidget widget; #endif /* ! __STDC__ */ { KeyboardWidget keyboard = (KeyboardWidget) widget->core.parent; widget->key.key_highlighted--; /* printf ("%s: KeyRelease %s\n", progname, widget->key.key_name); */ keyboard->keyboard.key_state_vector [widget->key.keycode / 8] &= ~(1 << (widget->key.keycode % 8)); if (widget->key.key_highlighted < 0) { printf ("%s: ERROR: more KeyReleases than KeyPresses on \"%s\"\n", progname, widget->key.key_name); widget->key.key_highlighted = 0; } if (key_highlighted_p (widget)) return; KeyDehighlight (widget); #if 0 printf (" real : 0x%02x & ~0x%02x = 0x%02x\n", real_modifier_state, widget->key.modifier_bits, real_modifier_state & ~widget->key.modifier_bits); #endif real_modifier_state &= ~widget->key.modifier_bits; } void #ifdef __STDC__ key_to_event (KeyWidget key, XEvent *event, int down_p) #else /* ! __STDC__ */ key_to_event (key, event, down_p) KeyWidget key; XEvent *event; int down_p; #endif /* ! __STDC__ */ { event->xkey.type = down_p ? KeyPress : KeyRelease; event->xkey.display = XtDisplay (key); event->xkey.time = CurrentTime; event->xkey.x = event->xkey.y = 0; event->xkey.x_root = event->xkey.y_root = 0; event->xkey.state = (simulated_modifier_state | real_modifier_state); event->xkey.keycode = key->key.keycode; } static void #ifdef __STDC__ simulate_key_event (KeyWidget widget, int down_p) #else /* ! __STDC__ */ simulate_key_event (widget, down_p) KeyWidget widget; int down_p; #endif /* ! __STDC__ */ { KeyboardWidget keyboard = (KeyboardWidget) widget->core.parent; XEvent event; Window window; int revert_to; if (! widget->key.keycode) return; XGetInputFocus (XtDisplay (widget), &window, &revert_to); /* If this widget (or any parent of it) has the keyboard focus, then send the events to the window the user has picked. */ if (window == PointerRoot) window = keyboard->keyboard.target_window; else { Widget parent; for (parent = (Widget) widget; parent; parent = XtParent (parent)) if (XtWindow (parent) == window) { window = keyboard->keyboard.target_window; break; } } if (!window) return; key_to_event (widget, &event, down_p); event.xkey.window = window; #ifdef HAVE_XTRAP if (keyboard->keyboard.trap_data) xkeycaps_xtrap_simulate_event (keyboard, &event); else #endif /* HAVE_XTRAP */ if (! XSendEvent (XtDisplay (widget), window, True, down_p ? KeyPressMask : KeyReleaseMask, &event)) { fprintf (stderr, "%s: Couldn't simulate a keypress: ", progname); if (window == None) fprintf (stderr, "No focus window\n"); else fprintf (stderr, "focus window doesn't accept XSendEvent input\n"); } XSync (XtDisplay (widget), 0); if (XSendEvent_BadWindow && keyboard->keyboard.target_window == XSendEvent_BadWindow) { char buf [255]; sprintf (buf, "Window 0x%X seems to have gone away. Keyboard focus cleared.", (int) XSendEvent_BadWindow); message (keyboard, buf); XBell (XtDisplay ((Widget) widget), 0); XSendEvent_BadWindow = 0; keyboard->keyboard.target_window = 0; } } int mappingNotify_event_expected = 0; static Bool #ifdef __STDC__ mapping_event_p (Display *dpy, XEvent *event, char *closure) #else /* ! __STDC__ */ mapping_event_p (dpy, event, closure) Display *dpy; XEvent *event; char *closure; #endif /* ! __STDC__ */ { if (event->xany.type == MappingNotify) *closure = 1; return False; } void #ifdef __STDC__ keyboard_handle_mapping_notify (Widget widget, XtPointer client_data, XEvent *event, Boolean *cont) #else /* ! __STDC__ */ keyboard_handle_mapping_notify (widget, client_data, event, cont) Widget widget; XtPointer client_data; XEvent *event; Boolean *cont; #endif /* ! __STDC__ */ { char events_queued_p = 0; XRefreshKeyboardMapping (&event->xmapping); init_modifier_mapping ((KeyboardWidget) widget); XSync (XtDisplay (widget), 0); if (XCheckIfEvent (XtDisplay (widget), event, mapping_event_p, &events_queued_p)) exit (-69); /* can't happen. */ if (!events_queued_p) /* refresh, in case the documented key has been modified */ { if (((KeyboardWidget) widget)->keyboard.documented_key) describe_key (((KeyboardWidget) widget)->keyboard.documented_key); if (! mappingNotify_event_expected) message ((KeyboardWidget) widget, "MappingNotify event received; keyboard state refreshed."); else mappingNotify_event_expected = 0; } } void #ifdef __STDC__ keyboard_handle_keymap_notify (Widget w, XtPointer client_data, XEvent *event, Boolean *cont) #else /* ! __STDC__ */ keyboard_handle_keymap_notify (w, client_data, event, cont) Widget w; XtPointer client_data; XEvent *event; Boolean *cont; #endif /* ! __STDC__ */ { /* To prevent getting out of sync with the real state of the keyboard during those unfortunate moments when we don't have the keyboard focus, we select KeymapNotify, which gives us the same data as XQueryKeymap would, but sends it just after any FocusIn or EnterNotify event would have been generated. Unfortunately, this means that this event will be generated every time the cursor move from inside of a key to the top- level keyboard window (since a particular kind of EnterNotify event would be generated there.) This shouldn't be too big a deal: it's just another 40 or so bytes, and a call to bcmp. */ KeyboardWidget widget = (KeyboardWidget) w; int i, j; #ifdef HAVE_XTRAP if (((KeyboardWidget) widget)->keyboard.trap_data) return; /* if we're in XTrap mode, this function is redundant */ #endif if (widget->core.being_destroyed) return; if (! memcmp (event->xkeymap.key_vector, ((KeyboardWidget) widget)->keyboard.key_state_vector, 32)) return; /* Nothing's changed, bug out. */ for (i = 0; i < widget->keyboard.nrows; i++) for (j = 0; j < widget->keyboard.rows[i].nkeys; j++) { KeyWidget key = widget->keyboard.rows[i].keys[j]; int down = ((event->xkeymap.key_vector [key->key.keycode / 8]) & (1 << (key->key.keycode % 8))); if (! key->key.keycode) continue; if (down && !key->key.key_highlighted) /* Down now, wasn't before */ highlight_key (key); else if (!down && key->key.key_highlighted) /* Not down now, was before */ dehighlight_key (key); } #if 0 /* This sometimes fails because the event contains random noise in the bits which correspond to a keycode for which there is no physical key. Presumably this is because X events are padded with uninitialized data. */ if (bcmp (event->xkeymap.key_vector, kbd->key_state_vector, 32)) fprintf (stderr, "%s: KeymapNotify handling is way broken...\n", progname); #endif } KeyWidget #ifdef __STDC__ window_to_key (Display *dpy, Window window) #else /* ! __STDC__ */ window_to_key (dpy, window) Display *dpy; Window window; #endif /* ! __STDC__ */ { KeyWidget key = (KeyWidget) XtWindowToWidget (dpy, window); if (! key) return 0; if (! XtIsSubclass ((Widget) key, keyWidgetClass)) return 0; return key; } KeyWidget #ifdef __STDC__ keycode_to_key (KeyboardWidget keyboard, KeyCode code) #else /* ! __STDC__ */ keycode_to_key (keyboard, code) KeyboardWidget keyboard; KeyCode code; #endif /* ! __STDC__ */ { int i, j; if (! code) return 0; for (i = 0; i < keyboard->keyboard.nrows; i++) for (j = 0; j < keyboard->keyboard.rows[i].nkeys; j++) if (keyboard->keyboard.rows[i].keys[j]->key.keycode == code) return keyboard->keyboard.rows[i].keys[j]; return 0; } static void #ifdef __STDC__ clear_modifier_flags (KeyboardWidget widget) #else /* ! __STDC__ */ clear_modifier_flags (widget) KeyboardWidget widget; #endif /* ! __STDC__ */ { int i, j; memset (widget->keyboard.modifier_vector, 0, 32); for (i = 0; i < widget->keyboard.nrows; i++) for (j = 0; j < widget->keyboard.rows[i].nkeys; j++) if (widget->keyboard.rows[i].keys[j]) widget->keyboard.rows[i].keys[j]->key.modifier_bits = 0; } void #ifdef __STDC__ init_modifier_mapping (KeyboardWidget widget) #else /* ! __STDC__ */ init_modifier_mapping (widget) KeyboardWidget widget; #endif /* ! __STDC__ */ { Display *dpy = XtDisplay (widget); XModifierKeymap *modifier_map; int modifier_index, modifier_key, i, j; XKeyboardState kbd_state; /* XKeyboardControl kbd_control;*/ int mkpm; clear_modifier_flags (widget); modifier_map = XGetModifierMapping (dpy); /* Look at the defined modifier keys, and annotate our key structures with which modifier bits they set. This will be done each time the user runs xmodmap as well. */ mkpm = modifier_map->max_keypermod; for (modifier_index = 0; modifier_index < 8; modifier_index++) for (modifier_key = 0; modifier_key < mkpm; modifier_key++) { int index = modifier_index * mkpm + modifier_key; int keycode = modifier_map->modifiermap [index]; KeyWidget key = keycode_to_key (widget, keycode); if (! key) continue; key->key.modifier_bits |= (1 << modifier_index); widget->keyboard.modifier_vector [keycode / 8] |= (1 << (keycode % 8)); } XFreeModifiermap (modifier_map); # if 0 kbd_control.auto_repeat_mode = 0; XChangeKeyboardControl (dpy, KBAutoRepeatMode, &kbd_control); # endif XGetKeyboardControl (dpy, &kbd_state); for (i = 0; i < widget->keyboard.nrows; i++) for (j = 0; j < widget->keyboard.rows[i].nkeys; j++) { KeyWidget key = widget->keyboard.rows[i].keys[j]; if (key) key->key.auto_repeat_p = !!((kbd_state.auto_repeats [key->key.keycode / 8]) & (1 << (key->key.keycode % 8))); } }