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         dbus_bool_t result;
 937         gchar *bus_name_dup;
 938         dbus_message_ref (message);
 939         dbus_pending_call_set_notify (pending, reset_hung_process, message,
 940                                       (DBusFreeFunction) dbus_message_unref);
 941         message = dbus_message_new_method_call (dest, "/",
 942                                                 "org.freedesktop.DBus.Peer",
 943                                                 "Ping");
 944         if (!message)
 945           return NULL;
 946         result = dbus_connection_send_with_reply (bus, message, &pending, -1);
 947         dbus_message_unref (message);
 948         if (!result || !pending)
 949           return NULL;
 950         bus_name_dup = g_strdup (dest);
 951         dbus_pending_call_set_notify (pending, reset_hung_process_from_ping,
 952                                       bus_name_dup, NULL);
 953         for (l = hung_processes; l; l = l->next)
 954           if (!strcmp (l->data, dest))
 955             return NULL;
 956         hung_processes = g_slist_prepend (hung_processes, g_strdup (dest));
 957         return NULL;
 958       }
 959     }
 960     dbus_pending_call_unref (pending);
 961     return reply;
 962 }
 963 static gboolean
 964 Accessibility_DeviceEventListener_NotifyEvent(SpiDEController *controller,
 965                                               SpiRegistry *registry,
 966                                               DEControllerListener *listener,
 967                                               const Accessibility_DeviceEvent *key_event)
 968 {
 969   DBusMessage *message = dbus_message_new_method_call(listener->bus_name,
 970                                                       listener->path,
 971                                                       SPI_DBUS_INTERFACE_DEVICE_EVENT_LISTENER,
 972                                                       "NotifyEvent");
 973   dbus_bool_t consumed = FALSE;
 974   GSList *l;
 975   gboolean hung = FALSE;
 976
 977   for (l = hung_processes; l; l = l->next)
 978   {
 979     if (!strcmp (l->data, listener->bus_name))
 980     {
 981       dbus_message_set_no_reply (message, TRUE);
 982       hung = TRUE;
 983       break;
 984     }
 985   }
 986
 987   if (spi_dbus_marshal_deviceEvent(message, key_event))
 988   {
 989     DBusMessage *reply;
 990
 991     if (hung)
 992     {
 993       dbus_connection_send (controller->bus, message, NULL);
 994       dbus_message_unref (message);
 995       return FALSE;
 996     }
 997
 998     reply = send_and_allow_reentry (controller->bus, message, 3000, NULL);
 999     if (reply)
1000     {
1001       dbus_message_get_args(reply, NULL, DBUS_TYPE_BOOLEAN, &consumed, DBUS_TYPE_INVALID);
1002       dbus_message_unref(reply);
1003     }
1004   }
1005   dbus_message_unref(message);
1006   return consumed;
1007 }
1008
1009 gboolean
1010 spi_controller_notify_mouselisteners (SpiDEController                 *controller,
1011                                       const Accessibility_DeviceEvent *event)
1012 {
1013   GList   *l;
1014   GSList  *notify = NULL, *l2;
1015   GList  **listeners = &controller->mouse_listeners;
1016   gboolean is_consumed;
1017 #ifdef SPI_KEYEVENT_DEBUG
1018   gboolean found = FALSE;
1019 #endif
1020   if (!listeners)
1021     {
1022       return FALSE;
1023     }
1024
1025   for (l = *listeners; l; l = l->next)
1026     {
1027        DEControllerListener *listener = l->data;
1028
1029        if (eventtype_seq_contains_event (listener->types, event))
1030          {
1031            /* we clone (don't dup) the listener, to avoid refcount inc. */
1032            notify = g_slist_prepend (notify,
1033                                      spi_listener_clone (listener));
1034 #ifdef SPI_KEYEVENT_DEBUG
1035            found = TRUE;
1036 #endif
1037          }
1038     }
1039
1040 #ifdef SPI_KEYEVENT_DEBUG
1041   if (!found)
1042     {
1043       g_print ("no match for event\n");
1044     }
1045 #endif
1046
1047   is_consumed = FALSE;
1048   for (l2 = notify; l2 && !is_consumed; l2 = l2->next)
1049     {
1050       DEControllerListener *listener = l2->data;
1051
1052       is_consumed = Accessibility_DeviceEventListener_NotifyEvent (controller, controller->registry, listener, event);
1053
1054       spi_listener_clone_free ((DEControllerListener *) l2->data);
1055     }
1056
1057   for (; l2; l2 = l2->next)
1058     {
1059       DEControllerListener *listener = l2->data;
1060       spi_listener_clone_free (listener);
1061       /* clone doesn't have its own ref, so don't use spi_device_listener_free */
1062     }
1063
1064   g_slist_free (notify);
1065
1066 #ifdef SPI_DEBUG
1067   if (is_consumed) g_message ("consumed\n");
1068 #endif
1069   return is_consumed;
1070 }
1071
1072 static gboolean
1073 key_set_contains_key (GSList                          *key_set,
1074                           const Accessibility_DeviceEvent *key_event)
1075 {
1076   gint i;
1077   gint len;
1078   GSList *l;
1079
1080   if (!key_set)
1081     {
1082 #ifdef SPI_DEBUG
1083       g_print ("null key set!\n");
1084 #endif
1085       return TRUE;
1086     }
1087
1088   len = g_slist_length (key_set);
1089
1090   if (len == 0) /* special case, means "all keys/any key" */
1091     {
1092 #ifdef SPI_DEBUG
1093       g_print ("anykey\n");
1094 #endif
1095       return TRUE;
1096     }
1097
1098   for (l = key_set,i = 0; l; l = g_slist_next(l),i++)
1099     {
1100       Accessibility_KeyDefinition *kd = l->data;
1101 #ifdef SPI_KEYEVENT_DEBUG
1102       g_print ("key_set[%d] event = %d, code = %d; key_event %d, code %d, string %s\n",
1103                 i,
1104                 (int) kd->keysym,
1105                 (int) kd->keycode,
1106                 (int) key_event->id,
1107                 (int) key_event->hw_code,
1108                 key_event->event_string);
1109 #endif
1110       if (kd->keysym == (dbus_uint32_t) key_event->id)
1111         {
1112           return TRUE;
1113         }
1114       if (kd->keycode == (dbus_uint32_t) key_event->hw_code)
1115         {
1116           return TRUE;
1117         }
1118       if (key_event->event_string && key_event->event_string[0] &&
1119           !strcmp (kd->keystring, key_event->event_string))
1120         {
1121           return TRUE;
1122         }
1123     }
1124
1125   return FALSE;
1126 }
1127
1128 static gboolean
1129 eventtype_seq_contains_event (dbus_uint32_t types,
1130                                   const Accessibility_DeviceEvent *event)
1131 {
1132   if (types == 0) /* special case, means "all events/any event" */
1133     {
1134       return TRUE;
1135     }
1136
1137   return (types & (1 << event->type));
1138 }
1139
1140 static gboolean
1141 spi_key_event_matches_listener (const Accessibility_DeviceEvent *key_event,
1142                                 DEControllerKeyListener         *listener,
1143                                 dbus_bool_t                    is_system_global)
1144 {
1145   if (((key_event->modifiers & 0xFF) == (dbus_uint16_t) (listener->mask & 0xFF)) &&
1146        key_set_contains_key (listener->keys, key_event) &&
1147        eventtype_seq_contains_event (listener->listener.types, key_event) &&
1148       (is_system_global == listener->mode->global))
1149     {
1150       return TRUE;
1151     }
1152   else
1153     {
1154       return FALSE;
1155     }
1156 }
1157
1158 gboolean
1159 spi_controller_notify_keylisteners (SpiDEController                 *controller,
1160                                     Accessibility_DeviceEvent       *key_event,
1161                                     dbus_bool_t                    is_system_global)
1162 {
1163   GList   *l;
1164   GSList  *notify = NULL, *l2;
1165   GList  **key_listeners = &controller->key_listeners;
1166   gboolean is_consumed;
1167
1168   if (!key_listeners)
1169     {
1170       return FALSE;
1171     }
1172
1173   /* set the NUMLOCK event mask bit if appropriate: see bug #143702 */
1174   if (key_event->modifiers & _numlock_physical_mask)
1175       key_event->modifiers |= SPI_KEYMASK_NUMLOCK;
1176
1177   for (l = *key_listeners; l; l = l->next)
1178     {
1179        DEControllerKeyListener *key_listener = l->data;
1180
1181        if (spi_key_event_matches_listener (key_event, key_listener, is_system_global))
1182          {
1183            /* we clone (don't dup) the listener, to avoid refcount inc. */
1184            notify = g_slist_prepend (notify,
1185                                      spi_key_listener_clone (key_listener));
1186          }
1187     }
1188
1189 #ifdef SPI_KEYEVENT_DEBUG
1190   if (!notify)
1191     {
1192       g_print ("no match for event\n");
1193     }
1194 #endif
1195
1196   is_consumed = FALSE;
1197   for (l2 = notify; l2 && !is_consumed; l2 = l2->next)
1198     {
1199       DEControllerKeyListener *key_listener = l2->data;
1200
1201       is_consumed = Accessibility_DeviceEventListener_NotifyEvent (controller, controller->registry, &key_listener->listener, key_event) &&
1202                     key_listener->mode->preemptive;
1203
1204       spi_key_listener_clone_free (key_listener);
1205     }
1206
1207   for (; l2; l2 = l2->next)
1208     {
1209       DEControllerKeyListener *key_listener = l2->data;
1210       spi_key_listener_clone_free (key_listener);
1211       /* clone doesn't have its own ref, so don't use spi_dec_listener_free */
1212     }
1213
1214   g_slist_free (notify);
1215
1216 #ifdef SPI_DEBUG
1217   if (is_consumed) g_message ("consumed\n");
1218 #endif
1219   return is_consumed;
1220 }
1221
1222 gboolean
1223 spi_clear_error_state (void)
1224 {
1225         gboolean retval = spi_error_code != 0;
1226         spi_error_code = 0;
1227         return retval;
1228 }
1229
1230 gboolean
1231 spi_controller_update_key_grabs (SpiDEController           *controller,
1232                                  Accessibility_DeviceEvent *recv)
1233 {
1234   GList *l, *next;
1235   gboolean   update_failed = FALSE;
1236   long keycode = 0;
1237
1238   g_return_val_if_fail (controller != NULL, FALSE);
1239
1240   /*
1241    * masks known to work with default RH 7.1+:
1242    * 0 (no mods), LockMask, Mod1Mask, Mod2Mask, ShiftMask,
1243    * ShiftMask|LockMask, Mod1Mask|LockMask, Mod2Mask|LockMask,
1244    * ShiftMask|Mod1Mask, ShiftMask|Mod2Mask, Mod1Mask|Mod2Mask,
1245    * ShiftMask|LockMask|Mod1Mask, ShiftMask|LockMask|Mod2Mask,
1246    *
1247    * ControlMask grabs are broken, must be in use already
1248    */
1249   if (recv)
1250     keycode = spi_dec_plat_get_keycode (controller, recv->id, NULL, TRUE, NULL);
1251   for (l = controller->keygrabs_list; l; l = next)
1252     {
1253       gboolean do_remove;
1254       gboolean re_issue_grab;
1255       DEControllerGrabMask *grab_mask = l->data;
1256
1257       next = l->next;
1258
1259       re_issue_grab = recv &&
1260               (recv->modifiers & grab_mask->mod_mask) &&
1261               (grab_mask->key_val == keycode);
1262
1263 #ifdef SPI_DEBUG
1264       fprintf (stderr, "mask=%lx %lx (%c%c) %s\n",
1265                (long int) grab_mask->key_val,
1266                (long int) grab_mask->mod_mask,
1267                grab_mask->pending_add ? '+' : '.',
1268                grab_mask->pending_remove ? '-' : '.',
1269                re_issue_grab ? "re-issue": "");
1270 #endif
1271
1272       do_remove = FALSE;
1273
1274       if (grab_mask->pending_add && grab_mask->pending_remove)
1275         {
1276           do_remove = TRUE;
1277         }
1278       else if (grab_mask->pending_remove)
1279         {
1280 #ifdef SPI_DEBUG
1281       fprintf (stderr, "ungrabbing, mask=%x\n", grab_mask->mod_mask);
1282 #endif
1283           spi_dec_plat_ungrab_key (controller,
1284                                grab_mask->key_val,
1285                                grab_mask->mod_mask);
1286
1287           do_remove = TRUE;
1288         }
1289       else if (grab_mask->pending_add || re_issue_grab)
1290         {
1291
1292 #ifdef SPI_DEBUG
1293           fprintf (stderr, "grab %d with mask %x\n", grab_mask->key_val, grab_mask->mod_mask);
1294 #endif
1295           update_failed = spi_dec_plat_grab_key (controller,
1296                                                grab_mask->key_val,
1297                                                grab_mask->mod_mask);
1298           if (update_failed) {
1299                   while (grab_mask->ref_count > 0) --grab_mask->ref_count;
1300                   do_remove = TRUE;
1301           }
1302         }
1303
1304       grab_mask->pending_add = FALSE;
1305       grab_mask->pending_remove = FALSE;
1306
1307       if (do_remove)
1308         {
1309           g_assert (grab_mask->ref_count <= 0);
1310
1311           controller->keygrabs_list = g_list_delete_link (
1312             controller->keygrabs_list, l);
1313
1314           spi_grab_mask_free (grab_mask);
1315         }
1316
1317     }
1318
1319   return ! update_failed;
1320 }
1321
1322 /*
1323  * Implemented GObject::finalize
1324  */
1325 static void
1326 spi_device_event_controller_object_finalize (GObject *object)
1327 {
1328   SpiDEController *controller;
1329   GObjectClass *parent_class = G_OBJECT_CLASS(spi_device_event_controller_parent_class);
1330   SpiDEControllerClass *klass;
1331
1332   controller = SPI_DEVICE_EVENT_CONTROLLER (object);
1333   klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);
1334 #ifdef SPI_DEBUG
1335   fprintf(stderr, "spi_device_event_controller_object_finalize called\n");
1336 #endif
1337   if (klass->plat.finalize)
1338     klass->plat.finalize (controller);
1339
1340   parent_class->finalize (object);
1341 }
1342
1343 /*
1344  * DBus Accessibility::DEController::RegisterKeystrokeListener
1345  *     method implementation
1346  */
1347 static DBusMessage *
1348 impl_register_keystroke_listener (DBusConnection *bus,
1349                                   DBusMessage *message,
1350                                   void *user_data)
1351 {
1352   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER(user_data);
1353   DEControllerKeyListener *dec_listener;
1354   DBusMessageIter iter, iter_array;
1355   const char *path;
1356   GSList *keys = NULL;
1357   dbus_int32_t mask, type;
1358   Accessibility_EventListenerMode *mode;
1359  dbus_bool_t ret;
1360   DBusMessage *reply = NULL;
1361   char *keystring;
1362
1363   if (strcmp (dbus_message_get_signature (message), "oa(iisi)uu(bbb)") != 0)
1364     return invalid_arguments_error (message);
1365
1366   dbus_message_iter_init(message, &iter);
1367   dbus_message_iter_get_basic(&iter, &path);
1368   dbus_message_iter_next(&iter);
1369   dbus_message_iter_recurse(&iter, &iter_array);
1370   while (dbus_message_iter_get_arg_type(&iter_array) != DBUS_TYPE_INVALID)
1371   {
1372     Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *)g_malloc(sizeof(Accessibility_KeyDefinition));
1373     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))
1374     {
1375       g_free (kd);
1376       break;
1377     }
1378     kd->keystring = g_strdup (keystring);
1379     keys = g_slist_append(keys, kd);
1380   }
1381   dbus_message_iter_next(&iter);
1382   dbus_message_iter_get_basic(&iter, &mask);
1383   dbus_message_iter_next(&iter);
1384   dbus_message_iter_get_basic(&iter, &type);
1385   dbus_message_iter_next(&iter);
1386   mode = (Accessibility_EventListenerMode *)g_malloc(sizeof(Accessibility_EventListenerMode));
1387   if (mode)
1388   {
1389     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);
1390   }
1391 #ifdef SPI_DEBUG
1392   fprintf (stderr, "registering keystroke listener %s:%s with maskVal %lu\n",
1393            dbus_message_get_sender(message), path, (unsigned long) mask);
1394 #endif
1395   dec_listener = spi_dec_key_listener_new (dbus_message_get_sender(message), path, keys, mask, type, mode);
1396   g_free (mode);
1397   ret = spi_controller_register_device_listener (
1398           controller, (DEControllerListener *) dec_listener);
1399   reply = dbus_message_new_method_return (message);
1400   if (reply)
1401   {
1402     dbus_message_append_args (reply, DBUS_TYPE_BOOLEAN, &ret, DBUS_TYPE_INVALID);
1403   }
1404   return reply;
1405 }
1406
1407 /*
1408  * DBus Accessibility::DEController::RegisterDeviceEventListener
1409  *     method implementation
1410  */
1411 static DBusMessage *
1412 impl_register_device_event_listener (DBusConnection *bus,
1413                                   DBusMessage *message,
1414                                   void *user_data)
1415 {
1416   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER(user_data);
1417   DEControllerListener *dec_listener;
1418   const char *path;
1419   dbus_int32_t event_types;
1420   dbus_bool_t ret;
1421   DBusMessage *reply = NULL;
1422
1423   if (!dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_UINT32, &event_types, DBUS_TYPE_INVALID))
1424   {
1425     return invalid_arguments_error (message);
1426   }
1427   dec_listener = spi_dec_listener_new (dbus_message_get_sender(message), path, event_types);
1428   ret =  spi_controller_register_device_listener (
1429           controller, (DEControllerListener *) dec_listener);
1430   reply = dbus_message_new_method_return (message);
1431   if (reply)
1432   {
1433     dbus_message_append_args (reply, DBUS_TYPE_BOOLEAN, &ret, DBUS_TYPE_INVALID);
1434   }
1435   return reply;
1436 }
1437
1438 typedef struct {
1439         DBusConnection *bus;
1440         DEControllerListener    *listener;
1441 } RemoveListenerClosure;
1442
1443 static SpiReEntrantContinue
1444 remove_listener_cb (GList * const *list,
1445                     gpointer       user_data)
1446 {
1447   DEControllerListener  *listener = (*list)->data;
1448   RemoveListenerClosure *ctx = user_data;
1449
1450   if (!strcmp(ctx->listener->bus_name, listener->bus_name) &&
1451       !strcmp(ctx->listener->path, listener->path))
1452     {
1453       spi_re_entrant_list_delete_link (list);
1454       spi_dbus_remove_disconnect_match (ctx->bus, listener->bus_name);
1455       spi_dec_listener_free (listener);
1456     }
1457
1458   return SPI_RE_ENTRANT_CONTINUE;
1459 }
1460
1461 static SpiReEntrantContinue
1462 copy_key_listener_cb (GList * const *list,
1463                       gpointer       user_data)
1464 {
1465   DEControllerKeyListener  *key_listener = (*list)->data;
1466   RemoveListenerClosure    *ctx = user_data;
1467
1468   if (!strcmp(ctx->listener->bus_name, key_listener->listener.bus_name) &&
1469       !strcmp(ctx->listener->path, key_listener->listener.path))
1470     {
1471       /* TODO: FIXME aggregate keys in case the listener is registered twice */
1472       DEControllerKeyListener *ctx_key_listener =
1473         (DEControllerKeyListener *) ctx->listener;
1474       keylist_free (ctx_key_listener->keys);
1475       ctx_key_listener->keys = keylist_clone(key_listener->keys);
1476     }
1477
1478   return SPI_RE_ENTRANT_CONTINUE;
1479 }
1480
1481 static void
1482 spi_controller_deregister_device_listener (SpiDEController            *controller,
1483                                            DEControllerListener *listener)
1484 {
1485   RemoveListenerClosure  ctx;
1486
1487   ctx.bus = controller->bus;
1488   ctx.listener = listener;
1489
1490   notify_mouse_listener (controller, listener, FALSE);
1491
1492   spi_re_entrant_list_foreach (&controller->mouse_listeners,
1493                                remove_listener_cb, &ctx);
1494   if (!controller->mouse_listeners)
1495     have_mouse_listener = FALSE;
1496 }
1497
1498 static void
1499 spi_deregister_controller_key_listener (SpiDEController            *controller,
1500                                         DEControllerKeyListener    *key_listener)
1501 {
1502   RemoveListenerClosure  ctx;
1503
1504   ctx.bus = controller->bus;
1505   ctx.listener = (DEControllerListener *) spi_key_listener_clone (key_listener);
1506
1507   notify_keystroke_listener (controller, key_listener, FALSE);
1508
1509   /* special case, copy keyset from existing controller list entry */
1510   if (g_slist_length(key_listener->keys) == 0)
1511     {
1512       spi_re_entrant_list_foreach (&controller->key_listeners,
1513                                   copy_key_listener_cb, &ctx);
1514     }
1515
1516   spi_controller_deregister_global_keygrabs (controller, key_listener);
1517
1518   spi_re_entrant_list_foreach (&controller->key_listeners,
1519                                 remove_listener_cb, &ctx);
1520
1521   spi_key_listener_clone_free ((DEControllerKeyListener *) ctx.listener);
1522 }
1523
1524 void
1525 spi_remove_device_listeners (SpiDEController *controller, const char *bus_name)
1526 {
1527   GList *l, *tmp;
1528
1529   for (l = controller->mouse_listeners; l; l = tmp)
1530   {
1531     DEControllerListener *listener = l->data;
1532     tmp = l->next;
1533     if (!strcmp (listener->bus_name, bus_name))
1534     {
1535       spi_controller_deregister_device_listener (controller, listener);
1536       tmp = controller->mouse_listeners;
1537     }
1538   }
1539   for (l = controller->key_listeners; l; l = tmp)
1540   {
1541     DEControllerKeyListener *key_listener = l->data;
1542     tmp = l->next;
1543     if (!strcmp (key_listener->listener.bus_name, bus_name))
1544     {
1545       /* TODO: untangle the below line(s) */
1546       spi_deregister_controller_key_listener (controller, key_listener);
1547       tmp = controller->key_listeners;
1548     }
1549   }
1550 }
1551
1552 /*
1553  * DBus Accessibility::DEController::DeregisterKeystrokeListener
1554  *     method implementation
1555  */
1556 static DBusMessage *
1557 impl_deregister_keystroke_listener (DBusConnection *bus,
1558                                   DBusMessage *message,
1559                                   void *user_data)
1560 {
1561   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER(user_data);
1562   DEControllerKeyListener *key_listener;
1563   DBusMessageIter iter, iter_array;
1564   const char *path;
1565   GSList *keys = NULL;
1566   dbus_int32_t mask, type;
1567   DBusMessage *reply = NULL;
1568
1569   dbus_message_iter_init(message, &iter);
1570   if (strcmp (dbus_message_get_signature (message), "oa(iisi)uu") != 0)
1571   {
1572     g_warning ("Received DeregisterKeystrokeListener with strange signature '%s'", dbus_message_get_signature (message));
1573     return invalid_arguments_error (message);
1574   }
1575
1576   dbus_message_iter_get_basic(&iter, &path);
1577   dbus_message_iter_next(&iter);
1578   dbus_message_iter_recurse(&iter, &iter_array);
1579   while (dbus_message_iter_get_arg_type(&iter_array) != DBUS_TYPE_INVALID)
1580   {
1581     Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *)g_malloc(sizeof(Accessibility_KeyDefinition));
1582   char *keystring;
1583
1584     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))
1585     {
1586       g_free(kd);
1587       break;
1588     }
1589     kd->keystring = g_strdup (keystring);
1590     keys = g_slist_append(keys, kd);
1591   }
1592   dbus_message_iter_next(&iter);
1593   dbus_message_iter_get_basic(&iter, &mask);
1594   dbus_message_iter_next(&iter);
1595   dbus_message_iter_get_basic(&iter, &type);
1596   dbus_message_iter_next(&iter);
1597   key_listener = spi_dec_key_listener_new (dbus_message_get_sender(message), path, keys, mask, type, NULL);
1598 #ifdef SPI_DEREGISTER_DEBUG
1599   fprintf (stderr, "deregistering keystroke listener %p with maskVal %lu\n",
1600            (void *) l, (unsigned long) mask->value);
1601 #endif
1602
1603   spi_deregister_controller_key_listener (controller, key_listener);
1604
1605   spi_dec_listener_free ((DEControllerListener *) key_listener);
1606   reply = dbus_message_new_method_return (message);
1607   return reply;
1608 }
1609
1610 /*
1611  * DBus Accessibility::DEController::DeregisterDeviceEventListener
1612  *     method implementation
1613  */
1614 static DBusMessage *
1615 impl_deregister_device_event_listener (DBusConnection *bus,
1616                                   DBusMessage *message,
1617                                   void *user_data)
1618 {
1619   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER(user_data);
1620   DEControllerListener *listener;
1621   const char *path;
1622   dbus_int32_t event_types;
1623   DBusMessage *reply = NULL;
1624
1625   if (!dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_UINT32, &event_types, DBUS_TYPE_INVALID))
1626   {
1627     return invalid_arguments_error (message);
1628   }
1629   listener = spi_dec_listener_new (dbus_message_get_sender(message), path, event_types);
1630   spi_controller_deregister_device_listener (
1631           controller, listener);
1632   reply = dbus_message_new_method_return (message);
1633   return reply;
1634 }
1635
1636 static DBusMessage *
1637 impl_get_keystroke_listeners (DBusConnection *bus,
1638                                   DBusMessage *message,
1639                                   void *user_data)
1640 {
1641   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER(user_data);
1642   DBusMessageIter iter, iter_array;
1643   DBusMessage *reply = dbus_message_new_method_return (message);
1644   GList *l;
1645
1646   if (!reply)
1647     return NULL;
1648
1649   dbus_message_iter_init_append (reply, &iter);
1650   dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY,
1651                                     "(souua(iisi)u(bbb))", &iter_array);
1652   for (l = controller->key_listeners; l; l = l->next)
1653   {
1654     append_keystroke_listener (&iter_array, l->data);
1655   }
1656   dbus_message_iter_close_container (&iter, &iter_array);
1657   return reply;
1658 }
1659
1660 static DBusMessage *
1661 impl_get_device_event_listeners (DBusConnection *bus,
1662                                   DBusMessage *message,
1663                                   void *user_data)
1664 {
1665   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER(user_data);
1666   DBusMessageIter iter, iter_array;
1667   GList *l;
1668   DBusMessage *reply = dbus_message_new_method_return (message);
1669
1670   if (!reply)
1671     return NULL;
1672
1673   dbus_message_iter_init_append (reply, &iter);
1674   dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY,
1675                                     "(sou)", &iter_array);
1676   for (l = controller->key_listeners; l; l = l->next)
1677   {
1678     append_mouse_listener (&iter_array, l->data);
1679   }
1680   dbus_message_iter_close_container (&iter, &iter_array);
1681   return reply;
1682 }
1683
1684 static unsigned
1685 get_modifier_state (SpiDEController *controller)
1686 {
1687         return mouse_mask_state;
1688 }
1689
1690 gboolean
1691 spi_dec_synth_keysym (SpiDEController *controller, long keysym)
1692 {
1693         long key_synth_code;
1694         unsigned int modifiers, synth_mods, lock_mods;
1695
1696         key_synth_code = spi_dec_plat_get_keycode (controller, keysym, NULL, TRUE, &synth_mods);
1697
1698         if ((key_synth_code == 0) || (synth_mods == 0xFF)) return FALSE;
1699
1700         /* TODO: set the modifiers accordingly! */
1701         modifiers = get_modifier_state (controller);
1702         /* side-effect; we may unset mousebutton modifiers here! */
1703
1704         lock_mods = 0;
1705         if (synth_mods != modifiers) {
1706                 lock_mods = synth_mods & ~modifiers;
1707                 spi_dec_plat_lock_modifiers (controller, lock_mods);
1708         }
1709         spi_dec_plat_synth_keycode_press (controller, key_synth_code);
1710         spi_dec_plat_synth_keycode_release (controller, key_synth_code);
1711
1712         if (synth_mods != modifiers)
1713                 spi_dec_plat_unlock_modifiers (controller, lock_mods);
1714         return TRUE;
1715 }
1716
1717
1718
1719 /*
1720  * DBus Accessibility::DEController::RegisterKeystrokeListener
1721  *     method implementation
1722  */
1723 static DBusMessage *
1724 impl_generate_keyboard_event (DBusConnection *bus, DBusMessage *message, void *user_data)
1725 {
1726   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER(user_data);
1727   dbus_int32_t keycode;
1728   char *keystring;
1729   dbus_uint32_t synth_type;
1730   DBusMessage *reply = NULL;
1731
1732   if (!dbus_message_get_args(message, NULL, DBUS_TYPE_INT32, &keycode, DBUS_TYPE_STRING, &keystring, DBUS_TYPE_UINT32, &synth_type, DBUS_TYPE_INVALID))
1733   {
1734     return invalid_arguments_error (message);
1735   }
1736
1737 #ifdef SPI_DEBUG
1738         fprintf (stderr, "synthesizing keystroke %ld, type %d\n",
1739                  (long) keycode, (int) synth_type);
1740 #endif
1741   /* TODO: hide/wrap/remove X dependency */
1742
1743   /*
1744    * TODO: when initializing, query for XTest extension before using,
1745    * and fall back to XSendEvent() if XTest is not available.
1746    */
1747
1748   switch (synth_type)
1749     {
1750       case Accessibility_KEY_PRESS:
1751               spi_dec_plat_synth_keycode_press (controller, keycode);
1752               break;
1753       case Accessibility_KEY_PRESSRELEASE:
1754               spi_dec_plat_synth_keycode_press (controller, keycode);
1755       case Accessibility_KEY_RELEASE:
1756               spi_dec_plat_synth_keycode_release (controller, keycode);
1757               break;
1758       case Accessibility_KEY_SYM:
1759 #ifdef SPI_XKB_DEBUG
1760               fprintf (stderr, "KeySym synthesis\n");
1761 #endif
1762               /*
1763                * note: we are using long for 'keycode'
1764                * in our arg list; it can contain either
1765                * a keycode or a keysym.
1766                */
1767 #ifdef HAVE_X11
1768               spi_dec_synth_keysym (controller, (KeySym) keycode);
1769 #else
1770               spi_dec_synth_keysym (controller, (long) keycode);
1771 #endif
1772               break;
1773       case Accessibility_KEY_STRING:
1774               if (!spi_dec_plat_synth_keystring (controller, synth_type, keycode, keystring))
1775                       fprintf (stderr, "Keystring synthesis failure, string=%s\n",
1776                                keystring);
1777               break;
1778     }
1779   reply = dbus_message_new_method_return (message);
1780   return reply;
1781 }
1782
1783 /* Accessibility::DEController::GenerateMouseEvent */
1784 static DBusMessage *
1785 impl_generate_mouse_event (DBusConnection *bus, DBusMessage *message, void *user_data)
1786 {
1787   dbus_int32_t       x;
1788   dbus_int32_t       y;
1789   char *eventName;
1790   DBusMessage *reply = NULL;
1791
1792   if (!dbus_message_get_args(message, NULL, DBUS_TYPE_INT32, &x, DBUS_TYPE_INT32, &y, DBUS_TYPE_STRING, &eventName, DBUS_TYPE_INVALID))
1793   {
1794     return invalid_arguments_error (message);
1795   }
1796
1797 #ifdef SPI_DEBUG
1798   fprintf (stderr, "generating mouse %s event at %ld, %ld\n",
1799            eventName, (long int) x, (long int) y);
1800 #endif
1801   spi_dec_plat_generate_mouse_event (saved_controller, x, y, eventName);
1802   reply = dbus_message_new_method_return (message);
1803   return reply;
1804 }
1805
1806 /* Accessibility::DEController::NotifyListenersSync */
1807 static DBusMessage *
1808 impl_notify_listeners_sync (DBusConnection *bus, DBusMessage *message, void *user_data)
1809 {
1810   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER(user_data);
1811   Accessibility_DeviceEvent event;
1812   dbus_bool_t ret;
1813   DBusMessage *reply = NULL;
1814
1815   if (!spi_dbus_demarshal_deviceEvent(message, &event))
1816   {
1817     return invalid_arguments_error (message);
1818   }
1819 #ifdef SPI_DEBUG
1820   g_print ("notifylistening listeners synchronously: controller %p, event id %d\n",
1821            controller, (int) event.id);
1822 #endif
1823   ret = spi_controller_notify_keylisteners (controller,
1824                                              (Accessibility_DeviceEvent *)
1825                                              &event, FALSE) ?
1826           TRUE : FALSE;
1827   reply = dbus_message_new_method_return (message);
1828   if (reply)
1829   {
1830     dbus_message_append_args (reply, DBUS_TYPE_BOOLEAN, &ret, DBUS_TYPE_INVALID);
1831   }
1832   return reply;
1833 }
1834
1835 static DBusMessage *
1836 impl_notify_listeners_async (DBusConnection *bus, DBusMessage *message, void *user_data)
1837 {
1838   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER(user_data);
1839   Accessibility_DeviceEvent event;
1840   DBusMessage *reply = NULL;
1841
1842   if (!spi_dbus_demarshal_deviceEvent(message, &event))
1843   {
1844     return invalid_arguments_error (message);
1845   }
1846 #ifdef SPI_DEBUG
1847   g_print ("notifylistening listeners asynchronously: controller %p, event id %d\n",
1848            controller, (int) event.id);
1849 #endif
1850   spi_controller_notify_keylisteners (controller, (Accessibility_DeviceEvent *)
1851                                       &event, FALSE);
1852   reply = dbus_message_new_method_return (message);
1853   return reply;
1854 }
1855
1856 static void
1857 spi_device_event_controller_class_init (SpiDEControllerClass *klass)
1858 {
1859   GObjectClass * object_class = (GObjectClass *) klass;
1860
1861   spi_device_event_controller_parent_class = g_type_class_peek_parent (klass);
1862
1863   object_class->finalize = spi_device_event_controller_object_finalize;
1864
1865 #ifdef HAVE_X11
1866   if (g_getenv ("DISPLAY"))
1867     spi_dec_setup_x11 (klass);
1868   else
1869 #endif
1870   g_type_class_add_private (object_class, sizeof (long)); /* dummy */
1871 }
1872
1873 static void
1874 spi_device_event_controller_init (SpiDEController *device_event_controller)
1875 {
1876   SpiDEControllerClass *klass;
1877   klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (device_event_controller);
1878
1879   /* TODO: shouldn't be gpointer below */
1880   device_event_controller->priv = G_TYPE_INSTANCE_GET_PRIVATE (device_event_controller,
1881                                               SPI_DEVICE_EVENT_CONTROLLER_TYPE,
1882                                               gpointer);
1883   device_event_controller->message_queue = g_queue_new ();
1884   saved_controller = device_event_controller;
1885
1886   if (klass->plat.init)
1887     klass->plat.init (device_event_controller);
1888 }
1889
1890
1891 /*---------------------------------------------------------------------------*/
1892
1893 static const char *introspection_header =
1894 "<?xml version=\"1.0\"?>\n";
1895
1896 static const char *introspection_node_element =
1897 "<node name=\"%s\">\n";
1898
1899 static const char *introspection_footer =
1900 "</node>";
1901
1902 static DBusMessage *
1903 impl_Introspect (DBusConnection * bus,
1904                  DBusMessage * message, void *user_data)
1905 {
1906   GString *output;
1907   gchar *final;
1908
1909   const gchar *pathstr = SPI_DBUS_PATH_DEC;
1910
1911   DBusMessage *reply;
1912
1913   output = g_string_new(introspection_header);
1914
1915   g_string_append_printf(output, introspection_node_element, pathstr);
1916
1917   g_string_append (output, spi_org_a11y_atspi_DeviceEventController);
1918
1919   g_string_append(output, introspection_footer);
1920   final = g_string_free(output, FALSE);
1921
1922   reply = dbus_message_new_method_return (message);
1923   dbus_message_append_args(reply, DBUS_TYPE_STRING, &final, DBUS_TYPE_INVALID);
1924
1925   g_free(final);
1926   return reply;
1927 }
1928
1929 /*---------------------------------------------------------------------------*/
1930
1931 static void
1932 handle_dec_method_from_idle (DBusConnection *bus, DBusMessage *message, void *user_data)
1933 {
1934   const gchar *iface   = dbus_message_get_interface (message);
1935   const gchar *member  = dbus_message_get_member (message);
1936   DBusHandlerResult result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1937   DBusMessage *reply = NULL;
1938
1939   if (!strcmp (iface, SPI_DBUS_INTERFACE_DEC))
1940     {
1941       result = DBUS_HANDLER_RESULT_HANDLED;
1942       if      (!strcmp (member, "RegisterKeystrokeListener"))
1943           reply = impl_register_keystroke_listener (bus, message, user_data);
1944       else if (!strcmp (member, "RegisterDeviceEventListener"))
1945           reply = impl_register_device_event_listener (bus, message, user_data);
1946       else if (!strcmp (member, "DeregisterKeystrokeListener"))
1947           reply = impl_deregister_keystroke_listener (bus, message, user_data);
1948       else if (!strcmp (member, "DeregisterDeviceEventListener"))
1949           reply = impl_deregister_device_event_listener (bus, message, user_data);
1950       else if (!strcmp (member, "GetKeystrokeListeners"))
1951           reply = impl_get_keystroke_listeners (bus, message, user_data);
1952       else if (!strcmp (member, "GetDeviceEventListeners"))
1953           reply = impl_get_device_event_listeners (bus, message, user_data);
1954       else if (!strcmp (member, "GenerateKeyboardEvent"))
1955           reply = impl_generate_keyboard_event (bus, message, user_data);
1956       else if (!strcmp (member, "GenerateMouseEvent"))
1957           reply = impl_generate_mouse_event (bus, message, user_data);
1958       else if (!strcmp (member, "NotifyListenersSync"))
1959           reply = impl_notify_listeners_sync (bus, message, user_data);
1960       else if (!strcmp (member, "NotifyListenersAsync"))
1961           reply = impl_notify_listeners_async (bus, message, user_data);
1962       else
1963           result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1964     }
1965
1966   if (!strcmp (iface, "org.freedesktop.DBus.Introspectable"))
1967     {
1968       result = DBUS_HANDLER_RESULT_HANDLED;
1969       if      (!strcmp (member, "Introspect"))
1970           reply = impl_Introspect (bus, message, user_data);
1971       else
1972           result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1973     }
1974
1975   if (result == DBUS_HANDLER_RESULT_HANDLED)
1976     {
1977       if (!reply)
1978         {
1979           reply = dbus_message_new_method_return (message);
1980         }
1981
1982       dbus_connection_send (bus, reply, NULL);
1983       dbus_message_unref (reply);
1984     }
1985 }
1986
1987 static gboolean
1988 message_queue_dispatch (gpointer data)
1989 {
1990   saved_controller->message_queue_idle = 0;
1991   while (!g_queue_is_empty (saved_controller->message_queue))
1992     {
1993       DBusMessage *message = g_queue_pop_head (saved_controller->message_queue);
1994       data = g_queue_pop_head (saved_controller->message_queue);
1995       handle_dec_method_from_idle (saved_controller->bus, message, data);
1996       dbus_message_unref (message);
1997     }
1998   return FALSE;
1999 }
2000
2001 static DBusHandlerResult
2002 handle_dec_method (DBusConnection *bus, DBusMessage *message, void *user_data)
2003 {
2004   const gchar *iface   = dbus_message_get_interface (message);
2005   const gchar *member  = dbus_message_get_member (message);
2006   const gint   type    = dbus_message_get_type (message);
2007
2008   /* Check for basic reasons not to handle */
2009   if (type   != DBUS_MESSAGE_TYPE_METHOD_CALL ||
2010       member == NULL ||
2011       iface  == NULL)
2012       return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2013
2014   dbus_message_ref (message);
2015   g_queue_push_tail (saved_controller->message_queue, message);
2016   g_queue_push_tail (saved_controller->message_queue, user_data);
2017   if (!saved_controller->message_queue_idle) {
2018     saved_controller->message_queue_idle = g_idle_add (message_queue_dispatch, NULL);
2019     g_source_set_name_by_id (saved_controller->message_queue_idle, "[at-spi2-core] message_queue_dispatch");
2020   }
2021   return DBUS_HANDLER_RESULT_HANDLED;
2022 }
2023
2024 static DBusObjectPathVTable dec_vtable =
2025 {
2026   NULL,
2027   &handle_dec_method,
2028   NULL, NULL, NULL, NULL
2029 };
2030
2031 SpiDEController *
2032 spi_registry_dec_new (SpiRegistry *reg, DBusConnection *bus)
2033 {
2034   SpiDEController *dec = g_object_new (SPI_DEVICE_EVENT_CONTROLLER_TYPE, NULL);
2035
2036   dec->registry = g_object_ref (reg);
2037   reg->dec = g_object_ref (dec);
2038   dec->bus = bus;
2039
2040   dbus_connection_register_object_path (bus, SPI_DBUS_PATH_DEC, &dec_vtable, dec);
2041
2042   return dec;
2043 }
2044
2045 void
2046 spi_device_event_controller_start_poll_mouse (SpiRegistry *registry)
2047 {
2048   if (!have_mouse_event_listener)
2049     {
2050       have_mouse_event_listener = TRUE;
2051       if (!have_mouse_listener) {
2052         guint id;
2053         id = g_timeout_add (100, spi_dec_poll_mouse_idle, registry->dec);
2054         g_source_set_name_by_id (id, "[at-spi2-core] spi_dec_poll_mouse_idle");
2055       }
2056     }
2057 }
2058
2059 void
2060 spi_device_event_controller_stop_poll_mouse (void)
2061 {
2062   have_mouse_event_listener = FALSE;
2063 }