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 <glib.h>
  38
  39 #include <dbus/dbus.h>
  40
  41 #include "paths.h"
  42 #include "keymasks.h"
  43 #include "de-types.h"
  44 #include "de-marshaller.h"
  45 #ifdef HAVE_X11
  46 #include "display.h"
  47 #include "event-source.h"
  48 #endif
  49
  50 #include "deviceeventcontroller.h"
  51 #include "reentrant-list.h"
  52
  53 #include "introspection.h"
  54
  55 #define CHECK_RELEASE_DELAY 20
  56 #define BIT(c, x)       (c[x/8]&(1<<(x%8)))
  57 static SpiDEController *saved_controller;
  58
  59 /* Our parent Gtk object type */
  60 #define PARENT_TYPE G_TYPE_OBJECT
  61
  62 /* A pointer to our parent object class */
  63 static int spi_error_code = 0;
  64 struct _SpiPoint {
  65     gint x;
  66     gint y;
  67 };
  68 typedef struct _SpiPoint SpiPoint;
  69 static unsigned int mouse_mask_state = 0;
  70 #ifdef HAVE_X11
  71 static unsigned int key_modifier_mask =
  72   Mod1Mask | Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask | ShiftMask | LockMask | ControlMask | SPI_KEYMASK_NUMLOCK;
  73 static unsigned int _numlock_physical_mask = Mod2Mask; /* a guess, will be reset */
  74 #else
  75 static unsigned int key_modifier_mask = 255;
  76 static unsigned int _numlock_physical_mask = (1<<4);
  77 #endif
  78
  79 static gboolean have_mouse_listener = FALSE;
  80 static gboolean have_mouse_event_listener = FALSE;
  81
  82
  83 typedef struct {
  84   guint                             ref_count : 30;
  85   guint                             pending_add : 1;
  86   guint                             pending_remove : 1;
  87
  88   Accessibility_ControllerEventMask mod_mask;
  89   dbus_uint32_t               key_val;  /* KeyCode */
  90 } DEControllerGrabMask;
  91
  92
  93 gboolean spi_controller_update_key_grabs               (SpiDEController           *controller,
  94                                                                Accessibility_DeviceEvent *recv);
  95
  96 static gboolean eventtype_seq_contains_event (dbus_uint32_t types,
  97                                               const Accessibility_DeviceEvent *event);
  98 static gboolean spi_dec_poll_mouse_moving (gpointer data);
  99 static gboolean spi_dec_poll_mouse_idle (gpointer data);
 100
 101 G_DEFINE_TYPE(SpiDEController, spi_device_event_controller, G_TYPE_OBJECT)
 102
 103 static gint
 104 spi_dec_plat_get_keycode (SpiDEController *controller,
 105                           gint keysym,
 106                           gchar *key_str,
 107                           gboolean fix,
 108                           guint *modmask)
 109 {
 110   SpiDEControllerClass *klass;
 111   klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);
 112   if (klass->plat.get_keycode)
 113     return klass->plat.get_keycode (controller, keysym, key_str, fix, modmask);
 114   else
 115     return keysym;
 116 }
 117
 118 static guint
 119 spi_dec_plat_mouse_check (SpiDEController *controller,
 120                      int *x, int *y, gboolean *moved)
 121 {
 122   SpiDEControllerClass *klass;
 123   klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);
 124   if (klass->plat.mouse_check)
 125     return klass->plat.mouse_check (controller, x, y, moved);
 126   else
 127     return 0;
 128 }
 129
 130 static gboolean
 131 spi_dec_plat_grab_key (SpiDEController *controller, guint key_val, Accessibility_ControllerEventMask mod_mask)
 132 {
 133   SpiDEControllerClass *klass;
 134   klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);
 135   if (klass->plat.grab_key)
 136     return klass->plat.grab_key (controller, key_val, mod_mask);
 137   else
 138     return FALSE;
 139 }
 140
 141 static void
 142 spi_dec_plat_ungrab_key (SpiDEController *controller, guint key_val, Accessibility_ControllerEventMask mod_mask)
 143 {
 144   SpiDEControllerClass *klass;
 145   klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);
 146   if (klass->plat.ungrab_key)
 147     klass->plat.ungrab_key (controller, key_val, mod_mask);
 148 }
 149
 150 static gboolean
 151 spi_dec_plat_synth_keycode_press (SpiDEController *controller,
 152                          unsigned int keycode)
 153 {
 154   SpiDEControllerClass *klass;
 155   klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);
 156   if (klass->plat.synth_keycode_press)
 157     return klass->plat.synth_keycode_press (controller, keycode);
 158   else
 159     return FALSE;
 160 }
 161
 162 static gboolean
 163 spi_dec_plat_synth_keycode_release (SpiDEController *controller,
 164                            unsigned int keycode)
 165 {
 166   SpiDEControllerClass *klass;
 167   klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);
 168   if (klass->plat.synth_keycode_release)
 169     return klass->plat.synth_keycode_release (controller, keycode);
 170   else
 171     return FALSE;
 172 }
 173
 174 static gboolean
 175 spi_dec_plat_lock_modifiers (SpiDEController *controller, unsigned modifiers)
 176 {
 177   SpiDEControllerClass *klass;
 178   klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);
 179   if (klass->plat.lock_modifiers)
 180     return klass->plat.lock_modifiers (controller, modifiers);
 181   else
 182     return FALSE;
 183 }
 184
 185 static gboolean
 186 spi_dec_plat_unlock_modifiers (SpiDEController *controller, unsigned modifiers)
 187 {
 188   SpiDEControllerClass *klass;
 189   klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);
 190   if (klass->plat.unlock_modifiers)
 191     return klass->plat.unlock_modifiers (controller, modifiers);
 192   else
 193     return FALSE;
 194 }
 195
 196 static gboolean
 197 spi_dec_plat_synth_keystring (SpiDEController *controller, guint synth_type, gint keycode, const char *keystring)
 198 {
 199   SpiDEControllerClass *klass;
 200   klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);
 201   if (klass->plat.synth_keystring)
 202     return klass->plat.synth_keystring (controller, synth_type, keycode, keystring);
 203   else
 204     return FALSE;
 205 }
 206
 207 static void
 208 spi_dec_plat_emit_modifier_event (SpiDEController *controller, guint prev_mask,
 209                              guint current_mask)
 210 {
 211   SpiDEControllerClass *klass;
 212   klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);
 213   if (klass->plat.emit_modifier_event)
 214     return klass->plat.emit_modifier_event (controller, prev_mask, current_mask);
 215 }
 216
 217 static void
 218 spi_dec_plat_generate_mouse_event (SpiDEController *controller,
 219                                    gint x,
 220                                    gint y,
 221                                    const char *eventName)
 222 {
 223   SpiDEControllerClass *klass;
 224   klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);
 225   if (klass->plat.generate_mouse_event)
 226     return klass->plat.generate_mouse_event (controller, x, y, eventName);
 227 }
 228
 229 DBusMessage *
 230 invalid_arguments_error (DBusMessage *message)
 231 {
 232     DBusMessage *reply;
 233     gchar       *errmsg;
 234
 235     errmsg= g_strdup_printf (
 236             "Method \"%s\" with signature \"%s\" on interface \"%s\" was supplied with invalid arguments\n",
 237             dbus_message_get_member (message),
 238             dbus_message_get_signature (message),
 239             dbus_message_get_interface (message));
 240     reply = dbus_message_new_error (message,
 241                                     DBUS_ERROR_INVALID_ARGS,
 242                                     errmsg);
 243     g_free (errmsg);
 244     return reply;
 245 }
 246
 247 /* Private methods */
 248 static dbus_bool_t
 249 spi_dbus_add_disconnect_match (DBusConnection *bus, const char *name)
 250 {
 251   char *match = g_strdup_printf ("interface=%s,member=NameOwnerChanged,arg0=%s", DBUS_INTERFACE_DBUS, name);
 252   if (match)
 253   {
 254     DBusError error;
 255     dbus_error_init (&error);
 256     dbus_bus_add_match (bus, match, &error);
 257     g_free (match);
 258     if (dbus_error_is_set (&error))
 259       {
 260         dbus_error_free (&error);
 261         return FALSE;
 262       }
 263     else
 264       {
 265         return TRUE;
 266       }
 267   }
 268   else return FALSE;
 269 }
 270
 271 static dbus_bool_t
 272 spi_dbus_remove_disconnect_match (DBusConnection *bus, const char *name)
 273 {
 274   char *match = g_strdup_printf ("interface=%s,member=NameOwnerChanged,arg0=%s", DBUS_INTERFACE_DBUS, name);
 275   if (match)
 276   {
 277     DBusError error;
 278     dbus_error_init (&error);
 279     dbus_bus_remove_match (bus, match, &error);
 280     g_free (match);
 281     if (dbus_error_is_set (&error))
 282       {
 283         dbus_error_free (&error);
 284         return FALSE;
 285       }
 286     else
 287       {
 288         return TRUE;
 289       }
 290   }
 291   else return FALSE;
 292 }
 293
 294 static DEControllerGrabMask *
 295 spi_grab_mask_clone (DEControllerGrabMask *grab_mask)
 296 {
 297   DEControllerGrabMask *clone = g_new (DEControllerGrabMask, 1);
 298
 299   memcpy (clone, grab_mask, sizeof (DEControllerGrabMask));
 300
 301   clone->ref_count = 1;
 302   clone->pending_add = TRUE;
 303   clone->pending_remove = FALSE;
 304
 305   return clone;
 306 }
 307
 308 static void
 309 spi_grab_mask_free (DEControllerGrabMask *grab_mask)
 310 {
 311   g_free (grab_mask);
 312 }
 313
 314 static gint
 315 spi_grab_mask_compare_values (gconstpointer p1, gconstpointer p2)
 316 {
 317   DEControllerGrabMask *l1 = (DEControllerGrabMask *) p1;
 318   DEControllerGrabMask *l2 = (DEControllerGrabMask *) p2;
 319
 320   if (p1 == p2)
 321     {
 322       return 0;
 323     }
 324   else
 325     {
 326       return ((l1->mod_mask != l2->mod_mask) || (l1->key_val != l2->key_val));
 327     }
 328 }
 329
 330 void
 331 spi_dec_dbus_emit (SpiDEController *controller, const char *interface,
 332                    const char *name, const char *minor, int a1, int a2)
 333 {
 334   DBusMessage *signal = NULL;
 335   DBusMessageIter iter, iter_struct, iter_variant;
 336   int nil = 0;
 337   const char *path = SPI_DBUS_PATH_ROOT;
 338   const char *bus_name = dbus_bus_get_unique_name (controller->bus);
 339
 340   signal = dbus_message_new_signal (path, interface, name);
 341
 342   dbus_message_iter_init_append (signal, &iter);
 343
 344   dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &minor);
 345   dbus_message_iter_append_basic (&iter, DBUS_TYPE_INT32, &a1);
 346   dbus_message_iter_append_basic (&iter, DBUS_TYPE_INT32, &a2);
 347   dbus_message_iter_open_container (&iter, DBUS_TYPE_VARIANT, "i", &iter_variant);
 348       dbus_message_iter_append_basic (&iter_variant, DBUS_TYPE_INT32, &nil);
 349   dbus_message_iter_close_container (&iter, &iter_variant);
 350
 351   dbus_message_iter_open_container (&iter, DBUS_TYPE_STRUCT, NULL,
 352                                     &iter_struct);
 353   dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_STRING, &bus_name);
 354   dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_OBJECT_PATH, &path);
 355   dbus_message_iter_close_container (&iter, &iter_struct);
 356
 357   dbus_connection_send (controller->bus, signal, NULL);
 358   dbus_message_unref (signal);
 359 }
 360
 361 static gboolean
 362 spi_dec_poll_mouse_moved (gpointer data)
 363 {
 364   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER(data);
 365   int x, y;
 366   gboolean moved;
 367   guint mask_return;
 368
 369   mask_return = spi_dec_plat_mouse_check (controller, &x, &y, &moved);
 370
 371   if ((mask_return & key_modifier_mask) !=
 372       (mouse_mask_state & key_modifier_mask))
 373     {
 374       spi_dec_plat_emit_modifier_event (controller, mouse_mask_state, mask_return);
 375       mouse_mask_state = mask_return;
 376     }
 377
 378   return moved;
 379 }
 380
 381 static gboolean
 382 spi_dec_poll_mouse_idle (gpointer data)
 383 {
 384   if (!have_mouse_event_listener && !have_mouse_listener)
 385     return FALSE;
 386   else if (!spi_dec_poll_mouse_moved (data))
 387     return TRUE;
 388   else
 389     {
 390       guint id;
 391       id = g_timeout_add (20, spi_dec_poll_mouse_moving, data);
 392       g_source_set_name_by_id (id, "[at-spi2-core] spi_dec_poll_mouse_moving");
 393       return FALSE;
 394     }
 395 }
 396
 397 static gboolean
 398 spi_dec_poll_mouse_moving (gpointer data)
 399 {
 400   if (!have_mouse_event_listener && !have_mouse_listener)
 401     return FALSE;
 402   else if (spi_dec_poll_mouse_moved (data))
 403     return TRUE;
 404   else
 405     {
 406       guint id;
 407       id = g_timeout_add (100, spi_dec_poll_mouse_idle, data);
 408       g_source_set_name_by_id (id, "[at-spi2-core] check_release");
 409       return FALSE;
 410     }
 411 }
 412
 413 /**
 414  * Eventually we can use this to make the marshalling of mask types
 415  * more sane, but for now we just use this to detect
 416  * the use of 'virtual' masks such as numlock and convert them to
 417  * system-specific mask values (i.e. ModMask).
 418  *
 419  **/
 420 static Accessibility_ControllerEventMask
 421 spi_dec_translate_mask (Accessibility_ControllerEventMask mask)
 422 {
 423   Accessibility_ControllerEventMask tmp_mask;
 424   gboolean has_numlock;
 425
 426   has_numlock = (mask & SPI_KEYMASK_NUMLOCK);
 427   tmp_mask = mask;
 428   if (has_numlock)
 429     {
 430       tmp_mask = mask ^ SPI_KEYMASK_NUMLOCK;
 431       tmp_mask |= _numlock_physical_mask;
 432     }
 433
 434   return tmp_mask;
 435 }
 436
 437 static DEControllerKeyListener *
 438 spi_dec_key_listener_new (const char *bus_name,
 439                           const char *path,
 440                           GSList *keys,
 441                           const Accessibility_ControllerEventMask mask,
 442                           const dbus_uint32_t types,
 443                           const Accessibility_EventListenerMode  *mode)
 444 {
 445   DEControllerKeyListener *key_listener = g_new0 (DEControllerKeyListener, 1);
 446   key_listener->listener.bus_name = g_strdup(bus_name);
 447   key_listener->listener.path = g_strdup(path);
 448   key_listener->listener.type = SPI_DEVICE_TYPE_KBD;
 449   key_listener->keys = keys;
 450   key_listener->mask = spi_dec_translate_mask (mask);
 451   key_listener->listener.types = types;
 452   if (mode)
 453   {
 454     key_listener->mode = (Accessibility_EventListenerMode *) g_malloc(sizeof(Accessibility_EventListenerMode));
 455     memcpy(key_listener->mode, mode, sizeof(*mode));
 456   }
 457   else
 458     key_listener->mode = NULL;
 459
 460 #ifdef SPI_DEBUG
 461   g_print ("new listener, with mask %x, is_global %d, keys %p (%d)\n",
 462            (unsigned int) key_listener->mask,
 463            (int) (mode ? mode->global : 0),
 464            (void *) key_listener->keys,
 465            (int) (key_listener->keys ? g_slist_length(key_listener->keys) : 0));
 466 #endif
 467
 468   return key_listener;
 469 }
 470
 471 static DEControllerListener *
 472 spi_dec_listener_new (const char *bus_name,
 473                       const char *path,
 474                       dbus_uint32_t types)
 475 {
 476   DEControllerListener *listener = g_new0 (DEControllerListener, 1);
 477   listener->bus_name = g_strdup(bus_name);
 478   listener->path = g_strdup(path);
 479   listener->type = SPI_DEVICE_TYPE_MOUSE;
 480   listener->types = types;
 481   return listener;
 482 }
 483
 484 static DEControllerListener *
 485 spi_listener_clone (DEControllerListener *listener)
 486 {
 487   DEControllerListener *clone = g_new0 (DEControllerListener, 1);
 488   clone->bus_name = g_strdup (listener->bus_name);
 489   clone->path = g_strdup (listener->path);
 490   clone->type = listener->type;
 491   clone->types = listener->types;
 492   return clone;
 493 }
 494
 495 static GSList *keylist_clone (GSList *s)
 496 {
 497   GSList *d = NULL;
 498   GSList *l;
 499
 500   for (l = s; l; l = g_slist_next(l))
 501   {
 502     Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *)g_malloc(sizeof(Accessibility_KeyDefinition));
 503     if (kd)
 504     {
 505       Accessibility_KeyDefinition *kds = (Accessibility_KeyDefinition *)l->data;
 506       kd->keycode = kds->keycode;
 507       kd->keysym = kds->keysym;
 508       kd->keystring = g_strdup(kds->keystring);
 509       d = g_slist_append(d, kd);
 510     }
 511   }
 512   return d;
 513 }
 514
 515 static DEControllerKeyListener *
 516 spi_key_listener_clone (DEControllerKeyListener *key_listener)
 517 {
 518   DEControllerKeyListener *clone = g_new0 (DEControllerKeyListener, 1);
 519   clone->listener.bus_name = g_strdup (key_listener->listener.bus_name);
 520   clone->listener.path = g_strdup (key_listener->listener.path);
 521   clone->listener.type = SPI_DEVICE_TYPE_KBD;
 522   clone->keys = keylist_clone (key_listener->keys);
 523   clone->mask = key_listener->mask;
 524   clone->listener.types = key_listener->listener.types;
 525   if (key_listener->mode)
 526   {
 527     clone->mode = (Accessibility_EventListenerMode *)g_malloc(sizeof(Accessibility_EventListenerMode));
 528     if (clone->mode) memcpy(clone->mode, key_listener->mode, sizeof(Accessibility_EventListenerMode));
 529   }
 530   else
 531     clone->mode = NULL;
 532   return clone;
 533 }
 534
 535 static void keylist_free(GSList *keys)
 536 {
 537   GSList *l;
 538
 539   for (l = keys; l; l = g_slist_next(l))
 540   {
 541     Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *)l->data;
 542     g_free(kd->keystring);
 543     g_free(kd);
 544   }
 545   g_slist_free (keys);
 546 }
 547
 548 static void
 549 spi_key_listener_data_free (DEControllerKeyListener *key_listener)
 550 {
 551   keylist_free(key_listener->keys);
 552   if (key_listener->mode) g_free(key_listener->mode);
 553   g_free (key_listener->listener.bus_name);
 554   g_free (key_listener->listener.path);
 555   g_free (key_listener);
 556 }
 557
 558 static void
 559 spi_key_listener_clone_free (DEControllerKeyListener *clone)
 560 {
 561   spi_key_listener_data_free (clone);
 562 }
 563
 564 static void
 565 spi_listener_clone_free (DEControllerListener *clone)
 566 {
 567   g_free (clone->path);
 568   g_free (clone->bus_name);
 569   g_free (clone);
 570 }
 571
 572 static void
 573 spi_dec_listener_free (DEControllerListener    *listener)
 574 {
 575   if (listener->type == SPI_DEVICE_TYPE_KBD)
 576     spi_key_listener_data_free ((DEControllerKeyListener *) listener);
 577   else
 578   {
 579     g_free (listener->bus_name);
 580     g_free (listener->path);
 581   }
 582 }
 583
 584 static void
 585 _register_keygrab (SpiDEController      *controller,
 586                    DEControllerGrabMask *grab_mask)
 587 {
 588   GList *l;
 589
 590   l = g_list_find_custom (controller->keygrabs_list, grab_mask,
 591                           spi_grab_mask_compare_values);
 592   if (l)
 593     {
 594       DEControllerGrabMask *cur_mask = l->data;
 595
 596       cur_mask->ref_count++;
 597       if (cur_mask->pending_remove)
 598         {
 599           cur_mask->pending_remove = FALSE;
 600         }
 601     }
 602   else
 603     {
 604       controller->keygrabs_list =
 605         g_list_prepend (controller->keygrabs_list,
 606                         spi_grab_mask_clone (grab_mask));
 607     }
 608 }
 609
 610 static void
 611 _deregister_keygrab (SpiDEController      *controller,
 612                      DEControllerGrabMask *grab_mask)
 613 {
 614   GList *l;
 615
 616   l = g_list_find_custom (controller->keygrabs_list, grab_mask,
 617                           spi_grab_mask_compare_values);
 618
 619   if (l)
 620     {
 621       DEControllerGrabMask *cur_mask = l->data;
 622
 623       cur_mask->ref_count--;
 624       if (cur_mask->ref_count <= 0)
 625         {
 626           cur_mask->pending_remove = TRUE;
 627         }
 628     }
 629 }
 630
 631 static void
 632 handle_keygrab (SpiDEController         *controller,
 633                 DEControllerKeyListener *key_listener,
 634                 void                   (*process_cb) (SpiDEController *controller,
 635                                                       DEControllerGrabMask *grab_mask))
 636 {
 637   DEControllerGrabMask grab_mask = { 0 };
 638
 639   grab_mask.mod_mask = key_listener->mask;
 640   if (g_slist_length (key_listener->keys) == 0) /* special case means AnyKey/AllKeys */
 641     {
 642 #ifdef HAVE_X11
 643       grab_mask.key_val = AnyKey;
 644 #else
 645       grab_mask.key_val = 0L;
 646 #endif
 647
 648 #ifdef SPI_DEBUG
 649       fprintf (stderr, "AnyKey grab!");
 650 #endif
 651       process_cb (controller, &grab_mask);
 652     }
 653   else
 654     {
 655       GSList *l;
 656
 657       for (l = key_listener->keys; l; l = g_slist_next(l))
 658         {
 659           Accessibility_KeyDefinition *keydef = l->data;
 660           long key_val;
 661           key_val = spi_dec_plat_get_keycode (controller, keydef->keysym, keydef->keystring, FALSE, NULL);
 662           if (!key_val)
 663             key_val = keydef->keycode;
 664           grab_mask.key_val = key_val;
 665           process_cb (controller, &grab_mask);
 666         }
 667     }
 668 }
 669
 670 static gboolean
 671 spi_controller_register_global_keygrabs (SpiDEController         *controller,
 672                                          DEControllerKeyListener *key_listener)
 673 {
 674   handle_keygrab (controller, key_listener, _register_keygrab);
 675   return spi_controller_update_key_grabs (controller, NULL);
 676 }
 677
 678 static void
 679 spi_controller_deregister_global_keygrabs (SpiDEController         *controller,
 680                                            DEControllerKeyListener *key_listener)
 681 {
 682   handle_keygrab (controller, key_listener, _deregister_keygrab);
 683   spi_controller_update_key_grabs (controller, NULL);
 684 }
 685
 686 static void
 687 append_keystroke_listener (DBusMessageIter *iter, DEControllerKeyListener *listener)
 688 {
 689   dbus_uint32_t d_uint;
 690   DBusMessageIter iter_struct, iter_subarray, iter_substruct;
 691   GSList *kl;
 692
 693   if (!dbus_message_iter_open_container (iter, DBUS_TYPE_STRUCT, NULL,
 694                                          &iter_struct))
 695     return;
 696
 697   dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_STRING,
 698                                   &listener->listener.bus_name);
 699   dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_OBJECT_PATH,
 700                                   &listener->listener.path);
 701   d_uint = listener->listener.type;
 702   dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_UINT32, &d_uint);
 703   d_uint = listener->listener.types;
 704   dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_UINT32, &d_uint);
 705   if (!dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_ARRAY,
 706                                          "(iisi)", &iter_subarray))
 707   {
 708     dbus_message_iter_close_container (iter, &iter_struct);
 709     return;
 710   }
 711   for (kl = listener->keys; kl; kl = kl->next)
 712   {
 713     Accessibility_KeyDefinition *kd = kl->data;
 714     if (!dbus_message_iter_open_container (&iter_subarray, DBUS_TYPE_STRUCT,
 715                                          NULL, &iter_substruct))
 716       break;
 717     dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_INT32, &kd->keycode);
 718     dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_INT32, &kd->keysym);
 719     dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_STRING, &kd->keystring);
 720     dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_INT32, &kd->unused);
 721     dbus_message_iter_close_container (&iter_subarray, &iter_substruct);
 722   }
 723   dbus_message_iter_close_container (&iter_struct, &iter_subarray);
 724   d_uint = listener->mask;
 725   dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_UINT32, &d_uint);
 726   if (dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_STRUCT,
 727                                          NULL, &iter_substruct))
 728   {
 729     if (listener->mode)
 730     {
 731       dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN,
 732                                       &listener->mode->synchronous);
 733       dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN,
 734                                       &listener->mode->preemptive);
 735       dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN,
 736                                       &listener->mode->global);
 737     }
 738     else
 739     {
 740       dbus_bool_t dummy_val = FALSE;
 741       dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN,
 742                                       &dummy_val);
 743       dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN,
 744                                       &dummy_val);
 745       dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN,
 746                                       &dummy_val);
 747     }
 748     dbus_message_iter_close_container (&iter_struct, &iter_substruct);
 749   }
 750   dbus_message_iter_close_container (iter, &iter_struct);
 751 }
 752
 753 static void
 754 notify_keystroke_listener (SpiDEController *controller,
 755                            DEControllerKeyListener *listener,
 756                            gboolean enable)
 757 {
 758   const char *path = SPI_DBUS_PATH_DEC;
 759   const char *interface = SPI_DBUS_INTERFACE_DEVICE_EVENT_LISTENER;
 760   const char *name = (enable
 761                       ? "KeystrokeListenerRegistered"
 762                       : "KeystrokeListenerDeregistered");
 763   DBusMessage *signal;
 764   DBusMessageIter iter;
 765
 766   signal = dbus_message_new_signal (path, interface, name);
 767   if (!signal)
 768     return;
 769   dbus_message_iter_init_append (signal, &iter);
 770   append_keystroke_listener (&iter, listener);
 771   dbus_connection_send (controller->bus, signal, NULL);
 772   dbus_message_unref (signal);
 773 }
 774
 775 static void
 776 append_mouse_listener (DBusMessageIter *iter, DEControllerListener *listener)
 777 {
 778   DBusMessageIter iter_struct;
 779   dbus_uint32_t d_uint;
 780
 781   if (!dbus_message_iter_open_container (iter, DBUS_TYPE_STRUCT, NULL,
 782                                          &iter_struct))
 783     return;
 784   dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_STRING,
 785                                   &listener->bus_name);
 786   dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_OBJECT_PATH,
 787                                   &listener->path);
 788   d_uint = listener->types;
 789   dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_UINT32, &d_uint);
 790   dbus_message_iter_close_container (iter, &iter_struct);
 791 }
 792
 793 static void
 794 notify_mouse_listener (SpiDEController *controller,
 795                        DEControllerListener *listener,
 796                        gboolean enable)
 797 {
 798   const char *path = SPI_DBUS_PATH_DEC;
 799   const char *interface = SPI_DBUS_INTERFACE_DEVICE_EVENT_LISTENER;
 800   const char *name = (enable
 801                       ? "DeviceListenerRegistered"
 802                       : "DeviceListenerDeregistered");
 803   DBusMessage *signal;
 804   DBusMessageIter iter;
 805
 806   signal = dbus_message_new_signal (path, interface, name);
 807   if (!signal)
 808     return;
 809   dbus_message_iter_init_append (signal, &iter);
 810   append_mouse_listener (&iter, listener);
 811   dbus_connection_send (controller->bus, signal, NULL);
 812   dbus_message_unref (signal);
 813 }
 814
 815 static gboolean
 816 spi_controller_register_device_listener (SpiDEController      *controller,
 817                                          DEControllerListener *listener)
 818 {
 819   DEControllerKeyListener *key_listener;
 820   gboolean retval;
 821
 822   switch (listener->type) {
 823   case SPI_DEVICE_TYPE_KBD:
 824       key_listener = (DEControllerKeyListener *) listener;
 825
 826       controller->key_listeners = g_list_prepend (controller->key_listeners,
 827                                                   key_listener);
 828       spi_dbus_add_disconnect_match (controller->bus, key_listener->listener.bus_name);
 829       if (key_listener->mode->global)
 830         {
 831           retval = spi_controller_register_global_keygrabs (controller, key_listener);
 832         }
 833       else
 834           retval = TRUE;
 835       if (retval)
 836         notify_keystroke_listener (controller, key_listener, TRUE);
 837       break;
 838   case SPI_DEVICE_TYPE_MOUSE:
 839       controller->mouse_listeners = g_list_prepend (controller->mouse_listeners, listener);
 840       if (!have_mouse_listener)
 841         {
 842           have_mouse_listener = TRUE;
 843           if (!have_mouse_event_listener) {
 844             guint id;
 845             id = g_timeout_add (100, spi_dec_poll_mouse_idle, controller);
 846             g_source_set_name_by_id (id, "[at-spi2-core] spi_dec_poll_mouse_idle");
 847           }
 848         }
 849       spi_dbus_add_disconnect_match (controller->bus, listener->bus_name);
 850       notify_mouse_listener (controller, listener, TRUE);
 851       break;
 852   default:
 853       break;
 854   }
 855   return FALSE;
 856 }
 857
 858 static void
 859 set_reply (DBusPendingCall *pending, void *user_data)
 860 {
 861     void **replyptr = (void **)user_data;
 862
 863     *replyptr = dbus_pending_call_steal_reply (pending);
 864 }
 865
 866 static GSList *hung_processes = NULL;
 867
 868 static void
 869 reset_hung_process (DBusPendingCall *pending, void *data)
 870 {
 871   DBusMessage *message = data;
 872   const char *dest = dbus_message_get_destination (message);
 873   GSList *l;
 874
 875   /* At this point we don't care about the result */
 876   dbus_pending_call_unref (pending);
 877
 878   for (l = hung_processes; l; l = l->next)
 879   {
 880     if (!strcmp (l->data, dest))
 881     {
 882       g_free (l->data);
 883       hung_processes = g_slist_remove (hung_processes, l->data);
 884       break;
 885     }
 886   }
 887 }
 888
 889 static gint
 890 time_elapsed (struct timeval *origin)
 891 {
 892   struct timeval tv;
 893
 894   gettimeofday (&tv, NULL);
 895   return (tv.tv_sec - origin->tv_sec) * 1000 + (tv.tv_usec - origin->tv_usec) / 1000;
 896 }
 897
 898 static void
 899 reset_hung_process_from_ping (DBusPendingCall *pending, void *data)
 900 {
 901   GSList *l;
 902
 903   for (l = hung_processes; l; l = l->next)
 904   {
 905     if (!strcmp (l->data, data))
 906     {
 907       g_free (l->data);
 908       hung_processes = g_slist_remove (hung_processes, l->data);
 909       break;
 910     }
 911   }
 912   g_free (data);
 913   dbus_pending_call_unref (pending);
 914 }
 915
 916 static DBusMessage *
 917 send_and_allow_reentry (DBusConnection *bus, DBusMessage *message, int timeout, DBusError *error)
 918 {
 919     DBusPendingCall *pending;
 920     DBusMessage *reply = NULL;
 921   struct timeval tv;
 922
 923     if (!dbus_connection_send_with_reply (bus, message, &pending, -1))
 924     {
 925         return NULL;
 926     }
 927     dbus_pending_call_set_notify (pending, set_reply, (void *)&reply, NULL);
 928     gettimeofday (&tv, NULL);
 929     while (!reply)
 930     {
 931       if (!dbus_connection_read_write_dispatch (bus, timeout) ||
 932           time_elapsed (&tv) > timeout)
 933       {
 934         const char *dest = dbus_message_get_destination (message);
 935         GSList *l;
 936         gchar *bus_name_dup;
 937         dbus_message_ref (message);
 938         dbus_pending_call_set_notify (pending, reset_hung_process, message,
 939                                       (DBusFreeFunction) dbus_message_unref);
 940         message = dbus_message_new_method_call (dest, "/",
 941                                                 "org.freedesktop.DBus.Peer",
 942                                                 "Ping");
 943         if (!message)
 944           return NULL;
 945         dbus_connection_send_with_reply (bus, message, &pending, -1);
 946         dbus_message_unref (message);
 947         if (!pending)
 948           return NULL;
 949         bus_name_dup = g_strdup (dest);
 950         dbus_pending_call_set_notify (pending, reset_hung_process_from_ping,
 951                                       bus_name_dup, NULL);
 952         for (l = hung_processes; l; l = l->next)
 953           if (!strcmp (l->data, dest))
 954             return NULL;
 955         hung_processes = g_slist_prepend (hung_processes, g_strdup (dest));
 956         return NULL;
 957       }
 958     }
 959     dbus_pending_call_unref (pending);
 960     return reply;
 961 }
 962 static gboolean
 963 Accessibility_DeviceEventListener_NotifyEvent(SpiDEController *controller,
 964                                               SpiRegistry *registry,
 965                                               DEControllerListener *listener,
 966                                               const Accessibility_DeviceEvent *key_event)
 967 {
 968   DBusMessage *message = dbus_message_new_method_call(listener->bus_name,
 969                                                       listener->path,
 970                                                       SPI_DBUS_INTERFACE_DEVICE_EVENT_LISTENER,
 971                                                       "NotifyEvent");
 972   dbus_bool_t consumed = FALSE;
 973   GSList *l;
 974   gboolean hung = FALSE;
 975
 976   for (l = hung_processes; l; l = l->next)
 977   {
 978     if (!strcmp (l->data, listener->bus_name))
 979     {
 980       dbus_message_set_no_reply (message, TRUE);
 981       hung = TRUE;
 982       break;
 983     }
 984   }
 985
 986   if (spi_dbus_marshal_deviceEvent(message, key_event))
 987   {
 988     DBusMessage *reply;
 989
 990     if (hung)
 991     {
 992       dbus_connection_send (controller->bus, message, NULL);
 993       dbus_message_unref (message);
 994       return FALSE;
 995     }
 996
 997     reply = send_and_allow_reentry (controller->bus, message, 3000, NULL);
 998     if (reply)
 999     {
1000       dbus_message_get_args(reply, NULL, DBUS_TYPE_BOOLEAN, &consumed, DBUS_TYPE_INVALID);
1001       dbus_message_unref(reply);
1002     }
1003   }
1004   dbus_message_unref(message);
1005   return consumed;
1006 }
1007
1008 gboolean
1009 spi_controller_notify_mouselisteners (SpiDEController                 *controller,
1010                                       const Accessibility_DeviceEvent *event)
1011 {
1012   GList   *l;
1013   GSList  *notify = NULL, *l2;
1014   GList  **listeners = &controller->mouse_listeners;
1015   gboolean is_consumed;
1016 #ifdef SPI_KEYEVENT_DEBUG
1017   gboolean found = FALSE;
1018 #endif
1019   if (!listeners)
1020     {
1021       return FALSE;
1022     }
1023
1024   for (l = *listeners; l; l = l->next)
1025     {
1026        DEControllerListener *listener = l->data;
1027
1028        if (eventtype_seq_contains_event (listener->types, event))
1029          {
1030            /* we clone (don't dup) the listener, to avoid refcount inc. */
1031            notify = g_slist_prepend (notify,
1032                                      spi_listener_clone (listener));
1033 #ifdef SPI_KEYEVENT_DEBUG
1034            found = TRUE;
1035 #endif
1036          }
1037     }
1038
1039 #ifdef SPI_KEYEVENT_DEBUG
1040   if (!found)
1041     {
1042       g_print ("no match for event\n");
1043     }
1044 #endif
1045
1046   is_consumed = FALSE;
1047   for (l2 = notify; l2 && !is_consumed; l2 = l2->next)
1048     {
1049       DEControllerListener *listener = l2->data;
1050
1051       is_consumed = Accessibility_DeviceEventListener_NotifyEvent (controller, controller->registry, listener, event);
1052
1053       spi_listener_clone_free ((DEControllerListener *) l2->data);
1054     }
1055
1056   for (; l2; l2 = l2->next)
1057     {
1058       DEControllerListener *listener = l2->data;
1059       spi_listener_clone_free (listener);
1060       /* clone doesn't have its own ref, so don't use spi_device_listener_free */
1061     }
1062
1063   g_slist_free (notify);
1064
1065 #ifdef SPI_DEBUG
1066   if (is_consumed) g_message ("consumed\n");
1067 #endif
1068   return is_consumed;
1069 }
1070
1071 static gboolean
1072 key_set_contains_key (GSList                          *key_set,
1073                           const Accessibility_DeviceEvent *key_event)
1074 {
1075   gint i;
1076   gint len;
1077   GSList *l;
1078
1079   if (!key_set)
1080     {
1081 #ifdef SPI_DEBUG
1082       g_print ("null key set!\n");
1083 #endif
1084       return TRUE;
1085     }
1086
1087   len = g_slist_length (key_set);
1088
1089   if (len == 0) /* special case, means "all keys/any key" */
1090     {
1091 #ifdef SPI_DEBUG
1092       g_print ("anykey\n");
1093 #endif
1094       return TRUE;
1095     }
1096
1097   for (l = key_set,i = 0; l; l = g_slist_next(l),i++)
1098     {
1099       Accessibility_KeyDefinition *kd = l->data;
1100 #ifdef SPI_KEYEVENT_DEBUG
1101       g_print ("key_set[%d] event = %d, code = %d; key_event %d, code %d, string %s\n",
1102                 i,
1103                 (int) kd->keysym,
1104                 (int) kd->keycode,
1105                 (int) key_event->id,
1106                 (int) key_event->hw_code,
1107                 key_event->event_string);
1108 #endif
1109       if (kd->keysym == (dbus_uint32_t) key_event->id)
1110         {
1111           return TRUE;
1112         }
1113       if (kd->keycode == (dbus_uint32_t) key_event->hw_code)
1114         {
1115           return TRUE;
1116         }
1117       if (key_event->event_string && key_event->event_string[0] &&
1118           !strcmp (kd->keystring, key_event->event_string))
1119         {
1120           return TRUE;
1121         }
1122     }
1123
1124   return FALSE;
1125 }
1126
1127 static gboolean
1128 eventtype_seq_contains_event (dbus_uint32_t types,
1129                                   const Accessibility_DeviceEvent *event)
1130 {
1131   if (types == 0) /* special case, means "all events/any event" */
1132     {
1133       return TRUE;
1134     }
1135
1136   return (types & (1 << event->type));
1137 }
1138
1139 static gboolean
1140 spi_key_event_matches_listener (const Accessibility_DeviceEvent *key_event,
1141                                 DEControllerKeyListener         *listener,
1142                                 dbus_bool_t                    is_system_global)
1143 {
1144   if (((key_event->modifiers & 0xFF) == (dbus_uint16_t) (listener->mask & 0xFF)) &&
1145        key_set_contains_key (listener->keys, key_event) &&
1146        eventtype_seq_contains_event (listener->listener.types, key_event) &&
1147       (is_system_global == listener->mode->global))
1148     {
1149       return TRUE;
1150     }
1151   else
1152     {
1153       return FALSE;
1154     }
1155 }
1156
1157 gboolean
1158 spi_controller_notify_keylisteners (SpiDEController                 *controller,
1159                                     Accessibility_DeviceEvent       *key_event,
1160                                     dbus_bool_t                    is_system_global)
1161 {
1162   GList   *l;
1163   GSList  *notify = NULL, *l2;
1164   GList  **key_listeners = &controller->key_listeners;
1165   gboolean is_consumed;
1166
1167   if (!key_listeners)
1168     {
1169       return FALSE;
1170     }
1171
1172   /* set the NUMLOCK event mask bit if appropriate: see bug #143702 */
1173   if (key_event->modifiers & _numlock_physical_mask)
1174       key_event->modifiers |= SPI_KEYMASK_NUMLOCK;
1175
1176   for (l = *key_listeners; l; l = l->next)
1177     {
1178        DEControllerKeyListener *key_listener = l->data;
1179
1180        if (spi_key_event_matches_listener (key_event, key_listener, is_system_global))
1181          {
1182            /* we clone (don't dup) the listener, to avoid refcount inc. */
1183            notify = g_slist_prepend (notify,
1184                                      spi_key_listener_clone (key_listener));
1185          }
1186     }
1187
1188 #ifdef SPI_KEYEVENT_DEBUG
1189   if (!notify)
1190     {
1191       g_print ("no match for event\n");
1192     }
1193 #endif
1194
1195   is_consumed = FALSE;
1196   for (l2 = notify; l2 && !is_consumed; l2 = l2->next)
1197     {
1198       DEControllerKeyListener *key_listener = l2->data;
1199
1200       is_consumed = Accessibility_DeviceEventListener_NotifyEvent (controller, controller->registry, &key_listener->listener, key_event) &&
1201                     key_listener->mode->preemptive;
1202
1203       spi_key_listener_clone_free (key_listener);
1204     }
1205
1206   for (; l2; l2 = l2->next)
1207     {
1208       DEControllerKeyListener *key_listener = l2->data;
1209       spi_key_listener_clone_free (key_listener);
1210       /* clone doesn't have its own ref, so don't use spi_dec_listener_free */
1211     }
1212
1213   g_slist_free (notify);
1214
1215 #ifdef SPI_DEBUG
1216   if (is_consumed) g_message ("consumed\n");
1217 #endif
1218   return is_consumed;
1219 }
1220
1221 gboolean
1222 spi_clear_error_state (void)
1223 {
1224         gboolean retval = spi_error_code != 0;
1225         spi_error_code = 0;
1226         return retval;
1227 }
1228
1229 gboolean
1230 spi_controller_update_key_grabs (SpiDEController           *controller,
1231                                  Accessibility_DeviceEvent *recv)
1232 {
1233   GList *l, *next;
1234   gboolean   update_failed = FALSE;
1235   long keycode = 0;
1236
1237   g_return_val_if_fail (controller != NULL, FALSE);
1238
1239   /*
1240    * masks known to work with default RH 7.1+:
1241    * 0 (no mods), LockMask, Mod1Mask, Mod2Mask, ShiftMask,
1242    * ShiftMask|LockMask, Mod1Mask|LockMask, Mod2Mask|LockMask,
1243    * ShiftMask|Mod1Mask, ShiftMask|Mod2Mask, Mod1Mask|Mod2Mask,
1244    * ShiftMask|LockMask|Mod1Mask, ShiftMask|LockMask|Mod2Mask,
1245    *
1246    * ControlMask grabs are broken, must be in use already
1247    */
1248   if (recv)
1249     keycode = spi_dec_plat_get_keycode (controller, recv->id, NULL, TRUE, NULL);
1250   for (l = controller->keygrabs_list; l; l = next)
1251     {
1252       gboolean do_remove;
1253       gboolean re_issue_grab;
1254       DEControllerGrabMask *grab_mask = l->data;
1255
1256       next = l->next;
1257
1258       re_issue_grab = recv &&
1259               (recv->modifiers & grab_mask->mod_mask) &&
1260               (grab_mask->key_val == keycode);
1261
1262 #ifdef SPI_DEBUG
1263       fprintf (stderr, "mask=%lx %lx (%c%c) %s\n",
1264                (long int) grab_mask->key_val,
1265                (long int) grab_mask->mod_mask,
1266                grab_mask->pending_add ? '+' : '.',
1267                grab_mask->pending_remove ? '-' : '.',
1268                re_issue_grab ? "re-issue": "");
1269 #endif
1270
1271       do_remove = FALSE;
1272
1273       if (grab_mask->pending_add && grab_mask->pending_remove)
1274         {
1275           do_remove = TRUE;
1276         }
1277       else if (grab_mask->pending_remove)
1278         {
1279 #ifdef SPI_DEBUG
1280       fprintf (stderr, "ungrabbing, mask=%x\n", grab_mask->mod_mask);
1281 #endif
1282           spi_dec_plat_ungrab_key (controller,
1283                                grab_mask->key_val,
1284                                grab_mask->mod_mask);
1285
1286           do_remove = TRUE;
1287         }
1288       else if (grab_mask->pending_add || re_issue_grab)
1289         {
1290
1291 #ifdef SPI_DEBUG
1292           fprintf (stderr, "grab %d with mask %x\n", grab_mask->key_val, grab_mask->mod_mask);
1293 #endif
1294           update_failed = spi_dec_plat_grab_key (controller,
1295                                                grab_mask->key_val,
1296                                                grab_mask->mod_mask);
1297           if (update_failed) {
1298                   while (grab_mask->ref_count > 0) --grab_mask->ref_count;
1299                   do_remove = TRUE;
1300           }
1301         }
1302
1303       grab_mask->pending_add = FALSE;
1304       grab_mask->pending_remove = FALSE;
1305
1306       if (do_remove)
1307         {
1308           g_assert (grab_mask->ref_count <= 0);
1309
1310           controller->keygrabs_list = g_list_delete_link (
1311             controller->keygrabs_list, l);
1312
1313           spi_grab_mask_free (grab_mask);
1314         }
1315
1316     }
1317
1318   return ! update_failed;
1319 }
1320
1321 /*
1322  * Implemented GObject::finalize
1323  */
1324 static void
1325 spi_device_event_controller_object_finalize (GObject *object)
1326 {
1327   SpiDEController *controller;
1328   GObjectClass *parent_class = G_OBJECT_CLASS(spi_device_event_controller_parent_class);
1329   SpiDEControllerClass *klass;
1330
1331   controller = SPI_DEVICE_EVENT_CONTROLLER (object);
1332   klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);
1333 #ifdef SPI_DEBUG
1334   fprintf(stderr, "spi_device_event_controller_object_finalize called\n");
1335 #endif
1336   if (klass->plat.finalize)
1337     klass->plat.finalize (controller);
1338
1339   parent_class->finalize (object);
1340 }
1341
1342 /*
1343  * DBus Accessibility::DEController::RegisterKeystrokeListener
1344  *     method implementation
1345  */
1346 static DBusMessage *
1347 impl_register_keystroke_listener (DBusConnection *bus,
1348                                   DBusMessage *message,
1349                                   void *user_data)
1350 {
1351   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER(user_data);
1352   DEControllerKeyListener *dec_listener;
1353   DBusMessageIter iter, iter_array;
1354   const char *path;
1355   GSList *keys = NULL;
1356   dbus_int32_t mask, type;
1357   Accessibility_EventListenerMode *mode;
1358  dbus_bool_t ret;
1359   DBusMessage *reply = NULL;
1360   char *keystring;
1361
1362   if (strcmp (dbus_message_get_signature (message), "oa(iisi)uu(bbb)") != 0)
1363     return invalid_arguments_error (message);
1364
1365   dbus_message_iter_init(message, &iter);
1366   dbus_message_iter_get_basic(&iter, &path);
1367   dbus_message_iter_next(&iter);
1368   dbus_message_iter_recurse(&iter, &iter_array);
1369   while (dbus_message_iter_get_arg_type(&iter_array) != DBUS_TYPE_INVALID)
1370   {
1371     Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *)g_malloc(sizeof(Accessibility_KeyDefinition));
1372     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))
1373     {
1374       break;
1375     }
1376     kd->keystring = g_strdup (keystring);
1377     keys = g_slist_append(keys, kd);
1378   }
1379   dbus_message_iter_next(&iter);
1380   dbus_message_iter_get_basic(&iter, &mask);
1381   dbus_message_iter_next(&iter);
1382   dbus_message_iter_get_basic(&iter, &type);
1383   dbus_message_iter_next(&iter);
1384   mode = (Accessibility_EventListenerMode *)g_malloc(sizeof(Accessibility_EventListenerMode));
1385   if (mode)
1386   {
1387     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);
1388   }
1389 #ifdef SPI_DEBUG
1390   fprintf (stderr, "registering keystroke listener %s:%s with maskVal %lu\n",
1391            dbus_message_get_sender(message), path, (unsigned long) mask);
1392 #endif
1393   dec_listener = spi_dec_key_listener_new (dbus_message_get_sender(message), path, keys, mask, type, mode);
1394   g_free (mode);
1395   ret = spi_controller_register_device_listener (
1396           controller, (DEControllerListener *) dec_listener);
1397   reply = dbus_message_new_method_return (message);
1398   if (reply)
1399   {
1400     dbus_message_append_args (reply, DBUS_TYPE_BOOLEAN, &ret, DBUS_TYPE_INVALID);
1401   }
1402   return reply;
1403 }
1404
1405 /*
1406  * DBus Accessibility::DEController::RegisterDeviceEventListener
1407  *     method implementation
1408  */
1409 static DBusMessage *
1410 impl_register_device_event_listener (DBusConnection *bus,
1411                                   DBusMessage *message,
1412                                   void *user_data)
1413 {
1414   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER(user_data);
1415   DEControllerListener *dec_listener;
1416   const char *path;
1417   dbus_int32_t event_types;
1418   dbus_bool_t ret;
1419   DBusMessage *reply = NULL;
1420
1421   if (!dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_UINT32, &event_types, DBUS_TYPE_INVALID))
1422   {
1423     return invalid_arguments_error (message);
1424   }
1425   dec_listener = spi_dec_listener_new (dbus_message_get_sender(message), path, event_types);
1426   ret =  spi_controller_register_device_listener (
1427           controller, (DEControllerListener *) dec_listener);
1428   reply = dbus_message_new_method_return (message);
1429   if (reply)
1430   {
1431     dbus_message_append_args (reply, DBUS_TYPE_BOOLEAN, &ret, DBUS_TYPE_INVALID);
1432   }
1433   return reply;
1434 }
1435
1436 typedef struct {
1437         DBusConnection *bus;
1438         DEControllerListener    *listener;
1439 } RemoveListenerClosure;
1440
1441 static SpiReEntrantContinue
1442 remove_listener_cb (GList * const *list,
1443                     gpointer       user_data)
1444 {
1445   DEControllerListener  *listener = (*list)->data;
1446   RemoveListenerClosure *ctx = user_data;
1447
1448   if (!strcmp(ctx->listener->bus_name, listener->bus_name) &&
1449       !strcmp(ctx->listener->path, listener->path))
1450     {
1451       spi_re_entrant_list_delete_link (list);
1452       spi_dbus_remove_disconnect_match (ctx->bus, listener->bus_name);
1453       spi_dec_listener_free (listener);
1454     }
1455
1456   return SPI_RE_ENTRANT_CONTINUE;
1457 }
1458
1459 static SpiReEntrantContinue
1460 copy_key_listener_cb (GList * const *list,
1461                       gpointer       user_data)
1462 {
1463   DEControllerKeyListener  *key_listener = (*list)->data;
1464   RemoveListenerClosure    *ctx = user_data;
1465
1466   if (!strcmp(ctx->listener->bus_name, key_listener->listener.bus_name) &&
1467       !strcmp(ctx->listener->path, key_listener->listener.path))
1468     {
1469       /* TODO: FIXME aggregate keys in case the listener is registered twice */
1470       DEControllerKeyListener *ctx_key_listener =
1471         (DEControllerKeyListener *) ctx->listener;
1472       keylist_free (ctx_key_listener->keys);
1473       ctx_key_listener->keys = keylist_clone(key_listener->keys);
1474     }
1475
1476   return SPI_RE_ENTRANT_CONTINUE;
1477 }
1478
1479 static void
1480 spi_controller_deregister_device_listener (SpiDEController            *controller,
1481                                            DEControllerListener *listener)
1482 {
1483   RemoveListenerClosure  ctx;
1484
1485   ctx.bus = controller->bus;
1486   ctx.listener = listener;
1487
1488   notify_mouse_listener (controller, listener, FALSE);
1489
1490   spi_re_entrant_list_foreach (&controller->mouse_listeners,
1491                                remove_listener_cb, &ctx);
1492   if (!controller->mouse_listeners)
1493     have_mouse_listener = FALSE;
1494 }
1495
1496 static void
1497 spi_deregister_controller_key_listener (SpiDEController            *controller,
1498                                         DEControllerKeyListener    *key_listener)
1499 {
1500   RemoveListenerClosure  ctx;
1501
1502   ctx.bus = controller->bus;
1503   ctx.listener = (DEControllerListener *) spi_key_listener_clone (key_listener);
1504
1505   notify_keystroke_listener (controller, key_listener, FALSE);
1506
1507   /* special case, copy keyset from existing controller list entry */
1508   if (g_slist_length(key_listener->keys) == 0)
1509     {
1510       spi_re_entrant_list_foreach (&controller->key_listeners,
1511                                   copy_key_listener_cb, &ctx);
1512     }
1513
1514   spi_controller_deregister_global_keygrabs (controller, key_listener);
1515
1516   spi_re_entrant_list_foreach (&controller->key_listeners,
1517                                 remove_listener_cb, &ctx);
1518
1519   spi_key_listener_clone_free ((DEControllerKeyListener *) ctx.listener);
1520 }
1521
1522 void
1523 spi_remove_device_listeners (SpiDEController *controller, const char *bus_name)
1524 {
1525   GList *l, *tmp;
1526
1527   for (l = controller->mouse_listeners; l; l = tmp)
1528   {
1529     DEControllerListener *listener = l->data;
1530     tmp = l->next;
1531     if (!strcmp (listener->bus_name, bus_name))
1532     {
1533       spi_controller_deregister_device_listener (controller, listener);
1534       tmp = controller->mouse_listeners;
1535     }
1536   }
1537   for (l = controller->key_listeners; l; l = tmp)
1538   {
1539     DEControllerKeyListener *key_listener = l->data;
1540     tmp = l->next;
1541     if (!strcmp (key_listener->listener.bus_name, bus_name))
1542     {
1543       /* TODO: untangle the below line(s) */
1544       spi_deregister_controller_key_listener (controller, key_listener);
1545       tmp = controller->key_listeners;
1546     }
1547   }
1548 }
1549
1550 /*
1551  * DBus Accessibility::DEController::DeregisterKeystrokeListener
1552  *     method implementation
1553  */
1554 static DBusMessage *
1555 impl_deregister_keystroke_listener (DBusConnection *bus,
1556                                   DBusMessage *message,
1557                                   void *user_data)
1558 {
1559   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER(user_data);
1560   DEControllerKeyListener *key_listener;
1561   DBusMessageIter iter, iter_array;
1562   const char *path;
1563   GSList *keys = NULL;
1564   dbus_int32_t mask, type;
1565   DBusMessage *reply = NULL;
1566
1567   dbus_message_iter_init(message, &iter);
1568   if (strcmp (dbus_message_get_signature (message), "oa(iisi)uu") != 0)
1569   {
1570     g_warning ("Received DeregisterKeystrokeListener with strange signature '%s'", dbus_message_get_signature (message));
1571     return invalid_arguments_error (message);
1572   }
1573
1574   dbus_message_iter_get_basic(&iter, &path);
1575   dbus_message_iter_next(&iter);
1576   dbus_message_iter_recurse(&iter, &iter_array);
1577   while (dbus_message_iter_get_arg_type(&iter_array) != DBUS_TYPE_INVALID)
1578   {
1579     Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *)g_malloc(sizeof(Accessibility_KeyDefinition));
1580   char *keystring;
1581
1582     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))
1583     {
1584       break;
1585     }
1586     kd->keystring = g_strdup (keystring);
1587     keys = g_slist_append(keys, kd);
1588   }
1589   dbus_message_iter_next(&iter);
1590   dbus_message_iter_get_basic(&iter, &mask);
1591   dbus_message_iter_next(&iter);
1592   dbus_message_iter_get_basic(&iter, &type);
1593   dbus_message_iter_next(&iter);
1594   key_listener = spi_dec_key_listener_new (dbus_message_get_sender(message), path, keys, mask, type, NULL);
1595 #ifdef SPI_DEREGISTER_DEBUG
1596   fprintf (stderr, "deregistering keystroke listener %p with maskVal %lu\n",
1597            (void *) l, (unsigned long) mask->value);
1598 #endif
1599
1600   spi_deregister_controller_key_listener (controller, key_listener);
1601
1602   spi_dec_listener_free ((DEControllerListener *) key_listener);
1603   reply = dbus_message_new_method_return (message);
1604   return reply;
1605 }
1606
1607 /*
1608  * DBus Accessibility::DEController::DeregisterDeviceEventListener
1609  *     method implementation
1610  */
1611 static DBusMessage *
1612 impl_deregister_device_event_listener (DBusConnection *bus,
1613                                   DBusMessage *message,
1614                                   void *user_data)
1615 {
1616   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER(user_data);
1617   DEControllerListener *listener;
1618   const char *path;
1619   dbus_int32_t event_types;
1620   DBusMessage *reply = NULL;
1621
1622   if (!dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_UINT32, &event_types, DBUS_TYPE_INVALID))
1623   {
1624     return invalid_arguments_error (message);
1625   }
1626   listener = spi_dec_listener_new (dbus_message_get_sender(message), path, event_types);
1627   spi_controller_deregister_device_listener (
1628           controller, listener);
1629   reply = dbus_message_new_method_return (message);
1630   return reply;
1631 }
1632
1633 static DBusMessage *
1634 impl_get_keystroke_listeners (DBusConnection *bus,
1635                                   DBusMessage *message,
1636                                   void *user_data)
1637 {
1638   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER(user_data);
1639   DBusMessageIter iter, iter_array;
1640   DBusMessage *reply = dbus_message_new_method_return (message);
1641   GList *l;
1642
1643   if (!reply)
1644     return NULL;
1645
1646   dbus_message_iter_init_append (reply, &iter);
1647   dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY,
1648                                     "(souua(iisi)u(bbb))", &iter_array);
1649   for (l = controller->key_listeners; l; l = l->next)
1650   {
1651     append_keystroke_listener (&iter_array, l->data);
1652   }
1653   dbus_message_iter_close_container (&iter, &iter_array);
1654   return reply;
1655 }
1656
1657 static DBusMessage *
1658 impl_get_device_event_listeners (DBusConnection *bus,
1659                                   DBusMessage *message,
1660                                   void *user_data)
1661 {
1662   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER(user_data);
1663   DBusMessageIter iter, iter_array;
1664   GList *l;
1665   DBusMessage *reply = dbus_message_new_method_return (message);
1666
1667   if (!reply)
1668     return NULL;
1669
1670   dbus_message_iter_init_append (reply, &iter);
1671   dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY,
1672                                     "(sou)", &iter_array);
1673   for (l = controller->key_listeners; l; l = l->next)
1674   {
1675     append_mouse_listener (&iter_array, l->data);
1676   }
1677   dbus_message_iter_close_container (&iter, &iter_array);
1678   return reply;
1679 }
1680
1681 static unsigned
1682 get_modifier_state (SpiDEController *controller)
1683 {
1684         return mouse_mask_state;
1685 }
1686
1687 gboolean
1688 spi_dec_synth_keysym (SpiDEController *controller, long keysym)
1689 {
1690         long key_synth_code;
1691         unsigned int modifiers, synth_mods, lock_mods;
1692
1693         key_synth_code = spi_dec_plat_get_keycode (controller, keysym, NULL, TRUE, &synth_mods);
1694
1695         if ((key_synth_code == 0) || (synth_mods == 0xFF)) return FALSE;
1696
1697         /* TODO: set the modifiers accordingly! */
1698         modifiers = get_modifier_state (controller);
1699         /* side-effect; we may unset mousebutton modifiers here! */
1700
1701         lock_mods = 0;
1702         if (synth_mods != modifiers) {
1703                 lock_mods = synth_mods & ~modifiers;
1704                 spi_dec_plat_lock_modifiers (controller, lock_mods);
1705         }
1706         spi_dec_plat_synth_keycode_press (controller, key_synth_code);
1707         spi_dec_plat_synth_keycode_release (controller, key_synth_code);
1708
1709         if (synth_mods != modifiers)
1710                 spi_dec_plat_unlock_modifiers (controller, lock_mods);
1711         return TRUE;
1712 }
1713
1714
1715
1716 /*
1717  * DBus Accessibility::DEController::RegisterKeystrokeListener
1718  *     method implementation
1719  */
1720 static DBusMessage *
1721 impl_generate_keyboard_event (DBusConnection *bus, DBusMessage *message, void *user_data)
1722 {
1723   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER(user_data);
1724   dbus_int32_t keycode;
1725   char *keystring;
1726   dbus_uint32_t synth_type;
1727   DBusMessage *reply = NULL;
1728
1729   if (!dbus_message_get_args(message, NULL, DBUS_TYPE_INT32, &keycode, DBUS_TYPE_STRING, &keystring, DBUS_TYPE_UINT32, &synth_type, DBUS_TYPE_INVALID))
1730   {
1731     return invalid_arguments_error (message);
1732   }
1733
1734 #ifdef SPI_DEBUG
1735         fprintf (stderr, "synthesizing keystroke %ld, type %d\n",
1736                  (long) keycode, (int) synth_type);
1737 #endif
1738   /* TODO: hide/wrap/remove X dependency */
1739
1740   /*
1741    * TODO: when initializing, query for XTest extension before using,
1742    * and fall back to XSendEvent() if XTest is not available.
1743    */
1744
1745   switch (synth_type)
1746     {
1747       case Accessibility_KEY_PRESS:
1748               spi_dec_plat_synth_keycode_press (controller, keycode);
1749               break;
1750       case Accessibility_KEY_PRESSRELEASE:
1751               spi_dec_plat_synth_keycode_press (controller, keycode);
1752       case Accessibility_KEY_RELEASE:
1753               spi_dec_plat_synth_keycode_release (controller, keycode);
1754               break;
1755       case Accessibility_KEY_SYM:
1756 #ifdef SPI_XKB_DEBUG
1757               fprintf (stderr, "KeySym synthesis\n");
1758 #endif
1759               /*
1760                * note: we are using long for 'keycode'
1761                * in our arg list; it can contain either
1762                * a keycode or a keysym.
1763                */
1764 #ifdef HAVE_X11
1765               spi_dec_synth_keysym (controller, (KeySym) keycode);
1766 #else
1767               spi_dec_synth_keysym (controller, (long) keycode);
1768 #endif
1769               break;
1770       case Accessibility_KEY_STRING:
1771               if (!spi_dec_plat_synth_keystring (controller, synth_type, keycode, keystring))
1772                       fprintf (stderr, "Keystring synthesis failure, string=%s\n",
1773                                keystring);
1774               break;
1775     }
1776   reply = dbus_message_new_method_return (message);
1777   return reply;
1778 }
1779
1780 /* Accessibility::DEController::GenerateMouseEvent */
1781 static DBusMessage *
1782 impl_generate_mouse_event (DBusConnection *bus, DBusMessage *message, void *user_data)
1783 {
1784   dbus_int32_t       x;
1785   dbus_int32_t       y;
1786   char *eventName;
1787   DBusMessage *reply = NULL;
1788
1789   if (!dbus_message_get_args(message, NULL, DBUS_TYPE_INT32, &x, DBUS_TYPE_INT32, &y, DBUS_TYPE_STRING, &eventName, DBUS_TYPE_INVALID))
1790   {
1791     return invalid_arguments_error (message);
1792   }
1793
1794 #ifdef SPI_DEBUG
1795   fprintf (stderr, "generating mouse %s event at %ld, %ld\n",
1796            eventName, (long int) x, (long int) y);
1797 #endif
1798   spi_dec_plat_generate_mouse_event (saved_controller, x, y, eventName);
1799   reply = dbus_message_new_method_return (message);
1800   return reply;
1801 }
1802
1803 /* Accessibility::DEController::NotifyListenersSync */
1804 static DBusMessage *
1805 impl_notify_listeners_sync (DBusConnection *bus, DBusMessage *message, void *user_data)
1806 {
1807   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER(user_data);
1808   Accessibility_DeviceEvent event;
1809   dbus_bool_t ret;
1810   DBusMessage *reply = NULL;
1811
1812   if (!spi_dbus_demarshal_deviceEvent(message, &event))
1813   {
1814     return invalid_arguments_error (message);
1815   }
1816 #ifdef SPI_DEBUG
1817   g_print ("notifylistening listeners synchronously: controller %p, event id %d\n",
1818            controller, (int) event.id);
1819 #endif
1820   ret = spi_controller_notify_keylisteners (controller,
1821                                              (Accessibility_DeviceEvent *)
1822                                              &event, FALSE) ?
1823           TRUE : FALSE;
1824   reply = dbus_message_new_method_return (message);
1825   if (reply)
1826   {
1827     dbus_message_append_args (reply, DBUS_TYPE_BOOLEAN, &ret, DBUS_TYPE_INVALID);
1828   }
1829   return reply;
1830 }
1831
1832 static DBusMessage *
1833 impl_notify_listeners_async (DBusConnection *bus, DBusMessage *message, void *user_data)
1834 {
1835   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER(user_data);
1836   Accessibility_DeviceEvent event;
1837   DBusMessage *reply = NULL;
1838
1839   if (!spi_dbus_demarshal_deviceEvent(message, &event))
1840   {
1841     return invalid_arguments_error (message);
1842   }
1843 #ifdef SPI_DEBUG
1844   g_print ("notifylistening listeners asynchronously: controller %p, event id %d\n",
1845            controller, (int) event.id);
1846 #endif
1847   spi_controller_notify_keylisteners (controller, (Accessibility_DeviceEvent *)
1848                                       &event, FALSE);
1849   reply = dbus_message_new_method_return (message);
1850   return reply;
1851 }
1852
1853 static void
1854 spi_device_event_controller_class_init (SpiDEControllerClass *klass)
1855 {
1856   GObjectClass * object_class = (GObjectClass *) klass;
1857
1858   spi_device_event_controller_parent_class = g_type_class_peek_parent (klass);
1859
1860   object_class->finalize = spi_device_event_controller_object_finalize;
1861
1862 #ifdef HAVE_X11
1863   if (g_getenv ("DISPLAY"))
1864     spi_dec_setup_x11 (klass);
1865   else
1866 #endif
1867   g_type_class_add_private (object_class, sizeof (long)); /* dummy */
1868 }
1869
1870 static void
1871 spi_device_event_controller_init (SpiDEController *device_event_controller)
1872 {
1873   SpiDEControllerClass *klass;
1874   klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (device_event_controller);
1875
1876   /* TODO: shouldn't be gpointer below */
1877   device_event_controller->priv = G_TYPE_INSTANCE_GET_PRIVATE (device_event_controller,
1878                                               SPI_DEVICE_EVENT_CONTROLLER_TYPE,
1879                                               gpointer);
1880   device_event_controller->message_queue = g_queue_new ();
1881   saved_controller = device_event_controller;
1882
1883   if (klass->plat.init)
1884     klass->plat.init (device_event_controller);
1885 }
1886
1887
1888 /*---------------------------------------------------------------------------*/
1889
1890 static const char *introspection_header =
1891 "<?xml version=\"1.0\"?>\n";
1892
1893 static const char *introspection_node_element =
1894 "<node name=\"%s\">\n";
1895
1896 static const char *introspection_footer =
1897 "</node>";
1898
1899 static DBusMessage *
1900 impl_Introspect (DBusConnection * bus,
1901                  DBusMessage * message, void *user_data)
1902 {
1903   GString *output;
1904   gchar *final;
1905
1906   const gchar *pathstr = SPI_DBUS_PATH_DEC;
1907
1908   DBusMessage *reply;
1909
1910   output = g_string_new(introspection_header);
1911
1912   g_string_append_printf(output, introspection_node_element, pathstr);
1913
1914   g_string_append (output, spi_org_a11y_atspi_DeviceEventController);
1915
1916   g_string_append(output, introspection_footer);
1917   final = g_string_free(output, FALSE);
1918
1919   reply = dbus_message_new_method_return (message);
1920   dbus_message_append_args(reply, DBUS_TYPE_STRING, &final, DBUS_TYPE_INVALID);
1921
1922   g_free(final);
1923   return reply;
1924 }
1925
1926 /*---------------------------------------------------------------------------*/
1927
1928 static void
1929 handle_dec_method_from_idle (DBusConnection *bus, DBusMessage *message, void *user_data)
1930 {
1931   const gchar *iface   = dbus_message_get_interface (message);
1932   const gchar *member  = dbus_message_get_member (message);
1933   DBusHandlerResult result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1934   DBusMessage *reply = NULL;
1935
1936   if (!strcmp (iface, SPI_DBUS_INTERFACE_DEC))
1937     {
1938       result = DBUS_HANDLER_RESULT_HANDLED;
1939       if      (!strcmp (member, "RegisterKeystrokeListener"))
1940           reply = impl_register_keystroke_listener (bus, message, user_data);
1941       else if (!strcmp (member, "RegisterDeviceEventListener"))
1942           reply = impl_register_device_event_listener (bus, message, user_data);
1943       else if (!strcmp (member, "DeregisterKeystrokeListener"))
1944           reply = impl_deregister_keystroke_listener (bus, message, user_data);
1945       else if (!strcmp (member, "DeregisterDeviceEventListener"))
1946           reply = impl_deregister_device_event_listener (bus, message, user_data);
1947       else if (!strcmp (member, "GetKeystrokeListeners"))
1948           reply = impl_get_keystroke_listeners (bus, message, user_data);
1949       else if (!strcmp (member, "GetDeviceEventListeners"))
1950           reply = impl_get_device_event_listeners (bus, message, user_data);
1951       else if (!strcmp (member, "GenerateKeyboardEvent"))
1952           reply = impl_generate_keyboard_event (bus, message, user_data);
1953       else if (!strcmp (member, "GenerateMouseEvent"))
1954           reply = impl_generate_mouse_event (bus, message, user_data);
1955       else if (!strcmp (member, "NotifyListenersSync"))
1956           reply = impl_notify_listeners_sync (bus, message, user_data);
1957       else if (!strcmp (member, "NotifyListenersAsync"))
1958           reply = impl_notify_listeners_async (bus, message, user_data);
1959       else
1960           result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1961     }
1962
1963   if (!strcmp (iface, "org.freedesktop.DBus.Introspectable"))
1964     {
1965       result = DBUS_HANDLER_RESULT_HANDLED;
1966       if      (!strcmp (member, "Introspect"))
1967           reply = impl_Introspect (bus, message, user_data);
1968       else
1969           result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1970     }
1971
1972   if (result == DBUS_HANDLER_RESULT_HANDLED)
1973     {
1974       if (!reply)
1975         {
1976           reply = dbus_message_new_method_return (message);
1977         }
1978
1979       dbus_connection_send (bus, reply, NULL);
1980       dbus_message_unref (reply);
1981     }
1982 }
1983
1984 static gboolean
1985 message_queue_dispatch (gpointer data)
1986 {
1987   saved_controller->message_queue_idle = 0;
1988   while (!g_queue_is_empty (saved_controller->message_queue))
1989     {
1990       DBusMessage *message = g_queue_pop_head (saved_controller->message_queue);
1991       data = g_queue_pop_head (saved_controller->message_queue);
1992       handle_dec_method_from_idle (saved_controller->bus, message, data);
1993       dbus_message_unref (message);
1994     }
1995   return FALSE;
1996 }
1997
1998 static DBusHandlerResult
1999 handle_dec_method (DBusConnection *bus, DBusMessage *message, void *user_data)
2000 {
2001   const gchar *iface   = dbus_message_get_interface (message);
2002   const gchar *member  = dbus_message_get_member (message);
2003   const gint   type    = dbus_message_get_type (message);
2004
2005   /* Check for basic reasons not to handle */
2006   if (type   != DBUS_MESSAGE_TYPE_METHOD_CALL ||
2007       member == NULL ||
2008       iface  == NULL)
2009       return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2010
2011   dbus_message_ref (message);
2012   g_queue_push_tail (saved_controller->message_queue, message);
2013   g_queue_push_tail (saved_controller->message_queue, user_data);
2014   if (!saved_controller->message_queue_idle) {
2015     saved_controller->message_queue_idle = g_idle_add (message_queue_dispatch, NULL);
2016     g_source_set_name_by_id (saved_controller->message_queue_idle, "[at-spi2-core] message_queue_dispatch");
2017   }
2018   return DBUS_HANDLER_RESULT_HANDLED;
2019 }
2020
2021 static DBusObjectPathVTable dec_vtable =
2022 {
2023   NULL,
2024   &handle_dec_method,
2025   NULL, NULL, NULL, NULL
2026 };
2027
2028 SpiDEController *
2029 spi_registry_dec_new (SpiRegistry *reg, DBusConnection *bus)
2030 {
2031   SpiDEController *dec = g_object_new (SPI_DEVICE_EVENT_CONTROLLER_TYPE, NULL);
2032
2033   dec->registry = g_object_ref (reg);
2034   reg->dec = g_object_ref (dec);
2035   dec->bus = bus;
2036
2037   dbus_connection_register_object_path (bus, SPI_DBUS_PATH_DEC, &dec_vtable, dec);
2038
2039   return dec;
2040 }
2041
2042 void
2043 spi_device_event_controller_start_poll_mouse (SpiRegistry *registry)
2044 {
2045   if (!have_mouse_event_listener)
2046     {
2047       have_mouse_event_listener = TRUE;
2048       if (!have_mouse_listener) {
2049         guint id;
2050         id = g_timeout_add (100, spi_dec_poll_mouse_idle, registry->dec);
2051         g_source_set_name_by_id (id, "[at-spi2-core] spi_dec_poll_mouse_idle");
2052       }
2053     }
2054 }
2055
2056 void
2057 spi_device_event_controller_stop_poll_mouse (void)
2058 {
2059   have_mouse_event_listener = FALSE;
2060 }