atk 0.90.2-x86-mingw32

data/ext/atk/rbatkimplementor.c

@@ -0,0 +1,27 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbatkimplementor.c -
+
+  $Author: mutoh $
+  $Date: 2003/12/07 17:18:16 $
+
+  Copyright (C) 2003 Masao Mutoh
+************************************************/
+#include "rbatk.h"
+
+#define _SELF(s) (ATK_IMPLEMENTOR(RVAL2GOBJ(s)))
+
+static VALUE
+rbatkimpl_ref_accessible(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(atk_implementor_ref_accessible(_SELF(self)));
+}
+
+void
+Init_atk_implementor()
+{
+    VALUE impl = G_DEF_INTERFACE(ATK_TYPE_IMPLEMENTOR, "Implementor", mAtk);
+    rb_define_method(impl, "ref_accessible", rbatkimpl_ref_accessible, 0);
+}

data/ext/atk/rbatkinits.c

@@ -0,0 +1,55 @@
+extern void   Init_atk_action();
+extern void   Init_atk_component();
+extern void   Init_atk_document();
+extern void   Init_atk_editabletext();
+extern void   Init_atk_gobjectaccessible();
+extern void   Init_atk_hyperlink();
+extern void   Init_atk_hypertext();
+extern void   Init_atk_image();
+extern void   Init_atk_implementor();
+extern void   Init_atk_noopobject();
+extern void   Init_atk_noopobjectfactory();
+extern void   Init_atk_object();
+extern void   Init_atk_objectfactory();
+extern void   Init_atk_registry();
+extern void   Init_atk_relation();
+extern void   Init_atk_relation_set();
+extern void   Init_atk_selection();
+extern void   Init_atk_state();
+extern void   Init_atk_state_set();
+extern void   Init_atk_streamable_content();
+extern void   Init_atk_table();
+extern void   Init_atk_text();
+extern void   Init_atk_text_range();
+extern void   Init_atk_text_rectangle();
+extern void   Init_atk_util();
+extern void   Init_atk_value();
+void Init_atk_inits()
+{
+   Init_atk_action();
+   Init_atk_component();
+   Init_atk_document();
+   Init_atk_editabletext();
+   Init_atk_gobjectaccessible();
+   Init_atk_hyperlink();
+   Init_atk_hypertext();
+   Init_atk_image();
+   Init_atk_implementor();
+   Init_atk_noopobject();
+   Init_atk_noopobjectfactory();
+   Init_atk_object();
+   Init_atk_objectfactory();
+   Init_atk_registry();
+   Init_atk_relation();
+   Init_atk_relation_set();
+   Init_atk_selection();
+   Init_atk_state();
+   Init_atk_state_set();
+   Init_atk_streamable_content();
+   Init_atk_table();
+   Init_atk_text();
+   Init_atk_text_range();
+   Init_atk_text_rectangle();
+   Init_atk_util();
+   Init_atk_value();
+}

data/ext/atk/rbatknoopobject.c

@@ -0,0 +1,30 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbatknoopobject.c -
+
+  $Author: mutoh $
+  $Date: 2003/12/04 18:06:17 $
+
+  Copyright (C) 2003 Masao Mutoh
+************************************************/
+
+#include "rbatk.h"
+
+#define _SELF(s) (ATK_NOOPOBJECT(RVAL2GOBJ(s)))
+
+static VALUE
+rbatk_no_op_object_initialize(self, gobj)
+    VALUE self, gobj;
+{
+    G_INITIALIZE(self, atk_no_op_object_new(RVAL2GOBJ(gobj)));
+    return Qnil;
+}
+
+void
+Init_atk_noopobject()
+{
+    VALUE noop = G_DEF_CLASS(ATK_TYPE_NO_OP_OBJECT, "NoOpObject", mAtk);
+
+    rb_define_method(noop, "initialize", rbatk_no_op_object_initialize, 1);
+}

data/ext/atk/rbatknoopobjectfactory.c

