registryd/deviceeventcontroller.c

   1 /* AT-SPI - Assistive Technology Service Provider Interface
   2  *
   3  * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
   4  *
   5  * Copyright 2001, 2003 Sun Microsystems Inc.,
   6  * Copyright 2001, 2002 Ximian, Inc.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 /* deviceeventcontroller.c: implement the DeviceEventController interface */
  25
  26 #include <config.h>
  27
  28 #undef  SPI_XKB_DEBUG
  29 #undef  SPI_DEBUG
  30 #undef  SPI_KEYEVENT_DEBUG
  31
  32 #include <string.h>
  33 #include <ctype.h>
  34 #include <stdio.h>
  35 #include <sys/time.h>
  36
  37 #include <X11/Xlib.h>
  38 #include <X11/extensions/XTest.h>
  39 #include <X11/XKBlib.h>
  40 #define XK_MISCELLANY
  41 #define XK_LATIN1
  42 #include <X11/keysymdef.h>
  43
  44 #ifdef HAVE_XEVIE
  45 #include <X11/Xproto.h>
  46 #include <X11/X.h>
  47 #include <X11/extensions/Xevie.h>
  48 #endif /* HAVE_XEVIE */
  49
  50 #include <gdk/gdk.h>
  51 #include <gdk/gdkx.h> /* TODO: hide dependency (wrap in single porting file) */
  52 #include <gdk/gdkkeysyms.h>
  53 #include <gdk/gdkwindow.h>
  54
  55 #include "../libspi/spi-private.h"
  56 #include "deviceeventcontroller.h"
  57 #include "libspi/keymasks.h"
  58
  59 KeySym ucs2keysym (long ucs);
  60 long keysym2ucs(KeySym keysym);
  61
  62 #define CHECK_RELEASE_DELAY 20
  63 #define BIT(c, x)       (c[x/8]&(1<<(x%8)))
  64 static guint check_release_handler = 0;
  65 static Accessibility_DeviceEvent pressed_event;
  66 static SpiDEController *saved_controller;
  67 static void wait_for_release_event (XEvent *event, SpiDEController *controller);
  68
  69 /* Our parent Gtk object type */
  70 #define PARENT_TYPE G_TYPE_OBJECT
  71
  72 /* A pointer to our parent object class */
  73 static int spi_error_code = 0;
  74 static GdkPoint last_mouse_pos_static = {0, 0};
  75 static GdkPoint *last_mouse_pos = &last_mouse_pos_static;
  76 static unsigned int mouse_mask_state = 0;
  77 static unsigned int mouse_button_mask =
  78   Button1Mask | Button2Mask | Button3Mask | Button4Mask | Button5Mask;
  79 static unsigned int key_modifier_mask =
  80   Mod1Mask | Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask | ShiftMask | LockMask | ControlMask | SPI_KEYMASK_NUMLOCK;
  81 static unsigned int _numlock_physical_mask = Mod2Mask; /* a guess, will be reset */
  82
  83 static GQuark spi_dec_private_quark = 0;
  84 static XModifierKeymap* xmkeymap = NULL;
  85
  86 static int (*x_default_error_handler) (Display *display, XErrorEvent *error_event);
  87
  88 typedef enum {
  89   SPI_DEVICE_TYPE_KBD,
  90   SPI_DEVICE_TYPE_MOUSE,
  91   SPI_DEVICE_TYPE_LAST_DEFINED
  92 } SpiDeviceTypeCategory;
  93
  94 typedef struct {
  95   guint                             ref_count : 30;
  96   guint                             pending_add : 1;
  97   guint                             pending_remove : 1;
  98
  99   Accessibility_ControllerEventMask mod_mask;
 100   dbus_uint32_t               key_val;  /* KeyCode */
 101 } DEControllerGrabMask;
 102
 103 typedef struct {
 104   char *app_path;
 105   char *path;
 106   SpiDeviceTypeCategory type;
 107   gulong types;
 108 } DEControllerListener;
 109
 110 typedef struct {
 111   DEControllerListener listener;
 112
 113  GSList *keys;
 114   Accessibility_ControllerEventMask mask;
 115   Accessibility_EventListenerMode  *mode;
 116 } DEControllerKeyListener;
 117
 118 typedef struct {
 119   unsigned int last_press_keycode;
 120   unsigned int last_release_keycode;
 121   struct timeval last_press_time;
 122   struct timeval last_release_time;
 123   int have_xkb;
 124   int xkb_major_extension_opcode;
 125   int xkb_base_event_code;
 126   int xkb_base_error_code;
 127   unsigned int xkb_latch_mask;
 128   unsigned int pending_xkb_mod_relatch_mask;
 129   XkbDescPtr xkb_desc;
 130   KeyCode reserved_keycode;
 131   KeySym reserved_keysym;
 132   guint  reserved_reset_timeout;
 133 } DEControllerPrivateData;
 134
 135 static void     spi_controller_register_with_devices          (SpiDEController           *controller);
 136 static gboolean spi_controller_update_key_grabs               (SpiDEController           *controller,
 137                                                                Accessibility_DeviceEvent *recv);
 138 static gboolean spi_controller_register_device_listener       (SpiDEController           *controller,
 139                                                                DEControllerListener      *l);
 140 static gboolean spi_device_event_controller_forward_key_event (SpiDEController           *controller,
 141                                                                const XEvent              *event);
 142 static void     spi_controller_deregister_device_listener (SpiDEController            *controller,
 143                                                            DEControllerListener *listener);
 144 static void     spi_deregister_controller_key_listener (SpiDEController         *controller,
 145                                                         DEControllerKeyListener *key_listener);
 146 static gboolean spi_controller_notify_mouselisteners (SpiDEController                 *controller,
 147                                                       const Accessibility_DeviceEvent *event);
 148
 149 static gboolean spi_eventtype_seq_contains_event (dbus_uint32_t types,
 150                                                   const Accessibility_DeviceEvent *event);
 151 static gboolean spi_clear_error_state (void);
 152 static gboolean spi_dec_poll_mouse_moved (gpointer data);
 153 static gboolean spi_dec_poll_mouse_moving (gpointer data);
 154 static gboolean spi_dec_poll_mouse_idle (gpointer data);
 155
 156 #define spi_get_display() GDK_DISPLAY()
 157
 158 G_DEFINE_TYPE(SpiDEController, spi_device_event_controller, G_TYPE_OBJECT)
 159
 160 /* Private methods */
 161
 162 static unsigned int
 163 keysym_mod_mask (KeySym keysym, KeyCode keycode)
 164 {
 165         /* we really should use XKB and look directly at the keymap */
 166         /* this is very inelegant */
 167         Display *display = spi_get_display ();
 168         unsigned int mods_rtn = 0;
 169         unsigned int retval = 0;
 170         KeySym sym_rtn;
 171
 172         if (XkbLookupKeySym (display, keycode, 0, &mods_rtn, &sym_rtn) &&
 173             (sym_rtn == keysym)) {
 174                 retval = 0;
 175         }
 176         else if (XkbLookupKeySym (display, keycode, ShiftMask, &mods_rtn, &sym_rtn) &&
 177                  (sym_rtn == keysym)) {
 178                 retval = ShiftMask;
 179         }
 180         else if (XkbLookupKeySym (display, keycode, Mod2Mask, &mods_rtn, &sym_rtn) &&
 181                  (sym_rtn == keysym)) {
 182                 retval = Mod2Mask;
 183         }
 184         else if (XkbLookupKeySym (display, keycode, Mod3Mask, &mods_rtn, &sym_rtn) &&
 185                  (sym_rtn == keysym)) {
 186                 retval = Mod3Mask;
 187         }
 188         else if (XkbLookupKeySym (display, keycode,
 189                                   ShiftMask | Mod2Mask, &mods_rtn, &sym_rtn) &&
 190                  (sym_rtn == keysym)) {
 191                 retval = (Mod2Mask | ShiftMask);
 192         }
 193         else if (XkbLookupKeySym (display, keycode,
 194                                   ShiftMask | Mod3Mask, &mods_rtn, &sym_rtn) &&
 195                  (sym_rtn == keysym)) {
 196                 retval = (Mod3Mask | ShiftMask);
 197         }
 198         else if (XkbLookupKeySym (display, keycode,
 199                                   ShiftMask | Mod4Mask, &mods_rtn, &sym_rtn) &&
 200                  (sym_rtn == keysym)) {
 201                 retval = (Mod4Mask | ShiftMask);
 202         }
 203         else
 204                 retval = 0xFFFF;
 205         return retval;
 206 }
 207
 208 static gboolean
 209 spi_dec_replace_map_keysym (DEControllerPrivateData *priv, KeyCode keycode, KeySym keysym)
 210 {
 211 #ifdef HAVE_XKB
 212   Display *dpy = spi_get_display ();
 213   XkbDescPtr desc;
 214   if (!(desc = XkbGetMap (dpy, XkbAllMapComponentsMask, XkbUseCoreKbd)))
 215     {
 216       fprintf (stderr, "ERROR getting map\n");
 217     }
 218   XFlush (dpy);
 219   XSync (dpy, False);
 220   if (desc && desc->map)
 221     {
 222       gint offset = desc->map->key_sym_map[keycode].offset;
 223       desc->map->syms[offset] = keysym;
 224     }
 225   else
 226     {
 227       fprintf (stderr, "Error changing key map: empty server structure\n");
 228     }
 229   XkbSetMap (dpy, XkbAllMapComponentsMask, desc);
 230   /**
 231    *  FIXME: the use of XkbChangeMap, and the reuse of the priv->xkb_desc structure,
 232    * would be far preferable.
 233    * HOWEVER it does not seem to work using XFree 4.3.
 234    **/
 235   /*        XkbChangeMap (dpy, priv->xkb_desc, priv->changes); */
 236   XFlush (dpy);
 237   XSync (dpy, False);
 238   XkbFreeKeyboard (desc, 0, TRUE);
 239
 240   return TRUE;
 241 #else
 242   return FALSE;
 243 #endif
 244 }
 245
 246 static gboolean
 247 spi_dec_reset_reserved (gpointer data)
 248 {
 249   DEControllerPrivateData *priv = data;
 250   spi_dec_replace_map_keysym (priv, priv->reserved_keycode, priv->reserved_keysym);
 251   priv->reserved_reset_timeout = 0;
 252   return FALSE;
 253 }
 254
 255 static KeyCode
 256 keycode_for_keysym (SpiDEController *controller, long keysym, unsigned int *modmask)
 257 {
 258         KeyCode keycode = 0;
 259         keycode = XKeysymToKeycode (spi_get_display (), (KeySym) keysym);
 260         if (!keycode)
 261         {
 262                 DEControllerPrivateData *priv = (DEControllerPrivateData *)
 263                         g_object_get_qdata (G_OBJECT (controller), spi_dec_private_quark);
 264                 /* if there's no keycode available, fix it */
 265                 if (spi_dec_replace_map_keysym (priv, priv->reserved_keycode, keysym))
 266                 {
 267                         keycode = priv->reserved_keycode;
 268                         /*
 269                          * queue a timer to restore the old keycode.  Ugly, but required
 270                          * due to races / asynchronous X delivery.
 271                          * Long-term fix is to extend the X keymap here instead of replace entries.
 272                          */
 273                         priv->reserved_reset_timeout = g_timeout_add (500, spi_dec_reset_reserved, priv);
 274                 }
 275                 *modmask = 0;
 276                 return keycode;
 277         }
 278         if (modmask)
 279                 *modmask = keysym_mod_mask (keysym, keycode);
 280         return keycode;
 281 }
 282
 283 static DEControllerGrabMask *
 284 spi_grab_mask_clone (DEControllerGrabMask *grab_mask)
 285 {
 286   DEControllerGrabMask *clone = g_new (DEControllerGrabMask, 1);
 287
 288   memcpy (clone, grab_mask, sizeof (DEControllerGrabMask));
 289
 290   clone->ref_count = 1;
 291   clone->pending_add = TRUE;
 292   clone->pending_remove = FALSE;
 293
 294   return clone;
 295 }
 296
 297 static void
 298 spi_grab_mask_free (DEControllerGrabMask *grab_mask)
 299 {
 300   g_free (grab_mask);
 301 }
 302
 303 static gint
 304 spi_grab_mask_compare_values (gconstpointer p1, gconstpointer p2)
 305 {
 306   DEControllerGrabMask *l1 = (DEControllerGrabMask *) p1;
 307   DEControllerGrabMask *l2 = (DEControllerGrabMask *) p2;
 308
 309   if (p1 == p2)
 310     {
 311       return 0;
 312     }
 313   else
 314     {
 315       return ((l1->mod_mask != l2->mod_mask) || (l1->key_val != l2->key_val));
 316     }
 317 }
 318
 319 static void
 320 spi_dec_set_unlatch_pending (SpiDEController *controller, unsigned mask)
 321 {
 322   DEControllerPrivateData *priv =
 323     g_object_get_qdata (G_OBJECT (controller), spi_dec_private_quark);
 324 #ifdef SPI_XKB_DEBUG
 325   if (priv->xkb_latch_mask) fprintf (stderr, "unlatch pending! %x\n",
 326                                      priv->xkb_latch_mask);
 327 #endif
 328   priv->pending_xkb_mod_relatch_mask |= priv->xkb_latch_mask;
 329 }
 330
 331 static void
 332 spi_dec_clear_unlatch_pending (SpiDEController *controller)
 333 {
 334   DEControllerPrivateData *priv =
 335     g_object_get_qdata (G_OBJECT (controller), spi_dec_private_quark);
 336   priv->xkb_latch_mask = 0;
 337 }
 338
 339 static void emit(SpiDEController *controller, const char *name, int first_type, ...)
 340 {
 341   va_list arg;
 342
 343   va_start(arg, first_type);
 344   spi_dbus_emit_valist(controller->registry->droute.bus, SPI_DBUS_PATH_DEC, SPI_DBUS_INTERFACE_DEC, name, first_type, arg);
 345   va_end(arg);
 346 }
 347
 348 static gboolean
 349 spi_dec_button_update_and_emit (SpiDEController *controller,
 350                                 guint mask_return)
 351 {
 352   Accessibility_DeviceEvent mouse_e;
 353   gchar event_name[24];
 354   gboolean is_consumed = FALSE;
 355
 356   if ((mask_return & mouse_button_mask) !=
 357       (mouse_mask_state & mouse_button_mask))
 358     {
 359       int button_number = 0;
 360       gboolean is_down = False;
 361
 362       if (!(mask_return & Button1Mask) &&
 363           (mouse_mask_state & Button1Mask))
 364         {
 365           mouse_mask_state &= ~Button1Mask;
 366           button_number = 1;
 367         }
 368       else if ((mask_return & Button1Mask) &&
 369                !(mouse_mask_state & Button1Mask))
 370         {
 371           mouse_mask_state |= Button1Mask;
 372           button_number = 1;
 373           is_down = True;
 374         }
 375       else if (!(mask_return & Button2Mask) &&
 376                (mouse_mask_state & Button2Mask))
 377         {
 378           mouse_mask_state &= ~Button2Mask;
 379           button_number = 2;
 380         }
 381       else if ((mask_return & Button2Mask) &&
 382                !(mouse_mask_state & Button2Mask))
 383         {
 384           mouse_mask_state |= Button2Mask;
 385           button_number = 2;
 386           is_down = True;
 387         }
 388       else if (!(mask_return & Button3Mask) &&
 389                (mouse_mask_state & Button3Mask))
 390         {
 391           mouse_mask_state &= ~Button3Mask;
 392           button_number = 3;
 393         }
 394       else if ((mask_return & Button3Mask) &&
 395                !(mouse_mask_state & Button3Mask))
 396         {
 397           mouse_mask_state |= Button3Mask;
 398           button_number = 3;
 399           is_down = True;
 400         }
 401       else if (!(mask_return & Button4Mask) &&
 402                (mouse_mask_state & Button4Mask))
 403         {
 404           mouse_mask_state &= ~Button4Mask;
 405           button_number = 4;
 406         }
 407       else if ((mask_return & Button4Mask) &&
 408                !(mouse_mask_state & Button4Mask))
 409         {
 410           mouse_mask_state |= Button4Mask;
 411           button_number = 4;
 412           is_down = True;
 413         }
 414       else if (!(mask_return & Button5Mask) &&
 415                (mouse_mask_state & Button5Mask))
 416         {
 417           mouse_mask_state &= ~Button5Mask;
 418           button_number = 5;
 419         }
 420       else if ((mask_return & Button5Mask) &&
 421                !(mouse_mask_state & Button5Mask))
 422         {
 423           mouse_mask_state |= Button5Mask;
 424           button_number = 5;
 425           is_down = True;
 426         }
 427       if (button_number) {
 428 #ifdef SPI_DEBUG
 429         fprintf (stderr, "Button %d %s\n",
 430                  button_number, (is_down) ? "Pressed" : "Released");
 431 #endif
 432         snprintf (event_name, 22, "mouse:button:%d%c", button_number,
 433                   (is_down) ? 'p' : 'r');
 434         /* TODO: FIXME distinguish between physical and
 435          * logical buttons
 436          */
 437         mouse_e.type      = (is_down) ?
 438           Accessibility_BUTTON_PRESSED_EVENT :
 439           Accessibility_BUTTON_RELEASED_EVENT;
 440         mouse_e.id        = button_number;
 441         mouse_e.hw_code   = button_number;
 442         mouse_e.modifiers = (dbus_uint16_t) mouse_mask_state;
 443         mouse_e.timestamp = 0;
 444         mouse_e.event_string = "";
 445         mouse_e.is_text   = FALSE;
 446         is_consumed =
 447           spi_controller_notify_mouselisteners (controller,
 448                                                 &mouse_e);
 449         if (!is_consumed)
 450           {
 451             dbus_uint32_t x = last_mouse_pos->x, y = last_mouse_pos->y;
 452             emit(controller, event_name, DBUS_TYPE_UINT32, &x, DBUS_TYPE_UINT32, &y, DBUS_TYPE_INVALID);
 453           }
 454         else
 455           spi_dec_set_unlatch_pending (controller, mask_return);
 456       }
 457       return TRUE;
 458     }
 459   else
 460     {
 461       return FALSE;
 462     }
 463 }
 464
 465
 466 static guint
 467 spi_dec_mouse_check (SpiDEController *controller,
 468                      int *x, int *y, gboolean *moved)
 469 {
 470   int win_x_return,win_y_return;
 471   unsigned int mask_return;
 472   Window root_return, child_return;
 473   Display *display = spi_get_display ();
 474
 475   if (display != NULL)
 476     XQueryPointer(display, DefaultRootWindow (display),
 477                   &root_return, &child_return,
 478                   x, y,
 479                   &win_x_return, &win_y_return, &mask_return);
 480   /*
 481    * Since many clients grab the pointer, and X goes an automatic
 482    * pointer grab on mouse-down, we often must detect mouse button events
 483    * by polling rather than via a button grab.
 484    * The while loop (rather than if) is used since it's possible that
 485    * multiple buttons have changed state since we last checked.
 486    */
 487   if (mask_return != mouse_mask_state)
 488     {
 489       while (spi_dec_button_update_and_emit (controller, mask_return));
 490     }
 491
 492   if (*x != last_mouse_pos->x || *y != last_mouse_pos->y)
 493     {
 494       // TODO: combine these two signals?
 495       dbus_uint32_t ix = *x, iy = *y;
 496       emit(controller, "mouse_abs", DBUS_TYPE_UINT32, &ix, DBUS_TYPE_UINT32, &iy, DBUS_TYPE_INVALID);
 497       ix -= last_mouse_pos->x;
 498       iy -= last_mouse_pos->y;
 499       emit(controller, "mouse_rel", DBUS_TYPE_UINT32, &ix, DBUS_TYPE_UINT32, &iy, DBUS_TYPE_INVALID);
 500       last_mouse_pos->x = *x;
 501       last_mouse_pos->y = *y;
 502       *moved = True;
 503     }
 504   else
 505     {
 506       *moved = False;
 507     }
 508
 509   return mask_return;
 510 }
 511
 512 static void
 513 spi_dec_emit_modifier_event (SpiDEController *controller, guint prev_mask,
 514                              guint current_mask)
 515 {
 516   dbus_uint32_t d1, d2;
 517
 518 #ifdef SPI_XKB_DEBUG
 519   fprintf (stderr, "MODIFIER CHANGE EVENT! %x to %x\n",
 520            prev_mask, current_mask);
 521 #endif
 522
 523   /* set bits for the virtual modifiers like NUMLOCK */
 524   if (prev_mask & _numlock_physical_mask)
 525     prev_mask |= SPI_KEYMASK_NUMLOCK;
 526   if (current_mask & _numlock_physical_mask)
 527     current_mask |= SPI_KEYMASK_NUMLOCK;
 528
 529   d1 = prev_mask & key_modifier_mask;
 530   d2 = current_mask & key_modifier_mask;
 531       emit(controller, "keyboard_modifiers", DBUS_TYPE_UINT32, &d1, DBUS_TYPE_UINT32, &d2, DBUS_TYPE_INVALID);
 532 }
 533
 534 static gboolean
 535 spi_dec_poll_mouse_moved (gpointer data)
 536 {
 537   SpiRegistry *registry = SPI_REGISTRY (data);
 538   SpiDEController *controller = registry->de_controller;
 539   int x, y;
 540   gboolean moved;
 541   guint mask_return;
 542
 543   mask_return = spi_dec_mouse_check (controller, &x, &y, &moved);
 544
 545   if ((mask_return & key_modifier_mask) !=
 546       (mouse_mask_state & key_modifier_mask))
 547     {
 548       spi_dec_emit_modifier_event (controller, mouse_mask_state, mask_return);
 549       mouse_mask_state = mask_return;
 550     }
 551
 552   return moved;
 553 }
 554
 555 static gboolean
 556 spi_dec_poll_mouse_idle (gpointer data)
 557 {
 558   if (! spi_dec_poll_mouse_moved (data))
 559     return TRUE;
 560   else
 561     {
 562       g_timeout_add (20, spi_dec_poll_mouse_moving, data);
 563       return FALSE;
 564     }
 565 }
 566
 567 static gboolean
 568 spi_dec_poll_mouse_moving (gpointer data)
 569 {
 570   if (spi_dec_poll_mouse_moved (data))
 571     return TRUE;
 572   else
 573     {
 574       g_timeout_add (100, spi_dec_poll_mouse_idle, data);
 575       return FALSE;
 576     }
 577 }
 578
 579 #ifdef WE_NEED_UGRAB_MOUSE
 580 static int
 581 spi_dec_ungrab_mouse (gpointer data)
 582 {
 583         Display *display = spi_get_display ();
 584         if (display)
 585           {
 586             XUngrabButton (spi_get_display (), AnyButton, AnyModifier,
 587                            XDefaultRootWindow (spi_get_display ()));
 588           }
 589         return FALSE;
 590 }
 591 #endif
 592
 593 static void
 594 spi_dec_init_mouse_listener (SpiRegistry *registry)
 595 {
 596 #ifdef GRAB_BUTTON
 597   Display *display = spi_get_display ();
 598 #endif
 599   g_timeout_add (100, spi_dec_poll_mouse_idle, registry);
 600
 601 #ifdef GRAB_BUTTON
 602   if (display)
 603     {
 604       if (XGrabButton (display, AnyButton, AnyModifier,
 605                        gdk_x11_get_default_root_xwindow (),
 606                        True, ButtonPressMask | ButtonReleaseMask,
 607                        GrabModeSync, GrabModeAsync, None, None) != Success) {
 608 #ifdef SPI_DEBUG
 609         fprintf (stderr, "WARNING: could not grab mouse buttons!\n");
 610 #endif
 611         ;
 612       }
 613       XSync (display, False);
 614 #ifdef SPI_DEBUG
 615       fprintf (stderr, "mouse buttons grabbed\n");
 616 #endif
 617     }
 618 #endif
 619 }
 620
 621 /**
 622  * Eventually we can use this to make the marshalling of mask types
 623  * more sane, but for now we just use this to detect
 624  * the use of 'virtual' masks such as numlock and convert them to
 625  * system-specific mask values (i.e. ModMask).
 626  *
 627  **/
 628 static Accessibility_ControllerEventMask
 629 spi_dec_translate_mask (Accessibility_ControllerEventMask mask)
 630 {
 631   Accessibility_ControllerEventMask tmp_mask;
 632   gboolean has_numlock;
 633
 634   has_numlock = (mask & SPI_KEYMASK_NUMLOCK);
 635   tmp_mask = mask;
 636   if (has_numlock)
 637     {
 638       tmp_mask = mask ^ SPI_KEYMASK_NUMLOCK;
 639       tmp_mask |= _numlock_physical_mask;
 640     }
 641
 642   return tmp_mask;
 643 }
 644
 645 static DEControllerKeyListener *
 646 spi_dec_key_listener_new (const char *app_path,
 647                           const char *path,
 648                           GSList *keys,
 649                           const Accessibility_ControllerEventMask mask,
 650                           const dbus_uint32_t types,
 651                           const Accessibility_EventListenerMode  *mode)
 652 {
 653   DEControllerKeyListener *key_listener = g_new0 (DEControllerKeyListener, 1);
 654   key_listener->listener.app_path = g_strdup(app_path);
 655   key_listener->listener.path = g_strdup(path);
 656   key_listener->listener.type = SPI_DEVICE_TYPE_KBD;
 657   key_listener->keys = keys;
 658   key_listener->mask = spi_dec_translate_mask (mask);
 659   key_listener->listener.types = types;
 660   if (mode)
 661   {
 662     key_listener->mode = (Accessibility_EventListenerMode *) g_malloc(sizeof(Accessibility_EventListenerMode));
 663     memcpy(key_listener->mode, mode, sizeof(*mode));
 664   }
 665   else
 666     key_listener->mode = NULL;
 667
 668 #ifdef SPI_DEBUG
 669   g_print ("new listener, with mask %x, is_global %d, keys %p (%d)\n",
 670            (unsigned int) key_listener->mask,
 671            (int) (mode ? mode->global : 0),
 672            (void *) key_listener->keys,
 673            (int) (key_listener->keys ? g_slist_length(key_listener->keys) : 0));
 674 #endif
 675
 676   return key_listener;
 677 }
 678
 679 static DEControllerListener *
 680 spi_dec_listener_new (const char *app_path,
 681                       const char *path,
 682                       dbus_uint32_t types)
 683 {
 684   DEControllerListener *listener = g_new0 (DEControllerListener, 1);
 685   listener->app_path = g_strdup(app_path);
 686   listener->path = g_strdup(path);
 687   listener->type = SPI_DEVICE_TYPE_MOUSE;
 688   listener->types = types;
 689   return listener;
 690 }
 691
 692 static DEControllerListener *
 693 spi_listener_clone (DEControllerListener *listener)
 694 {
 695   DEControllerListener *clone = g_new0 (DEControllerListener, 1);
 696   clone->app_path = g_strdup (listener->app_path);
 697   clone->path = g_strdup (listener->path);
 698   clone->type = listener->type;
 699   clone->types = listener->types;
 700   return clone;
 701 }
 702
 703 static GSList *keylist_clone (GSList *s)
 704 {
 705   GSList *d = NULL;
 706   GSList *l;
 707
 708   for (l = s; l; l = g_slist_next(l))
 709   {
 710     Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *)g_malloc(sizeof(Accessibility_KeyDefinition));
 711     if (kd)
 712     {
 713       Accessibility_KeyDefinition *kds = (Accessibility_KeyDefinition *)l->data;
 714       kd->keycode = kds->keycode;
 715       kd->keysym = kds->keysym;
 716       kd->keystring = g_strdup(kds->keystring);
 717       d = g_slist_append(d, kd);
 718     }
 719   }
 720   return d;
 721 }
 722
 723 static DEControllerKeyListener *
 724 spi_key_listener_clone (DEControllerKeyListener *key_listener)
 725 {
 726   DEControllerKeyListener *clone = g_new0 (DEControllerKeyListener, 1);
 727   clone->listener.app_path = g_strdup (key_listener->listener.app_path);
 728   clone->listener.path = g_strdup (key_listener->listener.path);
 729   clone->listener.type = SPI_DEVICE_TYPE_KBD;
 730   clone->keys = keylist_clone (key_listener->keys);
 731   clone->mask = key_listener->mask;
 732   clone->listener.types = key_listener->listener.types;
 733   if (key_listener->mode)
 734   {
 735     clone->mode = (Accessibility_EventListenerMode *)g_malloc(sizeof(Accessibility_EventListenerMode));
 736     if (clone->mode) memcpy(clone->mode, key_listener->mode, sizeof(Accessibility_EventListenerMode));
 737   }
 738   else
 739     clone->mode = NULL;
 740   return clone;
 741 }
 742
 743 static void keylist_free(GSList *keys)
 744 {
 745   GSList *l;
 746
 747   for (l = keys; l; l = g_slist_next(l))
 748   {
 749     Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *)l->data;
 750     g_free(kd->keystring);
 751     g_free(kd);
 752   }
 753   g_slist_free (keys);
 754 }
 755
 756 static void
 757 spi_key_listener_data_free (DEControllerKeyListener *key_listener)
 758 {
 759   keylist_free(key_listener->keys);
 760   if (key_listener->mode) g_free(key_listener->mode);
 761   g_free (key_listener);
 762 }
 763
 764 static void
 765 spi_key_listener_clone_free (DEControllerKeyListener *clone)
 766 {
 767   spi_key_listener_data_free (clone);
 768 }
 769
 770 static void
 771 spi_listener_clone_free (DEControllerListener *clone)
 772 {
 773   g_free (clone->path);
 774   g_free (clone->app_path);
 775   g_free (clone);
 776 }
 777
 778 static void
 779 spi_dec_listener_free (DEControllerListener    *listener)
 780 {
 781   g_free (listener->app_path);
 782   g_free (listener->path);
 783   if (listener->type == SPI_DEVICE_TYPE_KBD)
 784     spi_key_listener_data_free ((DEControllerKeyListener *) listener);
 785 }
 786
 787 static void
 788 _register_keygrab (SpiDEController      *controller,
 789                    DEControllerGrabMask *grab_mask)
 790 {
 791   GList *l;
 792
 793   l = g_list_find_custom (controller->keygrabs_list, grab_mask,
 794                           spi_grab_mask_compare_values);
 795   if (l)
 796     {
 797       DEControllerGrabMask *cur_mask = l->data;
 798
 799       cur_mask->ref_count++;
 800       if (cur_mask->pending_remove)
 801         {
 802           cur_mask->pending_remove = FALSE;
 803         }
 804     }
 805   else
 806     {
 807       controller->keygrabs_list =
 808         g_list_prepend (controller->keygrabs_list,
 809                         spi_grab_mask_clone (grab_mask));
 810     }
 811 }
 812
 813 static void
 814 _deregister_keygrab (SpiDEController      *controller,
 815                      DEControllerGrabMask *grab_mask)
 816 {
 817   GList *l;
 818
 819   l = g_list_find_custom (controller->keygrabs_list, grab_mask,
 820                           spi_grab_mask_compare_values);
 821
 822   if (l)
 823     {
 824       DEControllerGrabMask *cur_mask = l->data;
 825
 826       cur_mask->ref_count--;
 827       if (cur_mask->ref_count <= 0)
 828         {
 829           cur_mask->pending_remove = TRUE;
 830         }
 831     }
 832   else
 833     {
 834       DBG (1, g_warning ("De-registering non-existant grab"));
 835     }
 836 }
 837
 838 static void
 839 handle_keygrab (SpiDEController         *controller,
 840                 DEControllerKeyListener *key_listener,
 841                 void                   (*process_cb) (SpiDEController *controller,
 842                                                       DEControllerGrabMask *grab_mask))
 843 {
 844   DEControllerGrabMask grab_mask = { 0 };
 845
 846   grab_mask.mod_mask = key_listener->mask;
 847   if (g_slist_length (key_listener->keys) == 0) /* special case means AnyKey/AllKeys */
 848     {
 849       grab_mask.key_val = AnyKey;
 850 #ifdef SPI_DEBUG
 851       fprintf (stderr, "AnyKey grab!");
 852 #endif
 853       process_cb (controller, &grab_mask);
 854     }
 855   else
 856     {
 857       GSList *l;
 858
 859       for (l = key_listener->keys; l; l = g_slist_next(l))
 860         {
 861           Accessibility_KeyDefinition *keydef = l->data;
 862           long int key_val = keydef->keysym;
 863           /* X Grabs require keycodes, not keysyms */
 864           if (keydef->keystring && keydef->keystring[0])
 865             {
 866               key_val = XStringToKeysym(keydef->keystring);
 867             }
 868           if (key_val > 0)
 869             {
 870               key_val = XKeysymToKeycode (spi_get_display (), (KeySym) key_val);
 871             }
 872           else
 873             {
 874               key_val = keydef->keycode;
 875             }
 876           grab_mask.key_val = key_val;
 877           process_cb (controller, &grab_mask);
 878         }
 879     }
 880 }
 881
 882 static gboolean
 883 spi_controller_register_global_keygrabs (SpiDEController         *controller,
 884                                          DEControllerKeyListener *key_listener)
 885 {
 886   handle_keygrab (controller, key_listener, _register_keygrab);
 887   if (controller->xevie_display == NULL)
 888     return spi_controller_update_key_grabs (controller, NULL);
 889   else
 890     return TRUE;
 891 }
 892
 893 static void
 894 spi_controller_deregister_global_keygrabs (SpiDEController         *controller,
 895                                            DEControllerKeyListener *key_listener)
 896 {
 897   handle_keygrab (controller, key_listener, _deregister_keygrab);
 898   if (controller->xevie_display == NULL)
 899     spi_controller_update_key_grabs (controller, NULL);
 900 }
 901
 902 static gboolean
 903 spi_controller_register_device_listener (SpiDEController      *controller,
 904                                          DEControllerListener *listener)
 905 {
 906   DEControllerKeyListener *key_listener;
 907
 908   switch (listener->type) {
 909   case SPI_DEVICE_TYPE_KBD:
 910       key_listener = (DEControllerKeyListener *) listener;
 911
 912       controller->key_listeners = g_list_prepend (controller->key_listeners,
 913                                                   key_listener);
 914       if (key_listener->mode->global)
 915         {
 916           return spi_controller_register_global_keygrabs (controller, key_listener);
 917         }
 918       else
 919               return TRUE;
 920       break;
 921   case SPI_DEVICE_TYPE_MOUSE:
 922       controller->mouse_listeners = g_list_prepend (controller->mouse_listeners, listener);
 923       break;
 924   default:
 925       DBG (1, g_warning ("listener registration for unknown device type.\n"));
 926       break;
 927   }
 928   return FALSE;
 929 }
 930
 931 static gboolean Accessibility_DeviceEventListener_notifyEvent(SpiRegistry *registry, DEControllerListener *listener, const Accessibility_DeviceEvent *key_event)
 932 {
 933   DBusMessage *message = dbus_message_new_method_call(listener->app_path, listener->path, "org.freedesktop.atspi.Registry", "notifyEvent");
 934   DBusError error;
 935   dbus_bool_t consumed = FALSE;
 936
 937   dbus_error_init(&error);
 938   if (spi_dbus_marshall_deviceEvent(message, key_event))
 939   {
 940     // TODO: Evaluate performance: perhaps rework this whole architecture
 941     // to avoid blocking calls
 942     DBusMessage *reply = dbus_connection_send_with_reply_and_block(registry->droute.bus, message, 1000, &error);
 943     if (reply)
 944     {
 945       DBusError error;
 946       dbus_error_init(&error);
 947       dbus_message_get_args(reply, &error, DBUS_TYPE_BOOLEAN, &consumed, DBUS_TYPE_INVALID);
 948       dbus_message_unref(reply);
 949     }
 950   }
 951   dbus_message_unref(message);
 952   return consumed;
 953 }
 954
 955 static gboolean
 956 spi_controller_notify_mouselisteners (SpiDEController                 *controller,
 957                                       const Accessibility_DeviceEvent *event)
 958 {
 959   GList   *l;
 960   GSList  *notify = NULL, *l2;
 961   GList  **listeners = &controller->mouse_listeners;
 962   gboolean is_consumed;
 963 #ifdef SPI_KEYEVENT_DEBUG
 964   gboolean found = FALSE;
 965 #endif
 966   if (!listeners)
 967     {
 968       return FALSE;
 969     }
 970
 971   for (l = *listeners; l; l = l->next)
 972     {
 973        DEControllerListener *listener = l->data;
 974
 975        if (spi_eventtype_seq_contains_event (listener->types, event))
 976          {
 977            /* we clone (don't dup) the listener, to avoid refcount inc. */
 978            notify = g_slist_prepend (notify,
 979                                      spi_listener_clone (listener));
 980 #ifdef SPI_KEYEVENT_DEBUG
 981            found = TRUE;
 982 #endif
 983          }
 984     }
 985
 986 #ifdef SPI_KEYEVENT_DEBUG
 987   if (!found)
 988     {
 989       g_print ("no match for event\n");
 990     }
 991 #endif
 992
 993   is_consumed = FALSE;
 994   for (l2 = notify; l2 && !is_consumed; l2 = l2->next)
 995     {
 996       DEControllerListener *listener = l2->data;
 997
 998       is_consumed = Accessibility_DeviceEventListener_notifyEvent (controller->registry, listener, event);
 999
1000       spi_listener_clone_free ((DEControllerListener *) l2->data);
1001     }
1002
1003   for (; l2; l2 = l2->next)
1004     {
1005       DEControllerListener *listener = l2->data;
1006       spi_listener_clone_free (listener);
1007       /* clone doesn't have its own ref, so don't use spi_device_listener_free */
1008     }
1009
1010   g_slist_free (notify);
1011
1012 #ifdef SPI_DEBUG
1013   if (is_consumed) g_message ("consumed\n");
1014 #endif
1015   return is_consumed;
1016 }
1017
1018 static void
1019 spi_device_event_controller_forward_mouse_event (SpiDEController *controller,
1020                                                  XEvent *xevent)
1021 {
1022   Accessibility_DeviceEvent mouse_e;
1023   gchar event_name[24];
1024   gboolean is_consumed = FALSE;
1025   gboolean xkb_mod_unlatch_occurred;
1026   XButtonEvent *xbutton_event = (XButtonEvent *) xevent;
1027   dbus_uint32_t ix, iy;
1028
1029   int button = xbutton_event->button;
1030
1031   unsigned int mouse_button_state = xbutton_event->state;
1032
1033   switch (button)
1034     {
1035     case 1:
1036             mouse_button_state |= Button1Mask;
1037             break;
1038     case 2:
1039             mouse_button_state |= Button2Mask;
1040             break;
1041     case 3:
1042             mouse_button_state |= Button3Mask;
1043             break;
1044     case 4:
1045             mouse_button_state |= Button4Mask;
1046             break;
1047     case 5:
1048             mouse_button_state |= Button5Mask;
1049             break;
1050     }
1051
1052   last_mouse_pos->x = ((XButtonEvent *) xevent)->x_root;
1053   last_mouse_pos->y = ((XButtonEvent *) xevent)->y_root;
1054
1055 #ifdef SPI_DEBUG
1056   fprintf (stderr, "mouse button %d %s (%x)\n",
1057            xbutton_event->button,
1058            (xevent->type == ButtonPress) ? "Press" : "Release",
1059            mouse_button_state);
1060 #endif
1061   snprintf (event_name, 22, "mouse:button_%d%c", button,
1062             (xevent->type == ButtonPress) ? 'p' : 'r');
1063
1064   /* TODO: FIXME distinguish between physical and logical buttons */
1065   mouse_e.type      = (xevent->type == ButtonPress) ?
1066                       Accessibility_BUTTON_PRESSED_EVENT :
1067                       Accessibility_BUTTON_RELEASED_EVENT;
1068   mouse_e.id        = button;
1069   mouse_e.hw_code   = button;
1070   mouse_e.modifiers = (dbus_uint16_t) xbutton_event->state;
1071   mouse_e.timestamp = (dbus_uint32_t) xbutton_event->time;
1072   mouse_e.event_string = "";
1073   mouse_e.is_text   = FALSE;
1074   if ((mouse_button_state & mouse_button_mask) !=
1075        (mouse_mask_state & mouse_button_mask))
1076     {
1077       if ((mouse_mask_state & key_modifier_mask) !=
1078           (mouse_button_state & key_modifier_mask))
1079         spi_dec_emit_modifier_event (controller,
1080                                      mouse_mask_state, mouse_button_state);
1081       mouse_mask_state = mouse_button_state;
1082       is_consumed =
1083         spi_controller_notify_mouselisteners (controller, &mouse_e);
1084       ix = last_mouse_pos->x;
1085       iy = last_mouse_pos->y;
1086       emit(controller, event_name, DBUS_TYPE_UINT32, &ix, DBUS_TYPE_UINT32, &iy, DBUS_TYPE_INVALID);
1087     }
1088
1089   xkb_mod_unlatch_occurred = (xevent->type == ButtonPress ||
1090                               xevent->type == ButtonRelease);
1091
1092   /* if client wants to consume this event, and XKB latch state was
1093    *   unset by this button event, we reset it
1094    */
1095   if (is_consumed && xkb_mod_unlatch_occurred)
1096     spi_dec_set_unlatch_pending (controller, mouse_mask_state);
1097
1098   XAllowEvents (spi_get_display (),
1099                 (is_consumed) ? SyncPointer : ReplayPointer,
1100                 CurrentTime);
1101 }
1102
1103 static GdkFilterReturn
1104 global_filter_fn (GdkXEvent *gdk_xevent, GdkEvent *event, gpointer data)
1105 {
1106   XEvent *xevent = gdk_xevent;
1107   SpiDEController *controller;
1108   DEControllerPrivateData *priv;
1109   Display *display = spi_get_display ();
1110   controller = SPI_DEVICE_EVENT_CONTROLLER (data);
1111   priv = (DEControllerPrivateData *)
1112           g_object_get_qdata (G_OBJECT (controller), spi_dec_private_quark);
1113
1114   if (xevent->type == MappingNotify)
1115     xmkeymap = NULL;
1116
1117   if (xevent->type == KeyPress || xevent->type == KeyRelease)
1118     {
1119       if (controller->xevie_display == NULL)
1120         {
1121           gboolean is_consumed;
1122
1123           is_consumed =
1124             spi_device_event_controller_forward_key_event (controller, xevent);
1125
1126           if (is_consumed)
1127             {
1128               int n_events;
1129               int i;
1130               XEvent next_event;
1131               n_events = XPending (display);
1132
1133 #ifdef SPI_KEYEVENT_DEBUG
1134               g_print ("Number of events pending: %d\n", n_events);
1135 #endif
1136               for (i = 0; i < n_events; i++)
1137                 {
1138                   XNextEvent (display, &next_event);
1139                   if (next_event.type != KeyPress &&
1140                       next_event.type != KeyRelease)
1141                         g_warning ("Unexpected event type %d in queue", next_event.type);
1142                  }
1143
1144               XAllowEvents (display, AsyncKeyboard, CurrentTime);
1145               if (n_events)
1146                 XUngrabKeyboard (display, CurrentTime);
1147             }
1148           else
1149             {
1150               if (xevent->type == KeyPress)
1151                 wait_for_release_event (xevent, controller);
1152               XAllowEvents (display, ReplayKeyboard, CurrentTime);
1153             }
1154         }
1155
1156       return GDK_FILTER_CONTINUE;
1157     }
1158   if (xevent->type == ButtonPress || xevent->type == ButtonRelease)
1159     {
1160       spi_device_event_controller_forward_mouse_event (controller, xevent);
1161     }
1162   if (xevent->type == priv->xkb_base_event_code)
1163     {
1164       XkbAnyEvent * xkb_ev = (XkbAnyEvent *) xevent;
1165       /* ugly but probably necessary...*/
1166       XSynchronize (display, TRUE);
1167
1168       if (xkb_ev->xkb_type == XkbStateNotify)
1169         {
1170           XkbStateNotifyEvent *xkb_snev =
1171                   (XkbStateNotifyEvent *) xkb_ev;
1172           /* check the mouse, to catch mouse events grabbed by
1173            * another client; in case we should revert this XKB delatch
1174            */
1175           if (!priv->pending_xkb_mod_relatch_mask)
1176             {
1177               int x, y;
1178               gboolean moved;
1179               spi_dec_mouse_check (controller, &x, &y, &moved);
1180             }
1181           /* we check again, since the previous call may have
1182              changed this flag */
1183           if (priv->pending_xkb_mod_relatch_mask)
1184             {
1185               unsigned int feedback_mask;
1186 #ifdef SPI_XKB_DEBUG
1187               fprintf (stderr, "relatching %x\n",
1188                        priv->pending_xkb_mod_relatch_mask);
1189 #endif
1190               /* temporarily turn off the latch bell, if it's on */
1191               XkbGetControls (display,
1192                               XkbAccessXFeedbackMask,
1193                               priv->xkb_desc);
1194               feedback_mask = priv->xkb_desc->ctrls->ax_options;
1195               if (feedback_mask & XkbAX_StickyKeysFBMask)
1196               {
1197                 XkbControlsChangesRec changes = {XkbAccessXFeedbackMask,
1198                                                  0, False};
1199                 priv->xkb_desc->ctrls->ax_options
1200                               &= ~(XkbAX_StickyKeysFBMask);
1201                 XkbChangeControls (display, priv->xkb_desc, &changes);
1202               }
1203               /* TODO: account for lock as well as latch */
1204               XkbLatchModifiers (display,
1205                                  XkbUseCoreKbd,
1206                                  priv->pending_xkb_mod_relatch_mask,
1207                                  priv->pending_xkb_mod_relatch_mask);
1208               if (feedback_mask & XkbAX_StickyKeysFBMask)
1209               {
1210                 XkbControlsChangesRec changes = {XkbAccessXFeedbackMask,
1211                                                  0, False};
1212                 priv->xkb_desc->ctrls->ax_options = feedback_mask;
1213                 XkbChangeControls (display, priv->xkb_desc, &changes);
1214               }
1215 #ifdef SPI_XKB_DEBUG
1216               fprintf (stderr, "relatched %x\n",
1217                        priv->pending_xkb_mod_relatch_mask);
1218 #endif
1219               priv->pending_xkb_mod_relatch_mask = 0;
1220             }
1221           else
1222             {
1223               priv->xkb_latch_mask = xkb_snev->latched_mods;
1224             }
1225         }
1226         else
1227                DBG (2, g_warning ("XKB event %d\n", xkb_ev->xkb_type));
1228       XSynchronize (display, FALSE);
1229     }
1230
1231   return GDK_FILTER_CONTINUE;
1232 }
1233
1234 static int
1235 _spi_controller_device_error_handler (Display *display, XErrorEvent *error)
1236 {
1237   if (error->error_code == BadAccess)
1238     {
1239       g_message ("Could not complete key grab: grab already in use.\n");
1240       spi_error_code = BadAccess;
1241       return 0;
1242     }
1243   else
1244     {
1245       return (*x_default_error_handler) (display, error);
1246     }
1247 }
1248
1249 static void
1250 spi_controller_register_with_devices (SpiDEController *controller)
1251 {
1252   DEControllerPrivateData *priv = (DEControllerPrivateData *)
1253           g_object_get_qdata (G_OBJECT (controller), spi_dec_private_quark);
1254   /* FIXME: should check for extension first! */
1255   XTestGrabControl (spi_get_display (), True);
1256
1257   /* calls to device-specific implementations and routines go here */
1258   /* register with: keyboard hardware code handler */
1259   /* register with: (translated) keystroke handler */
1260
1261   priv->have_xkb = XkbQueryExtension (spi_get_display (),
1262                                       &priv->xkb_major_extension_opcode,
1263                                       &priv->xkb_base_event_code,
1264                                       &priv->xkb_base_error_code, NULL, NULL);
1265   if (priv->have_xkb)
1266     {
1267       gint i;
1268       guint64 reserved = 0;
1269       priv->xkb_desc = XkbGetMap (spi_get_display (), XkbKeySymsMask, XkbUseCoreKbd);
1270       XkbSelectEvents (spi_get_display (),
1271                        XkbUseCoreKbd,
1272                        XkbStateNotifyMask, XkbStateNotifyMask);
1273       _numlock_physical_mask = XkbKeysymToModifiers (spi_get_display (),
1274                                                      XK_Num_Lock);
1275       for (i = priv->xkb_desc->max_key_code; i >= priv->xkb_desc->min_key_code; --i)
1276       {
1277           if (priv->xkb_desc->map->key_sym_map[i].kt_index[0] == XkbOneLevelIndex)
1278           {
1279               if (XKeycodeToKeysym (spi_get_display (), i, 0) != 0)
1280               {
1281                   /* don't use this one if there's a grab client! */
1282                   gdk_error_trap_push ();
1283                   XGrabKey (spi_get_display (), i, 0,
1284                             gdk_x11_get_default_root_xwindow (),
1285                             TRUE,
1286                             GrabModeSync, GrabModeSync);
1287                   XSync (spi_get_display (), TRUE);
1288                   XUngrabKey (spi_get_display (), i, 0,
1289                               gdk_x11_get_default_root_xwindow ());
1290                   if (!gdk_error_trap_pop ())
1291                   {
1292                       reserved = i;
1293                       break;
1294                   }
1295               }
1296           }
1297       }
1298       if (reserved)
1299       {
1300           priv->reserved_keycode = reserved;
1301           priv->reserved_keysym = XKeycodeToKeysym (spi_get_display (), reserved, 0);
1302       }
1303       else
1304       {
1305           priv->reserved_keycode = XKeysymToKeycode (spi_get_display (), XK_numbersign);
1306           priv->reserved_keysym = XK_numbersign;
1307       }
1308 #ifdef SPI_RESERVED_DEBUG
1309       unsigned sym = 0;
1310       sym = XKeycodeToKeysym (spi_get_display (), reserved, 0);
1311       fprintf (stderr, "%x\n", sym);
1312       fprintf (stderr, "setting the reserved keycode to %d (%s)\n",
1313                reserved,
1314                XKeysymToString (XKeycodeToKeysym (spi_get_display (),
1315                                                             reserved, 0)));
1316 #endif
1317     }
1318
1319   gdk_window_add_filter (NULL, global_filter_fn, controller);
1320
1321   gdk_window_set_events (gdk_get_default_root_window (),
1322                          GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK);
1323
1324   x_default_error_handler = XSetErrorHandler (_spi_controller_device_error_handler);
1325 }
1326
1327 static gboolean
1328 spi_key_set_contains_key (GSList                          *key_set,
1329                           const Accessibility_DeviceEvent *key_event)
1330 {
1331   gint i;
1332   gint len;
1333   GSList *l;
1334
1335   if (!key_set)
1336     {
1337       g_print ("null key set!");
1338       return TRUE;
1339     }
1340
1341   len = g_slist_length (key_set);
1342
1343   if (len == 0) /* special case, means "all keys/any key" */
1344     {
1345 #ifdef SPI_DEBUG
1346       g_print ("anykey\n");
1347 #endif
1348       return TRUE;
1349     }
1350
1351   for (l = key_set,i = 0; l; l = g_slist_next(l),i++)
1352     {
1353       Accessibility_KeyDefinition *kd = l->data;
1354 #ifdef SPI_KEYEVENT_DEBUG
1355       g_print ("key_set[%d] event = %d, code = %d; key_event %d, code %d, string %s\n",
1356                 i,
1357                 (int) kd->keysym,
1358                 (int) kd->keycode,
1359                 (int) key_event->id,
1360                 (int) key_event->hw_code,
1361                 key_event->event_string);
1362 #endif
1363       if (kd->keysym == (dbus_uint32_t) key_event->id)
1364         {
1365           return TRUE;
1366         }
1367       if (kd->keycode == (dbus_uint32_t) key_event->hw_code)
1368         {
1369           return TRUE;
1370         }
1371       if (key_event->event_string && key_event->event_string[0] &&
1372           !strcmp (kd->keystring, key_event->event_string))
1373         {
1374           return TRUE;
1375         }
1376     }
1377
1378   return FALSE;
1379 }
1380
1381 static gboolean
1382 spi_eventtype_seq_contains_event (dbus_uint32_t types,
1383                                   const Accessibility_DeviceEvent *event)
1384 {
1385   if (types == 0) /* special case, means "all events/any event" */
1386     {
1387       return TRUE;
1388     }
1389
1390   return (types & (1 << event->type));
1391 }
1392
1393 static gboolean
1394 spi_key_event_matches_listener (const Accessibility_DeviceEvent *key_event,
1395                                 DEControllerKeyListener         *listener,
1396                                 dbus_bool_t                    is_system_global)
1397 {
1398   if (((key_event->modifiers & 0xFF) == (dbus_uint16_t) (listener->mask & 0xFF)) &&
1399        spi_key_set_contains_key (listener->keys, key_event) &&
1400        spi_eventtype_seq_contains_event (listener->listener.types, key_event) &&
1401       (is_system_global == listener->mode->global))
1402     {
1403       return TRUE;
1404     }
1405   else
1406     {
1407       return FALSE;
1408     }
1409 }
1410
1411 static gboolean
1412 spi_controller_notify_keylisteners (SpiDEController                 *controller,
1413                                     Accessibility_DeviceEvent       *key_event,
1414                                     dbus_bool_t                    is_system_global)
1415 {
1416   GList   *l;
1417   GSList  *notify = NULL, *l2;
1418   GList  **key_listeners = &controller->key_listeners;
1419   gboolean is_consumed;
1420
1421   if (!key_listeners)
1422     {
1423       return FALSE;
1424     }
1425
1426   /* set the NUMLOCK event mask bit if appropriate: see bug #143702 */
1427   if (key_event->modifiers & _numlock_physical_mask)
1428       key_event->modifiers |= SPI_KEYMASK_NUMLOCK;
1429
1430   for (l = *key_listeners; l; l = l->next)
1431     {
1432        DEControllerKeyListener *key_listener = l->data;
1433
1434        if (spi_key_event_matches_listener (key_event, key_listener, is_system_global))
1435          {
1436            /* we clone (don't dup) the listener, to avoid refcount inc. */
1437            notify = g_slist_prepend (notify,
1438                                      spi_key_listener_clone (key_listener));
1439          }
1440     }
1441
1442 #ifdef SPI_KEYEVENT_DEBUG
1443   if (!notify)
1444     {
1445       g_print ("no match for event\n");
1446     }
1447 #endif
1448
1449   is_consumed = FALSE;
1450   for (l2 = notify; l2 && !is_consumed; l2 = l2->next)
1451     {
1452       DEControllerKeyListener *key_listener = l2->data;
1453
1454       is_consumed = Accessibility_DeviceEventListener_notifyEvent (controller->registry, &key_listener->listener, key_event) &&
1455                     key_listener->mode->preemptive;
1456
1457       spi_key_listener_clone_free (key_listener);
1458     }
1459
1460   for (; l2; l2 = l2->next)
1461     {
1462       DEControllerKeyListener *key_listener = l2->data;
1463       spi_key_listener_clone_free (key_listener);
1464       /* clone doesn't have its own ref, so don't use spi_dec_listener_free */
1465     }
1466
1467   g_slist_free (notify);
1468
1469 #ifdef SPI_DEBUG
1470   if (is_consumed) g_message ("consumed\n");
1471 #endif
1472   return is_consumed;
1473 }
1474
1475 static gboolean
1476 spi_clear_error_state (void)
1477 {
1478         gboolean retval = spi_error_code != 0;
1479         spi_error_code = 0;
1480         return retval;
1481 }
1482
1483 static Accessibility_DeviceEvent
1484 spi_keystroke_from_x_key_event (XKeyEvent *x_key_event)
1485 {
1486   Accessibility_DeviceEvent key_event;
1487   KeySym keysym;
1488   const int cbuf_bytes = 20;
1489   char cbuf [21];
1490   int nbytes;
1491
1492   nbytes = XLookupString (x_key_event, cbuf, cbuf_bytes, &keysym, NULL);
1493   key_event.id = (dbus_int32_t)(keysym);
1494   key_event.hw_code = (dbus_int16_t) x_key_event->keycode;
1495   if (((XEvent *) x_key_event)->type == KeyPress)
1496     {
1497       key_event.type = Accessibility_KEY_PRESSED_EVENT;
1498     }
1499   else
1500     {
1501       key_event.type = Accessibility_KEY_RELEASED_EVENT;
1502     }
1503   key_event.modifiers = (dbus_uint16_t)(x_key_event->state);
1504   key_event.is_text = FALSE;
1505   switch (keysym)
1506     {
1507       case ' ':
1508         key_event.event_string = g_strdup ("space");
1509         break;
1510       case XK_Tab:
1511         key_event.event_string = g_strdup ("Tab");
1512         break;
1513       case XK_BackSpace:
1514         key_event.event_string = g_strdup ("Backspace");
1515         break;
1516       case XK_Return:
1517         key_event.event_string = g_strdup ("Return");
1518         break;
1519       case XK_Home:
1520         key_event.event_string = g_strdup ("Home");
1521         break;
1522       case XK_Page_Down:
1523         key_event.event_string = g_strdup ("Page_Down");
1524         break;
1525       case XK_Page_Up:
1526         key_event.event_string = g_strdup ("Page_Up");
1527         break;
1528       case XK_F1:
1529         key_event.event_string = g_strdup ("F1");
1530         break;
1531       case XK_F2:
1532         key_event.event_string = g_strdup ("F2");
1533         break;
1534       case XK_F3:
1535         key_event.event_string = g_strdup ("F3");
1536         break;
1537       case XK_F4:
1538         key_event.event_string = g_strdup ("F4");
1539         break;
1540       case XK_F5:
1541         key_event.event_string = g_strdup ("F5");
1542         break;
1543       case XK_F6:
1544         key_event.event_string = g_strdup ("F6");
1545         break;
1546       case XK_F7:
1547         key_event.event_string = g_strdup ("F7");
1548         break;
1549       case XK_F8:
1550         key_event.event_string = g_strdup ("F8");
1551         break;
1552       case XK_F9:
1553         key_event.event_string = g_strdup ("F9");
1554         break;
1555       case XK_F10:
1556         key_event.event_string = g_strdup ("F10");
1557         break;
1558       case XK_F11:
1559         key_event.event_string = g_strdup ("F11");
1560         break;
1561       case XK_F12:
1562         key_event.event_string = g_strdup ("F12");
1563         break;
1564       case XK_End:
1565         key_event.event_string = g_strdup ("End");
1566         break;
1567       case XK_Escape:
1568         key_event.event_string = g_strdup ("Escape");
1569         break;
1570       case XK_Up:
1571         key_event.event_string = g_strdup ("Up");
1572         break;
1573       case XK_Down:
1574         key_event.event_string = g_strdup ("Down");
1575         break;
1576       case XK_Left:
1577         key_event.event_string = g_strdup ("Left");
1578         break;
1579       case XK_Right:
1580         key_event.event_string = g_strdup ("Right");
1581         break;
1582       default:
1583         if (nbytes > 0)
1584           {
1585             gunichar c;
1586             cbuf[nbytes] = '\0'; /* OK since length is cbuf_bytes+1 */
1587             key_event.event_string = g_strdup (cbuf);
1588             c = keysym2ucs (keysym);
1589             if (c > 0 && !g_unichar_iscntrl (c))
1590               {
1591                 key_event.is_text = TRUE;
1592                 /* incorrect for some composed chars? */
1593               }
1594           }
1595         else
1596           {
1597             key_event.event_string = g_strdup ("");
1598           }
1599     }
1600
1601   key_event.timestamp = (dbus_uint32_t) x_key_event->time;
1602 #ifdef SPI_KEYEVENT_DEBUG
1603   {
1604     char *pressed_str  = "pressed";
1605     char *released_str = "released";
1606     char *state_ptr;
1607
1608     if (key_event.type == Accessibility_KEY_PRESSED_EVENT)
1609       state_ptr = pressed_str;
1610     else
1611       state_ptr = released_str;
1612
1613     fprintf (stderr,
1614              "Key %lu %s (%c), modifiers %d; string=%s [%x] %s\n",
1615              (unsigned long) keysym,
1616              state_ptr,
1617              keysym ? (int) keysym : '*',
1618              (int) x_key_event->state,
1619              key_event.event_string,
1620              key_event.event_string[0],
1621              (key_event.is_text == TRUE) ? "(text)" : "(not text)");
1622   }
1623 #endif
1624 #ifdef SPI_DEBUG
1625   fprintf (stderr, "%s%c\n",
1626      (x_key_event->state & Mod1Mask)?"Alt-":"",
1627      ((x_key_event->state & ShiftMask)^(x_key_event->state & LockMask))?
1628      g_ascii_toupper (keysym) : g_ascii_tolower (keysym));
1629   fprintf (stderr, "serial: %x Time: %x\n", x_key_event->serial, x_key_event->time);
1630 #endif /* SPI_DEBUG */
1631   return key_event;
1632 }
1633
1634 static gboolean
1635 spi_controller_update_key_grabs (SpiDEController           *controller,
1636                                  Accessibility_DeviceEvent *recv)
1637 {
1638   GList *l, *next;
1639   gboolean   update_failed = FALSE;
1640   KeyCode keycode = 0;
1641
1642   g_return_val_if_fail (controller != NULL, FALSE);
1643
1644   /*
1645    * masks known to work with default RH 7.1+:
1646    * 0 (no mods), LockMask, Mod1Mask, Mod2Mask, ShiftMask,
1647    * ShiftMask|LockMask, Mod1Mask|LockMask, Mod2Mask|LockMask,
1648    * ShiftMask|Mod1Mask, ShiftMask|Mod2Mask, Mod1Mask|Mod2Mask,
1649    * ShiftMask|LockMask|Mod1Mask, ShiftMask|LockMask|Mod2Mask,
1650    *
1651    * ControlMask grabs are broken, must be in use already
1652    */
1653   if (recv)
1654     keycode = keycode_for_keysym (controller, recv->id, NULL);
1655   for (l = controller->keygrabs_list; l; l = next)
1656     {
1657       gboolean do_remove;
1658       gboolean re_issue_grab;
1659       DEControllerGrabMask *grab_mask = l->data;
1660
1661       next = l->next;
1662
1663       re_issue_grab = recv &&
1664               (recv->modifiers & grab_mask->mod_mask) &&
1665               (grab_mask->key_val == keycode);
1666
1667 #ifdef SPI_DEBUG
1668       fprintf (stderr, "mask=%lx %lx (%c%c) %s\n",
1669                (long int) grab_mask->key_val,
1670                (long int) grab_mask->mod_mask,
1671                grab_mask->pending_add ? '+' : '.',
1672                grab_mask->pending_remove ? '-' : '.',
1673                re_issue_grab ? "re-issue": "");
1674 #endif
1675
1676       do_remove = FALSE;
1677
1678       if (grab_mask->pending_add && grab_mask->pending_remove)
1679         {
1680           do_remove = TRUE;
1681         }
1682       else if (grab_mask->pending_remove)
1683         {
1684 #ifdef SPI_DEBUG
1685       fprintf (stderr, "ungrabbing, mask=%x\n", grab_mask->mod_mask);
1686 #endif
1687           XUngrabKey (spi_get_display (),
1688                       grab_mask->key_val,
1689                       grab_mask->mod_mask,
1690                       gdk_x11_get_default_root_xwindow ());
1691
1692           do_remove = TRUE;
1693         }
1694       else if (grab_mask->pending_add || re_issue_grab)
1695         {
1696
1697 #ifdef SPI_DEBUG
1698           fprintf (stderr, "grab %d with mask %x\n", grab_mask->key_val, grab_mask->mod_mask);
1699 #endif
1700           XGrabKey (spi_get_display (),
1701                     grab_mask->key_val,
1702                     grab_mask->mod_mask,
1703                     gdk_x11_get_default_root_xwindow (),
1704                     True,
1705                     GrabModeSync,
1706                     GrabModeSync);
1707           XSync (spi_get_display (), False);
1708           update_failed = spi_clear_error_state ();
1709           if (update_failed) {
1710                   while (grab_mask->ref_count > 0) --grab_mask->ref_count;
1711                   do_remove = TRUE;
1712           }
1713         }
1714
1715       grab_mask->pending_add = FALSE;
1716       grab_mask->pending_remove = FALSE;
1717
1718       if (do_remove)
1719         {
1720           g_assert (grab_mask->ref_count <= 0);
1721
1722           controller->keygrabs_list = g_list_delete_link (
1723             controller->keygrabs_list, l);
1724
1725           spi_grab_mask_free (grab_mask);
1726         }
1727
1728     }
1729
1730   return ! update_failed;
1731 }
1732
1733 /*
1734  * Implemented GObject::finalize
1735  */
1736 static void
1737 spi_device_event_controller_object_finalize (GObject *object)
1738 {
1739   SpiDEController *controller;
1740   DEControllerPrivateData *private;
1741   controller = SPI_DEVICE_EVENT_CONTROLLER (object);
1742   GObjectClass *parent_class = G_OBJECT_CLASS(spi_device_event_controller_parent_class);
1743 #ifdef SPI_DEBUG
1744   fprintf(stderr, "spi_device_event_controller_object_finalize called\n");
1745 #endif
1746   /* disconnect any special listeners, get rid of outstanding keygrabs */
1747   XUngrabKey (spi_get_display (), AnyKey, AnyModifier, DefaultRootWindow (spi_get_display ()));
1748
1749 #ifdef HAVE_XEVIE
1750   if (controller->xevie_display != NULL)
1751     {
1752       XevieEnd(controller->xevie_display);
1753 #ifdef SPI_KEYEVENT_DEBUG
1754       printf("XevieEnd(dpy) finished \n");
1755 #endif
1756     }
1757 #endif
1758
1759   private = g_object_get_data (G_OBJECT (controller), "spi-dec-private");
1760   if (private->xkb_desc)
1761           XkbFreeKeyboard (private->xkb_desc, 0, True);
1762   g_free (private);
1763   parent_class->finalize (object);
1764 }
1765
1766 /*
1767  * DBus Accessibility::DEController::registerKeystrokeListener
1768  *     method implementation
1769  */
1770 static DBusMessage *
1771 impl_register_keystroke_listener (DBusConnection *bus,
1772                                   DBusMessage *message,
1773                                   void *user_data)
1774 {
1775   SpiDEController *controller = SPI_REGISTRY(user_data)->de_controller;
1776   DEControllerKeyListener *dec_listener;
1777   DBusMessageIter iter, iter_array;
1778   const char *path;
1779   GSList *keys = NULL;
1780   dbus_int32_t mask, type;
1781   Accessibility_EventListenerMode *mode;
1782   dbus_bool_t ret;
1783   DBusMessage *reply;
1784   char *keystring;
1785
1786   dbus_message_iter_init(message, &iter);
1787   // TODO: verify type signature
1788   dbus_message_iter_get_basic(&iter, &path);
1789   dbus_message_iter_next(&iter);
1790   dbus_message_iter_recurse(&iter, &iter_array);
1791   while (dbus_message_iter_get_arg_type(&iter_array) != DBUS_TYPE_INVALID)
1792   {
1793     Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *)g_malloc(sizeof(Accessibility_KeyDefinition));
1794     if (!spi_dbus_message_iter_get_struct(&iter_array, DBUS_TYPE_INT32, &kd->keycode, DBUS_TYPE_INT32, &kd->keysym, DBUS_TYPE_STRING, &keystring, DBUS_TYPE_INVALID))
1795     {
1796       break;
1797     }
1798     kd->keystring = g_strdup (keystring);
1799     keys = g_slist_append(keys, kd);
1800   }
1801   dbus_message_iter_next(&iter);
1802   dbus_message_iter_get_basic(&iter, &mask);
1803   dbus_message_iter_next(&iter);
1804   dbus_message_iter_get_basic(&iter, &type);
1805   dbus_message_iter_next(&iter);
1806   mode = (Accessibility_EventListenerMode *)g_malloc(sizeof(Accessibility_EventListenerMode));
1807   if (mode)
1808   {
1809     spi_dbus_message_iter_get_struct(&iter, DBUS_TYPE_BOOLEAN, &mode->synchronous, DBUS_TYPE_BOOLEAN, &mode->preemptive, DBUS_TYPE_BOOLEAN, &mode->global, DBUS_TYPE_INVALID);
1810   }
1811 #ifdef SPI_DEBUG
1812   fprintf (stderr, "registering keystroke listener %s:%s with maskVal %lu\n",
1813            dbus_message_get_sender(message), path, (unsigned long) mask);
1814 #endif
1815   dec_listener = spi_dec_key_listener_new (dbus_message_get_sender(message), path, keys, mask, type, mode);
1816   ret = spi_controller_register_device_listener (
1817           controller, (DEControllerListener *) dec_listener);
1818   reply = dbus_message_new_method_return (message);
1819   if (reply)
1820   {
1821     dbus_message_append_args (reply, DBUS_TYPE_BOOLEAN, &ret, DBUS_TYPE_INVALID);
1822   }
1823   return reply;
1824 }
1825
1826 /*
1827  * DBus Accessibility::DEController::registerDeviceEventListener
1828  *     method implementation
1829  */
1830 static DBusMessage *
1831 impl_register_device_listener (DBusConnection *bus,
1832                                   DBusMessage *message,
1833                                   void *user_data)
1834 {
1835   SpiDEController *controller = SPI_REGISTRY(user_data)->de_controller;
1836   DEControllerListener *dec_listener;
1837   DBusError error;
1838   const char *path;
1839   dbus_int32_t event_types;
1840   dbus_bool_t ret;
1841   DBusMessage *reply;
1842
1843   dbus_error_init(&error);
1844   if (!dbus_message_get_args(message, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_UINT32, &event_types, DBUS_TYPE_INVALID))
1845   {
1846     return spi_dbus_general_error (message);
1847   }
1848   dec_listener = spi_dec_listener_new (dbus_message_get_sender(message), path, event_types);
1849   ret =  spi_controller_register_device_listener (
1850           controller, (DEControllerListener *) dec_listener);
1851   reply = dbus_message_new_method_return (message);
1852   if (reply)
1853   {
1854     dbus_message_append_args (reply, DBUS_TYPE_BOOLEAN, &ret, DBUS_TYPE_INVALID);
1855   }
1856   return reply;
1857 }
1858
1859 typedef struct {
1860         DBusConnection *bus;
1861         DEControllerListener    *listener;
1862 } RemoveListenerClosure;
1863
1864 static SpiReEntrantContinue
1865 remove_listener_cb (GList * const *list,
1866                     gpointer       user_data)
1867 {
1868   DEControllerListener  *listener = (*list)->data;
1869   RemoveListenerClosure *ctx = user_data;
1870
1871   if (!strcmp(ctx->listener->app_path, listener->app_path) &&
1872       !strcmp(ctx->listener->path, listener->path))
1873     {
1874       spi_re_entrant_list_delete_link (list);
1875       spi_dec_listener_free (listener);
1876     }
1877
1878   return SPI_RE_ENTRANT_CONTINUE;
1879 }
1880
1881 static SpiReEntrantContinue
1882 copy_key_listener_cb (GList * const *list,
1883                       gpointer       user_data)
1884 {
1885   DEControllerKeyListener  *key_listener = (*list)->data;
1886   RemoveListenerClosure    *ctx = user_data;
1887
1888   if (!strcmp(ctx->listener->app_path, key_listener->listener.app_path) &&
1889       !strcmp(ctx->listener->path, key_listener->listener.path))
1890     {
1891       /* TODO: FIXME aggregate keys in case the listener is registered twice */
1892       DEControllerKeyListener *ctx_key_listener =
1893         (DEControllerKeyListener *) ctx->listener;
1894       keylist_free (ctx_key_listener->keys);
1895       ctx_key_listener->keys = keylist_clone(key_listener->keys);
1896     }
1897
1898   return SPI_RE_ENTRANT_CONTINUE;
1899 }
1900
1901 static void
1902 spi_controller_deregister_device_listener (SpiDEController            *controller,
1903                                            DEControllerListener *listener)
1904 {
1905   RemoveListenerClosure  ctx;
1906
1907   ctx.bus = controller->registry->droute.bus;
1908   ctx.listener = listener;
1909
1910   spi_re_entrant_list_foreach (&controller->mouse_listeners,
1911                                remove_listener_cb, &ctx);
1912 }
1913
1914 static void
1915 spi_deregister_controller_key_listener (SpiDEController            *controller,
1916                                         DEControllerKeyListener    *key_listener)
1917 {
1918   RemoveListenerClosure  ctx;
1919
1920   ctx.bus = controller->registry->droute.bus;
1921   ctx.listener = (DEControllerListener *) key_listener;
1922
1923   /* special case, copy keyset from existing controller list entry */
1924   if (g_slist_length(key_listener->keys) == 0)
1925     {
1926       spi_re_entrant_list_foreach (&controller->key_listeners,
1927                                   copy_key_listener_cb, &ctx);
1928     }
1929
1930   spi_controller_deregister_global_keygrabs (controller, key_listener);
1931
1932   spi_re_entrant_list_foreach (&controller->key_listeners,
1933                                 remove_listener_cb, &ctx);
1934
1935 }
1936
1937 /*
1938  * DBus Accessibility::DEController::deregisterKeystrokeListener
1939  *     method implementation
1940  */
1941 static DBusMessage *
1942 impl_deregister_keystroke_listener (DBusConnection *bus,
1943                                   DBusMessage *message,
1944                                   void *user_data)
1945 {
1946   SpiDEController *controller = SPI_REGISTRY(user_data)->de_controller;
1947   DEControllerKeyListener *key_listener;
1948   DBusMessageIter iter, iter_array;
1949   const char *path;
1950   GSList *keys = NULL;
1951   dbus_int32_t mask, type;
1952   DBusMessage *reply;
1953
1954   dbus_message_iter_init(message, &iter);
1955   // TODO: verify type signature
1956   dbus_message_iter_get_basic(&iter, &path);
1957   dbus_message_iter_next(&iter);
1958   dbus_message_iter_recurse(&iter, &iter_array);
1959   while (dbus_message_iter_get_arg_type(&iter_array) != DBUS_TYPE_INVALID)
1960   {
1961     Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *)g_malloc(sizeof(Accessibility_KeyDefinition));
1962   char *keystring;
1963
1964     if (!spi_dbus_message_iter_get_struct(&iter_array, DBUS_TYPE_INT32, &kd->keycode, DBUS_TYPE_INT32, &kd->keysym, DBUS_TYPE_STRING, &keystring, DBUS_TYPE_INVALID))
1965     {
1966       break;
1967     }
1968     kd->keystring = g_strdup (keystring);
1969     keys = g_slist_append(keys, kd);
1970   }
1971   dbus_message_iter_next(&iter);
1972   dbus_message_iter_get_basic(&iter, &mask);
1973   dbus_message_iter_next(&iter);
1974   dbus_message_iter_get_basic(&iter, &type);
1975   dbus_message_iter_next(&iter);
1976   key_listener = spi_dec_key_listener_new (dbus_message_get_sender(message), path, keys, mask, type, NULL);
1977 #ifdef SPI_DEREGISTER_DEBUG
1978   fprintf (stderr, "deregistering keystroke listener %p with maskVal %lu\n",
1979            (void *) l, (unsigned long) mask->value);
1980 #endif
1981
1982   spi_deregister_controller_key_listener (controller, key_listener);
1983
1984   spi_dec_listener_free ((DEControllerListener *) key_listener);
1985   reply = dbus_message_new_method_return (message);
1986   return reply;
1987 }
1988
1989 /*
1990  * DBus Accessibility::DEController::deregisterDeviceEventListener
1991  *     method implementation
1992  */
1993 static DBusMessage *
1994 impl_deregister_device_listener (DBusConnection *bus,
1995                                   DBusMessage *message,
1996                                   void *user_data)
1997 {
1998   SpiDEController *controller = SPI_REGISTRY(user_data)->de_controller;
1999   DEControllerListener *listener;
2000   DBusError error;
2001   const char *path;
2002   dbus_int32_t event_types;
2003   DBusMessage *reply;
2004
2005   dbus_error_init(&error);
2006   if (!dbus_message_get_args(message, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_UINT32, &event_types, DBUS_TYPE_INVALID))
2007   {
2008     return spi_dbus_general_error (message);
2009   }
2010   listener = spi_dec_listener_new (dbus_message_get_sender(message), path, event_types);
2011   spi_controller_deregister_device_listener (
2012           controller, listener);
2013   reply = dbus_message_new_method_return (message);
2014   return reply;
2015 }
2016
2017 static unsigned int dec_xkb_get_slowkeys_delay (SpiDEController *controller)
2018 {
2019   unsigned int retval = 0;
2020   DEControllerPrivateData *priv = (DEControllerPrivateData *)
2021           g_object_get_qdata (G_OBJECT (controller), spi_dec_private_quark);
2022 #ifdef HAVE_XKB
2023 #ifdef XKB_HAS_GET_SLOW_KEYS_DELAY
2024   retval = XkbGetSlowKeysDelay (spi_get_display (),
2025                                 XkbUseCoreKbd, &bounce_delay);
2026 #else
2027   if (!(priv->xkb_desc == (XkbDescPtr) BadAlloc || priv->xkb_desc == NULL))
2028     {
2029       Status s = XkbGetControls (spi_get_display (),
2030                                  XkbAllControlsMask, priv->xkb_desc);
2031       if (s == Success)
2032         {
2033          if (priv->xkb_desc->ctrls->enabled_ctrls & XkbSlowKeysMask)
2034                  retval = priv->xkb_desc->ctrls->slow_keys_delay;
2035         }
2036     }
2037 #endif
2038 #endif
2039 #ifdef SPI_XKB_DEBUG
2040         fprintf (stderr, "SlowKeys delay: %d\n", (int) retval);
2041 #endif
2042         return retval;
2043 }
2044
2045 static unsigned int dec_xkb_get_bouncekeys_delay (SpiDEController *controller)
2046 {
2047   unsigned int retval = 0;
2048   DEControllerPrivateData *priv = (DEControllerPrivateData *)
2049           g_object_get_qdata (G_OBJECT (controller), spi_dec_private_quark);
2050 #ifdef HAVE_XKB
2051 #ifdef XKB_HAS_GET_BOUNCE_KEYS_DELAY
2052   retval = XkbGetBounceKeysDelay (spi_get_display (),
2053                                   XkbUseCoreKbd, &bounce_delay);
2054 #else
2055   if (!(priv->xkb_desc == (XkbDescPtr) BadAlloc || priv->xkb_desc == NULL))
2056     {
2057       Status s = XkbGetControls (spi_get_display (),
2058                                  XkbAllControlsMask, priv->xkb_desc);
2059       if (s == Success)
2060         {
2061           if (priv->xkb_desc->ctrls->enabled_ctrls & XkbBounceKeysMask)
2062                   retval = priv->xkb_desc->ctrls->debounce_delay;
2063         }
2064     }
2065 #endif
2066 #endif
2067 #ifdef SPI_XKB_DEBUG
2068   fprintf (stderr, "BounceKeys delay: %d\n", (int) retval);
2069 #endif
2070   return retval;
2071 }
2072
2073 static gboolean
2074 dec_synth_keycode_press (SpiDEController *controller,
2075                          unsigned int keycode)
2076 {
2077         unsigned int time = CurrentTime;
2078         unsigned int bounce_delay;
2079         unsigned int elapsed_msec;
2080         struct timeval tv;
2081         DEControllerPrivateData *priv =
2082                 (DEControllerPrivateData *) g_object_get_qdata (G_OBJECT (controller),
2083                                                                 spi_dec_private_quark);
2084         if (keycode == priv->last_release_keycode)
2085         {
2086                 bounce_delay = dec_xkb_get_bouncekeys_delay (controller);
2087                 if (bounce_delay)
2088                 {
2089                         gettimeofday (&tv, NULL);
2090                         elapsed_msec =
2091                                 (tv.tv_sec - priv->last_release_time.tv_sec) * 1000
2092                                 + (tv.tv_usec - priv->last_release_time.tv_usec) / 1000;
2093 #ifdef SPI_XKB_DEBUG
2094                         fprintf (stderr, "%d ms elapsed (%ld usec)\n", elapsed_msec,
2095                                  (long) (tv.tv_usec - priv->last_release_time.tv_usec));
2096 #endif
2097 #ifdef THIS_IS_BROKEN
2098                         if (elapsed_msec < bounce_delay)
2099                                 time = bounce_delay - elapsed_msec + 1;
2100 #else
2101                         time = bounce_delay + 10;
2102                         /* fudge for broken XTest */
2103 #endif
2104 #ifdef SPI_XKB_DEBUG
2105                         fprintf (stderr, "waiting %d ms\n", time);
2106 #endif
2107                 }
2108         }
2109         XTestFakeKeyEvent (spi_get_display (), keycode, True, time);
2110         priv->last_press_keycode = keycode;
2111         XFlush (spi_get_display ());
2112         XSync (spi_get_display (), False);
2113         gettimeofday (&priv->last_press_time, NULL);
2114         return TRUE;
2115 }
2116
2117 static gboolean
2118 dec_synth_keycode_release (SpiDEController *controller,
2119                            unsigned int keycode)
2120 {
2121         unsigned int time = CurrentTime;
2122         unsigned int slow_delay;
2123         unsigned int elapsed_msec;
2124         struct timeval tv;
2125         DEControllerPrivateData *priv =
2126                 (DEControllerPrivateData *) g_object_get_qdata (G_OBJECT (controller),
2127                                                                 spi_dec_private_quark);
2128         if (keycode == priv->last_press_keycode)
2129         {
2130                 slow_delay = dec_xkb_get_slowkeys_delay (controller);
2131                 if (slow_delay)
2132                 {
2133                         gettimeofday (&tv, NULL);
2134                         elapsed_msec =
2135                                 (tv.tv_sec - priv->last_press_time.tv_sec) * 1000
2136                                 + (tv.tv_usec - priv->last_press_time.tv_usec) / 1000;
2137 #ifdef SPI_XKB_DEBUG
2138                         fprintf (stderr, "%d ms elapsed (%ld usec)\n", elapsed_msec,
2139                                  (long) (tv.tv_usec - priv->last_press_time.tv_usec));
2140 #endif
2141 #ifdef THIS_IS_BROKEN_DUNNO_WHY
2142                         if (elapsed_msec < slow_delay)
2143                                 time = slow_delay - elapsed_msec + 1;
2144 #else
2145                         time = slow_delay + 10;
2146                         /* our XTest seems broken, we have to add slop as above */
2147 #endif
2148 #ifdef SPI_XKB_DEBUG
2149                         fprintf (stderr, "waiting %d ms\n", time);
2150 #endif
2151                 }
2152         }
2153         XTestFakeKeyEvent (spi_get_display (), keycode, False, time);
2154         priv->last_release_keycode = keycode;
2155         XSync (spi_get_display (), False);
2156         gettimeofday (&priv->last_release_time, NULL);
2157         return TRUE;
2158 }
2159
2160 static unsigned
2161 dec_get_modifier_state (SpiDEController *controller)
2162 {
2163         return mouse_mask_state;
2164 }
2165
2166 static gboolean
2167 dec_lock_modifiers (SpiDEController *controller, unsigned modifiers)
2168 {
2169     DEControllerPrivateData *priv = (DEControllerPrivateData *)
2170     g_object_get_qdata (G_OBJECT (controller), spi_dec_private_quark);
2171
2172     if (priv->have_xkb) {
2173         return XkbLockModifiers (spi_get_display (), XkbUseCoreKbd,
2174                                   modifiers, modifiers);
2175     } else {
2176         int mod_index;
2177         for (mod_index=0;mod_index<8;mod_index++)
2178             if (modifiers & (1<<mod_index))
2179                 dec_synth_keycode_press(controller, xmkeymap->modifiermap[mod_index]);
2180         return TRUE;
2181     }
2182 }
2183
2184 static gboolean
2185 dec_unlock_modifiers (SpiDEController *controller, unsigned modifiers)
2186 {
2187     DEControllerPrivateData *priv = (DEControllerPrivateData *)
2188     g_object_get_qdata (G_OBJECT (controller), spi_dec_private_quark);
2189
2190     if (priv->have_xkb) {
2191         return XkbLockModifiers (spi_get_display (), XkbUseCoreKbd,
2192                                   modifiers, 0);
2193     } else {
2194         int mod_index;
2195         for (mod_index=0;mod_index<8;mod_index++)
2196             if (modifiers & (1<<mod_index))
2197                 dec_synth_keycode_release(controller, xmkeymap->modifiermap[mod_index]);
2198         return TRUE;
2199     }
2200 }
2201
2202 static KeySym
2203 dec_keysym_for_unichar (SpiDEController *controller, gunichar unichar)
2204 {
2205         return ucs2keysym ((long) unichar);
2206 }
2207
2208 static gboolean
2209 dec_synth_keysym (SpiDEController *controller, KeySym keysym)
2210 {
2211         KeyCode key_synth_code;
2212         unsigned int modifiers, synth_mods, lock_mods;
2213
2214         key_synth_code = keycode_for_keysym (controller, keysym, &synth_mods);
2215
2216         if ((key_synth_code == 0) || (synth_mods == 0xFF)) return FALSE;
2217
2218         /* TODO: set the modifiers accordingly! */
2219         modifiers = dec_get_modifier_state (controller);
2220         /* side-effect; we may unset mousebutton modifiers here! */
2221
2222         lock_mods = 0;
2223         if (synth_mods != modifiers) {
2224                 lock_mods = synth_mods & ~modifiers;
2225                 dec_lock_modifiers (controller, lock_mods);
2226         }
2227         dec_synth_keycode_press (controller, key_synth_code);
2228         dec_synth_keycode_release (controller, key_synth_code);
2229
2230         if (synth_mods != modifiers)
2231                 dec_unlock_modifiers (controller, lock_mods);
2232         return TRUE;
2233 }
2234
2235
2236 static gboolean
2237 dec_synth_keystring (SpiDEController *controller, const char *keystring)
2238 {
2239         /* probably we need to create and inject an XIM handler eventually. */
2240         /* for now, try to match the string to existing
2241          * keycode+modifier states.
2242          */
2243         KeySym *keysyms;
2244         gint maxlen = 0;
2245         gunichar unichar = 0;
2246         gint i = 0;
2247         gboolean retval = TRUE;
2248         const gchar *c;
2249
2250         maxlen = strlen (keystring);
2251         keysyms = g_new0 (KeySym, maxlen);
2252         if (!(keystring && *keystring && g_utf8_validate (keystring, -1, &c))) {
2253                 retval = FALSE;
2254         }
2255         else {
2256 #ifdef SPI_DEBUG
2257                 fprintf (stderr, "[keystring synthesis attempted on %s]\n", keystring);
2258 #endif
2259                 while (keystring && (unichar = g_utf8_get_char (keystring))) {
2260                         KeySym keysym;
2261                         char bytes[6];
2262                         gint mbytes;
2263
2264                         mbytes = g_unichar_to_utf8 (unichar, bytes);
2265                         bytes[mbytes] = '\0';
2266 #ifdef SPI_DEBUG
2267                         fprintf (stderr, "[unichar %s]", bytes);
2268 #endif
2269                         keysym = dec_keysym_for_unichar (controller, unichar);
2270                         if (keysym == NoSymbol) {
2271 #ifdef SPI_DEBUG
2272                                 fprintf (stderr, "no keysym for %s", bytes);
2273 #endif
2274                                 retval = FALSE;
2275                                 break;
2276                         }
2277                         keysyms[i++] = keysym;
2278                         keystring = g_utf8_next_char (keystring);
2279                 }
2280                 keysyms[i++] = 0;
2281                 XSynchronize (spi_get_display (), TRUE);
2282                 for (i = 0; keysyms[i]; ++i) {
2283                         if (!dec_synth_keysym (controller, keysyms[i])) {
2284 #ifdef SPI_DEBUG
2285                                 fprintf (stderr, "could not synthesize %c\n",
2286                                          (int) keysyms[i]);
2287 #endif
2288                                 retval = FALSE;
2289                                 break;
2290                         }
2291                 }
2292                 XSynchronize (spi_get_display (), FALSE);
2293         }
2294         g_free (keysyms);
2295
2296         return retval;
2297 }
2298
2299
2300 /*
2301  * DBus Accessibility::DEController::registerKeystrokeListener
2302  *     method implementation
2303  */
2304 static DBusMessage * impl_generate_keyboard_event (DBusConnection *bus, DBusMessage *message, void *user_data)
2305 {
2306   SpiDEController *controller = SPI_REGISTRY(user_data)->de_controller;
2307   DBusError error;
2308   dbus_int32_t keycode;
2309   char *keystring;
2310   dbus_uint32_t synth_type;
2311   gint err;
2312   KeySym keysym;
2313   DEControllerPrivateData *priv;
2314   DBusMessage *reply;
2315
2316   dbus_error_init(&error);
2317   if (!dbus_message_get_args(message, &error, DBUS_TYPE_INT32, &keycode, DBUS_TYPE_STRING, &keystring, DBUS_TYPE_UINT32, &synth_type, DBUS_TYPE_INVALID))
2318   {
2319     return spi_dbus_general_error (message);
2320   }
2321
2322 #ifdef SPI_DEBUG
2323         fprintf (stderr, "synthesizing keystroke %ld, type %d\n",
2324                  (long) keycode, (int) synth_type);
2325 #endif
2326   /* TODO: hide/wrap/remove X dependency */
2327
2328   /*
2329    * TODO: when initializing, query for XTest extension before using,
2330    * and fall back to XSendEvent() if XTest is not available.
2331    */
2332
2333   gdk_error_trap_push ();
2334
2335   priv = (DEControllerPrivateData *)
2336       g_object_get_qdata (G_OBJECT (controller), spi_dec_private_quark);
2337
2338   if (!priv->have_xkb && xmkeymap==NULL) {
2339     xmkeymap = XGetModifierMapping(spi_get_display ());
2340   }
2341
2342   switch (synth_type)
2343     {
2344       case Accessibility_KEY_PRESS:
2345               dec_synth_keycode_press (controller, keycode);
2346               break;
2347       case Accessibility_KEY_PRESSRELEASE:
2348               dec_synth_keycode_press (controller, keycode);
2349       case Accessibility_KEY_RELEASE:
2350               dec_synth_keycode_release (controller, keycode);
2351               break;
2352       case Accessibility_KEY_SYM:
2353 #ifdef SPI_XKB_DEBUG
2354               fprintf (stderr, "KeySym synthesis\n");
2355 #endif
2356               /*
2357                * note: we are using long for 'keycode'
2358                * in our arg list; it can contain either
2359                * a keycode or a keysym.
2360                */
2361               dec_synth_keysym (controller, (KeySym) keycode);
2362               break;
2363       case Accessibility_KEY_STRING:
2364               if (!dec_synth_keystring (controller, keystring))
2365                       fprintf (stderr, "Keystring synthesis failure, string=%s\n",
2366                                keystring);
2367               break;
2368     }
2369   if ((err = gdk_error_trap_pop ()))
2370     {
2371       DBG (-1, g_warning ("Error [%d] emitting keystroke", err));
2372     }
2373   if (synth_type == Accessibility_KEY_SYM) {
2374     keysym = keycode;
2375   }
2376   else {
2377     keysym = XkbKeycodeToKeysym (spi_get_display (), keycode, 0, 0);
2378   }
2379   if (XkbKeysymToModifiers (spi_get_display (), keysym) == 0)
2380     {
2381       spi_dec_clear_unlatch_pending (controller);
2382     }
2383   reply = dbus_message_new_method_return (message);
2384   return reply;
2385 }
2386
2387 /* Accessibility::DEController::generateMouseEvent */
2388 static DBusMessage * impl_generate_mouse_event (DBusConnection *bus, DBusMessage *message, void *user_data)
2389 {
2390   DBusError error;
2391   dbus_int32_t       x;
2392   dbus_int32_t       y;
2393   char *eventName;
2394   DBusMessage *reply;
2395   int button = 0;
2396   gboolean err = FALSE;
2397   Display *display = spi_get_display ();
2398
2399   if (!dbus_message_get_args(message, &error, DBUS_TYPE_INT32, &x, DBUS_TYPE_INT32, &y, DBUS_TYPE_STRING, &eventName, DBUS_TYPE_INVALID))
2400   {
2401     return spi_dbus_general_error (message);
2402   }
2403
2404 #ifdef SPI_DEBUG
2405   fprintf (stderr, "generating mouse %s event at %ld, %ld\n",
2406            eventName, (long int) x, (long int) y);
2407 #endif
2408   switch (eventName[0])
2409     {
2410       case 'b':
2411         switch (eventName[1])
2412           {
2413           /* TODO: check number of buttons before parsing */
2414           case '1':
2415                     button = 1;
2416                     break;
2417           case '2':
2418                   button = 2;
2419                   break;
2420           case '3':
2421                   button = 3;
2422                   break;
2423           case '4':
2424                   button = 4;
2425                   break;
2426           case '5':
2427                   button = 5;
2428                   break;
2429           default:
2430                   err = TRUE;
2431           }
2432         if (!err)
2433           {
2434             if (x != -1 && y != -1)
2435               {
2436                 XTestFakeMotionEvent (display, DefaultScreen (display),
2437                                       x, y, 0);
2438               }
2439             XTestFakeButtonEvent (display, button, !(eventName[2] == 'r'), 0);
2440             if (eventName[2] == 'c')
2441               XTestFakeButtonEvent (display, button, FALSE, 1);
2442             else if (eventName[2] == 'd')
2443               {
2444               XTestFakeButtonEvent (display, button, FALSE, 1);
2445               XTestFakeButtonEvent (display, button, TRUE, 2);
2446               XTestFakeButtonEvent (display, button, FALSE, 3);
2447               }
2448           }
2449         break;
2450       case 'r': /* relative motion */
2451         XTestFakeRelativeMotionEvent (display, x, y, 0);
2452         break;
2453       case 'a': /* absolute motion */
2454         XTestFakeMotionEvent (display, DefaultScreen (display),
2455                               x, y, 0);
2456         break;
2457     }
2458   reply = dbus_message_new_method_return (message);
2459   return reply;
2460 }
2461
2462 /* Accessibility::DEController::notifyListenersSync */
2463 static DBusMessage *
2464 impl_notify_listeners_sync (DBusConnection *bus, DBusMessage *message, void *user_data)
2465 {
2466   SpiDEController *controller = SPI_REGISTRY(user_data)->de_controller;
2467   Accessibility_DeviceEvent event;
2468   dbus_bool_t ret;
2469   DBusMessage *reply;
2470
2471   if (!spi_dbus_demarshall_deviceEvent(message, &event))
2472   {
2473     return spi_dbus_general_error (message);
2474   }
2475 #ifdef SPI_DEBUG
2476   g_print ("notifylistening listeners synchronously: controller %p, event id %d\n",
2477            controller, (int) event.id);
2478 #endif
2479   ret = spi_controller_notify_keylisteners (controller,
2480                                              (Accessibility_DeviceEvent *)
2481                                              &event, FALSE) ?
2482           TRUE : FALSE;
2483   reply = dbus_message_new_method_return (message);
2484   if (reply)
2485   {
2486     dbus_message_append_args (reply, DBUS_TYPE_BOOLEAN, &ret, DBUS_TYPE_INVALID);
2487   }
2488   return reply;
2489 }
2490
2491 static DBusMessage *
2492 impl_notify_listeners_async (DBusConnection *bus, DBusMessage *message, void *user_data)
2493 {
2494   SpiDEController *controller = SPI_REGISTRY(user_data)->de_controller;
2495   Accessibility_DeviceEvent event;
2496   DBusMessage *reply;
2497
2498   if (!spi_dbus_demarshall_deviceEvent(message, &event))
2499   {
2500     return spi_dbus_general_error (message);
2501   }
2502 #ifdef SPI_DEBUG
2503   g_print ("notifylistening listeners asynchronously: controller %p, event id %d\n",
2504            controller, (int) event.id);
2505 #endif
2506   spi_controller_notify_keylisteners (controller, (Accessibility_DeviceEvent *)
2507                                       &event, FALSE);
2508   reply = dbus_message_new_method_return (message);
2509   return reply;
2510 }
2511
2512 static void
2513 spi_device_event_controller_class_init (SpiDEControllerClass *klass)
2514 {
2515   GObjectClass * object_class = (GObjectClass *) klass;
2516
2517   spi_device_event_controller_parent_class = g_type_class_peek_parent (klass);
2518
2519   object_class->finalize = spi_device_event_controller_object_finalize;
2520
2521   if (!spi_dec_private_quark)
2522           spi_dec_private_quark = g_quark_from_static_string ("spi-dec-private");
2523 }
2524
2525 #ifdef HAVE_XEVIE
2526 static Bool isEvent(Display *dpy, XEvent *event, char *arg)
2527 {
2528    return TRUE;
2529 }
2530
2531 static gboolean
2532 handle_io (GIOChannel *source,
2533            GIOCondition condition,
2534            gpointer data)
2535 {
2536   SpiDEController *controller = (SpiDEController *) data;
2537   gboolean is_consumed = FALSE;
2538   XEvent ev;
2539
2540   while (XCheckIfEvent(controller->xevie_display, &ev, isEvent, NULL))
2541     {
2542       if (ev.type == KeyPress || ev.type == KeyRelease)
2543         is_consumed = spi_device_event_controller_forward_key_event (controller, &ev);
2544
2545       if (! is_consumed)
2546         XevieSendEvent(controller->xevie_display, &ev, XEVIE_UNMODIFIED);
2547     }
2548
2549   return TRUE;
2550 }
2551 #endif /* HAVE_XEVIE */
2552
2553 static void
2554 spi_device_event_controller_init (SpiDEController *device_event_controller)
2555 {
2556 #ifdef HAVE_XEVIE
2557   GIOChannel *ioc;
2558   int fd;
2559 #endif /* HAVE_XEVIE */
2560
2561   DEControllerPrivateData *private;
2562   device_event_controller->key_listeners   = NULL;
2563   device_event_controller->mouse_listeners = NULL;
2564   device_event_controller->keygrabs_list   = NULL;
2565   device_event_controller->xevie_display   = NULL;
2566
2567 #ifdef HAVE_XEVIE
2568   device_event_controller->xevie_display = XOpenDisplay(NULL);
2569
2570   if (XevieStart(device_event_controller->xevie_display) == TRUE)
2571     {
2572 #ifdef SPI_KEYEVENT_DEBUG
2573       fprintf (stderr, "XevieStart() success \n");
2574 #endif
2575       XevieSelectInput(device_event_controller->xevie_display, KeyPressMask | KeyReleaseMask);
2576
2577       fd = ConnectionNumber(device_event_controller->xevie_display);
2578       ioc = g_io_channel_unix_new (fd);
2579       g_io_add_watch (ioc, G_IO_IN | G_IO_HUP, handle_io, device_event_controller);
2580       g_io_channel_unref (ioc);
2581     }
2582   else
2583     {
2584       device_event_controller->xevie_display = NULL;
2585 #ifdef SPI_KEYEVENT_DEBUG
2586       fprintf (stderr, "XevieStart() failed, only one client is allowed to do event int exception\n");
2587 #endif
2588     }
2589 #endif /* HAVE_XEVIE */
2590
2591   private = g_new0 (DEControllerPrivateData, 1);
2592   gettimeofday (&private->last_press_time, NULL);
2593   gettimeofday (&private->last_release_time, NULL);
2594   g_object_set_qdata (G_OBJECT (device_event_controller),
2595                       spi_dec_private_quark,
2596                       private);
2597   spi_controller_register_with_devices (device_event_controller);
2598 }
2599
2600 static gboolean
2601 spi_device_event_controller_forward_key_event (SpiDEController *controller,
2602                                                const XEvent    *event)
2603 {
2604   Accessibility_DeviceEvent key_event;
2605   gboolean ret;
2606
2607   g_assert (event->type == KeyPress || event->type == KeyRelease);
2608
2609   key_event = spi_keystroke_from_x_key_event ((XKeyEvent *) event);
2610
2611   if (controller->xevie_display == NULL)
2612     spi_controller_update_key_grabs (controller, &key_event);
2613
2614   /* relay to listeners, and decide whether to consume it or not */
2615   ret = spi_controller_notify_keylisteners (controller, &key_event, TRUE);
2616   g_free(key_event.event_string);
2617   return ret;
2618 }
2619
2620 SpiDEController *
2621 spi_device_event_controller_new (SpiRegistry *registry)
2622 {
2623   SpiDEController *retval = g_object_new (
2624     SPI_DEVICE_EVENT_CONTROLLER_TYPE, NULL);
2625
2626   retval->registry = g_object_ref (registry);
2627
2628   spi_dec_init_mouse_listener (registry);
2629   /* TODO: kill mouse listener on finalize */
2630   return retval;
2631 }
2632
2633 static gboolean
2634 is_key_released (KeyCode code)
2635 {
2636   char keys[32];
2637   int down;
2638
2639   XQueryKeymap (spi_get_display (), keys);
2640   down = BIT (keys, code);
2641   return (down == 0);
2642 }
2643
2644 static gboolean
2645 check_release (gpointer data)
2646 {
2647   gboolean released;
2648   Accessibility_DeviceEvent *event = (Accessibility_DeviceEvent *)data;
2649   KeyCode code = event->hw_code;
2650
2651   released = is_key_released (code);
2652
2653   if (released)
2654     {
2655       check_release_handler = 0;
2656       event->type = Accessibility_KEY_RELEASED_EVENT;
2657       spi_controller_notify_keylisteners (saved_controller, event, TRUE);
2658     }
2659   return (released == 0);
2660 }
2661
2662 static void wait_for_release_event (XEvent          *event,
2663                                     SpiDEController *controller)
2664 {
2665   pressed_event = spi_keystroke_from_x_key_event ((XKeyEvent *) event);
2666   saved_controller = controller;
2667   check_release_handler = g_timeout_add (CHECK_RELEASE_DELAY, check_release, &pressed_event);
2668 }
2669
2670 static DRouteMethod methods[] =
2671 {
2672   { impl_register_keystroke_listener, "registerKeystrokeListener" },
2673   { impl_register_device_listener, "registerDeviceListener" },
2674   { impl_deregister_keystroke_listener, "deregisterKeystrokeListener" },
2675   { impl_deregister_device_listener, "deregisterDeviceListener" },
2676   { impl_generate_keyboard_event, "generateKeyboardEvent" },
2677   { impl_generate_mouse_event, "generateMouseEvent" },
2678   { impl_notify_listeners_sync, "notifyListenersSync" },
2679   { impl_notify_listeners_async, "notifyListenersAsync" },
2680   { NULL, NULL }
2681 };
2682
2683 void
2684 spi_registry_initialize_dec_interface (DRouteData * data)
2685 {
2686   droute_add_interface (data, "org.freedesktop.atspi.DeviceEventController", methods,
2687                         NULL, NULL, NULL);
2688 };