#include <cspi/spi-private.h>
-/**
- * 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
- * object:active-descendant-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
- *
- * (other events)
- *
- * focus:
- * mouse:abs
- * mouse:rel
- * mouse:b1p
- * mouse:b1r
- * mouse:b2p
- * mouse:b2r
- * mouse:b3p
- * mouse:b3r
- *
- * 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)
-{
- if (!listener)
- {
- return FALSE;
- }
-
- Accessibility_Registry_registerGlobalEventListener (
- cspi_registry (),
- cspi_event_listener_get_corba (listener),
- eventType, cspi_ev ());
-
- return !cspi_exception ();
-}
-
-/**
- * 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),
- eventType, cspi_ev ());
-
- return !cspi_exception ();
-}
+static GArray *desktops;
/**
* SPI_getDesktopCount:
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;
}
/**
Accessible*
SPI_getDesktop (int i)
{
- return cspi_object_add (
- Accessibility_Registry_getDesktop (
- cspi_registry (), 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));
}
/**
{
int i;
Accessible **list;
- Accessibility_DesktopSeq *desktops;
-
- if (!desktop_list)
- return 0;
-
- *desktop_list = NULL;
- desktops = Accessibility_Registry_getDesktopList (cspi_registry (),
- cspi_ev ());
+ if (desktop_list) *desktop_list = NULL;
- cspi_return_val_if_ev ("getDesktopList", 0);
+ 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;
+ }
- list = g_new0 (Accessible *, desktops->_length + 1);
+ list = g_new0 (Accessible *, desktops->len + 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;
AccessibleKeyEventMask eventmask,
AccessibleKeyListenerSyncType sync_type)
{
+ gchar *path = cspi_device_listener_get_path (listener);
gint i;
- Accessibility_KeySet key_set;
- Accessibility_KeyEventTypeSeq key_events;
+ GArray *key_set;
+ dbus_uint32_t key_events = 0;
Accessibility_ControllerEventMask controller_event_mask;
- Accessibility_DeviceEventController device_event_controller;
Accessibility_EventListenerMode listener_mode;
- Accessibility_EventType key_event_types [2];
+ DBusError error;
SPIBoolean retval = FALSE;
if (!listener)
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 = CORBA_string_dup(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 */
- i = 0;
- key_events._buffer = key_event_types;
+ /* 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_EVENT;
+ key_events |= (1 << Accessibility_KEY_PRESSED_EVENT);
}
if (eventmask & SPI_KEY_RELEASED)
{
- key_events._buffer[i++] = Accessibility_KEY_RELEASED_EVENT;
+ 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);
-
- retval = Accessibility_DeviceEventController_registerKeystrokeListener (
- device_event_controller,
- cspi_event_listener_get_corba (listener),
- &key_set,
- controller_event_mask,
- &key_events,
- &listener_mode,
- cspi_ev ());
-
- CORBA_free (key_set._buffer);
+ (dbus_bool_t) ((sync_type & SPI_KEYLISTENER_ALL_WINDOWS)!=0);
- cspi_return_val_if_ev ("registering keystroke listener", FALSE);
+ 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, controller_event_mask, key_set, &listener_mode, &retval);
- cspi_release_unref (device_event_controller);
+ g_array_free (key_set, TRUE);
+ g_free (path);
return retval;
}
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 = (CORBA_unsigned_long) modmask;
- key_events._buffer = NULL;
- key_events._length = 0;
-
- key_set._buffer = NULL;
- key_set._length = 0;
-
- Accessibility_DeviceEventController_deregisterKeystrokeListener (
- device_event_controller,
- cspi_event_listener_get_corba (listener),
- &key_set,
- controller_event_mask,
- &key_events,
- cspi_ev ());
-
- cspi_release_unref (device_event_controller);
+ 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;
}
AccessibleDeviceEventMask eventmask,
void *filter)
{
- Accessibility_DeviceEventController device_event_controller;
SPIBoolean retval = FALSE;
- Accessibility_EventTypeSeq event_types;
- Accessibility_EventType event_type_buffer[2];
+ dbus_uint32_t event_types = 0;
gint i;
+ gchar *path = cspi_device_listener_get_path (listener);
+ DBusError error;
if (!listener)
{
return retval;
}
- device_event_controller =
- Accessibility_Registry_getDeviceEventController (cspi_registry (), cspi_ev ());
-
- cspi_return_val_if_ev ("getting event controller", FALSE);
-
/* copy the event filter values from the C api into the CORBA KeyEventTypeSeq */
- event_types._buffer = event_type_buffer;
- i = 0;
-
if (eventmask & SPI_BUTTON_PRESSED)
{
- event_types._buffer[i++] = Accessibility_BUTTON_PRESSED_EVENT;
+ event_types |= (1 << Accessibility_BUTTON_PRESSED_EVENT);
}
if (eventmask & SPI_BUTTON_RELEASED)
{
- event_types._buffer[i++] = Accessibility_BUTTON_RELEASED_EVENT;
+ event_types |= (1 << Accessibility_BUTTON_RELEASED_EVENT);
}
- event_types._length = i;
-
- retval = Accessibility_DeviceEventController_registerDeviceEventListener (
- device_event_controller,
- cspi_event_listener_get_corba (listener),
- &event_types,
- cspi_ev ());
-
- cspi_return_val_if_ev ("registering keystroke listener", FALSE);
-
- cspi_release_unref (device_event_controller);
-
+ 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;
}
SPI_deregisterDeviceEventListener (AccessibleDeviceListener *listener,
void *filter)
{
- Accessibility_DeviceEventController device_event_controller;
- Accessibility_EventTypeSeq event_types;
- Accessibility_EventType event_type_buff[2];
+ dbus_uint32_t event_types = 0;
+ gchar *path = cspi_device_listener_get_path (listener);
+ 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);
-
- event_types._buffer = event_type_buff;
- event_types._length = 2;
- event_types._buffer[0] = Accessibility_BUTTON_PRESSED_EVENT;
- event_types._buffer[1] = Accessibility_BUTTON_RELEASED_EVENT;
-
- Accessibility_DeviceEventController_deregisterDeviceEventListener (
- device_event_controller,
- cspi_event_listener_get_corba (listener),
- &event_types,
- cspi_ev ());
-
- 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;
}
char *keystring,
AccessibleKeySynthType synth_type)
{
- 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)
{
return FALSE;
}
- Accessibility_DeviceEventController_generateKeyboardEvent (device_event_controller,
- keyval,
- keystring ? keystring : "",
- 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;
}
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);
+}
projects / platform / core / uifw / at-spi2-atk.git / blobdiff