@@ -0,0 +1,30 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbatknoopobjectfactory.c -
+
+  $Author: mutoh $
+  $Date: 2003/12/07 17:18:16 $
+
+  Copyright (C) 2003 Masao Mutoh
+************************************************/
+
+#include "rbatk.h"
+
+#define _SELF(s) (ATK_NO_OP_OBJECT_FACTORY(RVAL2GOBJ(s)))
+
+static VALUE
+rbatk_no_op_object_factory_initialize(self)
+    VALUE self;
+{
+    G_INITIALIZE(self, atk_no_op_object_factory_new());
+    return Qnil;
+}
+
+void
+Init_atk_noopobjectfactory()
+{
+    VALUE noop = G_DEF_CLASS(ATK_TYPE_NO_OP_OBJECT_FACTORY, "NoOpObjectFactory", mAtk);
+
+    rb_define_method(noop, "initialize", rbatk_no_op_object_factory_initialize, 0);
+}

data/ext/atk/rbatkobject.c

@@ -0,0 +1,178 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbatkobject.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 16:07:28 $
+
+  Copyright (C) 2003,2004 Masao Mutoh
+************************************************/
+
+#include "rbatk.h"
+
+#define _SELF(s) (ATK_OBJECT(RVAL2GOBJ(s)))
+
+/* How can I implement this? Since 1.10
+AtkObject*  atk_implementor_ref_accessible  (AtkImplementor *implementor);
+*/
+
+/* Use properties accessible_* 
+G_CONST_RETURN gchar* atk_object_get_name   (AtkObject *accessible);
+G_CONST_RETURN gchar* atk_object_get_description
+                                            (AtkObject *accessible);
+AtkObject*  atk_object_get_parent           (AtkObject *accessible);
+                                            (AtkObject *accessible);
+*/
+
+static VALUE
+rbatkobj_get_n_accessible_children(self)
+    VALUE self;
+{
+    return INT2NUM(atk_object_get_n_accessible_children(_SELF(self)));
+}
+
+static VALUE
+rbatkobj_ref_accessible_child(self, i)
+    VALUE self, i;
+{
+    return GOBJ2RVAL(atk_object_ref_accessible_child(_SELF(self), NUM2INT(i)));
+}
+
+static VALUE
+rbatkobj_ref_releation_set(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(atk_object_ref_relation_set(_SELF(self)));
+}
+
+/* Use properties accessible_* 
+AtkLayer    atk_object_get_layer            (AtkObject *accessible);
+gint        atk_object_get_mdi_zorder       (AtkObject *accessible);
+AtkRole     atk_object_get_role             (AtkObject *accessible);
+*/
+
+static VALUE
+rbatkobj_ref_state_set(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(atk_object_ref_state_set(_SELF(self)));
+}
+
+static VALUE
+rbatkobj_get_index_in_parent(self)
+    VALUE self;
+{
+    return INT2NUM(atk_object_get_index_in_parent(_SELF(self)));
+}
+/* Use properties accessible_* 
+void        atk_object_set_name             (AtkObject *accessible,
+                                             const gchar *name);
+void        atk_object_set_description      (AtkObject *accessible,
+                                             const gchar *description);
+void        atk_object_set_parent           (AtkObject *accessible,
+                                             AtkObject *parent);
+void        atk_object_set_role             (AtkObject *accessible,
+                                             AtkRole role);
+*/
+
+/*    
+guint       atk_object_connect_property_change_handler
+                                            (AtkObject *accessible,
+                                             AtkPropertyChangeHandler *handler);
+void        atk_object_remove_property_change_handler
+                                            (AtkObject *accessible,
+                                             guint handler_id);
+*/
+
+static VALUE
+rbatkobj_notify_state_change(self, state, value)
+    VALUE self, state, value;
+{
+    atk_object_notify_state_change(_SELF(self), 
+                                   RVAL2GENUM(state, ATK_TYPE_STATE_TYPE),
+                                   RVAL2CBOOL(value));
+    return self;
+}
+
+/* I don't have a good idea to implement this method. Any idea?
+void        atk_object_initialize           (AtkObject *accessible,
+                                             gpointer data);
+*/
+
+#ifdef HAVE_ATK_OBJECT_ADD_RELATIONSHIP
+static VALUE
+rbatkobj_add_relationship(self, relationship, target)
+    VALUE self, relationship, target;
+{
+    return CBOOL2RVAL(atk_object_add_relationship(
+                          _SELF(self), 
+                          RVAL2GENUM(relationship, ATK_TYPE_RELATION_TYPE),
+                          _SELF(target)));
+}
+#endif
+
+#ifdef HAVE_ATK_OBJECT_REMOVE_RELATIONSHIP
+static VALUE
+rbatkobj_remove_relationship(self, relationship, target)
+    VALUE self, relationship, target;
+{
+    return CBOOL2RVAL(atk_object_remove_relationship(
+                          _SELF(self), 
+                          RVAL2GENUM(relationship, ATK_TYPE_RELATION_TYPE),
+                          _SELF(target)));
+}
+#endif
+
+/* We don't need this.
+G_CONST_RETURN gchar* atk_role_get_name     (AtkRole role);
+*/
+
+static VALUE
+rbatkrole_get_localized_name(self)
+    VALUE self;
+{
+#ifdef HAVE_ATK_ROLE_GET_LOCALIZED_NAME
+    return CSTR2RVAL(atk_role_get_localized_name(RVAL2GENUM(self, ATK_TYPE_ROLE)));
+#else
+    rb_warning("not supported in this version of ATK.");
+    return Qnil;
+#endif
+}
+
+static VALUE
+rbatkrole_s_for_name(self, name)
+    VALUE self, name;
+{
+    return GENUM2RVAL(atk_role_for_name(RVAL2CSTR(name)), ATK_TYPE_ROLE);
+}
+
+void
+Init_atk_object()
+{
+    VALUE obj = G_DEF_CLASS(ATK_TYPE_OBJECT, "Object", mAtk);
+    VALUE role;
+
+    rb_define_method(obj, "n_accessible_children", rbatkobj_get_n_accessible_children, 0);
+    rb_define_method(obj, "ref_accessible_child", rbatkobj_ref_accessible_child, 1);
+    rb_define_method(obj, "ref_relation_set", rbatkobj_ref_releation_set, 0);
+    rb_define_method(obj, "ref_state_set", rbatkobj_ref_state_set, 0);
+    rb_define_method(obj, "index_in_parent", rbatkobj_get_index_in_parent, 0);
+    rb_define_method(obj, "notify_state_change", rbatkobj_notify_state_change, 2);
+#ifdef HAVE_ATK_OBJECT_ADD_RELATIONSHIP
+    rb_define_method(obj, "add_relationship", rbatkobj_add_relationship, 2);
+#endif
+#ifdef HAVE_ATK_OBJECT_REMOVE_RELATIONSHIP
+    rb_define_method(obj, "remove_relationship", rbatkobj_remove_relationship, 2);
+#endif
+
+    /* AtkRole */
+    role = G_DEF_CLASS(ATK_TYPE_ROLE, "Role", obj);
+    rb_define_method(role, "localized_name", rbatkrole_get_localized_name, 0);
+    rb_define_singleton_method(role, "for_name", rbatkrole_s_for_name, 1);
+    G_DEF_CONSTANTS(obj, ATK_TYPE_ROLE, "ATK_");
+
+    /* AtkLayer */
+    G_DEF_CLASS(ATK_TYPE_LAYER, "Layer", obj);
+    G_DEF_CONSTANTS(obj, ATK_TYPE_LAYER, "ATK_");
+}

