glib2 3.5.1 → 4.0.0

data/ext/glib2/rbglib_spawn.c

@@ -217,7 +217,7 @@ rg_s_close_pid(G_GNUC_UNUSED VALUE self, VALUE pid)
 void
 Init_glib_spawn(void)
 {
-    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(mGLib, "Spawn");
+    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(rbg_mGLib(), "Spawn");
 
     id_call = rb_intern("call");
     id_new = rb_intern("new");

data/ext/glib2/rbglib_spawnerror.c

@@ -28,7 +28,7 @@
 void
 Init_glib_spawnerror(void)
 {
-    VALUE RG_TARGET_NAMESPACE = G_DEF_ERROR2(G_SPAWN_ERROR, "SpawnError", mGLib, rb_eIOError);
+    VALUE RG_TARGET_NAMESPACE = G_DEF_ERROR2(G_SPAWN_ERROR, "SpawnError", rbg_mGLib(), rb_eIOError);
 
     rb_define_const(RG_TARGET_NAMESPACE, "FORK", INT2NUM(G_SPAWN_ERROR_FORK));
     rb_define_const(RG_TARGET_NAMESPACE, "READ", INT2NUM(G_SPAWN_ERROR_READ));

data/ext/glib2/rbglib_threads.c

@@ -41,7 +41,7 @@ rg_s_supported_p(G_GNUC_UNUSED VALUE self)
 void
 Init_glib_threads(void)
 {
-    RG_TARGET_NAMESPACE = rb_define_class_under(mGLib, "Thread", rb_cObject);
+    RG_TARGET_NAMESPACE = rb_define_class_under(rbg_mGLib(), "Thread", rb_cObject);
 
     RG_DEF_SMETHOD(init, 0);
     RG_DEF_SMETHOD_P(supported, 0);

data/ext/glib2/rbglib_timer.c

@@ -116,7 +116,7 @@ rg_reset(VALUE self)
 void
 Init_glib_timer(void)
 {
-    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_TIMER, "Timer", mGLib); 
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_TIMER, "Timer", rbg_mGLib()); 
 
     RG_DEF_METHOD(initialize, 0);
     RG_DEF_METHOD(start, 0);

data/ext/glib2/rbglib_timezone.c

@@ -73,7 +73,7 @@ void
 Init_glib_time_zone(void)
 {
     VALUE RG_TARGET_NAMESPACE;
-    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_TIME_ZONE, "TimeZone", mGLib);
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_TIME_ZONE, "TimeZone", rbg_mGLib());
     RG_DEF_METHOD(initialize, -1);
     RG_DEF_SMETHOD(local, 0);
     RG_DEF_SMETHOD(utc, 0);

data/ext/glib2/rbglib_ucs4.c

@@ -72,7 +72,7 @@ rg_s_to_utf8(G_GNUC_UNUSED VALUE self, VALUE rb_ucs4)
 void
 Init_glib_ucs4(void)
 {
-    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(mGLib, "UCS4");
+    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(rbg_mGLib(), "UCS4");
 
     RG_DEF_SMETHOD(to_utf16, 1);
     RG_DEF_SMETHOD(to_utf8, 1);

data/ext/glib2/rbglib_unichar.c

@@ -185,7 +185,7 @@ rg_s_decompose(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
 void
 Init_glib_unichar(void)
 {
-    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(mGLib, "UniChar");
+    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(rbg_mGLib(), "UniChar");
 
     rbg_define_singleton_method(RG_TARGET_NAMESPACE, "alnum?",
                               rbglib_m_unichar_isalnum, 1);

data/ext/glib2/rbglib_unicode.c

@@ -52,7 +52,7 @@ rg_s_canonical_ordering(G_GNUC_UNUSED VALUE self, VALUE rb_ucs4)
 void
 Init_glib_unicode(void)
 {
-    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(mGLib, "Unicode");
+    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(rbg_mGLib(), "Unicode");
 
     /* GUnicodeType */
     G_DEF_CLASS(G_TYPE_UNICODE_TYPE, "Type", RG_TARGET_NAMESPACE);
@@ -65,9 +65,9 @@ Init_glib_unicode(void)
     G_DEF_CLASS(G_TYPE_UNICODE_SCRIPT, "Script", RG_TARGET_NAMESPACE);
     G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, G_TYPE_UNICODE_SCRIPT, "G_UNICODE_");
 
-    G_DEF_CLASS(G_TYPE_NORMALIZE_MODE, "NormalizeMode", mGLib);
+    G_DEF_CLASS(G_TYPE_NORMALIZE_MODE, "NormalizeMode", rbg_mGLib());
 
-    rbg_define_singleton_method(mGLib, "charset", rbglib_m_charset, 0);
+    rbg_define_singleton_method(rbg_mGLib(), "charset", rbglib_m_charset, 0);
 
     RG_DEF_SMETHOD(canonical_ordering, 1);
 }

data/ext/glib2/rbglib_utf16.c

@@ -71,7 +71,7 @@ rg_s_to_utf8(G_GNUC_UNUSED VALUE self, VALUE rb_utf16)
 void
 Init_glib_utf16(void)
 {
-    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(mGLib, "UTF16");
+    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(rbg_mGLib(), "UTF16");
 
     RG_DEF_SMETHOD(to_ucs4, 1);
     RG_DEF_SMETHOD(to_utf8, 1);

data/ext/glib2/rbglib_utf8.c

@@ -218,7 +218,7 @@ rg_s_to_ucs4(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
 void
 Init_glib_utf8(void)
 {
-    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(mGLib, "UTF8");
+    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(rbg_mGLib(), "UTF8");
 
     /*
       Not implemented.

data/ext/glib2/rbglib_utils.c

@@ -21,7 +21,7 @@
 
 #include "rbgprivate.h"
 
-#define RG_TARGET_NAMESPACE mGLib
+#define RG_TARGET_NAMESPACE rbg_mGLib()
 
 static VALUE
 rg_s_application_name(G_GNUC_UNUSED VALUE self)

data/ext/glib2/rbglib_win32.c

@@ -90,17 +90,17 @@ Init_glib_win32(void)
 {
 #ifdef G_OS_WIN32
     /* glib/gwin32.h */
-    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(mGLib, "Win32");
+    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(rbg_mGLib(), "Win32");
 
     RG_DEF_SMETHOD(error_message, 1);
     RG_DEF_SMETHOD(locale, 0);
     RG_DEF_SMETHOD(version, 0);
     /* Deprecated */
-    rbg_define_singleton_method(mGLib, "win32_locale", rbglib_m_win32_locale_deprecated, 0);
+    rbg_define_singleton_method(rbg_mGLib(), "win32_locale", rbglib_m_win32_locale_deprecated, 0);
 
     RG_DEF_SMETHOD(locale_filename_from_utf8, 1);
     /* Deprecated */
-    rbg_define_singleton_method(mGLib, "win32_locale_filename_from_utf8",
+    rbg_define_singleton_method(rbg_mGLib(), "win32_locale_filename_from_utf8",
                               rbglib_m_win32_locale_filename_from_utf8_deprecated, 1);
 
     RG_DEF_SMETHOD(get_package_installation_directory_of_module, -1);

data/ext/glib2/rbgobj_binding.c

@@ -44,7 +44,7 @@ Init_gobject_gbinding(void)
 {
     VALUE RG_TARGET_NAMESPACE;
 
-    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_BINDING, "Binding", mGLib);
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_BINDING, "Binding", rbg_mGLib());
 
     RG_DEF_METHOD(unbind, 0);
 }

data/ext/glib2/rbgobj_boxed.c

@@ -302,7 +302,7 @@ boxed_from_ruby(VALUE from, GValue *to)
 void
 Init_gobject_gboxed(void)
 {
-    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_BOXED, "Boxed", mGLib);
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_BOXED, "Boxed", rbg_mGLib());
 
     rbgobj_register_g2r_func(G_TYPE_BOXED, boxed_to_ruby);
     rbgobj_register_r2g_func(G_TYPE_BOXED, boxed_from_ruby);

data/ext/glib2/rbgobj_closure.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2002-2021  Ruby-GNOME Project Team
+ *  Copyright (C) 2002-2022  Ruby-GNOME Project Team
  *  Copyright (C) 2002,2003  Masahiro Sakai
  *
  *  This library is free software; you can redistribute it and/or
@@ -34,7 +34,6 @@ struct _GRClosure
     VALUE callback;
     VALUE extra_args;
     VALUE rb_holder;
-    gint count;
     GList *objects;
     GValToRValSignalFunc g2r_func;
     RGClosureCallFunc call_func;
@@ -64,7 +63,7 @@ struct marshal_arg
 static int
 rclosure_alive_p(GRClosure *rclosure)
 {
-    return (rclosure->count > 0 && !NIL_P(rclosure->rb_holder));
+    return !NIL_P(rclosure->rb_holder);
 }
 
 static VALUE
@@ -121,8 +120,8 @@ rclosure_marshal_do(VALUE arg_)
 
         ret = rb_apply(callback, id_call, args);
     } else {
-        rb_warn("GRClosure invoking callback: already destroyed: %s",
-                rclosure->tag[0] ? rclosure->tag : "(anonymous)");
+        g_warning("GRClosure invoking callback: already destroyed: %s",
+                  rclosure->tag[0] ? rclosure->tag : "(anonymous)");
     }
 
     if (return_value && G_VALUE_TYPE(return_value))
@@ -159,43 +158,25 @@ rclosure_marshal(GClosure*       closure,
 static void rclosure_weak_notify(gpointer data, GObject* where_the_object_was);
 
 static void
-rclosure_unref(GRClosure *rclosure)
+rclosure_finalize(G_GNUC_UNUSED gpointer data, GClosure *closure)
 {
-    rclosure->count--;
+    GRClosure *rclosure = (GRClosure *)closure;
 
-    if (!rclosure_alive_p(rclosure)) {
-        GList *next;
-        for (next = rclosure->objects; next; next = next->next) {
-            GObject *object = G_OBJECT(next->data);
-            g_object_weak_unref(object, rclosure_weak_notify, rclosure);
-        }
-        g_list_free(rclosure->objects);
-        rclosure->objects = NULL;
-        if (!NIL_P(rclosure->rb_holder)) {
-            RTYPEDDATA_DATA(rclosure->rb_holder) = NULL;
-            rclosure->rb_holder = Qnil;
+    GList *next;
+    for (next = rclosure->objects; next; next = next->next) {
+        GObject *object = G_OBJECT(next->data);
+        g_object_weak_unref(object, rclosure_weak_notify, rclosure);
+        VALUE obj = rbgobj_ruby_object_from_instance2(object, FALSE);
+        if (!NIL_P(rclosure->rb_holder) && !NIL_P(obj)) {
+            rbgobj_object_remove_relative(obj, rclosure->rb_holder);
         }
     }
-}
-
-static void
-rclosure_invalidate(G_GNUC_UNUSED gpointer data, GClosure *closure)
-{
-    GRClosure *rclosure = (GRClosure*)closure;
-
-    if (rclosure->count > 0) {
-        GList *next;
-
-        rclosure->count = 1;
-        for (next = rclosure->objects; next; next = next->next) {
-            GObject *object = G_OBJECT(next->data);
-            VALUE obj = rbgobj_ruby_object_from_instance2(object, FALSE);
-            if (!NIL_P(rclosure->rb_holder) && !NIL_P(obj)) {
-                rbgobj_object_remove_relative(obj, rclosure->rb_holder);
-            }
-        }
+    g_list_free(rclosure->objects);
+    rclosure->objects = NULL;
 
-        rclosure_unref(rclosure);
+    if (!NIL_P(rclosure->rb_holder)) {
+        RTYPEDDATA_DATA(rclosure->rb_holder) = NULL;
+        rclosure->rb_holder = Qnil;
     }
 }
 
@@ -219,13 +200,7 @@ gr_closure_holder_free(void *data)
     if (!rclosure)
         return;
 
-    if (rclosure->count > 0) {
-        rclosure->count = 1;
-
-        /* No need to remove us from the relatives hash of our objects, as
-         * those aren't alive anymore anyway */
-        rclosure_unref(rclosure);
-    }
+    g_closure_unref((GClosure *)rclosure);
 }
 
 static const rb_data_type_t rbg_closure_holder_type = {
@@ -245,26 +220,24 @@ g_rclosure_new_raw(VALUE callback_proc,
                    GValToRValSignalFunc g2r_func,
                    RGClosureCallFunc call_func)
 {
-    GRClosure* closure;
-
-    closure = (GRClosure*)g_closure_new_simple(sizeof(GRClosure), NULL);
-
-    closure->count      = 1;
-    closure->g2r_func   = g2r_func;
-    closure->call_func  = call_func;
-    closure->objects    = NULL;
-    closure->callback   = callback_proc;
-    closure->extra_args = extra_args;
-    closure->rb_holder  = TypedData_Wrap_Struct(rb_cObject,
-                                                &rbg_closure_holder_type,
-                                                closure);
-    closure->tag[0]     = '\0';
-
-    g_closure_set_marshal((GClosure*)closure, &rclosure_marshal);
-    g_closure_add_invalidate_notifier((GClosure*)closure, NULL,
-                                      &rclosure_invalidate);
-
-    return (GClosure*)closure;
+    GClosure *closure = g_closure_new_simple(sizeof(GRClosure), NULL);
+
+    GRClosure *rclosure = (GRClosure *)closure;
+
+    rclosure->g2r_func   = g2r_func;
+    rclosure->call_func  = call_func;
+    rclosure->objects    = NULL;
+    rclosure->callback   = callback_proc;
+    rclosure->extra_args = extra_args;
+    rclosure->rb_holder  = TypedData_Wrap_Struct(rb_cObject,
+                                                 &rbg_closure_holder_type,
+                                                 rclosure);
+    rclosure->tag[0]     = '\0';
+
+    g_closure_set_marshal(closure, &rclosure_marshal);
+    g_closure_add_finalize_notifier(closure, NULL, rclosure_finalize);
+
+    return closure;
 }
 
 GClosure *
@@ -287,34 +260,30 @@ g_rclosure_new_call(VALUE callback_proc,
 }
 
 static void
-rclosure_weak_notify(gpointer data, GObject* where_the_object_was)
+rclosure_weak_notify(gpointer data, GObject *where_the_object_was)
 {
     GRClosure *rclosure = data;
-    if (rclosure_alive_p(rclosure)) {
-        rclosure->objects =
-            g_list_remove(rclosure->objects, where_the_object_was);
-        rclosure_unref(rclosure);
-    }
+    rclosure->objects = g_list_remove(rclosure->objects, where_the_object_was);
+    g_closure_unref((GClosure *)rclosure);
 }
 
 void
 g_rclosure_attach(GClosure *closure, VALUE object)
 {
-    static VALUE cGLibObject = Qnil;
     GRClosure *rclosure = (GRClosure *)closure;
-
     rbgobj_add_relative(object, rclosure->rb_holder);
+}
 
-    if (NIL_P(cGLibObject)) {
-        cGLibObject = rb_const_get(mGLib, rb_intern("Object"));
-    }
-    if (rb_obj_is_kind_of(object, cGLibObject)) {
-        GObject *gobject;
-        gobject = RVAL2GOBJ(object);
-        rclosure->count++;
-        g_object_weak_ref(gobject, rclosure_weak_notify, rclosure);
-        rclosure->objects = g_list_prepend(rclosure->objects, gobject);
-    }
+void
+g_rclosure_attach_gobject(GClosure *closure, VALUE object)
+{
+    GRClosure *rclosure = (GRClosure *)closure;
+    g_rclosure_attach(closure, object);
+
+    GObject *gobject = RVAL2GOBJ(object);
+    g_closure_ref(closure);
+    g_object_weak_ref(gobject, rclosure_weak_notify, rclosure);
+    rclosure->objects = g_list_prepend(rclosure->objects, gobject);
 }
 
 void
@@ -350,8 +319,9 @@ init_rclosure(void)
 static VALUE
 rg_initialize(VALUE self)
 {
-    GClosure* closure = g_rclosure_new(rb_block_proc(), Qnil, NULL);
+    GClosure *closure = g_rclosure_new(rb_block_proc(), Qnil, NULL);
     G_INITIALIZE(self, closure);
+    g_closure_ref(closure);
     g_closure_sink(closure);
     return self;
 }
@@ -387,7 +357,7 @@ Init_gobject_gclosure(void)
 
     init_rclosure();
 
-    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_CLOSURE, "Closure", mGLib);
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_CLOSURE, "Closure", rbg_mGLib());
 
     RG_DEF_METHOD(initialize, 0);
     RG_DEF_METHOD_P(in_marshal, 0);

data/ext/glib2/rbgobj_enums.c

@@ -413,7 +413,7 @@ Init_gobject_genums(void)
     id_to_s = rb_intern("to_s");
     id_values = rb_intern("values");
 
-    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_ENUM, "Enum", mGLib);
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_ENUM, "Enum", rbg_mGLib());
 
     rbg_define_singleton_method(RG_TARGET_NAMESPACE, "gtype", generic_s_gtype, 0);
     rbg_define_method(RG_TARGET_NAMESPACE, "gtype", generic_gtype, 0);

data/ext/glib2/rbgobj_flags.c

@@ -542,7 +542,7 @@ Init_gobject_gflags(void)
     id_or = rb_intern("|");
     id_to_i = rb_intern("to_i");
 
-    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_FLAGS, "Flags", mGLib);
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_FLAGS, "Flags", rbg_mGLib());
 
     rbg_define_singleton_method(RG_TARGET_NAMESPACE, "gtype", generic_s_gtype, 0);
     rbg_define_method(RG_TARGET_NAMESPACE, "gtype", generic_gtype, 0);

data/ext/glib2/rbgobj_object.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2002-2021  Ruby-GNOME Project Team
+ *  Copyright (C) 2002-2022  Ruby-GNOME Project Team
  *  Copyright (C) 2002-2003  Masahiro Sakai
  *  Copyright (C) 1998-2000  Yukihiro Matsumoto,
  *                           Daisuke Kanda,
@@ -30,6 +30,12 @@ VALUE RG_TARGET_NAMESPACE;
 static VALUE eNoPropertyError;
 static GQuark RUBY_GOBJECT_OBJ_KEY;
 
+VALUE
+rbg_cGLibObject(void)
+{
+    return RG_TARGET_NAMESPACE;
+}
+
 gboolean
 rbg_is_object(VALUE object)
 {
@@ -311,6 +317,12 @@ rg_s_new_bang(int argc, VALUE *argv, VALUE self)
     return result;
 }
 
+static VALUE
+rg_s_init(int argc, VALUE *argv, VALUE self)
+{
+    return RUBY_Qnil;
+}
+
 struct param_setup_arg {
     GObjectClass* gclass;
     GParameter* params;
@@ -872,6 +884,15 @@ rg_initialize(int argc, VALUE *argv, VALUE self)
     gobj = rbgobj_gobject_new(RVAL2GTYPE(self), params_hash);
 
     G_INITIALIZE(self, gobj);
+
+    rb_funcall(self, rb_intern("initialize_post"), 0);
+
+    return Qnil;
+}
+
+static VALUE
+rg_initialize_post(VALUE self)
+{
     return Qnil;
 }
 
@@ -956,6 +977,9 @@ rbgobj_class_init_func(gpointer g_class, G_GNUC_UNUSED gpointer class_data)
 
     g_object_class->set_property = set_prop_func;
     g_object_class->get_property = get_prop_func;
+
+    VALUE rb_class = GTYPE2CLASS(G_TYPE_FROM_CLASS(g_class));
+    rb_funcall(rb_class, rb_intern("init"), 0);
 }
 
 void
