glib2 0.20.0

data/src/rbgutil.h

@@ -0,0 +1,82 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgutil.h -
+
+  $Author: sakai $
+  $Date: 2007/07/08 03:17:21 $
+
+  Copyright (C) 2002,2003 Masao Mutoh
+************************************************/
+
+#ifndef __RBGUTIL_H__
+#define __RBGUTIL_H__
+
+#include <glib-object.h>
+#include "ruby.h"
+#ifdef HAVE_RUBY_ENCODING_H
+#  include <ruby/encoding.h>
+#endif
+#include "rbglib.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#define G_DEF_SETTER(klass, name) \
+    rb_funcall(klass, rbgutil_id_module_eval, 1, rb_str_new2( \
+    "def " name "=(val); set_" name "(val); val; end\n"))
+#define G_DEF_SETTERS(klass) rbgutil_def_setters(klass)
+
+#define G_SET_PROPERTIES(self, hash) (rbgutil_set_properties(self, hash))
+#define G_SET_SYMBOL_PROPERTY(gtype, name) \
+     rbgobj_register_property_getter(gtype, name, rbgutil_sym_g2r_func)
+#define G_PROTECT_CALLBACK(func, data) (rbgutil_invoke_callback((VALUE(*)(VALUE))func, (VALUE)data))
+
+#define GLIST2ARY(list)           (rbgutil_glist2ary(list))
+#define GLIST2ARY_FREE(list)      (rbgutil_glist2ary_and_free(list))
+#define GLIST2ARYF(list)          (GLIST2ARY_FREE(list))
+#define GLIST2ARY2(list, gtype)   (rbgutil_glist2ary_boxed(list, gtype))
+#define GLIST2ARY2F(list, gtype)  (rbgutil_glist2ary_boxed_and_free(list, gtype))
+#define GLIST2ARY_STR(list)       (rbgutil_glist2ary_string(list))
+#define GLIST2ARY_STR_FREE(list)  (rbgutil_glist2ary_string_and_free(list))
+#define GSLIST2ARY(list)          (rbgutil_gslist2ary(list))
+#define GSLIST2ARY_FREE(list)     (rbgutil_gslist2ary_and_free(list))
+#define GSLIST2ARYF(list)         (GSLIST2ARY_FREE(list))
+#define GSLIST2ARY2(list, gtype)  (rbgutil_gslist2ary_boxed(list, gtype))
+#define GSLIST2ARY2F(list, gtype) (rbgutil_gslist2ary_boxed_and_free(list, gtype))
+
+#define RBG_STRING_SET_UTF8_ENCODING(string) \
+    (rbgutil_string_set_utf8_encoding(string))
+
+extern VALUE rbgutil_def_setters(VALUE klass);
+extern void rbgutil_set_properties(VALUE self, VALUE hash);
+extern VALUE rbgutil_glist2ary(GList* list);
+extern VALUE rbgutil_glist2ary_boxed(GList* list, GType gtype);
+extern VALUE rbgutil_glist2ary_string(GList* list);
+extern VALUE rbgutil_glist2ary_and_free(GList* list);
+extern VALUE rbgutil_glist2ary_boxed_and_free(GList* list, GType gtype);
+extern VALUE rbgutil_glist2ary_string_and_free(GList* list);
+extern VALUE rbgutil_gslist2ary(GSList* list);
+extern VALUE rbgutil_gslist2ary_and_free(GSList* list);
+extern VALUE rbgutil_gslist2ary_boxed(GSList* list, GType gtype);
+extern VALUE rbgutil_gslist2ary_boxed_and_free(GSList* list, GType gtype);
+extern VALUE rbgutil_protect(VALUE (*proc) (VALUE), VALUE data);
+extern VALUE rbgutil_invoke_callback(VALUE (*func)(VALUE), VALUE arg);
+extern void rbgutil_start_callback_dispatch_thread(void);
+extern void rbgutil_stop_callback_dispatch_thread(void);
+
+extern VALUE rbgutil_string_set_utf8_encoding(VALUE string);
+
+/*< protected >*/
+RUBY_GLIB2_VAR ID rbgutil_id_module_eval;
+extern VALUE rbgutil_sym_g2r_func(const GValue *from);
+
+/* deprecated */
+#define G_BLOCK_PROC rb_block_proc
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __RBGLIB_H__ */

data/src/rbgutil_callback.c

