glib2 4.2.5 → 4.2.7

data/ext/glib2/rbgobj_object.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2002-2023  Ruby-GNOME Project Team
+ *  Copyright (C) 2002-2025  Ruby-GNOME Project Team
  *  Copyright (C) 2002-2003  Masahiro Sakai
  *  Copyright (C) 1998-2000  Yukihiro Matsumoto,
  *                           Daisuke Kanda,
@@ -112,7 +112,7 @@ static const rb_data_type_t rg_glib_object_type = {
         holder_mark,
         holder_free,
     },
-    NULL,
+    &rbg_glib_instantiatable_type,
     NULL,
     RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_FROZEN_SHAREABLE,
 };
@@ -301,144 +301,142 @@ gobj_mark(gpointer ptr)
     g_free(properties);
 }
 
-static VALUE
-rg_s_new_bang(int argc, VALUE *argv, VALUE self)
-{
-    const RGObjClassInfo* cinfo = rbgobj_lookup_class(self);
-    VALUE params_hash;
-    GObject* gobj;
-    VALUE result;
-
-    rb_scan_args(argc, argv, "01", &params_hash);
-
-    if (!NIL_P(params_hash))
-        Check_Type(params_hash, RUBY_T_HASH);
-
-    if (cinfo->klass != self)
-        rb_raise(rb_eTypeError, "%s isn't registered class",
-                 rb_class2name(self));
-
-    gobj = rbgobj_gobject_new(cinfo->gtype, params_hash);
-    result = GOBJ2RVAL(gobj);
-    g_object_unref(gobj);
-
-    return result;
-}
-
-static VALUE
-rg_s_init(VALUE self)
-{
-    return RUBY_Qnil;
-}
-
-struct param_setup_arg {
+typedef struct {
+    VALUE rb_properties;
     GObjectClass* gclass;
-    GParameter* params;
-    guint param_size;
-    VALUE params_hash;
+    guint n_properties;
+    const char **names;
+    GValue* values;
     guint index;
-};
+} rbgobj_new_data;
 
-static VALUE
-_params_setup(VALUE arg,
-              VALUE rb_param_setup_arg,
-              G_GNUC_UNUSED int argc,
-              G_GNUC_UNUSED const VALUE *argv,
-              G_GNUC_UNUSED VALUE block)
+static int
+rbgobj_new_set_property(VALUE key,
+                        VALUE value,
+                        VALUE rb_data)
 {
-    struct param_setup_arg *param_setup_arg =
-        (struct param_setup_arg *)rb_param_setup_arg;
-    guint index;
-    VALUE name, val;
-    GParamSpec* pspec;
-
-    index = param_setup_arg->index;
-    if (index >= param_setup_arg->param_size)
-       rb_raise(rb_eArgError, "too many parameters");
+    rbgobj_new_data *data = (rbgobj_new_data *)rb_data;
 
-    name = rb_ary_entry(arg, 0);
-    val  = rb_ary_entry(arg, 1);
+    guint index = data->index;
+    if (index >= data->n_properties)
+       rb_raise(rb_eArgError, "too many properties");
 
-    if (SYMBOL_P(name))
-        param_setup_arg->params[index].name = rb_id2name(SYM2ID(name));
-    else
-        param_setup_arg->params[index].name = StringValuePtr(name);
+    const char *name;
+    if (SYMBOL_P(key)) {
+        name = rb_id2name(SYM2ID(key));
+    } else {
+        name = StringValueCStr(key);
+    }
 
-    pspec = g_object_class_find_property(
-        param_setup_arg->gclass,
-        param_setup_arg->params[index].name);
+    GParamSpec *pspec = g_object_class_find_property(data->gclass, name);
     if (!pspec)
-        rb_raise(rb_eArgError, "No such property: %s",
-                 param_setup_arg->params[index].name);
+        rb_raise(rb_eArgError, "No such property: %s", name);
 
-    g_value_init(&(param_setup_arg->params[index].value),
-                 G_PARAM_SPEC_VALUE_TYPE(pspec));
-    rbgobj_rvalue_to_gvalue(val, &(param_setup_arg->params[index].value));
+    data->names[index] = pspec->name;
+    g_value_init(&(data->values[index]), G_PARAM_SPEC_VALUE_TYPE(pspec));
+    rbgobj_rvalue_to_gvalue(value, &(data->values[index]));
 
-    param_setup_arg->index++;
+    data->index++;
 
-    return Qnil;
+    return ST_CONTINUE;
 }
 
 static VALUE
