glib2 2.2.5 → 3.0.1

data/ext/glib2/rbgobj_flags.c

@@ -1,7 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2011  Ruby-GNOME2 Project Team
- *  Copyright (C) 2004-2006  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2004-2015  Ruby-GNOME2 Project Team
  *  Copyright (C) 2002,2003  Masahiro Sakai
  *
  *  This library is free software; you can redistribute it and/or
@@ -30,33 +29,10 @@ VALUE RG_TARGET_NAMESPACE;
 static ID id_new;
 static ID id_module_eval;
 static ID id_or;
+static ID id_to_i;
 
 /**********************************************************************/
 
-static VALUE
-resolve_flags_value(VALUE klass, VALUE nick_or_nicks)
-{
-    int i, len;
-    VALUE flags_value;
-
-    if (!RVAL2CBOOL(rb_obj_is_kind_of(nick_or_nicks, rb_cArray)))
-        return rg_enum_resolve_value(klass, nick_or_nicks);
-
-    len = RARRAY_LEN(nick_or_nicks);
-    flags_value = rb_funcall(klass, id_new, 0);
-    for (i = 0; i < len; i++) {
-        VALUE value;
-
-        value = rg_enum_resolve_value(klass, RARRAY_PTR(nick_or_nicks)[i]);
-        if (NIL_P(value))
-            return Qnil;
-
-        flags_value = rb_funcall(flags_value, id_or, 1, value);
-    }
-
-    return flags_value;
-}
-
 void
 rg_flags_add_constants(VALUE mod, GType flags_type, const gchar *strip_prefix)
 {
@@ -127,25 +103,13 @@ rbgobj_get_flags(VALUE obj, GType gtype)
         rb_raise(rb_eTypeError, "%s is not a %s",
                  g_type_name(gtype), g_type_name(G_TYPE_FLAGS));
 
-    /* for compatibility */
-    if (rb_obj_is_kind_of(obj, rb_cInteger))
-        obj = rbgobj_make_flags(NUM2UINT(obj), gtype);
-
     klass = GTYPE2CLASS(gtype);
 
-    if (!rb_obj_is_kind_of(obj, klass)) {
-        VALUE flags_value = Qnil;
-
-        flags_value = resolve_flags_value(klass, obj);
-        if (!NIL_P(flags_value))
-            obj = flags_value;
+    if (!RVAL2CBOOL(rb_obj_is_kind_of(obj, klass))) {
+        obj = rb_funcall(klass, id_new, 1, obj);
     }
 
-    if (rb_obj_is_kind_of(obj, klass))
-        return flags_get_holder(obj)->value;
-    else
-        rb_raise(rb_eTypeError, "not a %s: %s",
-                 rb_class2name(klass), RBG_INSPECT(obj));
+    return flags_get_holder(obj)->value;
 }
 
 /**********************************************************************/
@@ -251,29 +215,80 @@ flags_s_allocate(VALUE self)
     }
 }
 
