X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=cspi%2Fspi_event.c;h=215fdde892a673f772b07ca7c7c19bb1b6aa7c18;hb=b1419354d8c2b37d43601cd2f7ad4579ec10a5fa;hp=8550a9a0bb3ec6f000dba3c244f2aa395f2db860;hpb=0cd076473b00a6ef39eebaf1fc8800fef48a49fb;p=platform%2Fcore%2Fuifw%2Fat-spi2-atk.git diff --git a/cspi/spi_event.c b/cspi/spi_event.c index 8550a9a..215fdde 100644 --- a/cspi/spi_event.c +++ b/cspi/spi_event.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, 2003 Sun Microsystems Inc., + * Copyright 2001, 2002, 2003 Ximian, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public @@ -21,8 +22,9 @@ */ #include +#include - +static GSList *_cspi_event_queue = NULL; /** * SPI_freeAccessibleKeySet: @@ -69,7 +71,8 @@ SPI_freeAccessibleKeySet (AccessibleKeySet *keyset) * **/ AccessibleKeySet * -SPI_createAccessibleKeySet (int len, const char *keysyms, short *keycodes, const char **keystrings) +SPI_createAccessibleKeySet (int len, const char *keysyms, short *keycodes, + const char **keystrings) { AccessibleKeySet *keyset = g_new0 (AccessibleKeySet, 1); int i, keysym_len = 0; @@ -93,8 +96,14 @@ SPI_createAccessibleKeySet (int len, const char *keysyms, short *keycodes, const { keyset->keysyms [i] = 0; } - if (keycodes) keyset->keycodes [i] = keycodes [i]; - if (keystrings) keyset->keystrings [i] = keystrings [i]; + if (keycodes) + { + keyset->keycodes [i] = keycodes [i]; + } + if (keystrings) + { + keyset->keystrings [i] = g_strdup (keystrings [i]); + } } return keyset; } @@ -177,7 +186,7 @@ AccessibleEventListener_removeCallback (AccessibleEventListener *listener, } /** - * createAccessibleKeystrokeListener: + * SPI_createAccessibleKeystrokeListener: * @callback : an #AccessibleKeystrokeListenerCB callback function, or NULL. * @user_data: a pointer to data which will be passed to the callback when invoked. * @@ -190,10 +199,10 @@ AccessibleKeystrokeListener * SPI_createAccessibleKeystrokeListener (AccessibleKeystrokeListenerCB callback, void *user_data) { - AccessibleKeystrokeListener *listener = cspi_keystroke_listener_new (); + AccessibleDeviceListener *listener = cspi_device_listener_new (); if (callback) { - AccessibleKeystrokeListener_addCallback (listener, callback, user_data); + AccessibleDeviceListener_addCallback (listener, callback, user_data); } return listener; } @@ -214,7 +223,7 @@ AccessibleKeystrokeListener_addCallback (AccessibleKeystrokeListener *listener, AccessibleKeystrokeListenerCB callback, void *user_data) { - cspi_keystroke_listener_add_cb (listener, callback, user_data); + cspi_device_listener_add_cb (listener, callback, user_data); return TRUE; } @@ -232,7 +241,7 @@ SPIBoolean AccessibleKeystrokeListener_removeCallback (AccessibleKeystrokeListener *listener, AccessibleKeystrokeListenerCB callback) { - cspi_keystroke_listener_remove_cb (listener, callback); + cspi_device_listener_remove_cb (listener, callback); return TRUE; } @@ -245,5 +254,440 @@ AccessibleKeystrokeListener_removeCallback (AccessibleKeystrokeListener *listene void AccessibleKeystrokeListener_unref (AccessibleKeystrokeListener *listener) { - cspi_keystroke_listener_unref (listener); + cspi_device_listener_unref (listener); +} + +/** + * SPI_createAccessibleDeviceListener: + * @callback : an #AccessibleDeviceListenerCB callback function, or NULL. + * @user_data: a pointer to data which will be passed to the callback when invoked. + * + * Create a new #AccessibleDeviceListener with a specified callback function. + * + * Returns: a pointer to a newly-created #AccessibleDeviceListener. + * + **/ +AccessibleDeviceListener * +SPI_createAccessibleDeviceListener (AccessibleDeviceListenerCB callback, + void *user_data) +{ + AccessibleDeviceListener *listener = cspi_device_listener_new (); + if (callback) + { + AccessibleDeviceListener_addCallback (listener, callback, user_data); + } + return listener; +} + +/** + * AccessibleDeviceListener_addCallback: + * @listener: the #AccessibleDeviceListener instance to modify. + * @callback: an #AccessibleDeviceListenerCB function pointer. + * @user_data: a pointer to data which will be passed to the callback when invoked. + * + * Add an in-process callback function to an existing #AccessibleDeviceListener. + * + * Returns: #TRUE if successful, otherwise #FALSE. + * + **/ +SPIBoolean +AccessibleDeviceListener_addCallback (AccessibleDeviceListener *listener, + AccessibleDeviceListenerCB callback, + void *user_data) +{ + cspi_device_listener_add_cb (listener, callback, user_data); + return TRUE; +} + +/** + * AccessibleDeviceListener_removeCallback: + * @listener: the #AccessibleDeviceListener instance to modify. + * @callback: an #AccessibleDeviceListenerCB function pointer. + * + * Remove an in-process callback function from an existing #AccessibleDeviceListener. + * + * Returns: #TRUE if successful, otherwise #FALSE. + * + **/ +SPIBoolean +AccessibleDeviceListener_removeCallback (AccessibleDeviceListener *listener, + AccessibleDeviceListenerCB callback) +{ + cspi_device_listener_remove_cb (listener, callback); + return TRUE; +} + +/** + * AccessibleDeviceListener_unref: + * @listener: a pointer to the #AccessibleDeviceListener being operated on. + * + * Decrements an #AccessibleDeviceListener's reference count. + **/ +void +AccessibleDeviceListener_unref (AccessibleDeviceListener *listener) +{ + cspi_device_listener_unref (listener); +} + +static char * +cspi_internal_event_get_text (const InternalEvent *e) +{ + CORBA_any *any; + g_return_val_if_fail (e, NULL); + g_return_val_if_fail (e->data, NULL); + any = (CORBA_any *) e->data; + if (CORBA_TypeCode_equivalent (any->_type, TC_CORBA_string, NULL)) + { + return CORBA_string_dup (* (char **) any->_value); + } + else + { +#ifdef EVENT_CONTEXT_DEBUG + fprintf (stderr, "requested string, TC is not TC_CORBA_string! (%u)\n", + (unsigned) any->_type); +#endif + return NULL; + } +} + +static Accessible * +cspi_internal_event_get_object (const InternalEvent *e) +{ + CORBA_any *any; + + g_return_val_if_fail (e, NULL); + g_return_val_if_fail (e->data, NULL); + + any = (CORBA_any *) e->data; + if (CORBA_TypeCode_equal (any->_type, TC_CORBA_Object, cspi_ev())) + return cspi_object_take (* (CORBA_Object *) any->_value); + else + return NULL; +} + +/** + * AccessibleTextChangedEvent_getChangeString: + * @e: a pointer to the #AccessibleEvent being queried. + * + * Queries an #AccessibleEvent of type "object:text-changed", + * returning the text inserted or deleted. + * + * Returns: a UTF-8 text string indicating the text inserted, + * deleted, or substituted by this event. + **/ +char * +AccessibleTextChangedEvent_getChangeString (const AccessibleEvent *e) +{ + const InternalEvent *foo = (InternalEvent *) e; + /* TODO: check the event type? expensive... */ + return cspi_internal_event_get_text (foo); +} + +/** + * AccessibleTextSelectionChangedEvent_getSelectionString: + * @event: a pointer to the #AccessibleEvent being queried. + * + * Queries an #AccessibleEvent of type "object:text-selection-changed", + * returning the newly added, removed, or modified selection string. + * + * Returns: a UTF-8 text string indicating the recently changed selection. + **/ +char * +AccessibleTextSelectionChangedEvent_getSelectionString (const AccessibleEvent *e) +{ + const InternalEvent *foo = (InternalEvent *) e; + /* TODO: check the event type? expensive... */ + return cspi_internal_event_get_text (foo); +} + +/** + * AccessibleWindowEvent_getTitleString: + * @event: a pointer to the #AccessibleEvent being queried. + * + * Queries an #AccessibleEvent of type "window:", + * returning the window title. + * + * Returns: a UTF-8 text string representing the title of the + * recently changed window. + **/ +char * +AccessibleWindowEvent_getTitleString (const AccessibleEvent *e) +{ + const InternalEvent *foo = (InternalEvent *) e; + /* TODO: check the event type? expensive... */ + return cspi_internal_event_get_text (foo); +} + +/** + * AccessibleChildChangedEvent_getChildAccessible: + * @event: a pointer to the #AccessibleEvent being queried. + * + * Queries an #AccessibleEvent of type "object:children_changed" + * to get a reference to the changed #Accessible. + * Note that context #Accessibles are not guaranteed to outlive + * event delivery, in which case this call may return %NULL + * even if the object existed at the time of dispatch. + * + * Returns: the context #Accessible for the event, or %NULL if + * there is no longer a valid context #Accessible + * object for the event. + **/ +Accessible * +AccessibleChildChangedEvent_getChildAccessible (const AccessibleEvent *e) +{ + const InternalEvent *foo = (InternalEvent *) e; + return (Accessible *) cspi_internal_event_get_object (foo); +} + +/** + * AccessibleParentChangedEvent_getParentAccessible: + * @event: a pointer to the #AccessibleEvent being queried. + * + * Queries an #AccessibleEvent of type "object:property-change:accessible-parent" + * to get a reference to the changed #Accessible. + * Note that context #Accessibles are not guaranteed to outlive + * event delivery, in which case this call may return %NULL + * even if the object existed at the time of dispatch. + * + * Returns: an #Accessible pointer representing the new parent object. + **/ +Accessible * +AccessibleParentChangedEvent_getParentAccessible (const AccessibleEvent *e) +{ + const InternalEvent *foo = (InternalEvent *) e; + return (Accessible *) cspi_internal_event_get_object (foo); +} + +/** + * AccessibleActiveDescendantChangedEvent_getActiveDescendant: + * @event: a pointer to the #AccessibleEvent being queried. + * + * Queries an #AccessibleEvent of type "object:active-descendant-changed" + * to get a reference to the changed #Accessible. + * Note that context #Accessibles are not guaranteed to outlive + * event delivery, in which case this call may return %NULL + * even if the object existed at the time of dispatch. + * + * Returns: an #Accessible pointer representing the new active descendant. + **/ +Accessible * +AccessibleActiveDescendantChangedEvent_getActiveDescendant (const AccessibleEvent *e) +{ + const InternalEvent *foo = (InternalEvent *) e; + return (Accessible *) cspi_internal_event_get_object (foo); +} + +/** + * AccessibleTableSummaryChangedEvent_getSummaryAccessible: + * @event: a pointer to the #AccessibleEvent being queried. + * + * Queries an #AccessibleEvent of type "object:property-changed:accessible-table-summary" + * to get a reference to the changed #Accessible. + * Note that context #Accessibles are not guaranteed to outlive + * event delivery, in which case this call may return %NULL + * even if the object existed at the time of dispatch. + * + * Returns: an #Accessible pointer representing the new table summary. + **/ +Accessible * +AccessibleTableSummaryChangedEvent_getSummaryAccessible (const AccessibleEvent *e) +{ + const InternalEvent *foo = (InternalEvent *) e; + return (Accessible *) cspi_internal_event_get_object (foo); +} + +/** + * AccessibleTableHeaderChangedEvent_getHeaderAccessible: + * @event: a pointer to the #AccessibleEvent being queried. + * + * Queries an #AccessibleEvent of type + * "object:property-changed:accessible-table-row-header" or + * "object:property-changed:accessible-table-column-header" + * to get a reference to the changed #Accessible. + * Note that context #Accessibles are not guaranteed to outlive + * event delivery, in which case this call may return %NULL + * even if the object existed at the time of dispatch. + * + * Returns: an #Accessible pointer representing the new table header. + **/ +Accessible * +AccessibleTableHeaderChangedEvent_getHeaderAccessible (const AccessibleEvent *e) +{ + const InternalEvent *foo = (InternalEvent *) e; + return (Accessible *) cspi_internal_event_get_object (foo); +} + + +/** + * AccessibleTableCaptionChangedEvent_getCaptionString: + * @e: a pointer to the #AccessibleEvent being queried. + * + * Queries an #AccessibleEvent of type + * "object:property-changed:accessible-table-caption-object" + * returning the text in the caption, if present. + * + * Returns: a UTF-8 text string indicating the text in the caption. + **/ +char * +AccessibleTableCaptionChangedEvent_getCaptionString (const AccessibleEvent *e) +{ + const InternalEvent *foo = (InternalEvent *) e; + /* TODO: check the event type? expensive... */ + return cspi_internal_event_get_text (foo); +} + +/** + * AccessibleTableRowDescriptionEvent_getDescriptionString: + * @event: a pointer to the #AccessibleEvent being queried. + * + * Queries an #AccessibleEvent of type + * "object:property-changed:accessible-table-row-description" + * returning the new table row description. + * + * Returns: a UTF-8 text string representing the recently changed + * table row description + **/ +char * +AccessibleTableRowDescriptionChangedEvent_getDescriptionString (const AccessibleEvent *e) +{ + const InternalEvent *foo = (InternalEvent *) e; + /* TODO: check the event type? expensive... */ + return cspi_internal_event_get_text (foo); +} + +/** + * AccessibleTableColumnDescriptionEvent_getDescriptionString: + * @event: a pointer to the #AccessibleEvent being queried. + * + * Queries an #AccessibleEvent of type + * "object:property-changed:accessible-table-column-description" + * returning the new table column description. + * + * Returns: a UTF-8 text string representing the recently changed + * table column description + **/ +char * +AccessibleTableColumnDescriptionChangedEvent_getDescriptionString (const AccessibleEvent *e) +{ + const InternalEvent *foo = (InternalEvent *) e; + /* TODO: check the event type? expensive... */ + return cspi_internal_event_get_text (foo); +} + +/** + * AccessibleDescriptionEvent_getDescriptionString: + * @event: a pointer to the #AccessibleEvent being queried. + * + * Queries an #AccessibleEvent of type + * "object:property-changed:accessible-description" + * returning the new description. + * + * Returns: a UTF-8 text string representing the recently changed + * description + **/ +char * +AccessibleDescriptionChangedEvent_getDescriptionString (const AccessibleEvent *e) +{ + const InternalEvent *foo = (InternalEvent *) e; + /* TODO: check the event type? expensive... */ + return cspi_internal_event_get_text (foo); +} + +static gint +cspi_event_compare (gconstpointer p1, gconstpointer p2) +{ + const InternalEvent *e1 = p1, *e2 = p2; + return (gint) ((long) e2->id - (long) e1->id); +} + +static InternalEvent * +cspi_internal_event_lookup (const InternalEvent *e) +{ + InternalEvent *internal = NULL; + GSList *p = + g_slist_find_custom (_cspi_event_queue, e, cspi_event_compare); + if (p) + internal = p->data; + return internal; +} + +static const InternalEvent * +cspi_internal_event_check (const AccessibleEvent *e) +{ + InternalEvent *internal = (InternalEvent *) e; + if (internal->magic == SPI_INTERNAL_EVENT_MAGIC) + return internal; + else + return NULL; +} + +static InternalEvent * +cspi_internal_event_add (const InternalEvent *e) +{ + _cspi_event_queue = g_slist_prepend (_cspi_event_queue, (gpointer) e); + return (InternalEvent *) e; +} + +static void +cspi_internal_event_remove (const InternalEvent *e) +{ + GSList *link = g_slist_find_custom (_cspi_event_queue, e, cspi_event_compare); + if (link) + _cspi_event_queue = g_slist_remove_link (_cspi_event_queue, link); +} + +/** + * AccessibleNameChangedEvent_getNametring: + * @event: a pointer to the #AccessibleEvent being queried. + * + * Queries an #AccessibleEvent of type "object:property-change:accessible_name:", + * returning the name. + * + * Returns: a UTF-8 text string representing the name of the + * object which recently changed. + **/ +char * +AccessibleNameChangedEvent_getNameString (const AccessibleEvent *e) +{ + const InternalEvent *foo = (InternalEvent *) e; + return cspi_internal_event_get_text (foo); +} + +SPIBoolean +AccessibleEvent_ref (const AccessibleEvent *e) +{ + const InternalEvent *private = cspi_internal_event_check (e); + if (private) + { + InternalEvent *event = cspi_internal_event_lookup (private); + /* + * put event in the cache if it's not there already, + * and increment refcount + */ + if (!event) + { + event = cspi_internal_event_add (private); + } + event->ref_count++; + return TRUE; + } + else + return FALSE; +} + +void +AccessibleEvent_unref (const AccessibleEvent *e) +{ + const InternalEvent *private = cspi_internal_event_check (e); + /* decrement refcount and remove if appropriate */ + if (private) + { + InternalEvent *event = cspi_internal_event_lookup (private); + if (event) + { + event->ref_count--; + if (event->ref_count < 1) + cspi_internal_event_remove (event); + } + } }