glib2 1.0.3-x86-mingw32 → 1.1.0-x86-mingw32

data/ext/glib2/rbgobj_fundamental.c

@@ -1,10 +1,23 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
-
-   rbgobj_fundamental.c -
-
-   Copyright (C) 2007 Ruby-GNOME2 Project Team
-************************************************/
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2007  Ruby-GNOME2 Project Team
+ *
+ *  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 "rbgobject.h"
 #include "rbgprivate.h"

data/ext/glib2/rbgobj_object.c

@@ -1,36 +1,44 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/**********************************************************************
-
-  rbgobj_object.c -
-
-  $Author: sakai $
-  $Date: 2007/07/19 22:03:44 $
-
-  Copyright (C) 2002-2004  Ruby-GNOME2 Project Team
-  Copyright (C) 2002-2003  Masahiro Sakai
-
-  This file is derived from rbgtkobject.c in Ruby/Gtk distribution.
-  rbgtkobject.c -
-  Copyright (C) 1998-2000 Yukihiro Matsumoto,
-                          Daisuke Kanda,
-                          Hiroshi Igarashi
-
-**********************************************************************/
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002-2004  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002-2003  Masahiro Sakai
+ *  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+ *                          Daisuke Kanda,
+ *                          Hiroshi Igarashi
+ *
+ *  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 "rbgprivate.h"
 
-VALUE rbgobj_cObject;
+#define RG_TARGET_NAMESPACE rbgobj_cObject
+
+VALUE RG_TARGET_NAMESPACE;
 static VALUE eNoPropertyError;
 static GQuark RUBY_GOBJECT_OBJ_KEY;
 
 /* deperecated */
 void
-rbgobj_add_abstract_but_create_instance_class(GType gtype)
+rbgobj_add_abstract_but_create_instance_class(G_GNUC_UNUSED GType gtype)
 {
 }
 
 static void
-weak_notify(gpointer data, GObject *where_the_object_was)
+weak_notify(gpointer data, G_GNUC_UNUSED GObject *where_the_object_was)
 {
     gobj_holder *holder = data;
 
@@ -56,7 +64,7 @@ holder_free(gobj_holder *holder)
         if (!holder->destroyed) {
             g_object_set_qdata(holder->gobj, RUBY_GOBJECT_OBJ_KEY, NULL);
             g_object_weak_unref(holder->gobj, (GWeakNotify)weak_notify, holder);
-	    weak_notify(holder, holder->gobj);
+            weak_notify(holder, holder->gobj);
         }
         holder->gobj = NULL;
     }
@@ -121,7 +129,7 @@ rbgobj_get_ruby_object_from_gobject(GObject* gobj, gboolean alloc)
     } else if (alloc) {
         VALUE obj;
 
-	obj = gobj_s_allocate(GTYPE2CLASS(G_OBJECT_TYPE(gobj)));
+        obj = gobj_s_allocate(GTYPE2CLASS(G_OBJECT_TYPE(gobj)));
         gobj = g_object_ref(gobj);
         rbgobj_gobject_initialize(obj, (gpointer)gobj);
         return obj;
@@ -183,7 +191,7 @@ gobj_mark(gpointer ptr)
     GObject* gobj = ptr;
     guint n_properties;
     GParamSpec** properties;
-    GValue gval = {0,};
+    GValue gval = G_VALUE_INIT;
     guint i;
 
     properties = g_object_class_list_properties(G_OBJECT_GET_CLASS(gobj), &n_properties);
@@ -207,7 +215,7 @@ gobj_mark(gpointer ptr)
 }
 
 static VALUE
-gobj_s_gobject_new(int argc, VALUE *argv, VALUE self)
+rg_s_new_bang(int argc, VALUE *argv, VALUE self)
 {
     const RGObjClassInfo* cinfo = rbgobj_lookup_class(self);
     VALUE params_hash;
@@ -337,7 +345,7 @@ rbgobj_gobject_new(GType gtype, VALUE params_hash)
 }
 
 static VALUE
