glib2 3.2.5-x64-mingw32 → 3.2.6-x64-mingw32

data/ext/glib2/rbgobj_convert.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2011-2014  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2011-2018  Ruby-GNOME2 Project Team
  *  Copyright (C) 2006  Sjoerd Simons, Masao Mutoh
  *
  *  This library is free software; you can redistribute it and/or
@@ -19,7 +19,6 @@
  *  MA  02110-1301  USA
  */
 
-#include "rbgobject.h"
 #include "rbgprivate.h"
 
 static GHashTable *tables, *class_to_g_type_map;

data/ext/glib2/rbgobj_enums.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2011-2017  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2011-2018  Ruby-GNOME2 Project Team
  *  Copyright (C) 2004-2006  Ruby-GNOME2 Project Team
  *  Copyright (C) 2002,2003  Masahiro Sakai
  *
@@ -107,18 +107,31 @@ typedef struct {
 } enum_holder;
 
 static void
-enum_free(enum_holder* p)
+enum_free(void *data)
 {
-    g_type_class_unref(p->gclass);
-    free(p);
+    enum_holder *holder = data;
+    g_type_class_unref(holder->gclass);
+    xfree(holder);
 }
 
-static enum_holder*
-enum_get_holder(VALUE obj)
+static const rb_data_type_t rg_glib_enum_type = {
+    "GLib::Enum",
+    {
+        NULL,
+        enum_free,
+        NULL,
+    },
+    NULL,
+    NULL,
+    RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static enum_holder *
+enum_get_holder(VALUE rb_enum)
 {
-    enum_holder* p;
-    Data_Get_Struct(obj, enum_holder, p);
-    return p;
+    enum_holder *holder;
+    TypedData_Get_Struct(rb_enum, enum_holder, &rg_glib_enum_type, holder);
+    return holder;
 }
 
 static VALUE
@@ -262,11 +275,16 @@ rbgobj_enum_alloc_func(VALUE self)
     if (G_TYPE_IS_ABSTRACT(gtype)) {
         rb_raise(rb_eTypeError, "abstract class");
     } else {
-        enum_holder* p;
-        VALUE result = Data_Make_Struct(self, enum_holder, NULL, enum_free, p);
-        p->gclass = g_type_class_ref(gtype);
-        p->info   = NULL;
-        return result;
+        enum_holder *holder;
+        VALUE rb_enum;
+
+        rb_enum = TypedData_Make_Struct(self,
+                                        enum_holder,
+                                        &rg_glib_enum_type,
+                                        holder);
+        holder->gclass = g_type_class_ref(gtype);
+        holder->info   = NULL;
+        return rb_enum;
     }
 }
 

data/ext/glib2/rbgobj_flags.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2004-2017  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2004-2018  Ruby-GNOME2 Project Team
  *  Copyright (C) 2002,2003  Masahiro Sakai
  *
  *  This library is free software; you can redistribute it and/or
@@ -68,18 +68,31 @@ typedef struct {
 } flags_holder;
 
 static void
-flags_free(flags_holder* p)
+flags_free(void *data)
 {
-    g_type_class_unref(p->gclass);
-    free(p);
+    flags_holder *holder = data;
+    g_type_class_unref(holder->gclass);
+    xfree(holder);
 }
 
+static const rb_data_type_t rg_glib_flags_type = {
+    "GLib::Flags",
+    {
+        NULL,
+        flags_free,
+        NULL,
+    },
+    NULL,
+    NULL,
+    RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 static flags_holder*
-flags_get_holder(VALUE obj)
+flags_get_holder(VALUE rb_flags)
 {
-    flags_holder* p;
-    Data_Get_Struct(obj, flags_holder, p);
-    return p;
+    flags_holder *holder;
+    TypedData_Get_Struct(rb_flags, flags_holder, &rg_glib_flags_type, holder);
+    return holder;
 }
 
 static VALUE
@@ -209,12 +222,16 @@ rbgobj_flags_alloc_func(VALUE self)
     if (G_TYPE_IS_ABSTRACT(gtype)) {
         rb_raise(rb_eTypeError, "abstract class");
     } else {
-        flags_holder* p;
-        VALUE result = Data_Make_Struct(self, flags_holder, NULL, flags_free, p);
-        p->gclass = g_type_class_ref(gtype);
-        p->value  = 0;
-        p->info   = NULL;
-        return result;
+        flags_holder *holder;
+        VALUE rb_flags;
+        rb_flags = TypedData_Make_Struct(self,
+                                         flags_holder,
+                                         &rg_glib_flags_type,
+                                         holder);
+        holder->gclass = g_type_class_ref(gtype);
+        holder->value  = 0;
+        holder->info   = NULL;
+        return rb_flags;
     }
 }
 

