gio2 0.90.3

data/ext/gio2/gresolver.c

@@ -0,0 +1,230 @@
+/* -*- 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_RESOLVER(RVAL2GOBJ(value))
+
+static VALUE
+resolver_get_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)
+{
+        g_resolver_set_default(_SELF(resolver));
+
+        return self;
+}
+
+static VALUE
+resolver_lookup_by_name(VALUE self, VALUE hostname, VALUE cancellable)
+{
+        GError *error = NULL;
+        GList *addresses;
+
+        addresses = g_resolver_lookup_by_name(_SELF(self),
+                                              RVAL2CSTR(hostname),
+                                              RVAL2GCANCELLABLE(cancellable),
+                                              &error);
+        if (addresses == NULL)
+                rbgio_raise_error(error);
+
+        return GLIST2ARY_UNREF_FREE(addresses);
+}
+
+static VALUE
+resolver_lookup_by_name_async(int argc, VALUE *argv, VALUE self)
+{
+        VALUE rbhostname, rbcancellable, block;
+        const gchar *hostname;
+        GCancellable *cancellable;
+
+        rb_scan_args(argc, argv, "11&", &hostname, &rbcancellable, &block);
+        hostname = RVAL2CSTR(rbhostname);
+        cancellable = RVAL2GCANCELLABLE(rbcancellable);
+        SAVE_BLOCK(block);
+        g_resolver_lookup_by_name_async(_SELF(self),
+                                        hostname,
+                                        cancellable,
+                                        rbgio_async_ready_callback,
+                                        (gpointer)block);
+
+        return self;
+}
+
+static VALUE
+resolver_lookup_by_name_finish(VALUE self, VALUE result)
+{
+        GError *error = NULL;
+        GList *addresses;
+
+        addresses = g_resolver_lookup_by_name_finish(_SELF(self),
+                                                     RVAL2GASYNCRESULT(result),
+                                                     &error);
+        if (addresses == NULL)
+                rbgio_raise_error(error);
+
+        return GLIST2ARY_UNREF_FREE(addresses);
+}
+
+static VALUE
+resolver_lookup_by_address(int argc, VALUE *argv, VALUE self)
+{
+        VALUE address, cancellable;
+        GError *error = NULL;
+        gchar *hostname;
+
+        rb_scan_args(argc, argv, "11", &address, &cancellable);
+        hostname = g_resolver_lookup_by_address(_SELF(self),
+                                                RVAL2GINETADDRESS(address),
+                                                RVAL2GCANCELLABLE(cancellable),
+                                                &error);
+        if (hostname == NULL)
+                rbgio_raise_error(error);
+
+        return CSTR2RVAL_FREE(hostname);
+}
+
+static VALUE
+resolver_lookup_by_address_async(int argc, VALUE *argv, VALUE self)
+{
+        VALUE rbaddress, rbcancellable, block;
+        GInetAddress *address;
+        GCancellable *cancellable;
+
+        rb_scan_args(argc, argv, "11&", &rbaddress, &rbcancellable, &block);
+        address = RVAL2GINETADDRESS(rbaddress);
+        cancellable = RVAL2GCANCELLABLE(rbcancellable);
+        SAVE_BLOCK(block);
+        g_resolver_lookup_by_address_async(_SELF(self),
+                                           address,
+                                           cancellable,
+                                           rbgio_async_ready_callback,
+                                           (gpointer)block);
+
+        return self;
+}
+
+static VALUE
+resolver_lookup_by_address_finish(VALUE self, VALUE result)
+{
+        GError *error = NULL;
+        gchar *hostname;
+
+        hostname = g_resolver_lookup_by_address_finish(_SELF(self),
+                                                       RVAL2GASYNCRESULT(result),
+                                                       &error);
+        if (hostname == NULL)
+                rbgio_raise_error(error);
+
+        return CSTR2RVAL_FREE(hostname);
+}
+
+static VALUE
+resolver_lookup_service(int argc, VALUE *argv, VALUE self)
+{
+        VALUE service, protocol, domain, cancellable;
+        GError *error = NULL;
+        GList *targets;
+
+        rb_scan_args(argc, argv, "31", &service, &protocol, &domain, &cancellable);
+        targets = g_resolver_lookup_service(_SELF(self),
+                                            RVAL2CSTR(service),
+                                            RVAL2CSTR(protocol),
+                                            RVAL2CSTR(domain),
+                                            RVAL2GCANCELLABLE(cancellable),
+                                            &error);
+        if (targets == NULL)
+                rbgio_raise_error(error);
+
+        return GLIST2ARY_UNREF_FREE(targets);
+}
+
+static VALUE
+resolver_lookup_service_async(int argc, VALUE *argv, VALUE self)
+{
+        VALUE rbservice, rbprotocol, rbdomain, rbcancellable, block;
+        const gchar *service;
+        const gchar *protocol;
+        const gchar *domain;
+        GCancellable *cancellable;
+
+        rb_scan_args(argc, argv, "31&", &rbservice, &rbprotocol, &rbdomain, &rbcancellable, &block);
+        service = RVAL2CSTR(rbservice);
+        protocol = RVAL2CSTR(rbprotocol);
+        domain = RVAL2CSTR(rbdomain);
+        cancellable = RVAL2GCANCELLABLE(rbcancellable);
+        SAVE_BLOCK(block);
+        g_resolver_lookup_service_async(_SELF(self),
+                                        service,
+                                        protocol,
+                                        domain,
+                                        cancellable,
+                                        rbgio_async_ready_callback,
+                                        (gpointer)block);
+
+        return self;
+}
+
+static VALUE
+resolver_lookup_service_finish(VALUE self, VALUE result)
+{
+        GError *error = NULL;
+        GList *targets;
+
+        targets = g_resolver_lookup_service_finish(_SELF(self), RVAL2GASYNCRESULT(result), &error);
+        if (targets == NULL)
+                rbgio_raise_error(error);
+
+        return GLIST2ARY_UNREF_FREE(targets);
+}
+
+void
+Init_gresolver(VALUE glib)
+{
+        VALUE resolver, error;
+        
+        resolver = G_DEF_CLASS(G_TYPE_RESOLVER, "Resolver", glib);
+
+        rb_define_singleton_method(resolver, "default", resolver_get_default, 0);
+        rb_define_singleton_method(resolver, "set_default", resolver_set_default, 1);
+
+        rb_undef_alloc_func(resolver);
+
+        /* 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);
+}

data/ext/gio2/gseekable.c

@@ -0,0 +1,89 @@
+/* -*- 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_SEEKABLE(RVAL2GOBJ(value))
+
+#define RVAL2GSEEKTYPEDEFAULT(value) \
+        RVAL2TYPE_WITH_DEFAULT((value), NUM2INT, G_SEEK_CUR)
+
+static VALUE
+seekable_tell(VALUE self)
+{
+        return GOFFSET2RVAL(g_seekable_tell(_SELF(self)));
+}
+
+static VALUE
+seekable_can_seek(VALUE self)
+{
+        return CBOOL2RVAL(g_seekable_can_seek(_SELF(self)));
+}
+
+static VALUE
+seekable_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
+seekable_can_truncate(VALUE self)
+{
+        return CBOOL2RVAL(g_seekable_can_truncate(_SELF(self)));
+}
+
+static VALUE
+seekable_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 glib)
+{
+        VALUE seekable = G_DEF_INTERFACE(G_TYPE_SEEKABLE, "Seekable", glib);
+
+        rb_define_method(seekable, "tell", seekable_tell, 0);
+        rb_define_method(seekable, "can_seek?", seekable_can_seek, 0);
+        rb_define_method(seekable, "seek", seekable_seek, -1);
+        rb_define_method(seekable, "can_truncate?", seekable_can_truncate, 0);
+        rb_define_method(seekable, "truncate", seekable_truncate, -1);
+}

data/ext/gio2/gsimpleasyncresult.c

@@ -0,0 +1,153 @@
+/* -*- 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_SIMPLE_ASYNC_RESULT(RVAL2GOBJ(value))
+
+static VALUE
+simpleasyncresult_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
+simpleasyncresult_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
+simpleasyncresult_get_op_res_gssize(VALUE self)
+{
+        return GSSIZE2RVAL(g_simple_async_result_get_op_res_gssize(_SELF(self)));
+}
+
+static VALUE
+simpleasyncresult_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
+simpleasyncresult_get_op_res_gboolean(VALUE self)
+{
+        return CBOOL2RVAL(g_simple_async_result_get_op_res_gboolean(_SELF(self)));
+}
+
+static VALUE
+simpleasyncresult_get_source_tag(VALUE self)
+{
+        return (VALUE)g_simple_async_result_get_source_tag(_SELF(self));
+}
+
+static VALUE
+simpleasyncresult_is_valid(VALUE self, VALUE source, VALUE source_tag)
+{
+        return CBOOL2RVAL(g_simple_async_result_is_valid(RVAL2GASYNCRESULT(self),
+                                                         RVAL2GOBJ(source),
+                                                         (gpointer)source_tag));
+}
+
+static VALUE
+simpleasyncresult_set_handle_cancellation(VALUE self, VALUE handle_cancellation)
+{
+        g_simple_async_result_set_handle_cancellation(_SELF(self),
+                                                      RVAL2CBOOL(handle_cancellation));
+
+        return self;
+}
+
+static VALUE
+simpleasyncresult_complete(VALUE self)
+{
+        g_simple_async_result_complete(_SELF(self));
+
+        return self;
+}
+
+static VALUE
+simpleasyncresult_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 glib)
+{
+        VALUE simpleasyncresult = G_DEF_CLASS(G_TYPE_SIMPLE_ASYNC_RESULT, "SimpleAsyncResult", glib);
+
+        rb_define_method(simpleasyncresult, "initialize", simpleasyncresult_initialize, 1);
+        rb_define_method(simpleasyncresult, "set_op_res_gssize", simpleasyncresult_set_op_res_gssize, 1);
+        G_DEF_SETTER(simpleasyncresult, "op_res_gssize");
+        rb_define_method(simpleasyncresult, "op_res_gssize", simpleasyncresult_get_op_res_gssize, 0);
+        rb_define_method(simpleasyncresult, "set_op_res_gboolean", simpleasyncresult_set_op_res_gboolean, 1);
+        G_DEF_SETTER(simpleasyncresult, "op_res_gboolean");
+        rb_define_method(simpleasyncresult, "op_res_gboolean", simpleasyncresult_get_op_res_gboolean, 0);
+        rb_define_method(simpleasyncresult, "source_tag", simpleasyncresult_get_source_tag, 0);
+        rb_define_method(simpleasyncresult, "valid?", simpleasyncresult_is_valid, 2);
+        rb_define_method(simpleasyncresult, "set_handle_cancellation", simpleasyncresult_set_handle_cancellation, 1);
+        G_DEF_SETTER(simpleasyncresult, "handle_cancellation");
+        rb_define_method(simpleasyncresult, "complete", simpleasyncresult_complete, 0);
+        rb_define_method(simpleasyncresult, "complete_in_idle", simpleasyncresult_complete_in_idle, 0);
+}