2 * AT-SPI - Assistive Technology Service Provider Interface
3 * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
5 * Copyright 2001 Sun Microsystems Inc.
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.
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.
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.
23 /* deviceeventcontroller.c: implement the DeviceEventController interface */
28 #undef SPI_KEYEVENT_DEBUG
33 #include <bonobo/bonobo-exception.h>
36 #include <X11/extensions/XTest.h>
38 #include <X11/keysymdef.h>
40 #include <gdk/gdkx.h> /* TODO: hide dependency (wrap in single porting file) */
41 #include <gdk/gdkkeysyms.h>
42 #include <gdk/gdkwindow.h>
44 #include "../libspi/spi-private.h"
45 #include "deviceeventcontroller.h"
47 /* Our parent Gtk object type */
48 #define PARENT_TYPE BONOBO_TYPE_OBJECT
50 /* A pointer to our parent object class */
51 static GObjectClass *spi_device_event_controller_parent_class;
52 static int spi_error_code = 0;
53 static GdkPoint *last_mouse_pos = NULL;
55 int (*x_default_error_handler) (Display *display, XErrorEvent *error_event);
59 SPI_DEVICE_TYPE_MOUSE,
60 SPI_DEVICE_TYPE_LAST_DEFINED
61 } SpiDeviceTypeCategory;
65 guint pending_add : 1;
66 guint pending_remove : 1;
68 Accessibility_ControllerEventMask mod_mask;
69 CORBA_unsigned_long key_val; /* KeyCode */
70 } DEControllerGrabMask;
74 SpiDeviceTypeCategory type;
75 } DEControllerListener;
78 DEControllerListener listener;
80 Accessibility_KeySet *keys;
81 Accessibility_ControllerEventMask mask;
82 Accessibility_KeyEventTypeSeq *typeseq;
83 Accessibility_EventListenerMode *mode;
84 } DEControllerKeyListener;
86 static void spi_controller_register_with_devices (SpiDEController *controller);
87 static gboolean spi_controller_update_key_grabs (SpiDEController *controller,
88 Accessibility_DeviceEvent *recv);
89 static gboolean spi_controller_register_device_listener (SpiDEController *controller,
90 DEControllerListener *l,
91 CORBA_Environment *ev);
92 static void spi_device_event_controller_forward_key_event (SpiDEController *controller,
94 static void spi_deregister_controller_key_listener (SpiDEController *controller,
95 DEControllerKeyListener *key_listener,
96 CORBA_Environment *ev);
98 static gboolean spi_clear_error_state (void);
99 static gboolean spi_dec_poll_mouse_moved (gpointer data);
100 static gboolean spi_dec_poll_mouse_moving (gpointer data);
101 static gboolean spi_dec_poll_mouse_idle (gpointer data);
103 #define spi_get_display() GDK_DISPLAY()
105 /* Private methods */
108 keycode_for_keysym (long keysym)
110 return XKeysymToKeycode (spi_get_display (), (KeySym) keysym);
113 static DEControllerGrabMask *
114 spi_grab_mask_clone (DEControllerGrabMask *grab_mask)
116 DEControllerGrabMask *clone = g_new (DEControllerGrabMask, 1);
118 memcpy (clone, grab_mask, sizeof (DEControllerGrabMask));
120 clone->ref_count = 1;
121 clone->pending_add = TRUE;
122 clone->pending_remove = FALSE;
128 spi_grab_mask_free (DEControllerGrabMask *grab_mask)
134 spi_grab_mask_compare_values (gconstpointer p1, gconstpointer p2)
136 DEControllerGrabMask *l1 = (DEControllerGrabMask *) p1;
137 DEControllerGrabMask *l2 = (DEControllerGrabMask *) p2;
145 return ((l1->mod_mask != l2->mod_mask) || (l1->key_val != l2->key_val));
150 spi_dec_poll_mouse_moved (gpointer data)
152 SpiRegistry *registry = SPI_REGISTRY (data);
153 CORBA_Environment ev;
154 Accessibility_Event e;
155 Window root_return, child_return;
156 int win_x_return,win_y_return;
158 unsigned int mask_return;
159 Display *display = spi_get_display ();
160 if (last_mouse_pos == NULL) {
161 last_mouse_pos = g_new0 (GdkPoint, 1);
162 last_mouse_pos->x = 0;
163 last_mouse_pos->y = 0;
164 e.type = g_strdup ("mouse:abs");
166 e.type = g_strdup ("mouse:rel");
169 XQueryPointer(display, DefaultRootWindow (display),
170 &root_return, &child_return,
172 &win_x_return, &win_y_return, &mask_return);
173 if (x != last_mouse_pos->x || y != last_mouse_pos->y) {
174 e.source = BONOBO_OBJREF (registry->desktop);
175 e.detail1 = x - last_mouse_pos->x;
176 e.detail2 = y - last_mouse_pos->y;
177 CORBA_exception_init (&ev);
178 last_mouse_pos->x = x;
179 last_mouse_pos->y = y;
180 Accessibility_Registry_notifyEvent (BONOBO_OBJREF (registry),
189 spi_dec_poll_mouse_idle (gpointer data)
191 if (! spi_dec_poll_mouse_moved (data))
195 g_timeout_add (20, spi_dec_poll_mouse_moving, data);
201 spi_dec_poll_mouse_moving (gpointer data)
203 if (spi_dec_poll_mouse_moved (data))
207 g_timeout_add (100, spi_dec_poll_mouse_idle, data);
213 spi_dec_init_mouse_listener (SpiRegistry *registry)
215 g_timeout_add (100, spi_dec_poll_mouse_idle, registry);
218 static DEControllerKeyListener *
219 spi_dec_key_listener_new (CORBA_Object l,
220 const Accessibility_KeySet *keys,
221 const Accessibility_ControllerEventMask mask,
222 const Accessibility_KeyEventTypeSeq *typeseq,
223 const Accessibility_EventListenerMode *mode,
224 CORBA_Environment *ev)
226 DEControllerKeyListener *key_listener = g_new0 (DEControllerKeyListener, 1);
227 key_listener->listener.object = bonobo_object_dup_ref (l, ev);
228 key_listener->listener.type = SPI_DEVICE_TYPE_KBD;
229 key_listener->keys = ORBit_copy_value (keys, TC_Accessibility_KeySet);
230 key_listener->mask = mask;
231 key_listener->typeseq = ORBit_copy_value (typeseq, TC_Accessibility_KeyEventTypeSeq);
233 key_listener->mode = ORBit_copy_value (mode, TC_Accessibility_EventListenerMode);
235 key_listener->mode = NULL;
238 g_print ("new listener, with mask %x, is_global %d, keys %p (%d)\n",
239 (unsigned int) key_listener->mask,
240 (int) (mode ? mode->global : 0),
241 (void *) key_listener->keys,
242 (int) (key_listener->keys ? key_listener->keys->_length : 0));
248 static DEControllerKeyListener *
249 spi_key_listener_clone (DEControllerKeyListener *key_listener, CORBA_Environment *ev)
251 DEControllerKeyListener *clone = g_new0 (DEControllerKeyListener, 1);
252 clone->listener.object =
253 CORBA_Object_duplicate (key_listener->listener.object, ev);
254 clone->listener.type = SPI_DEVICE_TYPE_KBD;
255 clone->keys = ORBit_copy_value (key_listener->keys, TC_Accessibility_KeySet);
256 clone->mask = key_listener->mask;
257 clone->typeseq = ORBit_copy_value (key_listener->typeseq, TC_Accessibility_KeyEventTypeSeq);
258 if (key_listener->mode)
259 clone->mode = ORBit_copy_value (key_listener->mode, TC_Accessibility_EventListenerMode);
266 spi_key_listener_data_free (DEControllerKeyListener *key_listener, CORBA_Environment *ev)
268 CORBA_free (key_listener->typeseq);
269 CORBA_free (key_listener->keys);
270 g_free (key_listener);
274 spi_key_listener_clone_free (DEControllerKeyListener *clone, CORBA_Environment *ev)
276 CORBA_Object_release (clone->listener.object, ev);
277 spi_key_listener_data_free (clone, ev);
281 spi_dec_key_listener_free (DEControllerKeyListener *key_listener,
282 CORBA_Environment *ev)
284 bonobo_object_release_unref (key_listener->listener.object, ev);
285 spi_key_listener_data_free (key_listener, ev);
289 _register_keygrab (SpiDEController *controller,
290 DEControllerGrabMask *grab_mask)
294 l = g_list_find_custom (controller->keygrabs_list, grab_mask,
295 spi_grab_mask_compare_values);
298 DEControllerGrabMask *cur_mask = l->data;
300 cur_mask->ref_count++;
301 if (cur_mask->pending_remove)
303 cur_mask->pending_remove = FALSE;
308 controller->keygrabs_list =
309 g_list_prepend (controller->keygrabs_list,
310 spi_grab_mask_clone (grab_mask));
315 _deregister_keygrab (SpiDEController *controller,
316 DEControllerGrabMask *grab_mask)
320 l = g_list_find_custom (controller->keygrabs_list, grab_mask,
321 spi_grab_mask_compare_values);
325 DEControllerGrabMask *cur_mask = l->data;
327 cur_mask->ref_count--;
328 if (cur_mask->ref_count <= 0)
330 cur_mask->pending_remove = TRUE;
335 g_warning ("De-registering non-existant grab");
340 handle_keygrab (SpiDEController *controller,
341 DEControllerKeyListener *key_listener,
342 void (*process_cb) (SpiDEController *controller,
343 DEControllerGrabMask *grab_mask))
345 DEControllerGrabMask grab_mask = { 0 };
347 grab_mask.mod_mask = key_listener->mask;
348 if (key_listener->keys->_length == 0) /* special case means AnyKey/AllKeys */
350 grab_mask.key_val = AnyKey;
352 fprintf (stderr, "AnyKey grab!"); */
354 process_cb (controller, &grab_mask);
360 for (i = 0; i < key_listener->keys->_length; ++i)
362 Accessibility_KeyDefinition keydef = key_listener->keys->_buffer[i];
363 long int key_val = keydef.keysym;
364 /* X Grabs require keycodes, not keysyms */
365 if (keydef.keystring && keydef.keystring[0])
367 key_val = XStringToKeysym(keydef.keystring);
371 key_val = XKeysymToKeycode (spi_get_display (), (KeySym) key_val);
375 key_val = keydef.keycode;
377 grab_mask.key_val = key_val;
378 process_cb (controller, &grab_mask);
384 spi_controller_register_global_keygrabs (SpiDEController *controller,
385 DEControllerKeyListener *key_listener)
387 handle_keygrab (controller, key_listener, _register_keygrab);
388 return spi_controller_update_key_grabs (controller, NULL);
392 spi_controller_deregister_global_keygrabs (SpiDEController *controller,
393 DEControllerKeyListener *key_listener)
395 handle_keygrab (controller, key_listener, _deregister_keygrab);
396 spi_controller_update_key_grabs (controller, NULL);
400 spi_controller_register_device_listener (SpiDEController *controller,
401 DEControllerListener *listener,
402 CORBA_Environment *ev)
404 DEControllerKeyListener *key_listener;
406 switch (listener->type) {
407 case SPI_DEVICE_TYPE_KBD:
408 key_listener = (DEControllerKeyListener *) listener;
410 controller->key_listeners = g_list_prepend (controller->key_listeners,
412 if (key_listener->mode->global)
414 return spi_controller_register_global_keygrabs (controller, key_listener);
425 static GdkFilterReturn
426 global_filter_fn (GdkXEvent *gdk_xevent, GdkEvent *event, gpointer data)
428 XEvent *xevent = gdk_xevent;
429 SpiDEController *controller;
431 if (xevent->type != KeyPress && xevent->type != KeyRelease)
433 return GDK_FILTER_CONTINUE;
436 controller = SPI_DEVICE_EVENT_CONTROLLER (data);
438 spi_device_event_controller_forward_key_event (controller, xevent);
440 /* FIXME: is this right ? */
441 return GDK_FILTER_CONTINUE;
445 _spi_controller_device_error_handler (Display *display, XErrorEvent *error)
447 if (error->error_code == BadAccess)
449 g_message ("Could not complete key grab: grab already in use.\n");
450 spi_error_code = BadAccess;
455 return (*x_default_error_handler) (display, error);
460 spi_controller_register_with_devices (SpiDEController *controller)
462 /* calls to device-specific implementations and routines go here */
463 /* register with: keyboard hardware code handler */
464 /* register with: (translated) keystroke handler */
466 gdk_window_add_filter (NULL, global_filter_fn, controller);
468 gdk_window_set_events (gdk_get_default_root_window (),
469 GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK);
471 x_default_error_handler = XSetErrorHandler (_spi_controller_device_error_handler);
474 #define SPI_KEYEVENT_DEBUG
476 spi_key_set_contains_key (Accessibility_KeySet *key_set,
477 const Accessibility_DeviceEvent *key_event)
484 g_print ("null key set!");
488 len = key_set->_length;
490 if (len == 0) /* special case, means "all keys/any key" */
492 g_print ("anykey\n");
496 for (i = 0; i < len; ++i)
498 #ifdef SPI_KEYEVENT_DEBUG
499 g_print ("key_set[%d] = %d; key_event %d, code %d, string %s\n",
500 i, (int) key_set->_buffer[i].keycode,
501 (int) key_event->id, (int) key_event->hw_code,
502 key_event->event_string);
504 if (key_set->_buffer[i].keysym == (CORBA_long) key_event->id)
508 if (key_set->_buffer[i].keycode == (CORBA_long) key_event->hw_code)
512 if (key_event->event_string && key_event->event_string[0] &&
513 !strcmp (key_set->_buffer[i].keystring, key_event->event_string))
523 spi_key_eventtype_seq_contains_event (Accessibility_KeyEventTypeSeq *type_seq,
524 const Accessibility_DeviceEvent *key_event)
532 g_print ("null type seq!");
536 len = type_seq->_length;
538 if (len == 0) /* special case, means "all events/any event" */
543 for (i = 0; i < len; ++i)
546 g_print ("type_seq[%d] = %d; key event type = %d\n", i,
547 (int) type_seq->_buffer[i], (int) key_event->type);
549 if (type_seq->_buffer[i] == (CORBA_long) key_event->type)
559 spi_key_event_matches_listener (const Accessibility_DeviceEvent *key_event,
560 DEControllerKeyListener *listener,
561 CORBA_boolean is_system_global)
563 if ((key_event->modifiers == (CORBA_unsigned_short) (listener->mask & 0xFFFF)) &&
564 spi_key_set_contains_key (listener->keys, key_event) &&
565 spi_key_eventtype_seq_contains_event (listener->typeseq, key_event) &&
566 (is_system_global == listener->mode->global))
577 spi_controller_notify_keylisteners (SpiDEController *controller,
578 const Accessibility_DeviceEvent *key_event,
579 CORBA_boolean is_system_global,
580 CORBA_Environment *ev)
583 GSList *notify = NULL, *l2;
584 GList **key_listeners = &controller->key_listeners;
585 gboolean is_consumed;
592 for (l = *key_listeners; l; l = l->next)
594 DEControllerKeyListener *key_listener = l->data;
596 if (spi_key_event_matches_listener (key_event, key_listener, is_system_global))
598 Accessibility_DeviceEventListener ls = key_listener->listener.object;
600 if (ls != CORBA_OBJECT_NIL)
602 /* we clone (don't dup) the listener, to avoid refcount inc. */
603 notify = g_slist_prepend (notify,
604 spi_key_listener_clone (key_listener, ev));
609 #ifdef SPI_KEYEVENT_DEBUG
612 g_print ("no match for event\n");
617 for (l2 = notify; l2 && !is_consumed; l2 = l2->next)
619 DEControllerKeyListener *key_listener = l2->data;
620 Accessibility_DeviceEventListener ls = key_listener->listener.object;
622 is_consumed = Accessibility_DeviceEventListener_notifyEvent (ls, key_event, ev);
627 spi_deregister_controller_key_listener (controller, key_listener,
629 CORBA_exception_free (ev);
632 CORBA_Object_release (ls, ev);
635 for (; l2; l2 = l2->next)
637 DEControllerKeyListener *key_listener = l2->data;
638 spi_key_listener_clone_free (key_listener, ev);
639 /* clone doesn't have its own ref, so don't use spi_key_listener_free */
642 g_slist_free (notify);
645 if (is_consumed) g_message ("consumed\n");
651 spi_clear_error_state ()
653 gboolean retval = spi_error_code != 0;
658 static Accessibility_DeviceEvent
659 spi_keystroke_from_x_key_event (XKeyEvent *x_key_event)
661 Accessibility_DeviceEvent key_event;
663 const int cbuf_bytes = 20;
664 char cbuf [cbuf_bytes];
666 keysym = XLookupKeysym (x_key_event, 0);
667 key_event.id = (CORBA_long)(keysym);
668 key_event.hw_code = (CORBA_short) x_key_event->keycode;
669 if (((XEvent *) x_key_event)->type == KeyPress)
671 key_event.type = Accessibility_KEY_PRESSED;
675 key_event.type = Accessibility_KEY_RELEASED;
677 key_event.modifiers = (CORBA_unsigned_short)(x_key_event->state);
678 key_event.is_text = CORBA_FALSE;
682 key_event.event_string = CORBA_string_dup ("space");
685 #ifdef SPI_KEYEVENT_DEBUG
686 fprintf(stderr, "Tab\n");
688 key_event.event_string = CORBA_string_dup ("Tab");
691 key_event.event_string = CORBA_string_dup ("Backspace");
694 key_event.event_string = CORBA_string_dup ("Return");
697 key_event.event_string = CORBA_string_dup ("Home");
700 key_event.event_string = CORBA_string_dup ("Page_Down");
703 key_event.event_string = CORBA_string_dup ("Page_Up");
706 key_event.event_string = CORBA_string_dup ("F1");
709 key_event.event_string = CORBA_string_dup ("F2");
712 key_event.event_string = CORBA_string_dup ("F3");
715 key_event.event_string = CORBA_string_dup ("F4");
718 key_event.event_string = CORBA_string_dup ("F5");
721 key_event.event_string = CORBA_string_dup ("F6");
724 key_event.event_string = CORBA_string_dup ("F7");
727 key_event.event_string = CORBA_string_dup ("F8");
730 key_event.event_string = CORBA_string_dup ("F9");
733 key_event.event_string = CORBA_string_dup ("F10");
736 key_event.event_string = CORBA_string_dup ("F11");
739 key_event.event_string = CORBA_string_dup ("F12");
742 key_event.event_string = CORBA_string_dup ("End");
745 key_event.event_string = CORBA_string_dup ("Escape");
748 key_event.event_string = CORBA_string_dup ("Up");
751 key_event.event_string = CORBA_string_dup ("Down");
754 key_event.event_string = CORBA_string_dup ("Left");
757 key_event.event_string = CORBA_string_dup ("Right");
760 if (XLookupString (x_key_event, cbuf, cbuf_bytes, &keysym, NULL) > 0)
762 key_event.event_string = CORBA_string_dup (cbuf);
763 if (isgraph (keysym))
765 key_event.is_text = CORBA_TRUE; /* FIXME: incorrect for some composed chars? */
770 key_event.event_string = CORBA_string_dup ("");
774 key_event.timestamp = (CORBA_unsigned_long) x_key_event->time;
775 #ifdef SPI_KEYEVENT_DEBUG
777 "Key %lu pressed (%c), modifiers %d\n",
778 (unsigned long) keysym,
779 keysym ? (int) keysym : '*',
780 (int) x_key_event->state);
783 fprintf (stderr, "%s%c",
784 (x_key_event->state & Mod1Mask)?"Alt-":"",
785 ((x_key_event->state & ShiftMask)^(x_key_event->state & LockMask))?
786 g_ascii_toupper (keysym) : g_ascii_tolower (keysym));
787 #endif /* SPI_DEBUG */
792 spi_controller_update_key_grabs (SpiDEController *controller,
793 Accessibility_DeviceEvent *recv)
796 gboolean update_failed = FALSE;
798 g_return_val_if_fail (controller != NULL, FALSE);
801 * masks known to work with default RH 7.1+:
802 * 0 (no mods), LockMask, Mod1Mask, Mod2Mask, ShiftMask,
803 * ShiftMask|LockMask, Mod1Mask|LockMask, Mod2Mask|LockMask,
804 * ShiftMask|Mod1Mask, ShiftMask|Mod2Mask, Mod1Mask|Mod2Mask,
805 * ShiftMask|LockMask|Mod1Mask, ShiftMask|LockMask|Mod2Mask,
807 * ControlMask grabs are broken, must be in use already
809 for (l = controller->keygrabs_list; l; l = next)
812 gboolean re_issue_grab;
813 DEControllerGrabMask *grab_mask = l->data;
817 re_issue_grab = recv &&
818 /* (recv->type == Accessibility_KEY_RELEASED) && - (?) */
819 (recv->modifiers & grab_mask->mod_mask) &&
820 (grab_mask->key_val == keycode_for_keysym (recv->id));
823 fprintf (stderr, "mask=%lx %lx (%c%c) %s\n",
824 (long int) grab_mask->key_val,
825 (long int) grab_mask->mod_mask,
826 grab_mask->pending_add ? '+' : '.',
827 grab_mask->pending_remove ? '-' : '.',
828 re_issue_grab ? "re-issue": "");
833 if (grab_mask->pending_add && grab_mask->pending_remove)
837 else if (grab_mask->pending_remove)
840 fprintf (stderr, "ungrabbing, mask=%x\n", grab_mask->mod_mask);
842 XUngrabKey (spi_get_display (),
845 gdk_x11_get_default_root_xwindow ());
849 else if (grab_mask->pending_add || re_issue_grab)
853 fprintf (stderr, "grab with mask %x\n", grab_mask->mod_mask);
855 XGrabKey (spi_get_display (),
858 gdk_x11_get_default_root_xwindow (),
862 XSync (spi_get_display (), False);
863 update_failed = spi_clear_error_state ();
865 while (grab_mask->ref_count > 0) --grab_mask->ref_count;
870 grab_mask->pending_add = FALSE;
871 grab_mask->pending_remove = FALSE;
875 g_assert (grab_mask->ref_count <= 0);
877 controller->keygrabs_list = g_list_delete_link (
878 controller->keygrabs_list, l);
880 spi_grab_mask_free (grab_mask);
885 return ! update_failed;
889 * Implemented GObject::finalize
892 spi_device_event_controller_object_finalize (GObject *object)
894 SpiDEController *controller;
896 controller = SPI_DEVICE_EVENT_CONTROLLER (object);
899 fprintf(stderr, "spi_device_event_controller_object_finalize called\n");
901 /* disconnect any special listeners, get rid of outstanding keygrabs */
902 XUngrabKey (spi_get_display (), AnyKey, AnyModifier, DefaultRootWindow (spi_get_display ()));
904 spi_device_event_controller_parent_class->finalize (object);
908 * CORBA Accessibility::DEController::registerKeystrokeListener
909 * method implementation
912 impl_register_keystroke_listener (PortableServer_Servant servant,
913 const Accessibility_DeviceEventListener l,
914 const Accessibility_KeySet *keys,
915 const Accessibility_ControllerEventMask mask,
916 const Accessibility_KeyEventTypeSeq *type,
917 const Accessibility_EventListenerMode *mode,
918 CORBA_Environment *ev)
920 SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (
921 bonobo_object_from_servant (servant));
922 DEControllerKeyListener *dec_listener;
924 fprintf (stderr, "registering keystroke listener %p with maskVal %lu\n",
925 (void *) l, (unsigned long) mask);
927 dec_listener = spi_dec_key_listener_new (l, keys, mask, type, mode, ev);
928 return spi_controller_register_device_listener (
929 controller, (DEControllerListener *) dec_listener, ev);
934 CORBA_Environment *ev;
935 DEControllerKeyListener *key_listener;
936 } RemoveKeyListenerClosure;
938 static SpiReEntrantContinue
939 remove_key_listener_cb (GList * const *list,
942 DEControllerKeyListener *key_listener = (*list)->data;
943 RemoveKeyListenerClosure *ctx = user_data;
945 if (CORBA_Object_is_equivalent (ctx->key_listener->listener.object,
946 key_listener->listener.object, ctx->ev))
948 spi_re_entrant_list_delete_link (list);
949 spi_dec_key_listener_free (key_listener, ctx->ev);
952 return SPI_RE_ENTRANT_CONTINUE;
955 static SpiReEntrantContinue
956 copy_key_listener_cb (GList * const *list,
959 DEControllerKeyListener *key_listener = (*list)->data;
960 RemoveKeyListenerClosure *ctx = user_data;
962 if (CORBA_Object_is_equivalent (ctx->key_listener->listener.object,
963 key_listener->listener.object, ctx->ev))
965 /* TODO: FIXME aggregate keys in case the listener is registered twice */
966 CORBA_free (ctx->key_listener->keys);
967 ctx->key_listener->keys = ORBit_copy_value (key_listener->keys, TC_Accessibility_KeySet);
970 return SPI_RE_ENTRANT_CONTINUE;
975 spi_deregister_controller_key_listener (SpiDEController *controller,
976 DEControllerKeyListener *key_listener,
977 CORBA_Environment *ev)
979 RemoveKeyListenerClosure ctx;
982 ctx.key_listener = key_listener;
984 /* special case, copy keyset from existing controller list entry */
985 if (key_listener->keys->_length == 0)
987 spi_re_entrant_list_foreach (&controller->key_listeners,
988 copy_key_listener_cb, &ctx);
991 spi_controller_deregister_global_keygrabs (controller, key_listener);
993 spi_re_entrant_list_foreach (&controller->key_listeners,
994 remove_key_listener_cb, &ctx);
999 * CORBA Accessibility::DEController::deregisterKeystrokeListener
1000 * method implementation
1003 impl_deregister_keystroke_listener (PortableServer_Servant servant,
1004 const Accessibility_DeviceEventListener l,
1005 const Accessibility_KeySet *keys,
1006 const Accessibility_ControllerEventMask mask,
1007 const Accessibility_KeyEventTypeSeq *type,
1008 CORBA_Environment *ev)
1010 DEControllerKeyListener *key_listener;
1011 SpiDEController *controller;
1013 controller = SPI_DEVICE_EVENT_CONTROLLER (bonobo_object (servant));
1015 key_listener = spi_dec_key_listener_new (l, keys, mask, type, NULL, ev);
1017 #ifdef SPI_DEREGISTER_DEBUG
1018 fprintf (stderr, "deregistering keystroke listener %p with maskVal %lu\n",
1019 (void *) l, (unsigned long) mask->value);
1022 spi_deregister_controller_key_listener (controller, key_listener, ev);
1024 spi_dec_key_listener_free (key_listener, ev);
1028 * CORBA Accessibility::DEController::registerKeystrokeListener
1029 * method implementation
1032 impl_generate_keyboard_event (PortableServer_Servant servant,
1033 const CORBA_long keycode,
1034 const CORBA_char *keystring,
1035 const Accessibility_KeySynthType synth_type,
1036 CORBA_Environment *ev)
1038 long key_synth_code;
1041 fprintf (stderr, "synthesizing keystroke %ld, type %d\n",
1042 (long) keycode, (int) synth_type);
1044 /* TODO: hide/wrap/remove X dependency */
1046 /* TODO: be accessX-savvy so that keyrelease occurs after sufficient timeout */
1049 * TODO: when initializing, query for XTest extension before using,
1050 * and fall back to XSendEvent() if XTest is not available.
1053 /* TODO: implement keystring mode also */
1054 gdk_error_trap_push ();
1058 case Accessibility_KEY_PRESS:
1059 XTestFakeKeyEvent (spi_get_display (), (unsigned int) keycode, True, CurrentTime);
1061 case Accessibility_KEY_PRESSRELEASE:
1062 XTestFakeKeyEvent (spi_get_display (), (unsigned int) keycode, True, CurrentTime);
1063 case Accessibility_KEY_RELEASE:
1064 XTestFakeKeyEvent (spi_get_display (), (unsigned int) keycode, False, CurrentTime);
1066 case Accessibility_KEY_SYM:
1067 key_synth_code = keycode_for_keysym (keycode);
1068 XTestFakeKeyEvent (spi_get_display (), (unsigned int) key_synth_code, True, CurrentTime);
1069 XTestFakeKeyEvent (spi_get_display (), (unsigned int) key_synth_code, False, CurrentTime);
1071 case Accessibility_KEY_STRING:
1072 fprintf (stderr, "Not yet implemented\n");
1075 if (gdk_error_trap_pop ())
1077 g_warning ("Error emitting keystroke");
1081 /* Accessibility::DEController::generateMouseEvent */
1083 impl_generate_mouse_event (PortableServer_Servant servant,
1086 const CORBA_char *eventName,
1087 CORBA_Environment *ev)
1090 gboolean error = FALSE;
1091 Display *display = spi_get_display ();
1093 fprintf (stderr, "generating mouse %s event at %ld, %ld\n",
1094 eventName, (long int) x, (long int) y);
1096 g_message ("mouse event synthesis\n");
1097 switch (eventName[0])
1100 switch (eventName[1])
1102 /* TODO: check number of buttons before parsing */
1117 if (x != -1 && y != -1)
1119 XTestFakeMotionEvent (display, DefaultScreen (display),
1122 XTestFakeButtonEvent (display, button, !(eventName[2] == 'r'), 0);
1123 if (eventName[2] == 'c')
1124 XTestFakeButtonEvent (display, button, FALSE, 1);
1125 else if (eventName[2] == 'd')
1127 XTestFakeButtonEvent (display, button, FALSE, 1);
1128 XTestFakeButtonEvent (display, button, TRUE, 2);
1129 XTestFakeButtonEvent (display, button, FALSE, 3);
1133 case 'r': /* relative motion */
1134 XTestFakeRelativeMotionEvent (display, x, y, 0);
1136 case 'a': /* absolute motion */
1137 XTestFakeMotionEvent (display, DefaultScreen (display),
1143 /* Accessibility::DEController::notifyListenersSync */
1144 static CORBA_boolean
1145 impl_notify_listeners_sync (PortableServer_Servant servant,
1146 const Accessibility_DeviceEvent *event,
1147 CORBA_Environment *ev)
1149 SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (
1150 bonobo_object_from_servant (servant));
1152 g_print ("notifylistening listeners synchronously: controller %p, event id %d\n",
1153 controller, (int) event->id);
1155 return spi_controller_notify_keylisteners (controller, event, CORBA_FALSE, ev) ?
1156 CORBA_TRUE : CORBA_FALSE;
1159 /* Accessibility::DEController::notifyListenersAsync */
1161 impl_notify_listeners_async (PortableServer_Servant servant,
1162 const Accessibility_DeviceEvent *event,
1163 CORBA_Environment *ev)
1165 SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (
1166 bonobo_object_from_servant (servant));
1168 fprintf (stderr, "notifying listeners asynchronously\n");
1170 spi_controller_notify_keylisteners (controller, event, CORBA_FALSE, ev);
1174 spi_device_event_controller_class_init (SpiDEControllerClass *klass)
1176 GObjectClass * object_class = (GObjectClass *) klass;
1177 POA_Accessibility_DeviceEventController__epv *epv = &klass->epv;
1179 spi_device_event_controller_parent_class = g_type_class_peek_parent (klass);
1181 object_class->finalize = spi_device_event_controller_object_finalize;
1183 epv->registerKeystrokeListener = impl_register_keystroke_listener;
1184 epv->deregisterKeystrokeListener = impl_deregister_keystroke_listener;
1185 epv->generateKeyboardEvent = impl_generate_keyboard_event;
1186 epv->generateMouseEvent = impl_generate_mouse_event;
1187 epv->notifyListenersSync = impl_notify_listeners_sync;
1188 epv->notifyListenersAsync = impl_notify_listeners_async;
1192 spi_device_event_controller_init (SpiDEController *device_event_controller)
1194 device_event_controller->key_listeners = NULL;
1195 device_event_controller->mouse_listeners = NULL;
1196 device_event_controller->keygrabs_list = NULL;
1199 * TODO: fixme, this module makes the foolish assumptions that
1200 * registryd uses the same display as the apps, and that the
1201 * DISPLAY environment variable is set.
1203 gdk_init (NULL, NULL);
1205 spi_controller_register_with_devices (device_event_controller);
1209 spi_device_event_controller_forward_key_event (SpiDEController *controller,
1210 const XEvent *event)
1212 gboolean is_consumed = FALSE;
1213 CORBA_Environment ev;
1214 Accessibility_DeviceEvent key_event;
1216 g_assert (event->type == KeyPress || event->type == KeyRelease);
1218 CORBA_exception_init (&ev);
1220 key_event = spi_keystroke_from_x_key_event ((XKeyEvent *) event);
1222 spi_controller_update_key_grabs (controller, &key_event);
1224 /* relay to listeners, and decide whether to consume it or not */
1225 is_consumed = spi_controller_notify_keylisteners (
1226 controller, &key_event, CORBA_TRUE, &ev);
1228 CORBA_exception_free (&ev);
1232 XAllowEvents (spi_get_display (), AsyncKeyboard, CurrentTime);
1236 XAllowEvents (spi_get_display (), ReplayKeyboard, CurrentTime);
1241 spi_device_event_controller_new (SpiRegistry *registry)
1243 SpiDEController *retval = g_object_new (
1244 SPI_DEVICE_EVENT_CONTROLLER_TYPE, NULL);
1246 retval->registry = SPI_REGISTRY (bonobo_object_ref (
1247 BONOBO_OBJECT (registry)));
1249 spi_dec_init_mouse_listener (registry);
1250 /* TODO: kill mouse listener on finalize */
1255 BONOBO_TYPE_FUNC_FULL (SpiDEController,
1256 Accessibility_DeviceEventController,
1258 spi_device_event_controller);