AtkObject

ATK Library Reference Manual
<<< Previous Page	Home	Up	Next Page >>>

Details

struct AtkObject

struct AtkObject
{
  GObject parent;

  gchar *description;
  gchar *name;
  AtkObject *accessible_parent;
  AtkRole role;
  AtkRelationSet *relation_set;
  AtkLayer layer;
};

enum AtkRole

typedef enum
{
  ATK_ROLE_INVALID = 0, 
  ATK_ROLE_ACCEL_LABEL,
  ATK_ROLE_ALERT,
  ATK_ROLE_ANIMATION,
  ATK_ROLE_ARROW,
  ATK_ROLE_CALENDAR,
  ATK_ROLE_CANVAS,
  ATK_ROLE_CHECK_BOX,
  ATK_ROLE_CHECK_MENU_ITEM,
  ATK_ROLE_COLOR_CHOOSER,
  ATK_ROLE_COLUMN_HEADER,
  ATK_ROLE_COMBO_BOX,
  ATK_ROLE_DATE_EDITOR,
  ATK_ROLE_DESKTOP_ICON,
  ATK_ROLE_DESKTOP_FRAME,
  ATK_ROLE_DIAL,
  ATK_ROLE_DIALOG,
  ATK_ROLE_DIRECTORY_PANE,
  ATK_ROLE_DRAWING_AREA,
  ATK_ROLE_FILE_CHOOSER,
  ATK_ROLE_FILLER,
  ATK_ROLE_FONT_CHOOSER,
  ATK_ROLE_FRAME,
  ATK_ROLE_GLASS_PANE,
  ATK_ROLE_HTML_CONTAINER,
  ATK_ROLE_ICON,
  ATK_ROLE_IMAGE,
  ATK_ROLE_INTERNAL_FRAME,
  ATK_ROLE_LABEL,
  ATK_ROLE_LAYERED_PANE,
  ATK_ROLE_LIST,
  ATK_ROLE_LIST_ITEM,
  ATK_ROLE_MENU,
  ATK_ROLE_MENU_BAR,
  ATK_ROLE_MENU_ITEM,
  ATK_ROLE_OPTION_PANE,
  ATK_ROLE_PAGE_TAB,
  ATK_ROLE_PAGE_TAB_LIST,
  ATK_ROLE_PANEL,
  ATK_ROLE_PASSWORD_TEXT,
  ATK_ROLE_POPUP_MENU,
  ATK_ROLE_PROGRESS_BAR,
  ATK_ROLE_PUSH_BUTTON,
  ATK_ROLE_RADIO_BUTTON,
  ATK_ROLE_RADIO_MENU_ITEM,
  ATK_ROLE_ROOT_PANE,
  ATK_ROLE_ROW_HEADER,
  ATK_ROLE_SCROLL_BAR,
  ATK_ROLE_SCROLL_PANE,
  ATK_ROLE_SEPARATOR,
  ATK_ROLE_SLIDER,
  ATK_ROLE_SPLIT_PANE,
  ATK_ROLE_SPIN_BUTTON,
  ATK_ROLE_STATUSBAR,
  ATK_ROLE_TABLE,
  ATK_ROLE_TABLE_CELL,
  ATK_ROLE_TABLE_COLUMN_HEADER,
  ATK_ROLE_TABLE_ROW_HEADER,
  ATK_ROLE_TEAR_OFF_MENU_ITEM,
  ATK_ROLE_TERMINAL,
  ATK_ROLE_TEXT,
  ATK_ROLE_TOGGLE_BUTTON,
  ATK_ROLE_TOOL_BAR,
  ATK_ROLE_TOOL_TIP,
  ATK_ROLE_TREE,
  ATK_ROLE_TREE_TABLE,
  ATK_ROLE_UNKNOWN,
  ATK_ROLE_VIEWPORT,
  ATK_ROLE_WINDOW,
  ATK_ROLE_LAST_DEFINED
} AtkRole;

Describes the role of an object

These are the built-in enumerated roles that UI components can have in ATK. Other roles may be added at runtime, so an AtkRole >= ATK_ROLE_LAST_DEFINED is not necessarily an error.