@@ -0,0 +1,231 @@
+/* -*- 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
+
+**********************************************************************/
+
+#include "rbgprivate.h"
+
+#ifdef HAVE_UNISTD_H
+#  include <unistd.h>
+#endif
+#ifdef HAVE_IO_H
+#  include <io.h>
+#  define pipe(phandles) _pipe(phandles, 128, _O_BINARY)
+#endif
+#include <fcntl.h>
+#include <errno.h>
+
+#ifndef HAVE_RB_ERRINFO
+#  define rb_errinfo() (ruby_errinfo)
+#endif
+
+#ifndef HAVE_RUBY_NATIVE_THREAD_P
+#  define ruby_native_thread_p() is_ruby_native_thread()
+#endif
+
+static VALUE rbgutil_eGLibCallbackNotInitializedError;
+static ID id_exit_application;
+
+/**********************************************************************/
+
+VALUE
+rbgutil_protect(VALUE (*func) (VALUE), VALUE data)
+{
+    int state = 0;
+    VALUE ret = rb_protect(func, data, &state);
+    VALUE e = rb_errinfo();
+    if (state && !NIL_P(e))
+        rb_funcall(mGLib, id_exit_application, 2, e, INT2NUM(EXIT_FAILURE));
+    return ret;
+}
+
+/**********************************************************************/
+
+#ifdef HAVE_NATIVETHREAD
+
+typedef struct _CallbackRequest {
+    VALUE (*function)(VALUE);
+    VALUE argument;
+    VALUE result;
+    GMutex *done_mutex;
+    GCond *done_cond;
+} CallbackRequest;
+
+static GMutex *callback_dispatch_thread_mutex = NULL;
+static GAsyncQueue *callback_request_queue = NULL;
+static ID id_callback_dispatch_thread;
+static gint callback_pipe_fds[2] = {-1, -1};
+
+#define CALLBACK_PIPE_READY_MESSAGE "R"
+#define CALLBACK_PIPE_READY_MESSAGE_SIZE 1
+
+static VALUE
+exec_callback(VALUE data)
+{
+    CallbackRequest *request = (CallbackRequest *)data;
+    return request->function(request->argument);
+}
+
+static VALUE
+process_request(CallbackRequest *request)
+{
+    g_mutex_lock(request->done_mutex);
+    request->result = rbgutil_protect(exec_callback, (VALUE)request);
+    g_cond_signal(request->done_cond);
+    g_mutex_unlock(request->done_mutex);
+
+    return Qnil;
+}
+
+static VALUE
+mainloop(void)
+{
+    for (;;) {
+        CallbackRequest *request;
+        gchar ready_message_buffer[CALLBACK_PIPE_READY_MESSAGE_SIZE];
+
+        rb_thread_wait_fd(callback_pipe_fds[0]);
+        if (read(callback_pipe_fds[0], ready_message_buffer,
+                 CALLBACK_PIPE_READY_MESSAGE_SIZE
+                ) != CALLBACK_PIPE_READY_MESSAGE_SIZE ||
+            strncmp(ready_message_buffer,
+                    CALLBACK_PIPE_READY_MESSAGE,
+                    CALLBACK_PIPE_READY_MESSAGE_SIZE) != 0) {
+            g_error("failed to read valid callback dispatcher message");
+            continue;
+        }
+        request = g_async_queue_pop(callback_request_queue);
+        if (!request)
+            break;
+
+        rb_thread_create(process_request, request);
+    }
+
+    close(callback_pipe_fds[0]);
+    callback_pipe_fds[0] = -1;
+    close(callback_pipe_fds[1]);
+    callback_pipe_fds[1] = -1;
+
+    return Qnil;
+}
+
+static void
+queue_callback_request(CallbackRequest *request)
+{
+    g_async_queue_push(callback_request_queue, request);
+    write(callback_pipe_fds[1],
+          CALLBACK_PIPE_READY_MESSAGE,
+          CALLBACK_PIPE_READY_MESSAGE_SIZE);
+}
+
+static VALUE
+invoke_callback_in_ruby_thread(VALUE (*func)(VALUE), VALUE arg)
+{
+    CallbackRequest request;
+
+    g_mutex_lock(callback_dispatch_thread_mutex);
+    if (callback_pipe_fds[0] == -1) {
+        g_error("Please call rbgutil_start_callback_dispatch_thread() "
+                "to dispatch a callback from non-ruby thread before "
+                "callbacks are requested from non-ruby thread.");
+        g_mutex_unlock(callback_dispatch_thread_mutex);
+        return Qnil;
+    }
+
+    request.function = func;
+    request.argument = arg;
+    request.result = Qnil;
+    request.done_mutex = g_mutex_new();
+    request.done_cond = g_cond_new();
+
+    g_mutex_lock(request.done_mutex);
+    queue_callback_request(&request);
+    g_mutex_unlock(callback_dispatch_thread_mutex);
+
+    g_cond_wait(request.done_cond, request.done_mutex);
+    g_mutex_unlock(request.done_mutex);
+
+    g_cond_free(request.done_cond);
+    g_mutex_free(request.done_mutex);
+
+
+    return request.result;
+}
+#endif
+
+/**********************************************************************/
+
+VALUE
+rbgutil_invoke_callback(VALUE (*func)(VALUE), VALUE arg)
+{
+#ifdef HAVE_NATIVETHREAD
+    if (!ruby_native_thread_p()) {
+        return invoke_callback_in_ruby_thread(func, arg);
+    }
+#endif
+    return rbgutil_protect(func, arg);
+}
+
+/**********************************************************************/
+
+void
+rbgutil_start_callback_dispatch_thread(void)
+{
+#ifdef HAVE_NATIVETHREAD
+    VALUE callback_dispatch_thread;
+
+    g_mutex_lock(callback_dispatch_thread_mutex);
+    callback_dispatch_thread = rb_ivar_get(mGLib, id_callback_dispatch_thread);
+    if (NIL_P(callback_dispatch_thread)) {
+        if (pipe(callback_pipe_fds) == -1)
+            rb_sys_fail("pipe()");
+
+        callback_dispatch_thread = rb_thread_create(mainloop, NULL);
+        rb_ivar_set(mGLib, id_callback_dispatch_thread,
+                    callback_dispatch_thread);
+    }
+    g_mutex_unlock(callback_dispatch_thread_mutex);
+#endif
+}
+
+void
+rbgutil_stop_callback_dispatch_thread(void)
+{
+#ifdef HAVE_NATIVETHREAD
+    VALUE callback_dispatch_thread;
+
+    g_mutex_lock(callback_dispatch_thread_mutex);
+    callback_dispatch_thread = rb_ivar_get(mGLib, id_callback_dispatch_thread);
+    if (!NIL_P(callback_dispatch_thread)) {
+        queue_callback_request(NULL);
+        rb_ivar_set(mGLib, id_callback_dispatch_thread, Qnil);
+    }
+    g_mutex_unlock(callback_dispatch_thread_mutex);
+#endif
+}
+
+void Init_gutil_callback()
+{
+    id_exit_application = rb_intern("exit_application");
+    rbgutil_eGLibCallbackNotInitializedError =
+        rb_define_class_under(mGLib, "CallbackNotInitializedError",
+                              rb_eRuntimeError);
+
+#ifdef HAVE_NATIVETHREAD
+    if (!g_thread_supported())
+        g_thread_init(NULL);
+
+    id_callback_dispatch_thread = rb_intern("callback_dispatch_thread");
+    rb_ivar_set(mGLib, id_callback_dispatch_thread, Qnil);
+
+    callback_request_queue = g_async_queue_new();
+    callback_dispatch_thread_mutex = g_mutex_new();
+#endif
+}

