<MACRO>
<NAME>ATK_TYPE_ACTION</NAME>
#define ATK_TYPE_ACTION                    (atk_action_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_IS_ACTION</NAME>
#define ATK_IS_ACTION(obj)                 G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_ACTION)
</MACRO>
<MACRO>
<NAME>ATK_ACTION</NAME>
#define ATK_ACTION(obj)                    G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_ACTION, AtkAction)
</MACRO>
<MACRO>
<NAME>ATK_ACTION_GET_IFACE</NAME>
#define ATK_ACTION_GET_IFACE(obj)          (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_ACTION, AtkActionIface))
</MACRO>
<STRUCT>
<NAME>AtkActionIface</NAME>
struct _AtkActionIface
{
  GTypeInterface parent;

  gboolean                (*do_action)         (AtkAction         *action,
                                                gint              i);
  gint                    (*get_n_actions)     (AtkAction         *action);
  const gchar*            (*get_description)   (AtkAction         *action,
                                                gint              i);
  const gchar*            (*get_name)          (AtkAction         *action,
                                                gint              i);
  const gchar*            (*get_keybinding)    (AtkAction         *action,
                                                gint              i);
  gboolean                (*set_description)   (AtkAction         *action,
                                                gint              i,
                                                const gchar       *desc);
  const gchar*            (*get_localized_name)(AtkAction         *action,
						gint              i);
};
</STRUCT>
<FUNCTION>
<NAME>atk_action_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_action_do_action</NAME>
<RETURNS>gboolean</RETURNS>
AtkAction         *action, gint              i
</FUNCTION>
<FUNCTION>
<NAME>atk_action_get_n_actions</NAME>
<RETURNS>gint</RETURNS>
AtkAction *action
</FUNCTION>
<FUNCTION>
<NAME>atk_action_get_description</NAME>
<RETURNS>const gchar *</RETURNS>
AtkAction         *action, gint              i
</FUNCTION>
<FUNCTION>
<NAME>atk_action_get_name</NAME>
<RETURNS>const gchar *</RETURNS>
AtkAction         *action, gint              i
</FUNCTION>
<FUNCTION>
<NAME>atk_action_get_keybinding</NAME>
<RETURNS>const gchar *</RETURNS>
AtkAction         *action, gint              i
</FUNCTION>
<FUNCTION>
<NAME>atk_action_set_description</NAME>
<RETURNS>gboolean</RETURNS>
AtkAction         *action, gint              i, const gchar       *desc
</FUNCTION>
<FUNCTION>
<NAME>atk_action_get_localized_name</NAME>
<RETURNS>const gchar *</RETURNS>
AtkAction       *action, gint            i
</FUNCTION>
<STRUCT>
<NAME>AtkAction</NAME>
</STRUCT>
<ENUM>
<NAME>AtkScrollType</NAME>
typedef enum {
  ATK_SCROLL_TOP_LEFT,
  ATK_SCROLL_BOTTOM_RIGHT,
  ATK_SCROLL_TOP_EDGE,
  ATK_SCROLL_BOTTOM_EDGE,
  ATK_SCROLL_LEFT_EDGE,
  ATK_SCROLL_RIGHT_EDGE,
  ATK_SCROLL_ANYWHERE
} AtkScrollType;
</ENUM>
<MACRO>
<NAME>ATK_TYPE_COMPONENT</NAME>
#define ATK_TYPE_COMPONENT                    (atk_component_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_IS_COMPONENT</NAME>
#define ATK_IS_COMPONENT(obj)                 G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_COMPONENT)
</MACRO>
<MACRO>
<NAME>ATK_COMPONENT</NAME>
#define ATK_COMPONENT(obj)                    G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_COMPONENT, AtkComponent)
</MACRO>
<MACRO>
<NAME>ATK_COMPONENT_GET_IFACE</NAME>
#define ATK_COMPONENT_GET_IFACE(obj)          (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_COMPONENT, AtkComponentIface))
</MACRO>
<USER_FUNCTION>
<NAME>AtkFocusHandler</NAME>
<RETURNS>void</RETURNS>
AtkObject* object, gboolean focus_in
</USER_FUNCTION>
<STRUCT>
<NAME>AtkRectangle</NAME>
struct _AtkRectangle
{
  gint x;
  gint y;
  gint width;
  gint height;
};
</STRUCT>
<FUNCTION>
<NAME>atk_rectangle_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>ATK_TYPE_RECTANGLE</NAME>
#define ATK_TYPE_RECTANGLE (atk_rectangle_get_type ())
</MACRO>
<STRUCT>
<NAME>AtkComponentIface</NAME>
struct _AtkComponentIface
{
  GTypeInterface parent;

  guint          (* add_focus_handler)  (AtkComponent          *component,
                                         AtkFocusHandler        handler);

  gboolean       (* contains)           (AtkComponent          *component,
                                         gint                   x,
                                         gint                   y,
                                         AtkCoordType           coord_type);

  AtkObject*    (* ref_accessible_at_point)  (AtkComponent     *component,
                                         gint                   x,
                                         gint                   y,
                                         AtkCoordType           coord_type);
  void          (* get_extents)         (AtkComponent          *component,
                                         gint                  *x,
                                         gint                  *y,
                                         gint                  *width,
                                         gint                  *height,
                                         AtkCoordType          coord_type);
  void                     (* get_position)     (AtkComponent   *component,
                                                 gint           *x,
                                                 gint           *y,
                                                 AtkCoordType   coord_type);
  void                     (* get_size)                 (AtkComponent   *component,
                                                         gint           *width,
                                                         gint           *height);
  gboolean                 (* grab_focus)               (AtkComponent   *component);
  void                     (* remove_focus_handler)      (AtkComponent  *component,
                                                          guint         handler_id);
  gboolean                 (* set_extents)      (AtkComponent   *component,
                                                 gint           x,
                                                 gint           y,
                                                 gint           width,
                                                 gint           height,
                                                 AtkCoordType   coord_type);
  gboolean                 (* set_position)     (AtkComponent   *component,
                                                 gint           x,
                                                 gint           y,
                                                 AtkCoordType   coord_type);
  gboolean                 (* set_size)         (AtkComponent   *component,
                                                 gint           width,
                                                 gint           height);
  	
  AtkLayer                 (* get_layer)        (AtkComponent   *component);
  gint                     (* get_mdi_zorder)   (AtkComponent   *component);

  /*
   * signal handlers
   */
  void                     (* bounds_changed)   (AtkComponent   *component,
                                                 AtkRectangle   *bounds);
  gdouble                  (* get_alpha)        (AtkComponent   *component);

  /*
   * Scrolls this object so it becomes visible on the screen.
   * Since ATK 2.30
   */
  gboolean                (*scroll_to)          (AtkComponent   *component,
                                                 AtkScrollType   type);

  gboolean                (*scroll_to_point)    (AtkComponent   *component,
                                                 AtkCoordType    coords,
                                                 gint            x,
                                                 gint            y);
};
</STRUCT>
<FUNCTION>
<NAME>atk_component_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_component_add_focus_handler</NAME>
<DEPRECATED/>
<RETURNS>guint</RETURNS>
AtkComponent    *component, AtkFocusHandler handler
</FUNCTION>
<FUNCTION>
<NAME>atk_component_contains</NAME>
<RETURNS>gboolean</RETURNS>
AtkComponent    *component, gint            x, gint            y, AtkCoordType    coord_type
</FUNCTION>
<FUNCTION>
<NAME>atk_component_ref_accessible_at_point</NAME>
<RETURNS>AtkObject *</RETURNS>
AtkComponent    *component, gint            x, gint            y, AtkCoordType    coord_type
</FUNCTION>
<FUNCTION>
<NAME>atk_component_get_extents</NAME>
<RETURNS>void</RETURNS>
AtkComponent    *component, gint            *x, gint            *y, gint            *width, gint            *height, AtkCoordType    coord_type
</FUNCTION>
<FUNCTION>
<NAME>atk_component_get_position</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
AtkComponent    *component, gint            *x, gint            *y, AtkCoordType    coord_type
</FUNCTION>
<FUNCTION>
<NAME>atk_component_get_size</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
AtkComponent    *component, gint            *width, gint            *height
</FUNCTION>
<FUNCTION>
<NAME>atk_component_get_layer</NAME>
<RETURNS>AtkLayer</RETURNS>
AtkComponent    *component
</FUNCTION>
<FUNCTION>
<NAME>atk_component_get_mdi_zorder</NAME>
<RETURNS>gint</RETURNS>
AtkComponent    *component
</FUNCTION>
<FUNCTION>
<NAME>atk_component_grab_focus</NAME>
<RETURNS>gboolean</RETURNS>
AtkComponent    *component
</FUNCTION>
<FUNCTION>
<NAME>atk_component_remove_focus_handler</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
AtkComponent    *component, guint           handler_id
</FUNCTION>
<FUNCTION>
<NAME>atk_component_set_extents</NAME>
<RETURNS>gboolean</RETURNS>
AtkComponent    *component, gint            x, gint            y, gint            width, gint            height, AtkCoordType    coord_type
</FUNCTION>
<FUNCTION>
<NAME>atk_component_set_position</NAME>
<RETURNS>gboolean</RETURNS>
AtkComponent    *component, gint            x, gint            y, AtkCoordType    coord_type
</FUNCTION>
<FUNCTION>
<NAME>atk_component_set_size</NAME>
<RETURNS>gboolean</RETURNS>
AtkComponent    *component, gint            width, gint            height
</FUNCTION>
<FUNCTION>
<NAME>atk_component_get_alpha</NAME>
<RETURNS>gdouble</RETURNS>
AtkComponent    *component
</FUNCTION>
<FUNCTION>
<NAME>atk_component_scroll_to</NAME>
<RETURNS>gboolean</RETURNS>
AtkComponent    *component, AtkScrollType   type
</FUNCTION>
<FUNCTION>
<NAME>atk_component_scroll_to_point</NAME>
<RETURNS>gboolean</RETURNS>
AtkComponent    *component, AtkCoordType    coords, gint            x, gint            y
</FUNCTION>
<STRUCT>
<NAME>AtkComponent</NAME>
</STRUCT>
<MACRO>
<NAME>ATK_TYPE_DOCUMENT</NAME>
#define ATK_TYPE_DOCUMENT                   (atk_document_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_IS_DOCUMENT</NAME>
#define ATK_IS_DOCUMENT(obj)                G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_DOCUMENT)
</MACRO>
<MACRO>
<NAME>ATK_DOCUMENT</NAME>
#define ATK_DOCUMENT(obj)                   G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_DOCUMENT, AtkDocument)
</MACRO>
<MACRO>
<NAME>ATK_DOCUMENT_GET_IFACE</NAME>
#define ATK_DOCUMENT_GET_IFACE(obj)         (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_DOCUMENT, AtkDocumentIface))
</MACRO>
<STRUCT>
<NAME>AtkDocumentIface</NAME>
struct _AtkDocumentIface
{
  GTypeInterface parent;
  const gchar*          ( *get_document_type) (AtkDocument              *document);
  gpointer              ( *get_document)      (AtkDocument              *document);

  const gchar*          ( *get_document_locale) (AtkDocument              *document);
  AtkAttributeSet *     ( *get_document_attributes) (AtkDocument        *document);
  const gchar*          ( *get_document_attribute_value) (AtkDocument   *document,
                                                          const gchar   *attribute_name);
  gboolean              ( *set_document_attribute) (AtkDocument         *document,
                                                    const gchar         *attribute_name,
                                                    const gchar         *attribute_value);
  gint                  ( *get_current_page_number) (AtkDocument *document);
  gint                  ( *get_page_count) (AtkDocument *document);
};
</STRUCT>
<FUNCTION>
<NAME>atk_document_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_document_get_document_type</NAME>
<DEPRECATED/>
<RETURNS>const gchar *</RETURNS>
AtkDocument   *document
</FUNCTION>
<FUNCTION>
<NAME>atk_document_get_document</NAME>
<DEPRECATED/>
<RETURNS>gpointer</RETURNS>
AtkDocument   *document
</FUNCTION>
<FUNCTION>
<NAME>atk_document_get_locale</NAME>
<DEPRECATED/>
<RETURNS>const gchar *</RETURNS>
AtkDocument *document
</FUNCTION>
<FUNCTION>
<NAME>atk_document_get_attributes</NAME>
<RETURNS>AtkAttributeSet *</RETURNS>
AtkDocument *document
</FUNCTION>
<FUNCTION>
<NAME>atk_document_get_attribute_value</NAME>
<RETURNS>const gchar *</RETURNS>
AtkDocument *document, const gchar *attribute_name
</FUNCTION>
<FUNCTION>
<NAME>atk_document_set_attribute_value</NAME>
<RETURNS>gboolean</RETURNS>
AtkDocument *document, const gchar *attribute_name, const gchar *attribute_value
</FUNCTION>
<FUNCTION>
<NAME>atk_document_get_current_page_number</NAME>
<RETURNS>gint</RETURNS>
AtkDocument *document
</FUNCTION>
<FUNCTION>
<NAME>atk_document_get_page_count</NAME>
<RETURNS>gint</RETURNS>
AtkDocument *document
</FUNCTION>
<STRUCT>
<NAME>AtkDocument</NAME>
</STRUCT>
<MACRO>
<NAME>ATK_TYPE_EDITABLE_TEXT</NAME>
#define ATK_TYPE_EDITABLE_TEXT                    (atk_editable_text_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_IS_EDITABLE_TEXT</NAME>
#define ATK_IS_EDITABLE_TEXT(obj)                 G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_EDITABLE_TEXT)
</MACRO>
<MACRO>
<NAME>ATK_EDITABLE_TEXT</NAME>
#define ATK_EDITABLE_TEXT(obj)                    G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_EDITABLE_TEXT, AtkEditableText)
</MACRO>
<MACRO>
<NAME>ATK_EDITABLE_TEXT_GET_IFACE</NAME>
#define ATK_EDITABLE_TEXT_GET_IFACE(obj)          (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_EDITABLE_TEXT, AtkEditableTextIface))
</MACRO>
<STRUCT>
<NAME>AtkEditableTextIface</NAME>
struct _AtkEditableTextIface
{
  GTypeInterface parent_interface;

  gboolean (* set_run_attributes) (AtkEditableText  *text,
                                   AtkAttributeSet  *attrib_set,
                                   gint		    start_offset,
 				   gint		    end_offset);
  void   (* set_text_contents)    (AtkEditableText  *text,
                                   const gchar      *string);
  void   (* insert_text)          (AtkEditableText  *text,
                                   const gchar      *string,
                                   gint             length,
                                   gint             *position);
  void   (* copy_text)            (AtkEditableText  *text,
                                   gint             start_pos,
                                   gint             end_pos);
  void   (* cut_text)             (AtkEditableText  *text,
                                   gint             start_pos,
                                   gint             end_pos);
  void   (* delete_text)          (AtkEditableText  *text,
                                   gint             start_pos,
                                   gint             end_pos);
  void   (* paste_text)           (AtkEditableText  *text,
                                   gint             position);
};
</STRUCT>
<FUNCTION>
<NAME>atk_editable_text_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_editable_text_set_run_attributes</NAME>
<RETURNS>gboolean</RETURNS>
AtkEditableText          *text, AtkAttributeSet  *attrib_set, gint    	        start_offset, gint	        end_offset
</FUNCTION>
<FUNCTION>
<NAME>atk_editable_text_set_text_contents</NAME>
<RETURNS>void</RETURNS>
AtkEditableText  *text, const gchar      *string
</FUNCTION>
<FUNCTION>
<NAME>atk_editable_text_insert_text</NAME>
<RETURNS>void</RETURNS>
AtkEditableText  *text, const gchar      *string, gint             length, gint             *position
</FUNCTION>
<FUNCTION>
<NAME>atk_editable_text_copy_text</NAME>
<RETURNS>void</RETURNS>
AtkEditableText  *text, gint             start_pos, gint             end_pos
</FUNCTION>
<FUNCTION>
<NAME>atk_editable_text_cut_text</NAME>
<RETURNS>void</RETURNS>
AtkEditableText  *text, gint             start_pos, gint             end_pos
</FUNCTION>
<FUNCTION>
<NAME>atk_editable_text_delete_text</NAME>
<RETURNS>void</RETURNS>
AtkEditableText  *text, gint             start_pos, gint             end_pos
</FUNCTION>
<FUNCTION>
<NAME>atk_editable_text_paste_text</NAME>
<RETURNS>void</RETURNS>
AtkEditableText  *text, gint             position
</FUNCTION>
<STRUCT>
<NAME>AtkEditableText</NAME>
</STRUCT>
<MACRO>
<NAME>ATK_TYPE_GOBJECT_ACCESSIBLE</NAME>
#define ATK_TYPE_GOBJECT_ACCESSIBLE            (atk_gobject_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_GOBJECT_ACCESSIBLE</NAME>
#define ATK_GOBJECT_ACCESSIBLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_GOBJECT_ACCESSIBLE, AtkGObjectAccessible))
</MACRO>
<MACRO>
<NAME>ATK_GOBJECT_ACCESSIBLE_CLASS</NAME>
#define ATK_GOBJECT_ACCESSIBLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_GOBJECT_ACCESSIBLE, AtkGObjectAccessibleClass))
</MACRO>
<MACRO>
<NAME>ATK_IS_GOBJECT_ACCESSIBLE</NAME>
#define ATK_IS_GOBJECT_ACCESSIBLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_GOBJECT_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>ATK_IS_GOBJECT_ACCESSIBLE_CLASS</NAME>
#define ATK_IS_GOBJECT_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_GOBJECT_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>ATK_GOBJECT_ACCESSIBLE_GET_CLASS</NAME>
#define ATK_GOBJECT_ACCESSIBLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_GOBJECT_ACCESSIBLE, AtkGObjectAccessibleClass))
</MACRO>
<STRUCT>
<NAME>AtkGObjectAccessible</NAME>
struct _AtkGObjectAccessible
{
  AtkObject parent;
};
</STRUCT>
<FUNCTION>
<NAME>atk_gobject_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>AtkGObjectAccessibleClass</NAME>
struct _AtkGObjectAccessibleClass
{
  AtkObjectClass parent_class;

