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_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 DBusHandlerResult
-handle_dec_method (DBusConnection *bus, DBusMessage *message, void *user_data)
+static void
+handle_dec_method_from_idle (DBusConnection *bus, DBusMessage *message, void *user_data)
{
- DBusHandlerResult result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
-
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;
- /* 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))
{
result = DBUS_HANDLER_RESULT_HANDLED;
dbus_connection_send (bus, reply, NULL);
dbus_message_unref (reply);
}
-
- return result;
+}
+
+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 *iface = dbus_message_get_interface (message);
+ const gchar *member = dbus_message_get_member (message);
+ const gint type = dbus_message_get_type (message);
+
+ /* 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;
+
+ 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;
}
static DBusObjectPathVTable dec_vtable =
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