data/test/glib-test-init.rb

@@ -0,0 +1,6 @@
+$VERBOSE = true
+
+glib_top = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+
+$LOAD_PATH.unshift(File.join(glib_top, "test-unit", "lib"))
+require 'test/unit'

data/test/glib-test-utils.rb

@@ -0,0 +1,12 @@
+module GLibTestUtils
+  private
+  def only_glib_version(major, minor, micro)
+    unless GLib.check_version?(major, minor, micro)
+      omit("Require GLib >= #{major}.#{minor}.#{micro}")
+    end
+  end
+
+  def only_win32
+    omit("Only for Win32 platform") unless GLib.os_win32?
+  end
+end

data/test/run-test.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+base = File.expand_path(File.join(File.dirname(__FILE__)))
+top = File.expand_path(File.join(base, ".."))
+
+$LOAD_PATH.unshift(top)
+require 'test/glib-test-init'
+
+if system("which make > /dev/null")
+  system("cd #{top.dump} && make > /dev/null") or exit(1)
+end
+
+$LOAD_PATH.unshift(File.join(top, "src"))
+$LOAD_PATH.unshift(File.join(top, "src", "lib"))
+
+$LOAD_PATH.unshift(base)
+require 'glib-test-utils'
+
+require 'glib2'
+
+if !defined?(Test::Unit::AutoRunner)
+  require 'test-unit'
+end
+
+exit Test::Unit::AutoRunner.run(true, base)

data/test/test_enum.rb

