* 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
*
* object:property-change
* object:property-change:accessible-name
- * object:property-change:accessible-state
* object:property-change:accessible-description
* object:property-change:accessible-parent
* object:property-change:accessible-value
*
* (other object events)
*
+ * object:state-changed
* object:children-changed
* object:visible-data-changed
* object:selection-changed
* object:column-reordered
* object:column-deleted
* object:model-changed
+ * object:active-descendant-changed
*
* (window events)
*
* window:reparent
* window:desktop-create
* window:desktop-destroy
- * window:focus-in
- * window:focus-out
+ * window:activate
+ * window:deactivate
* window:raise
* window:lower
* window:move
* 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.
SPI_registerGlobalEventListener (AccessibleEventListener *listener,
const char *eventType)
{
- SPIBoolean retval;
-
if (!listener)
{
return FALSE;
cspi_event_listener_get_corba (listener),
eventType, cspi_ev ());
- retval = !cspi_exception ();
-
- return retval;
+ return !cspi_exception ();
}
/**
Accessibility_Registry_deregisterGlobalEventListener (
cspi_registry (),
cspi_event_listener_get_corba (listener),
- (CORBA_char *) eventType, cspi_ev ());
+ eventType, cspi_ev ());
return !cspi_exception ();
}
{
return cspi_object_add (
Accessibility_Registry_getDesktop (
- cspi_registry (), (CORBA_short) i, cspi_ev ()));
+ cspi_registry (), i, cspi_ev ()));
}
/**
desktops = Accessibility_Registry_getDesktopList (cspi_registry (),
cspi_ev ());
- cspi_return_val_if_ev ("getting desktop list", 0);
+ cspi_return_val_if_ev ("getDesktopList", 0);
list = g_new0 (Accessible *, desktops->_length + 1);
}
/**
+ * SPI_KEYSET_ALL_KEYS:
+ * @SPI_KEYSET_ALL_KEYS: A special value for an AccessibleKeySet type, which tacitly
+ * includes all keycodes and keyvals for the specified modifier set.
+ **/
+
+/**
* SPI_registerAccessibleKeystrokeListener:
* @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 #CSPI_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
* Returns: #TRUE if successful, otherwise #FALSE.
**/
SPIBoolean
-SPI_registerAccessibleKeystrokeListener (AccessibleKeystrokeListener *listener,
- AccessibleKeySet *keys,
- AccessibleKeyMaskType modmask,
- AccessibleKeyEventMask eventmask,
+SPI_registerAccessibleKeystrokeListener (AccessibleKeystrokeListener *listener,
+ AccessibleKeySet *keys,
+ AccessibleKeyMaskType modmask,
+ AccessibleKeyEventMask eventmask,
AccessibleKeyListenerSyncType sync_type)
{
- gint i, mask;
+ gint i;
Accessibility_KeySet key_set;
Accessibility_KeyEventTypeSeq key_events;
Accessibility_ControllerEventMask controller_event_mask;
Accessibility_DeviceEventController device_event_controller;
Accessibility_EventListenerMode listener_mode;
+ Accessibility_EventType key_event_types [2];
+ SPIBoolean retval = FALSE;
if (!listener)
{
- return FALSE;
+ return retval;
}
device_event_controller =
key_set._buffer = Accessibility_KeySet_allocbuf (keys->len);
for (i = 0; i < key_set._length; ++i)
{
- /* we overload the keyset long w/keycodes, the - bit acts as a flag */
- key_set._buffer[i] = (keys->keysyms[i]) ? keys->keysyms[i] :
- - keys->keycodes[i];
- /* fprintf (stderr, "key-set %d = %d\n", i, (int) key_set->_buffer[i]); */
+ key_set._buffer[i].keycode = keys->keycodes[i];
+ key_set._buffer[i].keysym = keys->keysyms[i];
+ if (keys->keystrings && keys->keystrings[i])
+ {
+ key_set._buffer[i].keystring = CORBA_string_dup(keys->keystrings[i]);
+ }
+ else
+ {
+ key_set._buffer[i].keystring = CORBA_string_dup("");
+ }
}
}
else
}
/* 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;
+ key_events._buffer = key_event_types;
if (eventmask & SPI_KEY_PRESSED)
{
- key_events._buffer[i++] = Accessibility_KEY_PRESSED;
+ key_events._buffer[i++] = Accessibility_KEY_PRESSED_EVENT;
}
if (eventmask & SPI_KEY_RELEASED)
{
- key_events._buffer[i++] = Accessibility_KEY_RELEASED;
+ key_events._buffer[i++] = Accessibility_KEY_RELEASED_EVENT;
}
key_events._length = i;
listener_mode.global =
(CORBA_boolean) ((sync_type & SPI_KEYLISTENER_ALL_WINDOWS)!=0);
- Accessibility_DeviceEventController_registerKeystrokeListener (
+ retval = Accessibility_DeviceEventController_registerKeystrokeListener (
device_event_controller,
cspi_event_listener_get_corba (listener),
&key_set,
&listener_mode,
cspi_ev ());
+ CORBA_free (key_set._buffer);
+
cspi_return_val_if_ev ("registering keystroke listener", FALSE);
cspi_release_unref (device_event_controller);
- return TRUE;
+ return retval;
}
/**
**/
SPIBoolean
SPI_deregisterAccessibleKeystrokeListener (AccessibleKeystrokeListener *listener,
- AccessibleKeyMaskType modmask)
+ AccessibleKeyMaskType modmask)
{
Accessibility_ControllerEventMask controller_event_mask;
Accessibility_KeySet key_set;
}
/**
+ * 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)
+{
+ Accessibility_DeviceEventController device_event_controller;
+ SPIBoolean retval = FALSE;
+ Accessibility_EventTypeSeq event_types;
+ Accessibility_EventType event_type_buffer[2];
+ gint i;
+
+ 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;
+ }
+ if (eventmask & SPI_BUTTON_RELEASED)
+ {
+ event_types._buffer[i++] = 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);
+
+ return retval;
+}
+
+/**
+ * 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)
+{
+ Accessibility_DeviceEventController device_event_controller;
+ Accessibility_EventTypeSeq event_types;
+ Accessibility_EventType event_type_buff[2];
+
+ 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);
+
+ return TRUE;
+}
+
+/**
* SPI_generateKeyboardEvent:
* @keyval: a long integer indicating the keycode or keysym of the key event
* being synthesized.
+ * @keystring: an (optional) UTF-8 string which, if @keyval is NULL,
+ * indicates a 'composed' keyboard input string which is
+ * being synthesized; this type of keyboard event synthesis does
+ * not emulate hardware keypresses but injects the string
+ * as though a composing input method (such as XIM) were used.
* @synth_type: a #AccessibleKeySynthType flag indicating whether @keyval
* is to be interpreted as a keysym rather than a keycode
* (CSPI_KEYSYM), or whether to synthesize
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 ());
case SPI_KEY_STRING:
keysynth_type = Accessibility_KEY_STRING;
break;
+ default:
+ return FALSE;
}
Accessibility_DeviceEventController_generateKeyboardEvent (device_event_controller,
keyval,
- "",
+ keystring ? keystring : "",
keysynth_type,
cspi_ev ());
* @x: a #long indicating the screen x coordinate of the mouse event.
* @y: a #long indicating the screen y coordinate of the mouse event.
* @name: a string indicating which mouse event to be synthesized
- * (e.g. "button1", "button2", "mousemove").
+ * (e.g. "b1p", "b1c", "b2r", "rel", "abs").
*
* Synthesize a mouse event at a specific screen coordinate.
* Most AT clients should use the #AccessibleAction interface when
* tempted to generate mouse events, rather than this method.
- * Not Yet Implemented.
+ * Event names: b1p = button 1 press; b2r = button 2 release;
+ * b3c = button 3 click; b2d = button 2 double-click;
+ * abs = absolute motion; rel = relative motion.
*
* Returns: #TRUE if successful, otherwise #FALSE.
**/
SPIBoolean
SPI_generateMouseEvent (long x, long y, char *name)
{
- return FALSE;
+ 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);
+
+ return TRUE;
}