gio2 0.90.3

data/ext/gio2/gapplaunchcontext.c

@@ -0,0 +1,79 @@
+/* -*- 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) RVAL2GAPPLAUNCHCONTEXT(value)
+
+static VALUE
+applaunchcontext_initialize(VALUE self)
+{
+        G_INITIALIZE(self, g_app_launch_context_new());
+
+        return Qnil;
+}
+
+typedef char *(*GetMethod)(GAppLaunchContext *, GAppInfo *, GList *);
+
+static VALUE
+get_value_by(GetMethod method, int argc, VALUE *argv, VALUE self)
+{
+        VALUE info, rbfiles;
+        GList *files;
+        char *value;
+
+        rb_scan_args(argc, argv, "11", &info, &rbfiles);
+        files = GFILEARY2GLIST_ACCEPT_NIL(rbfiles);
+        value = method(_SELF(self), RVAL2GAPPINFO(info), files);
+        g_list_free(files);
+
+        return CSTR2RVAL_FREE(value);
+}
+
+static VALUE
+applaunchcontext_get_display(int argc, VALUE *argv, VALUE self)
+{
+        return get_value_by(g_app_launch_context_get_display, argc, argv, self);
+}
+
+static VALUE
+applaunchcontext_get_startup_notify_id(int argc, VALUE *argv, VALUE self)
+{
+        return get_value_by(g_app_launch_context_get_startup_notify_id, argc, argv, self);
+}
+
+static VALUE
+applaunchcontext_launch_failed(VALUE self, VALUE sn_id)
+{
+        g_app_launch_context_launch_failed(_SELF(self), RVAL2CSTR(sn_id));
+
+        return self;
+}
+
+void
+Init_gapplaunchcontext(VALUE glib)
+{
+        VALUE applaunchcontext = G_DEF_CLASS(G_TYPE_APP_LAUNCH_CONTEXT, "AppLaunchContext", glib);
+
+        rb_define_method(applaunchcontext, "initialize", applaunchcontext_initialize, 0);
+        rb_define_method(applaunchcontext, "get_display", applaunchcontext_get_display, -1);
+        rb_define_method(applaunchcontext, "get_startup_notify_id", applaunchcontext_get_startup_notify_id, -1);
+        rb_define_method(applaunchcontext, "launch_failed", applaunchcontext_launch_failed, 1);
+}

data/ext/gio2/gasyncinitable.c

@@ -0,0 +1,244 @@
+/* -*- 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_ASYNC_INITABLE(RVAL2GOBJ(value))
+
+static VALUE
+asyncinitable_init_async(int argc, VALUE *argv, VALUE self)
+{
+        VALUE rbio_priority, rbcancellable, block;
+        int io_priority;
+        GCancellable *cancellable;
+
+        rb_scan_args(argc, argv, "02&", &rbio_priority, &rbcancellable, &block);
+        io_priority = RVAL2IOPRIORITYDEFAULT(rbio_priority);
+        cancellable = RVAL2GCANCELLABLE(rbcancellable);
+        SAVE_BLOCK(block);
+        g_async_initable_init_async(_SELF(self),
+                                    io_priority,
+                                    cancellable,
+                                    rbgio_async_ready_callback,
+                                    (gpointer)block);
+
+        return self;
+}
+
+static VALUE
+asyncinitable_init_finish(VALUE self, VALUE result)
+{
+        GError *error = NULL;
+
+        if (!g_async_initable_init_finish(_SELF(self),
+                                          RVAL2GASYNCRESULT(result),
+                                          &error))
+                rbgio_raise_error(error);
+
+        return self;
+}
+
+/* NOTE: We don’t implement g_async_initable_new_async. */
+
+/* NOTE: We don’t implement g_async_initable_new_valist_async. */
+
+struct rbgio_gasyncinitable_new_async_data {
+        GObjectClass *gclass;
+        int io_priority;
+        GCancellable *cancellable;
+        VALUE block;
+        VALUE rbparameters;
+        guint index;
+        guint n_parameters;
+        GParameter *parameters;
+};
+
+static VALUE
+rbgio_gasyncinitiable_new_async_parameters_initialize(VALUE key_value,
+                                                      struct rbgio_gasyncinitable_new_async_data *data)
+{
+        VALUE key, value;
+        GParamSpec *spec;
+
+        if (data->index >= data->n_parameters)
+                rb_raise(rb_eArgError,
+                         "too many parameters (%d >= %d)",
+                         data->index, data->n_parameters);
+
+        key = rb_ary_entry(key_value, 0);
+        value = rb_ary_entry(key_value, 1);
+
+        data->parameters[data->index].name = SYMBOL_P(key) ?
+                rb_id2name(SYM2ID(key)) :
+                StringValuePtr(key);
+        spec = g_object_class_find_property(data->gclass,
+                                            data->parameters[data->index].name);
+        if (spec == NULL)
+                rb_raise(rb_eArgError,
+                         "%s: no such property",
+                         data->parameters[data->index].name);
+        g_value_init(&(data->parameters[data->index].value),
+                     G_PARAM_SPEC_VALUE_TYPE(spec));
+        rbgobj_rvalue_to_gvalue(value, &(data->parameters[data->index].value));
+
+        data->index++;
+
+        return Qnil;
+}
+
+static VALUE
+rbgio_gasyncinitable_new_async_body(struct rbgio_gasyncinitable_new_async_data *data)
+{
+        rb_iterate(rb_each,
+                   data->rbparameters,
+                   rbgio_gasyncinitiable_new_async_parameters_initialize,
+                   (VALUE)data);
+
+        SAVE_BLOCK(data->block);
+
+        g_async_initable_newv_async(G_TYPE_FROM_CLASS(data->gclass),
+                                    data->n_parameters,
+                                    data->parameters,
+                                    data->io_priority,
+                                    data->cancellable,
+                                    rbgio_async_ready_callback,
+                                    (gpointer)data->block);
+
+        return Qnil;
+}
+
+static VALUE
+rbgio_gasyncinitable_new_async_ensure(struct rbgio_gasyncinitable_new_async_data *data)
+{
+        guint i;
+
+        g_type_class_unref(data->gclass);
+        for (i = 0; i < data->n_parameters; i++)
+                if (G_IS_VALUE(&data->parameters[i].value))
+                        g_value_unset(&data->parameters[i].value);
+
+        return Qnil;
+}
+
+void
+rbgio_gasyncinitable_new_async(GType type,
+                               VALUE parameters,
+                               VALUE io_priority,
+                               VALUE cancellable,
+                               VALUE block)
+{
+        static ID s_id_length;
+        struct rbgio_gasyncinitable_new_async_data data;
+
+        if (s_id_length == 0)
+                s_id_length = rb_intern("length");
+
+        if (!g_type_is_a(type, G_TYPE_OBJECT))
+                rb_raise(rb_eArgError,
+                         "%s is not a descendant of GObject",
+                         g_type_name(type));
+
+        if (NIL_P(parameters)) {
+                SAVE_BLOCK(block);
+                g_async_initable_newv_async(type,
+                                            0,
+                                            NULL,
+                                            RVAL2IOPRIORITYDEFAULT(io_priority),
+                                            RVAL2GCANCELLABLE(cancellable),
+                                            rbgio_async_ready_callback,
+                                            (gpointer)block);
+
+                return;
+        } else {
+                parameters = rb_convert_type(parameters,
+                                             T_HASH,
+                                             "Hash",
+                                             "to_hash");
+        }
+
+        data.gclass = G_OBJECT_CLASS(g_type_class_ref(type));
+        data.io_priority = RVAL2IOPRIORITYDEFAULT(io_priority);
+        data.cancellable = RVAL2GCANCELLABLE(cancellable);
+        data.block = block;
+        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);
+
+        rb_ensure(rbgio_gasyncinitable_new_async_body, (VALUE)&data,
+                  rbgio_gasyncinitable_new_async_ensure, (VALUE)&data);
+
+        return;
+}
+
+static VALUE
+asyncinitable_initialize(int argc, VALUE *argv, VALUE self)
+{
+        const RGObjClassInfo* info;
+        VALUE io_priority, cancellable, parameters, block;
+
+        rb_scan_args(argc, argv, "03&", &io_priority, &cancellable, &parameters, &block);
+
+        info = CLASS2CINFO(self);
+        if (info->klass != self)
+                rb_raise(rb_eTypeError,
+                         "%s: class not registered with GLib",
+                         rb_class2name(self));
+
+        rbgio_gasyncinitable_new_async(info->gtype,
+                                       parameters,
+                                       io_priority,
+                                       cancellable,
+                                       block);
+
+        return self;
+}
+
+
+static VALUE
+asyncinitable_initialize_finish(VALUE self, VALUE result)
+{
+        GError *error = NULL;
+        GObject *object;
+        VALUE rbobject;
+
+        object = g_async_initable_new_finish(_SELF(self),
+                                             RVAL2GASYNCRESULT(result),
+                                             &error);
+        if (object == NULL)
+                rbgio_raise_error(error);
+
+        rbobject = GOBJ2RVAL(object);
+        g_object_unref(object);
+
+        return rbobject;
+}
+
+void
+Init_gasyncinitable(VALUE glib)
+{
+        VALUE asyncinitable = G_DEF_INTERFACE(G_TYPE_ASYNC_INITABLE, "AsyncInitable", glib);
+
+        rb_define_method(asyncinitable, "init_async", asyncinitable_init_async, -1);
+        rb_define_method(asyncinitable, "init_finish", asyncinitable_init_finish, 1);
+        rb_define_method(asyncinitable, "initialize", asyncinitable_initialize, -1);
+        /* TODO: Ruby name? */
+        rb_define_method(asyncinitable, "initialize_finish", asyncinitable_initialize_finish, 1);
+}

