gio2 1.0.3-x86-mingw32 → 1.1.0-x86-mingw32

data/ext/gio2/{ginitable.c → rbgioinitable.c}

@@ -1,29 +1,31 @@
-/* -*- c-file-style: "ruby" -*- */
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- * Ruby/GIO: a Ruby binding of gio-2.0.x.
- * Copyright (C) 2008-2009  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  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 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.
+ *  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
+ *  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 "gio2.h"
+#include "rbgio2private.h"
 
-#define _SELF(value) G_INITABLE(RVAL2GOBJ(value))
+#define RG_TARGET_NAMESPACE mInitable
+#define _SELF(value) RVAL2GINITABLE(value)
 
 static VALUE
-initable_init(int argc, VALUE *argv, VALUE self)
+rg_init(int argc, VALUE *argv, VALUE self)
 {
         VALUE cancellable;
         GError *error = NULL;
@@ -105,6 +107,8 @@ rbgio_ginitable_new_ensure(struct rbgio_ginitable_new_data *data)
                 if (G_IS_VALUE(&data->parameters[i].value))
                         g_value_unset(&data->parameters[i].value);
 
+        g_free(data->parameters);
+
         return Qnil;
 }
 
@@ -146,7 +150,7 @@ rbgio_ginitable_new(GType type, VALUE parameters, VALUE cancellable)
         data.rbparameters = parameters;
         data.index = 0;
         data.n_parameters = RVAL2GUINT(rb_funcall(parameters, s_id_length, 0));
-        data.parameters = ALLOCA_N(GParameter, data.n_parameters);
+        data.parameters = g_new(GParameter, data.n_parameters);
         data.error = NULL;
 
         object = (GObject *)rb_ensure(rbgio_ginitable_new_body, (VALUE)&data,
@@ -157,12 +161,12 @@ rbgio_ginitable_new(GType type, VALUE parameters, VALUE cancellable)
         return object;
 }
 
-/* NOTE: We don’t implement g_initable_new. */
+/* NOTE: We don't implement g_initable_new. */
 
-/* NOTE: We don’t implement g_initable_new_valist. */
+/* NOTE: We don't implement g_initable_new_valist. */
 
 static VALUE
-initable_initialize(int argc, VALUE *argv, VALUE self)
+rg_m_new(int argc, VALUE *argv, VALUE self)
 {
         const RGObjClassInfo* info;
         VALUE cancellable, parameters;
@@ -185,11 +189,11 @@ initable_initialize(int argc, VALUE *argv, VALUE self)
 }
 
 void
-Init_ginitable(VALUE glib)
+Init_ginitable(VALUE mGio)
 {
-        VALUE initable = G_DEF_INTERFACE(G_TYPE_INITABLE, "Initable", glib);
+        VALUE RG_TARGET_NAMESPACE = G_DEF_INTERFACE(G_TYPE_INITABLE, "Initable", mGio);
 
-        rb_define_module_function(initable, "new", initable_initialize, -1);
+        RG_DEF_MODFUNC(new, -1);
 
-        rb_define_method(initable, "init", initable_init, -1);
+        RG_DEF_METHOD(init, -1);
 }

data/ext/gio2/{ginputstream.c → rbgioinputstream.c}

@@ -1,31 +1,33 @@
-/* -*- c-file-style: "ruby" -*- */
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- * Ruby/GIO: a Ruby binding of gio-2.0.x.
- * Copyright (C) 2008-2009  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  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 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.
+ *  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
+ *  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 "gio2.h"
+#include "rbgio2private.h"
 
+#define RG_TARGET_NAMESPACE cInputStream
 #define _SELF(value) RVAL2GINPUTSTREAM(value)
 
 static VALUE s_cReadAsyncResult;
 
 static VALUE
