X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;ds=sidebyside;f=registryd%2Fdeviceeventcontroller.c;h=e9ee33aa2ae20d1f0d75270c154dc6b934649bca;hb=dd8208f64e29554db9dc97b4ff9eb39ebf3de7e6;hp=bf512409a9b136b76926fe5da8e8e2308ca15afe;hpb=ddc97a94fd64425f4778c03060915abfb9160ff8;p=platform%2Fcore%2Fuifw%2Fat-spi2-atk.git diff --git a/registryd/deviceeventcontroller.c b/registryd/deviceeventcontroller.c index bf51240..e9ee33a 100644 --- a/registryd/deviceeventcontroller.c +++ b/registryd/deviceeventcontroller.c @@ -27,7 +27,7 @@ #undef SPI_XKB_DEBUG #undef SPI_DEBUG -#define SPI_KEYEVENT_DEBUG +#undef SPI_KEYEVENT_DEBUG #include #include @@ -39,7 +39,15 @@ #include #include #define XK_MISCELLANY +#define XK_LATIN1 #include + +#ifdef HAVE_XEVIE +#include +#include +#include +#endif /* HAVE_XEVIE */ + #include #include /* TODO: hide dependency (wrap in single porting file) */ #include @@ -48,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 @@ -60,11 +78,12 @@ static unsigned int mouse_mask_state = 0; static unsigned int mouse_button_mask = Button1Mask | Button2Mask | Button3Mask | Button4Mask | Button5Mask; static unsigned int key_modifier_mask = - Mod1Mask | Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask | ShiftMask | LockMask | ControlMask; + Mod1Mask | Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask | ShiftMask | LockMask | ControlMask | SPI_KEYMASK_NUMLOCK; +static unsigned int _numlock_physical_mask = Mod2Mask; /* a guess, will be reset */ static GQuark spi_dec_private_quark = 0; -int (*x_default_error_handler) (Display *display, XErrorEvent *error_event); +static int (*x_default_error_handler) (Display *display, XErrorEvent *error_event); typedef enum { SPI_DEVICE_TYPE_KBD, @@ -107,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); @@ -115,7 +137,7 @@ static gboolean spi_controller_update_key_grabs (SpiDEController static gboolean spi_controller_register_device_listener (SpiDEController *controller, DEControllerListener *l, CORBA_Environment *ev); -static void spi_device_event_controller_forward_key_event (SpiDEController *controller, +static gboolean spi_device_event_controller_forward_key_event (SpiDEController *controller, const XEvent *event); static void spi_deregister_controller_device_listener (SpiDEController *controller, DEControllerListener *listener, @@ -138,10 +160,125 @@ static gboolean spi_dec_poll_mouse_idle (gpointer data); /* Private methods */ +static unsigned int +keysym_mod_mask (KeySym keysym, KeyCode keycode) +{ + /* we really should use XKB and look directly at the keymap */ + /* this is very inelegant */ + Display *display = spi_get_display (); + unsigned int mods_rtn = 0; + unsigned int retval = 0; + KeySym sym_rtn; + + if (XkbLookupKeySym (display, keycode, 0, &mods_rtn, &sym_rtn) && + (sym_rtn == keysym)) { + retval = 0; + } + else if (XkbLookupKeySym (display, keycode, ShiftMask, &mods_rtn, &sym_rtn) && + (sym_rtn == keysym)) { + retval = ShiftMask; + } + else if (XkbLookupKeySym (display, keycode, Mod2Mask, &mods_rtn, &sym_rtn) && + (sym_rtn == keysym)) { + retval = Mod2Mask; + } + else if (XkbLookupKeySym (display, keycode, Mod3Mask, &mods_rtn, &sym_rtn) && + (sym_rtn == keysym)) { + retval = Mod3Mask; + } + else if (XkbLookupKeySym (display, keycode, + ShiftMask | Mod2Mask, &mods_rtn, &sym_rtn) && + (sym_rtn == keysym)) { + retval = (Mod2Mask | ShiftMask); + } + else if (XkbLookupKeySym (display, keycode, + ShiftMask | Mod3Mask, &mods_rtn, &sym_rtn) && + (sym_rtn == keysym)) { + retval = (Mod3Mask | ShiftMask); + } + else if (XkbLookupKeySym (display, keycode, + ShiftMask | Mod4Mask, &mods_rtn, &sym_rtn) && + (sym_rtn == keysym)) { + retval = (Mod4Mask | ShiftMask); + } + else + retval = 0xFFFF; + 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) +keycode_for_keysym (SpiDEController *controller, long keysym, unsigned int *modmask) { - return XKeysymToKeycode (spi_get_display (), (KeySym) keysym); + 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; } static DEControllerGrabMask * @@ -288,7 +425,7 @@ spi_dec_button_update_and_emit (SpiDEController *controller, #endif snprintf (event_name, 22, "mouse:button:%d%c", button_number, (is_down) ? 'p' : 'r'); - /* TODO: distinguish between physical and + /* TODO: FIXME distinguish between physical and * logical buttons */ mouse_e.type = (is_down) ? @@ -308,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) { @@ -318,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; } @@ -333,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; @@ -362,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 @@ -399,15 +552,26 @@ spi_dec_emit_modifier_event (SpiDEController *controller, guint prev_mask, fprintf (stderr, "MODIFIER CHANGE EVENT! %x to %x\n", prev_mask, current_mask); #endif + + /* set bits for the virtual modifiers like NUMLOCK */ + if (prev_mask & _numlock_physical_mask) + prev_mask |= SPI_KEYMASK_NUMLOCK; + if (current_mask & _numlock_physical_mask) + current_mask |= SPI_KEYMASK_NUMLOCK; + e.type = "keyboard:modifiers"; 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 @@ -472,21 +636,53 @@ 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, - gdk_x11_get_default_root_xwindow (), - True, ButtonPressMask | ButtonReleaseMask, - GrabModeSync, GrabModeAsync, None, None) != Success) + gdk_x11_get_default_root_xwindow (), + True, ButtonPressMask | ButtonReleaseMask, + GrabModeSync, GrabModeAsync, None, None) != Success) { +#ifdef SPI_DEBUG fprintf (stderr, "WARNING: could not grab mouse buttons!\n"); +#endif + ; + } XSync (display, False); #ifdef SPI_DEBUG 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 numlock and convert them to + * system-specific mask values (i.e. ModMask). + * + **/ +static Accessibility_ControllerEventMask +spi_dec_translate_mask (Accessibility_ControllerEventMask 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 * @@ -501,7 +697,7 @@ spi_dec_key_listener_new (CORBA_Object l, key_listener->listener.object = bonobo_object_dup_ref (l, ev); key_listener->listener.type = SPI_DEVICE_TYPE_KBD; key_listener->keys = ORBit_copy_value (keys, TC_Accessibility_KeySet); - key_listener->mask = mask; + key_listener->mask = spi_dec_translate_mask (mask); key_listener->listener.typeseq = ORBit_copy_value (typeseq, TC_Accessibility_EventTypeSeq); if (mode) key_listener->mode = ORBit_copy_value (mode, TC_Accessibility_EventListenerMode); @@ -691,7 +887,10 @@ spi_controller_register_global_keygrabs (SpiDEController *controller, DEControllerKeyListener *key_listener) { handle_keygrab (controller, key_listener, _register_keygrab); - return spi_controller_update_key_grabs (controller, NULL); + if (controller->xevie_display == NULL) + return spi_controller_update_key_grabs (controller, NULL); + else + return TRUE; } static void @@ -699,7 +898,8 @@ spi_controller_deregister_global_keygrabs (SpiDEController *controller, DEControllerKeyListener *key_listener) { handle_keygrab (controller, key_listener, _deregister_keygrab); - spi_controller_update_key_grabs (controller, NULL); + if (controller->xevie_display == NULL) + spi_controller_update_key_grabs (controller, NULL); } static gboolean @@ -741,7 +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; @@ -760,12 +962,15 @@ 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 } } } #ifdef SPI_KEYEVENT_DEBUG - if (!notify) + if (!found) { g_print ("no match for event\n"); } @@ -853,7 +1058,7 @@ spi_device_event_controller_forward_mouse_event (SpiDEController *controller, snprintf (event_name, 22, "mouse:button:%d%c", button, (xevent->type == ButtonPress) ? 'p' : 'r'); - /* TODO: distinguish between physical and logical buttons */ + /* TODO: FIXME distinguish between physical and logical buttons */ mouse_e.type = (xevent->type == ButtonPress) ? Accessibility_BUTTON_PRESSED_EVENT : Accessibility_BUTTON_RELEASED_EVENT; @@ -877,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 || @@ -912,7 +1121,43 @@ global_filter_fn (GdkXEvent *gdk_xevent, GdkEvent *event, gpointer data) if (xevent->type == KeyPress || xevent->type == KeyRelease) { - spi_device_event_controller_forward_key_event (controller, xevent); + if (controller->xevie_display == NULL) + { + gboolean is_consumed; + + is_consumed = + spi_device_event_controller_forward_key_event (controller, xevent); + + if (is_consumed) + { + 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 + { + if (xevent->type == KeyPress) + wait_for_release_event (xevent, controller); + XAllowEvents (display, ReplayKeyboard, CurrentTime); + } + } + return GDK_FILTER_CONTINUE; } if (xevent->type == ButtonPress || xevent->type == ButtonRelease) @@ -923,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) { @@ -985,13 +1230,13 @@ 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; } -int +static int _spi_controller_device_error_handler (Display *display, XErrorEvent *error) { if (error->error_code == BadAccess) @@ -1024,10 +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); @@ -1062,10 +1353,13 @@ spi_key_set_contains_key (Accessibility_KeySet *key_set, for (i = 0; i < len; ++i) { #ifdef SPI_KEYEVENT_DEBUG - g_print ("key_set[%d] = %d; key_event %d, code %d, string %s\n", - i, (int) key_set->_buffer[i].keycode, - (int) key_event->id, (int) key_event->hw_code, - key_event->event_string); + g_print ("key_set[%d] event = %d, code = %d; key_event %d, code %d, string %s\n", + i, + (int)key_set->_buffer[i].keysym, + (int) key_set->_buffer[i].keycode, + (int) key_event->id, + (int) key_event->hw_code, + key_event->event_string); #endif if (key_set->_buffer[i].keysym == (CORBA_long) key_event->id) { @@ -1081,7 +1375,7 @@ spi_key_set_contains_key (Accessibility_KeySet *key_set, return TRUE; } } - + return FALSE; } @@ -1126,7 +1420,7 @@ spi_key_event_matches_listener (const Accessibility_DeviceEvent *key_event, DEControllerKeyListener *listener, CORBA_boolean is_system_global) { - if ((key_event->modifiers == (CORBA_unsigned_short) (listener->mask & 0xFFFF)) && + if (((key_event->modifiers & 0xFF) == (CORBA_unsigned_short) (listener->mask & 0xFF)) && spi_key_set_contains_key (listener->keys, key_event) && spi_eventtype_seq_contains_event (listener->listener.typeseq, key_event) && (is_system_global == listener->mode->global)) @@ -1141,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) { @@ -1155,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; @@ -1185,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)) { @@ -1214,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; @@ -1227,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); @@ -1235,11 +1534,11 @@ spi_keystroke_from_x_key_event (XKeyEvent *x_key_event) key_event.hw_code = (CORBA_short) x_key_event->keycode; if (((XEvent *) x_key_event)->type == KeyPress) { - key_event.type = Accessibility_KEY_PRESSED; + key_event.type = Accessibility_KEY_PRESSED_EVENT; } else { - key_event.type = Accessibility_KEY_RELEASED; + key_event.type = Accessibility_KEY_RELEASED_EVENT; } key_event.modifiers = (CORBA_unsigned_short)(x_key_event->state); key_event.is_text = CORBA_FALSE; @@ -1326,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? */ @@ -1341,20 +1640,33 @@ spi_keystroke_from_x_key_event (XKeyEvent *x_key_event) key_event.timestamp = (CORBA_unsigned_long) x_key_event->time; #ifdef SPI_KEYEVENT_DEBUG - fprintf (stderr, - "Key %lu pressed (%c), modifiers %d; string=%s [%x] %s\n", - (unsigned long) keysym, - keysym ? (int) keysym : '*', - (int) x_key_event->state, - key_event.event_string, - key_event.event_string[0], - (key_event.is_text == CORBA_TRUE) ? "(text)" : "(not text)"); + { + char *pressed_str = "pressed"; + char *released_str = "released"; + char *state_ptr; + + if (key_event.type == Accessibility_KEY_PRESSED_EVENT) + state_ptr = pressed_str; + else + state_ptr = released_str; + + fprintf (stderr, + "Key %lu %s (%c), modifiers %d; string=%s [%x] %s\n", + (unsigned long) keysym, + state_ptr, + keysym ? (int) keysym : '*', + (int) x_key_event->state, + key_event.event_string, + key_event.event_string[0], + (key_event.is_text == CORBA_TRUE) ? "(text)" : "(not text)"); + } #endif #ifdef SPI_DEBUG - fprintf (stderr, "%s%c", + fprintf (stderr, "%s%c\n", (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; } @@ -1365,6 +1677,7 @@ spi_controller_update_key_grabs (SpiDEController *controller, { GList *l, *next; gboolean update_failed = FALSE; + KeyCode keycode = 0; g_return_val_if_fail (controller != NULL, FALSE); @@ -1377,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; @@ -1386,9 +1701,8 @@ spi_controller_update_key_grabs (SpiDEController *controller, next = l->next; re_issue_grab = recv && -/* (recv->type == Accessibility_KEY_RELEASED) && - (?) */ (recv->modifiers & grab_mask->mod_mask) && - (grab_mask->key_val == keycode_for_keysym (recv->id)); + (grab_mask->key_val == keycode); #ifdef SPI_DEBUG fprintf (stderr, "mask=%lx %lx (%c%c) %s\n", @@ -1472,6 +1786,16 @@ spi_device_event_controller_object_finalize (GObject *object) /* disconnect any special listeners, get rid of outstanding keygrabs */ XUngrabKey (spi_get_display (), AnyKey, AnyModifier, DefaultRootWindow (spi_get_display ())); +#ifdef HAVE_XEVIE + if (controller->xevie_display != NULL) + { + XevieEnd(controller->xevie_display); +#ifdef SPI_KEYEVENT_DEBUG + printf("XevieEnd(dpy) finished \n"); +#endif + } +#endif + private = g_object_get_data (G_OBJECT (controller), "spi-dec-private"); if (private->xkb_desc) XkbFreeKeyboard (private->xkb_desc, 0, True); @@ -1748,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; @@ -1796,6 +2121,124 @@ dec_synth_keycode_release (SpiDEController *controller, return TRUE; } +static unsigned +dec_get_modifier_state (SpiDEController *controller) +{ + return mouse_mask_state; +} + +static gboolean +dec_lock_modifiers (SpiDEController *controller, unsigned modifiers) +{ + return XkbLockModifiers (spi_get_display (), XkbUseCoreKbd, + modifiers, modifiers); +} + +static gboolean +dec_unlock_modifiers (SpiDEController *controller, unsigned modifiers) +{ + return XkbLockModifiers (spi_get_display (), XkbUseCoreKbd, + modifiers, 0); +} + +static KeySym +dec_keysym_for_unichar (SpiDEController *controller, gunichar unichar) +{ + return ucs2keysym ((long) unichar); +} + +static gboolean +dec_synth_keysym (SpiDEController *controller, KeySym keysym) +{ + KeyCode key_synth_code; + unsigned int modifiers, synth_mods, lock_mods; + + key_synth_code = keycode_for_keysym (controller, keysym, &synth_mods); + + if ((key_synth_code == 0) || (synth_mods == 0xFF)) return FALSE; + + /* TODO: set the modifiers accordingly! */ + modifiers = dec_get_modifier_state (controller); + /* side-effect; we may unset mousebutton modifiers here! */ + + lock_mods = 0; + if (synth_mods != modifiers) { + lock_mods = synth_mods & ~modifiers; + dec_lock_modifiers (controller, lock_mods); + } + 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; +} + + +static gboolean +dec_synth_keystring (SpiDEController *controller, const CORBA_char *keystring) +{ + /* probably we need to create and inject an XIM handler eventually. */ + /* for now, try to match the string to existing + * keycode+modifier states. + */ + KeySym *keysyms; + gint maxlen = 0; + gunichar unichar = 0; + gint i = 0; + gboolean retval = TRUE; + const gchar *c; + + maxlen = strlen (keystring); + keysyms = g_new0 (KeySym, maxlen); + if (!(keystring && *keystring && g_utf8_validate (keystring, -1, &c))) { + retval = FALSE; + } + else { +#ifdef SPI_DEBUG + fprintf (stderr, "[keystring synthesis attempted on %s]\n", keystring); +#endif + while (keystring && (unichar = g_utf8_get_char (keystring))) { + KeySym keysym; + char bytes[6]; + gint mbytes; + + mbytes = g_unichar_to_utf8 (unichar, bytes); + bytes[mbytes] = '\0'; +#ifdef SPI_DEBUG + fprintf (stderr, "[unichar %s]", bytes); +#endif + keysym = dec_keysym_for_unichar (controller, unichar); + if (keysym == NoSymbol) { +#ifdef SPI_DEBUG + fprintf (stderr, "no keysym for %s", bytes); +#endif + retval = FALSE; + break; + } + keysyms[i++] = keysym; + 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 + fprintf (stderr, "could not synthesize %c\n", + (int) keysyms[i]); +#endif + retval = FALSE; + break; + } + } + XSynchronize (spi_get_display (), FALSE); + } + g_free (keysyms); + + return retval; +} + + /* * CORBA Accessibility::DEController::registerKeystrokeListener * method implementation @@ -1809,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 @@ -1823,9 +2266,7 @@ impl_generate_keyboard_event (PortableServer_Servant servant, * and fall back to XSendEvent() if XTest is not available. */ - /* TODO: implement keystring mode also */ gdk_error_trap_push (); - key_synth_code = keycode; switch (synth_type) { @@ -1841,17 +2282,22 @@ impl_generate_keyboard_event (PortableServer_Servant servant, #ifdef SPI_XKB_DEBUG fprintf (stderr, "KeySym synthesis\n"); #endif - key_synth_code = keycode_for_keysym (keycode); - dec_synth_keycode_press (controller, key_synth_code); - dec_synth_keycode_release (controller, key_synth_code); + /* + * note: we are using long for 'keycode' + * in our arg list; it can contain either + * a keycode or a keysym. + */ + dec_synth_keysym (controller, (KeySym) keycode); break; case Accessibility_KEY_STRING: - fprintf (stderr, "Not yet implemented\n"); + if (!dec_synth_keystring (controller, keystring)) + fprintf (stderr, "Keystring synthesis failure, string=%s\n", + 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; @@ -1944,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; } @@ -1959,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 @@ -1985,13 +2434,71 @@ spi_device_event_controller_class_init (SpiDEControllerClass *klass) spi_dec_private_quark = g_quark_from_static_string ("spi-dec-private"); } +#ifdef HAVE_XEVIE +static Bool isEvent(Display *dpy, XEvent *event, char *arg) +{ + return TRUE; +} + +static gboolean +handle_io (GIOChannel *source, + GIOCondition condition, + gpointer data) +{ + SpiDEController *controller = (SpiDEController *) data; + gboolean is_consumed = FALSE; + XEvent ev; + + while (XCheckIfEvent(controller->xevie_display, &ev, isEvent, NULL)) + { + if (ev.type == KeyPress || ev.type == KeyRelease) + is_consumed = spi_device_event_controller_forward_key_event (controller, &ev); + + if (! is_consumed) + XevieSendEvent(controller->xevie_display, &ev, XEVIE_UNMODIFIED); + } + + return TRUE; +} +#endif /* HAVE_XEVIE */ + static void spi_device_event_controller_init (SpiDEController *device_event_controller) { +#ifdef HAVE_XEVIE + GIOChannel *ioc; + int fd; +#endif /* HAVE_XEVIE */ + DEControllerPrivateData *private; device_event_controller->key_listeners = NULL; device_event_controller->mouse_listeners = NULL; device_event_controller->keygrabs_list = NULL; + device_event_controller->xevie_display = NULL; + +#ifdef HAVE_XEVIE + device_event_controller->xevie_display = XOpenDisplay(NULL); + + if (XevieStart(device_event_controller->xevie_display) == TRUE) + { +#ifdef SPI_KEYEVENT_DEBUG + fprintf (stderr, "XevieStart() success \n"); +#endif + XevieSelectInput(device_event_controller->xevie_display, KeyPressMask | KeyReleaseMask); + + fd = ConnectionNumber(device_event_controller->xevie_display); + ioc = g_io_channel_unix_new (fd); + g_io_add_watch (ioc, G_IO_IN | G_IO_HUP, handle_io, device_event_controller); + g_io_channel_unref (ioc); + } + else + { + device_event_controller->xevie_display = NULL; +#ifdef SPI_KEYEVENT_DEBUG + fprintf (stderr, "XevieStart() failed, only one client is allowed to do event int exception\n"); +#endif + } +#endif /* HAVE_XEVIE */ private = g_new0 (DEControllerPrivateData, 1); gettimeofday (&private->last_press_time, NULL); @@ -2002,13 +2509,13 @@ spi_device_event_controller_init (SpiDEController *device_event_controller) spi_controller_register_with_devices (device_event_controller); } -static void +static gboolean spi_device_event_controller_forward_key_event (SpiDEController *controller, const XEvent *event) { - gboolean is_consumed = FALSE; CORBA_Environment ev; Accessibility_DeviceEvent key_event; + gboolean ret; g_assert (event->type == KeyPress || event->type == KeyRelease); @@ -2016,20 +2523,13 @@ spi_device_event_controller_forward_key_event (SpiDEController *controller, key_event = spi_keystroke_from_x_key_event ((XKeyEvent *) event); - spi_controller_update_key_grabs (controller, &key_event); + if (controller->xevie_display == NULL) + spi_controller_update_key_grabs (controller, &key_event); /* relay to listeners, and decide whether to consume it or not */ - is_consumed = spi_controller_notify_keylisteners ( - controller, &key_event, CORBA_TRUE, &ev); - - if (is_consumed) - { - XAllowEvents (spi_get_display (), AsyncKeyboard, CurrentTime); - } - else - { - XAllowEvents (spi_get_display (), ReplayKeyboard, CurrentTime); - } + ret = spi_controller_notify_keylisteners (controller, &key_event, CORBA_TRUE, &ev); + CORBA_free(key_event.event_string); + return ret; } SpiDEController * @@ -2046,7 +2546,46 @@ 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, - spi_device_event_controller); + spi_device_event_controller)