-gobj_new_body(VALUE rb_arg)
+rbgobj_new_body(VALUE rb_data)
 {
-    struct param_setup_arg *arg = (struct param_setup_arg *)rb_arg;
-    ID id_each;
-    CONST_ID(id_each, "each");
-    rb_block_call(arg->params_hash, id_each, 0, NULL, _params_setup, (VALUE)arg);
-    return (VALUE)g_object_newv(G_TYPE_FROM_CLASS(arg->gclass),
-                                arg->param_size, arg->params);
+    rbgobj_new_data *data = (rbgobj_new_data *)rb_data;
+    rb_hash_foreach(data->rb_properties, rbgobj_new_set_property, rb_data);
+    return (VALUE)g_object_new_with_properties(G_TYPE_FROM_CLASS(data->gclass),
+                                               data->n_properties,
+                                               data->names,
+                                               data->values);
 }
 
 static VALUE
-gobj_new_ensure(VALUE rb_arg)
+rbgobj_new_ensure(VALUE rb_data)
 {
-    struct param_setup_arg *arg = (struct param_setup_arg *)rb_arg;
+    rbgobj_new_data *data = (rbgobj_new_data *)rb_data;
     guint i;
-    g_type_class_unref(arg->gclass);
-    for (i = 0; i < arg->param_size; i++) {
-        if (G_IS_VALUE(&arg->params[i].value))
-            g_value_unset(&arg->params[i].value);
+    for (i = 0; i < data->n_properties; i++) {
+        g_value_unset(&(data->values[i]));
     }
+    g_type_class_unref(data->gclass);
     return Qnil;
 }
 
-GObject*
-rbgobj_gobject_new(GType gtype, VALUE params_hash)
+static GObject *
+rbgobj_gobject_new(int argc, VALUE *argv, GType gtype)
 {
-    GObject* result;
-
     if (!g_type_is_a(gtype, G_TYPE_OBJECT))
         rb_raise(rb_eArgError,
                  "type \"%s\" is not descendant of GObject",
                  g_type_name(gtype));
 
-    if (NIL_P(params_hash)) {
-        result = g_object_newv(gtype, 0, NULL);
+    VALUE rb_properties = Qnil;
+#ifdef RB_SCAN_ARGS_LAST_HASH_KEYWORDS
+    /* TODO: Can we use rb_get_kwargs()? */
+    rb_scan_args_kw(RB_SCAN_ARGS_LAST_HASH_KEYWORDS, argc, argv,
+                    "0:", &rb_properties);
+#else
+    /* We can remove this when we drop support for AlmaLinux 8 that
+     * ships Ruby 2.5 as the default Ruby. */
+    rb_scan_args(argc, argv, "01", &rb_properties);
+#endif
+
+    GObject *gobject;
+    if (NIL_P(rb_properties)) {
+        gobject = g_object_new_with_properties(gtype, 0, NULL, NULL);
     } else {
-        guint param_size;
-        struct param_setup_arg arg;
+        rbgobj_new_data data;
+        data.rb_properties = rb_properties;
+        data.gclass = G_OBJECT_CLASS(g_type_class_ref(gtype));
+        data.n_properties = RHASH_SIZE(rb_properties);
+        data.names = NULL;
+        data.values = NULL;
+        data.names = ALLOCA_N(const char *, data.n_properties);
+        data.values = ALLOCA_N(GValue, data.n_properties);
+        guint i;
+        GValue empty_value = G_VALUE_INIT;
+        for (i = 0; i < data.n_properties; i++) {
+            data.names[i] = NULL;
+            data.values[i] = empty_value;
+        }
+        data.index = 0;
 
-        param_size = NUM2UINT(rb_funcall(params_hash, rb_intern("length"), 0));
+        gobject = (GObject *)rb_ensure(&rbgobj_new_body, (VALUE)(&data),
+                                       &rbgobj_new_ensure, (VALUE)(&data));
+    }
 
-        arg.param_size = param_size;
-        arg.gclass = G_OBJECT_CLASS(g_type_class_ref(gtype));
-        arg.params = ALLOCA_N(GParameter, param_size);
-        memset(arg.params, 0, sizeof(GParameter) * param_size);
-        arg.params_hash = params_hash;
-        arg.index = 0;
+    if (!gobject)
+        rb_raise(rb_eRuntimeError, "g_object_new_with_properties() failed");
 
-        result = (GObject*)rb_ensure(&gobj_new_body, (VALUE)&arg,
-                                     &gobj_new_ensure, (VALUE)&arg);
-    }
+    return gobject;
+}
 
-    if (!result)
-        rb_raise(rb_eRuntimeError, "g_object_newv failed");
+static VALUE
+rg_s_new_bang(int argc, VALUE *argv, VALUE self)
+{
+    const RGObjClassInfo* cinfo = rbgobj_lookup_class(self);
+    GObject* gobj;
+    VALUE result;
+
+    if (cinfo->klass != self)
+        rb_raise(rb_eTypeError, "%s isn't registered class",
+                 rb_class2name(self));
+
+    gobj = rbgobj_gobject_new(argc, argv, cinfo->gtype);
+    result = GOBJ2RVAL(gobj);
+    g_object_unref(gobj);
 
     return result;
 }
 
+static VALUE
+rg_s_init(VALUE self)
+{
+    return RUBY_Qnil;
+}
+
 static VALUE
 rg_s_install_property(int argc, VALUE* argv, VALUE self)
 {
@@ -867,7 +865,6 @@ static VALUE
 rg_initialize(int argc, VALUE *argv, VALUE self)
 {
     GType gtype;
-    VALUE params_hash;
     GObject* gobj;
 
     gtype = CLASS2GTYPE(CLASS_OF(self));
@@ -877,12 +874,7 @@ rg_initialize(int argc, VALUE *argv, VALUE self)
                  RBG_INSPECT(CLASS_OF(self)));
     }
 
-    rb_scan_args(argc, argv, "01", &params_hash);
-
-    if (!NIL_P(params_hash))
-        Check_Type(params_hash, RUBY_T_HASH);
-
-    gobj = rbgobj_gobject_new(RVAL2GTYPE(self), params_hash);
+    gobj = rbgobj_gobject_new(argc, argv, gtype);
 
     G_INITIALIZE(self, gobj);
 
@@ -1052,8 +1044,8 @@ rbgobj_register_type(VALUE klass, VALUE type_name, GClassInitFunc class_init)
             initialize_module = rb_define_module_under(klass,
                                                        RubyGObjectHookModule);
             if (!(cinfo->flags & RBGOBJ_DEFINED_BY_RUBY)) {
-                rbg_define_method(initialize_module,
-                                  "initialize", rg_initialize, -1);
+                rb_define_method(initialize_module,
+                                 "initialize", rg_initialize, -1);
             }
 
             rb_include_module(klass, initialize_module);
@@ -1092,8 +1084,8 @@ Init_gobject_gobject(void)
 
     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);
