gio2 0.90.3

data/ext/gio2/gbufferedoutputstream.c

@@ -0,0 +1,82 @@
+/* -*- 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_OUTPUT_STREAM(RVAL2GOBJ(value))
+
+static VALUE
+bufferedoutputstream_initialize(int argc, VALUE *argv, VALUE self)
+{
+        VALUE rbbase_stream, size;
+        GOutputStream *base_stream, *stream;
+
+        rb_scan_args(argc, argv, "11", &rbbase_stream, &size);
+        base_stream = RVAL2GOUTPUTSTREAM(rbbase_stream);
+
+        stream = NIL_P(size) ?
+                g_buffered_output_stream_new(base_stream) :
+                g_buffered_output_stream_new_sized(base_stream, RVAL2GSIZE(size));
+        G_INITIALIZE(self, stream);
+
+        return Qnil;
+}
+
+static VALUE
+bufferedoutputstream_get_buffer_size(VALUE self)
+{
+        return GSIZE2RVAL(g_buffered_output_stream_get_buffer_size(_SELF(self)));
+}
+
+static VALUE
+bufferedoutputstream_set_buffer_size(VALUE self, VALUE size)
+{
+        g_buffered_output_stream_set_buffer_size(_SELF(self), RVAL2GSIZE(size));
+
+        return self;
+}
+
+static VALUE
+bufferedoutputstream_get_auto_grow(VALUE self)
+{
+        return CBOOL2RVAL(g_buffered_output_stream_get_auto_grow(_SELF(self)));
+}
+
+static VALUE
+bufferedoutputstream_set_auto_grow(VALUE self, VALUE grow)
+{
+        g_buffered_output_stream_set_auto_grow(_SELF(self), RVAL2CBOOL(grow));
+
+        return self;
+}
+
+void
+Init_gbufferedoutputstream(VALUE glib)
+{
+        VALUE bufferedoutputstream = G_DEF_CLASS(G_TYPE_BUFFERED_OUTPUT_STREAM, "BufferedOutputStream", glib);
+
+        rb_define_method(bufferedoutputstream, "initialize", bufferedoutputstream_initialize, -1);
+        rb_define_method(bufferedoutputstream, "buffer_size", bufferedoutputstream_get_buffer_size, 0);
+        rb_define_method(bufferedoutputstream, "set_buffer_size", bufferedoutputstream_set_buffer_size, 1);
+        G_DEF_SETTER(bufferedoutputstream, "buffer_size");
+        rb_define_method(bufferedoutputstream, "auto_grow", bufferedoutputstream_get_auto_grow, 0);
+        rb_define_method(bufferedoutputstream, "set_auto_grow", bufferedoutputstream_set_auto_grow, 1);
+        G_DEF_SETTER(bufferedoutputstream, "auto_grow");
+}

data/ext/gio2/gcancellable.c

@@ -0,0 +1,177 @@
+/* -*- 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) RVAL2GCANCELLABLE(value)
+
+static VALUE
+cancellable_initialize(VALUE self)
+{
+        G_INITIALIZE(self, g_cancellable_new());
+
+        return Qnil;
+}
+
+static VALUE
+cancellable_is_cancelled(VALUE self)
+{
+        return CBOOL2RVAL(g_cancellable_is_cancelled(_SELF(self)));
+}
+
+static VALUE
+cancellable_raise_error_if_cancelled(VALUE self)
+{
+        GError *error = NULL;
+
+        if (g_cancellable_set_error_if_cancelled(_SELF(self), &error))
+                rbgio_raise_error(error);
+
+        return self;
+}
+
+static VALUE
+cancellable_get_fd(VALUE self)
+{
+        return FD2RVAL(g_cancellable_get_fd(_SELF(self)));
+}
+
+static VALUE
+cancellable_make_pollfd(VALUE self)
+{
+        GPollFD *gfd = g_new(GPollFD, 1);
+
+        g_cancellable_make_pollfd(_SELF(self), gfd);
+
+        return BOXED2RVAL(gfd, G_TYPE_POLL_FD);
+}
+
+G_GNUC_NORETURN static VALUE
+cancellable_release_fd(VALUE self)
+{
+        /* TODO: How do we implement this?  Maybe not at all? */
+        self = self;
+        rb_raise(rb_eNotImpError, "release_fd has not been implemented yet");
+#if 0
+        g_cancellable_release_fd(_SELF(self));
+
+        return self;
+#endif
+}
+
+static VALUE
+cancellable_get_current(G_GNUC_UNUSED VALUE self)
+{
+        return GOBJ2RVAL(g_cancellable_get_current());
+}
+
+static VALUE
+cancellable_pop_current(VALUE self)
+{
+        g_cancellable_pop_current(_SELF(self));
+
+        return self;
+}
+
+static VALUE
+cancellable_push_current(VALUE self)
+{
+        g_cancellable_push_current(_SELF(self));
+
+        return self;
+}
+
+static VALUE
+cancellable_reset(VALUE self)
+{
+        g_cancellable_reset(_SELF(self));
+
+        return self;
+}
+
+static VALUE
+cancellable_connect_callback_call(VALUE block)
+{
+        static ID s_id_call;
+
+        if (s_id_call == 0)
+                s_id_call = rb_intern("call");
+
+        rb_funcall(block, s_id_call, 0);
+
+        return Qnil;
+}
+
+static void
+cancellable_connect_callback(gpointer block)
+{
+        G_PROTECT_CALLBACK(cancellable_connect_callback_call, block);
+}
+
+static VALUE
+cancellable_connect(VALUE self)
+{
+        VALUE block;
+
+        block = rb_block_proc();
+        G_RELATIVE(self, block);
+
+        return GULONG2RVAL(g_cancellable_connect(_SELF(self),
+                                                 G_CALLBACK(cancellable_connect_callback),
+                                                 (gpointer)block,
+                                                 NULL));
+}
+
+static VALUE
+cancellable_disconnect(VALUE self, VALUE handler_id)
+{
+        g_cancellable_disconnect(_SELF(self), RVAL2GULONG(handler_id));
+
+        return self;
+}
+
+static VALUE
+cancellable_cancel(VALUE self)
+{
+        g_cancellable_cancel(_SELF(self));
+
+        return self;
+}
+
+void
+Init_gcancellable(VALUE glib)
+{
+        VALUE cancellable = G_DEF_CLASS(G_TYPE_CANCELLABLE, "Cancellable", glib);
+
+        rb_define_singleton_method(cancellable, "current", cancellable_get_current, 0);
+
+        rb_define_method(cancellable, "initialize", cancellable_initialize, 0);
+        rb_define_method(cancellable, "cancelled?", cancellable_is_cancelled, 0);
+        rb_define_method(cancellable, "raise_error_if_cancelled", cancellable_raise_error_if_cancelled, 0);
+        rb_define_method(cancellable, "fd", cancellable_get_fd, 0);
+        rb_define_method(cancellable, "make_pollfd", cancellable_make_pollfd, 0);
+        rb_define_method(cancellable, "release_fd", cancellable_release_fd, 0);
+        rb_define_method(cancellable, "pop_current", cancellable_pop_current, 0);
+        rb_define_method(cancellable, "push_current", cancellable_push_current, 0);
+        rb_define_method(cancellable, "reset", cancellable_reset, 0);
+        rb_define_method(cancellable, "connect", cancellable_connect, 0);
+        rb_define_method(cancellable, "disconnect", cancellable_disconnect, 1);
+        rb_define_method(cancellable, "cancel", cancellable_cancel, 0);
+}

