glib2 1.1.2 → 1.1.3

data/ext/glib2/rbglib_win32.c

@@ -27,13 +27,13 @@
 #define RG_TARGET_NAMESPACE mWin32
 
 static VALUE
-rg_m_error_message(VALUE self, VALUE error)
+rg_s_error_message(VALUE self, VALUE error)
 {
     return CSTR2RVAL_FREE(g_win32_error_message(NUM2INT(error)));
 }
 
 static VALUE
-rg_m_locale(VALUE self)
+rg_s_locale(VALUE self)
 {
     return CSTR2RVAL_FREE(g_win32_getlocale());
 }
@@ -42,18 +42,18 @@ static VALUE
 rbglib_m_win32_locale_deprecated(VALUE self)
 {
     rb_warn("GLib.win32_locale() is deprecated. Use GLib::Win32.locale instead");
-    return rg_m_locale(self);
+    return rg_s_locale(self);
 }
 
 static VALUE
-rg_m_get_package_installation_directory(VALUE self, VALUE package, VALUE dll_name)
+rg_s_get_package_installation_directory(VALUE self, VALUE package, VALUE dll_name)
 {
     return CSTR2RVAL_FREE(g_win32_get_package_installation_directory(RVAL2CSTR(package), 
                                                                 RVAL2CSTR(dll_name)));
 }
 
 static VALUE