data/ext/atk/rbatkobjectfactory.c

@@ -0,0 +1,44 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbatkobjectfactory.c -
+
+  $Author: mutoh $
+  $Date: 2003/12/07 18:12:33 $
+
+  Copyright (C) 2003 Masao Mutoh
+************************************************/
+#include "rbatk.h"
+
+#define _SELF(s) (ATK_OBJECT_FACTORY(RVAL2GOBJ(s)))
+
+static VALUE
+rbatkfact_create_accessible(self, obj)
+    VALUE self, obj;
+{
+    return GOBJ2RVAL(atk_object_factory_create_accessible(_SELF(self), RVAL2GOBJ(obj)));
+}
+
+static VALUE
+rbatkfact_get_accessible_type(self)
+    VALUE self;
+{
+    return GTYPE2CLASS(atk_object_factory_get_accessible_type(_SELF(self)));
+}
+
+static VALUE
+rbatkfact_invalidate(self)
+    VALUE self;
+{
+    atk_object_factory_invalidate(_SELF(self));
+    return self;
+}
+
+void
+Init_atk_objectfactory()
+{
+    VALUE fact = G_DEF_CLASS(ATK_TYPE_OBJECT_FACTORY, "ObjectFactory", mAtk);
+    rb_define_method(fact, "create_accessible", rbatkfact_create_accessible, 0);
+    rb_define_method(fact, "accessible_type", rbatkfact_get_accessible_type, 0);
+    rb_define_method(fact, "invalidate", rbatkfact_invalidate, 0);
+}

