registryd/deviceeventcontroller.c

   1 /*
   2  * AT-SPI - Assistive Technology Service Provider Interface
   3  * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
   4  *
   5  * Copyright 2001, 2002 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 #define  SPI_DEBUG
  30 #undef  SPI_KEYEVENT_DEBUG
  31
  32 #include <string.h>
  33 #include <ctype.h>
  34 #include <stdio.h>
  35 #include <bonobo/bonobo-exception.h>
  36
  37 #include <X11/Xlib.h>
  38 #include <X11/extensions/XTest.h>
  39 #include <X11/XKBlib.h>
  40 #define XK_MISCELLANY
  41 #include <X11/keysymdef.h>
  42 #include <gdk/gdk.h>
  43 #include <gdk/gdkx.h> /* TODO: hide dependency (wrap in single porting file) */
  44 #include <gdk/gdkkeysyms.h>
  45 #include <gdk/gdkwindow.h>
  46
  47 #include "../libspi/spi-private.h"
  48 #include "deviceeventcontroller.h"
  49
  50 /* Our parent Gtk object type */
  51 #define PARENT_TYPE BONOBO_TYPE_OBJECT
  52
  53 /* A pointer to our parent object class */
  54 static GObjectClass *spi_device_event_controller_parent_class;
  55 static int spi_error_code = 0;
  56 static GdkPoint last_mouse_pos_static = {0, 0};
  57 static GdkPoint *last_mouse_pos = &last_mouse_pos_static;
  58 static unsigned int mouse_mask_state = 0;
  59 static unsigned int mouse_button_mask =
  60   Button1Mask | Button2Mask | Button3Mask | Button4Mask | Button5Mask;
  61 static unsigned int key_modifier_mask =
  62   Mod1Mask | Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask | ShiftMask | LockMask | ControlMask;
  63
  64 static GQuark spi_dec_private_quark = 0;
  65
  66 int (*x_default_error_handler) (Display *display, XErrorEvent *error_event);
  67
  68 typedef enum {
  69   SPI_DEVICE_TYPE_KBD,
  70   SPI_DEVICE_TYPE_MOUSE,
  71   SPI_DEVICE_TYPE_LAST_DEFINED
  72 } SpiDeviceTypeCategory;
  73
  74 typedef struct {
  75   guint                             ref_count : 30;
  76   guint                             pending_add : 1;
  77   guint                             pending_remove : 1;
  78
  79   Accessibility_ControllerEventMask mod_mask;
  80   CORBA_unsigned_long               key_val;  /* KeyCode */
  81 } DEControllerGrabMask;
  82
  83 typedef struct {
  84   CORBA_Object          object;
  85   SpiDeviceTypeCategory type;
  86   Accessibility_EventTypeSeq    *typeseq;
  87 } DEControllerListener;
  88
  89 typedef struct {
  90   DEControllerListener listener;
  91
  92   Accessibility_KeySet             *keys;
  93   Accessibility_ControllerEventMask mask;
  94   Accessibility_EventListenerMode  *mode;
  95 } DEControllerKeyListener;
  96
  97 typedef struct {
  98         unsigned int last_press_keycode;
  99         unsigned int last_release_keycode;
 100         struct timeval last_press_time;
 101         struct timeval last_release_time;
 102         int have_xkb;
 103         int xkb_major_extension_opcode;
 104         int xkb_base_event_code;
 105         int xkb_base_error_code;
 106         unsigned int xkb_latch_mask;
 107         unsigned int pending_xkb_mod_relatch_mask;
 108         XkbDescPtr xkb_desc;
 109 } DEControllerPrivateData;
 110
 111 static void     spi_controller_register_with_devices          (SpiDEController           *controller);
 112 static gboolean spi_controller_update_key_grabs               (SpiDEController           *controller,
 113                                                                Accessibility_DeviceEvent *recv);
 114 static gboolean spi_controller_register_device_listener       (SpiDEController           *controller,
 115                                                                DEControllerListener      *l,
 116                                                                CORBA_Environment         *ev);
 117 static void     spi_device_event_controller_forward_key_event (SpiDEController           *controller,
 118                                                                const XEvent              *event);
 119 static void     spi_deregister_controller_device_listener (SpiDEController            *controller,
 120                                                            DEControllerListener *listener,
 121                                                            CORBA_Environment          *ev);
 122 static void     spi_deregister_controller_key_listener (SpiDEController         *controller,
 123                                                         DEControllerKeyListener *key_listener,
 124                                                         CORBA_Environment       *ev);
 125 static gboolean spi_controller_notify_mouselisteners (SpiDEController                 *controller,
 126                                                       const Accessibility_DeviceEvent *event,
 127                                                       CORBA_Environment               *ev);
 128
 129 static gboolean spi_eventtype_seq_contains_event (Accessibility_EventTypeSeq      *type_seq,
 130                                                   const Accessibility_DeviceEvent *event);
 131 static gboolean spi_clear_error_state (void);
 132 static gboolean spi_dec_poll_mouse_moved (gpointer data);
 133 static gboolean spi_dec_poll_mouse_moving (gpointer data);
 134 static gboolean spi_dec_poll_mouse_idle (gpointer data);
 135
 136 #define spi_get_display() GDK_DISPLAY()
 137
 138 /* Private methods */
 139
 140 static KeyCode
 141 keycode_for_keysym (long keysym)
 142 {
 143   return XKeysymToKeycode (spi_get_display (), (KeySym) keysym);
 144 }
 145
 146 static DEControllerGrabMask *
 147 spi_grab_mask_clone (DEControllerGrabMask *grab_mask)
 148 {
 149   DEControllerGrabMask *clone = g_new (DEControllerGrabMask, 1);
 150
 151   memcpy (clone, grab_mask, sizeof (DEControllerGrabMask));
 152
 153   clone->ref_count = 1;
 154   clone->pending_add = TRUE;
 155   clone->pending_remove = FALSE;
 156
 157   return clone;
 158 }
 159
 160 static void
 161 spi_grab_mask_free (DEControllerGrabMask *grab_mask)
 162 {
 163   g_free (grab_mask);
 164 }
 165
 166 static gint
 167 spi_grab_mask_compare_values (gconstpointer p1, gconstpointer p2)
 168 {
 169   DEControllerGrabMask *l1 = (DEControllerGrabMask *) p1;
 170   DEControllerGrabMask *l2 = (DEControllerGrabMask *) p2;
 171
 172   if (p1 == p2)
 173     {
 174       return 0;
 175     }
 176   else
 177     {
 178       return ((l1->mod_mask != l2->mod_mask) || (l1->key_val != l2->key_val));
 179     }
 180 }
 181
 182 static gint poll_count = 0;
 183
 184 static gboolean
 185 spi_dec_poll_mouse_moved (gpointer data)
 186 {
 187   SpiRegistry *registry = SPI_REGISTRY (data);
 188   SpiDEController *controller = registry->de_controller;
 189   CORBA_Environment ev;
 190   Accessibility_Event e;
 191   Accessibility_DeviceEvent mouse_e;
 192   Window root_return, child_return;
 193   int win_x_return,win_y_return;
 194   int x, y;
 195   int poll_count_modulus = 10;
 196   unsigned int mask_return;
 197   gchar event_name[24];
 198   gboolean is_consumed;
 199   Display *display = spi_get_display ();
 200
 201   if (display != NULL)
 202           XQueryPointer(display, DefaultRootWindow (display),
 203                 &root_return, &child_return,
 204                 &x, &y,
 205                 &win_x_return, &win_y_return, &mask_return);
 206
 207   if (mask_return != mouse_mask_state) {
 208           if ((mask_return & mouse_button_mask) !=
 209               (mouse_mask_state & mouse_button_mask)) {
 210                   int button_number = 0;
 211                   if (!(mask_return & Button1Mask) &&
 212                       (mouse_mask_state & Button1Mask)) {
 213                           button_number = 1;
 214                   } else if (!(mask_return & Button2Mask) &&
 215                              (mouse_mask_state & Button2Mask)) {
 216                           button_number = 2;
 217                   } else if (!(mask_return & Button3Mask) &&
 218                              (mouse_mask_state & Button3Mask)) {
 219                           button_number = 3;
 220                   } else if (!(mask_return & Button4Mask) &&
 221                              (mouse_mask_state & Button1Mask)) {
 222                           button_number = 4;
 223                   } else if (!(mask_return & Button5Mask) &&
 224                              (mouse_mask_state & Button5Mask)) {
 225                           button_number = 5;
 226                   }
 227                   if (button_number) {
 228 #ifdef SPI_DEBUG
 229                           fprintf (stderr, "Button %d Released\n",
 230                                    button_number);
 231 #endif
 232                           snprintf (event_name, 22, "mouse:button:%dr", button_number);
 233                           /* TODO: distinguish between physical and
 234                            * logical buttons
 235                            */
 236                           mouse_e.type      = Accessibility_BUTTON_RELEASED_EVENT;
 237                           mouse_e.id        = button_number;
 238                           mouse_e.hw_code   = button_number;
 239                           mouse_e.modifiers = (CORBA_unsigned_short)
 240                                                mouse_mask_state;
 241                           mouse_e.timestamp = 0;
 242                           mouse_e.event_string = "";
 243                           mouse_e.is_text   = CORBA_FALSE;
 244                           is_consumed =
 245                             spi_controller_notify_mouselisteners (controller,
 246                                                                   &mouse_e,
 247                                                                   &ev);
 248                           e.type = event_name;
 249                           e.source = BONOBO_OBJREF (registry->desktop);
 250                           e.detail1 = last_mouse_pos->x;
 251                           e.detail2 = last_mouse_pos->y;
 252                           spi_init_any_nil (&e.any_data);
 253                           CORBA_exception_init (&ev);
 254                           if (!is_consumed)
 255                             Accessibility_Registry_notifyEvent (BONOBO_OBJREF (registry),
 256                                                                 &e,
 257                                                                 &ev);
 258                   }
 259           }
 260           if ((mask_return & key_modifier_mask) !=
 261               (mouse_mask_state & key_modifier_mask)) {
 262 #ifdef SPI_DEBUG
 263                   fprintf (stderr, "MODIFIER CHANGE EVENT!\n");
 264 #endif
 265                   e.type = "keyboard:modifiers";
 266                   e.source = BONOBO_OBJREF (registry->desktop);
 267                   e.detail1 = mouse_mask_state;
 268                   e.detail2 = mask_return;
 269                   spi_init_any_nil (&e.any_data);
 270                   CORBA_exception_init (&ev);
 271                   Accessibility_Registry_notifyEvent (BONOBO_OBJREF (registry),
 272                                                       &e,
 273                                                       &ev);
 274           }
 275           mouse_mask_state = mask_return;
 276   }
 277   if (poll_count++ == poll_count_modulus) {
 278           poll_count = 0;
 279           e.type = "mouse:abs";
 280           e.source = BONOBO_OBJREF (registry->desktop);
 281           e.detail1 = x;
 282           e.detail2 = y;
 283           spi_init_any_nil (&e.any_data);
 284           CORBA_exception_init (&ev);
 285           Accessibility_Registry_notifyEvent (BONOBO_OBJREF (registry),
 286                                               &e,
 287                                               &ev);
 288   }
 289   if (x != last_mouse_pos->x || y != last_mouse_pos->y) {
 290           e.type = "mouse:rel";
 291           e.source = BONOBO_OBJREF (registry->desktop);
 292           e.detail1 = x - last_mouse_pos->x;
 293           e.detail2 = y - last_mouse_pos->y;
 294           spi_init_any_nil (&e.any_data);
 295           CORBA_exception_init (&ev);
 296           last_mouse_pos->x = x;
 297           last_mouse_pos->y = y;
 298           Accessibility_Registry_notifyEvent (BONOBO_OBJREF (registry),
 299                                               &e,
 300                                               &ev);
 301           return TRUE;
 302   }
 303   return FALSE;
 304 }
 305
 306 static gboolean
 307 spi_dec_poll_mouse_idle (gpointer data)
 308 {
 309   if (! spi_dec_poll_mouse_moved (data))
 310     return TRUE;
 311   else
 312     {
 313       g_timeout_add (20, spi_dec_poll_mouse_moving, data);
 314       return FALSE;
 315     }
 316 }
 317
 318 static gboolean
 319 spi_dec_poll_mouse_moving (gpointer data)
 320 {
 321   if (spi_dec_poll_mouse_moved (data))
 322     return TRUE;
 323   else
 324     {
 325       g_timeout_add (100, spi_dec_poll_mouse_idle, data);
 326       return FALSE;
 327     }
 328 }
 329
 330 static int
 331 spi_dec_ungrab_mouse (gpointer data)
 332 {
 333         Display *display = spi_get_display ();
 334         if (display)
 335           {
 336             XUngrabButton (spi_get_display (), AnyButton, AnyModifier,
 337                            XDefaultRootWindow (spi_get_display ()));
 338           }
 339         return FALSE;
 340 }
 341
 342 static void
 343 spi_dec_init_mouse_listener (SpiRegistry *registry)
 344 {
 345   Display *display = spi_get_display ();
 346   g_timeout_add (100, spi_dec_poll_mouse_idle, registry);
 347
 348   if (display)
 349     {
 350       XGrabButton (display, AnyButton, AnyModifier,
 351                    gdk_x11_get_default_root_xwindow (),
 352                    True, ButtonPressMask | ButtonReleaseMask,
 353                    GrabModeSync, GrabModeAsync, None, None);
 354       XSync (display, False);
 355 #ifdef SPI_DEBUG
 356       fprintf (stderr, "mouse buttons grabbed\n");
 357 #endif
 358     }
 359 }
 360
 361 static DEControllerKeyListener *
 362 spi_dec_key_listener_new (CORBA_Object                            l,
 363                           const Accessibility_KeySet             *keys,
 364                           const Accessibility_ControllerEventMask mask,
 365                           const Accessibility_EventTypeSeq    *typeseq,
 366                           const Accessibility_EventListenerMode  *mode,
 367                           CORBA_Environment                      *ev)
 368 {
 369   DEControllerKeyListener *key_listener = g_new0 (DEControllerKeyListener, 1);
 370   key_listener->listener.object = bonobo_object_dup_ref (l, ev);
 371   key_listener->listener.type = SPI_DEVICE_TYPE_KBD;
 372   key_listener->keys = ORBit_copy_value (keys, TC_Accessibility_KeySet);
 373   key_listener->mask = mask;
 374   key_listener->listener.typeseq = ORBit_copy_value (typeseq, TC_Accessibility_EventTypeSeq);
 375   if (mode)
 376     key_listener->mode = ORBit_copy_value (mode, TC_Accessibility_EventListenerMode);
 377   else
 378     key_listener->mode = NULL;
 379
 380 #ifdef SPI_DEBUG
 381   g_print ("new listener, with mask %x, is_global %d, keys %p (%d)\n",
 382            (unsigned int) key_listener->mask,
 383            (int) (mode ? mode->global : 0),
 384            (void *) key_listener->keys,
 385            (int) (key_listener->keys ? key_listener->keys->_length : 0));
 386 #endif
 387
 388   return key_listener;
 389 }
 390
 391 static DEControllerListener *
 392 spi_dec_listener_new (CORBA_Object                            l,
 393                       const Accessibility_EventTypeSeq    *typeseq,
 394                       CORBA_Environment                      *ev)
 395 {
 396   DEControllerListener *listener = g_new0 (DEControllerListener, 1);
 397   listener->object = bonobo_object_dup_ref (l, ev);
 398   listener->type = SPI_DEVICE_TYPE_MOUSE;
 399   listener->typeseq = ORBit_copy_value (typeseq, TC_Accessibility_EventTypeSeq);
 400   return listener;
 401 }
 402
 403 static DEControllerListener *
 404 spi_listener_clone (DEControllerListener *listener, CORBA_Environment *ev)
 405 {
 406   DEControllerListener *clone = g_new0 (DEControllerListener, 1);
 407   clone->object =
 408           CORBA_Object_duplicate (listener->object, ev);
 409   clone->type = listener->type;
 410   clone->typeseq = ORBit_copy_value (listener->typeseq, TC_Accessibility_EventTypeSeq);
 411   return clone;
 412 }
 413
 414 static DEControllerKeyListener *
 415 spi_key_listener_clone (DEControllerKeyListener *key_listener, CORBA_Environment *ev)
 416 {
 417   DEControllerKeyListener *clone = g_new0 (DEControllerKeyListener, 1);
 418   clone->listener.object =
 419           CORBA_Object_duplicate (key_listener->listener.object, ev);
 420   clone->listener.type = SPI_DEVICE_TYPE_KBD;
 421   clone->keys = ORBit_copy_value (key_listener->keys, TC_Accessibility_KeySet);
 422   clone->mask = key_listener->mask;
 423   clone->listener.typeseq = ORBit_copy_value (key_listener->listener.typeseq, TC_Accessibility_EventTypeSeq);
 424   if (key_listener->mode)
 425     clone->mode = ORBit_copy_value (key_listener->mode, TC_Accessibility_EventListenerMode);
 426   else
 427     clone->mode = NULL;
 428   return clone;
 429 }
 430
 431 static void
 432 spi_key_listener_data_free (DEControllerKeyListener *key_listener, CORBA_Environment *ev)
 433 {
 434   CORBA_free (key_listener->listener.typeseq);
 435   CORBA_free (key_listener->keys);
 436   g_free (key_listener);
 437 }
 438
 439 static void
 440 spi_key_listener_clone_free (DEControllerKeyListener *clone, CORBA_Environment *ev)
 441 {
 442   CORBA_Object_release (clone->listener.object, ev);
 443   spi_key_listener_data_free (clone, ev);
 444 }
 445
 446 static void
 447 spi_listener_clone_free (DEControllerListener *clone, CORBA_Environment *ev)
 448 {
 449   CORBA_Object_release (clone->object, ev);
 450   CORBA_free (clone->typeseq);
 451   g_free (clone);
 452 }
 453
 454 static void
 455 spi_dec_listener_free (DEControllerListener    *listener,
 456                        CORBA_Environment       *ev)
 457 {
 458   bonobo_object_release_unref (listener->object, ev);
 459   if (listener->type == SPI_DEVICE_TYPE_KBD)
 460     spi_key_listener_data_free ((DEControllerKeyListener *) listener, ev);
 461 }
 462
 463 static void
 464 _register_keygrab (SpiDEController      *controller,
 465                    DEControllerGrabMask *grab_mask)
 466 {
 467   GList *l;
 468
 469   l = g_list_find_custom (controller->keygrabs_list, grab_mask,
 470                           spi_grab_mask_compare_values);
 471   if (l)
 472     {
 473       DEControllerGrabMask *cur_mask = l->data;
 474
 475       cur_mask->ref_count++;
 476       if (cur_mask->pending_remove)
 477         {
 478           cur_mask->pending_remove = FALSE;
 479         }
 480     }
 481   else
 482     {
 483       controller->keygrabs_list =
 484         g_list_prepend (controller->keygrabs_list,
 485                         spi_grab_mask_clone (grab_mask));
 486     }
 487 }
 488
 489 static void
 490 _deregister_keygrab (SpiDEController      *controller,
 491                      DEControllerGrabMask *grab_mask)
 492 {
 493   GList *l;
 494
 495   l = g_list_find_custom (controller->keygrabs_list, grab_mask,
 496                           spi_grab_mask_compare_values);
 497
 498   if (l)
 499     {
 500       DEControllerGrabMask *cur_mask = l->data;
 501
 502       cur_mask->ref_count--;
 503       if (cur_mask->ref_count <= 0)
 504         {
 505           cur_mask->pending_remove = TRUE;
 506         }
 507     }
 508   else
 509     {
 510       DBG (1, g_warning ("De-registering non-existant grab"));
 511     }
 512 }
 513
 514 static void
 515 handle_keygrab (SpiDEController         *controller,
 516                 DEControllerKeyListener *key_listener,
 517                 void                   (*process_cb) (SpiDEController *controller,
 518                                                       DEControllerGrabMask *grab_mask))
 519 {
 520   DEControllerGrabMask grab_mask = { 0 };
 521
 522   grab_mask.mod_mask = key_listener->mask;
 523   if (key_listener->keys->_length == 0) /* special case means AnyKey/AllKeys */
 524     {
 525       grab_mask.key_val = AnyKey;
 526 #ifdef SPI_DEBUG
 527       fprintf (stderr, "AnyKey grab!");
 528 #endif
 529       process_cb (controller, &grab_mask);
 530     }
 531   else
 532     {
 533       int i;
 534
 535       for (i = 0; i < key_listener->keys->_length; ++i)
 536         {
 537           Accessibility_KeyDefinition keydef = key_listener->keys->_buffer[i];
 538           long int key_val = keydef.keysym;
 539           /* X Grabs require keycodes, not keysyms */
 540           if (keydef.keystring && keydef.keystring[0])
 541             {
 542               key_val = XStringToKeysym(keydef.keystring);
 543             }
 544           if (key_val > 0)
 545             {
 546               key_val = XKeysymToKeycode (spi_get_display (), (KeySym) key_val);
 547             }
 548           else
 549             {
 550               key_val = keydef.keycode;
 551             }
 552           grab_mask.key_val = key_val;
 553           process_cb (controller, &grab_mask);
 554         }
 555     }
 556 }
 557
 558 static gboolean
 559 spi_controller_register_global_keygrabs (SpiDEController         *controller,
 560                                          DEControllerKeyListener *key_listener)
 561 {
 562   handle_keygrab (controller, key_listener, _register_keygrab);
 563   return spi_controller_update_key_grabs (controller, NULL);
 564 }
 565
 566 static void
 567 spi_controller_deregister_global_keygrabs (SpiDEController         *controller,
 568                                            DEControllerKeyListener *key_listener)
 569 {
 570   handle_keygrab (controller, key_listener, _deregister_keygrab);
 571   spi_controller_update_key_grabs (controller, NULL);
 572 }
 573
 574 static gboolean
 575 spi_controller_register_device_listener (SpiDEController      *controller,
 576                                          DEControllerListener *listener,
 577                                          CORBA_Environment    *ev)
 578 {
 579   DEControllerKeyListener *key_listener;
 580
 581   switch (listener->type) {
 582   case SPI_DEVICE_TYPE_KBD:
 583       key_listener = (DEControllerKeyListener *) listener;
 584
 585       controller->key_listeners = g_list_prepend (controller->key_listeners,
 586                                                   key_listener);
 587       if (key_listener->mode->global)
 588         {
 589           return spi_controller_register_global_keygrabs (controller, key_listener);
 590         }
 591       else
 592               return TRUE;
 593       break;
 594   case SPI_DEVICE_TYPE_MOUSE:
 595       controller->mouse_listeners = g_list_prepend (controller->mouse_listeners, listener);
 596       break;
 597   default:
 598       DBG (1, g_warning ("listener registration for unknown device type.\n"));
 599       break;
 600   }
 601   return FALSE;
 602 }
 603
 604 static gboolean
 605 spi_controller_notify_mouselisteners (SpiDEController                 *controller,
 606                                       const Accessibility_DeviceEvent *event,
 607                                       CORBA_Environment               *ev)
 608 {
 609   GList   *l;
 610   GSList  *notify = NULL, *l2;
 611   GList  **listeners = &controller->mouse_listeners;
 612   gboolean is_consumed;
 613
 614   if (!listeners)
 615     {
 616       return FALSE;
 617     }
 618
 619   for (l = *listeners; l; l = l->next)
 620     {
 621        DEControllerListener *listener = l->data;
 622
 623        if (spi_eventtype_seq_contains_event (listener->typeseq, event))
 624          {
 625            Accessibility_DeviceEventListener ls = listener->object;
 626
 627            if (ls != CORBA_OBJECT_NIL)
 628              {
 629                /* we clone (don't dup) the listener, to avoid refcount inc. */
 630                notify = g_slist_prepend (notify,
 631                                          spi_listener_clone (listener, ev));
 632              }
 633          }
 634     }
 635
 636 #ifdef SPI_KEYEVENT_DEBUG
 637   if (!notify)
 638     {
 639       g_print ("no match for event\n");
 640     }
 641 #endif
 642
 643   is_consumed = FALSE;
 644   for (l2 = notify; l2 && !is_consumed; l2 = l2->next)
 645     {
 646       DEControllerListener *listener = l2->data;
 647       Accessibility_DeviceEventListener ls = listener->object;
 648
 649       CORBA_exception_init (ev);
 650       is_consumed = Accessibility_DeviceEventListener_notifyEvent (ls, event, ev);
 651       if (BONOBO_EX (ev))
 652         {
 653           is_consumed = FALSE;
 654           DBG (2, g_warning ("error notifying listener, removing it\n"));
 655           spi_deregister_controller_device_listener (controller, listener,
 656                                                      ev);
 657           CORBA_exception_free (ev);
 658         }
 659
 660       spi_listener_clone_free ((DEControllerListener *) l2->data, ev);
 661     }
 662
 663   for (; l2; l2 = l2->next)
 664     {
 665       DEControllerListener *listener = l2->data;
 666       spi_listener_clone_free (listener, ev);
 667       /* clone doesn't have its own ref, so don't use spi_device_listener_free */
 668     }
 669
 670   g_slist_free (notify);
 671
 672 #ifdef SPI_DEBUG
 673   if (is_consumed) g_message ("consumed\n");
 674 #endif
 675   return is_consumed;
 676 }
 677
 678 static void
 679 spi_device_event_controller_forward_mouse_event (SpiDEController *controller,
 680                                                  XEvent *xevent)
 681 {
 682   Accessibility_Event e;
 683   Accessibility_DeviceEvent mouse_e;
 684   CORBA_Environment ev;
 685   gchar event_name[24];
 686   gboolean is_consumed = FALSE;
 687   gboolean xkb_mod_unlatch_occurred;
 688   DEControllerPrivateData *priv;
 689   XButtonEvent *xbutton_event = (XButtonEvent *) xevent;
 690
 691   int button = xbutton_event->button;
 692
 693   unsigned int mouse_button_state = xbutton_event->state;
 694
 695   switch (button)
 696     {
 697     case 1:
 698             mouse_button_state |= Button1Mask;
 699             break;
 700     case 2:
 701             mouse_button_state |= Button2Mask;
 702             break;
 703     case 3:
 704             mouse_button_state |= Button3Mask;
 705             break;
 706     case 4:
 707             mouse_button_state |= Button4Mask;
 708             break;
 709     case 5:
 710             mouse_button_state |= Button5Mask;
 711             break;
 712     }
 713   last_mouse_pos->x = ((XButtonEvent *) xevent)->x_root;
 714   last_mouse_pos->y = ((XButtonEvent *) xevent)->y_root;
 715
 716 #ifdef SPI_DEBUG
 717   fprintf (stderr, "mouse button %d %s (%x)\n",
 718            xbutton_event->button,
 719            (xevent->type == ButtonPress) ? "Press" : "Release",
 720            mouse_button_state);
 721 #endif
 722   snprintf (event_name, 22, "mouse:button:%d%c", button,
 723             (xevent->type == ButtonPress) ? 'p' : 'r');
 724
 725   /* TODO: distinguish between physical and logical buttons */
 726   mouse_e.type      = (xevent->type == ButtonPress) ?
 727                       Accessibility_BUTTON_PRESSED_EVENT :
 728                       Accessibility_BUTTON_RELEASED_EVENT;
 729   mouse_e.id        = button;
 730   mouse_e.hw_code   = button;
 731   mouse_e.modifiers = (CORBA_unsigned_short) xbutton_event->state;
 732   mouse_e.timestamp = (CORBA_unsigned_long) xbutton_event->time;
 733   mouse_e.event_string = "";
 734   mouse_e.is_text   = CORBA_FALSE;
 735   is_consumed = spi_controller_notify_mouselisteners (controller, &mouse_e, &ev);
 736
 737   e.type = CORBA_string_dup (event_name);
 738   e.source = BONOBO_OBJREF (controller->registry->desktop);
 739   e.detail1 = last_mouse_pos->x;
 740   e.detail2 = last_mouse_pos->y;
 741   spi_init_any_nil (&e.any_data);
 742   CORBA_exception_init (&ev);
 743
 744   Accessibility_Registry_notifyEvent (BONOBO_OBJREF (controller->registry),
 745                                       &e,
 746                                       &ev);
 747
 748   xkb_mod_unlatch_occurred = (xevent->type == ButtonPress ||
 749                               xevent->type == ButtonRelease);
 750
 751   /* if client wants to consume this event, and XKB latch state was
 752    *   unset by this button event, we reset it
 753    */
 754   if (is_consumed && xkb_mod_unlatch_occurred)
 755     {
 756       priv = g_object_get_qdata (G_OBJECT (controller), spi_dec_private_quark);
 757       priv->pending_xkb_mod_relatch_mask |= priv->xkb_latch_mask;
 758     }
 759
 760   XAllowEvents (spi_get_display (),
 761                 (is_consumed) ? SyncPointer : ReplayPointer,
 762                 CurrentTime);
 763 }
 764
 765 static GdkFilterReturn
 766 global_filter_fn (GdkXEvent *gdk_xevent, GdkEvent *event, gpointer data)
 767 {
 768   XEvent *xevent = gdk_xevent;
 769   SpiDEController *controller;
 770   DEControllerPrivateData *priv;
 771   Display *display = spi_get_display ();
 772   controller = SPI_DEVICE_EVENT_CONTROLLER (data);
 773   priv = (DEControllerPrivateData *)
 774           g_object_get_qdata (G_OBJECT (controller), spi_dec_private_quark);
 775
 776   if (xevent->type == KeyPress || xevent->type == KeyRelease)
 777     {
 778       spi_device_event_controller_forward_key_event (controller, xevent);
 779       return GDK_FILTER_CONTINUE;
 780     }
 781   if (xevent->type == ButtonPress || xevent->type == ButtonRelease)
 782     {
 783       spi_device_event_controller_forward_mouse_event (controller, xevent);
 784     }
 785   if (xevent->type == priv->xkb_base_event_code)
 786     {
 787       XkbAnyEvent * xkb_ev = (XkbAnyEvent *) xevent;
 788
 789       if (xkb_ev->xkb_type == XkbStateNotify)
 790         {
 791           XkbStateNotifyEvent *xkb_snev =
 792                   (XkbStateNotifyEvent *) xkb_ev;
 793           priv->xkb_latch_mask = xkb_snev->latched_mods;
 794           if (priv->pending_xkb_mod_relatch_mask)
 795             {
 796               unsigned int feedback_mask;
 797 #ifdef SPI_XKB_DEBUG
 798               fprintf (stderr, "relatching %x\n",
 799                        priv->pending_xkb_mod_relatch_mask);
 800 #endif
 801               /* temporarily turn off the latch bell, if it's on */
 802               XkbGetControls (display,
 803                               XkbAccessXFeedbackMask,
 804                               priv->xkb_desc);
 805               feedback_mask = priv->xkb_desc->ctrls->ax_options;
 806               if (feedback_mask & XkbAX_StickyKeysFBMask)
 807               {
 808                 XkbControlsChangesRec changes = {XkbAccessXFeedbackMask,
 809                                                  0, False};
 810                 priv->xkb_desc->ctrls->ax_options
 811                               &= ~(XkbAX_StickyKeysFBMask);
 812                 XkbChangeControls (display, priv->xkb_desc, &changes);
 813               }
 814               XkbLatchModifiers (display,
 815                                  XkbUseCoreKbd,
 816                                  priv->pending_xkb_mod_relatch_mask,
 817                                  priv->pending_xkb_mod_relatch_mask);
 818               if (feedback_mask & XkbAX_StickyKeysFBMask)
 819               {
 820                 XkbControlsChangesRec changes = {XkbAccessXFeedbackMask,
 821                                                  0, False};
 822                 priv->xkb_desc->ctrls->ax_options = feedback_mask;
 823                 XkbChangeControls (display, priv->xkb_desc, &changes);
 824               }
 825 #ifdef SPI_XKB_DEBUG
 826               fprintf (stderr, "relatched %x\n",
 827                        priv->pending_xkb_mod_relatch_mask);
 828 #endif
 829               priv->pending_xkb_mod_relatch_mask = 0;
 830             }
 831         }
 832         else
 833                DBG (2, g_warning ("XKB event %d\n", xkb_ev->xkb_type));
 834     }
 835
 836   return GDK_FILTER_CONTINUE;
 837 }
 838
 839 int
 840 _spi_controller_device_error_handler (Display *display, XErrorEvent *error)
 841 {
 842   if (error->error_code == BadAccess)
 843     {
 844       g_message ("Could not complete key grab: grab already in use.\n");
 845       spi_error_code = BadAccess;
 846       return 0;
 847     }
 848   else
 849     {
 850       return (*x_default_error_handler) (display, error);
 851     }
 852 }
 853
 854 static void
 855 spi_controller_register_with_devices (SpiDEController *controller)
 856 {
 857   DEControllerPrivateData *priv = (DEControllerPrivateData *)
 858           g_object_get_qdata (G_OBJECT (controller), spi_dec_private_quark);
 859
 860   priv->xkb_desc = XkbGetMap (spi_get_display (), 0, XkbUseCoreKbd);
 861
 862   /* calls to device-specific implementations and routines go here */
 863   /* register with: keyboard hardware code handler */
 864   /* register with: (translated) keystroke handler */
 865
 866   priv->have_xkb = XkbQueryExtension (spi_get_display (),
 867                                       &priv->xkb_major_extension_opcode,
 868                                       &priv->xkb_base_event_code,
 869                                       &priv->xkb_base_error_code, NULL, NULL);
 870   if (priv->have_xkb)
 871     {
 872       XkbSelectEvents (spi_get_display (),
 873                        XkbUseCoreKbd,
 874                        XkbStateNotifyMask, XkbStateNotifyMask);
 875     }
 876   gdk_window_add_filter (NULL, global_filter_fn, controller);
 877
 878   gdk_window_set_events (gdk_get_default_root_window (),
 879                          GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK);
 880
 881   x_default_error_handler = XSetErrorHandler (_spi_controller_device_error_handler);
 882 }
 883
 884 static gboolean
 885 spi_key_set_contains_key (Accessibility_KeySet            *key_set,
 886                           const Accessibility_DeviceEvent *key_event)
 887 {
 888   gint i;
 889   gint len;
 890
 891   if (!key_set)
 892     {
 893       g_print ("null key set!");
 894       return TRUE;
 895     }
 896
 897   len = key_set->_length;
 898
 899   if (len == 0) /* special case, means "all keys/any key" */
 900     {
 901       g_print ("anykey\n");
 902       return TRUE;
 903     }
 904
 905   for (i = 0; i < len; ++i)
 906     {
 907 #ifdef SPI_KEYEVENT_DEBUG
 908       g_print ("key_set[%d] = %d; key_event %d, code %d, string %s\n",
 909                 i, (int) key_set->_buffer[i].keycode,
 910                (int) key_event->id, (int) key_event->hw_code,
 911                key_event->event_string);
 912 #endif
 913       if (key_set->_buffer[i].keysym == (CORBA_long) key_event->id)
 914         {
 915           return TRUE;
 916         }
 917       if (key_set->_buffer[i].keycode == (CORBA_long) key_event->hw_code)
 918         {
 919           return TRUE;
 920         }
 921       if (key_event->event_string && key_event->event_string[0] &&
 922           !strcmp (key_set->_buffer[i].keystring, key_event->event_string))
 923         {
 924           return TRUE;
 925         }
 926     }
 927
 928   return FALSE;
 929 }
 930
 931 static gboolean
 932 spi_eventtype_seq_contains_event (Accessibility_EventTypeSeq      *type_seq,
 933                                   const Accessibility_DeviceEvent *event)
 934 {
 935   gint i;
 936   gint len;
 937
 938
 939   if (!type_seq)
 940     {
 941       g_print ("null type seq!");
 942       return TRUE;
 943     }
 944
 945   len = type_seq->_length;
 946
 947   if (len == 0) /* special case, means "all events/any event" */
 948     {
 949       return TRUE;
 950     }
 951
 952   for (i = 0; i < len; ++i)
 953     {
 954 #ifdef SPI_DEBUG
 955       g_print ("type_seq[%d] = %d; event type = %d\n", i,
 956                (int) type_seq->_buffer[i], (int) event->type);
 957 #endif
 958       if (type_seq->_buffer[i] == (CORBA_long) event->type)
 959         {
 960           return TRUE;
 961         }
 962     }
 963
 964   return FALSE;
 965 }
 966
 967 static gboolean
 968 spi_key_event_matches_listener (const Accessibility_DeviceEvent *key_event,
 969                                 DEControllerKeyListener         *listener,
 970                                 CORBA_boolean                    is_system_global)
 971 {
 972   if ((key_event->modifiers == (CORBA_unsigned_short) (listener->mask & 0xFFFF)) &&
 973        spi_key_set_contains_key (listener->keys, key_event) &&
 974        spi_eventtype_seq_contains_event (listener->listener.typeseq, key_event) &&
 975       (is_system_global == listener->mode->global))
 976     {
 977       return TRUE;
 978     }
 979   else
 980     {
 981       return FALSE;
 982     }
 983 }
 984
 985 static gboolean
 986 spi_controller_notify_keylisteners (SpiDEController                 *controller,
 987                                     const Accessibility_DeviceEvent *key_event,
 988                                     CORBA_boolean                    is_system_global,
 989                                     CORBA_Environment               *ev)
 990 {
 991   GList   *l;
 992   GSList  *notify = NULL, *l2;
 993   GList  **key_listeners = &controller->key_listeners;
 994   gboolean is_consumed;
 995
 996   if (!key_listeners)
 997     {
 998       return FALSE;
 999     }
1000
1001   for (l = *key_listeners; l; l = l->next)
1002     {
1003        DEControllerKeyListener *key_listener = l->data;
1004
1005        if (spi_key_event_matches_listener (key_event, key_listener, is_system_global))
1006          {
1007            Accessibility_DeviceEventListener ls = key_listener->listener.object;
1008
1009            if (ls != CORBA_OBJECT_NIL)
1010              {
1011                /* we clone (don't dup) the listener, to avoid refcount inc. */
1012                notify = g_slist_prepend (notify,
1013                                          spi_key_listener_clone (key_listener, ev));
1014              }
1015          }
1016     }
1017
1018 #ifdef SPI_KEYEVENT_DEBUG
1019   if (!notify)
1020     {
1021       g_print ("no match for event\n");
1022     }
1023 #endif
1024
1025   is_consumed = FALSE;
1026   for (l2 = notify; l2 && !is_consumed; l2 = l2->next)
1027     {
1028       DEControllerKeyListener *key_listener = l2->data;
1029       Accessibility_DeviceEventListener ls = key_listener->listener.object;
1030
1031       is_consumed = Accessibility_DeviceEventListener_notifyEvent (ls, key_event, ev);
1032
1033       if (BONOBO_EX (ev))
1034         {
1035           is_consumed = FALSE;
1036           spi_deregister_controller_key_listener (controller, key_listener,
1037                                                   ev);
1038           CORBA_exception_free (ev);
1039         }
1040
1041       spi_key_listener_clone_free (key_listener, ev);
1042     }
1043
1044   for (; l2; l2 = l2->next)
1045     {
1046       DEControllerKeyListener *key_listener = l2->data;
1047       spi_key_listener_clone_free (key_listener, ev);
1048       /* clone doesn't have its own ref, so don't use spi_dec_listener_free */
1049     }
1050
1051   g_slist_free (notify);
1052
1053 #ifdef SPI_DEBUG
1054   if (is_consumed) g_message ("consumed\n");
1055 #endif
1056   return is_consumed;
1057 }
1058
1059 static gboolean
1060 spi_clear_error_state ()
1061 {
1062         gboolean retval = spi_error_code != 0;
1063         spi_error_code = 0;
1064         return retval;
1065 }
1066
1067 static Accessibility_DeviceEvent
1068 spi_keystroke_from_x_key_event (XKeyEvent *x_key_event)
1069 {
1070   Accessibility_DeviceEvent key_event;
1071   KeySym keysym;
1072   const int cbuf_bytes = 20;
1073   char cbuf [cbuf_bytes];
1074
1075   keysym = XLookupKeysym (x_key_event, 0);
1076   key_event.id = (CORBA_long)(keysym);
1077   key_event.hw_code = (CORBA_short) x_key_event->keycode;
1078   if (((XEvent *) x_key_event)->type == KeyPress)
1079     {
1080       key_event.type = Accessibility_KEY_PRESSED;
1081     }
1082   else
1083     {
1084       key_event.type = Accessibility_KEY_RELEASED;
1085     }
1086   key_event.modifiers = (CORBA_unsigned_short)(x_key_event->state);
1087   key_event.is_text = CORBA_FALSE;
1088   switch (keysym)
1089     {
1090       case ' ':
1091         key_event.event_string = CORBA_string_dup ("space");
1092         break;
1093       case XK_Tab:
1094 #ifdef SPI_KEYEVENT_DEBUG
1095         fprintf(stderr, "Tab\n");
1096 #endif
1097         key_event.event_string = CORBA_string_dup ("Tab");
1098         break;
1099       case XK_BackSpace:
1100         key_event.event_string = CORBA_string_dup ("Backspace");
1101         break;
1102       case XK_Return:
1103         key_event.event_string = CORBA_string_dup ("Return");
1104         break;
1105       case XK_Home:
1106         key_event.event_string = CORBA_string_dup ("Home");
1107         break;
1108       case XK_Page_Down:
1109         key_event.event_string = CORBA_string_dup ("Page_Down");
1110         break;
1111       case XK_Page_Up:
1112         key_event.event_string = CORBA_string_dup ("Page_Up");
1113         break;
1114       case XK_F1:
1115         key_event.event_string = CORBA_string_dup ("F1");
1116         break;
1117       case XK_F2:
1118         key_event.event_string = CORBA_string_dup ("F2");
1119         break;
1120       case XK_F3:
1121         key_event.event_string = CORBA_string_dup ("F3");
1122         break;
1123       case XK_F4:
1124         key_event.event_string = CORBA_string_dup ("F4");
1125         break;
1126       case XK_F5:
1127         key_event.event_string = CORBA_string_dup ("F5");
1128         break;
1129       case XK_F6:
1130         key_event.event_string = CORBA_string_dup ("F6");
1131         break;
1132       case XK_F7:
1133         key_event.event_string = CORBA_string_dup ("F7");
1134         break;
1135       case XK_F8:
1136         key_event.event_string = CORBA_string_dup ("F8");
1137         break;
1138       case XK_F9:
1139         key_event.event_string = CORBA_string_dup ("F9");
1140         break;
1141       case XK_F10:
1142         key_event.event_string = CORBA_string_dup ("F10");
1143         break;
1144       case XK_F11:
1145         key_event.event_string = CORBA_string_dup ("F11");
1146         break;
1147       case XK_F12:
1148         key_event.event_string = CORBA_string_dup ("F12");
1149         break;
1150       case XK_End:
1151         key_event.event_string = CORBA_string_dup ("End");
1152         break;
1153       case XK_Escape:
1154         key_event.event_string = CORBA_string_dup ("Escape");
1155         break;
1156       case XK_Up:
1157         key_event.event_string = CORBA_string_dup ("Up");
1158         break;
1159       case XK_Down:
1160         key_event.event_string = CORBA_string_dup ("Down");
1161         break;
1162       case XK_Left:
1163         key_event.event_string = CORBA_string_dup ("Left");
1164         break;
1165       case XK_Right:
1166         key_event.event_string = CORBA_string_dup ("Right");
1167         break;
1168       default:
1169         if (XLookupString (x_key_event, cbuf, cbuf_bytes, &keysym, NULL) > 0)
1170           {
1171             key_event.event_string = CORBA_string_dup (cbuf);
1172             if (isgraph (keysym))
1173               {
1174                 key_event.is_text = CORBA_TRUE; /* FIXME: incorrect for some composed chars? */
1175               }
1176           }
1177         else
1178           {
1179             key_event.event_string = CORBA_string_dup ("");
1180           }
1181     }
1182
1183   key_event.timestamp = (CORBA_unsigned_long) x_key_event->time;
1184 #ifdef SPI_KEYEVENT_DEBUG
1185   fprintf (stderr,
1186      "Key %lu pressed (%c), modifiers %d\n",
1187      (unsigned long) keysym,
1188      keysym ? (int) keysym : '*',
1189      (int) x_key_event->state);
1190 #endif
1191 #ifdef SPI_DEBUG
1192   fprintf (stderr, "%s%c",
1193      (x_key_event->state & Mod1Mask)?"Alt-":"",
1194      ((x_key_event->state & ShiftMask)^(x_key_event->state & LockMask))?
1195      g_ascii_toupper (keysym) : g_ascii_tolower (keysym));
1196 #endif /* SPI_DEBUG */
1197   return key_event;
1198 }
1199
1200 static gboolean
1201 spi_controller_update_key_grabs (SpiDEController           *controller,
1202                                  Accessibility_DeviceEvent *recv)
1203 {
1204   GList *l, *next;
1205   gboolean   update_failed = FALSE;
1206
1207   g_return_val_if_fail (controller != NULL, FALSE);
1208
1209   /*
1210    * masks known to work with default RH 7.1+:
1211    * 0 (no mods), LockMask, Mod1Mask, Mod2Mask, ShiftMask,
1212    * ShiftMask|LockMask, Mod1Mask|LockMask, Mod2Mask|LockMask,
1213    * ShiftMask|Mod1Mask, ShiftMask|Mod2Mask, Mod1Mask|Mod2Mask,
1214    * ShiftMask|LockMask|Mod1Mask, ShiftMask|LockMask|Mod2Mask,
1215    *
1216    * ControlMask grabs are broken, must be in use already
1217    */
1218   for (l = controller->keygrabs_list; l; l = next)
1219     {
1220       gboolean do_remove;
1221       gboolean re_issue_grab;
1222       DEControllerGrabMask *grab_mask = l->data;
1223
1224       next = l->next;
1225
1226       re_issue_grab = recv &&
1227 /*            (recv->type == Accessibility_KEY_RELEASED) && - (?) */
1228               (recv->modifiers & grab_mask->mod_mask) &&
1229               (grab_mask->key_val == keycode_for_keysym (recv->id));
1230
1231 #ifdef SPI_DEBUG
1232       fprintf (stderr, "mask=%lx %lx (%c%c) %s\n",
1233                (long int) grab_mask->key_val,
1234                (long int) grab_mask->mod_mask,
1235                grab_mask->pending_add ? '+' : '.',
1236                grab_mask->pending_remove ? '-' : '.',
1237                re_issue_grab ? "re-issue": "");
1238 #endif
1239
1240       do_remove = FALSE;
1241
1242       if (grab_mask->pending_add && grab_mask->pending_remove)
1243         {
1244           do_remove = TRUE;
1245         }
1246       else if (grab_mask->pending_remove)
1247         {
1248 #ifdef SPI_DEBUG
1249       fprintf (stderr, "ungrabbing, mask=%x\n", grab_mask->mod_mask);
1250 #endif
1251           XUngrabKey (spi_get_display (),
1252                       grab_mask->key_val,
1253                       grab_mask->mod_mask,
1254                       gdk_x11_get_default_root_xwindow ());
1255
1256           do_remove = TRUE;
1257         }
1258       else if (grab_mask->pending_add || re_issue_grab)
1259         {
1260
1261 #ifdef SPI_DEBUG
1262           fprintf (stderr, "grab %d with mask %x\n", grab_mask->key_val, grab_mask->mod_mask);
1263 #endif
1264           XGrabKey (spi_get_display (),
1265                     grab_mask->key_val,
1266                     grab_mask->mod_mask,
1267                     gdk_x11_get_default_root_xwindow (),
1268                     True,
1269                     GrabModeSync,
1270                     GrabModeSync);
1271           XSync (spi_get_display (), False);
1272           update_failed = spi_clear_error_state ();
1273           if (update_failed) {
1274                   while (grab_mask->ref_count > 0) --grab_mask->ref_count;
1275                   do_remove = TRUE;
1276           }
1277         }
1278
1279       grab_mask->pending_add = FALSE;
1280       grab_mask->pending_remove = FALSE;
1281
1282       if (do_remove)
1283         {
1284           g_assert (grab_mask->ref_count <= 0);
1285
1286           controller->keygrabs_list = g_list_delete_link (
1287             controller->keygrabs_list, l);
1288
1289           spi_grab_mask_free (grab_mask);
1290         }
1291
1292     }
1293
1294   return ! update_failed;
1295 }
1296
1297 /*
1298  * Implemented GObject::finalize
1299  */
1300 static void
1301 spi_device_event_controller_object_finalize (GObject *object)
1302 {
1303   SpiDEController *controller;
1304   DEControllerPrivateData *private;
1305   controller = SPI_DEVICE_EVENT_CONTROLLER (object);
1306
1307 #ifdef SPI_DEBUG
1308   fprintf(stderr, "spi_device_event_controller_object_finalize called\n");
1309 #endif
1310   /* disconnect any special listeners, get rid of outstanding keygrabs */
1311   XUngrabKey (spi_get_display (), AnyKey, AnyModifier, DefaultRootWindow (spi_get_display ()));
1312
1313   private = g_object_get_data (G_OBJECT (controller), "spi-dec-private");
1314   if (private->xkb_desc)
1315           XkbFreeKeyboard (private->xkb_desc, 0, True);
1316   g_free (private);
1317   spi_device_event_controller_parent_class->finalize (object);
1318 }
1319
1320 /*
1321  * CORBA Accessibility::DEController::registerKeystrokeListener
1322  *     method implementation
1323  */
1324 static CORBA_boolean
1325 impl_register_keystroke_listener (PortableServer_Servant                  servant,
1326                                   const Accessibility_DeviceEventListener l,
1327                                   const Accessibility_KeySet             *keys,
1328                                   const Accessibility_ControllerEventMask mask,
1329                                   const Accessibility_EventTypeSeq       *type,
1330                                   const Accessibility_EventListenerMode  *mode,
1331                                   CORBA_Environment                      *ev)
1332 {
1333   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (
1334           bonobo_object_from_servant (servant));
1335   DEControllerKeyListener *dec_listener;
1336 #ifdef SPI_DEBUG
1337   fprintf (stderr, "registering keystroke listener %p with maskVal %lu\n",
1338            (void *) l, (unsigned long) mask);
1339 #endif
1340   dec_listener = spi_dec_key_listener_new (l, keys, mask, type, mode, ev);
1341   return spi_controller_register_device_listener (
1342           controller, (DEControllerListener *) dec_listener, ev);
1343 }
1344
1345
1346 /*
1347  * CORBA Accessibility::DEController::registerDeviceEventListener
1348  *     method implementation
1349  */
1350 static CORBA_boolean
1351 impl_register_device_listener (PortableServer_Servant                  servant,
1352                                const Accessibility_DeviceEventListener l,
1353                                const Accessibility_EventTypeSeq       *event_types,
1354                                CORBA_Environment                      *ev)
1355 {
1356   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (
1357           bonobo_object_from_servant (servant));
1358   DEControllerListener *dec_listener;
1359
1360   dec_listener = spi_dec_listener_new (l, event_types, ev);
1361   return spi_controller_register_device_listener (
1362           controller, (DEControllerListener *) dec_listener, ev);
1363 }
1364
1365 typedef struct {
1366         CORBA_Environment       *ev;
1367         DEControllerListener    *listener;
1368 } RemoveListenerClosure;
1369
1370 static SpiReEntrantContinue
1371 remove_listener_cb (GList * const *list,
1372                     gpointer       user_data)
1373 {
1374   DEControllerListener  *listener = (*list)->data;
1375   RemoveListenerClosure *ctx = user_data;
1376
1377   if (CORBA_Object_is_equivalent (ctx->listener->object,
1378                                   listener->object, ctx->ev))
1379     {
1380       spi_re_entrant_list_delete_link (list);
1381       spi_dec_listener_free (listener, ctx->ev);
1382     }
1383
1384   return SPI_RE_ENTRANT_CONTINUE;
1385 }
1386
1387 static SpiReEntrantContinue
1388 copy_key_listener_cb (GList * const *list,
1389                       gpointer       user_data)
1390 {
1391   DEControllerKeyListener  *key_listener = (*list)->data;
1392   RemoveListenerClosure    *ctx = user_data;
1393
1394   if (CORBA_Object_is_equivalent (ctx->listener->object,
1395                                   key_listener->listener.object, ctx->ev))
1396     {
1397       /* TODO: FIXME aggregate keys in case the listener is registered twice */
1398       DEControllerKeyListener *ctx_key_listener =
1399         (DEControllerKeyListener *) ctx->listener;
1400       CORBA_free (ctx_key_listener->keys);
1401       ctx_key_listener->keys = ORBit_copy_value (key_listener->keys, TC_Accessibility_KeySet);
1402     }
1403
1404   return SPI_RE_ENTRANT_CONTINUE;
1405 }
1406
1407 static void
1408 spi_deregister_controller_device_listener (SpiDEController            *controller,
1409                                            DEControllerListener *listener,
1410                                            CORBA_Environment          *ev)
1411 {
1412   RemoveListenerClosure  ctx;
1413
1414   ctx.ev = ev;
1415   ctx.listener = listener;
1416
1417   spi_re_entrant_list_foreach (&controller->mouse_listeners,
1418                                remove_listener_cb, &ctx);
1419 }
1420
1421 static void
1422 spi_deregister_controller_key_listener (SpiDEController            *controller,
1423                                         DEControllerKeyListener    *key_listener,
1424                                         CORBA_Environment          *ev)
1425 {
1426   RemoveListenerClosure  ctx;
1427
1428   ctx.ev = ev;
1429   ctx.listener = (DEControllerListener *) key_listener;
1430
1431   /* special case, copy keyset from existing controller list entry */
1432   if (key_listener->keys->_length == 0)
1433     {
1434       spi_re_entrant_list_foreach (&controller->key_listeners,
1435                                   copy_key_listener_cb, &ctx);
1436     }
1437
1438   spi_controller_deregister_global_keygrabs (controller, key_listener);
1439
1440   spi_re_entrant_list_foreach (&controller->key_listeners,
1441                                 remove_listener_cb, &ctx);
1442
1443 }
1444
1445 /*
1446  * CORBA Accessibility::DEController::deregisterKeystrokeListener
1447  *     method implementation
1448  */
1449 static void
1450 impl_deregister_keystroke_listener (PortableServer_Servant                  servant,
1451                                     const Accessibility_DeviceEventListener l,
1452                                     const Accessibility_KeySet             *keys,
1453                                     const Accessibility_ControllerEventMask mask,
1454                                     const Accessibility_EventTypeSeq       *type,
1455                                     CORBA_Environment                      *ev)
1456 {
1457   DEControllerKeyListener  *key_listener;
1458   SpiDEController *controller;
1459
1460   controller = SPI_DEVICE_EVENT_CONTROLLER (bonobo_object (servant));
1461
1462   key_listener = spi_dec_key_listener_new (l, keys, mask, type, NULL, ev);
1463
1464 #ifdef SPI_DEREGISTER_DEBUG
1465   fprintf (stderr, "deregistering keystroke listener %p with maskVal %lu\n",
1466            (void *) l, (unsigned long) mask->value);
1467 #endif
1468
1469   spi_deregister_controller_key_listener (controller, key_listener, ev);
1470
1471   spi_dec_listener_free ((DEControllerListener *) key_listener, ev);
1472 }
1473
1474 /*
1475  * CORBA Accessibility::DEController::deregisterDeviceEventListener
1476  *     method implementation
1477  */
1478 static void
1479 impl_deregister_device_listener (PortableServer_Servant                  servant,
1480                                  const Accessibility_DeviceEventListener l,
1481                                  const Accessibility_EventTypeSeq       *event_types,
1482                                  CORBA_Environment                      *ev)
1483 {
1484   SpiDEController *controller;
1485   DEControllerListener *listener =
1486           spi_dec_listener_new (l, event_types, ev);
1487
1488   controller = SPI_DEVICE_EVENT_CONTROLLER (bonobo_object (servant));
1489
1490   spi_deregister_controller_device_listener (controller, listener, ev);
1491
1492   spi_dec_listener_free (listener, ev);
1493 }
1494
1495 static unsigned int dec_xkb_get_slowkeys_delay (SpiDEController *controller)
1496 {
1497   unsigned int retval = 0;
1498   DEControllerPrivateData *priv = (DEControllerPrivateData *)
1499           g_object_get_qdata (G_OBJECT (controller), spi_dec_private_quark);
1500 #ifdef HAVE_XKB
1501 #ifdef XKB_HAS_GET_SLOW_KEYS_DELAY
1502   retval = XkbGetSlowKeysDelay (spi_get_display (),
1503                                 XkbUseCoreKbd, &bounce_delay);
1504 #else
1505   if (!(priv->xkb_desc == (XkbDescPtr) BadAlloc || priv->xkb_desc == NULL))
1506     {
1507       Status s = XkbGetControls (spi_get_display (),
1508                                  XkbAllControlsMask, priv->xkb_desc);
1509       if (s == Success)
1510         {
1511          if (priv->xkb_desc->ctrls->enabled_ctrls & XkbSlowKeysMask)
1512                  retval = priv->xkb_desc->ctrls->slow_keys_delay;
1513         }
1514     }
1515 #endif
1516 #endif
1517 #ifdef SPI_XKB_DEBUG
1518         fprintf (stderr, "SlowKeys delay: %d\n", (int) retval);
1519 #endif
1520         return retval;
1521 }
1522
1523 static unsigned int dec_xkb_get_bouncekeys_delay (SpiDEController *controller)
1524 {
1525   unsigned int retval = 0;
1526   DEControllerPrivateData *priv = (DEControllerPrivateData *)
1527           g_object_get_qdata (G_OBJECT (controller), spi_dec_private_quark);
1528 #ifdef HAVE_XKB
1529 #ifdef XKB_HAS_GET_BOUNCE_KEYS_DELAY
1530   retval = XkbGetBounceKeysDelay (spi_get_display (),
1531                                   XkbUseCoreKbd, &bounce_delay);
1532 #else
1533   if (!(priv->xkb_desc == (XkbDescPtr) BadAlloc || priv->xkb_desc == NULL))
1534     {
1535       Status s = XkbGetControls (spi_get_display (),
1536                                  XkbAllControlsMask, priv->xkb_desc);
1537       if (s == Success)
1538         {
1539           if (priv->xkb_desc->ctrls->enabled_ctrls & XkbBounceKeysMask)
1540                   retval = priv->xkb_desc->ctrls->debounce_delay;
1541         }
1542     }
1543 #endif
1544 #endif
1545 #ifdef SPI_XKB_DEBUG
1546   fprintf (stderr, "BounceKeys delay: %d\n", (int) retval);
1547 #endif
1548   return retval;
1549 }
1550
1551 static gboolean
1552 dec_synth_keycode_press (SpiDEController *controller,
1553                          unsigned int keycode)
1554 {
1555         unsigned int time = CurrentTime;
1556         unsigned int bounce_delay;
1557         unsigned int elapsed_msec;
1558         struct timeval tv;
1559         DEControllerPrivateData *priv =
1560                 (DEControllerPrivateData *) g_object_get_qdata (G_OBJECT (controller),
1561                                                                 spi_dec_private_quark);
1562         if (keycode == priv->last_release_keycode)
1563         {
1564                 bounce_delay = dec_xkb_get_bouncekeys_delay (controller);
1565                 if (bounce_delay)
1566                 {
1567                         gettimeofday (&tv, NULL);
1568                         elapsed_msec =
1569                                 (tv.tv_sec - priv->last_release_time.tv_sec) * 1000
1570                                 + (tv.tv_usec - priv->last_release_time.tv_usec) / 1000;
1571 #ifdef SPI_XKB_DEBUG
1572                         fprintf (stderr, "%d ms elapsed (%ld usec)\n", elapsed_msec,
1573                                  (long) (tv.tv_usec - priv->last_release_time.tv_usec));
1574 #endif
1575 #ifdef THIS_IS_BROKEN
1576                         if (elapsed_msec < bounce_delay)
1577                                 time = bounce_delay - elapsed_msec + 1;
1578 #else
1579                         time = bounce_delay + 10;
1580                         /* fudge for broken XTest */
1581 #endif
1582 #ifdef SPI_XKB_DEBUG
1583                         fprintf (stderr, "waiting %d ms\n", time);
1584 #endif
1585                 }
1586         }
1587         XTestFakeKeyEvent (spi_get_display (), keycode, True, time);
1588         priv->last_press_keycode = keycode;
1589         XSync (spi_get_display (), False);
1590         gettimeofday (&priv->last_press_time, NULL);
1591         return TRUE;
1592 }
1593
1594 static gboolean
1595 dec_synth_keycode_release (SpiDEController *controller,
1596                            unsigned int keycode)
1597 {
1598         unsigned int time = CurrentTime;
1599         unsigned int slow_delay;
1600         unsigned int elapsed_msec;
1601         struct timeval tv;
1602         DEControllerPrivateData *priv =
1603                 (DEControllerPrivateData *) g_object_get_qdata (G_OBJECT (controller),
1604                                                                 spi_dec_private_quark);
1605         if (keycode == priv->last_press_keycode)
1606         {
1607                 slow_delay = dec_xkb_get_slowkeys_delay (controller);
1608                 if (slow_delay)
1609                 {
1610                         gettimeofday (&tv, NULL);
1611                         elapsed_msec =
1612                                 (tv.tv_sec - priv->last_press_time.tv_sec) * 1000
1613                                 + (tv.tv_usec - priv->last_press_time.tv_usec) / 1000;
1614 #ifdef SPI_XKB_DEBUG
1615                         fprintf (stderr, "%d ms elapsed (%ld usec)\n", elapsed_msec,
1616                                  (long) (tv.tv_usec - priv->last_press_time.tv_usec));
1617 #endif
1618 #ifdef THIS_IS_BROKEN_DUNNO_WHY
1619                         if (elapsed_msec < slow_delay)
1620                                 time = slow_delay - elapsed_msec + 1;
1621 #else
1622                         time = slow_delay + 10;
1623                         /* our XTest seems broken, we have to add slop as above */
1624 #endif
1625 #ifdef SPI_XKB_DEBUG
1626                         fprintf (stderr, "waiting %d ms\n", time);
1627 #endif
1628                 }
1629         }
1630         XTestFakeKeyEvent (spi_get_display (), keycode, False, time);
1631         priv->last_release_keycode = keycode;
1632         XSync (spi_get_display (), False);
1633         gettimeofday (&priv->last_release_time, NULL);
1634         return TRUE;
1635 }
1636
1637 /*
1638  * CORBA Accessibility::DEController::registerKeystrokeListener
1639  *     method implementation
1640  */
1641 static void
1642 impl_generate_keyboard_event (PortableServer_Servant           servant,
1643                               const CORBA_long                 keycode,
1644                               const CORBA_char                *keystring,
1645                               const Accessibility_KeySynthType synth_type,
1646                               CORBA_Environment               *ev)
1647 {
1648   SpiDEController *controller =
1649         SPI_DEVICE_EVENT_CONTROLLER (bonobo_object (servant));
1650   long key_synth_code;
1651   unsigned int slow_keys_delay;
1652   unsigned int press_time;
1653   unsigned int release_time;
1654
1655 #ifdef SPI_DEBUG
1656         fprintf (stderr, "synthesizing keystroke %ld, type %d\n",
1657                  (long) keycode, (int) synth_type);
1658 #endif
1659   /* TODO: hide/wrap/remove X dependency */
1660
1661   /*
1662    * TODO: when initializing, query for XTest extension before using,
1663    * and fall back to XSendEvent() if XTest is not available.
1664    */
1665
1666   /* TODO: implement keystring mode also */
1667   gdk_error_trap_push ();
1668
1669   switch (synth_type)
1670     {
1671       case Accessibility_KEY_PRESS:
1672               dec_synth_keycode_press (controller, keycode);
1673               break;
1674       case Accessibility_KEY_PRESSRELEASE:
1675               dec_synth_keycode_press (controller, keycode);
1676       case Accessibility_KEY_RELEASE:
1677               dec_synth_keycode_release (controller, keycode);
1678               break;
1679       case Accessibility_KEY_SYM:
1680 #ifdef SPI_XKB_DEBUG
1681               fprintf (stderr, "KeySym synthesis\n");
1682 #endif
1683               key_synth_code = keycode_for_keysym (keycode);
1684               dec_synth_keycode_press (controller, key_synth_code);
1685               dec_synth_keycode_release (controller, key_synth_code);
1686               break;
1687       case Accessibility_KEY_STRING:
1688               fprintf (stderr, "Not yet implemented\n");
1689               break;
1690     }
1691   if (gdk_error_trap_pop ())
1692     {
1693       DBG (-1, g_warning ("Error emitting keystroke"));
1694     }
1695 }
1696
1697 /* Accessibility::DEController::generateMouseEvent */
1698 static void
1699 impl_generate_mouse_event (PortableServer_Servant servant,
1700                            const CORBA_long       x,
1701                            const CORBA_long       y,
1702                            const CORBA_char      *eventName,
1703                            CORBA_Environment     *ev)
1704 {
1705   int button;
1706   gboolean error = FALSE;
1707   Display *display = spi_get_display ();
1708 #ifdef SPI_DEBUG
1709   fprintf (stderr, "generating mouse %s event at %ld, %ld\n",
1710            eventName, (long int) x, (long int) y);
1711 #endif
1712   switch (eventName[0])
1713     {
1714       case 'b':
1715         switch (eventName[1])
1716           {
1717           /* TODO: check number of buttons before parsing */
1718           case '1':
1719                     button = 1;
1720                     break;
1721           case '2':
1722                   button = 2;
1723                   break;
1724           case '3':
1725                   button = 3;
1726                   break;
1727           default:
1728                   error = TRUE;
1729           }
1730         if (!error)
1731           {
1732             if (x != -1 && y != -1)
1733               {
1734                 XTestFakeMotionEvent (display, DefaultScreen (display),
1735                                       x, y, 0);
1736               }
1737             XTestFakeButtonEvent (display, button, !(eventName[2] == 'r'), 0);
1738             if (eventName[2] == 'c')
1739               XTestFakeButtonEvent (display, button, FALSE, 1);
1740             else if (eventName[2] == 'd')
1741               {
1742               XTestFakeButtonEvent (display, button, FALSE, 1);
1743               XTestFakeButtonEvent (display, button, TRUE, 2);
1744               XTestFakeButtonEvent (display, button, FALSE, 3);
1745               }
1746           }
1747         break;
1748       case 'r': /* relative motion */
1749         XTestFakeRelativeMotionEvent (display, x, y, 0);
1750         break;
1751       case 'a': /* absolute motion */
1752         XTestFakeMotionEvent (display, DefaultScreen (display),
1753                               x, y, 0);
1754         break;
1755     }
1756 }
1757
1758 /* Accessibility::DEController::notifyListenersSync */
1759 static CORBA_boolean
1760 impl_notify_listeners_sync (PortableServer_Servant           servant,
1761                             const Accessibility_DeviceEvent *event,
1762                             CORBA_Environment               *ev)
1763 {
1764   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (
1765     bonobo_object_from_servant (servant));
1766 #ifdef SPI_DEBUG
1767   g_print ("notifylistening listeners synchronously: controller %p, event id %d\n",
1768            controller, (int) event->id);
1769 #endif
1770   return spi_controller_notify_keylisteners (controller, event, CORBA_FALSE, ev) ?
1771           CORBA_TRUE : CORBA_FALSE;
1772 }
1773
1774 /* Accessibility::DEController::notifyListenersAsync */
1775 static void
1776 impl_notify_listeners_async (PortableServer_Servant           servant,
1777                              const Accessibility_DeviceEvent *event,
1778                              CORBA_Environment               *ev)
1779 {
1780   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (
1781     bonobo_object_from_servant (servant));
1782 #ifdef SPI_DEBUG
1783   fprintf (stderr, "notifying listeners asynchronously\n");
1784 #endif
1785   spi_controller_notify_keylisteners (controller, event, CORBA_FALSE, ev);
1786 }
1787
1788 static void
1789 spi_device_event_controller_class_init (SpiDEControllerClass *klass)
1790 {
1791   GObjectClass * object_class = (GObjectClass *) klass;
1792   POA_Accessibility_DeviceEventController__epv *epv = &klass->epv;
1793
1794   spi_device_event_controller_parent_class = g_type_class_peek_parent (klass);
1795
1796   object_class->finalize = spi_device_event_controller_object_finalize;
1797
1798   epv->registerKeystrokeListener   = impl_register_keystroke_listener;
1799   epv->deregisterKeystrokeListener = impl_deregister_keystroke_listener;
1800   epv->registerDeviceEventListener = impl_register_device_listener;
1801   epv->deregisterDeviceEventListener = impl_deregister_device_listener;
1802   epv->generateKeyboardEvent       = impl_generate_keyboard_event;
1803   epv->generateMouseEvent          = impl_generate_mouse_event;
1804   epv->notifyListenersSync         = impl_notify_listeners_sync;
1805   epv->notifyListenersAsync        = impl_notify_listeners_async;
1806
1807   if (!spi_dec_private_quark)
1808           spi_dec_private_quark = g_quark_from_static_string ("spi-dec-private");
1809 }
1810
1811 static void
1812 spi_device_event_controller_init (SpiDEController *device_event_controller)
1813 {
1814   DEControllerPrivateData *private;
1815   device_event_controller->key_listeners   = NULL;
1816   device_event_controller->mouse_listeners = NULL;
1817   device_event_controller->keygrabs_list   = NULL;
1818
1819   /*
1820    * TODO: fixme, this module makes the foolish assumptions that
1821    * registryd uses the same display as the apps, and that the
1822    * DISPLAY environment variable is set.
1823    */
1824   gdk_init (NULL, NULL);
1825
1826   private = g_new0 (DEControllerPrivateData, 1);
1827   gettimeofday (&private->last_press_time, NULL);
1828   gettimeofday (&private->last_release_time, NULL);
1829   g_object_set_qdata (G_OBJECT (device_event_controller),
1830                       spi_dec_private_quark,
1831                       private);
1832
1833   spi_controller_register_with_devices (device_event_controller);
1834 }
1835
1836 static void
1837 spi_device_event_controller_forward_key_event (SpiDEController *controller,
1838                                                const XEvent    *event)
1839 {
1840   gboolean is_consumed = FALSE;
1841   CORBA_Environment ev;
1842   Accessibility_DeviceEvent key_event;
1843
1844   g_assert (event->type == KeyPress || event->type == KeyRelease);
1845
1846   CORBA_exception_init (&ev);
1847
1848   key_event = spi_keystroke_from_x_key_event ((XKeyEvent *) event);
1849
1850   spi_controller_update_key_grabs (controller, &key_event);
1851
1852   /* relay to listeners, and decide whether to consume it or not */
1853   is_consumed = spi_controller_notify_keylisteners (
1854           controller, &key_event, CORBA_TRUE, &ev);
1855
1856   if (is_consumed)
1857     {
1858       XAllowEvents (spi_get_display (), AsyncKeyboard, CurrentTime);
1859     }
1860   else
1861     {
1862       XAllowEvents (spi_get_display (), ReplayKeyboard, CurrentTime);
1863     }
1864 }
1865
1866 SpiDEController *
1867 spi_device_event_controller_new (SpiRegistry *registry)
1868 {
1869   SpiDEController *retval = g_object_new (
1870     SPI_DEVICE_EVENT_CONTROLLER_TYPE, NULL);
1871   DEControllerPrivateData *private;
1872
1873   retval->registry = SPI_REGISTRY (bonobo_object_ref (
1874           BONOBO_OBJECT (registry)));
1875
1876   spi_dec_init_mouse_listener (registry);
1877   /* TODO: kill mouse listener on finalize */
1878   return retval;
1879 }
1880
1881 BONOBO_TYPE_FUNC_FULL (SpiDEController,
1882                        Accessibility_DeviceEventController,
1883                        PARENT_TYPE,
1884                        spi_device_event_controller);