@@ -1062,11 +1086,11 @@ rg_s_type_register(int argc, VALUE *argv, VALUE self)
 void
 Init_gobject_gobject(void)
 {
-    RG_TARGET_NAMESPACE = G_DEF_CLASS_WITH_GC_FUNC(G_TYPE_OBJECT, "Object", mGLib,
+    RG_TARGET_NAMESPACE = G_DEF_CLASS_WITH_GC_FUNC(G_TYPE_OBJECT, "Object", rbg_mGLib(),
                                                   gobj_mark, NULL);
 
 #ifdef G_TYPE_INITIALLY_UNOWNED
-    G_DEF_CLASS(G_TYPE_INITIALLY_UNOWNED, "InitiallyUnowned", mGLib);
+    G_DEF_CLASS(G_TYPE_INITIALLY_UNOWNED, "InitiallyUnowned", rbg_mGLib());
 #endif
 
     RUBY_GOBJECT_OBJ_KEY = g_quark_from_static_string("__ruby_gobject_object__");
@@ -1074,6 +1098,8 @@ Init_gobject_gobject(void)
     rb_define_alloc_func(RG_TARGET_NAMESPACE, rbgobj_object_alloc_func);
     RG_DEF_SMETHOD_BANG(new, -1);
 
+    RG_DEF_SMETHOD(init, 0);
+
     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);
@@ -1089,6 +1115,7 @@ Init_gobject_gobject(void)
     RG_DEF_METHOD_P(destroyed, 0);
 
     RG_DEF_METHOD(initialize, -1);
+    RG_DEF_PRIVATE_METHOD(initialize_post, 0);
     rbg_define_method(RG_TARGET_NAMESPACE, "ref_count", gobj_ref_count, 0); /* for debugging */
     RG_DEF_METHOD_P(floating, 0); /* for debugging */
     RG_DEF_METHOD(unref, 0);
@@ -1096,9 +1123,9 @@ Init_gobject_gobject(void)
     RG_DEF_METHOD(type_name, 0);
 
     RG_DEF_METHOD(bind_property, -1);
-    G_DEF_CLASS(G_TYPE_BINDING_FLAGS, "BindingFlags", mGLib);
+    G_DEF_CLASS(G_TYPE_BINDING_FLAGS, "BindingFlags", rbg_mGLib());
 
-    eNoPropertyError = rb_define_class_under(mGLib, "NoPropertyError",
+    eNoPropertyError = rb_define_class_under(rbg_mGLib(), "NoPropertyError",
                                              rb_eNameError);
 
     rbg_type_to_prop_setter_tables =

data/ext/glib2/rbgobj_param.c

@@ -353,7 +353,7 @@ void
 Init_gobject_gparam(void)
 {
     qparamspec = g_quark_from_static_string("__ruby_gobject_param_spec__");
-    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_PARAM, "Param", mGLib);
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_PARAM, "Param", rbg_mGLib());
 
     /* GParamFlags */
     rb_define_const(RG_TARGET_NAMESPACE, "READABLE",

data/ext/glib2/rbgobj_signal.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2002-2021  Ruby-GNOME Project Team
+ *  Copyright (C) 2002-2022  Ruby-GNOME Project Team
  *  Copyright (C) 2002,2003  Masahiro Sakai
  *
  *  This library is free software; you can redistribute it and/or
@@ -39,20 +39,28 @@ static const rb_data_type_t rg_glib_signal_type = {
     RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
-VALUE
-rbgobj_signal_new(guint id)
+static VALUE
+rbgobj_signal_alloc_func(VALUE klass)
 {
-    VALUE rb_query;
     GSignalQuery *query;
-
-    rb_query = TypedData_Make_Struct(RG_TARGET_NAMESPACE,
-                                     GSignalQuery,
-                                     &rg_glib_signal_type,
-                                     query);
-    g_signal_query(id, query);
+    VALUE rb_query = TypedData_Make_Struct(RG_TARGET_NAMESPACE,
+                                           GSignalQuery,
+                                           &rg_glib_signal_type,
+                                           query);
     return rb_query;
 }
 
+VALUE
+rbgobj_signal_new(guint id)
+{
+    ID id_new;
+    CONST_ID(id_new, "new");
+    return rb_funcall(RG_TARGET_NAMESPACE,
+                      id_new,
+                      1,
+                      UINT2NUM(id));
+}
+
 static GSignalQuery *
 rbgobj_signal_get_raw(VALUE rb_signal)
 {
@@ -398,15 +406,16 @@ gobj_sig_connect_impl(gboolean after, int argc, VALUE *argv, VALUE self)
                                       rbgobj_get_signal_func(signal_id));
         }
     }
-    g_rclosure_attach((GClosure *)rclosure, self);
+    g_rclosure_attach_gobject(rclosure, self);
     g_object = RVAL2GOBJ(self);
     tag = g_strdup_printf("%s::%s",
                           G_OBJECT_CLASS_NAME(G_OBJECT_GET_CLASS(g_object)),
                           sig_name);
-    g_rclosure_set_tag((GClosure *)rclosure, tag);
+    g_rclosure_set_tag(rclosure, tag);
     g_free(tag);
     handler_id = g_signal_connect_closure_by_id(g_object, signal_id, detail,
                                                 rclosure, after);
+    g_closure_unref(rclosure);
 
     return ULONG2NUM(handler_id);
 }
