gio2 1.0.3 → 1.1.0

data/ext/gio2/{goutputstream.c → rbgiooutputstream.c}

@@ -1,37 +1,36 @@
-/* -*- 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 cOutputStream
 #define _SELF(value) RVAL2GOUTPUTSTREAM(value)
 
-#define RVAL2GOUTPUTSTREAMSPLICEFLAGS(value) \
-        RVAL2GFLAGS((value), G_TYPE_OUTPUT_STREAM_SPLICE_FLAGS)
-
 #define RVAL2GOUTPUTSTREAMSPLICEFLAGSDEFAULT(value) \
         RVAL2TYPE_WITH_DEFAULT((value), \
                                RVAL2GOUTPUTSTREAMSPLICEFLAGS, \
                                G_OUTPUT_STREAM_SPLICE_NONE)
 
 static VALUE
-outputstream_write(int argc, VALUE *argv, VALUE self)
+rg_write(int argc, VALUE *argv, VALUE self)
 {
         VALUE rbbuffer, cancellable;
         const char *buffer;
@@ -52,7 +51,7 @@ outputstream_write(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-outputstream_write_all(int argc, VALUE *argv, VALUE self)
+rg_write_all(int argc, VALUE *argv, VALUE self)
 {
         VALUE rbbuffer, cancellable;
         const char *buffer;
@@ -73,7 +72,7 @@ outputstream_write_all(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-outputstream_splice(int argc, VALUE *argv, VALUE self)
+rg_splice(int argc, VALUE *argv, VALUE self)
 {
         VALUE source, flags, cancellable;
         GError *error = NULL;
@@ -107,23 +106,23 @@ cancellable_method(CancellableMethod method, int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-outputstream_flush(int argc, VALUE *argv, VALUE self)
+rg_flush(int argc, VALUE *argv, VALUE self)
 {
         return cancellable_method(g_output_stream_flush, argc, argv, self);
 }
 
 static VALUE
-outputstream_close(int argc, VALUE *argv, VALUE self)
+rg_close(int argc, VALUE *argv, VALUE self)
 {
         return cancellable_method(g_output_stream_close, argc, argv, self);
 }
 
 /* TODO: Does it make sense to use buffer and count?  We should probably
- * provide a better wrapper that simply pumps out buffer while count hasn’t
+ * provide a better wrapper that simply pumps out buffer while count hasn't
  * been reached, calling the callback with the bytes written, then with the
  * result. */
 static VALUE
-outputstream_write_async(int argc, VALUE *argv, VALUE self)
+rg_write_async(int argc, VALUE *argv, VALUE self)
 {
         VALUE rbbuffer, rbcount, rbio_priority, rbcancellable, block;
         const gchar *buffer;
@@ -164,13 +163,13 @@ ssize_finish_method(SSizeFinishMethod method, VALUE self, VALUE result)
 }
 
 static VALUE
-outputstream_write_finish(VALUE self, VALUE result)
+rg_write_finish(VALUE self, VALUE result)
 {
         return ssize_finish_method(g_output_stream_write_finish, self, result);
 }
 
 static VALUE
