glib2 2.2.5 → 3.0.1

data/ext/glib2/rbglib-variant.c

@@ -0,0 +1,132 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2015  Ruby-GNOME2 Project Team
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#include "rbgprivate.h"
+
+#define RG_TARGET_NAMESPACE cVariant
+
+#define _SELF(s) (DATA_PTR(s))
+
+static VALUE RG_TARGET_NAMESPACE;
+
+VALUE
+rbg_variant_to_ruby(GVariant *variant)
+{
+    const GVariantType *type;
+
+    if (!variant) {
+        return Qnil;
+    }
+
+    type = g_variant_get_type(variant);
+
+    if (g_variant_type_equal(type, G_VARIANT_TYPE_BOOLEAN)) {
+        return CBOOL2RVAL(g_variant_get_boolean(variant));
+    } else if (g_variant_type_equal(type, G_VARIANT_TYPE_STRING)) {
+        const gchar *string;
+        gsize string_length;
+        string = g_variant_get_string(variant, &string_length);
+        return CSTR2RVAL_LEN(string, string_length);
+    } else {
+        rb_raise(rb_eNotImpError,
+                 "TODO: GVariant(%.*s) -> Ruby",
+                 (int)g_variant_type_get_string_length(type),
+                 g_variant_type_peek_string(type));
+    }
+
+    return Qnil;
+}
+
+GVariant *
+rbg_variant_from_ruby(VALUE rb_variant)
+{
+    if (NIL_P(rb_variant)) {
+        return NULL;
+    } else {
+        return _SELF(rb_variant);
+    }
+}
+
+static void
+rg_variant_free(gpointer object)
+{
+    GVariant *variant = object;
+
+    g_variant_unref(variant);
+}
+
+static VALUE
+rg_variant_allocate(VALUE klass)
+{
+    return Data_Wrap_Struct(klass, NULL, rg_variant_free, NULL);
+}
+
+static VALUE
+rg_initialize(VALUE self, VALUE rb_value)
+{
+    GVariant *variant;
+
+    switch (rb_type(rb_value)) {
+      case RUBY_T_STRING:
+        variant = g_variant_new_string(RVAL2CSTR(rb_value));
+        break;
+      default:
+        rb_raise(rb_eNotImpError,
+                 "TODO: Ruby -> GVariant: %s",
+                 RBG_INSPECT(rb_value));
+        break;
+    }
+    g_variant_ref_sink(variant);
+    DATA_PTR(self) = variant;
+
+    return Qnil;
+}
+
+static VALUE
+rg_value(VALUE self)
+{
+    GVariant *variant;
+
+    variant = _SELF(self);
+
+    return rbg_variant_to_ruby(variant);
+}
+
+static VALUE
+rg_type(VALUE self)
+{
+    GVariant *variant;
+
+    variant = _SELF(self);
+
+    return GVARIANTTYPE2RVAL((GVariantType *)g_variant_get_type(variant));
+}
+
+void
+Init_glib_variant(void)
+{
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_VARIANT, "Variant", mGLib);
+
+    rb_define_alloc_func(RG_TARGET_NAMESPACE, rg_variant_allocate);
+
+    RG_DEF_METHOD(initialize, 1);
+    RG_DEF_METHOD(value, 0);
+    RG_DEF_METHOD(type, 0);
+}

data/ext/glib2/rbglib.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2011-2013  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2011-2015  Ruby-GNOME2 Project Team
  *  Copyright (C) 2002,2003  Masahiro Sakai
  *
  *  This library is free software; you can redistribute it and/or
