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