-outputstream_splice_async(int argc, VALUE *argv, VALUE self)
+rg_splice_async(int argc, VALUE *argv, VALUE self)
 {
         VALUE rbsource, rbflags, rbio_priority, rbcancellable, block;
         GInputStream *source;
@@ -196,13 +195,13 @@ outputstream_splice_async(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-outputstream_splice_finish(VALUE self, VALUE result)
+rg_splice_finish(VALUE self, VALUE result)
 {
         return ssize_finish_method(g_output_stream_splice_finish, self, result);
 }
 
 static VALUE
-outputstream_flush_async(int argc, VALUE *argv, VALUE self)
+rg_flush_async(int argc, VALUE *argv, VALUE self)
 {
         VALUE rbio_priority, rbcancellable, block;
         int io_priority;
@@ -235,13 +234,13 @@ boolean_finish_method(BooleanFinishMethod method, VALUE self, VALUE result)
 }
 
 static VALUE
-outputstream_flush_finish(VALUE self, VALUE result)
+rg_flush_finish(VALUE self, VALUE result)
 {
         return boolean_finish_method(g_output_stream_flush_finish, self, result);
 }
 
 static VALUE
-outputstream_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;
@@ -261,31 +260,31 @@ outputstream_close_async(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-outputstream_close_finish(VALUE self, VALUE result)
+rg_close_finish(VALUE self, VALUE result)
 {
         return boolean_finish_method(g_output_stream_close_finish, self, result);
 }
 
 static VALUE
-outputstream_is_closing(VALUE self)
+rg_closing_p(VALUE self)
 {
         return CBOOL2RVAL(g_output_stream_is_closing(_SELF(self)));
 }
 
 static VALUE
-outputstream_is_closed(VALUE self)
+rg_closed_p(VALUE self)
 {
         return CBOOL2RVAL(g_output_stream_is_closed(_SELF(self)));
 }
 
 static VALUE
-outputstream_has_pending(VALUE self)
+rg_has_pending_p(VALUE self)
 {
         return CBOOL2RVAL(g_output_stream_has_pending(_SELF(self)));
 }
 
 static VALUE
-outputstream_set_pending(VALUE self)
+rg_set_pending(VALUE self)
 {
         GError *error = NULL;
 
@@ -296,7 +295,7 @@ outputstream_set_pending(VALUE self)
 }
 
 static VALUE
-outputstream_clear_pending(VALUE self)
+rg_clear_pending(VALUE self)
 {
         g_output_stream_clear_pending(_SELF(self));
 
@@ -304,30 +303,30 @@ outputstream_clear_pending(VALUE self)
 }
 
 void
-Init_goutputstream(VALUE glib)
+Init_goutputstream(VALUE mGio)
 {
-        VALUE outputstream = G_DEF_CLASS(G_TYPE_OUTPUT_STREAM, "OutputStream", glib);
-
-        G_DEF_CLASS(G_TYPE_OUTPUT_STREAM_SPLICE_FLAGS, "SpliceFlags", outputstream);
-        G_DEF_CONSTANTS(outputstream, G_TYPE_OUTPUT_STREAM_SPLICE_FLAGS, "G_OUTPUT_STREAM_");
-
-        rb_define_method(outputstream, "write", outputstream_write, -1);
-        rb_define_method(outputstream, "write_all", outputstream_write_all, -1);
-        rb_define_method(outputstream, "splice", outputstream_splice, -1);
-        rb_define_method(outputstream, "flush", outputstream_flush, -1);
-        rb_define_method(outputstream, "close", outputstream_close, -1);
-        rb_define_method(outputstream, "write_async", outputstream_write_async, -1);
-        rb_define_method(outputstream, "write_finish", outputstream_write_finish, 1);
-        rb_define_method(outputstream, "splice_async", outputstream_splice_async, -1);
-        rb_define_method(outputstream, "splice_finish", outputstream_splice_finish, 1);
-        rb_define_method(outputstream, "flush_async", outputstream_flush_async, -1);
-        rb_define_method(outputstream, "flush_finish", outputstream_flush_finish, 1);
-        rb_define_method(outputstream, "close_async", outputstream_close_async, -1);
-        rb_define_method(outputstream, "close_finish", outputstream_close_finish, 0);
-        rb_define_method(outputstream, "closing?", outputstream_is_closing, 0);
-        rb_define_method(outputstream, "closed?", outputstream_is_closed, 0);
-        rb_define_method(outputstream, "has_pending?", outputstream_has_pending, 0);
-        rb_define_method(outputstream, "set_pending", outputstream_set_pending, 0);
-        G_DEF_SETTER(outputstream, "pending");
-        rb_define_method(outputstream, "clear_pending", outputstream_clear_pending, 0);
+        VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_OUTPUT_STREAM, "OutputStream", mGio);
+
+        G_DEF_CLASS(G_TYPE_OUTPUT_STREAM_SPLICE_FLAGS, "SpliceFlags", RG_TARGET_NAMESPACE);
+        G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, G_TYPE_OUTPUT_STREAM_SPLICE_FLAGS, "G_OUTPUT_STREAM_");
+
+        RG_DEF_METHOD(write, -1);
+        RG_DEF_METHOD(write_all, -1);
+        RG_DEF_METHOD(splice, -1);
+        RG_DEF_METHOD(flush, -1);
+        RG_DEF_METHOD(close, -1);
+        RG_DEF_METHOD(write_async, -1);
+        RG_DEF_METHOD(write_finish, 1);
+        RG_DEF_METHOD(splice_async, -1);
+        RG_DEF_METHOD(splice_finish, 1);
+        RG_DEF_METHOD(flush_async, -1);
+        RG_DEF_METHOD(flush_finish, 1);
+        RG_DEF_METHOD(close_async, -1);
+        RG_DEF_METHOD(close_finish, 0);
+        RG_DEF_METHOD_P(closing, 0);
+        RG_DEF_METHOD_P(closed, 0);
+        RG_DEF_METHOD_P(has_pending, 0);
+        RG_DEF_METHOD(set_pending, 0);
+        G_DEF_SETTER(RG_TARGET_NAMESPACE, "pending");
+        RG_DEF_METHOD(clear_pending, 0);
 }

data/ext/gio2/{gresolver.c → rbgioresolver.c}

@@ -1,35 +1,37 @@
-/* -*- 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_RESOLVER(RVAL2GOBJ(value))
+#define RG_TARGET_NAMESPACE cResolver
+#define _SELF(value) RVAL2GRESOLVER(value)
 
 static VALUE
-resolver_get_default(G_GNUC_UNUSED VALUE self)
+rg_s_default(G_GNUC_UNUSED VALUE self)
 {
         return GOBJ2RVAL_UNREF(g_resolver_get_default());
 }
 
 static VALUE
-resolver_set_default(G_GNUC_UNUSED VALUE self, VALUE resolver)
+rg_s_set_default(G_GNUC_UNUSED VALUE self, VALUE resolver)
 {
         g_resolver_set_default(_SELF(resolver));
 
@@ -37,7 +39,7 @@ resolver_set_default(G_GNUC_UNUSED VALUE self, VALUE resolver)
 }
 
 static VALUE
-resolver_lookup_by_name(VALUE self, VALUE hostname, VALUE cancellable)
+rg_lookup_by_name(VALUE self, VALUE hostname, VALUE cancellable)
 {
         GError *error = NULL;
         GList *addresses;
@@ -53,7 +55,7 @@ resolver_lookup_by_name(VALUE self, VALUE hostname, VALUE cancellable)
 }
 
 static VALUE
-resolver_lookup_by_name_async(int argc, VALUE *argv, VALUE self)
+rg_lookup_by_name_async(int argc, VALUE *argv, VALUE self)
 {
         VALUE rbhostname, rbcancellable, block;
         const gchar *hostname;
@@ -73,7 +75,7 @@ resolver_lookup_by_name_async(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-resolver_lookup_by_name_finish(VALUE self, VALUE result)
+rg_lookup_by_name_finish(VALUE self, VALUE result)
 {
         GError *error = NULL;
         GList *addresses;
@@ -88,7 +90,7 @@ resolver_lookup_by_name_finish(VALUE self, VALUE result)
 }
 
 static VALUE
-resolver_lookup_by_address(int argc, VALUE *argv, VALUE self)
+rg_lookup_by_address(int argc, VALUE *argv, VALUE self)
 {
         VALUE address, cancellable;
         GError *error = NULL;
@@ -106,7 +108,7 @@ resolver_lookup_by_address(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-resolver_lookup_by_address_async(int argc, VALUE *argv, VALUE self)
+rg_lookup_by_address_async(int argc, VALUE *argv, VALUE self)
 {
         VALUE rbaddress, rbcancellable, block;
         GInetAddress *address;
@@ -126,7 +128,7 @@ resolver_lookup_by_address_async(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-resolver_lookup_by_address_finish(VALUE self, VALUE result)
+rg_lookup_by_address_finish(VALUE self, VALUE result)
 {
         GError *error = NULL;
         gchar *hostname;
@@ -141,7 +143,7 @@ resolver_lookup_by_address_finish(VALUE self, VALUE result)
 }
 
 static VALUE
-resolver_lookup_service(int argc, VALUE *argv, VALUE self)
+rg_lookup_service(int argc, VALUE *argv, VALUE self)
 {
         VALUE service, protocol, domain, cancellable;
         GError *error = NULL;
@@ -161,7 +163,7 @@ resolver_lookup_service(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-resolver_lookup_service_async(int argc, VALUE *argv, VALUE self)
+rg_lookup_service_async(int argc, VALUE *argv, VALUE self)
 {
         VALUE rbservice, rbprotocol, rbdomain, rbcancellable, block;
         const gchar *service;
@@ -187,7 +189,7 @@ resolver_lookup_service_async(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-resolver_lookup_service_finish(VALUE self, VALUE result)
+rg_lookup_service_finish(VALUE self, VALUE result)
 {
         GError *error = NULL;
         GList *targets;
@@ -200,29 +202,29 @@ resolver_lookup_service_finish(VALUE self, VALUE result)
 }
 
 void
-Init_gresolver(VALUE glib)
+Init_gresolver(VALUE mGio)
 {
-        VALUE resolver, error;
-        
-        resolver = G_DEF_CLASS(G_TYPE_RESOLVER, "Resolver", glib);
+        VALUE RG_TARGET_NAMESPACE, error;
 
-        rb_define_singleton_method(resolver, "default", resolver_get_default, 0);
-        rb_define_singleton_method(resolver, "set_default", resolver_set_default, 1);
+        RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_RESOLVER, "Resolver", mGio);
+
+        RG_DEF_SMETHOD(default, 0);
+        RG_DEF_SMETHOD(set_default, 1);
 
         /* TODO: Taint result of these methods? */
-        rb_define_method(resolver, "lookup_by_name", resolver_lookup_by_name, 2);
-        rb_define_method(resolver, "lookup_by_name_async", resolver_lookup_by_name_async, -1);
-        rb_define_method(resolver, "lookup_by_name_finish", resolver_lookup_by_name_finish, 1);
-        rb_define_method(resolver, "lookup_by_address", resolver_lookup_by_address, -1);
-        rb_define_method(resolver, "lookup_by_address_async", resolver_lookup_by_address_async, -1);
-        rb_define_method(resolver, "lookup_by_address_finish", resolver_lookup_by_address_finish, 1);
-        rb_define_method(resolver, "lookup_service", resolver_lookup_service, -1);
-        rb_define_method(resolver, "lookup_service_async", resolver_lookup_service_async, -1);
-        rb_define_method(resolver, "lookup_service_finish", resolver_lookup_service_finish, 1);
-
-        error = rbgio_define_domain_error(resolver, "Error", G_RESOLVER_ERROR, "GResolverErrorEnum", rb_eIOError);
-
-        rbgio_define_error(resolver, "NotFoundError", G_RESOLVER_ERROR_NOT_FOUND, error);
-        rbgio_define_error(resolver, "TemporaryFailureError", G_RESOLVER_ERROR_TEMPORARY_FAILURE, error);
-        rbgio_define_error(resolver, "InternalError", G_RESOLVER_ERROR_INTERNAL, error);
+        RG_DEF_METHOD(lookup_by_name, 2);
+        RG_DEF_METHOD(lookup_by_name_async, -1);
+        RG_DEF_METHOD(lookup_by_name_finish, 1);
+        RG_DEF_METHOD(lookup_by_address, -1);
+        RG_DEF_METHOD(lookup_by_address_async, -1);
+        RG_DEF_METHOD(lookup_by_address_finish, 1);
+        RG_DEF_METHOD(lookup_service, -1);
+        RG_DEF_METHOD(lookup_service_async, -1);
+        RG_DEF_METHOD(lookup_service_finish, 1);
+
+        error = rbgio_define_domain_error(RG_TARGET_NAMESPACE, "Error", G_RESOLVER_ERROR, "GResolverErrorEnum", rb_eIOError);
+
+        rbgio_define_error(RG_TARGET_NAMESPACE, "NotFoundError", G_RESOLVER_ERROR_NOT_FOUND, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "TemporaryFailureError", G_RESOLVER_ERROR_TEMPORARY_FAILURE, error);
+        rbgio_define_error(RG_TARGET_NAMESPACE, "InternalError", G_RESOLVER_ERROR_INTERNAL, error);
 }

