glib2 3.3.9 → 3.4.4

data/ext/glib2/rbgobj_param.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2011-2019  Ruby-GNOME Project Team
+ *  Copyright (C) 2011-2021  Ruby-GNOME Project Team
  *  Copyright (C) 2002,2003  Masahiro Sakai
  *
  *  This library is free software; you can redistribute it and/or
@@ -276,7 +276,7 @@ rg_value_convert(int argc, VALUE* argv, VALUE self)
     rb_scan_args(argc, argv, "21", &src, &src_type, &strict_validation);
 
     /* FIXME: use rb_ensure to ensure following g_value_unset() call*/
-    g_value_init(&src_value, rbgobj_gtype_get(src_type));
+    g_value_init(&src_value, rbgobj_gtype_from_ruby(src_type));
     g_value_init(&dest_value, G_PARAM_SPEC_VALUE_TYPE(pspec));
 
     rbgobj_rvalue_to_gvalue(src, &src_value);
@@ -344,9 +344,7 @@ param_is_flag(G_PARAM_LAX_VALIDATION)
 param_is_flag(G_PARAM_STATIC_NAME)
 param_is_flag(G_PARAM_STATIC_NICK)
 param_is_flag(G_PARAM_STATIC_BLURB)
-#if GLIB_CHECK_VERSION(2, 42, 0)
 param_is_flag(G_PARAM_EXPLICIT_NOTIFY)
-#endif
 param_is_flag(G_PARAM_DEPRECATED)
 
 /**********************************************************************/
@@ -376,10 +374,8 @@ Init_gobject_gparam(void)
                     INT2FIX(G_PARAM_STATIC_NICK));
     rb_define_const(RG_TARGET_NAMESPACE, "STATIC_BLURB",
                     INT2FIX(G_PARAM_STATIC_BLURB));
-#if GLIB_CHECK_VERSION(2, 42, 0)
     rb_define_const(RG_TARGET_NAMESPACE, "EXPLICIT_NOTIFY",
                     INT2FIX(G_PARAM_EXPLICIT_NOTIFY));
-#endif
     rb_define_const(RG_TARGET_NAMESPACE, "DEPRECATED",
                     INT2FIX(G_PARAM_DEPRECATED));
     rb_define_const(RG_TARGET_NAMESPACE, "MASK",
@@ -432,10 +428,8 @@ Init_gobject_gparam(void)
                       param_is_G_PARAM_STATIC_NICK, 0);
     rbg_define_method(RG_TARGET_NAMESPACE, "static_blurb?",
                       param_is_G_PARAM_STATIC_BLURB, 0);
-#if GLIB_CHECK_VERSION(2, 42, 0)
     rbg_define_method(RG_TARGET_NAMESPACE, "explicit_notify?",
                       param_is_G_PARAM_EXPLICIT_NOTIFY, 0);
-#endif
     rbg_define_method(RG_TARGET_NAMESPACE, "deprecated?",
                       param_is_G_PARAM_DEPRECATED, 0);
 }

data/ext/glib2/rbgobj_paramspecs.c

@@ -1,7 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2011  Ruby-GNOME2 Project Team
- *  Copyright (C) 2004  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2004-2021  Ruby-GNOME Project Team
  *  Copyright (C) 2002,2003  Masahiro Sakai
  *
  *  This library is free software; you can redistribute it and/or
