X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=cspi%2Fspi_registry.c;h=18cf592b8d5e0dcc584381be33556f04866497e5;hb=0724cea984b691fdc60a020b237828e9ef018cd7;hp=95abd2bb39333708437ad685bf1c1335a9252ab5;hpb=207ac36102dabd5101e6162b9003b6e530db922d;p=platform%2Fcore%2Fuifw%2Fat-spi2-atk.git diff --git a/cspi/spi_registry.c b/cspi/spi_registry.c index 95abd2b..18cf592 100644 --- a/cspi/spi_registry.c +++ b/cspi/spi_registry.c @@ -2,7 +2,8 @@ * AT-SPI - Assistive Technology Service Provider Interface * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap) * - * Copyright 2001 Sun Microsystems Inc. + * Copyright 2001, 2002 Sun Microsystems Inc., + * Copyright 2001, 2002 Ximian, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public @@ -24,158 +25,7 @@ #include -/** - * SPI_registerGlobalEventListener: - * @listener: the #AccessibleEventListener to be registered against an - * event type. - * @eventType: a character string indicating the type of events for which - * notification is requested. Format is - * EventClass:major_type:minor_type:detail - * where all subfields other than EventClass are optional. - * EventClasses include "object", "window", "mouse", - * and toolkit events (e.g. "Gtk", "AWT"). - * Examples: "focus:", "Gtk:GtkWidget:button_press_event". - * - * Legal object event types: - * - * (property change events) - * - * object:property-change - * object:property-change:accessible-name - * object:property-change:accessible-description - * object:property-change:accessible-parent - * object:property-change:accessible-value - * object:property-change:accessible-role - * object:property-change:accessible-table-caption - * object:property-change:accessible-table-column-description - * object:property-change:accessible-table-column-header - * object:property-change:accessible-table-row-description - * object:property-change:accessible-table-row-header - * object:property-change:accessible-table-summary - * - * (other object events) - * - * object:state-changed - * object:children-changed - * object:visible-data-changed - * object:selection-changed - * object:text-selection-changed - * object:text-changed - * object:text-caret-moved - * object:row-inserted - * object:row-reordered - * object:row-deleted - * object:column-inserted - * object:column-reordered - * object:column-deleted - * object:model-changed - * - * (window events) - * - * window:minimize - * window:maximize - * window:restore - * window:close - * window:create - * window:reparent - * window:desktop-create - * window:desktop-destroy - * window:activate - * window:deactivate - * window:raise - * window:lower - * window:move - * window:resize - * window:shade - * window:unshade - * window:restyle - * - * NOTE: this string may be UTF-8, but should not contain byte value 56 - * (ascii ':'), except as a delimiter, since non-UTF-8 string - * delimiting functions are used internally. - * In general, listening to - * toolkit-specific events is not recommended. - * - * Add an in-process callback function to an existing AccessibleEventListener. - * - * Returns: #TRUE if successful, otherwise #FALSE. - **/ -SPIBoolean -SPI_registerGlobalEventListener (AccessibleEventListener *listener, - const char *eventType) -{ - SPIBoolean retval; - - if (!listener) - { - return FALSE; - } - - Accessibility_Registry_registerGlobalEventListener ( - cspi_registry (), - cspi_event_listener_get_corba (listener), - eventType, cspi_ev ()); - - retval = !cspi_exception (); - - return retval; -} - -/** - * SPI_deregisterGlobalEventListenerAll: - * @listener: the #AccessibleEventListener to be registered against - * an event type. - * - * deregisters an AccessibleEventListener from the registry, for all - * event types it may be listening to. Use - * AccessibleEventListener_unref to release the - * listener reference. - * - * Returns: #TRUE if successful, otherwise #FALSE. - **/ -SPIBoolean -SPI_deregisterGlobalEventListenerAll (AccessibleEventListener *listener) -{ - if (!listener) - { - return FALSE; - } - - Accessibility_Registry_deregisterGlobalEventListenerAll ( - cspi_registry (), - cspi_event_listener_get_corba (listener), - cspi_ev ()); - - return !cspi_exception (); -} - -/** - * SPI_deregisterGlobalEventListener: - * @listener: the #AccessibleEventListener registered against an event type. - * @eventType: a string specifying the event type for which this - * listener is to be deregistered. - * - * deregisters an AccessibleEventListener from the registry, for a specific - * event type. - * - * Returns: #TRUE if successful, otherwise #FALSE. - **/ -SPIBoolean -SPI_deregisterGlobalEventListener (AccessibleEventListener *listener, - const char *eventType) -{ - if (!listener) - { - return FALSE; - } - - Accessibility_Registry_deregisterGlobalEventListener ( - cspi_registry (), - cspi_event_listener_get_corba (listener), - (CORBA_char *) eventType, cspi_ev ()); - - return !cspi_exception (); -} +static GArray *desktops; /** * SPI_getDesktopCount: @@ -189,14 +39,9 @@ SPI_deregisterGlobalEventListener (AccessibleEventListener *listener, int SPI_getDesktopCount () { - int retval; - - retval = Accessibility_Registry_getDesktopCount ( - cspi_registry (), cspi_ev ()); - - cspi_return_val_if_ev ("getDesktopCount", -1); - - return retval; + if (!desktops) SPI_getDesktopList (NULL); + if (!desktops) return -1; + return desktops->len; } /** @@ -212,9 +57,9 @@ SPI_getDesktopCount () Accessible* SPI_getDesktop (int i) { - return cspi_object_add ( - Accessibility_Registry_getDesktop ( - cspi_registry (), (CORBA_short) i, cspi_ev ())); + if (!desktops) SPI_getDesktopList (NULL); + if (!desktops) return NULL; + return cspi_ref_accessible (spi_bus_registry, g_array_index (desktops, char *, i)); } /** @@ -238,29 +83,24 @@ SPI_getDesktopList (Accessible ***desktop_list) { int i; Accessible **list; - Accessibility_DesktopSeq *desktops; - - if (!desktop_list) - return 0; - *desktop_list = NULL; + if (desktop_list) *desktop_list = NULL; - desktops = Accessibility_Registry_getDesktopList (cspi_registry (), - cspi_ev ()); + if (!desktops) + { + dbind_connection_method_call (cspi_bus(), spi_bus_registry, spi_path_registry, spi_interface_registry, "getDesktopList", NULL, "=>ao", &desktops); + if (!desktops) return 0; + } - cspi_return_val_if_ev ("getting desktop list", 0); + list = g_new0 (Accessible *, desktops->len + 1); - list = g_new0 (Accessible *, desktops->_length + 1); - - for (i = 0; i < desktops->_length; i++) + if (!desktop_list) return desktops->len; + for (i = 0; i < desktops->len; i++) { - list [i] = cspi_object_add ( - CORBA_Object_duplicate (desktops->_buffer [i], cspi_ev ())); + list [i] = cspi_ref_accessible (spi_bus_registry, g_array_index (desktops, char *, i)); } list [i] = NULL; - CORBA_free (desktops); - *desktop_list = list; return i; @@ -296,7 +136,9 @@ SPI_freeDesktopList (Accessible **desktop_list) * @listener: a pointer to the #AccessibleKeystrokeListener for which * keystroke events are requested. * @keys: a pointer to the #AccessibleKeySet indicating which - * keystroke events are requested, or #CSPI_KEYSET_ALL_KEYS. + * keystroke events are requested, or #SPI_KEYSET_ALL_KEYS + * to indicate that all keycodes and keyvals for the specified + * modifier set are to be included. * @modmask: an #AccessibleKeyMaskType mask indicating which * key event modifiers must be set in combination with @keys, * events will only be reported for key events for which all @@ -309,9 +151,12 @@ SPI_freeDesktopList (Accessible **desktop_list) * the behavior of the notification/listener transaction. * * Register a listener for keystroke events, either pre-emptively for - * all windows (CSPI_KEYLISTENER_ALL_WINDOWS), or - * non-preemptively (CSPI_KEYLISTENER_NOSYNC). - * ( Other sync_type values may be available in the future.) + * all windows (SPI_KEYLISTENER_ALL_WINDOWS), + * non-preemptively (SPI_KEYLISTENER_NOSYNC), or + * pre-emptively at the toolkit level (SPI_KEYLISTENER_CANCONSUME). + * If ALL_WINDOWS or CANCONSUME are used, the event is consumed + * upon receipt if one of @listener's callbacks returns #TRUE. + * ( Other sync_type values may be available in the future ) * * Returns: #TRUE if successful, otherwise #FALSE. **/ @@ -322,96 +167,71 @@ SPI_registerAccessibleKeystrokeListener (AccessibleKeystrokeListener *listener, AccessibleKeyEventMask eventmask, AccessibleKeyListenerSyncType sync_type) { - gint i, mask; - Accessibility_KeySet key_set; - Accessibility_KeyEventTypeSeq key_events; + gchar *path = cspi_device_listener_get_path (listener); + gint i; + GArray *key_set; + dbus_uint32_t key_events = 0; Accessibility_ControllerEventMask controller_event_mask; - Accessibility_DeviceEventController device_event_controller; Accessibility_EventListenerMode listener_mode; + DBusError error; + SPIBoolean retval = FALSE; if (!listener) { - return FALSE; + return retval; } - device_event_controller = - Accessibility_Registry_getDeviceEventController (cspi_registry (), cspi_ev ()); - - cspi_return_val_if_ev ("getting event controller", FALSE); - - /* copy the keyval filter values from the C api into the CORBA KeySet */ + /* copy the keyval filter values from the C api into the DBind KeySet */ if (keys) { - key_set._length = keys->len; - key_set._buffer = Accessibility_KeySet_allocbuf (keys->len); - for (i = 0; i < key_set._length; ++i) + key_set = g_array_sized_new (FALSE, TRUE, sizeof (Accessibility_KeyDefinition), keys->len); + key_set->len = keys->len; + for (i = 0; i < keys->len; ++i) { - key_set._buffer[i].keycode = keys->keycodes[i]; - key_set._buffer[i].keysym = keys->keysyms[i]; - if (keys->keystrings && keys->keystrings[i]) + Accessibility_KeyDefinition *kd = ((Accessibility_KeyDefinition *) key_set->data) + i; + kd->keycode = keys->keycodes[i]; + kd->keysym = keys->keysyms[i]; + if (keys->keystrings && keys->keystrings[i]) { - key_set._buffer[i].keystring = keys->keystrings[i]; + kd->keystring = keys->keystrings[i]; } else { - key_set._buffer[i].keystring = CORBA_string_dup(""); + kd->keystring = ""; } } } else { - key_set._length = 0; - key_set._buffer = NULL; + key_set = g_array_sized_new (FALSE, TRUE, sizeof (Accessibility_KeyDefinition), 0); } - /* copy the event filter values from the C api into the CORBA KeyEventTypeSeq */ - mask = 1; - i = 0; - do - { - if (mask & eventmask) - { - ++i; - } - mask <<= 1; - } - while (mask & 0xFFFF); - - key_events._buffer = Accessibility_KeyEventTypeSeq_allocbuf (i); - i = 0; + /* copy the event filter values from the C api into the DBus key_events */ if (eventmask & SPI_KEY_PRESSED) { - key_events._buffer[i++] = Accessibility_KEY_PRESSED; + key_events |= (1 << Accessibility_KEY_PRESSED_EVENT); } if (eventmask & SPI_KEY_RELEASED) { - key_events._buffer[i++] = Accessibility_KEY_RELEASED; + key_events |= (1 << Accessibility_KEY_RELEASED_EVENT); } - key_events._length = i; - controller_event_mask = (CORBA_unsigned_long) modmask; + controller_event_mask = (dbus_uint32_t) modmask; listener_mode.synchronous = - (CORBA_boolean) ((sync_type & SPI_KEYLISTENER_SYNCHRONOUS)!=0); + (dbus_bool_t) ((sync_type & SPI_KEYLISTENER_SYNCHRONOUS)!=0); listener_mode.preemptive = - (CORBA_boolean) ((sync_type & SPI_KEYLISTENER_CANCONSUME)!=0); + (dbus_bool_t) ((sync_type & SPI_KEYLISTENER_CANCONSUME)!=0); listener_mode.global = - (CORBA_boolean) ((sync_type & SPI_KEYLISTENER_ALL_WINDOWS)!=0); + (dbus_bool_t) ((sync_type & SPI_KEYLISTENER_ALL_WINDOWS)!=0); - Accessibility_DeviceEventController_registerKeystrokeListener ( - device_event_controller, - cspi_event_listener_get_corba (listener), - &key_set, - controller_event_mask, - &key_events, - &listener_mode, - cspi_ev ()); + dbus_error_init (&error); + dbind_connection_method_call (cspi_bus(), spi_bus_registry, spi_path_dec, spi_interface_dec, "registerKeystrokeListener", &error, "oa(iisi)uu(bbb)=>b", path, key_set, key_events, controller_event_mask, &listener_mode, &retval); - cspi_return_val_if_ev ("registering keystroke listener", FALSE); + g_array_free (key_set, TRUE); + g_free (path); - cspi_release_unref (device_event_controller); - - return TRUE; + return retval; } /** @@ -430,39 +250,101 @@ SPIBoolean SPI_deregisterAccessibleKeystrokeListener (AccessibleKeystrokeListener *listener, AccessibleKeyMaskType modmask) { + gchar *path = cspi_device_listener_get_path (listener); Accessibility_ControllerEventMask controller_event_mask; - Accessibility_KeySet key_set; - Accessibility_KeyEventTypeSeq key_events; - Accessibility_DeviceEventController device_event_controller; + GArray *key_set; + dbus_uint32_t key_events = 0; + DBusError error; if (!listener) { return FALSE; } - device_event_controller = - Accessibility_Registry_getDeviceEventController (cspi_registry (), cspi_ev ()); - cspi_return_val_if_ev ("getting keystroke listener", FALSE); + controller_event_mask = (dbus_uint32_t) modmask; + + key_set = g_array_sized_new (FALSE, TRUE, sizeof (Accessibility_KeyDefinition), 0); + dbind_connection_method_call (cspi_bus(), spi_bus_registry, spi_path_dec, spi_interface_dec, "deregisterKeystrokeListener", &error, "oa(iisi)uu", path, &key_set, key_events, controller_event_mask); + g_free (path); + return TRUE; +} + +/** + * SPI_registerDeviceEventListener: + * @listener: a pointer to the #AccessibleDeviceListener which requests + * the events. + * @eventmask: an #AccessibleDeviceEventMask mask indicating which + * types of key events are requested (#SPI_KEY_PRESSED, etc.). + * @filter: Unused parameter. + * + * Register a listener for device events, for instance button events. + * + * Returns: #TRUE if successful, otherwise #FALSE. + **/ +SPIBoolean +SPI_registerDeviceEventListener (AccessibleDeviceListener *listener, + AccessibleDeviceEventMask eventmask, + void *filter) +{ + SPIBoolean retval = FALSE; + dbus_uint32_t event_types = 0; + gint i; + gchar *path = cspi_device_listener_get_path (listener); + DBusError error; + + if (!listener) + { + return retval; + } - controller_event_mask = (CORBA_unsigned_long) modmask; + /* copy the event filter values from the C api into the CORBA KeyEventTypeSeq */ + + if (eventmask & SPI_BUTTON_PRESSED) + { + event_types |= (1 << Accessibility_BUTTON_PRESSED_EVENT); + } + if (eventmask & SPI_BUTTON_RELEASED) + { + event_types |= (1 << Accessibility_BUTTON_RELEASED_EVENT); + } - key_events._buffer = NULL; - key_events._length = 0; + dbus_error_init (&error); + dbind_connection_method_call (cspi_bus(), spi_bus_registry, spi_path_dec, spi_interface_dec, "registerDeviceEventListener", &error, "ou=>b", path, event_types, &retval); + g_free (path); + return retval; +} - key_set._buffer = NULL; - key_set._length = 0; +/** + * SPI_deregisterDeviceEventListener: + * @listener: a pointer to the #AccessibleDeviceListener for which + * device events are requested. + * @filter: Unused parameter. + * + * Removes a device event listener from the registry's listener queue, + * ceasing notification of events of the specified type. + * + * Returns: #TRUE if successful, otherwise #FALSE. + **/ +SPIBoolean +SPI_deregisterDeviceEventListener (AccessibleDeviceListener *listener, + void *filter) +{ + dbus_uint32_t event_types = 0; + gchar *path = cspi_device_listener_get_path (listener); + DBusError error; - Accessibility_DeviceEventController_deregisterKeystrokeListener ( - device_event_controller, - cspi_event_listener_get_corba (listener), - &key_set, - controller_event_mask, - &key_events, - cspi_ev ()); + if (!listener) + { + return FALSE; + } - cspi_release_unref (device_event_controller); + event_types |= (1 << Accessibility_BUTTON_PRESSED_EVENT); + event_types |= (1 << Accessibility_BUTTON_RELEASED_EVENT); + dbus_error_init (&error); + dbind_connection_method_call (cspi_bus(), spi_bus_registry, spi_path_dec, spi_interface_dec, "deregisterDeviceEventListener", &error, "ou", path, event_types); + g_free (path); return TRUE; } @@ -490,16 +372,9 @@ SPI_generateKeyboardEvent (long int keyval, char *keystring, AccessibleKeySynthType synth_type) { -/* TODO: check current modifier status and - * send keycode to alter, if necessary - */ - - /* TODO: implement keystring use case */ - Accessibility_KeySynthType keysynth_type; - Accessibility_DeviceEventController device_event_controller = - Accessibility_Registry_getDeviceEventController (cspi_registry (), cspi_ev ()); - - cspi_return_val_if_ev ("getting event controller for key event gen", FALSE); + dbus_uint32_t keysynth_type; + dbus_int32_t keycode = keyval; + DBusError error; switch (synth_type) { @@ -522,15 +397,9 @@ SPI_generateKeyboardEvent (long int keyval, return FALSE; } - Accessibility_DeviceEventController_generateKeyboardEvent (device_event_controller, - keyval, - "", - keysynth_type, - cspi_ev ()); - - cspi_return_val_if_ev ("generating keyboard event", FALSE); - - cspi_release_unref (device_event_controller); + if (!keystring) keystring = ""; + dbus_error_init (&error); + dbind_connection_method_call (cspi_bus(), spi_bus_registry, spi_path_dec, spi_interface_dec, "generateKeyboardEvent", &error, "isu", keycode, keystring, keysynth_type); return TRUE; } @@ -554,17 +423,16 @@ SPI_generateKeyboardEvent (long int keyval, SPIBoolean SPI_generateMouseEvent (long x, long y, char *name) { - Accessibility_DeviceEventController device_event_controller = - Accessibility_Registry_getDeviceEventController (cspi_registry (), cspi_ev ()); - - cspi_return_val_if_ev ("getting event controller for mouse event gen", FALSE); - - Accessibility_DeviceEventController_generateMouseEvent (device_event_controller, - x, y, name, cspi_ev ()); - cspi_return_val_if_ev ("generating mouse event", FALSE); - - cspi_release_unref (device_event_controller); + dbus_int32_t dbus_x = x, dbus__y = y; + DBusError error; + dbus_error_init (&error); + dbind_connection_method_call (cspi_bus(), spi_bus_registry, spi_path_dec, spi_interface_dec, "generateMouseEvent", &error, "iis", x, y, name); return TRUE; } +char * +cspi_device_listener_get_path (CSpiDeviceListener *listener) +{ + return g_strdup_printf ("/org/freedesktop/atspi/listeners/%d", listener->id); +}