  AtkFunction pad1;
  AtkFunction pad2;
};
</STRUCT>
<FUNCTION>
<NAME>atk_gobject_accessible_for_object</NAME>
<RETURNS>AtkObject *</RETURNS>
GObject           *obj
</FUNCTION>
<FUNCTION>
<NAME>atk_gobject_accessible_get_object</NAME>
<RETURNS>GObject *</RETURNS>
AtkGObjectAccessible *obj
</FUNCTION>
<ENUM>
<NAME>AtkHyperlinkStateFlags</NAME>
typedef enum 
{
  ATK_HYPERLINK_IS_INLINE = 1 << 0
} AtkHyperlinkStateFlags;
</ENUM>
<MACRO>
<NAME>ATK_TYPE_HYPERLINK</NAME>
#define ATK_TYPE_HYPERLINK                        (atk_hyperlink_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_HYPERLINK</NAME>
#define ATK_HYPERLINK(obj)                        (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_HYPERLINK, AtkHyperlink))
</MACRO>
<MACRO>
<NAME>ATK_HYPERLINK_CLASS</NAME>
#define ATK_HYPERLINK_CLASS(klass)                (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_HYPERLINK, AtkHyperlinkClass))
</MACRO>
<MACRO>
<NAME>ATK_IS_HYPERLINK</NAME>
#define ATK_IS_HYPERLINK(obj)                     (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_HYPERLINK))
</MACRO>
<MACRO>
<NAME>ATK_IS_HYPERLINK_CLASS</NAME>
#define ATK_IS_HYPERLINK_CLASS(klass)             (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_HYPERLINK))
</MACRO>
<MACRO>
<NAME>ATK_HYPERLINK_GET_CLASS</NAME>
#define ATK_HYPERLINK_GET_CLASS(obj)              (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_HYPERLINK, AtkHyperlinkClass))
</MACRO>
<STRUCT>
<NAME>AtkHyperlink</NAME>
struct _AtkHyperlink
{
  GObject parent;
};
</STRUCT>
<STRUCT>
<NAME>AtkHyperlinkClass</NAME>
struct _AtkHyperlinkClass
{
  GObjectClass parent;

  gchar*           (* get_uri)             (AtkHyperlink     *link_,
                                            gint             i);
  AtkObject*       (* get_object)          (AtkHyperlink     *link_,
                                            gint             i);
  gint             (* get_end_index)       (AtkHyperlink     *link_);
  gint             (* get_start_index)     (AtkHyperlink     *link_);
  gboolean         (* is_valid)            (AtkHyperlink     *link_);
  gint	           (* get_n_anchors)	   (AtkHyperlink     *link_);
  guint	           (* link_state)	   (AtkHyperlink     *link_);
  gboolean         (* is_selected_link)    (AtkHyperlink     *link_);

  /* Signals */
  void             ( *link_activated)      (AtkHyperlink     *link_);
  AtkFunction      pad1;
};
</STRUCT>
<FUNCTION>
<NAME>atk_hyperlink_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_hyperlink_get_uri</NAME>
<RETURNS>gchar *</RETURNS>
AtkHyperlink     *link_, gint             i
</FUNCTION>
<FUNCTION>
<NAME>atk_hyperlink_get_object</NAME>
<RETURNS>AtkObject *</RETURNS>
AtkHyperlink     *link_, gint             i
</FUNCTION>
<FUNCTION>
<NAME>atk_hyperlink_get_end_index</NAME>
<RETURNS>gint</RETURNS>
AtkHyperlink     *link_
</FUNCTION>
<FUNCTION>
<NAME>atk_hyperlink_get_start_index</NAME>
<RETURNS>gint</RETURNS>
AtkHyperlink     *link_
</FUNCTION>
<FUNCTION>
<NAME>atk_hyperlink_is_valid</NAME>
<RETURNS>gboolean</RETURNS>
AtkHyperlink     *link_
</FUNCTION>
<FUNCTION>
<NAME>atk_hyperlink_is_inline</NAME>
<RETURNS>gboolean</RETURNS>
AtkHyperlink     *link_
</FUNCTION>
<FUNCTION>
<NAME>atk_hyperlink_get_n_anchors</NAME>
<RETURNS>gint</RETURNS>
AtkHyperlink     *link_
</FUNCTION>
<FUNCTION>
<NAME>atk_hyperlink_is_selected_link</NAME>
<DEPRECATED/>
<RETURNS>gboolean</RETURNS>
AtkHyperlink     *link_
</FUNCTION>
<MACRO>
<NAME>ATK_TYPE_HYPERLINK_IMPL</NAME>
#define ATK_TYPE_HYPERLINK_IMPL          (atk_hyperlink_impl_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_IS_HYPERLINK_IMPL</NAME>
#define ATK_IS_HYPERLINK_IMPL(obj)       G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_HYPERLINK_IMPL)
</MACRO>
<MACRO>
<NAME>ATK_HYPERLINK_IMPL</NAME>
#define ATK_HYPERLINK_IMPL(obj)             G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_HYPERLINK_IMPL, AtkHyperlinkImpl)
</MACRO>
<MACRO>
<NAME>ATK_HYPERLINK_IMPL_GET_IFACE</NAME>
#define ATK_HYPERLINK_IMPL_GET_IFACE(obj)   G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_HYPERLINK_IMPL, AtkHyperlinkImplIface)
</MACRO>
<STRUCT>
<NAME>AtkHyperlinkImplIface</NAME>
struct _AtkHyperlinkImplIface
{
  GTypeInterface parent;
    
  AtkHyperlink*  (* get_hyperlink) (AtkHyperlinkImpl *impl);
};
</STRUCT>
<FUNCTION>
<NAME>atk_hyperlink_impl_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_hyperlink_impl_get_hyperlink</NAME>
<RETURNS>AtkHyperlink *</RETURNS>
AtkHyperlinkImpl *impl
</FUNCTION>
<STRUCT>
<NAME>AtkHyperlinkImpl</NAME>
</STRUCT>
<MACRO>
<NAME>ATK_TYPE_HYPERTEXT</NAME>
#define ATK_TYPE_HYPERTEXT                    (atk_hypertext_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_IS_HYPERTEXT</NAME>
#define ATK_IS_HYPERTEXT(obj)                 G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_HYPERTEXT)
</MACRO>
<MACRO>
<NAME>ATK_HYPERTEXT</NAME>
#define ATK_HYPERTEXT(obj)                    G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_HYPERTEXT, AtkHypertext)
</MACRO>
<MACRO>
<NAME>ATK_HYPERTEXT_GET_IFACE</NAME>
#define ATK_HYPERTEXT_GET_IFACE(obj)          (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_HYPERTEXT, AtkHypertextIface))
</MACRO>
<STRUCT>
<NAME>AtkHypertextIface</NAME>
struct _AtkHypertextIface
{
  GTypeInterface parent;

  AtkHyperlink*(* get_link)                 (AtkHypertext       *hypertext,
                                             gint               link_index);
  gint         (* get_n_links)              (AtkHypertext       *hypertext);
  gint         (* get_link_index)           (AtkHypertext       *hypertext,
                                             gint               char_index);