+    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");
@@ -1108,7 +1100,7 @@ Init_gobject_gobject(void)
 
     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 */
+    rb_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);
     RG_DEF_METHOD(inspect, 0);

data/ext/glib2/rbgobj_param.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2011-2021  Ruby-GNOME Project Team
+ *  Copyright (C) 2011-2025  Ruby-GNOME Project Team
  *  Copyright (C) 2002,2003  Masahiro Sakai
  *
  *  This library is free software; you can redistribute it and/or
@@ -59,7 +59,7 @@ static const rb_data_type_t rg_glib_param_type = {
         pspec_mark,
         pspec_free,
     },
-    NULL,
+    &rbg_glib_instantiatable_type,
     NULL,
     RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_FROZEN_SHAREABLE,
 };
@@ -410,26 +410,26 @@ Init_gobject_gparam(void)
     /* for debugging */
     RG_DEF_METHOD(ref_count, 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, "readwrite?",
-                      param_is_G_PARAM_READWRITE, 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, "static_name?",
-                      param_is_G_PARAM_STATIC_NAME, 0);
-    rbg_define_method(RG_TARGET_NAMESPACE, "static_nick?",
-                      param_is_G_PARAM_STATIC_NICK, 0);
-    rbg_define_method(RG_TARGET_NAMESPACE, "static_blurb?",
-                      param_is_G_PARAM_STATIC_BLURB, 0);
-    rbg_define_method(RG_TARGET_NAMESPACE, "explicit_notify?",
-                      param_is_G_PARAM_EXPLICIT_NOTIFY, 0);
-    rbg_define_method(RG_TARGET_NAMESPACE, "deprecated?",
-                      param_is_G_PARAM_DEPRECATED, 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, "readwrite?",
+                     param_is_G_PARAM_READWRITE, 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, "static_name?",
+                     param_is_G_PARAM_STATIC_NAME, 0);
+    rb_define_method(RG_TARGET_NAMESPACE, "static_nick?",
+                     param_is_G_PARAM_STATIC_NICK, 0);
+    rb_define_method(RG_TARGET_NAMESPACE, "static_blurb?",
+                     param_is_G_PARAM_STATIC_BLURB, 0);
+    rb_define_method(RG_TARGET_NAMESPACE, "explicit_notify?",
+                     param_is_G_PARAM_EXPLICIT_NOTIFY, 0);
+    rb_define_method(RG_TARGET_NAMESPACE, "deprecated?",
+                     param_is_G_PARAM_DEPRECATED, 0);
 }

