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