libspi/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 #ifdef SPI_DEBUG
  28 #  include <stdio.h>
  29 #endif
  30
  31 #include <X11/Xlib.h>
  32 #include <X11/extensions/XTest.h>
  33 #include <gdk/gdkx.h> /* TODO: hide dependency (wrap in single porting file) */
  34 #include <gdk/gdkwindow.h>
  35
  36 #include <libspi/deviceeventcontroller.h>
  37
  38 /* Our parent Gtk object type */
  39 #define PARENT_TYPE BONOBO_TYPE_OBJECT
  40
  41 /* A pointer to our parent object class */
  42 static GObjectClass *spi_device_event_controller_parent_class;
  43
  44 static gboolean kbd_registered = FALSE;
  45
  46 static Display *display;
  47
  48 static Window root_window;
  49
  50 typedef enum {
  51         SPI_DEVICE_TYPE_KBD,
  52         SPI_DEVICE_TYPE_MOUSE,
  53         SPI_DEVICE_TYPE_LAST_DEFINED
  54 } SpiDeviceTypeCategory;
  55
  56 struct _DEControllerListener {
  57         CORBA_Object          object;
  58         SpiDeviceTypeCategory type;
  59 };
  60
  61 typedef struct _DEControllerListener DEControllerListener;
  62
  63 struct _DEControllerKeyListener {
  64         DEControllerListener listener;
  65         Accessibility_KeySet *keys;
  66         Accessibility_ControllerEventMask *mask;
  67         Accessibility_KeyEventTypeSeq *typeseq;
  68         gboolean is_system_global;
  69 };
  70
  71 typedef struct _DEControllerKeyListener DEControllerKeyListener;
  72
  73 static gboolean _controller_register_with_devices (SpiDeviceEventController *controller);
  74 static gboolean _controller_grab_keyboard (SpiDeviceEventController *controller);
  75
  76 static void controller_register_device_listener (SpiDeviceEventController *controller,
  77                                                  DEControllerListener *l,
  78                                                  CORBA_Environment *ev);
  79
  80 /*
  81  * Private methods
  82  */
  83
  84 static gint
  85 _compare_corba_objects (gconstpointer p1, gconstpointer p2)
  86 {
  87   CORBA_Environment ev;
  88   gint retval;
  89   retval = !CORBA_Object_is_equivalent ((CORBA_Object) p1, (CORBA_Object) p2, &ev);
  90
  91 #ifdef SPI_DEBUG
  92   fprintf (stderr, "comparing %p to %p; result %d\n",
  93            p1, p2,
  94            retval);
  95 #endif
  96   return retval;
  97 }
  98
  99 static gint
 100 _compare_listeners (gconstpointer p1, gconstpointer p2)
 101 {
 102   DEControllerListener *l1 = (DEControllerListener *) p1;
 103   DEControllerListener *l2 = (DEControllerListener *) p2;
 104   return _compare_corba_objects (l1->object, l2->object);
 105 }
 106
 107 static gint
 108 _eventmask_compare_value (gconstpointer p1, gconstpointer p2)
 109 {
 110     long d;
 111     if (!p1 || !p2)
 112         return (gint) (p1?1:(p2?-1:0));
 113     else
 114         d = ((long)((Accessibility_ControllerEventMask*)p2)->value) -
 115                 ((long)((Accessibility_ControllerEventMask*)p1)->value);
 116     return (gint) d;
 117 }
 118
 119 static DEControllerKeyListener *
 120 dec_key_listener_new (CORBA_Object l,
 121                       const Accessibility_KeySet *keys,
 122                       const Accessibility_ControllerEventMask *mask,
 123                       const Accessibility_KeyEventTypeSeq *typeseq,
 124                       const CORBA_boolean is_system_global,
 125                       CORBA_Environment *ev)
 126 {
 127   DEControllerKeyListener *key_listener = g_new0 (DEControllerKeyListener, 1);
 128   key_listener->listener.object = CORBA_Object_duplicate (l, ev);
 129   key_listener->listener.type = SPI_DEVICE_TYPE_KBD;
 130   key_listener->keys = ORBit_copy_value (keys, TC_Accessibility_KeySet);
 131   key_listener->mask = ORBit_copy_value (mask, TC_Accessibility_ControllerEventMask);
 132   key_listener->typeseq = ORBit_copy_value (typeseq, TC_Accessibility_KeyEventTypeSeq);
 133   key_listener->is_system_global = is_system_global;
 134
 135 #ifdef SPI_DEBUG
 136   g_print ("new listener, with mask %x, is_global %d, keys %p\n",
 137            (unsigned int) key_listener->mask->value,
 138            (int) key_listener->is_system_global,
 139            (void *) key_listener->keys);
 140 #endif
 141   return key_listener;
 142 }
 143
 144 static void
 145 controller_register_device_listener (SpiDeviceEventController *controller,
 146                                      DEControllerListener *listener,
 147                                      CORBA_Environment *ev)
 148 {
 149   Accessibility_ControllerEventMask *mask_ptr = NULL;
 150   DEControllerKeyListener *key_listener;
 151
 152   switch (listener->type) {
 153   case SPI_DEVICE_TYPE_KBD:
 154       key_listener = (DEControllerKeyListener *) listener;
 155       controller->key_listeners = g_list_append (controller->key_listeners, key_listener);
 156       if (key_listener->is_system_global)
 157         {
 158           mask_ptr = (Accessibility_ControllerEventMask *)
 159               g_list_find_custom (controller->keymask_list, (gpointer) key_listener->mask,
 160                                   _eventmask_compare_value);
 161           if (mask_ptr)
 162               ++(mask_ptr->refcount);
 163           else
 164            {
 165               if (key_listener->mask->refcount != (CORBA_unsigned_short) 1)
 166                       fprintf (stderr, "mask initial refcount is not 1!\n");
 167               if (key_listener->mask->value > (CORBA_unsigned_long) 2048)
 168                       fprintf (stderr, "mask value looks invalid (%lu)\n",
 169                                (unsigned long) key_listener->mask->value);
 170               else
 171                       fprintf (stderr, "appending mask with val=%lu\n",
 172                                (unsigned long) key_listener->mask->value);
 173               mask_ptr = Accessibility_ControllerEventMask__alloc();
 174               mask_ptr->value = key_listener->mask->value;
 175               mask_ptr->refcount = (CORBA_unsigned_short) 1;
 176               controller->keymask_list = g_list_append (controller->keymask_list,
 177                                                         (gpointer) mask_ptr);
 178           }
 179         }
 180       break;
 181   case SPI_DEVICE_TYPE_MOUSE:
 182 /*    controller->mouse_listeners = g_list_append (controller->mouse_listeners,
 183                                                    CORBA_Object_duplicate (l, ev));*/
 184
 185 /* possibly this interface should NOT be used for mouse events ? */
 186       break;
 187   }
 188 }
 189
 190 static void
 191 controller_deregister_device_listener (SpiDeviceEventController *controller,
 192                                        DEControllerListener *listener,
 193                                        CORBA_Environment *ev)
 194 {
 195   Accessibility_ControllerEventMask *mask_ptr;
 196   DEControllerKeyListener *key_listener;
 197   GList *list_ptr;
 198   switch (listener->type) {
 199   case SPI_DEVICE_TYPE_KBD:
 200       key_listener = (DEControllerKeyListener *) listener;
 201       list_ptr = g_list_find_custom (controller->key_listeners, listener, _compare_listeners);
 202       /* TODO: need a different custom compare func */
 203       if (list_ptr)
 204           controller->key_listeners = g_list_remove (controller->key_listeners, list_ptr);
 205       list_ptr = (GList *)
 206                   g_list_find_custom (controller->keymask_list, (gpointer) key_listener->mask,
 207                                      _eventmask_compare_value);
 208       if (list_ptr)
 209         {
 210           mask_ptr = (Accessibility_ControllerEventMask *) list_ptr->data;
 211           if (mask_ptr)
 212               --mask_ptr->refcount;
 213           if (!mask_ptr->refcount)
 214             {
 215               controller->keymask_list =
 216                       g_list_remove (controller->keymask_list, mask_ptr);
 217               ;  /* TODO: release any key grabs that are in place for this key mask */
 218             }
 219         }
 220       break;
 221   case SPI_DEVICE_TYPE_MOUSE:
 222 /*    controller->mouse_listeners = g_list_append (controller->mouse_listeners,
 223                                                    CORBA_Object_duplicate (l, ev));*/
 224
 225 /* possibly this interface should NOT be used for mouse events ? */
 226       break;
 227   }
 228 }
 229
 230 static gboolean
 231 _controller_register_with_devices (SpiDeviceEventController *controller)
 232 {
 233   gboolean retval = FALSE;
 234
 235   /* calls to device-specific implementations and routines go here */
 236   /* register with: keyboard hardware code handler */
 237   /* register with: (translated) keystroke handler */
 238 #ifdef SPI_DEBUG
 239   fprintf (stderr, "About to request events on window %ld of display %p\n",
 240            (unsigned long) GDK_ROOT_WINDOW(), GDK_DISPLAY());
 241 #endif
 242   /* We must open a new connection to the server to avoid clashing with the GDK event loop */
 243   display = XOpenDisplay (g_getenv ("DISPLAY"));
 244   root_window = DefaultRootWindow (display);
 245   XSelectInput (display,
 246                 root_window,
 247                 KeyPressMask | KeyReleaseMask);
 248   /* register with: mouse hardware device handler? */
 249   /* register with: mouse event handler */
 250   return retval;
 251 }
 252
 253 static gboolean
 254 key_set_contains_key (Accessibility_KeySet *key_set, Accessibility_KeyStroke *key_event)
 255 {
 256   gint i;
 257   gint len;
 258
 259   /* g_assert (key_set); */
 260   if (!key_set) { g_print ("null key set!"); return TRUE; }
 261
 262   len = key_set->_length;
 263
 264   if (len == 0) /* special case, means "all keys/any key" */
 265     {
 266       return TRUE;
 267     }
 268
 269   for (i=0; i<len; ++i)
 270     {
 271       g_print ("key_set[%d] = %d\n", i, (int) key_set->_buffer[i]);
 272       if (key_set->_buffer[i] == (CORBA_long) key_event->keyID) return TRUE;
 273     }
 274
 275   return TRUE;
 276 }
 277
 278 static gboolean
 279 key_eventtype_seq_contains_event (Accessibility_KeyEventTypeSeq *type_seq,
 280                                   Accessibility_KeyStroke *key_event)
 281 {
 282   gint i;
 283   gint len;
 284
 285   /* g_assert (type_seq); */
 286   if (!type_seq) { g_print ("null type seq!"); return TRUE; }
 287
 288   len = type_seq->_length;
 289
 290   if (len == 0) /* special case, means "all events/any event" */
 291     {
 292       return TRUE;
 293     }
 294
 295   for (i=0; i<len; ++i)
 296     {
 297       g_print ("type_seq[%d] = %d\n", i, (int) type_seq->_buffer[i]);
 298       if (type_seq->_buffer[i] == (CORBA_long) key_event->type) return TRUE;
 299     }
 300
 301   return TRUE;
 302 }
 303
 304 static gboolean
 305 key_event_matches_listener (Accessibility_KeyStroke *key_event,
 306                             DEControllerKeyListener *listener,
 307                             CORBA_boolean is_system_global)
 308 {
 309   if ((key_event->modifiers == (CORBA_unsigned_short) (listener->mask->value & 0xFFFF)) &&
 310        key_set_contains_key (listener->keys, key_event) &&
 311        key_eventtype_seq_contains_event (listener->typeseq, key_event) &&
 312       (is_system_global == listener->is_system_global))
 313     {
 314       return TRUE;
 315     }
 316   else
 317     return FALSE;
 318 }
 319
 320 static gboolean
 321 notify_keylisteners (GList *key_listeners,
 322                      Accessibility_KeyStroke *key_event,
 323                      CORBA_boolean is_system_global,
 324                      CORBA_Environment *ev)
 325 {
 326   int i, n_listeners = g_list_length (key_listeners);
 327   gboolean is_consumed = FALSE;
 328
 329   for (i=0; i<n_listeners && !is_consumed; ++i)
 330     {
 331       Accessibility_KeystrokeListener ls;
 332       DEControllerKeyListener *key_listener = (DEControllerKeyListener *)
 333             g_list_nth_data (key_listeners, i);
 334       ls = (Accessibility_KeystrokeListener) key_listener->listener.object;
 335       if (key_event_matches_listener (key_event, key_listener, is_system_global))
 336         {
 337           if (!CORBA_Object_is_nil(ls, ev))
 338             {
 339               is_consumed = Accessibility_KeystrokeListener_keyEvent (ls, key_event, ev);
 340             }
 341         }
 342       else g_print ("no match for listener %d\n", i);
 343     }
 344   return is_consumed;
 345 }
 346
 347 static gboolean
 348 _check_key_event (SpiDeviceEventController *controller)
 349 {
 350         static gboolean initialized = FALSE;
 351         XEvent *x_event = g_new0 (XEvent, 1);
 352         XKeyEvent *x_key_event;
 353         KeySym keysym;
 354         gboolean is_consumed = FALSE;
 355         Accessibility_KeyStroke key_event;
 356         static CORBA_Environment ev;
 357
 358         if (!initialized)
 359         {
 360           initialized = TRUE;
 361           CORBA_exception_init (&ev);
 362         }
 363
 364         while (XPending(display))
 365           {
 366             XNextEvent (display, x_event);
 367             if (XFilterEvent (x_event, None)) continue;
 368             if (x_event->type == KeyPress)
 369               {
 370                 x_key_event = (XKeyEvent *)x_event;
 371                 keysym = XLookupKeysym (x_key_event, 0);
 372                 key_event.keyID = (CORBA_long)(keysym);
 373                 key_event.keycode = (CORBA_short) x_key_event->keycode;
 374                 key_event.type = Accessibility_KEY_PRESSED;
 375                 key_event.modifiers = (CORBA_unsigned_short)(x_key_event->state);
 376 #ifdef SPI_KEYEVENT_DEBUG
 377             fprintf (stderr,
 378                      "Key %lu pressed (%c), modifiers %d\n",
 379                      (unsigned long) keysym,
 380                      keysym ? (int) keysym : '*',
 381                      (int) x_key_event->state);
 382 #endif
 383 #ifdef SPI_DEBUG
 384             fprintf (stderr, "%s%c",
 385                      (x_key_event->state & Mod1Mask)?"Alt-":"",
 386                      ((x_key_event->state & ShiftMask)^(x_key_event->state & LockMask))?
 387                      g_ascii_toupper (keysym) : g_ascii_tolower (keysym));
 388 #endif /* SPI_DEBUG */
 389               }
 390             else
 391             {
 392 #ifdef SPI_KEYEVENT_DEBUG
 393                     fprintf (stderr, "other event, type %d\n", (int) x_event->type);
 394 #endif
 395             }
 396             /* relay to listeners, and decide whether to consume it or not */
 397             is_consumed = notify_keylisteners (controller->key_listeners, &key_event, CORBA_TRUE, &ev);
 398
 399             if (is_consumed)
 400             {
 401               XAllowEvents (display, AsyncKeyboard, CurrentTime);
 402             }
 403             else
 404             {
 405               XAllowEvents (display, ReplayKeyboard, CurrentTime);
 406             }
 407           }
 408         XUngrabKey (display, AnyKey, AnyModifier, root_window);
 409         return _controller_grab_keyboard (controller);
 410 }
 411
 412 static gboolean
 413 _controller_grab_keyboard (SpiDeviceEventController *controller)
 414 {
 415         GList *maskList = controller->keymask_list;
 416         int i;
 417         int last_mask;
 418         last_mask = g_list_length (maskList);
 419
 420 /*
 421  * masks known to work with default RH 7.1:
 422  * 0 (no mods), LockMask, Mod1Mask, Mod2Mask, ShiftMask,
 423  * ShiftMask|LockMask, Mod1Mask|LockMask, Mod2Mask|LockMask,
 424  * ShiftMask|Mod1Mask, ShiftMask|Mod2Mask, Mod1Mask|Mod2Mask,
 425  * ShiftMask|LockMask|Mod1Mask, ShiftMask|LockMask|Mod2Mask,
 426  *
 427  * ControlMask grabs are broken, must be in use already
 428  */
 429
 430         for (i=0; i < last_mask; ++i)
 431         {
 432                 Accessibility_ControllerEventMask *mask
 433                         = (Accessibility_ControllerEventMask *)g_list_nth_data (maskList, i);
 434                 unsigned long maskVal = 0xFFFFFFFF;
 435                 if (mask) maskVal = (unsigned long) mask->value;
 436 #ifdef SPI_KEYEVENT_DEBUG
 437                 fprintf (stderr, "mask=%lx\n", maskVal);
 438 #endif
 439                 if (!(maskVal & ControlMask))
 440                 {
 441                         XGrabKey (display,
 442                                   AnyKey,
 443                                   maskVal,
 444                                   root_window,
 445                                   True,
 446                                   GrabModeAsync,
 447                                   GrabModeAsync);
 448                         /* TODO: check call for errors and return FALSE if error occurs */
 449                 } else {
 450                         return FALSE; /* can't do control key yet */
 451                 }
 452         }
 453         return TRUE;
 454 }
 455
 456 /*
 457  * Implemented GObject::finalize
 458  */
 459 static void
 460 spi_device_event_controller_object_finalize (GObject *object)
 461 {
 462
 463 #ifdef SPI_DEBUG
 464         fprintf(stderr, "spi_device_event_controller_object_finalize called\n");
 465 #endif
 466         spi_device_event_controller_parent_class->finalize (object);
 467 }
 468
 469 /*
 470  * CORBA Accessibility::DeviceEventController::registerKeystrokeListener
 471  *     method implementation
 472  */
 473 static void
 474 impl_register_keystroke_listener (PortableServer_Servant     servant,
 475                                   const Accessibility_KeystrokeListener l,
 476                                   const Accessibility_KeySet *keys,
 477                                   const Accessibility_ControllerEventMask *mask,
 478                                   const Accessibility_KeyEventTypeSeq *type,
 479                                   const CORBA_boolean is_system_global,
 480                                   CORBA_Environment         *ev)
 481 {
 482         SpiDeviceEventController *controller = SPI_DEVICE_EVENT_CONTROLLER (
 483                 bonobo_object_from_servant (servant));
 484         DEControllerKeyListener *dec_listener;
 485 #ifdef SPI_DEBUG
 486         fprintf (stderr, "registering keystroke listener %p with maskVal %lu\n",
 487                  (void *) l, (unsigned long) mask->value);
 488 #endif
 489         dec_listener = dec_key_listener_new (l, keys, mask, type, is_system_global, ev);
 490         controller_register_device_listener (controller, (DEControllerListener *) dec_listener, ev);
 491 }
 492
 493 /*
 494  * CORBA Accessibility::DeviceEventController::deregisterKeystrokeListener
 495  *     method implementation
 496  */
 497 static void
 498 impl_deregister_keystroke_listener (PortableServer_Servant     servant,
 499                                     const Accessibility_KeystrokeListener l,
 500                                     const Accessibility_KeySet *keys,
 501                                     const Accessibility_ControllerEventMask *mask,
 502                                     const Accessibility_KeyEventTypeSeq *type,
 503                                     const CORBA_boolean is_system_global,
 504                                     CORBA_Environment         *ev)
 505 {
 506         SpiDeviceEventController *controller = SPI_DEVICE_EVENT_CONTROLLER (
 507                 bonobo_object_from_servant (servant));
 508         DEControllerKeyListener *key_listener = dec_key_listener_new (l,
 509                                                                       keys,
 510                                                                       mask,
 511                                                                       type,
 512                                                                       is_system_global,
 513                                                                       ev);
 514 #ifdef SPI_DEBUG
 515         fprintf (stderr, "deregistering keystroke listener %p with maskVal %lu\n",
 516                  (void *) l, (unsigned long) mask->value);
 517 #endif
 518         controller_deregister_device_listener(controller,
 519                                               (DEControllerListener *) key_listener,
 520                                               ev);
 521 }
 522
 523 /*
 524  * CORBA Accessibility::DeviceEventController::registerMouseListener
 525  *     method implementation
 526  */
 527 /*
 528 static void
 529 impl_register_mouse_listener (PortableServer_Servant     servant,
 530                               const Accessibility_MouseListener *l,
 531                               CORBA_Environment         *ev)
 532 {
 533         SpiDeviceEventController *controller = SPI_DEVICE_EVENT_CONTROLLER (
 534                 bonobo_object_from_servant (servant));
 535 #ifdef SPI_DEBUG
 536         fprintf (stderr, "registering mouse listener %p\n", l);
 537 #endif
 538         controller_register_device_listener(controller, DEVICE_TYPE_MOUSE, l, keys, mask, ev);
 539 }
 540 */
 541
 542 static KeyCode
 543 keycode_for_keysym (long keysym)
 544 {
 545   return XKeysymToKeycode (display, (KeySym) keysym);
 546 }
 547
 548 /*
 549  * CORBA Accessibility::DeviceEventController::registerKeystrokeListener
 550  *     method implementation
 551  */
 552 static void
 553 impl_generate_key_event (PortableServer_Servant     servant,
 554                          const CORBA_long           keycode,
 555                          const Accessibility_KeySynthType synth_type,
 556                          CORBA_Environment          *ev)
 557 {
 558         long key_synth_code;
 559 #ifdef SPI_DEBUG
 560         fprintf (stderr, "synthesizing keystroke %ld\n", (long) keycode);
 561 #endif
 562         /* TODO: hide/wrap/remove X dependency */
 563
 564         /* TODO: be accessX-savvy so that keyrelease occurs after sufficient timeout */
 565
 566         /*
 567          * TODO: when initializing, query for XTest extension before using,
 568          * and fall back to XSendEvent() if XTest is not available.
 569          */
 570
 571         switch (synth_type)
 572         {
 573         case Accessibility_KEY_PRESS:
 574                 XTestFakeKeyEvent (GDK_DISPLAY(), (unsigned int) keycode, True, CurrentTime);
 575                 break;
 576         case Accessibility_KEY_PRESSRELEASE:
 577                 XTestFakeKeyEvent (GDK_DISPLAY(), (unsigned int) keycode, True, CurrentTime);
 578         case Accessibility_KEY_RELEASE:
 579                 XTestFakeKeyEvent (GDK_DISPLAY(), (unsigned int) keycode, False, CurrentTime);
 580                 break;
 581         case Accessibility_KEY_SYM:
 582                 key_synth_code = keycode_for_keysym (keycode);
 583                 XTestFakeKeyEvent (GDK_DISPLAY(), (unsigned int) key_synth_code, True, CurrentTime);
 584                 XTestFakeKeyEvent (GDK_DISPLAY(), (unsigned int) key_synth_code, False, CurrentTime);
 585                 break;
 586         }
 587 }
 588
 589 /* Accessibility::DeviceEventController::generateMouseEvent */
 590 static void
 591 impl_generate_mouse_event (PortableServer_Servant servant,
 592                            const CORBA_long       x,
 593                            const CORBA_long       y,
 594                            const CORBA_char      *eventName,
 595                            CORBA_Environment     *ev)
 596 {
 597 #ifdef SPI_DEBUG
 598   fprintf (stderr, "generating mouse %s event at %ld, %ld\n", eventName, x, y);
 599 #endif
 600 }
 601
 602 /* Accessibility::DeviceEventController::notifyListenersSync */
 603 static CORBA_boolean
 604 impl_notify_listeners_sync(PortableServer_Servant     servant,
 605                            const Accessibility_DeviceEvent *event,
 606                            CORBA_Environment         *ev)
 607 {
 608   SpiDeviceEventController *controller = SPI_DEVICE_EVENT_CONTROLLER (
 609                                          bonobo_object_from_servant (servant));
 610   Accessibility_KeyStroke *key_event = (Accessibility_KeyStroke *) event;
 611 #ifdef SPI_DEBUG
 612   g_print ("notifying listeners synchronously: controller %x, event id %d\n",
 613            (void *) controller, (int) event->eventID);
 614 #endif
 615   return (notify_keylisteners (controller->key_listeners, key_event, CORBA_FALSE, ev) ?
 616           CORBA_TRUE : CORBA_FALSE);
 617 }
 618
 619 /* Accessibility::DeviceEventController::notifyListenersAsync */
 620 static void
 621 impl_notify_listeners_async (PortableServer_Servant     servant,
 622                              const Accessibility_DeviceEvent *event,
 623                              CORBA_Environment         *ev)
 624 {
 625   SpiDeviceEventController *controller = SPI_DEVICE_EVENT_CONTROLLER(
 626                                          bonobo_object_from_servant (servant));
 627   Accessibility_KeyStroke *key_event = (Accessibility_KeyStroke *) event;
 628 #ifdef SPI_DEBUG
 629   fprintf (stderr, "notifying listeners asynchronously\n");
 630 #endif
 631   notify_keylisteners (controller->key_listeners, key_event, CORBA_FALSE, ev);
 632 }
 633
 634 static void
 635 spi_device_event_controller_class_init (SpiDeviceEventControllerClass *klass)
 636 {
 637         GObjectClass * object_class = (GObjectClass *) klass;
 638         POA_Accessibility_DeviceEventController__epv *epv = &klass->epv;
 639         spi_device_event_controller_parent_class = g_type_class_peek_parent (klass);
 640
 641         object_class->finalize = spi_device_event_controller_object_finalize;
 642
 643         epv->registerKeystrokeListener = impl_register_keystroke_listener;
 644         epv->deregisterKeystrokeListener = impl_deregister_keystroke_listener;
 645 /*        epv->registerMouseListener = impl_register_mouse_listener; */
 646         epv->generateKeyEvent = impl_generate_key_event;
 647         epv->generateMouseEvent = impl_generate_mouse_event;
 648         epv->notifyListenersSync = impl_notify_listeners_sync;
 649         epv->notifyListenersAsync = impl_notify_listeners_async;
 650         klass->check_key_event = _check_key_event;
 651 }
 652
 653 static void
 654 spi_device_event_controller_init (SpiDeviceEventController *device_event_controller)
 655 {
 656   device_event_controller->key_listeners = NULL;
 657   device_event_controller->mouse_listeners = NULL;
 658   device_event_controller->keymask_list = NULL;
 659   kbd_registered = _controller_register_with_devices (device_event_controller);
 660 }
 661
 662 gboolean
 663 spi_device_event_controller_check_key_event (SpiDeviceEventController *controller)
 664 {
 665         SpiDeviceEventControllerClass *klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);
 666         if (klass->check_key_event)
 667                 return (klass->check_key_event) (controller);
 668         return FALSE;
 669 }
 670
 671 SpiDeviceEventController *
 672 spi_device_event_controller_new (void *registryp)
 673 {
 674   BonoboObject *registry = (BonoboObject *) registryp;
 675   SpiDeviceEventController *retval = g_object_new (
 676           SPI_DEVICE_EVENT_CONTROLLER_TYPE, NULL);
 677   retval->registry = registry;
 678   bonobo_object_ref (registry);
 679   return retval;
 680 }
 681
 682 BONOBO_TYPE_FUNC_FULL (SpiDeviceEventController,
 683                        Accessibility_DeviceEventController,
 684                        PARENT_TYPE,
 685                        spi_device_event_controller);
 686