data/ext/glib2/rbgobj_paramspecs.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2004-2024  Ruby-GNOME Project Team
+ *  Copyright (C) 2004-2025  Ruby-GNOME Project Team
  *  Copyright (C) 2002,2003  Masahiro Sakai
  *
  *  This library is free software; you can redistribute it and/or
@@ -281,14 +281,14 @@ Init_gobject_gparamspecs(void)
 
 #define DEF_NUMERIC_PSPEC_METHODS(c, typename) \
   G_STMT_START {\
-    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); \
+    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); \
   } G_STMT_END
 
 #if 0
-    rbg_define_method(c, "default_value", typename##_default_value, 0); \
+    rb_define_method(c, "default_value", typename##_default_value, 0); \
     rb_define_alias(c, "default", "default_value"); \
 
 #endif
@@ -319,39 +319,39 @@ Init_gobject_gparamspecs(void)
 
     c = G_DEF_CLASS(G_TYPE_PARAM_FLOAT, "Float", cParamSpec);
     DEF_NUMERIC_PSPEC_METHODS(c, float);
-    rbg_define_method(c, "epsilon", float_epsilon, 0);
+    rb_define_method(c, "epsilon", float_epsilon, 0);
 
     c = G_DEF_CLASS(G_TYPE_PARAM_DOUBLE, "Double", cParamSpec);
     DEF_NUMERIC_PSPEC_METHODS(c, double);
-    rbg_define_method(c, "epsilon", double_epsilon, 0);
+    rb_define_method(c, "epsilon", double_epsilon, 0);
 
     c = G_DEF_CLASS(G_TYPE_PARAM_BOOLEAN, "Boolean", cParamSpec);
-    rbg_define_method(c, "initialize", boolean_initialize, 5);
+    rb_define_method(c, "initialize", boolean_initialize, 5);
 
     c = G_DEF_CLASS(G_TYPE_PARAM_UNICHAR, "UniChar", cParamSpec);
-    rbg_define_method(c, "initialize", unichar_initialize, 5);
+    rb_define_method(c, "initialize", unichar_initialize, 5);
 
     c = G_DEF_CLASS(G_TYPE_PARAM_ENUM, "Enum", cParamSpec);
-    rbg_define_method(c, "initialize", enum_initialize, 6);
+    rb_define_method(c, "initialize", enum_initialize, 6);
 
     c = G_DEF_CLASS(G_TYPE_PARAM_FLAGS, "Flags", cParamSpec);
-    rbg_define_method(c, "initialize", flags_initialize, 6);
+    rb_define_method(c, "initialize", flags_initialize, 6);
 
     c = G_DEF_CLASS(G_TYPE_PARAM_STRING, "String", cParamSpec);
-    rbg_define_method(c, "initialize", string_initialize, 5);
+    rb_define_method(c, "initialize", string_initialize, 5);
 
     c = G_DEF_CLASS(G_TYPE_PARAM_PARAM, "Param", cParamSpec);
-    rbg_define_method(c, "initialize", param_initialize, 5);
+    rb_define_method(c, "initialize", param_initialize, 5);
 
     c = G_DEF_CLASS(G_TYPE_PARAM_BOXED, "Boxed", cParamSpec);
-    rbg_define_method(c, "initialize", boxed_initialize, 5);
+    rb_define_method(c, "initialize", boxed_initialize, 5);
 
     c = G_DEF_CLASS(G_TYPE_PARAM_POINTER, "Pointer", cParamSpec);
-    rbg_define_method(c, "initialize", pointer_initialize, 4);
+    rb_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);
+    rb_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);
+    rb_define_method(c, "initialize", object_initialize, 5);
 }

