glib2 1.0.3 → 1.1.0

data/ext/glib2/rbgutil_callback.c

@@ -1,14 +1,23 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/**********************************************************************
-
-  utils_callback.c -
-
-  $Author: sakai $
-  $Date: 2007/07/14 07:16:18 $
-
-  Copyright (C) 2007  Ruby-GNOME2 Project
-
-**********************************************************************/
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2007  Ruby-GNOME2 Project
+ *
+ *  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"
 
@@ -165,6 +174,18 @@ invoke_callback_in_ruby_thread(VALUE (*func)(VALUE), VALUE arg)
 
     return request.result;
 }
+
+#ifdef HAVE_RB_THREAD_CALL_WITH_GVL
+extern void *rb_thread_call_with_gvl(void *(*func)(void *), void *data1);
+
+static void *
+invoke_callback_with_gvl(void *arg)
+{
+    CallbackRequest *req = (CallbackRequest*)arg;
+    return (void *)rbgutil_protect(req->function, req->argument);
+}
+#endif
+
 #endif
 
 /**********************************************************************/
@@ -173,7 +194,21 @@ VALUE
 rbgutil_invoke_callback(VALUE (*func)(VALUE), VALUE arg)
 {
 #ifdef HAVE_NATIVETHREAD
-    if (!ruby_native_thread_p()) {
+    if (ruby_native_thread_p()) {
+#  ifdef HAVE_RB_THREAD_BLOCKING_REGION
+        if (!GPOINTER_TO_INT(g_static_private_get(&rg_polling_key))) {
+            return rbgutil_protect(func, arg);
+        }
+#  endif
+#  ifdef HAVE_RB_THREAD_CALL_WITH_GVL
+        {
+            CallbackRequest req;
+            req.function = func;
+            req.argument = arg;
+            return (VALUE)rb_thread_call_with_gvl(invoke_callback_with_gvl, &req);
+        }
+#  endif
+    } else {
         return invoke_callback_in_ruby_thread(func, arg);
     }
 #endif
@@ -219,7 +254,7 @@ rbgutil_stop_callback_dispatch_thread(void)
 }
 
 void
-Init_gutil_callback()
+Init_gutil_callback(void)
 {
     id_exit_application = rb_intern("exit_application");
     rbgutil_eGLibCallbackNotInitializedError =

data/ext/glib2/rbgutil_list.c

@@ -0,0 +1,173 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  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"
+
+struct list2rval_args {
+    gpointer list;
+    RBGRValueFunc conv;
+    GFreeFunc free_list;
+    GFreeFunc free_elem;
+};
+
+struct list2rval_with_type_args {
+    struct list2rval_args args;
+    RBGRValueFuncWithType conv_with_type;
+    GType gtype;
+};
+
+static VALUE
+glist2rval_body(VALUE data)
+{
+    struct list2rval_args *args = (struct list2rval_args *)data;
+    RBGRValueFunc conv = args->conv;
+    GList *node;
+    VALUE ary;
+
+    ary = rb_ary_new();
+    if (conv)
+        for (node = args->list; node; node = g_list_next(node))
+            rb_ary_push(ary, conv(node->data));
+
+    return ary;
+}
+
+static VALUE
+gslist2rval_body(VALUE data)
+{
+    struct list2rval_args *args = (struct list2rval_args *)data;
+    RBGRValueFunc conv = args->conv;
+    GSList *node;
+    VALUE ary;
+
+    ary = rb_ary_new();
+    if (conv)
+        for (node = args->list; node; node = g_slist_next(node))
+            rb_ary_push(ary, conv(node->data));
+
+    return ary;
+}
+
+static VALUE
+glist2rval_with_type_body(VALUE data)
+{
+    struct list2rval_with_type_args *args_with_type = (struct list2rval_with_type_args *)data;
+    struct list2rval_args *args = (struct list2rval_args *)data;
+    RBGRValueFuncWithType conv = args_with_type->conv_with_type;
+    GType gtype = args_with_type->gtype;
+    GList *node;
+    VALUE ary;
+
+    ary = rb_ary_new();
+    if (conv)
+        for (node = args->list; node; node = g_list_next(node))
+            rb_ary_push(ary, conv(node->data, gtype));
+
+    return ary;
+}
+
+static VALUE
+gslist2rval_with_type_body(VALUE data)
+{
+    struct list2rval_with_type_args *args_with_type = (struct list2rval_with_type_args *)data;
+    struct list2rval_args *args = (struct list2rval_args *)data;
+    RBGRValueFuncWithType conv = args_with_type->conv_with_type;
+    GType gtype = args_with_type->gtype;
+    GSList *node;
+    VALUE ary;
+
+    ary = rb_ary_new();
+    if (conv)
+        for (node = args->list; node; node = g_slist_next(node))
+            rb_ary_push(ary, conv(node->data, gtype));
+
+    return ary;
+}
+
+static VALUE
+glist2rval_ensure(VALUE data)
+{
+    struct list2rval_args *args = (struct list2rval_args *)data;
+    GList *node;
+
+    if (args->free_elem)
+        for (node = args->list; node; node = g_list_next(node))
+            args->free_elem(node->data);
+    if (args->free_list)
+        args->free_list(args->list);
+
+    return Qnil;
+}
+
+static VALUE
+gslist2rval_ensure(VALUE data)
+{
+    struct list2rval_args *args = (struct list2rval_args *)data;
+    GSList *node;
+
+    if (args->free_elem)
+        for (node = args->list; node; node = g_slist_next(node))
+            args->free_elem(node->data);
+    if (args->free_list)
+        args->free_list(args->list);
+
+    return Qnil;
+}
+
+VALUE
+rbg_glist2rval(GList *const list, RBGRValueFunc conv,
+               GFreeFunc free_list, GFreeFunc free_elem)
+{
+    struct list2rval_args args = {list, conv, free_list, free_elem};
+
+    return rb_ensure(glist2rval_body, (VALUE)&args,
+                     glist2rval_ensure, (VALUE)&args);
+}
+
+VALUE
+rbg_gslist2rval(GSList *const list, RBGRValueFunc conv,
+                GFreeFunc free_list, GFreeFunc free_elem)
+{
+    struct list2rval_args args = {list, conv, free_list, free_elem};
+
+    return rb_ensure(gslist2rval_body, (VALUE)&args,
+                     gslist2rval_ensure, (VALUE)&args);
+}
+
+VALUE
+rbg_glist2rval_with_type(GList *const list, RBGRValueFuncWithType conv, GType gtype,
+                         GFreeFunc free_list, GFreeFunc free_elem)
+{
+    struct list2rval_with_type_args args = {{list, NULL, free_list, free_elem}, conv, gtype};
+
+    return rb_ensure(glist2rval_with_type_body, (VALUE)&args,
+                     glist2rval_ensure, (VALUE)&args);
+}
+
+VALUE
+rbg_gslist2rval_with_type(GSList *const list, RBGRValueFuncWithType conv, GType gtype,
+                          GFreeFunc free_list, GFreeFunc free_elem)
+{
+    struct list2rval_with_type_args args = {{list, NULL, free_list, free_elem}, conv, gtype};
+
+    return rb_ensure(gslist2rval_with_type_body, (VALUE)&args,
+                     gslist2rval_ensure, (VALUE)&args);
+}
+

data/ext/glib2/rbgutil_list.h

@@ -0,0 +1,85 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  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
+ */
+
+#ifndef __RBGUTIL_LIST_H__
+#define __RBGUTIL_LIST_H__
+
+G_BEGIN_DECLS
+
+#define CSTRGLIST2RVAL(list) \
+        CSTRGLIST2RVAL_FREE(list, NULL, NULL)
+#define CSTRGLIST2RVAL_FREE(list, free_list, free_elem) \
+        rbg_glist2rval(list, (RBGRValueFunc)rbg_cstr2rval, \
+                       (GFreeFunc)free_list, (GFreeFunc)free_elem)
+#define CSTRGSLIST2RVAL(list) \
+        CSTRGSLIST2RVAL_FREE(list, NULL, NULL)
+#define CSTRGSLIST2RVAL_FREE(list, free_list, free_elem) \
+        rbg_gslist2rval(list, (RBGRValueFunc)rbg_cstr2rval, \
+                        (GFreeFunc)free_list, (GFreeFunc)free_elem)
+
+#define FILENAMEGLIST2RVAL(list) \
+        FILENAMEGLIST2RVAL_FREE(list, NULL, NULL)
+#define FILENAMEGLIST2RVAL_FREE(list, free_list, free_elem) \
+        rbg_glist2rval(list, (RBGRValueFunc)rbg_filename_to_ruby, \
+                       (GFreeFunc)free_list, (GFreeFunc)free_elem)
+#define FILENAMEGSLIST2RVAL(list) \
+        FILENAMEGSLIST2RVAL_FREE(list, NULL, NULL)
+#define FILENAMEGSLIST2RVAL_FREE(list, free_list, free_elem) \
+        rbg_gslist2rval(list, (RBGRValueFunc)rbg_filename_to_ruby, \
+                        (GFreeFunc)free_list, (GFreeFunc)free_elem)
+
+#define GOBJGLIST2RVAL(list) \
+        GOBJGLIST2RVAL_FREE(list, NULL, NULL)
+#define GOBJGLIST2RVAL_FREE(list, free_list, free_elem) \
+        rbg_glist2rval(list, (RBGRValueFunc)rbgobj_ruby_object_from_instance, \
+                       (GFreeFunc)free_list, (GFreeFunc)free_elem)
+#define GOBJGSLIST2RVAL(list) \
+        GOBJGSLIST2RVAL_FREE(list, NULL, NULL)
+#define GOBJGSLIST2RVAL_FREE(list, free_list, free_elem) \
+        rbg_gslist2rval(list, (RBGRValueFunc)rbgobj_ruby_object_from_instance, \
+                        (GFreeFunc)free_list, (GFreeFunc)free_elem)
+
+#define BOXEDGLIST2RVAL(list, gtype) \
+        BOXEDGLIST2RVAL_FREE(list, gtype, NULL, NULL)
+#define BOXEDGLIST2RVAL_FREE(list, gtype, free_list, free_elem) \
+        rbg_glist2rval_with_type(list, (RBGRValueFuncWithType)rbgobj_make_boxed, gtype, \
+                                 (GFreeFunc)free_list, (GFreeFunc)free_elem)
+#define BOXEDGSLIST2RVAL(list, gtype) \
+        BOXEDGSLIST2RVAL_FREE(list, gtype, NULL, NULL)
+#define BOXEDGSLIST2RVAL_FREE(list, gtype, free_list, free_elem) \
+        rbg_gslist2rval_with_type(list, (RBGRValueFuncWithType)rbgobj_make_boxed, gtype, \
+                                  (GFreeFunc)free_list, (GFreeFunc)free_elem)
+
+typedef VALUE (*RBGRValueFunc)(gpointer obj);
+typedef VALUE (*RBGRValueFuncWithType)(gpointer obj, GType gtype);
+
+extern VALUE rbg_glist2rval(GList *const list, RBGRValueFunc conv,
+                            GFreeFunc free_list, GFreeFunc free_elem);
+extern VALUE rbg_gslist2rval(GSList *const list, RBGRValueFunc conv,
+                             GFreeFunc free_list, GFreeFunc free_elem);
+extern VALUE rbg_glist2rval_with_type(GList *const list, RBGRValueFuncWithType conv, GType gtype,
+                                      GFreeFunc free_list, GFreeFunc free_elem);
+extern VALUE rbg_gslist2rval_with_type(GSList *const list, RBGRValueFuncWithType conv, GType gtype,
+                                       GFreeFunc free_list, GFreeFunc free_elem);
+
+G_END_DECLS
+
+#endif /* __RBGUTIL_LIST_H__ */
+

data/ext/glib2/rbgutildeprecated.c

@@ -0,0 +1,252 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002-2004 Masao Mutoh
+ *
+ *  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"
+
+VALUE
+rbgutil_glist2ary(const GList *const list)
+{
+    VALUE ary;
+    const GList *i;
+
+    ary = rb_ary_new();
+    for (i = list; i != NULL; i = i->next)
+        rb_ary_push(ary, GOBJ2RVAL(i->data));
+
+    return ary;
+}
+
+static VALUE
+rbgutil_glist2ary_and_free_body(VALUE data)
+{
+    VALUE ary;
+    GList *i;
+
+    ary = rb_ary_new();
+    for (i = (GList *)data; i != NULL; i = i->next)
+        rb_ary_push(ary, GOBJ2RVAL(i->data));
+
+    return ary;
+}
+
+static VALUE
+rbgutil_glist2ary_and_free_ensure(VALUE data)
+{
+    g_list_free((GList *)data);
+
+    return Qnil;
+}
+
+VALUE
+rbgutil_glist2ary_and_free(GList *const list)
+{
+    return rb_ensure(rbgutil_glist2ary_and_free_body, (VALUE)list,
+                     rbgutil_glist2ary_and_free_ensure, (VALUE)list);
+}
+
+VALUE
+rbgutil_glist2ary_boxed(const GList *const list, GType gtype)
+{
+    VALUE ary;
+    const GList *i;
+
+    ary = rb_ary_new();
+    for (i = list; i != NULL; i = i->next)
+        rb_ary_push(ary, BOXED2RVAL(i->data, gtype));
+
+    return ary;
+}
+
+struct rbgutil_glist2ary_boxed_and_free_data
+{
+    GList *const list;
+    GType gtype;
+};
+
+static VALUE
+rbgutil_glist2ary_boxed_and_free_body(VALUE data)
+{
+    struct rbgutil_glist2ary_boxed_and_free_data *real;
+    VALUE ary;
+    GList *i;
+
+    real = (struct rbgutil_glist2ary_boxed_and_free_data *)data;
+    ary = rb_ary_new();
+    for (i = real->list; i != NULL; i = i->next)
+        rb_ary_push(ary, BOXED2RVAL(i->data, real->gtype));
+
+    return ary;
+}
+
+static VALUE
+rbgutil_glist2ary_boxed_and_free_ensure(VALUE data)
+{
+    g_list_free(((struct rbgutil_glist2ary_boxed_and_free_data *)data)->list);
+
+    return Qnil;
+}
+
+VALUE
+rbgutil_glist2ary_boxed_and_free(GList *const list, GType gtype)
+{
+    struct rbgutil_glist2ary_boxed_and_free_data data = { list, gtype };
+
+    return rb_ensure(rbgutil_glist2ary_boxed_and_free_body, (VALUE)&data,
+                     rbgutil_glist2ary_boxed_and_free_ensure, (VALUE)&data);
+}
+
+VALUE
+rbgutil_glist2ary_string(const GList *const list)
+{
+    VALUE ary;
+    const GList *i;
+
+    ary = rb_ary_new();
+    for (i = list; i != NULL; i = i->next)
+        rb_ary_push(ary, CSTR2RVAL(i->data));
+
+    return ary;
+}
+
+static VALUE
+rbgutil_glist2ary_string_and_free_body(VALUE data)
+{
+    VALUE ary;
+    GList *i;
+
+    ary = rb_ary_new();
+    for (i = (GList *)data; i != NULL; i = i->next)
+        rb_ary_push(ary, CSTR2RVAL(i->data));
+
+    return ary;
+}
+
+static VALUE
+rbgutil_glist2ary_string_and_free_ensure(VALUE data)
+{
+    GList *i;
+
+    for (i = (GList *)data; i != NULL; i = i->next)
+        g_free(i->data);
+    g_list_free((GList *)data);
+
+    return Qnil;
+}
+
+VALUE
+rbgutil_glist2ary_string_and_free(GList *const list)
+{
+    return rb_ensure(rbgutil_glist2ary_string_and_free_body, (VALUE)list,
+                     rbgutil_glist2ary_string_and_free_ensure, (VALUE)list);
+}
+
+VALUE
+rbgutil_gslist2ary(const GSList *const list)
+{
+    VALUE ary;
+    const GSList *i;
+    
+    ary = rb_ary_new();
+    for (i = list; i != NULL; i = i->next)
+        rb_ary_push(ary, GOBJ2RVAL(i->data));
+
+    return ary;
+}
+
+static VALUE
+rbgutil_gslist2ary_and_free_body(VALUE data)
+{
+    VALUE ary;
+    GSList *i;
+
+    ary = rb_ary_new();
+    for (i = (GSList *)data; i != NULL; i = i->next)
+        rb_ary_push(ary, GOBJ2RVAL(i->data));
+
+    return ary;
+}
+
+static VALUE
+rbgutil_gslist2ary_and_free_ensure(VALUE data)
+{
+    g_slist_free((GSList *)data);
+
+    return Qnil;
+}
+
+VALUE
+rbgutil_gslist2ary_and_free(GSList *const list)
+{
+    return rb_ensure(rbgutil_gslist2ary_and_free_body, (VALUE)list,
+                     rbgutil_gslist2ary_and_free_ensure, (VALUE)list);
+}
+
+VALUE
+rbgutil_gslist2ary_boxed(const GSList *const list, GType gtype)
+{
+    VALUE ary;
+    const GSList *i;
+    
+    ary = rb_ary_new();
+    for (i = list; i != NULL; i = i->next)
+        rb_ary_push(ary, BOXED2RVAL(i->data, gtype));
+
+    return ary;
+}
+
+struct rbgutil_gslist2ary_boxed_and_free_data
+{
+    GSList *const list;
+    GType gtype;
+};
+
+static VALUE
+rbgutil_gslist2ary_boxed_and_free_body(VALUE data)
+{
+    struct rbgutil_gslist2ary_boxed_and_free_data *real;
+    VALUE ary;
+    GSList *i;
+
+    real = (struct rbgutil_gslist2ary_boxed_and_free_data *)data;
+    ary = rb_ary_new();
+    for (i = real->list; i != NULL; i = i->next)
+        rb_ary_push(ary, BOXED2RVAL(i->data, real->gtype));
+
+    return ary;
+}
+
+static VALUE
+rbgutil_gslist2ary_boxed_and_free_ensure(VALUE data)
+{
+    g_slist_free(((struct rbgutil_gslist2ary_boxed_and_free_data *)data)->list);
+
+    return Qnil;
+}
+
+VALUE
+rbgutil_gslist2ary_boxed_and_free(GSList *const list, GType gtype)
+{
+    struct rbgutil_gslist2ary_boxed_and_free_data data = { list, gtype };
+
+    return rb_ensure(rbgutil_gslist2ary_boxed_and_free_body, (VALUE)&data,
+                     rbgutil_gslist2ary_boxed_and_free_ensure, (VALUE)&data);
+}
+