data/ext/atk/rbatkregistry.c

@@ -0,0 +1,55 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbatkregistry.c -
+
+  $Author: mutoh $
+  $Date: 2003/12/07 18:12:33 $
+
+  Copyright (C) 2003 Masao Mutoh
+************************************************/
+#include "rbatk.h"
+
+#define _SELF(s) (ATK_REGISTRY(RVAL2GOBJ(s)))
+
+static VALUE
+rbatkregistry_set_factory_type(self, type, factory_type)
+    VALUE self, type, factory_type;
+{
+    atk_registry_set_factory_type(_SELF(self),
+                                  CLASS2GTYPE(type),
+                                  CLASS2GTYPE(factory_type));
+    return self;
+}
+
+static VALUE
+rbatkregistry_get_factory_type(self, type)
+    VALUE self, type;
+{
+    return GTYPE2CLASS(atk_registry_get_factory_type(_SELF(self), CLASS2GTYPE(type)));
+}
+
+static VALUE
+rbatkregistry_get_factory(self, type)
+    VALUE self, type;
+{
+    return GOBJ2RVAL(atk_registry_get_factory(_SELF(self),
+                                              CLASS2GTYPE(type)));
+}
+
+static VALUE
+rbatkregistry_s_get_default_registry(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(atk_get_default_registry());
+}
+
+void
+Init_atk_registry()
+{
+    VALUE registry = G_DEF_CLASS(ATK_TYPE_REGISTRY, "Registry", mAtk);
+    rb_define_method(registry, "set_factory_type", rbatkregistry_set_factory_type, 2);
+    rb_define_method(registry, "get_factory_type", rbatkregistry_get_factory_type, 1);
+    rb_define_method(registry, "get_factory", rbatkregistry_get_factory, 1);
+    rb_define_singleton_method(registry, "default_registry", rbatkregistry_s_get_default_registry, 0);
+}

data/ext/atk/rbatkrelation.c

