X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=cspi%2Fspi_event.c;h=07feaed43db3922a92507ceb96c4d7528e39a527;hb=5d01be6ec7d2cb2e662c695bd4c28c50ac3f2dab;hp=974ce411a71a0b70a476bb0a6d79cb26d967b8b0;hpb=92458bbffd350b574b27f64a315653c94d847dcf;p=platform%2Fcore%2Fuifw%2Fat-spi2-atk.git diff --git a/cspi/spi_event.c b/cspi/spi_event.c index 974ce41..07feaed 100644 --- a/cspi/spi_event.c +++ b/cspi/spi_event.c @@ -2,8 +2,8 @@ * AT-SPI - Assistive Technology Service Provider Interface * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap) * - * Copyright 2001, 2002 Sun Microsystems Inc., - * Copyright 2001, 2002 Ximian, 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 @@ -24,6 +24,8 @@ #include #include +static GSList *_cspi_event_queue = NULL; + /** * SPI_freeAccessibleKeySet: * @keyset: An AccessibleKeyset to free. @@ -334,9 +336,18 @@ cspi_internal_event_get_text (const InternalEvent *e) 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)) + if (CORBA_TypeCode_equivalent (any->_type, TC_Accessibility_EventDetails, NULL)) + { + Accessibility_EventDetails *details = (Accessibility_EventDetails *)any->_value; + if (CORBA_TypeCode_equal (details->any_data._type, TC_CORBA_string, cspi_ev())) + return CORBA_string_dup (* (char **) (details->any_data._value)); + else + return CORBA_string_dup (""); + return CORBA_string_dup (* (char **) (details->any_data._value)); + } + else if (CORBA_TypeCode_equivalent (any->_type, TC_CORBA_string, NULL)) { - return * (char **) any->_value; + return CORBA_string_dup (* (char **) any->_value); } else { @@ -348,23 +359,191 @@ cspi_internal_event_get_text (const InternalEvent *e) } } -static char * +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 (any->_type == TC_CORBA_Object) - return cspi_object_add (* (CORBA_Object *) any->_value); + if (CORBA_TypeCode_equivalent (any->_type, TC_Accessibility_EventDetails, NULL)) + { + Accessibility_EventDetails *details = (Accessibility_EventDetails *)any->_value; + if (CORBA_TypeCode_equal (details->any_data._type, TC_CORBA_Object, cspi_ev())) + return cspi_object_take (* (CORBA_Object *) (details->any_data._value)); + else + return NULL; + } + else if (CORBA_TypeCode_equal (any->_type, TC_CORBA_Object, cspi_ev())) + return cspi_object_take (* (CORBA_Object *) any->_value); else return NULL; } +static SPIRect * +cspi_internal_event_get_rect (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_Accessibility_EventDetails, NULL)) + { + Accessibility_EventDetails *details = (Accessibility_EventDetails *)any->_value; + SPIRect *rect = g_new (SPIRect, 1); + if (CORBA_TypeCode_equal (details->any_data._type, TC_Accessibility_BoundingBox, cspi_ev())) + { + Accessibility_BoundingBox *bounds = (Accessibility_BoundingBox *) details->any_data._value; + rect->x = bounds->x; + rect->y = bounds->y; + rect->width = bounds->width; + rect->height = bounds->height; + return rect; + } + else + return NULL; + } + if (CORBA_TypeCode_equivalent (any->_type, TC_Accessibility_BoundingBox, NULL)) + { + SPIRect *rect = g_new (SPIRect, 1); + Accessibility_BoundingBox *bounds = (Accessibility_BoundingBox *) any->_value; + rect->x = bounds->x; + rect->y = bounds->y; + rect->width = bounds->width; + rect->height = bounds->height; + return rect; + } + else + { +#ifdef EVENT_CONTEXT_DEBUG + fprintf (stderr, "requested string, TC is not TC_Accessible_RectBounds! (%u)\n", + (unsigned) any->_type); +#endif + return NULL; + } +} + +/** + * AccessibleEvent_getSourceName: + * @e: an #AccessibleEvent to be queried. + * + * Get the 'accessible-name' of the object emitting the event. + * + * Returns: The name of the event source, or NULL if the event source cannot be identified + * or does not report a name. + */ +char* AccessibleEvent_getSourceName (const AccessibleEvent *e) +{ + InternalEvent *ie = (InternalEvent *)e; + CORBA_any *any = ((ie && ie->data) ? (CORBA_any *)ie->data : NULL); + if (any && + CORBA_TypeCode_equivalent (any->_type, + TC_Accessibility_EventDetails, NULL)) + { + Accessibility_EventDetails *details = (Accessibility_EventDetails *) any->_value; + return CORBA_string_dup (details->source_name); + } + else + return NULL; +} + +/** + * AccessibleEvent_getSourceRole: + * @e: an #AccessibleEvent to be queried. + * + * Get the #AccessibleRole of the object emitting the event. + * + * Returns: #AccessibleRole of the event source, or SPI_ROLE_UNKNOWN + * if the event source's role is unknown or unspecified. + * (Some kinds of events, such as 'mouse:' events or + * toolkit events, don't have associated object roles.) + */ +AccessibleRole AccessibleEvent_getSourceRole (const AccessibleEvent *e) +{ + InternalEvent *ie = (InternalEvent *)e; + CORBA_any *any = ((ie && ie->data) ? (CORBA_any *)ie->data : NULL); + if (any && + CORBA_TypeCode_equivalent (any->_type, + TC_Accessibility_EventDetails, NULL)) + { + Accessibility_EventDetails *details = (Accessibility_EventDetails *) any->_value; + return cspi_role_from_spi_role (details->source_role); + } + else + return SPI_ROLE_UNKNOWN; +} + +/** + * AccessibleEvent_getSourceApplication: + * @e: an #AccessibleEvent to be queried. + * + * Get the #Application hosting the object which emitted the event. + * + * Returns: A pointer to the host #Application contining the event source + * component. + */ +AccessibleApplication* AccessibleEvent_getSourceApplication (const AccessibleEvent *e) +{ + InternalEvent *ie = (InternalEvent *)e; + CORBA_any *any = ((ie && ie->data) ? (CORBA_any *)ie->data : NULL); + if (any && + CORBA_TypeCode_equivalent (any->_type, + TC_Accessibility_EventDetails, NULL)) + { + Accessibility_EventDetails *details = (Accessibility_EventDetails *) any->_value; + return cspi_object_take (details->host_application); + } + else + return NULL; +} + +/** + * AccessibleEvent_getSourceDetails: + * @e: an #AccessibleEvent to be queried. + * @name: a pointer to a character string which will point to the name of the event source + * on successful completion of the call. + * @role: a pointer to an #AccessibleRole which will point to the role of the event source + * on successful completion of the call. + * @app: A pointer to an #AccessibleApplication which points to the host application for this event + * on successful completion of the call. + * + * Get the host #Application, "accessible name", and #AccessibleRole + * of the object which emitted the event. + * + * Returns: TRUE if the source details were successfully retrieved, + * FALSE if they were not, either due to error, incomplete data, + * or the fact that the event did not encapsulate the required data. + */ +SPIBoolean AccessibleEvent_getSourceDetails (const AccessibleEvent *e, + char **name, AccessibleRole *role, + AccessibleApplication **app) +{ + InternalEvent *ie = (InternalEvent *)e; + CORBA_any *any = ((ie && ie->data) ? (CORBA_any *)ie->data : NULL); + if (any && + CORBA_TypeCode_equivalent (any->_type, + TC_Accessibility_EventDetails, NULL)) + { + Accessibility_EventDetails *details = (Accessibility_EventDetails *) any->_value; + *name = CORBA_string_dup (details->source_name); + *role = cspi_role_from_spi_role (details->source_role); + *app = cspi_object_take (details->host_application); + return TRUE; + } + else + { + *name = NULL; + *role = SPI_ROLE_UNKNOWN; + *app = NULL; + return FALSE; + } +} /** * AccessibleTextChangedEvent_getChangeString: - * @event: a pointer to the #AccessibleEvent being queried. + * @e: a pointer to the #AccessibleEvent being queried. * * Queries an #AccessibleEvent of type "object:text-changed", * returning the text inserted or deleted. @@ -375,14 +554,49 @@ cspi_internal_event_get_object (const InternalEvent *e) char * AccessibleTextChangedEvent_getChangeString (const AccessibleEvent *e) { - InternalEvent *foo = (InternalEvent *) e; - /* TODO: check the event type? expensive... */ - return cspi_internal_event_get_text (e); + const InternalEvent *foo = (InternalEvent *) e; + /* TODO: check the event type. */ + return cspi_internal_event_get_text (foo); +} + +/** + * AccessibleTextSelectionChangedEvent_getSelectionString: + * @e: 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. */ + return cspi_internal_event_get_text (foo); +} + +/** + * AccessibleWindowEvent_getTitleString: + * @e: 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. */ + return cspi_internal_event_get_text (foo); } /** * AccessibleChildChangedEvent_getChildAccessible: - * @event: a pointer to the #AccessibleEvent being queried. + * @e: a pointer to the #AccessibleEvent being queried. * * Queries an #AccessibleEvent of type "object:children_changed" * to get a reference to the changed #Accessible. @@ -397,7 +611,304 @@ AccessibleTextChangedEvent_getChangeString (const AccessibleEvent *e) Accessible * AccessibleChildChangedEvent_getChildAccessible (const AccessibleEvent *e) { - InternalEvent *foo = (InternalEvent *) e; - return cspi_internal_event_get_object (e); + const InternalEvent *foo = (InternalEvent *) e; + return (Accessible *) cspi_internal_event_get_object (foo); +} + +/** + * AccessibleParentChangedEvent_getParentAccessible: + * @e: 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: + * @e: 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: + * @e: 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: + * @e: 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. */ + return cspi_internal_event_get_text (foo); +} + +/** + * AccessibleTableRowDescriptionChangedEvent_getDescriptionString: + * @e: 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. */ + return cspi_internal_event_get_text (foo); +} + +/** + * AccessibleTableColumnDescriptionChangedEvent_getDescriptionString: + * @e: 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. */ + return cspi_internal_event_get_text (foo); } +/** + * AccessibleDescriptionChangedEvent_getDescriptionString: + * @e: 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. */ + return cspi_internal_event_get_text (foo); +} + +/** + * AccessibleBoundsChangedEvent_getNewBounds: + * @e: a pointer to the #AccessibleEvent being queried. + * + * Queries an #AccessibleEvent of type "object:bounds-changed", + * returning a pointer to an SPIRect structure containing the + * new bounds, or NULL on error. + * The returned structure should be freed with SPI_freeRect when + * the caller has finished referencing it. + * + * @Since: AT-SPI 1.6 + * + * Returns: a pointer to an SPIRect defining the new object bounds. + **/ +SPIRect * +AccessibleBoundsChangedEvent_getNewBounds (const AccessibleEvent *e) +{ + const InternalEvent *foo = (InternalEvent *) e; + /* TODO: check the event type. */ + return cspi_internal_event_get_rect (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_getNameString: + * @e: 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); +} + +/** + * AccessibleEvent_ref: + * @e: a pointer to the #AccessibleEvent being referenced. + * + * Increments by 1 the reference count of the event + * + * Returns: TRUE if the function succeeded; FALSE if the pointer is not a + * valid event. + **/ +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; +} + +/** + * AccessibleEvent_unref: + * @e: a pointer to the #AccessibleEvent being referenced. + * + * Decrements by 1 the reference count of the event. The event is destroyed + * when the reference count recahes zero. + * + **/ +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); + g_free ((gpointer)e->type); + Accessible_unref (e->source); + CORBA_free (event->data); + g_free ((gpointer)e); + } + } + } +}