1 | /* |
---|
2 | * AT-SPI - Assistive Technology Service Provider Interface |
---|
3 | * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap) |
---|
4 | * |
---|
5 | * Copyright 2001, 2002 Sun Microsystems Inc., |
---|
6 | * Copyright 2001, 2002 Ximian, Inc. |
---|
7 | * |
---|
8 | * This library is free software; you can redistribute it and/or |
---|
9 | * modify it under the terms of the GNU Library General Public |
---|
10 | * License as published by the Free Software Foundation; either |
---|
11 | * version 2 of the License, or (at your option) any later version. |
---|
12 | * |
---|
13 | * This library is distributed in the hope that it will be useful, |
---|
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
---|
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
---|
16 | * Library General Public License for more details. |
---|
17 | * |
---|
18 | * You should have received a copy of the GNU Library General Public |
---|
19 | * License along with this library; if not, write to the |
---|
20 | * Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
---|
21 | * Boston, MA 02111-1307, USA. |
---|
22 | */ |
---|
23 | |
---|
24 | #include <stdlib.h> /* for malloc */ |
---|
25 | #include <libspi/stateset.h> |
---|
26 | #include <cspi/spi-private.h> |
---|
27 | |
---|
28 | static const char *role_names [] = |
---|
29 | { |
---|
30 | "invalid", |
---|
31 | "accel-label", |
---|
32 | "alert", |
---|
33 | "animation", |
---|
34 | "arrow", |
---|
35 | "calendar", |
---|
36 | "canvas", |
---|
37 | "check-box", |
---|
38 | "check-menu-item", |
---|
39 | "color-chooser", |
---|
40 | "column-header", |
---|
41 | "combo-box", |
---|
42 | "date-editor", |
---|
43 | "desktop-icon", |
---|
44 | "desktop-frame", |
---|
45 | "dial", |
---|
46 | "dialog", |
---|
47 | "directory-pane", |
---|
48 | "drawing-area", |
---|
49 | "file-chooser", |
---|
50 | "filler", |
---|
51 | "font-chooser", |
---|
52 | "frame", |
---|
53 | "glass-pane", |
---|
54 | "html-container", |
---|
55 | "icon", |
---|
56 | "image", |
---|
57 | "internalframe", |
---|
58 | "label", |
---|
59 | "layered-pane", |
---|
60 | "list", |
---|
61 | "list-item", |
---|
62 | "menu", |
---|
63 | "menu-bar", |
---|
64 | "menu-item", |
---|
65 | "option-pane", |
---|
66 | "page-tab", |
---|
67 | "page-tab-list", |
---|
68 | "panel", |
---|
69 | "password-text", |
---|
70 | "popup-menu", |
---|
71 | "progress-bar", |
---|
72 | "push-button", |
---|
73 | "radio-button", |
---|
74 | "radio-menu-item", |
---|
75 | "root-pane", |
---|
76 | "row-header", |
---|
77 | "scroll-bar", |
---|
78 | "scroll-pane", |
---|
79 | "separator", |
---|
80 | "slider", |
---|
81 | "spin-button", |
---|
82 | "split-pane", |
---|
83 | "statusbar", |
---|
84 | "table", |
---|
85 | "table-cell", |
---|
86 | "table-column-header", |
---|
87 | "table-row-header", |
---|
88 | "tear-off-menu-item", |
---|
89 | "terminal", |
---|
90 | "text", |
---|
91 | "toggle-button", |
---|
92 | "tool-bar", |
---|
93 | "tool-tip", |
---|
94 | "tree", |
---|
95 | "tree-table", |
---|
96 | "unknown", |
---|
97 | "viewport", |
---|
98 | "window", |
---|
99 | NULL, |
---|
100 | "header", |
---|
101 | "fooler", |
---|
102 | "paragraph", |
---|
103 | "ruler", |
---|
104 | "application" |
---|
105 | }; |
---|
106 | |
---|
107 | #define MAX_ROLES (sizeof (role_names) / sizeof (char *)) |
---|
108 | |
---|
109 | static SPIBoolean |
---|
110 | cspi_init_role_table (AccessibleRole *role_table) |
---|
111 | { |
---|
112 | int i; |
---|
113 | for (i = 0; i < Accessibility_ROLE_LAST_DEFINED; ++i) |
---|
114 | { |
---|
115 | role_table [i] = SPI_ROLE_UNKNOWN; |
---|
116 | } |
---|
117 | role_table [Accessibility_ROLE_INVALID] = SPI_ROLE_INVALID; |
---|
118 | role_table [Accessibility_ROLE_ACCELERATOR_LABEL] = SPI_ROLE_ACCEL_LABEL; |
---|
119 | role_table [Accessibility_ROLE_ALERT] = SPI_ROLE_ALERT; |
---|
120 | role_table [Accessibility_ROLE_ANIMATION] = SPI_ROLE_ANIMATION; |
---|
121 | role_table [Accessibility_ROLE_ARROW] = SPI_ROLE_ARROW; |
---|
122 | role_table [Accessibility_ROLE_CALENDAR] = SPI_ROLE_CALENDAR; |
---|
123 | role_table [Accessibility_ROLE_CANVAS] = SPI_ROLE_CANVAS; |
---|
124 | role_table [Accessibility_ROLE_CHECK_BOX] = SPI_ROLE_CHECK_BOX; |
---|
125 | role_table [Accessibility_ROLE_CHECK_MENU_ITEM] = SPI_ROLE_CHECK_MENU_ITEM; |
---|
126 | role_table [Accessibility_ROLE_COLOR_CHOOSER] = SPI_ROLE_COLOR_CHOOSER; |
---|
127 | role_table [Accessibility_ROLE_COLUMN_HEADER] = SPI_ROLE_COLUMN_HEADER; |
---|
128 | role_table [Accessibility_ROLE_COMBO_BOX] = SPI_ROLE_COMBO_BOX; |
---|
129 | role_table [Accessibility_ROLE_DATE_EDITOR] = SPI_ROLE_DATE_EDITOR; |
---|
130 | role_table [Accessibility_ROLE_DESKTOP_ICON] = SPI_ROLE_DESKTOP_ICON; |
---|
131 | role_table [Accessibility_ROLE_DESKTOP_FRAME] = SPI_ROLE_DESKTOP_FRAME; |
---|
132 | role_table [Accessibility_ROLE_DIAL] = SPI_ROLE_DIAL; |
---|
133 | role_table [Accessibility_ROLE_DIALOG] = SPI_ROLE_DIALOG; |
---|
134 | role_table [Accessibility_ROLE_DIRECTORY_PANE] = SPI_ROLE_DIRECTORY_PANE; |
---|
135 | role_table [Accessibility_ROLE_DRAWING_AREA] = SPI_ROLE_DRAWING_AREA; |
---|
136 | role_table [Accessibility_ROLE_FILE_CHOOSER] = SPI_ROLE_FILE_CHOOSER; |
---|
137 | role_table [Accessibility_ROLE_FILLER] = SPI_ROLE_FILLER; |
---|
138 | role_table [Accessibility_ROLE_FONT_CHOOSER] = SPI_ROLE_FONT_CHOOSER; |
---|
139 | role_table [Accessibility_ROLE_FRAME] = SPI_ROLE_FRAME; |
---|
140 | role_table [Accessibility_ROLE_GLASS_PANE] = SPI_ROLE_GLASS_PANE; |
---|
141 | role_table [Accessibility_ROLE_HTML_CONTAINER] = SPI_ROLE_HTML_CONTAINER; |
---|
142 | role_table [Accessibility_ROLE_ICON] = SPI_ROLE_ICON; |
---|
143 | role_table [Accessibility_ROLE_IMAGE] = SPI_ROLE_IMAGE; |
---|
144 | role_table [Accessibility_ROLE_INTERNAL_FRAME] = SPI_ROLE_INTERNAL_FRAME; |
---|
145 | role_table [Accessibility_ROLE_LABEL] = SPI_ROLE_LABEL; |
---|
146 | role_table [Accessibility_ROLE_LAYERED_PANE] = SPI_ROLE_LAYERED_PANE; |
---|
147 | role_table [Accessibility_ROLE_LIST] = SPI_ROLE_LIST; |
---|
148 | role_table [Accessibility_ROLE_LIST_ITEM] = SPI_ROLE_LIST_ITEM; |
---|
149 | role_table [Accessibility_ROLE_MENU] = SPI_ROLE_MENU; |
---|
150 | role_table [Accessibility_ROLE_MENU_BAR] = SPI_ROLE_MENU_BAR; |
---|
151 | role_table [Accessibility_ROLE_MENU_ITEM] = SPI_ROLE_MENU_ITEM; |
---|
152 | role_table [Accessibility_ROLE_OPTION_PANE] = SPI_ROLE_OPTION_PANE; |
---|
153 | role_table [Accessibility_ROLE_PAGE_TAB] = SPI_ROLE_PAGE_TAB; |
---|
154 | role_table [Accessibility_ROLE_PAGE_TAB_LIST] = SPI_ROLE_PAGE_TAB_LIST; |
---|
155 | role_table [Accessibility_ROLE_PANEL] = SPI_ROLE_PANEL; |
---|
156 | role_table [Accessibility_ROLE_PASSWORD_TEXT] = SPI_ROLE_PASSWORD_TEXT; |
---|
157 | role_table [Accessibility_ROLE_POPUP_MENU] = SPI_ROLE_POPUP_MENU; |
---|
158 | role_table [Accessibility_ROLE_PROGRESS_BAR] = SPI_ROLE_PROGRESS_BAR; |
---|
159 | role_table [Accessibility_ROLE_PUSH_BUTTON] = SPI_ROLE_PUSH_BUTTON; |
---|
160 | role_table [Accessibility_ROLE_RADIO_BUTTON] = SPI_ROLE_RADIO_BUTTON; |
---|
161 | role_table [Accessibility_ROLE_RADIO_MENU_ITEM] = SPI_ROLE_RADIO_MENU_ITEM; |
---|
162 | role_table [Accessibility_ROLE_ROOT_PANE] = SPI_ROLE_ROOT_PANE; |
---|
163 | role_table [Accessibility_ROLE_ROW_HEADER] = SPI_ROLE_ROW_HEADER; |
---|
164 | role_table [Accessibility_ROLE_SCROLL_BAR] = SPI_ROLE_SCROLL_BAR; |
---|
165 | role_table [Accessibility_ROLE_SCROLL_PANE] = SPI_ROLE_SCROLL_PANE; |
---|
166 | role_table [Accessibility_ROLE_SEPARATOR] = SPI_ROLE_SEPARATOR; |
---|
167 | role_table [Accessibility_ROLE_SLIDER] = SPI_ROLE_SLIDER; |
---|
168 | role_table [Accessibility_ROLE_SPIN_BUTTON] = SPI_ROLE_SPIN_BUTTON; |
---|
169 | role_table [Accessibility_ROLE_SPLIT_PANE] = SPI_ROLE_SPLIT_PANE; |
---|
170 | role_table [Accessibility_ROLE_STATUS_BAR] = SPI_ROLE_STATUS_BAR; |
---|
171 | role_table [Accessibility_ROLE_TABLE] = SPI_ROLE_TABLE; |
---|
172 | role_table [Accessibility_ROLE_TABLE_CELL] = SPI_ROLE_TABLE_CELL; |
---|
173 | role_table[Accessibility_ROLE_TABLE_COLUMN_HEADER] = SPI_ROLE_TABLE_COLUMN_HEADER; |
---|
174 | role_table[Accessibility_ROLE_TABLE_ROW_HEADER] = SPI_ROLE_TABLE_ROW_HEADER; |
---|
175 | role_table [Accessibility_ROLE_TEAROFF_MENU_ITEM] = SPI_ROLE_TEAROFF_MENU_ITEM; |
---|
176 | role_table[Accessibility_ROLE_TERMINAL] = SPI_ROLE_TERMINAL; |
---|
177 | role_table [Accessibility_ROLE_TEXT] = SPI_ROLE_TEXT; |
---|
178 | role_table [Accessibility_ROLE_TOGGLE_BUTTON] = SPI_ROLE_TOGGLE_BUTTON; |
---|
179 | role_table [Accessibility_ROLE_TOOL_BAR] = SPI_ROLE_TOOL_BAR; |
---|
180 | role_table [Accessibility_ROLE_TOOL_TIP] = SPI_ROLE_TOOL_TIP; |
---|
181 | role_table [Accessibility_ROLE_TREE] = SPI_ROLE_TREE; |
---|
182 | role_table [Accessibility_ROLE_TREE_TABLE] = SPI_ROLE_TREE_TABLE; |
---|
183 | role_table [Accessibility_ROLE_VIEWPORT] = SPI_ROLE_VIEWPORT; |
---|
184 | role_table [Accessibility_ROLE_WINDOW] = SPI_ROLE_WINDOW; |
---|
185 | role_table [Accessibility_ROLE_EXTENDED] = SPI_ROLE_EXTENDED; |
---|
186 | role_table [Accessibility_ROLE_HEADER] = SPI_ROLE_HEADER; |
---|
187 | role_table [Accessibility_ROLE_FOOTER] = SPI_ROLE_FOOTER; |
---|
188 | role_table [Accessibility_ROLE_PARAGRAPH] = SPI_ROLE_PARAGRAPH; |
---|
189 | role_table [Accessibility_ROLE_RULER] = SPI_ROLE_RULER; |
---|
190 | role_table [Accessibility_ROLE_APPLICATION] = SPI_ROLE_APPLICATION; |
---|
191 | |
---|
192 | return TRUE; |
---|
193 | } |
---|
194 | |
---|
195 | static AccessibleRole |
---|
196 | cspi_role_from_spi_role (Accessibility_Role role) |
---|
197 | { |
---|
198 | /* array is sized according to IDL roles because IDL roles are the index */ |
---|
199 | static AccessibleRole cspi_role_table [Accessibility_ROLE_LAST_DEFINED]; |
---|
200 | static SPIBoolean is_initialized = FALSE; |
---|
201 | AccessibleRole cspi_role; |
---|
202 | if (!is_initialized) |
---|
203 | { |
---|
204 | is_initialized = cspi_init_role_table (cspi_role_table); |
---|
205 | } |
---|
206 | if (role >= 0 && role < Accessibility_ROLE_LAST_DEFINED) |
---|
207 | { |
---|
208 | cspi_role = cspi_role_table [role]; |
---|
209 | } |
---|
210 | else |
---|
211 | { |
---|
212 | cspi_role = SPI_ROLE_EXTENDED; |
---|
213 | } |
---|
214 | return cspi_role; |
---|
215 | } |
---|
216 | |
---|
217 | /** |
---|
218 | * AccessibleRole_getName: |
---|
219 | * @role: an #AccessibleRole object to query. |
---|
220 | * |
---|
221 | * Get a localizeable string that indicates the name of an #AccessibleRole. |
---|
222 | * <em>DEPRECATED.</em> |
---|
223 | * |
---|
224 | * Returns: a localizable string name for an #AccessibleRole enumerated type. |
---|
225 | **/ |
---|
226 | char * |
---|
227 | AccessibleRole_getName (AccessibleRole role) |
---|
228 | { |
---|
229 | if (role < MAX_ROLES && role_names [(int) role]) |
---|
230 | { |
---|
231 | return CORBA_string_dup (role_names [(int) role]); |
---|
232 | } |
---|
233 | else |
---|
234 | { |
---|
235 | return g_strdup (""); |
---|
236 | } |
---|
237 | } |
---|
238 | |
---|
239 | /** |
---|
240 | * Accessible_ref: |
---|
241 | * @obj: a pointer to the #Accessible object on which to operate. |
---|
242 | * |
---|
243 | * Increment the reference count for an #Accessible object. |
---|
244 | **/ |
---|
245 | void |
---|
246 | Accessible_ref (Accessible *obj) |
---|
247 | { |
---|
248 | cspi_object_ref (obj); |
---|
249 | } |
---|
250 | |
---|
251 | /** |
---|
252 | * Accessible_unref: |
---|
253 | * @obj: a pointer to the #Accessible object on which to operate. |
---|
254 | * |
---|
255 | * Decrement the reference count for an #Accessible object. |
---|
256 | **/ |
---|
257 | void |
---|
258 | Accessible_unref (Accessible *obj) |
---|
259 | { |
---|
260 | cspi_object_unref (obj); |
---|
261 | } |
---|
262 | |
---|
263 | /** |
---|
264 | * Accessible_getName: |
---|
265 | * @obj: a pointer to the #Accessible object on which to operate. |
---|
266 | * |
---|
267 | * Get the name of an #Accessible object. |
---|
268 | * |
---|
269 | * Returns: a UTF-8 string indicating the name of the #Accessible object. |
---|
270 | * or NULL on exception |
---|
271 | **/ |
---|
272 | char * |
---|
273 | Accessible_getName (Accessible *obj) |
---|
274 | { |
---|
275 | char *retval; |
---|
276 | |
---|
277 | cspi_return_val_if_fail (obj != NULL, NULL); |
---|
278 | |
---|
279 | retval = Accessibility_Accessible__get_name (CSPI_OBJREF (obj), cspi_ev ()); |
---|
280 | |
---|
281 | cspi_return_val_if_ev ("getName", NULL); |
---|
282 | |
---|
283 | return retval; |
---|
284 | } |
---|
285 | |
---|
286 | /** |
---|
287 | * Accessible_getDescription: |
---|
288 | * @obj: a pointer to the #Accessible object on which to operate. |
---|
289 | * |
---|
290 | * Get the description of an #Accessible object. |
---|
291 | * |
---|
292 | * Returns: a UTF-8 string describing the #Accessible object. |
---|
293 | * or NULL on exception |
---|
294 | **/ |
---|
295 | char * |
---|
296 | Accessible_getDescription (Accessible *obj) |
---|
297 | { |
---|
298 | char *retval; |
---|
299 | |
---|
300 | cspi_return_val_if_fail (obj != NULL, NULL); |
---|
301 | |
---|
302 | retval = Accessibility_Accessible__get_description (CSPI_OBJREF (obj), |
---|
303 | cspi_ev ()); |
---|
304 | |
---|
305 | cspi_return_val_if_ev ("getDescription", NULL); |
---|
306 | |
---|
307 | return retval; |
---|
308 | } |
---|
309 | |
---|
310 | /** |
---|
311 | * Accessible_getParent: |
---|
312 | * @obj: a pointer to the #Accessible object to query. |
---|
313 | * |
---|
314 | * Get an #Accessible object's parent container. |
---|
315 | * |
---|
316 | * Returns: a pointer tothe #Accessible object which contains the given |
---|
317 | * #Accessible instance, or NULL if the @obj has no parent container. |
---|
318 | * |
---|
319 | **/ |
---|
320 | Accessible * |
---|
321 | Accessible_getParent (Accessible *obj) |
---|
322 | { |
---|
323 | Accessible *retval; |
---|
324 | |
---|
325 | cspi_return_val_if_fail (obj != NULL, NULL); |
---|
326 | |
---|
327 | retval = cspi_object_add ( |
---|
328 | Accessibility_Accessible__get_parent (CSPI_OBJREF (obj), |
---|
329 | cspi_ev ())); |
---|
330 | |
---|
331 | cspi_return_val_if_ev ("getParent", NULL); |
---|
332 | |
---|
333 | return retval; |
---|
334 | } |
---|
335 | |
---|
336 | /** |
---|
337 | * Accessible_getChildCount: |
---|
338 | * @obj: a pointer to the #Accessible object on which to operate. |
---|
339 | * |
---|
340 | * Get the number of children contained by an #Accessible object. |
---|
341 | * |
---|
342 | * Returns: a #long indicating the number of #Accessible children |
---|
343 | * contained by an #Accessible object. or -1 on exception |
---|
344 | * |
---|
345 | **/ |
---|
346 | long |
---|
347 | Accessible_getChildCount (Accessible *obj) |
---|
348 | { |
---|
349 | long retval; |
---|
350 | |
---|
351 | cspi_return_val_if_fail (obj != NULL, -1); |
---|
352 | |
---|
353 | retval = Accessibility_Accessible__get_childCount (CSPI_OBJREF (obj), |
---|
354 | cspi_ev ()); |
---|
355 | |
---|
356 | cspi_return_val_if_ev ("getChildCount", -1); |
---|
357 | |
---|
358 | return retval; |
---|
359 | } |
---|
360 | |
---|
361 | /** |
---|
362 | * Accessible_getChildAtIndex: |
---|
363 | * @obj: a pointer to the #Accessible object on which to operate. |
---|
364 | * @childIndex: a #long indicating which child is specified. |
---|
365 | * |
---|
366 | * Get the #Accessible child of an #Accessible object at a given index. |
---|
367 | * |
---|
368 | * Returns: a pointer to the #Accessible child object at index |
---|
369 | * @childIndex. or NULL on exception |
---|
370 | **/ |
---|
371 | Accessible * |
---|
372 | Accessible_getChildAtIndex (Accessible *obj, |
---|
373 | long int childIndex) |
---|
374 | { |
---|
375 | Accessible *retval; |
---|
376 | |
---|
377 | cspi_return_val_if_fail (obj != NULL, NULL); |
---|
378 | |
---|
379 | retval = cspi_object_add ( |
---|
380 | Accessibility_Accessible_getChildAtIndex (CSPI_OBJREF (obj), |
---|
381 | childIndex, cspi_ev ())); |
---|
382 | |
---|
383 | cspi_return_val_if_ev ("getChildAtIndex", NULL); |
---|
384 | return retval; |
---|
385 | } |
---|
386 | |
---|
387 | /** |
---|
388 | * Accessible_getIndexInParent: |
---|
389 | * @obj: a pointer to the #Accessible object on which to operate. |
---|
390 | * |
---|
391 | * Get the index of an #Accessible object in its containing #Accessible. |
---|
392 | * |
---|
393 | * Returns: a #long indicating the index of the #Accessible object |
---|
394 | * in its parent (i.e. containing) #Accessible instance, |
---|
395 | * or -1 if @obj has no containing parent or on exception. |
---|
396 | **/ |
---|
397 | long |
---|
398 | Accessible_getIndexInParent (Accessible *obj) |
---|
399 | { |
---|
400 | long retval; |
---|
401 | |
---|
402 | cspi_return_val_if_fail (obj != NULL, -1); |
---|
403 | |
---|
404 | retval = Accessibility_Accessible_getIndexInParent (CSPI_OBJREF (obj), cspi_ev ()); |
---|
405 | |
---|
406 | cspi_return_val_if_ev ("getIndexInparent", -1); |
---|
407 | return retval; |
---|
408 | } |
---|
409 | |
---|
410 | /** |
---|
411 | * Accessible_getRelationSet: |
---|
412 | * @obj: a pointer to the #Accessible object on which to operate. |
---|
413 | * |
---|
414 | * Get the set of #AccessibleRelation objects which describe this #Accessible object's |
---|
415 | * relationships with other #Accessible objects. |
---|
416 | * |
---|
417 | * Returns: an array of #AccessibleRelation pointers. or NULL on exception |
---|
418 | **/ |
---|
419 | AccessibleRelation ** |
---|
420 | Accessible_getRelationSet (Accessible *obj) |
---|
421 | { |
---|
422 | int i; |
---|
423 | int n_relations; |
---|
424 | AccessibleRelation **relations; |
---|
425 | Accessibility_RelationSet *relation_set; |
---|
426 | |
---|
427 | cspi_return_val_if_fail (obj != NULL, NULL); |
---|
428 | |
---|
429 | relation_set = |
---|
430 | Accessibility_Accessible_getRelationSet (CSPI_OBJREF (obj), cspi_ev ()); |
---|
431 | |
---|
432 | cspi_return_val_if_ev ("getRelationSet", NULL); |
---|
433 | |
---|
434 | n_relations = relation_set->_length; |
---|
435 | relations = malloc (sizeof (AccessibleRelation *) * (n_relations + 1)); |
---|
436 | |
---|
437 | for (i = 0; i < n_relations; ++i) |
---|
438 | { |
---|
439 | relations[i] = cspi_object_add (CORBA_Object_duplicate ( |
---|
440 | relation_set->_buffer[i], cspi_ev ())); |
---|
441 | } |
---|
442 | relations[i] = NULL; |
---|
443 | |
---|
444 | CORBA_free (relation_set); |
---|
445 | |
---|
446 | return relations; |
---|
447 | } |
---|
448 | |
---|
449 | /** |
---|
450 | * Accessible_getRole: |
---|
451 | * @obj: a pointer to the #Accessible object on which to operate. |
---|
452 | * |
---|
453 | * Get the UI role of an #Accessible object. |
---|
454 | * A UTF-8 string describing this role can be obtained via Accessible_getRoleName (). |
---|
455 | * |
---|
456 | * Returns: the #AccessibleRole of the object. |
---|
457 | * |
---|
458 | **/ |
---|
459 | AccessibleRole |
---|
460 | Accessible_getRole (Accessible *obj) |
---|
461 | { |
---|
462 | Accessibility_Role retval; |
---|
463 | |
---|
464 | cspi_return_val_if_fail (obj != NULL, SPI_ROLE_INVALID); |
---|
465 | |
---|
466 | retval = |
---|
467 | Accessibility_Accessible_getRole (CSPI_OBJREF (obj), cspi_ev ()); |
---|
468 | |
---|
469 | cspi_return_val_if_ev ("getRole", SPI_ROLE_INVALID); |
---|
470 | |
---|
471 | return cspi_role_from_spi_role (retval); |
---|
472 | } |
---|
473 | |
---|
474 | /** |
---|
475 | * Accessible_getRoleName: |
---|
476 | * @obj: a pointer to the #Accessible object on which to operate. |
---|
477 | * |
---|
478 | * Get a UTF-8 string describing the role this object plays in the UI. |
---|
479 | * This method will return useful values for roles that fall outside the |
---|
480 | * enumeration used in Accessible_getRole (). |
---|
481 | * |
---|
482 | * Returns: a UTF-8 string specifying the role of this #Accessible object. |
---|
483 | * |
---|
484 | **/ |
---|
485 | char * |
---|
486 | Accessible_getRoleName (Accessible *obj) |
---|
487 | { |
---|
488 | char *retval; |
---|
489 | |
---|
490 | cspi_return_val_if_fail (obj != NULL, CORBA_string_dup ("invalid")); |
---|
491 | |
---|
492 | retval = |
---|
493 | Accessibility_Accessible_getRoleName (CSPI_OBJREF (obj), cspi_ev ()); |
---|
494 | |
---|
495 | cspi_return_val_if_ev ("getRoleName", CORBA_string_dup ("invalid")); |
---|
496 | |
---|
497 | return retval; |
---|
498 | } |
---|
499 | |
---|
500 | /** |
---|
501 | * Accessible_getStateSet: |
---|
502 | * @obj: a pointer to the #Accessible object on which to operate. |
---|
503 | * |
---|
504 | * Not Yet Implemented. |
---|
505 | * |
---|
506 | * Returns: a pointer to an #AccessibleStateSet representing the object's current state. |
---|
507 | **/ |
---|
508 | AccessibleStateSet * |
---|
509 | Accessible_getStateSet (Accessible *obj) |
---|
510 | { |
---|
511 | AccessibleStateSet *retval; |
---|
512 | Accessibility_StateSet corba_stateset; |
---|
513 | Accessibility_StateSeq *corba_seq; |
---|
514 | |
---|
515 | cspi_return_val_if_fail (obj != NULL, NULL); |
---|
516 | |
---|
517 | corba_stateset = Accessibility_Accessible_getState ( |
---|
518 | CSPI_OBJREF (obj), cspi_ev ()); |
---|
519 | cspi_return_val_if_ev ("getState", NULL); |
---|
520 | |
---|
521 | corba_seq = Accessibility_StateSet_getStates (corba_stateset, cspi_ev ()); |
---|
522 | cspi_return_val_if_ev ("getState", NULL); |
---|
523 | |
---|
524 | retval = spi_state_set_cache_new (corba_seq); |
---|
525 | |
---|
526 | CORBA_free (corba_seq); |
---|
527 | cspi_release_unref (corba_stateset); |
---|
528 | |
---|
529 | return retval; |
---|
530 | } |
---|
531 | |
---|
532 | /* Interface query methods */ |
---|
533 | |
---|
534 | /** |
---|
535 | * Accessible_isAction: |
---|
536 | * @obj: a pointer to the #Accessible instance to query. |
---|
537 | * |
---|
538 | * Query whether the specified #Accessible implements #AccessibleAction. |
---|
539 | * |
---|
540 | * Returns: #TRUE if @obj implements the #AccessibleAction interface, |
---|
541 | * #FALSE otherwise. |
---|
542 | **/ |
---|
543 | SPIBoolean |
---|
544 | Accessible_isAction (Accessible *obj) |
---|
545 | { |
---|
546 | return cspi_accessible_is_a (obj, |
---|
547 | "IDL:Accessibility/Action:1.0"); |
---|
548 | } |
---|
549 | |
---|
550 | /** |
---|
551 | * Accessible_isApplication: |
---|
552 | * @obj: a pointer to the #Accessible instance to query. |
---|
553 | * |
---|
554 | * Query whether the specified #Accessible implements #AccessibleApplication. |
---|
555 | * |
---|
556 | * Returns: #TRUE if @obj implements the #AccessibleApplication interface, |
---|
557 | * #FALSE otherwise. |
---|
558 | **/ |
---|
559 | SPIBoolean |
---|
560 | Accessible_isApplication (Accessible *obj) |
---|
561 | { |
---|
562 | return cspi_accessible_is_a (obj, |
---|
563 | "IDL:Accessibility/Application:1.0"); |
---|
564 | } |
---|
565 | |
---|
566 | /** |
---|
567 | * Accessible_isComponent: |
---|
568 | * @obj: a pointer to the #Accessible instance to query. |
---|
569 | * |
---|
570 | * Query whether the specified #Accessible implements #AccessibleComponent. |
---|
571 | * |
---|
572 | * Returns: #TRUE if @obj implements the #AccessibleComponent interface, |
---|
573 | * #FALSE otherwise. |
---|
574 | **/ |
---|
575 | SPIBoolean |
---|
576 | Accessible_isComponent (Accessible *obj) |
---|
577 | { |
---|
578 | return cspi_accessible_is_a (obj, |
---|
579 | "IDL:Accessibility/Component:1.0"); |
---|
580 | } |
---|
581 | |
---|
582 | /** |
---|
583 | * Accessible_isEditableText: |
---|
584 | * @obj: a pointer to the #Accessible instance to query. |
---|
585 | * |
---|
586 | * Query whether the specified #Accessible implements #AccessibleEditableText. |
---|
587 | * |
---|
588 | * Returns: #TRUE if @obj implements the #AccessibleEditableText interface, |
---|
589 | * #FALSE otherwise. |
---|
590 | **/ |
---|
591 | SPIBoolean |
---|
592 | Accessible_isEditableText (Accessible *obj) |
---|
593 | { |
---|
594 | return cspi_accessible_is_a (obj, |
---|
595 | "IDL:Accessibility/EditableText:1.0"); |
---|
596 | } |
---|
597 | |
---|
598 | /** |
---|
599 | * Accessible_isHypertext: |
---|
600 | * @obj: a pointer to the #Accessible instance to query. |
---|
601 | * |
---|
602 | * Query whether the specified #Accessible implements #AccessibleHypertext. |
---|
603 | * |
---|
604 | * Returns: #TRUE if @obj implements the #AccessibleHypertext interface, |
---|
605 | * #FALSE otherwise. |
---|
606 | **/ |
---|
607 | SPIBoolean |
---|
608 | Accessible_isHypertext (Accessible *obj) |
---|
609 | { |
---|
610 | return cspi_accessible_is_a (obj, |
---|
611 | "IDL:Accessibility/Hypertext:1.0"); |
---|
612 | } |
---|
613 | |
---|
614 | /** |
---|
615 | * Accessible_isImage: |
---|
616 | * @obj: a pointer to the #Accessible instance to query. |
---|
617 | * |
---|
618 | * Query whether the specified #Accessible implements #AccessibleImage. |
---|
619 | * |
---|
620 | * Returns: #TRUE if @obj implements the #AccessibleImage interface, |
---|
621 | * #FALSE otherwise. |
---|
622 | **/ |
---|
623 | SPIBoolean |
---|
624 | Accessible_isImage (Accessible *obj) |
---|
625 | { |
---|
626 | return cspi_accessible_is_a (obj, |
---|
627 | "IDL:Accessibility/Image:1.0"); |
---|
628 | } |
---|
629 | |
---|
630 | /** |
---|
631 | * Accessible_isSelection: |
---|
632 | * @obj: a pointer to the #Accessible instance to query. |
---|
633 | * |
---|
634 | * Query whether the specified #Accessible implements #AccessibleSelection. |
---|
635 | * |
---|
636 | * Returns: #TRUE if @obj implements the #AccessibleSelection interface, |
---|
637 | * #FALSE otherwise. |
---|
638 | **/ |
---|
639 | SPIBoolean |
---|
640 | Accessible_isSelection (Accessible *obj) |
---|
641 | { |
---|
642 | return cspi_accessible_is_a (obj, |
---|
643 | "IDL:Accessibility/Selection:1.0"); |
---|
644 | } |
---|
645 | |
---|
646 | /** |
---|
647 | * Accessible_isTable: |
---|
648 | * @obj: a pointer to the #Accessible instance to query. |
---|
649 | * |
---|
650 | * Query whether the specified #Accessible implements #AccessibleTable. |
---|
651 | * |
---|
652 | * Returns: #TRUE if @obj implements the #AccessibleTable interface, |
---|
653 | * #FALSE otherwise. |
---|
654 | **/ |
---|
655 | SPIBoolean |
---|
656 | Accessible_isTable (Accessible *obj) |
---|
657 | { |
---|
658 | return cspi_accessible_is_a (obj, |
---|
659 | "IDL:Accessibility/Table:1.0"); |
---|
660 | } |
---|
661 | |
---|
662 | /** |
---|
663 | * Accessible_isStreamableContent: |
---|
664 | * @obj: a pointer to the #Accessible instance to query. |
---|
665 | * |
---|
666 | * Query whether the specified #Accessible implements |
---|
667 | * #AccessibleStreamableContent. |
---|
668 | * |
---|
669 | * Returns: #TRUE if @obj implements the #AccessibleStreamableContent interface, |
---|
670 | * #FALSE otherwise. |
---|
671 | **/ |
---|
672 | SPIBoolean |
---|
673 | Accessible_isStreamableContent (Accessible *obj) |
---|
674 | { |
---|
675 | return cspi_accessible_is_a (obj, |
---|
676 | "IDL:Accessibility/StreamableContent:1.0"); |
---|
677 | } |
---|
678 | |
---|
679 | /** |
---|
680 | * Accessible_isText: |
---|
681 | * @obj: a pointer to the #Accessible instance to query. |
---|
682 | * |
---|
683 | * Query whether the specified #Accessible implements #AccessibleText. |
---|
684 | * |
---|
685 | * Returns: #TRUE if @obj implements the #AccessibleText interface, |
---|
686 | * #FALSE otherwise. |
---|
687 | **/ |
---|
688 | SPIBoolean |
---|
689 | Accessible_isText (Accessible *obj) |
---|
690 | { |
---|
691 | return cspi_accessible_is_a (obj, |
---|
692 | "IDL:Accessibility/Text:1.0"); |
---|
693 | } |
---|
694 | |
---|
695 | /** |
---|
696 | * Accessible_isValue: |
---|
697 | * @obj: a pointer to the #Accessible instance to query. |
---|
698 | * |
---|
699 | * Query whether the specified #Accessible implements #AccessibleValue. |
---|
700 | * |
---|
701 | * Returns: #TRUE if @obj implements the #AccessibleValue interface, |
---|
702 | * #FALSE otherwise. |
---|
703 | **/ |
---|
704 | SPIBoolean |
---|
705 | Accessible_isValue (Accessible *obj) |
---|
706 | { |
---|
707 | return cspi_accessible_is_a (obj, |
---|
708 | "IDL:Accessibility/Value:1.0"); |
---|
709 | } |
---|
710 | |
---|
711 | /** |
---|
712 | * Accessible_getApplication: |
---|
713 | * @obj: a pointer to the #Accessible instance to query. |
---|
714 | * |
---|
715 | * Get the #AccessibleApplication interface for an #Accessible. |
---|
716 | * |
---|
717 | * Returns: a pointer to an #AccessibleApplication interface instance, or |
---|
718 | * NULL if @obj does not implement #AccessibleApplication. |
---|
719 | **/ |
---|
720 | AccessibleApplication * |
---|
721 | Accessible_getApplication (Accessible *obj) |
---|
722 | { |
---|
723 | return (AccessibleApplication *) Accessible_queryInterface ( |
---|
724 | obj, "IDL:Accessibility/Application:1.0"); |
---|
725 | } |
---|
726 | |
---|
727 | /** |
---|
728 | * Accessible_getAction: |
---|
729 | * @obj: a pointer to the #Accessible instance to query. |
---|
730 | * |
---|
731 | * Get the #AccessibleAction interface for an #Accessible. |
---|
732 | * |
---|
733 | * Returns: a pointer to an #AccessibleAction interface instance, or |
---|
734 | * NULL if @obj does not implement #AccessibleAction. |
---|
735 | **/ |
---|
736 | AccessibleAction * |
---|
737 | Accessible_getAction (Accessible *obj) |
---|
738 | { |
---|
739 | return (AccessibleAction *) Accessible_queryInterface ( |
---|
740 | obj, "IDL:Accessibility/Action:1.0"); |
---|
741 | } |
---|
742 | |
---|
743 | /** |
---|
744 | * Accessible_getComponent: |
---|
745 | * @obj: a pointer to the #Accessible instance to query. |
---|
746 | * |
---|
747 | * Get the #AccessibleComponent interface for an #Accessible. |
---|
748 | * |
---|
749 | * Returns: a pointer to an #AccessibleComponent interface instance, or |
---|
750 | * NULL if @obj does not implement #AccessibleComponent. |
---|
751 | **/ |
---|
752 | AccessibleComponent * |
---|
753 | Accessible_getComponent (Accessible *obj) |
---|
754 | { |
---|
755 | return (AccessibleComponent *) Accessible_queryInterface ( |
---|
756 | obj, "IDL:Accessibility/Component:1.0"); |
---|
757 | } |
---|
758 | |
---|
759 | /** |
---|
760 | * Accessible_getEditableText: |
---|
761 | * @obj: a pointer to the #Accessible instance to query. |
---|
762 | * |
---|
763 | * Get the #AccessibleEditableText interface for an #Accessible. |
---|
764 | * |
---|
765 | * Returns: a pointer to an #AccessibleEditableText interface instance, or |
---|
766 | * NULL if @obj does not implement #AccessibleEditableText. |
---|
767 | **/ |
---|
768 | AccessibleEditableText * |
---|
769 | Accessible_getEditableText (Accessible *obj) |
---|
770 | { |
---|
771 | return (AccessibleEditableText *) Accessible_queryInterface ( |
---|
772 | obj, "IDL:Accessibility/EditableText:1.0"); |
---|
773 | } |
---|
774 | |
---|
775 | |
---|
776 | |
---|
777 | /** |
---|
778 | * Accessible_getHypertext: |
---|
779 | * @obj: a pointer to the #Accessible instance to query. |
---|
780 | * |
---|
781 | * Get the #AccessibleHypertext interface for an #Accessible. |
---|
782 | * |
---|
783 | * Returns: a pointer to an #AccessibleHypertext interface instance, or |
---|
784 | * NULL if @obj does not implement #AccessibleHypertext. |
---|
785 | **/ |
---|
786 | AccessibleHypertext * |
---|
787 | Accessible_getHypertext (Accessible *obj) |
---|
788 | { |
---|
789 | return (AccessibleHypertext *) Accessible_queryInterface ( |
---|
790 | obj, "IDL:Accessibility/Hypertext:1.0"); |
---|
791 | } |
---|
792 | |
---|
793 | |
---|
794 | |
---|
795 | /** |
---|
796 | * Accessible_getImage: |
---|
797 | * @obj: a pointer to the #Accessible instance to query. |
---|
798 | * |
---|
799 | * Get the #AccessibleImage interface for an #Accessible. |
---|
800 | * |
---|
801 | * Returns: a pointer to an #AccessibleImage interface instance, or |
---|
802 | * NULL if @obj does not implement #AccessibleImage. |
---|
803 | **/ |
---|
804 | AccessibleImage * |
---|
805 | Accessible_getImage (Accessible *obj) |
---|
806 | { |
---|
807 | return (AccessibleImage *) Accessible_queryInterface ( |
---|
808 | obj, "IDL:Accessibility/Image:1.0"); |
---|
809 | } |
---|
810 | |
---|
811 | |
---|
812 | |
---|
813 | /** |
---|
814 | * Accessible_getSelection: |
---|
815 | * @obj: a pointer to the #Accessible instance to query. |
---|
816 | * |
---|
817 | * Get the #AccessibleSelection interface for an #Accessible. |
---|
818 | * |
---|
819 | * Returns: a pointer to an #AccessibleSelection interface instance, or |
---|
820 | * NULL if @obj does not implement #AccessibleSelection. |
---|
821 | **/ |
---|
822 | AccessibleSelection * |
---|
823 | Accessible_getSelection (Accessible *obj) |
---|
824 | { |
---|
825 | return (AccessibleSelection *) Accessible_queryInterface ( |
---|
826 | obj, "IDL:Accessibility/Selection:1.0"); |
---|
827 | } |
---|
828 | |
---|
829 | |
---|
830 | |
---|
831 | /** |
---|
832 | * Accessible_getStreamableContent: |
---|
833 | * @obj: a pointer to the #Accessible instance to query. |
---|
834 | * |
---|
835 | * Get the #AccessibleStreamableContent interface for an #Accessible. |
---|
836 | * |
---|
837 | * Returns: a pointer to an #AccessibleStreamableContent interface instance, or |
---|
838 | * NULL if @obj does not implement #AccessibleStreamableContent. |
---|
839 | **/ |
---|
840 | AccessibleStreamableContent * |
---|
841 | Accessible_getStreamableContent (Accessible *obj) |
---|
842 | { |
---|
843 | return (AccessibleStreamableContent *) Accessible_queryInterface ( |
---|
844 | obj, "IDL:Accessibility/StreamableContent:1.0"); |
---|
845 | } |
---|
846 | |
---|
847 | /** |
---|
848 | * Accessible_getTable: |
---|
849 | * @obj: a pointer to the #Accessible instance to query. |
---|
850 | * |
---|
851 | * Get the #AccessibleTable interface for an #Accessible. |
---|
852 | * |
---|
853 | * Returns: a pointer to an #AccessibleTable interface instance, or |
---|
854 | * NULL if @obj does not implement #AccessibleTable. |
---|
855 | **/ |
---|
856 | AccessibleTable * |
---|
857 | Accessible_getTable (Accessible *obj) |
---|
858 | { |
---|
859 | return (AccessibleTable *) Accessible_queryInterface ( |
---|
860 | obj, "IDL:Accessibility/Table:1.0"); |
---|
861 | } |
---|
862 | |
---|
863 | /** |
---|
864 | * Accessible_getText: |
---|
865 | * @obj: a pointer to the #Accessible instance to query. |
---|
866 | * |
---|
867 | * Get the #AccessibleText interface for an #Accessible. |
---|
868 | * |
---|
869 | * Returns: a pointer to an #AccessibleText interface instance, or |
---|
870 | * NULL if @obj does not implement #AccessibleText. |
---|
871 | **/ |
---|
872 | AccessibleText * |
---|
873 | Accessible_getText (Accessible *obj) |
---|
874 | { |
---|
875 | return (AccessibleText *) Accessible_queryInterface ( |
---|
876 | obj, "IDL:Accessibility/Text:1.0"); |
---|
877 | } |
---|
878 | |
---|
879 | |
---|
880 | |
---|
881 | /** |
---|
882 | * Accessible_getValue: |
---|
883 | * @obj: a pointer to the #Accessible instance to query. |
---|
884 | * |
---|
885 | * Get the #AccessibleValue interface for an #Accessible. |
---|
886 | * |
---|
887 | * Returns: a pointer to an #AccessibleValue interface instance, or |
---|
888 | * NULL if @obj does not implement #AccessibleValue. |
---|
889 | **/ |
---|
890 | AccessibleValue * |
---|
891 | Accessible_getValue (Accessible *obj) |
---|
892 | { |
---|
893 | return (AccessibleValue *) Accessible_queryInterface ( |
---|
894 | obj, "IDL:Accessibility/Value:1.0"); |
---|
895 | } |
---|
896 | |
---|
897 | |
---|
898 | |
---|
899 | /** |
---|
900 | * Accessible_queryInterface: |
---|
901 | * @obj: a pointer to the #Accessible instance to query. |
---|
902 | * @interface_name: a UTF-8 character string specifiying the requested interface. |
---|
903 | * |
---|
904 | * Query an #Accessible object to for a named interface. |
---|
905 | * |
---|
906 | * Returns: an instance of the named interface object, if it is implemented |
---|
907 | * by @obj, or NULL otherwise. |
---|
908 | * |
---|
909 | **/ |
---|
910 | AccessibleUnknown * |
---|
911 | Accessible_queryInterface (Accessible *obj, |
---|
912 | const char *interface_name) |
---|
913 | { |
---|
914 | Bonobo_Unknown iface; |
---|
915 | |
---|
916 | if (!obj) |
---|
917 | { |
---|
918 | return NULL; |
---|
919 | } |
---|
920 | |
---|
921 | iface = Accessibility_Accessible_queryInterface (CSPI_OBJREF (obj), |
---|
922 | interface_name, |
---|
923 | cspi_ev ()); |
---|
924 | |
---|
925 | |
---|
926 | cspi_return_val_if_ev ("queryInterface", NULL); |
---|
927 | |
---|
928 | /* |
---|
929 | * FIXME: we need to be fairly sure that references are going |
---|
930 | * to mach up if we are going to expose QueryInterface, ie. we |
---|
931 | * can't allow people to do: |
---|
932 | * b = a.qi ("b"); b.unref, b.unref to release a's reference. |
---|
933 | * this should be no real problem though for this level of API |
---|
934 | * user. |
---|
935 | */ |
---|
936 | |
---|
937 | return cspi_object_add (iface); |
---|
938 | } |
---|
939 | |
---|
940 | |
---|
941 | /** |
---|
942 | * AccessibleRelation_ref: |
---|
943 | * @obj: a pointer to the #AccessibleRelation object on which to operate. |
---|
944 | * |
---|
945 | * Increment the reference count for an #AccessibleRelation object. |
---|
946 | * |
---|
947 | **/ |
---|
948 | void |
---|
949 | AccessibleRelation_ref (AccessibleRelation *obj) |
---|
950 | { |
---|
951 | cspi_object_ref (obj); |
---|
952 | } |
---|
953 | |
---|
954 | /** |
---|
955 | * AccessibleRelation_unref: |
---|
956 | * @obj: a pointer to the #AccessibleRelation object on which to operate. |
---|
957 | * |
---|
958 | * Decrement the reference count for an #AccessibleRelation object. |
---|
959 | * |
---|
960 | **/ |
---|
961 | void |
---|
962 | AccessibleRelation_unref (AccessibleRelation *obj) |
---|
963 | { |
---|
964 | cspi_object_unref (obj); |
---|
965 | } |
---|
966 | |
---|
967 | /** |
---|
968 | * AccessibleRelation_getRelationType: |
---|
969 | * @obj: a pointer to the #AccessibleRelation object to query. |
---|
970 | * |
---|
971 | * Get the type of relationship represented by an #AccessibleRelation. |
---|
972 | * |
---|
973 | * Returns: an #AccessibleRelationType indicating the type of relation |
---|
974 | * encapsulated in this #AccessibleRelation object. |
---|
975 | * |
---|
976 | **/ |
---|
977 | AccessibleRelationType |
---|
978 | AccessibleRelation_getRelationType (AccessibleRelation *obj) |
---|
979 | { |
---|
980 | AccessibleRelationType retval; |
---|
981 | |
---|
982 | cspi_return_val_if_fail (obj, SPI_RELATION_NULL); |
---|
983 | retval = |
---|
984 | Accessibility_Relation_getRelationType (CSPI_OBJREF (obj), cspi_ev()); |
---|
985 | cspi_return_val_if_ev ("getRelationType", SPI_RELATION_NULL); |
---|
986 | return retval; |
---|
987 | } |
---|
988 | |
---|
989 | /** |
---|
990 | * AccessibleRelation_getNTargets: |
---|
991 | * @obj: a pointer to the #AccessibleRelation object to query. |
---|
992 | * |
---|
993 | * Get the number of objects which this relationship has as its |
---|
994 | * target objects (the subject is the #Accessible from which this |
---|
995 | * #AccessibleRelation originated). |
---|
996 | * |
---|
997 | * Returns: a short integer indicating how many target objects which the |
---|
998 | * originating #Accessible object has the #AccessibleRelation |
---|
999 | * relationship with. |
---|
1000 | **/ |
---|
1001 | int |
---|
1002 | AccessibleRelation_getNTargets (AccessibleRelation *obj) |
---|
1003 | { |
---|
1004 | int retval; |
---|
1005 | |
---|
1006 | cspi_return_val_if_fail (obj, -1); |
---|
1007 | retval = Accessibility_Relation_getNTargets (CSPI_OBJREF (obj), cspi_ev()); |
---|
1008 | cspi_return_val_if_ev ("getNTargets", -1); |
---|
1009 | return retval; |
---|
1010 | } |
---|
1011 | |
---|
1012 | /** |
---|
1013 | * AccessibleRelation_getTarget: |
---|
1014 | * @obj: a pointer to the #AccessibleRelation object to query. |
---|
1015 | * @i: a (zero-index) integer indicating which (of possibly several) target is requested. |
---|
1016 | * |
---|
1017 | * Get the @i-th target of a specified #AccessibleRelation relationship. |
---|
1018 | * |
---|
1019 | * Returns: an #Accessible which is the @i-th object with which the |
---|
1020 | * originating #Accessible has relationship specified in the |
---|
1021 | * #AccessibleRelation object. |
---|
1022 | * |
---|
1023 | **/ |
---|
1024 | Accessible * |
---|
1025 | AccessibleRelation_getTarget (AccessibleRelation *obj, int i) |
---|
1026 | { |
---|
1027 | Accessible *retval; |
---|
1028 | |
---|
1029 | cspi_return_val_if_fail (obj, NULL); |
---|
1030 | |
---|
1031 | retval = cspi_object_add ( |
---|
1032 | Accessibility_Relation_getTarget (CSPI_OBJREF(obj), |
---|
1033 | i, cspi_ev())); |
---|
1034 | cspi_return_val_if_ev ("getTarget", NULL); |
---|
1035 | return retval; |
---|
1036 | } |
---|
1037 | |
---|
1038 | /** |
---|
1039 | * AccessibleStateSet_ref: |
---|
1040 | * @obj: a pointer to the #AccessibleStateSet object on which to operate. |
---|
1041 | * |
---|
1042 | * Increment the reference count for an #AccessibleStateSet object. |
---|
1043 | * |
---|
1044 | **/ |
---|
1045 | void |
---|
1046 | AccessibleStateSet_ref (AccessibleStateSet *obj) |
---|
1047 | { |
---|
1048 | spi_state_set_cache_ref (obj); |
---|
1049 | } |
---|
1050 | |
---|
1051 | /** |
---|
1052 | * AccessibleStateSet_unref: |
---|
1053 | * @obj: a pointer to the #AccessibleStateSet object on which to operate. |
---|
1054 | * |
---|
1055 | * Decrement the reference count for an #AccessibleStateSet object. |
---|
1056 | * |
---|
1057 | **/ |
---|
1058 | void |
---|
1059 | AccessibleStateSet_unref (AccessibleStateSet *obj) |
---|
1060 | { |
---|
1061 | spi_state_set_cache_unref (obj); |
---|
1062 | } |
---|
1063 | |
---|
1064 | static Accessibility_StateType |
---|
1065 | spi_state_to_corba (AccessibleState state) |
---|
1066 | { |
---|
1067 | #define MAP_STATE(a) \ |
---|
1068 | case SPI_STATE_##a: \ |
---|
1069 | return Accessibility_STATE_##a |
---|
1070 | |
---|
1071 | switch (state) |
---|
1072 | { |
---|
1073 | MAP_STATE (INVALID); |
---|
1074 | MAP_STATE (ACTIVE); |
---|
1075 | MAP_STATE (ARMED); |
---|
1076 | MAP_STATE (BUSY); |
---|
1077 | MAP_STATE (CHECKED); |
---|
1078 | MAP_STATE (DEFUNCT); |
---|
1079 | MAP_STATE (EDITABLE); |
---|
1080 | MAP_STATE (ENABLED); |
---|
1081 | MAP_STATE (EXPANDABLE); |
---|
1082 | MAP_STATE (EXPANDED); |
---|
1083 | MAP_STATE (FOCUSABLE); |
---|
1084 | MAP_STATE (FOCUSED); |
---|
1085 | MAP_STATE (HORIZONTAL); |
---|
1086 | MAP_STATE (ICONIFIED); |
---|
1087 | MAP_STATE (MODAL); |
---|
1088 | MAP_STATE (MULTI_LINE); |
---|
1089 | MAP_STATE (MULTISELECTABLE); |
---|
1090 | MAP_STATE (OPAQUE); |
---|
1091 | MAP_STATE (PRESSED); |
---|
1092 | MAP_STATE (RESIZABLE); |
---|
1093 | MAP_STATE (SELECTABLE); |
---|
1094 | MAP_STATE (SELECTED); |
---|
1095 | MAP_STATE (SENSITIVE); |
---|
1096 | MAP_STATE (SHOWING); |
---|
1097 | MAP_STATE (SINGLE_LINE); |
---|
1098 | MAP_STATE (STALE); |
---|
1099 | MAP_STATE (TRANSIENT); |
---|
1100 | MAP_STATE (VERTICAL); |
---|
1101 | MAP_STATE (VISIBLE); |
---|
1102 | MAP_STATE (MANAGES_DESCENDANTS); |
---|
1103 | default: |
---|
1104 | return ATK_STATE_INVALID; |
---|
1105 | } |
---|
1106 | #undef MAP_STATE |
---|
1107 | } |
---|
1108 | |
---|
1109 | /** |
---|
1110 | * AccessibleStateSet_contains: |
---|
1111 | * @obj: a pointer to the #AccessibleStateSet object on which to operate. |
---|
1112 | * @state: an #AccessibleState for which the specified #AccessibleStateSet |
---|
1113 | * will be queried. |
---|
1114 | * |
---|
1115 | * Determine whether a given #AccessibleStateSet includes a given state; that is, |
---|
1116 | * whether @state is true for the stateset in question. |
---|
1117 | * |
---|
1118 | * Returns: #TRUE if @state is true/included in the given #AccessibleStateSet, |
---|
1119 | * otherwise #FALSE. |
---|
1120 | * |
---|
1121 | **/ |
---|
1122 | SPIBoolean |
---|
1123 | AccessibleStateSet_contains (AccessibleStateSet *obj, |
---|
1124 | AccessibleState state) |
---|
1125 | { |
---|
1126 | return spi_state_set_cache_contains (obj, spi_state_to_corba (state)); |
---|
1127 | } |
---|
1128 | |
---|
1129 | /** |
---|
1130 | * AccessibleStateSet_add: |
---|
1131 | * @obj: a pointer to the #AccessibleStateSet object on which to operate. |
---|
1132 | * @state: an #AccessibleState to be added to the specified #AccessibleStateSet |
---|
1133 | * |
---|
1134 | * Add a particular #AccessibleState to an #AccessibleStateSet (i.e. set the |
---|
1135 | * given state to #TRUE in the stateset. |
---|
1136 | * |
---|
1137 | **/ |
---|
1138 | void |
---|
1139 | AccessibleStateSet_add (AccessibleStateSet *obj, |
---|
1140 | AccessibleState state) |
---|
1141 | { |
---|
1142 | spi_state_set_cache_add (obj, spi_state_to_corba (state)); |
---|
1143 | } |
---|
1144 | |
---|
1145 | /** |
---|
1146 | * AccessibleStateSet_remove: |
---|
1147 | * @obj: a pointer to the #AccessibleStateSet object on which to operate. |
---|
1148 | * @state: an #AccessibleState to be removed from the specified #AccessibleStateSet |
---|
1149 | * |
---|
1150 | * Remove a particular #AccessibleState to an #AccessibleStateSet (i.e. set the |
---|
1151 | * given state to #FALSE in the stateset.) |
---|
1152 | * |
---|
1153 | **/ |
---|
1154 | void |
---|
1155 | AccessibleStateSet_remove (AccessibleStateSet *obj, |
---|
1156 | AccessibleState state) |
---|
1157 | { |
---|
1158 | spi_state_set_cache_remove (obj, spi_state_to_corba (state)); |
---|
1159 | } |
---|
1160 | |
---|
1161 | /** |
---|
1162 | * AccessibleStateSet_equals: |
---|
1163 | * @obj: a pointer to the first #AccessibleStateSet object on which to operate. |
---|
1164 | * @obj2: a pointer to the second #AccessibleStateSet object on which to operate. |
---|
1165 | * |
---|
1166 | * Determine whether two instances of #AccessibleStateSet are equivalent (i.e. |
---|
1167 | * consist of the same #AccessibleStates). Useful for checking multiple |
---|
1168 | * state variables at once; construct the target state then compare against it. |
---|
1169 | * |
---|
1170 | * @see AccessibleStateSet_compare(). |
---|
1171 | * |
---|
1172 | * Returns: #TRUE if the two #AccessibleStateSets are equivalent, |
---|
1173 | * otherwise #FALSE. |
---|
1174 | * |
---|
1175 | **/ |
---|
1176 | SPIBoolean |
---|
1177 | AccessibleStateSet_equals (AccessibleStateSet *obj, |
---|
1178 | AccessibleStateSet *obj2) |
---|
1179 | { |
---|
1180 | SPIBoolean eq; |
---|
1181 | AtkStateSet *cmp; |
---|
1182 | |
---|
1183 | if (obj == obj2) |
---|
1184 | { |
---|
1185 | return TRUE; |
---|
1186 | } |
---|
1187 | |
---|
1188 | cmp = spi_state_set_cache_xor (obj, obj2); |
---|
1189 | eq = spi_state_set_cache_is_empty (cmp); |
---|
1190 | spi_state_set_cache_unref (cmp); |
---|
1191 | |
---|
1192 | return eq; |
---|
1193 | } |
---|
1194 | |
---|
1195 | /** |
---|
1196 | * AccessibleStateSet_compare: |
---|
1197 | * @obj: a pointer to the first #AccessibleStateSet object on which to operate. |
---|
1198 | * @obj2: a pointer to the second #AccessibleStateSet object on which to operate. |
---|
1199 | * |
---|
1200 | * Determine the differences between two instances of #AccessibleStateSet. |
---|
1201 | * Not Yet Implemented. |
---|
1202 | *. |
---|
1203 | * @see AccessibleStateSet_equals(). |
---|
1204 | * |
---|
1205 | * Returns: an #AccessibleStateSet object containing all states contained on one of |
---|
1206 | * the two sets but not the other. |
---|
1207 | * |
---|
1208 | **/ |
---|
1209 | AccessibleStateSet * |
---|
1210 | AccessibleStateSet_compare (AccessibleStateSet *obj, |
---|
1211 | AccessibleStateSet *obj2) |
---|
1212 | { |
---|
1213 | return spi_state_set_cache_xor (obj, obj2); |
---|
1214 | } |
---|
1215 | |
---|
1216 | /** |
---|
1217 | * AccessibleStateSet_isEmpty: |
---|
1218 | * @obj: a pointer to the #AccessibleStateSet object on which to operate. |
---|
1219 | * |
---|
1220 | * Determine whether a given #AccessibleStateSet is the empty set. |
---|
1221 | * |
---|
1222 | * Returns: #TRUE if the given #AccessibleStateSet contains no (true) states, |
---|
1223 | * otherwise #FALSE. |
---|
1224 | * |
---|
1225 | **/ |
---|
1226 | SPIBoolean |
---|
1227 | AccessibleStateSet_isEmpty (AccessibleStateSet *obj) |
---|
1228 | { |
---|
1229 | return spi_state_set_cache_is_empty (obj); |
---|
1230 | } |
---|
1231 | |
---|
1232 | |
---|