@@ -0,0 +1,104 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbatkrelation.c -
+
+  $Author: mutoh $
+  $Date: 2005/09/15 17:30:46 $
+
+  Copyright (C) 2003 Masao Mutoh
+************************************************/
+#include "rbatk.h"
+
+#define _SELF(s) (ATK_RELATION(RVAL2GOBJ(s)))
+
+static VALUE
+rbatkrel_s_type_register(self, name)
+    VALUE self, name;
+{
+    return GENUM2RVAL(atk_relation_type_register(RVAL2CSTR(name)), ATK_TYPE_RELATION_TYPE);
+}
+
+/* We don't need them
+G_CONST_RETURN gchar* atk_relation_type_get_name
+                                            (AtkRelationType type);
+*/
+
+static VALUE
+rbatkrelation_s_for_name(self, name)
+    VALUE self, name;
+{
+    return GENUM2RVAL(atk_relation_type_for_name(RVAL2CSTR(name)), ATK_TYPE_RELATION_TYPE);
+}
+
+
+static VALUE
+rbatkrel_initialize(self, targets, relationship)
+    VALUE self, targets, relationship;
+{
+    gint i;
+    gint len = RARRAY_LEN(targets);
+    AtkObject* objects = g_new(AtkObject, len);
+
+    for (i = 0; i < len; i++) {
+        objects = (AtkObject*)RARRAY_PTR(targets)[i];
+        objects++;
+    }
+
+    G_INITIALIZE(self, atk_relation_new(&objects, len, 
+                                        RVAL2GENUM(relationship, ATK_TYPE_RELATION_TYPE)));
+    g_free(objects);
+
+    return Qnil;
+}
+
+static VALUE
+rbatkrel_get_relation_type(self)
+    VALUE self;
+{
+    return GENUM2RVAL(atk_relation_get_relation_type(_SELF(self)), ATK_TYPE_RELATION_TYPE);
+}
+
+static VALUE
+rbatkrel_get_target(self)
+    VALUE self;
+{
+    gint i;
+    GPtrArray* garray = atk_relation_get_target(_SELF(self));
+    VALUE ary = rb_ary_new();
+
+    for (i = 0; i < garray->len; i++){
+        rb_ary_push(ary, GOBJ2RVAL((AtkObject*)g_ptr_array_index(garray, i)));
+    }
+    g_ptr_array_free(garray, TRUE);
+    return ary;
+}
+
+#if ATK_CHECK_VERSION(1,9,0)
+static VALUE
+rbatkrel_add_target(self, obj)
+    VALUE self, obj;
+{
+    atk_relation_add_target(_SELF(self), ATK_OBJECT(RVAL2GOBJ(obj)));
+    return self;
+}
+#endif
+
+void
+Init_atk_relation()
+{
+    VALUE rel = G_DEF_CLASS(ATK_TYPE_RELATION, "Relation", mAtk);
+    VALUE type;
+    rb_define_singleton_method(rel, "type_register", rbatkrel_s_type_register, 1);
+    rb_define_method(rel, "initialize", rbatkrel_initialize, 2);
+    rb_define_method(rel, "relation_type", rbatkrel_get_relation_type, 0);
+    rb_define_method(rel, "target", rbatkrel_get_target, 0);
+#if ATK_CHECK_VERSION(1,9,0)
+    rb_define_method(rel, "add_target", rbatkrel_add_target, 1);
+#endif
+
+    /* AtkRelationType */
+    type = G_DEF_CLASS(ATK_TYPE_RELATION_TYPE, "Type", rel);
+    rb_define_singleton_method(type, "for_name", rbatkrelation_s_for_name, 1);
+    G_DEF_CONSTANTS(rel, ATK_TYPE_RELATION_TYPE, "ATK_");
+}

data/ext/atk/rbatkrelationset.c

@@ -0,0 +1,94 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbatkrelationset.c -
+
+  $Author: mutoh $
+  $Date: 2005/09/15 17:30:46 $
+
+  Copyright (C) 2003 Masao Mutoh
+************************************************/
+#include "rbatk.h"
+
+#define _SELF(s) (ATK_RELATION_SET(RVAL2GOBJ(s)))
+
+static VALUE
+rbatkrelset_initialize(self)
+    VALUE self;
+{
+    G_INITIALIZE(self, atk_relation_set_new());
+    return Qnil;
+}
+
+static VALUE
+rbatkrelset_contains(self, relationship)
+    VALUE self, relationship;
+{
+    return CBOOL2RVAL(atk_relation_set_contains(
+                          _SELF(self),
+                          RVAL2GENUM(relationship, ATK_TYPE_RELATION_TYPE)));
+}
+
+static VALUE
+rbatkrelset_remove(self, relation)
+    VALUE self, relation;
+{
+    atk_relation_set_remove(_SELF(self), ATK_RELATION(RVAL2GOBJ(relation)));
+    return self;
+}
+
+static VALUE
+rbatkrelset_add(self, relation)
+    VALUE self, relation;
+{
+    atk_relation_set_add(_SELF(self), ATK_RELATION(RVAL2GOBJ(relation)));
+    return self;
+}
+
+static VALUE
+rbatkrelset_get_n_relations(self)
+    VALUE self;
+{
+    return INT2NUM(atk_relation_set_get_n_relations(_SELF(self)));
+}
+
+static VALUE
+rbatkrelset_get_relation(self, i)
+    VALUE self, i;
+{
+    if (rb_obj_is_kind_of(i, GTYPE2CLASS(ATK_TYPE_RELATION_TYPE))){
+        return GOBJ2RVAL(atk_relation_set_get_relation_by_type(
+                             _SELF(self),
+                             RVAL2GENUM(i, ATK_TYPE_RELATION_TYPE)));
+    } else {
+        return GOBJ2RVAL(atk_relation_set_get_relation(_SELF(self), NUM2INT(i)));
+    }
+}
+
+#if ATK_CHECK_VERSION(1,9,0)
+static VALUE
+rbatkrelset_add_relation(self, relationship, obj)
+    VALUE self, relationship, obj;
+{
+    atk_relation_set_add_relation_by_type(_SELF(self), 
+                                          RVAL2GENUM(relationship, ATK_TYPE_RELATION_TYPE), 
+                                          ATK_OBJECT(RVAL2GOBJ(obj)));
+    return self;
+}
+#endif
+
+void
+Init_atk_relation_set()
+{
+    VALUE rel = G_DEF_CLASS(ATK_TYPE_RELATION_SET, "RelationSet", mAtk);
+
+    rb_define_method(rel, "initialize", rbatkrelset_initialize, 0);
+    rb_define_method(rel, "contains?", rbatkrelset_contains, 1);
+    rb_define_method(rel, "remove", rbatkrelset_remove, 1);
+    rb_define_method(rel, "add", rbatkrelset_add, 1);
+    rb_define_method(rel, "n_relations", rbatkrelset_get_n_relations, 0);
+    rb_define_method(rel, "get_relation", rbatkrelset_get_relation, 1);
+#if ATK_CHECK_VERSION(1,9,0)
+    rb_define_method(rel, "add_relation", rbatkrelset_add_relation, 2);
+#endif
+}