@@ -725,7 +734,7 @@ gobj_s_signal_handler_attach(VALUE klass,
                                         Qnil,
                                         rbgobj_get_signal_func(signal_id));
     g_rclosure_set_tag(rclosure, handler_name);
-    g_rclosure_attach((GClosure *)rclosure, klass);
+    g_rclosure_attach(rclosure, klass);
     g_signal_override_class_closure(signal_id, cinfo->gtype, rclosure);
 
     {
@@ -745,6 +754,13 @@ rbgobj_signal_wrap(guint sig_id)
     return rbgobj_signal_new(sig_id);
 }
 
+static VALUE
+rg_initialize(VALUE self, VALUE id)
+{
+    g_signal_query(NUM2UINT(id), rbgobj_signal_get_raw(self));
+    return RUBY_Qnil;
+}
+
 static VALUE
 rg_id(VALUE self)
 {
@@ -957,8 +973,10 @@ Init_gobject_gsignal(void)
 {
     VALUE cSignalFlags, cSignalMatchType;
 
-    RG_TARGET_NAMESPACE = rb_define_class_under(mGLib, "Signal", rb_cObject);
+    RG_TARGET_NAMESPACE = rb_define_class_under(rbg_mGLib(), "Signal", rb_cObject);
+    rb_define_alloc_func(RG_TARGET_NAMESPACE, rbgobj_signal_alloc_func);
 
+    RG_DEF_METHOD(initialize, 1);
     RG_DEF_METHOD(id, 0);
     RG_DEF_METHOD(name, 0);
     RG_DEF_METHOD(flags, 0);
@@ -972,7 +990,7 @@ Init_gobject_gsignal(void)
     RG_DEF_METHOD(remove_emission_hook, 1);
 
     /* GSignalFlags */
-    cSignalFlags = G_DEF_CLASS(G_TYPE_SIGNAL_FLAGS, "SignalFlags", mGLib);
+    cSignalFlags = G_DEF_CLASS(G_TYPE_SIGNAL_FLAGS, "SignalFlags", rbg_mGLib());
     G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, G_TYPE_SIGNAL_FLAGS, "G_SIGNAL_");
     rb_define_const(cSignalFlags, "MASK", INT2NUM(G_SIGNAL_FLAGS_MASK));
     rb_define_const(RG_TARGET_NAMESPACE, "FLAGS_MASK", INT2NUM(G_SIGNAL_FLAGS_MASK));
@@ -986,19 +1004,19 @@ Init_gobject_gsignal(void)
     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);