data/ext/glib2/rbgobj_signal.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2002-2023  Ruby-GNOME Project Team
+ *  Copyright (C) 2002-2025  Ruby-GNOME Project Team
  *  Copyright (C) 2002,2003  Masahiro Sakai
  *
  *  This library is free software; you can redistribute it and/or
@@ -769,7 +769,7 @@ gobj_s_signal_handler_attach(VALUE klass,
     {
         VALUE mod = rb_define_module_under(klass, RubyGObjectHookModule);
         rb_include_module(klass, mod);
-        rbg_define_method(mod, handler_name, gobj_sig_chain_from_overridden, -1);
+        rb_define_method(mod, handler_name, gobj_sig_chain_from_overridden, -1);
     }
 
     return Qnil;
@@ -1026,13 +1026,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));
 
-    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);
+    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);
 
     /* GConnectFlags */
     G_DEF_CLASS(G_TYPE_CONNECT_FLAGS, "ConnectFlags", rbg_mGLib());
@@ -1056,40 +1056,40 @@ Init_gobject_gsignal(void)
     g_mutex_init(&rbg_signal_call_func_table_mutex);
 
     rbgobj_mMetaSignal = rb_define_module_under(rbg_mGLib(), "MetaSignal");
-    rbg_define_method(rbgobj_mMetaSignal, "define_signal", gobj_s_define_signal, -1);
+    rb_define_method(rbgobj_mMetaSignal, "define_signal", gobj_s_define_signal, -1);
     rb_define_alias(rbgobj_mMetaSignal, "signal_new", "define_signal");
-    rbg_define_method(rbgobj_mMetaSignal, "signals", gobj_s_signals, -1);
-    rbg_define_method(rbgobj_mMetaSignal, "signal", gobj_s_signal, 1);
+    rb_define_method(rbgobj_mMetaSignal, "signals", gobj_s_signals, -1);
+    rb_define_method(rbgobj_mMetaSignal, "signal", gobj_s_signal, 1);
     rb_extend_object(rbgobj_cObject, rbgobj_mMetaSignal);
     rb_extend_object(rbgobj_mInterface, rbgobj_mMetaSignal);
 