  /*
   * signal handlers
   */
  void         (* link_selected)            (AtkHypertext       *hypertext,
                                             gint               link_index);
};
</STRUCT>
<FUNCTION>
<NAME>atk_hypertext_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_hypertext_get_link</NAME>
<RETURNS>AtkHyperlink *</RETURNS>
AtkHypertext *hypertext, gint          link_index
</FUNCTION>
<FUNCTION>
<NAME>atk_hypertext_get_n_links</NAME>
<RETURNS>gint</RETURNS>
AtkHypertext *hypertext
</FUNCTION>
<FUNCTION>
<NAME>atk_hypertext_get_link_index</NAME>
<RETURNS>gint</RETURNS>
AtkHypertext *hypertext, gint          char_index
</FUNCTION>
<STRUCT>
<NAME>AtkHypertext</NAME>
</STRUCT>
<MACRO>
<NAME>ATK_TYPE_IMAGE</NAME>
#define ATK_TYPE_IMAGE                   (atk_image_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_IS_IMAGE</NAME>
#define ATK_IS_IMAGE(obj)                G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_IMAGE)
</MACRO>
<MACRO>
<NAME>ATK_IMAGE</NAME>
#define ATK_IMAGE(obj)                   G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_IMAGE, AtkImage)
</MACRO>
<MACRO>
<NAME>ATK_IMAGE_GET_IFACE</NAME>
#define ATK_IMAGE_GET_IFACE(obj)         (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_IMAGE, AtkImageIface))
</MACRO>
<STRUCT>
<NAME>AtkImageIface</NAME>
struct _AtkImageIface
{
  GTypeInterface parent;
  void          	( *get_image_position)    (AtkImage		 *image,
                                                   gint                  *x,
				                   gint	                 *y,
    			                           AtkCoordType	         coord_type);
  const gchar*          ( *get_image_description) (AtkImage              *image);
  void                  ( *get_image_size)        (AtkImage              *image,
                                                   gint                  *width,
                                                   gint                  *height);
  gboolean              ( *set_image_description) (AtkImage              *image,
                                                   const gchar           *description);
  const gchar*          ( *get_image_locale)      (AtkImage              *image);
};
</STRUCT>
<FUNCTION>
<NAME>atk_image_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_image_get_image_description</NAME>
<RETURNS>const gchar *</RETURNS>
AtkImage   *image
</FUNCTION>
<FUNCTION>
<NAME>atk_image_get_image_size</NAME>
<RETURNS>void</RETURNS>
AtkImage           *image, gint               *width, gint               *height
</FUNCTION>
<FUNCTION>
<NAME>atk_image_set_image_description</NAME>
<RETURNS>gboolean</RETURNS>
AtkImage           *image, const gchar       *description
</FUNCTION>
<FUNCTION>
<NAME>atk_image_get_image_position</NAME>
<RETURNS>void</RETURNS>
AtkImage	     *image, gint               *x, gint	             *y, AtkCoordType	     coord_type
</FUNCTION>
<FUNCTION>
<NAME>atk_image_get_image_locale</NAME>
<RETURNS>const gchar *</RETURNS>
AtkImage   *image
</FUNCTION>
<STRUCT>
<NAME>AtkImage</NAME>
</STRUCT>
<MACRO>
<NAME>ATK_VAR</NAME>
#      define ATK_VAR extern
</MACRO>
<MACRO>
<NAME>ATK_TYPE_MISC</NAME>
#define ATK_TYPE_MISC                   (atk_misc_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_IS_MISC</NAME>
#define ATK_IS_MISC(obj)                G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_MISC)
</MACRO>
<MACRO>
<NAME>ATK_MISC</NAME>
#define ATK_MISC(obj)                   G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_MISC, AtkMisc)
</MACRO>
<MACRO>
<NAME>ATK_MISC_CLASS</NAME>
#define ATK_MISC_CLASS(klass)                   (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_MISC, AtkMiscClass))
</MACRO>
<MACRO>
<NAME>ATK_IS_MISC_CLASS</NAME>
#define ATK_IS_MISC_CLASS(klass)                (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_MISC))
</MACRO>
<MACRO>
<NAME>ATK_MISC_GET_CLASS</NAME>
#define ATK_MISC_GET_CLASS(obj)                 (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_MISC, AtkMiscClass))
</MACRO>
<STRUCT>
<NAME>AtkMisc</NAME>
struct _AtkMisc
{
  GObject parent;
};
</STRUCT>
<VARIABLE>
<NAME>atk_misc_instance</NAME>
extern AtkMisc *atk_misc_instance;
</VARIABLE>
<STRUCT>
<NAME>AtkMiscClass</NAME>
struct _AtkMiscClass
{
   GObjectClass parent;
   void   (* threads_enter)                     (AtkMisc *misc);
   void   (* threads_leave)                     (AtkMisc *misc);
   gpointer vfuncs[32]; /* future bincompat */
};
</STRUCT>
<FUNCTION>
<NAME>atk_misc_get_type</NAME>
<DEPRECATED/>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_misc_threads_enter</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
AtkMisc *misc
</FUNCTION>
<FUNCTION>
<NAME>atk_misc_threads_leave</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
AtkMisc *misc
</FUNCTION>
<FUNCTION>
<NAME>atk_misc_get_instance</NAME>
<DEPRECATED/>
<RETURNS>const AtkMisc *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>ATK_TYPE_NO_OP_OBJECT</NAME>
#define ATK_TYPE_NO_OP_OBJECT                (atk_no_op_object_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_NO_OP_OBJECT</NAME>
#define ATK_NO_OP_OBJECT(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_NO_OP_OBJECT, AtkNoOpObject))
</MACRO>
<MACRO>
<NAME>ATK_NO_OP_OBJECT_CLASS</NAME>
#define ATK_NO_OP_OBJECT_CLASS(klass)        (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_NO_OP_OBJECT, AtkNoOpObjectClass))
</MACRO>
<MACRO>
<NAME>ATK_IS_NO_OP_OBJECT</NAME>
#define ATK_IS_NO_OP_OBJECT(obj)             (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_NO_OP_OBJECT))
</MACRO>
<MACRO>
<NAME>ATK_IS_NO_OP_OBJECT_CLASS</NAME>
#define ATK_IS_NO_OP_OBJECT_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_NO_OP_OBJECT))
</MACRO>
<MACRO>
<NAME>ATK_NO_OP_OBJECT_GET_CLASS</NAME>
#define ATK_NO_OP_OBJECT_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_NO_OP_OBJECT, AtkNoOpObjectClass))
</MACRO>
<STRUCT>
<NAME>AtkNoOpObject</NAME>
struct _AtkNoOpObject
{
  AtkObject     parent;
};
</STRUCT>
<FUNCTION>
<NAME>atk_no_op_object_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>AtkNoOpObjectClass</NAME>
struct _AtkNoOpObjectClass
{
  AtkObjectClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>atk_no_op_object_new</NAME>
<RETURNS>AtkObject *</RETURNS>
GObject  *obj
</FUNCTION>
<MACRO>
<NAME>ATK_TYPE_NO_OP_OBJECT_FACTORY</NAME>
#define ATK_TYPE_NO_OP_OBJECT_FACTORY                (atk_no_op_object_factory_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_NO_OP_OBJECT_FACTORY</NAME>
#define ATK_NO_OP_OBJECT_FACTORY(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_NO_OP_OBJECT_FACTORY, AtkNoOpObjectFactory))
</MACRO>
<MACRO>
<NAME>ATK_NO_OP_OBJECT_FACTORY_CLASS</NAME>
#define ATK_NO_OP_OBJECT_FACTORY_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_NO_OP_OBJECT_FACTORY, AtkNoOpObjectFactoryClass))
</MACRO>
<MACRO>
<NAME>ATK_IS_NO_OP_OBJECT_FACTORY</NAME>
#define ATK_IS_NO_OP_OBJECT_FACTORY(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_NO_OP_OBJECT_FACTORY))
</MACRO>
<MACRO>
<NAME>ATK_IS_NO_OP_OBJECT_FACTORY_CLASS</NAME>
#define ATK_IS_NO_OP_OBJECT_FACTORY_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_NO_OP_OBJECT_FACTORY))
</MACRO>
<MACRO>
<NAME>ATK_NO_OP_OBJECT_FACTORY_GET_CLASS</NAME>
#define ATK_NO_OP_OBJECT_FACTORY_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ( (obj), ATK_TYPE_NO_OP_OBJECT_FACTORY, AtkNoOpObjectFactoryClass))
</MACRO>
<STRUCT>
<NAME>AtkNoOpObjectFactory</NAME>
struct _AtkNoOpObjectFactory
{
  AtkObjectFactory parent;
};
</STRUCT>
<STRUCT>
<NAME>AtkNoOpObjectFactoryClass</NAME>
struct _AtkNoOpObjectFactoryClass
{
  AtkObjectFactoryClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>atk_no_op_object_factory_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_no_op_object_factory_new</NAME>
<RETURNS>AtkObjectFactory *</RETURNS>
void
</FUNCTION>
<ENUM>
<NAME>AtkRole</NAME>
typedef enum
{
  ATK_ROLE_INVALID = 0,
  ATK_ROLE_ACCEL_LABEL,      /*<nick=accelerator-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_HEADER,
  ATK_ROLE_FOOTER,
  ATK_ROLE_PARAGRAPH,
  ATK_ROLE_RULER,
  ATK_ROLE_APPLICATION,
  ATK_ROLE_AUTOCOMPLETE,
  ATK_ROLE_EDITBAR,          /*<nick=edit-bar>*/
  ATK_ROLE_EMBEDDED,
  ATK_ROLE_ENTRY,
  ATK_ROLE_CHART,
  ATK_ROLE_CAPTION,
  ATK_ROLE_DOCUMENT_FRAME,
  ATK_ROLE_HEADING,
  ATK_ROLE_PAGE,
  ATK_ROLE_SECTION,
  ATK_ROLE_REDUNDANT_OBJECT,
  ATK_ROLE_FORM,
  ATK_ROLE_LINK,
  ATK_ROLE_INPUT_METHOD_WINDOW,
  ATK_ROLE_TABLE_ROW,
  ATK_ROLE_TREE_ITEM,
  ATK_ROLE_DOCUMENT_SPREADSHEET,
  ATK_ROLE_DOCUMENT_PRESENTATION,
  ATK_ROLE_DOCUMENT_TEXT,
  ATK_ROLE_DOCUMENT_WEB,
  ATK_ROLE_DOCUMENT_EMAIL,
  ATK_ROLE_COMMENT,
  ATK_ROLE_LIST_BOX,
  ATK_ROLE_GROUPING,
  ATK_ROLE_IMAGE_MAP,
  ATK_ROLE_NOTIFICATION,
  ATK_ROLE_INFO_BAR,
  ATK_ROLE_LEVEL_BAR,
  ATK_ROLE_TITLE_BAR,
  ATK_ROLE_BLOCK_QUOTE,
  ATK_ROLE_AUDIO,
  ATK_ROLE_VIDEO,
  ATK_ROLE_DEFINITION,
  ATK_ROLE_ARTICLE,
  ATK_ROLE_LANDMARK,
  ATK_ROLE_LOG,
  ATK_ROLE_MARQUEE,
  ATK_ROLE_MATH,
  ATK_ROLE_RATING,
  ATK_ROLE_TIMER,
  ATK_ROLE_DESCRIPTION_LIST,
  ATK_ROLE_DESCRIPTION_TERM,
  ATK_ROLE_DESCRIPTION_VALUE,
  ATK_ROLE_STATIC,
  ATK_ROLE_MATH_FRACTION,
  ATK_ROLE_MATH_ROOT,
  ATK_ROLE_SUBSCRIPT,
  ATK_ROLE_SUPERSCRIPT,
  ATK_ROLE_FOOTNOTE,
  ATK_ROLE_LAST_DEFINED
} AtkRole;
</ENUM>
<ENUM>
<NAME>AtkLayer</NAME>
typedef enum
{
  ATK_LAYER_INVALID,
  ATK_LAYER_BACKGROUND,
  ATK_LAYER_CANVAS,
  ATK_LAYER_WIDGET,
  ATK_LAYER_MDI,
  ATK_LAYER_POPUP,
  ATK_LAYER_OVERLAY,
  ATK_LAYER_WINDOW
} AtkLayer;
</ENUM>
<TYPEDEF>
<NAME>AtkAttributeSet</NAME>
typedef GSList AtkAttributeSet;
</TYPEDEF>
<STRUCT>
<NAME>AtkAttribute</NAME>
struct _AtkAttribute {
  gchar* name;
  gchar* value;
};
</STRUCT>
<MACRO>
<NAME>ATK_TYPE_OBJECT</NAME>
#define ATK_TYPE_OBJECT                           (atk_object_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_OBJECT</NAME>
#define ATK_OBJECT(obj)                           (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_OBJECT, AtkObject))
</MACRO>
<MACRO>
<NAME>ATK_OBJECT_CLASS</NAME>
#define ATK_OBJECT_CLASS(klass)                   (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_OBJECT, AtkObjectClass))
</MACRO>
<MACRO>
<NAME>ATK_IS_OBJECT</NAME>
#define ATK_IS_OBJECT(obj)                        (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_OBJECT))
</MACRO>
<MACRO>
<NAME>ATK_IS_OBJECT_CLASS</NAME>
#define ATK_IS_OBJECT_CLASS(klass)                (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_OBJECT))
</MACRO>
<MACRO>
<NAME>ATK_OBJECT_GET_CLASS</NAME>
#define ATK_OBJECT_GET_CLASS(obj)                 (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_OBJECT, AtkObjectClass))
</MACRO>
<MACRO>
<NAME>ATK_TYPE_IMPLEMENTOR</NAME>
#define ATK_TYPE_IMPLEMENTOR                      (atk_implementor_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_IS_IMPLEMENTOR</NAME>
#define ATK_IS_IMPLEMENTOR(obj)                   G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_IMPLEMENTOR)
</MACRO>
<MACRO>
<NAME>ATK_IMPLEMENTOR</NAME>
#define ATK_IMPLEMENTOR(obj)                      G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_IMPLEMENTOR, AtkImplementor)
</MACRO>
<MACRO>
<NAME>ATK_IMPLEMENTOR_GET_IFACE</NAME>
#define ATK_IMPLEMENTOR_GET_IFACE(obj)            (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_IMPLEMENTOR, AtkImplementorIface))
</MACRO>
<STRUCT>
<NAME>AtkPropertyValues</NAME>
struct _AtkPropertyValues
{
  const gchar  *property_name;
  GValue old_value;
  GValue new_value;
};
</STRUCT>
<USER_FUNCTION>
<NAME>AtkFunction</NAME>
<RETURNS>gboolean</RETURNS>
gpointer user_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>AtkPropertyChangeHandler</NAME>
<RETURNS>void</RETURNS>
AtkObject* obj, AtkPropertyValues* vals
</USER_FUNCTION>
<STRUCT>
<NAME>AtkObject</NAME>
struct _AtkObject
{
  GObject parent;

  gchar *description;
  gchar *name;
  AtkObject *accessible_parent;
  AtkRole role;
  AtkRelationSet *relation_set;
  AtkLayer layer;
};
</STRUCT>
<STRUCT>
<NAME>AtkObjectClass</NAME>
struct _AtkObjectClass
{
  GObjectClass parent;

  /*
   * Gets the accessible name of the object
   */
  const gchar*             (* get_name)            (AtkObject                *accessible);
  /*
   * Gets the accessible description of the object
   */
  const gchar*             (* get_description)     (AtkObject                *accessible);
  /*
   * Gets the accessible parent of the object
   */
  AtkObject*               (*get_parent)           (AtkObject                *accessible);

  /*
   * Gets the number of accessible children of the object
   */
  gint                    (* get_n_children)       (AtkObject                *accessible);
  /*
   * Returns 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.
   */
  AtkObject*              (* ref_child)            (AtkObject                *accessible,
                                                    gint                      i);
  /*
   * Gets the 0-based index of this object in its parent; returns -1 if the
   * object does not have an accessible parent.
   */
  gint                    (* get_index_in_parent) (AtkObject                 *accessible);
  /*
   * Gets the RelationSet associated with the object
   */
  AtkRelationSet*         (* ref_relation_set)    (AtkObject                 *accessible);
  /*
   * Gets the role of the object
   */
  AtkRole                 (* get_role)            (AtkObject                 *accessible);
  AtkLayer                (* get_layer)           (AtkObject                 *accessible);
  gint                    (* get_mdi_zorder)      (AtkObject                 *accessible);
  /*
   * Gets the state set of the object
   */
  AtkStateSet*            (* ref_state_set)       (AtkObject                 *accessible);
  /*
   * Sets the accessible name of the object
   */
  void                    (* set_name)            (AtkObject                 *accessible,
                                                   const gchar               *name);
  /*
   * Sets the accessible description of the object
   */
  void                    (* set_description)     (AtkObject                 *accessible,
                                                   const gchar               *description);
  /*
   * Sets the accessible parent of the object
   */
  void                    (* set_parent)          (AtkObject                 *accessible,
                                                   AtkObject                 *parent);
  /*
   * Sets the accessible role of the object
   */
  void                    (* set_role)            (AtkObject                 *accessible,
                                                   AtkRole                   role);
  /*
   * Specifies a function to be called when a property changes value
   */
guint                     (* connect_property_change_handler)    (AtkObject
                 *accessible,
                                                                  AtkPropertyChangeHandler       *handler);
  /*
   * Removes a property change handler which was specified using
   * connect_property_change_handler
   */
void                      (* remove_property_change_handler)     (AtkObject
                *accessible,
                                                                  guint
                handler_id);
void                      (* initialize)                         (AtkObject                     *accessible,
                                                                  gpointer                      data);
  /*
   * The signal handler which is executed when there is a change in the
   * children of the object
   */
  void                    (* children_changed)    (AtkObject                  *accessible,
                                                   guint                      change_index,
                                                   gpointer                   changed_child);
  /*
   * The signal handler which is executed  when there is a focus event
   * for an object.
   */
  void                    (* focus_event)         (AtkObject                  *accessible,
                                                   gboolean                   focus_in);
  /*
   * The signal handler which is executed  when there is a property_change 
   * signal for an object.
   */
  void                    (* property_change)     (AtkObject                  *accessible,
                                                   AtkPropertyValues          *values);
  /*
   * The signal handler which is executed  when there is a state_change 
   * signal for an object.
   */
  void                    (* state_change)        (AtkObject                  *accessible,
                                                   const gchar                *name,
                                                   gboolean                   state_set);
  /*
   * The signal handler which is executed when there is a change in the
   * visible data for an object
   */
  void                    (*visible_data_changed) (AtkObject                  *accessible);

  /*
   * The signal handler which is executed when there is a change in the
   * 'active' child or children of the object, for instance when 
   * interior focus changes in a table or list.  This signal should be emitted
   * by objects whose state includes ATK_STATE_MANAGES_DESCENDANTS.
   */
  void                    (*active_descendant_changed) (AtkObject                  *accessible,
                                                        gpointer                   *child);

  /*    	
   * Gets a list of properties applied to this object as a whole, as an #AtkAttributeSet consisting of name-value pairs. 
   * Since ATK 1.12
   */
  AtkAttributeSet* 	  (*get_attributes)            (AtkObject                  *accessible);

  const gchar*            (*get_object_locale)         (AtkObject                  *accessible);

  AtkFunction             pad1;
};
</STRUCT>
<FUNCTION>
<NAME>atk_object_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>AtkImplementorIface</NAME>
struct _AtkImplementorIface
{
  GTypeInterface parent;

  AtkObject*   (*ref_accessible) (AtkImplementor *implementor);
};
</STRUCT>
<FUNCTION>
<NAME>atk_implementor_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_implementor_ref_accessible</NAME>
<RETURNS>AtkObject *</RETURNS>
AtkImplementor *implementor
</FUNCTION>
<FUNCTION>
<NAME>atk_object_get_name</NAME>
<RETURNS>const gchar *</RETURNS>
AtkObject *accessible
</FUNCTION>
<FUNCTION>
<NAME>atk_object_get_description</NAME>
<RETURNS>const gchar *</RETURNS>
AtkObject *accessible
</FUNCTION>
<FUNCTION>
<NAME>atk_object_get_parent</NAME>
<RETURNS>AtkObject *</RETURNS>
AtkObject *accessible
</FUNCTION>
<FUNCTION>
<NAME>atk_object_peek_parent</NAME>
<RETURNS>AtkObject *</RETURNS>
AtkObject *accessible
</FUNCTION>
<FUNCTION>
<NAME>atk_object_get_n_accessible_children</NAME>
<RETURNS>gint</RETURNS>
AtkObject *accessible
</FUNCTION>
<FUNCTION>
<NAME>atk_object_ref_accessible_child</NAME>
<RETURNS>AtkObject *</RETURNS>
AtkObject *accessible, gint        i
</FUNCTION>
<FUNCTION>
<NAME>atk_object_ref_relation_set</NAME>
<RETURNS>AtkRelationSet *</RETURNS>
AtkObject *accessible
</FUNCTION>
<FUNCTION>
<NAME>atk_object_get_role</NAME>
<RETURNS>AtkRole</RETURNS>
AtkObject *accessible
</FUNCTION>
<FUNCTION>
<NAME>atk_object_get_layer</NAME>
<DEPRECATED/>
<RETURNS>AtkLayer</RETURNS>
AtkObject *accessible
</FUNCTION>
<FUNCTION>
<NAME>atk_object_get_mdi_zorder</NAME>
<DEPRECATED/>
<RETURNS>gint</RETURNS>
AtkObject *accessible
</FUNCTION>
<FUNCTION>
<NAME>atk_object_get_attributes</NAME>
<RETURNS>AtkAttributeSet *</RETURNS>
AtkObject *accessible
</FUNCTION>
<FUNCTION>
<NAME>atk_object_ref_state_set</NAME>
<RETURNS>AtkStateSet *</RETURNS>
AtkObject *accessible
</FUNCTION>
<FUNCTION>
<NAME>atk_object_get_index_in_parent</NAME>
<RETURNS>gint</RETURNS>
AtkObject *accessible
</FUNCTION>
<FUNCTION>
<NAME>atk_object_set_name</NAME>
<RETURNS>void</RETURNS>
AtkObject *accessible, const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>atk_object_set_description</NAME>
<RETURNS>void</RETURNS>
AtkObject *accessible, const gchar *description
</FUNCTION>
<FUNCTION>
<NAME>atk_object_set_parent</NAME>
<RETURNS>void</RETURNS>
AtkObject *accessible, AtkObject *parent
</FUNCTION>
<FUNCTION>
<NAME>atk_object_set_role</NAME>
<RETURNS>void</RETURNS>
AtkObject *accessible, AtkRole   role
</FUNCTION>
<FUNCTION>
<NAME>atk_object_connect_property_change_handler</NAME>
<DEPRECATED/>
<RETURNS>guint</RETURNS>
AtkObject                      *accessible, AtkPropertyChangeHandler       *handler
</FUNCTION>
<FUNCTION>
<NAME>atk_object_remove_property_change_handler</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
AtkObject                      *accessible, guint                          handler_id
</FUNCTION>
<FUNCTION>
<NAME>atk_object_notify_state_change</NAME>
<RETURNS>void</RETURNS>
AtkObject                      *accessible, AtkState                       state, gboolean                       value
</FUNCTION>
<FUNCTION>
<NAME>atk_object_initialize</NAME>
<RETURNS>void</RETURNS>
AtkObject                     *accessible, gpointer                      data
</FUNCTION>
<FUNCTION>
<NAME>atk_role_get_name</NAME>
<RETURNS>const gchar *</RETURNS>
AtkRole         role
</FUNCTION>
<FUNCTION>
<NAME>atk_role_for_name</NAME>
<RETURNS>AtkRole</RETURNS>
const gchar     *name
</FUNCTION>
<FUNCTION>
<NAME>atk_object_add_relationship</NAME>
<RETURNS>gboolean</RETURNS>
AtkObject      *object, AtkRelationType relationship, AtkObject      *target
</FUNCTION>
<FUNCTION>
<NAME>atk_object_remove_relationship</NAME>
<RETURNS>gboolean</RETURNS>
AtkObject      *object, AtkRelationType relationship, AtkObject      *target
</FUNCTION>
<FUNCTION>
<NAME>atk_role_get_localized_name</NAME>
<RETURNS>const gchar *</RETURNS>
AtkRole     role
</FUNCTION>
<FUNCTION>
<NAME>atk_role_register</NAME>
<DEPRECATED/>
<RETURNS>AtkRole</RETURNS>
const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>atk_object_get_object_locale</NAME>
<RETURNS>const gchar *</RETURNS>
AtkObject   *accessible
</FUNCTION>
<STRUCT>
<NAME>AtkImplementor</NAME>
</STRUCT>
<STRUCT>
<NAME>AtkPropertyValues</NAME>
</STRUCT>
<STRUCT>
<NAME>AtkRelationSet</NAME>
</STRUCT>
<STRUCT>
<NAME>AtkStateSet</NAME>
</STRUCT>
<MACRO>
<NAME>ATK_TYPE_OBJECT_FACTORY</NAME>
#define ATK_TYPE_OBJECT_FACTORY                     (atk_object_factory_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_OBJECT_FACTORY</NAME>
#define ATK_OBJECT_FACTORY(obj)                     (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_OBJECT_FACTORY, AtkObjectFactory))
</MACRO>
<MACRO>
<NAME>ATK_OBJECT_FACTORY_CLASS</NAME>
#define ATK_OBJECT_FACTORY_CLASS(klass)             (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_OBJECT_FACTORY, AtkObjectFactoryClass))
</MACRO>
<MACRO>
<NAME>ATK_IS_OBJECT_FACTORY</NAME>
#define ATK_IS_OBJECT_FACTORY(obj)                  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_OBJECT_FACTORY))
</MACRO>
<MACRO>
<NAME>ATK_IS_OBJECT_FACTORY_CLASS</NAME>
#define ATK_IS_OBJECT_FACTORY_CLASS(klass)          (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_OBJECT_FACTORY))
</MACRO>
<MACRO>
<NAME>ATK_OBJECT_FACTORY_GET_CLASS</NAME>
#define ATK_OBJECT_FACTORY_GET_CLASS(obj)           (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_OBJECT_FACTORY, AtkObjectFactoryClass))
</MACRO>
<STRUCT>
<NAME>AtkObjectFactory</NAME>
struct _AtkObjectFactory
{
  GObject parent;
};
</STRUCT>
<STRUCT>
<NAME>AtkObjectFactoryClass</NAME>
struct _AtkObjectFactoryClass
{
  GObjectClass parent_class;

