atk 1.0.3 → 1.1.0

data/ext/atk/rbatkrelationtype.c

@@ -0,0 +1,38 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2003  Masao Mutoh
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#include "rbatkprivate.h"
+
+#define RG_TARGET_NAMESPACE cType
+
+static VALUE
+rg_s_for_name(G_GNUC_UNUSED VALUE self, VALUE name)
+{
+    return ATKRELATIONTYPE2RVAL(atk_relation_type_for_name(RVAL2CSTR(name)));
+}
+
+void
+Init_atk_relation_type(VALUE cRelation)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(ATK_TYPE_RELATION_TYPE, "Type", cRelation);
+    RG_DEF_SMETHOD(for_name, 1);
+    G_DEF_CONSTANTS(cRelation, ATK_TYPE_RELATION_TYPE, "ATK_");
+}

data/ext/atk/rbatkselection.c

@@ -1,19 +1,31 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2004  Masao Mutoh
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
 
-  rbatkselection.c -
+#include "rbatkprivate.h"
 
-  $Author: mutoh $
-  $Date: 2004/03/05 15:33:48 $
-
-  Copyright (C) 2004 Masao Mutoh
-************************************************/
-#include "rbatk.h"
-
-#define _SELF(s) (ATK_SELECTION(RVAL2GOBJ(s)))
+#define RG_TARGET_NAMESPACE mSelection
+#define _SELF(s) (RVAL2ATKSELECTION(s))
 
 static VALUE
-rbatksel_add_selection(VALUE self, VALUE i)
+rg_add_selection(VALUE self, VALUE i)
 {
     gboolean ret = atk_selection_add_selection(_SELF(self), NUM2INT(i));
     if (! ret) rb_raise(rb_eRuntimeError, "Can't add selection");
@@ -21,7 +33,7 @@ rbatksel_add_selection(VALUE self, VALUE i)
 }
 
 static VALUE
-rbatksel_clear_selection(VALUE self)
+rg_clear_selection(VALUE self)
 {
     gboolean ret = atk_selection_clear_selection(_SELF(self));
     if (! ret) rb_raise(rb_eRuntimeError, "Can't clear selection");
@@ -29,25 +41,25 @@ rbatksel_clear_selection(VALUE self)
 }
 
 static VALUE
-rbatksel_ref_selection(VALUE self, VALUE i)
+rg_ref_selection(VALUE self, VALUE i)
 {
     return GOBJ2RVAL(atk_selection_ref_selection(_SELF(self), NUM2INT(i)));
 }
 
 static VALUE
-rbatksel_get_selection_count(VALUE self)
+rg_selection_count(VALUE self)
 {
     return INT2NUM(atk_selection_get_selection_count(_SELF(self)));
 }
 
 static VALUE
-rbatksel_is_child_selected(VALUE self, VALUE i)
+rg_child_selected_p(VALUE self, VALUE i)
 {
     return CBOOL2RVAL(atk_selection_is_child_selected(_SELF(self), NUM2INT(i)));
 }
 
 static VALUE
-rbatksel_remove_selection(VALUE self, VALUE i)
+rg_remove_selection(VALUE self, VALUE i)
 {
     gboolean ret = atk_selection_remove_selection(_SELF(self), NUM2INT(i));
     if (! ret) rb_raise(rb_eRuntimeError, "Can't remove selection");
@@ -55,21 +67,21 @@ rbatksel_remove_selection(VALUE self, VALUE i)
 }
 
 static VALUE
-rbatksel_select_all_selection(VALUE self)
+rg_select_all_selection(VALUE self)
 {
     return CBOOL2RVAL(atk_selection_select_all_selection(_SELF(self)));
 }
 
 void
-Init_atk_selection()
+Init_atk_selection(VALUE mAtk)
 {
-    VALUE sel = G_DEF_INTERFACE(ATK_TYPE_SELECTION, "Selection", mAtk);
+    VALUE RG_TARGET_NAMESPACE = 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);
+    RG_DEF_METHOD(add_selection, 1);
+    RG_DEF_METHOD(clear_selection, 0);
+    RG_DEF_METHOD(ref_selection, 1);
+    RG_DEF_METHOD(selection_count, 0);
+    RG_DEF_METHOD_P(child_selected, 1);
+    RG_DEF_METHOD(remove_selection, 1);
+    RG_DEF_METHOD(select_all_selection, 0);
 }

