#include "deviceeventcontroller.h"
#include "reentrant-list.h"
+#include "introspection.h"
+
KeySym ucs2keysym (long ucs);
long keysym2ucs(KeySym keysym);
static void emit(SpiDEController *controller, const char *interface, const char *name, const char *minor, int a1, int a2)
{
DBusMessage *signal = NULL;
- DBusMessageIter iter, iter_variant;
+ DBusMessageIter iter, iter_struct, iter_variant;
int nil = 0;
const char *path = SPI_DBUS_PATH_ROOT;
+ const char *bus_name = dbus_bus_get_unique_name (controller->bus);
signal = dbus_message_new_signal (path, interface, name);
dbus_message_iter_init_append (signal, &iter);
dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &minor);
- dbus_message_iter_append_basic (&iter, DBUS_TYPE_UINT32, &a1);
- dbus_message_iter_append_basic (&iter, DBUS_TYPE_UINT32, &a2);
+ dbus_message_iter_append_basic (&iter, DBUS_TYPE_INT32, &a1);
+ dbus_message_iter_append_basic (&iter, DBUS_TYPE_INT32, &a2);
dbus_message_iter_open_container (&iter, DBUS_TYPE_VARIANT, "i", &iter_variant);
dbus_message_iter_append_basic (&iter_variant, DBUS_TYPE_INT32, &nil);
dbus_message_iter_close_container (&iter, &iter_variant);
+ dbus_message_iter_open_container (&iter, DBUS_TYPE_STRUCT, NULL,
+ &iter_struct);
+ dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_STRING, &bus_name);
+ dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_OBJECT_PATH, &path);
+ dbus_message_iter_close_container (&iter, &iter_struct);
+
dbus_connection_send (controller->bus, signal, NULL);
+ dbus_message_unref (signal);
}
static gboolean
{
keylist_free(key_listener->keys);
if (key_listener->mode) g_free(key_listener->mode);
+ g_free (key_listener->listener.bus_name);
+ g_free (key_listener->listener.path);
g_free (key_listener);
}
{
have_mouse_listener = TRUE;
if (!have_mouse_event_listener)
- g_timeout_add (100, spi_dec_poll_mouse_idle, controller->registry);
+ g_timeout_add (100, spi_dec_poll_mouse_idle, controller);
}
spi_dbus_add_disconnect_match (controller->bus, listener->bus_name);
break;
return FALSE;
}
+static void
+set_reply (DBusPendingCall *pending, void *user_data)
+{
+ void **replyptr = (void **)user_data;
+
+ *replyptr = dbus_pending_call_steal_reply (pending);
+}
+
+static DBusMessage *
+send_and_allow_reentry (DBusConnection *bus, DBusMessage *message, int timeout, DBusError *error)
+{
+ DBusPendingCall *pending;
+ DBusMessage *reply = NULL;
+
+ if (!dbus_connection_send_with_reply (bus, message, &pending, -1))
+ {
+ return NULL;
+ }
+ dbus_pending_call_set_notify (pending, set_reply, (void *)&reply, NULL);
+ while (!reply)
+ {
+ if (!dbus_connection_read_write_dispatch (bus, timeout))
+ return NULL;
+ }
+ dbus_pending_call_unref (pending);
+ return reply;
+}
static gboolean
Accessibility_DeviceEventListener_NotifyEvent(SpiDEController *controller,
SpiRegistry *registry,
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(controller->bus, message, 1000, &error);
+ DBusMessage *reply = send_and_allow_reentry (controller->bus, message, 1000, &error);
if (reply)
{
DBusError error;
dbus_bool_t ret;
DBusMessage *reply = NULL;
char *keystring;
+ char *sig;
dbus_message_iter_init(message, &iter);
// TODO: verify type signature
dbus_message_iter_next(&iter);
dbus_message_iter_get_basic(&iter, &mask);
dbus_message_iter_next(&iter);
- if (!strcmp (dbus_message_iter_get_signature (&iter), "u"))
+ sig = dbus_message_iter_get_signature (&iter);
+ if (sig && !strcmp (sig, "u"))
dbus_message_iter_get_basic(&iter, &type);
else
{
}
dbus_message_iter_next (&iter_array);
}
+ dbus_free (sig);
dbus_message_iter_next(&iter);
mode = (Accessibility_EventListenerMode *)g_malloc(sizeof(Accessibility_EventListenerMode));
if (mode)
dbus_message_get_sender(message), path, (unsigned long) mask);
#endif
dec_listener = spi_dec_key_listener_new (dbus_message_get_sender(message), path, keys, mask, type, mode);
+ g_free (mode);
ret = spi_controller_register_device_listener (
controller, (DEControllerListener *) dec_listener);
reply = dbus_message_new_method_return (message);
spi_dec_private_quark,
private);
spi_controller_register_with_devices (device_event_controller);
+ device_event_controller->message_queue = g_queue_new ();
+ saved_controller = device_event_controller;
}
static gboolean
SpiDEController *controller)
{
pressed_event = spi_keystroke_from_x_key_event ((XKeyEvent *) event);
- saved_controller = controller;
check_release_handler = g_timeout_add (CHECK_RELEASE_DELAY, check_release, &pressed_event);
}
+/*---------------------------------------------------------------------------*/
+
+static const char *introspection_header =
+"<?xml version=\"1.0\"?>\n";
+
+static const char *introspection_node_element =
+"<node name=\"%s\">\n";
+
+static const char *introspection_footer =
+"</node>";
+
+static DBusMessage *
+impl_Introspect (DBusConnection * bus,
+ DBusMessage * message, void *user_data)
+{
+ GString *output;
+ gchar *final;
+ gint i;
+
+ const gchar *pathstr = SPI_DBUS_PATH_DEC;
+
+ DBusMessage *reply;
+
+ output = g_string_new(introspection_header);
+
+ g_string_append_printf(output, introspection_node_element, pathstr);
+
+ g_string_append (output, spi_org_a11y_atspi_DeviceEventController);
+
+ g_string_append(output, introspection_footer);
+ final = g_string_free(output, FALSE);
+
+ reply = dbus_message_new_method_return (message);
+ dbus_message_append_args(reply, DBUS_TYPE_STRING, &final, DBUS_TYPE_INVALID);
+
+ g_free(final);
+ return reply;
+}
+
+/*---------------------------------------------------------------------------*/
+
+static void
+handle_dec_method_from_idle (DBusConnection *bus, DBusMessage *message, void *user_data)
+{
+ const gchar *iface = dbus_message_get_interface (message);
+ const gchar *member = dbus_message_get_member (message);
+ const gint type = dbus_message_get_type (message);
+ DBusHandlerResult result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+ DBusMessage *reply = NULL;
+
+ if (!strcmp (iface, SPI_DBUS_INTERFACE_DEC))
+ {
+ result = DBUS_HANDLER_RESULT_HANDLED;
+ if (!strcmp (member, "RegisterKeystrokeListener"))
+ reply = impl_register_keystroke_listener (bus, message, user_data);
+ else if (!strcmp (member, "RegisterDeviceEventListener"))
+ reply = impl_register_device_event_listener (bus, message, user_data);
+ else if (!strcmp (member, "DeregisterKeystrokeListener"))
+ reply = impl_deregister_keystroke_listener (bus, message, user_data);
+ else if (!strcmp (member, "DeregisterDeviceEventListener"))
+ reply = impl_deregister_device_event_listener (bus, message, user_data);
+ else if (!strcmp (member, "GenerateKeyboardEvent"))
+ reply = impl_generate_keyboard_event (bus, message, user_data);
+ else if (!strcmp (member, "GenerateMouseEvent"))
+ reply = impl_generate_mouse_event (bus, message, user_data);
+ else if (!strcmp (member, "NotifyListenersSync"))
+ reply = impl_notify_listeners_sync (bus, message, user_data);
+ else if (!strcmp (member, "NotifyListenersAsync"))
+ reply = impl_notify_listeners_async (bus, message, user_data);
+ else
+ result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+ }
+
+ if (!strcmp (iface, "org.freedesktop.DBus.Introspectable"))
+ {
+ result = DBUS_HANDLER_RESULT_HANDLED;
+ if (!strcmp (member, "Introspect"))
+ reply = impl_Introspect (bus, message, user_data);
+ else
+ result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+ }
+
+ if (result == DBUS_HANDLER_RESULT_HANDLED)
+ {
+ if (!reply)
+ {
+ reply = dbus_message_new_method_return (message);
+ }
+
+ dbus_connection_send (bus, reply, NULL);
+ dbus_message_unref (reply);
+ }
+}
+
+static gboolean
+message_queue_dispatch (gpointer data)
+{
+ saved_controller->message_queue_idle = 0;
+ while (!g_queue_is_empty (saved_controller->message_queue))
+ {
+ DBusMessage *message = g_queue_pop_head (saved_controller->message_queue);
+ data = g_queue_pop_head (saved_controller->message_queue);
+ handle_dec_method_from_idle (saved_controller->bus, message, data);
+ dbus_message_unref (message);
+ }
+ return FALSE;
+}
+
static DBusHandlerResult
handle_dec_method (DBusConnection *bus, DBusMessage *message, void *user_data)
{
const gchar *member = dbus_message_get_member (message);
const gint type = dbus_message_get_type (message);
- DBusMessage *reply = NULL;
-
/* Check for basic reasons not to handle */
if (type != DBUS_MESSAGE_TYPE_METHOD_CALL ||
member == NULL ||
iface == NULL)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
- if (strcmp (iface, SPI_DBUS_INTERFACE_DEC))
- return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
-
- if (!strcmp (member, "RegisterKeystrokeListener"))
- reply = impl_register_keystroke_listener (bus, message, user_data);
- else if (!strcmp (member, "RegisterDeviceEventListener"))
- reply = impl_register_device_event_listener (bus, message, user_data);
- else if (!strcmp (member, "DeregisterKeystrokeListener"))
- reply = impl_deregister_keystroke_listener (bus, message, user_data);
- else if (!strcmp (member, "DeregisterDeviceEventListener"))
- reply = impl_deregister_device_event_listener (bus, message, user_data);
- else if (!strcmp (member, "GenerateKeyboardEvent"))
- reply = impl_generate_keyboard_event (bus, message, user_data);
- else if (!strcmp (member, "GenerateMouseEvent"))
- reply = impl_generate_mouse_event (bus, message, user_data);
- else if (!strcmp (member, "NotifyListenersSync"))
- reply = impl_notify_listeners_sync (bus, message, user_data);
- else if (!strcmp (member, "NotifyListenersAsync"))
- reply = impl_notify_listeners_async (bus, message, user_data);
- else
- return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
-
- if (!reply)
- {
- reply = dbus_message_new_method_return (message);
- }
- dbus_connection_send (bus, reply, NULL);
- dbus_message_unref (reply);
-
+ dbus_message_ref (message);
+ g_queue_push_tail (saved_controller->message_queue, message);
+ g_queue_push_tail (saved_controller->message_queue, user_data);
+ if (!saved_controller->message_queue_idle)
+ saved_controller->message_queue_idle = g_idle_add (message_queue_dispatch, NULL);
return DBUS_HANDLER_RESULT_HANDLED;
}
SpiDEController *dec = g_object_new (SPI_DEVICE_EVENT_CONTROLLER_TYPE, NULL);
dec->registry = g_object_ref (reg);
+ reg->dec = g_object_ref (dec);
dec->bus = bus;
dbus_connection_register_object_path (bus, SPI_DBUS_PATH_DEC, &dec_vtable, dec);
{
have_mouse_event_listener = TRUE;
if (!have_mouse_listener)
- g_timeout_add (100, spi_dec_poll_mouse_idle, registry);
+ g_timeout_add (100, spi_dec_poll_mouse_idle, registry->dec);
}
}
projects / platform / upstream / at-spi2-core.git / blobdiff