data/ext/glib2/rbgobj_param.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2011-2018  Ruby-GNOME2 Project Team
  *  Copyright (C) 2002,2003  Masahiro Sakai
  *
  *  This library is free software; you can redistribute it and/or
@@ -34,36 +34,57 @@ typedef struct {
 } pspec_holder;
 
 static void
-pspec_mark(pspec_holder *holder)
+pspec_mark(void *data)
 {
+    pspec_holder *holder = data;
     if (holder->instance)
         rbgobj_instance_call_cinfo_mark(holder->instance);
 }
 
 static void
-pspec_free(pspec_holder *holder)
+pspec_free(void *data)
 {
+    pspec_holder *holder = data;
     if (holder->instance){
         rbgobj_instance_call_cinfo_free(holder->instance);
         g_param_spec_set_qdata(holder->instance, qparamspec, NULL);
         g_param_spec_unref(holder->instance);
     }
-    free(holder);
+    xfree(holder);
+}
+
+static const rb_data_type_t rg_glib_param_type = {
+    "GLib::Param",
+    {
+        pspec_mark,
+        pspec_free,
+        NULL,
+    },
+    NULL,
+    NULL,
+    RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static pspec_holder *
+rbgobj_param_get_raw(VALUE rb_param)
+{
+    pspec_holder *holder;
+    TypedData_Get_Struct(rb_param, pspec_holder, &rg_glib_param_type, holder);
+    return holder;
 }
 
 GParamSpec*
 rbgobj_get_param_spec(VALUE obj)
 {
-    pspec_holder* holder;
-    Data_Get_Struct(obj, pspec_holder, holder);
-    return G_PARAM_SPEC(holder->instance);
+    return G_PARAM_SPEC(rbgobj_param_get_raw(obj)->instance);
 }
 
 void
 rbgobj_param_spec_initialize(VALUE self, GParamSpec *pspec)
 {
-    pspec_holder* holder;
-    Data_Get_Struct(self, pspec_holder, holder);
+    pspec_holder *holder;
+
+    holder = rbgobj_param_get_raw(self);
 
     pspec = g_param_spec_ref(pspec);
     g_param_spec_sink(pspec);
@@ -97,30 +118,29 @@ pspec_s_allocate(VALUE klass)
         rb_raise(rb_eTypeError, "abstract class");
 
     {
-        pspec_holder* holder;
-        VALUE result;
+        pspec_holder *holder;
+        VALUE rb_param;
 
-        result = Data_Make_Struct(klass, pspec_holder, pspec_mark, pspec_free,
-                                  holder);
+        rb_param = TypedData_Make_Struct(klass,
+                                         pspec_holder,
+                                         &rg_glib_param_type,
+                                         holder);
         holder->instance = NULL;
         holder->cinfo    = NULL;
 
-        return result;
+        return rb_param;
     }
 }
 
 static VALUE
 rg_inspect(VALUE self)
 {
-    GParamSpec* pspec = rbgobj_get_param_spec(self);
-    VALUE v = rb_inspect(GTYPE2CLASS(pspec->owner_type));
-    gchar* str = g_strdup_printf("#<%s: %s#%s>",
-                                 rb_class2name(CLASS_OF(self)),
-                                 StringValuePtr(v),
-                                 g_param_spec_get_name(pspec));
-    VALUE result = rb_str_new2(str);
-    g_free(str);
-    return result;
+    GParamSpec *pspec = rbgobj_get_param_spec(self);
+
+    return rb_sprintf("#<%" PRIsVALUE "%" PRIsVALUE "#%s",
+                      CLASS_OF(self),
+                      GTYPE2CLASS(pspec->owner_type),
+                      g_param_spec_get_name(pspec));
 }
 
 static VALUE

data/ext/glib2/rbgobj_signal.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2011-2018  Ruby-GNOME2 Project Team
  *  Copyright (C) 2002-2004  Ruby-GNOME2 Project Team
  *  Copyright (C) 2002,2003  Masahiro Sakai
  *
@@ -31,6 +31,40 @@ VALUE rbgobj_signal_wrap(guint sig_id);
 
 /**********************************************************************/
 
+static const rb_data_type_t rg_glib_signal_type = {
+    "GLib::Signal",
+    {
+        NULL,
+        NULL,
+        NULL,
+    },
+    NULL,
+    NULL,
+    RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+VALUE
+rbgobj_signal_new(guint id)
+{
+    VALUE rb_query;
+    GSignalQuery *query;
+
+    rb_query = TypedData_Make_Struct(RG_TARGET_NAMESPACE,
+                                     GSignalQuery,
+                                     &rg_glib_signal_type,
+                                     query);
+    g_signal_query(id, query);
+    return rb_query;
+}
+
+static GSignalQuery *
+rbgobj_signal_get_raw(VALUE rb_signal)
+{
+    GSignalQuery *query;
+    TypedData_Get_Struct(rb_signal, GSignalQuery, &rg_glib_signal_type, query);
+    return query;
+}
+
 static VALUE signal_func_table;
 
 void
@@ -164,7 +198,7 @@ rbg_rval2gtypes_accept_nil(volatile VALUE *value, long *n)
 #define RVAL2GTYPES_ACCEPT_NIL(value, n) rbg_rval2gtypes_accept_nil(&(value), &(n))
 
 static VALUE
-gobj_s_signal_new(int argc, VALUE* argv, VALUE self)
+gobj_s_define_signal(int argc, VALUE* argv, VALUE self)
 {
     const RGObjClassInfo *cinfo = rbgobj_lookup_class(self);
     VALUE rbsignal_name, rbsignal_flags, accumulator, rbreturn_type, params;
@@ -175,6 +209,7 @@ gobj_s_signal_new(int argc, VALUE* argv, VALUE self)
     GType *param_types;
     long n_params;
     guint signal;
+    VALUE rb_signal;
 
     rb_scan_args(argc, argv, "4*",
                  &rbsignal_name, &rbsignal_flags, &accumulator, &rbreturn_type, &params);
@@ -187,20 +222,23 @@ gobj_s_signal_new(int argc, VALUE* argv, VALUE self)
         rbsignal_name = rb_str_new2(rb_id2name(SYM2ID(rbsignal_name)));
     signal_name = RVAL2CSTR(rbsignal_name);
 
-    signal_flags = NUM2INT(rbsignal_flags);
+    signal_flags = RVAL2GFLAGS(rbsignal_flags, G_TYPE_SIGNAL_FLAGS);
 
     {
+        VALUE rb_method_name;
         VALUE proc;
         ID method_id;
 
-        method_id = rb_to_id(rb_str_concat(rb_str_new2(default_handler_method_prefix), rbsignal_name));
+        rb_method_name =
+            rb_str_concat(rb_str_new_cstr(default_handler_method_prefix),
+                          rbsignal_name);
+        method_id = rb_to_id(rb_method_name);
 
         proc = rb_funcall(mMetaInterface, rb_intern("signal_callback"), 2,
                           self, ID2SYM(method_id));
 
         class_closure = g_rclosure_new(proc, Qnil, NULL);
-        /* TODO: Should this be done even if something below it fails? */
-        g_rclosure_attach(class_closure, self);
+        g_rclosure_set_tag(class_closure, RVAL2CSTR(rb_method_name));
     }
 
     return_type = rbgobj_gtype_get(rbreturn_type);
@@ -222,10 +260,13 @@ gobj_s_signal_new(int argc, VALUE* argv, VALUE self)
     if (!signal)
         rb_raise(rb_eRuntimeError, "g_signal_newv failed");
 
+    rb_signal = rbgobj_signal_new(signal);
     if (!NIL_P(accumulator))
-        G_RELATIVE(self, accumulator); /* FIXME */
+        rbgobj_add_relative(rb_signal, accumulator);
+    g_rclosure_attach(class_closure, rb_signal);
+    rbgobj_add_relative(self, rb_signal);
 
-    return rbgobj_signal_wrap(signal);
+    return rb_signal;
 }
 
 static void
@@ -280,7 +321,7 @@ gobj_s_signal(VALUE self, VALUE name)
     if (!sig_id)
         rb_raise(eNoSignalError, "no such signal: %s", sig_name);
 
-    return rbgobj_signal_wrap(sig_id);
+    return rbgobj_signal_new(sig_id);
 }
 
 static VALUE
@@ -338,7 +379,7 @@ gobj_sig_connect_impl(gboolean after, int argc, VALUE *argv, VALUE self)
         CONST_ID(id_create_signal_handler, "create_signal_handler");
         normalized_signal_name = g_signal_name(signal_id);
         func = rb_funcall(self,
-                          rb_intern("create_signal_handler"),
+                          id_create_signal_handler,
                           2,
                           rb_str_new_cstr(normalized_signal_name),
                           rb_block_proc());
@@ -388,7 +429,7 @@ gobj_sig_get_invocation_hint(VALUE self)
     GSignalInvocationHint* hint;
     hint = g_signal_get_invocation_hint(RVAL2GOBJ(self));
     return rb_ary_new3(3,
-                       rbgobj_signal_wrap(hint->signal_id),
+                       rbgobj_signal_new(hint->signal_id),
                        hint->detail ? rb_str_new2(g_quark_to_string(hint->detail)) : Qnil,
                        INT2NUM(hint->run_type));
 }