  AtkObject* (* create_accessible) (GObject          *obj);
  void       (* invalidate)        (AtkObjectFactory *factory);
  GType      (* get_accessible_type)    (void);

  AtkFunction pad1;
  AtkFunction pad2;
};
</STRUCT>
<FUNCTION>
<NAME>atk_object_factory_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_object_factory_create_accessible</NAME>
<RETURNS>AtkObject *</RETURNS>
AtkObjectFactory *factory, GObject *obj
</FUNCTION>
<FUNCTION>
<NAME>atk_object_factory_invalidate</NAME>
<RETURNS>void</RETURNS>
AtkObjectFactory *factory
</FUNCTION>
<FUNCTION>
<NAME>atk_object_factory_get_accessible_type</NAME>
<RETURNS>GType</RETURNS>
AtkObjectFactory *factory
</FUNCTION>
<MACRO>
<NAME>ATK_TYPE_PLUG</NAME>
#define ATK_TYPE_PLUG               (atk_plug_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_PLUG</NAME>
#define ATK_PLUG(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_PLUG, AtkPlug))
</MACRO>
<MACRO>
<NAME>ATK_IS_PLUG</NAME>
#define ATK_IS_PLUG(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_PLUG))
</MACRO>
<MACRO>
<NAME>ATK_PLUG_CLASS</NAME>
#define ATK_PLUG_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_PLUG, AtkPlugClass))
</MACRO>
<MACRO>
<NAME>ATK_IS_PLUG_CLASS</NAME>
#define ATK_IS_PLUG_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_PLUG))
</MACRO>
<MACRO>
<NAME>ATK_PLUG_GET_CLASS</NAME>
#define ATK_PLUG_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_PLUG, AtkPlugClass))
</MACRO>
<STRUCT>
<NAME>AtkPlug</NAME>
struct _AtkPlug
{
  AtkObject parent;
};
</STRUCT>
<FUNCTION>
<NAME>atk_plug_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>AtkPlugClass</NAME>
struct _AtkPlugClass
{
  AtkObjectClass parent_class;
  
  /* to be subscribed to by atk-bridge */

  /*< protected >*/
  gchar* (* get_object_id) (AtkPlug* obj);
};
</STRUCT>
<FUNCTION>
<NAME>atk_plug_new</NAME>
<RETURNS>AtkObject *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_plug_get_id</NAME>
<RETURNS>gchar *</RETURNS>
AtkPlug* plug
</FUNCTION>
<MACRO>
<NAME>ATK_TYPE_RANGE</NAME>
#define ATK_TYPE_RANGE         (atk_range_get_type ())
</MACRO>
<FUNCTION>
<NAME>atk_range_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_range_copy</NAME>
<RETURNS>AtkRange *</RETURNS>
AtkRange *src
</FUNCTION>
<FUNCTION>
<NAME>atk_range_free</NAME>
<RETURNS>void</RETURNS>
AtkRange *range
</FUNCTION>
<FUNCTION>
<NAME>atk_range_get_lower_limit</NAME>
<RETURNS>gdouble</RETURNS>
AtkRange    *range
</FUNCTION>
<FUNCTION>
<NAME>atk_range_get_upper_limit</NAME>
<RETURNS>gdouble</RETURNS>
AtkRange    *range
</FUNCTION>
<FUNCTION>
<NAME>atk_range_get_description</NAME>
<RETURNS>const gchar *</RETURNS>
AtkRange    *range
</FUNCTION>
<FUNCTION>
<NAME>atk_range_new</NAME>
<RETURNS>AtkRange *</RETURNS>
gdouble      lower_limit, gdouble      upper_limit, const gchar *description
</FUNCTION>
<STRUCT>
<NAME>AtkRange</NAME>
</STRUCT>
<MACRO>
<NAME>ATK_TYPE_REGISTRY</NAME>
#define ATK_TYPE_REGISTRY                (atk_registry_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_REGISTRY</NAME>
#define ATK_REGISTRY(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_REGISTRY, AtkRegistry))
</MACRO>
<MACRO>
<NAME>ATK_REGISTRY_CLASS</NAME>
#define ATK_REGISTRY_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_REGISTRY, AtkRegistryClass))
</MACRO>
<MACRO>
<NAME>ATK_IS_REGISTRY</NAME>
#define ATK_IS_REGISTRY(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_REGISTRY))
</MACRO>
<MACRO>
<NAME>ATK_IS_REGISTRY_CLASS</NAME>
#define ATK_IS_REGISTRY_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_REGISTRY))
</MACRO>
<MACRO>
<NAME>ATK_REGISTRY_GET_CLASS</NAME>
#define ATK_REGISTRY_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_REGISTRY, AtkRegistryClass))
</MACRO>
<STRUCT>
<NAME>AtkRegistry</NAME>
struct _AtkRegistry
{
  GObject    parent;
  GHashTable *factory_type_registry;
  GHashTable *factory_singleton_cache;
};
</STRUCT>
<STRUCT>
<NAME>AtkRegistryClass</NAME>
struct _AtkRegistryClass
{
  GObjectClass    parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>atk_registry_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_registry_set_factory_type</NAME>
<RETURNS>void</RETURNS>
AtkRegistry *registry, GType type, GType factory_type
</FUNCTION>
<FUNCTION>
<NAME>atk_registry_get_factory_type</NAME>
<RETURNS>GType</RETURNS>
AtkRegistry *registry, GType type
</FUNCTION>
<FUNCTION>
<NAME>atk_registry_get_factory</NAME>
<RETURNS>AtkObjectFactory *</RETURNS>
AtkRegistry *registry, GType type
</FUNCTION>
<FUNCTION>
<NAME>atk_get_default_registry</NAME>
<RETURNS>AtkRegistry *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>AtkRegistry</NAME>
</STRUCT>
<STRUCT>
<NAME>AtkRegistryClass</NAME>
</STRUCT>
<MACRO>
<NAME>ATK_TYPE_RELATION</NAME>
#define ATK_TYPE_RELATION                         (atk_relation_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_RELATION</NAME>
#define ATK_RELATION(obj)                         (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_RELATION, AtkRelation))
</MACRO>
<MACRO>
<NAME>ATK_RELATION_CLASS</NAME>
#define ATK_RELATION_CLASS(klass)                 (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_RELATION, AtkRelationClass))
</MACRO>
<MACRO>
<NAME>ATK_IS_RELATION</NAME>
#define ATK_IS_RELATION(obj)                      (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_RELATION))
</MACRO>
<MACRO>
<NAME>ATK_IS_RELATION_CLASS</NAME>
#define ATK_IS_RELATION_CLASS(klass)              (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_RELATION))
</MACRO>
<MACRO>
<NAME>ATK_RELATION_GET_CLASS</NAME>
#define ATK_RELATION_GET_CLASS(obj)               (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_RELATION, AtkRelationClass))
</MACRO>
<STRUCT>
<NAME>AtkRelation</NAME>
struct _AtkRelation
{
  GObject parent;

  GPtrArray       *target;
  AtkRelationType relationship;
};
</STRUCT>
<STRUCT>
<NAME>AtkRelationClass</NAME>
struct _AtkRelationClass
{
  GObjectClass parent;
};
</STRUCT>
<FUNCTION>
<NAME>atk_relation_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_relation_type_register</NAME>
<RETURNS>AtkRelationType</RETURNS>
const gchar     *name
</FUNCTION>
<FUNCTION>
<NAME>atk_relation_type_get_name</NAME>
<RETURNS>const gchar *</RETURNS>
AtkRelationType type
</FUNCTION>
<FUNCTION>
<NAME>atk_relation_type_for_name</NAME>
<RETURNS>AtkRelationType</RETURNS>
const gchar     *name
</FUNCTION>
<FUNCTION>
<NAME>atk_relation_new</NAME>
<RETURNS>AtkRelation *</RETURNS>
AtkObject       **targets, gint            n_targets, AtkRelationType relationship
</FUNCTION>
<FUNCTION>
<NAME>atk_relation_get_relation_type</NAME>
<RETURNS>AtkRelationType</RETURNS>
AtkRelation     *relation
</FUNCTION>
<FUNCTION>
<NAME>atk_relation_get_target</NAME>
<RETURNS>GPtrArray *</RETURNS>
AtkRelation     *relation
</FUNCTION>
<FUNCTION>
<NAME>atk_relation_add_target</NAME>
<RETURNS>void</RETURNS>
AtkRelation     *relation, AtkObject       *target
</FUNCTION>
<FUNCTION>
<NAME>atk_relation_remove_target</NAME>
<RETURNS>gboolean</RETURNS>
AtkRelation     *relation, AtkObject       *target
</FUNCTION>
<MACRO>
<NAME>ATK_TYPE_RELATION_SET</NAME>
#define ATK_TYPE_RELATION_SET                     (atk_relation_set_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_RELATION_SET</NAME>
#define ATK_RELATION_SET(obj)                     (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_RELATION_SET, AtkRelationSet))
</MACRO>
<MACRO>
<NAME>ATK_RELATION_SET_CLASS</NAME>
#define ATK_RELATION_SET_CLASS(klass)             (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_RELATION_SET, AtkRelationSetClass))
</MACRO>
<MACRO>
<NAME>ATK_IS_RELATION_SET</NAME>
#define ATK_IS_RELATION_SET(obj)                  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_RELATION_SET))
</MACRO>
<MACRO>
<NAME>ATK_IS_RELATION_SET_CLASS</NAME>
#define ATK_IS_RELATION_SET_CLASS(klass)          (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_RELATION_SET))
</MACRO>
<MACRO>
<NAME>ATK_RELATION_SET_GET_CLASS</NAME>
#define ATK_RELATION_SET_GET_CLASS(obj)           (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_RELATION_SET, AtkRelationSetClass))
</MACRO>
<STRUCT>
<NAME>AtkRelationSet</NAME>
struct _AtkRelationSet
{
  GObject parent;

  GPtrArray *relations;
};
</STRUCT>
<STRUCT>
<NAME>AtkRelationSetClass</NAME>
struct _AtkRelationSetClass
{
  GObjectClass parent;

  AtkFunction pad1;
  AtkFunction pad2;
};
</STRUCT>
<FUNCTION>
<NAME>atk_relation_set_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_relation_set_new</NAME>
<RETURNS>AtkRelationSet *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_relation_set_contains</NAME>
<RETURNS>gboolean</RETURNS>
AtkRelationSet  *set, AtkRelationType relationship
</FUNCTION>
<FUNCTION>
<NAME>atk_relation_set_contains_target</NAME>
<RETURNS>gboolean</RETURNS>
AtkRelationSet  *set, AtkRelationType relationship, AtkObject       *target
</FUNCTION>
<FUNCTION>
<NAME>atk_relation_set_remove</NAME>
<RETURNS>void</RETURNS>
AtkRelationSet  *set, AtkRelation     *relation
</FUNCTION>
<FUNCTION>
<NAME>atk_relation_set_add</NAME>
<RETURNS>void</RETURNS>
AtkRelationSet  *set, AtkRelation     *relation
</FUNCTION>
<FUNCTION>
<NAME>atk_relation_set_get_n_relations</NAME>
<RETURNS>gint</RETURNS>
AtkRelationSet  *set
</FUNCTION>
<FUNCTION>
<NAME>atk_relation_set_get_relation</NAME>
<RETURNS>AtkRelation *</RETURNS>
AtkRelationSet  *set, gint            i
</FUNCTION>
<FUNCTION>
<NAME>atk_relation_set_get_relation_by_type</NAME>
<RETURNS>AtkRelation *</RETURNS>
AtkRelationSet  *set, AtkRelationType relationship
</FUNCTION>
<FUNCTION>
<NAME>atk_relation_set_add_relation_by_type</NAME>
<RETURNS>void</RETURNS>
AtkRelationSet  *set, AtkRelationType relationship, AtkObject       *target
</FUNCTION>
<ENUM>
<NAME>AtkRelationType</NAME>
typedef enum
{
  ATK_RELATION_NULL = 0,
  ATK_RELATION_CONTROLLED_BY,
  ATK_RELATION_CONTROLLER_FOR,
  ATK_RELATION_LABEL_FOR,
  ATK_RELATION_LABELLED_BY,
  ATK_RELATION_MEMBER_OF,
  ATK_RELATION_NODE_CHILD_OF,
  ATK_RELATION_FLOWS_TO,
  ATK_RELATION_FLOWS_FROM,
  ATK_RELATION_SUBWINDOW_OF, 
  ATK_RELATION_EMBEDS, 
  ATK_RELATION_EMBEDDED_BY, 
  ATK_RELATION_POPUP_FOR, 
  ATK_RELATION_PARENT_WINDOW_OF, 
  ATK_RELATION_DESCRIBED_BY,
  ATK_RELATION_DESCRIPTION_FOR,
  ATK_RELATION_NODE_PARENT_OF,
  ATK_RELATION_DETAILS,
  ATK_RELATION_DETAILS_FOR,
  ATK_RELATION_ERROR_MESSAGE,
  ATK_RELATION_ERROR_FOR,
  ATK_RELATION_LAST_DEFINED
} AtkRelationType;
</ENUM>
<MACRO>
<NAME>ATK_TYPE_SELECTION</NAME>
#define ATK_TYPE_SELECTION                        (atk_selection_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_IS_SELECTION</NAME>
#define ATK_IS_SELECTION(obj)                     G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_SELECTION)
</MACRO>
<MACRO>
<NAME>ATK_SELECTION</NAME>
#define ATK_SELECTION(obj)                        G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_SELECTION, AtkSelection)
</MACRO>
<MACRO>
<NAME>ATK_SELECTION_GET_IFACE</NAME>
#define ATK_SELECTION_GET_IFACE(obj)              (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_SELECTION, AtkSelectionIface))
</MACRO>
<STRUCT>
<NAME>AtkSelectionIface</NAME>
struct _AtkSelectionIface
{
  GTypeInterface parent;

