Default implementations for some some functions atk_object_real_get_name,
[platform/upstream/atk.git] / atk / atkobject.h
1 /* ATK -  Accessibility Toolkit
2  * Copyright 2001 Sun Microsystems Inc.
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Library General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Library General Public License for more details.
13  *
14  * You should have received a copy of the GNU Library General Public
15  * License along with this library; if not, write to the
16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17  * Boston, MA 02111-1307, USA.
18  */
19
20 #ifndef __ATK_OBJECT_H__
21 #define __ATK_OBJECT_H__
22
23 #ifdef __cplusplus
24 extern "C" {
25 #endif /* __cplusplus */
26
27 #include <glib-object.h>
28
29 /*
30  * AtkObject represents the minimum information all accessible objects
31  * return. This information includes accessible name, accessible
32  * description, role and state of the object, as well information about
33  * its parent and children. It is also possible to obtain more specific
34  * accessibility information about a component if it supports one or more
35  * of the following interfaces:
36  */
37
38
39 /**
40  *AtkRole:
41  *@ATK_ROLE_INVALID: Invalid role
42  *@ATK_ROLE_ACCEL_LABEL: A label which represents an accelerator
43  *@ATK_ROLE_ALERT: An object which is an alert to the user
44  *@ATK_ROLE_ANIMATION: An object which is an animated image
45  *@ATK_ROLE_ARROW: An arrow in one of the four cardinal directions
46  *@ATK_ROLE_CALENDAR:  An object that displays a calendar and allows the user to select a date
47  *@ATK_ROLE_CANVAS: An object that can be drawn into and is used to trap events
48  *@ATK_ROLE_CHECK_BOX: A choice that can be checked or unchecked and provides a separate indicator for the current state
49  *@ATK_ROLE_CHECK_MENU_ITEM: A menu item with a check box
50  *@ATK_ROLE_COLOR_CHOOSER: A specialized dialog that lets the user choose a color
51  *@ATK_ROLE_COLUMN_HEADER: The header for a column of data
52  *@ATK_ROLE_COMBO_BOX: A list of choices the user can select from
53  *@ATK_ROLE_DATE_EDITOR: An object whose purpose is to allow a user to edit a date
54  *@ATK_ROLE_DESKTOP_ICON: An inconifed internal frame within a DESKTOP_PANE
55  *@ATK_ROLE_DESKTOP_FRAME: A pane that supports internal frames and iconified versions of those internal frames
56  *@ATK_ROLE_DIAL: An object whose purpose is to allow a user to set a value
57  *@ATK_ROLE_DIALOG: A top level window with title bar and a border
58  *@ATK_ROLE_DIRECTORY_PANE: A pane that allows the user to navigate through and select the contents of a directory
59  *@ATK_ROLE_DRAWING_AREA: An object used for drawing custom user interface elements
60  *@ATK_ROLE_FILE_CHOOSER: A specialized dialog that lets the user choose a file
61  *@ATK_ROLE_FILLER: A object that fills up space in a user interface
62  *@ATK_ROLE_FONT_CHOOSER: A specialized dialog that lets the user choose a font
63  *@ATK_ROLE_FRAME: A top level window with a title bar, border, menubar, etc.
64  *@ATK_ROLE_GLASS_PANE: A pane that is guaranteed to be painted on top of all panes beneath it
65  *@ATK_ROLE_HTML_CONTAINER: A document container for HTML, whose children represent the document content
66  *@ATK_ROLE_ICON: A small fixed size picture, typically used to decorate components
67  *@ATK_ROLE_IMAGE: An object whose primary purpose is to display an image
68  *@ATK_ROLE_INTERNAL_FRAME: A frame-like object that is clipped by a desktop pane
69  *@ATK_ROLE_LABEL: An object used to present an icon or short string in an interface
70  *@ATK_ROLE_LAYERED_PANE: A specialized pane that allows its children to be drawn in layers, providing a form of stacking order
71  *@ATK_ROLE_LIST: An object that presents a list of objects to the user and allows the user to select one or more of them 
72  *@ATK_ROLE_LIST_ITEM: An object that represents an element of a list 
73  *@ATK_ROLE_MENU: An object usually found inside a menu bar that contains a list of actions the user can choose from
74  *@ATK_ROLE_MENU_BAR: An object usually drawn at the top of the primary dialog box of an application that contains a list of menus the user can choose from 
75  *@ATK_ROLE_MENU_ITEM: An object usually contained in a menu that presents an action the user can choose
76  *@ATK_ROLE_OPTION_PANE: A specialized pane whose primary use is inside a DIALOG
77  *@ATK_ROLE_PAGE_TAB: An object that is a child of a page tab list
78  *@ATK_ROLE_PAGE_TAB_LIST: An object that presents a series of panels (or page tabs), one at a time, through some mechanism provided by the object 
79  *@ATK_ROLE_PANEL: A generic container that is often used to group objects
80  *@ATK_ROLE_PASSWORD_TEXT: A text object uses for passwords, or other places where the text content is not shown visibly to the user
81  *@ATK_ROLE_POPUP_MENU: A temporary window that is usually used to offer the user a list of choices, and then hides when the user selects one of those choices
82  *@ATK_ROLE_PROGRESS_BAR: An object used to indicate how much of a task has been completed
83  *@ATK_ROLE_PUSH_BUTTON: An object the user can manipulate to tell the application to do something
84  *@ATK_ROLE_RADIO_BUTTON: A specialized check box that will cause other radio buttons in the same group to become unchecked when this one is checked
85  *@ATK_ROLE_RADIO_MENU_ITEM: A check menu item which belongs to a group. At each instant exactly one of the radio menu items from a group is selected
86  *@ATK_ROLE_ROOT_PANE: A specialized pane that has a glass pane and a layered pane as its children
87  *@ATK_ROLE_ROW_HEADER: The header for a row of data
88  *@ATK_ROLE_SCROLL_BAR: An object usually used to allow a user to incrementally view a large amount of data.
89  *@ATK_ROLE_SCROLL_PANE: An object that allows a user to incrementally view a large amount of information
90  *@ATK_ROLE_SEPARATOR: An object usually contained in a menu to provide a visible and logical separation of the contents in a menu
91  *@ATK_ROLE_SLIDER: An object that allows the user to select from a bounded range
92  *@ATK_ROLE_SPLIT_PANE: A specialized panel that presents two other panels at the same time
93  *@ATK_ROLE_SPIN_BUTTON: An object used to get an integer or floating point number from the user
94  *@ATK_ROLE_STATUSBAR: An object which reports messages of minor importance to the user
95  *@ATK_ROLE_TABLE: An object used to represent information in terms of rows and columns
96  *@ATK_ROLE_TABLE_CELL: A cell in a table
97  *@ATK_ROLE_TABLE_COLUMN_HEADER: The header for a column of a table
98  *@ATK_ROLE_TABLE_ROW_HEADER: The header for a row of a table
99  *@ATK_ROLE_TEAR_OFF_MENU_ITEM: A menu item used to tear off and reattach its menu
100  *@ATK_ROLE_TEXT: An object that presents text to the user
101  *@ATK_ROLE_TOGGLE_BUTTON: A specialized push button that can be checked or unchecked, but does not provide a separate indicator for the current state
102  *@ATK_ROLE_TOOL_BAR: A bar or palette usually composed of push buttons or toggle buttons
103  *@ATK_ROLE_TOOL_TIP: An object that provides information about another object
104  *@ATK_ROLE_TREE: An object used to represent hierarchical information to the user
105  *@ATK_ROLE_UNKNOWN: The object contains some Accessible information, but its role is not known
106  *@ATK_ROLE_VIEWPORT: An object usually used in a scroll pane
107  *@ATK_ROLE_WINDOW: A top level window with no title or border
108  *@ATK_ROLE_LAST_DEFINED: not a valid role, used for finding end of enumeration
109  * 
110  *Describes the role of an object
111  **/
112 typedef enum
113 {
114   ATK_ROLE_INVALID,
115   ATK_ROLE_ACCEL_LABEL,
116   ATK_ROLE_ALERT,
117   ATK_ROLE_ANIMATION,
118   ATK_ROLE_ARROW,
119   ATK_ROLE_CALENDAR,
120   ATK_ROLE_CANVAS,
121   ATK_ROLE_CHECK_BOX,
122   ATK_ROLE_CHECK_MENU_ITEM,
123   ATK_ROLE_COLOR_CHOOSER,
124   ATK_ROLE_COLUMN_HEADER,
125   ATK_ROLE_COMBO_BOX,
126   ATK_ROLE_DATE_EDITOR,
127   ATK_ROLE_DESKTOP_ICON,
128   ATK_ROLE_DESKTOP_FRAME,
129   ATK_ROLE_DIAL,
130   ATK_ROLE_DIALOG,
131   ATK_ROLE_DIRECTORY_PANE,
132   ATK_ROLE_DRAWING_AREA,
133   ATK_ROLE_FILE_CHOOSER,
134   ATK_ROLE_FILLER,
135   ATK_ROLE_FONT_CHOOSER,
136   ATK_ROLE_FRAME,
137   ATK_ROLE_GLASS_PANE,
138   ATK_ROLE_HTML_CONTAINER,
139   ATK_ROLE_ICON,
140   ATK_ROLE_IMAGE,
141   ATK_ROLE_INTERNAL_FRAME,
142   ATK_ROLE_LABEL,
143   ATK_ROLE_LAYERED_PANE,
144   ATK_ROLE_LIST,
145   ATK_ROLE_LIST_ITEM,
146   ATK_ROLE_MENU,
147   ATK_ROLE_MENU_BAR,
148   ATK_ROLE_MENU_ITEM,
149   ATK_ROLE_OPTION_PANE,
150   ATK_ROLE_PAGE_TAB,
151   ATK_ROLE_PAGE_TAB_LIST,
152   ATK_ROLE_PANEL,
153   ATK_ROLE_PASSWORD_TEXT,
154   ATK_ROLE_POPUP_MENU,
155   ATK_ROLE_PROGRESS_BAR,
156   ATK_ROLE_PUSH_BUTTON,
157   ATK_ROLE_RADIO_BUTTON,
158   ATK_ROLE_RADIO_MENU_ITEM,
159   ATK_ROLE_ROOT_PANE,
160   ATK_ROLE_ROW_HEADER,
161   ATK_ROLE_SCROLL_BAR,
162   ATK_ROLE_SCROLL_PANE,
163   ATK_ROLE_SEPARATOR,
164   ATK_ROLE_SLIDER,
165   ATK_ROLE_SPLIT_PANE,
166   ATK_ROLE_SPIN_BUTTON,
167   ATK_ROLE_STATUSBAR,
168   ATK_ROLE_TABLE,
169   ATK_ROLE_TABLE_CELL,
170   ATK_ROLE_TABLE_COLUMN_HEADER,
171   ATK_ROLE_TABLE_ROW_HEADER,
172   ATK_ROLE_TEAR_OFF_MENU_ITEM,
173   ATK_ROLE_TEXT,
174   ATK_ROLE_TOGGLE_BUTTON,
175   ATK_ROLE_TOOL_BAR,
176   ATK_ROLE_TOOL_TIP,
177   ATK_ROLE_TREE,
178   ATK_ROLE_UNKNOWN,
179   ATK_ROLE_VIEWPORT,
180   ATK_ROLE_WINDOW,
181   ATK_ROLE_LAST_DEFINED
182 } AtkRole;
183
184 AtkRole                  atk_role_register        (const gchar *name);
185
186
187 #define ATK_TYPE_OBJECT                           (atk_object_get_type ())
188 #define ATK_OBJECT(obj)                           (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_OBJECT, AtkObject))
189 #define ATK_OBJECT_CLASS(klass)                   (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_OBJECT, AtkObjectClass))
190 #define ATK_IS_OBJECT(obj)                        (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_OBJECT))
191 #define ATK_IS_OBJECT_CLASS(klass)                (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_OBJECT))
192 #define ATK_OBJECT_GET_CLASS(obj)                 (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_OBJECT, AtkObjectClass))
193
194 #define ATK_TYPE_IMPLEMENTOR                      (atk_implementor_get_type ())
195 #define ATK_IS_IMPLEMENTOR(obj)                   G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_IMPLEMENTOR)
196 #define ATK_IMPLEMENTOR(obj)                      G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_IMPLEMENTOR, AtkImplementor)
197 #define ATK_IMPLEMENTOR_GET_IFACE(obj)            (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_IMPLEMENTOR, AtkImplementorIface))
198
199
200 typedef struct _AtkImplementor            AtkImplementor; /* dummy typedef */
201 typedef struct _AtkImplementorIface       AtkImplementorIface;
202
203
204 typedef struct _AtkObject                 AtkObject;
205 typedef struct _AtkObjectClass            AtkObjectClass;
206 typedef struct _AtkRelationSet            AtkRelationSet;
207 typedef struct _AtkStateSet               AtkStateSet;
208
209 struct _AtkPropertyValues
210 {
211   gchar  *property_name;
212   GValue old_value;
213   GValue new_value;
214 };
215
216 typedef struct _AtkPropertyValues        AtkPropertyValues;
217
218 /*
219  * For most properties the old_value field of AtkPropertyValues will
220  * not contain a valid value.
221  *
222  * Currently, the only property for which old_value is used is
223  * accessible-state; for instance if there is a focus state the
224  * property change handler will be called for the object which lost the focus
225  * with the old_value containing an AtkState value corresponding to focused
226  * and the property change handler will be called for the object which
227  * received the focus with the new_value containing an AtkState value
228  * corresponding to focused.
229  */
230 typedef void (*AtkPropertyChangeHandler) (AtkObject*, AtkPropertyValues*);
231
232
233 struct _AtkObject
234 {
235   GObject parent;
236
237   gchar *description;
238   gchar *name;
239   AtkObject *accessible_parent;
240   AtkRole role;
241   AtkRelationSet *relation_set;
242 };
243
244 struct _AtkObjectClass
245 {
246   GObjectClass parent;
247
248   /*
249    * Gets the accessible name of the object
250    */
251   G_CONST_RETURN gchar*    (* get_name)            (AtkObject                *accessible);
252   /*
253    * Gets the accessible description of the object
254    */
255   G_CONST_RETURN gchar*    (* get_description)     (AtkObject                *accessible);
256   /*
257    * Gets the accessible parent of the object
258    */
259   AtkObject*               (*get_parent)           (AtkObject                *accessible);
260
261   /*
262    * Gets the number of accessible children of the object
263    */
264   gint                    (* get_n_children)       (AtkObject                *accessible);
265   /*
266    * Returns a reference to the specified accessible child of the object.
267    * The accessible children are 0-based so the first accessible child is
268    * at index 0, the second at index 1 and so on.
269    */
270   AtkObject*              (* ref_child)            (AtkObject                *accessible,
271                                                     gint                      i);
272   /*
273    * Gets the 0-based index of this object in its parent; returns -1 if the
274    * object does not have an accessible parent.
275    */
276   gint                    (* get_index_in_parent) (AtkObject                 *accessible);
277   /*
278    * Gets the RelationSet associated with the object
279    */
280   AtkRelationSet*         (* ref_relation_set)    (AtkObject                 *accessible);
281   /*
282    * Gets the role of the object
283    */
284   AtkRole                 (* get_role)            (AtkObject                 *accessible);
285   /*
286    * Gets the state set of the object
287    */
288   AtkStateSet*            (* ref_state_set)       (AtkObject                 *accessible);
289   /*
290    * Sets the accessible name of the object
291    */
292   void                    (* set_name)            (AtkObject                 *accessible,
293                                                    const gchar               *name);
294   /*
295    * Sets the accessible description of the object
296    */
297   void                    (* set_description)     (AtkObject                 *accessible,
298                                                    const gchar               *description);
299   /*
300    * Sets the accessible parent of the object
301    */
302   void                    (* set_parent)          (AtkObject                 *accessible,
303                                                    AtkObject                 *parent);
304   /*
305    * Sets the accessible role of the object
306    */
307   void                    (* set_role)            (AtkObject                 *accessible,
308                                                    AtkRole                   role);
309   /*
310    * Specifies a function to be called when a property changes value
311    */
312 guint                     (* connect_property_change_handler)    (AtkObject
313                  *accessible,
314                                                                   AtkPropertyChangeHandler       *handler);
315   /*
316    * Removes a property change handler which was specified using
317    * connect_property_change_handler
318    */
319 void                      (* remove_property_change_handler)     (AtkObject
320                 *accessible,
321                                                                   guint
322                 handler_id);
323   /*
324    * The signal handler which is executed when there is a change in the
325    * children of the object
326    */
327   void                    (* children_changed)    (AtkObject                  *accessible,
328                                                    gint                       change_index,
329                                                    AtkObject                  *changed_child);
330   /*
331    * The signal handler which is executed  when there is a focus event
332    * for an object.
333    */
334   void                    (*focus_event)          (AtkObject                  *accessible,
335                                                    gboolean                   focus_in);
336   /*
337    * The signal handler which is executed  when there is a property_change 
338    * signal for an object.
339    */
340   gint                    (*property_change)      (AtkObject                 *accessible,
341                                                    AtkPropertyValues         *values);
342
343 };
344
345 GType            atk_object_get_type   (void);
346
347 struct _AtkImplementorIface
348 {
349   GTypeInterface parent;
350
351   AtkObject*   (*ref_accessible) (AtkImplementor *implementor);
352 };
353 GType atk_implementor_get_type (void);
354
355 /*
356  * This method uses the ref_accessible method in AtkImplementorIface,
357  * if the object's class implements AtkImplementorIface.
358  * Otherwise it returns %NULL.
359  *
360  * IMPORTANT:
361  * Note also that because this method may return flyweight objects,
362  * it increments the returned AtkObject's reference count.
363  * Therefore it is the responsibility of the calling
364  * program to unreference the object when no longer needed.
365  * (c.f. gtk_widget_get_accessible() where this is not the case).
366  */
367 AtkObject*              atk_implementor_ref_accessible            (AtkImplementor *implementor);
368
369 /*
370  * Properties directly supported by AtkObject
371  */
372
373 G_CONST_RETURN gchar*   atk_object_get_name                       (AtkObject *accessible);
374 G_CONST_RETURN gchar*   atk_object_get_description                (AtkObject *accessible);
375 AtkObject*              atk_object_get_parent                     (AtkObject *accessible);
376 gint                    atk_object_get_n_accessible_children      (AtkObject *accessible);
377 AtkObject*              atk_object_ref_accessible_child           (AtkObject *accessible,
378                                                                    gint        i);
379 AtkRelationSet*         atk_object_ref_relation_set               (AtkObject *accessible);
380 AtkRole                 atk_object_get_role                       (AtkObject *accessible);
381 AtkStateSet*            atk_object_ref_state_set                  (AtkObject *accessible);
382 gint                    atk_object_get_index_in_parent            (AtkObject *accessible);
383 void                    atk_object_set_name                       (AtkObject *accessible,
384                                                                    const gchar *name);
385 void                    atk_object_set_description                (AtkObject *accessible,
386                                                                    const gchar *description);
387 void                    atk_object_set_parent                     (AtkObject *accessible,
388                                                                    AtkObject *parent);
389 void                    atk_object_set_role                       (AtkObject *accessible,
390                                                                    AtkRole   role);
391
392
393 /*
394  * to install property change listener, one must
395  * install signal handler for gobject "properties_changed" signal.
396  * (for single notifications of multiple changes).
397  * We could use the "notify" signal instead.
398  *
399  */
400 guint                atk_object_connect_property_change_handler  (AtkObject                      *accessible,
401                                                                   AtkPropertyChangeHandler       *handler);
402 void                 atk_object_remove_property_change_handler  (AtkObject                      *accessible,
403                                                                   guint                         handler_id);
404
405 /*
406  * Note: the properties which are registered with the GType
407  *   property registry, for type ATK_TYPE_OBJECT, are as follows:
408  *
409  *   "accessible-name"
410  *   "accessible-description"
411  *   "accessible-parent"
412  *   "accessible-child"
413  *   "accessible-role"
414  *   "accessible-state"
415  *
416  * accessibility property change listeners should use the
417  *   normal GObject property interfaces and "properties_changed"
418  *   signal handler semantics to interpret the property change
419  *   information relayed from AtkObject.
420  *   (AtkObject instances will connect to the "properties_changed"
421  *   signal in their host objects, and relay the signals when appropriate).
422  */
423
424 /* For other signals, see related interfaces
425  *
426  *    AtkActionIface,
427  *    AtkComponentIface,
428  *    AtkHypertextIface,
429  *    AtkImageIface,
430  *    AtkSelectionIface,
431  *    AtkTableIface,
432  *    AtkTextIface,
433  *    AtkValueIface.
434  *
435  *  The usage model for obtaining these interface instances is:
436  *    ATK_<interfacename>_GET_IFACE(GObject *accessible),
437  *    where accessible, though specified as a GObject, is
438  *    the AtkObject instance being queried.
439  *  More usually, the interface will be used via a cast to the
440  *    interface's corresponding "type":
441  *
442  *    AtkText textImpl = ATK_TEXT(accessible);
443  *    if (textImpl)
444  *      {
445  *        cpos = atk_text_get_caret_position(textImpl);
446  *      }
447  *
448  *  If it's known in advance that accessible implements AtkTextIface,
449  *    this is shortened to:
450  *
451  *    cpos = atk_text_get_caret_position (ATK_TEXT (accessible));
452  */
453
454 #ifdef __cplusplus
455 }
456 #endif /* __cplusplus */
457
458
459 #endif /* __ATK_OBJECT_H__ */