-inputstream_read(int argc, VALUE *argv, VALUE self)
+rg_read(int argc, VALUE *argv, VALUE self)
 {
         VALUE rbcount, cancellable, result;
         gsize count;
@@ -51,7 +53,7 @@ inputstream_read(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-inputstream_read_all(int argc, VALUE *argv, VALUE self)
+rg_read_all(int argc, VALUE *argv, VALUE self)
 {
         VALUE rbcount, cancellable, result;
         gsize count;
@@ -77,7 +79,7 @@ inputstream_read_all(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-inputstream_skip(int argc, VALUE *argv, VALUE self)
+rg_skip(int argc, VALUE *argv, VALUE self)
 {
         VALUE count, cancellable;
         GError *error = NULL;
@@ -95,7 +97,7 @@ inputstream_skip(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-inputstream_close(int argc, VALUE *argv, VALUE self)
+rg_close(int argc, VALUE *argv, VALUE self)
 {
         VALUE cancellable;
         GError *error = NULL;
@@ -169,7 +171,7 @@ read_async_callback(G_GNUC_UNUSED GObject *source,
 }
 
 static VALUE
-inputstream_read_async(int argc, VALUE *argv, VALUE self)
+rg_read_async(int argc, VALUE *argv, VALUE self)
 {
         VALUE rbcount, rbio_priority, rbcancellable, block, data;
         gsize count;
@@ -194,7 +196,7 @@ inputstream_read_async(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-inputstream_read_finish(VALUE self, VALUE rbresult)
+rg_read_finish(VALUE self, VALUE rbresult)
 {
         struct read_async_result *result;
         GError *error = NULL;
@@ -215,7 +217,7 @@ inputstream_read_finish(VALUE self, VALUE rbresult)
 }
 
 static VALUE
-inputstream_skip_async(int argc, VALUE *argv, VALUE self)
+rg_skip_async(int argc, VALUE *argv, VALUE self)
 {
         VALUE rbcount, rbio_priority, rbcancellable, block;
         gsize count;
@@ -238,7 +240,7 @@ inputstream_skip_async(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-inputstream_skip_finish(VALUE self, VALUE result)
+rg_skip_finish(VALUE self, VALUE result)
 {
         GError *error = NULL;
         gssize skipped_bytes;
@@ -253,7 +255,7 @@ inputstream_skip_finish(VALUE self, VALUE result)
 }
 
 static VALUE
-inputstream_close_async(int argc, VALUE *argv, VALUE self)
+rg_close_async(int argc, VALUE *argv, VALUE self)
 {
         VALUE rbio_priority, rbcancellable, block;
         int io_priority;
@@ -273,7 +275,7 @@ inputstream_close_async(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-inputstream_close_finish(VALUE self, VALUE result)
+rg_close_finish(VALUE self, VALUE result)
 {
         GError *error = NULL;
         if (!g_input_stream_skip_finish(_SELF(self),
@@ -285,19 +287,19 @@ inputstream_close_finish(VALUE self, VALUE result)
 }
 
 static VALUE
-inputstream_is_closed(VALUE self)
+rg_closed_p(VALUE self)
 {
         return CBOOL2RVAL(g_input_stream_is_closed(_SELF(self)));
 }
 
 static VALUE
-inputstream_has_pending(VALUE self)
+rg_has_pending_p(VALUE self)
 {
         return CBOOL2RVAL(g_input_stream_has_pending(_SELF(self)));
 }
 
 static VALUE
-inputstream_set_pending(VALUE self)
+rg_set_pending(VALUE self)
 {
         GError *error = NULL;
 
@@ -308,7 +310,7 @@ inputstream_set_pending(VALUE self)
 }
 
 static VALUE
-inputstream_clear_pending(VALUE self)
+rg_clear_pending(VALUE self)
 {
         g_input_stream_clear_pending(_SELF(self));
 
@@ -316,24 +318,24 @@ inputstream_clear_pending(VALUE self)
 }
 
 void
-Init_ginputstream(VALUE glib)
+Init_ginputstream(VALUE mGio)
 {
-        VALUE inputstream = G_DEF_CLASS(G_TYPE_INPUT_STREAM, "InputStream", glib);
-
-        s_cReadAsyncResult = rb_define_class_under(inputstream, "ReadAsyncResult", rb_cObject);
-        
-        rb_define_method(inputstream, "read", inputstream_read, -1);
-        rb_define_method(inputstream, "read_all", inputstream_read_all, -1);
-        rb_define_method(inputstream, "skip", inputstream_skip, -1);
-        rb_define_method(inputstream, "close", inputstream_close, -1);
-        rb_define_method(inputstream, "read_async", inputstream_read_async, -1);
-        rb_define_method(inputstream, "read_finish", inputstream_read_finish, 1);
-        rb_define_method(inputstream, "skip_async", inputstream_skip_async, -1);
-        rb_define_method(inputstream, "skip_finish", inputstream_skip_finish, 1);
-        rb_define_method(inputstream, "close_async", inputstream_close_async, -1);
-        rb_define_method(inputstream, "close_finish", inputstream_close_finish, 1);
-        rb_define_method(inputstream, "closed?", inputstream_is_closed, 0);
-        rb_define_method(inputstream, "has_pending?", inputstream_has_pending, 0);
-        rb_define_method(inputstream, "set_pending", inputstream_set_pending, 0);
-        rb_define_method(inputstream, "clear_pending", inputstream_clear_pending, 0);
+        VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_INPUT_STREAM, "InputStream", mGio);
+
+        s_cReadAsyncResult = rb_define_class_under(RG_TARGET_NAMESPACE, "ReadAsyncResult", rb_cObject);
+
+        RG_DEF_METHOD(read, -1);
+        RG_DEF_METHOD(read_all, -1);
+        RG_DEF_METHOD(skip, -1);
+        RG_DEF_METHOD(close, -1);
+        RG_DEF_METHOD(read_async, -1);
+        RG_DEF_METHOD(read_finish, 1);
+        RG_DEF_METHOD(skip_async, -1);
+        RG_DEF_METHOD(skip_finish, 1);
+        RG_DEF_METHOD(close_async, -1);
+        RG_DEF_METHOD(close_finish, 1);
+        RG_DEF_METHOD_P(closed, 0);
+        RG_DEF_METHOD_P(has_pending, 0);
+        RG_DEF_METHOD(set_pending, 0);
+        RG_DEF_METHOD(clear_pending, 0);
 }

data/ext/gio2/rbgioio.c

@@ -0,0 +1,73 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  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, 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 "rbgio2private.h"
+
+#define RG_TARGET_NAMESPACE mIO
+
+/* NOTE: g_io_error_from_errno doesn't make sense from Ruby. */
+
+void
+Init_gioerror(VALUE mGio)
+{
+        VALUE RG_TARGET_NAMESPACE, error;
+
+        RG_TARGET_NAMESPACE = rb_define_module_under(mGio, "IO");
+
+        error = rbgio_define_domain_error(RG_TARGET_NAMESPACE, "Error", G_IO_ERROR, "GIOErrorEnum", rb_eIOError);
+
+        rbgio_define_error(RG_TARGET_NAMESPACE, "FailedError", G_IO_ERROR_FAILED, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "NotFoundError", G_IO_ERROR_NOT_FOUND, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "ExistsError", G_IO_ERROR_EXISTS, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "IsDirectoryError", G_IO_ERROR_IS_DIRECTORY, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "NotDirectoryError", G_IO_ERROR_NOT_DIRECTORY, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "NotEmptyError", G_IO_ERROR_NOT_EMPTY, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "NotRegularFileError", G_IO_ERROR_NOT_REGULAR_FILE, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "NotSymbolicLinkError", G_IO_ERROR_NOT_SYMBOLIC_LINK, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "NotMountableFileError", G_IO_ERROR_NOT_MOUNTABLE_FILE, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "FilenameTooLongError", G_IO_ERROR_FILENAME_TOO_LONG, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "InvalidFilenameError", G_IO_ERROR_INVALID_FILENAME, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "TooManyLinksError", G_IO_ERROR_TOO_MANY_LINKS, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "NoSpaceError", G_IO_ERROR_NO_SPACE, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "InvalidArgumentError", G_IO_ERROR_INVALID_ARGUMENT, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "PermissionDeniedError", G_IO_ERROR_PERMISSION_DENIED, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "NotSupportedError", G_IO_ERROR_NOT_SUPPORTED, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "NotMountedError", G_IO_ERROR_NOT_MOUNTED, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "AlreadyMountedError", G_IO_ERROR_ALREADY_MOUNTED, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "ClosedError", G_IO_ERROR_CLOSED, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "CancelledError", G_IO_ERROR_CANCELLED, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "PendingError", G_IO_ERROR_PENDING, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "ReadOnlyError", G_IO_ERROR_READ_ONLY, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "CantCreateBackupError", G_IO_ERROR_CANT_CREATE_BACKUP, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "WrongEtagError", G_IO_ERROR_WRONG_ETAG, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "TimedOutError", G_IO_ERROR_TIMED_OUT, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "WouldRecurseError", G_IO_ERROR_WOULD_RECURSE, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "BusyError", G_IO_ERROR_BUSY, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "WouldBlockError", G_IO_ERROR_WOULD_BLOCK, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "HostNotFoundError", G_IO_ERROR_HOST_NOT_FOUND, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "WouldMergeError", G_IO_ERROR_WOULD_MERGE, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "FailedHandledError", G_IO_ERROR_FAILED_HANDLED, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "TooManyOpenFilesError", G_IO_ERROR_TOO_MANY_OPEN_FILES, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "NotInitializedError", G_IO_ERROR_NOT_INITIALIZED, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "AddressInUseError", G_IO_ERROR_ADDRESS_IN_USE, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "PartialInputError", G_IO_ERROR_PARTIAL_INPUT, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "InvalidDataError", G_IO_ERROR_INVALID_DATA, error);
+}

data/ext/gio2/rbgioiomodule.c

@@ -0,0 +1,45 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  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, 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 "rbgio2private.h"
+
+#define RG_TARGET_NAMESPACE cIOModule
+#define _SELF(value) RVAL2GIOMODULE(value)
+
+static VALUE
+rg_initialize(VALUE self, VALUE filename)
+{
+        G_INITIALIZE(self, g_io_module_new(RVAL2CSTR(filename)));
+
+        return Qnil;
+}
+
+/* NOTE: No point in implementing g_io_module_query. */
+
+void
+Init_giomodule(VALUE mGio)
+{
+        VALUE RG_TARGET_NAMESPACE;
+
+        RG_TARGET_NAMESPACE = G_DEF_CLASS(G_IO_TYPE_MODULE, "IOModule", mGio);
+
+        RG_DEF_METHOD(initialize, 1);
+}

data/ext/gio2/rbgioiomodules.c

@@ -0,0 +1,47 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  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, 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 "rbgio2private.h"
+
+#define RG_TARGET_NAMESPACE mIOModules
+
+static VALUE
+rg_m_load_all_in_directory(G_GNUC_UNUSED VALUE self, VALUE dirname)
+{
+        return GLIST2ARY_FREE(g_io_modules_load_all_in_directory(RVAL2CSTR(dirname)));
+}
+
+static VALUE
+rg_m_scan_all_in_directory(VALUE self, VALUE dirname)
+{
+        g_io_modules_scan_all_in_directory(RVAL2CSTR(dirname));
+
+        return self;
+}
+
+void
+Init_giomodules(VALUE mGio)
+{
+        VALUE RG_TARGET_NAMESPACE = rb_define_module_under(mGio, "IOModules");
+
+        RG_DEF_MODFUNC(load_all_in_directory, 1);
+        RG_DEF_MODFUNC(scan_all_in_directory, 1);
+}

data/ext/gio2/rbgioioscheduler.c

@@ -0,0 +1,102 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  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, 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 "rbgio2private.h"
+
+#define RG_TARGET_NAMESPACE mIOScheduler
+
+struct ioscheduler_job_callback_data
+{
+        GIOSchedulerJob *job;
+        GCancellable *cancellable;
+        gpointer data;
+};
+
+static VALUE
+ioscheduler_job_callback_call(VALUE data)
+{
+        static VALUE s_id_call;
+        struct ioscheduler_job_callback_data *real;
+
+        if (s_id_call == 0)
+                s_id_call = rb_intern("call");
+
+        real = (struct ioscheduler_job_callback_data *)data;
+
+        /* TODO: Totally unsure if _UNREF is correct here or not. */
+        return rb_funcall(USE_BLOCK_AND_SAVE(real->data), s_id_call, 2,
+                          GOBJ2RVAL_UNREF(real->job),
+                          GOBJ2RVAL_UNREF(real->cancellable));
+}
+
+static gboolean
+ioscheduler_job_callback(GIOSchedulerJob *job,
+                         GCancellable *cancellable,
+                         gpointer data)
+{
+        struct ioscheduler_job_callback_data real = { job, cancellable, data };
+
+        return RVAL2CBOOL(G_PROTECT_CALLBACK(ioscheduler_job_callback_call,
+                                             &real));
+}
+
+static void
+ioscheduler_job_callback_free(gpointer data)
+{
+        USE_BLOCK((VALUE)data);
+}
+
+static VALUE
+rg_s_push_job(int argc, VALUE *argv, VALUE self)
+{
+        VALUE rbio_priority, rbcancellable, block;
+        gint io_priority;
+        GCancellable *cancellable;
+
+        rb_scan_args(argc, argv, "02", &rbio_priority, &rbcancellable);
+        io_priority = RVAL2IOPRIORITYDEFAULT(rbio_priority);
+        cancellable = RVAL2GCANCELLABLE(rbcancellable);
+        block = rb_block_proc();
+        SAVE_BLOCK(block);
+        g_io_scheduler_push_job(ioscheduler_job_callback,
+                                (gpointer)block,
+                                ioscheduler_job_callback_free,
+                                io_priority,
+                                cancellable);
+
+        return self;
+}
+
+static VALUE
+rg_s_cancel_all_jobs(VALUE self)
+{
+        g_io_scheduler_cancel_all_jobs();
+
+        return self;
+}
+
+void
+Init_gioscheduler(VALUE mGio)
+{
+        VALUE RG_TARGET_NAMESPACE = rb_define_module_under(mGio, "IOScheduler");
+        RG_DEF_SMETHOD(push_job, -1);
+        RG_DEF_SMETHOD(cancel_all_jobs, 0);
+}