  gboolean     (* add_selection)        (AtkSelection   *selection,
                                         gint           i);
  gboolean     (* clear_selection)      (AtkSelection   *selection);
  AtkObject*   (* ref_selection)        (AtkSelection   *selection,
                                         gint           i);
  gint         (* get_selection_count)  (AtkSelection   *selection);
  gboolean     (* is_child_selected)    (AtkSelection   *selection,
                                         gint           i);
  gboolean     (* remove_selection)     (AtkSelection   *selection,
                                         gint           i);
  gboolean     (* select_all_selection) (AtkSelection   *selection);

  /* signal handlers */
  
  void         (*selection_changed)     (AtkSelection   *selection);
};
</STRUCT>
<FUNCTION>
<NAME>atk_selection_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_selection_add_selection</NAME>
<RETURNS>gboolean</RETURNS>
AtkSelection   *selection, gint           i
</FUNCTION>
<FUNCTION>
<NAME>atk_selection_clear_selection</NAME>
<RETURNS>gboolean</RETURNS>
AtkSelection   *selection
</FUNCTION>
<FUNCTION>
<NAME>atk_selection_ref_selection</NAME>
<RETURNS>AtkObject *</RETURNS>
AtkSelection   *selection, gint           i
</FUNCTION>
<FUNCTION>
<NAME>atk_selection_get_selection_count</NAME>
<RETURNS>gint</RETURNS>
AtkSelection   *selection
</FUNCTION>
<FUNCTION>
<NAME>atk_selection_is_child_selected</NAME>
<RETURNS>gboolean</RETURNS>
AtkSelection   *selection, gint           i
</FUNCTION>
<FUNCTION>
<NAME>atk_selection_remove_selection</NAME>
<RETURNS>gboolean</RETURNS>
AtkSelection   *selection, gint           i
</FUNCTION>
<FUNCTION>
<NAME>atk_selection_select_all_selection</NAME>
<RETURNS>gboolean</RETURNS>
AtkSelection   *selection
</FUNCTION>
<STRUCT>
<NAME>AtkSelection</NAME>
</STRUCT>
<MACRO>
<NAME>ATK_TYPE_SOCKET</NAME>
#define ATK_TYPE_SOCKET               (atk_socket_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_SOCKET</NAME>
#define ATK_SOCKET(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_SOCKET, AtkSocket))
</MACRO>
<MACRO>
<NAME>ATK_IS_SOCKET</NAME>
#define ATK_IS_SOCKET(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_SOCKET))
</MACRO>
<MACRO>
<NAME>ATK_SOCKET_CLASS</NAME>
#define ATK_SOCKET_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_SOCKET, AtkSocketClass))
</MACRO>
<MACRO>
<NAME>ATK_IS_SOCKET_CLASS</NAME>
#define ATK_IS_SOCKET_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_SOCKET))
</MACRO>
<MACRO>
<NAME>ATK_SOCKET_GET_CLASS</NAME>
#define ATK_SOCKET_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_SOCKET, AtkSocketClass))
</MACRO>
<STRUCT>
<NAME>AtkSocket</NAME>
struct _AtkSocket
{
  AtkObject parent;

  /*< private >*/
  gchar* embedded_plug_id;
};
</STRUCT>
<FUNCTION>
<NAME>atk_socket_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>AtkSocketClass</NAME>
struct _AtkSocketClass
{
  AtkObjectClass parent_class;
  
  /* to be subscribed to by atk-bridge */

  /*< protected >*/
  void (* embed) (AtkSocket *obj, gchar* plug_id);
};
</STRUCT>
<FUNCTION>
<NAME>atk_socket_new</NAME>
<RETURNS>AtkObject *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_socket_embed</NAME>
<RETURNS>void</RETURNS>
AtkSocket* obj, gchar* plug_id
</FUNCTION>
<FUNCTION>
<NAME>atk_socket_is_occupied</NAME>
<RETURNS>gboolean</RETURNS>
AtkSocket* obj
</FUNCTION>
<ENUM>
<NAME>AtkStateType</NAME>
typedef enum
{
  ATK_STATE_INVALID,
  ATK_STATE_ACTIVE,
  ATK_STATE_ARMED,
  ATK_STATE_BUSY,
  ATK_STATE_CHECKED,
  ATK_STATE_DEFUNCT,
  ATK_STATE_EDITABLE,
  ATK_STATE_ENABLED,
  ATK_STATE_EXPANDABLE,
  ATK_STATE_EXPANDED,
  ATK_STATE_FOCUSABLE,
  ATK_STATE_FOCUSED,
  ATK_STATE_HORIZONTAL,
  ATK_STATE_ICONIFIED,
  ATK_STATE_MODAL,
  ATK_STATE_MULTI_LINE,
  ATK_STATE_MULTISELECTABLE,
  ATK_STATE_OPAQUE,
  ATK_STATE_PRESSED,
  ATK_STATE_RESIZABLE,
  ATK_STATE_SELECTABLE,
  ATK_STATE_SELECTED,
  ATK_STATE_SENSITIVE,
  ATK_STATE_SHOWING,
  ATK_STATE_SINGLE_LINE,
  ATK_STATE_STALE,
  ATK_STATE_TRANSIENT,
  ATK_STATE_VERTICAL,
  ATK_STATE_VISIBLE,
  ATK_STATE_MANAGES_DESCENDANTS,
  ATK_STATE_INDETERMINATE,
  ATK_STATE_TRUNCATED,
  ATK_STATE_REQUIRED,
  ATK_STATE_INVALID_ENTRY,
  ATK_STATE_SUPPORTS_AUTOCOMPLETION,
  ATK_STATE_SELECTABLE_TEXT,
  ATK_STATE_DEFAULT,
  ATK_STATE_ANIMATED,
  ATK_STATE_VISITED,
  ATK_STATE_CHECKABLE,
  ATK_STATE_HAS_POPUP,
  ATK_STATE_HAS_TOOLTIP,
  ATK_STATE_READ_ONLY,
  ATK_STATE_LAST_DEFINED
} AtkStateType;
</ENUM>
<TYPEDEF>
<NAME>AtkState</NAME>
typedef guint64      AtkState;
</TYPEDEF>
<FUNCTION>
<NAME>atk_state_type_register</NAME>
<RETURNS>AtkStateType</RETURNS>
const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>atk_state_type_get_name</NAME>
<RETURNS>const gchar *</RETURNS>
AtkStateType type
</FUNCTION>
<FUNCTION>
<NAME>atk_state_type_for_name</NAME>
<RETURNS>AtkStateType</RETURNS>
const gchar  *name
</FUNCTION>
<MACRO>
<NAME>ATK_TYPE_STATE_SET</NAME>
#define ATK_TYPE_STATE_SET                        (atk_state_set_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_STATE_SET</NAME>
#define ATK_STATE_SET(obj)                        (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_STATE_SET, AtkStateSet))
</MACRO>
<MACRO>
<NAME>ATK_STATE_SET_CLASS</NAME>
#define ATK_STATE_SET_CLASS(klass)                (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_STATE_SET, AtkStateSetClass))
</MACRO>
<MACRO>
<NAME>ATK_IS_STATE_SET</NAME>
#define ATK_IS_STATE_SET(obj)                     (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_STATE_SET))
</MACRO>
<MACRO>
<NAME>ATK_IS_STATE_SET_CLASS</NAME>
#define ATK_IS_STATE_SET_CLASS(klass)             (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_STATE_SET))
</MACRO>
<MACRO>
<NAME>ATK_STATE_SET_GET_CLASS</NAME>
#define ATK_STATE_SET_GET_CLASS(obj)              (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_STATE_SET, AtkStateSetClass))
</MACRO>
<STRUCT>
<NAME>AtkStateSet</NAME>
struct _AtkStateSet
{
  GObject parent;

};
</STRUCT>
<STRUCT>
<NAME>AtkStateSetClass</NAME>
struct _AtkStateSetClass
{
  GObjectClass parent;
};
</STRUCT>
<FUNCTION>
<NAME>atk_state_set_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_state_set_new</NAME>
<RETURNS>AtkStateSet *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_state_set_is_empty</NAME>
<RETURNS>gboolean</RETURNS>
AtkStateSet  *set
</FUNCTION>
<FUNCTION>
<NAME>atk_state_set_add_state</NAME>
<RETURNS>gboolean</RETURNS>
AtkStateSet  *set, AtkStateType type
</FUNCTION>
<FUNCTION>
<NAME>atk_state_set_add_states</NAME>
<RETURNS>void</RETURNS>
AtkStateSet  *set, AtkStateType *types, gint         n_types
</FUNCTION>
<FUNCTION>
<NAME>atk_state_set_clear_states</NAME>
<RETURNS>void</RETURNS>
AtkStateSet  *set
</FUNCTION>
<FUNCTION>
<NAME>atk_state_set_contains_state</NAME>
<RETURNS>gboolean</RETURNS>
AtkStateSet  *set, AtkStateType type
</FUNCTION>
<FUNCTION>
<NAME>atk_state_set_contains_states</NAME>
<RETURNS>gboolean</RETURNS>
AtkStateSet  *set, AtkStateType *types, gint         n_types
</FUNCTION>
<FUNCTION>
<NAME>atk_state_set_remove_state</NAME>
<RETURNS>gboolean</RETURNS>
AtkStateSet  *set, AtkStateType type
</FUNCTION>
<FUNCTION>
<NAME>atk_state_set_and_sets</NAME>
<RETURNS>AtkStateSet *</RETURNS>
AtkStateSet  *set, AtkStateSet  *compare_set
</FUNCTION>
<FUNCTION>
<NAME>atk_state_set_or_sets</NAME>
<RETURNS>AtkStateSet *</RETURNS>
AtkStateSet  *set, AtkStateSet  *compare_set
</FUNCTION>
<FUNCTION>
<NAME>atk_state_set_xor_sets</NAME>
<RETURNS>AtkStateSet *</RETURNS>
AtkStateSet  *set, AtkStateSet  *compare_set
</FUNCTION>
<MACRO>
<NAME>ATK_TYPE_STREAMABLE_CONTENT</NAME>
#define ATK_TYPE_STREAMABLE_CONTENT           (atk_streamable_content_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_IS_STREAMABLE_CONTENT</NAME>
#define ATK_IS_STREAMABLE_CONTENT(obj)        G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_STREAMABLE_CONTENT)
</MACRO>
<MACRO>
<NAME>ATK_STREAMABLE_CONTENT</NAME>
#define ATK_STREAMABLE_CONTENT(obj)           G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_STREAMABLE_CONTENT, AtkStreamableContent)
</MACRO>
<MACRO>
<NAME>ATK_STREAMABLE_CONTENT_GET_IFACE</NAME>
#define ATK_STREAMABLE_CONTENT_GET_IFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_STREAMABLE_CONTENT, AtkStreamableContentIface))
</MACRO>
<STRUCT>
<NAME>AtkStreamableContentIface</NAME>
struct _AtkStreamableContentIface
{
  GTypeInterface parent;

  /*
   * Get the number of mime types supported by this object
   */
  gint                      (* get_n_mime_types)  (AtkStreamableContent     *streamable);
  /*
   * Gets the specified mime type supported by this object.
   * The mime types are 0-based so the first mime type is 
   * at index 0, the second at index 1 and so on.  The mime-type
   * at index 0 should be considered the "default" data type for the stream.
   *
   * This assumes that the strings for the mime types are stored in the
   * AtkStreamableContent. Alternatively the const could be removed
   * and the caller would be responsible for calling g_free() on the
   * returned value.
   */
  const gchar*              (* get_mime_type)     (AtkStreamableContent     *streamable,
                                                   gint                     i);
  /*
   * One possible implementation for this method is that it constructs the
   * content appropriate for the mime type and then creates a temporary
   * file containing the content, opens the file and then calls
   * g_io_channel_unix_new_fd().
   */
  GIOChannel*               (* get_stream)        (AtkStreamableContent     *streamable,
                                                   const gchar              *mime_type);

/*
 * Returns a string representing a URI in IETF standard format
 * (see http://www.ietf.org/rfc/rfc2396.txt) from which the object's content
 * may be streamed in the specified mime-type.
 * If mime_type is NULL, the URI for the default (and possibly only) mime-type is
 * returned.
 *
 * returns NULL if the mime-type is not supported, or if no URI can be 
 * constructed.  Note that it is possible for get_uri to return NULL but for
 * get_stream to work nonetheless, since not all GIOChannels connect to URIs.
 */
    const  gchar*           (* get_uri)           (AtkStreamableContent     *streamable,
                                                   const gchar              *mime_type);


  AtkFunction               pad1;
  AtkFunction               pad2;
  AtkFunction               pad3;
};
</STRUCT>
<FUNCTION>
<NAME>atk_streamable_content_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_streamable_content_get_n_mime_types</NAME>
<RETURNS>gint</RETURNS>
AtkStreamableContent     *streamable
</FUNCTION>
<FUNCTION>
<NAME>atk_streamable_content_get_mime_type</NAME>
<RETURNS>const gchar *</RETURNS>
AtkStreamableContent     *streamable, gint                     i
</FUNCTION>
<FUNCTION>
<NAME>atk_streamable_content_get_stream</NAME>
<RETURNS>GIOChannel *</RETURNS>
AtkStreamableContent     *streamable, const gchar              *mime_type
</FUNCTION>
<FUNCTION>
<NAME>atk_streamable_content_get_uri</NAME>
<RETURNS>const gchar *</RETURNS>
AtkStreamableContent     *streamable, const gchar              *mime_type
</FUNCTION>
<STRUCT>
<NAME>AtkStreamableContent</NAME>
</STRUCT>
<MACRO>
<NAME>ATK_TYPE_TABLE</NAME>
#define ATK_TYPE_TABLE                    (atk_table_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_IS_TABLE</NAME>
#define ATK_IS_TABLE(obj)                 G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_TABLE)
</MACRO>
<MACRO>
<NAME>ATK_TABLE</NAME>
#define ATK_TABLE(obj)                    G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_TABLE, AtkTable)
</MACRO>
<MACRO>
<NAME>ATK_TABLE_GET_IFACE</NAME>
#define ATK_TABLE_GET_IFACE(obj)          (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_TABLE, AtkTableIface))
</MACRO>
<STRUCT>
<NAME>AtkTableIface</NAME>
struct _AtkTableIface
{
  GTypeInterface parent;

