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