@@ -34,6 +34,19 @@ rbg_rval2cstr(VALUE *str)
 {
     StringValue(*str);
 
+#ifdef HAVE_RUBY_ENCODING_H
+    if (rb_enc_get(*str) != rb_utf8_encoding())
+        *str = rb_str_export_to_enc(*str, rb_utf8_encoding());
+#endif
+
+    return StringValueCStr(*str);
+}
+
+const gchar *
+rbg_rval2cstr_ptr(VALUE *str)
+{
+    StringValue(*str);
+
 #ifdef HAVE_RUBY_ENCODING_H
     if (rb_enc_get(*str) != rb_utf8_encoding())
         *str = rb_str_export_to_enc(*str, rb_utf8_encoding());
@@ -1155,4 +1168,6 @@ union       GDoubleIEEE754;
     Init_glib_unichar();
     Init_glib_keyfile();
     Init_glib_bookmark_file();
+    Init_glib_variant_type();
+    Init_glib_variant();
 }

data/ext/glib2/rbglib.h

@@ -1,7 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2011-2014  Ruby-GNOME2 Project Team
- *  Copyright (C) 2002-2005  Ruby-GNOME2 Project
+ *  Copyright (C) 2002-2015  Ruby-GNOME2 Project Team
  *  Copyright (C) 2002,2003  Masahiro Sakai
  *
  *  This library is free software; you can redistribute it and/or
@@ -21,6 +20,7 @@
  */
 
 #include <glib-object.h>
+#include "glib-enum-types.h"
 
 #include "ruby.h"
 