data/ext/atk/rbatkstate.c

@@ -1,21 +1,33 @@
 /* -*- 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)))
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2003,2004 Masao Mutoh
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#include "rbatkprivate.h"
+
+#define RG_TARGET_NAMESPACE cState
+#define _SELF(s) (RVAL2ATKSTATE(s))
 
 static VALUE
-rbatkstate_s_type_register(VALUE self, VALUE name)
+rg_s_type_register(G_GNUC_UNUSED VALUE self, VALUE name)
 {
-    return GENUM2RVAL(atk_state_type_register(RVAL2CSTR(name)), ATK_TYPE_STATE_TYPE);
+    return ATKSTATETYPE2RVAL(atk_state_type_register(RVAL2CSTR(name)));
 }
 
 /* We don't need this.
@@ -24,16 +36,16 @@ G_CONST_RETURN gchar* atk_state_type_get_name
 */
 
 static VALUE
-rbatkstate_s_for_name(VALUE self, VALUE name)
+rg_s_for_name(G_GNUC_UNUSED VALUE self, VALUE name)
 {
-    return GENUM2RVAL(atk_state_type_for_name(RVAL2CSTR(name)), ATK_TYPE_STATE_TYPE);
+    return ATKSTATETYPE2RVAL(atk_state_type_for_name(RVAL2CSTR(name)));
 }
 
 void
-Init_atk_state()
+Init_atk_state(VALUE mAtk)
 {
-    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);
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(ATK_TYPE_STATE_TYPE, "State", mAtk);
+    RG_DEF_SMETHOD(type_register, 1);
+    RG_DEF_SMETHOD(for_name, 1);
     G_DEF_CONSTANTS(mAtk, ATK_TYPE_STATE_TYPE, "ATK_");
 }

data/ext/atk/rbatkstateset.c