  AtkObject*        (* ref_at)                   (AtkTable      *table,
                                                  gint          row,
                                                  gint          column);
  gint              (* get_index_at)             (AtkTable      *table,
                                                  gint          row,
                                                  gint          column);
  gint              (* get_column_at_index)      (AtkTable      *table,
                                                  gint          index_);
  gint              (* get_row_at_index)         (AtkTable      *table,
                                                  gint          index_);
  gint              (* get_n_columns)           (AtkTable      *table);
  gint              (* get_n_rows)               (AtkTable      *table);
  gint              (* get_column_extent_at)     (AtkTable      *table,
                                                  gint          row,
                                                  gint          column);
  gint              (* get_row_extent_at)        (AtkTable      *table,
                                                  gint          row,
                                                  gint          column);
  AtkObject*
                    (* get_caption)              (AtkTable      *table);
  const gchar*      (* get_column_description)   (AtkTable      *table,
                                                  gint          column);
  AtkObject*        (* get_column_header)        (AtkTable      *table,
						  gint		column);
  const gchar*      (* get_row_description)      (AtkTable      *table,
                                                  gint          row);
  AtkObject*        (* get_row_header)           (AtkTable      *table,
						  gint		row);
  AtkObject*        (* get_summary)              (AtkTable      *table);
  void              (* set_caption)              (AtkTable      *table,
                                                  AtkObject     *caption);
  void              (* set_column_description)   (AtkTable      *table,
                                                  gint          column,
                                                  const gchar   *description);
  void              (* set_column_header)        (AtkTable      *table,
                                                  gint          column,
                                                  AtkObject     *header);
  void              (* set_row_description)      (AtkTable      *table,
                                                  gint          row,
                                                  const gchar   *description);
  void              (* set_row_header)           (AtkTable      *table,
                                                  gint          row,
                                                  AtkObject     *header);
  void              (* set_summary)              (AtkTable      *table,
                                                  AtkObject     *accessible);
  gint              (* get_selected_columns)     (AtkTable      *table,
                                                  gint          **selected);
  gint              (* get_selected_rows)        (AtkTable      *table,
                                                  gint          **selected);
  gboolean          (* is_column_selected)       (AtkTable      *table,
                                                  gint          column);
  gboolean          (* is_row_selected)          (AtkTable      *table,
                                                  gint          row);
  gboolean          (* is_selected)              (AtkTable      *table,
                                                  gint          row,
                                                  gint          column);
  gboolean          (* add_row_selection)        (AtkTable      *table,
                                                  gint          row);
  gboolean          (* remove_row_selection)     (AtkTable      *table,
                                                  gint          row);
  gboolean          (* add_column_selection)     (AtkTable      *table,
                                                  gint          column);
  gboolean          (* remove_column_selection)  (AtkTable      *table,
                                                  gint          column);

  /*
   * signal handlers
   */
  void              (* row_inserted)             (AtkTable      *table,
                                                  gint          row,
                                                  gint          num_inserted);
  void              (* column_inserted)          (AtkTable      *table,
                                                  gint          column,
                                                  gint          num_inserted);
  void              (* row_deleted)              (AtkTable      *table,
                                                  gint          row,
                                                  gint          num_deleted);
  void              (* column_deleted)           (AtkTable      *table,
                                                  gint          column,
                                                  gint          num_deleted);
  void              (* row_reordered)            (AtkTable      *table);
  void              (* column_reordered)         (AtkTable      *table);
  void              (* model_changed)            (AtkTable      *table);
};
</STRUCT>
<FUNCTION>
<NAME>atk_table_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_table_ref_at</NAME>
<RETURNS>AtkObject *</RETURNS>
AtkTable         *table, gint             row, gint             column
</FUNCTION>
<FUNCTION>
<NAME>atk_table_get_index_at</NAME>
<DEPRECATED/>
<RETURNS>gint</RETURNS>
AtkTable         *table, gint             row, gint             column
</FUNCTION>
<FUNCTION>
<NAME>atk_table_get_column_at_index</NAME>
<DEPRECATED/>
<RETURNS>gint</RETURNS>
AtkTable         *table, gint             index_
</FUNCTION>
<FUNCTION>
<NAME>atk_table_get_row_at_index</NAME>
<DEPRECATED/>
<RETURNS>gint</RETURNS>
AtkTable         *table, gint             index_
</FUNCTION>
<FUNCTION>
<NAME>atk_table_get_n_columns</NAME>
<RETURNS>gint</RETURNS>
AtkTable         *table
</FUNCTION>
<FUNCTION>
<NAME>atk_table_get_n_rows</NAME>
<RETURNS>gint</RETURNS>
AtkTable         *table
</FUNCTION>
<FUNCTION>
<NAME>atk_table_get_column_extent_at</NAME>
<RETURNS>gint</RETURNS>
AtkTable         *table, gint             row, gint             column
</FUNCTION>
<FUNCTION>
<NAME>atk_table_get_row_extent_at</NAME>
<RETURNS>gint</RETURNS>
AtkTable         *table, gint             row, gint             column
</FUNCTION>
<FUNCTION>
<NAME>atk_table_get_caption</NAME>
<RETURNS>AtkObject *</RETURNS>
AtkTable         *table
</FUNCTION>
<FUNCTION>
<NAME>atk_table_get_column_description</NAME>
<RETURNS>const gchar *</RETURNS>
AtkTable         *table, gint             column
</FUNCTION>
<FUNCTION>
<NAME>atk_table_get_column_header</NAME>
<RETURNS>AtkObject *</RETURNS>
AtkTable         *table, gint		   column
</FUNCTION>
<FUNCTION>
<NAME>atk_table_get_row_description</NAME>
<RETURNS>const gchar *</RETURNS>
AtkTable         *table, gint             row
</FUNCTION>
<FUNCTION>
<NAME>atk_table_get_row_header</NAME>
<RETURNS>AtkObject *</RETURNS>
AtkTable         *table, gint		   row
</FUNCTION>
<FUNCTION>
<NAME>atk_table_get_summary</NAME>
<RETURNS>AtkObject *</RETURNS>
AtkTable         *table
</FUNCTION>
<FUNCTION>
<NAME>atk_table_set_caption</NAME>
<RETURNS>void</RETURNS>
AtkTable         *table, AtkObject        *caption
</FUNCTION>
<FUNCTION>
<NAME>atk_table_set_column_description</NAME>
<RETURNS>void</RETURNS>
AtkTable         *table, gint             column, const gchar      *description
</FUNCTION>
<FUNCTION>
<NAME>atk_table_set_column_header</NAME>
<RETURNS>void</RETURNS>
AtkTable         *table, gint             column, AtkObject        *header
</FUNCTION>
<FUNCTION>
<NAME>atk_table_set_row_description</NAME>
<RETURNS>void</RETURNS>
AtkTable         *table, gint             row, const gchar      *description
</FUNCTION>
<FUNCTION>
<NAME>atk_table_set_row_header</NAME>
<RETURNS>void</RETURNS>
AtkTable         *table, gint             row, AtkObject        *header
</FUNCTION>
<FUNCTION>
<NAME>atk_table_set_summary</NAME>
<RETURNS>void</RETURNS>
AtkTable         *table, AtkObject        *accessible
</FUNCTION>
<FUNCTION>
<NAME>atk_table_get_selected_columns</NAME>
<RETURNS>gint</RETURNS>
AtkTable         *table, gint             **selected
</FUNCTION>
<FUNCTION>
<NAME>atk_table_get_selected_rows</NAME>
<RETURNS>gint</RETURNS>
AtkTable         *table, gint             **selected
</FUNCTION>
<FUNCTION>
<NAME>atk_table_is_column_selected</NAME>
<RETURNS>gboolean</RETURNS>
AtkTable         *table, gint             column
</FUNCTION>
<FUNCTION>
<NAME>atk_table_is_row_selected</NAME>
<RETURNS>gboolean</RETURNS>
AtkTable         *table, gint             row
</FUNCTION>
<FUNCTION>
<NAME>atk_table_is_selected</NAME>
<RETURNS>gboolean</RETURNS>
AtkTable         *table, gint             row, gint             column
</FUNCTION>
<FUNCTION>
<NAME>atk_table_add_row_selection</NAME>
<RETURNS>gboolean</RETURNS>
AtkTable         *table, gint             row
</FUNCTION>
<FUNCTION>
<NAME>atk_table_remove_row_selection</NAME>
<RETURNS>gboolean</RETURNS>
AtkTable         *table, gint             row
</FUNCTION>
<FUNCTION>
<NAME>atk_table_add_column_selection</NAME>
<RETURNS>gboolean</RETURNS>
AtkTable         *table, gint             column
</FUNCTION>
<FUNCTION>
<NAME>atk_table_remove_column_selection</NAME>
<RETURNS>gboolean</RETURNS>
AtkTable         *table, gint             column
</FUNCTION>
<STRUCT>
<NAME>AtkTable</NAME>
</STRUCT>
<MACRO>
<NAME>ATK_TYPE_TABLE_CELL</NAME>
#define ATK_TYPE_TABLE_CELL                    (atk_table_cell_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_IS_TABLE_CELL</NAME>
#define ATK_IS_TABLE_CELL(obj)                 G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_TABLE_CELL)
</MACRO>
<MACRO>
<NAME>ATK_TABLE_CELL</NAME>
#define ATK_TABLE_CELL(obj)                    G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_TABLE_CELL, AtkTableCell)
</MACRO>
<MACRO>
<NAME>ATK_TABLE_CELL_GET_IFACE</NAME>
#define ATK_TABLE_CELL_GET_IFACE(obj)          (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_TABLE_CELL, AtkTableCellIface))
</MACRO>
<STRUCT>
<NAME>AtkTableCellIface</NAME>
struct _AtkTableCellIface
{
  GTypeInterface parent;

  gint          (*get_column_span)         (AtkTableCell *cell);
  GPtrArray *   (*get_column_header_cells) (AtkTableCell *cell);
  gboolean      (*get_position)            (AtkTableCell *cell,
                                            gint         *row,
                                            gint         *column);
  gint          (*get_row_span)            (AtkTableCell *cell);
  GPtrArray *   (*get_row_header_cells)    (AtkTableCell *cell);
  gboolean      (*get_row_column_span)     (AtkTableCell *cell,
                                            gint         *row,
                                            gint         *column,
                                            gint         *row_span,
                                            gint         *column_span);
  AtkObject *   (*get_table)               (AtkTableCell *cell);
};
</STRUCT>
<FUNCTION>
<NAME>atk_table_cell_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_table_cell_get_column_span</NAME>
<RETURNS>gint</RETURNS>
AtkTableCell *cell
</FUNCTION>
<FUNCTION>
<NAME>atk_table_cell_get_column_header_cells</NAME>
<RETURNS>GPtrArray *</RETURNS>
AtkTableCell *cell
</FUNCTION>
<FUNCTION>
<NAME>atk_table_cell_get_position</NAME>
<RETURNS>gboolean</RETURNS>
AtkTableCell *cell, gint         *row, gint         *column
</FUNCTION>
<FUNCTION>
<NAME>atk_table_cell_get_row_span</NAME>
<RETURNS>gint</RETURNS>
AtkTableCell *cell
</FUNCTION>
<FUNCTION>
<NAME>atk_table_cell_get_row_header_cells</NAME>
<RETURNS>GPtrArray *</RETURNS>
AtkTableCell *cell
</FUNCTION>
<FUNCTION>
<NAME>atk_table_cell_get_row_column_span</NAME>
<RETURNS>gboolean</RETURNS>
AtkTableCell *cell, gint         *row, gint         *column, gint         *row_span, gint         *column_span
</FUNCTION>
<FUNCTION>
<NAME>atk_table_cell_get_table</NAME>
<RETURNS>AtkObject *</RETURNS>
AtkTableCell *cell
</FUNCTION>
<STRUCT>
<NAME>AtkTableCell</NAME>
</STRUCT>
<ENUM>
<NAME>AtkTextAttribute</NAME>
typedef enum
{
  ATK_TEXT_ATTR_INVALID = 0,
  ATK_TEXT_ATTR_LEFT_MARGIN,
  ATK_TEXT_ATTR_RIGHT_MARGIN,
  ATK_TEXT_ATTR_INDENT,
  ATK_TEXT_ATTR_INVISIBLE,
  ATK_TEXT_ATTR_EDITABLE,
  ATK_TEXT_ATTR_PIXELS_ABOVE_LINES,
  ATK_TEXT_ATTR_PIXELS_BELOW_LINES,
  ATK_TEXT_ATTR_PIXELS_INSIDE_WRAP,
  ATK_TEXT_ATTR_BG_FULL_HEIGHT,
  ATK_TEXT_ATTR_RISE,
  ATK_TEXT_ATTR_UNDERLINE,
  ATK_TEXT_ATTR_STRIKETHROUGH,
  ATK_TEXT_ATTR_SIZE,
  ATK_TEXT_ATTR_SCALE,
  ATK_TEXT_ATTR_WEIGHT,
  ATK_TEXT_ATTR_LANGUAGE,
  ATK_TEXT_ATTR_FAMILY_NAME,
  ATK_TEXT_ATTR_BG_COLOR,
  ATK_TEXT_ATTR_FG_COLOR,
  ATK_TEXT_ATTR_BG_STIPPLE,
  ATK_TEXT_ATTR_FG_STIPPLE,
  ATK_TEXT_ATTR_WRAP_MODE,
  ATK_TEXT_ATTR_DIRECTION,
  ATK_TEXT_ATTR_JUSTIFICATION,
  ATK_TEXT_ATTR_STRETCH,
  ATK_TEXT_ATTR_VARIANT,
  ATK_TEXT_ATTR_STYLE,
  ATK_TEXT_ATTR_LAST_DEFINED
} AtkTextAttribute;
</ENUM>
<FUNCTION>
<NAME>atk_text_attribute_register</NAME>
<RETURNS>AtkTextAttribute</RETURNS>
const gchar *name
</FUNCTION>
<MACRO>
<NAME>ATK_TYPE_TEXT</NAME>
#define ATK_TYPE_TEXT                    (atk_text_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_IS_TEXT</NAME>
#define ATK_IS_TEXT(obj)                 G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_TEXT)
</MACRO>
<MACRO>
<NAME>ATK_TEXT</NAME>
#define ATK_TEXT(obj)                    G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_TEXT, AtkText)
</MACRO>
<MACRO>
<NAME>ATK_TEXT_GET_IFACE</NAME>
#define ATK_TEXT_GET_IFACE(obj)          (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_TEXT, AtkTextIface))
</MACRO>
<ENUM>
<NAME>AtkTextBoundary</NAME>
typedef enum {
  ATK_TEXT_BOUNDARY_CHAR,
  ATK_TEXT_BOUNDARY_WORD_START,
  ATK_TEXT_BOUNDARY_WORD_END,
  ATK_TEXT_BOUNDARY_SENTENCE_START,
  ATK_TEXT_BOUNDARY_SENTENCE_END,
  ATK_TEXT_BOUNDARY_LINE_START,
  ATK_TEXT_BOUNDARY_LINE_END
} AtkTextBoundary;
</ENUM>
<ENUM>
<NAME>AtkTextGranularity</NAME>
typedef enum {
  ATK_TEXT_GRANULARITY_CHAR,
  ATK_TEXT_GRANULARITY_WORD,
  ATK_TEXT_GRANULARITY_SENTENCE,
  ATK_TEXT_GRANULARITY_LINE,
  ATK_TEXT_GRANULARITY_PARAGRAPH
} AtkTextGranularity;
</ENUM>
<STRUCT>
<NAME>AtkTextRectangle</NAME>
struct _AtkTextRectangle {
  gint x;
  gint y;
  gint width;
  gint height;
};
</STRUCT>
<STRUCT>
<NAME>AtkTextRange</NAME>
struct _AtkTextRange {
  AtkTextRectangle bounds;
  gint start_offset;
  gint end_offset;
  gchar* content;
};
</STRUCT>
<FUNCTION>
<NAME>atk_text_range_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<ENUM>
<NAME>AtkTextClipType</NAME>
typedef enum {
    ATK_TEXT_CLIP_NONE,
    ATK_TEXT_CLIP_MIN,
    ATK_TEXT_CLIP_MAX,
    ATK_TEXT_CLIP_BOTH
} AtkTextClipType;
</ENUM>
<STRUCT>
<NAME>AtkTextIface</NAME>
struct _AtkTextIface
{
  GTypeInterface parent;