@@ -116,7 +115,7 @@ enum_initialize(VALUE self, VALUE name, VALUE nick, VALUE blurb,
                 VALUE enum_type, VALUE default_value, VALUE flags)
 {
     GParamSpec* pspec;
-    GType gtype = rbgobj_gtype_get(enum_type);
+    GType gtype = rbgobj_gtype_from_ruby(enum_type);
 
     pspec = g_param_spec_enum(StringValuePtr(name),
                               StringValuePtr(nick),
@@ -133,7 +132,7 @@ flags_initialize(VALUE self, VALUE name, VALUE nick, VALUE blurb,
                  VALUE flags_type, VALUE default_value, VALUE flags)
 {
     GParamSpec* pspec;
-    GType gtype = rbgobj_gtype_get(flags_type);
+    GType gtype = rbgobj_gtype_from_ruby(flags_type);
 
     pspec = g_param_spec_flags(StringValuePtr(name),
                               StringValuePtr(nick),
@@ -167,7 +166,7 @@ param_initialize(VALUE self, VALUE name, VALUE nick, VALUE blurb,
     pspec = g_param_spec_param(StringValuePtr(name),
                                StringValuePtr(nick),
                                StringValuePtr(blurb),
-                               rbgobj_gtype_get(param_type),
+                               rbgobj_gtype_from_ruby(param_type),
                                NUM2UINT(flags));
     rbgobj_param_spec_initialize(self, pspec);
     return Qnil;
@@ -181,7 +180,7 @@ boxed_initialize(VALUE self, VALUE name, VALUE nick, VALUE blurb,
     pspec = g_param_spec_boxed(StringValuePtr(name),
                                StringValuePtr(nick),
                                StringValuePtr(blurb),
-                               rbgobj_gtype_get(boxed_type),
+                               rbgobj_gtype_from_ruby(boxed_type),
                                NUM2UINT(flags));
     rbgobj_param_spec_initialize(self, pspec);
     return Qnil;
@@ -199,20 +198,6 @@ pointer_initialize(VALUE self, VALUE name, VALUE nick, VALUE blurb, VALUE flags)
     return Qnil;
 }
 
-static VALUE
-value_array_initialize(VALUE self, VALUE name, VALUE nick, VALUE blurb,
-                       VALUE element_spec, VALUE flags)
-{
-    GParamSpec* pspec;
-    pspec = g_param_spec_value_array(StringValuePtr(name),
-                                     StringValuePtr(nick),
-                                     StringValuePtr(blurb),
-                                     RVAL2GOBJ(element_spec),
-                                     NUM2UINT(flags));
-    rbgobj_param_spec_initialize(self, pspec);
-    return Qnil;
-}
-
 static VALUE
 object_initialize(VALUE self, VALUE name, VALUE nick, VALUE blurb,
                   VALUE object_type, VALUE flags)
@@ -221,7 +206,7 @@ object_initialize(VALUE self, VALUE name, VALUE nick, VALUE blurb,
     pspec = g_param_spec_object(StringValuePtr(name),
                                 StringValuePtr(nick),
                                 StringValuePtr(blurb),
-                                rbgobj_gtype_get(object_type),
+                                rbgobj_gtype_from_ruby(object_type),
                                 NUM2UINT(flags));
     rbgobj_param_spec_initialize(self, pspec);
     return Qnil;
@@ -303,9 +288,6 @@ Init_gobject_gparamspecs(void)
     c = G_DEF_CLASS(G_TYPE_PARAM_POINTER, "Pointer", cParamSpec);
     rbg_define_method(c, "initialize", pointer_initialize, 4);
 
-    c = G_DEF_CLASS(G_TYPE_PARAM_VALUE_ARRAY, "ValueArray", cParamSpec);
-    rbg_define_method(c, "initialize", value_array_initialize, 5);
-
     c = G_DEF_CLASS(G_TYPE_PARAM_OBJECT, "Object", cParamSpec);
     rbg_define_method(c, "initialize", object_initialize, 5);
 }

data/ext/glib2/rbgobj_signal.c

@@ -1,7 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2011-2019  Ruby-GNOME Project Team
- *  Copyright (C) 2002-2004  Ruby-GNOME Project Team
+ *  Copyright (C) 2002-2021  Ruby-GNOME Project Team
  *  Copyright (C) 2002,2003  Masahiro Sakai
  *
  *  This library is free software; you can redistribute it and/or
@@ -64,45 +63,57 @@ rbgobj_signal_get_raw(VALUE rb_signal)
     return query;
 }
 
-static VALUE signal_func_table;
+static GHashTable *rbg_signal_func_table;
+static GMutex rbg_signal_func_table_mutex;
 
 void
-rbgobj_set_signal_func(VALUE klass, const gchar *sig_name, GValToRValSignalFunc func)
+rbgobj_set_signal_func(VALUE klass,
+                       const gchar *signal_name,
+                       GValToRValSignalFunc func)
 {
-    VALUE obj = Data_Wrap_Struct(rb_cData, NULL, NULL, func);
-    guint signal_id = g_signal_lookup(sig_name, CLASS2GTYPE(klass));
-    rb_hash_aset(signal_func_table, UINT2NUM(signal_id), obj);
+    guint signal_id = g_signal_lookup(signal_name, CLASS2GTYPE(klass));
+    g_mutex_lock(&rbg_signal_func_table_mutex);
+    g_hash_table_insert(rbg_signal_func_table,
+                        GUINT_TO_POINTER(signal_id),
+                        func);
+    g_mutex_unlock(&rbg_signal_func_table_mutex);
 }
 
 GValToRValSignalFunc
 rbgobj_get_signal_func(guint signal_id)
 {
-    GValToRValSignalFunc func = NULL;
-    VALUE func_obj = rb_hash_aref(signal_func_table, UINT2NUM(signal_id));
-    if (!NIL_P(func_obj))
-        Data_Get_Struct(func_obj, void, func);
+    g_mutex_lock(&rbg_signal_func_table_mutex);
+    GValToRValSignalFunc func =
+        g_hash_table_lookup(rbg_signal_func_table,
+                            GUINT_TO_POINTER(signal_id));
+    g_mutex_unlock(&rbg_signal_func_table_mutex);
     return func;
 }
 
-static VALUE signal_call_func_table;
+static GHashTable *rbg_signal_call_func_table;
+static GMutex rbg_signal_call_func_table_mutex;
 
 void
 rbgobj_set_signal_call_func(VALUE klass,
                             const gchar *signal_name,
                             RGClosureCallFunc func)
 {
-    VALUE obj = Data_Wrap_Struct(rb_cData, NULL, NULL, func);
     guint signal_id = g_signal_lookup(signal_name, CLASS2GTYPE(klass));
-    rb_hash_aset(signal_call_func_table, UINT2NUM(signal_id), obj);
+    g_mutex_lock(&rbg_signal_call_func_table_mutex);
+    g_hash_table_insert(rbg_signal_call_func_table,
+                        GUINT_TO_POINTER(signal_id),
+                        func);
+    g_mutex_unlock(&rbg_signal_call_func_table_mutex);
 }
 
 RGClosureCallFunc
 rbgobj_get_signal_call_func(guint signal_id)
 {
-    RGClosureCallFunc func = NULL;
-    VALUE func_obj = rb_hash_aref(signal_call_func_table, UINT2NUM(signal_id));
-    if (!NIL_P(func_obj))
-        Data_Get_Struct(func_obj, void, func);
+    g_mutex_lock(&rbg_signal_call_func_table_mutex);
+    RGClosureCallFunc func =
+        g_hash_table_lookup(rbg_signal_call_func_table,
+                            GUINT_TO_POINTER(signal_id));
+    g_mutex_unlock(&rbg_signal_call_func_table_mutex);
     return func;
 }
 
@@ -150,7 +161,7 @@ rbg_rval2gtypes_body(VALUE value)
     struct rval2gtypes_args *args = (struct rval2gtypes_args *)value;
 
     for (i = 0; i < args->n; i++)
-        args->result[i] = rbgobj_gtype_get(RARRAY_PTR(args->ary)[i]);
+        args->result[i] = rbgobj_gtype_from_ruby(RARRAY_PTR(args->ary)[i]);
 
     return Qnil;
 }
@@ -240,7 +251,7 @@ gobj_s_define_signal(int argc, VALUE* argv, VALUE self)
         g_rclosure_set_tag(class_closure, RVAL2CSTR(rb_method_name));
     }
 
-    return_type = rbgobj_gtype_get(rbreturn_type);
+    return_type = rbgobj_gtype_from_ruby(rbreturn_type);
     param_types = RVAL2GTYPES_ACCEPT_NIL(params, n_params);
 
     signal = g_signal_newv(signal_name,
@@ -440,30 +451,33 @@ struct emit_arg {
 
     GSignalQuery query;
     GQuark detail;
-    GValueArray* instance_and_params;
+    GArray *instance_and_params;
 };
 
 static VALUE
 emit_body(VALUE rb_arg)
 {
     struct emit_arg *arg = (struct emit_arg *)rb_arg;
-    GValue param = G_VALUE_INIT;
 
-    g_value_init(&param, G_TYPE_FROM_INSTANCE(RVAL2GOBJ(arg->self)));
-    rbgobj_rvalue_to_gvalue(arg->self, &param);
-    g_value_array_append(arg->instance_and_params, &param);
-    g_value_unset(&param);
+    gsize value_index = 0;
+    GValue *gself = &g_array_index(arg->instance_and_params,
+                                   GValue,
+                                   value_index);
+    g_value_init(gself, G_TYPE_FROM_INSTANCE(RVAL2GOBJ(arg->self)));
+    rbgobj_rvalue_to_gvalue(arg->self, gself);
+    value_index++;
 
     {
         guint i;
         for (i = 0; i < arg->query.n_params; i++){
             GType gtype = arg->query.param_types[i] & ~G_SIGNAL_TYPE_STATIC_SCOPE;
 
-            g_value_init(&param,  gtype);
-
-            rbgobj_rvalue_to_gvalue(rb_ary_entry(arg->args, i), &param);
-            g_value_array_append(arg->instance_and_params, &param);
-            g_value_unset(&param);
+            GValue *gparam = &g_array_index(arg->instance_and_params,
+                                            GValue,
+                                            value_index);
+            g_value_init(gparam,  gtype);
+            rbgobj_rvalue_to_gvalue(rb_ary_entry(arg->args, i), gparam);
+            value_index++;
         }
     }
 
@@ -475,7 +489,7 @@ emit_body(VALUE rb_arg)
             g_value_init(&return_value,
                          arg->query.return_type & ~G_SIGNAL_TYPE_STATIC_SCOPE);
 
-        g_signal_emitv(arg->instance_and_params->values,
+        g_signal_emitv((GValue *)(arg->instance_and_params->data),
                        arg->query.signal_id, arg->detail,
                        (use_ret) ? &return_value : NULL);
 
@@ -493,7 +507,7 @@ static VALUE
 emit_ensure(VALUE rb_arg)
 {
     struct emit_arg *arg = (struct emit_arg *)rb_arg;
-    g_value_array_free(arg->instance_and_params);
+    g_array_unref(arg->instance_and_params);
     return Qnil;
 }
 
@@ -525,7 +539,13 @@ gobj_sig_emit(int argc, VALUE *argv, VALUE self)
                  arg.query.n_params + 1);
 
     arg.self = self;
-    arg.instance_and_params = g_value_array_new(1 + arg.query.n_params);
+    arg.instance_and_params = g_array_sized_new(FALSE,
+                                                TRUE,
+                                                sizeof(GValue),
+                                                1 + arg.query.n_params);
+    g_array_set_clear_func(arg.instance_and_params,
+                           (GDestroyNotify)g_value_unset);
+    g_array_set_size(arg.instance_and_params, 1 + arg.query.n_params);
 
     return rb_ensure(emit_body, (VALUE)&arg, emit_ensure, (VALUE)&arg);
 }
@@ -628,17 +648,24 @@ static VALUE
 chain_from_overridden_body(VALUE rb_arg)
 {
     struct emit_arg *arg = (struct emit_arg *)rb_arg;
-    g_value_init(arg->instance_and_params->values,
-                 G_TYPE_FROM_INSTANCE(RVAL2GOBJ(arg->self)));
-    rbgobj_rvalue_to_gvalue(arg->self, arg->instance_and_params->values);
+    gsize value_index = 0;
+    GValue *gself = &g_array_index(arg->instance_and_params,
+                                   GValue,
+                                   value_index);
+    g_value_init(gself, G_TYPE_FROM_INSTANCE(RVAL2GOBJ(arg->self)));
+    rbgobj_rvalue_to_gvalue(arg->self, gself);
+    value_index++;
 
     {
-        GValue* params = arg->instance_and_params->values + 1;
         guint i;
         for (i = 0; i < arg->query.n_params; i++) {
             GType gtype = arg->query.param_types[i] & ~G_SIGNAL_TYPE_STATIC_SCOPE;
-            g_value_init(params + i, gtype);
-            rbgobj_rvalue_to_gvalue(rb_ary_entry(arg->args, i), params + i);
+            GValue *gparam = &g_array_index(arg->instance_and_params,
+                                            GValue,
+                                            value_index);
+            g_value_init(gparam, gtype);
+            rbgobj_rvalue_to_gvalue(rb_ary_entry(arg->args, i), gparam);
+            value_index++;
         }
     }
 
@@ -650,7 +677,7 @@ chain_from_overridden_body(VALUE rb_arg)
             g_value_init(&return_value,
                          arg->query.return_type & ~G_SIGNAL_TYPE_STATIC_SCOPE);
 
-        g_signal_chain_from_overridden(arg->instance_and_params->values,
+        g_signal_chain_from_overridden((GValue *)(arg->instance_and_params->data),
                                        (use_ret) ? &return_value : NULL);
 
         if (use_ret) {
@@ -682,7 +709,13 @@ gobj_sig_chain_from_overridden(int argc, VALUE *argv, VALUE self)
 
     arg.self = self;
     arg.args = rb_ary_new4(argc, argv);
-    arg.instance_and_params = g_value_array_new(1 + argc);
+    arg.instance_and_params = g_array_sized_new(FALSE,
+                                                TRUE,
+                                                sizeof(GValue),
+                                                1 + argc);
+    g_array_set_clear_func(arg.instance_and_params,
+                           (GDestroyNotify)g_value_unset);
+    g_array_set_size(arg.instance_and_params, 1 + argc);
 
     return rb_ensure(chain_from_overridden_body, (VALUE)&arg,
                      emit_ensure, (VALUE)&arg);
@@ -699,7 +732,7 @@ gobj_s_method_added(VALUE klass, VALUE id)
     if (cinfo->klass != klass) return Qnil;
     if (strncmp(default_handler_method_prefix, name, prefix_len)) return Qnil;
 
-    signal_id = g_signal_lookup(name + prefix_len, cinfo->gtype);    
+    signal_id = g_signal_lookup(name + prefix_len, cinfo->gtype);
     if (!signal_id) return Qnil;
 
     {
@@ -947,7 +980,7 @@ Init_gobject_gsignal(void)
 {
     VALUE cSignalFlags, cSignalMatchType;
 
-    RG_TARGET_NAMESPACE = rb_define_class_under(mGLib, "Signal", rb_cData);
+    RG_TARGET_NAMESPACE = rb_define_class_under(mGLib, "Signal", rb_cObject);
 
     RG_DEF_METHOD(id, 0);
     RG_DEF_METHOD(name, 0);
@@ -990,11 +1023,11 @@ Init_gobject_gsignal(void)
 
     eNoSignalError = rb_define_class_under(mGLib, "NoSignalError", rb_eNameError);
 
-    signal_func_table = rb_hash_new();
-    rb_global_variable(&signal_func_table);
+    rbg_signal_func_table = g_hash_table_new(g_direct_hash, g_direct_equal);
+    g_mutex_init(&rbg_signal_func_table_mutex);
 
-    signal_call_func_table = rb_hash_new();
-    rb_global_variable(&signal_call_func_table);
+    rbg_signal_call_func_table = g_hash_table_new(g_direct_hash, g_direct_equal);
+    g_mutex_init(&rbg_signal_call_func_table_mutex);
 
     rbg_define_method(mMetaInterface, "define_signal", gobj_s_define_signal, -1);
     rb_define_alias(mMetaInterface, "signal_new", "define_signal");

data/ext/glib2/rbgobj_strv.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2011-2020  Ruby-GNOME Project Team
  *  Copyright (C) 2005  Masao Mutoh
  *
  *  This library is free software; you can redistribute it and/or
@@ -30,7 +30,7 @@ strv_to_ruby(const GValue *from)
 static void
 strv_from_ruby(VALUE from, GValue *to)
 {
-    const gchar **strings = RVAL2STRV(from);
+    gchar **strings = RVAL2STRV(from);
     g_value_set_boxed(to, strings);
     g_free(strings);
 }

data/ext/glib2/rbgobj_type.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2002-2019  Ruby-GNOME Project Team
+ *  Copyright (C) 2002-2021  Ruby-GNOME Project Team
  *  Copyright (C) 2002,2003  Masahiro Sakai
  *
  *  This library is free software; you can redistribute it and/or
@@ -31,9 +31,10 @@ static VALUE rb_cMutex;
 #endif
 static VALUE lookup_class_mutex;
 
+static ID id_gtype;
+static ID id_lock;
 static ID id_new;
 static ID id_superclass;
-static ID id_lock;
 static ID id_unlock;
 static GHashTable *gtype_to_cinfo;
 static VALUE klass_to_cinfo;
@@ -110,7 +111,7 @@ rbgobj_class_info_create_data_type(VALUE klass)
     if (RB_TYPE_P(klass, RUBY_T_CLASS) && klass != rb_cObject) {
         VALUE p = RCLASS_SUPER(klass);
         while (p != rb_cObject) {
-            if (RTYPEDDATA_P(p)) {
+            if (RB_TYPE_P(p, RUBY_T_DATA) && RTYPEDDATA_P(p)) {
                 data_type->parent = RTYPEDDATA_TYPE(p);
                 break;
             }
@@ -133,7 +134,7 @@ rbgobj_class_info_register_without_lock(GType gtype, VALUE klass)
     VALUE c;
 
     data_type = rbgobj_class_info_create_data_type(klass);
-    c = TypedData_Make_Struct(rb_cData, RGObjClassInfo, data_type, cinfo);
+    c = TypedData_Make_Struct(rb_cObject, RGObjClassInfo, data_type, cinfo);
     cinfo->klass = klass;
     cinfo->gtype = gtype;
     cinfo->mark  = NULL;
@@ -238,9 +239,7 @@ get_superclass(GType gtype, VALUE module)
       case G_TYPE_OBJECT:
         return cInstantiatable;
       case G_TYPE_BOXED:
-        return rb_cObject;
       case G_TYPE_POINTER:
-        return rb_cData;
       case G_TYPE_ENUM:
       case G_TYPE_FLAGS:
         return rb_cObject;
@@ -432,9 +431,9 @@ rbgobj_gtype_to_ruby_class(GType gtype)
 GType
 rbgobj_gtype_from_ruby(VALUE rb_gtype)
 {
-    ID id_gtype;
-
-    if (RB_TYPE_P(rb_gtype, RUBY_T_STRING)) {
+    if (NIL_P(rb_gtype)) {
+        return G_TYPE_NONE;
+    } else if (RB_TYPE_P(rb_gtype, RUBY_T_STRING)) {
         GType gtype;
         gtype = g_type_from_name(RVAL2CSTR(rb_gtype));
         if (gtype == G_TYPE_INVALID) {
@@ -443,14 +442,13 @@ rbgobj_gtype_from_ruby(VALUE rb_gtype)
                      RVAL2CSTR(rb_gtype));
         }
         return gtype;
+    } else if (RVAL2CBOOL(rb_obj_is_kind_of(rb_gtype, RG_TARGET_NAMESPACE))) {
+        return NUM2SIZET(rb_ivar_get(rb_gtype, id_gtype));
+    } else if (RVAL2CBOOL(rb_obj_is_kind_of(rb_gtype, rb_cClass))) {
+        return CLASS2GTYPE(rb_gtype);
+    } else {
+        return NUM2SIZET(rb_to_int(rb_gtype));
     }
-
-    CONST_ID(id_gtype, "gtype");
-    if (rb_respond_to(rb_gtype, id_gtype)) {
-        rb_gtype = rb_funcall(rb_gtype, id_gtype, 0);
-    }
-
-    return NUM2ULONG(rb_gtype);
 }
 
 VALUE
@@ -532,7 +530,7 @@ rbgobj_register_class(VALUE klass,
 
     if (klass2gtype) {
         data_type = rbgobj_class_info_create_data_type(klass);
-        c = TypedData_Make_Struct(rb_cData, RGObjClassInfo, data_type, cinfo);
+        c = TypedData_Make_Struct(rb_cObject, RGObjClassInfo, data_type, cinfo);
     }
     if (gtype2klass && !cinfo)
         cinfo = g_new(RGObjClassInfo, 1);
@@ -607,26 +605,21 @@ init_typemap(void)
 /* GLib::Type */
 
 VALUE RG_TARGET_NAMESPACE;
-static ID id_gtype;
 
 VALUE
 rbgobj_gtype_new(GType gtype)
 {
     VALUE result = rb_obj_alloc(RG_TARGET_NAMESPACE);
-    VALUE arg = ULONG2NUM(gtype);
+    VALUE arg = SIZET2NUM(gtype);
     rb_obj_call_init(result, 1, &arg);
     return result;
 }
 
+/* Deprecated. Use rbgobj_gtype_from_ruby() instead. */
 GType
-rbgobj_gtype_get(VALUE self)
+rbgobj_gtype_get(VALUE rb_gtype)
 {
-    if (RVAL2CBOOL(rb_obj_is_kind_of(self, RG_TARGET_NAMESPACE))) {
-        return NUM2ULONG(rb_ivar_get(self, id_gtype));
-    } else {
-        return CLASS2GTYPE(self);
-    }
-    rb_raise(rb_eTypeError, "Not a GLib::Type");
+    return rbgobj_gtype_from_ruby(rb_gtype);
 }
 
 static VALUE
@@ -690,7 +683,7 @@ rg_initialize(VALUE self, VALUE type)
     GType gtype;
 
     if (RVAL2CBOOL(rb_obj_is_kind_of(type, rb_cInteger))) {
-        gtype = NUM2ULONG(type);
+        gtype = NUM2SIZET(type);
         if (!g_type_name(gtype))
             gtype = G_TYPE_INVALID;
     } else {
@@ -700,7 +693,7 @@ rg_initialize(VALUE self, VALUE type)
     if (G_TYPE_INVALID == gtype)
         rb_raise(rb_eArgError, "invalid GType");
 
-    rb_ivar_set(self, id_gtype, ULONG2NUM(gtype));
+    rb_ivar_set(self, id_gtype, SIZET2NUM(gtype));
 
     return Qnil;
 }
@@ -708,7 +701,7 @@ rg_initialize(VALUE self, VALUE type)
 static VALUE
 rg_inspect(VALUE self)
 {
-    GType gtype = rbgobj_gtype_get(self);
+    GType gtype = rbgobj_gtype_from_ruby(self);
     gchar* str;
     VALUE result;
 
@@ -725,8 +718,8 @@ rg_operator_type_compare(VALUE self, VALUE other)
     if (!RVAL2CBOOL(rb_obj_is_kind_of(other, RG_TARGET_NAMESPACE)))
         return Qnil;
     else {
-        GType a = rbgobj_gtype_get(self);
-        GType b = rbgobj_gtype_get(other);
+        GType a = rbgobj_gtype_from_ruby(self);
+        GType b = rbgobj_gtype_from_ruby(other);
 
         if (a==b)
             return INT2FIX(0);
@@ -745,8 +738,8 @@ rg_operator_type_eq(VALUE self, VALUE other)
     if (!RVAL2CBOOL(rb_obj_is_kind_of(other, RG_TARGET_NAMESPACE)))
         return Qnil;
     else {
-        GType a = rbgobj_gtype_get(self);
-        GType b = rbgobj_gtype_get(other);
+        GType a = rbgobj_gtype_from_ruby(self);
+        GType b = rbgobj_gtype_from_ruby(other);
         return CBOOL2RVAL(a == b);
     }
 }
@@ -757,8 +750,8 @@ rg_operator_type_lt_eq(VALUE self, VALUE other)
     if (!RVAL2CBOOL(rb_obj_is_kind_of(other, RG_TARGET_NAMESPACE)))
         return Qnil;
     else {
-        GType a = rbgobj_gtype_get(self);
-        GType b = rbgobj_gtype_get(other);
+        GType a = rbgobj_gtype_from_ruby(self);
+        GType b = rbgobj_gtype_from_ruby(other);
         return CBOOL2RVAL(g_type_is_a(a, b));
     }
 }
@@ -769,8 +762,8 @@ rg_operator_type_gt_eq(VALUE self, VALUE other)
     if (!RVAL2CBOOL(rb_obj_is_kind_of(other, RG_TARGET_NAMESPACE)))
         return Qnil;
     else {
-        GType a = rbgobj_gtype_get(self);
-        GType b = rbgobj_gtype_get(other);
+        GType a = rbgobj_gtype_from_ruby(self);
+        GType b = rbgobj_gtype_from_ruby(other);
         return CBOOL2RVAL(g_type_is_a(b, a));
     }
 }
@@ -781,8 +774,8 @@ rg_operator_type_lt(VALUE self, VALUE other)
     if (!RVAL2CBOOL(rb_obj_is_kind_of(other, RG_TARGET_NAMESPACE)))
         return Qnil;
     else {
-        GType a = rbgobj_gtype_get(self);
-        GType b = rbgobj_gtype_get(other);
+        GType a = rbgobj_gtype_from_ruby(self);
+        GType b = rbgobj_gtype_from_ruby(other);
         return CBOOL2RVAL(g_type_is_a(a, b) && a != b);
     }
 }
@@ -793,8 +786,8 @@ rg_operator_type_gt(VALUE self, VALUE other)
     if (!RVAL2CBOOL(rb_obj_is_kind_of(other, RG_TARGET_NAMESPACE)))
         return Qnil;
     else {
-        GType a = rbgobj_gtype_get(self);
-        GType b = rbgobj_gtype_get(other);
+        GType a = rbgobj_gtype_from_ruby(self);
+        GType b = rbgobj_gtype_from_ruby(other);
         return CBOOL2RVAL(g_type_is_a(b, a) && a != b);
     }
 }
@@ -808,112 +801,113 @@ rg_hash(VALUE self)
 static VALUE
 rg_to_class(VALUE self)
 {
-    return GTYPE2CLASS(rbgobj_gtype_get(self));
+    return GTYPE2CLASS(rbgobj_gtype_from_ruby(self));
 }
 
 static VALUE
 rg_fundamental(VALUE self)
 {
-    return rbgobj_gtype_new(G_TYPE_FUNDAMENTAL(rbgobj_gtype_get(self)));
+    return rbgobj_gtype_new(G_TYPE_FUNDAMENTAL(rbgobj_gtype_from_ruby(self)));
 }
 
 static VALUE
 rg_fundamental_p(VALUE self)
 {
-    return CBOOL2RVAL(G_TYPE_IS_FUNDAMENTAL(rbgobj_gtype_get(self)));
+    return CBOOL2RVAL(G_TYPE_IS_FUNDAMENTAL(rbgobj_gtype_from_ruby(self)));
 }
 
 static VALUE
 rg_derived_p(VALUE self)
 {
-    return CBOOL2RVAL(G_TYPE_IS_DERIVED(rbgobj_gtype_get(self)));
+    return CBOOL2RVAL(G_TYPE_IS_DERIVED(rbgobj_gtype_from_ruby(self)));
 }
 
 static VALUE
 rg_interface_p(VALUE self)
 {
-    return CBOOL2RVAL(G_TYPE_IS_INTERFACE(rbgobj_gtype_get(self)));
+    return CBOOL2RVAL(G_TYPE_IS_INTERFACE(rbgobj_gtype_from_ruby(self)));
 }
 
 static VALUE
 rg_classed_p(VALUE self)
 {
-    return CBOOL2RVAL(G_TYPE_IS_CLASSED(rbgobj_gtype_get(self)));
+    return CBOOL2RVAL(G_TYPE_IS_CLASSED(rbgobj_gtype_from_ruby(self)));
 }
 
 static VALUE
 rg_instantiatable_p(VALUE self)
 {
-    return CBOOL2RVAL(G_TYPE_IS_INSTANTIATABLE(rbgobj_gtype_get(self)));
+    return CBOOL2RVAL(G_TYPE_IS_INSTANTIATABLE(rbgobj_gtype_from_ruby(self)));
 }
 
 static VALUE
 rg_derivable_p(VALUE self)
 {
-    return CBOOL2RVAL(G_TYPE_IS_DERIVABLE(rbgobj_gtype_get(self)));
+    return CBOOL2RVAL(G_TYPE_IS_DERIVABLE(rbgobj_gtype_from_ruby(self)));
 }
 
 static VALUE
 rg_deep_derivable_p(VALUE self)
 {
-    return CBOOL2RVAL(G_TYPE_IS_DEEP_DERIVABLE(rbgobj_gtype_get(self)));
+    return CBOOL2RVAL(G_TYPE_IS_DEEP_DERIVABLE(rbgobj_gtype_from_ruby(self)));
 }
 
 static VALUE
 rg_abstract_p(VALUE self)
 {
-    return CBOOL2RVAL(G_TYPE_IS_ABSTRACT(rbgobj_gtype_get(self)));
+    return CBOOL2RVAL(G_TYPE_IS_ABSTRACT(rbgobj_gtype_from_ruby(self)));
 }
 
 static VALUE
 rg_value_abstract_p(VALUE self)
 {
-    return CBOOL2RVAL(G_TYPE_IS_VALUE_ABSTRACT(rbgobj_gtype_get(self)));
+    return CBOOL2RVAL(G_TYPE_IS_VALUE_ABSTRACT(rbgobj_gtype_from_ruby(self)));
 }
 
 static VALUE
 rg_value_type_p(VALUE self)
 {
-    return CBOOL2RVAL(G_TYPE_IS_VALUE_TYPE(rbgobj_gtype_get(self)));
+    return CBOOL2RVAL(G_TYPE_IS_VALUE_TYPE(rbgobj_gtype_from_ruby(self)));
 }
 
 static VALUE
 rg_has_value_table(VALUE self)
 {
-    return CBOOL2RVAL(G_TYPE_HAS_VALUE_TABLE(rbgobj_gtype_get(self)));
+    return CBOOL2RVAL(G_TYPE_HAS_VALUE_TABLE(rbgobj_gtype_from_ruby(self)));
 }
 
 static VALUE
 rg_name(VALUE self)
 {
-    return rb_str_new2(g_type_name(rbgobj_gtype_get(self)));
+    return rb_str_new2(g_type_name(rbgobj_gtype_from_ruby(self)));
 }
 
 static VALUE
 rg_parent(VALUE self)
 {
-    GType parent = g_type_parent(rbgobj_gtype_get(self));
+    GType parent = g_type_parent(rbgobj_gtype_from_ruby(self));
     return parent ? rbgobj_gtype_new(parent) : Qnil;
 }
 
 static VALUE
 rg_depth(VALUE self)
 {
-    return UINT2NUM(g_type_depth(rbgobj_gtype_get(self)));
+    return UINT2NUM(g_type_depth(rbgobj_gtype_from_ruby(self)));
 }
 
 static VALUE
 rg_next_base(VALUE leaf_type, VALUE root_type)
 {
-    GType ret = g_type_next_base(rbgobj_gtype_get(leaf_type),
-                                 rbgobj_gtype_get(root_type));
+    GType ret = g_type_next_base(rbgobj_gtype_from_ruby(leaf_type),
+                                 rbgobj_gtype_from_ruby(root_type));
     return ret ? rbgobj_gtype_new(ret) : Qnil;
 }
 
 static VALUE
 rg_type_is_a_p(VALUE self, VALUE is_a_type)
 {
-    return CBOOL2RVAL(g_type_is_a(rbgobj_gtype_get(self), rbgobj_gtype_get(is_a_type)));
+    return CBOOL2RVAL(g_type_is_a(rbgobj_gtype_from_ruby(self),
+                                  rbgobj_gtype_from_ruby(is_a_type)));
 }
 
 #if 0
@@ -934,7 +928,7 @@ rg_children(VALUE self)
     VALUE result;
     guint i;
 
-    types = g_type_children(rbgobj_gtype_get(self), &n_children);
+    types = g_type_children(rbgobj_gtype_from_ruby(self), &n_children);
     result = rb_ary_new2(n_children);
     for (i = 0; i < n_children; i++)
         rb_ary_store(result, i, rbgobj_gtype_new(types[i]));
@@ -951,7 +945,7 @@ rg_interfaces(VALUE self)
     VALUE result;
     guint i;
 
-    types = g_type_interfaces(rbgobj_gtype_get(self), &n_interfaces);
+    types = g_type_interfaces(rbgobj_gtype_from_ruby(self), &n_interfaces);
     result = rb_ary_new2(n_interfaces);
     for (i = 0; i < n_interfaces; i++)
         rb_ary_store(result, i, rbgobj_gtype_new(types[i]));
@@ -964,7 +958,7 @@ static VALUE
 rg_class_size(VALUE self)
 {
     GTypeQuery query;
-    g_type_query(rbgobj_gtype_get(self), &query);
+    g_type_query(rbgobj_gtype_from_ruby(self), &query);
     return UINT2NUM(query.class_size);
 }
 
@@ -972,7 +966,7 @@ static VALUE
 rg_instance_size(VALUE self)
 {
     GTypeQuery query;
-    g_type_query(rbgobj_gtype_get(self), &query);
+    g_type_query(rbgobj_gtype_from_ruby(self), &query);
     return UINT2NUM(query.instance_size);
 }
 
@@ -989,10 +983,6 @@ _def_fundamental_type(VALUE ary, GType gtype, const char* name)
 void
 Init_gobject_gtype(void)
 {
-#if !GLIB_CHECK_VERSION(2, 35, 1)
-    g_type_init();
-#endif
-
     init_typemap();
 
     /* type */