@@ -34,9 +34,9 @@
 extern "C" {
 #endif /* __cplusplus */
 
-#define RBGLIB_MAJOR_VERSION 2
-#define RBGLIB_MINOR_VERSION 2
-#define RBGLIB_MICRO_VERSION 5
+#define RBGLIB_MAJOR_VERSION 3
+#define RBGLIB_MINOR_VERSION 0
+#define RBGLIB_MICRO_VERSION 1
 
 #ifndef RSTRING_PTR
 #  define RSTRING_PTR(s) (RSTRING(s)->ptr)
@@ -44,8 +44,12 @@ extern "C" {
 #endif
 
 #ifndef RARRAY_PTR
-#  define RARRAY_PTR(s) (RARRAY(s)->ptr)
-#  define RARRAY_LEN(s) (RARRAY(s)->len)
+#  define RARRAY_PTR(a) (RARRAY(a)->ptr)
+#  define RARRAY_LEN(a) (RARRAY(a)->len)
+#endif
+
+#ifndef RARRAY_CONST_PTR
+#  define RARRAY_CONST_PTR(a) RARRAY_PTR(a)
 #endif
 
 #ifndef DBL2NUM
@@ -67,6 +71,7 @@ extern "C" {
 #define RBG_INSPECT(object) (rbg_rval_inspect(object))
 
 #define RVAL2CSTR(v) (rbg_rval2cstr(&(v)))
+#define RVAL2CSTR_PTR(v) (rbg_rval2cstr_ptr(&(v)))
 #define RVAL2CSTR_ACCEPT_NIL(v) (rbg_rval2cstr_accept_nil(&(v)))
 #define RVAL2CSTR2(v) (RVAL2CSTR_ACCEPT_NIL(v))
 #define RVAL2CSTR_ACCEPT_SYMBOL(v) (rbg_rval2cstr_accept_symbol(&(v)))
@@ -142,6 +147,7 @@ extern const gchar *rbg_rval_inspect(VALUE object);
 
 extern gchar* rbg_string_value_ptr(volatile VALUE* ptr); /* no longer used */
 extern const gchar *rbg_rval2cstr(VALUE *str);
+extern const gchar *rbg_rval2cstr_ptr(VALUE *str);
 extern const gchar *rbg_rval2cstr_accept_nil(VALUE *str);
 extern const gchar *rbg_rval2cstr_accept_symbol(volatile VALUE *value);
 extern const gchar *rbg_rval2cstr_accept_symbol_accept_nil(volatile VALUE *value);
@@ -195,6 +201,11 @@ extern VALUE rbglib_uint64_to_num(guint64 val);
 extern gint64 rbglib_num_to_int64(VALUE val);
 extern guint64 rbglib_num_to_uint64(VALUE val);
 
+
+extern VALUE rbg_variant_to_ruby(GVariant *variant);
+extern GVariant *rbg_variant_from_ruby(VALUE rb_variant);
+
+
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */

data/ext/glib2/rbglib2conversions.h

@@ -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
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
@@ -41,6 +41,8 @@
 #define GTIMER2RVAL(o)                     (BOXED2RVAL(o, G_TYPE_TIMER))
 #define RVAL2GVALUE(o)                     ((GValue*)RVAL2BOXED(o, G_TYPE_VALUE))
 #define GVALUE2RVAL(o)                     (BOXED2RVAL(o, G_TYPE_VALUE))
+#define RVAL2GVARIANTTYPE(o)               ((GVariantType *)RVAL2BOXED(o, G_TYPE_VARIANT_TYPE))
+#define GVARIANTTYPE2RVAL(o)               (BOXED2RVAL(o, G_TYPE_VARIANT_TYPE))
 
 #define RVAL2GIOCONDITION(o)               (RVAL2GFLAGS(o, G_TYPE_IO_CONDITION))
 #define GIOCONDITION2RVAL(o)               (GFLAGS2RVAL(o, G_TYPE_IO_CONDITION))
@@ -54,4 +56,7 @@
 
 #define RVAL2GFORMATSIZEFLAGS(o)           (RVAL2GFLAGS(o, G_TYPE_FORMAT_SIZE_FLAGS))
 #define GFORMATSIZEFLAGS2RVAL(o)           (GFLAGS2RVAL(o, G_TYPE_FORMAT_SIZE_FLAGS))
+
+#define RVAL2GBINDINGFLAGS(o)              (RVAL2GFLAGS(o, G_TYPE_BINDING_FLAGS))
+#define GBINDINGFLAGS2RVAL(o)              (GFLAGS2RVAL(o, G_TYPE_BINDING_FLAGS))
 #endif /* __GLIB2CONVERSIONS_H__ */

data/ext/glib2/rbglib_fileutils.c

@@ -53,7 +53,7 @@ void        g_dir_close                     (GDir *dir);
 static VALUE
 rbglib_m_format_size_for_display(G_GNUC_UNUSED VALUE self, VALUE size)
 {
-    return CSTR2RVAL_FREE(g_format_size_for_display(NUM2INT(size)));
+    return CSTR2RVAL_FREE(g_format_size_for_display(NUM2ULONG(size)));
 }
 #endif
 
@@ -65,14 +65,14 @@ rbglib_m_format_size(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
 
     rb_scan_args(argc, argv, "11", &rb_size, &rb_options);
     if (NIL_P(rb_options)) {
-      return CSTR2RVAL_FREE(g_format_size(NUM2UINT(rb_size)));
+      return CSTR2RVAL_FREE(g_format_size(NUM2ULONG(rb_size)));
     } else {
       VALUE rb_flags;
       rbg_scan_options(rb_options,
                        "flags", &rb_flags,
                        NULL);
 
-      return CSTR2RVAL_FREE(g_format_size_full(NUM2UINT(rb_size),
+      return CSTR2RVAL_FREE(g_format_size_full(NUM2ULONG(rb_size),
                                                RVAL2GFORMATSIZEFLAGS(rb_flags)));
     }
 }

data/ext/glib2/rbglib_maincontext.c

@@ -21,6 +21,10 @@
 
 #include "rbgprivate.h"
 
+#ifdef HAVE_RUBY_THREAD_H
+#  include <ruby/thread.h>
+#endif
+
 GStaticPrivate rg_polling_key = G_STATIC_PRIVATE_INIT;
 
 /*
@@ -32,6 +36,8 @@ static VALUE mGLibSource;
 static ID id__callbacks__;
 static GHashTable *callbacks_table;
 
+static GThread *main_thread;
+
 typedef struct _callback_info_t
 {
     VALUE callback;
@@ -49,15 +55,29 @@ typedef struct _PollInfo
     gint result;
 } PollInfo;
 
+static void
+rg_poll_in_blocking_raw(PollInfo *info)
+{
+    info->result = default_poll_func(info->ufds, info->nfsd, info->timeout);
+}
+
+#ifdef HAVE_RB_THREAD_CALL_WITHOUT_GVL
+static void *
+rg_poll_in_blocking(void *data)
+{
+    PollInfo *info = data;
+    rg_poll_in_blocking_raw(info);
+    return NULL;
+}
+#else
 static VALUE
 rg_poll_in_blocking(void *data)
 {
     PollInfo *info = data;
-
-    info->result = default_poll_func(info->ufds, info->nfsd, info->timeout);
-
+    rg_poll_in_blocking_raw(info);
     return Qnil;
 }
+#endif
 
 static gint
 rg_poll(GPollFD *ufds, guint nfsd, gint timeout)
@@ -70,11 +90,17 @@ rg_poll(GPollFD *ufds, guint nfsd, gint timeout)
     info.result = 0;
 
     g_static_private_set(&rg_polling_key, GINT_TO_POINTER(TRUE), NULL);
+    if (g_thread_self() == main_thread) {
 #ifdef HAVE_RB_THREAD_CALL_WITHOUT_GVL
-    rb_thread_call_without_gvl(rg_poll_in_blocking, &info, RUBY_UBF_IO, NULL);
+        rb_thread_call_without_gvl(rg_poll_in_blocking, &info,
+                                   RUBY_UBF_IO, NULL);
 #else
-    rb_thread_blocking_region(rg_poll_in_blocking, &info, RUBY_UBF_IO, NULL);
+        rb_thread_blocking_region(rg_poll_in_blocking, &info,
+                                  RUBY_UBF_IO, NULL);
 #endif
+    } else {
+        rg_poll_in_blocking_raw(&info);
+    }
     g_static_private_set(&rg_polling_key, GINT_TO_POINTER(FALSE), NULL);
 
     return info.result;
@@ -512,6 +538,10 @@ Init_glib_main_context(void)
     id__callbacks__ = rb_intern("__callbacks__");
     callbacks_table = g_hash_table_new(NULL, NULL);
 
+    g_static_private_set(&rg_polling_key, GINT_TO_POINTER(FALSE), NULL);
+
+    main_thread = g_thread_self();
+
     rbg_define_singleton_method(mGLib, "set_ruby_thread_priority",
                                ruby_source_set_priority, 1);
 

data/ext/glib2/rbgobj_binding.c

@@ -0,0 +1,48 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2015  Ruby-GNOME2 Project Team
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#include "rbgprivate.h"
+
+#define RG_TARGET_NAMESPACE cBinding
+
+#define _SELF(object) G_BINDING(RVAL2GOBJ(self))
+
+#if GLIB_CHECK_VERSION(2, 38, 0)
+static VALUE
+rg_unbind(VALUE self)
+{
+    g_binding_unbind(_SELF(self));
+    return self;
+}
+#endif
+
+void
+Init_gobject_gbinding(void)
+{
+#if GLIB_CHECK_VERSION(2, 26, 0)
+    VALUE RG_TARGET_NAMESPACE;
+
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_BINDING, "Binding", mGLib);
+#endif
+
+#if GLIB_CHECK_VERSION(2, 38, 0)
+    RG_DEF_METHOD(unbind, 0);
+#endif
+}

data/ext/glib2/rbgobj_boxed.c

@@ -75,14 +75,18 @@ static VALUE
 rg_initialize(VALUE self)
 {
     VALUE rb_class;
+    gsize instance_size = 0;
 
     rb_class = CLASS_OF(self);
     if (RVAL2CBOOL(rb_ivar_defined(rb_class, rb_intern("@size")))) {
+        instance_size = NUM2UINT(rb_iv_get(rb_class, "@size"));
+    }
+
+    if (instance_size > 0) {
         const RGObjClassInfo *cinfo;
         gpointer instance;
-        gsize instance_size;
+
         cinfo = rbgobj_lookup_class(rb_class);
-        instance_size = NUM2UINT(rb_iv_get(rb_class, "@size"));
         instance = alloca(instance_size);
         memset(instance, 0, instance_size);
         G_INITIALIZE(self, g_boxed_copy(cinfo->gtype, instance));

data/ext/glib2/rbgobj_enums.c

@@ -29,6 +29,7 @@ VALUE RG_TARGET_NAMESPACE;
 
 static ID id_new;
 static ID id_to_s;
+static ID id_to_i;
 
 /**********************************************************************/
 
@@ -270,20 +271,61 @@ enum_s_allocate(VALUE self)
 }
 
 static VALUE
-rg_initialize(VALUE self, VALUE arg)
+rg_initialize(int argc, VALUE *argv, VALUE self)
 {
     enum_holder* p = enum_get_holder(self);
+    VALUE rb_value;
+    VALUE klass;
 
-    if (rb_respond_to(arg, rb_intern("to_str"))) {
-        const char* str = StringValuePtr(arg);
-        p->info = g_enum_get_value_by_name(p->gclass, str);
-        if (! p->info)
-            p->info = g_enum_get_value_by_nick(p->gclass, str);
-        if (! p->info)
-            rb_raise(rb_eArgError, "invalid argument");
-    } else {
-        p->value = NUM2INT(arg);
-        p->info  = g_enum_get_value(p->gclass, p->value);
+    rb_scan_args(argc, argv, "01", &rb_value);
+
+    klass = CLASS_OF(self);
+
+    switch (TYPE(rb_value)) {
+    case RUBY_T_NIL:
+        p->value = 0;
+        break;
+    case RUBY_T_FIXNUM:
+        p->value = NUM2UINT(rb_value);
+        break;
+    case RUBY_T_STRING:
+    case RUBY_T_SYMBOL:
+    {
+        const gchar *name;
+
+        name = RVAL2CSTR_ACCEPT_SYMBOL(rb_value);
+        p->info = g_enum_get_value_by_name(p->gclass, name);
+        if (!p->info) {
+            gchar *nick;
+            nick = rbg_name_to_nick(name);
+            p->info = g_enum_get_value_by_nick(p->gclass, name);
+            g_free(nick);
+        }
+        if (!p->info) {
+            rb_raise(rb_eArgError, "unknown enum name: <%s>(%s)",
+                     name,
+                     g_type_name(G_TYPE_FROM_CLASS(p->gclass)));
+        }
+        p->value = p->info->value;
+        break;
+    }
+    default:
+        if (RVAL2CBOOL(rb_obj_is_kind_of(rb_value, klass))) {
+            p->value = NUM2INT(rb_funcall(rb_value, id_to_i, 0));
+        } else {
+            rb_raise(rb_eArgError,
+                     "enum value must be one of "
+                     "nil, Fixnum, String, Symbol o %s: "
+                     "<%s>(%s)",
+                     RBG_INSPECT(klass),
+                     RBG_INSPECT(rb_value),
+                     g_type_name(G_TYPE_FROM_CLASS(p->gclass)));
+        }
+        break;
+    }
+
+    if (!p->info) {
+        p->info = g_enum_get_value(p->gclass, p->value);
     }
 
     return Qnil;
@@ -374,6 +416,7 @@ Init_gobject_genums(void)
 {
     id_new = rb_intern("new");
     id_to_s = rb_intern("to_s");
+    id_to_i = rb_intern("to_i");
 
     RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_ENUM, "Enum", mGLib);
 
@@ -385,7 +428,7 @@ Init_gobject_genums(void)
 
     rb_define_alloc_func(RG_TARGET_NAMESPACE, enum_s_allocate);
 
-    RG_DEF_METHOD(initialize, 1);
+    RG_DEF_METHOD(initialize, -1);
     RG_DEF_METHOD(to_i, 0);
     RG_DEF_METHOD(name, 0);
     RG_DEF_METHOD(nick, 0);