-gobj_s_install_property(int argc, VALUE* argv, VALUE self)
+rg_s_install_property(int argc, VALUE* argv, VALUE self)
 {
     const RGObjClassInfo* cinfo = rbgobj_lookup_class(self);
     gpointer gclass;
@@ -431,8 +439,8 @@ rbgobj_register_property_setter(GType gtype, const char *name, RValueToGValueFun
 
     oclass = g_type_class_ref(gtype);
     pspec = g_object_class_find_property(oclass, name);
-    
-    rb_hash_aset(table, rb_str_new2(g_param_spec_get_name(pspec)),
+
+    rb_hash_aset(table, CSTR2RVAL(g_param_spec_get_name(pspec)),
                  Data_Wrap_Struct(rb_cData, NULL, NULL, func));
 
     g_type_class_unref(oclass);
@@ -453,12 +461,14 @@ rbgobj_register_property_getter(GType gtype, const char *name, GValueToRValueFun
     oclass = g_type_class_ref(gtype);
     pspec = g_object_class_find_property(oclass, name);
 
-    rb_hash_aset(table, rb_str_new2(g_param_spec_get_name(pspec)),
+    rb_hash_aset(table, CSTR2RVAL(g_param_spec_get_name(pspec)),
                  Data_Wrap_Struct(rb_cData, NULL, NULL, func));
+
+    g_type_class_unref(oclass);
 }
 
 static VALUE
-gobj_set_property(VALUE self, VALUE prop_name, VALUE val)
+rg_set_property(VALUE self, VALUE prop_name, VALUE val)
 {
     GParamSpec* pspec;
     const char* name;
@@ -476,7 +486,7 @@ gobj_set_property(VALUE self, VALUE prop_name, VALUE val)
     else {
         // FIXME: use rb_ensure to call g_value_unset()
         RValueToGValueFunc setter = NULL;
-        GValue gval = {0,};
+        GValue gval = G_VALUE_INIT;
 
         g_value_init(&gval, G_PARAM_SPEC_VALUE_TYPE(pspec));
 
@@ -484,7 +494,7 @@ gobj_set_property(VALUE self, VALUE prop_name, VALUE val)
             VALUE table = rb_hash_aref(type_to_prop_setter_table,
                                        INT2FIX(pspec->owner_type));
             if (!NIL_P(table)){
-                VALUE obj = rb_hash_aref(table, rb_intern(g_param_spec_get_name(pspec)));
+                VALUE obj = rb_hash_aref(table, CSTR2RVAL(g_param_spec_get_name(pspec)));
                 if (!NIL_P(obj))
                     Data_Get_Struct(obj, void, setter);
             }
@@ -505,7 +515,7 @@ gobj_set_property(VALUE self, VALUE prop_name, VALUE val)
 }
 
 static VALUE
-gobj_get_property(VALUE self, VALUE prop_name)
+rg_get_property(VALUE self, VALUE prop_name)
 {
     GParamSpec* pspec;
     const char* name;
@@ -523,7 +533,7 @@ gobj_get_property(VALUE self, VALUE prop_name)
     else {
         // FIXME: use rb_ensure to call g_value_unset()
         GValueToRValueFunc getter = NULL;
-        GValue gval = {0,};
+        GValue gval = G_VALUE_INIT;
         VALUE ret;
 
         {
@@ -548,34 +558,34 @@ gobj_get_property(VALUE self, VALUE prop_name)
     }
 }
 
-static VALUE gobj_thaw_notify(VALUE self);
+static VALUE rg_thaw_notify(VALUE self);
 
 static VALUE
-gobj_freeze_notify(VALUE self)
+rg_freeze_notify(VALUE self)
 {
     g_object_freeze_notify(RVAL2GOBJ(self));
     if (rb_block_given_p()) {
-        return rb_ensure(rb_yield, self, gobj_thaw_notify, self);
+        return rb_ensure(rb_yield, self, rg_thaw_notify, self);
     }
     return self;
 }
 
 static VALUE
-gobj_notify(VALUE self, VALUE property_name)
+rg_notify(VALUE self, VALUE property_name)
 {
     g_object_notify(RVAL2GOBJ(self), StringValuePtr(property_name));
     return self;
 }
 
 static VALUE
-gobj_thaw_notify(VALUE self)
+rg_thaw_notify(VALUE self)
 {
     g_object_thaw_notify(RVAL2GOBJ(self));
     return self;
 }
 
 static VALUE
-gobj_is_destroyed(VALUE self)
+rg_destroyed_p(VALUE self)
 {
     gobj_holder* holder;
 
@@ -588,7 +598,7 @@ gobj_is_destroyed(VALUE self)
 }
 
 static VALUE
-gobj_inspect(VALUE self)
+rg_inspect(VALUE self)
 {
     gobj_holder* holder;
     const char *class_name;
@@ -600,7 +610,7 @@ gobj_inspect(VALUE self)
     class_name = rb_class2name(CLASS_OF(self));
     if (!holder->destroyed)
         s = g_strdup_printf("#<%s:%p ptr=%p>", class_name, (void *)self,
-			    holder->gobj);
+                            holder->gobj);
     else
         s = g_strdup_printf("#<%s:%p destroyed>", class_name, (void *)self);
 
@@ -611,11 +621,17 @@ gobj_inspect(VALUE self)
 }
 
 static VALUE
-gobj_initialize(int argc, VALUE *argv, VALUE self)
+rg_type_name(VALUE self)
+{
+    return CSTR2RVAL(G_OBJECT_TYPE_NAME(RVAL2GOBJ(self)));
+}
+
+static VALUE
+rg_initialize(int argc, VALUE *argv, VALUE self)
 {
     VALUE params_hash;
     GObject* gobj;
-    
+
     rb_scan_args(argc, argv, "01", &params_hash);
 
     if (!NIL_P(params_hash))
@@ -651,7 +667,7 @@ static GQuark q_ruby_getter;
 // FIXME: use rb_protect
 static void
 get_prop_func(GObject* object,
-              guint property_id,
+              G_GNUC_UNUSED guint property_id,
               GValue* value,
               GParamSpec* pspec)
 {
@@ -677,7 +693,7 @@ get_prop_func(GObject* object,
 // FIXME: use rb_protect
 static void
 set_prop_func(GObject* object,
-              guint property_id,
+              G_GNUC_UNUSED guint property_id,
               const GValue* value,
               GParamSpec* pspec)
 {
@@ -699,7 +715,7 @@ set_prop_func(GObject* object,
 
 // FIXME: use rb_protect
 static void
-class_init_func(gpointer g_class_, gpointer class_data)
+class_init_func(gpointer g_class_, G_GNUC_UNUSED gpointer class_data)
 {
     GObjectClass* g_class = G_OBJECT_CLASS(g_class_);
 
@@ -714,7 +730,7 @@ class_init_func(gpointer g_class_, gpointer class_data)
 }
 
 static VALUE
-type_register(int argc, VALUE* argv, VALUE self)
+rg_s_type_register(int argc, VALUE* argv, VALUE self)
 {
     VALUE type_name, flags;
     volatile VALUE class_init_proc = Qnil;
@@ -752,6 +768,8 @@ type_register(int argc, VALUE* argv, VALUE self)
         GTypeQuery query;
         g_type_query(parent_type, &query);
 
+        /* TODO: Why new?  g_type_register_static() doesn’t retain a copy, so
+         * this should be allocated on the stack. */
         info = g_new0(GTypeInfo, 1);
         info->class_size     = query.class_size;
         info->base_init      = NULL;
@@ -785,7 +803,7 @@ type_register(int argc, VALUE* argv, VALUE self)
             VALUE m = rb_define_module_under(self, RubyGObjectHookModule);
 
             if (! (cinfo->flags & RBGOBJ_DEFINED_BY_RUBY)) {
-                rb_define_method(m, "initialize", gobj_initialize, -1);
+                rb_define_method(m, "initialize", rg_initialize, -1);
             }
 
             rb_include_module(self, m);
@@ -795,26 +813,13 @@ type_register(int argc, VALUE* argv, VALUE self)
     }
 }
 
-static void
-Init_gobject_subclass()
-{
-    VALUE cGObject = GTYPE2CLASS(G_TYPE_OBJECT);
-    rb_define_singleton_method(cGObject, "type_register", type_register, -1);
-
-    rb_global_variable(&proc_mod_eval);
-    proc_mod_eval = rb_eval_string("lambda{|obj,proc| obj.module_eval(&proc)}");
-}
-
 /**********************************************************************/
 
 void 
-Init_gobject_gobject()
+Init_gobject_gobject(void)
 {
-    VALUE cGObject;
-
-    rbgobj_cObject = G_DEF_CLASS_WITH_GC_FUNC(G_TYPE_OBJECT, "Object", mGLib,
-					      gobj_mark, NULL);
-    cGObject = rbgobj_cObject;
+    RG_TARGET_NAMESPACE = G_DEF_CLASS_WITH_GC_FUNC(G_TYPE_OBJECT, "Object", mGLib,
+                                                  gobj_mark, NULL);
 
 #ifdef G_TYPE_INITIALLY_UNOWNED
     G_DEF_CLASS(G_TYPE_INITIALLY_UNOWNED, "InitiallyUnowned", mGLib);
@@ -822,26 +827,27 @@ Init_gobject_gobject()
 
     RUBY_GOBJECT_OBJ_KEY = g_quark_from_static_string("__ruby_gobject_object__");
 
-    rb_define_alloc_func(cGObject, (VALUE(*)_((VALUE)))gobj_s_allocate);
-    rb_define_singleton_method(cGObject, "new!", gobj_s_gobject_new, -1);
+    rb_define_alloc_func(RG_TARGET_NAMESPACE, (VALUE(*)_((VALUE)))gobj_s_allocate);
+    RG_DEF_SMETHOD_BANG(new, -1);
 
-    rb_define_singleton_method(cGObject, "property", &gobj_s_property, 1);
-    rb_define_singleton_method(cGObject, "properties", &gobj_s_properties, -1);
-    rb_define_singleton_method(cGObject, "install_property", gobj_s_install_property, -1);
+    rb_define_singleton_method(RG_TARGET_NAMESPACE, "property", &gobj_s_property, 1);
+    rb_define_singleton_method(RG_TARGET_NAMESPACE, "properties", &gobj_s_properties, -1);
+    RG_DEF_SMETHOD(install_property, -1);
     q_ruby_getter = g_quark_from_static_string("__ruby_getter");
     q_ruby_setter = g_quark_from_static_string("__ruby_setter");
 
-    rb_define_method(cGObject, "set_property", gobj_set_property, 2);
-    rb_define_method(cGObject, "get_property", gobj_get_property, 1);
-    rb_define_method(cGObject, "freeze_notify", gobj_freeze_notify, 0);
-    rb_undef_method(cGObject, "notify");
-    rb_define_method(cGObject, "notify", gobj_notify, 1);
-    rb_define_method(cGObject, "thaw_notify", gobj_thaw_notify, 0);
-    rb_define_method(cGObject, "destroyed?", gobj_is_destroyed, 0);
+    RG_DEF_METHOD(set_property, 2);
+    RG_DEF_METHOD(get_property, 1);
+    RG_DEF_METHOD(freeze_notify, 0);
+    rb_undef_method(RG_TARGET_NAMESPACE, "notify");
+    RG_DEF_METHOD(notify, 1);
+    RG_DEF_METHOD(thaw_notify, 0);
+    RG_DEF_METHOD_P(destroyed, 0);
 
-    rb_define_method(cGObject, "initialize", gobj_initialize, -1);
-    rb_define_method(cGObject, "ref_count", gobj_ref_count, 0); /* for debugging */
-    rb_define_method(cGObject, "inspect", gobj_inspect, 0);
+    RG_DEF_METHOD(initialize, -1);
+    rb_define_method(RG_TARGET_NAMESPACE, "ref_count", gobj_ref_count, 0); /* for debugging */
+    RG_DEF_METHOD(inspect, 0);
+    RG_DEF_METHOD(type_name, 0);
 
     eNoPropertyError = rb_define_class_under(mGLib, "NoPropertyError",
                                              rb_eNameError);
@@ -851,6 +857,9 @@ Init_gobject_gobject()
     type_to_prop_setter_table = rb_hash_new();
     type_to_prop_getter_table = rb_hash_new();
 
-    Init_gobject_subclass();
-}
+    /* subclass */
+    RG_DEF_SMETHOD(type_register, -1);
 
+    rb_global_variable(&proc_mod_eval);
+    proc_mod_eval = rb_eval_string("lambda{|obj,proc| obj.module_eval(&proc)}");
+}

data/ext/glib2/rbgobj_param.c

@@ -1,19 +1,29 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/**********************************************************************
-
-  rbgobj_param.c -
-
-  $Author: ggc $
-  $Date: 2007/07/13 16:07:28 $
-  created at: Sun Jun  9 20:31:47 JST 2002
-
-  Copyright (C) 2002,2003  Masahiro Sakai
-
-**********************************************************************/
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002,2003  Masahiro Sakai
+ *
+ *  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 "rbgprivate.h"
 
-VALUE rbgobj_cParam;
+#define RG_TARGET_NAMESPACE rbgobj_cParam
+
+VALUE RG_TARGET_NAMESPACE;
 static GQuark qparamspec;
 
 static VALUE pspec_s_allocate(VALUE klass);
@@ -100,7 +110,7 @@ pspec_s_allocate(VALUE klass)
 }
 
 static VALUE
-inspect(VALUE self)
+rg_inspect(VALUE self)
 {
     GParamSpec* pspec = rbgobj_get_param_spec(self);
     VALUE v = rb_inspect(GTYPE2CLASS(pspec->owner_type));
@@ -114,53 +124,53 @@ inspect(VALUE self)
 }
 
 static VALUE
-get_name(VALUE self)
+rg_name(VALUE self)
 {
     return rb_str_new2(g_param_spec_get_name(rbgobj_get_param_spec(self)));
 }
 
 static VALUE
-get_nick(VALUE self)
+rg_nick(VALUE self)
 {
     const gchar* str = g_param_spec_get_nick(rbgobj_get_param_spec(self));
     return str ? rb_str_new2(str) : Qnil;
 }
 
 static VALUE
-get_blurb(VALUE self)
+rg_blurb(VALUE self)
 {
     const gchar* str = g_param_spec_get_blurb(rbgobj_get_param_spec(self));
     return str ? rb_str_new2(str) : Qnil;
 }
 
 static VALUE
-get_flags(VALUE self)
+rg_flags(VALUE self)
 {
     return INT2NUM(rbgobj_get_param_spec(self)->flags);
 }
 
 static VALUE
-get_value_type(VALUE self)
+rg_value_type(VALUE self)
 {
     return rbgobj_gtype_new(G_PARAM_SPEC_VALUE_TYPE(rbgobj_get_param_spec(self)));
 }
 
 static VALUE
-get_owner_type(VALUE self)
+rg_owner_type(VALUE self)
 {
     return rbgobj_gtype_new(rbgobj_get_param_spec(self)->owner_type);
 }
 
 static VALUE
-get_owner(VALUE self)
+rg_owner(VALUE self)
 {
     return GTYPE2CLASS(rbgobj_get_param_spec(self)->owner_type);
 }
 
 static VALUE
-value_default(VALUE self)
+rg_value_default(VALUE self)
 {
-    GValue tmp = {0,};
+    GValue tmp = G_VALUE_INIT;
     VALUE result;
 
     g_value_init(&tmp,
@@ -174,7 +184,7 @@ value_default(VALUE self)
 
 #if 0
 static VALUE
-value_defaults(VALUE self, VALUE val)
+rg_value_defaults_p(VALUE self, VALUE val)
 {
     GValue tmp = {0,};
     gboolean result;
@@ -190,7 +200,6 @@ value_defaults(VALUE self, VALUE val)
 }
 #endif
 
-
 struct validate_arg{
     GParamSpec* pspec;
     GValue* value;
@@ -217,10 +226,10 @@ value_validate_ensure(struct validate_arg* arg)
 }
 
 static VALUE
-value_validate(VALUE self, VALUE obj)
+rg_value_validate(VALUE self, VALUE obj)
 {
     struct validate_arg arg;
-    GValue value = {0,};
+    GValue value = G_VALUE_INIT;
 
     arg.pspec = rbgobj_get_param_spec(self);
     arg.value = &value;
@@ -232,16 +241,15 @@ value_validate(VALUE self, VALUE obj)
                      value_validate_ensure, (VALUE)&arg);
 }
 
-
 static VALUE
-value_convert(int argc, VALUE* argv, VALUE self)
+rg_value_convert(int argc, VALUE* argv, VALUE self)
 {
     GParamSpec* pspec = rbgobj_get_param_spec(self);
     VALUE src, strict_validation;
     VALUE src_type;
     VALUE result = Qnil;
-    GValue src_value = {0,};
-    GValue dest_value = {0,};
+    GValue src_value = G_VALUE_INIT;
+    GValue dest_value = G_VALUE_INIT;
     gboolean b;
 
     rb_scan_args(argc, argv, "21", &src, &src_type, &strict_validation);
@@ -269,12 +277,12 @@ value_convert(int argc, VALUE* argv, VALUE self)
 }
 
 static VALUE
-values_compare(VALUE self, VALUE a, VALUE b)
+rg_value_compare(VALUE self, VALUE a, VALUE b)
 {
     GParamSpec* pspec = rbgobj_get_param_spec(self);
     GType type = G_PARAM_SPEC_VALUE_TYPE(pspec);
-    GValue v1 = {0,};
-    GValue v2 = {0,};
+    GValue v1 = G_VALUE_INIT;
+    GValue v2 = G_VALUE_INIT;
     gint result;
 
     g_value_init(&v1, type);
@@ -292,14 +300,12 @@ values_compare(VALUE self, VALUE a, VALUE b)
     return INT2NUM(result);
 }
 
-
 static VALUE
-get_ref_count(VALUE self)
+rg_ref_count(VALUE self)
 {
     return INT2NUM(G_PARAM_SPEC(rbgobj_get_param_spec(self))->ref_count);
 }
 
-
 #define param_is_flag(flag) \
     static VALUE \
     param_is_##flag(VALUE self) \
@@ -318,66 +324,55 @@ param_is_flag(G_PARAM_READWRITE)
 
 /**********************************************************************/
 
-static void
-Init_gobject_gparam_spec()
+void
+Init_gobject_gparam(void)
 {
-    VALUE cParamSpec;
-
     qparamspec = g_quark_from_static_string("__ruby_gobject_param_spec__");
-    rbgobj_cParam = G_DEF_CLASS(G_TYPE_PARAM, "Param", mGLib);
-    cParamSpec = rbgobj_cParam;
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_PARAM, "Param", mGLib);
 
     /* GParamFlags */
-    rb_define_const(cParamSpec, "READABLE",       INT2FIX(G_PARAM_READABLE));
-    rb_define_const(cParamSpec, "WRITABLE",       INT2FIX(G_PARAM_WRITABLE));
-    rb_define_const(cParamSpec, "CONSTRUCT",      INT2FIX(G_PARAM_CONSTRUCT));
-    rb_define_const(cParamSpec, "CONSTRUCT_ONLY", INT2FIX(G_PARAM_CONSTRUCT_ONLY));
-    rb_define_const(cParamSpec, "LAX_VALIDATION", INT2FIX(G_PARAM_LAX_VALIDATION));
-    rb_define_const(cParamSpec, "PRIVATE",        INT2FIX(G_PARAM_PRIVATE));
-    rb_define_const(cParamSpec, "READWRITE",      INT2FIX(G_PARAM_READWRITE));
-    rb_define_const(cParamSpec, "MASK",           INT2FIX(G_PARAM_MASK));
-    rb_define_const(cParamSpec, "USER_SHIFT",     INT2FIX(G_PARAM_USER_SHIFT));
+    rb_define_const(RG_TARGET_NAMESPACE, "READABLE",       INT2FIX(G_PARAM_READABLE));
+    rb_define_const(RG_TARGET_NAMESPACE, "WRITABLE",       INT2FIX(G_PARAM_WRITABLE));
+    rb_define_const(RG_TARGET_NAMESPACE, "CONSTRUCT",      INT2FIX(G_PARAM_CONSTRUCT));
+    rb_define_const(RG_TARGET_NAMESPACE, "CONSTRUCT_ONLY", INT2FIX(G_PARAM_CONSTRUCT_ONLY));
+    rb_define_const(RG_TARGET_NAMESPACE, "LAX_VALIDATION", INT2FIX(G_PARAM_LAX_VALIDATION));
+    rb_define_const(RG_TARGET_NAMESPACE, "PRIVATE",        INT2FIX(G_PARAM_PRIVATE));
+    rb_define_const(RG_TARGET_NAMESPACE, "READWRITE",      INT2FIX(G_PARAM_READWRITE));
+    rb_define_const(RG_TARGET_NAMESPACE, "MASK",           INT2FIX(G_PARAM_MASK));
+    rb_define_const(RG_TARGET_NAMESPACE, "USER_SHIFT",     INT2FIX(G_PARAM_USER_SHIFT));
 
-    rb_define_alloc_func(cParamSpec, pspec_s_allocate);
+    rb_define_alloc_func(RG_TARGET_NAMESPACE, pspec_s_allocate);
 
-    rb_define_method(cParamSpec, "inspect", inspect, 0);
+    RG_DEF_METHOD(inspect, 0);
 
-    rb_define_method(cParamSpec, "name", get_name, 0);
-    rb_define_method(cParamSpec, "nick", get_nick, 0);
-    rb_define_method(cParamSpec, "blurb", get_blurb, 0);
+    RG_DEF_METHOD(name, 0);
+    RG_DEF_METHOD(nick, 0);
+    RG_DEF_METHOD(blurb, 0);
 
-    rb_define_method(cParamSpec, "flags", get_flags, 0);
-    rb_define_method(cParamSpec, "value_type", get_value_type, 0);
-    rb_define_method(cParamSpec, "owner_type", get_owner_type, 0);
-    rb_define_method(cParamSpec, "owner", get_owner, 0);
+    RG_DEF_METHOD(flags, 0);
+    RG_DEF_METHOD(value_type, 0);
+    RG_DEF_METHOD(owner_type, 0);
+    RG_DEF_METHOD(owner, 0);
 
-    rb_define_method(cParamSpec, "value_default", value_default, 0);
-    rb_define_alias(cParamSpec, "default", "value_default");
+    RG_DEF_METHOD(value_default, 0);
+    RG_DEF_ALIAS("default", "value_default");
 
     // FIXME: better name
 #if 0
-    rb_define_method(cParamSpec, "value_defaults?", value_defaults, 1);
+    RG_DEF_METHOD_P(value_defaults, 1);
 #endif
-    rb_define_method(cParamSpec, "value_validate", value_validate, 1);
-    rb_define_method(cParamSpec, "value_convert", value_convert, -1);
-    rb_define_method(cParamSpec, "value_compare", values_compare, 2);
+    RG_DEF_METHOD(value_validate, 1);
+    RG_DEF_METHOD(value_convert, -1);
+    RG_DEF_METHOD(value_compare, 2);
 
     /* for debugging */
-    rb_define_method(cParamSpec, "ref_count", get_ref_count, 0);
-
-    rb_define_method(cParamSpec, "readable?",       param_is_G_PARAM_READABLE, 0);
-    rb_define_method(cParamSpec, "writable?",       param_is_G_PARAM_WRITABLE, 0);
-    rb_define_method(cParamSpec, "construct?",      param_is_G_PARAM_CONSTRUCT, 0);
-    rb_define_method(cParamSpec, "construct_only?", param_is_G_PARAM_CONSTRUCT_ONLY, 0);
-    rb_define_method(cParamSpec, "lax_validation?", param_is_G_PARAM_LAX_VALIDATION, 0);
-    rb_define_method(cParamSpec, "private?",        param_is_G_PARAM_PRIVATE, 0);
-    rb_define_method(cParamSpec, "readwrite?",      param_is_G_PARAM_READWRITE, 0);
-}
-
-/**********************************************************************/
-
-void
-Init_gobject_gparam()
-{
-    Init_gobject_gparam_spec();
+    RG_DEF_METHOD(ref_count, 0);
+
+    rb_define_method(RG_TARGET_NAMESPACE, "readable?",       param_is_G_PARAM_READABLE, 0);
+    rb_define_method(RG_TARGET_NAMESPACE, "writable?",       param_is_G_PARAM_WRITABLE, 0);
+    rb_define_method(RG_TARGET_NAMESPACE, "construct?",      param_is_G_PARAM_CONSTRUCT, 0);
+    rb_define_method(RG_TARGET_NAMESPACE, "construct_only?", param_is_G_PARAM_CONSTRUCT_ONLY, 0);
+    rb_define_method(RG_TARGET_NAMESPACE, "lax_validation?", param_is_G_PARAM_LAX_VALIDATION, 0);
+    rb_define_method(RG_TARGET_NAMESPACE, "private?",        param_is_G_PARAM_PRIVATE, 0);
+    rb_define_method(RG_TARGET_NAMESPACE, "readwrite?",      param_is_G_PARAM_READWRITE, 0);
 }