@@ -0,0 +1,99 @@
+# -*- coding: utf-8 -*-
+require 'test/unit'
+require 'glib2'
+
+class TestEnum < Test::Unit::TestCase
+  def test_enum_by_symbol
+    original = [0x00c1].pack("U*") # A with acute
+
+    assert_equal(GLib::UTF8.normalize(original, GLib::NormalizeMode::NFD),
+                 GLib::UTF8.normalize(original, :nfd))
+    assert_equal(GLib::UTF8.normalize(original, GLib::NormalizeMode::NFD),
+                 GLib::UTF8.normalize(original, :NFD))
+
+    assert_raise(TypeError) do
+      GLib::UTF8.normalize(original, :unknown)
+    end
+  end
+
+  def test_enum_by_string
+    original = [0x00c1].pack("U*") # A with acute
+
+    assert_equal(GLib::UTF8.normalize(original, GLib::NormalizeMode::NFD),
+                 GLib::UTF8.normalize(original, "nfd"))
+    assert_equal(GLib::UTF8.normalize(original, GLib::NormalizeMode::NFD),
+                 GLib::UTF8.normalize(original, "NFD"))
+
+    assert_raise(TypeError) do
+      GLib::UTF8.normalize(original, "unknown")
+    end
+  end
+
+  def test_flags_simple
+    assert_key_file_load(GLib::KeyFile::KEEP_COMMENTS, :keep_comments)
+    assert_key_file_load(GLib::KeyFile::KEEP_COMMENTS, :KEEP_COMMENTS)
+    assert_key_file_load(GLib::KeyFile::KEEP_COMMENTS, "keep_comments")
+    assert_key_file_load(GLib::KeyFile::KEEP_COMMENTS, "KEEP_COMMENTS")
+    assert_key_file_load(GLib::KeyFile::KEEP_COMMENTS, "keep COMMENTS")
+
+    assert_raise(TypeError) do
+      assert_key_file_load(GLib::KeyFile::KEEP_COMMENTS, :unknown)
+    end
+
+    assert_raise(TypeError) do
+      assert_key_file_load(GLib::KeyFile::KEEP_COMMENTS, "UNKNOWN")
+    end
+  end
+
+  def test_flags_by_array
+    assert_key_file_load(GLib::KeyFile::KEEP_COMMENTS |
+                         GLib::KeyFile::KEEP_TRANSLATIONS,
+                         [:keep_comments, :keep_translations])
+    assert_key_file_load(GLib::KeyFile::KEEP_COMMENTS |
+                         GLib::KeyFile::KEEP_TRANSLATIONS,
+                         [:keep_COMMENTS, "KEEP_TRANSLATIONS"])
+    assert_key_file_load(GLib::KeyFile::KEEP_COMMENTS |
+                         GLib::KeyFile::KEEP_TRANSLATIONS,
+                         ["keep_comments", "KEEP_translations"])
+    assert_key_file_load(GLib::KeyFile::KEEP_COMMENTS |
+                         GLib::KeyFile::KEEP_TRANSLATIONS,
+                         [:keep_comments, GLib::KeyFile::KEEP_TRANSLATIONS])
+
+    assert_raise(TypeError) do
+      assert_key_file_load(GLib::KeyFile::KEEP_COMMENTS |
+                           GLib::KeyFile::KEEP_TRANSLATIONS,
+                           [:keep_comments, nil, :keep_translations])
+    end
+  end
+
+  def test_flags_or
+    assert_equal(GLib::KeyFile::KEEP_COMMENTS,
+                 GLib::KeyFile::KEEP_COMMENTS | [])
+    assert_equal(GLib::KeyFile::KEEP_COMMENTS |
+                 GLib::KeyFile::KEEP_TRANSLATIONS ,
+                 GLib::KeyFile::KEEP_COMMENTS | [:keep_translations])
+  end
+
+  private
+  def assert_key_file_load(flags, convenience_flags)
+    data = <<-EOD
+[SECTION]
+KEY=VALUE
+# comment
+
+KEY[ja]=値
+EOD
+
+    expected_key_file = GLib::KeyFile.new
+    expected_key_file.load_from_data(data, flags)
+
+    actual_key_file = GLib::KeyFile.new
+    actual_key_file.load_from_data(data, convenience_flags)
+
+    assert_equal(expected_key_file.get_value("SECTION", "KEY"),
+                 actual_key_file.get_value("SECTION", "KEY"))
+
+    assert_equal(expected_key_file.to_data,
+                 actual_key_file.to_data)
+  end
+end