* Boston, MA 02111-1307, USA.
*/
-#include <cspi/spi-private.h>
-
-/*
- *
- * Global functions serviced by the registry
- *
- */
+/* spi_registry.c: Global functions wrapping the registry */
-#if 0
-/* static stuff used only by registry C bindings */
-static GList *key_listeners = NULL;
-static Display *display = NULL;
-#endif
+#include <cspi/spi-private.h>
/**
- * registerGlobalEventListener:
+ * SPI_registerGlobalEventListener:
* @listener: the #AccessibleEventListener to be registered against an
* event type.
* @eventType: a character string indicating the type of events for which
* 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:focus-in
+ * window:focus-out
+ * 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.
* Add an in-process callback function to an existing AccessibleEventListener.
*
* Returns: #TRUE if successful, otherwise #FALSE.
- *
**/
-boolean
-registerGlobalEventListener (AccessibleEventListener *listener,
- char *eventType)
+SPIBoolean
+SPI_registerGlobalEventListener (AccessibleEventListener *listener,
+ const char *eventType)
{
- boolean retval;
+ SPIBoolean retval;
+
+ if (!listener)
+ {
+ return FALSE;
+ }
Accessibility_Registry_registerGlobalEventListener (
- cspi_registry (),
- (Accessibility_EventListener)
- bonobo_object_corba_objref (bonobo_object (listener)),
- eventType,
- cspi_ev ());
+ cspi_registry (),
+ cspi_event_listener_get_corba (listener),
+ eventType, cspi_ev ());
retval = !cspi_exception ();
}
/**
- * deregisterGlobalEventListenerAll:
+ * 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. Also unrefs the listener.
- * The listener cannot subsequently be reused.
+ * event types it may be listening to. Use
+ * AccessibleEventListener_unref to release the
+ * listener reference.
*
* Returns: #TRUE if successful, otherwise #FALSE.
- *
**/
-boolean
-deregisterGlobalEventListenerAll (AccessibleEventListener *listener)
+SPIBoolean
+SPI_deregisterGlobalEventListenerAll (AccessibleEventListener *listener)
{
- Accessibility_Registry_deregisterGlobalEventListenerAll (
- cspi_registry (),
- (Accessibility_EventListener)
- CORBA_Object_duplicate (
- bonobo_object_corba_objref (
- bonobo_object (listener)), cspi_ev ()),
- cspi_ev ());
- if (!cspi_exception ())
+ if (!listener)
{
- bonobo_object_unref (BONOBO_OBJECT (listener));
- /* Would prefer that this were not a bonobo object: g_object_unref (listener);*/
+ return FALSE;
}
+ Accessibility_Registry_deregisterGlobalEventListenerAll (
+ cspi_registry (),
+ cspi_event_listener_get_corba (listener),
+ cspi_ev ());
+
return !cspi_exception ();
}
+
/**
- * deregisterGlobalEventListener:
+ * 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.
* event type.
*
* Returns: #TRUE if successful, otherwise #FALSE.
- *
**/
-boolean
-deregisterGlobalEventListener (AccessibleEventListener *listener,
- char *eventType)
+SPIBoolean
+SPI_deregisterGlobalEventListener (AccessibleEventListener *listener,
+ const char *eventType)
{
+ if (!listener)
+ {
+ return FALSE;
+ }
+
Accessibility_Registry_deregisterGlobalEventListener (
- cspi_registry (),
- (Accessibility_EventListener)
- CORBA_Object_duplicate (
- bonobo_object_corba_objref (bonobo_object (listener)), cspi_ev ()),
- (CORBA_char *) eventType,
- cspi_ev ());
+ cspi_registry (),
+ cspi_event_listener_get_corba (listener),
+ (CORBA_char *) eventType, cspi_ev ());
return !cspi_exception ();
}
/**
- * getDesktopCount:
+ * SPI_getDesktopCount:
*
* Get the number of virtual desktops.
* NOTE: currently multiple virtual desktops are not implemented, this
* function always returns '1'.
*
* Returns: an integer indicating the number of active virtual desktops.
- *
**/
int
-getDesktopCount ()
+SPI_getDesktopCount ()
{
- return Accessibility_Registry_getDesktopCount (cspi_registry (), cspi_ev ());
+ int retval;
+
+ retval = Accessibility_Registry_getDesktopCount (
+ cspi_registry (), cspi_ev ());
+
+ cspi_return_val_if_ev ("getDesktopCount", -1);
+
+ return retval;
}
/**
- * getDesktop:
+ * SPI_getDesktop:
* @i: an integer indicating which of the accessible desktops is to be returned.
*
* Get the virtual desktop indicated by index @i.
* function always returns '1'.
*
* Returns: a pointer to the 'i-th' virtual desktop's #Accessible representation.
- *
**/
Accessible*
-getDesktop (int i)
+SPI_getDesktop (int i)
{
- return cspi_object_add (Accessibility_Registry_getDesktop (cspi_registry (),
- (CORBA_short) i,
- cspi_ev ()));
+ return cspi_object_add (
+ Accessibility_Registry_getDesktop (
+ cspi_registry (), (CORBA_short) i, cspi_ev ()));
}
/**
- * getDesktopList:
+ * SPI_getDesktopList:
* @list: a pointer to an array of #Accessible objects.
*
* Get the list of virtual desktops. On return, @list will point
* placed in the list pointed to by parameter @list.
**/
int
-getDesktopList (Accessible **list)
+SPI_getDesktopList (Accessible **list)
{
*list = NULL;
return 0;
}
-#if 0
-static gboolean
-key_event_source_func (void *p)
-{
- GList *listeners = (GList *)p;
- XEvent *x_event = g_new0 (XEvent, 1);
- while (XPending (display))
- {
- XNextEvent (display, x_event);
- while (listeners)
- {
- /* if the listener mask matches, notify it*/
- if (1)
- {
- ;
- }
- }
- }
- return TRUE;
-}
-#endif
-
/**
- * registerAccessibleKeystrokeListener:
+ * SPI_registerAccessibleKeystrokeListener:
* @listener: a pointer to the #AccessibleKeystrokeListener for which
* keystroke events are requested.
* @keys: a pointer to the #AccessibleKeySet indicating which
* all windows (CSPI_KEYLISTENER_ALL_WINDOWS), or
* non-preemptively (CSPI_KEYLISTENER_NOSYNC).
* ( Other sync_type values may be available in the future.)
+ *
+ * Returns: #TRUE if successful, otherwise #FALSE.
**/
-void
-registerAccessibleKeystrokeListener (AccessibleKeystrokeListener *listener,
- AccessibleKeySet *keys,
- AccessibleKeyMaskType modmask,
- AccessibleKeyEventMask eventmask,
- AccessibleKeyListenerSyncType sync_type)
+SPIBoolean
+SPI_registerAccessibleKeystrokeListener (AccessibleKeystrokeListener *listener,
+ AccessibleKeySet *keys,
+ AccessibleKeyMaskType modmask,
+ AccessibleKeyEventMask eventmask,
+ AccessibleKeyListenerSyncType sync_type)
{
- Accessibility_ControllerEventMask *controller_event_mask =
- Accessibility_ControllerEventMask__alloc();
- Accessibility_DeviceEventController device_event_controller =
- Accessibility_Registry_getDeviceEventController (cspi_registry (), cspi_ev ());
- Accessibility_KeySet *key_set = Accessibility_KeySet__alloc();
- Accessibility_KeyEventTypeSeq *key_events = Accessibility_KeyEventTypeSeq__alloc();
- Accessibility_KeystrokeListener cspi_listener_corba_ref;
- gint i, mask;
- Accessibility_DeviceEventController_ref (device_event_controller, cspi_ev ());
+ gint i, mask;
+ Accessibility_KeySet key_set;
+ Accessibility_KeyEventTypeSeq key_events;
+ Accessibility_ControllerEventMask controller_event_mask;
+ Accessibility_DeviceEventController device_event_controller;
+ Accessibility_EventListenerMode listener_mode;
+
+ if (!listener)
+ {
+ return FALSE;
+ }
+
+ 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 */
if (keys)
{
- key_set->_buffer = Accessibility_KeySet_allocbuf (
- (unsigned long) keys->len);
- key_set->_length = (unsigned long) keys->len;
- for (i=0; i < key_set->_length; ++i)
+ key_set._length = keys->len;
+ 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];
- /* g_print ("key-set %d = %d\n", i, (int) key_set->_buffer[i]); */
+ 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]); */
}
}
+ else
+ {
+ key_set._length = 0;
+ key_set._buffer = NULL;
+ }
+
/* copy the event filter values from the C api into the CORBA KeyEventTypeSeq */
- mask=1;
- i=0;
+ mask = 1;
+ i = 0;
do
{
- if (mask & eventmask) ++i;
+ if (mask & eventmask)
+ {
+ ++i;
+ }
mask <<= 1;
- } while (mask & 0xFFFF);
+ }
+ while (mask & 0xFFFF);
- key_events->_buffer = Accessibility_KeyEventTypeSeq_allocbuf (i);
- i=0;
+ key_events._buffer = Accessibility_KeyEventTypeSeq_allocbuf (i);
+ i = 0;
if (eventmask & SPI_KEY_PRESSED)
{
- key_events->_buffer[i++] = Accessibility_KEY_PRESSED;
+ key_events._buffer[i++] = Accessibility_KEY_PRESSED;
}
if (eventmask & SPI_KEY_RELEASED)
{
- key_events->_buffer[i++] = Accessibility_KEY_RELEASED;
+ key_events._buffer[i++] = Accessibility_KEY_RELEASED;
}
- key_events->_length = i;
+ key_events._length = i;
- controller_event_mask->value = (CORBA_unsigned_long) modmask;
- controller_event_mask->refcount = (CORBA_unsigned_short) 1;
+ controller_event_mask = (CORBA_unsigned_long) modmask;
- cspi_listener_corba_ref = (Accessibility_KeystrokeListener)
- CORBA_Object_duplicate (bonobo_object_corba_objref (bonobo_object (listener)), cspi_ev ());
-
- Accessibility_DeviceEventController_registerKeystrokeListener (
- device_event_controller,
- cspi_listener_corba_ref,
- key_set,
- controller_event_mask,
- key_events,
- (CORBA_boolean) ((sync_type & SPI_KEYLISTENER_ALL_WINDOWS)!=0),
- cspi_ev ());
+ listener_mode.synchronous =
+ (CORBA_boolean) ((sync_type & SPI_KEYLISTENER_SYNCHRONOUS)!=0);
+ listener_mode.preemptive =
+ (CORBA_boolean) ((sync_type & SPI_KEYLISTENER_CANCONSUME)!=0);
+ listener_mode.global =
+ (CORBA_boolean) ((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 ());
+
+ cspi_return_val_if_ev ("registering keystroke listener", FALSE);
+
+ cspi_release_unref (device_event_controller);
+
+ return TRUE;
}
/**
- * deregisterAccessibleKeystrokeListener:
+ * SPI_deregisterAccessibleKeystrokeListener:
* @listener: a pointer to the #AccessibleKeystrokeListener for which
* keystroke events are requested.
* @modmask: the key modifier mask for which this listener is to be
*
* Removes a keystroke event listener from the registry's listener queue,
* ceasing notification of events with modifiers matching @modmask.
+ *
+ * Returns: #TRUE if successful, otherwise #FALSE.
**/
-void
-deregisterAccessibleKeystrokeListener (AccessibleKeystrokeListener *listener,
- AccessibleKeyMaskType modmask)
+SPIBoolean
+SPI_deregisterAccessibleKeystrokeListener (AccessibleKeystrokeListener *listener,
+ AccessibleKeyMaskType modmask)
{
- Accessibility_ControllerEventMask *controller_event_mask =
- Accessibility_ControllerEventMask__alloc();
- Accessibility_DeviceEventController device_event_controller =
- Accessibility_Registry_getDeviceEventController (cspi_registry (), cspi_ev ());
- Accessibility_KeySet *all_keys = Accessibility_KeySet__alloc();
- Accessibility_KeyEventTypeSeq *key_events = Accessibility_KeyEventTypeSeq__alloc();
- Accessibility_KeystrokeListener cspi_listener_corba_ref;
- Accessibility_DeviceEventController_unref (device_event_controller, cspi_ev ());
- controller_event_mask->value = (CORBA_unsigned_long) modmask;
- controller_event_mask->refcount = (CORBA_unsigned_short) 1;
-
- cspi_listener_corba_ref = (Accessibility_KeystrokeListener)
- CORBA_Object_duplicate (BONOBO_OBJREF(listener), cspi_ev ());
-
+ Accessibility_ControllerEventMask controller_event_mask;
+ Accessibility_KeySet key_set;
+ Accessibility_KeyEventTypeSeq key_events;
+ Accessibility_DeviceEventController device_event_controller;
+
+ 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_listener_corba_ref,
- all_keys,
- controller_event_mask,
- key_events,
- (CORBA_boolean) TRUE,
- cspi_ev ());
+ device_event_controller,
+ cspi_event_listener_get_corba (listener),
+ &key_set,
+ controller_event_mask,
+ &key_events,
+ cspi_ev ());
+
+ cspi_release_unref (device_event_controller);
+
+ return TRUE;
}
/**
- * generateKeyEvent:
+ * SPI_generateKeyboardEvent:
* @keyval: a long integer indicating the keycode or keysym of the key event
* being synthesized.
* @synth_type: a #AccessibleKeySynthType flag indicating whether @keyval
* Synthesize a keyboard event (as if a hardware keyboard event occurred in the
* current UI context).
*
+ * Returns: #TRUE if successful, otherwise #FALSE.
**/
-void
-generateKeyEvent (long int keyval, AccessibleKeySynthType synth_type)
+SPIBoolean
+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 ());
- Accessibility_DeviceEventController_generateKeyEvent (device_event_controller,
- keyval,
- (unsigned long) synth_type,
- cspi_ev ());
+
+ cspi_return_val_if_ev ("getting event controller for key event gen", FALSE);
+
+ switch (synth_type)
+ {
+ case SPI_KEY_PRESS:
+ keysynth_type = Accessibility_KEY_PRESS;
+ break;
+ case SPI_KEY_RELEASE:
+ keysynth_type = Accessibility_KEY_RELEASE;
+ break;
+ case SPI_KEY_PRESSRELEASE:
+ keysynth_type = Accessibility_KEY_PRESSRELEASE;
+ break;
+ case SPI_KEY_SYM:
+ keysynth_type = Accessibility_KEY_SYM;
+ break;
+ case SPI_KEY_STRING:
+ keysynth_type = Accessibility_KEY_STRING;
+ break;
+ }
+
+ 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);
+
+ return TRUE;
}
/**
- * generateMouseEvent:
+ * SPI_generateMouseEvent:
* @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
* tempted to generate mouse events, rather than this method.
* Not Yet Implemented.
*
+ * Returns: #TRUE if successful, otherwise #FALSE.
**/
-void
-generateMouseEvent (long x, long y, char *name)
+SPIBoolean
+SPI_generateMouseEvent (long x, long y, char *name)
{
- ;
+ return FALSE;
}