+ for (l = s; l; l = g_slist_next(l))
+ {
+ Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *)g_malloc(sizeof(Accessibility_KeyDefinition));
+ if (kd)
+ {
+ Accessibility_KeyDefinition *kds = (Accessibility_KeyDefinition *)l->data;
+ kd->keycode = kds->keycode;
+ kd->keysym = kds->keysym;
+ kd->keystring = g_strdup(kds->keystring);
+ d = g_slist_append(d, kd);
+ }
+ }
+ return d;
+}
+
+static DEControllerKeyListener *
+spi_key_listener_clone (DEControllerKeyListener *key_listener)
+{
+ DEControllerKeyListener *clone = g_new0 (DEControllerKeyListener, 1);
+ clone->listener.bus_name = g_strdup (key_listener->listener.bus_name);
+ clone->listener.path = g_strdup (key_listener->listener.path);
+ clone->listener.type = SPI_DEVICE_TYPE_KBD;
+ clone->keys = keylist_clone (key_listener->keys);
+ clone->mask = key_listener->mask;
+ clone->listener.types = key_listener->listener.types;
+ if (key_listener->mode)
+ {
+ clone->mode = (Accessibility_EventListenerMode *)g_malloc(sizeof(Accessibility_EventListenerMode));
+ if (clone->mode) memcpy(clone->mode, key_listener->mode, sizeof(Accessibility_EventListenerMode));
+ }
+ else
+ clone->mode = NULL;
+ return clone;
+}
+
+static void keylist_free(GSList *keys)
+{
+ GSList *l;
+
+ for (l = keys; l; l = g_slist_next(l))
+ {
+ Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *)l->data;
+ g_free(kd->keystring);
+ g_free(kd);
+ }
+ g_slist_free (keys);
+}
+
+static void
+spi_key_listener_data_free (DEControllerKeyListener *key_listener)
+{
+ keylist_free(key_listener->keys);
+ if (key_listener->mode) g_free(key_listener->mode);
+ g_free (key_listener);
+}
+
+static void
+spi_key_listener_clone_free (DEControllerKeyListener *clone)
+{
+ spi_key_listener_data_free (clone);
+}
+
+static void
+spi_listener_clone_free (DEControllerListener *clone)
+{
+ g_free (clone->path);
+ g_free (clone->bus_name);
+ g_free (clone);
+}
+
+static void
+spi_dec_listener_free (DEControllerListener *listener)
+{
+ g_free (listener->bus_name);
+ g_free (listener->path);
+ if (listener->type == SPI_DEVICE_TYPE_KBD)
+ spi_key_listener_data_free ((DEControllerKeyListener *) listener);
+}
+
+static void
+_register_keygrab (SpiDEController *controller,
+ DEControllerGrabMask *grab_mask)
+{
+ GList *l;
+
+ l = g_list_find_custom (controller->keygrabs_list, grab_mask,
+ spi_grab_mask_compare_values);
+ if (l)
+ {
+ DEControllerGrabMask *cur_mask = l->data;
+
+ cur_mask->ref_count++;
+ if (cur_mask->pending_remove)
+ {
+ cur_mask->pending_remove = FALSE;
+ }
+ }
+ else
+ {
+ controller->keygrabs_list =
+ g_list_prepend (controller->keygrabs_list,
+ spi_grab_mask_clone (grab_mask));
+ }
+}
+
+static void
+_deregister_keygrab (SpiDEController *controller,
+ DEControllerGrabMask *grab_mask)
+{
+ GList *l;
+
+ l = g_list_find_custom (controller->keygrabs_list, grab_mask,
+ spi_grab_mask_compare_values);
+
+ if (l)
+ {
+ DEControllerGrabMask *cur_mask = l->data;
+
+ cur_mask->ref_count--;
+ if (cur_mask->ref_count <= 0)
+ {
+ cur_mask->pending_remove = TRUE;
+ }
+ }
+ else
+ {
+ DBG (1, g_warning ("De-registering non-existant grab"));
+ }
+}
+
+static void
+handle_keygrab (SpiDEController *controller,
+ DEControllerKeyListener *key_listener,
+ void (*process_cb) (SpiDEController *controller,
+ DEControllerGrabMask *grab_mask))
+{
+ DEControllerGrabMask grab_mask = { 0 };
+
+ grab_mask.mod_mask = key_listener->mask;
+ if (g_slist_length (key_listener->keys) == 0) /* special case means AnyKey/AllKeys */
+ {
+ grab_mask.key_val = AnyKey;
+#ifdef SPI_DEBUG
+ fprintf (stderr, "AnyKey grab!");
+#endif
+ process_cb (controller, &grab_mask);
+ }
+ else
+ {
+ GSList *l;
+
+ for (l = key_listener->keys; l; l = g_slist_next(l))
+ {
+ Accessibility_KeyDefinition *keydef = l->data;
+ long int key_val = keydef->keysym;
+ /* X Grabs require keycodes, not keysyms */
+ if (keydef->keystring && keydef->keystring[0])
+ {
+ key_val = XStringToKeysym(keydef->keystring);
+ }
+ if (key_val > 0)
+ {
+ key_val = XKeysymToKeycode (spi_get_display (), (KeySym) key_val);
+ }
+ else
+ {
+ key_val = keydef->keycode;
+ }
+ grab_mask.key_val = key_val;
+ process_cb (controller, &grab_mask);
+ }
+ }
+}
+
+static gboolean
+spi_controller_register_global_keygrabs (SpiDEController *controller,
+ DEControllerKeyListener *key_listener)
+{
+ handle_keygrab (controller, key_listener, _register_keygrab);
+ if (controller->xevie_display == NULL)
+ return spi_controller_update_key_grabs (controller, NULL);
+ else
+ return TRUE;
+}
+
+static void
+spi_controller_deregister_global_keygrabs (SpiDEController *controller,
+ DEControllerKeyListener *key_listener)
+{
+ handle_keygrab (controller, key_listener, _deregister_keygrab);
+ if (controller->xevie_display == NULL)
+ spi_controller_update_key_grabs (controller, NULL);
+}
+
+static gboolean
+spi_controller_register_device_listener (SpiDEController *controller,
+ DEControllerListener *listener)
+{
+ DEControllerKeyListener *key_listener;
+
+ switch (listener->type) {
+ case SPI_DEVICE_TYPE_KBD:
+ key_listener = (DEControllerKeyListener *) listener;
+
+ controller->key_listeners = g_list_prepend (controller->key_listeners,
+ key_listener);
+ spi_dbus_add_disconnect_match (controller->registry->droute.bus, key_listener->listener.bus_name);
+ if (key_listener->mode->global)
+ {
+ return spi_controller_register_global_keygrabs (controller, key_listener);
+ }
+ else
+ return TRUE;
+ break;
+ case SPI_DEVICE_TYPE_MOUSE:
+ controller->mouse_listeners = g_list_prepend (controller->mouse_listeners, listener);
+ spi_dbus_add_disconnect_match (controller->registry->droute.bus, listener->bus_name);
+ break;
+ default:
+ DBG (1, g_warning ("listener registration for unknown device type.\n"));
+ break;
+ }
+ return FALSE;
+}
+
+static gboolean Accessibility_DeviceEventListener_notifyEvent(SpiRegistry *registry, DEControllerListener *listener, const Accessibility_DeviceEvent *key_event)
+{
+ DBusMessage *message = dbus_message_new_method_call(listener->bus_name, listener->path, "org.freedesktop.atspi.Registry", "notifyEvent");
+ DBusError error;
+ dbus_bool_t consumed = FALSE;
+
+ dbus_error_init(&error);
+ if (spi_dbus_marshal_deviceEvent(message, key_event))
+ {
+ // TODO: Evaluate performance: perhaps rework this whole architecture
+ // to avoid blocking calls
+ DBusMessage *reply = dbus_connection_send_with_reply_and_block(registry->droute.bus, message, 1000, &error);
+ if (reply)
+ {
+ DBusError error;
+ dbus_error_init(&error);
+ dbus_message_get_args(reply, &error, DBUS_TYPE_BOOLEAN, &consumed, DBUS_TYPE_INVALID);
+ dbus_message_unref(reply);
+ }
+ }
+ dbus_message_unref(message);
+ return consumed;
+}
+
+static gboolean
+spi_controller_notify_mouselisteners (SpiDEController *controller,
+ const Accessibility_DeviceEvent *event)
+{
+ GList *l;
+ GSList *notify = NULL, *l2;
+ GList **listeners = &controller->mouse_listeners;
+ gboolean is_consumed;