diff options
Diffstat (limited to 'registryd')
| -rw-r--r-- | registryd/de-marshaller.c | 90 | ||||
| -rw-r--r-- | registryd/de-marshaller.h | 8 | ||||
| -rw-r--r-- | registryd/de-types.h | 46 | ||||
| -rw-r--r-- | registryd/deviceeventcontroller-x11.c | 1425 | ||||
| -rw-r--r-- | registryd/deviceeventcontroller-x11.h | 11 | ||||
| -rw-r--r-- | registryd/deviceeventcontroller.c | 1138 | ||||
| -rw-r--r-- | registryd/deviceeventcontroller.h | 65 | ||||
| -rw-r--r-- | registryd/display.c | 74 | ||||
| -rw-r--r-- | registryd/event-source.c | 71 | ||||
| -rw-r--r-- | registryd/event-source.h | 2 | ||||
| -rw-r--r-- | registryd/keymasks.h | 30 | ||||
| -rw-r--r-- | registryd/paths.h | 38 | ||||
| -rw-r--r-- | registryd/reentrant-list.c | 72 | ||||
| -rw-r--r-- | registryd/reentrant-list.h | 19 | ||||
| -rw-r--r-- | registryd/registry-main.c | 262 | ||||
| -rw-r--r-- | registryd/registry.c | 402 | ||||
| -rw-r--r-- | registryd/registry.h | 24 | ||||
| -rw-r--r-- | registryd/ucs2keysym.c | 89 |
18 files changed, 1972 insertions, 1894 deletions
diff --git a/registryd/de-marshaller.c b/registryd/de-marshaller.c index f1094846..8c65bfe7 100644 --- a/registryd/de-marshaller.c +++ b/registryd/de-marshaller.c @@ -20,85 +20,93 @@ * Boston, MA 02110-1301, USA. */ -#include <stdlib.h> -#include <glib.h> -#include <glib-object.h> #include <dbus/dbus.h> +#include <glib-object.h> +#include <glib.h> +#include <stdlib.h> #include "de-types.h" -dbus_bool_t spi_dbus_message_iter_get_struct(DBusMessageIter *iter, ...) +dbus_bool_t +spi_dbus_message_iter_get_struct (DBusMessageIter *iter, ...) { va_list args; DBusMessageIter iter_struct; int type; void *ptr; - dbus_message_iter_recurse(iter, &iter_struct); - va_start(args, iter); + dbus_message_iter_recurse (iter, &iter_struct); + va_start (args, iter); for (;;) - { - type = va_arg(args, int); - if (type == DBUS_TYPE_INVALID) break; - if (type != dbus_message_iter_get_arg_type(&iter_struct)) { - va_end(args); - return FALSE; + type = va_arg (args, int); + if (type == DBUS_TYPE_INVALID) + break; + if (type != dbus_message_iter_get_arg_type (&iter_struct)) + { + va_end (args); + return FALSE; + } + ptr = va_arg (args, void *); + dbus_message_iter_get_basic (&iter_struct, ptr); + dbus_message_iter_next (&iter_struct); } - ptr = va_arg(args, void *); - dbus_message_iter_get_basic(&iter_struct, ptr); - dbus_message_iter_next(&iter_struct); - } - dbus_message_iter_next(iter); - va_end(args); + dbus_message_iter_next (iter); + va_end (args); return TRUE; } -dbus_bool_t spi_dbus_message_iter_append_struct(DBusMessageIter *iter, ...) +dbus_bool_t +spi_dbus_message_iter_append_struct (DBusMessageIter *iter, ...) { va_list args; DBusMessageIter iter_struct; int type; void *ptr; - if (!dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT, NULL, &iter_struct)) return FALSE; - va_start(args, iter); - for (;;) - { - type = va_arg(args, int); - if (type == DBUS_TYPE_INVALID) break; - ptr = va_arg(args, void *); - dbus_message_iter_append_basic(&iter_struct, type, ptr); - } - if (!dbus_message_iter_close_container(iter, &iter_struct)) - { - va_end(args); + if (!dbus_message_iter_open_container (iter, DBUS_TYPE_STRUCT, NULL, &iter_struct)) return FALSE; - } - va_end(args); + va_start (args, iter); + for (;;) + { + type = va_arg (args, int); + if (type == DBUS_TYPE_INVALID) + break; + ptr = va_arg (args, void *); + dbus_message_iter_append_basic (&iter_struct, type, ptr); + } + if (!dbus_message_iter_close_container (iter, &iter_struct)) + { + va_end (args); + return FALSE; + } + va_end (args); return TRUE; } -dbus_bool_t spi_dbus_marshal_deviceEvent(DBusMessage *message, const Accessibility_DeviceEvent *e) +dbus_bool_t +spi_dbus_marshal_deviceEvent (DBusMessage *message, const Accessibility_DeviceEvent *e) { DBusMessageIter iter; - if (!message) return FALSE; - dbus_message_iter_init_append(message, &iter); - return spi_dbus_message_iter_append_struct(&iter, DBUS_TYPE_UINT32, &e->type, DBUS_TYPE_INT32, &e->id, DBUS_TYPE_UINT32, &e->hw_code, DBUS_TYPE_UINT32, &e->modifiers, DBUS_TYPE_INT32, &e->timestamp, DBUS_TYPE_STRING, &e->event_string, DBUS_TYPE_BOOLEAN, &e->is_text, DBUS_TYPE_INVALID); + if (!message) + return FALSE; + dbus_message_iter_init_append (message, &iter); + return spi_dbus_message_iter_append_struct (&iter, DBUS_TYPE_UINT32, &e->type, DBUS_TYPE_INT32, &e->id, DBUS_TYPE_UINT32, &e->hw_code, DBUS_TYPE_UINT32, &e->modifiers, DBUS_TYPE_INT32, &e->timestamp, DBUS_TYPE_STRING, &e->event_string, DBUS_TYPE_BOOLEAN, &e->is_text, DBUS_TYPE_INVALID); } -dbus_bool_t spi_dbus_demarshal_deviceEvent(DBusMessage *message, Accessibility_DeviceEvent *e) +dbus_bool_t +spi_dbus_demarshal_deviceEvent (DBusMessage *message, Accessibility_DeviceEvent *e) { DBusMessageIter iter; dbus_uint16_t hw_code; dbus_uint16_t modifiers; - dbus_message_iter_init(message, &iter); - if (spi_dbus_message_iter_get_struct(&iter, DBUS_TYPE_UINT32, &e->type, DBUS_TYPE_INT32, &e->id, DBUS_TYPE_INT32, &e->hw_code, DBUS_TYPE_INT32, &e->modifiers, DBUS_TYPE_INT32, &e->timestamp, DBUS_TYPE_STRING, &e->event_string, DBUS_TYPE_BOOLEAN, &e->is_text, DBUS_TYPE_INVALID)) + dbus_message_iter_init (message, &iter); + if (spi_dbus_message_iter_get_struct (&iter, DBUS_TYPE_UINT32, &e->type, DBUS_TYPE_INT32, &e->id, DBUS_TYPE_INT32, &e->hw_code, DBUS_TYPE_INT32, &e->modifiers, DBUS_TYPE_INT32, &e->timestamp, DBUS_TYPE_STRING, &e->event_string, DBUS_TYPE_BOOLEAN, &e->is_text, DBUS_TYPE_INVALID)) return TRUE; /* TODO: Perhaps remove the below code for 2.1 */ - if (!spi_dbus_message_iter_get_struct(&iter, DBUS_TYPE_UINT32, &e->type, DBUS_TYPE_INT32, &e->id, DBUS_TYPE_INT16, &hw_code, DBUS_TYPE_INT16, &modifiers, DBUS_TYPE_INT32, &e->timestamp, DBUS_TYPE_STRING, &e->event_string, DBUS_TYPE_BOOLEAN, &e->is_text, DBUS_TYPE_INVALID)) + if (!spi_dbus_message_iter_get_struct (&iter, DBUS_TYPE_UINT32, &e->type, DBUS_TYPE_INT32, &e->id, DBUS_TYPE_INT16, &hw_code, DBUS_TYPE_INT16, &modifiers, DBUS_TYPE_INT32, &e->timestamp, DBUS_TYPE_STRING, &e->event_string, DBUS_TYPE_BOOLEAN, &e->is_text, DBUS_TYPE_INVALID)) return FALSE; e->hw_code = hw_code; e->modifiers = modifiers; diff --git a/registryd/de-marshaller.h b/registryd/de-marshaller.h index 93eaa423..ddaf1360 100644 --- a/registryd/de-marshaller.h +++ b/registryd/de-marshaller.h @@ -29,9 +29,9 @@ #include "de-types.h" -dbus_bool_t spi_dbus_message_iter_get_struct(DBusMessageIter *iter, ...); -dbus_bool_t spi_dbus_message_iter_append_struct(DBusMessageIter *iter, ...); -dbus_bool_t spi_dbus_marshal_deviceEvent(DBusMessage *message, const Accessibility_DeviceEvent *e); -dbus_bool_t spi_dbus_demarshal_deviceEvent(DBusMessage *message, Accessibility_DeviceEvent *e); +dbus_bool_t spi_dbus_message_iter_get_struct (DBusMessageIter *iter, ...); +dbus_bool_t spi_dbus_message_iter_append_struct (DBusMessageIter *iter, ...); +dbus_bool_t spi_dbus_marshal_deviceEvent (DBusMessage *message, const Accessibility_DeviceEvent *e); +dbus_bool_t spi_dbus_demarshal_deviceEvent (DBusMessage *message, Accessibility_DeviceEvent *e); #endif /* SPI_DE_MARSHALLER_H_ */ diff --git a/registryd/de-types.h b/registryd/de-types.h index d26cc90f..656aded1 100644 --- a/registryd/de-types.h +++ b/registryd/de-types.h @@ -29,45 +29,51 @@ typedef unsigned long Accessibility_ControllerEventMask; -typedef enum { - Accessibility_KEY_PRESSED_EVENT, - Accessibility_KEY_RELEASED_EVENT, - Accessibility_BUTTON_PRESSED_EVENT, - Accessibility_BUTTON_RELEASED_EVENT, +typedef enum +{ + Accessibility_KEY_PRESSED_EVENT, + Accessibility_KEY_RELEASED_EVENT, + Accessibility_BUTTON_PRESSED_EVENT, + Accessibility_BUTTON_RELEASED_EVENT, } Accessibility_EventType; -typedef enum { - Accessibility_KEY_PRESSED, - Accessibility_KEY_RELEASED, +typedef enum +{ + Accessibility_KEY_PRESSED, + Accessibility_KEY_RELEASED, } Accessibility_KeyEventType; -typedef enum { - Accessibility_KEY_PRESS, - Accessibility_KEY_RELEASE, - Accessibility_KEY_PRESSRELEASE, - Accessibility_KEY_SYM, - Accessibility_KEY_STRING, - Accessibility_KEY_LOCKMODIFIERS, - Accessibility_KEY_UNLOCKMODIFIERS, +typedef enum +{ + Accessibility_KEY_PRESS, + Accessibility_KEY_RELEASE, + Accessibility_KEY_PRESSRELEASE, + Accessibility_KEY_SYM, + Accessibility_KEY_STRING, + Accessibility_KEY_LOCKMODIFIERS, + Accessibility_KEY_UNLOCKMODIFIERS, } Accessibility_KeySynthType; -typedef struct { +typedef struct +{ Accessibility_EventType type; dbus_uint32_t id; dbus_uint32_t hw_code; dbus_uint32_t modifiers; dbus_uint32_t timestamp; - char * event_string; + char *event_string; dbus_bool_t is_text; } Accessibility_DeviceEvent; -typedef struct { +typedef struct +{ dbus_bool_t synchronous; dbus_bool_t preemptive; dbus_bool_t global; } Accessibility_EventListenerMode; -typedef struct { +typedef struct +{ dbus_int32_t keycode; dbus_int32_t keysym; char *keystring; diff --git a/registryd/deviceeventcontroller-x11.c b/registryd/deviceeventcontroller-x11.c index 689191f7..d5cae611 100644 --- a/registryd/deviceeventcontroller-x11.c +++ b/registryd/deviceeventcontroller-x11.c @@ -25,13 +25,13 @@ #include <config.h> -#undef SPI_XKB_DEBUG -#undef SPI_DEBUG -#undef SPI_KEYEVENT_DEBUG +#undef SPI_XKB_DEBUG +#undef SPI_DEBUG +#undef SPI_KEYEVENT_DEBUG -#include <string.h> #include <ctype.h> #include <stdio.h> +#include <string.h> #include <sys/time.h> #define XK_MISCELLANY @@ -42,49 +42,50 @@ #include <dbus/dbus.h> -#include "paths.h" -#include "keymasks.h" -#include "de-types.h" #include "de-marshaller.h" +#include "de-types.h" #include "display.h" #include "event-source.h" +#include "keymasks.h" +#include "paths.h" #include "deviceeventcontroller.h" + #include "deviceeventcontroller-x11.h" #include "reentrant-list.h" static void spi_dec_x11_emit_modifier_event (SpiDEController *controller, - guint prev_mask, - guint current_mask); + guint prev_mask, + guint current_mask); #define CHECK_RELEASE_DELAY 20 -#define BIT(c, x) (c[x/8]&(1<<(x%8))) +#define BIT(c, x) (c[x / 8] & (1 << (x % 8))) static guint check_release_handler = 0; static Accessibility_DeviceEvent pressed_event; static void wait_for_release_event (XEvent *event, SpiDEController *controller); static int spi_error_code = 0; -typedef struct { - gint x; - gint y; +typedef struct +{ + gint x; + gint y; } SpiPoint; -static SpiPoint last_mouse_pos_static = {0, 0}; +static SpiPoint last_mouse_pos_static = { 0, 0 }; static SpiPoint *last_mouse_pos = &last_mouse_pos_static; static unsigned int mouse_mask_state = 0; static unsigned int mouse_button_mask = - Button1Mask | Button2Mask | Button3Mask | Button4Mask | Button5Mask; + Button1Mask | Button2Mask | Button3Mask | Button4Mask | Button5Mask; static unsigned int key_modifier_mask = - Mod1Mask | Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask | ShiftMask | LockMask | ControlMask | SPI_KEYMASK_NUMLOCK; + Mod1Mask | Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask | ShiftMask | LockMask | ControlMask | SPI_KEYMASK_NUMLOCK; extern unsigned int _numlock_physical_mask; -static XModifierKeymap* xmkeymap = NULL; - +static XModifierKeymap *xmkeymap = NULL; static int (*x_default_error_handler) (Display *display, XErrorEvent *error_event); -static void spi_controller_register_with_devices (SpiDEController *controller); -static gboolean spi_device_event_controller_forward_key_event (SpiDEController *controller, - const XEvent *event); +static void spi_controller_register_with_devices (SpiDEController *controller); +static gboolean spi_device_event_controller_forward_key_event (SpiDEController *controller, + const XEvent *event); static SpiDEController *saved_controller; @@ -99,66 +100,76 @@ static SpiDEController *saved_controller; static SpiDEControllerPrivate * spi_device_event_controller_get_instance_private (SpiDEController *controller) { - return g_type_instance_get_private ((GTypeInstance *) controller, SPI_DEVICE_EVENT_CONTROLLER_TYPE); + return g_type_instance_get_private ((GTypeInstance *) controller, SPI_DEVICE_EVENT_CONTROLLER_TYPE); } static unsigned int keysym_mod_mask (KeySym keysym, KeyCode keycode) { - /* we really should use XKB and look directly at the keymap */ - /* this is very inelegant */ - Display *display = spi_get_display (); - unsigned int mods_rtn = 0; - unsigned int retval = 0; - KeySym sym_rtn; - - if (XkbLookupKeySym (display, keycode, 0, &mods_rtn, &sym_rtn) && - (sym_rtn == keysym)) { - retval = 0; - } - else if (XkbLookupKeySym (display, keycode, ShiftMask, &mods_rtn, &sym_rtn) && - (sym_rtn == keysym)) { - retval = ShiftMask; - } - else if (XkbLookupKeySym (display, keycode, Mod2Mask, &mods_rtn, &sym_rtn) && - (sym_rtn == keysym)) { - retval = Mod2Mask; - } - else if (XkbLookupKeySym (display, keycode, Mod3Mask, &mods_rtn, &sym_rtn) && - (sym_rtn == keysym)) { - retval = Mod3Mask; - } - else if (XkbLookupKeySym (display, keycode, Mod4Mask, &mods_rtn, &sym_rtn) && - (sym_rtn == keysym)) { - retval = Mod4Mask; - } - else if (XkbLookupKeySym (display, keycode, Mod5Mask, &mods_rtn, &sym_rtn) && - (sym_rtn == keysym)) { - retval = Mod5Mask; - } - else if (XkbLookupKeySym (display, keycode, - ShiftMask | Mod2Mask, &mods_rtn, &sym_rtn) && - (sym_rtn == keysym)) { - retval = (Mod2Mask | ShiftMask); - } - else if (XkbLookupKeySym (display, keycode, - ShiftMask | Mod3Mask, &mods_rtn, &sym_rtn) && - (sym_rtn == keysym)) { - retval = (Mod3Mask | ShiftMask); - } - else if (XkbLookupKeySym (display, keycode, - ShiftMask | Mod4Mask, &mods_rtn, &sym_rtn) && - (sym_rtn == keysym)) { - retval = (Mod4Mask | ShiftMask); - } - else if (XkbLookupKeySym (display, keycode, - ShiftMask | Mod5Mask, &mods_rtn, &sym_rtn) && - (sym_rtn == keysym)) { - retval = (Mod5Mask | ShiftMask); - } - else - retval = 0xFFFF; - return retval; + /* we really should use XKB and look directly at the keymap */ + /* this is very inelegant */ + Display *display = spi_get_display (); + unsigned int mods_rtn = 0; + unsigned int retval = 0; + KeySym sym_rtn; + + if (XkbLookupKeySym (display, keycode, 0, &mods_rtn, &sym_rtn) && + (sym_rtn == keysym)) + { + retval = 0; + } + else if (XkbLookupKeySym (display, keycode, ShiftMask, &mods_rtn, &sym_rtn) && + (sym_rtn == keysym)) + { + retval = ShiftMask; + } + else if (XkbLookupKeySym (display, keycode, Mod2Mask, &mods_rtn, &sym_rtn) && + (sym_rtn == keysym)) + { + retval = Mod2Mask; + } + else if (XkbLookupKeySym (display, keycode, Mod3Mask, &mods_rtn, &sym_rtn) && + (sym_rtn == keysym)) + { + retval = Mod3Mask; + } + else if (XkbLookupKeySym (display, keycode, Mod4Mask, &mods_rtn, &sym_rtn) && + (sym_rtn == keysym)) + { + retval = Mod4Mask; + } + else if (XkbLookupKeySym (display, keycode, Mod5Mask, &mods_rtn, &sym_rtn) && + (sym_rtn == keysym)) + { + retval = Mod5Mask; + } + else if (XkbLookupKeySym (display, keycode, + ShiftMask | Mod2Mask, &mods_rtn, &sym_rtn) && + (sym_rtn == keysym)) + { + retval = (Mod2Mask | ShiftMask); + } + else if (XkbLookupKeySym (display, keycode, + ShiftMask | Mod3Mask, &mods_rtn, &sym_rtn) && + (sym_rtn == keysym)) + { + retval = (Mod3Mask | ShiftMask); + } + else if (XkbLookupKeySym (display, keycode, + ShiftMask | Mod4Mask, &mods_rtn, &sym_rtn) && + (sym_rtn == keysym)) + { + retval = (Mod4Mask | ShiftMask); + } + else if (XkbLookupKeySym (display, keycode, + ShiftMask | Mod5Mask, &mods_rtn, &sym_rtn) && + (sym_rtn == keysym)) + { + retval = (Mod5Mask | ShiftMask); + } + else + retval = 0xFFFF; + return retval; } static gboolean @@ -176,17 +187,17 @@ replace_map_keysym (SpiDEControllerPrivate *priv, KeyCode keycode, KeySym keysym if (desc && desc->map) { gint offset = desc->map->key_sym_map[keycode].offset; - desc->map->syms[offset] = keysym; + desc->map->syms[offset] = keysym; } else { fprintf (stderr, "Error changing key map: empty server structure\n"); - } + } XkbSetMap (dpy, XkbAllMapComponentsMask, desc); /** - * FIXME: the use of XkbChangeMap, and the reuse of the priv->xkb_desc structure, + * FIXME: the use of XkbChangeMap, and the reuse of the priv->xkb_desc structure, * would be far preferable. - * HOWEVER it does not seem to work using XFree 4.3. + * HOWEVER it does not seem to work using XFree 4.3. **/ /* XkbChangeMap (dpy, priv->xkb_desc, priv->changes); */ XFlush (dpy); @@ -210,126 +221,127 @@ spi_dec_reset_reserved (gpointer data) static gint spi_dec_x11_get_keycode (SpiDEController *controller, - gint keysym, - gchar *key_str, - gboolean fix, - guint *modmask) + gint keysym, + gchar *key_str, + gboolean fix, + guint *modmask) { - KeyCode keycode = 0; + KeyCode keycode = 0; if (key_str && key_str[0]) - keysym = XStringToKeysym(key_str); - keycode = XKeysymToKeycode (spi_get_display (), (KeySym) keysym); - if (!keycode && fix) - { - SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller); - /* if there's no keycode available, fix it */ - if (replace_map_keysym (priv, priv->reserved_keycode, keysym)) - { - keycode = priv->reserved_keycode; - /* - * queue a timer to restore the old keycode. Ugly, but required - * due to races / asynchronous X delivery. - * Long-term fix is to extend the X keymap here instead of replace entries. - */ - priv->reserved_reset_timeout = g_timeout_add (500, spi_dec_reset_reserved, priv); - g_source_set_name_by_id (priv->reserved_reset_timeout, "[at-spi2-core] spi_dec_reset_reserved"); - } - if (modmask) - *modmask = 0; - return keycode; - } - if (modmask) - *modmask = keysym_mod_mask (keysym, keycode); - return keycode; + keysym = XStringToKeysym (key_str); + keycode = XKeysymToKeycode (spi_get_display (), (KeySym) keysym); + if (!keycode && fix) + { + SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller); + /* if there's no keycode available, fix it */ + if (replace_map_keysym (priv, priv->reserved_keycode, keysym)) + { + keycode = priv->reserved_keycode; + /* + * queue a timer to restore the old keycode. Ugly, but required + * due to races / asynchronous X delivery. + * Long-term fix is to extend the X keymap here instead of replace entries. + */ + priv->reserved_reset_timeout = g_timeout_add (500, spi_dec_reset_reserved, priv); + g_source_set_name_by_id (priv->reserved_reset_timeout, "[at-spi2-core] spi_dec_reset_reserved"); + } + if (modmask) + *modmask = 0; + return keycode; + } + if (modmask) + *modmask = keysym_mod_mask (keysym, keycode); + return keycode; } static gboolean spi_dec_button_update_and_emit (SpiDEController *controller, - guint mask_return) + guint mask_return) { gchar event_detail[3]; if ((mask_return & mouse_button_mask) != - (mouse_mask_state & mouse_button_mask)) + (mouse_mask_state & mouse_button_mask)) { int button_number = 0; gboolean is_down = False; - + if (!(mask_return & Button1Mask) && - (mouse_mask_state & Button1Mask)) - { - mouse_mask_state &= ~Button1Mask; - button_number = 1; - } + (mouse_mask_state & Button1Mask)) + { + mouse_mask_state &= ~Button1Mask; + button_number = 1; + } else if ((mask_return & Button1Mask) && - !(mouse_mask_state & Button1Mask)) - { - mouse_mask_state |= Button1Mask; - button_number = 1; - is_down = True; - } + !(mouse_mask_state & Button1Mask)) + { + mouse_mask_state |= Button1Mask; + button_number = 1; + is_down = True; + } else if (!(mask_return & Button2Mask) && - (mouse_mask_state & Button2Mask)) - { - mouse_mask_state &= ~Button2Mask; - button_number = 2; - } + (mouse_mask_state & Button2Mask)) + { + mouse_mask_state &= ~Button2Mask; + button_number = 2; + } else if ((mask_return & Button2Mask) && - !(mouse_mask_state & Button2Mask)) - { - mouse_mask_state |= Button2Mask; - button_number = 2; - is_down = True; - } + !(mouse_mask_state & Button2Mask)) + { + mouse_mask_state |= Button2Mask; + button_number = 2; + is_down = True; + } else if (!(mask_return & Button3Mask) && - (mouse_mask_state & Button3Mask)) - { - mouse_mask_state &= ~Button3Mask; - button_number = 3; - } + (mouse_mask_state & Button3Mask)) + { + mouse_mask_state &= ~Button3Mask; + button_number = 3; + } else if ((mask_return & Button3Mask) && - !(mouse_mask_state & Button3Mask)) - { - mouse_mask_state |= Button3Mask; - button_number = 3; - is_down = True; - } + !(mouse_mask_state & Button3Mask)) + { + mouse_mask_state |= Button3Mask; + button_number = 3; + is_down = True; + } else if (!(mask_return & Button4Mask) && - (mouse_mask_state & Button4Mask)) - { - mouse_mask_state &= ~Button4Mask; - button_number = 4; - } + (mouse_mask_state & Button4Mask)) + { + mouse_mask_state &= ~Button4Mask; + button_number = 4; + } else if ((mask_return & Button4Mask) && - !(mouse_mask_state & Button4Mask)) - { - mouse_mask_state |= Button4Mask; - button_number = 4; - is_down = True; - } + !(mouse_mask_state & Button4Mask)) + { + mouse_mask_state |= Button4Mask; + button_number = 4; + is_down = True; + } else if (!(mask_return & Button5Mask) && - (mouse_mask_state & Button5Mask)) - { - mouse_mask_state &= ~Button5Mask; - button_number = 5; - } + (mouse_mask_state & Button5Mask)) + { + mouse_mask_state &= ~Button5Mask; + button_number = 5; + } else if ((mask_return & Button5Mask) && - !(mouse_mask_state & Button5Mask)) - { - mouse_mask_state |= Button5Mask; - button_number = 5; - is_down = True; - } - if (button_number) { -#ifdef SPI_DEBUG - fprintf (stderr, "Button %d %s\n", - button_number, (is_down) ? "Pressed" : "Released"); + !(mouse_mask_state & Button5Mask)) + { + mouse_mask_state |= Button5Mask; + button_number = 5; + is_down = True; + } + if (button_number) + { +#ifdef SPI_DEBUG + fprintf (stderr, "Button %d %s\n", + button_number, (is_down) ? "Pressed" : "Released"); #endif - snprintf (event_detail, 3, "%d%c", button_number, - (is_down) ? 'p' : 'r'); - dbus_uint32_t x = last_mouse_pos->x, y = last_mouse_pos->y; - spi_dec_dbus_emit(controller, SPI_DBUS_INTERFACE_EVENT_MOUSE, "Button", event_detail, x, y); - } + snprintf (event_detail, 3, "%d%c", button_number, + (is_down) ? 'p' : 'r'); + dbus_uint32_t x = last_mouse_pos->x, y = last_mouse_pos->y; + spi_dec_dbus_emit (controller, SPI_DBUS_INTERFACE_EVENT_MOUSE, "Button", event_detail, x, y); + } return TRUE; } else @@ -339,10 +351,12 @@ spi_dec_button_update_and_emit (SpiDEController *controller, } static guint -spi_dec_x11_mouse_check (SpiDEController *controller, - int *x, int *y, gboolean *moved) +spi_dec_x11_mouse_check (SpiDEController *controller, + int *x, + int *y, + gboolean *moved) { - int win_x_return,win_y_return; + int win_x_return, win_y_return; unsigned int mask_return; Window root_return, child_return; Display *display = spi_get_display (); @@ -352,30 +366,31 @@ spi_dec_x11_mouse_check (SpiDEController *controller, return 0; } - XQueryPointer(display, DefaultRootWindow (display), - &root_return, &child_return, - x, y, - &win_x_return, &win_y_return, &mask_return); - /* + XQueryPointer (display, DefaultRootWindow (display), + &root_return, &child_return, + x, y, + &win_x_return, &win_y_return, &mask_return); + /* * Since many clients grab the pointer, and X goes an automatic * pointer grab on mouse-down, we often must detect mouse button events - * by polling rather than via a button grab. - * The while loop (rather than if) is used since it's possible that + * by polling rather than via a button grab. + * The while loop (rather than if) is used since it's possible that * multiple buttons have changed state since we last checked. */ - if (mask_return != mouse_mask_state) + if (mask_return != mouse_mask_state) { - while (spi_dec_button_update_and_emit (controller, mask_return)); + while (spi_dec_button_update_and_emit (controller, mask_return)) + ; } - if (*x != last_mouse_pos->x || *y != last_mouse_pos->y) + if (*x != last_mouse_pos->x || *y != last_mouse_pos->y) { // TODO: combine these two signals? dbus_uint32_t ix = *x, iy = *y; - spi_dec_dbus_emit(controller, SPI_DBUS_INTERFACE_EVENT_MOUSE, "Abs", "", ix, iy); + spi_dec_dbus_emit (controller, SPI_DBUS_INTERFACE_EVENT_MOUSE, "Abs", "", ix, iy); ix -= last_mouse_pos->x; iy -= last_mouse_pos->y; - spi_dec_dbus_emit(controller, SPI_DBUS_INTERFACE_EVENT_MOUSE, "Rel", "", ix, iy); + spi_dec_dbus_emit (controller, SPI_DBUS_INTERFACE_EVENT_MOUSE, "Rel", "", ix, iy); last_mouse_pos->x = *x; last_mouse_pos->y = *y; *moved = True; @@ -392,13 +407,13 @@ spi_dec_x11_mouse_check (SpiDEController *controller, static int spi_dec_ungrab_mouse (gpointer data) { - Display *display = spi_get_display (); - if (display) - { - XUngrabButton (spi_get_display (), AnyButton, AnyModifier, - XDefaultRootWindow (spi_get_display ())); - } - return FALSE; + Display *display = spi_get_display (); + if (display) + { + XUngrabButton (spi_get_display (), AnyButton, AnyModifier, + XDefaultRootWindow (spi_get_display ())); + } + return FALSE; } #endif @@ -411,14 +426,15 @@ spi_dec_init_mouse_listener (SpiDEController *dec) if (display) { if (XGrabButton (display, AnyButton, AnyModifier, - spi_get_root_window (), - True, ButtonPressMask | ButtonReleaseMask, - GrabModeSync, GrabModeAsync, None, None) != Success) { + spi_get_root_window (), + True, ButtonPressMask | ButtonReleaseMask, + GrabModeSync, GrabModeAsync, None, None) != Success) + { #ifdef SPI_DEBUG - fprintf (stderr, "WARNING: could not grab mouse buttons!\n"); + fprintf (stderr, "WARNING: could not grab mouse buttons!\n"); #endif - ; - } + ; + } XSync (display, False); #ifdef SPI_DEBUG fprintf (stderr, "mouse buttons grabbed\n"); @@ -436,63 +452,63 @@ spi_dec_clear_unlatch_pending (SpiDEController *controller) static void spi_device_event_controller_forward_mouse_event (SpiDEController *controller, - XEvent *xevent) + XEvent *xevent) { gchar event_detail[3]; XButtonEvent *xbutton_event = (XButtonEvent *) xevent; dbus_uint32_t ix, iy; int button = xbutton_event->button; - + unsigned int mouse_button_state = xbutton_event->state; switch (button) { case 1: - mouse_button_state |= Button1Mask; - break; + mouse_button_state |= Button1Mask; + break; case 2: - mouse_button_state |= Button2Mask; - break; + mouse_button_state |= Button2Mask; + break; case 3: - mouse_button_state |= Button3Mask; - break; + mouse_button_state |= Button3Mask; + break; case 4: - mouse_button_state |= Button4Mask; - break; + mouse_button_state |= Button4Mask; + break; case 5: - mouse_button_state |= Button5Mask; - break; + mouse_button_state |= Button5Mask; + break; } last_mouse_pos->x = ((XButtonEvent *) xevent)->x_root; last_mouse_pos->y = ((XButtonEvent *) xevent)->y_root; -#ifdef SPI_DEBUG +#ifdef SPI_DEBUG fprintf (stderr, "mouse button %d %s (%x)\n", - xbutton_event->button, - (xevent->type == ButtonPress) ? "Press" : "Release", - mouse_button_state); + xbutton_event->button, + (xevent->type == ButtonPress) ? "Press" : "Release", + mouse_button_state); #endif snprintf (event_detail, 3, "%d%c", button, - (xevent->type == ButtonPress) ? 'p' : 'r'); + (xevent->type == ButtonPress) ? 'p' : 'r'); - if ((mouse_button_state & mouse_button_mask) != - (mouse_mask_state & mouse_button_mask)) - { + if ((mouse_button_state & mouse_button_mask) != + (mouse_mask_state & mouse_button_mask)) + { if ((mouse_mask_state & key_modifier_mask) != - (mouse_button_state & key_modifier_mask)) - spi_dec_x11_emit_modifier_event (controller, - mouse_mask_state, mouse_button_state); + (mouse_button_state & key_modifier_mask)) + spi_dec_x11_emit_modifier_event (controller, + mouse_mask_state, mouse_button_state); mouse_mask_state = mouse_button_state; ix = last_mouse_pos->x; iy = last_mouse_pos->y; - spi_dec_dbus_emit(controller, SPI_DBUS_INTERFACE_EVENT_MOUSE, "Button", event_detail, ix, iy); + spi_dec_dbus_emit (controller, SPI_DBUS_INTERFACE_EVENT_MOUSE, "Button", event_detail, ix, iy); } XAllowEvents (spi_get_display (), - ReplayPointer, - CurrentTime); + ReplayPointer, + CurrentTime); } static void @@ -512,7 +528,7 @@ global_filter_fn (XEvent *xevent, void *data) gboolean is_consumed; is_consumed = - spi_device_event_controller_forward_key_event (controller, xevent); + spi_device_event_controller_forward_key_event (controller, xevent); if (is_consumed) { @@ -527,10 +543,10 @@ global_filter_fn (XEvent *xevent, void *data) for (i = 0; i < n_events; i++) { XNextEvent (display, &next_event); - if (next_event.type != KeyPress && - next_event.type != KeyRelease) - g_warning ("Unexpected event type %d in queue", next_event.type); - } + if (next_event.type != KeyPress && + next_event.type != KeyRelease) + g_warning ("Unexpected event type %d in queue", next_event.type); + } XAllowEvents (display, AsyncKeyboard, CurrentTime); if (n_events) @@ -552,92 +568,91 @@ global_filter_fn (XEvent *xevent, void *data) } if (xevent->type == priv->xkb_base_event_code) { - XkbAnyEvent * xkb_ev = (XkbAnyEvent *) xevent; + XkbAnyEvent *xkb_ev = (XkbAnyEvent *) xevent; /* ugly but probably necessary...*/ XSynchronize (display, TRUE); if (xkb_ev->xkb_type == XkbStateNotify) { - XkbStateNotifyEvent *xkb_snev = - (XkbStateNotifyEvent *) xkb_ev; - /* check the mouse, to catch mouse events grabbed by - * another client; in case we should revert this XKB delatch - */ - if (!priv->pending_xkb_mod_relatch_mask) - { - int x, y; - gboolean moved; - spi_dec_x11_mouse_check (controller, &x, &y, &moved); - } - /* we check again, since the previous call may have - changed this flag */ - if (priv->pending_xkb_mod_relatch_mask) - { - unsigned int feedback_mask; + XkbStateNotifyEvent *xkb_snev = + (XkbStateNotifyEvent *) xkb_ev; + /* check the mouse, to catch mouse events grabbed by + * another client; in case we should revert this XKB delatch + */ + if (!priv->pending_xkb_mod_relatch_mask) + { + int x, y; + gboolean moved; + spi_dec_x11_mouse_check (controller, &x, &y, &moved); + } + /* we check again, since the previous call may have + changed this flag */ + if (priv->pending_xkb_mod_relatch_mask) + { + unsigned int feedback_mask; #ifdef SPI_XKB_DEBUG - fprintf (stderr, "relatching %x\n", - priv->pending_xkb_mod_relatch_mask); + fprintf (stderr, "relatching %x\n", + priv->pending_xkb_mod_relatch_mask); #endif - /* temporarily turn off the latch bell, if it's on */ - XkbGetControls (display, - XkbAccessXFeedbackMask, - priv->xkb_desc); - feedback_mask = priv->xkb_desc->ctrls->ax_options; - if (feedback_mask & XkbAX_StickyKeysFBMask) - { - XkbControlsChangesRec changes = {XkbAccessXFeedbackMask, - 0, False}; - priv->xkb_desc->ctrls->ax_options - &= ~(XkbAX_StickyKeysFBMask); - XkbChangeControls (display, priv->xkb_desc, &changes); - } - /* TODO: account for lock as well as latch */ - XkbLatchModifiers (display, - XkbUseCoreKbd, - priv->pending_xkb_mod_relatch_mask, - priv->pending_xkb_mod_relatch_mask); - if (feedback_mask & XkbAX_StickyKeysFBMask) - { - XkbControlsChangesRec changes = {XkbAccessXFeedbackMask, - 0, False}; - priv->xkb_desc->ctrls->ax_options = feedback_mask; - XkbChangeControls (display, priv->xkb_desc, &changes); - } + /* temporarily turn off the latch bell, if it's on */ + XkbGetControls (display, + XkbAccessXFeedbackMask, + priv->xkb_desc); + feedback_mask = priv->xkb_desc->ctrls->ax_options; + if (feedback_mask & XkbAX_StickyKeysFBMask) + { + XkbControlsChangesRec changes = { XkbAccessXFeedbackMask, + 0, False }; + priv->xkb_desc->ctrls->ax_options &= ~(XkbAX_StickyKeysFBMask); + XkbChangeControls (display, priv->xkb_desc, &changes); + } + /* TODO: account for lock as well as latch */ + XkbLatchModifiers (display, + XkbUseCoreKbd, + priv->pending_xkb_mod_relatch_mask, + priv->pending_xkb_mod_relatch_mask); + if (feedback_mask & XkbAX_StickyKeysFBMask) + { + XkbControlsChangesRec changes = { XkbAccessXFeedbackMask, + 0, False }; + priv->xkb_desc->ctrls->ax_options = feedback_mask; + XkbChangeControls (display, priv->xkb_desc, &changes); + } #ifdef SPI_XKB_DEBUG - fprintf (stderr, "relatched %x\n", - priv->pending_xkb_mod_relatch_mask); + fprintf (stderr, "relatched %x\n", + priv->pending_xkb_mod_relatch_mask); #endif - priv->pending_xkb_mod_relatch_mask = 0; - } - else - { - priv->xkb_latch_mask = xkb_snev->latched_mods; - } - } + priv->pending_xkb_mod_relatch_mask = 0; + } + else + { + priv->xkb_latch_mask = xkb_snev->latched_mods; + } + } XSynchronize (display, FALSE); } - + return; } static gboolean spi_clear_error_state (void) { - gboolean retval = spi_error_code != 0; - spi_error_code = 0; - return retval; + gboolean retval = spi_error_code != 0; + spi_error_code = 0; + return retval; } static int _spi_controller_device_error_handler (Display *display, XErrorEvent *error) { - if (error->error_code == BadAccess) - { + if (error->error_code == BadAccess) + { g_message ("Could not complete key grab: grab already in use.\n"); spi_error_code = BadAccess; return 0; } - else + else { return (*x_default_error_handler) (display, error); } @@ -649,7 +664,7 @@ spi_controller_register_with_devices (SpiDEController *controller) SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller); int event_base, error_base, major_version, minor_version; - if (XTestQueryExtension (spi_get_display(), &event_base, &error_base, &major_version, &minor_version)) + if (XTestQueryExtension (spi_get_display (), &event_base, &error_base, &major_version, &minor_version)) { XTestGrabControl (spi_get_display (), True); } @@ -659,71 +674,71 @@ spi_controller_register_with_devices (SpiDEController *controller) /* register with: (translated) keystroke handler */ priv->have_xkb = XkbQueryExtension (spi_get_display (), - &priv->xkb_major_extension_opcode, - &priv->xkb_base_event_code, - &priv->xkb_base_error_code, NULL, NULL); + &priv->xkb_major_extension_opcode, + &priv->xkb_base_event_code, + &priv->xkb_base_error_code, NULL, NULL); if (priv->have_xkb) { gint i; guint64 reserved = 0; priv->xkb_desc = XkbGetMap (spi_get_display (), XkbKeySymsMask, XkbUseCoreKbd); XkbSelectEvents (spi_get_display (), - XkbUseCoreKbd, - XkbStateNotifyMask, XkbStateNotifyMask); - _numlock_physical_mask = XkbKeysymToModifiers (spi_get_display (), - XK_Num_Lock); + XkbUseCoreKbd, + XkbStateNotifyMask, XkbStateNotifyMask); + _numlock_physical_mask = XkbKeysymToModifiers (spi_get_display (), + XK_Num_Lock); for (i = priv->xkb_desc->max_key_code; i >= priv->xkb_desc->min_key_code; --i) - { - if (priv->xkb_desc->map->key_sym_map[i].kt_index[0] == XkbOneLevelIndex) - { - if (XkbKeycodeToKeysym (spi_get_display (), i, 0, 0) != 0) - { - /* don't use this one if there's a grab client! */ - - /* Runtime errors are generated from these functions, - * that are then quashed. Equivalent to: - * try - * {Blah} - * except - * {;} - */ - - spi_x_error_trap (); - XGrabKey (spi_get_display (), i, 0, - spi_get_root_window (), - TRUE, - GrabModeSync, GrabModeSync); - XSync (spi_get_display (), TRUE); - XUngrabKey (spi_get_display (), i, 0, - spi_get_root_window ()); - if (!spi_x_error_release ()) - { - reserved = i; - break; - } - } - } - } - if (reserved) - { - priv->reserved_keycode = reserved; - priv->reserved_keysym = XkbKeycodeToKeysym (spi_get_display (), reserved, 0, 0); - } + { + if (priv->xkb_desc->map->key_sym_map[i].kt_index[0] == XkbOneLevelIndex) + { + if (XkbKeycodeToKeysym (spi_get_display (), i, 0, 0) != 0) + { + /* don't use this one if there's a grab client! */ + + /* Runtime errors are generated from these functions, + * that are then quashed. Equivalent to: + * try + * {Blah} + * except + * {;} + */ + + spi_x_error_trap (); + XGrabKey (spi_get_display (), i, 0, + spi_get_root_window (), + TRUE, + GrabModeSync, GrabModeSync); + XSync (spi_get_display (), TRUE); + XUngrabKey (spi_get_display (), i, 0, + spi_get_root_window ()); + if (!spi_x_error_release ()) + { + reserved = i; + break; + } + } + } + } + if (reserved) + { + priv->reserved_keycode = reserved; + priv->reserved_keysym = XkbKeycodeToKeysym (spi_get_display (), reserved, 0, 0); + } else - { - priv->reserved_keycode = XKeysymToKeycode (spi_get_display (), XK_numbersign); - priv->reserved_keysym = XK_numbersign; - } + { + priv->reserved_keycode = XKeysymToKeycode (spi_get_display (), XK_numbersign); + priv->reserved_keysym = XK_numbersign; + } #ifdef SPI_RESERVED_DEBUG unsigned sym = 0; sym = XKeycodeToKeysym (spi_get_display (), reserved, 0); fprintf (stderr, "%x\n", sym); - fprintf (stderr, "setting the reserved keycode to %d (%s)\n", - reserved, - XKeysymToString (XKeycodeToKeysym (spi_get_display (), - reserved, 0))); + fprintf (stderr, "setting the reserved keycode to %d (%s)\n", + reserved, + XKeysymToString (XKeycodeToKeysym (spi_get_display (), + reserved, 0))); #endif - } + } spi_set_filter (global_filter_fn, controller); spi_set_events (KeyPressMask | KeyReleaseMask); @@ -737,11 +752,11 @@ spi_keystroke_from_x_key_event (XKeyEvent *x_key_event) Accessibility_DeviceEvent key_event; KeySym keysym; const int cbuf_bytes = 20; - char cbuf [21]; + char cbuf[21]; int nbytes; - nbytes = XLookupString (x_key_event, cbuf, cbuf_bytes, &keysym, NULL); - key_event.id = (dbus_int32_t)(keysym); + nbytes = XLookupString (x_key_event, cbuf, cbuf_bytes, &keysym, NULL); + key_event.id = (dbus_int32_t) (keysym); key_event.hw_code = (dbus_int16_t) x_key_event->keycode; if (((XEvent *) x_key_event)->type == KeyPress) { @@ -750,109 +765,109 @@ spi_keystroke_from_x_key_event (XKeyEvent *x_key_event) else { key_event.type = Accessibility_KEY_RELEASED_EVENT; - } - key_event.modifiers = (dbus_uint16_t)(x_key_event->state); + } + key_event.modifiers = (dbus_uint16_t) (x_key_event->state); key_event.is_text = FALSE; switch (keysym) { - case ' ': - key_event.event_string = g_strdup ("space"); - break; - case XK_Tab: - key_event.event_string = g_strdup ("Tab"); - break; - case XK_BackSpace: - key_event.event_string = g_strdup ("Backspace"); - break; - case XK_Return: - key_event.event_string = g_strdup ("Return"); - break; - case XK_Home: - key_event.event_string = g_strdup ("Home"); - break; - case XK_Page_Down: - key_event.event_string = g_strdup ("Page_Down"); - break; - case XK_Page_Up: - key_event.event_string = g_strdup ("Page_Up"); - break; - case XK_F1: - key_event.event_string = g_strdup ("F1"); - break; - case XK_F2: - key_event.event_string = g_strdup ("F2"); - break; - case XK_F3: - key_event.event_string = g_strdup ("F3"); - break; - case XK_F4: - key_event.event_string = g_strdup ("F4"); - break; - case XK_F5: - key_event.event_string = g_strdup ("F5"); - break; - case XK_F6: - key_event.event_string = g_strdup ("F6"); - break; - case XK_F7: - key_event.event_string = g_strdup ("F7"); - break; - case XK_F8: - key_event.event_string = g_strdup ("F8"); - break; - case XK_F9: - key_event.event_string = g_strdup ("F9"); - break; - case XK_F10: - key_event.event_string = g_strdup ("F10"); - break; - case XK_F11: - key_event.event_string = g_strdup ("F11"); - break; - case XK_F12: - key_event.event_string = g_strdup ("F12"); - break; - case XK_End: - key_event.event_string = g_strdup ("End"); - break; - case XK_Escape: - key_event.event_string = g_strdup ("Escape"); - break; - case XK_Up: - key_event.event_string = g_strdup ("Up"); - break; - case XK_Down: - key_event.event_string = g_strdup ("Down"); - break; - case XK_Left: - key_event.event_string = g_strdup ("Left"); - break; - case XK_Right: - key_event.event_string = g_strdup ("Right"); - break; - default: - if (nbytes > 0) - { - gunichar c; - cbuf[nbytes] = '\0'; /* OK since length is cbuf_bytes+1 */ - key_event.event_string = g_strdup (cbuf); - c = keysym2ucs (keysym); - if (c > 0 && !g_unichar_iscntrl (c)) - { - key_event.is_text = TRUE; - /* incorrect for some composed chars? */ - } - } - else - { - key_event.event_string = g_strdup (""); - } + case ' ': + key_event.event_string = g_strdup ("space"); + break; + case XK_Tab: + key_event.event_string = g_strdup ("Tab"); + break; + case XK_BackSpace: + key_event.event_string = g_strdup ("Backspace"); + break; + case XK_Return: + key_event.event_string = g_strdup ("Return"); + break; + case XK_Home: + key_event.event_string = g_strdup ("Home"); + break; + case XK_Page_Down: + key_event.event_string = g_strdup ("Page_Down"); + break; + case XK_Page_Up: + key_event.event_string = g_strdup ("Page_Up"); + break; + case XK_F1: + key_event.event_string = g_strdup ("F1"); + break; + case XK_F2: + key_event.event_string = g_strdup ("F2"); + break; + case XK_F3: + key_event.event_string = g_strdup ("F3"); + break; + case XK_F4: + key_event.event_string = g_strdup ("F4"); + break; + case XK_F5: + key_event.event_string = g_strdup ("F5"); + break; + case XK_F6: + key_event.event_string = g_strdup ("F6"); + break; + case XK_F7: + key_event.event_string = g_strdup ("F7"); + break; + case XK_F8: + key_event.event_string = g_strdup ("F8"); + break; + case XK_F9: + key_event.event_string = g_strdup ("F9"); + break; + case XK_F10: + key_event.event_string = g_strdup ("F10"); + break; + case XK_F11: + key_event.event_string = g_strdup ("F11"); + break; + case XK_F12: + key_event.event_string = g_strdup ("F12"); + break; + case XK_End: + key_event.event_string = g_strdup ("End"); + break; + case XK_Escape: + key_event.event_string = g_strdup ("Escape"); + break; + case XK_Up: + key_event.event_string = g_strdup ("Up"); + break; + case XK_Down: + key_event.event_string = g_strdup ("Down"); + break; + case XK_Left: + key_event.event_string = g_strdup ("Left"); + break; + case XK_Right: + key_event.event_string = g_strdup ("Right"); + break; + default: + if (nbytes > 0) + { + gunichar c; + cbuf[nbytes] = '\0'; /* OK since length is cbuf_bytes+1 */ + key_event.event_string = g_strdup (cbuf); + c = keysym2ucs (keysym); + if (c > 0 && !g_unichar_iscntrl (c)) + { + key_event.is_text = TRUE; + /* incorrect for some composed chars? */ + } + } + else + { + key_event.event_string = g_strdup (""); + } } key_event.timestamp = (dbus_uint32_t) x_key_event->time; #ifdef SPI_KEYEVENT_DEBUG { - char *pressed_str = "pressed"; + char *pressed_str = "pressed"; char *released_str = "released"; char *state_ptr; @@ -860,26 +875,25 @@ spi_keystroke_from_x_key_event (XKeyEvent *x_key_event) state_ptr = pressed_str; else state_ptr = released_str; - + fprintf (stderr, - "Key %lu %s (%c), modifiers %d; string=%s [%x] %s\n", - (unsigned long) keysym, - state_ptr, - keysym ? (int) keysym : '*', - (int) x_key_event->state, - key_event.event_string, - key_event.event_string[0], - (key_event.is_text == TRUE) ? "(text)" : "(not text)"); + "Key %lu %s (%c), modifiers %d; string=%s [%x] %s\n", + (unsigned long) keysym, + state_ptr, + keysym ? (int) keysym : '*', + (int) x_key_event->state, + key_event.event_string, + key_event.event_string[0], + (key_event.is_text == TRUE) ? "(text)" : "(not text)"); } #endif #ifdef SPI_DEBUG fprintf (stderr, "%s%c\n", - (x_key_event->state & Mod1Mask)?"Alt-":"", - ((x_key_event->state & ShiftMask)^(x_key_event->state & LockMask))? - g_ascii_toupper (keysym) : g_ascii_tolower (keysym)); + (x_key_event->state & Mod1Mask) ? "Alt-" : "", + ((x_key_event->state & ShiftMask) ^ (x_key_event->state & LockMask)) ? g_ascii_toupper (keysym) : g_ascii_tolower (keysym)); fprintf (stderr, "serial: %x Time: %x\n", x_key_event->serial, x_key_event->time); #endif /* SPI_DEBUG */ - return key_event; + return key_event; } static gboolean @@ -888,12 +902,12 @@ spi_dec_x11_grab_key (SpiDEController *controller, Accessibility_ControllerEventMask mod_mask) { XGrabKey (spi_get_display (), - key_val, - mod_mask, - spi_get_root_window (), - True, - GrabModeSync, - GrabModeSync); + key_val, + mod_mask, + spi_get_root_window (), + True, + GrabModeSync, + GrabModeSync); XSync (spi_get_display (), False); return spi_clear_error_state (); } @@ -904,9 +918,9 @@ spi_dec_x11_ungrab_key (SpiDEController *controller, Accessibility_ControllerEventMask mod_mask) { XUngrabKey (spi_get_display (), - key_val, - mod_mask, - spi_get_root_window ()); + key_val, + mod_mask, + spi_get_root_window ()); } static unsigned int @@ -915,26 +929,26 @@ xkb_get_slowkeys_delay (SpiDEController *controller) unsigned int retval = 0; SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller); #ifdef HAVE_XKB -#ifdef XKB_HAS_GET_SLOW_KEYS_DELAY +#ifdef XKB_HAS_GET_SLOW_KEYS_DELAY retval = XkbGetSlowKeysDelay (spi_get_display (), - XkbUseCoreKbd, &bounce_delay); + XkbUseCoreKbd, &bounce_delay); #else if (!(priv->xkb_desc == (XkbDescPtr) BadAlloc || priv->xkb_desc == NULL)) { Status s = XkbGetControls (spi_get_display (), - XkbAllControlsMask, priv->xkb_desc); + XkbAllControlsMask, priv->xkb_desc); if (s == Success) { - if (priv->xkb_desc->ctrls->enabled_ctrls & XkbSlowKeysMask) - retval = priv->xkb_desc->ctrls->slow_keys_delay; - } + if (priv->xkb_desc->ctrls->enabled_ctrls & XkbSlowKeysMask) + retval = priv->xkb_desc->ctrls->slow_keys_delay; + } } #endif #endif #ifdef SPI_XKB_DEBUG - fprintf (stderr, "SlowKeys delay: %d\n", (int) retval); + fprintf (stderr, "SlowKeys delay: %d\n", (int) retval); #endif - return retval; + return retval; } static unsigned int @@ -943,19 +957,19 @@ xkb_get_bouncekeys_delay (SpiDEController *controller) unsigned int retval = 0; SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller); #ifdef HAVE_XKB -#ifdef XKB_HAS_GET_BOUNCE_KEYS_DELAY +#ifdef XKB_HAS_GET_BOUNCE_KEYS_DELAY retval = XkbGetBounceKeysDelay (spi_get_display (), - XkbUseCoreKbd, &bounce_delay); + XkbUseCoreKbd, &bounce_delay); #else if (!(priv->xkb_desc == (XkbDescPtr) BadAlloc || priv->xkb_desc == NULL)) { Status s = XkbGetControls (spi_get_display (), - XkbAllControlsMask, priv->xkb_desc); + XkbAllControlsMask, priv->xkb_desc); if (s == Success) { - if (priv->xkb_desc->ctrls->enabled_ctrls & XkbBounceKeysMask) - retval = priv->xkb_desc->ctrls->debounce_delay; - } + if (priv->xkb_desc->ctrls->enabled_ctrls & XkbBounceKeysMask) + retval = priv->xkb_desc->ctrls->debounce_delay; + } } #endif #endif @@ -969,210 +983,223 @@ static gboolean spi_dec_x11_synth_keycode_press (SpiDEController *controller, unsigned int keycode) { - unsigned int time = CurrentTime; - unsigned int bounce_delay; -#ifdef THIS_IS_BROKEN - unsigned int elapsed_msec; - struct timeval tv; + unsigned int time = CurrentTime; + unsigned int bounce_delay; +#ifdef THIS_IS_BROKEN + unsigned int elapsed_msec; + struct timeval tv; #endif - SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller); - - spi_x_error_trap (); - if (keycode == priv->last_release_keycode) - { - bounce_delay = xkb_get_bouncekeys_delay (controller); - if (bounce_delay) - { + SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller); + + spi_x_error_trap (); + if (keycode == priv->last_release_keycode) + { + bounce_delay = xkb_get_bouncekeys_delay (controller); + if (bounce_delay) + { #ifdef THIS_IS_BROKEN - gettimeofday (&tv, NULL); - elapsed_msec = - (tv.tv_sec - priv->last_release_time.tv_sec) * 1000 - + (tv.tv_usec - priv->last_release_time.tv_usec) / 1000; -# ifdef SPI_XKB_DEBUG - fprintf (stderr, "%d ms elapsed (%ld usec)\n", elapsed_msec, - (long) (tv.tv_usec - priv->last_release_time.tv_usec)); -# endif - if (elapsed_msec < bounce_delay) - time = bounce_delay - elapsed_msec + 1; + gettimeofday (&tv, NULL); + elapsed_msec = + (tv.tv_sec - priv->last_release_time.tv_sec) * 1000 + (tv.tv_usec - priv->last_release_time.tv_usec) / 1000; +#ifdef SPI_XKB_DEBUG + fprintf (stderr, "%d ms elapsed (%ld usec)\n", elapsed_msec, + (long) (tv.tv_usec - priv->last_release_time.tv_usec)); +#endif + if (elapsed_msec < bounce_delay) + time = bounce_delay - elapsed_msec + 1; #else - time = bounce_delay + 10; - /* fudge for broken XTest */ + time = bounce_delay + 10; + /* fudge for broken XTest */ #endif -#ifdef SPI_XKB_DEBUG - fprintf (stderr, "waiting %d ms\n", time); +#ifdef SPI_XKB_DEBUG + fprintf (stderr, "waiting %d ms\n", time); #endif - } - } - XTestFakeKeyEvent (spi_get_display (), keycode, True, time); - priv->last_press_keycode = keycode; - XFlush (spi_get_display ()); - XSync (spi_get_display (), False); - gettimeofday (&priv->last_press_time, NULL); - return TRUE; + } + } + XTestFakeKeyEvent (spi_get_display (), keycode, True, time); + priv->last_press_keycode = keycode; + XFlush (spi_get_display ()); + XSync (spi_get_display (), False); + gettimeofday (&priv->last_press_time, NULL); + return TRUE; } static gboolean spi_dec_x11_synth_keycode_release (SpiDEController *controller, - unsigned int keycode) + unsigned int keycode) { - unsigned int time = CurrentTime; - unsigned int slow_delay; + unsigned int time = CurrentTime; + unsigned int slow_delay; #ifdef THIS_IS_BROKEN_DUNNO_WHY - unsigned int elapsed_msec; - struct timeval tv; + unsigned int elapsed_msec; + struct timeval tv; #endif - SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller); - - spi_x_error_trap (); - if (keycode == priv->last_press_keycode) - { - slow_delay = xkb_get_slowkeys_delay (controller); - if (slow_delay) - { + SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller); + + spi_x_error_trap (); + if (keycode == priv->last_press_keycode) + { + slow_delay = xkb_get_slowkeys_delay (controller); + if (slow_delay) + { #ifdef THIS_IS_BROKEN_DUNNO_WHY - gettimeofday (&tv, NULL); - elapsed_msec = - (tv.tv_sec - priv->last_press_time.tv_sec) * 1000 - + (tv.tv_usec - priv->last_press_time.tv_usec) / 1000; -# ifdef SPI_XKB_DEBUG - fprintf (stderr, "%d ms elapsed (%ld usec)\n", elapsed_msec, - (long) (tv.tv_usec - priv->last_press_time.tv_usec)); -# endif - if (elapsed_msec < slow_delay) - time = slow_delay - elapsed_msec + 1; + gettimeofday (&tv, NULL); + elapsed_msec = + (tv.tv_sec - priv->last_press_time.tv_sec) * 1000 + (tv.tv_usec - priv->last_press_time.tv_usec) / 1000; +#ifdef SPI_XKB_DEBUG + fprintf (stderr, "%d ms elapsed (%ld usec)\n", elapsed_msec, + (long) (tv.tv_usec - priv->last_press_time.tv_usec)); +#endif + if (elapsed_msec < slow_delay) + time = slow_delay - elapsed_msec + 1; #else - time = slow_delay + 10; - /* our XTest seems broken, we have to add slop as above */ + time = slow_delay + 10; + /* our XTest seems broken, we have to add slop as above */ #endif -#ifdef SPI_XKB_DEBUG - fprintf (stderr, "waiting %d ms\n", time); +#ifdef SPI_XKB_DEBUG + fprintf (stderr, "waiting %d ms\n", time); #endif - } - } - XTestFakeKeyEvent (spi_get_display (), keycode, False, time); - priv->last_release_keycode = keycode; - XSync (spi_get_display (), False); - gettimeofday (&priv->last_release_time, NULL); - return TRUE; + } + } + XTestFakeKeyEvent (spi_get_display (), keycode, False, time); + priv->last_release_keycode = keycode; + XSync (spi_get_display (), False); + gettimeofday (&priv->last_release_time, NULL); + return TRUE; } static gboolean spi_dec_x11_lock_modifiers (SpiDEController *controller, unsigned modifiers) { - SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller); - - if (priv->have_xkb) { - return XkbLockModifiers (spi_get_display (), XkbUseCoreKbd, - modifiers, modifiers); - } else { - int mod_index; - if (xmkeymap==NULL) - xmkeymap = XGetModifierMapping(spi_get_display ()); - for (mod_index=0;mod_index<8;mod_index++) - if (modifiers & (1<<mod_index)) - spi_dec_x11_synth_keycode_press(controller, xmkeymap->modifiermap[mod_index]); - return TRUE; + SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller); + + if (priv->have_xkb) + { + return XkbLockModifiers (spi_get_display (), XkbUseCoreKbd, + modifiers, modifiers); + } + else + { + int mod_index; + if (xmkeymap == NULL) + xmkeymap = XGetModifierMapping (spi_get_display ()); + for (mod_index = 0; mod_index < 8; mod_index++) + if (modifiers & (1 << mod_index)) + spi_dec_x11_synth_keycode_press (controller, xmkeymap->modifiermap[mod_index]); + return TRUE; } } static gboolean spi_dec_x11_unlock_modifiers (SpiDEController *controller, unsigned modifiers) { - SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller); - - if (priv->have_xkb) { - return XkbLockModifiers (spi_get_display (), XkbUseCoreKbd, - modifiers, 0); - } else { - int mod_index; - if (xmkeymap==NULL) - xmkeymap = XGetModifierMapping(spi_get_display ()); - - for (mod_index=0;mod_index<8;mod_index++) - if (modifiers & (1<<mod_index)) - spi_dec_x11_synth_keycode_release(controller, xmkeymap->modifiermap[mod_index]); - return TRUE; + SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller); + + if (priv->have_xkb) + { + return XkbLockModifiers (spi_get_display (), XkbUseCoreKbd, + modifiers, 0); + } + else + { + int mod_index; + if (xmkeymap == NULL) + xmkeymap = XGetModifierMapping (spi_get_display ()); + + for (mod_index = 0; mod_index < 8; mod_index++) + if (modifiers & (1 << mod_index)) + spi_dec_x11_synth_keycode_release (controller, xmkeymap->modifiermap[mod_index]); + return TRUE; } } static KeySym keysym_for_unichar (SpiDEController *controller, gunichar unichar) { - return (KeySym) ucs2keysym ((long) unichar); + return (KeySym) ucs2keysym ((long) unichar); } static gboolean spi_dec_x11_synth_keystring (SpiDEController *controller, guint synth_type, gint keycode, const char *keystring) { - /* probably we need to create and inject an XIM handler eventually. */ - /* for now, try to match the string to existing - * keycode+modifier states. - */ - KeySym *keysyms; - gint maxlen = 0; - gunichar unichar = 0; - gint i = 0; - gboolean retval = TRUE; - const gchar *c; - KeySym keysym; - - if (!(keystring && *keystring && g_utf8_validate (keystring, -1, &c))) { - retval = FALSE; - } - else { + /* probably we need to create and inject an XIM handler eventually. */ + /* for now, try to match the string to existing + * keycode+modifier states. + */ + KeySym *keysyms; + gint maxlen = 0; + gunichar unichar = 0; + gint i = 0; + gboolean retval = TRUE; + const gchar *c; + KeySym keysym; + + if (!(keystring && *keystring && g_utf8_validate (keystring, -1, &c))) + { + retval = FALSE; + } + else + { #ifdef SPI_DEBUG - fprintf (stderr, "[keystring synthesis attempted on %s]\n", keystring); + fprintf (stderr, "[keystring synthesis attempted on %s]\n", keystring); #endif - maxlen = strlen (keystring) + 1; - keysyms = g_new0 (KeySym, maxlen); - - while (keystring && (unichar = g_utf8_get_char (keystring))) { - char bytes[6]; - gint mbytes; - - mbytes = g_unichar_to_utf8 (unichar, bytes); - bytes[mbytes] = '\0'; + maxlen = strlen (keystring) + 1; + keysyms = g_new0 (KeySym, maxlen); + + while (keystring && (unichar = g_utf8_get_char (keystring))) + { + char bytes[6]; + gint mbytes; + + mbytes = g_unichar_to_utf8 (unichar, bytes); + bytes[mbytes] = '\0'; #ifdef SPI_DEBUG - fprintf (stderr, "[unichar %s]", bytes); + fprintf (stderr, "[unichar %s]", bytes); #endif - keysym = keysym_for_unichar (controller, unichar); - if (keysym == NoSymbol) { + keysym = keysym_for_unichar (controller, unichar); + if (keysym == NoSymbol) + { #ifdef SPI_DEBUG - fprintf (stderr, "no keysym for %s", bytes); + fprintf (stderr, "no keysym for %s", bytes); #endif - retval = FALSE; - break; - } - keysyms[i++] = keysym; - keystring = g_utf8_next_char (keystring); - } - keysyms[i++] = 0; - XSynchronize (spi_get_display (), TRUE); - for (i = 0; keysyms[i]; ++i) { - if (!spi_dec_synth_keysym (controller, keysyms[i])) { + retval = FALSE; + break; + } + keysyms[i++] = keysym; + keystring = g_utf8_next_char (keystring); + } + keysyms[i++] = 0; + XSynchronize (spi_get_display (), TRUE); + for (i = 0; keysyms[i]; ++i) + { + if (!spi_dec_synth_keysym (controller, keysyms[i])) + { #ifdef SPI_DEBUG - fprintf (stderr, "could not synthesize %c\n", - (int) keysyms[i]); + fprintf (stderr, "could not synthesize %c\n", + (int) keysyms[i]); #endif - retval = FALSE; - break; - } - } - XSynchronize (spi_get_display (), FALSE); - - g_free (keysyms); - } - - if (synth_type == Accessibility_KEY_SYM) { - keysym = keycode; - } - else { - keysym = XkbKeycodeToKeysym (spi_get_display (), keycode, 0, 0); - } - if (XkbKeysymToModifiers (spi_get_display (), keysym) == 0) { - spi_dec_clear_unlatch_pending (controller); - } - return retval; + retval = FALSE; + break; + } + } + XSynchronize (spi_get_display (), FALSE); + + g_free (keysyms); + } + + if (synth_type == Accessibility_KEY_SYM) + { + keysym = keycode; + } + else + { + keysym = XkbKeycodeToKeysym (spi_get_display (), keycode, 0, 0); + } + if (XkbKeysymToModifiers (spi_get_display (), keysym) == 0) + { + spi_dec_clear_unlatch_pending (controller); + } + return retval; } static void @@ -1206,7 +1233,7 @@ spi_dec_x11_finalize (SpiDEController *controller) static gboolean spi_device_event_controller_forward_key_event (SpiDEController *controller, - const XEvent *event) + const XEvent *event) { SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller); Accessibility_DeviceEvent key_event; @@ -1221,11 +1248,10 @@ spi_device_event_controller_forward_key_event (SpiDEController *controller, /* relay to listeners, and decide whether to consume it or not */ ret = spi_controller_notify_keylisteners (controller, &key_event, TRUE); - g_free(key_event.event_string); + g_free (key_event.event_string); return ret; } - static gboolean is_key_released (long code) { @@ -1241,7 +1267,7 @@ static gboolean check_release (gpointer data) { gboolean released; - Accessibility_DeviceEvent *event = (Accessibility_DeviceEvent *)data; + Accessibility_DeviceEvent *event = (Accessibility_DeviceEvent *) data; KeyCode code = event->hw_code; released = is_key_released (code); @@ -1256,8 +1282,8 @@ check_release (gpointer data) } static void -wait_for_release_event (XEvent *event, - SpiDEController *controller) +wait_for_release_event (XEvent *event, + SpiDEController *controller) { pressed_event = spi_keystroke_from_x_key_event ((XKeyEvent *) event); check_release_handler = g_timeout_add (CHECK_RELEASE_DELAY, check_release, &pressed_event); @@ -1265,25 +1291,24 @@ wait_for_release_event (XEvent *event, } static void -spi_dec_x11_emit_modifier_event (SpiDEController *controller, guint prev_mask, - guint current_mask) +spi_dec_x11_emit_modifier_event (SpiDEController *controller, guint prev_mask, guint current_mask) { dbus_uint32_t d1, d2; #ifdef SPI_XKB_DEBUG - fprintf (stderr, "MODIFIER CHANGE EVENT! %x to %x\n", - prev_mask, current_mask); + fprintf (stderr, "MODIFIER CHANGE EVENT! %x to %x\n", + prev_mask, current_mask); #endif /* set bits for the virtual modifiers like NUMLOCK */ - if (prev_mask & _numlock_physical_mask) + if (prev_mask & _numlock_physical_mask) prev_mask |= SPI_KEYMASK_NUMLOCK; - if (current_mask & _numlock_physical_mask) + if (current_mask & _numlock_physical_mask) current_mask |= SPI_KEYMASK_NUMLOCK; d1 = prev_mask & key_modifier_mask; d2 = current_mask & key_modifier_mask; - spi_dec_dbus_emit(controller, SPI_DBUS_INTERFACE_EVENT_KEYBOARD, "Modifiers", "", d1, d2); + spi_dec_dbus_emit (controller, SPI_DBUS_INTERFACE_EVENT_KEYBOARD, "Modifiers", "", d1, d2); } static void @@ -1298,53 +1323,53 @@ spi_dec_x11_generate_mouse_event (SpiDEController *controller, switch (eventName[0]) { - case 'b': - switch (eventName[1]) - { - /* TODO: check number of buttons before parsing */ - case '1': - button = 1; - break; - case '2': - button = 2; - break; - case '3': - button = 3; - break; - case '4': - button = 4; - break; - case '5': - button = 5; - break; - default: - err = TRUE; - } - if (!err) - { - if (x != -1 && y != -1) - { - XTestFakeMotionEvent (display, DefaultScreen (display), - x, y, 0); - } - XTestFakeButtonEvent (display, button, !(eventName[2] == 'r'), 0); - if (eventName[2] == 'c') - XTestFakeButtonEvent (display, button, FALSE, 1); - else if (eventName[2] == 'd') - { - XTestFakeButtonEvent (display, button, FALSE, 1); - XTestFakeButtonEvent (display, button, TRUE, 2); - XTestFakeButtonEvent (display, button, FALSE, 3); - } - } - break; - case 'r': /* relative motion */ - XTestFakeRelativeMotionEvent (display, x, y, 0); - break; - case 'a': /* absolute motion */ - XTestFakeMotionEvent (display, DefaultScreen (display), - x, y, 0); - break; + case 'b': + switch (eventName[1]) + { + /* TODO: check number of buttons before parsing */ + case '1': + button = 1; + break; + case '2': + button = 2; + break; + case '3': + button = 3; + break; + case '4': + button = 4; + break; + case '5': + button = 5; + break; + default: + err = TRUE; + } + if (!err) + { + if (x != -1 && y != -1) + { + XTestFakeMotionEvent (display, DefaultScreen (display), + x, y, 0); + } + XTestFakeButtonEvent (display, button, !(eventName[2] == 'r'), 0); + if (eventName[2] == 'c') + XTestFakeButtonEvent (display, button, FALSE, 1); + else if (eventName[2] == 'd') + { + XTestFakeButtonEvent (display, button, FALSE, 1); + XTestFakeButtonEvent (display, button, TRUE, 2); + XTestFakeButtonEvent (display, button, FALSE, 3); + } + } + break; + case 'r': /* relative motion */ + XTestFakeRelativeMotionEvent (display, x, y, 0); + break; + case 'a': /* absolute motion */ + XTestFakeMotionEvent (display, DefaultScreen (display), + x, y, 0); + break; } } diff --git a/registryd/deviceeventcontroller-x11.h b/registryd/deviceeventcontroller-x11.h index e66799e4..a39b57d7 100644 --- a/registryd/deviceeventcontroller-x11.h +++ b/registryd/deviceeventcontroller-x11.h @@ -1,13 +1,14 @@ #ifndef _DEVICEEVENTCONTROLLER_X11_H_ #define _DEVICEEVENTCONTROLLER_X11_H_ -#include <glib.h> +#include <X11/XKBlib.h> #include <X11/Xlib.h> #include <X11/Xutil.h> #include <X11/extensions/XTest.h> -#include <X11/XKBlib.h> +#include <glib.h> -typedef struct { +typedef struct +{ Display *xevie_display; unsigned int last_press_keycode; unsigned int last_release_keycode; @@ -22,7 +23,7 @@ typedef struct { XkbDescPtr xkb_desc; KeyCode reserved_keycode; KeySym reserved_keysym; - guint reserved_reset_timeout; + guint reserved_reset_timeout; } SpiDEControllerPrivate; #ifdef HAVE_X11 @@ -30,6 +31,6 @@ void spi_dec_setup_x11 (SpiDEControllerClass *klass); #endif long ucs2keysym (long ucs); -long keysym2ucs(long keysym); +long keysym2ucs (long keysym); #endif /* _DEVICEEVENTCONTROLLER_X11_H_ */ diff --git a/registryd/deviceeventcontroller.c b/registryd/deviceeventcontroller.c index c5d7b9c5..466bae22 100644 --- a/registryd/deviceeventcontroller.c +++ b/registryd/deviceeventcontroller.c @@ -25,27 +25,27 @@ #include "config.h" -#undef SPI_XKB_DEBUG -#undef SPI_DEBUG -#undef SPI_KEYEVENT_DEBUG +#undef SPI_XKB_DEBUG +#undef SPI_DEBUG +#undef SPI_KEYEVENT_DEBUG -#include <string.h> #include <ctype.h> #include <stdio.h> +#include <string.h> #include <sys/time.h> #include <glib.h> #include <dbus/dbus.h> -#include "paths.h" -#include "de-types.h" #include "de-marshaller.h" +#include "de-types.h" #include "keymasks.h" +#include "paths.h" #include "deviceeventcontroller.h" -#include "reentrant-list.h" #include "introspection.h" +#include "reentrant-list.h" #ifdef HAVE_X11 #include "deviceeventcontroller-x11.h" @@ -59,43 +59,43 @@ * Otherwise, there is no private data and so we use a dummy struct. * This is so that G_ADD_PRIVATE() will have a type to work with. */ -typedef struct { +typedef struct +{ int _dummy; } SpiDEControllerPrivate; #endif -typedef struct { - gint x; - gint y; +typedef struct +{ + gint x; + gint y; } SpiPoint; static unsigned int key_modifier_mask = - SPI_KEYMASK_MOD1 | SPI_KEYMASK_MOD2 | SPI_KEYMASK_MOD3 | SPI_KEYMASK_MOD4 | - SPI_KEYMASK_MOD5 | SPI_KEYMASK_SHIFT | SPI_KEYMASK_SHIFTLOCK | - SPI_KEYMASK_CONTROL | SPI_KEYMASK_NUMLOCK; + SPI_KEYMASK_MOD1 | SPI_KEYMASK_MOD2 | SPI_KEYMASK_MOD3 | SPI_KEYMASK_MOD4 | + SPI_KEYMASK_MOD5 | SPI_KEYMASK_SHIFT | SPI_KEYMASK_SHIFTLOCK | + SPI_KEYMASK_CONTROL | SPI_KEYMASK_NUMLOCK; unsigned int _numlock_physical_mask = SPI_KEYMASK_MOD2; /* a guess, will be reset */ - -typedef struct { - guint ref_count : 30; - guint pending_add : 1; - guint pending_remove : 1; +typedef struct +{ + guint ref_count : 30; + guint pending_add : 1; + guint pending_remove : 1; Accessibility_ControllerEventMask mod_mask; - dbus_uint32_t key_val; /* KeyCode */ + dbus_uint32_t key_val; /* KeyCode */ } DEControllerGrabMask; - -gboolean spi_controller_update_key_grabs (SpiDEController *controller, - Accessibility_DeviceEvent *recv); +gboolean spi_controller_update_key_grabs (SpiDEController *controller, + Accessibility_DeviceEvent *recv); static gboolean eventtype_seq_contains_event (dbus_uint32_t types, - const Accessibility_DeviceEvent *event); + const Accessibility_DeviceEvent *event); static gboolean spi_dec_poll_mouse_moving (gpointer data); static gboolean spi_dec_poll_mouse_idle (gpointer data); -G_DEFINE_TYPE_WITH_CODE(SpiDEController, spi_device_event_controller, G_TYPE_OBJECT, - G_ADD_PRIVATE (SpiDEController)) +G_DEFINE_TYPE_WITH_CODE (SpiDEController, spi_device_event_controller, G_TYPE_OBJECT, G_ADD_PRIVATE (SpiDEController)) static gint spi_dec_plat_get_keycode (SpiDEController *controller, @@ -119,8 +119,10 @@ spi_dec_plat_get_keycode (SpiDEController *controller, } static guint -spi_dec_plat_mouse_check (SpiDEController *controller, - int *x, int *y, gboolean *moved) +spi_dec_plat_mouse_check (SpiDEController *controller, + int *x, + int *y, + gboolean *moved) { SpiDEControllerClass *klass; klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller); @@ -158,7 +160,7 @@ spi_dec_plat_ungrab_key (SpiDEController *controller, guint key_val, Accessibili static gboolean spi_dec_plat_synth_keycode_press (SpiDEController *controller, - unsigned int keycode) + unsigned int keycode) { SpiDEControllerClass *klass; klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller); @@ -170,7 +172,7 @@ spi_dec_plat_synth_keycode_press (SpiDEController *controller, static gboolean spi_dec_plat_synth_keycode_release (SpiDEController *controller, - unsigned int keycode) + unsigned int keycode) { SpiDEControllerClass *klass; klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller); @@ -214,8 +216,7 @@ spi_dec_plat_synth_keystring (SpiDEController *controller, guint synth_type, gin } static void -spi_dec_plat_emit_modifier_event (SpiDEController *controller, guint prev_mask, - guint current_mask) +spi_dec_plat_emit_modifier_event (SpiDEController *controller, guint prev_mask, guint current_mask) { SpiDEControllerClass *klass; klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller); @@ -238,19 +239,19 @@ spi_dec_plat_generate_mouse_event (SpiDEController *controller, static DBusMessage * invalid_arguments_error (DBusMessage *message) { - DBusMessage *reply; - gchar *errmsg; - - errmsg= g_strdup_printf ( - "Method \"%s\" with signature \"%s\" on interface \"%s\" was supplied with invalid arguments\n", - dbus_message_get_member (message), - dbus_message_get_signature (message), - dbus_message_get_interface (message)); - reply = dbus_message_new_error (message, - DBUS_ERROR_INVALID_ARGS, - errmsg); - g_free (errmsg); - return reply; + DBusMessage *reply; + gchar *errmsg; + + errmsg = g_strdup_printf ( + "Method \"%s\" with signature \"%s\" on interface \"%s\" was supplied with invalid arguments\n", + dbus_message_get_member (message), + dbus_message_get_signature (message), + dbus_message_get_interface (message)); + reply = dbus_message_new_error (message, + DBUS_ERROR_INVALID_ARGS, + errmsg); + g_free (errmsg); + return reply; } /* Private methods */ @@ -278,22 +279,23 @@ spi_dbus_remove_disconnect_match (DBusConnection *bus, const char *name) { char *match = g_strdup_printf ("interface=%s,member=NameOwnerChanged,arg0=%s", DBUS_INTERFACE_DBUS, name); if (match) - { - DBusError error; - dbus_error_init (&error); - dbus_bus_remove_match (bus, match, &error); - g_free (match); - if (dbus_error_is_set (&error)) - { - dbus_error_free (&error); - return FALSE; - } - else - { - return TRUE; - } - } - else return FALSE; + { + DBusError error; + dbus_error_init (&error); + dbus_bus_remove_match (bus, match, &error); + g_free (match); + if (dbus_error_is_set (&error)) + { + dbus_error_free (&error); + return FALSE; + } + else + { + return TRUE; + } + } + else + return FALSE; } static DEControllerGrabMask * @@ -327,14 +329,13 @@ spi_grab_mask_compare_values (gconstpointer p1, gconstpointer p2) return 0; } else - { + { return ((l1->mod_mask != l2->mod_mask) || (l1->key_val != l2->key_val)); } } void -spi_dec_dbus_emit (SpiDEController *controller, const char *interface, - const char *name, const char *minor, int a1, int a2) +spi_dec_dbus_emit (SpiDEController *controller, const char *interface, const char *name, const char *minor, int a1, int a2) { DBusMessage *signal = NULL; DBusMessageIter iter, iter_dict, iter_variant; @@ -349,11 +350,11 @@ spi_dec_dbus_emit (SpiDEController *controller, const char *interface, 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_append_basic (&iter_variant, DBUS_TYPE_INT32, &nil); dbus_message_iter_close_container (&iter, &iter_variant); dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "{sv}", &iter_dict); - dbus_message_iter_close_container (&iter, &iter_dict); + dbus_message_iter_close_container (&iter, &iter_dict); dbus_connection_send (controller->bus, signal, NULL); dbus_message_unref (signal); @@ -362,7 +363,7 @@ spi_dec_dbus_emit (SpiDEController *controller, const char *interface, static gboolean spi_dec_poll_mouse_moved (gpointer data) { - SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER(data); + SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (data); int x, y; gboolean moved; guint mask_return; @@ -382,7 +383,7 @@ spi_dec_poll_mouse_moved (gpointer data) static gboolean spi_dec_poll_mouse_idle (gpointer data) { - SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER(data); + SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (data); if (!controller->have_mouse_event_listener) return FALSE; @@ -393,14 +394,14 @@ spi_dec_poll_mouse_idle (gpointer data) guint id; id = g_timeout_add (20, spi_dec_poll_mouse_moving, controller); g_source_set_name_by_id (id, "[at-spi2-core] spi_dec_poll_mouse_moving"); - return FALSE; + return FALSE; } } static gboolean spi_dec_poll_mouse_moving (gpointer data) { - SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER(data); + SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (data); if (!controller->have_mouse_event_listener) return FALSE; @@ -417,10 +418,10 @@ spi_dec_poll_mouse_moving (gpointer data) /** * Eventually we can use this to make the marshalling of mask types - * more sane, but for now we just use this to detect + * more sane, but for now we just use this to detect * the use of 'virtual' masks such as numlock and convert them to * system-specific mask values (i.e. ModMask). - * + * **/ static Accessibility_ControllerEventMask spi_dec_translate_mask (Accessibility_ControllerEventMask mask) @@ -435,61 +436,62 @@ spi_dec_translate_mask (Accessibility_ControllerEventMask mask) tmp_mask = mask ^ SPI_KEYMASK_NUMLOCK; tmp_mask |= _numlock_physical_mask; } - + return tmp_mask; } static DEControllerKeyListener * spi_dec_key_listener_new (const char *bus_name, - const char *path, - GSList *keys, - const Accessibility_ControllerEventMask mask, - const dbus_uint32_t types, - const Accessibility_EventListenerMode *mode) + const char *path, + GSList *keys, + const Accessibility_ControllerEventMask mask, + const dbus_uint32_t types, + const Accessibility_EventListenerMode *mode) { DEControllerKeyListener *key_listener = g_new0 (DEControllerKeyListener, 1); - key_listener->listener.bus_name = g_strdup(bus_name); - key_listener->listener.path = g_strdup(path); + key_listener->listener.bus_name = g_strdup (bus_name); + key_listener->listener.path = g_strdup (path); key_listener->listener.type = SPI_DEVICE_TYPE_KBD; key_listener->keys = keys; key_listener->mask = spi_dec_translate_mask (mask); key_listener->listener.types = types; if (mode) - { - key_listener->mode = (Accessibility_EventListenerMode *) g_malloc(sizeof(Accessibility_EventListenerMode)); - memcpy(key_listener->mode, mode, sizeof(*mode)); - } + { + key_listener->mode = (Accessibility_EventListenerMode *) g_malloc (sizeof (Accessibility_EventListenerMode)); + memcpy (key_listener->mode, mode, sizeof (*mode)); + } else key_listener->mode = NULL; #ifdef SPI_DEBUG g_print ("new listener, with mask %x, is_global %d, keys %p (%d)\n", - (unsigned int) key_listener->mask, + (unsigned int) key_listener->mask, (int) (mode ? mode->global : 0), - (void *) key_listener->keys, - (int) (key_listener->keys ? g_slist_length(key_listener->keys) : 0)); + (void *) key_listener->keys, + (int) (key_listener->keys ? g_slist_length (key_listener->keys) : 0)); #endif - return key_listener; + return key_listener; } -static GSList *keylist_clone (GSList *s) +static GSList * +keylist_clone (GSList *s) { GSList *d = NULL; GSList *l; - for (l = s; l; l = g_slist_next(l)) - { - Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *)g_malloc(sizeof(Accessibility_KeyDefinition)); - if (kd) + for (l = s; l; l = g_slist_next (l)) { - 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); + 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; } @@ -504,33 +506,36 @@ spi_key_listener_clone (DEControllerKeyListener *key_listener) 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)); - } + { + 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) +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); - } + 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); + 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); @@ -543,25 +548,25 @@ spi_key_listener_clone_free (DEControllerKeyListener *clone) } static void -spi_dec_listener_free (DEControllerListener *listener) +spi_dec_listener_free (DEControllerListener *listener) { - if (listener->type == SPI_DEVICE_TYPE_KBD) + if (listener->type == SPI_DEVICE_TYPE_KBD) spi_key_listener_data_free ((DEControllerKeyListener *) listener); else - { - g_free (listener->bus_name); - g_free (listener->path); - } + { + g_free (listener->bus_name); + g_free (listener->path); + } } static void -_register_keygrab (SpiDEController *controller, - DEControllerGrabMask *grab_mask) +_register_keygrab (SpiDEController *controller, + DEControllerGrabMask *grab_mask) { GList *l; l = g_list_find_custom (controller->keygrabs_list, grab_mask, - spi_grab_mask_compare_values); + spi_grab_mask_compare_values); if (l) { DEControllerGrabMask *cur_mask = l->data; @@ -570,24 +575,24 @@ _register_keygrab (SpiDEController *controller, 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)); + g_list_prepend (controller->keygrabs_list, + spi_grab_mask_clone (grab_mask)); } } static void -_deregister_keygrab (SpiDEController *controller, - DEControllerGrabMask *grab_mask) +_deregister_keygrab (SpiDEController *controller, + DEControllerGrabMask *grab_mask) { GList *l; l = g_list_find_custom (controller->keygrabs_list, grab_mask, - spi_grab_mask_compare_values); + spi_grab_mask_compare_values); if (l) { @@ -597,15 +602,15 @@ _deregister_keygrab (SpiDEController *controller, if (cur_mask->ref_count <= 0) { cur_mask->pending_remove = TRUE; - } + } } } static void -handle_keygrab (SpiDEController *controller, - DEControllerKeyListener *key_listener, - void (*process_cb) (SpiDEController *controller, - DEControllerGrabMask *grab_mask)) +handle_keygrab (SpiDEController *controller, + DEControllerKeyListener *key_listener, + void (*process_cb) (SpiDEController *controller, + DEControllerGrabMask *grab_mask)) { DEControllerGrabMask grab_mask = { 0 }; @@ -622,30 +627,30 @@ handle_keygrab (SpiDEController *controller, { GSList *l; - for (l = key_listener->keys; l; l = g_slist_next(l)) + for (l = key_listener->keys; l; l = g_slist_next (l)) { - Accessibility_KeyDefinition *keydef = l->data; - long key_val; - key_val = spi_dec_plat_get_keycode (controller, keydef->keysym, keydef->keystring, FALSE, NULL); - if (!key_val) - key_val = keydef->keycode; - grab_mask.key_val = key_val; - process_cb (controller, &grab_mask); - } + Accessibility_KeyDefinition *keydef = l->data; + long key_val; + key_val = spi_dec_plat_get_keycode (controller, keydef->keysym, keydef->keystring, FALSE, NULL); + if (!key_val) + 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) +spi_controller_register_global_keygrabs (SpiDEController *controller, + DEControllerKeyListener *key_listener) { handle_keygrab (controller, key_listener, _register_keygrab); return spi_controller_update_key_grabs (controller, NULL); } static void -spi_controller_deregister_global_keygrabs (SpiDEController *controller, - DEControllerKeyListener *key_listener) +spi_controller_deregister_global_keygrabs (SpiDEController *controller, + DEControllerKeyListener *key_listener) { handle_keygrab (controller, key_listener, _deregister_keygrab); spi_controller_update_key_grabs (controller, NULL); @@ -672,49 +677,49 @@ append_keystroke_listener (DBusMessageIter *iter, DEControllerKeyListener *liste dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_UINT32, &d_uint); if (!dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_ARRAY, "(iisi)", &iter_subarray)) - { - dbus_message_iter_close_container (iter, &iter_struct); - return; - } + { + dbus_message_iter_close_container (iter, &iter_struct); + return; + } for (kl = listener->keys; kl; kl = kl->next) - { - Accessibility_KeyDefinition *kd = kl->data; - if (!dbus_message_iter_open_container (&iter_subarray, DBUS_TYPE_STRUCT, - NULL, &iter_substruct)) - break; - dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_INT32, &kd->keycode); - dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_INT32, &kd->keysym); - dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_STRING, &kd->keystring); - dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_INT32, &kd->unused); - dbus_message_iter_close_container (&iter_subarray, &iter_substruct); - } + { + Accessibility_KeyDefinition *kd = kl->data; + if (!dbus_message_iter_open_container (&iter_subarray, DBUS_TYPE_STRUCT, + NULL, &iter_substruct)) + break; + dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_INT32, &kd->keycode); + dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_INT32, &kd->keysym); + dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_STRING, &kd->keystring); + dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_INT32, &kd->unused); + dbus_message_iter_close_container (&iter_subarray, &iter_substruct); + } dbus_message_iter_close_container (&iter_struct, &iter_subarray); d_uint = listener->mask; dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_UINT32, &d_uint); if (dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_STRUCT, - NULL, &iter_substruct)) - { - if (listener->mode) - { - dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN, - &listener->mode->synchronous); - dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN, - &listener->mode->preemptive); - dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN, - &listener->mode->global); - } - else - { - dbus_bool_t dummy_val = FALSE; - dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN, - &dummy_val); - dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN, - &dummy_val); - dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN, - &dummy_val); - } - dbus_message_iter_close_container (&iter_struct, &iter_substruct); - } + NULL, &iter_substruct)) + { + if (listener->mode) + { + dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN, + &listener->mode->synchronous); + dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN, + &listener->mode->preemptive); + dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN, + &listener->mode->global); + } + else + { + dbus_bool_t dummy_val = FALSE; + dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN, + &dummy_val); + dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN, + &dummy_val); + dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN, + &dummy_val); + } + dbus_message_iter_close_container (&iter_struct, &iter_substruct); + } dbus_message_iter_close_container (iter, &iter_struct); } @@ -726,8 +731,8 @@ notify_keystroke_listener (SpiDEController *controller, const char *path = SPI_DBUS_PATH_DEC; const char *interface = SPI_DBUS_INTERFACE_DEVICE_EVENT_LISTENER; const char *name = (enable - ? "KeystrokeListenerRegistered" - : "KeystrokeListenerDeregistered"); + ? "KeystrokeListenerRegistered" + : "KeystrokeListenerDeregistered"); DBusMessage *signal; DBusMessageIter iter; @@ -741,41 +746,42 @@ notify_keystroke_listener (SpiDEController *controller, } static gboolean -spi_controller_register_device_listener (SpiDEController *controller, - DEControllerListener *listener) +spi_controller_register_device_listener (SpiDEController *controller, + DEControllerListener *listener) { DEControllerKeyListener *key_listener; gboolean retval; - - switch (listener->type) { - case SPI_DEVICE_TYPE_KBD: + + switch (listener->type) + { + case SPI_DEVICE_TYPE_KBD: key_listener = (DEControllerKeyListener *) listener; controller->key_listeners = g_list_prepend (controller->key_listeners, - key_listener); + key_listener); spi_dbus_add_disconnect_match (controller->bus, key_listener->listener.bus_name); if (key_listener->mode->global) { - retval = spi_controller_register_global_keygrabs (controller, key_listener); - } + retval = spi_controller_register_global_keygrabs (controller, key_listener); + } else - retval = TRUE; + retval = TRUE; if (retval) - notify_keystroke_listener (controller, key_listener, TRUE); + notify_keystroke_listener (controller, key_listener, TRUE); break; - default: + default: g_assert_not_reached (); break; - } + } return FALSE; } static void set_reply (DBusPendingCall *pending, void *user_data) { - void **replyptr = (void **)user_data; + void **replyptr = (void **) user_data; - *replyptr = dbus_pending_call_steal_reply (pending); + *replyptr = dbus_pending_call_steal_reply (pending); } static GSList *hung_processes = NULL; @@ -791,15 +797,15 @@ reset_hung_process (DBusPendingCall *pending, void *data) dbus_pending_call_unref (pending); for (l = hung_processes; l; l = l->next) - { - if (!strcmp (l->data, dest)) { - gpointer l_data = l->data; - hung_processes = g_slist_remove (hung_processes, l_data); - g_free (l_data); - break; + if (!strcmp (l->data, dest)) + { + gpointer l_data = l->data; + hung_processes = g_slist_remove (hung_processes, l_data); + g_free (l_data); + break; + } } - } } static gint @@ -817,15 +823,15 @@ reset_hung_process_from_ping (DBusPendingCall *pending, void *data) GSList *l; for (l = hung_processes; l; l = l->next) - { - if (!strcmp (l->data, data)) { - gpointer l_data = l->data; - hung_processes = g_slist_remove (hung_processes, l_data); - g_free (l_data); - break; + if (!strcmp (l->data, data)) + { + gpointer l_data = l->data; + hung_processes = g_slist_remove (hung_processes, l_data); + g_free (l_data); + break; + } } - } g_free (data); dbus_pending_call_unref (pending); } @@ -833,97 +839,97 @@ reset_hung_process_from_ping (DBusPendingCall *pending, void *data) static DBusMessage * send_and_allow_reentry (DBusConnection *bus, DBusMessage *message, int timeout, DBusError *error) { - DBusPendingCall *pending; - DBusMessage *reply = NULL; + DBusPendingCall *pending; + DBusMessage *reply = NULL; struct timeval tv; - if (!dbus_connection_send_with_reply (bus, message, &pending, -1)) + if (!dbus_connection_send_with_reply (bus, message, &pending, -1)) { - return NULL; + return NULL; } - dbus_pending_call_set_notify (pending, set_reply, (void *)&reply, NULL); - gettimeofday (&tv, NULL); - while (!reply) + dbus_pending_call_set_notify (pending, set_reply, (void *) &reply, NULL); + gettimeofday (&tv, NULL); + while (!reply) { if (!dbus_connection_read_write_dispatch (bus, timeout) || time_elapsed (&tv) > timeout) - { - const char *dest = dbus_message_get_destination (message); - GSList *l; - gchar *bus_name_dup; - dbus_message_ref (message); - dbus_pending_call_set_notify (pending, reset_hung_process, message, - (DBusFreeFunction) dbus_message_unref); - message = dbus_message_new_method_call (dest, "/", - "org.freedesktop.DBus.Peer", - "Ping"); - if (!message) - return NULL; - dbus_connection_send_with_reply (bus, message, &pending, -1); - dbus_message_unref (message); - if (!pending) - return NULL; - bus_name_dup = g_strdup (dest); - dbus_pending_call_set_notify (pending, reset_hung_process_from_ping, - bus_name_dup, NULL); - for (l = hung_processes; l; l = l->next) - if (!strcmp (l->data, dest)) + { + const char *dest = dbus_message_get_destination (message); + GSList *l; + gchar *bus_name_dup; + dbus_message_ref (message); + dbus_pending_call_set_notify (pending, reset_hung_process, message, + (DBusFreeFunction) dbus_message_unref); + message = dbus_message_new_method_call (dest, "/", + "org.freedesktop.DBus.Peer", + "Ping"); + if (!message) + return NULL; + dbus_connection_send_with_reply (bus, message, &pending, -1); + dbus_message_unref (message); + if (!pending) return NULL; - hung_processes = g_slist_prepend (hung_processes, g_strdup (dest)); - return NULL; - } + bus_name_dup = g_strdup (dest); + dbus_pending_call_set_notify (pending, reset_hung_process_from_ping, + bus_name_dup, NULL); + for (l = hung_processes; l; l = l->next) + if (!strcmp (l->data, dest)) + return NULL; + hung_processes = g_slist_prepend (hung_processes, g_strdup (dest)); + return NULL; + } } - dbus_pending_call_unref (pending); - return reply; + dbus_pending_call_unref (pending); + return reply; } static gboolean -Accessibility_DeviceEventListener_NotifyEvent(SpiDEController *controller, - DEControllerListener *listener, - const Accessibility_DeviceEvent *key_event) -{ - DBusMessage *message = dbus_message_new_method_call(listener->bus_name, - listener->path, - SPI_DBUS_INTERFACE_DEVICE_EVENT_LISTENER, - "NotifyEvent"); +Accessibility_DeviceEventListener_NotifyEvent (SpiDEController *controller, + DEControllerListener *listener, + const Accessibility_DeviceEvent *key_event) +{ + DBusMessage *message = dbus_message_new_method_call (listener->bus_name, + listener->path, + SPI_DBUS_INTERFACE_DEVICE_EVENT_LISTENER, + "NotifyEvent"); dbus_bool_t consumed = FALSE; GSList *l; gboolean hung = FALSE; for (l = hung_processes; l; l = l->next) - { - if (!strcmp (l->data, listener->bus_name)) { - dbus_message_set_no_reply (message, TRUE); - hung = TRUE; - break; + if (!strcmp (l->data, listener->bus_name)) + { + dbus_message_set_no_reply (message, TRUE); + hung = TRUE; + break; + } } - } - - if (spi_dbus_marshal_deviceEvent(message, key_event)) - { - DBusMessage *reply; - if (hung) + if (spi_dbus_marshal_deviceEvent (message, key_event)) { - dbus_connection_send (controller->bus, message, NULL); - dbus_message_unref (message); - return FALSE; - } + DBusMessage *reply; - reply = send_and_allow_reentry (controller->bus, message, 3000, NULL); - if (reply) - { - dbus_message_get_args(reply, NULL, DBUS_TYPE_BOOLEAN, &consumed, DBUS_TYPE_INVALID); - dbus_message_unref(reply); + if (hung) + { + dbus_connection_send (controller->bus, message, NULL); + dbus_message_unref (message); + return FALSE; + } + + reply = send_and_allow_reentry (controller->bus, message, 3000, NULL); + if (reply) + { + dbus_message_get_args (reply, NULL, DBUS_TYPE_BOOLEAN, &consumed, DBUS_TYPE_INVALID); + dbus_message_unref (reply); + } } - } - dbus_message_unref(message); + dbus_message_unref (message); return consumed; } static gboolean -key_set_contains_key (GSList *key_set, - const Accessibility_DeviceEvent *key_event) +key_set_contains_key (GSList *key_set, + const Accessibility_DeviceEvent *key_event) { gint i; gint len; @@ -938,40 +944,40 @@ key_set_contains_key (GSList *key_set, } len = g_slist_length (key_set); - + if (len == 0) /* special case, means "all keys/any key" */ { #ifdef SPI_DEBUG - g_print ("anykey\n"); + g_print ("anykey\n"); #endif return TRUE; } - for (l = key_set,i = 0; l; l = g_slist_next(l),i++) + for (l = key_set, i = 0; l; l = g_slist_next (l), i++) { Accessibility_KeyDefinition *kd = l->data; -#ifdef SPI_KEYEVENT_DEBUG +#ifdef SPI_KEYEVENT_DEBUG g_print ("key_set[%d] event = %d, code = %d; key_event %d, code %d, string %s\n", - i, - (int) kd->keysym, - (int) kd->keycode, - (int) key_event->id, - (int) key_event->hw_code, - key_event->event_string); + i, + (int) kd->keysym, + (int) kd->keycode, + (int) key_event->id, + (int) key_event->hw_code, + key_event->event_string); #endif if (kd->keysym == (dbus_uint32_t) key_event->id) { return TRUE; - } + } if (kd->keycode == (dbus_uint32_t) key_event->hw_code) { return TRUE; - } + } if (key_event->event_string && key_event->event_string[0] && - !strcmp (kd->keystring, key_event->event_string)) + !strcmp (kd->keystring, key_event->event_string)) { return TRUE; - } + } } return FALSE; @@ -979,7 +985,7 @@ key_set_contains_key (GSList *key_set, static gboolean eventtype_seq_contains_event (dbus_uint32_t types, - const Accessibility_DeviceEvent *event) + const Accessibility_DeviceEvent *event) { if (types == 0) /* special case, means "all events/any event" */ { @@ -991,12 +997,12 @@ eventtype_seq_contains_event (dbus_uint32_t types, static gboolean spi_key_event_matches_listener (const Accessibility_DeviceEvent *key_event, - DEControllerKeyListener *listener, - dbus_bool_t is_system_global) + DEControllerKeyListener *listener, + dbus_bool_t is_system_global) { if (((key_event->modifiers & 0xFF) == (dbus_uint16_t) (listener->mask & 0xFF)) && - key_set_contains_key (listener->keys, key_event) && - eventtype_seq_contains_event (listener->listener.types, key_event) && + key_set_contains_key (listener->keys, key_event) && + eventtype_seq_contains_event (listener->listener.types, key_event) && (is_system_global == listener->mode->global)) { return TRUE; @@ -1008,13 +1014,13 @@ spi_key_event_matches_listener (const Accessibility_DeviceEvent *key_event, } gboolean -spi_controller_notify_keylisteners (SpiDEController *controller, - Accessibility_DeviceEvent *key_event, - dbus_bool_t is_system_global) +spi_controller_notify_keylisteners (SpiDEController *controller, + Accessibility_DeviceEvent *key_event, + dbus_bool_t is_system_global) { - GList *l; - GSList *notify = NULL, *l2; - GList **key_listeners = &controller->key_listeners; + GList *l; + GSList *notify = NULL, *l2; + GList **key_listeners = &controller->key_listeners; gboolean is_consumed; if (!key_listeners) @@ -1024,18 +1030,18 @@ spi_controller_notify_keylisteners (SpiDEController *controller, /* set the NUMLOCK event mask bit if appropriate: see bug #143702 */ if (key_event->modifiers & _numlock_physical_mask) - key_event->modifiers |= SPI_KEYMASK_NUMLOCK; + key_event->modifiers |= SPI_KEYMASK_NUMLOCK; for (l = *key_listeners; l; l = l->next) { - DEControllerKeyListener *key_listener = l->data; + DEControllerKeyListener *key_listener = l->data; - if (spi_key_event_matches_listener (key_event, key_listener, is_system_global)) - { - /* we clone (don't dup) the listener, to avoid refcount inc. */ - notify = g_slist_prepend (notify, - spi_key_listener_clone (key_listener)); - } + if (spi_key_event_matches_listener (key_event, key_listener, is_system_global)) + { + /* we clone (don't dup) the listener, to avoid refcount inc. */ + notify = g_slist_prepend (notify, + spi_key_listener_clone (key_listener)); + } } #ifdef SPI_KEYEVENT_DEBUG @@ -1048,17 +1054,17 @@ spi_controller_notify_keylisteners (SpiDEController *controller, is_consumed = FALSE; for (l2 = notify; l2 && !is_consumed; l2 = l2->next) { - DEControllerKeyListener *key_listener = l2->data; + DEControllerKeyListener *key_listener = l2->data; is_consumed = Accessibility_DeviceEventListener_NotifyEvent (controller, &key_listener->listener, key_event) && - key_listener->mode->preemptive; + key_listener->mode->preemptive; spi_key_listener_clone_free (key_listener); } for (; l2; l2 = l2->next) { - DEControllerKeyListener *key_listener = l2->data; + DEControllerKeyListener *key_listener = l2->data; spi_key_listener_clone_free (key_listener); /* clone doesn't have its own ref, so don't use spi_dec_listener_free */ } @@ -1066,19 +1072,20 @@ spi_controller_notify_keylisteners (SpiDEController *controller, g_slist_free (notify); #ifdef SPI_DEBUG - if (is_consumed) g_message ("consumed\n"); + if (is_consumed) + g_message ("consumed\n"); #endif return is_consumed; } gboolean -spi_controller_update_key_grabs (SpiDEController *controller, - Accessibility_DeviceEvent *recv) +spi_controller_update_key_grabs (SpiDEController *controller, + Accessibility_DeviceEvent *recv) { GList *l, *next; - gboolean update_failed = FALSE; + gboolean update_failed = FALSE; long keycode = 0; - + g_return_val_if_fail (controller != NULL, FALSE); /* @@ -1101,16 +1108,16 @@ spi_controller_update_key_grabs (SpiDEController *controller, next = l->next; re_issue_grab = recv && - (recv->modifiers & grab_mask->mod_mask) && - (grab_mask->key_val == keycode); + (recv->modifiers & grab_mask->mod_mask) && + (grab_mask->key_val == keycode); #ifdef SPI_DEBUG fprintf (stderr, "mask=%lx %lx (%c%c) %s\n", - (long int) grab_mask->key_val, - (long int) grab_mask->mod_mask, - grab_mask->pending_add ? '+' : '.', - grab_mask->pending_remove ? '-' : '.', - re_issue_grab ? "re-issue": ""); + (long int) grab_mask->key_val, + (long int) grab_mask->mod_mask, + grab_mask->pending_add ? '+' : '.', + grab_mask->pending_remove ? '-' : '.', + re_issue_grab ? "re-issue" : ""); #endif do_remove = FALSE; @@ -1118,32 +1125,34 @@ spi_controller_update_key_grabs (SpiDEController *controller, if (grab_mask->pending_add && grab_mask->pending_remove) { do_remove = TRUE; - } + } else if (grab_mask->pending_remove) { #ifdef SPI_DEBUG - fprintf (stderr, "ungrabbing, mask=%x\n", grab_mask->mod_mask); + fprintf (stderr, "ungrabbing, mask=%x\n", grab_mask->mod_mask); #endif - spi_dec_plat_ungrab_key (controller, - grab_mask->key_val, - grab_mask->mod_mask); + spi_dec_plat_ungrab_key (controller, + grab_mask->key_val, + grab_mask->mod_mask); do_remove = TRUE; - } + } else if (grab_mask->pending_add || re_issue_grab) { #ifdef SPI_DEBUG - fprintf (stderr, "grab %d with mask %x\n", grab_mask->key_val, grab_mask->mod_mask); + fprintf (stderr, "grab %d with mask %x\n", grab_mask->key_val, grab_mask->mod_mask); #endif - update_failed = spi_dec_plat_grab_key (controller, - grab_mask->key_val, - grab_mask->mod_mask); - if (update_failed) { - while (grab_mask->ref_count > 0) --grab_mask->ref_count; - do_remove = TRUE; - } - } + update_failed = spi_dec_plat_grab_key (controller, + grab_mask->key_val, + grab_mask->mod_mask); + if (update_failed) + { + while (grab_mask->ref_count > 0) + --grab_mask->ref_count; + do_remove = TRUE; + } + } grab_mask->pending_add = FALSE; grab_mask->pending_remove = FALSE; @@ -1152,15 +1161,14 @@ spi_controller_update_key_grabs (SpiDEController *controller, { g_assert (grab_mask->ref_count <= 0); - controller->keygrabs_list = g_list_delete_link ( - controller->keygrabs_list, l); + controller->keygrabs_list = g_list_delete_link ( + controller->keygrabs_list, l); - spi_grab_mask_free (grab_mask); - } - - } + spi_grab_mask_free (grab_mask); + } + } - return ! update_failed; + return !update_failed; } /* @@ -1170,13 +1178,13 @@ static void spi_device_event_controller_object_finalize (GObject *object) { SpiDEController *controller; - GObjectClass *parent_class = G_OBJECT_CLASS(spi_device_event_controller_parent_class); + GObjectClass *parent_class = G_OBJECT_CLASS (spi_device_event_controller_parent_class); SpiDEControllerClass *klass; controller = SPI_DEVICE_EVENT_CONTROLLER (object); klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller); #ifdef SPI_DEBUG - fprintf(stderr, "spi_device_event_controller_object_finalize called\n"); + fprintf (stderr, "spi_device_event_controller_object_finalize called\n"); #endif if (klass->plat.finalize) klass->plat.finalize (controller); @@ -1197,68 +1205,69 @@ impl_register_keystroke_listener (DBusMessage *message, SpiDEController *control GSList *keys = NULL; dbus_int32_t mask, types; Accessibility_EventListenerMode *mode; - dbus_bool_t ret; + dbus_bool_t ret; DBusMessage *reply = NULL; char *keystring; if (strcmp (dbus_message_get_signature (message), "oa(iisi)uu(bbb)") != 0) return invalid_arguments_error (message); - dbus_message_iter_init(message, &iter); - dbus_message_iter_get_basic(&iter, &path); - dbus_message_iter_next(&iter); - dbus_message_iter_recurse(&iter, &iter_array); - while (dbus_message_iter_get_arg_type(&iter_array) != DBUS_TYPE_INVALID) - { - Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *)g_malloc(sizeof(Accessibility_KeyDefinition)); - if (!spi_dbus_message_iter_get_struct(&iter_array, DBUS_TYPE_INT32, &kd->keycode, DBUS_TYPE_INT32, &kd->keysym, DBUS_TYPE_STRING, &keystring, DBUS_TYPE_INVALID)) + dbus_message_iter_init (message, &iter); + dbus_message_iter_get_basic (&iter, &path); + dbus_message_iter_next (&iter); + dbus_message_iter_recurse (&iter, &iter_array); + while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID) { - g_free(kd); - break; + Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *) g_malloc (sizeof (Accessibility_KeyDefinition)); + if (!spi_dbus_message_iter_get_struct (&iter_array, DBUS_TYPE_INT32, &kd->keycode, DBUS_TYPE_INT32, &kd->keysym, DBUS_TYPE_STRING, &keystring, DBUS_TYPE_INVALID)) + { + g_free (kd); + break; + } + kd->keystring = g_strdup (keystring); + keys = g_slist_append (keys, kd); } - kd->keystring = g_strdup (keystring); - keys = g_slist_append(keys, kd); - } - dbus_message_iter_next(&iter); - dbus_message_iter_get_basic(&iter, &mask); - dbus_message_iter_next(&iter); - dbus_message_iter_get_basic(&iter, &types); - dbus_message_iter_next(&iter); - mode = (Accessibility_EventListenerMode *)g_malloc(sizeof(Accessibility_EventListenerMode)); + dbus_message_iter_next (&iter); + dbus_message_iter_get_basic (&iter, &mask); + dbus_message_iter_next (&iter); + dbus_message_iter_get_basic (&iter, &types); + dbus_message_iter_next (&iter); + mode = (Accessibility_EventListenerMode *) g_malloc (sizeof (Accessibility_EventListenerMode)); if (mode) - { - spi_dbus_message_iter_get_struct(&iter, DBUS_TYPE_BOOLEAN, &mode->synchronous, DBUS_TYPE_BOOLEAN, &mode->preemptive, DBUS_TYPE_BOOLEAN, &mode->global, DBUS_TYPE_INVALID); - } + { + spi_dbus_message_iter_get_struct (&iter, DBUS_TYPE_BOOLEAN, &mode->synchronous, DBUS_TYPE_BOOLEAN, &mode->preemptive, DBUS_TYPE_BOOLEAN, &mode->global, DBUS_TYPE_INVALID); + } #ifdef SPI_DEBUG fprintf (stderr, "registering keystroke listener %s:%s with maskVal %lu\n", - dbus_message_get_sender(message), path, (unsigned long) mask); + 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, types, mode); + dec_listener = spi_dec_key_listener_new (dbus_message_get_sender (message), path, keys, mask, types, mode); g_free (mode); ret = spi_controller_register_device_listener ( - controller, (DEControllerListener *) dec_listener); + controller, (DEControllerListener *) dec_listener); reply = dbus_message_new_method_return (message); if (reply) - { - dbus_message_append_args (reply, DBUS_TYPE_BOOLEAN, &ret, DBUS_TYPE_INVALID); - } + { + dbus_message_append_args (reply, DBUS_TYPE_BOOLEAN, &ret, DBUS_TYPE_INVALID); + } return reply; } -typedef struct { - DBusConnection *bus; - DEControllerListener *listener; +typedef struct +{ + DBusConnection *bus; + DEControllerListener *listener; } RemoveListenerClosure; static SpiReEntrantContinue -remove_listener_cb (GList * const *list, - gpointer user_data) +remove_listener_cb (GList *const *list, + gpointer user_data) { - DEControllerListener *listener = (*list)->data; + DEControllerListener *listener = (*list)->data; RemoveListenerClosure *ctx = user_data; - if (!strcmp(ctx->listener->bus_name, listener->bus_name) && - !strcmp(ctx->listener->path, listener->path)) + if (!strcmp (ctx->listener->bus_name, listener->bus_name) && + !strcmp (ctx->listener->path, listener->path)) { spi_re_entrant_list_delete_link (list); spi_dbus_remove_disconnect_match (ctx->bus, listener->bus_name); @@ -1269,30 +1278,30 @@ remove_listener_cb (GList * const *list, } static SpiReEntrantContinue -copy_key_listener_cb (GList * const *list, - gpointer user_data) +copy_key_listener_cb (GList *const *list, + gpointer user_data) { - DEControllerKeyListener *key_listener = (*list)->data; - RemoveListenerClosure *ctx = user_data; + DEControllerKeyListener *key_listener = (*list)->data; + RemoveListenerClosure *ctx = user_data; - if (!strcmp(ctx->listener->bus_name, key_listener->listener.bus_name) && - !strcmp(ctx->listener->path, key_listener->listener.path)) + if (!strcmp (ctx->listener->bus_name, key_listener->listener.bus_name) && + !strcmp (ctx->listener->path, key_listener->listener.path)) { /* TODO: FIXME aggregate keys in case the listener is registered twice */ - DEControllerKeyListener *ctx_key_listener = - (DEControllerKeyListener *) ctx->listener; - keylist_free (ctx_key_listener->keys); - ctx_key_listener->keys = keylist_clone(key_listener->keys); + DEControllerKeyListener *ctx_key_listener = + (DEControllerKeyListener *) ctx->listener; + keylist_free (ctx_key_listener->keys); + ctx_key_listener->keys = keylist_clone (key_listener->keys); } return SPI_RE_ENTRANT_CONTINUE; } static void -spi_deregister_controller_key_listener (SpiDEController *controller, - DEControllerKeyListener *key_listener) +spi_deregister_controller_key_listener (SpiDEController *controller, + DEControllerKeyListener *key_listener) { - RemoveListenerClosure ctx; + RemoveListenerClosure ctx; ctx.bus = controller->bus; ctx.listener = (DEControllerListener *) spi_key_listener_clone (key_listener); @@ -1300,16 +1309,16 @@ spi_deregister_controller_key_listener (SpiDEController *controller, notify_keystroke_listener (controller, key_listener, FALSE); /* special case, copy keyset from existing controller list entry */ - if (g_slist_length(key_listener->keys) == 0) + if (g_slist_length (key_listener->keys) == 0) { spi_re_entrant_list_foreach (&controller->key_listeners, - copy_key_listener_cb, &ctx); + copy_key_listener_cb, &ctx); } spi_controller_deregister_global_keygrabs (controller, key_listener); spi_re_entrant_list_foreach (&controller->key_listeners, - remove_listener_cb, &ctx); + remove_listener_cb, &ctx); spi_key_listener_clone_free ((DEControllerKeyListener *) ctx.listener); } @@ -1320,16 +1329,16 @@ spi_remove_device_listeners (SpiDEController *controller, const char *bus_name) GList *l, *tmp; for (l = controller->key_listeners; l; l = tmp) - { - DEControllerKeyListener *key_listener = l->data; - tmp = l->next; - if (!strcmp (key_listener->listener.bus_name, bus_name)) { - /* TODO: untangle the below line(s) */ - spi_deregister_controller_key_listener (controller, key_listener); - tmp = controller->key_listeners; + DEControllerKeyListener *key_listener = l->data; + tmp = l->next; + if (!strcmp (key_listener->listener.bus_name, bus_name)) + { + /* TODO: untangle the below line(s) */ + spi_deregister_controller_key_listener (controller, key_listener); + tmp = controller->key_listeners; + } } - } } /* @@ -1346,38 +1355,38 @@ impl_deregister_keystroke_listener (DBusMessage *message, SpiDEController *contr dbus_int32_t mask, type; DBusMessage *reply = NULL; - dbus_message_iter_init(message, &iter); + dbus_message_iter_init (message, &iter); if (strcmp (dbus_message_get_signature (message), "oa(iisi)uu") != 0) - { - g_warning ("Received DeregisterKeystrokeListener with strange signature '%s'", dbus_message_get_signature (message)); - return invalid_arguments_error (message); - } - - dbus_message_iter_get_basic(&iter, &path); - dbus_message_iter_next(&iter); - dbus_message_iter_recurse(&iter, &iter_array); - while (dbus_message_iter_get_arg_type(&iter_array) != DBUS_TYPE_INVALID) - { - Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *)g_malloc(sizeof(Accessibility_KeyDefinition)); - char *keystring; + { + g_warning ("Received DeregisterKeystrokeListener with strange signature '%s'", dbus_message_get_signature (message)); + return invalid_arguments_error (message); + } - if (!spi_dbus_message_iter_get_struct(&iter_array, DBUS_TYPE_INT32, &kd->keycode, DBUS_TYPE_INT32, &kd->keysym, DBUS_TYPE_STRING, &keystring, DBUS_TYPE_INVALID)) + dbus_message_iter_get_basic (&iter, &path); + dbus_message_iter_next (&iter); + dbus_message_iter_recurse (&iter, &iter_array); + while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID) { - g_free(kd); - break; + Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *) g_malloc (sizeof (Accessibility_KeyDefinition)); + char *keystring; + + if (!spi_dbus_message_iter_get_struct (&iter_array, DBUS_TYPE_INT32, &kd->keycode, DBUS_TYPE_INT32, &kd->keysym, DBUS_TYPE_STRING, &keystring, DBUS_TYPE_INVALID)) + { + g_free (kd); + break; + } + kd->keystring = g_strdup (keystring); + keys = g_slist_append (keys, kd); } - kd->keystring = g_strdup (keystring); - keys = g_slist_append(keys, kd); - } - dbus_message_iter_next(&iter); - dbus_message_iter_get_basic(&iter, &mask); - dbus_message_iter_next(&iter); - dbus_message_iter_get_basic(&iter, &type); - dbus_message_iter_next(&iter); - key_listener = spi_dec_key_listener_new (dbus_message_get_sender(message), path, keys, mask, type, NULL); + dbus_message_iter_next (&iter); + dbus_message_iter_get_basic (&iter, &mask); + dbus_message_iter_next (&iter); + dbus_message_iter_get_basic (&iter, &type); + dbus_message_iter_next (&iter); + key_listener = spi_dec_key_listener_new (dbus_message_get_sender (message), path, keys, mask, type, NULL); #ifdef SPI_DEREGISTER_DEBUG fprintf (stderr, "deregistering keystroke listener %p with maskVal %lu\n", - (void *) l, (unsigned long) mask->value); + (void *) l, (unsigned long) mask->value); #endif spi_deregister_controller_key_listener (controller, key_listener); @@ -1401,9 +1410,9 @@ impl_get_keystroke_listeners (DBusMessage *message, SpiDEController *controller) dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "(souua(iisi)u(bbb))", &iter_array); for (l = controller->key_listeners; l; l = l->next) - { - append_keystroke_listener (&iter_array, l->data); - } + { + append_keystroke_listener (&iter_array, l->data); + } dbus_message_iter_close_container (&iter, &iter_array); return reply; } @@ -1411,44 +1420,45 @@ impl_get_keystroke_listeners (DBusMessage *message, SpiDEController *controller) static unsigned get_modifier_state (SpiDEController *controller) { - spi_dec_poll_mouse_moved (controller); - return controller->mouse_mask_state; + spi_dec_poll_mouse_moved (controller); + return controller->mouse_mask_state; } gboolean spi_dec_synth_keysym (SpiDEController *controller, long keysym) { - long key_synth_code; - unsigned int modifiers, synth_mods, lock_mods; + long key_synth_code; + unsigned int modifiers, synth_mods, lock_mods; - key_synth_code = spi_dec_plat_get_keycode (controller, keysym, NULL, TRUE, &synth_mods); + key_synth_code = spi_dec_plat_get_keycode (controller, keysym, NULL, TRUE, &synth_mods); - if ((key_synth_code == 0) || (synth_mods == 0xFF)) return FALSE; + if ((key_synth_code == 0) || (synth_mods == 0xFF)) + return FALSE; - /* TODO: set the modifiers accordingly! */ - modifiers = get_modifier_state (controller); - /* side-effect; we may unset mousebutton modifiers here! */ + /* TODO: set the modifiers accordingly! */ + modifiers = get_modifier_state (controller); + /* side-effect; we may unset mousebutton modifiers here! */ - lock_mods = 0; - if (synth_mods != modifiers) { - lock_mods = synth_mods & ~modifiers; - spi_dec_plat_lock_modifiers (controller, lock_mods); - if (modifiers & SPI_KEYMASK_SHIFTLOCK) - spi_dec_plat_unlock_modifiers (controller, SPI_KEYMASK_SHIFTLOCK); - } - spi_dec_plat_synth_keycode_press (controller, key_synth_code); - spi_dec_plat_synth_keycode_release (controller, key_synth_code); + lock_mods = 0; + if (synth_mods != modifiers) + { + lock_mods = synth_mods & ~modifiers; + spi_dec_plat_lock_modifiers (controller, lock_mods); + if (modifiers & SPI_KEYMASK_SHIFTLOCK) + spi_dec_plat_unlock_modifiers (controller, SPI_KEYMASK_SHIFTLOCK); + } + spi_dec_plat_synth_keycode_press (controller, key_synth_code); + spi_dec_plat_synth_keycode_release (controller, key_synth_code); - if (synth_mods != modifiers) { - spi_dec_plat_unlock_modifiers (controller, lock_mods); - if (modifiers & SPI_KEYMASK_SHIFTLOCK) - spi_dec_plat_lock_modifiers (controller, SPI_KEYMASK_SHIFTLOCK); - } - return TRUE; + if (synth_mods != modifiers) + { + spi_dec_plat_unlock_modifiers (controller, lock_mods); + if (modifiers & SPI_KEYMASK_SHIFTLOCK) + spi_dec_plat_lock_modifiers (controller, SPI_KEYMASK_SHIFTLOCK); + } + return TRUE; } - - /* * DBus Accessibility::DEController::RegisterKeystrokeListener * method implementation @@ -1461,14 +1471,14 @@ impl_generate_keyboard_event (DBusMessage *message, SpiDEController *controller) dbus_uint32_t synth_type; DBusMessage *reply = NULL; - if (!dbus_message_get_args(message, NULL, DBUS_TYPE_INT32, &keycode, DBUS_TYPE_STRING, &keystring, DBUS_TYPE_UINT32, &synth_type, DBUS_TYPE_INVALID)) - { - return invalid_arguments_error (message); - } + if (!dbus_message_get_args (message, NULL, DBUS_TYPE_INT32, &keycode, DBUS_TYPE_STRING, &keystring, DBUS_TYPE_UINT32, &synth_type, DBUS_TYPE_INVALID)) + { + return invalid_arguments_error (message); + } #ifdef SPI_DEBUG - fprintf (stderr, "synthesizing keystroke %ld, type %d\n", - (long) keycode, (int) synth_type); + fprintf (stderr, "synthesizing keystroke %ld, type %d\n", + (long) keycode, (int) synth_type); #endif /* TODO: hide/wrap/remove X dependency */ @@ -1476,39 +1486,39 @@ impl_generate_keyboard_event (DBusMessage *message, SpiDEController *controller) * TODO: when initializing, query for XTest extension before using, * and fall back to XSendEvent() if XTest is not available. */ - + switch (synth_type) { - case Accessibility_KEY_PRESS: - spi_dec_plat_synth_keycode_press (controller, keycode); - break; - case Accessibility_KEY_PRESSRELEASE: - spi_dec_plat_synth_keycode_press (controller, keycode); - case Accessibility_KEY_RELEASE: - spi_dec_plat_synth_keycode_release (controller, keycode); - break; - case Accessibility_KEY_SYM: -#ifdef SPI_XKB_DEBUG - fprintf (stderr, "KeySym synthesis\n"); + case Accessibility_KEY_PRESS: + spi_dec_plat_synth_keycode_press (controller, keycode); + break; + case Accessibility_KEY_PRESSRELEASE: + spi_dec_plat_synth_keycode_press (controller, keycode); + case Accessibility_KEY_RELEASE: + spi_dec_plat_synth_keycode_release (controller, keycode); + break; + case Accessibility_KEY_SYM: +#ifdef SPI_XKB_DEBUG + fprintf (stderr, "KeySym synthesis\n"); #endif - /* - * note: we are using long for 'keycode' - * in our arg list; it can contain either - * a keycode or a keysym. - */ - spi_dec_synth_keysym (controller, keycode); - break; - case Accessibility_KEY_STRING: - if (!spi_dec_plat_synth_keystring (controller, synth_type, keycode, keystring)) - fprintf (stderr, "Keystring synthesis failure, string=%s\n", - keystring); - break; - case Accessibility_KEY_LOCKMODIFIERS: - spi_dec_plat_lock_modifiers (controller, keycode); - break; - case Accessibility_KEY_UNLOCKMODIFIERS: - spi_dec_plat_unlock_modifiers (controller, keycode); - break; + /* + * note: we are using long for 'keycode' + * in our arg list; it can contain either + * a keycode or a keysym. + */ + spi_dec_synth_keysym (controller, keycode); + break; + case Accessibility_KEY_STRING: + if (!spi_dec_plat_synth_keystring (controller, synth_type, keycode, keystring)) + fprintf (stderr, "Keystring synthesis failure, string=%s\n", + keystring); + break; + case Accessibility_KEY_LOCKMODIFIERS: + spi_dec_plat_lock_modifiers (controller, keycode); + break; + case Accessibility_KEY_UNLOCKMODIFIERS: + spi_dec_plat_unlock_modifiers (controller, keycode); + break; } reply = dbus_message_new_method_return (message); return reply; @@ -1518,19 +1528,19 @@ impl_generate_keyboard_event (DBusMessage *message, SpiDEController *controller) static DBusMessage * impl_generate_mouse_event (DBusMessage *message, SpiDEController *controller) { - dbus_int32_t x; - dbus_int32_t y; + dbus_int32_t x; + dbus_int32_t y; char *eventName; DBusMessage *reply = NULL; - if (!dbus_message_get_args(message, NULL, DBUS_TYPE_INT32, &x, DBUS_TYPE_INT32, &y, DBUS_TYPE_STRING, &eventName, DBUS_TYPE_INVALID)) - { - return invalid_arguments_error (message); - } + if (!dbus_message_get_args (message, NULL, DBUS_TYPE_INT32, &x, DBUS_TYPE_INT32, &y, DBUS_TYPE_STRING, &eventName, DBUS_TYPE_INVALID)) + { + return invalid_arguments_error (message); + } #ifdef SPI_DEBUG fprintf (stderr, "generating mouse %s event at %ld, %ld\n", - eventName, (long int) x, (long int) y); + eventName, (long int) x, (long int) y); #endif spi_dec_plat_generate_mouse_event (controller, x, y, eventName); reply = dbus_message_new_method_return (message); @@ -1545,23 +1555,23 @@ impl_notify_listeners_sync (DBusMessage *message, SpiDEController *controller) dbus_bool_t ret; DBusMessage *reply = NULL; - if (!spi_dbus_demarshal_deviceEvent(message, &event)) - { - return invalid_arguments_error (message); - } + if (!spi_dbus_demarshal_deviceEvent (message, &event)) + { + return invalid_arguments_error (message); + } #ifdef SPI_DEBUG g_print ("notifylistening listeners synchronously: controller %p, event id %d\n", - controller, (int) event.id); + controller, (int) event.id); #endif ret = spi_controller_notify_keylisteners (controller, - (Accessibility_DeviceEvent *) - &event, FALSE) ? - TRUE : FALSE; + (Accessibility_DeviceEvent *) &event, FALSE) + ? TRUE + : FALSE; reply = dbus_message_new_method_return (message); if (reply) - { - dbus_message_append_args (reply, DBUS_TYPE_BOOLEAN, &ret, DBUS_TYPE_INVALID); - } + { + dbus_message_append_args (reply, DBUS_TYPE_BOOLEAN, &ret, DBUS_TYPE_INVALID); + } return reply; } @@ -1571,16 +1581,15 @@ impl_notify_listeners_async (DBusMessage *message, SpiDEController *controller) Accessibility_DeviceEvent event; DBusMessage *reply = NULL; - if (!spi_dbus_demarshal_deviceEvent(message, &event)) - { - return invalid_arguments_error (message); - } + if (!spi_dbus_demarshal_deviceEvent (message, &event)) + { + return invalid_arguments_error (message); + } #ifdef SPI_DEBUG g_print ("notifylistening listeners asynchronously: controller %p, event id %d\n", - controller, (int) event.id); + controller, (int) event.id); #endif - spi_controller_notify_keylisteners (controller, (Accessibility_DeviceEvent *) - &event, FALSE); + spi_controller_notify_keylisteners (controller, (Accessibility_DeviceEvent *) &event, FALSE); reply = dbus_message_new_method_return (message); return reply; } @@ -1588,7 +1597,7 @@ impl_notify_listeners_async (DBusMessage *message, SpiDEController *controller) static void spi_device_event_controller_class_init (SpiDEControllerClass *klass) { - GObjectClass * object_class = (GObjectClass *) klass; + GObjectClass *object_class = (GObjectClass *) klass; spi_device_event_controller_parent_class = g_type_class_peek_parent (klass); @@ -1612,20 +1621,19 @@ spi_device_event_controller_init (SpiDEController *device_event_controller) klass->plat.init (device_event_controller); } - /*---------------------------------------------------------------------------*/ static const char *introspection_header = -"<?xml version=\"1.0\"?>\n"; + "<?xml version=\"1.0\"?>\n"; static const char *introspection_node_element = -"<node name=\"%s\">\n"; + "<node name=\"%s\">\n"; static const char *introspection_footer = -"</node>"; + "</node>"; static DBusMessage * -impl_Introspect (DBusMessage * message, SpiDEController *controller) +impl_Introspect (DBusMessage *message, SpiDEController *controller) { GString *output; gchar *final; @@ -1634,19 +1642,19 @@ impl_Introspect (DBusMessage * message, SpiDEController *controller) DBusMessage *reply; - output = g_string_new(introspection_header); + output = g_string_new (introspection_header); - g_string_append_printf(output, introspection_node_element, pathstr); + 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); + 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); + dbus_message_append_args (reply, DBUS_TYPE_STRING, &final, DBUS_TYPE_INVALID); - g_free(final); + g_free (final); return reply; } @@ -1655,39 +1663,39 @@ impl_Introspect (DBusMessage * message, SpiDEController *controller) static void handle_message (DBusMessage *message, SpiDEController *controller) { - const gchar *iface = dbus_message_get_interface (message); - const gchar *member = dbus_message_get_member (message); + const gchar *iface = dbus_message_get_interface (message); + const gchar *member = dbus_message_get_member (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 (message, controller); + if (!strcmp (member, "RegisterKeystrokeListener")) + reply = impl_register_keystroke_listener (message, controller); else if (!strcmp (member, "DeregisterKeystrokeListener")) - reply = impl_deregister_keystroke_listener (message, controller); + reply = impl_deregister_keystroke_listener (message, controller); else if (!strcmp (member, "GetKeystrokeListeners")) - reply = impl_get_keystroke_listeners (message, controller); + reply = impl_get_keystroke_listeners (message, controller); else if (!strcmp (member, "GenerateKeyboardEvent")) - reply = impl_generate_keyboard_event (message, controller); + reply = impl_generate_keyboard_event (message, controller); else if (!strcmp (member, "GenerateMouseEvent")) - reply = impl_generate_mouse_event (message, controller); + reply = impl_generate_mouse_event (message, controller); else if (!strcmp (member, "NotifyListenersSync")) - reply = impl_notify_listeners_sync (message, controller); + reply = impl_notify_listeners_sync (message, controller); else if (!strcmp (member, "NotifyListenersAsync")) - reply = impl_notify_listeners_async (message, controller); + reply = impl_notify_listeners_async (message, controller); else - result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + 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 (message, controller); + if (!strcmp (member, "Introspect")) + reply = impl_Introspect (message, controller); else - result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } if (result == DBUS_HANDLER_RESULT_HANDLED) @@ -1721,27 +1729,27 @@ static DBusHandlerResult handle_dec_method (DBusConnection *bus, DBusMessage *message, void *user_data) { SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (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); + 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 || + if (type != DBUS_MESSAGE_TYPE_METHOD_CALL || member == NULL || - iface == NULL) - return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + iface == NULL) + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; dbus_message_ref (message); g_queue_push_tail (controller->message_queue, message); - if (!controller->message_queue_idle) { - controller->message_queue_idle = g_idle_add (message_queue_dispatch, controller); - g_source_set_name_by_id (controller->message_queue_idle, "[at-spi2-core] message_queue_dispatch"); - } + if (!controller->message_queue_idle) + { + controller->message_queue_idle = g_idle_add (message_queue_dispatch, controller); + g_source_set_name_by_id (controller->message_queue_idle, "[at-spi2-core] message_queue_dispatch"); + } return DBUS_HANDLER_RESULT_HANDLED; } -static DBusObjectPathVTable dec_vtable = -{ +static DBusObjectPathVTable dec_vtable = { NULL, &handle_dec_method, NULL, NULL, NULL, NULL diff --git a/registryd/deviceeventcontroller.h b/registryd/deviceeventcontroller.h index a080a13e..a78148ce 100644 --- a/registryd/deviceeventcontroller.h +++ b/registryd/deviceeventcontroller.h @@ -28,19 +28,20 @@ typedef struct _SpiDEController SpiDEController; -#include "registry.h" #include "de-types.h" +#include "registry.h" G_BEGIN_DECLS -#define SPI_DEVICE_EVENT_CONTROLLER_TYPE (spi_device_event_controller_get_type ()) -#define SPI_DEVICE_EVENT_CONTROLLER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SPI_DEVICE_EVENT_CONTROLLER_TYPE, SpiDEController)) -#define SPI_DEVICE_EVENT_CONTROLLER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), SPI_DEVICE_EVENT_CONTROLLER_TYPE, SpiDEControllerClass)) -#define SPI_IS_DEVICE_EVENT_CONTROLLER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), SPI_DEVICE_EVENT_CONTROLLER_TYPE)) +#define SPI_DEVICE_EVENT_CONTROLLER_TYPE (spi_device_event_controller_get_type ()) +#define SPI_DEVICE_EVENT_CONTROLLER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SPI_DEVICE_EVENT_CONTROLLER_TYPE, SpiDEController)) +#define SPI_DEVICE_EVENT_CONTROLLER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), SPI_DEVICE_EVENT_CONTROLLER_TYPE, SpiDEControllerClass)) +#define SPI_IS_DEVICE_EVENT_CONTROLLER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), SPI_DEVICE_EVENT_CONTROLLER_TYPE)) #define SPI_IS_DEVICE_EVENT_CONTROLLER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), SPI_DEVICE_EVENT_CONTROLLER_TYPE)) #define SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SPI_DEVICE_EVENT_CONTROLLER_TYPE, SpiDEControllerClass)) -struct _SpiDEController { +struct _SpiDEController +{ GObject parent; DBusConnection *bus; GList *key_listeners; @@ -53,24 +54,27 @@ struct _SpiDEController { gboolean have_mouse_event_listener; }; -typedef enum { +typedef enum +{ SPI_DEVICE_TYPE_KBD, SPI_DEVICE_TYPE_LAST_DEFINED } SpiDeviceTypeCategory; -typedef struct { +typedef struct +{ char *bus_name; char *path; SpiDeviceTypeCategory type; gulong types; } DEControllerListener; -typedef struct { +typedef struct +{ DEControllerListener listener; GSList *keys; Accessibility_ControllerEventMask mask; - Accessibility_EventListenerMode *mode; + Accessibility_EventListenerMode *mode; } DEControllerKeyListener; typedef struct @@ -81,22 +85,22 @@ typedef struct gboolean fix, guint *modmask); - guint (*mouse_check) (SpiDEController *controller, - gint *x, - gint *y, - gboolean *moved); + guint (*mouse_check) (SpiDEController *controller, + gint *x, + gint *y, + gboolean *moved); - gboolean (*register_global_keygrabs) (SpiDEController *controller, - DEControllerKeyListener *key_listener); + gboolean (*register_global_keygrabs) (SpiDEController *controller, + DEControllerKeyListener *key_listener); - void (*deregister_global_keygrabs) (SpiDEController *controller, - DEControllerKeyListener *key_listener); + void (*deregister_global_keygrabs) (SpiDEController *controller, + DEControllerKeyListener *key_listener); gboolean (*synth_keycode_press) (SpiDEController *controller, - guint keycode); + guint keycode); gboolean (*synth_keycode_release) (SpiDEController *controller, - guint keycode); + guint keycode); gboolean (*lock_modifiers) (SpiDEController *controller, unsigned modifiers); @@ -118,8 +122,8 @@ typedef struct Accessibility_ControllerEventMask mod_mask); void (*emit_modifier_event) (SpiDEController *controller, - guint prev_mask, - guint current_mask); + guint prev_mask, + guint current_mask); void (*generate_mouse_event) (SpiDEController *controller, gint x, @@ -130,12 +134,13 @@ typedef struct void (*finalize) (SpiDEController *controller); } SpiDEControllerPlat; -typedef struct { +typedef struct +{ GObjectClass parent_class; SpiDEControllerPlat plat; } SpiDEControllerClass; -GType spi_device_event_controller_get_type (void); +GType spi_device_event_controller_get_type (void); void spi_device_event_controller_start_poll_mouse (SpiDEController *dec); void spi_device_event_controller_stop_poll_mouse (SpiDEController *dec); @@ -145,16 +150,16 @@ void spi_remove_device_listeners (SpiDEController *controller, const char *bus_n SpiDEController *spi_registry_dec_new (DBusConnection *bus); gboolean -spi_controller_notify_keylisteners (SpiDEController *controller, - Accessibility_DeviceEvent *key_event, - dbus_bool_t is_system_global); +spi_controller_notify_keylisteners (SpiDEController *controller, + Accessibility_DeviceEvent *key_event, + dbus_bool_t is_system_global); -gboolean spi_controller_update_key_grabs (SpiDEController *controller, - Accessibility_DeviceEvent *recv); +gboolean spi_controller_update_key_grabs (SpiDEController *controller, + Accessibility_DeviceEvent *recv); gboolean spi_dec_synth_keysym (SpiDEController *controller, long keysym); -void spi_dec_dbus_emit(SpiDEController *controller, const char *interface, const char *name, const char *minor, int a1, int a2); +void spi_dec_dbus_emit (SpiDEController *controller, const char *interface, const char *name, const char *minor, int a1, int a2); G_END_DECLS diff --git a/registryd/display.c b/registryd/display.c index 011f2941..16e1c5da 100644 --- a/registryd/display.c +++ b/registryd/display.c @@ -22,10 +22,10 @@ #include <glib.h> +#include <X11/Xatom.h> #include <X11/Xlib.h> -#include <X11/Xutil.h> #include <X11/Xos.h> -#include <X11/Xatom.h> +#include <X11/Xutil.h> #include <stdio.h> #include <stdlib.h> @@ -34,57 +34,63 @@ static Display *default_display = NULL; -Display *spi_set_display (const char *display_name) +Display * +spi_set_display (const char *display_name) { - /* - * TODO - Should we ever do anything different might need to - * close previous display. - */ - default_display = XOpenDisplay (display_name); - if (!default_display) - { - g_warning ("AT-SPI: Cannot open default display"); - exit (1); - } - return default_display; + /* + * TODO - Should we ever do anything different might need to + * close previous display. + */ + default_display = XOpenDisplay (display_name); + if (!default_display) + { + g_warning ("AT-SPI: Cannot open default display"); + exit (1); + } + return default_display; } -Display *spi_get_display () +Display * +spi_get_display () { - if (!default_display) - spi_set_display (NULL); + if (!default_display) + spi_set_display (NULL); - return default_display; + return default_display; } -Window spi_get_root_window () +Window +spi_get_root_window () { - if (!default_display) - spi_set_display (NULL); + if (!default_display) + spi_set_display (NULL); - return DefaultRootWindow (default_display); + return DefaultRootWindow (default_display); } static int (*old_x_error_handler) (Display *, XErrorEvent *); static int x_error_code; -static int spi_x_error_handler (Display *display, XErrorEvent *error) +static int +spi_x_error_handler (Display *display, XErrorEvent *error) { - if (error->error_code) - x_error_code = error->error_code; - else - x_error_code = 0; - - return 0; + if (error->error_code) + x_error_code = error->error_code; + else + x_error_code = 0; + + return 0; } -void spi_x_error_trap (void) +void +spi_x_error_trap (void) { - old_x_error_handler = XSetErrorHandler (spi_x_error_handler); + old_x_error_handler = XSetErrorHandler (spi_x_error_handler); } -int spi_x_error_release (void) +int +spi_x_error_release (void) { - XSetErrorHandler (old_x_error_handler); - return x_error_code; + XSetErrorHandler (old_x_error_handler); + return x_error_code; } diff --git a/registryd/event-source.c b/registryd/event-source.c index ca4340c5..d73c9b67 100644 --- a/registryd/event-source.c +++ b/registryd/event-source.c @@ -24,36 +24,37 @@ #include "event-source.h" -typedef struct { +typedef struct +{ GSource source; - + Display *display; - GPollFD event_poll_fd; + GPollFD event_poll_fd; } DisplaySource; /*---------------------------------------------------------------------------*/ -static void (*_spi_default_filter) (XEvent*, void*) = NULL; -static void* _spi_default_filter_data = NULL; +static void (*_spi_default_filter) (XEvent *, void *) = NULL; +static void *_spi_default_filter_data = NULL; /*---------------------------------------------------------------------------*/ -static gboolean +static gboolean event_prepare (GSource *source, gint *timeout) { - Display *display = ((DisplaySource *)source)->display; + Display *display = ((DisplaySource *) source)->display; gboolean retval; - + *timeout = -1; retval = XPending (display); - + return retval; } -static gboolean -event_check (GSource *source) +static gboolean +event_check (GSource *source) { - DisplaySource *display_source = (DisplaySource*)source; + DisplaySource *display_source = (DisplaySource *) source; gboolean retval; if (display_source->event_poll_fd.revents & G_IO_IN) @@ -64,12 +65,12 @@ event_check (GSource *source) return retval; } -static gboolean -event_dispatch (GSource *source, GSourceFunc callback, gpointer user_data) +static gboolean +event_dispatch (GSource *source, GSourceFunc callback, gpointer user_data) { - Display *display = ((DisplaySource*)source)->display; + Display *display = ((DisplaySource *) source)->display; XEvent xevent; - + /* TODO - Should this be "if (XPending (display))"? * The effect of this might be to run other main loop functions * before dispatching the next XEvent. @@ -79,19 +80,19 @@ event_dispatch (GSource *source, GSourceFunc callback, gpointer user_data) XNextEvent (display, &xevent); switch (xevent.type) - { - case KeyPress: - case KeyRelease: - break; - default: - if (XFilterEvent (&xevent, None)) - continue; - } - + { + case KeyPress: + case KeyRelease: + break; + default: + if (XFilterEvent (&xevent, None)) + continue; + } + if (_spi_default_filter) { _spi_default_filter (&xevent, _spi_default_filter_data); - } + } } return TRUE; @@ -112,9 +113,9 @@ display_source_new (Display *display) GSource *source = g_source_new (&event_funcs, sizeof (DisplaySource)); DisplaySource *display_source = (DisplaySource *) source; g_source_set_name (source, "[at-spi2-core] display_source_funcs"); - + display_source->display = display; - + return source; } @@ -122,7 +123,7 @@ display_source_new (Display *display) static DisplaySource *spi_display_source = NULL; -void +void spi_events_init (Display *display) { GSource *source; @@ -130,13 +131,13 @@ spi_events_init (Display *display) int connection_number = ConnectionNumber (display); source = display_source_new (display); - spi_display_source = (DisplaySource*) source; + spi_display_source = (DisplaySource *) source; g_source_set_priority (source, G_PRIORITY_DEFAULT); - + spi_display_source->event_poll_fd.fd = connection_number; spi_display_source->event_poll_fd.events = G_IO_IN; - + g_source_add_poll (source, &spi_display_source->event_poll_fd); g_source_set_can_recurse (source, TRUE); g_source_attach (source, NULL); @@ -158,14 +159,14 @@ spi_set_events (long event_mask) { long xevent_mask = StructureNotifyMask | PropertyChangeMask; xevent_mask |= event_mask; - - XSelectInput (spi_display_source->display, + + XSelectInput (spi_display_source->display, DefaultRootWindow (spi_display_source->display), xevent_mask); } void -spi_set_filter (void (*filter) (XEvent*, void*), void* data) +spi_set_filter (void (*filter) (XEvent *, void *), void *data) { _spi_default_filter = filter; _spi_default_filter_data = data; diff --git a/registryd/event-source.h b/registryd/event-source.h index ad080f7d..1ddd34b7 100644 --- a/registryd/event-source.h +++ b/registryd/event-source.h @@ -28,6 +28,6 @@ void spi_events_init (Display *display); void spi_events_uninit (); void spi_set_events (long event_mask); -void spi_set_filter (void (*filter) (XEvent*, void*), void* data); +void spi_set_filter (void (*filter) (XEvent *, void *), void *data); #endif /* SPI_EVENT_SOURCE_H_ */ diff --git a/registryd/keymasks.h b/registryd/keymasks.h index 9f6c2c9f..1ee64b3d 100644 --- a/registryd/keymasks.h +++ b/registryd/keymasks.h @@ -31,21 +31,21 @@ G_BEGIN_DECLS typedef unsigned long SpiKeyMaskType; /* Values taken from Xlib.h */ -#define SPI_KEYMASK_ALT (1<<3) /* Mod1Mask */ -#define SPI_KEYMASK_MOD1 (1<<3) /* Mod1Mask */ -#define SPI_KEYMASK_MOD2 (1<<4) /* Mod2Mask */ -#define SPI_KEYMASK_MOD3 (1<<5) /* Mod3Mask */ -#define SPI_KEYMASK_MOD4 (1<<6) /* Mod4Mask */ -#define SPI_KEYMASK_MOD5 (1<<7) /* Mod5Mask */ -#define SPI_KEYMASK_BUTTON1 (1L<<8) /* Button1Mask */ -#define SPI_KEYMASK_BUTTON2 (1L<<9) /* Button2Mask */ -#define SPI_KEYMASK_BUTTON3 (1L<<10) /* Button3Mask */ -#define SPI_KEYMASK_BUTTON4 (1L<<11) /* Button4Mask */ -#define SPI_KEYMASK_BUTTON5 (1L<<12) /* Button5Mask */ -#define SPI_KEYMASK_CONTROL (1<<2) /* ControlMask */ -#define SPI_KEYMASK_SHIFT (1<<0) /* ShiftMask */ -#define SPI_KEYMASK_SHIFTLOCK (1<<1) /* LockMask */ -#define SPI_KEYMASK_NUMLOCK (1<<14) +#define SPI_KEYMASK_ALT (1 << 3) /* Mod1Mask */ +#define SPI_KEYMASK_MOD1 (1 << 3) /* Mod1Mask */ +#define SPI_KEYMASK_MOD2 (1 << 4) /* Mod2Mask */ +#define SPI_KEYMASK_MOD3 (1 << 5) /* Mod3Mask */ +#define SPI_KEYMASK_MOD4 (1 << 6) /* Mod4Mask */ +#define SPI_KEYMASK_MOD5 (1 << 7) /* Mod5Mask */ +#define SPI_KEYMASK_BUTTON1 (1L << 8) /* Button1Mask */ +#define SPI_KEYMASK_BUTTON2 (1L << 9) /* Button2Mask */ +#define SPI_KEYMASK_BUTTON3 (1L << 10) /* Button3Mask */ +#define SPI_KEYMASK_BUTTON4 (1L << 11) /* Button4Mask */ +#define SPI_KEYMASK_BUTTON5 (1L << 12) /* Button5Mask */ +#define SPI_KEYMASK_CONTROL (1 << 2) /* ControlMask */ +#define SPI_KEYMASK_SHIFT (1 << 0) /* ShiftMask */ +#define SPI_KEYMASK_SHIFTLOCK (1 << 1) /* LockMask */ +#define SPI_KEYMASK_NUMLOCK (1 << 14) #define SPI_KEYMASK_UNMODIFIED 0 G_END_DECLS diff --git a/registryd/paths.h b/registryd/paths.h index a505222a..b4e9ee80 100644 --- a/registryd/paths.h +++ b/registryd/paths.h @@ -24,30 +24,30 @@ #ifndef SPI_PATHS_H_ #define SPI_PATHS_H_ -#define SPI_DBUS_NAME_PREFIX "org.a11y.atspi." -#define SPI_DBUS_PATH_PREFIX "/org/a11y/atspi/" -#define SPI_DBUS_INTERFACE_PREFIX "org.a11y.atspi." +#define SPI_DBUS_NAME_PREFIX "org.a11y.atspi." +#define SPI_DBUS_PATH_PREFIX "/org/a11y/atspi/" +#define SPI_DBUS_INTERFACE_PREFIX "org.a11y.atspi." -#define SPI_DBUS_PATH_NULL SPI_DBUS_PATH_PREFIX "null" -#define SPI_DBUS_PATH_ROOT SPI_DBUS_PATH_PREFIX "accessible/root" +#define SPI_DBUS_PATH_NULL SPI_DBUS_PATH_PREFIX "null" +#define SPI_DBUS_PATH_ROOT SPI_DBUS_PATH_PREFIX "accessible/root" -#define SPI_DBUS_NAME_REGISTRY SPI_DBUS_NAME_PREFIX "Registry" -#define SPI_DBUS_INTERFACE_REGISTRY SPI_DBUS_INTERFACE_PREFIX "Registry" -#define SPI_DBUS_PATH_REGISTRY SPI_DBUS_PATH_PREFIX "registry" +#define SPI_DBUS_NAME_REGISTRY SPI_DBUS_NAME_PREFIX "Registry" +#define SPI_DBUS_INTERFACE_REGISTRY SPI_DBUS_INTERFACE_PREFIX "Registry" +#define SPI_DBUS_PATH_REGISTRY SPI_DBUS_PATH_PREFIX "registry" -#define SPI_DBUS_PATH_DEC SPI_DBUS_PATH_PREFIX "registry/deviceeventcontroller" -#define SPI_DBUS_INTERFACE_DEC SPI_DBUS_INTERFACE_PREFIX "DeviceEventController" +#define SPI_DBUS_PATH_DEC SPI_DBUS_PATH_PREFIX "registry/deviceeventcontroller" +#define SPI_DBUS_INTERFACE_DEC SPI_DBUS_INTERFACE_PREFIX "DeviceEventController" #define SPI_DBUS_INTERFACE_DEVICE_EVENT_LISTENER SPI_DBUS_INTERFACE_PREFIX "DeviceEventListener" -#define SPI_DBUS_PATH_CACHE SPI_DBUS_PATH_PREFIX "cache" -#define SPI_DBUS_INTERFACE_CACHE SPI_DBUS_INTERFACE_PREFIX "Cache" +#define SPI_DBUS_PATH_CACHE SPI_DBUS_PATH_PREFIX "cache" +#define SPI_DBUS_INTERFACE_CACHE SPI_DBUS_INTERFACE_PREFIX "Cache" -#define SPI_DBUS_INTERFACE_ACCESSIBLE SPI_DBUS_INTERFACE_PREFIX "Accessible" -#define SPI_DBUS_INTERFACE_APPLICATION SPI_DBUS_INTERFACE_PREFIX "Application" -#define SPI_DBUS_INTERFACE_COMPONENT SPI_DBUS_INTERFACE_PREFIX "Component" -#define SPI_DBUS_INTERFACE_EVENT_KEYBOARD SPI_DBUS_INTERFACE_PREFIX "Keyboard" -#define SPI_DBUS_INTERFACE_EVENT_MOUSE SPI_DBUS_INTERFACE_PREFIX "Event.Mouse" -#define SPI_DBUS_INTERFACE_EVENT_OBJECT SPI_DBUS_INTERFACE_PREFIX "Event.Object" -#define SPI_DBUS_INTERFACE_SOCKET SPI_DBUS_INTERFACE_PREFIX "Socket" +#define SPI_DBUS_INTERFACE_ACCESSIBLE SPI_DBUS_INTERFACE_PREFIX "Accessible" +#define SPI_DBUS_INTERFACE_APPLICATION SPI_DBUS_INTERFACE_PREFIX "Application" +#define SPI_DBUS_INTERFACE_COMPONENT SPI_DBUS_INTERFACE_PREFIX "Component" +#define SPI_DBUS_INTERFACE_EVENT_KEYBOARD SPI_DBUS_INTERFACE_PREFIX "Keyboard" +#define SPI_DBUS_INTERFACE_EVENT_MOUSE SPI_DBUS_INTERFACE_PREFIX "Event.Mouse" +#define SPI_DBUS_INTERFACE_EVENT_OBJECT SPI_DBUS_INTERFACE_PREFIX "Event.Object" +#define SPI_DBUS_INTERFACE_SOCKET SPI_DBUS_INTERFACE_PREFIX "Socket" #endif /* SPI_PATHS_H_ */ diff --git a/registryd/reentrant-list.c b/registryd/reentrant-list.c index 2c08c42d..b723c76b 100644 --- a/registryd/reentrant-list.c +++ b/registryd/reentrant-list.c @@ -26,9 +26,10 @@ #include "reentrant-list.h" -typedef struct { - GList **list; - GList *iterator; +typedef struct +{ + GList **list; + GList *iterator; } Iteration; static GSList *working_list = NULL; /* of Iteration */ @@ -39,12 +40,12 @@ static GSList *working_list = NULL; /* of Iteration */ * element. */ void -spi_re_entrant_list_delete_link (GList * const *element_ptr) +spi_re_entrant_list_delete_link (GList *const *element_ptr) { - GSList *l; - GList *next; - GList *element; - gboolean first_item; + GSList *l; + GList *next; + GList *element; + gboolean first_item; GList *dummy G_GNUC_UNUSED; g_return_if_fail (element_ptr != NULL); @@ -59,47 +60,48 @@ spi_re_entrant_list_delete_link (GList * const *element_ptr) for (l = working_list; l; l = l->next) { - Iteration *i = l->data; + Iteration *i = l->data; - if (i->iterator == element) - { - i->iterator = next; - } + if (i->iterator == element) + { + i->iterator = next; + } - if (first_item && *(i->list) == element) - { - *(i->list) = next; - } + if (first_item && *(i->list) == element) + { + *(i->list) = next; + } } g_list_free_1 (element); } void -spi_re_entrant_list_foreach (GList **list, - SpiReEntrantFn func, - gpointer user_data) +spi_re_entrant_list_foreach (GList **list, + SpiReEntrantFn func, + gpointer user_data) { - Iteration i; + Iteration i; - if (!list || !*list) - { - return; - } + if (!list || !*list) + { + return; + } - i.list = list; - i.iterator = *list; + i.list = list; + i.iterator = *list; - working_list = g_slist_prepend (working_list, &i); + working_list = g_slist_prepend (working_list, &i); - while (i.iterator) { - GList *l = i.iterator; + while (i.iterator) + { + GList *l = i.iterator; - func (&i.iterator, user_data); + func (&i.iterator, user_data); - if (i.iterator == l) - i.iterator = i.iterator->next; - } + if (i.iterator == l) + i.iterator = i.iterator->next; + } - working_list = g_slist_remove (working_list, &i); + working_list = g_slist_remove (working_list, &i); } diff --git a/registryd/reentrant-list.h b/registryd/reentrant-list.h index e1241561..39f5527a 100644 --- a/registryd/reentrant-list.h +++ b/registryd/reentrant-list.h @@ -28,18 +28,19 @@ G_BEGIN_DECLS -typedef enum { - SPI_RE_ENTRANT_CONTINUE = 0, - SPI_RE_ENTRANT_TERMINATE +typedef enum +{ + SPI_RE_ENTRANT_CONTINUE = 0, + SPI_RE_ENTRANT_TERMINATE } SpiReEntrantContinue; -typedef SpiReEntrantContinue (*SpiReEntrantFn) (GList * const *list, - gpointer user_data); +typedef SpiReEntrantContinue (*SpiReEntrantFn) (GList *const *list, + gpointer user_data); -void spi_re_entrant_list_delete_link (GList * const *element_ptr); -void spi_re_entrant_list_foreach (GList **list, - SpiReEntrantFn func, - gpointer user_data); +void spi_re_entrant_list_delete_link (GList *const *element_ptr); +void spi_re_entrant_list_foreach (GList **list, + SpiReEntrantFn func, + gpointer user_data); G_END_DECLS diff --git a/registryd/registry-main.c b/registryd/registry-main.c index f46886d2..7619c86a 100644 --- a/registryd/registry-main.c +++ b/registryd/registry-main.c @@ -21,38 +21,37 @@ * Boston, MA 02110-1301, USA. */ -#include <stdlib.h> #include <config.h> -#include <string.h> -#include <glib.h> +#include <dlfcn.h> #include <gio/gio.h> +#include <glib.h> #include <stdio.h> -#include <dlfcn.h> +#include <stdlib.h> +#include <string.h> #include <dbus/dbus.h> +#include "atspi/atspi.h" +#include "deviceeventcontroller.h" #include "paths.h" #include "registry.h" -#include "deviceeventcontroller.h" -#include "atspi/atspi.h" static GMainLoop *mainloop; static gchar *dbus_name = NULL; static gboolean use_gnome_session = FALSE; -static GOptionEntry optentries[] = -{ - {"dbus-name", 0, 0, G_OPTION_ARG_STRING, &dbus_name, "Well-known name to register with D-Bus", NULL}, - {"use-gnome-session", 0, 0, G_OPTION_ARG_NONE, &use_gnome_session, "Should register with gnome session manager", NULL}, - {NULL} +static GOptionEntry optentries[] = { + { "dbus-name", 0, 0, G_OPTION_ARG_STRING, &dbus_name, "Well-known name to register with D-Bus", NULL }, + { "use-gnome-session", 0, 0, G_OPTION_ARG_NONE, &use_gnome_session, "Should register with gnome session manager", NULL }, + { NULL } }; -static GDBusProxy *sm_proxy = NULL; -static char *client_id = NULL; -static GDBusProxy *client_proxy = NULL; +static GDBusProxy *sm_proxy = NULL; +static char *client_id = NULL; +static GDBusProxy *client_proxy = NULL; -#define SM_DBUS_NAME "org.gnome.SessionManager" -#define SM_DBUS_PATH "/org/gnome/SessionManager" +#define SM_DBUS_NAME "org.gnome.SessionManager" +#define SM_DBUS_PATH "/org/gnome/SessionManager" #define SM_DBUS_INTERFACE "org.gnome.SessionManager" #define SM_CLIENT_DBUS_INTERFACE "org.gnome.SessionManager.ClientPrivate" @@ -61,71 +60,77 @@ static gboolean register_client (void); static void on_session_signal (GDBusProxy *proxy, - gchar *sender_name, - gchar *signal_name, - GVariant *parameters, - gpointer user_data) + gchar *sender_name, + gchar *signal_name, + GVariant *parameters, + gpointer user_data) { - if (g_strcmp0 (signal_name, "SessionOver") == 0) { - g_main_loop_quit (mainloop); - } else if (g_strcmp0 (signal_name, "SessionRunning") == 0) { - if (!register_client ()) - g_warning ("Unable to register client with session manager"); - } + if (g_strcmp0 (signal_name, "SessionOver") == 0) + { + g_main_loop_quit (mainloop); + } + else if (g_strcmp0 (signal_name, "SessionRunning") == 0) + { + if (!register_client ()) + g_warning ("Unable to register client with session manager"); + } } static gboolean session_manager_connect (void) { - GVariant *res; - gboolean is_running; - - sm_proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION, 0, NULL, - SM_DBUS_NAME, - SM_DBUS_PATH, - SM_DBUS_INTERFACE, NULL, NULL); - - res = g_dbus_proxy_call_sync (sm_proxy, - "IsSessionRunning", NULL, - 0, 1000, NULL, NULL); - - if (res) { - g_variant_get (res, "(b)", &is_running); - g_variant_unref (res); - if (is_running) { - if (!register_client ()) - g_warning ("Unable to register client with session manager"); - } + GVariant *res; + gboolean is_running; + + sm_proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION, 0, NULL, + SM_DBUS_NAME, + SM_DBUS_PATH, + SM_DBUS_INTERFACE, NULL, NULL); + + res = g_dbus_proxy_call_sync (sm_proxy, + "IsSessionRunning", NULL, + 0, 1000, NULL, NULL); + + if (res) + { + g_variant_get (res, "(b)", &is_running); + g_variant_unref (res); + if (is_running) + { + if (!register_client ()) + g_warning ("Unable to register client with session manager"); } + } - g_signal_connect (G_OBJECT (sm_proxy), "g-signal", - G_CALLBACK (on_session_signal), NULL); + g_signal_connect (G_OBJECT (sm_proxy), "g-signal", + G_CALLBACK (on_session_signal), NULL); - return (sm_proxy != NULL); + return (sm_proxy != NULL); } static gboolean end_session_response (gboolean is_okay, const gchar *reason) { - GVariant *ret; - GError *error = NULL; + GVariant *ret; + GError *error = NULL; - if (!reason) - reason = ""; + if (!reason) + reason = ""; - ret = g_dbus_proxy_call_sync (client_proxy, "EndSessionResponse", - g_variant_new ("(bs)", is_okay, reason), - 0, 1000, NULL, &error); + ret = g_dbus_proxy_call_sync (client_proxy, "EndSessionResponse", + g_variant_new ("(bs)", is_okay, reason), + 0, 1000, NULL, &error); - if (!ret) { - g_warning ("Failed to send session response %s", error->message); - g_error_free (error); - return FALSE; - } - else - g_variant_unref (ret); + if (!ret) + { + g_warning ("Failed to send session response %s", error->message); + g_error_free (error); + return FALSE; + } + else + g_variant_unref (ret); - return TRUE; + return TRUE; } static void @@ -135,73 +140,78 @@ client_proxy_signal_cb (GDBusProxy *proxy, GVariant *parameters, gpointer user_data) { - if (g_strcmp0 (signal_name, "QueryEndSession") == 0) { - g_debug ("Got QueryEndSession signal"); - end_session_response (TRUE, NULL); - } else if (g_strcmp0 (signal_name, "EndSession") == 0) { - g_debug ("Got EndSession signal"); - end_session_response (TRUE, NULL); - g_main_loop_quit (mainloop); - } else if (g_strcmp0 (signal_name, "Stop") == 0) { - g_debug ("Got Stop signal"); - g_main_loop_quit (mainloop); - } + if (g_strcmp0 (signal_name, "QueryEndSession") == 0) + { + g_debug ("Got QueryEndSession signal"); + end_session_response (TRUE, NULL); + } + else if (g_strcmp0 (signal_name, "EndSession") == 0) + { + g_debug ("Got EndSession signal"); + end_session_response (TRUE, NULL); + g_main_loop_quit (mainloop); + } + else if (g_strcmp0 (signal_name, "Stop") == 0) + { + g_debug ("Got Stop signal"); + g_main_loop_quit (mainloop); + } } static gboolean register_client (void) { - GError *error; - GVariant *res; - const char *startup_id; - const char *app_id; - - if (client_proxy) - return TRUE; - - startup_id = g_getenv ("DESKTOP_AUTOSTART_ID"); - if (!startup_id) - startup_id = ""; - app_id = "at-spi-registryd.desktop"; - - error = NULL; - res = g_dbus_proxy_call_sync (sm_proxy, - "RegisterClient", - g_variant_new ("(ss)", app_id, - startup_id), - 0, 1000, NULL, &error); - if (! res) { - const char *message = (error && error->message ? error->message - : "no error"); - g_warning ("Failed to register client: %s", message); - if (error) - g_error_free (error); - return FALSE; - } - g_variant_get (res, "(o)", &client_id); - g_variant_unref (res); + GError *error; + GVariant *res; + const char *startup_id; + const char *app_id; + + if (client_proxy) + return TRUE; + + startup_id = g_getenv ("DESKTOP_AUTOSTART_ID"); + if (!startup_id) + startup_id = ""; + app_id = "at-spi-registryd.desktop"; + + error = NULL; + res = g_dbus_proxy_call_sync (sm_proxy, + "RegisterClient", + g_variant_new ("(ss)", app_id, + startup_id), + 0, 1000, NULL, &error); + if (!res) + { + const char *message = (error && error->message ? error->message + : "no error"); + g_warning ("Failed to register client: %s", message); + if (error) + g_error_free (error); + return FALSE; + } + g_variant_get (res, "(o)", &client_id); + g_variant_unref (res); - client_proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION, 0, NULL, - SM_DBUS_NAME, - client_id, - SM_CLIENT_DBUS_INTERFACE, - NULL, NULL); + client_proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION, 0, NULL, + SM_DBUS_NAME, + client_id, + SM_CLIENT_DBUS_INTERFACE, + NULL, NULL); - g_signal_connect (client_proxy, "g-signal", - G_CALLBACK (client_proxy_signal_cb), NULL); + g_signal_connect (client_proxy, "g-signal", + G_CALLBACK (client_proxy_signal_cb), NULL); - g_unsetenv ("DESKTOP_AUTOSTART_ID"); + g_unsetenv ("DESKTOP_AUTOSTART_ID"); - return TRUE; + return TRUE; } /*---------------------------------------------------------------------------*/ - /*---------------------------------------------------------------------------*/ typedef GObject *(*gconf_client_get_default_t) (); -typedef gboolean (*gconf_client_get_bool_t)(GObject *, const char *, void *); +typedef gboolean (*gconf_client_get_bool_t) (GObject *, const char *, void *); int main (int argc, char **argv) @@ -217,31 +227,31 @@ main (int argc, char **argv) int ret; /*Parse command options*/ - opt = g_option_context_new(NULL); - g_option_context_add_main_entries(opt, optentries, NULL); + opt = g_option_context_new (NULL); + g_option_context_add_main_entries (opt, optentries, NULL); - if (!g_option_context_parse(opt, &argc, &argv, &err)) + if (!g_option_context_parse (opt, &argc, &argv, &err)) { - g_error("Option parsing failed: %s\n", err->message); + g_error ("Option parsing failed: %s\n", err->message); g_clear_error (&err); } if (dbus_name == NULL) - dbus_name = SPI_DBUS_NAME_REGISTRY; + dbus_name = SPI_DBUS_NAME_REGISTRY; bus = atspi_get_a11y_bus (); if (!bus) - { - return 0; - } + { + return 0; + } mainloop = g_main_loop_new (NULL, FALSE); - atspi_dbus_connection_setup_with_g_main(bus, NULL); + atspi_dbus_connection_setup_with_g_main (bus, NULL); - ret = dbus_bus_request_name(bus, dbus_name, DBUS_NAME_FLAG_DO_NOT_QUEUE, NULL); + ret = dbus_bus_request_name (bus, dbus_name, DBUS_NAME_FLAG_DO_NOT_QUEUE, NULL); if (ret == DBUS_REQUEST_NAME_REPLY_EXISTS) { - exit (0); /* most likely already running */ + exit (0); /* most likely already running */ } else { @@ -254,7 +264,7 @@ main (int argc, char **argv) if (use_gnome_session) { if (!session_manager_connect ()) - g_warning ("Unable to connect to session manager"); + g_warning ("Unable to connect to session manager"); } g_main_loop_run (mainloop); diff --git a/registryd/registry.c b/registryd/registry.c index 6cb10f08..349e92ec 100644 --- a/registryd/registry.c +++ b/registryd/registry.c @@ -23,12 +23,12 @@ */ #include <config.h> -#include <string.h> #include <ctype.h> +#include <string.h> +#include "introspection.h" #include "paths.h" #include "registry.h" -#include "introspection.h" typedef struct { @@ -74,7 +74,7 @@ spi_reference_free (SpiReference *ref) /*---------------------------------------------------------------------------*/ -G_DEFINE_TYPE(SpiRegistry, spi_registry, G_TYPE_OBJECT) +G_DEFINE_TYPE (SpiRegistry, spi_registry, G_TYPE_OBJECT) static void spi_registry_finalize (GObject *object) @@ -106,12 +106,12 @@ spi_registry_init (SpiRegistry *registry) /*---------------------------------------------------------------------------*/ static dbus_bool_t -return_v_string (DBusMessageIter * iter, const gchar * str) +return_v_string (DBusMessageIter *iter, const gchar *str) { DBusMessageIter variant; if (!dbus_message_iter_open_container (iter, DBUS_TYPE_VARIANT, "s", - &variant)) + &variant)) return FALSE; dbus_message_iter_append_basic (&variant, DBUS_TYPE_STRING, &str); @@ -120,12 +120,12 @@ return_v_string (DBusMessageIter * iter, const gchar * str) } static dbus_bool_t -append_reference (DBusMessageIter * iter, SpiReference *ref) +append_reference (DBusMessageIter *iter, SpiReference *ref) { DBusMessageIter iter_struct; if (!dbus_message_iter_open_container (iter, DBUS_TYPE_STRUCT, NULL, - &iter_struct)) + &iter_struct)) return FALSE; dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_STRING, &ref->name); dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_OBJECT_PATH, &ref->path); @@ -174,15 +174,15 @@ emit_children_changed (DBusConnection *bus, DBusMessageIter iter, iter_variant, iter_array; dbus_int32_t unused = 0; - sig = dbus_message_new_signal(SPI_DBUS_PATH_ROOT, - SPI_DBUS_INTERFACE_EVENT_OBJECT, - "ChildrenChanged"); + sig = dbus_message_new_signal (SPI_DBUS_PATH_ROOT, + SPI_DBUS_INTERFACE_EVENT_OBJECT, + "ChildrenChanged"); - dbus_message_iter_init_append(sig, &iter); + dbus_message_iter_init_append (sig, &iter); - dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &operation); - dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &index); - dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &unused); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &operation); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_INT32, &index); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_INT32, &unused); dbus_message_iter_open_container (&iter, DBUS_TYPE_VARIANT, "(so)", &iter_variant); @@ -193,8 +193,8 @@ emit_children_changed (DBusConnection *bus, &iter_array); dbus_message_iter_close_container (&iter, &iter_array); - dbus_connection_send(bus, sig, NULL); - dbus_message_unref(sig); + dbus_connection_send (bus, sig, NULL); + dbus_message_unref (sig); } static void @@ -256,11 +256,11 @@ event_is_subtype (gchar **needle, gchar **haystack) static gboolean needs_mouse_poll (char **event) { - if (g_strcmp0 (event [0], "Mouse") != 0) + if (g_strcmp0 (event[0], "Mouse") != 0) return FALSE; - if (!event [1] || !event [1][0]) + if (!event[1] || !event[1][0]) return TRUE; - return (g_strcmp0 (event [1], "Abs") == 0); + return (g_strcmp0 (event[1], "Abs") == 0); } static void @@ -383,23 +383,24 @@ signal_filter (DBusConnection *bus, DBusMessage *message, void *user_data) SpiRegistry *reg = SPI_REGISTRY (user_data); guint res = DBUS_HANDLER_RESULT_HANDLED; - const gint type = dbus_message_get_type (message); + const gint type = dbus_message_get_type (message); const char *iface = dbus_message_get_interface (message); const char *member = dbus_message_get_member (message); if (type != DBUS_MESSAGE_TYPE_SIGNAL) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; - if (!g_strcmp0(iface, DBUS_INTERFACE_DBUS) && - !g_strcmp0(member, "NameOwnerChanged")) - handle_disconnection (reg, message); + if (!g_strcmp0 (iface, DBUS_INTERFACE_DBUS) && + !g_strcmp0 (member, "NameOwnerChanged")) + handle_disconnection (reg, message); else - res = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + res = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; return res; } -typedef enum { +typedef enum +{ DEMARSHAL_STATUS_SUCCESS, DEMARSHAL_STATUS_INVALID_SIGNATURE, DEMARSHAL_STATUS_INVALID_VALUE, @@ -444,7 +445,7 @@ socket_embed (SpiRegistry *registry, SpiReference *app_root) return spi_reference_new (registry->bus_unique_name, SPI_DBUS_PATH_ROOT); } -static DBusMessage* +static DBusMessage * impl_Embed (DBusMessage *message, SpiRegistry *registry) { SpiReference *app_root = NULL; @@ -468,7 +469,7 @@ impl_Embed (DBusMessage *message, SpiRegistry *registry) return reply; } -static DBusMessage* +static DBusMessage * impl_Unembed (DBusMessage *message, SpiRegistry *registry) { SpiReference *app_reference; @@ -491,7 +492,7 @@ impl_Unembed (DBusMessage *message, SpiRegistry *registry) /*---------------------------------------------------------------------------*/ static DBusMessage * -impl_Contains (DBusMessage * message, SpiRegistry *registry) +impl_Contains (DBusMessage *message, SpiRegistry *registry) { dbus_bool_t retval = FALSE; DBusMessage *reply; @@ -503,7 +504,7 @@ impl_Contains (DBusMessage * message, SpiRegistry *registry) } static DBusMessage * -impl_GetAccessibleAtPoint (DBusMessage * message, SpiRegistry *registry) +impl_GetAccessibleAtPoint (DBusMessage *message, SpiRegistry *registry) { DBusMessage *reply = NULL; DBusMessageIter iter; @@ -518,7 +519,7 @@ impl_GetAccessibleAtPoint (DBusMessage * message, SpiRegistry *registry) } static DBusMessage * -impl_GetExtents (DBusMessage * message, SpiRegistry *registry) +impl_GetExtents (DBusMessage *message, SpiRegistry *registry) { dbus_int32_t x = 0, y = 0, width = 1024, height = 768; DBusMessage *reply; @@ -528,16 +529,16 @@ impl_GetExtents (DBusMessage * message, SpiRegistry *registry) dbus_message_iter_init_append (reply, &iter); dbus_message_iter_open_container (&iter, DBUS_TYPE_STRUCT, NULL, &iter_struct); - dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32, &x); - dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32, &y); - dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32, &width); - dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32, &height); + dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32, &x); + dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32, &y); + dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32, &width); + dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32, &height); dbus_message_iter_close_container (&iter, &iter_struct); return reply; } static DBusMessage * -impl_GetPosition (DBusMessage * message, SpiRegistry *registry) +impl_GetPosition (DBusMessage *message, SpiRegistry *registry) { DBusMessage *reply; dbus_int32_t x = 0, y = 0; @@ -549,7 +550,7 @@ impl_GetPosition (DBusMessage * message, SpiRegistry *registry) } static DBusMessage * -impl_GetSize (DBusMessage * message, SpiRegistry *registry) +impl_GetSize (DBusMessage *message, SpiRegistry *registry) { /* TODO - Get the screen size */ DBusMessage *reply; @@ -564,7 +565,7 @@ impl_GetSize (DBusMessage * message, SpiRegistry *registry) #define LAYER_WIDGET 3; static DBusMessage * -impl_GetLayer (DBusMessage * message, SpiRegistry *registry) +impl_GetLayer (DBusMessage *message, SpiRegistry *registry) { DBusMessage *reply; dbus_uint32_t rv = LAYER_WIDGET; @@ -576,7 +577,7 @@ impl_GetLayer (DBusMessage * message, SpiRegistry *registry) } static DBusMessage * -impl_GetMDIZOrder (DBusMessage * message, SpiRegistry *registry) +impl_GetMDIZOrder (DBusMessage *message, SpiRegistry *registry) { DBusMessage *reply; dbus_int16_t rv = 0; @@ -588,7 +589,7 @@ impl_GetMDIZOrder (DBusMessage * message, SpiRegistry *registry) } static DBusMessage * -impl_GrabFocus (DBusMessage * message, SpiRegistry *registry) +impl_GrabFocus (DBusMessage *message, SpiRegistry *registry) { DBusMessage *reply; dbus_bool_t retval = FALSE; @@ -600,7 +601,7 @@ impl_GrabFocus (DBusMessage * message, SpiRegistry *registry) } static DBusMessage * -impl_GetAlpha (DBusMessage * message, SpiRegistry *registry) +impl_GetAlpha (DBusMessage *message, SpiRegistry *registry) { double rv = 1.0; DBusMessage *reply; @@ -615,21 +616,21 @@ impl_GetAlpha (DBusMessage * message, SpiRegistry *registry) /*---------------------------------------------------------------------------*/ static dbus_bool_t -impl_get_Name (DBusMessageIter * iter, SpiRegistry *registry) +impl_get_Name (DBusMessageIter *iter, SpiRegistry *registry) { const gchar *name = "main"; return return_v_string (iter, name); } static dbus_bool_t -impl_get_Description (DBusMessageIter * iter, SpiRegistry *registry) +impl_get_Description (DBusMessageIter *iter, SpiRegistry *registry) { const gchar *description = ""; return return_v_string (iter, description); } static dbus_bool_t -impl_get_Parent (DBusMessageIter * iter, SpiRegistry *registry) +impl_get_Parent (DBusMessageIter *iter, SpiRegistry *registry) { DBusMessageIter iter_variant; SpiReference *null_ref = spi_reference_null (""); @@ -643,7 +644,7 @@ impl_get_Parent (DBusMessageIter * iter, SpiRegistry *registry) } static dbus_bool_t -impl_get_ChildCount (DBusMessageIter * iter, SpiRegistry *registry) +impl_get_ChildCount (DBusMessageIter *iter, SpiRegistry *registry) { dbus_int32_t rv = registry->apps->len; dbus_bool_t result; @@ -658,19 +659,19 @@ impl_get_ChildCount (DBusMessageIter * iter, SpiRegistry *registry) } static dbus_bool_t -impl_get_ToolkitName (DBusMessageIter * iter, SpiRegistry *registry) +impl_get_ToolkitName (DBusMessageIter *iter, SpiRegistry *registry) { return return_v_string (iter, "at-spi-registry"); } static dbus_bool_t -impl_get_ToolkitVersion (DBusMessageIter * iter, SpiRegistry *registry) +impl_get_ToolkitVersion (DBusMessageIter *iter, SpiRegistry *registry) { return return_v_string (iter, "2.0"); } static DBusMessage * -impl_GetChildAtIndex (DBusMessage * message, SpiRegistry *registry) +impl_GetChildAtIndex (DBusMessage *message, SpiRegistry *registry) { DBusMessage *reply; DBusMessageIter iter; @@ -679,8 +680,7 @@ impl_GetChildAtIndex (DBusMessage * message, SpiRegistry *registry) dbus_int32_t i; dbus_error_init (&error); - if (!dbus_message_get_args - (message, &error, DBUS_TYPE_INT32, &i, DBUS_TYPE_INVALID)) + if (!dbus_message_get_args (message, &error, DBUS_TYPE_INT32, &i, DBUS_TYPE_INVALID)) { return dbus_message_new_error (message, DBUS_ERROR_FAILED, "Invalid arguments"); } @@ -704,7 +704,7 @@ impl_GetChildAtIndex (DBusMessage * message, SpiRegistry *registry) } static DBusMessage * -impl_GetChildren (DBusMessage * message, SpiRegistry *registry) +impl_GetChildren (DBusMessage *message, SpiRegistry *registry) { DBusMessage *reply = NULL; DBusMessageIter iter, iter_array; @@ -713,18 +713,18 @@ impl_GetChildren (DBusMessage * message, SpiRegistry *registry) reply = dbus_message_new_method_return (message); dbus_message_iter_init_append (reply, &iter); - dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(so)", &iter_array); - for (i=0; i < registry->apps->len; i++) + dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "(so)", &iter_array); + for (i = 0; i < registry->apps->len; i++) { SpiReference *current = g_ptr_array_index (registry->apps, i); append_reference (&iter_array, current); } - dbus_message_iter_close_container(&iter, &iter_array); + dbus_message_iter_close_container (&iter, &iter_array); return reply; } static DBusMessage * -impl_GetIndexInParent (DBusMessage * message, SpiRegistry *registry) +impl_GetIndexInParent (DBusMessage *message, SpiRegistry *registry) { DBusMessage *reply; dbus_uint32_t rv = 0; @@ -735,7 +735,7 @@ impl_GetIndexInParent (DBusMessage * message, SpiRegistry *registry) } static DBusMessage * -impl_GetRelationSet (DBusMessage * message, SpiRegistry *registry) +impl_GetRelationSet (DBusMessage *message, SpiRegistry *registry) { DBusMessage *reply; DBusMessageIter iter, iter_array; @@ -749,10 +749,10 @@ impl_GetRelationSet (DBusMessage * message, SpiRegistry *registry) } static DBusMessage * -impl_GetRole (DBusMessage * message, SpiRegistry *registry) +impl_GetRole (DBusMessage *message, SpiRegistry *registry) { DBusMessage *reply; - dbus_uint32_t rv = 14; /* TODO: Get DESKTOP_FRAME from somewhere */ + dbus_uint32_t rv = 14; /* TODO: Get DESKTOP_FRAME from somewhere */ reply = dbus_message_new_method_return (message); dbus_message_append_args (reply, DBUS_TYPE_UINT32, &rv, DBUS_TYPE_INVALID); @@ -760,7 +760,7 @@ impl_GetRole (DBusMessage * message, SpiRegistry *registry) } static DBusMessage * -impl_GetRoleName (DBusMessage * message, SpiRegistry *registry) +impl_GetRoleName (DBusMessage *message, SpiRegistry *registry) { DBusMessage *reply; const char *role_name = "desktop frame"; @@ -772,7 +772,7 @@ impl_GetRoleName (DBusMessage * message, SpiRegistry *registry) } static DBusMessage * -impl_GetLocalizedRoleName (DBusMessage * message, SpiRegistry *registry) +impl_GetLocalizedRoleName (DBusMessage *message, SpiRegistry *registry) { /* FIXME - Localize this */ DBusMessage *reply; @@ -785,12 +785,12 @@ impl_GetLocalizedRoleName (DBusMessage * message, SpiRegistry *registry) } static DBusMessage * -impl_GetState (DBusMessage * message, SpiRegistry *registry) +impl_GetState (DBusMessage *message, SpiRegistry *registry) { DBusMessage *reply = NULL; DBusMessageIter iter, iter_array; - dbus_uint32_t states[2] = {0, 0}; + dbus_uint32_t states[2] = { 0, 0 }; guint count; reply = dbus_message_new_method_return (message); @@ -807,7 +807,7 @@ impl_GetState (DBusMessage * message, SpiRegistry *registry) } static DBusMessage * -impl_GetAttributes (DBusMessage * message, SpiRegistry *registry) +impl_GetAttributes (DBusMessage *message, SpiRegistry *registry) { DBusMessage *reply = NULL; DBusMessageIter iter, array; @@ -821,7 +821,7 @@ impl_GetAttributes (DBusMessage * message, SpiRegistry *registry) } static DBusMessage * -impl_GetApplication (DBusMessage * message, SpiRegistry *registry) +impl_GetApplication (DBusMessage *message, SpiRegistry *registry) { DBusMessage *reply = NULL; DBusMessageIter iter; @@ -836,7 +836,7 @@ impl_GetApplication (DBusMessage * message, SpiRegistry *registry) } static DBusMessage * -impl_GetInterfaces (DBusMessage * message, SpiRegistry *registry) +impl_GetInterfaces (DBusMessage *message, SpiRegistry *registry) { DBusMessage *reply; DBusMessageIter iter, iter_array; @@ -861,7 +861,7 @@ impl_GetInterfaces (DBusMessage * message, SpiRegistry *registry) } static DBusMessage * -impl_GetItems (DBusMessage * message, SpiRegistry *registry) +impl_GetItems (DBusMessage *message, SpiRegistry *registry) { DBusMessage *reply; DBusMessageIter iter, iter_array; @@ -894,10 +894,10 @@ impl_RegisterEvent (DBusMessage *message, SpiRegistry *registry) if (strcmp (signature, "sas") != 0 && strcmp (signature, "s") != 0 && strcmp (signature, "sass") != 0) - { - g_warning ("got RegisterEvent with invalid signature '%s'", signature); - return NULL; - } + { + g_warning ("got RegisterEvent with invalid signature '%s'", signature); + return NULL; + } dbus_message_iter_init (message, &iter); dbus_message_iter_get_basic (&iter, &orig_name); @@ -910,27 +910,27 @@ impl_RegisterEvent (DBusMessage *message, SpiRegistry *registry) evdata->data = data; if (dbus_message_iter_get_arg_type (&iter) == DBUS_TYPE_ARRAY) - { - dbus_message_iter_recurse (&iter, &iter_array); - while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID) { - const char *property; - dbus_message_iter_get_basic (&iter_array, &property); - evdata->properties = g_slist_append (evdata->properties, - g_strdup (property)); - dbus_message_iter_next (&iter_array); + dbus_message_iter_recurse (&iter, &iter_array); + while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID) + { + const char *property; + dbus_message_iter_get_basic (&iter_array, &property); + evdata->properties = g_slist_append (evdata->properties, + g_strdup (property)); + dbus_message_iter_next (&iter_array); + } + dbus_message_iter_next (&iter); } - dbus_message_iter_next (&iter); - } if (dbus_message_iter_get_arg_type (&iter) == DBUS_TYPE_STRING) - { - const char *app; - dbus_message_iter_get_basic (&iter, &app); - if (app[0]) - evdata->app_bus_name = g_strdup (app); - dbus_message_iter_next (&iter); - } + { + const char *app; + dbus_message_iter_get_basic (&iter, &app); + if (app[0]) + evdata->app_bus_name = g_strdup (app); + dbus_message_iter_next (&iter); + } registry->events = g_list_append (registry->events, evdata); @@ -943,23 +943,23 @@ impl_RegisterEvent (DBusMessage *message, SpiRegistry *registry) SPI_DBUS_INTERFACE_REGISTRY, "EventListenerRegistered"); if (signal) - { - GSList *ls = evdata->properties; - if (evdata->app_bus_name) - dbus_message_set_destination (message, evdata->app_bus_name); - dbus_message_iter_init_append (signal, &iter); - dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &sender); - dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &name); - dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "s", &iter_array); - while (ls) { - dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_STRING, &ls->data); - ls = g_slist_next (ls); + GSList *ls = evdata->properties; + if (evdata->app_bus_name) + dbus_message_set_destination (message, evdata->app_bus_name); + dbus_message_iter_init_append (signal, &iter); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &sender); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &name); + dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "s", &iter_array); + while (ls) + { + dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_STRING, &ls->data); + ls = g_slist_next (ls); + } + dbus_message_iter_close_container (&iter, &iter_array); + dbus_connection_send (registry->bus, signal, NULL); + dbus_message_unref (signal); } - dbus_message_iter_close_container (&iter, &iter_array); - dbus_connection_send (registry->bus, signal, NULL); - dbus_message_unref (signal); - } g_free (name); return dbus_message_new_method_return (message); @@ -973,7 +973,7 @@ impl_DeregisterEvent (DBusMessage *message, SpiRegistry *registry) const char *sender = dbus_message_get_sender (message); if (!dbus_message_get_args (message, NULL, DBUS_TYPE_STRING, &orig_name, - DBUS_TYPE_INVALID)) + DBUS_TYPE_INVALID)) return NULL; name = ensure_proper_format (orig_name); @@ -1005,9 +1005,9 @@ impl_GetRegisteredEvents (DBusMessage *message, SpiRegistry *registry) if (evdata->app_bus_name && strcmp (evdata->app_bus_name, sender) != 0) continue; - str = g_strconcat (evdata->data [0], - ":", (evdata->data [1]? evdata->data [1]: ""), - ":", (evdata->data [1] && evdata->data [2]? evdata->data [2]: ""), NULL); + str = g_strconcat (evdata->data[0], + ":", (evdata->data[1] ? evdata->data[1] : ""), + ":", (evdata->data[1] && evdata->data[2] ? evdata->data[2] : ""), NULL); dbus_message_iter_open_container (&iter_array, DBUS_TYPE_STRUCT, NULL, &iter_struct); dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_STRING, &evdata->listener_bus_name); dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_STRING, &str); @@ -1020,8 +1020,8 @@ impl_GetRegisteredEvents (DBusMessage *message, SpiRegistry *registry) /*---------------------------------------------------------------------------*/ -static void -emit_Available (DBusConnection * bus) +static void +emit_Available (DBusConnection *bus) { DBusMessage *sig; DBusMessageIter iter; @@ -1029,29 +1029,29 @@ emit_Available (DBusConnection * bus) SPI_DBUS_NAME_REGISTRY, SPI_DBUS_PATH_ROOT, }; - - sig = dbus_message_new_signal(SPI_DBUS_PATH_ROOT, SPI_DBUS_INTERFACE_SOCKET, "Available"); - dbus_message_iter_init_append(sig, &iter); + sig = dbus_message_new_signal (SPI_DBUS_PATH_ROOT, SPI_DBUS_INTERFACE_SOCKET, "Available"); + + dbus_message_iter_init_append (sig, &iter); append_reference (&iter, &root_ref); - dbus_connection_send(bus, sig, NULL); - dbus_message_unref(sig); + dbus_connection_send (bus, sig, NULL); + dbus_message_unref (sig); } /*---------------------------------------------------------------------------*/ static const char *introspection_header = -"<?xml version=\"1.0\"?>\n"; + "<?xml version=\"1.0\"?>\n"; static const char *introspection_node_element = -"<node name=\"%s\">\n"; + "<node name=\"%s\">\n"; static const char *introspection_footer = -"</node>"; + "</node>"; static DBusMessage * -impl_Introspect_root (DBusMessage * message, SpiRegistry *registry) +impl_Introspect_root (DBusMessage *message, SpiRegistry *registry) { GString *output; gchar *final; @@ -1060,26 +1060,26 @@ impl_Introspect_root (DBusMessage * message, SpiRegistry *registry) DBusMessage *reply; - output = g_string_new(introspection_header); + output = g_string_new (introspection_header); - g_string_append_printf(output, introspection_node_element, pathstr); + g_string_append_printf (output, introspection_node_element, pathstr); g_string_append (output, spi_org_a11y_atspi_Accessible); g_string_append (output, spi_org_a11y_atspi_Component); g_string_append (output, spi_org_a11y_atspi_Socket); - g_string_append(output, introspection_footer); - final = g_string_free(output, FALSE); + 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); + dbus_message_append_args (reply, DBUS_TYPE_STRING, &final, DBUS_TYPE_INVALID); - g_free(final); + g_free (final); return reply; } static DBusMessage * -impl_Introspect_registry (DBusMessage * message, SpiRegistry *registry) +impl_Introspect_registry (DBusMessage *message, SpiRegistry *registry) { GString *output; gchar *final; @@ -1088,19 +1088,19 @@ impl_Introspect_registry (DBusMessage * message, SpiRegistry *registry) DBusMessage *reply; - output = g_string_new(introspection_header); + output = g_string_new (introspection_header); - g_string_append_printf(output, introspection_node_element, pathstr); + g_string_append_printf (output, introspection_node_element, pathstr); g_string_append (output, spi_org_a11y_atspi_Registry); - g_string_append(output, introspection_footer); - final = g_string_free(output, FALSE); + 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); + dbus_message_append_args (reply, DBUS_TYPE_STRING, &final, DBUS_TYPE_INVALID); - g_free(final); + g_free (final); return reply; } @@ -1112,17 +1112,17 @@ handle_method_root (DBusConnection *bus, DBusMessage *message, void *user_data) SpiRegistry *registry = SPI_REGISTRY (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); + const gchar *iface = dbus_message_get_interface (message); + 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 || + if (type != DBUS_MESSAGE_TYPE_METHOD_CALL || member == NULL || - iface == NULL) - return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + iface == NULL) + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; if (!strcmp (iface, "org.freedesktop.DBus.Properties")) { @@ -1146,10 +1146,9 @@ handle_method_root (DBusConnection *bus, DBusMessage *message, void *user_data) reply = dbus_message_new_method_return (message); dbus_message_iter_init_append (reply, &iter); - if (!strcmp (prop_iface, SPI_DBUS_INTERFACE_ACCESSIBLE)) { - if (!strcmp (prop_member, "Name")) + if (!strcmp (prop_member, "Name")) impl_get_Name (&iter, registry); else if (!strcmp (prop_member, "Description")) impl_get_Description (&iter, registry); @@ -1159,7 +1158,7 @@ handle_method_root (DBusConnection *bus, DBusMessage *message, void *user_data) impl_get_ChildCount (&iter, registry); else { - dbus_message_unref (reply); + dbus_message_unref (reply); reply = dbus_message_new_error (message, DBUS_ERROR_FAILED, "Property unavailable"); } } @@ -1171,13 +1170,13 @@ handle_method_root (DBusConnection *bus, DBusMessage *message, void *user_data) impl_get_ToolkitVersion (&iter, registry); else { - dbus_message_unref (reply); + dbus_message_unref (reply); reply = dbus_message_new_error (message, DBUS_ERROR_FAILED, "Property unavailable"); } } else { - dbus_message_unref (reply); + dbus_message_unref (reply); reply = dbus_message_new_error (message, DBUS_ERROR_FAILED, "Property unavailable"); } } @@ -1196,75 +1195,75 @@ handle_method_root (DBusConnection *bus, DBusMessage *message, void *user_data) if (!strcmp (iface, SPI_DBUS_INTERFACE_ACCESSIBLE)) { result = DBUS_HANDLER_RESULT_HANDLED; - if (!strcmp (member, "GetChildAtIndex")) - reply = impl_GetChildAtIndex (message, registry); + if (!strcmp (member, "GetChildAtIndex")) + reply = impl_GetChildAtIndex (message, registry); else if (!strcmp (member, "GetChildren")) - reply = impl_GetChildren (message, registry); + reply = impl_GetChildren (message, registry); else if (!strcmp (member, "GetIndexInParent")) - reply = impl_GetIndexInParent (message, registry); + reply = impl_GetIndexInParent (message, registry); else if (!strcmp (member, "GetRelationSet")) - reply = impl_GetRelationSet (message, registry); + reply = impl_GetRelationSet (message, registry); else if (!strcmp (member, "GetRole")) - reply = impl_GetRole (message, registry); + reply = impl_GetRole (message, registry); else if (!strcmp (member, "GetRoleName")) - reply = impl_GetRoleName (message, registry); + reply = impl_GetRoleName (message, registry); else if (!strcmp (member, "GetLocalizedRoleName")) - reply = impl_GetLocalizedRoleName (message, registry); + reply = impl_GetLocalizedRoleName (message, registry); else if (!strcmp (member, "GetState")) - reply = impl_GetState (message, registry); + reply = impl_GetState (message, registry); else if (!strcmp (member, "GetAttributes")) - reply = impl_GetAttributes (message, registry); + reply = impl_GetAttributes (message, registry); else if (!strcmp (member, "GetApplication")) - reply = impl_GetApplication (message, registry); + reply = impl_GetApplication (message, registry); else if (!strcmp (member, "GetInterfaces")) - reply = impl_GetInterfaces (message, registry); + reply = impl_GetInterfaces (message, registry); else - result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } if (!strcmp (iface, SPI_DBUS_INTERFACE_COMPONENT)) { result = DBUS_HANDLER_RESULT_HANDLED; - if (!strcmp (member, "Contains")) - reply = impl_Contains (message, registry); + if (!strcmp (member, "Contains")) + reply = impl_Contains (message, registry); else if (!strcmp (member, "GetAccessibleAtPoint")) - reply = impl_GetAccessibleAtPoint (message, registry); + reply = impl_GetAccessibleAtPoint (message, registry); else if (!strcmp (member, "GetExtents")) - reply = impl_GetExtents (message, registry); + reply = impl_GetExtents (message, registry); else if (!strcmp (member, "GetPosition")) - reply = impl_GetPosition (message, registry); + reply = impl_GetPosition (message, registry); else if (!strcmp (member, "GetSize")) - reply = impl_GetSize (message, registry); + reply = impl_GetSize (message, registry); else if (!strcmp (member, "GetLayer")) - reply = impl_GetLayer (message, registry); + reply = impl_GetLayer (message, registry); else if (!strcmp (member, "GetMDIZOrder")) - reply = impl_GetMDIZOrder (message, registry); + reply = impl_GetMDIZOrder (message, registry); else if (!strcmp (member, "GrabFocus")) - reply = impl_GrabFocus (message, registry); + reply = impl_GrabFocus (message, registry); else if (!strcmp (member, "GetAlpha")) - reply = impl_GetAlpha (message, registry); + reply = impl_GetAlpha (message, registry); else - result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } if (!strcmp (iface, SPI_DBUS_INTERFACE_SOCKET)) { result = DBUS_HANDLER_RESULT_HANDLED; - if (!strcmp (member, "Embed")) - reply = impl_Embed (message, registry); + if (!strcmp (member, "Embed")) + reply = impl_Embed (message, registry); else if (!strcmp (member, "Unembed")) - reply = impl_Unembed (message, registry); + reply = impl_Unembed (message, registry); else - result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + 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_root (message, registry); + if (!strcmp (member, "Introspect")) + reply = impl_Introspect_root (message, registry); else - result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } if (result == DBUS_HANDLER_RESULT_HANDLED) @@ -1283,7 +1282,7 @@ handle_method_root (DBusConnection *bus, DBusMessage *message, void *user_data) g_print ("Registry | Unhandled message : %s|%s\n", iface, member); } #endif - + return result; } @@ -1293,25 +1292,25 @@ handle_method_cache (DBusConnection *bus, DBusMessage *message, void *user_data) SpiRegistry *registry = SPI_REGISTRY (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); + const gchar *iface = dbus_message_get_interface (message); + 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 || + if (type != DBUS_MESSAGE_TYPE_METHOD_CALL || member == NULL || - iface == NULL) - return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + iface == NULL) + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; if (!strcmp (iface, SPI_DBUS_INTERFACE_CACHE)) { result = DBUS_HANDLER_RESULT_HANDLED; - if (!strcmp (member, "GetItems")) - reply = impl_GetItems (message, registry); + if (!strcmp (member, "GetItems")) + reply = impl_GetItems (message, registry); else - result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } if (result == DBUS_HANDLER_RESULT_HANDLED) @@ -1333,38 +1332,38 @@ handle_method_registry (DBusConnection *bus, DBusMessage *message, void *user_da SpiRegistry *registry = SPI_REGISTRY (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); + const gchar *iface = dbus_message_get_interface (message); + 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 || + if (type != DBUS_MESSAGE_TYPE_METHOD_CALL || member == NULL || - iface == NULL) - return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + iface == NULL) + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; if (!strcmp (iface, SPI_DBUS_INTERFACE_REGISTRY)) { result = DBUS_HANDLER_RESULT_HANDLED; - if (!strcmp(member, "RegisterEvent")) - reply = impl_RegisterEvent (message, registry); - else if (!strcmp(member, "DeregisterEvent")) + if (!strcmp (member, "RegisterEvent")) + reply = impl_RegisterEvent (message, registry); + else if (!strcmp (member, "DeregisterEvent")) reply = impl_DeregisterEvent (message, registry); - else if (!strcmp(member, "GetRegisteredEvents")) + else if (!strcmp (member, "GetRegisteredEvents")) reply = impl_GetRegisteredEvents (message, registry); else - result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + 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_registry (message, registry); + if (!strcmp (member, "Introspect")) + reply = impl_Introspect_registry (message, registry); else - result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } if (result == DBUS_HANDLER_RESULT_HANDLED) @@ -1383,35 +1382,32 @@ handle_method_registry (DBusConnection *bus, DBusMessage *message, void *user_da g_print ("Registry | Unhandled message : %s|%s\n", iface, member); } #endif - + return result; } /*---------------------------------------------------------------------------*/ -static DBusObjectPathVTable root_vtable = -{ +static DBusObjectPathVTable root_vtable = { NULL, &handle_method_root, NULL, NULL, NULL, NULL }; -static DBusObjectPathVTable registry_vtable = -{ +static DBusObjectPathVTable registry_vtable = { NULL, &handle_method_registry, NULL, NULL, NULL, NULL }; -static DBusObjectPathVTable cache_vtable = -{ +static DBusObjectPathVTable cache_vtable = { NULL, &handle_method_cache, NULL, NULL, NULL, NULL }; static gchar *app_sig_match_name_owner = - "type='signal', interface='org.freedesktop.DBus', member='NameOwnerChanged'"; + "type='signal', interface='org.freedesktop.DBus', member='NameOwnerChanged'"; SpiRegistry * spi_registry_new (DBusConnection *bus, SpiDEController *dec) diff --git a/registryd/registry.h b/registryd/registry.h index a66233e5..96569f2e 100644 --- a/registryd/registry.h +++ b/registryd/registry.h @@ -24,8 +24,8 @@ #ifndef SPI_REGISTRY_H_ #define SPI_REGISTRY_H_ -#include <glib.h> #include <glib-object.h> +#include <glib.h> #include <dbus/dbus.h> @@ -36,16 +36,17 @@ typedef struct _SpiRegistryClass SpiRegistryClass; G_BEGIN_DECLS -#define SPI_REGISTRY_TYPE (spi_registry_get_type ()) -#define SPI_REGISTRY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SPI_REGISTRY_TYPE, SpiRegistry)) -#define SPI_REGISTRY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), SPI_REGISTRY_TYPE, SpiRegistryClass)) -#define SPI_IS_REGISTRY(o) (G_TYPE_CHECK__INSTANCE_TYPE ((o), SPI_REGISTRY_TYPE)) +#define SPI_REGISTRY_TYPE (spi_registry_get_type ()) +#define SPI_REGISTRY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SPI_REGISTRY_TYPE, SpiRegistry)) +#define SPI_REGISTRY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), SPI_REGISTRY_TYPE, SpiRegistryClass)) +#define SPI_IS_REGISTRY(o) (G_TYPE_CHECK__INSTANCE_TYPE ((o), SPI_REGISTRY_TYPE)) #define SPI_IS_REGISTRY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), SPI_REGISTRY_TYPE)) -struct _SpiRegistry { - GObject parent; +struct _SpiRegistry +{ + GObject parent; SpiDEController *dec; - GPtrArray *apps; + GPtrArray *apps; dbus_int32_t id; DBusConnection *bus; @@ -53,12 +54,13 @@ struct _SpiRegistry { GList *events; }; -struct _SpiRegistryClass { +struct _SpiRegistryClass +{ GObjectClass parent_class; }; -GType spi_registry_get_type (void); -SpiRegistry *spi_registry_new (DBusConnection *bus, SpiDEController *dec); +GType spi_registry_get_type (void); +SpiRegistry *spi_registry_new (DBusConnection *bus, SpiDEController *dec); G_END_DECLS diff --git a/registryd/ucs2keysym.c b/registryd/ucs2keysym.c index 29a92f3e..bcc3e702 100644 --- a/registryd/ucs2keysym.c +++ b/registryd/ucs2keysym.c @@ -31,13 +31,14 @@ * */ +#include "deviceeventcontroller.h" /* for prototype */ #include <X11/X.h> -#include "deviceeventcontroller.h" /* for prototype */ /* DO NOT UPATE BY HAND! * This table can be regenerated from Xorg's keysymdef.h with the ucs2keysym.sh * script. */ -struct codepair { +struct codepair +{ unsigned short keysym; unsigned short ucs; } keysymtab[] = { @@ -823,56 +824,62 @@ struct codepair { { 0x0ef5, 0x3186 }, /* Hangul_YeorinHieuh ㆆ HANGUL LETTER YEORINHIEUH */ { 0x0ef6, 0x318d }, /* Hangul_AraeA ㆍ HANGUL LETTER ARAEA */ { 0x0ef7, 0x318e }, /* Hangul_AraeAE ㆎ HANGUL LETTER ARAEAE */ - }; +}; -long ucs2keysym (long ucs) +long +ucs2keysym (long ucs) { - int min = 0; - int max = sizeof(keysymtab) / sizeof(struct codepair) - 1; - int mid; - - /* first check for Latin-1 characters (1:1 mapping) */ - if ((ucs >= 0x0020 && ucs <= 0x007e) || - (ucs >= 0x00a0 && ucs <= 0x00ff)) - return ucs; + int min = 0; + int max = sizeof (keysymtab) / sizeof (struct codepair) - 1; + int mid; + + /* first check for Latin-1 characters (1:1 mapping) */ + if ((ucs >= 0x0020 && ucs <= 0x007e) || + (ucs >= 0x00a0 && ucs <= 0x00ff)) + return ucs; - /* binary search in table */ - while (max >= min) { - mid = (min + max) / 2; - if (keysymtab[mid].ucs < ucs) - min = mid + 1; - else if (keysymtab[mid].ucs > ucs) - max = mid - 1; - else { - /* found it */ - return keysymtab[mid].keysym; - } + /* binary search in table */ + while (max >= min) + { + mid = (min + max) / 2; + if (keysymtab[mid].ucs < ucs) + min = mid + 1; + else if (keysymtab[mid].ucs > ucs) + max = mid - 1; + else + { + /* found it */ + return keysymtab[mid].keysym; + } } - /* no matching keysym value found, return UCS2 with bit set */ - return ucs | 0x01000000; + /* no matching keysym value found, return UCS2 with bit set */ + return ucs | 0x01000000; } -long keysym2ucs(long keysym) +long +keysym2ucs (long keysym) { - int i; + int i; - /* first check for Latin-1 characters (1:1 mapping) */ - if ((keysym >= 0x0020 && keysym <= 0x007e) || - (keysym >= 0x00a0 && keysym <= 0x00ff)) - return (long) keysym; + /* first check for Latin-1 characters (1:1 mapping) */ + if ((keysym >= 0x0020 && keysym <= 0x007e) || + (keysym >= 0x00a0 && keysym <= 0x00ff)) + return (long) keysym; - /* also check for directly encoded 24-bit UCS characters */ - if ((keysym & 0xff000000) == 0x01000000) - return keysym & 0x00ffffff; + /* also check for directly encoded 24-bit UCS characters */ + if ((keysym & 0xff000000) == 0x01000000) + return keysym & 0x00ffffff; - for (i = 0; i < sizeof(keysymtab) / sizeof(keysymtab[0]); i++) { - if (keysymtab[i].keysym == keysym) { - /* found it */ - return keysymtab[i].ucs; - } + for (i = 0; i < sizeof (keysymtab) / sizeof (keysymtab[0]); i++) + { + if (keysymtab[i].keysym == keysym) + { + /* found it */ + return keysymtab[i].ucs; + } } - /* no matching Unicode value found */ - return -1; + /* no matching Unicode value found */ + return -1; } |