data/ext/atk/rbatkselection.c

@@ -0,0 +1,82 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbatkselection.c -
+
+  $Author: mutoh $
+  $Date: 2004/03/05 15:33:48 $
+
+  Copyright (C) 2004 Masao Mutoh
+************************************************/
+#include "rbatk.h"
+
+#define _SELF(s) (ATK_SELECTION(RVAL2GOBJ(s)))
+
+static VALUE
+rbatksel_add_selection(self, i)
+    VALUE self, i;
+{
+    gboolean ret = atk_selection_add_selection(_SELF(self), NUM2INT(i));
+    if (! ret) rb_raise(rb_eRuntimeError, "Can't add selection");
+    return self;
+}
+
+static VALUE
+rbatksel_clear_selection(self)
+    VALUE self;
+{
+    gboolean ret = atk_selection_clear_selection(_SELF(self));
+    if (! ret) rb_raise(rb_eRuntimeError, "Can't clear selection");
+    return self;
+}
+
+static VALUE
+rbatksel_ref_selection(self, i)
+    VALUE self, i;
+{
+    return GOBJ2RVAL(atk_selection_ref_selection(_SELF(self), NUM2INT(i)));
+}
+
+static VALUE
+rbatksel_get_selection_count(self)
+    VALUE self;
+{
+    return INT2NUM(atk_selection_get_selection_count(_SELF(self)));
+}
+
+static VALUE
+rbatksel_is_child_selected(self, i)
+    VALUE self, i;
+{
+    return CBOOL2RVAL(atk_selection_is_child_selected(_SELF(self), NUM2INT(i)));
+}
+
+static VALUE
+rbatksel_remove_selection(self, i)
+    VALUE self, i;
+{
+    gboolean ret = atk_selection_remove_selection(_SELF(self), NUM2INT(i));
+    if (! ret) rb_raise(rb_eRuntimeError, "Can't remove selection");
+    return self;
+}
+
+static VALUE
+rbatksel_select_all_selection(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(atk_selection_select_all_selection(_SELF(self)));
+}
+
+void
+Init_atk_selection()
+{
+    VALUE sel = G_DEF_INTERFACE(ATK_TYPE_SELECTION, "Selection", mAtk);
+
+    rb_define_method(sel, "add_selection", rbatksel_add_selection, 1);
+    rb_define_method(sel, "clear_selection", rbatksel_clear_selection, 0);
+    rb_define_method(sel, "ref_selection", rbatksel_ref_selection, 1);
+    rb_define_method(sel, "selection_count", rbatksel_get_selection_count, 0);
+    rb_define_method(sel, "child_selected?", rbatksel_is_child_selected, 1);
+    rb_define_method(sel, "remove_selection", rbatksel_remove_selection, 1);
+    rb_define_method(sel, "select_all_selection", rbatksel_select_all_selection, 0);
+}