+    G_DEF_CLASS(G_TYPE_CONNECT_FLAGS, "ConnectFlags", rbg_mGLib());
     G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, G_TYPE_CONNECT_FLAGS, "G_");
 
     /* GSignalMatchType */
     cSignalMatchType = G_DEF_CLASS(G_TYPE_SIGNAL_MATCH_TYPE,
-                                   "SignalMatchType", mGLib);
+                                   "SignalMatchType", rbg_mGLib());
     G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, G_TYPE_SIGNAL_MATCH_TYPE, "G_SIGNAL_");
     rb_define_const(cSignalMatchType, "MASK", INT2NUM(G_SIGNAL_MATCH_MASK));
     rb_define_const(RG_TARGET_NAMESPACE, "MATCH_MASK", INT2NUM(G_SIGNAL_MATCH_MASK));
 
     rb_define_const(RG_TARGET_NAMESPACE, "TYPE_STATIC_SCOPE", INT2FIX(G_SIGNAL_TYPE_STATIC_SCOPE));
 
-    eNoSignalError = rb_define_class_under(mGLib, "NoSignalError", rb_eNameError);
+    eNoSignalError = rb_define_class_under(rbg_mGLib(), "NoSignalError", rb_eNameError);
 
     rbg_signal_func_table = g_hash_table_new(g_direct_hash, g_direct_equal);
     g_mutex_init(&rbg_signal_func_table_mutex);

data/ext/glib2/rbgobj_type.c

@@ -993,12 +993,12 @@ Init_gobject_gtype(void)
     id_lock = rb_intern("lock");
     id_unlock = rb_intern("unlock");
     lookup_class_mutex = rb_funcall(rb_cMutex, id_new, 0);
-    rb_iv_set(mGLib, "lookup_class_mutex", lookup_class_mutex);
+    rb_iv_set(rbg_mGLib(), "lookup_class_mutex", lookup_class_mutex);
 
     dynamic_gtype_list = g_hash_table_new(g_str_hash, g_str_equal);
     id_gtype = rb_intern("__gobject_gtype__");
 
-    RG_TARGET_NAMESPACE = rb_define_class_under(mGLib, "Type", rb_cObject);
+    RG_TARGET_NAMESPACE = rb_define_class_under(rbg_mGLib(), "Type", rb_cObject);
 
     RG_DEF_SMETHOD(try_convert, 1);