X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;ds=sidebyside;f=cspi%2Fspi_registry.c;h=77341a95e50e9ef32825afdda2b5933e1e708229;hb=5d01be6ec7d2cb2e662c695bd4c28c50ac3f2dab;hp=0f393f233409d6d9ba61a767cbb705b9f558a8d9;hpb=108ea160464d63a407472abf09f3a37631b69f15;p=platform%2Fcore%2Fuifw%2Fat-spi2-atk.git diff --git a/cspi/spi_registry.c b/cspi/spi_registry.c index 0f393f2..77341a9 100644 --- a/cspi/spi_registry.c +++ b/cspi/spi_registry.c @@ -2,7 +2,8 @@ * 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 @@ -42,7 +43,6 @@ * * 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 @@ -56,6 +56,7 @@ * * (other object events) * + * object:state-changed * object:children-changed * object:visible-data-changed * object:selection-changed @@ -69,6 +70,7 @@ * object:column-reordered * object:column-deleted * object:model-changed + * object:active-descendant-changed * * (window events) * @@ -80,8 +82,8 @@ * window:reparent * window:desktop-create * window:desktop-destroy - * window:focus-in - * window:focus-out + * window:activate + * window:deactivate * window:raise * window:lower * window:move @@ -90,6 +92,18 @@ * 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. @@ -104,8 +118,6 @@ SPIBoolean SPI_registerGlobalEventListener (AccessibleEventListener *listener, const char *eventType) { - SPIBoolean retval; - if (!listener) { return FALSE; @@ -116,9 +128,7 @@ SPI_registerGlobalEventListener (AccessibleEventListener *listener, cspi_event_listener_get_corba (listener), eventType, cspi_ev ()); - retval = !cspi_exception (); - - return retval; + return !cspi_exception (); } /** @@ -172,7 +182,7 @@ SPI_deregisterGlobalEventListener (AccessibleEventListener *listener, Accessibility_Registry_deregisterGlobalEventListener ( cspi_registry (), cspi_event_listener_get_corba (listener), - (CORBA_char *) eventType, cspi_ev ()); + eventType, cspi_ev ()); return !cspi_exception (); } @@ -214,7 +224,7 @@ SPI_getDesktop (int i) { return cspi_object_add ( Accessibility_Registry_getDesktop ( - cspi_registry (), (CORBA_short) i, cspi_ev ())); + cspi_registry (), i, cspi_ev ())); } /** @@ -248,7 +258,7 @@ SPI_getDesktopList (Accessible ***desktop_list) 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); @@ -286,11 +296,19 @@ SPI_freeDesktopList (Accessible **desktop_list) } /** + * 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 #SPI_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 @@ -303,29 +321,34 @@ SPI_freeDesktopList (Accessible **desktop_list) * the behavior of the notification/listener transaction. * * Register a listener for keystroke events, either pre-emptively for - * all windows (CSPI_KEYLISTENER_ALL_WINDOWS), or - * non-preemptively (CSPI_KEYLISTENER_NOSYNC). - * ( Other sync_type values may be available in the future.) + * all windows (SPI_KEYLISTENER_ALL_WINDOWS), + * non-preemptively (SPI_KEYLISTENER_NOSYNC), or + * pre-emptively at the toolkit level (SPI_KEYLISTENER_CANCONSUME). + * If ALL_WINDOWS or CANCONSUME are used, the event is consumed + * upon receipt if one of @listener's callbacks returns #TRUE. + * ( Other sync_type values may be available in the future ) * * 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 = @@ -340,10 +363,16 @@ SPI_registerAccessibleKeystrokeListener (AccessibleKeystrokeListener *listener, 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 @@ -353,27 +382,15 @@ SPI_registerAccessibleKeystrokeListener (AccessibleKeystrokeListener *listener, } /* 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; @@ -386,7 +403,7 @@ SPI_registerAccessibleKeystrokeListener (AccessibleKeystrokeListener *listener, 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, @@ -395,11 +412,13 @@ SPI_registerAccessibleKeystrokeListener (AccessibleKeystrokeListener *listener, &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; } /** @@ -416,7 +435,7 @@ SPI_registerAccessibleKeystrokeListener (AccessibleKeystrokeListener *listener, **/ SPIBoolean SPI_deregisterAccessibleKeystrokeListener (AccessibleKeystrokeListener *listener, - AccessibleKeyMaskType modmask) + AccessibleKeyMaskType modmask) { Accessibility_ControllerEventMask controller_event_mask; Accessibility_KeySet key_set; @@ -455,6 +474,113 @@ SPI_deregisterAccessibleKeystrokeListener (AccessibleKeystrokeListener *listener } /** + * 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. @@ -478,11 +604,6 @@ 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 ()); @@ -512,7 +633,7 @@ SPI_generateKeyboardEvent (long int keyval, Accessibility_DeviceEventController_generateKeyboardEvent (device_event_controller, keyval, - "", + keystring ? keystring : "", keysynth_type, cspi_ev ()); @@ -528,18 +649,31 @@ SPI_generateKeyboardEvent (long int keyval, * @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; }