-rg_m_get_package_installation_subdirectory(VALUE self, VALUE package, VALUE dll_name, VALUE subdir)
+rg_s_get_package_installation_subdirectory(VALUE self, VALUE package, VALUE dll_name, VALUE subdir)
 {
     return CSTR2RVAL_FREE(g_win32_get_package_installation_subdirectory(RVAL2CSTR(package), 
                                                                     RVAL2CSTR(dll_name),
@@ -62,7 +62,7 @@ rg_m_get_package_installation_subdirectory(VALUE self, VALUE package, VALUE dll_
 
 #if GLIB_CHECK_VERSION(2,6,0)
 static VALUE
-rg_m_version(VALUE self)
+rg_s_version(VALUE self)
 {
     return UINT2NUM(g_win32_get_windows_version());
 }
@@ -70,7 +70,7 @@ rg_m_version(VALUE self)
 
 #if GLIB_CHECK_VERSION(2,8,0)
 static VALUE
-rg_m_locale_filename_from_utf8(VALUE self, VALUE utf8_filename)
+rg_s_locale_filename_from_utf8(VALUE self, VALUE utf8_filename)
 {
     return CSTR2RVAL_FREE(g_win32_locale_filename_from_utf8(RVAL2CSTR(utf8_filename)));
 }
@@ -80,14 +80,14 @@ rbglib_m_win32_locale_filename_from_utf8_deprecated(VALUE self,
                                                     VALUE utf8_filename)
 {
     rb_warn("GLib.win32_locale_filename_from_utf8() is deprecated. Use GLib::Win32.locale_filename_from_utf8 instead");
-    return rg_m_locale_filename_from_utf8(self, utf8_filename);
+    return rg_s_locale_filename_from_utf8(self, utf8_filename);
 }
 
 #endif
 
 #  if GLIB_CHECK_VERSION(2, 16, 0)
 static VALUE
-rg_m_get_package_installation_directory_of_module(int argc,
+rg_s_get_package_installation_directory_of_module(int argc,
                                 VALUE *argv,
                                 VALUE self)
 {
@@ -114,23 +114,23 @@ Init_glib_win32(void)
     /* glib/gwin32.h */
     VALUE RG_TARGET_NAMESPACE = rb_define_module_under(mGLib, "Win32");
 
-    RG_DEF_MODFUNC(error_message, 1);
-    RG_DEF_MODFUNC(locale, 0);
-    RG_DEF_MODFUNC(get_package_installation_directory, 2);
-    RG_DEF_MODFUNC(get_package_installation_subdirectory, 3);
-    RG_DEF_MODFUNC(version, 0);
+    RG_DEF_SMETHOD(error_message, 1);
+    RG_DEF_SMETHOD(locale, 0);
+    RG_DEF_SMETHOD(get_package_installation_directory, 2);
+    RG_DEF_SMETHOD(get_package_installation_subdirectory, 3);
+    RG_DEF_SMETHOD(version, 0);
     /* Deprecated */
-    rb_define_module_function(mGLib, "win32_locale", rbglib_m_win32_locale_deprecated, 0);
+    rbg_define_singleton_method(mGLib, "win32_locale", rbglib_m_win32_locale_deprecated, 0);
 
 #  if GLIB_CHECK_VERSION(2,8,0)
-    RG_DEF_MODFUNC(locale_filename_from_utf8, 1);
+    RG_DEF_SMETHOD(locale_filename_from_utf8, 1);
     /* Deprecated */
-    rb_define_module_function(mGLib, "win32_locale_filename_from_utf8",
+    rbg_define_singleton_method(mGLib, "win32_locale_filename_from_utf8",
                               rbglib_m_win32_locale_filename_from_utf8_deprecated, 1);
 #  endif
 
 #  if GLIB_CHECK_VERSION(2, 16, 0)
-    RG_DEF_MODFUNC(get_package_installation_directory_of_module, -1);
+    RG_DEF_SMETHOD(get_package_installation_directory_of_module, -1);
 #  endif
 #endif
 }

data/ext/glib2/rbgobj_boxed.c

@@ -237,10 +237,10 @@ Init_gobject_gboxed(void)
     rbgobj_register_r2g_func(G_TYPE_BOXED, boxed_from_ruby);
 
     rb_define_alloc_func(RG_TARGET_NAMESPACE, (VALUE(*)_((VALUE)))rbgobj_boxed_s_allocate);
-    rb_define_singleton_method(RG_TARGET_NAMESPACE, "gtype", generic_s_gtype, 0);
-    rb_define_method(RG_TARGET_NAMESPACE, "gtype", generic_gtype, 0);
+    rbg_define_singleton_method(RG_TARGET_NAMESPACE, "gtype", generic_s_gtype, 0);
+    rbg_define_method(RG_TARGET_NAMESPACE, "gtype", generic_gtype, 0);
     RG_DEF_METHOD(initialize, 0);
     RG_DEF_METHOD(inspect, 0);
     RG_DEF_METHOD(initialize_copy, 1);
     RG_DEF_ALIAS("copy", "dup");
-}
+}

data/ext/glib2/rbgobj_enums.c

@@ -377,8 +377,8 @@ Init_gobject_genums(void)
 
     RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_ENUM, "Enum", mGLib);
 
-    rb_define_singleton_method(RG_TARGET_NAMESPACE, "gtype", generic_s_gtype, 0);
-    rb_define_method(RG_TARGET_NAMESPACE, "gtype", generic_gtype, 0);
+    rbg_define_singleton_method(RG_TARGET_NAMESPACE, "gtype", generic_s_gtype, 0);
+    rbg_define_method(RG_TARGET_NAMESPACE, "gtype", generic_gtype, 0);
 
     RG_DEF_SMETHOD(range, 0);
     RG_DEF_SMETHOD(values, 0);

data/ext/glib2/rbgobj_flags.c

@@ -479,8 +479,8 @@ Init_gobject_gflags(void)
 
     RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_FLAGS, "Flags", mGLib);
 
-    rb_define_singleton_method(RG_TARGET_NAMESPACE, "gtype", generic_s_gtype, 0);
-    rb_define_method(RG_TARGET_NAMESPACE, "gtype", generic_gtype, 0);
+    rbg_define_singleton_method(RG_TARGET_NAMESPACE, "gtype", generic_s_gtype, 0);
+    rbg_define_method(RG_TARGET_NAMESPACE, "gtype", generic_gtype, 0);
 
     RG_DEF_SMETHOD(mask, 0);
     RG_DEF_SMETHOD(values, 0);
@@ -495,7 +495,7 @@ Init_gobject_gflags(void)
     RG_DEF_METHOD(nick, 0);
 
     /*
-    rb_define_method(RG_TARGET_NAMESPACE, "inspect", flags_inspect, 0);
+    rbg_define_method(RG_TARGET_NAMESPACE, "inspect", flags_inspect, 0);
     */
 
     RG_DEF_METHOD_OPERATOR("<=>", flags_compare, 1);
@@ -505,9 +505,9 @@ Init_gobject_gflags(void)
     RG_DEF_METHOD_OPERATOR(">", flags_gt, 1);
     RG_DEF_METHOD_OPERATOR("<", flags_lt, 1);
     RG_DEF_METHOD_OPERATOR("~", flags_not, 0);
-    rb_define_method(RG_TARGET_NAMESPACE, "&", flags_and, 1);
-    rb_define_method(RG_TARGET_NAMESPACE, "|", flags_or, 1);
-    rb_define_method(RG_TARGET_NAMESPACE, "^", flags_xor, 1);
+    rbg_define_method(RG_TARGET_NAMESPACE, "&", flags_and, 1);
+    rbg_define_method(RG_TARGET_NAMESPACE, "|", flags_or, 1);
+    rbg_define_method(RG_TARGET_NAMESPACE, "^", flags_xor, 1);
     RG_DEF_METHOD_OPERATOR("-", flags_minus, 1);
 
     RG_DEF_METHOD_P(empty, 0);

data/ext/glib2/rbgobj_object.c

@@ -171,7 +171,7 @@ rbgobj_init_object_class(VALUE klass)
 {
     rbgobj_define_property_accessors(klass);
     if (G_TYPE_IS_ABSTRACT(CLASS2GTYPE(klass)))
-        rb_define_method(klass, "initialize", dummy_init, -1);
+        rbg_define_method(klass, "initialize", dummy_init, -1);
 }
 
 /**********************************************************************/
@@ -803,7 +803,7 @@ rg_s_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", rg_initialize, -1);
+                rbg_define_method(m, "initialize", rg_initialize, -1);
             }
 
             rb_include_module(self, m);
@@ -830,8 +830,8 @@ Init_gobject_gobject(void)
     rb_define_alloc_func(RG_TARGET_NAMESPACE, (VALUE(*)_((VALUE)))gobj_s_allocate);
     RG_DEF_SMETHOD_BANG(new, -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);
+    rbg_define_singleton_method(RG_TARGET_NAMESPACE, "property", &gobj_s_property, 1);
+    rbg_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");
@@ -845,7 +845,7 @@ Init_gobject_gobject(void)
     RG_DEF_METHOD_P(destroyed, 0);
 
     RG_DEF_METHOD(initialize, -1);
-    rb_define_method(RG_TARGET_NAMESPACE, "ref_count", gobj_ref_count, 0); /* for debugging */
+    rbg_define_method(RG_TARGET_NAMESPACE, "ref_count", gobj_ref_count, 0); /* for debugging */
     RG_DEF_METHOD(inspect, 0);
     RG_DEF_METHOD(type_name, 0);
 

data/ext/glib2/rbgobj_param.c

@@ -368,11 +368,11 @@ Init_gobject_gparam(void)
     /* for debugging */
     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);