@@ -1,132 +1,180 @@
 /* -*- 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)))
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2003  Masao Mutoh
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#include "rbatkprivate.h"
+
+#define RG_TARGET_NAMESPACE cStateSet
+#define _SELF(s) (RVAL2ATKSTATESET(s))
 
 static VALUE
-rbatkstateset_initialize(VALUE self)
+rg_initialize(VALUE self)
 {
     G_INITIALIZE(self, atk_state_set_new());
     return Qnil;
 }
 
 static VALUE
-rbatkstateset_is_empty(VALUE self)
+rg_empty_p(VALUE self)
 {
     return CBOOL2RVAL(atk_state_set_is_empty(_SELF(self)));
 }
 
 static VALUE
-rbatkstateset_add_state(VALUE self, VALUE type)
+rg_add_state(VALUE self, VALUE type)
 {
     return CBOOL2RVAL(atk_state_set_add_state(_SELF(self), 
-                                              RVAL2GENUM(type, ATK_TYPE_STATE_TYPE)));
+                                              RVAL2ATKSTATETYPE(type)));
+}
+
+struct rval2atkstatetype_args {
+    VALUE ary;
+    long n;
+    AtkStateType *result;
+};
+
+static VALUE
+rval2atkstatetype_body(VALUE value)
+{
+    long i;
+    struct rval2atkstatetype_args *args = (struct rval2atkstatetype_args *)value;
+
+    for (i = 0; i < args->n; i++)
+            args->result[i] = RVAL2ATKSTATETYPE(RARRAY_PTR(args->ary)[i]);
+
+    return Qnil;
 }
 
+static G_GNUC_NORETURN VALUE
+rval2atkstatetype_rescue(VALUE value)
+{
+    g_free(((struct rval2atkstatetype_args *)value)->result);
+
+    rb_exc_raise(rb_errinfo());
+}
+
+static AtkStateType *
+rval2atkstatetype(VALUE value, long *n)
+{
+    struct rval2atkstatetype_args args;
+
+    args.ary = rb_ary_to_ary(value);
+    args.n = RARRAY_LEN(args.ary);
+    args.result = g_new(AtkStateType, args.n + 1);
+
+    rb_rescue(rval2atkstatetype_body, (VALUE)&args,
+              rval2atkstatetype_rescue, (VALUE)&args);
+
+    if (n != NULL)
+        *n = args.n;
+
+    return args.result;
+}
+
+#define RVAL2ATKSTATETYPES(value, n) rval2atkstatetype(value, n)
+
 static VALUE
-rbatkstateset_add_states(VALUE self, VALUE types)
+rg_add_states(VALUE self, VALUE rbtypes)
 {
-    gint i;
-    gint n_types = RARRAY_LEN(types);
-    AtkStateType* atypes = g_new(AtkStateType, n_types);
+    AtkStateSet *set = _SELF(self);
+    long n;
+    AtkStateType *types = RVAL2ATKSTATETYPES(rbtypes, &n);
 
-    Check_Type(types, T_ARRAY);
+    atk_state_set_add_states(set, types, n);
 
-    for (i = 0; i < n_types; i++) {
-        atypes[i] = RVAL2GENUM(RARRAY_PTR(types)[i], ATK_TYPE_STATE_TYPE);
-    }
+    g_free(types);
 
-    atk_state_set_add_states(_SELF(self), atypes, n_types);
-    g_free(atypes);
     return self;
 }
 
 static VALUE
-rbatkstateset_clear_states(VALUE self)
+rg_clear_states(VALUE self)
 {
     atk_state_set_clear_states(_SELF(self));
     return self;
 }
 
 static VALUE
-rbatkstateset_contains_state(VALUE self, VALUE type)
+rg_contains_state(VALUE self, VALUE type)
 {
     return CBOOL2RVAL(atk_state_set_contains_state(_SELF(self), 
-                                                   RVAL2GENUM(type, ATK_TYPE_STATE_TYPE)));
+                                                   RVAL2ATKSTATETYPE(type)));
 }
 
 static VALUE
-rbatkstateset_contains_states(VALUE self, VALUE types)
+rg_contains_states(VALUE self, VALUE rbtypes)
 {
-    gint i;
-    gboolean ret;
-    gint n_types = RARRAY_LEN(types);
-    AtkStateType* atypes = g_new(AtkStateType, n_types);
+    AtkStateSet *set = _SELF(self);
+    long n;
+    AtkStateType *types = RVAL2ATKSTATETYPES(rbtypes, &n);
+    gboolean result;
 
-    Check_Type(types, T_ARRAY);
+    result = atk_state_set_contains_states(set, types, n);
 
-    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(types);
 
-    g_free(atypes);
-    return ret;
+    return CBOOL2RVAL(result);
 }
 
 static VALUE
-rbatkstateset_remove_state(VALUE self, VALUE type)
+rg_remove_state(VALUE self, VALUE type)
 {
     return CBOOL2RVAL(atk_state_set_remove_state(_SELF(self), 
-                                                 RVAL2GENUM(type, ATK_TYPE_STATE_TYPE)));
+                                                 RVAL2ATKSTATETYPE(type)));
 }
 
 static VALUE
-rbatkstateset_and_sets(VALUE self, VALUE compare_set)
+rg_and(VALUE self, VALUE compare_set)
 {
     return GOBJ2RVAL(atk_state_set_and_sets(_SELF(self), _SELF(compare_set)));
 }
 
 static VALUE
-rbatkstateset_or_sets(VALUE self, VALUE compare_set)
+rg_or(VALUE self, VALUE compare_set)
 {
     return GOBJ2RVAL(atk_state_set_or_sets(_SELF(self), _SELF(compare_set)));
 }
 
 static VALUE
-rbatkstateset_xor_sets(VALUE self, VALUE compare_set)
+rg_xor(VALUE self, VALUE compare_set)
 {
     return GOBJ2RVAL(atk_state_set_xor_sets(_SELF(self), _SELF(compare_set)));
 }
 
 void
-Init_atk_state_set()
+Init_atk_state_set(VALUE mAtk)
 {
-    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");
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(ATK_TYPE_STATE_SET, "StateSet", mAtk);
+
+    RG_DEF_METHOD(initialize, 0);
+    RG_DEF_METHOD_P(empty, 0);
+    RG_DEF_METHOD(add_state, 1);
+    RG_DEF_METHOD(add_states, 1);
+    RG_DEF_METHOD(clear_states, 0);
+    RG_DEF_METHOD(contains_state, 1);
+    RG_DEF_METHOD(contains_states, 1);
+    RG_DEF_METHOD(remove_state, 1);
+    RG_DEF_METHOD(and, 1);
+    RG_DEF_ALIAS("&", "and");
+    RG_DEF_METHOD(or, 1);
+    RG_DEF_ALIAS("|", "or");
+    RG_DEF_METHOD(xor, 1);
+    RG_DEF_ALIAS("^", "xor");
 }