registryd/deviceeventcontroller.c

   1 /* AT-SPI - Assistive Technology Service Provider Interface
   2  *
   3  * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
   4  *
   5  * Copyright 2001, 2003 Sun Microsystems Inc.,
   6  * Copyright 2001, 2002 Ximian, Inc.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 /* deviceeventcontroller.c: implement the DeviceEventController interface */
  25
  26 #include <config.h>
  27
  28 #undef  SPI_XKB_DEBUG
  29 #undef  SPI_DEBUG
  30 #undef  SPI_KEYEVENT_DEBUG
  31
  32 #include <string.h>
  33 #include <ctype.h>
  34 #include <stdio.h>
  35 #include <sys/time.h>
  36 #include <bonobo/bonobo-exception.h>
  37
  38 #include <X11/Xlib.h>
  39 #include <X11/extensions/XTest.h>
  40 #include <X11/XKBlib.h>
  41 #define XK_MISCELLANY
  42 #include <X11/keysymdef.h>
  43 #include <gdk/gdk.h>
  44 #include <gdk/gdkx.h> /* TODO: hide dependency (wrap in single porting file) */
  45 #include <gdk/gdkkeysyms.h>
  46 #include <gdk/gdkwindow.h>
  47
  48 #include "../libspi/spi-private.h"
  49 #include "deviceeventcontroller.h"
  50
  51 /* Our parent Gtk object type */
  52 #define PARENT_TYPE BONOBO_TYPE_OBJECT
  53
  54 /* A pointer to our parent object class */
  55 static GObjectClass *spi_device_event_controller_parent_class;
  56 static int spi_error_code = 0;
  57 static GdkPoint last_mouse_pos_static = {0, 0};
  58 static GdkPoint *last_mouse_pos = &last_mouse_pos_static;
  59 static unsigned int mouse_mask_state = 0;
  60 static unsigned int mouse_button_mask =
  61   Button1Mask | Button2Mask | Button3Mask | Button4Mask | Button5Mask;
  62 static unsigned int key_modifier_mask =
  63   Mod1Mask | Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask | ShiftMask | LockMask | ControlMask | SPI_KEYMASK_NUMLOCK;
  64 static unsigned int _numlock_physical_mask = Mod2Mask; /* a guess, will be reset */
  65
  66 static GQuark spi_dec_private_quark = 0;
  67
  68 int (*x_default_error_handler) (Display *display, XErrorEvent *error_event);
  69
  70 typedef enum {
  71   SPI_DEVICE_TYPE_KBD,
  72   SPI_DEVICE_TYPE_MOUSE,
  73   SPI_DEVICE_TYPE_LAST_DEFINED
  74 } SpiDeviceTypeCategory;
  75
  76 typedef struct {
  77   guint                             ref_count : 30;
  78   guint                             pending_add : 1;
  79   guint                             pending_remove : 1;
  80
  81   Accessibility_ControllerEventMask mod_mask;
  82   CORBA_unsigned_long               key_val;  /* KeyCode */
  83 } DEControllerGrabMask;
  84
  85 typedef struct {
  86   CORBA_Object          object;
  87   SpiDeviceTypeCategory type;
  88   Accessibility_EventTypeSeq    *typeseq;
  89 } DEControllerListener;
  90
  91 typedef struct {
  92   DEControllerListener listener;
  93
  94   Accessibility_KeySet             *keys;
  95   Accessibility_ControllerEventMask mask;
  96   Accessibility_EventListenerMode  *mode;
  97 } DEControllerKeyListener;
  98
  99 typedef struct {
 100   unsigned int last_press_keycode;
 101   unsigned int last_release_keycode;
 102   struct timeval last_press_time;
 103   struct timeval last_release_time;
 104   int have_xkb;
 105   int xkb_major_extension_opcode;
 106   int xkb_base_event_code;
 107   int xkb_base_error_code;
 108   unsigned int xkb_latch_mask;
 109   unsigned int pending_xkb_mod_relatch_mask;
 110   XkbDescPtr xkb_desc;
 111 } DEControllerPrivateData;
 112
 113 static void     spi_controller_register_with_devices          (SpiDEController           *controller);
 114 static gboolean spi_controller_update_key_grabs               (SpiDEController           *controller,
 115                                                                Accessibility_DeviceEvent *recv);
 116 static gboolean spi_controller_register_device_listener       (SpiDEController           *controller,
 117                                                                DEControllerListener      *l,
 118                                                                CORBA_Environment         *ev);
 119 static void     spi_device_event_controller_forward_key_event (SpiDEController           *controller,
 120                                                                const XEvent              *event);
 121 static void     spi_deregister_controller_device_listener (SpiDEController            *controller,
 122                                                            DEControllerListener *listener,
 123                                                            CORBA_Environment          *ev);
 124 static void     spi_deregister_controller_key_listener (SpiDEController         *controller,
 125                                                         DEControllerKeyListener *key_listener,
 126                                                         CORBA_Environment       *ev);
 127 static gboolean spi_controller_notify_mouselisteners (SpiDEController                 *controller,
 128                                                       const Accessibility_DeviceEvent *event,
 129                                                       CORBA_Environment               *ev);
 130
 131 static gboolean spi_eventtype_seq_contains_event (Accessibility_EventTypeSeq      *type_seq,
 132                                                   const Accessibility_DeviceEvent *event);
 133 static gboolean spi_clear_error_state (void);
 134 static gboolean spi_dec_poll_mouse_moved (gpointer data);
 135 static gboolean spi_dec_poll_mouse_moving (gpointer data);
 136 static gboolean spi_dec_poll_mouse_idle (gpointer data);
 137
 138 #define spi_get_display() GDK_DISPLAY()
 139
 140 /* Private methods */
 141
 142 static unsigned int
 143 keysym_mod_mask (KeySym keysym, KeyCode keycode)
 144 {
 145         /* we really should use XKB and look directly at the keymap */
 146         /* this is very inelegant */
 147         Display *display = spi_get_display ();
 148         unsigned int mods_rtn = 0;
 149         unsigned int retval = 0;
 150         KeySym sym_rtn;
 151
 152         if (XkbLookupKeySym (display, keycode, 0, &mods_rtn, &sym_rtn) &&
 153             (sym_rtn == keysym)) {
 154                 retval = 0;
 155         }
 156         else if (XkbLookupKeySym (display, keycode, ShiftMask, &mods_rtn, &sym_rtn) &&
 157                  (sym_rtn == keysym)) {
 158                 retval = ShiftMask;
 159         }
 160         else if (XkbLookupKeySym (display, keycode, Mod2Mask, &mods_rtn, &sym_rtn) &&
 161                  (sym_rtn == keysym)) {
 162                 retval = Mod2Mask;
 163         }
 164         else if (XkbLookupKeySym (display, keycode, Mod3Mask, &mods_rtn, &sym_rtn) &&
 165                  (sym_rtn == keysym)) {
 166                 retval = Mod3Mask;
 167         }
 168         else if (XkbLookupKeySym (display, keycode,
 169                                   ShiftMask | Mod2Mask, &mods_rtn, &sym_rtn) &&
 170                  (sym_rtn == keysym)) {
 171                 retval = (Mod2Mask | ShiftMask);
 172         }
 173         else if (XkbLookupKeySym (display, keycode,
 174                                   ShiftMask | Mod3Mask, &mods_rtn, &sym_rtn) &&
 175                  (sym_rtn == keysym)) {
 176                 retval = (Mod3Mask | ShiftMask);
 177         }
 178         else if (XkbLookupKeySym (display, keycode,
 179                                   ShiftMask | Mod4Mask, &mods_rtn, &sym_rtn) &&
 180                  (sym_rtn == keysym)) {
 181                 retval = (Mod4Mask | ShiftMask);
 182         }
 183         else
 184                 retval = 0xFFFF;
 185         return retval;
 186 }
 187
 188 static KeyCode
 189 keycode_for_keysym (long keysym, unsigned int *modmask)
 190 {
 191         KeyCode keycode = 0;
 192         keycode = XKeysymToKeycode (spi_get_display (), (KeySym) keysym);
 193         if (modmask)
 194                 *modmask = keysym_mod_mask (keysym, keycode);
 195         return keycode;
 196 }
 197
 198 static DEControllerGrabMask *
 199 spi_grab_mask_clone (DEControllerGrabMask *grab_mask)
 200 {
 201   DEControllerGrabMask *clone = g_new (DEControllerGrabMask, 1);
 202
 203   memcpy (clone, grab_mask, sizeof (DEControllerGrabMask));
 204
 205   clone->ref_count = 1;
 206   clone->pending_add = TRUE;
 207   clone->pending_remove = FALSE;
 208
 209   return clone;
 210 }
 211
 212 static void
 213 spi_grab_mask_free (DEControllerGrabMask *grab_mask)
 214 {
 215   g_free (grab_mask);
 216 }
 217
 218 static gint
 219 spi_grab_mask_compare_values (gconstpointer p1, gconstpointer p2)
 220 {
 221   DEControllerGrabMask *l1 = (DEControllerGrabMask *) p1;
 222   DEControllerGrabMask *l2 = (DEControllerGrabMask *) p2;
 223
 224   if (p1 == p2)
 225     {
 226       return 0;
 227     }
 228   else
 229     {
 230       return ((l1->mod_mask != l2->mod_mask) || (l1->key_val != l2->key_val));
 231     }
 232 }
 233
 234 static void
 235 spi_dec_set_unlatch_pending (SpiDEController *controller, unsigned mask)
 236 {
 237   DEControllerPrivateData *priv =
 238     g_object_get_qdata (G_OBJECT (controller), spi_dec_private_quark);
 239 #ifdef SPI_XKB_DEBUG
 240   if (priv->xkb_latch_mask) fprintf (stderr, "unlatch pending! %x\n",
 241                                      priv->xkb_latch_mask);
 242 #endif
 243   priv->pending_xkb_mod_relatch_mask |= priv->xkb_latch_mask;
 244 }
 245
 246 static void
 247 spi_dec_clear_unlatch_pending (SpiDEController *controller)
 248 {
 249   DEControllerPrivateData *priv =
 250     g_object_get_qdata (G_OBJECT (controller), spi_dec_private_quark);
 251   priv->xkb_latch_mask = 0;
 252 }
 253
 254 static gboolean
 255 spi_dec_button_update_and_emit (SpiDEController *controller,
 256                                 guint mask_return)
 257 {
 258   CORBA_Environment ev;
 259   Accessibility_Event e;
 260   Accessibility_DeviceEvent mouse_e;
 261   gchar event_name[24];
 262   gboolean is_consumed = FALSE;
 263
 264   if ((mask_return & mouse_button_mask) !=
 265       (mouse_mask_state & mouse_button_mask))
 266     {
 267       int button_number = 0;
 268       gboolean is_down = False;
 269
 270       if (!(mask_return & Button1Mask) &&
 271           (mouse_mask_state & Button1Mask))
 272         {
 273           mouse_mask_state &= ~Button1Mask;
 274           button_number = 1;
 275         }
 276       else if ((mask_return & Button1Mask) &&
 277                !(mouse_mask_state & Button1Mask))
 278         {
 279           mouse_mask_state |= Button1Mask;
 280           button_number = 1;
 281           is_down = True;
 282         }
 283       else if (!(mask_return & Button2Mask) &&
 284                (mouse_mask_state & Button2Mask))
 285         {
 286           mouse_mask_state &= ~Button2Mask;
 287           button_number = 2;
 288         }
 289       else if ((mask_return & Button2Mask) &&
 290                !(mouse_mask_state & Button2Mask))
 291         {
 292           mouse_mask_state |= Button2Mask;
 293           button_number = 2;
 294           is_down = True;
 295         }
 296       else if (!(mask_return & Button3Mask) &&
 297                (mouse_mask_state & Button3Mask))
 298         {
 299           mouse_mask_state &= ~Button3Mask;
 300           button_number = 3;
 301         }
 302       else if ((mask_return & Button3Mask) &&
 303                !(mouse_mask_state & Button3Mask))
 304         {
 305           mouse_mask_state |= Button3Mask;
 306           button_number = 3;
 307           is_down = True;
 308         }
 309       else if (!(mask_return & Button4Mask) &&
 310                (mouse_mask_state & Button4Mask))
 311         {
 312           mouse_mask_state &= ~Button4Mask;
 313           button_number = 4;
 314         }
 315       else if ((mask_return & Button4Mask) &&
 316                !(mouse_mask_state & Button4Mask))
 317         {
 318           mouse_mask_state |= Button4Mask;
 319           button_number = 4;
 320           is_down = True;
 321         }
 322       else if (!(mask_return & Button5Mask) &&
 323                (mouse_mask_state & Button5Mask))
 324         {
 325           mouse_mask_state &= ~Button5Mask;
 326           button_number = 5;
 327         }
 328       else if ((mask_return & Button5Mask) &&
 329                !(mouse_mask_state & Button5Mask))
 330         {
 331           mouse_mask_state |= Button5Mask;
 332           button_number = 5;
 333           is_down = True;
 334         }
 335       if (button_number) {
 336 #ifdef SPI_DEBUG
 337         fprintf (stderr, "Button %d %s\n",
 338                  button_number, (is_down) ? "Pressed" : "Released");
 339 #endif
 340         snprintf (event_name, 22, "mouse:button:%d%c", button_number,
 341                   (is_down) ? 'p' : 'r');
 342         /* TODO: FIXME distinguish between physical and
 343          * logical buttons
 344          */
 345         mouse_e.type      = (is_down) ?
 346           Accessibility_BUTTON_PRESSED_EVENT :
 347           Accessibility_BUTTON_RELEASED_EVENT;
 348         mouse_e.id        = button_number;
 349         mouse_e.hw_code   = button_number;
 350         mouse_e.modifiers = (CORBA_unsigned_short) mouse_mask_state;
 351         mouse_e.timestamp = 0;
 352         mouse_e.event_string = "";
 353         mouse_e.is_text   = CORBA_FALSE;
 354         is_consumed =
 355           spi_controller_notify_mouselisteners (controller,
 356                                                 &mouse_e,
 357                                                 &ev);
 358         e.type = event_name;
 359         e.source = BONOBO_OBJREF (controller->registry->desktop);
 360         e.detail1 = last_mouse_pos->x;
 361         e.detail2 = last_mouse_pos->y;
 362         spi_init_any_nil (&e.any_data);
 363         CORBA_exception_init (&ev);
 364         if (!is_consumed)
 365           {
 366             Accessibility_Registry_notifyEvent (BONOBO_OBJREF (controller->registry),
 367                                                 &e,
 368                                                 &ev);
 369           }
 370         else
 371           spi_dec_set_unlatch_pending (controller, mask_return);
 372       }
 373       return TRUE;
 374     }
 375   else
 376     {
 377       return FALSE;
 378     }
 379 }
 380
 381
 382 static guint
 383 spi_dec_mouse_check (SpiDEController *controller,
 384                      int *x, int *y, gboolean *moved)
 385 {
 386   Accessibility_Event e;
 387   CORBA_Environment ev;
 388   int win_x_return,win_y_return;
 389   unsigned int mask_return;
 390   Window root_return, child_return;
 391   Display *display = spi_get_display ();
 392
 393   if (display != NULL)
 394     XQueryPointer(display, DefaultRootWindow (display),
 395                   &root_return, &child_return,
 396                   x, y,
 397                   &win_x_return, &win_y_return, &mask_return);
 398   /*
 399    * Since many clients grab the pointer, and X goes an automatic
 400    * pointer grab on mouse-down, we often must detect mouse button events
 401    * by polling rather than via a button grab.
 402    * The while loop (rather than if) is used since it's possible that
 403    * multiple buttons have changed state since we last checked.
 404    */
 405   if (mask_return != mouse_mask_state)
 406     {
 407       while (spi_dec_button_update_and_emit (controller, mask_return));
 408     }
 409
 410   if (*x != last_mouse_pos->x || *y != last_mouse_pos->y)
 411     {
 412       e.type = "mouse:abs";
 413       e.source = BONOBO_OBJREF (controller->registry->desktop);
 414       e.detail1 = *x;
 415       e.detail2 = *y;
 416       spi_init_any_nil (&e.any_data);
 417       CORBA_exception_init (&ev);
 418       Accessibility_Registry_notifyEvent (BONOBO_OBJREF (controller->registry),
 419                                           &e,
 420                                           &ev);
 421       e.type = "mouse:rel";
 422       e.source = BONOBO_OBJREF (controller->registry->desktop);
 423       e.detail1 = *x - last_mouse_pos->x;
 424       e.detail2 = *y - last_mouse_pos->y;
 425       spi_init_any_nil (&e.any_data);
 426       CORBA_exception_init (&ev);
 427       last_mouse_pos->x = *x;
 428       last_mouse_pos->y = *y;
 429       Accessibility_Registry_notifyEvent (BONOBO_OBJREF (controller->registry),
 430                                           &e,
 431                                           &ev);
 432       *moved = True;
 433     }
 434   else
 435     {
 436       *moved = False;
 437     }
 438
 439   return mask_return;
 440 }
 441
 442 static void
 443 spi_dec_emit_modifier_event (SpiDEController *controller, guint prev_mask,
 444                              guint current_mask)
 445 {
 446   Accessibility_Event e;
 447   CORBA_Environment ev;
 448
 449 #ifdef SPI_XKB_DEBUG
 450   fprintf (stderr, "MODIFIER CHANGE EVENT! %x to %x\n",
 451            prev_mask, current_mask);
 452 #endif
 453
 454   /* set bits for the virtual modifiers like NUMLOCK */
 455   if (prev_mask & _numlock_physical_mask)
 456     prev_mask |= SPI_KEYMASK_NUMLOCK;
 457   if (current_mask & _numlock_physical_mask)
 458     current_mask |= SPI_KEYMASK_NUMLOCK;
 459
 460   e.type = "keyboard:modifiers";
 461   e.source = BONOBO_OBJREF (controller->registry->desktop);
 462   e.detail1 = prev_mask & key_modifier_mask;
 463   e.detail2 = current_mask & key_modifier_mask;
 464   spi_init_any_nil (&e.any_data);
 465   CORBA_exception_init (&ev);
 466   Accessibility_Registry_notifyEvent (BONOBO_OBJREF (controller->registry),
 467                                       &e,
 468                                       &ev);
 469 }
 470
 471 static gboolean
 472 spi_dec_poll_mouse_moved (gpointer data)
 473 {
 474   SpiRegistry *registry = SPI_REGISTRY (data);
 475   SpiDEController *controller = registry->de_controller;
 476   int x, y;
 477   gboolean moved;
 478   guint mask_return;
 479
 480   mask_return = spi_dec_mouse_check (controller, &x, &y, &moved);
 481
 482   if ((mask_return & key_modifier_mask) !=
 483       (mouse_mask_state & key_modifier_mask))
 484     {
 485       spi_dec_emit_modifier_event (controller, mouse_mask_state, mask_return);
 486       mouse_mask_state = mask_return;
 487     }
 488
 489   return moved;
 490 }
 491
 492 static gboolean
 493 spi_dec_poll_mouse_idle (gpointer data)
 494 {
 495   if (! spi_dec_poll_mouse_moved (data))
 496     return TRUE;
 497   else
 498     {
 499       g_timeout_add (20, spi_dec_poll_mouse_moving, data);
 500       return FALSE;
 501     }
 502 }
 503
 504 static gboolean
 505 spi_dec_poll_mouse_moving (gpointer data)
 506 {
 507   if (spi_dec_poll_mouse_moved (data))
 508     return TRUE;
 509   else
 510     {
 511       g_timeout_add (100, spi_dec_poll_mouse_idle, data);
 512       return FALSE;
 513     }
 514 }
 515
 516 #ifdef WE_NEED_UGRAB_MOUSE
 517 static int
 518 spi_dec_ungrab_mouse (gpointer data)
 519 {
 520         Display *display = spi_get_display ();
 521         if (display)
 522           {
 523             XUngrabButton (spi_get_display (), AnyButton, AnyModifier,
 524                            XDefaultRootWindow (spi_get_display ()));
 525           }
 526         return FALSE;
 527 }
 528 #endif
 529
 530 static void
 531 spi_dec_init_mouse_listener (SpiRegistry *registry)
 532 {
 533   Display *display = spi_get_display ();
 534   g_timeout_add (100, spi_dec_poll_mouse_idle, registry);
 535
 536   if (display)
 537     {
 538       if (XGrabButton (display, AnyButton, AnyModifier,
 539                    gdk_x11_get_default_root_xwindow (),
 540                    True, ButtonPressMask | ButtonReleaseMask,
 541                    GrabModeSync, GrabModeAsync, None, None) != Success)
 542         fprintf (stderr, "WARNING: could not grab mouse buttons!\n");
 543       XSync (display, False);
 544 #ifdef SPI_DEBUG
 545       fprintf (stderr, "mouse buttons grabbed\n");
 546 #endif
 547     }
 548 }
 549
 550 /**
 551  * Eventually we can use this to make the marshalling of mask types
 552  * more sane, but for now we just use this to detect
 553  * the use of 'virtual' masks such as Mumlock and convert them to
 554  * system-specific mask values (i.e. ModMask).
 555  *
 556  **/
 557 static Accessibility_ControllerEventMask
 558 spi_dec_translate_mask (Accessibility_ControllerEventMask mask)
 559 {
 560   DEControllerPrivateData *priv;
 561
 562   if (mask == SPI_KEYMASK_NUMLOCK) {
 563     mask = _numlock_physical_mask;
 564   }
 565   return mask;
 566 }
 567
 568 static DEControllerKeyListener *
 569 spi_dec_key_listener_new (CORBA_Object                            l,
 570                           const Accessibility_KeySet             *keys,
 571                           const Accessibility_ControllerEventMask mask,
 572                           const Accessibility_EventTypeSeq    *typeseq,
 573                           const Accessibility_EventListenerMode  *mode,
 574                           CORBA_Environment                      *ev)
 575 {
 576   DEControllerKeyListener *key_listener = g_new0 (DEControllerKeyListener, 1);
 577   key_listener->listener.object = bonobo_object_dup_ref (l, ev);
 578   key_listener->listener.type = SPI_DEVICE_TYPE_KBD;
 579   key_listener->keys = ORBit_copy_value (keys, TC_Accessibility_KeySet);
 580   key_listener->mask = spi_dec_translate_mask (mask);
 581   key_listener->listener.typeseq = ORBit_copy_value (typeseq, TC_Accessibility_EventTypeSeq);
 582   if (mode)
 583     key_listener->mode = ORBit_copy_value (mode, TC_Accessibility_EventListenerMode);
 584   else
 585     key_listener->mode = NULL;
 586
 587 #ifdef SPI_DEBUG
 588   g_print ("new listener, with mask %x, is_global %d, keys %p (%d)\n",
 589            (unsigned int) key_listener->mask,
 590            (int) (mode ? mode->global : 0),
 591            (void *) key_listener->keys,
 592            (int) (key_listener->keys ? key_listener->keys->_length : 0));
 593 #endif
 594
 595   return key_listener;
 596 }
 597
 598 static DEControllerListener *
 599 spi_dec_listener_new (CORBA_Object                            l,
 600                       const Accessibility_EventTypeSeq    *typeseq,
 601                       CORBA_Environment                      *ev)
 602 {
 603   DEControllerListener *listener = g_new0 (DEControllerListener, 1);
 604   listener->object = bonobo_object_dup_ref (l, ev);
 605   listener->type = SPI_DEVICE_TYPE_MOUSE;
 606   listener->typeseq = ORBit_copy_value (typeseq, TC_Accessibility_EventTypeSeq);
 607   return listener;
 608 }
 609
 610 static DEControllerListener *
 611 spi_listener_clone (DEControllerListener *listener, CORBA_Environment *ev)
 612 {
 613   DEControllerListener *clone = g_new0 (DEControllerListener, 1);
 614   clone->object =
 615           CORBA_Object_duplicate (listener->object, ev);
 616   clone->type = listener->type;
 617   clone->typeseq = ORBit_copy_value (listener->typeseq, TC_Accessibility_EventTypeSeq);
 618   return clone;
 619 }
 620
 621 static DEControllerKeyListener *
 622 spi_key_listener_clone (DEControllerKeyListener *key_listener, CORBA_Environment *ev)
 623 {
 624   DEControllerKeyListener *clone = g_new0 (DEControllerKeyListener, 1);
 625   clone->listener.object =
 626           CORBA_Object_duplicate (key_listener->listener.object, ev);
 627   clone->listener.type = SPI_DEVICE_TYPE_KBD;
 628   clone->keys = ORBit_copy_value (key_listener->keys, TC_Accessibility_KeySet);
 629   clone->mask = key_listener->mask;
 630   clone->listener.typeseq = ORBit_copy_value (key_listener->listener.typeseq, TC_Accessibility_EventTypeSeq);
 631   if (key_listener->mode)
 632     clone->mode = ORBit_copy_value (key_listener->mode, TC_Accessibility_EventListenerMode);
 633   else
 634     clone->mode = NULL;
 635   return clone;
 636 }
 637
 638 static void
 639 spi_key_listener_data_free (DEControllerKeyListener *key_listener, CORBA_Environment *ev)
 640 {
 641   CORBA_free (key_listener->listener.typeseq);
 642   CORBA_free (key_listener->keys);
 643   g_free (key_listener);
 644 }
 645
 646 static void
 647 spi_key_listener_clone_free (DEControllerKeyListener *clone, CORBA_Environment *ev)
 648 {
 649   CORBA_Object_release (clone->listener.object, ev);
 650   spi_key_listener_data_free (clone, ev);
 651 }
 652
 653 static void
 654 spi_listener_clone_free (DEControllerListener *clone, CORBA_Environment *ev)
 655 {
 656   CORBA_Object_release (clone->object, ev);
 657   CORBA_free (clone->typeseq);
 658   g_free (clone);
 659 }
 660
 661 static void
 662 spi_dec_listener_free (DEControllerListener    *listener,
 663                        CORBA_Environment       *ev)
 664 {
 665   bonobo_object_release_unref (listener->object, ev);
 666   if (listener->type == SPI_DEVICE_TYPE_KBD)
 667     spi_key_listener_data_free ((DEControllerKeyListener *) listener, ev);
 668 }
 669
 670 static void
 671 _register_keygrab (SpiDEController      *controller,
 672                    DEControllerGrabMask *grab_mask)
 673 {
 674   GList *l;
 675
 676   l = g_list_find_custom (controller->keygrabs_list, grab_mask,
 677                           spi_grab_mask_compare_values);
 678   if (l)
 679     {
 680       DEControllerGrabMask *cur_mask = l->data;
 681
 682       cur_mask->ref_count++;
 683       if (cur_mask->pending_remove)
 684         {
 685           cur_mask->pending_remove = FALSE;
 686         }
 687     }
 688   else
 689     {
 690       controller->keygrabs_list =
 691         g_list_prepend (controller->keygrabs_list,
 692                         spi_grab_mask_clone (grab_mask));
 693     }
 694 }
 695
 696 static void
 697 _deregister_keygrab (SpiDEController      *controller,
 698                      DEControllerGrabMask *grab_mask)
 699 {
 700   GList *l;
 701
 702   l = g_list_find_custom (controller->keygrabs_list, grab_mask,
 703                           spi_grab_mask_compare_values);
 704
 705   if (l)
 706     {
 707       DEControllerGrabMask *cur_mask = l->data;
 708
 709       cur_mask->ref_count--;
 710       if (cur_mask->ref_count <= 0)
 711         {
 712           cur_mask->pending_remove = TRUE;
 713         }
 714     }
 715   else
 716     {
 717       DBG (1, g_warning ("De-registering non-existant grab"));
 718     }
 719 }
 720
 721 static void
 722 handle_keygrab (SpiDEController         *controller,
 723                 DEControllerKeyListener *key_listener,
 724                 void                   (*process_cb) (SpiDEController *controller,
 725                                                       DEControllerGrabMask *grab_mask))
 726 {
 727   DEControllerGrabMask grab_mask = { 0 };
 728
 729   grab_mask.mod_mask = key_listener->mask;
 730   if (key_listener->keys->_length == 0) /* special case means AnyKey/AllKeys */
 731     {
 732       grab_mask.key_val = AnyKey;
 733 #ifdef SPI_DEBUG
 734       fprintf (stderr, "AnyKey grab!");
 735 #endif
 736       process_cb (controller, &grab_mask);
 737     }
 738   else
 739     {
 740       int i;
 741
 742       for (i = 0; i < key_listener->keys->_length; ++i)
 743         {
 744           Accessibility_KeyDefinition keydef = key_listener->keys->_buffer[i];
 745           long int key_val = keydef.keysym;
 746           /* X Grabs require keycodes, not keysyms */
 747           if (keydef.keystring && keydef.keystring[0])
 748             {
 749               key_val = XStringToKeysym(keydef.keystring);
 750             }
 751           if (key_val > 0)
 752             {
 753               key_val = XKeysymToKeycode (spi_get_display (), (KeySym) key_val);
 754             }
 755           else
 756             {
 757               key_val = keydef.keycode;
 758             }
 759           grab_mask.key_val = key_val;
 760           process_cb (controller, &grab_mask);
 761         }
 762     }
 763 }
 764
 765 static gboolean
 766 spi_controller_register_global_keygrabs (SpiDEController         *controller,
 767                                          DEControllerKeyListener *key_listener)
 768 {
 769   handle_keygrab (controller, key_listener, _register_keygrab);
 770   return spi_controller_update_key_grabs (controller, NULL);
 771 }
 772
 773 static void
 774 spi_controller_deregister_global_keygrabs (SpiDEController         *controller,
 775                                            DEControllerKeyListener *key_listener)
 776 {
 777   handle_keygrab (controller, key_listener, _deregister_keygrab);
 778   spi_controller_update_key_grabs (controller, NULL);
 779 }
 780
 781 static gboolean
 782 spi_controller_register_device_listener (SpiDEController      *controller,
 783                                          DEControllerListener *listener,
 784                                          CORBA_Environment    *ev)
 785 {
 786   DEControllerKeyListener *key_listener;
 787
 788   switch (listener->type) {
 789   case SPI_DEVICE_TYPE_KBD:
 790       key_listener = (DEControllerKeyListener *) listener;
 791
 792       controller->key_listeners = g_list_prepend (controller->key_listeners,
 793                                                   key_listener);
 794       if (key_listener->mode->global)
 795         {
 796           return spi_controller_register_global_keygrabs (controller, key_listener);
 797         }
 798       else
 799               return TRUE;
 800       break;
 801   case SPI_DEVICE_TYPE_MOUSE:
 802       controller->mouse_listeners = g_list_prepend (controller->mouse_listeners, listener);
 803       break;
 804   default:
 805       DBG (1, g_warning ("listener registration for unknown device type.\n"));
 806       break;
 807   }
 808   return FALSE;
 809 }
 810
 811 static gboolean
 812 spi_controller_notify_mouselisteners (SpiDEController                 *controller,
 813                                       const Accessibility_DeviceEvent *event,
 814                                       CORBA_Environment               *ev)
 815 {
 816   GList   *l;
 817   GSList  *notify = NULL, *l2;
 818   GList  **listeners = &controller->mouse_listeners;
 819   gboolean is_consumed;
 820
 821   if (!listeners)
 822     {
 823       return FALSE;
 824     }
 825
 826   for (l = *listeners; l; l = l->next)
 827     {
 828        DEControllerListener *listener = l->data;
 829
 830        if (spi_eventtype_seq_contains_event (listener->typeseq, event))
 831          {
 832            Accessibility_DeviceEventListener ls = listener->object;
 833
 834            if (ls != CORBA_OBJECT_NIL)
 835              {
 836                /* we clone (don't dup) the listener, to avoid refcount inc. */
 837                notify = g_slist_prepend (notify,
 838                                          spi_listener_clone (listener, ev));
 839              }
 840          }
 841     }
 842
 843 #ifdef SPI_KEYEVENT_DEBUG
 844   if (!notify)
 845     {
 846       g_print ("no match for event\n");
 847     }
 848 #endif
 849
 850   is_consumed = FALSE;
 851   for (l2 = notify; l2 && !is_consumed; l2 = l2->next)
 852     {
 853       DEControllerListener *listener = l2->data;
 854       Accessibility_DeviceEventListener ls = listener->object;
 855
 856       CORBA_exception_init (ev);
 857       is_consumed = Accessibility_DeviceEventListener_notifyEvent (ls, event, ev);
 858       if (BONOBO_EX (ev))
 859         {
 860           is_consumed = FALSE;
 861           DBG (2, g_warning ("error notifying listener, removing it\n"));
 862           spi_deregister_controller_device_listener (controller, listener,
 863                                                      ev);
 864           CORBA_exception_free (ev);
 865         }
 866
 867       spi_listener_clone_free ((DEControllerListener *) l2->data, ev);
 868     }
 869
 870   for (; l2; l2 = l2->next)
 871     {
 872       DEControllerListener *listener = l2->data;
 873       spi_listener_clone_free (listener, ev);
 874       /* clone doesn't have its own ref, so don't use spi_device_listener_free */
 875     }
 876
 877   g_slist_free (notify);
 878
 879 #ifdef SPI_DEBUG
 880   if (is_consumed) g_message ("consumed\n");
 881 #endif
 882   return is_consumed;
 883 }
 884
 885 static void
 886 spi_device_event_controller_forward_mouse_event (SpiDEController *controller,
 887                                                  XEvent *xevent)
 888 {
 889   Accessibility_Event e;
 890   Accessibility_DeviceEvent mouse_e;
 891   CORBA_Environment ev;
 892   gchar event_name[24];
 893   gboolean is_consumed = FALSE;
 894   gboolean xkb_mod_unlatch_occurred;
 895   XButtonEvent *xbutton_event = (XButtonEvent *) xevent;
 896
 897   int button = xbutton_event->button;
 898
 899   unsigned int mouse_button_state = xbutton_event->state;
 900
 901   switch (button)
 902     {
 903     case 1:
 904             mouse_button_state |= Button1Mask;
 905             break;
 906     case 2:
 907             mouse_button_state |= Button2Mask;
 908             break;
 909     case 3:
 910             mouse_button_state |= Button3Mask;
 911             break;
 912     case 4:
 913             mouse_button_state |= Button4Mask;
 914             break;
 915     case 5:
 916             mouse_button_state |= Button5Mask;
 917             break;
 918     }
 919
 920   last_mouse_pos->x = ((XButtonEvent *) xevent)->x_root;
 921   last_mouse_pos->y = ((XButtonEvent *) xevent)->y_root;
 922
 923 #ifdef SPI_DEBUG
 924   fprintf (stderr, "mouse button %d %s (%x)\n",
 925            xbutton_event->button,
 926            (xevent->type == ButtonPress) ? "Press" : "Release",
 927            mouse_button_state);
 928 #endif
 929   snprintf (event_name, 22, "mouse:button:%d%c", button,
 930             (xevent->type == ButtonPress) ? 'p' : 'r');
 931
 932   /* TODO: FIXME distinguish between physical and logical buttons */
 933   mouse_e.type      = (xevent->type == ButtonPress) ?
 934                       Accessibility_BUTTON_PRESSED_EVENT :
 935                       Accessibility_BUTTON_RELEASED_EVENT;
 936   mouse_e.id        = button;
 937   mouse_e.hw_code   = button;
 938   mouse_e.modifiers = (CORBA_unsigned_short) xbutton_event->state;
 939   mouse_e.timestamp = (CORBA_unsigned_long) xbutton_event->time;
 940   mouse_e.event_string = "";
 941   mouse_e.is_text   = CORBA_FALSE;
 942   if ((mouse_button_state & mouse_button_mask) !=
 943        (mouse_mask_state & mouse_button_mask))
 944     {
 945       if ((mouse_mask_state & key_modifier_mask) !=
 946           (mouse_button_state & key_modifier_mask))
 947         spi_dec_emit_modifier_event (controller,
 948                                      mouse_mask_state, mouse_button_state);
 949       mouse_mask_state = mouse_button_state;
 950       is_consumed =
 951         spi_controller_notify_mouselisteners (controller, &mouse_e, &ev);
 952       e.type = CORBA_string_dup (event_name);
 953       e.source = BONOBO_OBJREF (controller->registry->desktop);
 954       e.detail1 = last_mouse_pos->x;
 955       e.detail2 = last_mouse_pos->y;
 956       spi_init_any_nil (&e.any_data);
 957       CORBA_exception_init (&ev);
 958
 959       Accessibility_Registry_notifyEvent (BONOBO_OBJREF (controller->registry),
 960                                           &e,
 961                                           &ev);
 962     }
 963
 964   xkb_mod_unlatch_occurred = (xevent->type == ButtonPress ||
 965                               xevent->type == ButtonRelease);
 966
 967   /* if client wants to consume this event, and XKB latch state was
 968    *   unset by this button event, we reset it
 969    */
 970   if (is_consumed && xkb_mod_unlatch_occurred)
 971     spi_dec_set_unlatch_pending (controller, mouse_mask_state);
 972
 973   XAllowEvents (spi_get_display (),
 974                 (is_consumed) ? SyncPointer : ReplayPointer,
 975                 CurrentTime);
 976 }
 977
 978 static GdkFilterReturn
 979 global_filter_fn (GdkXEvent *gdk_xevent, GdkEvent *event, gpointer data)
 980 {
 981   XEvent *xevent = gdk_xevent;
 982   SpiDEController *controller;
 983   DEControllerPrivateData *priv;
 984   Display *display = spi_get_display ();
 985   controller = SPI_DEVICE_EVENT_CONTROLLER (data);
 986   priv = (DEControllerPrivateData *)
 987           g_object_get_qdata (G_OBJECT (controller), spi_dec_private_quark);
 988
 989   if (xevent->type == KeyPress || xevent->type == KeyRelease)
 990     {
 991       spi_device_event_controller_forward_key_event (controller, xevent);
 992       return GDK_FILTER_CONTINUE;
 993     }
 994   if (xevent->type == ButtonPress || xevent->type == ButtonRelease)
 995     {
 996       spi_device_event_controller_forward_mouse_event (controller, xevent);
 997     }
 998   if (xevent->type == priv->xkb_base_event_code)
 999     {
1000       XkbAnyEvent * xkb_ev = (XkbAnyEvent *) xevent;
1001       /* ugly but probably necessary...*/
1002       XSynchronize (spi_get_display (), TRUE);
1003
1004       if (xkb_ev->xkb_type == XkbStateNotify)
1005         {
1006           XkbStateNotifyEvent *xkb_snev =
1007                   (XkbStateNotifyEvent *) xkb_ev;
1008           /* check the mouse, to catch mouse events grabbed by
1009            * another client; in case we should revert this XKB delatch
1010            */
1011           if (!priv->pending_xkb_mod_relatch_mask)
1012             {
1013               int x, y;
1014               gboolean moved;
1015               spi_dec_mouse_check (controller, &x, &y, &moved);
1016             }
1017           /* we check again, since the previous call may have
1018              changed this flag */
1019           if (priv->pending_xkb_mod_relatch_mask)
1020             {
1021               unsigned int feedback_mask;
1022 #ifdef SPI_XKB_DEBUG
1023               fprintf (stderr, "relatching %x\n",
1024                        priv->pending_xkb_mod_relatch_mask);
1025 #endif
1026               /* temporarily turn off the latch bell, if it's on */
1027               XkbGetControls (display,
1028                               XkbAccessXFeedbackMask,
1029                               priv->xkb_desc);
1030               feedback_mask = priv->xkb_desc->ctrls->ax_options;
1031               if (feedback_mask & XkbAX_StickyKeysFBMask)
1032               {
1033                 XkbControlsChangesRec changes = {XkbAccessXFeedbackMask,
1034                                                  0, False};
1035                 priv->xkb_desc->ctrls->ax_options
1036                               &= ~(XkbAX_StickyKeysFBMask);
1037                 XkbChangeControls (display, priv->xkb_desc, &changes);
1038               }
1039               /* TODO: account for lock as well as latch */
1040               XkbLatchModifiers (display,
1041                                  XkbUseCoreKbd,
1042                                  priv->pending_xkb_mod_relatch_mask,
1043                                  priv->pending_xkb_mod_relatch_mask);
1044               if (feedback_mask & XkbAX_StickyKeysFBMask)
1045               {
1046                 XkbControlsChangesRec changes = {XkbAccessXFeedbackMask,
1047                                                  0, False};
1048                 priv->xkb_desc->ctrls->ax_options = feedback_mask;
1049                 XkbChangeControls (display, priv->xkb_desc, &changes);
1050               }
1051 #ifdef SPI_XKB_DEBUG
1052               fprintf (stderr, "relatched %x\n",
1053                        priv->pending_xkb_mod_relatch_mask);
1054 #endif
1055               priv->pending_xkb_mod_relatch_mask = 0;
1056             }
1057           else
1058             {
1059               priv->xkb_latch_mask = xkb_snev->latched_mods;
1060             }
1061         }
1062         else
1063                DBG (2, g_warning ("XKB event %d\n", xkb_ev->xkb_type));
1064       XSynchronize (spi_get_display (), FALSE);
1065     }
1066
1067   return GDK_FILTER_CONTINUE;
1068 }
1069
1070 int
1071 _spi_controller_device_error_handler (Display *display, XErrorEvent *error)
1072 {
1073   if (error->error_code == BadAccess)
1074     {
1075       g_message ("Could not complete key grab: grab already in use.\n");
1076       spi_error_code = BadAccess;
1077       return 0;
1078     }
1079   else
1080     {
1081       return (*x_default_error_handler) (display, error);
1082     }
1083 }
1084
1085 static void
1086 spi_controller_register_with_devices (SpiDEController *controller)
1087 {
1088   DEControllerPrivateData *priv = (DEControllerPrivateData *)
1089           g_object_get_qdata (G_OBJECT (controller), spi_dec_private_quark);
1090   /* FIXME: should check for extension first! */
1091   XTestGrabControl (spi_get_display (), True);
1092
1093   /* calls to device-specific implementations and routines go here */
1094   /* register with: keyboard hardware code handler */
1095   /* register with: (translated) keystroke handler */
1096
1097   priv->have_xkb = XkbQueryExtension (spi_get_display (),
1098                                       &priv->xkb_major_extension_opcode,
1099                                       &priv->xkb_base_event_code,
1100                                       &priv->xkb_base_error_code, NULL, NULL);
1101   if (priv->have_xkb)
1102     {
1103       priv->xkb_desc = XkbGetMap (spi_get_display (), 0, XkbUseCoreKbd);
1104       XkbSelectEvents (spi_get_display (),
1105                        XkbUseCoreKbd,
1106                        XkbStateNotifyMask, XkbStateNotifyMask);
1107       _numlock_physical_mask = XkbKeysymToModifiers (spi_get_display (),
1108                                                      XK_Num_Lock);
1109     }
1110
1111   gdk_window_add_filter (NULL, global_filter_fn, controller);
1112
1113   gdk_window_set_events (gdk_get_default_root_window (),
1114                          GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK);
1115
1116   x_default_error_handler = XSetErrorHandler (_spi_controller_device_error_handler);
1117 }
1118
1119 static gboolean
1120 spi_key_set_contains_key (Accessibility_KeySet            *key_set,
1121                           const Accessibility_DeviceEvent *key_event)
1122 {
1123   gint i;
1124   gint len;
1125
1126   if (!key_set)
1127     {
1128       g_print ("null key set!");
1129       return TRUE;
1130     }
1131
1132   len = key_set->_length;
1133
1134   if (len == 0) /* special case, means "all keys/any key" */
1135     {
1136       g_print ("anykey\n");
1137       return TRUE;
1138     }
1139
1140   for (i = 0; i < len; ++i)
1141     {
1142 #ifdef SPI_KEYEVENT_DEBUG
1143       g_print ("key_set[%d] = %d; key_event %d, code %d, string %s\n",
1144                 i, (int) key_set->_buffer[i].keycode,
1145                (int) key_event->id, (int) key_event->hw_code,
1146                key_event->event_string);
1147 #endif
1148       if (key_set->_buffer[i].keysym == (CORBA_long) key_event->id)
1149         {
1150           return TRUE;
1151         }
1152       if (key_set->_buffer[i].keycode == (CORBA_long) key_event->hw_code)
1153         {
1154           return TRUE;
1155         }
1156       if (key_event->event_string && key_event->event_string[0] &&
1157           !strcmp (key_set->_buffer[i].keystring, key_event->event_string))
1158         {
1159           return TRUE;
1160         }
1161     }
1162
1163   return FALSE;
1164 }
1165
1166 static gboolean
1167 spi_eventtype_seq_contains_event (Accessibility_EventTypeSeq      *type_seq,
1168                                   const Accessibility_DeviceEvent *event)
1169 {
1170   gint i;
1171   gint len;
1172
1173
1174   if (!type_seq)
1175     {
1176       g_print ("null type seq!");
1177       return TRUE;
1178     }
1179
1180   len = type_seq->_length;
1181
1182   if (len == 0) /* special case, means "all events/any event" */
1183     {
1184       return TRUE;
1185     }
1186
1187   for (i = 0; i < len; ++i)
1188     {
1189 #ifdef SPI_DEBUG
1190       g_print ("type_seq[%d] = %d; event type = %d\n", i,
1191                (int) type_seq->_buffer[i], (int) event->type);
1192 #endif
1193       if (type_seq->_buffer[i] == (CORBA_long) event->type)
1194         {
1195           return TRUE;
1196         }
1197     }
1198
1199   return FALSE;
1200 }
1201
1202 static gboolean
1203 spi_key_event_matches_listener (const Accessibility_DeviceEvent *key_event,
1204                                 DEControllerKeyListener         *listener,
1205                                 CORBA_boolean                    is_system_global)
1206 {
1207   if ((key_event->modifiers == (CORBA_unsigned_short) (listener->mask & 0xFF)) &&
1208        spi_key_set_contains_key (listener->keys, key_event) &&
1209        spi_eventtype_seq_contains_event (listener->listener.typeseq, key_event) &&
1210       (is_system_global == listener->mode->global))
1211     {
1212       return TRUE;
1213     }
1214   else
1215     {
1216       return FALSE;
1217     }
1218 }
1219
1220 static gboolean
1221 spi_controller_notify_keylisteners (SpiDEController                 *controller,
1222                                     const Accessibility_DeviceEvent *key_event,
1223                                     CORBA_boolean                    is_system_global,
1224                                     CORBA_Environment               *ev)
1225 {
1226   GList   *l;
1227   GSList  *notify = NULL, *l2;
1228   GList  **key_listeners = &controller->key_listeners;
1229   gboolean is_consumed;
1230
1231   if (!key_listeners)
1232     {
1233       return FALSE;
1234     }
1235
1236   for (l = *key_listeners; l; l = l->next)
1237     {
1238        DEControllerKeyListener *key_listener = l->data;
1239
1240        if (spi_key_event_matches_listener (key_event, key_listener, is_system_global))
1241          {
1242            Accessibility_DeviceEventListener ls = key_listener->listener.object;
1243
1244            if (ls != CORBA_OBJECT_NIL)
1245              {
1246                /* we clone (don't dup) the listener, to avoid refcount inc. */
1247                notify = g_slist_prepend (notify,
1248                                          spi_key_listener_clone (key_listener, ev));
1249              }
1250          }
1251     }
1252
1253 #ifdef SPI_KEYEVENT_DEBUG
1254   if (!notify)
1255     {
1256       g_print ("no match for event\n");
1257     }
1258 #endif
1259
1260   is_consumed = FALSE;
1261   for (l2 = notify; l2 && !is_consumed; l2 = l2->next)
1262     {
1263       DEControllerKeyListener *key_listener = l2->data;
1264       Accessibility_DeviceEventListener ls = key_listener->listener.object;
1265
1266       is_consumed = Accessibility_DeviceEventListener_notifyEvent (ls, key_event, ev);
1267
1268       if (BONOBO_EX (ev))
1269         {
1270           is_consumed = FALSE;
1271           spi_deregister_controller_key_listener (controller, key_listener,
1272                                                   ev);
1273           CORBA_exception_free (ev);
1274         }
1275
1276       spi_key_listener_clone_free (key_listener, ev);
1277     }
1278
1279   for (; l2; l2 = l2->next)
1280     {
1281       DEControllerKeyListener *key_listener = l2->data;
1282       spi_key_listener_clone_free (key_listener, ev);
1283       /* clone doesn't have its own ref, so don't use spi_dec_listener_free */
1284     }
1285
1286   g_slist_free (notify);
1287
1288 #ifdef SPI_DEBUG
1289   if (is_consumed) g_message ("consumed\n");
1290 #endif
1291   return is_consumed;
1292 }
1293
1294 static gboolean
1295 spi_clear_error_state ()
1296 {
1297         gboolean retval = spi_error_code != 0;
1298         spi_error_code = 0;
1299         return retval;
1300 }
1301
1302 static Accessibility_DeviceEvent
1303 spi_keystroke_from_x_key_event (XKeyEvent *x_key_event)
1304 {
1305   Accessibility_DeviceEvent key_event;
1306   KeySym keysym;
1307   const int cbuf_bytes = 20;
1308   char cbuf [cbuf_bytes+1];
1309   int nbytes;
1310
1311   nbytes = XLookupString (x_key_event, cbuf, cbuf_bytes, &keysym, NULL);
1312   key_event.id = (CORBA_long)(keysym);
1313   key_event.hw_code = (CORBA_short) x_key_event->keycode;
1314   if (((XEvent *) x_key_event)->type == KeyPress)
1315     {
1316       key_event.type = Accessibility_KEY_PRESSED_EVENT;
1317     }
1318   else
1319     {
1320       key_event.type = Accessibility_KEY_RELEASED_EVENT;
1321     }
1322   key_event.modifiers = (CORBA_unsigned_short)(x_key_event->state);
1323   key_event.is_text = CORBA_FALSE;
1324   switch (keysym)
1325     {
1326       case ' ':
1327         key_event.event_string = CORBA_string_dup ("space");
1328         break;
1329       case XK_Tab:
1330         key_event.event_string = CORBA_string_dup ("Tab");
1331         break;
1332       case XK_BackSpace:
1333         key_event.event_string = CORBA_string_dup ("Backspace");
1334         break;
1335       case XK_Return:
1336         key_event.event_string = CORBA_string_dup ("Return");
1337         break;
1338       case XK_Home:
1339         key_event.event_string = CORBA_string_dup ("Home");
1340         break;
1341       case XK_Page_Down:
1342         key_event.event_string = CORBA_string_dup ("Page_Down");
1343         break;
1344       case XK_Page_Up:
1345         key_event.event_string = CORBA_string_dup ("Page_Up");
1346         break;
1347       case XK_F1:
1348         key_event.event_string = CORBA_string_dup ("F1");
1349         break;
1350       case XK_F2:
1351         key_event.event_string = CORBA_string_dup ("F2");
1352         break;
1353       case XK_F3:
1354         key_event.event_string = CORBA_string_dup ("F3");
1355         break;
1356       case XK_F4:
1357         key_event.event_string = CORBA_string_dup ("F4");
1358         break;
1359       case XK_F5:
1360         key_event.event_string = CORBA_string_dup ("F5");
1361         break;
1362       case XK_F6:
1363         key_event.event_string = CORBA_string_dup ("F6");
1364         break;
1365       case XK_F7:
1366         key_event.event_string = CORBA_string_dup ("F7");
1367         break;
1368       case XK_F8:
1369         key_event.event_string = CORBA_string_dup ("F8");
1370         break;
1371       case XK_F9:
1372         key_event.event_string = CORBA_string_dup ("F9");
1373         break;
1374       case XK_F10:
1375         key_event.event_string = CORBA_string_dup ("F10");
1376         break;
1377       case XK_F11:
1378         key_event.event_string = CORBA_string_dup ("F11");
1379         break;
1380       case XK_F12:
1381         key_event.event_string = CORBA_string_dup ("F12");
1382         break;
1383       case XK_End:
1384         key_event.event_string = CORBA_string_dup ("End");
1385         break;
1386       case XK_Escape:
1387         key_event.event_string = CORBA_string_dup ("Escape");
1388         break;
1389       case XK_Up:
1390         key_event.event_string = CORBA_string_dup ("Up");
1391         break;
1392       case XK_Down:
1393         key_event.event_string = CORBA_string_dup ("Down");
1394         break;
1395       case XK_Left:
1396         key_event.event_string = CORBA_string_dup ("Left");
1397         break;
1398       case XK_Right:
1399         key_event.event_string = CORBA_string_dup ("Right");
1400         break;
1401       default:
1402         if (nbytes > 0)
1403           {
1404             gunichar c;
1405             cbuf[nbytes] = '\0'; /* OK since length is cbuf_bytes+1 */
1406             key_event.event_string = CORBA_string_dup (cbuf);
1407             c = g_utf8_get_char_validated (cbuf, nbytes);
1408             if ((c > 0) && g_unichar_isprint (c))
1409               {
1410                 key_event.is_text = CORBA_TRUE;
1411                 /* incorrect for some composed chars? */
1412               }
1413           }
1414         else
1415           {
1416             key_event.event_string = CORBA_string_dup ("");
1417           }
1418     }
1419
1420   key_event.timestamp = (CORBA_unsigned_long) x_key_event->time;
1421 #ifdef SPI_KEYEVENT_DEBUG
1422   fprintf (stderr,
1423            "Key %lu pressed (%c), modifiers %d; string=%s [%x] %s\n",
1424            (unsigned long) keysym,
1425            keysym ? (int) keysym : '*',
1426            (int) x_key_event->state,
1427            key_event.event_string,
1428            key_event.event_string[0],
1429            (key_event.is_text == CORBA_TRUE) ? "(text)" : "(not text)");
1430 #endif
1431 #ifdef SPI_DEBUG
1432   fprintf (stderr, "%s%c",
1433      (x_key_event->state & Mod1Mask)?"Alt-":"",
1434      ((x_key_event->state & ShiftMask)^(x_key_event->state & LockMask))?
1435      g_ascii_toupper (keysym) : g_ascii_tolower (keysym));
1436 #endif /* SPI_DEBUG */
1437   return key_event;
1438 }
1439
1440 static gboolean
1441 spi_controller_update_key_grabs (SpiDEController           *controller,
1442                                  Accessibility_DeviceEvent *recv)
1443 {
1444   GList *l, *next;
1445   gboolean   update_failed = FALSE;
1446
1447   g_return_val_if_fail (controller != NULL, FALSE);
1448
1449   /*
1450    * masks known to work with default RH 7.1+:
1451    * 0 (no mods), LockMask, Mod1Mask, Mod2Mask, ShiftMask,
1452    * ShiftMask|LockMask, Mod1Mask|LockMask, Mod2Mask|LockMask,
1453    * ShiftMask|Mod1Mask, ShiftMask|Mod2Mask, Mod1Mask|Mod2Mask,
1454    * ShiftMask|LockMask|Mod1Mask, ShiftMask|LockMask|Mod2Mask,
1455    *
1456    * ControlMask grabs are broken, must be in use already
1457    */
1458   for (l = controller->keygrabs_list; l; l = next)
1459     {
1460       gboolean do_remove;
1461       gboolean re_issue_grab;
1462       DEControllerGrabMask *grab_mask = l->data;
1463
1464       next = l->next;
1465
1466       re_issue_grab = recv &&
1467               (recv->modifiers & grab_mask->mod_mask) &&
1468               (grab_mask->key_val == keycode_for_keysym (recv->id, NULL));
1469
1470 #ifdef SPI_DEBUG
1471       fprintf (stderr, "mask=%lx %lx (%c%c) %s\n",
1472                (long int) grab_mask->key_val,
1473                (long int) grab_mask->mod_mask,
1474                grab_mask->pending_add ? '+' : '.',
1475                grab_mask->pending_remove ? '-' : '.',
1476                re_issue_grab ? "re-issue": "");
1477 #endif
1478
1479       do_remove = FALSE;
1480
1481       if (grab_mask->pending_add && grab_mask->pending_remove)
1482         {
1483           do_remove = TRUE;
1484         }
1485       else if (grab_mask->pending_remove)
1486         {
1487 #ifdef SPI_DEBUG
1488       fprintf (stderr, "ungrabbing, mask=%x\n", grab_mask->mod_mask);
1489 #endif
1490           XUngrabKey (spi_get_display (),
1491                       grab_mask->key_val,
1492                       grab_mask->mod_mask,
1493                       gdk_x11_get_default_root_xwindow ());
1494
1495           do_remove = TRUE;
1496         }
1497       else if (grab_mask->pending_add || re_issue_grab)
1498         {
1499
1500 #ifdef SPI_DEBUG
1501           fprintf (stderr, "grab %d with mask %x\n", grab_mask->key_val, grab_mask->mod_mask);
1502 #endif
1503           XGrabKey (spi_get_display (),
1504                     grab_mask->key_val,
1505                     grab_mask->mod_mask,
1506                     gdk_x11_get_default_root_xwindow (),
1507                     True,
1508                     GrabModeSync,
1509                     GrabModeSync);
1510           XSync (spi_get_display (), False);
1511           update_failed = spi_clear_error_state ();
1512           if (update_failed) {
1513                   while (grab_mask->ref_count > 0) --grab_mask->ref_count;
1514                   do_remove = TRUE;
1515           }
1516         }
1517
1518       grab_mask->pending_add = FALSE;
1519       grab_mask->pending_remove = FALSE;
1520
1521       if (do_remove)
1522         {
1523           g_assert (grab_mask->ref_count <= 0);
1524
1525           controller->keygrabs_list = g_list_delete_link (
1526             controller->keygrabs_list, l);
1527
1528           spi_grab_mask_free (grab_mask);
1529         }
1530
1531     }
1532
1533   return ! update_failed;
1534 }
1535
1536 /*
1537  * Implemented GObject::finalize
1538  */
1539 static void
1540 spi_device_event_controller_object_finalize (GObject *object)
1541 {
1542   SpiDEController *controller;
1543   DEControllerPrivateData *private;
1544   controller = SPI_DEVICE_EVENT_CONTROLLER (object);
1545
1546 #ifdef SPI_DEBUG
1547   fprintf(stderr, "spi_device_event_controller_object_finalize called\n");
1548 #endif
1549   /* disconnect any special listeners, get rid of outstanding keygrabs */
1550   XUngrabKey (spi_get_display (), AnyKey, AnyModifier, DefaultRootWindow (spi_get_display ()));
1551
1552   private = g_object_get_data (G_OBJECT (controller), "spi-dec-private");
1553   if (private->xkb_desc)
1554           XkbFreeKeyboard (private->xkb_desc, 0, True);
1555   g_free (private);
1556   spi_device_event_controller_parent_class->finalize (object);
1557 }
1558
1559 /*
1560  * CORBA Accessibility::DEController::registerKeystrokeListener
1561  *     method implementation
1562  */
1563 static CORBA_boolean
1564 impl_register_keystroke_listener (PortableServer_Servant                  servant,
1565                                   const Accessibility_DeviceEventListener l,
1566                                   const Accessibility_KeySet             *keys,
1567                                   const Accessibility_ControllerEventMask mask,
1568                                   const Accessibility_EventTypeSeq       *type,
1569                                   const Accessibility_EventListenerMode  *mode,
1570                                   CORBA_Environment                      *ev)
1571 {
1572   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (
1573           bonobo_object_from_servant (servant));
1574   DEControllerKeyListener *dec_listener;
1575 #ifdef SPI_DEBUG
1576   fprintf (stderr, "registering keystroke listener %p with maskVal %lu\n",
1577            (void *) l, (unsigned long) mask);
1578 #endif
1579   dec_listener = spi_dec_key_listener_new (l, keys, mask, type, mode, ev);
1580   return spi_controller_register_device_listener (
1581           controller, (DEControllerListener *) dec_listener, ev);
1582 }
1583
1584
1585 /*
1586  * CORBA Accessibility::DEController::registerDeviceEventListener
1587  *     method implementation
1588  */
1589 static CORBA_boolean
1590 impl_register_device_listener (PortableServer_Servant                  servant,
1591                                const Accessibility_DeviceEventListener l,
1592                                const Accessibility_EventTypeSeq       *event_types,
1593                                CORBA_Environment                      *ev)
1594 {
1595   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (
1596           bonobo_object_from_servant (servant));
1597   DEControllerListener *dec_listener;
1598
1599   dec_listener = spi_dec_listener_new (l, event_types, ev);
1600   return spi_controller_register_device_listener (
1601           controller, (DEControllerListener *) dec_listener, ev);
1602 }
1603
1604 typedef struct {
1605         CORBA_Environment       *ev;
1606         DEControllerListener    *listener;
1607 } RemoveListenerClosure;
1608
1609 static SpiReEntrantContinue
1610 remove_listener_cb (GList * const *list,
1611                     gpointer       user_data)
1612 {
1613   DEControllerListener  *listener = (*list)->data;
1614   RemoveListenerClosure *ctx = user_data;
1615
1616   if (CORBA_Object_is_equivalent (ctx->listener->object,
1617                                   listener->object, ctx->ev))
1618     {
1619       spi_re_entrant_list_delete_link (list);
1620       spi_dec_listener_free (listener, ctx->ev);
1621     }
1622
1623   return SPI_RE_ENTRANT_CONTINUE;
1624 }
1625
1626 static SpiReEntrantContinue
1627 copy_key_listener_cb (GList * const *list,
1628                       gpointer       user_data)
1629 {
1630   DEControllerKeyListener  *key_listener = (*list)->data;
1631   RemoveListenerClosure    *ctx = user_data;
1632
1633   if (CORBA_Object_is_equivalent (ctx->listener->object,
1634                                   key_listener->listener.object, ctx->ev))
1635     {
1636       /* TODO: FIXME aggregate keys in case the listener is registered twice */
1637       DEControllerKeyListener *ctx_key_listener =
1638         (DEControllerKeyListener *) ctx->listener;
1639       CORBA_free (ctx_key_listener->keys);
1640       ctx_key_listener->keys = ORBit_copy_value (key_listener->keys, TC_Accessibility_KeySet);
1641     }
1642
1643   return SPI_RE_ENTRANT_CONTINUE;
1644 }
1645
1646 static void
1647 spi_deregister_controller_device_listener (SpiDEController            *controller,
1648                                            DEControllerListener *listener,
1649                                            CORBA_Environment          *ev)
1650 {
1651   RemoveListenerClosure  ctx;
1652
1653   ctx.ev = ev;
1654   ctx.listener = listener;
1655
1656   spi_re_entrant_list_foreach (&controller->mouse_listeners,
1657                                remove_listener_cb, &ctx);
1658 }
1659
1660 static void
1661 spi_deregister_controller_key_listener (SpiDEController            *controller,
1662                                         DEControllerKeyListener    *key_listener,
1663                                         CORBA_Environment          *ev)
1664 {
1665   RemoveListenerClosure  ctx;
1666
1667   ctx.ev = ev;
1668   ctx.listener = (DEControllerListener *) key_listener;
1669
1670   /* special case, copy keyset from existing controller list entry */
1671   if (key_listener->keys->_length == 0)
1672     {
1673       spi_re_entrant_list_foreach (&controller->key_listeners,
1674                                   copy_key_listener_cb, &ctx);
1675     }
1676
1677   spi_controller_deregister_global_keygrabs (controller, key_listener);
1678
1679   spi_re_entrant_list_foreach (&controller->key_listeners,
1680                                 remove_listener_cb, &ctx);
1681
1682 }
1683
1684 /*
1685  * CORBA Accessibility::DEController::deregisterKeystrokeListener
1686  *     method implementation
1687  */
1688 static void
1689 impl_deregister_keystroke_listener (PortableServer_Servant                  servant,
1690                                     const Accessibility_DeviceEventListener l,
1691                                     const Accessibility_KeySet             *keys,
1692                                     const Accessibility_ControllerEventMask mask,
1693                                     const Accessibility_EventTypeSeq       *type,
1694                                     CORBA_Environment                      *ev)
1695 {
1696   DEControllerKeyListener  *key_listener;
1697   SpiDEController *controller;
1698
1699   controller = SPI_DEVICE_EVENT_CONTROLLER (bonobo_object (servant));
1700
1701   key_listener = spi_dec_key_listener_new (l, keys, mask, type, NULL, ev);
1702
1703 #ifdef SPI_DEREGISTER_DEBUG
1704   fprintf (stderr, "deregistering keystroke listener %p with maskVal %lu\n",
1705            (void *) l, (unsigned long) mask->value);
1706 #endif
1707
1708   spi_deregister_controller_key_listener (controller, key_listener, ev);
1709
1710   spi_dec_listener_free ((DEControllerListener *) key_listener, ev);
1711 }
1712
1713 /*
1714  * CORBA Accessibility::DEController::deregisterDeviceEventListener
1715  *     method implementation
1716  */
1717 static void
1718 impl_deregister_device_listener (PortableServer_Servant                  servant,
1719                                  const Accessibility_DeviceEventListener l,
1720                                  const Accessibility_EventTypeSeq       *event_types,
1721                                  CORBA_Environment                      *ev)
1722 {
1723   SpiDEController *controller;
1724   DEControllerListener *listener =
1725           spi_dec_listener_new (l, event_types, ev);
1726
1727   controller = SPI_DEVICE_EVENT_CONTROLLER (bonobo_object (servant));
1728
1729   spi_deregister_controller_device_listener (controller, listener, ev);
1730
1731   spi_dec_listener_free (listener, ev);
1732 }
1733
1734 static unsigned int dec_xkb_get_slowkeys_delay (SpiDEController *controller)
1735 {
1736   unsigned int retval = 0;
1737   DEControllerPrivateData *priv = (DEControllerPrivateData *)
1738           g_object_get_qdata (G_OBJECT (controller), spi_dec_private_quark);
1739 #ifdef HAVE_XKB
1740 #ifdef XKB_HAS_GET_SLOW_KEYS_DELAY
1741   retval = XkbGetSlowKeysDelay (spi_get_display (),
1742                                 XkbUseCoreKbd, &bounce_delay);
1743 #else
1744   if (!(priv->xkb_desc == (XkbDescPtr) BadAlloc || priv->xkb_desc == NULL))
1745     {
1746       Status s = XkbGetControls (spi_get_display (),
1747                                  XkbAllControlsMask, priv->xkb_desc);
1748       if (s == Success)
1749         {
1750          if (priv->xkb_desc->ctrls->enabled_ctrls & XkbSlowKeysMask)
1751                  retval = priv->xkb_desc->ctrls->slow_keys_delay;
1752         }
1753     }
1754 #endif
1755 #endif
1756 #ifdef SPI_XKB_DEBUG
1757         fprintf (stderr, "SlowKeys delay: %d\n", (int) retval);
1758 #endif
1759         return retval;
1760 }
1761
1762 static unsigned int dec_xkb_get_bouncekeys_delay (SpiDEController *controller)
1763 {
1764   unsigned int retval = 0;
1765   DEControllerPrivateData *priv = (DEControllerPrivateData *)
1766           g_object_get_qdata (G_OBJECT (controller), spi_dec_private_quark);
1767 #ifdef HAVE_XKB
1768 #ifdef XKB_HAS_GET_BOUNCE_KEYS_DELAY
1769   retval = XkbGetBounceKeysDelay (spi_get_display (),
1770                                   XkbUseCoreKbd, &bounce_delay);
1771 #else
1772   if (!(priv->xkb_desc == (XkbDescPtr) BadAlloc || priv->xkb_desc == NULL))
1773     {
1774       Status s = XkbGetControls (spi_get_display (),
1775                                  XkbAllControlsMask, priv->xkb_desc);
1776       if (s == Success)
1777         {
1778           if (priv->xkb_desc->ctrls->enabled_ctrls & XkbBounceKeysMask)
1779                   retval = priv->xkb_desc->ctrls->debounce_delay;
1780         }
1781     }
1782 #endif
1783 #endif
1784 #ifdef SPI_XKB_DEBUG
1785   fprintf (stderr, "BounceKeys delay: %d\n", (int) retval);
1786 #endif
1787   return retval;
1788 }
1789
1790 static gboolean
1791 dec_synth_keycode_press (SpiDEController *controller,
1792                          unsigned int keycode)
1793 {
1794         unsigned int time = CurrentTime;
1795         unsigned int bounce_delay;
1796         unsigned int elapsed_msec;
1797         struct timeval tv;
1798         DEControllerPrivateData *priv =
1799                 (DEControllerPrivateData *) g_object_get_qdata (G_OBJECT (controller),
1800                                                                 spi_dec_private_quark);
1801         if (keycode == priv->last_release_keycode)
1802         {
1803                 bounce_delay = dec_xkb_get_bouncekeys_delay (controller);
1804                 if (bounce_delay)
1805                 {
1806                         gettimeofday (&tv, NULL);
1807                         elapsed_msec =
1808                                 (tv.tv_sec - priv->last_release_time.tv_sec) * 1000
1809                                 + (tv.tv_usec - priv->last_release_time.tv_usec) / 1000;
1810 #ifdef SPI_XKB_DEBUG
1811                         fprintf (stderr, "%d ms elapsed (%ld usec)\n", elapsed_msec,
1812                                  (long) (tv.tv_usec - priv->last_release_time.tv_usec));
1813 #endif
1814 #ifdef THIS_IS_BROKEN
1815                         if (elapsed_msec < bounce_delay)
1816                                 time = bounce_delay - elapsed_msec + 1;
1817 #else
1818                         time = bounce_delay + 10;
1819                         /* fudge for broken XTest */
1820 #endif
1821 #ifdef SPI_XKB_DEBUG
1822                         fprintf (stderr, "waiting %d ms\n", time);
1823 #endif
1824                 }
1825         }
1826         XTestFakeKeyEvent (spi_get_display (), keycode, True, time);
1827         priv->last_press_keycode = keycode;
1828         XSync (spi_get_display (), False);
1829         gettimeofday (&priv->last_press_time, NULL);
1830         return TRUE;
1831 }
1832
1833 static gboolean
1834 dec_synth_keycode_release (SpiDEController *controller,
1835                            unsigned int keycode)
1836 {
1837         unsigned int time = CurrentTime;
1838         unsigned int slow_delay;
1839         unsigned int elapsed_msec;
1840         struct timeval tv;
1841         DEControllerPrivateData *priv =
1842                 (DEControllerPrivateData *) g_object_get_qdata (G_OBJECT (controller),
1843                                                                 spi_dec_private_quark);
1844         if (keycode == priv->last_press_keycode)
1845         {
1846                 slow_delay = dec_xkb_get_slowkeys_delay (controller);
1847                 if (slow_delay)
1848                 {
1849                         gettimeofday (&tv, NULL);
1850                         elapsed_msec =
1851                                 (tv.tv_sec - priv->last_press_time.tv_sec) * 1000
1852                                 + (tv.tv_usec - priv->last_press_time.tv_usec) / 1000;
1853 #ifdef SPI_XKB_DEBUG
1854                         fprintf (stderr, "%d ms elapsed (%ld usec)\n", elapsed_msec,
1855                                  (long) (tv.tv_usec - priv->last_press_time.tv_usec));
1856 #endif
1857 #ifdef THIS_IS_BROKEN_DUNNO_WHY
1858                         if (elapsed_msec < slow_delay)
1859                                 time = slow_delay - elapsed_msec + 1;
1860 #else
1861                         time = slow_delay + 10;
1862                         /* our XTest seems broken, we have to add slop as above */
1863 #endif
1864 #ifdef SPI_XKB_DEBUG
1865                         fprintf (stderr, "waiting %d ms\n", time);
1866 #endif
1867                 }
1868         }
1869         XTestFakeKeyEvent (spi_get_display (), keycode, False, time);
1870         priv->last_release_keycode = keycode;
1871         XSync (spi_get_display (), False);
1872         gettimeofday (&priv->last_release_time, NULL);
1873         return TRUE;
1874 }
1875
1876 static unsigned
1877 dec_get_modifier_state (SpiDEController *controller)
1878 {
1879         return mouse_mask_state;
1880 }
1881
1882 static gboolean
1883 dec_lock_modifiers (SpiDEController *controller, unsigned modifiers)
1884 {
1885         return XkbLockModifiers (spi_get_display (), XkbUseCoreKbd,
1886                           modifiers, modifiers);
1887 }
1888
1889 static gboolean
1890 dec_unlock_modifiers (SpiDEController *controller, unsigned modifiers)
1891 {
1892         return XkbLockModifiers (spi_get_display (), XkbUseCoreKbd,
1893                           modifiers, 0);
1894 }
1895
1896 dec_keysym_for_unichar (SpiDEController *controller, gunichar unichar)
1897 {
1898         /* TODO: table lookups within a range, for various code pages! */
1899         KeySym keysym = NoSymbol;
1900
1901         if (unichar >= 0x20 && unichar < 0x7f) { /* Basic Latin/ASCII */
1902                 keysym = (KeySym) unichar;
1903         }
1904         else if (unichar >= 0xa0 && unichar <= 0xff) { /* Latin 1 extensions */
1905                 keysym = (KeySym) unichar;
1906         }
1907         else if (unichar >= 0x100 && unichar <= 0x233) { /* unfortunately the mapping gets nasty for Latin-2 and 3... help! */
1908                 keysym = NoSymbol;
1909         }
1910         else if (unichar >= 0x7c1 && unichar <= 0x3a1) { /* let's try Greek anyway... */
1911                 keysym = (KeySym) (0x391 + (unichar - 0x7c1));
1912         }
1913         else if (unichar >= 0x3a3 && unichar <= 0x3a9) { /* let's try Greek anyway... */
1914                 keysym = (KeySym) (0x7d2 + (unichar - 0x3a3));
1915         }
1916         else if (unichar >= 0x3b1 && unichar <= 0x3c1) { /* let's try Greek anyway... */
1917                 keysym = (KeySym) (0x7e1 + (unichar - 0x3b1));
1918         }
1919         else if (unichar == 0x3c2) {
1920                 keysym = (KeySym) 0x7f3; /* XK_Greek_finalsmallsigma; */
1921         }
1922         else if (unichar >= 0x3c3 && unichar <= 0x3c9) { /* let's try Greek anyway... */
1923                 keysym = (KeySym) (0x7f2 + (unichar - 0x3c2));
1924         }
1925         else if (unichar >= 0x5d0 && unichar <= 0x5ea) { /* Hebrew basics */
1926                 /* probably broken :-) */
1927                 keysym = (KeySym) (0xce0 + (unichar - 0x5d0));
1928         }
1929         else if (unichar >= 0x30a1 && unichar <= 0x30ab) { /* partial katakana support */
1930                 /* TODO: complete! */
1931                 keysym = (KeySym) (0x4b1 + (unichar - 0x30a1)/2);
1932         }
1933         else if (unichar >= 0x20a0 && unichar <= 0x20ac) { /* currency */
1934                 keysym = (KeySym) unichar; /* how convenient ;-) */
1935         }
1936         return keysym;
1937 }
1938
1939 static gboolean
1940 dec_synth_keysym (SpiDEController *controller, KeySym keysym)
1941 {
1942         KeyCode key_synth_code;
1943         unsigned int modifiers, synth_mods, lock_mods;
1944
1945         key_synth_code = keycode_for_keysym (keysym, &synth_mods);
1946
1947         if ((key_synth_code == 0) || (synth_mods == 0xFF)) return FALSE;
1948
1949         /* TODO: set the modifiers accordingly! */
1950         modifiers = dec_get_modifier_state (controller);
1951         /* side-effect; we may unset mousebutton modifiers here! */
1952
1953         if (synth_mods != modifiers) {
1954                 lock_mods = synth_mods & ~modifiers;
1955                 dec_lock_modifiers (controller, lock_mods);
1956         }
1957         dec_synth_keycode_press (controller, key_synth_code);
1958         dec_synth_keycode_release (controller, key_synth_code);
1959         if (synth_mods != modifiers)
1960                 dec_unlock_modifiers (controller, lock_mods);
1961         return TRUE;
1962 }
1963
1964
1965 static gboolean
1966 dec_synth_keystring (SpiDEController *controller, const CORBA_char *keystring)
1967 {
1968         /* probably we need to create and inject an XIM handler eventually. */
1969         /* for now, try to match the string to existing
1970          * keycode+modifier states.
1971          */
1972         KeySym *keysyms;
1973         gint maxlen = 0;
1974         gunichar unichar = 0;
1975         gint i = 0;
1976         gboolean retval = TRUE;
1977         const gchar *c;
1978
1979         maxlen = strlen (keystring);
1980         keysyms = g_new0 (KeySym, maxlen);
1981         if (!(keystring && *keystring && g_utf8_validate (keystring, -1, &c))) {
1982                 retval = FALSE;
1983         }
1984         else {
1985 #ifdef SPI_DEBUG
1986                 fprintf (stderr, "[keystring synthesis attempted on %s]\n", keystring);
1987 #endif
1988                 while (keystring && (unichar = g_utf8_get_char (keystring))) {
1989                         KeySym keysym;
1990                         char bytes[6];
1991                         gint mbytes;
1992
1993                         mbytes = g_unichar_to_utf8 (unichar, bytes);
1994                         bytes[mbytes] = '\0';
1995 #ifdef SPI_DEBUG
1996                         fprintf (stderr, "[unichar %s]", bytes);
1997 #endif
1998                         keysym = dec_keysym_for_unichar (controller, unichar);
1999                         if (keysym == NoSymbol) {
2000 #ifdef SPI_DEBUG
2001                                 fprintf (stderr, "no keysym for %s", bytes);
2002 #endif
2003                                 retval = FALSE;
2004                                 break;
2005                         }
2006                         keysyms[i++] = keysym;
2007                         keystring = g_utf8_next_char (keystring);
2008                 }
2009                 keysyms[i++] = 0;
2010                 for (i = 0; keysyms[i]; ++i) {
2011                         if (!dec_synth_keysym (controller, keysyms[i])) {
2012 #ifdef SPI_DEBUG
2013                                 fprintf (stderr, "could not synthesize %c\n",
2014                                          (int) keysyms[i]);
2015 #endif
2016                                 retval = FALSE;
2017                                 break;
2018                         }
2019                 }
2020         }
2021         g_free (keysyms);
2022
2023         return retval;
2024 }
2025
2026
2027 /*
2028  * CORBA Accessibility::DEController::registerKeystrokeListener
2029  *     method implementation
2030  */
2031 static void
2032 impl_generate_keyboard_event (PortableServer_Servant           servant,
2033                               const CORBA_long                 keycode,
2034                               const CORBA_char                *keystring,
2035                               const Accessibility_KeySynthType synth_type,
2036                               CORBA_Environment               *ev)
2037 {
2038   SpiDEController *controller =
2039         SPI_DEVICE_EVENT_CONTROLLER (bonobo_object (servant));
2040   long key_synth_code;
2041   KeySym keysym;
2042
2043 #ifdef SPI_DEBUG
2044         fprintf (stderr, "synthesizing keystroke %ld, type %d\n",
2045                  (long) keycode, (int) synth_type);
2046 #endif
2047   /* TODO: hide/wrap/remove X dependency */
2048
2049   /*
2050    * TODO: when initializing, query for XTest extension before using,
2051    * and fall back to XSendEvent() if XTest is not available.
2052    */
2053
2054   gdk_error_trap_push ();
2055   key_synth_code = keycode;
2056
2057   switch (synth_type)
2058     {
2059       case Accessibility_KEY_PRESS:
2060               dec_synth_keycode_press (controller, keycode);
2061               break;
2062       case Accessibility_KEY_PRESSRELEASE:
2063               dec_synth_keycode_press (controller, keycode);
2064       case Accessibility_KEY_RELEASE:
2065               dec_synth_keycode_release (controller, keycode);
2066               break;
2067       case Accessibility_KEY_SYM:
2068 #ifdef SPI_XKB_DEBUG
2069               fprintf (stderr, "KeySym synthesis\n");
2070 #endif
2071               /*
2072                * note: we are using long for 'keycode'
2073                * in our arg list; it can contain either
2074                * a keycode or a keysym.
2075                */
2076               dec_synth_keysym (controller, (KeySym) keycode);
2077               break;
2078       case Accessibility_KEY_STRING:
2079               if (!dec_synth_keystring (controller, keystring))
2080                       fprintf (stderr, "Keystring synthesis failure, string=%s\n",
2081                                keystring);
2082               break;
2083     }
2084   if (gdk_error_trap_pop ())
2085     {
2086       DBG (-1, g_warning ("Error emitting keystroke"));
2087     }
2088   if (synth_type == Accessibility_KEY_SYM) {
2089     keysym = keycode;
2090   }
2091   else {
2092     keysym = XkbKeycodeToKeysym (spi_get_display (), keycode, 0, 0);
2093   }
2094   if (XkbKeysymToModifiers (spi_get_display (), keysym) == 0)
2095     {
2096       spi_dec_clear_unlatch_pending (controller);
2097     }
2098 }
2099
2100 /* Accessibility::DEController::generateMouseEvent */
2101 static void
2102 impl_generate_mouse_event (PortableServer_Servant servant,
2103                            const CORBA_long       x,
2104                            const CORBA_long       y,
2105                            const CORBA_char      *eventName,
2106                            CORBA_Environment     *ev)
2107 {
2108   int button = 0;
2109   gboolean error = FALSE;
2110   Display *display = spi_get_display ();
2111 #ifdef SPI_DEBUG
2112   fprintf (stderr, "generating mouse %s event at %ld, %ld\n",
2113            eventName, (long int) x, (long int) y);
2114 #endif
2115   switch (eventName[0])
2116     {
2117       case 'b':
2118         switch (eventName[1])
2119           {
2120           /* TODO: check number of buttons before parsing */
2121           case '1':
2122                     button = 1;
2123                     break;
2124           case '2':
2125                   button = 2;
2126                   break;
2127           case '3':
2128                   button = 3;
2129                   break;
2130           case '4':
2131                   button = 4;
2132                   break;
2133           case '5':
2134                   button = 5;
2135                   break;
2136           default:
2137                   error = TRUE;
2138           }
2139         if (!error)
2140           {
2141             if (x != -1 && y != -1)
2142               {
2143                 XTestFakeMotionEvent (display, DefaultScreen (display),
2144                                       x, y, 0);
2145               }
2146             XTestFakeButtonEvent (display, button, !(eventName[2] == 'r'), 0);
2147             if (eventName[2] == 'c')
2148               XTestFakeButtonEvent (display, button, FALSE, 1);
2149             else if (eventName[2] == 'd')
2150               {
2151               XTestFakeButtonEvent (display, button, FALSE, 1);
2152               XTestFakeButtonEvent (display, button, TRUE, 2);
2153               XTestFakeButtonEvent (display, button, FALSE, 3);
2154               }
2155           }
2156         break;
2157       case 'r': /* relative motion */
2158         XTestFakeRelativeMotionEvent (display, x, y, 0);
2159         break;
2160       case 'a': /* absolute motion */
2161         XTestFakeMotionEvent (display, DefaultScreen (display),
2162                               x, y, 0);
2163         break;
2164     }
2165 }
2166
2167 /* Accessibility::DEController::notifyListenersSync */
2168 static CORBA_boolean
2169 impl_notify_listeners_sync (PortableServer_Servant           servant,
2170                             const Accessibility_DeviceEvent *event,
2171                             CORBA_Environment               *ev)
2172 {
2173   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (
2174     bonobo_object_from_servant (servant));
2175 #ifdef SPI_DEBUG
2176   g_print ("notifylistening listeners synchronously: controller %p, event id %d\n",
2177            controller, (int) event->id);
2178 #endif
2179   return spi_controller_notify_keylisteners (controller, event, CORBA_FALSE, ev) ?
2180           CORBA_TRUE : CORBA_FALSE;
2181 }
2182
2183 /* Accessibility::DEController::notifyListenersAsync */
2184 static void
2185 impl_notify_listeners_async (PortableServer_Servant           servant,
2186                              const Accessibility_DeviceEvent *event,
2187                              CORBA_Environment               *ev)
2188 {
2189   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (
2190     bonobo_object_from_servant (servant));
2191 #ifdef SPI_DEBUG
2192   fprintf (stderr, "notifying listeners asynchronously\n");
2193 #endif
2194   spi_controller_notify_keylisteners (controller, event, CORBA_FALSE, ev);
2195 }
2196
2197 static void
2198 spi_device_event_controller_class_init (SpiDEControllerClass *klass)
2199 {
2200   GObjectClass * object_class = (GObjectClass *) klass;
2201   POA_Accessibility_DeviceEventController__epv *epv = &klass->epv;
2202
2203   spi_device_event_controller_parent_class = g_type_class_peek_parent (klass);
2204
2205   object_class->finalize = spi_device_event_controller_object_finalize;
2206
2207   epv->registerKeystrokeListener   = impl_register_keystroke_listener;
2208   epv->deregisterKeystrokeListener = impl_deregister_keystroke_listener;
2209   epv->registerDeviceEventListener = impl_register_device_listener;
2210   epv->deregisterDeviceEventListener = impl_deregister_device_listener;
2211   epv->generateKeyboardEvent       = impl_generate_keyboard_event;
2212   epv->generateMouseEvent          = impl_generate_mouse_event;
2213   epv->notifyListenersSync         = impl_notify_listeners_sync;
2214   epv->notifyListenersAsync        = impl_notify_listeners_async;
2215
2216   if (!spi_dec_private_quark)
2217           spi_dec_private_quark = g_quark_from_static_string ("spi-dec-private");
2218 }
2219
2220 static void
2221 spi_device_event_controller_init (SpiDEController *device_event_controller)
2222 {
2223   DEControllerPrivateData *private;
2224   device_event_controller->key_listeners   = NULL;
2225   device_event_controller->mouse_listeners = NULL;
2226   device_event_controller->keygrabs_list   = NULL;
2227
2228   private = g_new0 (DEControllerPrivateData, 1);
2229   gettimeofday (&private->last_press_time, NULL);
2230   gettimeofday (&private->last_release_time, NULL);
2231   g_object_set_qdata (G_OBJECT (device_event_controller),
2232                       spi_dec_private_quark,
2233                       private);
2234   spi_controller_register_with_devices (device_event_controller);
2235 }
2236
2237 static void
2238 spi_device_event_controller_forward_key_event (SpiDEController *controller,
2239                                                const XEvent    *event)
2240 {
2241   gboolean is_consumed = FALSE;
2242   CORBA_Environment ev;
2243   Accessibility_DeviceEvent key_event;
2244
2245   g_assert (event->type == KeyPress || event->type == KeyRelease);
2246
2247   CORBA_exception_init (&ev);
2248
2249   key_event = spi_keystroke_from_x_key_event ((XKeyEvent *) event);
2250
2251   spi_controller_update_key_grabs (controller, &key_event);
2252
2253   /* relay to listeners, and decide whether to consume it or not */
2254   is_consumed = spi_controller_notify_keylisteners (
2255           controller, &key_event, CORBA_TRUE, &ev);
2256
2257   if (is_consumed)
2258     {
2259       XAllowEvents (spi_get_display (), AsyncKeyboard, CurrentTime);
2260     }
2261   else
2262     {
2263       XAllowEvents (spi_get_display (), ReplayKeyboard, CurrentTime);
2264     }
2265 }
2266
2267 SpiDEController *
2268 spi_device_event_controller_new (SpiRegistry *registry)
2269 {
2270   SpiDEController *retval = g_object_new (
2271     SPI_DEVICE_EVENT_CONTROLLER_TYPE, NULL);
2272
2273   retval->registry = SPI_REGISTRY (bonobo_object_ref (
2274           BONOBO_OBJECT (registry)));
2275
2276   spi_dec_init_mouse_listener (registry);
2277   /* TODO: kill mouse listener on finalize */
2278   return retval;
2279 }
2280
2281 BONOBO_TYPE_FUNC_FULL (SpiDEController,
2282                        Accessibility_DeviceEventController,
2283                        PARENT_TYPE,
2284                        spi_device_event_controller)