data/ext/gio2/gcharsetconverter.c

@@ -0,0 +1,72 @@
+/* -*- 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_CHARSET_CONVERTER(RVAL2GOBJ(value))
+
+static VALUE
+charsetconverter_initialize(VALUE self, VALUE to, VALUE from)
+{
+        GError *error = NULL;
+        GCharsetConverter *converter;
+
+        converter = g_charset_converter_new(RVAL2CSTR(to),
+                                            RVAL2CSTR(from),
+                                            &error);
+        if (converter == NULL)
+                rbgio_raise_error(error);
+
+        G_INITIALIZE(self, converter);
+
+        return Qnil;
+}
+
+static VALUE
+charsetconverter_set_use_fallback(VALUE self, VALUE use_fallback)
+{
+        g_charset_converter_set_use_fallback(_SELF(self), RVAL2CBOOL(use_fallback));
+
+        return self;
+}
+
+static VALUE
+charsetconverter_get_use_fallback(VALUE self)
+{
+        return CBOOL2RVAL(g_charset_converter_get_use_fallback(_SELF(self)));
+}
+
+static VALUE
+charsetconverter_get_num_fallbacks(VALUE self)
+{
+        return GUINT2RVAL(g_charset_converter_get_num_fallbacks(_SELF(self)));
+}
+
+void
+Init_gcharsetconverter(VALUE glib)
+{
+        VALUE charsetconverter = G_DEF_CLASS(G_TYPE_CHARSET_CONVERTER, "CharsetConverter", glib);
+
+        rb_define_method(charsetconverter, "initialize", charsetconverter_initialize, 2);
+        rb_define_method(charsetconverter, "set_use_fallback", charsetconverter_set_use_fallback, 1);
+        G_DEF_SETTER(charsetconverter, "use_fallback");
+        rb_define_method(charsetconverter, "use_fallback?", charsetconverter_get_use_fallback, 0);
+        rb_define_method(charsetconverter, "num_fallbacks", charsetconverter_get_num_fallbacks, 0);
+}

data/ext/gio2/gcontenttype.c

@@ -0,0 +1,135 @@
+/* -*- 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 VALUE
+contenttype_equals(G_GNUC_UNUSED VALUE self, VALUE arg1, VALUE arg2)
+{
+        return CBOOL2RVAL(g_content_type_equals(RVAL2CSTR(arg1), RVAL2CSTR(arg2)));
+}
+
+static VALUE
+contenttype_is_a(G_GNUC_UNUSED VALUE self, VALUE arg1, VALUE arg2)
+{
+        return CBOOL2RVAL(g_content_type_is_a(RVAL2CSTR(arg1), RVAL2CSTR(arg2)));
+}
+
+static VALUE
+contenttype_is_unknown(G_GNUC_UNUSED VALUE type)
+{
+        return CBOOL2RVAL(g_content_type_is_unknown(RVAL2CSTR(type)));
+}
+
+static VALUE
+contenttype_get_description(G_GNUC_UNUSED VALUE type)
+{
+        return CSTR2RVAL_FREE(g_content_type_get_description(RVAL2CSTR(type)));
+}
+
+static VALUE
+contenttype_get_mime_type(G_GNUC_UNUSED VALUE type)
+{
+        return CSTR2RVAL_FREE(g_content_type_get_mime_type(RVAL2CSTR(type)));
+}
+
+static VALUE
+contenttype_get_icon(G_GNUC_UNUSED VALUE type)
+{
+        return GOBJ2RVAL_UNREF(g_content_type_get_icon(RVAL2CSTR(type)));
+}
+
+static VALUE
+contenttype_can_be_executable(G_GNUC_UNUSED VALUE type)
+{
+        return CBOOL2RVAL(g_content_type_can_be_executable(RVAL2CSTR(type)));
+}
+
+static VALUE
+contenttype_from_mime_type(G_GNUC_UNUSED VALUE type)
+{
+        return CSTR2RVAL(g_content_type_from_mime_type(RVAL2CSTR(type)));
+}
+
+static VALUE
+contenttype_guess(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
+{
+        VALUE rbfilename,
+              rbdata;
+        const char *filename;
+        const guchar *data;
+        gsize data_size;
+        gboolean result_uncertain;
+        char *type;
+
+        rb_scan_args(argc, argv, "02", &rbfilename, &rbdata);
+
+        if (NIL_P(rbfilename) && NIL_P(rbdata))
+                rb_raise(rb_eArgError,
+                         "Either filename or data can be nil but not both");
+
+        filename = RVAL2CSTR_ACCEPT_NIL(rbfilename);
+        data = (guchar *)RVAL2CSTR_ACCEPT_NIL(rbdata);
+        if (data != NULL) {
+                StringValue(rbdata);
+                data_size = RSTRING_LEN(rbdata);
+        } else {
+                data_size = 0;
+        }
+
+        type = g_content_type_guess(filename,
+                                    data,
+                                    data_size,
+                                    &result_uncertain);
+
+        return rb_assoc_new(CSTR2RVAL_FREE(type), CBOOL2RVAL(result_uncertain));
+}
+
+static VALUE
+contenttype_guess_for_tree(G_GNUC_UNUSED VALUE self, VALUE root)
+{
+        return STRVECTOR2ARY_FREE(g_content_type_guess_for_tree(RVAL2GFILE(root)));
+}
+
+static VALUE
+contenttype_get_registered(G_GNUC_UNUSED VALUE self)
+{
+        return GLIST2ARY_STR_FREE(g_content_types_get_registered());
+}
+
+void
+Init_gcontenttype(VALUE glib)
+{
+        VALUE contenttype = rb_define_module_under(glib, "ContentType");
+
+        /* TODO: Should wrap this in a class. */
+        rb_define_module_function(contenttype, "equals?", contenttype_equals, 2);
+        /* TODO: This name isn’t great. */
+        rb_define_module_function(contenttype, "is_a?", contenttype_is_a, 2);
+        rb_define_module_function(contenttype, "unknown?", contenttype_is_unknown, 1);
+        rb_define_module_function(contenttype, "get_description", contenttype_get_description, 1);
+        rb_define_module_function(contenttype, "get_mime_type", contenttype_get_mime_type, 1);
+        rb_define_module_function(contenttype, "get_icon", contenttype_get_icon, 1);
+        rb_define_module_function(contenttype, "can_be_executable?", contenttype_can_be_executable, 1);
+        rb_define_module_function(contenttype, "from_mime_type", contenttype_from_mime_type, 1);
+        rb_define_module_function(contenttype, "guess", contenttype_guess, -1);
+        rb_define_module_function(contenttype, "guess_for_tree", contenttype_guess_for_tree, 1);
+        rb_define_module_function(contenttype, "registered", contenttype_get_registered, 0);
+}