data/ext/gio2/gasyncresult.c

@@ -0,0 +1,39 @@
+/* -*- 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) RVAL2GASYNCRESULT(value)
+
+/* NOTE: g_async_result_get_user_data isn’t of any use from Ruby. */
+
+static VALUE
+asyncresult_get_source_object(VALUE self)
+{
+        return GOBJ2RVAL_UNREF(g_async_result_get_source_object(_SELF(self)));
+}
+
+void
+Init_gasyncresult(VALUE glib)
+{
+        VALUE asyncresult = G_DEF_INTERFACE(G_TYPE_ASYNC_RESULT, "AsyncResult", glib);
+
+        rb_define_method(asyncresult, "source_object", asyncresult_get_source_object, 0);
+}

data/ext/gio2/gbufferedinputstream.c

@@ -0,0 +1,184 @@
+/* -*- 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_BUFFERED_INPUT_STREAM(RVAL2GOBJ(value))
+
+static VALUE
+bufferedinputstream_initialize(int argc, VALUE *argv, VALUE self)
+{
+        VALUE rbbase_stream, size;
+        GInputStream *base_stream, *stream;
+
+        rb_scan_args(argc, argv, "11", &rbbase_stream, &size);
+        base_stream = RVAL2GINPUTSTREAM(rbbase_stream);
+
+        stream = NIL_P(size) ?
+                g_buffered_input_stream_new(base_stream) :
+                g_buffered_input_stream_new_sized(base_stream, RVAL2GSIZE(size));
+        G_INITIALIZE(self, stream);
+
+        return Qnil;
+}
+
+static VALUE
+bufferedinputstream_get_buffer_size(VALUE self)
+{
+        return GSIZE2RVAL(g_buffered_input_stream_get_buffer_size(_SELF(self)));
+}
+
+static VALUE
+bufferedinputstream_set_buffer_size(VALUE self, VALUE size)
+{
+        g_buffered_input_stream_set_buffer_size(_SELF(self), RVAL2GSIZE(size));
+
+        return self;
+}
+
+static VALUE
+bufferedinputstream_get_available(VALUE self)
+{
+        return GSIZE2RVAL(g_buffered_input_stream_get_available(_SELF(self)));
+}
+
+static VALUE
+bufferedinputstream_peek_buffer(VALUE self)
+{
+        gsize size;
+        const void *buffer;
+
+        buffer = g_buffered_input_stream_peek_buffer(_SELF(self), &size);
+
+        return CSTR2RVAL_TAINTED(buffer, size);
+}
+
+static VALUE
+bufferedinputstream_peek(VALUE self, VALUE rboffset, VALUE rbcount)
+{
+        gsize offset = RVAL2GSIZE(rboffset);
+        gsize count = RVAL2GSIZE(rbcount);
+        VALUE result = rb_str_new(NULL, count);
+        gsize bytes_peeked = g_buffered_input_stream_peek(_SELF(self),
+                                                          RSTRING_PTR(result),
+                                                          offset,
+                                                          count);
+        if (bytes_peeked == (gsize)-1)
+                rb_raise(rb_eIOError, "cannot peek"); /* TODO: Better class and message */
+
+        rb_str_set_len(result, bytes_peeked);
+        rb_str_resize(result, bytes_peeked);
+        OBJ_TAINT(result);
+
+        return result;
+}
+
+static VALUE
+bufferedinputstream_fill(int argc, VALUE *argv, VALUE self)
+{
+        VALUE count, cancellable;
+        GError *error = NULL;
+        gsize bytes_read;
+
+        rb_scan_args(argc, argv, "02", &count, &cancellable);
+        bytes_read = g_buffered_input_stream_fill(_SELF(self),
+                                                  NIL_P(count) ?
+                                                  -1 :
+                                                  RVAL2GSSIZE(count),
+                                                  RVAL2GCANCELLABLE(cancellable),
+                                                  &error);
+        if (error != NULL)
+                rbgio_raise_error(error);
+
+        return GSSIZE2RVAL(bytes_read);
+}
+
+static VALUE
+bufferedinputstream_fill_async(int argc, VALUE *argv, VALUE self)
+{
+        VALUE rbcount, rbio_priority, rbcancellable, block;
+        gssize count;
+        int io_priority;
+        GCancellable *cancellable;
+
+        rb_scan_args(argc, argv, "03&", &rbcount, &rbio_priority, &rbcancellable, &block);
+        count = NIL_P(rbcount) ? -1 : RVAL2GSSIZE(rbcount);
+        io_priority = RVAL2IOPRIORITYDEFAULT(rbio_priority);
+        cancellable = RVAL2GCANCELLABLE(rbcancellable);
+        SAVE_BLOCK(block);
+        g_buffered_input_stream_fill_async(_SELF(self),
+                                           count,
+                                           io_priority,
+                                           cancellable,
+                                           rbgio_async_ready_callback,
+                                           (gpointer)block);
+
+        return self;
+}
+
+static VALUE
+bufferedinputstream_fill_finish(VALUE self, VALUE result)
+{
+        GError *error = NULL;
+        gsize bytes_read;
+
+        bytes_read = g_buffered_input_stream_fill_finish(_SELF(self),
+                                                         RVAL2GASYNCRESULT(result),
+                                                         &error);
+        if (error != NULL)
+                rbgio_raise_error(error);
+
+        return GSSIZE2RVAL(bytes_read);
+}
+
+static VALUE
+bufferedinputstream_read_byte(int argc, VALUE *argv, VALUE self)
+{
+        VALUE cancellable;
+        GError *error = NULL;
+        int byte;
+
+        rb_scan_args(argc, argv, "01", &cancellable);
+        byte = g_buffered_input_stream_read_byte(_SELF(self),
+                                                 RVAL2GCANCELLABLE(cancellable),
+                                                 &error);
+        if (error != NULL)
+                rbgio_raise_error(error);
+
+        return INT2FIX(byte);
+}
+
+void
+Init_gbufferedinputstream(VALUE glib)
+{
+        VALUE bufferedinputstream = G_DEF_CLASS(G_TYPE_BUFFERED_INPUT_STREAM, "BufferedInputStream", glib);
+
+        rb_define_method(bufferedinputstream, "initialize", bufferedinputstream_initialize, -1);
+        rb_define_method(bufferedinputstream, "buffer_size", bufferedinputstream_get_buffer_size, 0);
+        rb_define_method(bufferedinputstream, "set_buffer_size", bufferedinputstream_set_buffer_size, 1);
+        G_DEF_SETTER(bufferedinputstream, "buffer_size");
+        rb_define_method(bufferedinputstream, "available", bufferedinputstream_get_available, 0);
+        rb_define_method(bufferedinputstream, "peek_buffer", bufferedinputstream_peek_buffer, 0);
+        rb_define_method(bufferedinputstream, "peek", bufferedinputstream_peek, 2);
+        rb_define_method(bufferedinputstream, "fill", bufferedinputstream_fill, -1);
+        rb_define_method(bufferedinputstream, "fill_async", bufferedinputstream_fill_async, -1);
+        rb_define_method(bufferedinputstream, "fill_finish", bufferedinputstream_fill_finish, 1);
+        rb_define_method(bufferedinputstream, "read_byte", bufferedinputstream_read_byte, -1);
+}