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 Sun Microsystems Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 /* deviceeventcontroler.c: implement the DeviceEventController interface */
  24
  25 #include <config.h>
  26
  27 #undef  SPI_DEBUG
  28 #undef  SPI_KEYEVENT_DEBUG
  29
  30 #include <string.h>
  31 #include <ctype.h>
  32 #include <stdio.h>
  33 #include <bonobo/bonobo-exception.h>
  34
  35 #include <X11/Xlib.h>
  36 #include <X11/extensions/XTest.h>
  37 #define XK_MISCELLANY
  38 #include <X11/keysymdef.h>
  39 #include <gdk/gdk.h>
  40 #include <gdk/gdkx.h> /* TODO: hide dependency (wrap in single porting file) */
  41 #include <gdk/gdkkeysyms.h>
  42 #include <gdk/gdkwindow.h>
  43
  44 #include "../libspi/spi-private.h"
  45 #include "deviceeventcontroller.h"
  46
  47 /* Our parent Gtk object type */
  48 #define PARENT_TYPE BONOBO_TYPE_OBJECT
  49
  50 /* A pointer to our parent object class */
  51 static GObjectClass *spi_device_event_controller_parent_class;
  52
  53 int (*x_default_error_handler) (Display *display, XErrorEvent *error_event);
  54
  55 typedef enum {
  56   SPI_DEVICE_TYPE_KBD,
  57   SPI_DEVICE_TYPE_MOUSE,
  58   SPI_DEVICE_TYPE_LAST_DEFINED
  59 } SpiDeviceTypeCategory;
  60
  61 typedef struct {
  62   guint                             ref_count : 30;
  63   guint                             pending_add : 1;
  64   guint                             pending_remove : 1;
  65
  66   Accessibility_ControllerEventMask mod_mask;
  67   CORBA_unsigned_long               key_val;  /* KeyCode */
  68 } DEControllerGrabMask;
  69
  70 typedef struct {
  71   CORBA_Object          object;
  72   SpiDeviceTypeCategory type;
  73 } DEControllerListener;
  74
  75 typedef struct {
  76   DEControllerListener listener;
  77
  78   Accessibility_KeySet             *keys;
  79   Accessibility_ControllerEventMask mask;
  80   Accessibility_KeyEventTypeSeq    *typeseq;
  81   Accessibility_EventListenerMode  *mode;
  82 } DEControllerKeyListener;
  83
  84 static void     spi_controller_register_with_devices          (SpiDEController           *controller);
  85 static gboolean spi_controller_update_key_grabs               (SpiDEController           *controller,
  86                                                                Accessibility_DeviceEvent *recv);
  87 static gboolean spi_controller_register_device_listener       (SpiDEController           *controller,
  88                                                                DEControllerListener      *l,
  89                                                                CORBA_Environment         *ev);
  90 static void     spi_device_event_controller_forward_key_event (SpiDEController           *controller,
  91                                                                const XEvent              *event);
  92
  93 #define spi_get_display() GDK_DISPLAY()
  94
  95 /* Private methods */
  96
  97 static KeyCode
  98 keycode_for_keysym (long keysym)
  99 {
 100   return XKeysymToKeycode (spi_get_display (), (KeySym) keysym);
 101 }
 102
 103 static DEControllerGrabMask *
 104 spi_grab_mask_clone (DEControllerGrabMask *grab_mask)
 105 {
 106   DEControllerGrabMask *clone = g_new (DEControllerGrabMask, 1);
 107
 108   memcpy (clone, grab_mask, sizeof (DEControllerGrabMask));
 109
 110   clone->ref_count = 1;
 111   clone->pending_add = TRUE;
 112   clone->pending_remove = FALSE;
 113
 114   return clone;
 115 }
 116
 117 static void
 118 spi_grab_mask_free (DEControllerGrabMask *grab_mask)
 119 {
 120   g_free (grab_mask);
 121 }
 122
 123 static gint
 124 spi_grab_mask_compare_values (gconstpointer p1, gconstpointer p2)
 125 {
 126   DEControllerGrabMask *l1 = (DEControllerGrabMask *) p1;
 127   DEControllerGrabMask *l2 = (DEControllerGrabMask *) p2;
 128
 129   if (p1 == p2)
 130     {
 131       return 0;
 132     }
 133   else
 134     {
 135       return ((l1->mod_mask != l2->mod_mask) || (l1->key_val != l2->key_val));
 136     }
 137 }
 138
 139 static DEControllerKeyListener *
 140 spi_dec_key_listener_new (CORBA_Object                            l,
 141                           const Accessibility_KeySet             *keys,
 142                           const Accessibility_ControllerEventMask mask,
 143                           const Accessibility_KeyEventTypeSeq    *typeseq,
 144                           const Accessibility_EventListenerMode  *mode,
 145                           CORBA_Environment                      *ev)
 146 {
 147   DEControllerKeyListener *key_listener = g_new0 (DEControllerKeyListener, 1);
 148   key_listener->listener.object = bonobo_object_dup_ref (l, ev);
 149   key_listener->listener.type = SPI_DEVICE_TYPE_KBD;
 150   key_listener->keys = ORBit_copy_value (keys, TC_Accessibility_KeySet);
 151   key_listener->mask = mask;
 152   key_listener->typeseq = ORBit_copy_value (typeseq, TC_Accessibility_KeyEventTypeSeq);
 153   if (mode)
 154     key_listener->mode = ORBit_copy_value (mode, TC_Accessibility_EventListenerMode);
 155   else
 156     key_listener->mode = NULL;
 157
 158 #ifdef SPI_DEBUG
 159   g_print ("new listener, with mask %x, is_global %d, keys %p (%d)\n",
 160            (unsigned int) key_listener->mask,
 161            (int) (mode ? mode->global : 0),
 162            (void *) key_listener->keys,
 163            (int) (key_listener->keys ? key_listener->keys->_length : 0));
 164 #endif
 165
 166   return key_listener;
 167 }
 168
 169 static void
 170 spi_dec_key_listener_free (DEControllerKeyListener *key_listener,
 171                            CORBA_Environment       *ev)
 172 {
 173   bonobo_object_release_unref (key_listener->listener.object, ev);
 174   CORBA_free (key_listener->typeseq);
 175   CORBA_free (key_listener->keys);
 176   g_free (key_listener);
 177 }
 178
 179 static void
 180 _register_keygrab (SpiDEController      *controller,
 181                    DEControllerGrabMask *grab_mask)
 182 {
 183   GList *l;
 184
 185   l = g_list_find_custom (controller->keygrabs_list, grab_mask,
 186                           spi_grab_mask_compare_values);
 187   if (l)
 188     {
 189       DEControllerGrabMask *cur_mask = l->data;
 190
 191       cur_mask->ref_count++;
 192       if (cur_mask->pending_remove)
 193         {
 194           cur_mask->pending_remove = FALSE;
 195         }
 196     }
 197   else
 198     {
 199       controller->keygrabs_list =
 200         g_list_prepend (controller->keygrabs_list,
 201                         spi_grab_mask_clone (grab_mask));
 202     }
 203 }
 204
 205 static void
 206 _deregister_keygrab (SpiDEController      *controller,
 207                      DEControllerGrabMask *grab_mask)
 208 {
 209   GList *l;
 210
 211   l = g_list_find_custom (controller->keygrabs_list, grab_mask,
 212                           spi_grab_mask_compare_values);
 213
 214   if (l)
 215     {
 216       DEControllerGrabMask *cur_mask = l->data;
 217
 218       cur_mask->ref_count--;
 219       if (cur_mask->ref_count <= 0)
 220         {
 221           cur_mask->pending_remove = TRUE;
 222         }
 223     }
 224   else
 225     {
 226       g_warning ("De-registering non-existant grab");
 227     }
 228 }
 229
 230 static void
 231 handle_keygrab (SpiDEController         *controller,
 232                 DEControllerKeyListener *key_listener,
 233                 void                   (*process_cb) (SpiDEController *controller,
 234                                                       DEControllerGrabMask *grab_mask))
 235 {
 236   DEControllerGrabMask grab_mask = { 0 };
 237
 238   grab_mask.mod_mask = key_listener->mask;
 239   if (key_listener->keys->_length == 0) /* special case means AnyKey/AllKeys */
 240     {
 241       grab_mask.key_val = AnyKey;
 242 #ifdef SPI_DEBUG
 243       fprintf (stderr, "AnyKey grab!"); */
 244 #endif
 245       process_cb (controller, &grab_mask);
 246     }
 247   else
 248     {
 249       int i;
 250
 251       for (i = 0; i < key_listener->keys->_length; ++i)
 252         {
 253           Accessibility_KeyDefinition keydef = key_listener->keys->_buffer[i];
 254           long int key_val = keydef.keysym;
 255           /* X Grabs require keycodes, not keysyms */
 256           if (keydef.keystring && keydef.keystring[0])
 257             {
 258               key_val = XStringToKeysym(keydef.keystring);
 259             }
 260           if (key_val > 0)
 261             {
 262               key_val = XKeysymToKeycode (spi_get_display (), (KeySym) key_val);
 263             }
 264           else
 265             {
 266               key_val = keydef.keycode;
 267             }
 268           grab_mask.key_val = key_val;
 269           process_cb (controller, &grab_mask);
 270         }
 271     }
 272 }
 273
 274 static gboolean
 275 spi_controller_register_global_keygrabs (SpiDEController         *controller,
 276                                          DEControllerKeyListener *key_listener)
 277 {
 278   handle_keygrab (controller, key_listener, _register_keygrab);
 279   return spi_controller_update_key_grabs (controller, NULL);
 280 }
 281
 282 static void
 283 spi_controller_deregister_global_keygrabs (SpiDEController         *controller,
 284                                            DEControllerKeyListener *key_listener)
 285 {
 286   handle_keygrab (controller, key_listener, _deregister_keygrab);
 287   spi_controller_update_key_grabs (controller, NULL);
 288 }
 289
 290 static gboolean
 291 spi_controller_register_device_listener (SpiDEController      *controller,
 292                                          DEControllerListener *listener,
 293                                          CORBA_Environment    *ev)
 294 {
 295   DEControllerKeyListener *key_listener;
 296
 297   switch (listener->type) {
 298   case SPI_DEVICE_TYPE_KBD:
 299       key_listener = (DEControllerKeyListener *) listener;
 300
 301       controller->key_listeners = g_list_prepend (controller->key_listeners,
 302                                                   key_listener);
 303       if (key_listener->mode->global)
 304         {
 305           return spi_controller_register_global_keygrabs (controller, key_listener);
 306         }
 307       else
 308               return TRUE;
 309       break;
 310     default:
 311       break;
 312   }
 313   return FALSE;
 314 }
 315
 316 static GdkFilterReturn
 317 global_filter_fn (GdkXEvent *gdk_xevent, GdkEvent *event, gpointer data)
 318 {
 319   XEvent *xevent = gdk_xevent;
 320   SpiDEController *controller;
 321
 322   if (xevent->type != KeyPress && xevent->type != KeyRelease)
 323     {
 324       return GDK_FILTER_CONTINUE;
 325     }
 326
 327   controller = SPI_DEVICE_EVENT_CONTROLLER (data);
 328
 329   spi_device_event_controller_forward_key_event (controller, xevent);
 330
 331   /* FIXME: is this right ? */
 332   return GDK_FILTER_CONTINUE;
 333 }
 334
 335 int
 336 _spi_controller_device_error_handler (Display *display, XErrorEvent *error)
 337 {
 338   if (error->error_code == BadAccess)
 339     {
 340       g_message ("Could not complete key grab: grab already in use.\n");
 341       return 0;
 342     }
 343   else
 344     {
 345       return (*x_default_error_handler) (display, error);
 346     }
 347 }
 348
 349 static void
 350 spi_controller_register_with_devices (SpiDEController *controller)
 351 {
 352   /* calls to device-specific implementations and routines go here */
 353   /* register with: keyboard hardware code handler */
 354   /* register with: (translated) keystroke handler */
 355
 356   gdk_window_add_filter (NULL, global_filter_fn, controller);
 357
 358   gdk_window_set_events (gdk_get_default_root_window (),
 359                          GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK);
 360
 361   x_default_error_handler = XSetErrorHandler (_spi_controller_device_error_handler);
 362 }
 363
 364 #define SPI_KEYEVENT_DEBUG
 365 static gboolean
 366 spi_key_set_contains_key (Accessibility_KeySet            *key_set,
 367                           const Accessibility_DeviceEvent *key_event)
 368 {
 369   gint i;
 370   gint len;
 371
 372   if (!key_set)
 373     {
 374       g_print ("null key set!");
 375       return TRUE;
 376     }
 377
 378   len = key_set->_length;
 379
 380   if (len == 0) /* special case, means "all keys/any key" */
 381     {
 382       g_print ("anykey\n");
 383       return TRUE;
 384     }
 385
 386   for (i = 0; i < len; ++i)
 387     {
 388 #ifdef SPI_KEYEVENT_DEBUG
 389       g_print ("key_set[%d] = %d; key_event %d, code %d, string %s\n",
 390                 i, (int) key_set->_buffer[i].keycode,
 391                (int) key_event->id, (int) key_event->hw_code,
 392                key_event->event_string);
 393 #endif
 394       if (key_set->_buffer[i].keysym == (CORBA_long) key_event->id)
 395         {
 396           return TRUE;
 397         }
 398       if (key_set->_buffer[i].keycode == (CORBA_long) key_event->hw_code)
 399         {
 400           return TRUE;
 401         }
 402       if (key_event->event_string && key_event->event_string[0] &&
 403           !strcmp (key_set->_buffer[i].keystring, key_event->event_string))
 404         {
 405           return TRUE;
 406         }
 407     }
 408
 409   return FALSE;
 410 }
 411
 412 static gboolean
 413 spi_key_eventtype_seq_contains_event (Accessibility_KeyEventTypeSeq   *type_seq,
 414                                       const Accessibility_DeviceEvent *key_event)
 415 {
 416   gint i;
 417   gint len;
 418
 419
 420   if (!type_seq)
 421     {
 422       g_print ("null type seq!");
 423       return TRUE;
 424     }
 425
 426   len = type_seq->_length;
 427
 428   if (len == 0) /* special case, means "all events/any event" */
 429     {
 430       return TRUE;
 431     }
 432
 433   for (i = 0; i < len; ++i)
 434     {
 435 #ifdef SPI_DEBUG
 436       g_print ("type_seq[%d] = %d; key event type = %d\n", i,
 437                (int) type_seq->_buffer[i], (int) key_event->type);
 438 #endif
 439       if (type_seq->_buffer[i] == (CORBA_long) key_event->type)
 440         {
 441           return TRUE;
 442         }
 443     }
 444
 445   return FALSE;
 446 }
 447
 448 static gboolean
 449 spi_key_event_matches_listener (const Accessibility_DeviceEvent *key_event,
 450                                 DEControllerKeyListener         *listener,
 451                                 CORBA_boolean                    is_system_global)
 452 {
 453   if ((key_event->modifiers == (CORBA_unsigned_short) (listener->mask & 0xFFFF)) &&
 454        spi_key_set_contains_key (listener->keys, key_event) &&
 455        spi_key_eventtype_seq_contains_event (listener->typeseq, key_event) &&
 456       (is_system_global == listener->mode->global))
 457     {
 458       return TRUE;
 459     }
 460   else
 461     {
 462       return FALSE;
 463     }
 464 }
 465
 466 static gboolean
 467 spi_notify_keylisteners (GList                          **key_listeners,
 468                          const Accessibility_DeviceEvent *key_event,
 469                          CORBA_boolean                    is_system_global,
 470                          CORBA_Environment               *ev)
 471 {
 472   GList   *l;
 473   GSList  *notify = NULL, *l2;
 474   gboolean is_consumed;
 475
 476   if (!key_listeners)
 477     {
 478       return FALSE;
 479     }
 480
 481   for (l = *key_listeners; l; l = l->next)
 482     {
 483        DEControllerKeyListener *key_listener = l->data;
 484
 485        if (spi_key_event_matches_listener (key_event, key_listener, is_system_global))
 486          {
 487            Accessibility_DeviceEventListener ls = key_listener->listener.object;
 488
 489            if (ls != CORBA_OBJECT_NIL)
 490              {
 491                notify = g_slist_prepend (notify, CORBA_Object_duplicate (ls, ev));
 492              }
 493          }
 494     }
 495
 496 #ifdef SPI_KEYEVENT_DEBUG
 497   if (!notify)
 498     {
 499       g_print ("no match for event\n");
 500     }
 501 #endif
 502
 503   is_consumed = FALSE;
 504   for (l2 = notify; l2 && !is_consumed; l2 = l2->next)
 505     {
 506       Accessibility_DeviceEventListener ls = l2->data;
 507
 508       is_consumed = Accessibility_DeviceEventListener_notifyEvent (ls, key_event, ev);
 509
 510       if (BONOBO_EX (ev))
 511         {
 512           is_consumed = FALSE;
 513           CORBA_exception_free (ev);
 514         }
 515
 516       CORBA_Object_release (ls, ev);
 517     }
 518
 519   for (; l2; l2 = l2->next)
 520     {
 521       CORBA_Object_release (l2->data, ev);
 522     }
 523
 524   g_slist_free (notify);
 525
 526 #ifdef SPI_DEBUG
 527   if (is_consumed) g_message ("consumed\n");
 528 #endif
 529   return is_consumed;
 530 }
 531
 532 static Accessibility_DeviceEvent
 533 spi_keystroke_from_x_key_event (XKeyEvent *x_key_event)
 534 {
 535   Accessibility_DeviceEvent key_event;
 536   KeySym keysym;
 537   const int cbuf_bytes = 20;
 538   char cbuf [cbuf_bytes];
 539
 540   keysym = XLookupKeysym (x_key_event, 0);
 541   key_event.id = (CORBA_long)(keysym);
 542   key_event.hw_code = (CORBA_short) x_key_event->keycode;
 543   if (((XEvent *) x_key_event)->type == KeyPress)
 544     {
 545       key_event.type = Accessibility_KEY_PRESSED;
 546     }
 547   else
 548     {
 549       key_event.type = Accessibility_KEY_RELEASED;
 550     }
 551   key_event.modifiers = (CORBA_unsigned_short)(x_key_event->state);
 552   key_event.is_text = CORBA_FALSE;
 553   switch (keysym)
 554     {
 555       case ' ':
 556         key_event.event_string = CORBA_string_dup ("space");
 557         break;
 558       case XK_Tab:
 559 #ifdef SPI_KEYEVENT_DEBUG
 560         fprintf(stderr, "Tab\n");
 561 #endif
 562         key_event.event_string = CORBA_string_dup ("Tab");
 563         break;
 564       case XK_BackSpace:
 565         key_event.event_string = CORBA_string_dup ("Backspace");
 566         break;
 567       case XK_Return:
 568         key_event.event_string = CORBA_string_dup ("Return");
 569         break;
 570       case XK_Home:
 571         key_event.event_string = CORBA_string_dup ("Home");
 572         break;
 573       case XK_Page_Down:
 574         key_event.event_string = CORBA_string_dup ("Page_Down");
 575         break;
 576       case XK_Page_Up:
 577         key_event.event_string = CORBA_string_dup ("Page_Up");
 578         break;
 579       case XK_F1:
 580         key_event.event_string = CORBA_string_dup ("F1");
 581         break;
 582       case XK_F2:
 583         key_event.event_string = CORBA_string_dup ("F2");
 584         break;
 585       case XK_F3:
 586         key_event.event_string = CORBA_string_dup ("F3");
 587         break;
 588       case XK_F4:
 589         key_event.event_string = CORBA_string_dup ("F4");
 590         break;
 591       case XK_F5:
 592         key_event.event_string = CORBA_string_dup ("F5");
 593         break;
 594       case XK_F6:
 595         key_event.event_string = CORBA_string_dup ("F6");
 596         break;
 597       case XK_F7:
 598         key_event.event_string = CORBA_string_dup ("F7");
 599         break;
 600       case XK_F8:
 601         key_event.event_string = CORBA_string_dup ("F8");
 602         break;
 603       case XK_F9:
 604         key_event.event_string = CORBA_string_dup ("F9");
 605         break;
 606       case XK_F10:
 607         key_event.event_string = CORBA_string_dup ("F10");
 608         break;
 609       case XK_F11:
 610         key_event.event_string = CORBA_string_dup ("F11");
 611         break;
 612       case XK_F12:
 613         key_event.event_string = CORBA_string_dup ("F12");
 614         break;
 615       case XK_End:
 616         key_event.event_string = CORBA_string_dup ("End");
 617         break;
 618       case XK_Escape:
 619         key_event.event_string = CORBA_string_dup ("Escape");
 620         break;
 621       case XK_Up:
 622         key_event.event_string = CORBA_string_dup ("Up");
 623         break;
 624       case XK_Down:
 625         key_event.event_string = CORBA_string_dup ("Down");
 626         break;
 627       case XK_Left:
 628         key_event.event_string = CORBA_string_dup ("Left");
 629         break;
 630       case XK_Right:
 631         key_event.event_string = CORBA_string_dup ("Right");
 632         break;
 633       default:
 634         if (XLookupString (x_key_event, cbuf, cbuf_bytes, &keysym, NULL) > 0)
 635           {
 636             key_event.event_string = CORBA_string_dup (cbuf);
 637             if (isgraph (keysym))
 638               {
 639                 key_event.is_text = CORBA_TRUE; /* FIXME: incorrect for some composed chars? */
 640               }
 641           }
 642         else
 643           {
 644             key_event.event_string = CORBA_string_dup ("");
 645           }
 646     }
 647
 648   key_event.timestamp = (CORBA_unsigned_long) x_key_event->time;
 649 #ifdef SPI_KEYEVENT_DEBUG
 650   fprintf (stderr,
 651      "Key %lu pressed (%c), modifiers %d\n",
 652      (unsigned long) keysym,
 653      keysym ? (int) keysym : '*',
 654      (int) x_key_event->state);
 655 #endif
 656 #ifdef SPI_DEBUG
 657   fprintf (stderr, "%s%c",
 658      (x_key_event->state & Mod1Mask)?"Alt-":"",
 659      ((x_key_event->state & ShiftMask)^(x_key_event->state & LockMask))?
 660      g_ascii_toupper (keysym) : g_ascii_tolower (keysym));
 661 #endif /* SPI_DEBUG */
 662   return key_event;
 663 }
 664
 665 static gboolean
 666 spi_controller_update_key_grabs (SpiDEController           *controller,
 667                                  Accessibility_DeviceEvent *recv)
 668 {
 669   GList *l, *next;
 670
 671   g_return_val_if_fail (controller != NULL, FALSE);
 672
 673   /*
 674    * masks known to work with default RH 7.1+:
 675    * 0 (no mods), LockMask, Mod1Mask, Mod2Mask, ShiftMask,
 676    * ShiftMask|LockMask, Mod1Mask|LockMask, Mod2Mask|LockMask,
 677    * ShiftMask|Mod1Mask, ShiftMask|Mod2Mask, Mod1Mask|Mod2Mask,
 678    * ShiftMask|LockMask|Mod1Mask, ShiftMask|LockMask|Mod2Mask,
 679    *
 680    * ControlMask grabs are broken, must be in use already
 681    */
 682   for (l = controller->keygrabs_list; l; l = next)
 683     {
 684       gboolean do_remove;
 685       gboolean re_issue_grab;
 686       DEControllerGrabMask *grab_mask = l->data;
 687
 688       next = l->next;
 689
 690       re_issue_grab = recv &&
 691 /*            (recv->type == Accessibility_KEY_RELEASED) && - (?) */
 692               (recv->modifiers & grab_mask->mod_mask) &&
 693               (grab_mask->key_val == keycode_for_keysym (recv->id));
 694
 695 #ifdef SPI_DEBUG
 696       fprintf (stderr, "mask=%lx %lx (%c%c) %s\n",
 697                (long int) grab_mask->key_val,
 698                (long int) grab_mask->mod_mask,
 699                grab_mask->pending_add ? '+' : '.',
 700                grab_mask->pending_remove ? '-' : '.',
 701                re_issue_grab ? "re-issue": "");
 702 #endif
 703
 704       do_remove = FALSE;
 705
 706       if (grab_mask->pending_add && grab_mask->pending_remove)
 707         {
 708           do_remove = TRUE;
 709         }
 710       else if (grab_mask->pending_remove)
 711         {
 712 #ifdef SPI_DEBUG
 713       fprintf (stderr, "ungrabbing, mask=%x\n", grab_mask->mod_mask);
 714 #endif
 715           XUngrabKey (spi_get_display (),
 716                       grab_mask->key_val,
 717                       grab_mask->mod_mask,
 718                       gdk_x11_get_default_root_xwindow ());
 719
 720           do_remove = TRUE;
 721         }
 722       else if (grab_mask->pending_add || re_issue_grab)
 723         {
 724
 725 #ifdef SPI_DEBUG
 726           fprintf (stderr, "grab with mask %x\n", grab_mask->mod_mask);
 727 #endif
 728           XGrabKey (spi_get_display (),
 729                     grab_mask->key_val,
 730                     grab_mask->mod_mask,
 731                     gdk_x11_get_default_root_xwindow (),
 732                     True,
 733                     GrabModeAsync,
 734                     GrabModeAsync);
 735         }
 736
 737       grab_mask->pending_add = FALSE;
 738       grab_mask->pending_remove = FALSE;
 739
 740       if (do_remove)
 741         {
 742           g_assert (grab_mask->ref_count <= 0);
 743
 744           controller->keygrabs_list = g_list_delete_link (
 745             controller->keygrabs_list, l);
 746
 747           spi_grab_mask_free (grab_mask);
 748         }
 749
 750       /* TODO: check calls for errors and return FALSE if error occurs */
 751     }
 752
 753   return TRUE;
 754 }
 755
 756 /*
 757  * Implemented GObject::finalize
 758  */
 759 static void
 760 spi_device_event_controller_object_finalize (GObject *object)
 761 {
 762   SpiDEController *controller;
 763
 764   controller = SPI_DEVICE_EVENT_CONTROLLER (object);
 765
 766 #ifdef SPI_DEBUG
 767   fprintf(stderr, "spi_device_event_controller_object_finalize called\n");
 768 #endif
 769   /* disconnect any special listeners, get rid of outstanding keygrabs */
 770   XUngrabKey (spi_get_display (), AnyKey, AnyModifier, DefaultRootWindow (spi_get_display ()));
 771
 772   spi_device_event_controller_parent_class->finalize (object);
 773 }
 774
 775 /*
 776  * CORBA Accessibility::DEController::registerKeystrokeListener
 777  *     method implementation
 778  */
 779 static CORBA_boolean
 780 impl_register_keystroke_listener (PortableServer_Servant                  servant,
 781                                   const Accessibility_DeviceEventListener l,
 782                                   const Accessibility_KeySet             *keys,
 783                                   const Accessibility_ControllerEventMask mask,
 784                                   const Accessibility_KeyEventTypeSeq    *type,
 785                                   const Accessibility_EventListenerMode  *mode,
 786                                   CORBA_Environment                      *ev)
 787 {
 788   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (
 789           bonobo_object_from_servant (servant));
 790   DEControllerKeyListener *dec_listener;
 791 #ifdef SPI_DEBUG
 792   fprintf (stderr, "registering keystroke listener %p with maskVal %lu\n",
 793            (void *) l, (unsigned long) mask);
 794 #endif
 795   dec_listener = spi_dec_key_listener_new (l, keys, mask, type, mode, ev);
 796   return spi_controller_register_device_listener (
 797           controller, (DEControllerListener *) dec_listener, ev);
 798 }
 799
 800
 801 typedef struct {
 802         CORBA_Environment       *ev;
 803         DEControllerKeyListener *key_listener;
 804 } RemoveKeyListenerClosure;
 805
 806 static SpiReEntrantContinue
 807 remove_key_listener_cb (GList * const *list,
 808                         gpointer       user_data)
 809 {
 810   DEControllerKeyListener  *key_listener = (*list)->data;
 811   RemoveKeyListenerClosure *ctx = user_data;
 812
 813   if (CORBA_Object_is_equivalent (ctx->key_listener->listener.object,
 814                                   key_listener->listener.object, ctx->ev))
 815     {
 816       spi_re_entrant_list_delete_link (list);
 817       spi_dec_key_listener_free (key_listener, ctx->ev);
 818     }
 819
 820   return SPI_RE_ENTRANT_CONTINUE;
 821 }
 822
 823 static SpiReEntrantContinue
 824 copy_key_listener_cb (GList * const *list,
 825                       gpointer       user_data)
 826 {
 827   DEControllerKeyListener  *key_listener = (*list)->data;
 828   RemoveKeyListenerClosure *ctx = user_data;
 829
 830   if (CORBA_Object_is_equivalent (ctx->key_listener->listener.object,
 831                                   key_listener->listener.object, ctx->ev))
 832     {
 833       /* TODO: FIXME aggregate keys in case the listener is registered twice */
 834       CORBA_free (ctx->key_listener->keys);
 835       ctx->key_listener->keys = ORBit_copy_value (key_listener->keys, TC_Accessibility_KeySet);
 836     }
 837
 838   return SPI_RE_ENTRANT_CONTINUE;
 839 }
 840
 841 /*
 842  * CORBA Accessibility::DEController::deregisterKeystrokeListener
 843  *     method implementation
 844  */
 845 static void
 846 impl_deregister_keystroke_listener (PortableServer_Servant                  servant,
 847                                     const Accessibility_DeviceEventListener l,
 848                                     const Accessibility_KeySet             *keys,
 849                                     const Accessibility_ControllerEventMask mask,
 850                                     const Accessibility_KeyEventTypeSeq    *type,
 851                                     CORBA_Environment                      *ev)
 852 {
 853   DEControllerKeyListener  *key_listener;
 854   RemoveKeyListenerClosure  ctx;
 855   SpiDEController *controller;
 856
 857   controller = SPI_DEVICE_EVENT_CONTROLLER (bonobo_object (servant));
 858
 859   key_listener = spi_dec_key_listener_new (l, keys, mask, type, NULL, ev);
 860
 861 #ifdef SPI_DEREGISTER_DEBUG
 862   fprintf (stderr, "deregistering keystroke listener %p with maskVal %lu\n",
 863            (void *) l, (unsigned long) mask->value);
 864 #endif
 865
 866   ctx.ev = ev;
 867   ctx.key_listener = key_listener;
 868
 869   /* special case, copy keyset from existing controller list entry */
 870   if (keys->_length == 0)
 871     {
 872       spi_re_entrant_list_foreach (&controller->key_listeners,
 873                                   copy_key_listener_cb, &ctx);
 874     }
 875
 876   spi_controller_deregister_global_keygrabs (controller, key_listener);
 877
 878   spi_re_entrant_list_foreach (&controller->key_listeners,
 879                                 remove_key_listener_cb, &ctx);
 880
 881   spi_dec_key_listener_free (key_listener, ev);
 882 }
 883
 884 /*
 885  * CORBA Accessibility::DEController::registerKeystrokeListener
 886  *     method implementation
 887  */
 888 static void
 889 impl_generate_keyboard_event (PortableServer_Servant           servant,
 890                               const CORBA_long                 keycode,
 891                               const CORBA_char                *keystring,
 892                               const Accessibility_KeySynthType synth_type,
 893                               CORBA_Environment               *ev)
 894 {
 895   long key_synth_code;
 896
 897 #ifdef SPI_DEBUG
 898   fprintf (stderr, "synthesizing keystroke %ld, type %d\n",
 899            (long) keycode, (int) synth_type);
 900 #endif
 901   /* TODO: hide/wrap/remove X dependency */
 902
 903   /* TODO: be accessX-savvy so that keyrelease occurs after sufficient timeout */
 904
 905   /*
 906    * TODO: when initializing, query for XTest extension before using,
 907    * and fall back to XSendEvent() if XTest is not available.
 908    */
 909
 910   /* TODO: implement keystring mode also */
 911   gdk_error_trap_push ();
 912
 913   switch (synth_type)
 914     {
 915       case Accessibility_KEY_PRESS:
 916         XTestFakeKeyEvent (spi_get_display (), (unsigned int) keycode, True, CurrentTime);
 917         break;
 918       case Accessibility_KEY_PRESSRELEASE:
 919         XTestFakeKeyEvent (spi_get_display (), (unsigned int) keycode, True, CurrentTime);
 920       case Accessibility_KEY_RELEASE:
 921         XTestFakeKeyEvent (spi_get_display (), (unsigned int) keycode, False, CurrentTime);
 922         break;
 923       case Accessibility_KEY_SYM:
 924         key_synth_code = keycode_for_keysym (keycode);
 925         XTestFakeKeyEvent (spi_get_display (), (unsigned int) key_synth_code, True, CurrentTime);
 926         XTestFakeKeyEvent (spi_get_display (), (unsigned int) key_synth_code, False, CurrentTime);
 927         break;
 928       case Accessibility_KEY_STRING:
 929         fprintf (stderr, "Not yet implemented\n");
 930         break;
 931     }
 932   if (gdk_error_trap_pop ())
 933     {
 934       g_warning ("Error emitting keystroke");
 935     }
 936 }
 937
 938 /* Accessibility::DEController::generateMouseEvent */
 939 static void
 940 impl_generate_mouse_event (PortableServer_Servant servant,
 941                            const CORBA_long       x,
 942                            const CORBA_long       y,
 943                            const CORBA_char      *eventName,
 944                            CORBA_Environment     *ev)
 945 {
 946   int button;
 947   gboolean error = FALSE;
 948   Display *display = spi_get_display ();
 949 #ifdef SPI_DEBUG
 950   fprintf (stderr, "generating mouse %s event at %ld, %ld\n",
 951            eventName, (long int) x, (long int) y);
 952 #endif
 953   g_message ("mouse event synthesis\n");
 954   switch (eventName[0])
 955     {
 956       case 'b':
 957         switch (eventName[1])
 958           {
 959           /* TODO: check number of buttons before parsing */
 960           case '1':
 961                     button = 1;
 962                     break;
 963           case '2':
 964                   button = 2;
 965                   break;
 966           case '3':
 967                   button = 3;
 968                   break;
 969           default:
 970                   error = TRUE;
 971           }
 972         if (!error)
 973           {
 974             if (x != -1 && y != -1)
 975               {
 976                 XTestFakeMotionEvent (display, DefaultScreen (display),
 977                                       x, y, 0);
 978               }
 979             XTestFakeButtonEvent (display, button, !(eventName[2] == 'r'), 0);
 980             if (eventName[2] == 'c')
 981               XTestFakeButtonEvent (display, button, FALSE, 1);
 982             else if (eventName[2] == 'd')
 983               {
 984               XTestFakeButtonEvent (display, button, FALSE, 1);
 985               XTestFakeButtonEvent (display, button, TRUE, 2);
 986               XTestFakeButtonEvent (display, button, FALSE, 3);
 987               }
 988           }
 989         break;
 990       case 'r': /* relative motion */
 991         XTestFakeRelativeMotionEvent (display, x, y, 0);
 992         break;
 993       case 'a': /* absolute motion */
 994         XTestFakeMotionEvent (display, DefaultScreen (display),
 995                               x, y, 0);
 996         break;
 997     }
 998 }
 999
