gio2 0.90.3-x86-mingw32

data/ext/gio2/gvfs.c

@@ -0,0 +1,84 @@
+/* -*- c-file-style: "ruby" -*- */
+/*
+ * Ruby/GIO: a Ruby binding of gio-2.0.x.
+ * Copyright (C) 2008-2009  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.
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "gio2.h"
+
+#define _SELF(value) G_VFS(RVAL2GOBJ(value))
+
+static VALUE
+vfs_get_file_for_path(VALUE self, VALUE path)
+{
+        return GOBJ2RVAL_UNREF(g_vfs_get_file_for_path(_SELF(self), RVAL2CSTR(path)));
+}
+
+static VALUE
+vfs_get_file_for_uri(VALUE self, VALUE uri)
+{
+        return GOBJ2RVAL_UNREF(g_vfs_get_file_for_uri(_SELF(self), RVAL2CSTR(uri)));
+}
+
+static VALUE
+vfs_parse_name(VALUE self, VALUE parse_name)
+{
+        return GOBJ2RVAL_UNREF(g_vfs_parse_name(_SELF(self), RVAL2CSTR(parse_name)));
+}
+
+static VALUE
+vfs_get_default(G_GNUC_UNUSED VALUE self)
+{
+        return GOBJ2RVAL(g_vfs_get_default());
+}
+
+static VALUE
+vfs_get_local(G_GNUC_UNUSED VALUE self)
+{
+        return GOBJ2RVAL(g_vfs_get_local());
+}
+
+static VALUE
+vfs_is_active(VALUE self)
+{
+        return CBOOL2RVAL(g_vfs_is_active(_SELF(self)));
+}
+
+static VALUE
+vfs_get_supported_uri_schemes(VALUE self)
+{
+        return STRVECTOR2ARY(g_vfs_get_supported_uri_schemes(_SELF(self)));
+}
+
+void
+Init_gvfs(VALUE glib)
+{
+        VALUE vfs = G_DEF_CLASS(G_TYPE_VFS, "Vfs", glib);
+
+        rb_define_const(vfs, "EXTENSION_POINT_NAME", CSTR2RVAL(G_VFS_EXTENSION_POINT_NAME));
+
+        rb_define_singleton_method(vfs, "default", vfs_get_default, 0);
+        rb_define_singleton_method(vfs, "local", vfs_get_local, 0);
+
+        rb_undef_alloc_func(vfs);
+
+        rb_define_method(vfs, "file_for_path", vfs_get_file_for_path, 1);
+        rb_define_method(vfs, "file_for_uri", vfs_get_file_for_uri, 1);
+        rb_define_method(vfs, "parse_name", vfs_parse_name, 1);
+        rb_define_method(vfs, "active?", vfs_is_active, 0);
+        rb_define_method(vfs, "supported_uri_schemes", vfs_get_supported_uri_schemes, 0);
+}

data/ext/gio2/gvolume.c

@@ -0,0 +1,191 @@
+/* -*- c-file-style: "ruby" -*- */
+/*
+ * Ruby/GIO: a Ruby binding of gio-2.0.x.
+ * Copyright (C) 2008-2009  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.
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "gio2.h"
+
+#define _SELF(value) G_VOLUME(RVAL2GOBJ(value))
+
+static VALUE
+volume_get_name(VALUE self)
+{
+        return CSTR2RVAL_FREE(g_volume_get_name(_SELF(self)));
+}
+
+static VALUE
+volume_get_uuid(VALUE self)
+{
+        return CSTR2RVAL_FREE(g_volume_get_uuid(_SELF(self)));
+}
+
+static VALUE
+volume_get_icon(VALUE self)
+{
+        return GOBJ2RVAL_UNREF(g_volume_get_icon(_SELF(self)));
+}
+
+static VALUE
+volume_get_drive(VALUE self)
+{
+        return GOBJ2RVAL_UNREF(g_volume_get_drive(_SELF(self)));
+}
+
+static VALUE
+volume_get_mount(VALUE self)
+{
+        return GOBJ2RVAL_UNREF(g_volume_get_mount(_SELF(self)));
+}
+
+static VALUE
+volume_can_mount(VALUE self)
+{
+        return CBOOL2RVAL(g_volume_can_mount(_SELF(self)));
+}
+
+static VALUE
+volume_should_automount(VALUE self)
+{
+        return CBOOL2RVAL(g_volume_should_automount(_SELF(self)));
+}
+
+static VALUE
+volume_get_activation_root(VALUE self)
+{
+        return GOBJ2RVAL_UNREF(g_volume_get_activation_root(_SELF(self)));
+}
+
+static VALUE
+volume_mount(int argc, VALUE *argv, VALUE self)
+{
+        VALUE rbflags, rbmount_operation, rbcancellable, block;
+        GMountMountFlags flags;
+        GMountOperation *mount_operation;
+        GCancellable *cancellable;
+
+        rb_scan_args(argc, argv, "03&", &rbflags, &rbmount_operation, &rbcancellable, &block);
+        flags = RVAL2GMOUNTMOUNTFLAGSDEFAULT(rbflags);
+        mount_operation = RVAL2GMOUNTOPERATION(rbmount_operation);
+        cancellable = RVAL2GCANCELLABLE(rbcancellable);
+        SAVE_BLOCK(block);
+        g_volume_mount(_SELF(self),
+                       flags,
+                       mount_operation,
+                       cancellable,
+                       rbgio_async_ready_callback,
+                       (gpointer)block);
+
+        return self;
+}
+
+typedef gboolean (*BooleanFinishMethod)(GVolume *,
+                                        GAsyncResult *,
+                                        GError **);
+
+static VALUE
+boolean_finish_method(BooleanFinishMethod method, VALUE self, VALUE result)
+{
+        GError *error = NULL;
+
+        if (!method(_SELF(self), RVAL2GASYNCRESULT(result), &error))
+                rbgio_raise_error(error);
+
+        return self;
+}
+
+static VALUE
+volume_mount_finish(VALUE self, VALUE result)
+{
+        return boolean_finish_method(g_volume_mount_finish, self, result);
+}
+
+static VALUE
+volume_can_eject(VALUE self)
+{
+        return CBOOL2RVAL(g_volume_can_eject(_SELF(self)));
+}
+
+static VALUE
+volume_eject_with_operation(int argc, VALUE *argv, VALUE self)
+{
+        VALUE rbflags, rbmount_operation, rbcancellable, block;
+        GMountUnmountFlags flags;
+        GMountOperation *mount_operation;
+        GCancellable *cancellable;
+
+        rb_scan_args(argc, argv, "03&", &rbflags, &rbmount_operation, &rbcancellable, &block);
+        flags = RVAL2GMOUNTUNMOUNTFLAGSDEFAULT(rbflags);
+        mount_operation = RVAL2GMOUNTOPERATION(rbmount_operation);
+        cancellable = RVAL2GCANCELLABLE(rbcancellable);
+        SAVE_BLOCK(block);
+        g_volume_eject_with_operation(_SELF(self),
+                                      flags,
+                                      mount_operation,
+                                      cancellable,
+                                      rbgio_async_ready_callback,
+                                      (gpointer)block);
+
+        return self;
+}
+
+static VALUE
+volume_eject_with_operation_finish(VALUE self, VALUE result)
+{
+        return boolean_finish_method(g_volume_eject_with_operation_finish, self, result);
+}
+
+static VALUE
+volume_enumerate_identifiers(VALUE self)
+{
+        return STRVECTOR2ARY_FREE(g_volume_enumerate_identifiers(_SELF(self)));
+}
+
+static VALUE
+volume_get_identifier(VALUE self, VALUE kind)
+{
+        return CSTR2RVAL_FREE(g_volume_get_identifier(_SELF(self), RVAL2CSTR(kind)));
+}
+
+void
+Init_gvolume(VALUE glib)
+{
+        VALUE volume = G_DEF_INTERFACE(G_TYPE_VOLUME, "Volume", glib);
+
+        rb_define_const(volume, "IDENTIFIER_KIND_HAL_UDI", CSTR2RVAL(G_VOLUME_IDENTIFIER_KIND_HAL_UDI));
+        rb_define_const(volume, "IDENTIFIER_KIND_LABEL", CSTR2RVAL(G_VOLUME_IDENTIFIER_KIND_LABEL));
+        rb_define_const(volume, "IDENTIFIER_KIND_NFS_MOUNT", CSTR2RVAL(G_VOLUME_IDENTIFIER_KIND_NFS_MOUNT));
+        rb_define_const(volume, "IDENTIFIER_KIND_UNIX_DEVICE", CSTR2RVAL(G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE));
+        rb_define_const(volume, "IDENTIFIER_KIND_UUID", CSTR2RVAL(G_VOLUME_IDENTIFIER_KIND_UUID));
+
+        rb_define_method(volume, "name", volume_get_name, 0);
+        rb_define_method(volume, "uuid", volume_get_uuid, 0);
+        rb_define_method(volume, "icon", volume_get_icon, 0);
+        rb_define_method(volume, "drive", volume_get_drive, 0);
+        rb_define_method(volume, "mount", volume_get_mount, 0);
+        rb_define_method(volume, "can_mount?", volume_can_mount, 0);
+        rb_define_method(volume, "should_automount?", volume_should_automount, 0);
+        rb_define_method(volume, "activation_root", volume_get_activation_root, 0);
+        rb_define_method(volume, "mount", volume_mount, -1);
+        rb_define_method(volume, "mount_finish", volume_mount_finish, 1);
+        rb_define_method(volume, "can_eject?", volume_can_eject, 0);
+        rb_define_method(volume, "eject_with_operation", volume_eject_with_operation, -1);
+        rb_define_method(volume, "eject_with_operation_finish", volume_eject_with_operation_finish, 1);
+        rb_define_method(volume, "enumerate_identifiers", volume_enumerate_identifiers, -1);
+        rb_define_alias(volume, "identifiers", "enumerate_identifiers");
+        rb_define_method(volume, "get_identifier", volume_get_identifier, 1);
+}

data/ext/gio2/gvolumemonitor.c

@@ -0,0 +1,77 @@
+/* -*- c-file-style: "ruby" -*- */
+/*
+ * Ruby/GIO: a Ruby binding of gio-2.0.x.
+ * Copyright (C) 2008-2009  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.
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "gio2.h"
+
+#define _SELF(value) G_VOLUME_MONITOR(RVAL2GOBJ(value))
+
+static VALUE
+volumemonitor_get(G_GNUC_UNUSED VALUE self)
+{
+        return GOBJ2RVAL_UNREF(g_volume_monitor_get());
+}
+
+static VALUE
+volumemonitor_get_connected_drives(VALUE self)
+{
+        return GLIST2ARY_FREE(g_volume_monitor_get_connected_drives(_SELF(self)));
+}
+
+static VALUE
+volumemonitor_get_volumes(VALUE self)
+{
+        return GLIST2ARY_FREE(g_volume_monitor_get_volumes(_SELF(self)));
+}
+
+static VALUE
+volumemonitor_get_mounts(VALUE self)
+{
+        return GLIST2ARY_FREE(g_volume_monitor_get_mounts(_SELF(self)));
+}
+
+static VALUE
+volumemonitor_get_mount_for_uuid(VALUE self, VALUE value)
+{
+        return GOBJ2RVAL_UNREF(g_volume_monitor_get_mount_for_uuid(_SELF(self), RVAL2CSTR(value)));
+}
+
+static VALUE
+volumemonitor_get_volume_for_uuid(VALUE self, VALUE value)
+{
+        return GOBJ2RVAL_UNREF(g_volume_monitor_get_volume_for_uuid(_SELF(self), RVAL2CSTR(value)));
+}
+
+void
+Init_gvolumemonitor(VALUE glib)
+{
+        VALUE volumemonitor = G_DEF_CLASS(G_TYPE_VOLUME_MONITOR, "VolumeMonitor", glib);
+
+        rb_define_const(volumemonitor, "EXTENSION_POINT_NAME", CSTR2RVAL(G_VOLUME_MONITOR_EXTENSION_POINT_NAME));
+
+        rb_undef_alloc_func(volumemonitor);
+
+        rb_define_singleton_method(volumemonitor, "get", volumemonitor_get, 0);
+
+        rb_define_method(volumemonitor, "connected_drives", volumemonitor_get_connected_drives, 0);
+        rb_define_method(volumemonitor, "volumes", volumemonitor_get_volumes, 0);
+        rb_define_method(volumemonitor, "mounts", volumemonitor_get_mounts, 0);
+        rb_define_method(volumemonitor, "get_mount_for_uuid", volumemonitor_get_mount_for_uuid, 0);
+        rb_define_method(volumemonitor, "get_volume_for_uuid", volumemonitor_get_volume_for_uuid, 0);
+}

data/ext/gio2/gzlibcompressor.c

@@ -0,0 +1,47 @@
+/* -*- c-file-style: "ruby" -*- */
+/*
+ * Ruby/GIO: a Ruby binding of gio-2.0.x.
+ * Copyright (C) 2008-2009  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.
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "gio2.h"
+
+#define _SELF(value) G_ZLIB_COMPRESSOR(RVAL2GOBJ(value))
+
+#define RVAL2ZLIBCOMPRESSORLEVELDEFAULT(value) \
+        RVAL2TYPE_WITH_DEFAULT((value), FIX2INT, -1)
+
+static VALUE
+zlibcompressor_initialize(int argc, VALUE *argv, VALUE self)
+{
+        VALUE format, level;
+
+        rb_scan_args(argc, argv, "02", &format, &level);
+        G_INITIALIZE(self,
+                     g_zlib_compressor_new(RVAL2GZLIBCOMPRESSORFORMATDEFAULT(format),
+                                           RVAL2GZLIBCOMPRESSORFORMATDEFAULT(level)));
+
+        return Qnil;
+}
+
+void
+Init_gzlibcompressor(VALUE glib)
+{
+        VALUE zlibcompressor = G_DEF_CLASS(G_TYPE_ZLIB_COMPRESSOR, "ZlibCompressor", glib);
+
+        rb_define_method(zlibcompressor, "initialize", zlibcompressor_initialize, -1);
+}

data/ext/gio2/gzlibdecompressor.c

@@ -0,0 +1,43 @@
+/* -*- c-file-style: "ruby" -*- */
+/*
+ * Ruby/GIO: a Ruby binding of gio-2.0.x.
+ * Copyright (C) 2008-2009  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.
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "gio2.h"
+
+#define _SELF(value) G_ZLIB_DECOMPRESSOR(RVAL2GOBJ(value))
+
+static VALUE
+zlibdecompressor_initialize(int argc, VALUE *argv, VALUE self)
+{
+        VALUE format;
+
+        rb_scan_args(argc, argv, "01", &format);
+        G_INITIALIZE(self,
+                     g_zlib_decompressor_new(RVAL2GZLIBCOMPRESSORFORMATDEFAULT(format)));
+
+        return Qnil;
+}
+
+void
+Init_gzlibdecompressor(VALUE glib)
+{
+        VALUE zlibdecompressor = G_DEF_CLASS(G_TYPE_ZLIB_DECOMPRESSOR, "ZlibDecompressor", glib);
+
+        rb_define_method(zlibdecompressor, "initialize", zlibdecompressor_initialize, -1);
+}

data/ext/gio2/util.c

@@ -0,0 +1,323 @@
+/* -*- c-file-style: "ruby" -*- */
+/*
+ * Ruby/GIO: a Ruby binding of gio-2.0.x.
+ * Copyright (C) 2008-2009  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.
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "gio2.h"
+
+static ID s_id_enum_name;
+static ID s_id_errors;
+
+static VALUE s_errors;
+
+VALUE
+rbgio_cstr_to_rval_tainted(const char *string, gsize length)
+{
+        VALUE result;
+
+        if (string == NULL)
+                return Qnil;
+
+        result = rb_str_new(string, length);
+        OBJ_TAINT(result);
+
+        return result;
+}
+
+struct rbgio_cstr_to_rval_tainted_free_data
+{
+        char *string;
+        gsize length;
+};
+
+static VALUE
+rbgio_cstr_to_rval_tainted_free_body(VALUE data)
+{
+        struct rbgio_cstr_to_rval_tainted_free_data *real;
+
+        real = (struct rbgio_cstr_to_rval_tainted_free_data *)data;
+
+        return rbgio_cstr_to_rval_tainted(real->string, real->length);
+}
+
+static VALUE
+rbgio_cstr_to_rval_tainted_free_ensure(VALUE data)
+{
+        g_free(((struct rbgio_cstr_to_rval_tainted_free_data *)data)->string);
+
+        return Qnil;
+}
+
+VALUE
+rbgio_cstr_to_rval_tainted_free(char *string, gsize length)
+{
+        struct rbgio_cstr_to_rval_tainted_free_data data = { string, length };
+        
+        return rb_ensure(rbgio_cstr_to_rval_tainted_free_body, (VALUE)&data,
+                         rbgio_cstr_to_rval_tainted_free_ensure, (VALUE)&data);
+}
+
+VALUE
+rbgio_glist_to_ary_unref_free(GList *list)
+{
+        VALUE ary;
+        GList *i;
+
+        ary = rb_ary_new();
+        for (i = list; i != NULL; i = i->next)
+                rb_ary_push(ary, GOBJ2RVAL_UNREF(i->data));
+        g_list_free(list);
+
+        return ary;
+}
+
+VALUE
+rbgio_fds_to_ary(const gint *fds)
+{
+        int i, n;
+        VALUE ary;
+
+        for (i = n = 0; fds[i] != -1; i++)
+                n++;
+
+        ary = rb_ary_new2(n);
+        for (i = 0; i < n; i++)
+                RARRAY_PTR(ary)[i] = FD2RVAL(fds[i]);
+
+        return ary;
+}
+
+static VALUE
+rbgio_fds_to_ary_free_ensure(gint *fds)
+{
+        g_free(fds);
+
+        return Qnil;
+}
+
+VALUE
+rbgio_fds_to_ary_free(gint *fds)
+{
+        return rb_ensure(rbgio_fds_to_ary, (VALUE)fds,
+                         rbgio_fds_to_ary_free_ensure, (VALUE)fds);
+}
+
+GList *
+rbgio_gfile_ary_to_glist(VALUE ary)
+{
+        int i, n;
+        volatile GFile *file;
+        GList *list = NULL;
+
+        ary = rb_ary_to_ary(ary);
+        n = RARRAY_LEN(ary);
+
+        for (i = 0; i < n; i++)
+                file = RVAL2GFILE(RARRAY_PTR(ary)[i]);
+
+        for (i = 0; i < n; i++)
+                list = g_list_append(list, RVAL2GFILE(RARRAY_PTR(ary)[i]));
+
+        return list;
+}
+
+GList *
+rbgio_gfile_ary_to_glist_accept_nil(VALUE ary)
+{
+        if (NIL_P(ary))
+                return NULL;
+
+        return rbgio_gfile_ary_to_glist(ary);
+}
+
+void
+rbgio_rval_to_gtimeval(VALUE value, GTimeVal *time)
+{
+        if (rb_respond_to(value, rb_intern("tv_sec"))) {
+                time->tv_sec = RVAL2GLONG(rb_funcall(value, rb_intern("tv_sec"), 0));
+                time->tv_usec = rb_respond_to(value, rb_intern("tv_usec")) ?
+                        RVAL2GLONG(rb_funcall(value, rb_intern("tv_usec"), 0)) :
+                        0;
+        } else if (rb_respond_to(value, rb_intern("to_ary"))) {
+                VALUE ary = rb_ary_to_ary(value);
+                if (RARRAY_LEN(ary) < 1 || RARRAY_LEN(ary) > 2)
+                        rb_raise(rb_eArgError, "Array of length 1 or 2 expected");
+                time->tv_sec = RVAL2GLONG(RARRAY_PTR(ary)[0]);
+                time->tv_usec = RARRAY_LEN(ary) > 1 ? RVAL2GLONG(RARRAY_PTR(ary)[1]) : 0;
+        } else {
+                time->tv_sec = RVAL2GLONG(value);
+                time->tv_usec = 0;
+        }
+}
+
+VALUE
+rbgio_str_vector_to_ary(const gchar * const *vector)
+{
+        int i, n;
+        VALUE ary;
+ 
+        for (i = n = 0; vector[i] != NULL; i++)
+                n++;
+        ary = rb_ary_new2(n);
+        for (i = 0; i < n; i++)
+                RARRAY_PTR(ary)[i] = CSTR2RVAL(vector[i]);
+
+        return ary;
+}
+
+static VALUE
+rbgio_str_vector_to_ary_free_ensure(gchar **vector)
+{
+        g_strfreev(vector);
+
+        return Qnil;
+}
+
+VALUE
+rbgio_str_vector_to_ary_free(gchar **vector)
+{
+        return rb_ensure(rbgio_str_vector_to_ary, (VALUE)vector,
+                         rbgio_str_vector_to_ary_free_ensure, (VALUE)vector);
+}
+
+char **
+rbgio_ary_to_str_vector(VALUE ary)
+{
+        int i, n;
+        char **strings;
+
+        ary = rb_ary_to_ary(ary);
+        n = RARRAY_LEN(ary);
+
+        for (i = 0; i < n; i++)
+                StringValue(RARRAY_PTR(ary)[i]);
+
+        strings = g_new(char *, n + 1);
+        for (i = 0; i < n; i++)
+                strings[i] = RVAL2CSTR(RARRAY_PTR(ary)[i]);
+        strings[n] = NULL;
+
+        return strings;
+}
+
+struct async_ready_callback_data
+{
+        GAsyncResult *result;
+        gpointer data;
+};
+
+static VALUE
+rbgio_async_ready_callback_call(VALUE data)
+{
+        static VALUE s_id_call;
+        struct async_ready_callback_data *real;
+        VALUE block;
+ 
+        if (s_id_call == 0)
+                s_id_call = rb_intern("call");
+
+        real = (struct async_ready_callback_data *)data;
+        block = USE_BLOCK(real->data);
+        if (!NIL_P(block))
+                rb_funcall(block, s_id_call, 1, GOBJ2RVAL_UNREF(real->result));
+
+        return Qnil;
+}
+
+void
+rbgio_async_ready_callback(G_GNUC_UNUSED GObject *source,
+                           GAsyncResult *result,
+                           gpointer data)
+{
+        struct async_ready_callback_data real = { result, data };
+
+        G_PROTECT_CALLBACK(rbgio_async_ready_callback_call, &real);
+}
+
+VALUE
+rbgio_child_remove_and_return(VALUE parent, VALUE child)
+{
+        G_CHILD_REMOVE(parent, child);
+
+        return child;
+}
+
+VALUE
+rbgio_define_domain_error(VALUE module,
+                          const char *name,
+                          GQuark domain,
+                          const char *enum_name,
+                          VALUE parent)
+{
+        VALUE error;
+
+        error = rb_define_class_under(module, name, parent);
+        rb_ivar_set(error, s_id_enum_name, CSTR2RVAL(enum_name));
+        rb_ivar_set(error, s_id_errors, rb_hash_new());
+        rb_hash_aset(s_errors, UINT2NUM(domain), error);
+
+        return error;
+}
+
+VALUE
+rbgio_define_error(VALUE module,
+                   const char *name,
+                   gint code,
+                   VALUE domain_error)
+{
+        VALUE error;
+        
+        error = rb_define_class_under(module, name, domain_error);
+        rb_hash_aset(rb_ivar_get(domain_error, s_id_errors),
+                     INT2NUM(code),
+                     error);
+
+        return error;
+}
+
+void
+rbgio_raise_error(GError *error)
+{
+        VALUE domain_error, rberror;
+
+        domain_error = rb_hash_aref(s_errors, UINT2NUM(error->domain));
+        if (NIL_P(domain_error))
+                RAISE_GERROR(error);
+
+        rberror = rb_hash_aref(rb_ivar_get(domain_error, s_id_errors),
+                               INT2NUM(error->code));
+        if (NIL_P(rberror)) {
+                VALUE enum_name = rb_ivar_get(domain_error, s_id_enum_name);
+
+                rb_raise(rb_eNotImpError,
+                         "%s contains error codes that have not been implemented: %d",
+                         RVAL2CSTR(enum_name), error->code);
+        }
+
+        rb_raise(rberror, "%s", error->message);
+}
+
+void
+Init_util(void)
+{
+        s_id_enum_name = rb_intern("@enum_name");
+        s_id_errors = rb_intern("@errors");
+
+        s_errors = rb_hash_new();
+        rb_global_variable(&s_errors);
+}