data/ext/gio2/rbgioseekable.c

@@ -0,0 +1,91 @@
+/* -*- 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 mSeekable
+#define _SELF(value) RVAL2GSEEKABLE(value)
+
+#define RVAL2GSEEKTYPEDEFAULT(value) \
+        RVAL2TYPE_WITH_DEFAULT((value), NUM2INT, G_SEEK_CUR)
+
+static VALUE
+rg_tell(VALUE self)
+{
+        return GOFFSET2RVAL(g_seekable_tell(_SELF(self)));
+}
+
+static VALUE
+rg_can_seek_p(VALUE self)
+{
+        return CBOOL2RVAL(g_seekable_can_seek(_SELF(self)));
+}
+
+static VALUE
+rg_seek(int argc, VALUE *argv, VALUE self)
+{
+        VALUE offset, type, cancellable;
+        GError *error = NULL;
+
+        rb_scan_args(argc, argv, "12", &offset, &type, &cancellable);
+        if (!g_seekable_seek(_SELF(self),
+                             RVAL2GOFFSET(offset),
+                             RVAL2GSEEKTYPEDEFAULT(type),
+                             RVAL2GCANCELLABLE(cancellable),
+                             &error))
+                rbgio_raise_error(error);
+
+        return self;
+}
+
+static VALUE
+rg_can_truncate_p(VALUE self)
+{
+        return CBOOL2RVAL(g_seekable_can_truncate(_SELF(self)));
+}
+
+static VALUE
+rg_truncate(int argc, VALUE *argv, VALUE self)
+{
+        VALUE offset, cancellable;
+        GError *error = NULL;
+
+        rb_scan_args(argc, argv, "11", &offset, &cancellable);
+        if (!g_seekable_truncate(_SELF(self),
+                                 RVAL2GOFFSET(offset),
+                                 RVAL2GCANCELLABLE(cancellable),
+                                 &error))
+                rbgio_raise_error(error);
+
+        return self;
+}
+
+void
+Init_gseekable(VALUE mGio)
+{
+        VALUE RG_TARGET_NAMESPACE = G_DEF_INTERFACE(G_TYPE_SEEKABLE, "Seekable", mGio);
+
+        RG_DEF_METHOD(tell, 0);
+        RG_DEF_METHOD_P(can_seek, 0);
+        RG_DEF_METHOD(seek, -1);
+        RG_DEF_METHOD_P(can_truncate, 0);
+        RG_DEF_METHOD(truncate, -1);
+}

data/ext/gio2/rbgiosimpleasyncresult.c

@@ -0,0 +1,155 @@
+/* -*- 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 cSimpleAsyncResult
+#define _SELF(value) RVAL2GSIMPLEASYNCRESULT(value)
+
+static VALUE
+rg_initialize(VALUE self, VALUE object)
+{
+        VALUE block;
+
+        /* TODO: I have absolutely no idea if this makes sense.  Should we even
+         * be providing this method? */
+        block = rb_block_proc();
+        SAVE_BLOCK(block);
+        G_INITIALIZE(self,
+                     g_simple_async_result_new(RVAL2GOBJ(object),
+                                               rbgio_async_ready_callback,
+                                               (gpointer)block,
+                                               (gpointer)block));
+
+        return Qnil;
+}
+
+/* NOTE: Can't implement g_simple_async_result_new_error. */
+
+/* NOTE: Can't implement g_simple_async_result_new_from_error. */
+
+/* NOTE: Can't implement g_simple_async_result_set_op_res_gpointer. */
+
+/* NOTE: Can't implement g_simple_async_result_get_op_res_gpointer. */
+
+static VALUE
+rg_set_op_res_gssize(VALUE self, VALUE op_res)
+{
+        g_simple_async_result_set_op_res_gssize(_SELF(self),
+                                                RVAL2GSSIZE(op_res));
+
+        return self;
+}
+
+static VALUE
+rg_op_res_gssize(VALUE self)
+{
+        return GSSIZE2RVAL(g_simple_async_result_get_op_res_gssize(_SELF(self)));
+}
+
+static VALUE
+rg_set_op_res_gboolean(VALUE self, VALUE op_res)
+{
+        g_simple_async_result_set_op_res_gboolean(_SELF(self),
+                                                  RVAL2CBOOL(op_res));
+
+        return self;
+}
+
+static VALUE
+rg_op_res_gboolean(VALUE self)
+{
+        return CBOOL2RVAL(g_simple_async_result_get_op_res_gboolean(_SELF(self)));
+}
+
+static VALUE
+rg_source_tag(VALUE self)
+{
+        return (VALUE)g_simple_async_result_get_source_tag(_SELF(self));
+}
+
+static VALUE
+rg_valid_p(VALUE self, VALUE source, VALUE source_tag)
+{
+        return CBOOL2RVAL(g_simple_async_result_is_valid(RVAL2GASYNCRESULT(self),
+                                                         RVAL2GOBJ(source),
+                                                         (gpointer)source_tag));
+}
+
+static VALUE
+rg_set_handle_cancellation(VALUE self, VALUE handle_cancellation)
+{
+        g_simple_async_result_set_handle_cancellation(_SELF(self),
+                                                      RVAL2CBOOL(handle_cancellation));
+
+        return self;
+}
+
+static VALUE
+rg_complete(VALUE self)
+{
+        g_simple_async_result_complete(_SELF(self));
+
+        return self;
+}
+
+static VALUE
+rg_complete_in_idle(VALUE self)
+{
+        g_simple_async_result_complete_in_idle(_SELF(self));
+
+        return self;
+}
+
+/* TODO: Should we implement g_simple_async_result_run_in_thread?  I'd say no,
+ * but I'm not sure. */
+
+/* NOTE: Can't implement g_simple_async_result_set_from_error. */
+
+/* NOTE: Can't implement g_simple_async_result_propagate_error. */
+
+/* NOTE: Can't implement g_simple_async_result_set_error. */
+
+/* NOTE: Can't implement g_simple_async_result_set_error_va. */
+
+/* NOTE: Can't implement g_simple_async_result_report_error_in_idle. */
+
+/* NOTE: Can't implement g_simple_async_result_report_gerror_in_idle. */
+
+void
+Init_gsimpleasyncresult(VALUE mGio)
+{
+        VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_SIMPLE_ASYNC_RESULT, "SimpleAsyncResult", mGio);
+
+        RG_DEF_METHOD(initialize, 1);
+        RG_DEF_METHOD(set_op_res_gssize, 1);
+        G_DEF_SETTER(RG_TARGET_NAMESPACE, "op_res_gssize");
+        RG_DEF_METHOD(op_res_gssize, 0);
+        RG_DEF_METHOD(set_op_res_gboolean, 1);
+        G_DEF_SETTER(RG_TARGET_NAMESPACE, "op_res_gboolean");
+        RG_DEF_METHOD(op_res_gboolean, 0);
+        RG_DEF_METHOD(source_tag, 0);
+        RG_DEF_METHOD_P(valid, 2);
+        RG_DEF_METHOD(set_handle_cancellation, 1);
+        G_DEF_SETTER(RG_TARGET_NAMESPACE, "handle_cancellation");
+        RG_DEF_METHOD(complete, 0);
+        RG_DEF_METHOD(complete_in_idle, 0);
+}