X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=registryd%2Fdeviceeventcontroller.c;h=66cc323d3b9296f427f4a9b5875e36ad5659e3eb;hb=59568fcca2ea754f1ebb7133f29e1e0908e2af4a;hp=07fd0598636f72d6181b552ff78ed677365131da;hpb=dd8fbc44011aa6002bc70f1b7dbb8b15023f9f81;p=platform%2Fcore%2Fuifw%2Fat-spi2-atk.git diff --git a/registryd/deviceeventcontroller.c b/registryd/deviceeventcontroller.c index 07fd059..66cc323 100644 --- a/registryd/deviceeventcontroller.c +++ b/registryd/deviceeventcontroller.c @@ -39,6 +39,7 @@ #include #include #define XK_MISCELLANY +#define XK_LATIN1 #include #ifdef HAVE_XEVIE @@ -55,6 +56,16 @@ #include "../libspi/spi-private.h" #include "deviceeventcontroller.h" +KeySym ucs2keysym (long ucs); +long keysym2ucs(KeySym keysym); + +#define CHECK_RELEASE_DELAY 20 +#define BIT(c, x) (c[x/8]&(1<<(x%8))) +static guint check_release_handler = 0; +static Accessibility_DeviceEvent pressed_event; +static SpiDEController *saved_controller; +static void wait_for_release_event (XEvent *event, SpiDEController *controller); + /* Our parent Gtk object type */ #define PARENT_TYPE BONOBO_TYPE_OBJECT @@ -115,6 +126,9 @@ typedef struct { unsigned int xkb_latch_mask; unsigned int pending_xkb_mod_relatch_mask; XkbDescPtr xkb_desc; + KeyCode reserved_keycode; + KeySym reserved_keysym; + guint reserved_reset_timeout; } DEControllerPrivateData; static void spi_controller_register_with_devices (SpiDEController *controller); @@ -192,11 +206,76 @@ keysym_mod_mask (KeySym keysym, KeyCode keycode) return retval; } +static gboolean +spi_dec_replace_map_keysym (DEControllerPrivateData *priv, KeyCode keycode, KeySym keysym) +{ +#ifdef HAVE_XKB + Display *dpy = spi_get_display (); + XkbDescPtr desc; + if (!(desc = XkbGetMap (dpy, XkbAllMapComponentsMask, XkbUseCoreKbd))) + { + fprintf (stderr, "ERROR getting map\n"); + } + XFlush (dpy); + XSync (dpy, False); + if (desc && desc->map) + { + gint offset = desc->map->key_sym_map[keycode].offset; + desc->map->syms[offset] = keysym; + } + else + { + fprintf (stderr, "Error changing key map: empty server structure\n"); + } + XkbSetMap (dpy, XkbAllMapComponentsMask, desc); + /** + * FIXME: the use of XkbChangeMap, and the reuse of the priv->xkb_desc structure, + * would be far preferable. + * HOWEVER it does not seem to work using XFree 4.3. + **/ + /* XkbChangeMap (dpy, priv->xkb_desc, priv->changes); */ + XFlush (dpy); + XSync (dpy, False); + XkbFreeKeyboard (desc, 0, TRUE); + + return TRUE; +#else + return FALSE; +#endif +} + +static gboolean +spi_dec_reset_reserved (gpointer data) +{ + DEControllerPrivateData *priv = data; + spi_dec_replace_map_keysym (priv, priv->reserved_keycode, priv->reserved_keysym); + priv->reserved_reset_timeout = 0; + return FALSE; +} + static KeyCode -keycode_for_keysym (long keysym, unsigned int *modmask) +keycode_for_keysym (SpiDEController *controller, long keysym, unsigned int *modmask) { KeyCode keycode = 0; keycode = XKeysymToKeycode (spi_get_display (), (KeySym) keysym); + if (!keycode) + { + DEControllerPrivateData *priv = (DEControllerPrivateData *) + g_object_get_qdata (G_OBJECT (controller), spi_dec_private_quark); + /* if there's no keycode available, fix it */ + if (spi_dec_replace_map_keysym (priv, priv->reserved_keycode, keysym)) + { + keycode = priv->reserved_keycode; + /* + * queue a timer to restore the old keycode. Ugly, but required + * due to races / asynchronous X delivery. + * Long-term fix is to extend the X keymap here instead of replace entries. + */ + priv->reserved_reset_timeout = g_timeout_add (500, spi_dec_reset_reserved, priv); + } + *modmask = 0; + return keycode; + } if (modmask) *modmask = keysym_mod_mask (keysym, keycode); return keycode; @@ -366,7 +445,10 @@ spi_dec_button_update_and_emit (SpiDEController *controller, e.source = BONOBO_OBJREF (controller->registry->desktop); e.detail1 = last_mouse_pos->x; e.detail2 = last_mouse_pos->y; - spi_init_any_nil (&e.any_data); + spi_init_any_nil (&e.any_data, + spi_accessible_new_return (atk_get_root (), FALSE, NULL), + Accessibility_ROLE_UNKNOWN, + ""); CORBA_exception_init (&ev); if (!is_consumed) { @@ -376,6 +458,8 @@ spi_dec_button_update_and_emit (SpiDEController *controller, } else spi_dec_set_unlatch_pending (controller, mask_return); + + CORBA_free (e.any_data._value); } return TRUE; } @@ -391,6 +475,7 @@ spi_dec_mouse_check (SpiDEController *controller, int *x, int *y, gboolean *moved) { Accessibility_Event e; + Accessibility_EventDetails *details; CORBA_Environment ev; int win_x_return,win_y_return; unsigned int mask_return; @@ -420,22 +505,32 @@ spi_dec_mouse_check (SpiDEController *controller, e.source = BONOBO_OBJREF (controller->registry->desktop); e.detail1 = *x; e.detail2 = *y; - spi_init_any_nil (&e.any_data); + spi_init_any_nil (&e.any_data, + spi_accessible_new_return (atk_get_root (), FALSE, NULL), + Accessibility_ROLE_UNKNOWN, + ""); CORBA_exception_init (&ev); Accessibility_Registry_notifyEvent (BONOBO_OBJREF (controller->registry), &e, &ev); + details = e.any_data._value; + CORBA_free (details); e.type = "mouse:rel"; e.source = BONOBO_OBJREF (controller->registry->desktop); e.detail1 = *x - last_mouse_pos->x; e.detail2 = *y - last_mouse_pos->y; - spi_init_any_nil (&e.any_data); + spi_init_any_nil (&e.any_data, + spi_accessible_new_return (atk_get_root (), FALSE, NULL), + Accessibility_ROLE_UNKNOWN, + ""); CORBA_exception_init (&ev); last_mouse_pos->x = *x; last_mouse_pos->y = *y; Accessibility_Registry_notifyEvent (BONOBO_OBJREF (controller->registry), &e, &ev); + details = e.any_data._value; + CORBA_free (details); *moved = True; } else @@ -468,11 +563,15 @@ spi_dec_emit_modifier_event (SpiDEController *controller, guint prev_mask, e.source = BONOBO_OBJREF (controller->registry->desktop); e.detail1 = prev_mask & key_modifier_mask; e.detail2 = current_mask & key_modifier_mask; - spi_init_any_nil (&e.any_data); + spi_init_any_nil (&e.any_data, + spi_accessible_new_return (atk_get_root (), FALSE, NULL), + Accessibility_ROLE_UNKNOWN, + ""); CORBA_exception_init (&ev); Accessibility_Registry_notifyEvent (BONOBO_OBJREF (controller->registry), &e, &ev); + CORBA_free (e.any_data._value); } static gboolean @@ -537,9 +636,12 @@ spi_dec_ungrab_mouse (gpointer data) static void spi_dec_init_mouse_listener (SpiRegistry *registry) { +#ifdef GRAB_BUTTON Display *display = spi_get_display (); +#endif g_timeout_add (100, spi_dec_poll_mouse_idle, registry); +#ifdef GRAB_BUTTON if (display) { if (XGrabButton (display, AnyButton, AnyModifier, @@ -556,22 +658,31 @@ spi_dec_init_mouse_listener (SpiRegistry *registry) fprintf (stderr, "mouse buttons grabbed\n"); #endif } +#endif } /** * Eventually we can use this to make the marshalling of mask types * more sane, but for now we just use this to detect - * the use of 'virtual' masks such as Mumlock and convert them to + * the use of 'virtual' masks such as numlock and convert them to * system-specific mask values (i.e. ModMask). * **/ static Accessibility_ControllerEventMask spi_dec_translate_mask (Accessibility_ControllerEventMask mask) { - if (mask == SPI_KEYMASK_NUMLOCK) { - mask = _numlock_physical_mask; - } - return mask; + Accessibility_ControllerEventMask tmp_mask; + gboolean has_numlock; + + has_numlock = (mask & SPI_KEYMASK_NUMLOCK); + tmp_mask = mask; + if (has_numlock) + { + tmp_mask = mask ^ SPI_KEYMASK_NUMLOCK; + tmp_mask |= _numlock_physical_mask; + } + + return tmp_mask; } static DEControllerKeyListener * @@ -830,8 +941,9 @@ spi_controller_notify_mouselisteners (SpiDEController *controlle GSList *notify = NULL, *l2; GList **listeners = &controller->mouse_listeners; gboolean is_consumed; +#ifdef SPI_KEYEVENT_DEBUG gboolean found = FALSE; - +#endif if (!listeners) { return FALSE; @@ -850,7 +962,9 @@ spi_controller_notify_mouselisteners (SpiDEController *controlle /* we clone (don't dup) the listener, to avoid refcount inc. */ notify = g_slist_prepend (notify, spi_listener_clone (listener, ev)); +#ifdef SPI_KEYEVENT_DEBUG found = TRUE; +#endif } } } @@ -968,12 +1082,16 @@ spi_device_event_controller_forward_mouse_event (SpiDEController *controller, e.source = BONOBO_OBJREF (controller->registry->desktop); e.detail1 = last_mouse_pos->x; e.detail2 = last_mouse_pos->y; - spi_init_any_nil (&e.any_data); + spi_init_any_nil (&e.any_data, + spi_accessible_new_return (atk_get_root (), FALSE, NULL), + Accessibility_ROLE_UNKNOWN, + ""); CORBA_exception_init (&ev); Accessibility_Registry_notifyEvent (BONOBO_OBJREF (controller->registry), &e, &ev); + CORBA_free (e.any_data._value); } xkb_mod_unlatch_occurred = (xevent->type == ButtonPress || @@ -1005,13 +1123,39 @@ global_filter_fn (GdkXEvent *gdk_xevent, GdkEvent *event, gpointer data) { if (controller->xevie_display == NULL) { - gboolean is_consumed = + gboolean is_consumed; + + is_consumed = spi_device_event_controller_forward_key_event (controller, xevent); if (is_consumed) - XAllowEvents (spi_get_display (), AsyncKeyboard, CurrentTime); + { + int n_events; + int i; + XEvent next_event; + n_events = XPending (display); + +#ifdef SPI_KEYEVENT_DEBUG + g_print ("Number of events pending: %d\n", n_events); +#endif + for (i = 0; i < n_events; i++) + { + XNextEvent (display, &next_event); + if (next_event.type != KeyPress && + next_event.type != KeyRelease) + g_warning ("Unexpected event type %d in queue", next_event.type); + } + + XAllowEvents (display, AsyncKeyboard, CurrentTime); + if (n_events) + XUngrabKeyboard (display, CurrentTime); + } else - XAllowEvents (spi_get_display (), ReplayKeyboard, CurrentTime); + { + if (xevent->type == KeyPress) + wait_for_release_event (xevent, controller); + XAllowEvents (display, ReplayKeyboard, CurrentTime); + } } return GDK_FILTER_CONTINUE; @@ -1024,7 +1168,7 @@ global_filter_fn (GdkXEvent *gdk_xevent, GdkEvent *event, gpointer data) { XkbAnyEvent * xkb_ev = (XkbAnyEvent *) xevent; /* ugly but probably necessary...*/ - XSynchronize (spi_get_display (), TRUE); + XSynchronize (display, TRUE); if (xkb_ev->xkb_type == XkbStateNotify) { @@ -1086,7 +1230,7 @@ global_filter_fn (GdkXEvent *gdk_xevent, GdkEvent *event, gpointer data) } else DBG (2, g_warning ("XKB event %d\n", xkb_ev->xkb_type)); - XSynchronize (spi_get_display (), FALSE); + XSynchronize (display, FALSE); } return GDK_FILTER_CONTINUE; @@ -1125,12 +1269,56 @@ spi_controller_register_with_devices (SpiDEController *controller) &priv->xkb_base_error_code, NULL, NULL); if (priv->have_xkb) { - priv->xkb_desc = XkbGetMap (spi_get_display (), 0, XkbUseCoreKbd); + gint i; + guint64 reserved = 0; + priv->xkb_desc = XkbGetMap (spi_get_display (), XkbKeySymsMask, XkbUseCoreKbd); XkbSelectEvents (spi_get_display (), XkbUseCoreKbd, XkbStateNotifyMask, XkbStateNotifyMask); _numlock_physical_mask = XkbKeysymToModifiers (spi_get_display (), XK_Num_Lock); + for (i = priv->xkb_desc->max_key_code; i >= priv->xkb_desc->min_key_code; --i) + { + if (priv->xkb_desc->map->key_sym_map[i].kt_index[0] == XkbOneLevelIndex) + { + if (XKeycodeToKeysym (spi_get_display (), i, 0) != 0) + { + /* don't use this one if there's a grab client! */ + gdk_error_trap_push (); + XGrabKey (spi_get_display (), i, 0, + gdk_x11_get_default_root_xwindow (), + TRUE, + GrabModeSync, GrabModeSync); + XSync (spi_get_display (), TRUE); + XUngrabKey (spi_get_display (), i, 0, + gdk_x11_get_default_root_xwindow ()); + if (!gdk_error_trap_pop ()) + { + reserved = i; + break; + } + } + } + } + if (reserved) + { + priv->reserved_keycode = reserved; + priv->reserved_keysym = XKeycodeToKeysym (spi_get_display (), reserved, 0); + } + else + { + priv->reserved_keycode = XKeysymToKeycode (spi_get_display (), XK_numbersign); + priv->reserved_keysym = XK_numbersign; + } +#ifdef SPI_RESERVED_DEBUG + unsigned sym = 0; + sym = XKeycodeToKeysym (spi_get_display (), reserved, 0); + fprintf (stderr, "%x\n", sym); + fprintf (stderr, "setting the reserved keycode to %d (%s)\n", + reserved, + XKeysymToString (XKeycodeToKeysym (spi_get_display (), + reserved, 0))); +#endif } gdk_window_add_filter (NULL, global_filter_fn, controller); @@ -1247,7 +1435,7 @@ spi_key_event_matches_listener (const Accessibility_DeviceEvent *key_event, static gboolean spi_controller_notify_keylisteners (SpiDEController *controller, - const Accessibility_DeviceEvent *key_event, + Accessibility_DeviceEvent *key_event, CORBA_boolean is_system_global, CORBA_Environment *ev) { @@ -1261,6 +1449,10 @@ spi_controller_notify_keylisteners (SpiDEController *controller, return FALSE; } + /* set the NUMLOCK event mask bit if appropriate: see bug #143702 */ + if (key_event->modifiers & _numlock_physical_mask) + key_event->modifiers |= SPI_KEYMASK_NUMLOCK; + for (l = *key_listeners; l; l = l->next) { DEControllerKeyListener *key_listener = l->data; @@ -1291,7 +1483,8 @@ spi_controller_notify_keylisteners (SpiDEController *controller, DEControllerKeyListener *key_listener = l2->data; Accessibility_DeviceEventListener ls = key_listener->listener.object; - is_consumed = Accessibility_DeviceEventListener_notifyEvent (ls, key_event, ev); + is_consumed = Accessibility_DeviceEventListener_notifyEvent (ls, key_event, ev) && + key_listener->mode->preemptive; if (BONOBO_EX (ev)) { @@ -1320,7 +1513,7 @@ spi_controller_notify_keylisteners (SpiDEController *controller, } static gboolean -spi_clear_error_state () +spi_clear_error_state (void) { gboolean retval = spi_error_code != 0; spi_error_code = 0; @@ -1333,7 +1526,7 @@ spi_keystroke_from_x_key_event (XKeyEvent *x_key_event) Accessibility_DeviceEvent key_event; KeySym keysym; const int cbuf_bytes = 20; - char cbuf [cbuf_bytes+1]; + char cbuf [21]; int nbytes; nbytes = XLookupString (x_key_event, cbuf, cbuf_bytes, &keysym, NULL); @@ -1432,8 +1625,8 @@ spi_keystroke_from_x_key_event (XKeyEvent *x_key_event) gunichar c; cbuf[nbytes] = '\0'; /* OK since length is cbuf_bytes+1 */ key_event.event_string = CORBA_string_dup (cbuf); - c = g_utf8_get_char_validated (cbuf, nbytes); - if ((c > 0) && g_unichar_isprint (c)) + c = keysym2ucs (keysym); + if (c > 0 && !g_unichar_iscntrl (c)) { key_event.is_text = CORBA_TRUE; /* incorrect for some composed chars? */ @@ -1473,6 +1666,7 @@ spi_keystroke_from_x_key_event (XKeyEvent *x_key_event) (x_key_event->state & Mod1Mask)?"Alt-":"", ((x_key_event->state & ShiftMask)^(x_key_event->state & LockMask))? g_ascii_toupper (keysym) : g_ascii_tolower (keysym)); + fprintf (stderr, "serial: %x Time: %x\n", x_key_event->serial, x_key_event->time); #endif /* SPI_DEBUG */ return key_event; } @@ -1483,6 +1677,7 @@ spi_controller_update_key_grabs (SpiDEController *controller, { GList *l, *next; gboolean update_failed = FALSE; + KeyCode keycode; g_return_val_if_fail (controller != NULL, FALSE); @@ -1495,6 +1690,8 @@ spi_controller_update_key_grabs (SpiDEController *controller, * * ControlMask grabs are broken, must be in use already */ + if (recv) + keycode = keycode_for_keysym (controller, recv->id, NULL); for (l = controller->keygrabs_list; l; l = next) { gboolean do_remove; @@ -1505,7 +1702,7 @@ spi_controller_update_key_grabs (SpiDEController *controller, re_issue_grab = recv && (recv->modifiers & grab_mask->mod_mask) && - (grab_mask->key_val == keycode_for_keysym (recv->id, NULL)); + (grab_mask->key_val == keycode); #ifdef SPI_DEBUG fprintf (stderr, "mask=%lx %lx (%c%c) %s\n", @@ -1875,6 +2072,7 @@ dec_synth_keycode_press (SpiDEController *controller, } XTestFakeKeyEvent (spi_get_display (), keycode, True, time); priv->last_press_keycode = keycode; + XFlush (spi_get_display ()); XSync (spi_get_display (), False); gettimeofday (&priv->last_press_time, NULL); return TRUE; @@ -1946,45 +2144,7 @@ dec_unlock_modifiers (SpiDEController *controller, unsigned modifiers) static KeySym dec_keysym_for_unichar (SpiDEController *controller, gunichar unichar) { - /* TODO: table lookups within a range, for various code pages! */ - KeySym keysym = NoSymbol; - - if (unichar >= 0x20 && unichar < 0x7f) { /* Basic Latin/ASCII */ - keysym = (KeySym) unichar; - } - else if (unichar >= 0xa0 && unichar <= 0xff) { /* Latin 1 extensions */ - keysym = (KeySym) unichar; - } - else if (unichar >= 0x100 && unichar <= 0x233) { /* unfortunately the mapping gets nasty for Latin-2 and 3... help! */ - keysym = NoSymbol; - } - else if (unichar >= 0x7c1 && unichar <= 0x3a1) { /* let's try Greek anyway... */ - keysym = (KeySym) (0x391 + (unichar - 0x7c1)); - } - else if (unichar >= 0x3a3 && unichar <= 0x3a9) { /* let's try Greek anyway... */ - keysym = (KeySym) (0x7d2 + (unichar - 0x3a3)); - } - else if (unichar >= 0x3b1 && unichar <= 0x3c1) { /* let's try Greek anyway... */ - keysym = (KeySym) (0x7e1 + (unichar - 0x3b1)); - } - else if (unichar == 0x3c2) { - keysym = (KeySym) 0x7f3; /* XK_Greek_finalsmallsigma; */ - } - else if (unichar >= 0x3c3 && unichar <= 0x3c9) { /* let's try Greek anyway... */ - keysym = (KeySym) (0x7f2 + (unichar - 0x3c2)); - } - else if (unichar >= 0x5d0 && unichar <= 0x5ea) { /* Hebrew basics */ - /* probably broken :-) */ - keysym = (KeySym) (0xce0 + (unichar - 0x5d0)); - } - else if (unichar >= 0x30a1 && unichar <= 0x30ab) { /* partial katakana support */ - /* TODO: complete! */ - keysym = (KeySym) (0x4b1 + (unichar - 0x30a1)/2); - } - else if (unichar >= 0x20a0 && unichar <= 0x20ac) { /* currency */ - keysym = (KeySym) unichar; /* how convenient ;-) */ - } - return keysym; + return ucs2keysym ((long) unichar); } static gboolean @@ -1993,7 +2153,7 @@ dec_synth_keysym (SpiDEController *controller, KeySym keysym) KeyCode key_synth_code; unsigned int modifiers, synth_mods, lock_mods; - key_synth_code = keycode_for_keysym (keysym, &synth_mods); + key_synth_code = keycode_for_keysym (controller, keysym, &synth_mods); if ((key_synth_code == 0) || (synth_mods == 0xFF)) return FALSE; @@ -2008,6 +2168,7 @@ dec_synth_keysym (SpiDEController *controller, KeySym keysym) } dec_synth_keycode_press (controller, key_synth_code); dec_synth_keycode_release (controller, key_synth_code); + if (synth_mods != modifiers) dec_unlock_modifiers (controller, lock_mods); return TRUE; @@ -2059,6 +2220,7 @@ dec_synth_keystring (SpiDEController *controller, const CORBA_char *keystring) keystring = g_utf8_next_char (keystring); } keysyms[i++] = 0; + XSynchronize (spi_get_display (), TRUE); for (i = 0; keysyms[i]; ++i) { if (!dec_synth_keysym (controller, keysyms[i])) { #ifdef SPI_DEBUG @@ -2069,6 +2231,7 @@ dec_synth_keystring (SpiDEController *controller, const CORBA_char *keystring) break; } } + XSynchronize (spi_get_display (), FALSE); } g_free (keysyms); @@ -2089,7 +2252,7 @@ impl_generate_keyboard_event (PortableServer_Servant servant, { SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (bonobo_object (servant)); - long key_synth_code; + gint err; KeySym keysym; #ifdef SPI_DEBUG @@ -2104,7 +2267,6 @@ impl_generate_keyboard_event (PortableServer_Servant servant, */ gdk_error_trap_push (); - key_synth_code = keycode; switch (synth_type) { @@ -2133,9 +2295,9 @@ impl_generate_keyboard_event (PortableServer_Servant servant, keystring); break; } - if (gdk_error_trap_pop ()) + if ((err = gdk_error_trap_pop ())) { - DBG (-1, g_warning ("Error emitting keystroke")); + DBG (-1, g_warning ("Error [%d] emitting keystroke", err)); } if (synth_type == Accessibility_KEY_SYM) { keysym = keycode; @@ -2228,7 +2390,9 @@ impl_notify_listeners_sync (PortableServer_Servant servant, g_print ("notifylistening listeners synchronously: controller %p, event id %d\n", controller, (int) event->id); #endif - return spi_controller_notify_keylisteners (controller, event, CORBA_FALSE, ev) ? + return spi_controller_notify_keylisteners (controller, + (Accessibility_DeviceEvent *) + event, CORBA_FALSE, ev) ? CORBA_TRUE : CORBA_FALSE; } @@ -2243,7 +2407,8 @@ impl_notify_listeners_async (PortableServer_Servant servant, #ifdef SPI_DEBUG fprintf (stderr, "notifying listeners asynchronously\n"); #endif - spi_controller_notify_keylisteners (controller, event, CORBA_FALSE, ev); + spi_controller_notify_keylisteners (controller, (Accessibility_DeviceEvent *) + event, CORBA_FALSE, ev); } static void @@ -2353,6 +2518,7 @@ spi_device_event_controller_forward_key_event (SpiDEController *controller, { CORBA_Environment ev; Accessibility_DeviceEvent key_event; + gboolean ret; g_assert (event->type == KeyPress || event->type == KeyRelease); @@ -2364,7 +2530,9 @@ spi_device_event_controller_forward_key_event (SpiDEController *controller, spi_controller_update_key_grabs (controller, &key_event); /* relay to listeners, and decide whether to consume it or not */ - return spi_controller_notify_keylisteners (controller, &key_event, CORBA_TRUE, &ev); + ret = spi_controller_notify_keylisteners (controller, &key_event, CORBA_TRUE, &ev); + CORBA_free(key_event.event_string); + return ret; } SpiDEController * @@ -2381,6 +2549,45 @@ spi_device_event_controller_new (SpiRegistry *registry) return retval; } +static gboolean +is_key_released (KeyCode code) +{ + char keys[32]; + int down; + + XQueryKeymap (spi_get_display (), keys); + down = BIT (keys, code); + return (down == 0); +} + +static gboolean +check_release (gpointer data) +{ + gboolean released; + Accessibility_DeviceEvent *event = (Accessibility_DeviceEvent *)data; + KeyCode code = event->hw_code; + CORBA_Environment ev; + + released = is_key_released (code); + + if (released) + { + check_release_handler = 0; + event->type = Accessibility_KEY_RELEASED_EVENT; + ev._major = CORBA_NO_EXCEPTION; + spi_controller_notify_keylisteners (saved_controller, event, CORBA_TRUE, &ev); + } + return (released == 0); +} + +static void wait_for_release_event (XEvent *event, + SpiDEController *controller) +{ + pressed_event = spi_keystroke_from_x_key_event ((XKeyEvent *) event); + saved_controller = controller; + check_release_handler = g_timeout_add (CHECK_RELEASE_DELAY, check_release, &pressed_event); +} + BONOBO_TYPE_FUNC_FULL (SpiDEController, Accessibility_DeviceEventController, PARENT_TYPE,