  gchar*         (* get_text)                     (AtkText          *text,
                                                   gint             start_offset,
                                                   gint             end_offset);
  gchar*         (* get_text_after_offset)        (AtkText          *text,
                                                   gint             offset,
                                                   AtkTextBoundary  boundary_type,
						   gint             *start_offset,
						   gint             *end_offset);
  gchar*         (* get_text_at_offset)           (AtkText          *text,
                                                   gint             offset,
                                                   AtkTextBoundary  boundary_type,
						   gint             *start_offset,
						   gint             *end_offset);
  gunichar       (* get_character_at_offset)      (AtkText          *text,
                                                   gint             offset);
  gchar*         (* get_text_before_offset)       (AtkText          *text,
                                                   gint             offset,
                                                   AtkTextBoundary  boundary_type,
 						   gint             *start_offset,
						   gint             *end_offset);
  gint           (* get_caret_offset)             (AtkText          *text);
  AtkAttributeSet* (* get_run_attributes)         (AtkText	    *text,
						   gint	  	    offset,
						   gint             *start_offset,
						   gint	 	    *end_offset);
  AtkAttributeSet* (* get_default_attributes)     (AtkText	    *text);
  void           (* get_character_extents)        (AtkText          *text,
                                                   gint             offset,
                                                   gint             *x,
                                                   gint             *y,
                                                   gint             *width,
                                                   gint             *height,
                                                   AtkCoordType	    coords);
  gint           (* get_character_count)          (AtkText          *text);
  gint           (* get_offset_at_point)          (AtkText          *text,
                                                   gint             x,
                                                   gint             y,
                                                   AtkCoordType	    coords);
  gint		 (* get_n_selections)		  (AtkText          *text);
  gchar*         (* get_selection)	          (AtkText          *text,
						   gint		    selection_num,
						   gint		    *start_offset,
						   gint		    *end_offset);
  gboolean       (* add_selection)		  (AtkText          *text,
						   gint		    start_offset,
						   gint		    end_offset);
  gboolean       (* remove_selection)		  (AtkText          *text,
						   gint             selection_num);
  gboolean       (* set_selection)		  (AtkText          *text,
						   gint		    selection_num,
						   gint		    start_offset,
						   gint		    end_offset);
  gboolean       (* set_caret_offset)             (AtkText          *text,
                                                   gint             offset);

  /*
   * signal handlers
   */
  void		 (* text_changed)                 (AtkText          *text,
                                                   gint             position,
                                                   gint             length);
  void           (* text_caret_moved)             (AtkText          *text,
                                                   gint             location);
  void           (* text_selection_changed)       (AtkText          *text);

  void           (* text_attributes_changed)      (AtkText          *text);


  void           (* get_range_extents)            (AtkText          *text,
                                                   gint             start_offset,
                                                   gint             end_offset,
                                                   AtkCoordType     coord_type,
                                                   AtkTextRectangle *rect);

  AtkTextRange** (* get_bounded_ranges)           (AtkText          *text,
                                                   AtkTextRectangle *rect,
                                                   AtkCoordType     coord_type,
                                                   AtkTextClipType  x_clip_type,
                                                   AtkTextClipType  y_clip_type);

  gchar*         (* get_string_at_offset)         (AtkText            *text,
                                                   gint               offset,
                                                   AtkTextGranularity granularity,
                                                   gint               *start_offset,
                                                   gint               *end_offset);
};
</STRUCT>
<FUNCTION>
<NAME>atk_text_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_text_get_text</NAME>
<RETURNS>gchar *</RETURNS>
AtkText          *text, gint             start_offset, gint             end_offset
</FUNCTION>
<FUNCTION>
<NAME>atk_text_get_character_at_offset</NAME>
<RETURNS>gunichar</RETURNS>
AtkText          *text, gint             offset
</FUNCTION>
<FUNCTION>
<NAME>atk_text_get_text_after_offset</NAME>
<DEPRECATED/>
<RETURNS>gchar *</RETURNS>
AtkText          *text, gint             offset, AtkTextBoundary  boundary_type, gint             *start_offset, gint	            *end_offset
</FUNCTION>
<FUNCTION>
<NAME>atk_text_get_text_at_offset</NAME>
<DEPRECATED/>
<RETURNS>gchar *</RETURNS>
AtkText          *text, gint             offset, AtkTextBoundary  boundary_type, gint             *start_offset, gint             *end_offset
</FUNCTION>
<FUNCTION>
<NAME>atk_text_get_text_before_offset</NAME>
<DEPRECATED/>
<RETURNS>gchar *</RETURNS>
AtkText          *text, gint             offset, AtkTextBoundary  boundary_type, gint             *start_offset, gint	            *end_offset
</FUNCTION>
<FUNCTION>
<NAME>atk_text_get_string_at_offset</NAME>
<RETURNS>gchar *</RETURNS>
AtkText            *text, gint               offset, AtkTextGranularity granularity, gint               *start_offset, gint               *end_offset
</FUNCTION>
<FUNCTION>
<NAME>atk_text_get_caret_offset</NAME>
<RETURNS>gint</RETURNS>
AtkText          *text
</FUNCTION>
<FUNCTION>
<NAME>atk_text_get_character_extents</NAME>
<RETURNS>void</RETURNS>
AtkText          *text, gint             offset, gint             *x, gint             *y, gint             *width, gint             *height, AtkCoordType	    coords
</FUNCTION>
<FUNCTION>
<NAME>atk_text_get_run_attributes</NAME>
<RETURNS>AtkAttributeSet *</RETURNS>
AtkText	    *text, gint	  	    offset, gint             *start_offset, gint	 	    *end_offset
</FUNCTION>
<FUNCTION>
<NAME>atk_text_get_default_attributes</NAME>
<RETURNS>AtkAttributeSet *</RETURNS>
AtkText	    *text
</FUNCTION>
<FUNCTION>
<NAME>atk_text_get_character_count</NAME>
<RETURNS>gint</RETURNS>
AtkText          *text
</FUNCTION>
<FUNCTION>
<NAME>atk_text_get_offset_at_point</NAME>
<RETURNS>gint</RETURNS>
AtkText          *text, gint             x, gint             y, AtkCoordType	    coords
</FUNCTION>
<FUNCTION>
<NAME>atk_text_get_n_selections</NAME>
<RETURNS>gint</RETURNS>
AtkText          *text
</FUNCTION>
<FUNCTION>
<NAME>atk_text_get_selection</NAME>
<RETURNS>gchar *</RETURNS>
AtkText          *text, gint		    selection_num, gint             *start_offset, gint             *end_offset
</FUNCTION>
<FUNCTION>
<NAME>atk_text_add_selection</NAME>
<RETURNS>gboolean</RETURNS>
AtkText          *text, gint             start_offset, gint             end_offset
</FUNCTION>
<FUNCTION>
<NAME>atk_text_remove_selection</NAME>
<RETURNS>gboolean</RETURNS>
AtkText          *text, gint		    selection_num
</FUNCTION>
<FUNCTION>
<NAME>atk_text_set_selection</NAME>
<RETURNS>gboolean</RETURNS>
AtkText          *text, gint		    selection_num, gint             start_offset, gint             end_offset
</FUNCTION>
<FUNCTION>
<NAME>atk_text_set_caret_offset</NAME>
<RETURNS>gboolean</RETURNS>
AtkText          *text, gint             offset
</FUNCTION>
<FUNCTION>
<NAME>atk_text_get_range_extents</NAME>
<RETURNS>void</RETURNS>
AtkText          *text, gint             start_offset, gint             end_offset, AtkCoordType     coord_type, AtkTextRectangle *rect
</FUNCTION>
<FUNCTION>
<NAME>atk_text_get_bounded_ranges</NAME>
<RETURNS>AtkTextRange **</RETURNS>
AtkText          *text, AtkTextRectangle *rect, AtkCoordType     coord_type, AtkTextClipType  x_clip_type, AtkTextClipType  y_clip_type
</FUNCTION>
<FUNCTION>
<NAME>atk_text_free_ranges</NAME>
<RETURNS>void</RETURNS>
AtkTextRange     **ranges
</FUNCTION>
<FUNCTION>
<NAME>atk_attribute_set_free</NAME>
<RETURNS>void</RETURNS>
AtkAttributeSet  *attrib_set
</FUNCTION>
<FUNCTION>
<NAME>atk_text_attribute_get_name</NAME>
<RETURNS>const gchar *</RETURNS>
AtkTextAttribute attr
</FUNCTION>
<FUNCTION>
<NAME>atk_text_attribute_for_name</NAME>
<RETURNS>AtkTextAttribute</RETURNS>
const gchar      *name
</FUNCTION>
<FUNCTION>
<NAME>atk_text_attribute_get_value</NAME>
<RETURNS>const gchar *</RETURNS>
AtkTextAttribute attr, gint             index_
</FUNCTION>
<STRUCT>
<NAME>AtkText</NAME>
</STRUCT>
<MACRO>
<NAME>ATK_TYPE_UTIL</NAME>
#define ATK_TYPE_UTIL                   (atk_util_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_IS_UTIL</NAME>
#define ATK_IS_UTIL(obj)                G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_UTIL)
</MACRO>
<MACRO>
<NAME>ATK_UTIL</NAME>
#define ATK_UTIL(obj)                   G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_UTIL, AtkUtil)
</MACRO>
<MACRO>
<NAME>ATK_UTIL_CLASS</NAME>
#define ATK_UTIL_CLASS(klass)                   (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_UTIL, AtkUtilClass))
</MACRO>
<MACRO>
<NAME>ATK_IS_UTIL_CLASS</NAME>
#define ATK_IS_UTIL_CLASS(klass)                (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_UTIL))
</MACRO>
<MACRO>
<NAME>ATK_UTIL_GET_CLASS</NAME>
#define ATK_UTIL_GET_CLASS(obj)                 (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_UTIL, AtkUtilClass))
</MACRO>
<USER_FUNCTION>
<NAME>AtkEventListener</NAME>
<RETURNS>void</RETURNS>
AtkObject* obj
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>AtkEventListenerInit</NAME>
<RETURNS>void</RETURNS>
void
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>AtkKeySnoopFunc</NAME>
<RETURNS>gint</RETURNS>
AtkKeyEventStruct *event, gpointer user_data
</USER_FUNCTION>
<STRUCT>
<NAME>AtkKeyEventStruct</NAME>
struct _AtkKeyEventStruct {
  gint type;
  guint state;
  guint keyval;
  gint length;
  gchar *string;
  guint16 keycode;
  guint32 timestamp;	
};
</STRUCT>
<ENUM>
<NAME>AtkKeyEventType</NAME>
typedef enum
{
  ATK_KEY_EVENT_PRESS,
  ATK_KEY_EVENT_RELEASE,
  ATK_KEY_EVENT_LAST_DEFINED
} AtkKeyEventType;
</ENUM>
<STRUCT>
<NAME>AtkUtil</NAME>
struct _AtkUtil
{
  GObject parent;
};
</STRUCT>
<STRUCT>
<NAME>AtkUtilClass</NAME>
struct _AtkUtilClass
{
   GObjectClass parent;
   guint        (* add_global_event_listener)    (GSignalEmissionHook listener,
						  const gchar        *event_type);
   void         (* remove_global_event_listener) (guint               listener_id);
   guint	(* add_key_event_listener) 	 (AtkKeySnoopFunc     listener,
						  gpointer data);
   void         (* remove_key_event_listener)    (guint               listener_id);
   AtkObject*   (* get_root)                     (void);
   const gchar* (* get_toolkit_name)             (void);
   const gchar* (* get_toolkit_version)          (void);
};
</STRUCT>
<FUNCTION>
<NAME>atk_util_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<ENUM>
<NAME>AtkCoordType</NAME>
typedef enum {
  ATK_XY_SCREEN,
  ATK_XY_WINDOW,
  ATK_XY_PARENT
}AtkCoordType;
</ENUM>
<FUNCTION>
<NAME>atk_add_focus_tracker</NAME>
<DEPRECATED/>
<RETURNS>guint</RETURNS>
AtkEventListener      focus_tracker
</FUNCTION>
<FUNCTION>
<NAME>atk_remove_focus_tracker</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
guint                tracker_id
</FUNCTION>
<FUNCTION>
<NAME>atk_focus_tracker_init</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
AtkEventListenerInit  init
</FUNCTION>
<FUNCTION>
<NAME>atk_focus_tracker_notify</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
AtkObject            *object
</FUNCTION>
<FUNCTION>
<NAME>atk_add_global_event_listener</NAME>
<RETURNS>guint</RETURNS>
GSignalEmissionHook listener, const gchar        *event_type
</FUNCTION>
<FUNCTION>
<NAME>atk_remove_global_event_listener</NAME>
<RETURNS>void</RETURNS>
guint listener_id
</FUNCTION>
<FUNCTION>
<NAME>atk_add_key_event_listener</NAME>
<RETURNS>guint</RETURNS>
AtkKeySnoopFunc listener, gpointer data
</FUNCTION>
<FUNCTION>
<NAME>atk_remove_key_event_listener</NAME>
<RETURNS>void</RETURNS>
guint listener_id
</FUNCTION>
<FUNCTION>
<NAME>atk_get_root</NAME>
<RETURNS>AtkObject *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_get_focus_object</NAME>
<RETURNS>AtkObject *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_get_toolkit_name</NAME>
<RETURNS>const gchar *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_get_toolkit_version</NAME>
<RETURNS>const gchar *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_get_version</NAME>
<RETURNS>const gchar *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>ATK_DEFINE_TYPE</NAME>
#define ATK_DEFINE_TYPE(TN, t_n, T_P)			       ATK_DEFINE_TYPE_EXTENDED (TN, t_n, T_P, 0, {})
</MACRO>
<MACRO>
<NAME>ATK_DEFINE_TYPE_WITH_CODE</NAME>
#define ATK_DEFINE_TYPE_WITH_CODE(TN, t_n, T_P, _C_)	      _ATK_DEFINE_TYPE_EXTENDED_BEGIN (TN, t_n, T_P, 0) {_C_;} _ATK_DEFINE_TYPE_EXTENDED_END()
</MACRO>
<MACRO>
<NAME>ATK_DEFINE_ABSTRACT_TYPE</NAME>
#define ATK_DEFINE_ABSTRACT_TYPE(TN, t_n, T_P)		       ATK_DEFINE_TYPE_EXTENDED (TN, t_n, T_P, G_TYPE_FLAG_ABSTRACT, {})
</MACRO>
<MACRO>
<NAME>ATK_DEFINE_ABSTRACT_TYPE_WITH_CODE</NAME>
#define ATK_DEFINE_ABSTRACT_TYPE_WITH_CODE(TN, t_n, T_P, _C_) _ATK_DEFINE_TYPE_EXTENDED_BEGIN (TN, t_n, T_P, G_TYPE_FLAG_ABSTRACT) {_C_;} _ATK_DEFINE_TYPE_EXTENDED_END()
</MACRO>
<MACRO>
<NAME>ATK_DEFINE_TYPE_EXTENDED</NAME>
#define ATK_DEFINE_TYPE_EXTENDED(TN, t_n, T_P, _f_, _C_)      _ATK_DEFINE_TYPE_EXTENDED_BEGIN (TN, t_n, T_P, _f_) {_C_;} _ATK_DEFINE_TYPE_EXTENDED_END()
</MACRO>
<MACRO>
<NAME>ATK_TYPE_VALUE</NAME>
#define ATK_TYPE_VALUE                    (atk_value_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_IS_VALUE</NAME>
#define ATK_IS_VALUE(obj)                 G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_VALUE)
</MACRO>
<MACRO>
<NAME>ATK_VALUE</NAME>
#define ATK_VALUE(obj)                    G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_VALUE, AtkValue)
</MACRO>
<MACRO>
<NAME>ATK_VALUE_GET_IFACE</NAME>
#define ATK_VALUE_GET_IFACE(obj)          (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_VALUE, AtkValueIface))
</MACRO>
<ENUM>
<NAME>AtkValueType</NAME>
typedef enum
{
  ATK_VALUE_VERY_WEAK,
  ATK_VALUE_WEAK,
  ATK_VALUE_ACCEPTABLE,
  ATK_VALUE_STRONG,
  ATK_VALUE_VERY_STRONG,
  ATK_VALUE_VERY_LOW,
  ATK_VALUE_LOW,
  ATK_VALUE_MEDIUM,
  ATK_VALUE_HIGH,
  ATK_VALUE_VERY_HIGH,
  ATK_VALUE_VERY_BAD,
  ATK_VALUE_BAD,
  ATK_VALUE_GOOD,
  ATK_VALUE_VERY_GOOD,
  ATK_VALUE_BEST,
  ATK_VALUE_LAST_DEFINED
}AtkValueType;
</ENUM>
<STRUCT>
<NAME>AtkValueIface</NAME>
struct _AtkValueIface
{
  GTypeInterface parent;