@@ -689,71 +730,54 @@ gobj_s_method_added(VALUE klass, VALUE id)
 VALUE
 rbgobj_signal_wrap(guint sig_id)
 {
-    VALUE result;
-    GSignalQuery* query;
-
-    result = Data_Make_Struct(RG_TARGET_NAMESPACE, GSignalQuery, NULL, free, query);
-    g_signal_query(sig_id, query);
-    return result;
+    return rbgobj_signal_new(sig_id);
 }
 
 static VALUE
 rg_id(VALUE self)
 {
-    GSignalQuery* query;
-    Data_Get_Struct(self, GSignalQuery, query);
-    return UINT2NUM(query->signal_id);
+    return UINT2NUM(rbgobj_signal_get_raw(self)->signal_id);
 }
 
 static VALUE
 rg_name(VALUE self)
 {
-    GSignalQuery* query;
-    Data_Get_Struct(self, GSignalQuery, query);
-    return rb_str_new2(query->signal_name);
+    return CSTR2RVAL(rbgobj_signal_get_raw(self)->signal_name);
 }
 
 static VALUE
 rg_itype(VALUE self)
 {
-    GSignalQuery* query;
-    Data_Get_Struct(self, GSignalQuery, query);
-    return rbgobj_gtype_new(query->itype);
+    return rbgobj_gtype_new(rbgobj_signal_get_raw(self)->itype);
 }
 
 static VALUE
 rg_owner(VALUE self)
 {
-    GSignalQuery* query;
-    Data_Get_Struct(self, GSignalQuery, query);
-    return GTYPE2CLASS(query->itype);
+    return GTYPE2CLASS(rbgobj_signal_get_raw(self)->itype);
 }
 
 static VALUE
 rg_return_type(VALUE self)
 {
-    GSignalQuery* query;
-    Data_Get_Struct(self, GSignalQuery, query);
-    return rbgobj_gtype_new(query->return_type);
+    return rbgobj_gtype_new(rbgobj_signal_get_raw(self)->return_type);
 }
 
 static VALUE
 rg_flags(VALUE self)
 {
-    GSignalQuery* query;
-    Data_Get_Struct(self, GSignalQuery, query);
-    return UINT2NUM(query->signal_flags);
+    return UINT2NUM(rbgobj_signal_get_raw(self)->signal_flags);
 }
 
 static VALUE
 rg_param_types(VALUE self)
 {
-    GSignalQuery* query;
+    GSignalQuery *query;
     VALUE result;
     guint i;
-    Data_Get_Struct(self, GSignalQuery, query);
 
-    result = rb_ary_new2(query->n_params);
+    query = rbgobj_signal_get_raw(self);
+    result = rb_ary_new_capa(query->n_params);
     for (i = 0; i < query->n_params; i++)
         rb_ary_store(result, i, rbgobj_gtype_new(query->param_types[i]));
 
@@ -763,31 +787,19 @@ rg_param_types(VALUE self)
 static VALUE
 rg_inspect(VALUE self)
 {
-    GSignalQuery* query;
-    gchar* s;
-    VALUE result, v;
-
-    Data_Get_Struct(self, GSignalQuery, query);
-
-    v = rb_inspect(GTYPE2CLASS(query->itype));
-
-    s = g_strdup_printf("#<%s: %s#%s>",
-                        rb_class2name(CLASS_OF(self)),
-                        StringValuePtr(v),
-                        query->signal_name);
-    result = rb_str_new2(s);
-    g_free(s);
-
-    return result;
+    GSignalQuery *query;
+    query = rbgobj_signal_get_raw(self);
+    return rb_sprintf("#<%" PRIsVALUE " %+" PRIsVALUE "#%s>",
+                      CLASS_OF(self),
+                      GTYPE2CLASS(query->itype),
+                      query->signal_name);
 }
 
 #define query_is_flag(flag) \
     static VALUE \
     query_is_##flag(VALUE self) \
     { \
-        GSignalQuery* query; \
-        Data_Get_Struct(self, GSignalQuery, query); \
-        return CBOOL2RVAL(query->signal_flags & flag); \
+        return CBOOL2RVAL(rbgobj_signal_get_raw(self)->signal_flags & flag); \
     }
 
 query_is_flag(G_SIGNAL_RUN_FIRST)
@@ -804,8 +816,8 @@ hook_func(GSignalInvocationHint* ihint,
           const GValue*          param_values,
           gpointer               data)
 {
-    GClosure* closure = data;
-    GValue ret_val =G_VALUE_INIT;
+    GClosure *closure = data;
+    GValue ret_val = G_VALUE_INIT;
     gboolean ret;
 
     g_value_init(&ret_val, G_TYPE_BOOLEAN);
@@ -833,13 +845,13 @@ g_signal_add_emission_hook_closure (guint     signal_id,
 static VALUE
 rg_add_emission_hook(int argc, VALUE* argv, VALUE self)
 {
-    GSignalQuery* query;
+    GSignalQuery *query;
     VALUE proc;
     guint hook_id;
     GQuark detail = 0;
     GClosure* closure;
 
-    Data_Get_Struct(self, GSignalQuery, query);
+    query = rbgobj_signal_get_raw(self);
 
     if (query->signal_flags & G_SIGNAL_DETAILED) {
         VALUE detail_obj;
@@ -847,7 +859,7 @@ rg_add_emission_hook(int argc, VALUE* argv, VALUE self)
             if (SYMBOL_P(detail_obj))
                 detail = g_quark_from_string(rb_id2name(SYM2ID(detail_obj)));
             else
-                detail = g_quark_from_string(StringValuePtr(detail_obj));
+                detail = g_quark_from_string(RVAL2CSTR(detail_obj));
         }
     } else {
         rb_scan_args(argc, argv, "00&", &proc);
@@ -863,9 +875,8 @@ rg_add_emission_hook(int argc, VALUE* argv, VALUE self)
 static VALUE
 rg_remove_emission_hook(VALUE self, VALUE hook_id)
 {
-    GSignalQuery* query;
-    Data_Get_Struct(self, GSignalQuery, query);
-    g_signal_remove_emission_hook(query->signal_id, NUM2ULONG(hook_id));
+    g_signal_remove_emission_hook(rbgobj_signal_get_raw(self)->signal_id,
+                                  NUM2ULONG(hook_id));
     return Qnil;
 }
 
@@ -983,7 +994,8 @@ Init_gobject_gsignal(void)
     signal_call_func_table = rb_hash_new();
     rb_global_variable(&signal_call_func_table);
 
-    rbg_define_method(mMetaInterface, "signal_new", gobj_s_signal_new, -1);
+    rbg_define_method(mMetaInterface, "define_signal", gobj_s_define_signal, -1);
+    rb_define_alias(mMetaInterface, "signal_new", "define_signal");
     rbg_define_method(mMetaInterface, "signals", gobj_s_signals, -1);
     rbg_define_method(mMetaInterface, "signal", gobj_s_signal, 1);