registryd/deviceeventcontroller.c

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