  /*<deprecated>*/
  void     (* get_current_value) (AtkValue     *obj,
                                  GValue       *value);
  void     (* get_maximum_value) (AtkValue     *obj,
                                  GValue       *value);
  void     (* get_minimum_value) (AtkValue     *obj,
                                  GValue       *value);
  gboolean (* set_current_value) (AtkValue     *obj,
                                  const GValue *value);
  void     (* get_minimum_increment) (AtkValue   *obj,
				      GValue     *value);
  /*</deprecated>*/
  void     (* get_value_and_text) (AtkValue *obj,
                                   gdouble *value,
                                   gchar  **text);
  AtkRange*(* get_range)          (AtkValue *obj);
  gdouble  (* get_increment)      (AtkValue *obj);
  GSList*  (* get_sub_ranges)     (AtkValue *obj);
  void     (* set_value)          (AtkValue     *obj,
                                   const gdouble new_value);

};
</STRUCT>
<FUNCTION>
<NAME>atk_value_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_value_get_current_value</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
AtkValue     *obj, GValue       *value
</FUNCTION>
<FUNCTION>
<NAME>atk_value_get_maximum_value</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
AtkValue     *obj, GValue       *value
</FUNCTION>
<FUNCTION>
<NAME>atk_value_get_minimum_value</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
AtkValue     *obj, GValue       *value
</FUNCTION>
<FUNCTION>
<NAME>atk_value_set_current_value</NAME>
<DEPRECATED/>
<RETURNS>gboolean</RETURNS>
AtkValue     *obj, const GValue *value
</FUNCTION>
<FUNCTION>
<NAME>atk_value_get_minimum_increment</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
AtkValue     *obj, GValue       *value
</FUNCTION>
<FUNCTION>
<NAME>atk_value_get_value_and_text</NAME>
<RETURNS>void</RETURNS>
AtkValue *obj, gdouble *value, gchar  **text
</FUNCTION>
<FUNCTION>
<NAME>atk_value_get_range</NAME>
<RETURNS>AtkRange *</RETURNS>
AtkValue *obj
</FUNCTION>
<FUNCTION>
<NAME>atk_value_get_increment</NAME>
<RETURNS>gdouble</RETURNS>
AtkValue *obj
</FUNCTION>
<FUNCTION>
<NAME>atk_value_get_sub_ranges</NAME>
<RETURNS>GSList *</RETURNS>
AtkValue *obj
</FUNCTION>
<FUNCTION>
<NAME>atk_value_set_value</NAME>
<RETURNS>void</RETURNS>
AtkValue     *obj, const gdouble new_value
</FUNCTION>
<FUNCTION>
<NAME>atk_value_type_get_name</NAME>
<RETURNS>const gchar *</RETURNS>
AtkValueType value_type
</FUNCTION>
<FUNCTION>
<NAME>atk_value_type_get_localized_name</NAME>
<RETURNS>const gchar *</RETURNS>
AtkValueType value_type
</FUNCTION>
<STRUCT>
<NAME>AtkValue</NAME>
</STRUCT>
<MACRO>
<NAME>ATK_TYPE_WINDOW</NAME>
#define ATK_TYPE_WINDOW                    (atk_window_get_type ())
</MACRO>
<MACRO>
<NAME>ATK_IS_WINDOW</NAME>
#define ATK_IS_WINDOW(obj)                 G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_WINDOW)
</MACRO>
<MACRO>
<NAME>ATK_WINDOW</NAME>
#define ATK_WINDOW(obj)                    G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_WINDOW, AtkWindow)
</MACRO>
<MACRO>
<NAME>ATK_WINDOW_GET_IFACE</NAME>
#define ATK_WINDOW_GET_IFACE(obj)          (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_WINDOW, AtkWindowIface))
</MACRO>
<STRUCT>
<NAME>AtkWindowIface</NAME>
struct _AtkWindowIface
{
  GTypeInterface parent;
};
</STRUCT>
<FUNCTION>
<NAME>atk_window_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>AtkWindow</NAME>
</STRUCT>
<FUNCTION>
<NAME>atk_scroll_type_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>ATK_TYPE_SCROLL_TYPE</NAME>
#define ATK_TYPE_SCROLL_TYPE (atk_scroll_type_get_type())
</MACRO>
<FUNCTION>
<NAME>atk_hyperlink_state_flags_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>ATK_TYPE_HYPERLINK_STATE_FLAGS</NAME>
#define ATK_TYPE_HYPERLINK_STATE_FLAGS (atk_hyperlink_state_flags_get_type())
</MACRO>
<FUNCTION>
<NAME>atk_role_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>ATK_TYPE_ROLE</NAME>
#define ATK_TYPE_ROLE (atk_role_get_type())
</MACRO>
<FUNCTION>
<NAME>atk_layer_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>ATK_TYPE_LAYER</NAME>
#define ATK_TYPE_LAYER (atk_layer_get_type())
</MACRO>
<FUNCTION>
<NAME>atk_relation_type_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>ATK_TYPE_RELATION_TYPE</NAME>
#define ATK_TYPE_RELATION_TYPE (atk_relation_type_get_type())
</MACRO>
<FUNCTION>
<NAME>atk_state_type_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>ATK_TYPE_STATE_TYPE</NAME>
#define ATK_TYPE_STATE_TYPE (atk_state_type_get_type())
</MACRO>
<FUNCTION>
<NAME>atk_text_attribute_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>ATK_TYPE_TEXT_ATTRIBUTE</NAME>
#define ATK_TYPE_TEXT_ATTRIBUTE (atk_text_attribute_get_type())
</MACRO>
<FUNCTION>
<NAME>atk_text_boundary_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>ATK_TYPE_TEXT_BOUNDARY</NAME>
#define ATK_TYPE_TEXT_BOUNDARY (atk_text_boundary_get_type())
</MACRO>
<FUNCTION>
<NAME>atk_text_granularity_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>ATK_TYPE_TEXT_GRANULARITY</NAME>
#define ATK_TYPE_TEXT_GRANULARITY (atk_text_granularity_get_type())
</MACRO>
<FUNCTION>
<NAME>atk_text_clip_type_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>ATK_TYPE_TEXT_CLIP_TYPE</NAME>
#define ATK_TYPE_TEXT_CLIP_TYPE (atk_text_clip_type_get_type())
</MACRO>
<FUNCTION>
<NAME>atk_key_event_type_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>ATK_TYPE_KEY_EVENT_TYPE</NAME>
#define ATK_TYPE_KEY_EVENT_TYPE (atk_key_event_type_get_type())
</MACRO>
<FUNCTION>
<NAME>atk_coord_type_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>ATK_TYPE_COORD_TYPE</NAME>
#define ATK_TYPE_COORD_TYPE (atk_coord_type_get_type())
</MACRO>
<FUNCTION>
<NAME>atk_value_type_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>ATK_TYPE_VALUE_TYPE</NAME>
#define ATK_TYPE_VALUE_TYPE (atk_value_type_get_type())
</MACRO>
<MACRO>
<NAME>ATK_MAJOR_VERSION</NAME>
#define ATK_MAJOR_VERSION (2)
</MACRO>
<MACRO>
<NAME>ATK_MINOR_VERSION</NAME>
#define ATK_MINOR_VERSION (30)
</MACRO>
<MACRO>
<NAME>ATK_MICRO_VERSION</NAME>
#define ATK_MICRO_VERSION (0)
</MACRO>
<MACRO>
<NAME>ATK_BINARY_AGE</NAME>
#define ATK_BINARY_AGE    (23010)
</MACRO>
<MACRO>
<NAME>ATK_INTERFACE_AGE</NAME>
#define ATK_INTERFACE_AGE (1)
</MACRO>
<MACRO>
<NAME>ATK_CHECK_VERSION</NAME>
#define ATK_CHECK_VERSION(major,minor,micro)                          \
    (ATK_MAJOR_VERSION > (major) ||                                   \
     (ATK_MAJOR_VERSION == (major) && ATK_MINOR_VERSION > (minor)) || \
     (ATK_MAJOR_VERSION == (major) && ATK_MINOR_VERSION == (minor) && \
      ATK_MICRO_VERSION >= (micro)))
</MACRO>
<MACRO>
<NAME>ATK_VERSION_2_2</NAME>
#define ATK_VERSION_2_2       (G_ENCODE_VERSION (2, 2))
</MACRO>
<MACRO>
<NAME>ATK_VERSION_2_4</NAME>
#define ATK_VERSION_2_4       (G_ENCODE_VERSION (2, 4))
</MACRO>
<MACRO>
<NAME>ATK_VERSION_2_6</NAME>
#define ATK_VERSION_2_6       (G_ENCODE_VERSION (2, 6))
</MACRO>
<MACRO>
<NAME>ATK_VERSION_2_8</NAME>
#define ATK_VERSION_2_8       (G_ENCODE_VERSION (2, 8))
</MACRO>
<MACRO>
<NAME>ATK_VERSION_2_10</NAME>
#define ATK_VERSION_2_10       (G_ENCODE_VERSION (2, 10))
</MACRO>
<MACRO>
<NAME>ATK_VERSION_2_12</NAME>
#define ATK_VERSION_2_12       (G_ENCODE_VERSION (2, 12))
</MACRO>
<MACRO>
<NAME>ATK_VERSION_2_14</NAME>
#define ATK_VERSION_2_14       (G_ENCODE_VERSION (2, 14))
</MACRO>
<MACRO>
<NAME>ATK_VERSION_2_30</NAME>
#define ATK_VERSION_2_30       (G_ENCODE_VERSION (2, 30))
</MACRO>
<MACRO>
<NAME>ATK_VERSION_CUR_STABLE</NAME>
#define ATK_VERSION_CUR_STABLE         (G_ENCODE_VERSION (ATK_MAJOR_VERSION, ATK_MINOR_VERSION + 1))
</MACRO>
<MACRO>
<NAME>ATK_VERSION_PREV_STABLE</NAME>
#define ATK_VERSION_PREV_STABLE        (G_ENCODE_VERSION (ATK_MAJOR_VERSION, ATK_MINOR_VERSION - 1))
</MACRO>
<MACRO>
<NAME>ATK_VERSION_MIN_REQUIRED</NAME>
# define ATK_VERSION_MIN_REQUIRED      (ATK_VERSION_CUR_STABLE)
</MACRO>
<MACRO>
<NAME>ATK_VERSION_MAX_ALLOWED</NAME>
# define ATK_VERSION_MAX_ALLOWED      (ATK_VERSION_CUR_STABLE)
</MACRO>
<MACRO>
<NAME>ATK_DEPRECATED</NAME>
#define ATK_DEPRECATED _ATK_EXTERN
</MACRO>
<MACRO>
<NAME>ATK_DEPRECATED_FOR</NAME>
#define ATK_DEPRECATED_FOR(f) _ATK_EXTERN
</MACRO>
<MACRO>
<NAME>ATK_UNAVAILABLE</NAME>
#define ATK_UNAVAILABLE(maj,min) _ATK_EXTERN
</MACRO>
<MACRO>
<NAME>ATK_AVAILABLE_IN_ALL</NAME>
#define ATK_AVAILABLE_IN_ALL _ATK_EXTERN
</MACRO>
<MACRO>
<NAME>ATK_DEPRECATED_IN_2_2</NAME>
# define ATK_DEPRECATED_IN_2_2                ATK_DEPRECATED
</MACRO>
<MACRO>
<NAME>ATK_DEPRECATED_IN_2_2_FOR</NAME>
# define ATK_DEPRECATED_IN_2_2_FOR(f)         ATK_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>ATK_AVAILABLE_IN_2_2</NAME>
# define ATK_AVAILABLE_IN_2_2                 ATK_UNAVAILABLE(2, 2)
</MACRO>
<MACRO>
<NAME>ATK_DEPRECATED_IN_2_4</NAME>
# define ATK_DEPRECATED_IN_2_4                ATK_DEPRECATED
</MACRO>
<MACRO>
<NAME>ATK_DEPRECATED_IN_2_4_FOR</NAME>
# define ATK_DEPRECATED_IN_2_4_FOR(f)         ATK_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>ATK_AVAILABLE_IN_2_4</NAME>
# define ATK_AVAILABLE_IN_2_4                 ATK_UNAVAILABLE(2, 4)
</MACRO>
<MACRO>
<NAME>ATK_DEPRECATED_IN_2_6</NAME>
# define ATK_DEPRECATED_IN_2_6                ATK_DEPRECATED
</MACRO>
<MACRO>
<NAME>ATK_DEPRECATED_IN_2_6_FOR</NAME>
# define ATK_DEPRECATED_IN_2_6_FOR(f)         ATK_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>ATK_AVAILABLE_IN_2_6</NAME>
# define ATK_AVAILABLE_IN_2_6                 ATK_UNAVAILABLE(2, 6)
</MACRO>
<MACRO>
<NAME>ATK_DEPRECATED_IN_2_8</NAME>
# define ATK_DEPRECATED_IN_2_8                ATK_DEPRECATED
</MACRO>
<MACRO>
<NAME>ATK_DEPRECATED_IN_2_8_FOR</NAME>
# define ATK_DEPRECATED_IN_2_8_FOR(f)         ATK_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>ATK_AVAILABLE_IN_2_8</NAME>
# define ATK_AVAILABLE_IN_2_8                 ATK_UNAVAILABLE(2, 8)
</MACRO>
<MACRO>
<NAME>ATK_DEPRECATED_IN_2_10</NAME>
# define ATK_DEPRECATED_IN_2_10                ATK_DEPRECATED
</MACRO>
<MACRO>
<NAME>ATK_DEPRECATED_IN_2_10_FOR</NAME>
# define ATK_DEPRECATED_IN_2_10_FOR(f)         ATK_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>ATK_AVAILABLE_IN_2_10</NAME>
# define ATK_AVAILABLE_IN_2_10                 ATK_UNAVAILABLE(2, 10)
</MACRO>
<MACRO>
<NAME>ATK_DEPRECATED_IN_2_12</NAME>
# define ATK_DEPRECATED_IN_2_12                ATK_DEPRECATED
</MACRO>
<MACRO>
<NAME>ATK_DEPRECATED_IN_2_12_FOR</NAME>
# define ATK_DEPRECATED_IN_2_12_FOR(f)         ATK_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>ATK_AVAILABLE_IN_2_12</NAME>
# define ATK_AVAILABLE_IN_2_12                 ATK_UNAVAILABLE(2, 12)
</MACRO>
<MACRO>
<NAME>ATK_DEPRECATED_IN_2_14</NAME>
# define ATK_DEPRECATED_IN_2_14                ATK_DEPRECATED
</MACRO>
<MACRO>
<NAME>ATK_DEPRECATED_IN_2_14_FOR</NAME>
# define ATK_DEPRECATED_IN_2_14_FOR(f)         ATK_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>ATK_AVAILABLE_IN_2_14</NAME>
# define ATK_AVAILABLE_IN_2_14                 ATK_UNAVAILABLE(2, 14)
</MACRO>
<MACRO>
<NAME>ATK_DEPRECATED_IN_2_30</NAME>
# define ATK_DEPRECATED_IN_2_30                ATK_DEPRECATED
</MACRO>
<MACRO>
<NAME>ATK_DEPRECATED_IN_2_30_FOR</NAME>
# define ATK_DEPRECATED_IN_2_30_FOR(f)         ATK_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>ATK_AVAILABLE_IN_2_30</NAME>
# define ATK_AVAILABLE_IN_2_30                 ATK_UNAVAILABLE(2, 30)
</MACRO>
<FUNCTION>
<NAME>atk_get_major_version</NAME>
<RETURNS>guint</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_get_minor_version</NAME>
<RETURNS>guint</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_get_micro_version</NAME>
<RETURNS>guint</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_get_binary_age</NAME>
<RETURNS>guint</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>atk_get_interface_age</NAME>
<RETURNS>guint</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>atk_major_version</NAME>
#define atk_major_version atk_get_major_version ()
</MACRO>
<MACRO>
<NAME>atk_minor_version</NAME>
#define atk_minor_version atk_get_minor_version ()
</MACRO>
<MACRO>
<NAME>atk_micro_version</NAME>
#define atk_micro_version atk_get_micro_version ()
</MACRO>
<MACRO>
<NAME>atk_binary_age</NAME>
#define atk_binary_age atk_get_binary_age ()
</MACRO>
<MACRO>
<NAME>atk_interface_age</NAME>
#define atk_interface_age atk_get_interface_age ()
</MACRO>
