atk 0.20.0

data/src/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/src/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/src/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/src/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/src/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);
+}

data/src/rbatkstate.c

@@ -0,0 +1,41 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbatkstate.c -
+
+  $Author: mutoh $
+  $Date: 2004/10/17 23:06:07 $
+
+  Copyright (C) 2003,2004 Masao Mutoh
+************************************************/
+#include "rbatk.h"
+
+#define _SELF(s) (ATK_STATE(RVAL2GOBJ(s)))
+
+static VALUE
+rbatkstate_s_type_register(self, name)
+    VALUE self, name;
+{
+    return GENUM2RVAL(atk_state_type_register(RVAL2CSTR(name)), ATK_TYPE_STATE_TYPE);
+}
+
+/* We don't need this.
+G_CONST_RETURN gchar* atk_state_type_get_name
+                                            (AtkStateType type);
+*/
+
+static VALUE
+rbatkstate_s_for_name(self, name)
+    VALUE self, name;
+{
+    return GENUM2RVAL(atk_state_type_for_name(RVAL2CSTR(name)), ATK_TYPE_STATE_TYPE);
+}
+
+void
+Init_atk_state()
+{
+    VALUE state = G_DEF_CLASS(ATK_TYPE_STATE_TYPE, "State", mAtk);
+    rb_define_singleton_method(state, "type_register", rbatkstate_s_type_register, 1);
+    rb_define_singleton_method(state, "for_name", rbatkstate_s_for_name, 1);
+    G_DEF_CONSTANTS(mAtk, ATK_TYPE_STATE_TYPE, "ATK_");
+}

data/src/rbatkstateset.c

@@ -0,0 +1,143 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbatkstateset.c -
+
+  $Author: mutoh $
+  $Date: 2003/12/23 15:59:28 $
+
+  Copyright (C) 2003 Masao Mutoh
+************************************************/
+
+#include "rbatk.h"
+
+#define _SELF(s) (ATK_STATE_SET(RVAL2GOBJ(s)))
+
+static VALUE
+rbatkstateset_initialize(self)
+    VALUE self;
+{
+    G_INITIALIZE(self, atk_state_set_new());
+    return Qnil;
+}
+
+static VALUE
+rbatkstateset_is_empty(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(atk_state_set_is_empty(_SELF(self)));
+}
+
+static VALUE
+rbatkstateset_add_state(self, type)
+    VALUE self, type;
+{
+    return CBOOL2RVAL(atk_state_set_add_state(_SELF(self), 
+                                              RVAL2GENUM(type, ATK_TYPE_STATE_TYPE)));
+}
+
+static VALUE
+rbatkstateset_add_states(self, types)
+    VALUE self, types;
+{
+    gint i;
+    gint n_types = RARRAY_LEN(types);
+    AtkStateType* atypes = g_new(AtkStateType, n_types);
+
+    Check_Type(types, T_ARRAY);
+
+    for (i = 0; i < n_types; i++) {
+        atypes[i] = RVAL2GENUM(RARRAY_PTR(types)[i], ATK_TYPE_STATE_TYPE);
+    }
+
+    atk_state_set_add_states(_SELF(self), atypes, n_types);
+    g_free(atypes);
+    return self;
+}
+
+static VALUE
+rbatkstateset_clear_states(self)
+    VALUE self;
+{
+    atk_state_set_clear_states(_SELF(self));
+    return self;
+}
+
+static VALUE
+rbatkstateset_contains_state(self, type)
+    VALUE self;
+{
+    return CBOOL2RVAL(atk_state_set_contains_state(_SELF(self), 
+                                                   RVAL2GENUM(type, ATK_TYPE_STATE_TYPE)));
+}
+
+static VALUE
+rbatkstateset_contains_states(self, types)
+    VALUE self, types;
+{
+    gint i;
+    gboolean ret;
+    gint n_types = RARRAY_LEN(types);
+    AtkStateType* atypes = g_new(AtkStateType, n_types);
+
+    Check_Type(types, T_ARRAY);
+
+    for (i = 0; i < n_types; i++) {
+        atypes[i] = RVAL2GENUM(RARRAY_PTR(types)[i], ATK_TYPE_STATE_TYPE);
+    }
+    
+    ret = CBOOL2RVAL(atk_state_set_contains_states(_SELF(self), atypes, n_types));
+
+    g_free(atypes);
+    return ret;
+}
+
+static VALUE
+rbatkstateset_remove_state(self, type)
+    VALUE self, type;
+{
+    return CBOOL2RVAL(atk_state_set_remove_state(_SELF(self), 
+                                                 RVAL2GENUM(type, ATK_TYPE_STATE_TYPE)));
+}
+
+static VALUE
+rbatkstateset_and_sets(self, compare_set)
+    VALUE self, compare_set;
+{
+    return GOBJ2RVAL(atk_state_set_and_sets(_SELF(self), _SELF(compare_set)));
+}
+
+static VALUE
+rbatkstateset_or_sets(self, compare_set)
+    VALUE self, compare_set;
+{
+    return GOBJ2RVAL(atk_state_set_or_sets(_SELF(self), _SELF(compare_set)));
+}
+
+static VALUE
+rbatkstateset_xor_sets(self, compare_set)
+    VALUE self, compare_set;
+{
+    return GOBJ2RVAL(atk_state_set_xor_sets(_SELF(self), _SELF(compare_set)));
+}
+
+void
+Init_atk_state_set()
+{
+    VALUE stateset = G_DEF_CLASS(ATK_TYPE_STATE_SET, "StateSet", mAtk);
+
+    rb_define_method(stateset, "initialize", rbatkstateset_initialize, 0);
+    rb_define_method(stateset, "empty?", rbatkstateset_is_empty, 0);
+    rb_define_method(stateset, "add_state", rbatkstateset_add_state, 1);
+    rb_define_method(stateset, "add_states", rbatkstateset_add_states, 1);
+    rb_define_method(stateset, "clear_states", rbatkstateset_clear_states, 0);
+    rb_define_method(stateset, "contains_state", rbatkstateset_contains_state, 1);
+    rb_define_method(stateset, "contains_states", rbatkstateset_contains_states, 1);
+    rb_define_method(stateset, "remove_state", rbatkstateset_remove_state, 1);
+    rb_define_method(stateset, "and", rbatkstateset_and_sets, 1);
+    rb_define_alias(stateset, "&", "and");
+    rb_define_method(stateset, "or", rbatkstateset_or_sets, 1);
+    rb_define_alias(stateset, "|", "or");
+    rb_define_method(stateset, "xor", rbatkstateset_xor_sets, 1);
+    rb_define_alias(stateset, "^", "xor");
+}