-    rbg_define_method(cInstantiatable, "signal_has_handler_pending?",
+    rb_define_method(cInstantiatable, "signal_has_handler_pending?",
                      gobj_sig_has_handler_pending, -1);
-    rbg_define_method(cInstantiatable, "signal_connect", gobj_sig_connect, -1);
-    rbg_define_method(cInstantiatable, "signal_connect_after",
+    rb_define_method(cInstantiatable, "signal_connect", gobj_sig_connect, -1);
+    rb_define_method(cInstantiatable, "signal_connect_after",
                      gobj_sig_connect_after, -1);
 
 #if 0
-    rbg_define_method(cInstantiatable, "signal_invocation_hint",
+    rb_define_method(cInstantiatable, "signal_invocation_hint",
                      gobj_sig_get_invocation_hint, 0);
 #endif
 
-    rbg_define_method(cInstantiatable, "signal_emit",
+    rb_define_method(cInstantiatable, "signal_emit",
                      gobj_sig_emit, -1);
-    rbg_define_method(cInstantiatable, "signal_emit_stop",
+    rb_define_method(cInstantiatable, "signal_emit_stop",
                      gobj_sig_emit_stop, 1);
-    rbg_define_method(cInstantiatable, "signal_handler_block",
+    rb_define_method(cInstantiatable, "signal_handler_block",
                      gobj_sig_handler_block, 1);
-    rbg_define_method(cInstantiatable, "signal_handler_unblock",
+    rb_define_method(cInstantiatable, "signal_handler_unblock",
                      gobj_sig_handler_unblock, 1);
-    rbg_define_method(cInstantiatable, "signal_handler_disconnect",
+    rb_define_method(cInstantiatable, "signal_handler_disconnect",
                      gobj_sig_handler_disconnect, 1);
 
-    rbg_define_method(cInstantiatable, "signal_handler_is_connected?",
+    rb_define_method(cInstantiatable, "signal_handler_is_connected?",
                      gobj_sig_handler_is_connected, 1);
 
-    rbg_define_singleton_method(cInstantiatable,
-                                "signal_handler_attach",
-                                gobj_s_signal_handler_attach,
-                                2);
+    rb_define_singleton_method(cInstantiatable,
+                               "signal_handler_attach",
+                               gobj_s_signal_handler_attach,
+                               2);
 }

data/ext/glib2/rbgobj_type.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2002-2023  Ruby-GNOME Project Team
+ *  Copyright (C) 2002-2025  Ruby-GNOME Project Team
  *  Copyright (C) 2002,2003  Masahiro Sakai
  *
  *  This library is free software; you can redistribute it and/or
@@ -365,14 +365,10 @@ rbgobj_class_info_lookup(VALUE klass)
     VALUE data = rb_hash_aref(klass_to_cinfo, klass);
     if (!NIL_P(data)) {
         RGObjClassInfo *cinfo;
-        if (RTYPEDDATA_P(data)) {
-            TypedData_Get_Struct(data,
-                                 RGObjClassInfo,
-                                 RTYPEDDATA_TYPE(data),
-                                 cinfo);
-        } else {
-            Data_Get_Struct(data, RGObjClassInfo, cinfo);
-        }
+        TypedData_Get_Struct(data,
+                             RGObjClassInfo,
+                             RTYPEDDATA_TYPE(data),
+                             cinfo);
         return cinfo;
     }
 
@@ -664,14 +660,10 @@ rg_s_try_convert(VALUE self, VALUE value)
             if (NIL_P(data))
                 continue;
 
-            if (RTYPEDDATA_P(data)) {
-                TypedData_Get_Struct(data,
-                                     RGObjClassInfo,
-                                     RTYPEDDATA_TYPE(data),
-                                     cinfo);
-            } else {
-                Data_Get_Struct(data, RGObjClassInfo, cinfo);
-            }
+            TypedData_Get_Struct(data,
+                                 RGObjClassInfo,
+                                 RTYPEDDATA_TYPE(data),
+                                 cinfo);
             return rb_funcall(self, id_new, 1, SIZET2NUM(cinfo->gtype));
         }
         return Qnil;