glib2 0.90.2-x86-mingw32

data/ext/glib2/rbgprivate.h

@@ -0,0 +1,88 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/**********************************************************************
+  rbgprivate.h -
+
+  Copyright (C) 2007  Ruby-GNOME2 Project Team
+**********************************************************************/
+
+#ifndef __RBGPRIVATE_H__
+#define __RBGPRIVATE_H__
+
+#include "rbgobject.h"
+#include "glib-enum-types.h"
+
+G_BEGIN_DECLS
+
+typedef struct {
+    VALUE self;
+    GObject* gobj;
+    const RGObjClassInfo* cinfo;
+    gboolean destroyed;
+} gobj_holder;
+
+typedef struct {
+    gpointer boxed;
+    gboolean own;
+    GType type;
+} boxed_holder;
+
+extern VALUE rbgobj_cEnum;
+extern VALUE rbgobj_cFlags;
+extern VALUE rbgobj_cBoxed;
+extern VALUE rbgobj_cParam;
+extern VALUE rbgobj_mInterface;
+extern VALUE rbgobj_cObject;
+
+extern VALUE rbgobj_cInstantiatable;
+extern VALUE rbgobj_mMetaInterface;
+#define cInstantiatable   rbgobj_cInstantiatable
+#define mMetaInterface rbgobj_mMetaInterface
+
+extern void rbgobj_define_property_accessors(VALUE klass);
+extern void rbgobj_define_action_methods(VALUE klass);
+
+extern void rbgobj_param_spec_initialize(VALUE self, GParamSpec* pspec);
+extern void rbgobj_boxed_initialize(VALUE obj, gpointer boxed);
+extern void rbgobj_gobject_initialize(VALUE obj, gpointer cobj);
+
+extern GParamSpec* rbgobj_get_param_spec(VALUE obj);
+extern GObject* rbgobj_get_gobject(VALUE obj);
+
+extern VALUE rbgobj_get_ruby_object_from_param_spec(GParamSpec* pspec, gboolean alloc);
+
+extern void rbgobj_init_object_class(VALUE klass);
+extern void rbgobj_init_flags_class(VALUE klass);
+extern void rbgobj_init_enum_class(VALUE klass);
+extern void rbgobj_init_interface(VALUE interf);
+
+/* FIXME: should have better name */
+extern void rbgobj_instance_call_cinfo_mark(gpointer instance);
+extern void rbgobj_instance_call_cinfo_free(gpointer instance);
+
+VALUE rbgutil_generic_s_gtype(VALUE klass);
+VALUE rbgutil_generic_gtype(VALUE self);
+#define generic_s_gtype rbgutil_generic_s_gtype
+#define generic_gtype rbgutil_generic_gtype
+
+extern gboolean rbgobj_convert_has_type(GType type);
+extern RGConvertTable *rbgobj_convert_lookup(GType type);
+
+extern gboolean rbgobj_convert_get_superclass(GType type, VALUE *result);
+extern gboolean rbgobj_convert_type_init_hook(GType type, VALUE klass);
+extern gboolean rbgobj_convert_gvalue2rvalue(GType type, const GValue *value,
+                                             VALUE *result);
+extern gboolean rbgobj_convert_rvalue2gvalue(GType type, VALUE val,
+                                             GValue *result);
+extern GType rbgobj_convert_rvalue2gtype(VALUE val);
+extern gboolean rbgobj_convert_initialize(GType type, VALUE obj, gpointer cobj);
+extern gboolean rbgobj_convert_robj2instance(GType type, VALUE obj,
+                                             gpointer *result);
+extern gboolean rbgobj_convert_instance2robj(GType type, gpointer instance,
+                                             VALUE *result);
+extern gboolean rbgobj_convert_unref(GType type, gpointer instance);
+
+#define RubyGObjectHookModule "RubyGObjectHook__"
+
+G_END_DECLS
+
+#endif

data/ext/glib2/rbgutil.c

@@ -0,0 +1,316 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgutil.c -
+
+  $Author: sakai $
+  $Date: 2007/07/07 08:15:26 $
+
+  Copyright (C) 2002-2004 Masao Mutoh
+************************************************/
+
+#include "rbgprivate.h"
+
+ID rbgutil_id_module_eval;
+
+static ID id_add_one_arg_setter;
+static ID id_set_property;
+static ID id_to_a;
+static ID id_allocate;
+
+void
+rbgutil_set_properties(self, hash)
+    VALUE self, hash;
+{
+    int i;
+    VALUE ary;
+    GObject* obj;
+
+    Check_Type(hash, T_HASH);
+    ary = rb_funcall(hash, id_to_a, 0);
+    obj = RVAL2GOBJ(self);
+
+    g_object_freeze_notify(obj);
+    for (i = 0; i < RARRAY_LEN(ary); i++) {
+      rb_funcall(self, id_set_property, 2,
+                 RARRAY_PTR(RARRAY_PTR(ary)[i])[0],
+                 RARRAY_PTR(RARRAY_PTR(ary)[i])[1]);
+    }
+    g_object_thaw_notify(obj);
+}
+
+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;
+}
+
+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;
+}
+
+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;
+};
+
+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;
+}
+
+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);
+}
+
+VALUE
+rbgutil_def_setters(klass)
+    VALUE klass;
+{
+    return rb_funcall(mGLib, id_add_one_arg_setter, 1, klass);
+}
+
+VALUE
+rbgutil_sym_g2r_func(from)
+    const GValue *from;
+{
+    const gchar *str = g_value_get_string(from);
+    return str ? ID2SYM(rb_intern(str)) : Qnil;
+}
+
+VALUE
+rbgutil_generic_s_gtype(VALUE klass)
+{
+    return rbgobj_gtype_new(CLASS2GTYPE(klass));
+}
+
+VALUE
+rbgutil_generic_gtype(VALUE self)
+{
+    return generic_s_gtype(CLASS_OF(self));
+}
+
+VALUE
+rbgutil_string_set_utf8_encoding(VALUE string)
+{
+#ifdef HAVE_RB_STR_ENCODE
+    if (!NIL_P(string))
+        rb_enc_associate(string, rb_utf8_encoding());
+#endif
+    return string;
+}
+
+void
+Init_gutil()
+{
+    rbgutil_id_module_eval = rb_intern("module_eval");
+    id_set_property = rb_intern("set_property");
+    id_to_a = rb_intern("to_a");
+    id_add_one_arg_setter = rb_intern("__add_one_arg_setter");
+    id_allocate = rb_intern("allocate");
+}

data/ext/glib2/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(const GList *list);
+extern VALUE rbgutil_glist2ary_and_free(GList* list);
+extern VALUE rbgutil_glist2ary_boxed(const GList *list, GType gtype);
+extern VALUE rbgutil_glist2ary_boxed_and_free(GList *list, GType gtype);
+extern VALUE rbgutil_glist2ary_string(const GList *list);
+extern VALUE rbgutil_glist2ary_string_and_free(GList *list);
+extern VALUE rbgutil_gslist2ary(const GSList *list);
+extern VALUE rbgutil_gslist2ary_and_free(GSList *list);
+extern VALUE rbgutil_gslist2ary_boxed(const 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/ext/glib2/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
+}