X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=cspi%2Fspi_registry.c;h=aae9358f83a9c0b2844d33aa8e5ad160202e6a42;hb=d2e4455a1f174f2900ea63b59e9488416e47e32a;hp=dff0c63c3b996384fff00836994e1d90fa93cf6e;hpb=8e873a6ebbed811c4f41cbdddf6e6ba23d6bce0a;p=platform%2Fcore%2Fuifw%2Fat-spi2-atk.git diff --git a/cspi/spi_registry.c b/cspi/spi_registry.c index dff0c63..aae9358 100644 --- a/cspi/spi_registry.c +++ b/cspi/spi_registry.c @@ -20,20 +20,12 @@ * Boston, MA 02111-1307, USA. */ -#include - -/* - * - * Global functions serviced by the registry - * - */ +/* spi_registry.c: Global functions wrapping the registry */ -/* static stuff used only by registry C bindings */ -static GList *key_listeners = NULL; -static Display *display = NULL; +#include /** - * registerGlobalEventListener: + * SPI_registerGlobalEventListener: * @listener: the #AccessibleEventListener to be registered against an * event type. * @eventType: a character string indicating the type of events for which @@ -87,52 +79,58 @@ static Display *display = NULL; * 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 ( - spi_registry (), - (Accessibility_EventListener) - bonobo_object_corba_objref (bonobo_object (listener)), - eventType, - spi_ev ()); + cspi_registry (), + cspi_event_listener_get_corba (listener), + eventType, cspi_ev ()); - retval = !spi_exception (); + retval = !cspi_exception (); return retval; } /** - * 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. + * 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) { + if (!listener) + { + return FALSE; + } + Accessibility_Registry_deregisterGlobalEventListenerAll ( - spi_registry (), - (Accessibility_EventListener) - CORBA_Object_duplicate ( - bonobo_object_corba_objref ( - bonobo_object (listener)), spi_ev ()), - spi_ev ()); - - return !spi_exception (); + 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. @@ -141,42 +139,48 @@ deregisterGlobalEventListenerAll (AccessibleEventListener *listener) * 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 ( - spi_registry (), - (Accessibility_EventListener) - CORBA_Object_duplicate ( - bonobo_object_corba_objref (bonobo_object (listener)), spi_ev ()), - (CORBA_char *) eventType, - spi_ev ()); - - return !spi_exception (); + 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 ( - spi_registry (), spi_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. @@ -184,16 +188,17 @@ getDesktopCount () * 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 spi_object_add (Accessibility_Registry_getDesktop (spi_registry (), (CORBA_short) i, spi_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 @@ -208,38 +213,18 @@ getDesktop (int i) * placed in the list pointed to by parameter @list. **/ int -getDesktopList (Accessible **list) +SPI_getDesktopList (Accessible **list) { *list = NULL; return 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; -} - /** - * registerAccessibleKeystrokeListener: + * 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 #SPI_KEYSET_ALL_KEYS. + * keystroke events are requested, or #CSPI_KEYSET_ALL_KEYS. * @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 @@ -252,79 +237,98 @@ key_event_source_func (void *p) * the behavior of the notification/listener transaction. * * Register a listener for keystroke events, either pre-emptively for - * all windows (SPI_KEYLISTENER_ALL_WINDOWS), or - * non-preemptively (SPI_KEYLISTENER_NOSYNC). + * 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 (spi_registry (), spi_ev ()); - Accessibility_KeySet *key_set = Accessibility_KeySet__alloc(); - Accessibility_KeyEventTypeSeq *key_events = Accessibility_KeyEventTypeSeq__alloc(); - Accessibility_KeystrokeListener spi_listener_corba_ref; - gint i, mask; - Accessibility_DeviceEventController_ref (device_event_controller, spi_ev ()); + gint i, mask; + Accessibility_KeySet key_set; + Accessibility_KeyEventTypeSeq key_events; + Accessibility_ControllerEventMask controller_event_mask; + 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 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] : + 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.value = (CORBA_unsigned_long) modmask; + controller_event_mask.refcount = (CORBA_unsigned_short) 1; - spi_listener_corba_ref = (Accessibility_KeystrokeListener) - CORBA_Object_duplicate (bonobo_object_corba_objref (bonobo_object (listener)), spi_ev ()); - - Accessibility_DeviceEventController_registerKeystrokeListener ( - device_event_controller, - spi_listener_corba_ref, - key_set, - controller_event_mask, - key_events, - (CORBA_boolean) ((sync_type & SPI_KEYLISTENER_ALL_WINDOWS)!=0), - spi_ev ()); + Accessibility_DeviceEventController_registerKeystrokeListener ( + device_event_controller, + cspi_event_listener_get_corba (listener), + &key_set, + &controller_event_mask, + &key_events, + (CORBA_boolean) ((sync_type & SPI_KEYLISTENER_ALL_WINDOWS)!=0), + cspi_ev ()); + + 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 @@ -332,64 +336,88 @@ registerAccessibleKeystrokeListener (AccessibleKeystrokeListener *listener, * * 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 (spi_registry (), spi_ev ()); - Accessibility_KeySet *all_keys = Accessibility_KeySet__alloc(); - Accessibility_KeyEventTypeSeq *key_events = Accessibility_KeyEventTypeSeq__alloc(); - Accessibility_KeystrokeListener spi_listener_corba_ref; - Accessibility_DeviceEventController_unref (device_event_controller, spi_ev ()); - controller_event_mask->value = (CORBA_unsigned_long) modmask; - controller_event_mask->refcount = (CORBA_unsigned_short) 1; - - spi_listener_corba_ref = (Accessibility_KeystrokeListener) - CORBA_Object_duplicate (bonobo_object_corba_objref (bonobo_object (listener)), spi_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.value = (CORBA_unsigned_long) modmask; + controller_event_mask.refcount = (CORBA_unsigned_short) 1; + + key_events._buffer = NULL; + key_events._length = 0; + + key_set._buffer = NULL; + key_set._length = 0; + Accessibility_DeviceEventController_deregisterKeystrokeListener ( - device_event_controller, - spi_listener_corba_ref, - all_keys, - controller_event_mask, - key_events, - (CORBA_boolean) TRUE, - spi_ev ()); + device_event_controller, + cspi_event_listener_get_corba (listener), + &key_set, + &controller_event_mask, + &key_events, + (CORBA_boolean) TRUE, + cspi_ev ()); + + cspi_release_unref (device_event_controller); + + return TRUE; } /** - * generateKeyEvent: + * SPI_generateKeyEvent: * @keyval: a long integer indicating the keycode or keysym of the key event * being synthesized. * @synth_type: a #AccessibleKeySynthType flag indicating whether @keyval * is to be interpreted as a keysym rather than a keycode - * (SPI_KEYSYM), or whether to synthesize + * (CSPI_KEYSYM), or whether to synthesize * SPI_KEY_PRESS, SPI_KEY_RELEASE, or both (SPI_KEY_PRESSRELEASE). * * 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_generateKeyEvent (long int keyval, AccessibleKeySynthType synth_type) { /* TODO: check current modifier status and * send keycode to alter, if necessary */ Accessibility_DeviceEventController device_event_controller = - Accessibility_Registry_getDeviceEventController (spi_registry (), spi_ev ()); + Accessibility_Registry_getDeviceEventController (cspi_registry (), cspi_ev ()); + + cspi_return_val_if_ev ("getting event controller", FALSE); + Accessibility_DeviceEventController_generateKeyEvent (device_event_controller, keyval, (unsigned long) synth_type, - spi_ev ()); + cspi_ev ()); + + 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 @@ -400,10 +428,11 @@ generateKeyEvent (long int keyval, AccessibleKeySynthType synth_type) * 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; }