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