2 * AT-SPI - Assistive Technology Service Provider Interface
3 * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
5 * Copyright 2001 Sun Microsystems Inc.
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Library General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Library General Public License for more details.
17 * You should have received a copy of the GNU Library General Public
18 * License along with this library; if not, write to the
19 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 * Boston, MA 02111-1307, USA.
23 /* spi_registry.c: Global functions wrapping the registry */
25 #include <cspi/spi-private.h>
28 * SPI_registerGlobalEventListener:
29 * @listener: the #AccessibleEventListener to be registered against an
31 * @eventType: a character string indicating the type of events for which
32 * notification is requested. Format is
33 * EventClass:major_type:minor_type:detail
34 * where all subfields other than EventClass are optional.
35 * EventClasses include "object", "window", "mouse",
36 * and toolkit events (e.g. "Gtk", "AWT").
37 * Examples: "focus:", "Gtk:GtkWidget:button_press_event".
39 * Legal object event types:
41 * (property change events)
43 * object:property-change
44 * object:property-change:accessible-name
45 * object:property-change:accessible-state
46 * object:property-change:accessible-description
47 * object:property-change:accessible-parent
48 * object:property-change:accessible-value
49 * object:property-change:accessible-role
50 * object:property-change:accessible-table-caption
51 * object:property-change:accessible-table-column-description
52 * object:property-change:accessible-table-column-header
53 * object:property-change:accessible-table-row-description
54 * object:property-change:accessible-table-row-header
55 * object:property-change:accessible-table-summary
57 * (other object events)
59 * object:children-changed
60 * object:visible-data-changed
61 * object:selection-changed
62 * object:text-selection-changed
64 * object:text-caret-moved
66 * object:row-reordered
68 * object:column-inserted
69 * object:column-reordered
70 * object:column-deleted
71 * object:model-changed
73 * NOTE: this string may be UTF-8, but should not contain byte value 56
74 * (ascii ':'), except as a delimiter, since non-UTF-8 string
75 * delimiting functions are used internally.
76 * In general, listening to
77 * toolkit-specific events is not recommended.
79 * Add an in-process callback function to an existing AccessibleEventListener.
81 * Returns: #TRUE if successful, otherwise #FALSE.
84 SPI_registerGlobalEventListener (AccessibleEventListener *listener,
85 const char *eventType)
94 Accessibility_Registry_registerGlobalEventListener (
96 cspi_event_listener_get_corba (listener),
97 eventType, cspi_ev ());
99 retval = !cspi_exception ();
105 * SPI_deregisterGlobalEventListenerAll:
106 * @listener: the #AccessibleEventListener to be registered against
109 * deregisters an AccessibleEventListener from the registry, for all
110 * event types it may be listening to. Use
111 * AccessibleEventListener_unref to release the
112 * listener reference.
114 * Returns: #TRUE if successful, otherwise #FALSE.
117 SPI_deregisterGlobalEventListenerAll (AccessibleEventListener *listener)
124 Accessibility_Registry_deregisterGlobalEventListenerAll (
126 cspi_event_listener_get_corba (listener),
129 return !cspi_exception ();
133 * SPI_deregisterGlobalEventListener:
134 * @listener: the #AccessibleEventListener registered against an event type.
135 * @eventType: a string specifying the event type for which this
136 * listener is to be deregistered.
138 * deregisters an AccessibleEventListener from the registry, for a specific
141 * Returns: #TRUE if successful, otherwise #FALSE.
144 SPI_deregisterGlobalEventListener (AccessibleEventListener *listener,
145 const char *eventType)
152 Accessibility_Registry_deregisterGlobalEventListener (
154 cspi_event_listener_get_corba (listener),
155 (CORBA_char *) eventType, cspi_ev ());
157 return !cspi_exception ();
161 * SPI_getDesktopCount:
163 * Get the number of virtual desktops.
164 * NOTE: currently multiple virtual desktops are not implemented, this
165 * function always returns '1'.
167 * Returns: an integer indicating the number of active virtual desktops.
170 SPI_getDesktopCount ()
174 retval = Accessibility_Registry_getDesktopCount (
175 cspi_registry (), cspi_ev ());
177 cspi_return_val_if_ev ("getDesktopCount", -1);
184 * @i: an integer indicating which of the accessible desktops is to be returned.
186 * Get the virtual desktop indicated by index @i.
187 * NOTE: currently multiple virtual desktops are not implemented, this
188 * function always returns '1'.
190 * Returns: a pointer to the 'i-th' virtual desktop's #Accessible representation.
193 SPI_getDesktop (int i)
195 return cspi_object_add (
196 Accessibility_Registry_getDesktop (
197 cspi_registry (), (CORBA_short) i, cspi_ev ()));
201 * SPI_getDesktopList:
202 * @list: a pointer to an array of #Accessible objects.
204 * Get the list of virtual desktops. On return, @list will point
205 * to a newly-created array of virtual desktop pointers.
206 * It is the responsibility of the caller to free this array when
207 * it is no longer needed.
209 * Not Yet Implemented : this implementation always returns a single
210 * #Accessible desktop.
212 * Returns: an integer indicating how many virtual desktops have been
213 * placed in the list pointed to by parameter @list.
216 SPI_getDesktopList (Accessible **list)
223 * SPI_registerAccessibleKeystrokeListener:
224 * @listener: a pointer to the #AccessibleKeystrokeListener for which
225 * keystroke events are requested.
226 * @keys: a pointer to the #AccessibleKeySet indicating which
227 * keystroke events are requested, or #CSPI_KEYSET_ALL_KEYS.
228 * @modmask: an #AccessibleKeyMaskType mask indicating which
229 * key event modifiers must be set in combination with @keys,
230 * events will only be reported for key events for which all
231 * modifiers in @modmask are set. If you wish to listen for
232 * events with multiple modifier combinations you must call
233 * registerAccessibleKeystrokeListener() once for each combination.
234 * @eventmask: an #AccessibleKeyMaskType mask indicating which
235 * types of key events are requested (#SPI_KEY_PRESSED, etc.).
236 * @sync_type: a #AccessibleKeyListenerSyncType parameter indicating
237 * the behavior of the notification/listener transaction.
239 * Register a listener for keystroke events, either pre-emptively for
240 * all windows (CSPI_KEYLISTENER_ALL_WINDOWS), or
241 * non-preemptively (CSPI_KEYLISTENER_NOSYNC).
242 * ( Other sync_type values may be available in the future.)
244 * Returns: #TRUE if successful, otherwise #FALSE.
247 SPI_registerAccessibleKeystrokeListener (AccessibleKeystrokeListener *listener,
248 AccessibleKeySet *keys,
249 AccessibleKeyMaskType modmask,
250 AccessibleKeyEventMask eventmask,
251 AccessibleKeyListenerSyncType sync_type)
254 Accessibility_KeySet key_set;
255 Accessibility_KeyEventTypeSeq key_events;
256 Accessibility_ControllerEventMask controller_event_mask;
257 Accessibility_DeviceEventController device_event_controller;
264 device_event_controller =
265 Accessibility_Registry_getDeviceEventController (cspi_registry (), cspi_ev ());
267 cspi_return_val_if_ev ("getting event controller", FALSE);
269 /* copy the keyval filter values from the C api into the CORBA KeySet */
272 key_set._length = keys->len;
273 key_set._buffer = Accessibility_KeySet_allocbuf (keys->len);
274 for (i = 0; i < key_set._length; ++i)
276 /* we overload the keyset long w/keycodes, the - bit acts as a flag */
277 key_set._buffer[i] = (keys->keysyms[i]) ? keys->keysyms[i] :
279 /* fprintf (stderr, "key-set %d = %d\n", i, (int) key_set->_buffer[i]); */
285 key_set._buffer = NULL;
288 /* copy the event filter values from the C api into the CORBA KeyEventTypeSeq */
293 if (mask & eventmask)
299 while (mask & 0xFFFF);
301 key_events._buffer = Accessibility_KeyEventTypeSeq_allocbuf (i);
303 if (eventmask & SPI_KEY_PRESSED)
305 key_events._buffer[i++] = Accessibility_KEY_PRESSED;
307 if (eventmask & SPI_KEY_RELEASED)
309 key_events._buffer[i++] = Accessibility_KEY_RELEASED;
311 key_events._length = i;
313 controller_event_mask = (CORBA_unsigned_long) modmask;
315 Accessibility_DeviceEventController_registerKeystrokeListener (
316 device_event_controller,
317 cspi_event_listener_get_corba (listener),
319 controller_event_mask,
321 ((sync_type & SPI_KEYLISTENER_ALL_WINDOWS)!=0) ? CORBA_TRUE : CORBA_FALSE,
324 cspi_return_val_if_ev ("registering keystroke listener", FALSE);
326 cspi_release_unref (device_event_controller);
332 * SPI_deregisterAccessibleKeystrokeListener:
333 * @listener: a pointer to the #AccessibleKeystrokeListener for which
334 * keystroke events are requested.
335 * @modmask: the key modifier mask for which this listener is to be
336 * 'deregistered' (of type #AccessibleeyMaskType).
338 * Removes a keystroke event listener from the registry's listener queue,
339 * ceasing notification of events with modifiers matching @modmask.
341 * Returns: #TRUE if successful, otherwise #FALSE.
344 SPI_deregisterAccessibleKeystrokeListener (AccessibleKeystrokeListener *listener,
345 AccessibleKeyMaskType modmask)
347 Accessibility_ControllerEventMask controller_event_mask;
348 Accessibility_KeySet key_set;
349 Accessibility_KeyEventTypeSeq key_events;
350 Accessibility_DeviceEventController device_event_controller;
357 device_event_controller =
358 Accessibility_Registry_getDeviceEventController (cspi_registry (), cspi_ev ());
360 cspi_return_val_if_ev ("getting keystroke listener", FALSE);
362 controller_event_mask = (CORBA_unsigned_long) modmask;
364 key_events._buffer = NULL;
365 key_events._length = 0;
367 key_set._buffer = NULL;
370 Accessibility_DeviceEventController_deregisterKeystrokeListener (
371 device_event_controller,
372 cspi_event_listener_get_corba (listener),
374 controller_event_mask,
376 (CORBA_boolean) TRUE,
379 cspi_release_unref (device_event_controller);
385 * SPI_generateKeyEvent:
386 * @keyval: a long integer indicating the keycode or keysym of the key event
388 * @synth_type: a #AccessibleKeySynthType flag indicating whether @keyval
389 * is to be interpreted as a keysym rather than a keycode
390 * (CSPI_KEYSYM), or whether to synthesize
391 * SPI_KEY_PRESS, SPI_KEY_RELEASE, or both (SPI_KEY_PRESSRELEASE).
393 * Synthesize a keyboard event (as if a hardware keyboard event occurred in the
394 * current UI context).
396 * Returns: #TRUE if successful, otherwise #FALSE.
399 SPI_generateKeyEvent (long int keyval, AccessibleKeySynthType synth_type)
401 /* TODO: check current modifier status and
402 * send keycode to alter, if necessary
404 Accessibility_DeviceEventController device_event_controller =
405 Accessibility_Registry_getDeviceEventController (cspi_registry (), cspi_ev ());
407 g_print ("keyval %d\n", (int) keyval);
408 cspi_return_val_if_ev ("getting event controller", FALSE);
410 Accessibility_DeviceEventController_generateKeyEvent (device_event_controller,
412 (unsigned long) synth_type,
415 cspi_release_unref (device_event_controller);
421 * SPI_generateMouseEvent:
422 * @x: a #long indicating the screen x coordinate of the mouse event.
423 * @y: a #long indicating the screen y coordinate of the mouse event.
424 * @name: a string indicating which mouse event to be synthesized
425 * (e.g. "button1", "button2", "mousemove").
427 * Synthesize a mouse event at a specific screen coordinate.
428 * Most AT clients should use the #AccessibleAction interface when
429 * tempted to generate mouse events, rather than this method.
430 * Not Yet Implemented.
432 * Returns: #TRUE if successful, otherwise #FALSE.
435 SPI_generateMouseEvent (long x, long y, char *name)