1000 /* Accessibility::DEController::notifyListenersSync */
1001 static CORBA_boolean
1002 impl_notify_listeners_sync (PortableServer_Servant           servant,
1003                             const Accessibility_DeviceEvent *event,
1004                             CORBA_Environment               *ev)
1005 {
1006   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (
1007     bonobo_object_from_servant (servant));
1008 #ifdef SPI_DEBUG
1009   g_print ("notifylistening listeners synchronously: controller %p, event id %d\n",
1010            controller, (int) event->id);
1011 #endif
1012   return spi_notify_keylisteners (&controller->key_listeners, event, CORBA_FALSE, ev) ?
1013           CORBA_TRUE : CORBA_FALSE;
1014 }
1015
1016 /* Accessibility::DEController::notifyListenersAsync */
1017 static void
1018 impl_notify_listeners_async (PortableServer_Servant           servant,
1019                              const Accessibility_DeviceEvent *event,
1020                              CORBA_Environment               *ev)
1021 {
1022   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (
1023     bonobo_object_from_servant (servant));
1024 #ifdef SPI_DEBUG
1025   fprintf (stderr, "notifying listeners asynchronously\n");
1026 #endif
1027   spi_notify_keylisteners (&controller->key_listeners, event, CORBA_FALSE, ev);
1028 }
1029
1030 static void
1031 spi_device_event_controller_class_init (SpiDEControllerClass *klass)
1032 {
1033   GObjectClass * object_class = (GObjectClass *) klass;
1034   POA_Accessibility_DeviceEventController__epv *epv = &klass->epv;
1035
1036   spi_device_event_controller_parent_class = g_type_class_peek_parent (klass);
1037
1038   object_class->finalize = spi_device_event_controller_object_finalize;
1039
1040   epv->registerKeystrokeListener   = impl_register_keystroke_listener;
1041   epv->deregisterKeystrokeListener = impl_deregister_keystroke_listener;
1042   epv->generateKeyboardEvent       = impl_generate_keyboard_event;
1043   epv->generateMouseEvent          = impl_generate_mouse_event;
1044   epv->notifyListenersSync         = impl_notify_listeners_sync;
1045   epv->notifyListenersAsync        = impl_notify_listeners_async;
1046 }
1047
1048 static void
1049 spi_device_event_controller_init (SpiDEController *device_event_controller)
1050 {
1051   device_event_controller->key_listeners   = NULL;
1052   device_event_controller->mouse_listeners = NULL;
1053   device_event_controller->keygrabs_list   = NULL;
1054
1055   /*
1056    * TODO: fixme, this module makes the foolish assumptions that
1057    * registryd uses the same display as the apps, and that the
1058    * DISPLAY environment variable is set.
1059    */
1060   gdk_init (NULL, NULL);
1061
1062   spi_controller_register_with_devices (device_event_controller);
1063 }
1064
1065 static void
1066 spi_device_event_controller_forward_key_event (SpiDEController *controller,
1067                                                const XEvent    *event)
1068 {
1069   gboolean is_consumed = FALSE;
1070   CORBA_Environment ev;
1071   Accessibility_DeviceEvent key_event;
1072
1073   g_assert (event->type == KeyPress || event->type == KeyRelease);
1074
1075   CORBA_exception_init (&ev);
1076
1077   key_event = spi_keystroke_from_x_key_event ((XKeyEvent *) event);
1078
1079   spi_controller_update_key_grabs (controller, &key_event);
1080
1081   /* relay to listeners, and decide whether to consume it or not */
1082   is_consumed = spi_notify_keylisteners (
1083     &controller->key_listeners, &key_event, CORBA_TRUE, &ev);
1084
1085   CORBA_exception_free (&ev);
1086
1087   if (is_consumed)
1088     {
1089       XAllowEvents (spi_get_display (), AsyncKeyboard, CurrentTime);
1090     }
1091   else
1092     {
1093       XAllowEvents (spi_get_display (), ReplayKeyboard, CurrentTime);
1094     }
1095 }
1096
1097 SpiDEController *
1098 spi_device_event_controller_new (SpiRegistry *registry)
1099 {
1100   SpiDEController *retval = g_object_new (
1101     SPI_DEVICE_EVENT_CONTROLLER_TYPE, NULL);
1102
1103   retval->registry = SPI_REGISTRY (bonobo_object_ref (
1104           BONOBO_OBJECT (registry)));
1105
1106   return retval;
1107 }
1108
1109 BONOBO_TYPE_FUNC_FULL (SpiDEController,
1110                        Accessibility_DeviceEventController,
1111                        PARENT_TYPE,
1112                        spi_device_event_controller);