+    rbg_define_method(RG_TARGET_NAMESPACE, "readable?",       param_is_G_PARAM_READABLE, 0);
+    rbg_define_method(RG_TARGET_NAMESPACE, "writable?",       param_is_G_PARAM_WRITABLE, 0);
+    rbg_define_method(RG_TARGET_NAMESPACE, "construct?",      param_is_G_PARAM_CONSTRUCT, 0);
+    rbg_define_method(RG_TARGET_NAMESPACE, "construct_only?", param_is_G_PARAM_CONSTRUCT_ONLY, 0);
+    rbg_define_method(RG_TARGET_NAMESPACE, "lax_validation?", param_is_G_PARAM_LAX_VALIDATION, 0);
+    rbg_define_method(RG_TARGET_NAMESPACE, "private?",        param_is_G_PARAM_PRIVATE, 0);
+    rbg_define_method(RG_TARGET_NAMESPACE, "readwrite?",      param_is_G_PARAM_READWRITE, 0);
 }

data/ext/glib2/rbgobj_paramspecs.c

@@ -235,14 +235,14 @@ Init_gobject_gparamspecs(void)
 
 #define DEF_NUMERIC_PSPEC_METHODS(c, typename) \
   G_STMT_START {\
-    rb_define_method(c, "initialize", typename##_initialize, 7); \
-    rb_define_method(c, "minimum", typename##_minimum, 0); \
-    rb_define_method(c, "maximum", typename##_maximum, 0); \
-    rb_define_method(c, "range", typename##_range, 0); \
+    rbg_define_method(c, "initialize", typename##_initialize, 7); \
+    rbg_define_method(c, "minimum", typename##_minimum, 0); \
+    rbg_define_method(c, "maximum", typename##_maximum, 0); \
+    rbg_define_method(c, "range", typename##_range, 0); \
   } G_STMT_END
 
 #if 0
-    rb_define_method(c, "default_value", typename##_default_value, 0); \
+    rbg_define_method(c, "default_value", typename##_default_value, 0); \
     rb_define_alias(c, "default", "default_value"); \
 
 #endif
@@ -273,39 +273,39 @@ Init_gobject_gparamspecs(void)
 
     c = G_DEF_CLASS(G_TYPE_PARAM_FLOAT, "Float", cParamSpec);
     DEF_NUMERIC_PSPEC_METHODS(c, float);
-    rb_define_method(c, "epsilon", float_epsilon, 0);
+    rbg_define_method(c, "epsilon", float_epsilon, 0);
 
     c = G_DEF_CLASS(G_TYPE_PARAM_DOUBLE, "Double", cParamSpec);
     DEF_NUMERIC_PSPEC_METHODS(c, double);
-    rb_define_method(c, "epsilon", double_epsilon, 0);
+    rbg_define_method(c, "epsilon", double_epsilon, 0);
 
     c = G_DEF_CLASS(G_TYPE_PARAM_BOOLEAN, "Boolean", cParamSpec);
-    rb_define_method(c, "initialize", boolean_initialize, 5);
+    rbg_define_method(c, "initialize", boolean_initialize, 5);
 
     c = G_DEF_CLASS(G_TYPE_PARAM_UNICHAR, "UniChar", cParamSpec);
-    rb_define_method(c, "initialize", unichar_initialize, 5);
+    rbg_define_method(c, "initialize", unichar_initialize, 5);
 
     c = G_DEF_CLASS(G_TYPE_PARAM_ENUM, "Enum", cParamSpec);
-    rb_define_method(c, "initialize", enum_initialize, 6);
+    rbg_define_method(c, "initialize", enum_initialize, 6);
 
     c = G_DEF_CLASS(G_TYPE_PARAM_FLAGS, "Flags", cParamSpec);
-    rb_define_method(c, "initialize", flags_initialize, 6);
+    rbg_define_method(c, "initialize", flags_initialize, 6);
 
     c = G_DEF_CLASS(G_TYPE_PARAM_STRING, "String", cParamSpec);
-    rb_define_method(c, "initialize", string_initialize, 5);
+    rbg_define_method(c, "initialize", string_initialize, 5);
 
     c = G_DEF_CLASS(G_TYPE_PARAM_PARAM, "Param", cParamSpec);
-    rb_define_method(c, "initialize", param_initialize, 5);
+    rbg_define_method(c, "initialize", param_initialize, 5);
 
     c = G_DEF_CLASS(G_TYPE_PARAM_BOXED, "Boxed", cParamSpec);
-    rb_define_method(c, "initialize", boxed_initialize, 5);
+    rbg_define_method(c, "initialize", boxed_initialize, 5);
 
     c = G_DEF_CLASS(G_TYPE_PARAM_POINTER, "Pointer", cParamSpec);
-    rb_define_method(c, "initialize", pointer_initialize, 4);
+    rbg_define_method(c, "initialize", pointer_initialize, 4);
 
     c = G_DEF_CLASS(G_TYPE_PARAM_VALUE_ARRAY, "ValueArray", cParamSpec);
-    rb_define_method(c, "initialize", value_array_initialize, 5);
+    rbg_define_method(c, "initialize", value_array_initialize, 5);
 
     c = G_DEF_CLASS(G_TYPE_PARAM_OBJECT, "Object", cParamSpec);
-    rb_define_method(c, "initialize", object_initialize, 5);
+    rbg_define_method(c, "initialize", object_initialize, 5);
 }

data/ext/glib2/rbgobj_signal.c

@@ -294,7 +294,7 @@ static VALUE
 gobj_sig_connect_impl(gboolean after, int argc, VALUE *argv, VALUE self)
 {
     VALUE sig, rest;
-    int i;
+    gulong handler_id;
     GClosure* rclosure;
     const char* sig_name;
     guint signal_id;
@@ -325,9 +325,10 @@ gobj_sig_connect_impl(gboolean after, int argc, VALUE *argv, VALUE self)
                           sig_name);
     g_rclosure_set_tag((GClosure *)rclosure, tag);
     g_free(tag);
-    i = g_signal_connect_closure_by_id(g_object, signal_id, detail, rclosure, after);
+    handler_id = g_signal_connect_closure_by_id(g_object, signal_id, detail,
+                                                rclosure, after);
 
-    return INT2FIX(i);
+    return ULONG2NUM(handler_id);
 }
 
 static VALUE
@@ -644,7 +645,7 @@ gobj_s_method_added(VALUE klass, VALUE id)
     {
         VALUE mod = rb_define_module_under(klass, RubyGObjectHookModule);
         rb_include_module(klass, mod);
-        rb_define_method(mod, name, gobj_sig_chain_from_overridden, -1);
+        rbg_define_method(mod, name, gobj_sig_chain_from_overridden, -1);
     }
 
     return Qnil;
@@ -917,13 +918,13 @@ Init_gobject_gsignal(void)
     rb_define_const(cSignalFlags, "MASK", INT2NUM(G_SIGNAL_FLAGS_MASK));
     rb_define_const(RG_TARGET_NAMESPACE, "FLAGS_MASK", INT2NUM(G_SIGNAL_FLAGS_MASK));
 
-    rb_define_method(RG_TARGET_NAMESPACE, "run_first?", query_is_G_SIGNAL_RUN_FIRST, 0);
-    rb_define_method(RG_TARGET_NAMESPACE, "run_last?", query_is_G_SIGNAL_RUN_LAST, 0);
-    rb_define_method(RG_TARGET_NAMESPACE, "run_cleanup?", query_is_G_SIGNAL_RUN_CLEANUP, 0);
-    rb_define_method(RG_TARGET_NAMESPACE, "no_recurse?", query_is_G_SIGNAL_NO_RECURSE, 0);
-    rb_define_method(RG_TARGET_NAMESPACE, "detailed?", query_is_G_SIGNAL_DETAILED, 0);
-    rb_define_method(RG_TARGET_NAMESPACE, "action?", query_is_G_SIGNAL_ACTION, 0);
-    rb_define_method(RG_TARGET_NAMESPACE, "no_hooks?", query_is_G_SIGNAL_NO_HOOKS, 0);
+    rbg_define_method(RG_TARGET_NAMESPACE, "run_first?", query_is_G_SIGNAL_RUN_FIRST, 0);
+    rbg_define_method(RG_TARGET_NAMESPACE, "run_last?", query_is_G_SIGNAL_RUN_LAST, 0);
+    rbg_define_method(RG_TARGET_NAMESPACE, "run_cleanup?", query_is_G_SIGNAL_RUN_CLEANUP, 0);
+    rbg_define_method(RG_TARGET_NAMESPACE, "no_recurse?", query_is_G_SIGNAL_NO_RECURSE, 0);
+    rbg_define_method(RG_TARGET_NAMESPACE, "detailed?", query_is_G_SIGNAL_DETAILED, 0);
+    rbg_define_method(RG_TARGET_NAMESPACE, "action?", query_is_G_SIGNAL_ACTION, 0);
+    rbg_define_method(RG_TARGET_NAMESPACE, "no_hooks?", query_is_G_SIGNAL_NO_HOOKS, 0);
 
     /* GConnectFlags */
     G_DEF_CLASS(G_TYPE_CONNECT_FLAGS, "ConnectFlags", mGLib);
@@ -943,35 +944,35 @@ Init_gobject_gsignal(void)
     signal_func_table = rb_hash_new();
     rb_global_variable(&signal_func_table);
 
-    rb_define_method(mMetaInterface, "signal_new", gobj_s_signal_new, -1);
-    rb_define_method(mMetaInterface, "signals", gobj_s_signals, -1);
-    rb_define_method(mMetaInterface, "signal", gobj_s_signal, 1);
+    rbg_define_method(mMetaInterface, "signal_new", gobj_s_signal_new, -1);
+    rbg_define_method(mMetaInterface, "signals", gobj_s_signals, -1);
+    rbg_define_method(mMetaInterface, "signal", gobj_s_signal, 1);
 
-    rb_define_method(cInstantiatable, "signal_has_handler_pending?",
+    rbg_define_method(cInstantiatable, "signal_has_handler_pending?",
                      gobj_sig_has_handler_pending, -1);
-    rb_define_method(cInstantiatable, "signal_connect", gobj_sig_connect, -1);
-    rb_define_method(cInstantiatable, "signal_connect_after",
+    rbg_define_method(cInstantiatable, "signal_connect", gobj_sig_connect, -1);
+    rbg_define_method(cInstantiatable, "signal_connect_after",
                      gobj_sig_connect_after, -1);
 
 #if 0
-    rb_define_method(cInstantiatable, "signal_invocation_hint",
+    rbg_define_method(cInstantiatable, "signal_invocation_hint",
                      gobj_sig_get_invocation_hint, 0);
 #endif
 
-    rb_define_method(cInstantiatable, "signal_emit",
+    rbg_define_method(cInstantiatable, "signal_emit",
                      gobj_sig_emit, -1);
-    rb_define_method(cInstantiatable, "signal_emit_stop",
+    rbg_define_method(cInstantiatable, "signal_emit_stop",
                      gobj_sig_emit_stop, 1);
-    rb_define_method(cInstantiatable, "signal_handler_block",
+    rbg_define_method(cInstantiatable, "signal_handler_block",
                      gobj_sig_handler_block, 1);
-    rb_define_method(cInstantiatable, "signal_handler_unblock",
+    rbg_define_method(cInstantiatable, "signal_handler_unblock",
                      gobj_sig_handler_unblock, 1);
-    rb_define_method(cInstantiatable, "signal_handler_disconnect",
+    rbg_define_method(cInstantiatable, "signal_handler_disconnect",
                      gobj_sig_handler_disconnect, 1);
 
-    rb_define_method(cInstantiatable, "signal_handler_is_connected?",
+    rbg_define_method(cInstantiatable, "signal_handler_is_connected?",
                      gobj_sig_handler_is_connected, 1);
 
-    rb_define_singleton_method(cInstantiatable, "method_added",
+    rbg_define_singleton_method(cInstantiatable, "method_added",
                                gobj_s_method_added, 1);
-}
+}

data/ext/glib2/rbgobj_typeinterface.c

@@ -143,7 +143,7 @@ void
 Init_gobject_typeinterface(void)
 {
     RG_TARGET_NAMESPACE = rb_define_module_under(mGLib, "MetaInterface");
-    rb_define_method(RG_TARGET_NAMESPACE, "gtype", generic_s_gtype, 0);
+    rbg_define_method(RG_TARGET_NAMESPACE, "gtype", generic_s_gtype, 0);
     RG_DEF_METHOD(append_features, 1);
 #if GLIB_CHECK_VERSION(2,4,0)
     RG_DEF_METHOD(install_property, 1);
@@ -152,4 +152,4 @@ Init_gobject_typeinterface(void)
 #endif
 
     rbgobj_mInterface = G_DEF_INTERFACE(G_TYPE_INTERFACE, "Interface", mGLib);
-}
+}

data/ext/glib2/rbgobj_valuetypes.c

@@ -111,13 +111,13 @@ static void
 Init_gtype_pointer(void)
 {
     VALUE cPtr = G_DEF_CLASS(G_TYPE_POINTER, "Pointer", mGLib);
-    rb_define_singleton_method(cPtr, "gtype", ptr_s_gtype, 1);
-    rb_define_method(cPtr, "gtype", ptr_gtype, 1);
+    rbg_define_singleton_method(cPtr, "gtype", ptr_s_gtype, 1);
+    rbg_define_method(cPtr, "gtype", ptr_gtype, 1);
 #ifndef RBGOBJ_USE_DLPTR
-    rb_define_method(cPtr, "inspect", ptr_inspect, 0);
-    rb_define_method(cPtr, "==", ptr_eql, 1);
-    rb_define_method(cPtr, "eql?", ptr_eql, 1);
-    rb_define_method(cPtr, "hash", ptr_hash, 0);
+    rbg_define_method(cPtr, "inspect", ptr_inspect, 0);
+    rbg_define_method(cPtr, "==", ptr_eql, 1);
+    rbg_define_method(cPtr, "eql?", ptr_eql, 1);
+    rbg_define_method(cPtr, "hash", ptr_hash, 0);
 #endif
 }
 

data/ext/glib2/rbgutil.h

@@ -42,7 +42,7 @@ extern "C" {
 #define RG_DEF_MODFUNC_OPERATOR(ope, func, argc) \
         rb_define_module_function(RG_TARGET_NAMESPACE, ope, rg_m_operator_ ## func, argc)
 #define RG_DEF_SMETHOD(method, argc) \
-        rb_define_singleton_method(RG_TARGET_NAMESPACE, #method, rg_s_ ## method, argc)
+        rbg_define_singleton_method(RG_TARGET_NAMESPACE, #method, rg_s_ ## method, argc)
 #define RG_DEF_SMETHOD_P(method, argc) \
         rb_define_singleton_method(RG_TARGET_NAMESPACE, #method"?", rg_s_ ## method ## _p, argc)
 #define RG_DEF_SMETHOD_BANG(method, argc) \
@@ -50,7 +50,7 @@ extern "C" {
 #define RG_DEF_SMETHOD_OPERATOR(ope, func, argc) \
         rb_define_singleton_method(RG_TARGET_NAMESPACE, ope, rg_s_operator_ ## func, argc)
 #define RG_DEF_METHOD(method, argc) \
-        rb_define_method(RG_TARGET_NAMESPACE, #method, rg_ ## method, argc)
+        rbg_define_method(RG_TARGET_NAMESPACE, #method, rg_ ## method, argc)
 #define RG_DEF_METHOD_P(method, argc) \
         rb_define_method(RG_TARGET_NAMESPACE, #method"?", rg_ ## method ## _p, argc)
 #define RG_DEF_METHOD_BANG(method, argc) \

data/lib/glib-mkenums.rb

@@ -40,7 +40,7 @@ module GLib
       end
       constants = []
       const_lines.scan(/^\s*([^\s,]*).*\n/) do |name|
-        constants << name[0] unless name[0] =~ /(^[\/\*]|^$)/
+        constants << name[0] unless name[0] =~ /(^[\/\*]|^#|^$)/
       end
       @prefix = extract_prefix(constants)
       constants.each do |name|