+static guint
+resolve_flags_value(VALUE klass, GFlagsClass *gclass, VALUE flag_or_flags)
+{
+    guint value = 0;
+
+    switch (TYPE(flag_or_flags)) {
+    case RUBY_T_NIL:
+        value = 0;
+        break;
+    case RUBY_T_FIXNUM:
+    case RUBY_T_BIGNUM:
+        value = NUM2UINT(flag_or_flags);
+        break;
+    case RUBY_T_STRING:
+    case RUBY_T_SYMBOL:
+    {
+        const gchar *name;
+        GFlagsValue *info;
+
+        name = RVAL2CSTR_ACCEPT_SYMBOL(flag_or_flags);
+        info = g_flags_get_value_by_name(gclass, name);
+        if (!info) {
+            gchar *nick;
+            nick = rbg_name_to_nick(name);
+            info = g_flags_get_value_by_nick(gclass, nick);
+            g_free(nick);
+        }
+        if (!info) {
+            rb_raise(rb_eArgError,
+                     "unknown flag name: <%s>(%s)",
+                     name,
+                     g_type_name(G_TYPE_FROM_CLASS(gclass)));
+        }
+        value = info->value;
+        break;
+    }
+    case RUBY_T_ARRAY:
+    {
+        int i, n;
+        n = RARRAY_LEN(flag_or_flags);
+        for (i = 0; i < n; i++) {
+            value |= resolve_flags_value(klass,
+                                         gclass,
+                                         RARRAY_PTR(flag_or_flags)[i]);
+        }
+        break;
+    }
+    default:
+        if (RVAL2CBOOL(rb_obj_is_kind_of(flag_or_flags, klass))) {
+            value = NUM2UINT(rb_funcall(flag_or_flags, id_to_i, 0));
+        } else {
+            rb_raise(rb_eArgError,
+                     "flag value must be one of "
+                     "nil, Fixnum, String, Symbol, %s or Array of them: "
+                     "<%s>(%s)",
+                     RBG_INSPECT(klass),
+                     RBG_INSPECT(flag_or_flags),
+                     g_type_name(G_TYPE_FROM_CLASS(gclass)));
+        }
+        break;
+    }
+
+    return value;
+}
+
 static VALUE
 rg_initialize(int argc, VALUE* argv, VALUE self)
 {
     flags_holder* p = flags_get_holder(self);
-    VALUE arg;
+    VALUE flag_or_flags;
 
-    rb_scan_args(argc, argv, "01", &arg);
+    rb_scan_args(argc, argv, "01", &flag_or_flags);
 
-    if (argc == 0) {
-        p->value = 0;
-    } else {
-        if (rb_respond_to(arg, rb_intern("to_str"))) {
-            const char* str = StringValuePtr(arg);
-            p->info = g_flags_get_value_by_name(p->gclass, str);
-            if (!p->info)
-                p->info = g_flags_get_value_by_nick(p->gclass, str);
-            if (!p->info)
-                rb_raise(rb_eArgError, "invalid argument");
-            p->value = p->info->value;
-        } else {
-            p->value = NUM2UINT(arg);
-        }
-    }
+    p->value = resolve_flags_value(CLASS_OF(self), p->gclass, flag_or_flags);
 
     if (!p->info) {
         guint i;
@@ -316,27 +331,56 @@ rg_nick(VALUE self)
 #define FLAGS_COMP_ELSE         -2
 #define FLAGS_COMP_INCOMPARABLE -3
 
+typedef struct {
+    GType gtype;
+    VALUE rb_value;
+    guint value;
+    gboolean compatible;
+} compare_data;
+
+static VALUE
+flags_compare_get_flags_body(VALUE user_data)
+{
+    compare_data *data = (compare_data *)user_data;
+
+    data->value = rbgobj_get_flags(data->rb_value, data->gtype);
+    data->compatible = TRUE;
+
+    return Qnil;
+}
+
+static VALUE
+flags_compare_get_flags_rescue(VALUE user_data)
+{
+    compare_data *data = (compare_data *)user_data;
+
+    data->compatible = FALSE;
+
+    return Qnil;
+}
+
 static gint
 flags_compare(VALUE self, VALUE rhs)
 {
     flags_holder* p = flags_get_holder(self);
-    GType gtype = G_TYPE_FROM_CLASS(p->gclass);
-    VALUE klass = GTYPE2CLASS(gtype);
-    guint rhs_val;
+    compare_data data;
 
-    if (!rb_obj_is_kind_of(rhs, rb_cInteger)) {
-        rhs = resolve_flags_value(klass, rhs);
-        if (CLASS_OF(rhs) != CLASS_OF(self))
-            return FLAGS_COMP_INCOMPARABLE;
-    }
+    data.gtype = G_TYPE_FROM_CLASS(p->gclass);
+    data.rb_value = rhs;
+    data.value = 0;
+    data.compatible = TRUE;
 
-    rhs_val = rbgobj_get_flags(rhs, gtype);
+    rb_rescue(flags_compare_get_flags_body, (VALUE)&data,
+              flags_compare_get_flags_rescue, (VALUE)&data);
+    if (!data.compatible) {
+        return FLAGS_COMP_INCOMPARABLE;
+    }
 
-    if (p->value == rhs_val)
+    if (p->value == data.value)
         return FLAGS_COMP_EQUAL;
-    else if ((p->value & rhs_val) == rhs_val)
+    else if ((p->value & data.value) == data.value)
         return FLAGS_COMP_GREATER;
-    else if ((p->value & rhs_val) == p->value)
+    else if ((p->value & data.value) == p->value)
         return FLAGS_COMP_LESS;
     else
         return FLAGS_COMP_ELSE;
@@ -476,6 +520,7 @@ Init_gobject_gflags(void)
     id_module_eval = rb_intern("module_eval");
     id_new = rb_intern("new");
     id_or = rb_intern("|");
+    id_to_i = rb_intern("to_i");
 
     RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_FLAGS, "Flags", mGLib);
 

data/ext/glib2/rbgobj_object.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2011-2015  Ruby-GNOME2 Project Team
  *  Copyright (C) 2002-2004  Ruby-GNOME2 Project Team
  *  Copyright (C) 2002-2003  Masahiro Sakai
  *  Copyright (C) 1998-2000 Yukihiro Matsumoto,
@@ -170,15 +170,6 @@ rbgobj_init_object_class(VALUE klass)
 
 /**********************************************************************/
 
-static gboolean
-is_gtkobject(GObject *gobj)
-{
-    static GType gtype_gtkobject = G_TYPE_INVALID;
-    if (!gtype_gtkobject)
-        gtype_gtkobject = g_type_from_name("GtkObject");
-    return gtype_gtkobject && g_type_is_a(G_OBJECT_TYPE(gobj), gtype_gtkobject);
-}
-
 static void
 gobj_mark(gpointer ptr)
 {
@@ -227,15 +218,7 @@ rg_s_new_bang(int argc, VALUE *argv, VALUE self)
 
     gobj = rbgobj_gobject_new(cinfo->gtype, params_hash);
     result = GOBJ2RVAL(gobj);
-
-    // XXX: Ughhhhh
-    if (is_gtkobject(gobj)){
-        // We can't call gtk_object_sink() here.
-        // But hopefully someone will call it in the future.
-        //gtk_object_sink(gobj);
-    } else {
-        g_object_unref(gobj);
-    }
+    g_object_unref(gobj);
 
     return result;
 }
@@ -637,6 +620,35 @@ rg_type_name(VALUE self)
     return CSTR2RVAL(G_OBJECT_TYPE_NAME(RVAL2GOBJ(self)));
 }
 
+#if GLIB_CHECK_VERSION(2, 26, 0)
+static VALUE
+rg_bind_property(VALUE self,
+                 VALUE rb_source_property,
+                 VALUE rb_target,
+                 VALUE rb_target_property,
+                 VALUE rb_flags)
+{
+    gpointer source;
+    const gchar *source_property;
+    gpointer target;
+    const gchar *target_property;
+    GBindingFlags flags;
+    GBinding *binding;
+
+    source = RVAL2GOBJ(self);
+    source_property = RVAL2CSTR(rb_source_property);
+    target = RVAL2GOBJ(rb_target);
+    target_property = RVAL2CSTR(rb_target_property);
+    flags = RVAL2GBINDINGFLAGS(rb_flags);
+
+    binding = g_object_bind_property(source, source_property,
+                                     target, target_property,
+                                     flags);
+
+    return GOBJ2RVAL(binding);
+}
+#endif
+
 static VALUE
 rg_initialize(int argc, VALUE *argv, VALUE self)
 {
@@ -658,13 +670,6 @@ rg_initialize(int argc, VALUE *argv, VALUE self)
 
     gobj = rbgobj_gobject_new(RVAL2GTYPE(self), params_hash);
 
-    if (is_gtkobject(gobj)){
-        gobj = g_object_ref(gobj);
-        // We can't call gtk_object_sink() here.
-        // But hopefully someone will call it in the future.
-        //gtk_object_sink(gobj);
-    }
-
     G_INITIALIZE(self, gobj);
     return Qnil;
 }
@@ -679,7 +684,6 @@ gobj_ref_count(VALUE self)
 
 /**********************************************************************/
 
-static VALUE proc_mod_eval;
 static GQuark q_ruby_setter;
 static GQuark q_ruby_getter;
 
@@ -732,55 +736,51 @@ set_prop_func(GObject* object,
     rb_funcall(GOBJ2RVAL(object), ruby_setter, 1, GVAL2RVAL(value));
 }
 
-// FIXME: use rb_protect
-static void
-class_init_func(gpointer g_class_, G_GNUC_UNUSED gpointer class_data)
+void
+rbgobj_class_init_func(gpointer g_class, G_GNUC_UNUSED gpointer class_data)
 {
-    GObjectClass* g_class = G_OBJECT_CLASS(g_class_);
+    GObjectClass* g_object_class = G_OBJECT_CLASS(g_class);
 
-    g_class->set_property = set_prop_func;
-    g_class->get_property = get_prop_func;
-
-#if 0
-    VALUE class_init_proc = (VALUE)class_data;
-    rb_funcall(proc_mod_eval, rb_intern("call"), 2,
-               GTYPE2CLASS(G_TYPE_FROM_CLASS(g_class)), class_init_proc);
-#endif
+    g_object_class->set_property = set_prop_func;
+    g_object_class->get_property = get_prop_func;
 }
 
-static VALUE
-rg_s_type_register(int argc, VALUE* argv, VALUE self)
+void
+rbgobj_register_type(VALUE klass, VALUE type_name, GClassInitFunc class_init)
 {
-    VALUE type_name, flags;
-    volatile VALUE class_init_proc = Qnil;
     GType parent_type;
-    GTypeInfo* info;
-
-    rb_scan_args(argc, argv, "03", &type_name, &info, &flags);
+    GTypeInfo *info;
 
     {
-        const RGObjClassInfo* cinfo = rbgobj_lookup_class(self);
-        if (cinfo->klass == self)
-            rb_raise(rb_eTypeError, "already registered");
+        const RGObjClassInfo *cinfo = rbgobj_lookup_class(klass);
+        if (cinfo->klass == klass)
+            rb_raise(rb_eTypeError,
+                     "already registered class: <%s>",
+                     RBG_INSPECT(klass));
     }
 
     {
-        VALUE superclass = rb_funcall(self, rb_intern("superclass"), 0);
-        const RGObjClassInfo* cinfo = rbgobj_lookup_class(superclass);
+        VALUE superclass = rb_funcall(klass, rb_intern("superclass"), 0);
+        const RGObjClassInfo *cinfo = rbgobj_lookup_class(superclass);
         if (cinfo->klass != superclass)
-            rb_raise(rb_eTypeError, "super class must be registered to GLib");
+            rb_raise(rb_eTypeError,
+                     "super class must be registered to GLib: <%s>",
+                     RBG_INSPECT(superclass));
         parent_type = cinfo->gtype;
     }
 
     if (NIL_P(type_name)) {
-        VALUE s = rb_funcall(self, rb_intern("name"), 0);
+        VALUE klass_name = rb_funcall(klass, rb_intern("name"), 0);
 
-        if (strlen(StringValuePtr(s)) == 0)
-            rb_raise(rb_eTypeError, "can't determine type name");
+        if (strlen(StringValueCStr(klass_name)) == 0)
+            rb_raise(rb_eTypeError,
+                     "can't determine type name: <%s>",
+                     RBG_INSPECT(klass));
 
-        type_name = rb_funcall(
-            rb_eval_string("lambda{|x| x.gsub(/::/,'') }"),
-            rb_intern("call"), 1, s);
+        type_name = rb_funcall(klass_name, rb_intern("gsub"),
+                               2,
+                               rb_str_new_cstr("::"),
+                               rb_str_new_cstr(""));
     }
 
     {
@@ -793,9 +793,9 @@ rg_s_type_register(int argc, VALUE* argv, VALUE self)
         info->class_size     = query.class_size;
         info->base_init      = NULL;
         info->base_finalize  = NULL;
-        info->class_init     = class_init_func;
+        info->class_init     = class_init;
         info->class_finalize = NULL;
-        info->class_data     = (gpointer)class_init_proc;
+        info->class_data     = NULL;
         info->instance_size  = query.instance_size;
         info->n_preallocs    = 0;
         info->instance_init  = NULL;
@@ -804,37 +804,49 @@ rg_s_type_register(int argc, VALUE* argv, VALUE self)
 
     {
         GType type = g_type_register_static(parent_type,
-                                            StringValuePtr(type_name),
+                                            StringValueCStr(type_name),
                                             info,
-                                            NIL_P(flags) ? 0 : NUM2INT(flags));
-        G_RELATIVE(self, class_init_proc);
+                                            0);
 
-        rbgobj_register_class(self, type, TRUE, TRUE);
+        rbgobj_register_class(klass, type, TRUE, TRUE);
 
         {
-            RGObjClassInfo* cinfo = (RGObjClassInfo*)rbgobj_lookup_class(self);
+            RGObjClassInfo *cinfo = (RGObjClassInfo *)rbgobj_lookup_class(klass);
             cinfo->flags |= RBGOBJ_DEFINED_BY_RUBY;
         }
 
         {
             GType parent = g_type_parent(type);
-            const RGObjClassInfo* cinfo =  GTYPE2CINFO(parent);
-            VALUE m = rb_define_module_under(self, RubyGObjectHookModule);
-
-            if (! (cinfo->flags & RBGOBJ_DEFINED_BY_RUBY)) {
-                rbg_define_method(m, "initialize", rg_initialize, -1);
+            const RGObjClassInfo *cinfo =  GTYPE2CINFO(parent);
+            VALUE initialize_module;
+
+            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_include_module(self, m);
+            rb_include_module(klass, initialize_module);
         }
-
-        return Qnil;
     }
 }
 
+static VALUE
+rg_s_type_register(int argc, VALUE *argv, VALUE self)
+{
+    VALUE type_name;
+
+    rb_scan_args(argc, argv, "01", &type_name);
+
+    rbgobj_register_type(self, type_name, rbgobj_class_init_func);
+
+    return Qnil;
+}
+
 /**********************************************************************/
 
-void 
+void
 Init_gobject_gobject(void)
 {
     RG_TARGET_NAMESPACE = G_DEF_CLASS_WITH_GC_FUNC(G_TYPE_OBJECT, "Object", mGLib,
@@ -869,6 +881,11 @@ Init_gobject_gobject(void)
     RG_DEF_METHOD(inspect, 0);
     RG_DEF_METHOD(type_name, 0);
 
+#if GLIB_CHECK_VERSION(2, 26, 0)
+    RG_DEF_METHOD(bind_property, 4);
+    G_DEF_CLASS(G_TYPE_BINDING_FLAGS, "BindingFlags", mGLib);
+#endif
+
     eNoPropertyError = rb_define_class_under(mGLib, "NoPropertyError",
                                              rb_eNameError);
 
@@ -879,7 +896,4 @@ Init_gobject_gobject(void)
 
     /* subclass */
     RG_DEF_SMETHOD(type_register, -1);
-
-    rb_global_variable(&proc_mod_eval);
-    proc_mod_eval = rb_eval_string("lambda{|obj,proc| obj.module_eval(&proc)}");
 }