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 = keys;
 131   key_listener->mask = mask;
 132   key_listener->is_system_global = is_system_global;
 133
 134   return key_listener;
 135 }
 136
 137 static void
 138 controller_register_device_listener (SpiDeviceEventController *controller,
 139                                      DEControllerListener *listener,
 140                                      CORBA_Environment *ev)
 141 {
 142   Accessibility_ControllerEventMask *mask_ptr = NULL;
 143   DEControllerKeyListener *key_listener;
 144
 145   switch (listener->type) {
 146   case SPI_DEVICE_TYPE_KBD:
 147       key_listener = (DEControllerKeyListener *) listener;
 148       controller->key_listeners = g_list_append (controller->key_listeners, key_listener);
 149
 150       mask_ptr = (Accessibility_ControllerEventMask *)
 151               g_list_find_custom (controller->keymask_list, (gpointer) key_listener->mask,
 152                                   _eventmask_compare_value);
 153       if (mask_ptr)
 154               ++(mask_ptr->refcount);
 155       else
 156       {
 157               if (key_listener->mask->refcount != (CORBA_unsigned_short) 1)
 158                       fprintf (stderr, "mask initial refcount is not 1!\n");
 159               if (key_listener->mask->value > (CORBA_unsigned_long) 2048)
 160                       fprintf (stderr, "mask value looks invalid (%lu)\n",
 161                                (unsigned long) key_listener->mask->value);
 162               else
 163                       fprintf (stderr, "appending mask with val=%lu\n",
 164                                (unsigned long) key_listener->mask->value);
 165               mask_ptr = Accessibility_ControllerEventMask__alloc();
 166               mask_ptr->value = key_listener->mask->value;
 167               mask_ptr->refcount = (CORBA_unsigned_short) 1;
 168               controller->keymask_list = g_list_append (controller->keymask_list,
 169                                                         (gpointer) mask_ptr);
 170       }
 171       break;
 172   case SPI_DEVICE_TYPE_MOUSE:
 173 /*    controller->mouse_listeners = g_list_append (controller->mouse_listeners,
 174                                                    CORBA_Object_duplicate (l, ev));*/
 175
 176 /* possibly this interface should NOT be used for mouse events ? */
 177       break;
 178   }
 179 }
 180
 181 static void
 182 controller_deregister_device_listener (SpiDeviceEventController *controller,
 183                                        DEControllerListener *listener,
 184                                        CORBA_Environment *ev)
 185 {
 186   Accessibility_ControllerEventMask *mask_ptr;
 187   DEControllerKeyListener *key_listener;
 188   GList *list_ptr;
 189   switch (listener->type) {
 190   case SPI_DEVICE_TYPE_KBD:
 191       key_listener = (DEControllerKeyListener *) listener;
 192       list_ptr = g_list_find_custom (controller->key_listeners, listener, _compare_listeners);
 193       /* TODO: need a different custom compare func */
 194       if (list_ptr)
 195           controller->key_listeners = g_list_remove (controller->key_listeners, list_ptr);
 196       list_ptr = (GList *)
 197                   g_list_find_custom (controller->keymask_list, (gpointer) key_listener->mask,
 198                                      _eventmask_compare_value);
 199       if (list_ptr)
 200         {
 201           mask_ptr = (Accessibility_ControllerEventMask *) list_ptr->data;
 202           if (mask_ptr)
 203               --mask_ptr->refcount;
 204           if (!mask_ptr->refcount)
 205             {
 206               controller->keymask_list =
 207                       g_list_remove (controller->keymask_list, mask_ptr);
 208               ;  /* TODO: release any key grabs that are in place for this key mask */
 209             }
 210         }
 211       break;
 212   case SPI_DEVICE_TYPE_MOUSE:
 213 /*    controller->mouse_listeners = g_list_append (controller->mouse_listeners,
 214                                                    CORBA_Object_duplicate (l, ev));*/
 215
 216 /* possibly this interface should NOT be used for mouse events ? */
 217       break;
 218   }
 219 }
 220
 221 static gboolean
 222 _controller_register_with_devices (SpiDeviceEventController *controller)
 223 {
 224   gboolean retval = FALSE;
 225
 226   /* calls to device-specific implementations and routines go here */
 227   /* register with: keyboard hardware code handler */
 228   /* register with: (translated) keystroke handler */
 229 #ifdef SPI_DEBUG
 230   fprintf (stderr, "About to request events on window %ld of display %p\n",
 231            (unsigned long) GDK_ROOT_WINDOW(), GDK_DISPLAY());
 232 #endif
 233   /* We must open a new connection to the server to avoid clashing with the GDK event loop */
 234   display = XOpenDisplay (g_getenv ("DISPLAY"));
 235   root_window = DefaultRootWindow (display);
 236   XSelectInput (display,
 237                 root_window,
 238                 KeyPressMask | KeyReleaseMask);
 239   /* register with: mouse hardware device handler? */
 240   /* register with: mouse event handler */
 241   return retval;
 242 }
 243
 244
 245 static gboolean
 246 notify_keylisteners (GList *key_listeners, Accessibility_KeyStroke *key_event, CORBA_Environment *ev)
 247 {
 248   int i, n_listeners = g_list_length (key_listeners);
 249   gboolean is_consumed = FALSE;
 250   for (i=0; i<n_listeners && !is_consumed; ++i)
 251     {
 252       Accessibility_KeystrokeListener ls;
 253       ls = (Accessibility_KeystrokeListener)
 254             g_list_nth_data (key_listeners, i);
 255       if (!CORBA_Object_is_nil(ls, ev))
 256         {
 257             is_consumed = Accessibility_KeystrokeListener_keyEvent (ls, key_event, ev);
 258         }
 259     }
 260   return is_consumed;
 261 }
 262
 263
 264 static gboolean
 265 _check_key_event (SpiDeviceEventController *controller)
 266 {
 267         static gboolean initialized = FALSE;
 268         XEvent *x_event = g_new0 (XEvent, 1);
 269         XKeyEvent *x_key_event;
 270         KeySym keysym;
 271         gboolean is_consumed = FALSE;
 272         Accessibility_KeyStroke key_event;
 273         static CORBA_Environment ev;
 274
 275         if (!initialized)
 276         {
 277           initialized = TRUE;
 278           CORBA_exception_init (&ev);
 279         }
 280
 281         while (XPending(display))
 282           {
 283             XNextEvent (display, x_event);
 284             if (XFilterEvent (x_event, None)) continue;
 285             if (x_event->type == KeyPress)
 286               {
 287                 x_key_event = (XKeyEvent *)x_event;
 288                 keysym = XLookupKeysym (x_key_event, 0);
 289                 key_event.keyID = (CORBA_long)(keysym);
 290                 key_event.keycode = (CORBA_short) x_key_event->keycode;
 291                 key_event.type = Accessibility_KEY_PRESSED;
 292                 key_event.modifiers = (CORBA_unsigned_short)(x_key_event->state);
 293 #ifdef SPI_KEYEVENT_DEBUG
 294             fprintf (stderr,
 295                      "Key %lu pressed (%c), modifiers %d\n",
 296                      (unsigned long) keysym,
 297                      keysym ? (int) keysym : '*',
 298                      (int) x_key_event->state);
 299 #endif
 300 #ifdef SPI_DEBUG
 301             fprintf (stderr, "%s%c",
 302                      (x_key_event->state & Mod1Mask)?"Alt-":"",
 303                      ((x_key_event->state & ShiftMask)^(x_key_event->state & LockMask))?
 304                      g_ascii_toupper (keysym) : g_ascii_tolower (keysym));
 305 #endif /* SPI_DEBUG */
 306               }
 307             else
 308             {
 309 #ifdef SPI_KEYEVENT_DEBUG
 310                     fprintf (stderr, "other event, type %d\n", (int) x_event->type);
 311 #endif
 312             }
 313             /* relay to listeners, and decide whether to consume it or not */
 314             is_consumed = notify_keylisteners (controller->key_listeners, &key_event, &ev);
 315
 316             if (is_consumed)
 317             {
 318               XAllowEvents (display, SyncKeyboard, CurrentTime);
 319             }
 320             else
 321             {
 322               XAllowEvents (display, ReplayKeyboard, CurrentTime);
 323             }
 324           }
 325         XUngrabKey (display, AnyKey, AnyModifier, root_window);
 326         return _controller_grab_keyboard (controller);
 327 }
 328
 329 static gboolean
 330 _controller_grab_keyboard (SpiDeviceEventController *controller)
 331 {
 332         GList *maskList = controller->keymask_list;
 333         int i;
 334         int last_mask;
 335         last_mask = g_list_length (maskList);
 336
 337 /*
 338  * masks known to work with default RH 7.1:
 339  * 0 (no mods), LockMask, Mod1Mask, Mod2Mask, ShiftMask,
 340  * ShiftMask|LockMask, Mod1Mask|LockMask, Mod2Mask|LockMask,
 341  * ShiftMask|Mod1Mask, ShiftMask|Mod2Mask, Mod1Mask|Mod2Mask,
 342  * ShiftMask|LockMask|Mod1Mask, ShiftMask|LockMask|Mod2Mask,
 343  *
 344  * ControlMask grabs are broken, must be in use already
 345  */
 346
 347         for (i=0; i < last_mask; ++i)
 348         {
 349                 Accessibility_ControllerEventMask *mask
 350                         = (Accessibility_ControllerEventMask *)g_list_nth_data (maskList, i);
 351                 unsigned long maskVal = 0xFFFFFFFF;
 352                 if (mask) maskVal = (unsigned long) mask->value;
 353 #ifdef SPI_KEYEVENT_DEBUG
 354                 fprintf (stderr, "mask=%lx\n", maskVal);
 355 #endif
 356                 if (!(maskVal & ControlMask))
 357                 {
 358                         XGrabKey (display,
 359                                   AnyKey,
 360                                   maskVal,
 361                                   root_window,
 362                                   True,
 363                                   GrabModeAsync,
 364                                   GrabModeSync);
 365                         /* TODO: check call for errors and return FALSE if error occurs */
 366                 } else {
 367                         return FALSE; /* can't do control key yet */
 368                 }
 369         }
 370         return TRUE;
 371 }
 372
 373 /*
 374  * Implemented GObject::finalize
 375  */
 376 static void
 377 spi_device_event_controller_object_finalize (GObject *object)
 378 {
 379
 380 #ifdef SPI_DEBUG
 381         fprintf(stderr, "spi_device_event_controller_object_finalize called\n");
 382 #endif
 383         spi_device_event_controller_parent_class->finalize (object);
 384 }
 385
 386 /*
 387  * CORBA Accessibility::DeviceEventController::registerKeystrokeListener
 388  *     method implementation
 389  */
 390 static void
 391 impl_register_keystroke_listener (PortableServer_Servant     servant,
 392                                   const Accessibility_KeystrokeListener l,
 393                                   const Accessibility_KeySet *keys,
 394                                   const Accessibility_ControllerEventMask *mask,
 395                                   const Accessibility_KeyEventTypeSeq *type,
 396                                   const CORBA_boolean is_system_global,
 397                                   CORBA_Environment         *ev)
 398 {
 399         SpiDeviceEventController *controller = SPI_DEVICE_EVENT_CONTROLLER (
 400                 bonobo_object_from_servant (servant));
 401         DEControllerKeyListener *dec_listener;
 402 #ifdef SPI_DEBUG
 403         fprintf (stderr, "registering keystroke listener %p with maskVal %lu\n",
 404                  (void *) l, (unsigned long) mask->value);
 405 #endif
 406         dec_listener = dec_key_listener_new (l, keys, mask, type, is_system_global, ev);
 407         controller_register_device_listener (controller, (DEControllerListener *) dec_listener, ev);
 408 }
 409
 410 /*
 411  * CORBA Accessibility::DeviceEventController::deregisterKeystrokeListener
 412  *     method implementation
 413  */
 414 static void
 415 impl_deregister_keystroke_listener (PortableServer_Servant     servant,
 416                                     const Accessibility_KeystrokeListener l,
 417                                     const Accessibility_KeySet *keys,
 418                                     const Accessibility_ControllerEventMask *mask,
 419                                     const Accessibility_KeyEventTypeSeq *type,
 420                                     const CORBA_boolean is_system_global,
 421                                     CORBA_Environment         *ev)
 422 {
 423         SpiDeviceEventController *controller = SPI_DEVICE_EVENT_CONTROLLER (
 424                 bonobo_object_from_servant (servant));
 425         DEControllerKeyListener *key_listener = dec_key_listener_new (l,
 426                                                                       keys,
 427                                                                       mask,
 428                                                                       type,
 429                                                                       is_system_global,
 430                                                                       ev);
 431 #ifdef SPI_DEBUG
 432         fprintf (stderr, "deregistering keystroke listener %p with maskVal %lu\n",
 433                  (void *) l, (unsigned long) mask->value);
 434 #endif
 435         controller_deregister_device_listener(controller,
 436                                               (DEControllerListener *) key_listener,
 437                                               ev);
 438 }
 439
 440 /*
 441  * CORBA Accessibility::DeviceEventController::registerMouseListener
 442  *     method implementation
 443  */
 444 /*
 445 static void
 446 impl_register_mouse_listener (PortableServer_Servant     servant,
 447                               const Accessibility_MouseListener *l,
 448                               CORBA_Environment         *ev)
 449 {
 450         SpiDeviceEventController *controller = SPI_DEVICE_EVENT_CONTROLLER (
 451                 bonobo_object_from_servant (servant));
 452 #ifdef SPI_DEBUG
 453         fprintf (stderr, "registering mouse listener %p\n", l);
 454 #endif
 455         controller_register_device_listener(controller, DEVICE_TYPE_MOUSE, l, keys, mask, ev);
 456 }
 457 */
 458
 459 static KeyCode
 460 keycode_for_keysym (long keysym)
 461 {
 462   return XKeysymToKeycode (display, (KeySym) keysym);
 463 }
 464
 465 /*
 466  * CORBA Accessibility::DeviceEventController::registerKeystrokeListener
 467  *     method implementation
 468  */
 469 static void
 470 impl_generate_key_event (PortableServer_Servant     servant,
 471                          const CORBA_long           keycode,
 472                          const Accessibility_KeySynthType synth_type,
 473                          CORBA_Environment          *ev)
 474 {
 475         long key_synth_code;
 476 #ifdef SPI_DEBUG
 477         fprintf (stderr, "synthesizing keystroke %ld\n", (long) keycode);
 478 #endif
 479         /* TODO: hide/wrap/remove X dependency */
 480
 481         /* TODO: be accessX-savvy so that keyrelease occurs after sufficient timeout */
 482
 483         /*
 484          * TODO: when initializing, query for XTest extension before using,
 485          * and fall back to XSendEvent() if XTest is not available.
 486          */
 487
 488         switch (synth_type)
 489         {
 490         case Accessibility_KEY_PRESS:
 491                 XTestFakeKeyEvent (GDK_DISPLAY(), (unsigned int) keycode, True, CurrentTime);
 492                 break;
 493         case Accessibility_KEY_PRESSRELEASE:
 494                 XTestFakeKeyEvent (GDK_DISPLAY(), (unsigned int) keycode, True, CurrentTime);
 495         case Accessibility_KEY_RELEASE:
 496                 XTestFakeKeyEvent (GDK_DISPLAY(), (unsigned int) keycode, False, CurrentTime);
 497                 break;
 498         case Accessibility_KEY_SYM:
 499                 key_synth_code = keycode_for_keysym (keycode);
 500                 XTestFakeKeyEvent (GDK_DISPLAY(), (unsigned int) key_synth_code, True, CurrentTime);
 501                 XTestFakeKeyEvent (GDK_DISPLAY(), (unsigned int) key_synth_code, False, CurrentTime);
 502                 break;
 503         }
 504 }
 505
 506 /*
 507  * CORBA Accessibility::DeviceEventController::generateMouseEvent
 508  *     method implementation
 509  */
 510 static void
 511 impl_generate_mouse_event (PortableServer_Servant servant,
 512                            const CORBA_long       x,
 513                            const CORBA_long       y,
 514                            const CORBA_char      *eventName,
 515                            CORBA_Environment     *ev)
 516 {
 517 #ifdef SPI_DEBUG
 518         fprintf (stderr, "generating mouse %s event at %ld, %ld\n", eventName, x, y);
 519 #endif
 520 }
 521
 522 static void
 523 spi_device_event_controller_class_init (SpiDeviceEventControllerClass *klass)
 524 {
 525         GObjectClass * object_class = (GObjectClass *) klass;
 526         POA_Accessibility_DeviceEventController__epv *epv = &klass->epv;
 527         spi_device_event_controller_parent_class = g_type_class_peek_parent (klass);
 528
 529         object_class->finalize = spi_device_event_controller_object_finalize;
 530
 531         epv->registerKeystrokeListener = impl_register_keystroke_listener;
 532         epv->deregisterKeystrokeListener = impl_deregister_keystroke_listener;
 533 /*        epv->registerMouseListener = impl_register_mouse_listener; */
 534         epv->generateKeyEvent = impl_generate_key_event;
 535         epv->generateMouseEvent = impl_generate_mouse_event;
 536         klass->check_key_event = _check_key_event;
 537 }
 538
 539 static void
 540 spi_device_event_controller_init (SpiDeviceEventController *device_event_controller)
 541 {
 542   device_event_controller->key_listeners = NULL;
 543   device_event_controller->mouse_listeners = NULL;
 544   device_event_controller->keymask_list = NULL;
 545   kbd_registered = _controller_register_with_devices (device_event_controller);
 546 }
 547
 548 gboolean
 549 spi_device_event_controller_check_key_event (SpiDeviceEventController *controller)
 550 {
 551         SpiDeviceEventControllerClass *klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);
 552         if (klass->check_key_event)
 553                 return (klass->check_key_event) (controller);
 554         return FALSE;
 555 }
 556
 557 SpiDeviceEventController *
 558 spi_device_event_controller_new (void *registryp)
 559 {
 560   SpiRegistry *registry = SPI_REGISTRY (registryp);
 561   SpiDeviceEventController *retval = g_object_new (
 562           SPI_DEVICE_EVENT_CONTROLLER_TYPE, NULL);
 563   retval->registry = registry;
 564   bonobo_object_ref (registry);
 565   return retval;
 566 }
 567
 568 BONOBO_TYPE_FUNC_FULL (SpiDeviceEventController,
 569                        Accessibility_DeviceEventController,
 570                        PARENT_TYPE,
 571                        spi_device_event_controller);
 572