`ATK_ROLE_INVALID`	Invalid role
`ATK_ROLE_ACCEL_LABEL`	A label which represents an accelerator
`ATK_ROLE_ALERT`	An object which is an alert to the user
`ATK_ROLE_ANIMATION`	An object which is an animated image
`ATK_ROLE_ARROW`	An arrow in one of the four cardinal directions
`ATK_ROLE_CALENDAR`	An object that displays a calendar and allows the user to select a date
`ATK_ROLE_CANVAS`	An object that can be drawn into and is used to trap events
`ATK_ROLE_CHECK_BOX`	A choice that can be checked or unchecked and provides a separate indicator for the current state
`ATK_ROLE_CHECK_MENU_ITEM`	A menu item with a check box
`ATK_ROLE_COLOR_CHOOSER`	A specialized dialog that lets the user choose a color
`ATK_ROLE_COLUMN_HEADER`	The header for a column of data
`ATK_ROLE_COMBO_BOX`	A list of choices the user can select from
`ATK_ROLE_DATE_EDITOR`	An object whose purpose is to allow a user to edit a date
`ATK_ROLE_DESKTOP_ICON`	An inconifed internal frame within a DESKTOP_PANE
`ATK_ROLE_DESKTOP_FRAME`	A pane that supports internal frames and iconified versions of those internal frames
`ATK_ROLE_DIAL`	An object whose purpose is to allow a user to set a value
`ATK_ROLE_DIALOG`	A top level window with title bar and a border
`ATK_ROLE_DIRECTORY_PANE`	A pane that allows the user to navigate through and select the contents of a directory
`ATK_ROLE_DRAWING_AREA`	An object used for drawing custom user interface elements
`ATK_ROLE_FILE_CHOOSER`	A specialized dialog that lets the user choose a file
`ATK_ROLE_FILLER`	A object that fills up space in a user interface
`ATK_ROLE_FONT_CHOOSER`	A specialized dialog that lets the user choose a font
`ATK_ROLE_FRAME`	A top level window with a title bar, border, menubar, etc.
`ATK_ROLE_GLASS_PANE`	A pane that is guaranteed to be painted on top of all panes beneath it
`ATK_ROLE_HTML_CONTAINER`	A document container for HTML, whose children represent the document content
`ATK_ROLE_ICON`	A small fixed size picture, typically used to decorate components
`ATK_ROLE_IMAGE`	An object whose primary purpose is to display an image
`ATK_ROLE_INTERNAL_FRAME`	A frame-like object that is clipped by a desktop pane
`ATK_ROLE_LABEL`	An object used to present an icon or short string in an interface
`ATK_ROLE_LAYERED_PANE`	A specialized pane that allows its children to be drawn in layers, providing a form of stacking order
`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
`ATK_ROLE_LIST_ITEM`	An object that represents an element of a list
`ATK_ROLE_MENU`	An object usually found inside a menu bar that contains a list of actions the user can choose from
`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
`ATK_ROLE_MENU_ITEM`	An object usually contained in a menu that presents an action the user can choose
`ATK_ROLE_OPTION_PANE`	A specialized pane whose primary use is inside a DIALOG
`ATK_ROLE_PAGE_TAB`	An object that is a child of a page tab list
`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
`ATK_ROLE_PANEL`	A generic container that is often used to group objects
`ATK_ROLE_PASSWORD_TEXT`	A text object uses for passwords, or other places where the text content is not shown visibly to the user
`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
`ATK_ROLE_PROGRESS_BAR`	An object used to indicate how much of a task has been completed
`ATK_ROLE_PUSH_BUTTON`	An object the user can manipulate to tell the application to do something
`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
`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
`ATK_ROLE_ROOT_PANE`	A specialized pane that has a glass pane and a layered pane as its children
`ATK_ROLE_ROW_HEADER`	The header for a row of data
`ATK_ROLE_SCROLL_BAR`	An object usually used to allow a user to incrementally view a large amount of data.
`ATK_ROLE_SCROLL_PANE`	An object that allows a user to incrementally view a large amount of information
`ATK_ROLE_SEPARATOR`	An object usually contained in a menu to provide a visible and logical separation of the contents in a menu
`ATK_ROLE_SLIDER`	An object that allows the user to select from a bounded range
`ATK_ROLE_SPLIT_PANE`	A specialized panel that presents two other panels at the same time
`ATK_ROLE_SPIN_BUTTON`	An object used to get an integer or floating point number from the user
`ATK_ROLE_STATUSBAR`	An object which reports messages of minor importance to the user
`ATK_ROLE_TABLE`	An object used to represent information in terms of rows and columns
`ATK_ROLE_TABLE_CELL`	A cell in a table
`ATK_ROLE_TABLE_COLUMN_HEADER`	The header for a column of a table
`ATK_ROLE_TABLE_ROW_HEADER`	The header for a row of a table
`ATK_ROLE_TEAR_OFF_MENU_ITEM`	A menu item used to tear off and reattach its menu
`ATK_ROLE_TERMINAL`	An object that represents an accessible terminal
`ATK_ROLE_TEXT`	An object that presents text to the user
`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
`ATK_ROLE_TOOL_BAR`	A bar or palette usually composed of push buttons or toggle buttons
`ATK_ROLE_TOOL_TIP`	An object that provides information about another object
`ATK_ROLE_TREE`	An object used to represent hierarchical information to the user
`ATK_ROLE_TREE_TABLE`	An object capable of expanding and collapsing rows as well as showing multiple columns of data
`ATK_ROLE_UNKNOWN`	The object contains some Accessible information, but its role is not known
`ATK_ROLE_VIEWPORT`	An object usually used in a scroll pane
`ATK_ROLE_WINDOW`	A top level window with no title or border
`ATK_ROLE_LAST_DEFINED`	not a valid role, used for finding end of enumeration

atk_role_register ()

AtkRole     atk_role_register               (const gchar *name);

Registers the role specified by name.

`name` :	a character string describing the new role.
Returns :	an AtkRole for the new role.

enum AtkLayer

typedef enum
{
  ATK_LAYER_INVALID,
  ATK_LAYER_BACKGROUND,
  ATK_LAYER_CANVAS,
  ATK_LAYER_WIDGET,
  ATK_LAYER_MDI,
  ATK_LAYER_POPUP,
  ATK_LAYER_OVERLAY
} AtkLayer;

Describes the layer of a component

These enumerated "layer values" are used when determining which UI rendering layer a component is drawn into, which can help in making determinations of when components occlude one another.

`ATK_LAYER_INVALID`	The object does not have a layer
`ATK_LAYER_BACKGROUND`	This layer is reserved for the desktop background
`ATK_LAYER_CANVAS`	This layer is used for Canvas components
`ATK_LAYER_WIDGET`	This layer is normally used for components
`ATK_LAYER_MDI`	This layer is used for layered components
`ATK_LAYER_POPUP`	This layer is used for popup components, such as menus
`ATK_LAYER_OVERLAY`	This layer is reserved for future use.

struct AtkImplementor

struct AtkImplementor;

struct AtkImplementorIface

struct AtkImplementorIface
{
  GTypeInterface parent;

  AtkObject*   (*ref_accessible) (AtkImplementor *implementor);
};

This interface provides an alternative means of obtaining AtkObjects from a GOBject instance, and for querying whether a GObject instance provides ATK functionality.

struct AtkRelationSet

struct AtkRelationSet
{
  GObject parent;

  GPtrArray *relations;
};

struct AtkPropertyValues

struct AtkPropertyValues
{
  const gchar  *property_name;
  GValue old_value;
  GValue new_value;
};

AtkFunction ()

gboolean    (*AtkFunction)                  (gpointer data);

`data` :
Returns :

AtkPropertyChangeHandler ()

void        (*AtkPropertyChangeHandler)     (AtkObject*,
                                             AtkPropertyValues*);

`Param1` :
`Param2` :

atk_implementor_ref_accessible ()

AtkObject*  atk_implementor_ref_accessible  (AtkImplementor *implementor);

Gets a reference to an object's AtkObject implementation, if the object implements AtkObjectIface

`implementor` :	The GObject instance which should implement AtkImplementorIface if a non-null return value is required.
Returns :	a reference to an object's AtkObject implementation

atk_object_get_name ()

G_CONST_RETURN gchar* atk_object_get_name   (AtkObject *accessible);

Gets the accessible name of the accessible.

`accessible` :	an AtkObject
Returns :	a character string representing the accessible name of the object.

atk_object_get_description ()

G_CONST_RETURN gchar* atk_object_get_description
                                            (AtkObject *accessible);

Gets the accessible description of the accessible.

`accessible` :	an AtkObject
Returns :	a character string representing the accessible description of the accessible.

atk_object_get_parent ()

AtkObject*  atk_object_get_parent           (AtkObject *accessible);

Gets the accessible parent of the accessible.

`accessible` :	an AtkObject
Returns :	a AtkObject representing the accessible parent of the accessible

atk_object_get_n_accessible_children ()

gint        atk_object_get_n_accessible_children
                                            (AtkObject *accessible);

Gets the number of accessible children of the accessible.

`accessible` :	an AtkObject
Returns :	an integer representing the number of accessible children of the accessible.

atk_object_ref_accessible_child ()

AtkObject*  atk_object_ref_accessible_child (AtkObject *accessible,
                                             gint i);

Gets a reference to the specified accessible child of the object. The accessible children are 0-based so the first accessible child is at index 0, the second at index 1 and so on.

`accessible` :	an AtkObject
`i` :	a gint representing the position of the child, starting from 0
Returns :	an AtkObject representing the specified accessible child of the accessible.

atk_object_ref_relation_set ()

AtkRelationSet* atk_object_ref_relation_set (AtkObject *accessible);

Gets the AtkRelationSet associated with the object.

`accessible` :	an AtkObject
Returns :	an AtkRelationSet representing the relation set of the object.

atk_object_get_layer ()

AtkLayer    atk_object_get_layer            (AtkObject *accessible);

Gets the layer of the accessible. DEPRECATED: use atk_component_get_layer instead!

`accessible` :	an AtkObject
Returns :	an AtkLayer which is the layer of the accessible

atk_object_get_mdi_zorder ()

gint        atk_object_get_mdi_zorder       (AtkObject *accessible);

Gets the zorder of the accessible. The value G_MININT will be returned if the layer of the accessible is not ATK_LAYER_MDI. DEPRECATED: use atk_component_get_mdi_zorder instead!

`accessible` :	an AtkObject
Returns :	a gint which is the zorder of the accessible, i.e. the depth at which the component is shown in relation to other components in the same container.

atk_object_get_role ()

AtkRole     atk_object_get_role             (AtkObject *accessible);

Gets the role of the accessible.

`accessible` :	an AtkObject
Returns :	an AtkRole which is the role of the accessible

atk_object_ref_state_set ()

AtkStateSet* atk_object_ref_state_set       (AtkObject *accessible);

Gets a reference to the state set of the accessible; the caller must unreference it when it is no longer needed.

`accessible` :	an AtkObject
Returns :	a reference to an AtkStateSet which is the state set of the accessible

atk_object_get_index_in_parent ()

gint        atk_object_get_index_in_parent  (AtkObject *accessible);

Gets the 0-based index of this accessible in its parent; returns -1 if the accessible does not have an accessible parent.

`accessible` :	an AtkObject
Returns :	an integer which is the index of the accessible in its parent

atk_object_set_name ()

void        atk_object_set_name             (AtkObject *accessible,
                                             const gchar *name);

Sets the accessible name of the accessible.

`accessible` :	an AtkObject
`name` :	a character string to be set as the accessible name

atk_object_set_description ()

void        atk_object_set_description      (AtkObject *accessible,
                                             const gchar *description);

Sets the accessible description of the accessible.

`accessible` :	an AtkObject
`description` :	a character string to be set as the accessible description

atk_object_set_parent ()

void        atk_object_set_parent           (AtkObject *accessible,
                                             AtkObject *parent);

Sets the accessible parent of the accessible.

`accessible` :	an AtkObject
`parent` :	an AtkObject to be set as the accessible parent

atk_object_set_role ()

void        atk_object_set_role             (AtkObject *accessible,
                                             AtkRole role);

Sets the role of the accessible.

`accessible` :	an AtkObject
`role` :	an AtkRole to be set as the role

atk_object_connect_property_change_handler ()

guint       atk_object_connect_property_change_handler
                                            (AtkObject *accessible,
                                             AtkPropertyChangeHandler *handler);

Specifies a function to be called when a property changes value.

`accessible` :	an AtkObject
`handler` :	a function to be called when a property changes its value
Returns :	a guint which is the handler id used in atk_object_remove_property_change_handler()

atk_object_remove_property_change_handler ()

void        atk_object_remove_property_change_handler
                                            (AtkObject *accessible,
                                             guint handler_id);

Removes a property change handler.

`accessible` :	an AtkObject
`handler_id` :	a guint which identifies the handler to be removed.

atk_object_notify_state_change ()

void        atk_object_notify_state_change  (AtkObject *accessible,
                                             AtkState state,
                                             gboolean value);

Emits a state-change signal for the specified state.

`accessible` :	an AtkObject
`state` :	an AtkState whose state is changed
`value` :	a gboolean which indicates whether the state is being set on or off

atk_object_initialize ()

void        atk_object_initialize           (AtkObject *accessible,
                                             gpointer data);

This function is called when implementing subclasses of AtkObject. It does initialization required for the new object. It is intended that this function should called only in the ..._new() functions used to create an instance of a subclass of AtkObject

`accessible` :	a AtkObject
`data` :	a gpointer which identifies the object for which the AtkObject was created.

atk_role_get_name ()

G_CONST_RETURN gchar* atk_role_get_name     (AtkRole role);

Gets the description string describing the Roleype role.

`role` :	The AtkRole whose name is required
Returns :	the string describing the AtkRole

atk_role_for_name ()

AtkRole     atk_role_for_name               (const gchar *name);

Get the AtkRole type corresponding to a rolew name.

`name` :	a string which is the (non-localized) name of an ATK role.
Returns :	the AtkRole enumerated type corresponding to the specified name, or ATK_ROLE_INVALID if no matching role is found.