X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=cspi%2Fspi_event.c;h=07feaed43db3922a92507ceb96c4d7528e39a527;hb=5d01be6ec7d2cb2e662c695bd4c28c50ac3f2dab;hp=577f8e67154efe503678629170853ba97125c5a2;hpb=3f4e56a0a5514e74d2f753a9d04c7ba81f692ad6;p=platform%2Fcore%2Fuifw%2Fat-spi2-atk.git diff --git a/cspi/spi_event.c b/cspi/spi_event.c index 577f8e6..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 @@ -336,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)) { - return * (char **) any->_value; + 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 CORBA_string_dup (* (char **) any->_value); } else { @@ -354,19 +363,187 @@ static Accessible * cspi_internal_event_get_object (const InternalEvent *e) { CORBA_any *any; - Accessible *accessible; + 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) + 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. @@ -378,13 +555,13 @@ char * AccessibleTextChangedEvent_getChangeString (const AccessibleEvent *e) { const InternalEvent *foo = (InternalEvent *) e; - /* TODO: check the event type? expensive... */ + /* TODO: check the event type. */ return cspi_internal_event_get_text (foo); } /** * AccessibleTextSelectionChangedEvent_getSelectionString: - * @event: a pointer to the #AccessibleEvent being queried. + * @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. @@ -395,13 +572,13 @@ char * AccessibleTextSelectionChangedEvent_getSelectionString (const AccessibleEvent *e) { const InternalEvent *foo = (InternalEvent *) e; - /* TODO: check the event type? expensive... */ + /* TODO: check the event type. */ return cspi_internal_event_get_text (foo); } /** * AccessibleWindowEvent_getTitleString: - * @event: a pointer to the #AccessibleEvent being queried. + * @e: a pointer to the #AccessibleEvent being queried. * * Queries an #AccessibleEvent of type "window:", * returning the window title. @@ -413,13 +590,13 @@ char * AccessibleWindowEvent_getTitleString (const AccessibleEvent *e) { const InternalEvent *foo = (InternalEvent *) e; - /* TODO: check the event type? expensive... */ + /* 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. @@ -440,9 +617,9 @@ AccessibleChildChangedEvent_getChildAccessible (const AccessibleEvent *e) /** * AccessibleParentChangedEvent_getParentAccessible: - * @event: a pointer to the #AccessibleEvent being queried. + * @e: a pointer to the #AccessibleEvent being queried. * - * Queries an #AccessibleEvent of type "object:parent_changed" + * 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 @@ -457,8 +634,18 @@ AccessibleParentChangedEvent_getParentAccessible (const AccessibleEvent *e) return (Accessible *) cspi_internal_event_get_object (foo); } -/** NEED TO DOCUMENT THESE **/ - +/** + * 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) { @@ -466,6 +653,18 @@ AccessibleActiveDescendantChangedEvent_getActiveDescendant (const AccessibleEven 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) { @@ -473,35 +672,123 @@ AccessibleTableSummaryChangedEvent_getSummaryAccessible (const AccessibleEvent * 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) { - return NULL; + 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) { - return NULL; + 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) { - return NULL; + 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) { - return NULL; + 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) { - return NULL; + 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 @@ -535,7 +822,7 @@ cspi_internal_event_check (const AccessibleEvent *e) static InternalEvent * cspi_internal_event_add (const InternalEvent *e) { - _cspi_event_queue = g_slist_prepend (_cspi_event_queue, e); + _cspi_event_queue = g_slist_prepend (_cspi_event_queue, (gpointer) e); return (InternalEvent *) e; } @@ -547,12 +834,32 @@ cspi_internal_event_remove (const InternalEvent *e) _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) { - return NULL; + 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) { @@ -575,6 +882,14 @@ AccessibleEvent_ref (const AccessibleEvent *e) 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) { @@ -587,7 +902,13 @@ AccessibleEvent_unref (const AccessibleEvent *e) { event->ref_count--; if (event->ref_count < 1) - cspi_internal_event_remove (event); + { + cspi_internal_event_remove (event); + g_free ((gpointer)e->type); + Accessible_unref (e->source); + CORBA_free (event->data); + g_free ((gpointer)e); + } } } }