X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=cspi%2Fspi_accessible.c;h=f28485e534cfd38ea58aca401ee48c74935c63d3;hb=a5cd6a8e19126d8fe27f5a6db5d4edb35890b73f;hp=78db9f651e7f3ff47fb33d7b338980ec2d1f7b8c;hpb=7b24d9fcc3d6f82195a5e7a95af9f60a833cf79f;p=platform%2Fcore%2Fuifw%2Fat-spi2-atk.git diff --git a/cspi/spi_accessible.c b/cspi/spi_accessible.c index 78db9f6..f28485e 100644 --- a/cspi/spi_accessible.c +++ b/cspi/spi_accessible.c @@ -1,105 +1,257 @@ +/* + * 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. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + #include /* for malloc */ +#include #include static const char *role_names [] = { - "", + "invalid", + "accel-label", "alert", + "animation", + "arrow", + "calendar", "canvas", - "check box", - "color chooser", - "column header", - "combo box", - "desktop icon", - "desktop frame", + "check-box", + "check-menu-item", + "color-chooser", + "column-header", + "combo-box", + "date-editor", + "desktop-icon", + "desktop-frame", + "dial", "dialog", - "directory pane", - "file chooser", + "directory-pane", + "drawing-area", + "file-chooser", "filler", - "focus traversable", + "font-chooser", "frame", - "glass pane", - "HTML container", + "glass-pane", + "html-container", "icon", - "internal frame", + "image", + "internalframe", "label", - "layered pane", + "layered-pane", "list", - "list item", + "list-item", "menu", - "menubar", - "menu item", - "option pane", - "page tab", - "page tab list", + "menu-bar", + "menu-item", + "option-pane", + "page-tab", + "page-tab-list", "panel", - "password text", - "popup menu", - "progress bar", - "pushbutton", - "radiobutton", - "root pane", - "row header", - "scrollbar", - "scrollpane", + "password-text", + "popup-menu", + "progress-bar", + "push-button", + "radio-button", + "radio-menu-item", + "root-pane", + "row-header", + "scroll-bar", + "scroll-pane", "separator", "slider", - "split pane", + "spin-button", + "split-pane", + "statusbar", "table", - "table cell", - "table column header", - "table row header", + "table-cell", + "table-column-header", + "table-row-header", + "tear-off-menu-item", + "terminal", "text", - "toggle button", - "toolbar", - "tooltip", + "toggle-button", + "tool-bar", + "tool-tip", "tree", - "", + "tree-table", + "unknown", "viewport", "window", - - /* These have no equivalent AccessibleRole enum values */ - "accelerator label", - "animation", - "arrow", - "calendar", - "menu item", - "date editor", - "dial", - "drawing area", - "font chooser", - "image", - "radio menu item", - "tearoff menu item", - "spin button", - "status bar", + NULL, + "header", + "fooler", + "paragraph", + "ruler", + "application" }; #define MAX_ROLES (sizeof (role_names) / sizeof (char *)) +static SPIBoolean +cspi_init_role_table (AccessibleRole *role_table) +{ + int i; + for (i = 0; i < Accessibility_ROLE_LAST_DEFINED; ++i) + { + role_table [i] = SPI_ROLE_UNKNOWN; + } + role_table [Accessibility_ROLE_INVALID] = SPI_ROLE_INVALID; + role_table [Accessibility_ROLE_ACCELERATOR_LABEL] = SPI_ROLE_ACCEL_LABEL; + role_table [Accessibility_ROLE_ALERT] = SPI_ROLE_ALERT; + role_table [Accessibility_ROLE_ANIMATION] = SPI_ROLE_ANIMATION; + role_table [Accessibility_ROLE_ARROW] = SPI_ROLE_ARROW; + role_table [Accessibility_ROLE_CALENDAR] = SPI_ROLE_CALENDAR; + role_table [Accessibility_ROLE_CANVAS] = SPI_ROLE_CANVAS; + role_table [Accessibility_ROLE_CHECK_BOX] = SPI_ROLE_CHECK_BOX; + role_table [Accessibility_ROLE_CHECK_MENU_ITEM] = SPI_ROLE_CHECK_MENU_ITEM; + role_table [Accessibility_ROLE_COLOR_CHOOSER] = SPI_ROLE_COLOR_CHOOSER; + role_table [Accessibility_ROLE_COLUMN_HEADER] = SPI_ROLE_COLUMN_HEADER; + role_table [Accessibility_ROLE_COMBO_BOX] = SPI_ROLE_COMBO_BOX; + role_table [Accessibility_ROLE_DATE_EDITOR] = SPI_ROLE_DATE_EDITOR; + role_table [Accessibility_ROLE_DESKTOP_ICON] = SPI_ROLE_DESKTOP_ICON; + role_table [Accessibility_ROLE_DESKTOP_FRAME] = SPI_ROLE_DESKTOP_FRAME; + role_table [Accessibility_ROLE_DIAL] = SPI_ROLE_DIAL; + role_table [Accessibility_ROLE_DIALOG] = SPI_ROLE_DIALOG; + role_table [Accessibility_ROLE_DIRECTORY_PANE] = SPI_ROLE_DIRECTORY_PANE; + role_table [Accessibility_ROLE_DRAWING_AREA] = SPI_ROLE_DRAWING_AREA; + role_table [Accessibility_ROLE_FILE_CHOOSER] = SPI_ROLE_FILE_CHOOSER; + role_table [Accessibility_ROLE_FILLER] = SPI_ROLE_FILLER; + role_table [Accessibility_ROLE_FONT_CHOOSER] = SPI_ROLE_FONT_CHOOSER; + role_table [Accessibility_ROLE_FRAME] = SPI_ROLE_FRAME; + role_table [Accessibility_ROLE_GLASS_PANE] = SPI_ROLE_GLASS_PANE; + role_table [Accessibility_ROLE_HTML_CONTAINER] = SPI_ROLE_HTML_CONTAINER; + role_table [Accessibility_ROLE_ICON] = SPI_ROLE_ICON; + role_table [Accessibility_ROLE_IMAGE] = SPI_ROLE_IMAGE; + role_table [Accessibility_ROLE_INTERNAL_FRAME] = SPI_ROLE_INTERNAL_FRAME; + role_table [Accessibility_ROLE_LABEL] = SPI_ROLE_LABEL; + role_table [Accessibility_ROLE_LAYERED_PANE] = SPI_ROLE_LAYERED_PANE; + role_table [Accessibility_ROLE_LIST] = SPI_ROLE_LIST; + role_table [Accessibility_ROLE_LIST_ITEM] = SPI_ROLE_LIST_ITEM; + role_table [Accessibility_ROLE_MENU] = SPI_ROLE_MENU; + role_table [Accessibility_ROLE_MENU_BAR] = SPI_ROLE_MENU_BAR; + role_table [Accessibility_ROLE_MENU_ITEM] = SPI_ROLE_MENU_ITEM; + role_table [Accessibility_ROLE_OPTION_PANE] = SPI_ROLE_OPTION_PANE; + role_table [Accessibility_ROLE_PAGE_TAB] = SPI_ROLE_PAGE_TAB; + role_table [Accessibility_ROLE_PAGE_TAB_LIST] = SPI_ROLE_PAGE_TAB_LIST; + role_table [Accessibility_ROLE_PANEL] = SPI_ROLE_PANEL; + role_table [Accessibility_ROLE_PASSWORD_TEXT] = SPI_ROLE_PASSWORD_TEXT; + role_table [Accessibility_ROLE_POPUP_MENU] = SPI_ROLE_POPUP_MENU; + role_table [Accessibility_ROLE_PROGRESS_BAR] = SPI_ROLE_PROGRESS_BAR; + role_table [Accessibility_ROLE_PUSH_BUTTON] = SPI_ROLE_PUSH_BUTTON; + role_table [Accessibility_ROLE_RADIO_BUTTON] = SPI_ROLE_RADIO_BUTTON; + role_table [Accessibility_ROLE_RADIO_MENU_ITEM] = SPI_ROLE_RADIO_MENU_ITEM; + role_table [Accessibility_ROLE_ROOT_PANE] = SPI_ROLE_ROOT_PANE; + role_table [Accessibility_ROLE_ROW_HEADER] = SPI_ROLE_ROW_HEADER; + role_table [Accessibility_ROLE_SCROLL_BAR] = SPI_ROLE_SCROLL_BAR; + role_table [Accessibility_ROLE_SCROLL_PANE] = SPI_ROLE_SCROLL_PANE; + role_table [Accessibility_ROLE_SEPARATOR] = SPI_ROLE_SEPARATOR; + role_table [Accessibility_ROLE_SLIDER] = SPI_ROLE_SLIDER; + role_table [Accessibility_ROLE_SPIN_BUTTON] = SPI_ROLE_SPIN_BUTTON; + role_table [Accessibility_ROLE_SPLIT_PANE] = SPI_ROLE_SPLIT_PANE; + role_table [Accessibility_ROLE_STATUS_BAR] = SPI_ROLE_STATUS_BAR; + role_table [Accessibility_ROLE_TABLE] = SPI_ROLE_TABLE; + role_table [Accessibility_ROLE_TABLE_CELL] = SPI_ROLE_TABLE_CELL; + role_table[Accessibility_ROLE_TABLE_COLUMN_HEADER] = SPI_ROLE_TABLE_COLUMN_HEADER; + role_table[Accessibility_ROLE_TABLE_ROW_HEADER] = SPI_ROLE_TABLE_ROW_HEADER; + role_table [Accessibility_ROLE_TEAROFF_MENU_ITEM] = SPI_ROLE_TEAROFF_MENU_ITEM; + role_table[Accessibility_ROLE_TERMINAL] = SPI_ROLE_TERMINAL; + role_table [Accessibility_ROLE_TEXT] = SPI_ROLE_TEXT; + role_table [Accessibility_ROLE_TOGGLE_BUTTON] = SPI_ROLE_TOGGLE_BUTTON; + role_table [Accessibility_ROLE_TOOL_BAR] = SPI_ROLE_TOOL_BAR; + role_table [Accessibility_ROLE_TOOL_TIP] = SPI_ROLE_TOOL_TIP; + role_table [Accessibility_ROLE_TREE] = SPI_ROLE_TREE; + role_table [Accessibility_ROLE_TREE_TABLE] = SPI_ROLE_TREE_TABLE; + role_table [Accessibility_ROLE_VIEWPORT] = SPI_ROLE_VIEWPORT; + role_table [Accessibility_ROLE_WINDOW] = SPI_ROLE_WINDOW; + role_table [Accessibility_ROLE_EXTENDED] = SPI_ROLE_EXTENDED; + role_table [Accessibility_ROLE_HEADER] = SPI_ROLE_HEADER; + role_table [Accessibility_ROLE_FOOTER] = SPI_ROLE_FOOTER; + role_table [Accessibility_ROLE_PARAGRAPH] = SPI_ROLE_PARAGRAPH; + role_table [Accessibility_ROLE_RULER] = SPI_ROLE_RULER; + role_table [Accessibility_ROLE_APPLICATION] = SPI_ROLE_APPLICATION; + role_table [Accessibility_ROLE_AUTOCOMPLETE] = SPI_ROLE_AUTOCOMPLETE; + role_table [Accessibility_ROLE_EDITBAR] = SPI_ROLE_EDITBAR; + role_table [Accessibility_ROLE_EMBEDDED] = SPI_ROLE_EMBEDDED; + + return TRUE; +} + +AccessibleRole +cspi_role_from_spi_role (Accessibility_Role role) +{ + /* array is sized according to IDL roles because IDL roles are the index */ + static AccessibleRole cspi_role_table [Accessibility_ROLE_LAST_DEFINED]; + static SPIBoolean is_initialized = FALSE; + AccessibleRole cspi_role; + if (!is_initialized) + { + is_initialized = cspi_init_role_table (cspi_role_table); + } + if (role >= 0 && role < Accessibility_ROLE_LAST_DEFINED) + { + cspi_role = cspi_role_table [role]; + } + else + { + cspi_role = SPI_ROLE_EXTENDED; + } + return cspi_role; +} + +AccessibleAttributeSet * +cspi_attribute_set_from_sequence (const Accessibility_AttributeSet *seq) +{ + AccessibleAttributeSet *set = g_new0 (AccessibleAttributeSet, 1); + int i; + + set->len = seq->_length; + set->attributes = g_newa (char *, set->len); + for (i = 0; i < set->len; ++i) + { + set->attributes[i] = g_strdup (seq->_buffer [i]); + } + return set; +} + /** * AccessibleRole_getName: * @role: an #AccessibleRole object to query. * * Get a localizeable string that indicates the name of an #AccessibleRole. + * DEPRECATED. * * Returns: a localizable string name for an #AccessibleRole enumerated type. **/ -const char * +char * AccessibleRole_getName (AccessibleRole role) { - if (role < MAX_ROLES) + if (role < MAX_ROLES && role_names [(int) role]) { - return role_names [(int) role]; + return CORBA_string_dup (role_names [(int) role]); } else { - return ""; + return CORBA_string_dup (""); } - /* - * TODO: replace with implementation linked to ATK, which - * now supports Role/Name mapping - */ } /** @@ -142,8 +294,7 @@ Accessible_getName (Accessible *obj) cspi_return_val_if_fail (obj != NULL, NULL); - retval = (char *) - Accessibility_Accessible__get_name (CSPI_OBJREF (obj), cspi_ev ()); + retval = Accessibility_Accessible__get_name (CSPI_OBJREF (obj), cspi_ev ()); cspi_return_val_if_ev ("getName", NULL); @@ -166,8 +317,7 @@ Accessible_getDescription (Accessible *obj) cspi_return_val_if_fail (obj != NULL, NULL); - retval = (char *) - Accessibility_Accessible__get_description (CSPI_OBJREF (obj), + retval = Accessibility_Accessible__get_description (CSPI_OBJREF (obj), cspi_ev ()); cspi_return_val_if_ev ("getDescription", NULL); @@ -218,8 +368,7 @@ Accessible_getChildCount (Accessible *obj) cspi_return_val_if_fail (obj != NULL, -1); - retval = (long) - Accessibility_Accessible__get_childCount (CSPI_OBJREF (obj), + retval = Accessibility_Accessible__get_childCount (CSPI_OBJREF (obj), cspi_ev ()); cspi_return_val_if_ev ("getChildCount", -1); @@ -249,6 +398,7 @@ Accessible_getChildAtIndex (Accessible *obj, Accessibility_Accessible_getChildAtIndex (CSPI_OBJREF (obj), childIndex, cspi_ev ())); + cspi_return_val_if_ev ("getChildAtIndex", NULL); return retval; } @@ -269,8 +419,7 @@ Accessible_getIndexInParent (Accessible *obj) cspi_return_val_if_fail (obj != NULL, -1); - retval = (long) - Accessibility_Accessible_getIndexInParent (CSPI_OBJREF (obj), cspi_ev ()); + retval = Accessibility_Accessible_getIndexInParent (CSPI_OBJREF (obj), cspi_ev ()); cspi_return_val_if_ev ("getIndexInparent", -1); return retval; @@ -295,21 +444,22 @@ Accessible_getRelationSet (Accessible *obj) cspi_return_val_if_fail (obj != NULL, NULL); + g_assert (!cspi_exception ()); + relation_set = Accessibility_Accessible_getRelationSet (CSPI_OBJREF (obj), cspi_ev ()); cspi_return_val_if_ev ("getRelationSet", NULL); - /* this looks hack-ish, but it's based on the CORBA C bindings spec */ n_relations = relation_set->_length; - relations = malloc (sizeof (AccessibleRelation *) * n_relations); + relations = malloc (sizeof (AccessibleRelation *) * (n_relations + 1)); for (i = 0; i < n_relations; ++i) { relations[i] = cspi_object_add (CORBA_Object_duplicate ( relation_set->_buffer[i], cspi_ev ())); } - relations[i] = CORBA_OBJECT_NIL; + relations[i] = NULL; CORBA_free (relation_set); @@ -321,37 +471,156 @@ Accessible_getRelationSet (Accessible *obj) * @obj: a pointer to the #Accessible object on which to operate. * * Get the UI role of an #Accessible object. + * A UTF-8 string describing this role can be obtained via Accessible_getRoleName (). * - * Returns: a UTF-8 string indicating the UI role of the #Accessible object. + * Returns: the #AccessibleRole of the object. * **/ -const char * +AccessibleRole Accessible_getRole (Accessible *obj) { - const char *retval; + Accessibility_Role retval; - cspi_return_val_if_fail (obj != NULL, NULL); + cspi_return_val_if_fail (obj != NULL, SPI_ROLE_INVALID); + + retval = + Accessibility_Accessible_getRole (CSPI_OBJREF (obj), cspi_ev ()); + + cspi_return_val_if_ev ("getRole", SPI_ROLE_INVALID); + + return cspi_role_from_spi_role (retval); +} + +/** + * Accessible_getRoleName: + * @obj: a pointer to the #Accessible object on which to operate. + * + * Get a UTF-8 string describing the role this object plays in the UI. + * This method will return useful values for roles that fall outside the + * enumeration used in Accessible_getRole (). + * + * Returns: a UTF-8 string specifying the role of this #Accessible object. + * + **/ +char * +Accessible_getRoleName (Accessible *obj) +{ + char *retval; + + cspi_return_val_if_fail (obj != NULL, CORBA_string_dup ("invalid")); - retval = AccessibleRole_getName ( - Accessibility_Accessible_getRole (CSPI_OBJREF (obj), cspi_ev ())); + retval = + Accessibility_Accessible_getRoleName (CSPI_OBJREF (obj), cspi_ev ()); - cspi_return_val_if_ev ("getRole", NULL); + cspi_return_val_if_ev ("getRoleName", CORBA_string_dup ("invalid")); return retval; } /** - * Accessible_getStateSet: + * Accessible_getLocalizedRoleName: * @obj: a pointer to the #Accessible object on which to operate. * - * Not Yet Implemented. + * Get a UTF-8 string describing the (localized) role this object plays in the UI. + * This method will return useful values for roles that fall outside the + * enumeration used in Accessible_getRole (). + * + * Returns: a UTF-8 string specifying the role of this #Accessible object. + * + **/ +char * +Accessible_getLocalizedRoleName (Accessible *obj) +{ + char *retval; + + cspi_return_val_if_fail (obj != NULL, CORBA_string_dup ("invalid")); + + retval = + Accessibility_Accessible_getLocalizedRoleName (CSPI_OBJREF (obj), cspi_ev ()); + + cspi_return_val_if_ev ("getLocalizedRoleName", CORBA_string_dup ("invalid")); + + return retval; +} + +/** + * Accessible_getStateSet: + * @obj: a pointer to the #Accessible object on which to operate. * * Returns: a pointer to an #AccessibleStateSet representing the object's current state. **/ AccessibleStateSet * Accessible_getStateSet (Accessible *obj) { - return NULL; + AccessibleStateSet *retval; + Accessibility_StateSet corba_stateset; + Accessibility_StateSeq *corba_seq; + + cspi_return_val_if_fail (obj != NULL, NULL); + + corba_stateset = Accessibility_Accessible_getState ( + CSPI_OBJREF (obj), cspi_ev ()); + cspi_return_val_if_ev ("getState", NULL); + + cspi_return_val_if_fail (corba_stateset != CORBA_OBJECT_NIL, NULL); + cspi_return_val_if_fail (cspi_ping (corba_stateset), NULL); + corba_seq = Accessibility_StateSet_getStates (corba_stateset, cspi_ev ()); + cspi_return_val_if_ev ("getState", NULL); + + retval = spi_state_set_cache_new (corba_seq); + + CORBA_free (corba_seq); + cspi_release_unref (corba_stateset); + + return retval; +} + +/** + * Accessible_getAttributes: + * Get the #AttributeSet representing any assigned + * name-value pair attributes or annotations for this object. + * For typographic, textual, or textually-semantic attributes, see + * AccessibleText_getAttributes instead. + * @obj: The #Accessible being queried. + * Returns: The name-value-pair attributes assigned to this object. + */ +AccessibleAttributeSet * +Accessible_getAttributes (Accessible *obj) +{ + AccessibleAttributeSet *retval; + Accessibility_AttributeSet *corba_seq; + + cspi_return_val_if_fail (obj != NULL, NULL); + + corba_seq = Accessibility_Accessible_getAttributes ( + CSPI_OBJREF (obj), cspi_ev ()); + cspi_return_val_if_ev ("getAttributes", NULL); + + retval = cspi_attribute_set_from_sequence (corba_seq); + CORBA_free (corba_seq); + + return NULL; +} + +/** + * Accessible_getHostApplication: + * Get the containing #AccessibleApplication for an object. + * @obj: The #Accessible being queried. + * Returns: the containing AccessibleApplication instance for this object. + */ +AccessibleApplication * +Accessible_getHostApplication (Accessible *obj) +{ + AccessibleApplication *retval; + + cspi_return_val_if_fail (obj != NULL, NULL); + + retval = Accessible_getApplication (cspi_object_add ( + Accessibility_Accessible_getApplication (CSPI_OBJREF (obj), + cspi_ev ()))); + cspi_return_val_if_ev ("getApplication", NULL); + + return retval; } /* Interface query methods */ @@ -485,6 +754,23 @@ Accessible_isTable (Accessible *obj) } /** + * Accessible_isStreamableContent: + * @obj: a pointer to the #Accessible instance to query. + * + * Query whether the specified #Accessible implements + * #AccessibleStreamableContent. + * + * Returns: #TRUE if @obj implements the #AccessibleStreamableContent interface, + * #FALSE otherwise. +**/ +SPIBoolean +Accessible_isStreamableContent (Accessible *obj) +{ + return cspi_accessible_is_a (obj, + "IDL:Accessibility/StreamableContent:1.0"); +} + +/** * Accessible_isText: * @obj: a pointer to the #Accessible instance to query. * @@ -637,6 +923,22 @@ Accessible_getSelection (Accessible *obj) /** + * Accessible_getStreamableContent: + * @obj: a pointer to the #Accessible instance to query. + * + * Get the #AccessibleStreamableContent interface for an #Accessible. + * + * Returns: a pointer to an #AccessibleStreamableContent interface instance, or + * NULL if @obj does not implement #AccessibleStreamableContent. + **/ +AccessibleStreamableContent * +Accessible_getStreamableContent (Accessible *obj) +{ + return (AccessibleStreamableContent *) Accessible_queryInterface ( + obj, "IDL:Accessibility/StreamableContent:1.0"); +} + +/** * Accessible_getTable: * @obj: a pointer to the #Accessible instance to query. * @@ -699,7 +1001,7 @@ Accessible_getValue (Accessible *obj) * by @obj, or NULL otherwise. * **/ -GenericInterface * +AccessibleUnknown * Accessible_queryInterface (Accessible *obj, const char *interface_name) { @@ -756,6 +1058,53 @@ AccessibleRelation_unref (AccessibleRelation *obj) cspi_object_unref (obj); } +static SPIBoolean +cspi_init_relation_type_table (AccessibleRelationType *relation_type_table) +{ + int i; + for (i = 0; i < Accessibility_RELATION_LAST_DEFINED; ++i) + { + relation_type_table [i] = SPI_RELATION_NULL; + } + relation_type_table [Accessibility_RELATION_NULL] = SPI_RELATION_NULL; + relation_type_table [Accessibility_RELATION_LABEL_FOR] = SPI_RELATION_LABEL_FOR; + relation_type_table [Accessibility_RELATION_LABELLED_BY] = SPI_RELATION_LABELED_BY; + relation_type_table [Accessibility_RELATION_CONTROLLER_FOR] = SPI_RELATION_CONTROLLER_FOR; + relation_type_table [Accessibility_RELATION_CONTROLLED_BY] = SPI_RELATION_CONTROLLED_BY; + relation_type_table [Accessibility_RELATION_MEMBER_OF] = SPI_RELATION_MEMBER_OF; + relation_type_table [Accessibility_RELATION_TOOLTIP_FOR] = SPI_RELATION_NULL; + relation_type_table [Accessibility_RELATION_NODE_CHILD_OF] = SPI_RELATION_NODE_CHILD_OF; + relation_type_table [Accessibility_RELATION_EXTENDED] = SPI_RELATION_EXTENDED; + relation_type_table [Accessibility_RELATION_FLOWS_TO] = SPI_RELATION_FLOWS_TO; + relation_type_table [Accessibility_RELATION_FLOWS_FROM] = SPI_RELATION_FLOWS_FROM; + relation_type_table [Accessibility_RELATION_SUBWINDOW_OF] = SPI_RELATION_SUBWINDOW_OF; + relation_type_table [Accessibility_RELATION_EMBEDS] = SPI_RELATION_EMBEDS; + relation_type_table [Accessibility_RELATION_EMBEDDED_BY] = SPI_RELATION_EMBEDDED_BY; + relation_type_table [Accessibility_RELATION_POPUP_FOR] = SPI_RELATION_POPUP_FOR; + return TRUE; +} + +static AccessibleRelationType +cspi_relation_type_from_spi_relation_type (Accessibility_RelationType type) +{ + /* array is sized according to IDL RelationType because IDL RelationTypes are the index */ + static AccessibleRelationType cspi_relation_type_table [Accessibility_RELATION_LAST_DEFINED]; + static SPIBoolean is_initialized = FALSE; + AccessibleRelationType cspi_type; + if (!is_initialized) + { + is_initialized = cspi_init_relation_type_table (cspi_relation_type_table); + } + if (type >= 0 && type < Accessibility_RELATION_LAST_DEFINED) + { + cspi_type = cspi_relation_type_table [type]; + } + else + { + cspi_type = SPI_RELATION_NULL; + } + return cspi_type; +} /** * AccessibleRelation_getRelationType: * @obj: a pointer to the #AccessibleRelation object to query. @@ -769,8 +1118,13 @@ AccessibleRelation_unref (AccessibleRelation *obj) AccessibleRelationType AccessibleRelation_getRelationType (AccessibleRelation *obj) { - cspi_return_val_if_fail (obj != NULL, -1); - return 0; + Accessibility_RelationType retval; + + cspi_return_val_if_fail (obj, SPI_RELATION_NULL); + retval = + Accessibility_Relation_getRelationType (CSPI_OBJREF (obj), cspi_ev()); + cspi_return_val_if_ev ("getRelationType", SPI_RELATION_NULL); + return cspi_relation_type_from_spi_relation_type (retval); } /** @@ -788,8 +1142,12 @@ AccessibleRelation_getRelationType (AccessibleRelation *obj) int AccessibleRelation_getNTargets (AccessibleRelation *obj) { - cspi_return_val_if_fail (obj != NULL, -1); - return 0; + int retval; + + cspi_return_val_if_fail (obj, -1); + retval = Accessibility_Relation_getNTargets (CSPI_OBJREF (obj), cspi_ev()); + cspi_return_val_if_ev ("getNTargets", -1); + return retval; } /** @@ -807,8 +1165,15 @@ AccessibleRelation_getNTargets (AccessibleRelation *obj) Accessible * AccessibleRelation_getTarget (AccessibleRelation *obj, int i) { - cspi_return_val_if_fail (obj != NULL, NULL); - return NULL; + Accessible *retval; + + cspi_return_val_if_fail (obj, NULL); + + retval = cspi_object_add ( + Accessibility_Relation_getTarget (CSPI_OBJREF(obj), + i, cspi_ev())); + cspi_return_val_if_ev ("getTarget", NULL); + return retval; } /** @@ -821,7 +1186,7 @@ AccessibleRelation_getTarget (AccessibleRelation *obj, int i) void AccessibleStateSet_ref (AccessibleStateSet *obj) { - cspi_object_ref (obj); + spi_state_set_cache_ref (obj); } /** @@ -834,9 +1199,55 @@ AccessibleStateSet_ref (AccessibleStateSet *obj) void AccessibleStateSet_unref (AccessibleStateSet *obj) { - cspi_object_unref (obj); + spi_state_set_cache_unref (obj); } +static Accessibility_StateType +spi_state_to_corba (AccessibleState state) +{ +#define MAP_STATE(a) \ + case SPI_STATE_##a: \ + return Accessibility_STATE_##a + + switch (state) + { + MAP_STATE (INVALID); + MAP_STATE (ACTIVE); + MAP_STATE (ARMED); + MAP_STATE (BUSY); + MAP_STATE (CHECKED); + MAP_STATE (DEFUNCT); + MAP_STATE (EDITABLE); + MAP_STATE (ENABLED); + MAP_STATE (EXPANDABLE); + MAP_STATE (EXPANDED); + MAP_STATE (FOCUSABLE); + MAP_STATE (FOCUSED); + MAP_STATE (HORIZONTAL); + MAP_STATE (ICONIFIED); + MAP_STATE (MODAL); + MAP_STATE (MULTI_LINE); + MAP_STATE (MULTISELECTABLE); + MAP_STATE (OPAQUE); + MAP_STATE (PRESSED); + MAP_STATE (RESIZABLE); + MAP_STATE (SELECTABLE); + MAP_STATE (SELECTED); + MAP_STATE (SENSITIVE); + MAP_STATE (SHOWING); + MAP_STATE (SINGLE_LINE); + MAP_STATE (STALE); + MAP_STATE (TRANSIENT); + MAP_STATE (VERTICAL); + MAP_STATE (VISIBLE); + MAP_STATE (MANAGES_DESCENDANTS); + MAP_STATE (INDETERMINATE); + default: + return Accessibility_STATE_INVALID; + } +#undef MAP_STATE +} + /** * AccessibleStateSet_contains: * @obj: a pointer to the #AccessibleStateSet object on which to operate. @@ -854,16 +1265,7 @@ SPIBoolean AccessibleStateSet_contains (AccessibleStateSet *obj, AccessibleState state) { - CORBA_boolean retval; - - cspi_return_val_if_fail (obj != NULL, FALSE); - - retval = Accessibility_StateSet_contains (CSPI_OBJREF (obj), - state, cspi_ev ()); - - cspi_return_val_if_ev ("contains", FALSE); - - return (SPIBoolean) retval; + return spi_state_set_cache_contains (obj, spi_state_to_corba (state)); } /** @@ -879,10 +1281,7 @@ void AccessibleStateSet_add (AccessibleStateSet *obj, AccessibleState state) { - cspi_return_if_fail (obj != NULL); - - Accessibility_StateSet_add (CSPI_OBJREF (obj), state, cspi_ev ()); - cspi_check_ev ("add"); + spi_state_set_cache_add (obj, spi_state_to_corba (state)); } /** @@ -898,10 +1297,7 @@ void AccessibleStateSet_remove (AccessibleStateSet *obj, AccessibleState state) { - cspi_return_if_fail (obj != NULL); - - Accessibility_StateSet_remove (CSPI_OBJREF (obj), state, cspi_ev ()); - cspi_check_ev ("remove"); + spi_state_set_cache_remove (obj, spi_state_to_corba (state)); } /** @@ -923,16 +1319,19 @@ SPIBoolean AccessibleStateSet_equals (AccessibleStateSet *obj, AccessibleStateSet *obj2) { + SPIBoolean eq; + AtkStateSet *cmp; + if (obj == obj2) { return TRUE; } - cspi_return_val_if_fail (obj != NULL, FALSE); - cspi_return_val_if_fail (obj2 != NULL, FALSE); + cmp = spi_state_set_cache_xor (obj, obj2); + eq = spi_state_set_cache_is_empty (cmp); + spi_state_set_cache_unref (cmp); - return Accessibility_StateSet_equals (CSPI_OBJREF (obj), - CSPI_OBJREF (obj2), cspi_ev ()); + return eq; } /** @@ -953,9 +1352,7 @@ AccessibleStateSet * AccessibleStateSet_compare (AccessibleStateSet *obj, AccessibleStateSet *obj2) { - cspi_return_val_if_fail (obj != NULL, NULL); - cspi_return_val_if_fail (obj2 != NULL, NULL); - return NULL; + return spi_state_set_cache_xor (obj, obj2); } /** @@ -971,9 +1368,7 @@ AccessibleStateSet_compare (AccessibleStateSet *obj, SPIBoolean AccessibleStateSet_isEmpty (AccessibleStateSet *obj) { - cspi_return_val_if_fail (obj != NULL, FALSE); - return TRUE; - /* return Accessibility_StateSet_isEmpty (CSPI_OBJREF (obj), cspi_ev ());*/ + return spi_state_set_cache_is_empty (obj); }