gio2 0.90.3

data/ext/gio2/gfilteroutputstream.c

@@ -0,0 +1,56 @@
+/* -*- 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_FILTER_OUTPUT_STREAM(RVAL2GOBJ(value))
+
+static VALUE
+filteroutputstream_get_base_stream(VALUE self)
+{
+        return GOBJ2RVAL(g_filter_output_stream_get_base_stream(_SELF(self)));
+}
+
+static VALUE
+filteroutputstream_get_close_base_stream(VALUE self)
+{
+        return CBOOL2RVAL(g_filter_output_stream_get_close_base_stream(_SELF(self)));
+}
+
+static VALUE
+filteroutputstream_set_close_base_stream(VALUE self, VALUE close_base)
+{
+        g_filter_output_stream_set_close_base_stream(_SELF(self), RVAL2CBOOL(close_base));
+
+        return self;
+}
+
+void
+Init_gfilteroutputstream(VALUE glib)
+{
+        VALUE filteroutputstream = G_DEF_CLASS(G_TYPE_FILTER_OUTPUT_STREAM, "FilterOutputStream", glib);
+
+        rb_undef_alloc_func(filteroutputstream);
+
+        rb_define_method(filteroutputstream, "base_stream", filteroutputstream_get_base_stream, 0);
+        rb_define_method(filteroutputstream, "close_base_stream?", filteroutputstream_get_close_base_stream, 0);
+        rb_define_method(filteroutputstream, "set_close_base_stream", filteroutputstream_set_close_base_stream, 1);
+        G_DEF_SETTER(filteroutputstream, "close_base_stream");
+}

data/ext/gio2/gicon.c

@@ -0,0 +1,69 @@
+/* -*- 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) RVAL2GICON(value)
+
+static VALUE
+icon_new_for_string(G_GNUC_UNUSED VALUE self, VALUE string)
+{
+        GError *error = NULL;
+        GIcon *icon;
+
+        icon = g_icon_new_for_string(RVAL2CSTR(string), &error);
+        if (icon == NULL)
+                rbgio_raise_error(error);
+
+        return GOBJ2RVAL_UNREF(icon);
+}
+
+static VALUE
+icon_hash(VALUE self)
+{
+        return GUINT2RVAL(g_icon_hash(_SELF(self)));
+}
+
+static VALUE
+icon_equal(VALUE self, VALUE other)
+{
+        return CBOOL2RVAL(g_icon_equal(_SELF(self), _SELF(other)));
+}
+
+static VALUE
+icon_to_string(VALUE self)
+{
+        /* TODO: Should we raise if it returns NULL? */
+        return CSTR2RVAL_FREE(g_icon_to_string(_SELF(self)));
+}
+
+void
+Init_gicon(VALUE glib)
+{
+        VALUE icon = G_DEF_INTERFACE(G_TYPE_ICON, "Icon", glib);
+
+        rb_define_singleton_method(icon, "new_for_string", icon_new_for_string, 1);
+
+        rb_define_method(icon, "hash", icon_hash, 0);
+        rb_define_method(icon, "==", icon_equal, 1);
+        rb_define_method(icon, "to_string", icon_to_string, 0);
+        rb_define_alias(icon, "to_str", "to_string");
+        rb_define_alias(icon, "to_s", "to_string");
+}

data/ext/gio2/ginetaddress.c

@@ -0,0 +1,188 @@
+/* -*- 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) RVAL2GINETADDRESS(value)
+
+static VALUE
+inetaddress_new_from_string(G_GNUC_UNUSED VALUE self, VALUE string)
+{
+        return GOBJ2RVAL_UNREF(g_inet_address_new_from_string(RVAL2CSTR(string)));
+}
+
+/* TODO: Should this take an array instead? */
+static VALUE
+inetaddress_new_from_bytes(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
+{
+        VALUE rbbytes, rbfamily;
+        guint8 *bytes;
+        GSocketFamily family;
+
+        rb_scan_args(argc, argv, "11", &rbbytes, &rbfamily);
+        bytes = (guint8 *)RVAL2CSTR(rbbytes);
+        family = RVAL2GSOCKETFAMILY(rbfamily);
+
+        /* TODO: Should check encoding. */
+        /* TODO: We can’t pass bytes as such, as it will be NULL-terminated. */
+        /* TODO: Do we need to deal with G_SOCKET_FAMILY_UNIX? */
+        switch (family) {
+        case G_SOCKET_FAMILY_IPV4:
+                if (RSTRING_LEN(rbbytes) != 4)
+                        rb_raise(rb_eArgError, "string containing 4 bytes expected");
+                break;
+        case G_SOCKET_FAMILY_IPV6:
+                if (RSTRING_LEN(rbbytes) != 16)
+                        rb_raise(rb_eArgError, "string containing 16 bytes expected");
+                break;
+        case G_SOCKET_FAMILY_INVALID:
+        case G_SOCKET_FAMILY_UNIX:
+                rb_raise(rb_eArgError, "invalid family: %d", family);
+        default:
+                rb_raise(rb_eArgError, "unknown family: %d", family);
+                break;
+        }
+
+        return GOBJ2RVAL_UNREF(g_inet_address_new_from_bytes(bytes, family));
+}
+
+static VALUE
+inetaddress_new_any(G_GNUC_UNUSED VALUE self, VALUE family)
+{
+        return GOBJ2RVAL_UNREF(g_inet_address_new_any(RVAL2GSOCKETFAMILY(family)));
+}
+
+static VALUE
+inetaddress_new_loopback(G_GNUC_UNUSED VALUE self, VALUE family)
+{
+        return GOBJ2RVAL_UNREF(g_inet_address_new_loopback(RVAL2GSOCKETFAMILY(family)));
+}
+
+/* TODO: Return array of bytes instead? */
+static VALUE
+inetaddress_to_bytes(VALUE self)
+{
+        gsize size;
+
+        size = g_inet_address_get_native_size(_SELF(self));
+        return rb_str_new((const gchar *)g_inet_address_to_bytes(_SELF(self)),
+                          size);
+}
+
+static VALUE
+inetaddress_get_native_size(VALUE self)
+{
+        return GSIZE2RVAL(g_inet_address_get_native_size(_SELF(self)));
+}
+
+static VALUE
+inetaddress_to_string(VALUE self)
+{
+        return CSTR2RVAL_FREE(g_inet_address_to_string(_SELF(self)));
+}
+
+static VALUE
+inetaddress_get_family(VALUE self)
+{
+        return GSOCKETFAMILY2RVAL(g_inet_address_get_family(_SELF(self)));
+}
+
+static VALUE
+inetaddress_get_is_any(VALUE self)
+{
+        return CBOOL2RVAL(g_inet_address_get_is_any(_SELF(self)));
+}
+
+static VALUE
+inetaddress_get_is_loopback(VALUE self)
+{
+        return CBOOL2RVAL(g_inet_address_get_is_loopback(_SELF(self)));
+}
+
+static VALUE
+inetaddress_get_is_link_local(VALUE self)
+{
+        return CBOOL2RVAL(g_inet_address_get_is_link_local(_SELF(self)));
+}
+
+static VALUE
+inetaddress_get_is_site_local(VALUE self)
+{
+        return CBOOL2RVAL(g_inet_address_get_is_site_local(_SELF(self)));
+}
+
+static VALUE
+inetaddress_get_is_multicast(VALUE self)
+{
+        return CBOOL2RVAL(g_inet_address_get_is_multicast(_SELF(self)));
+}
+
+static VALUE
+inetaddress_get_is_mc_link_local(VALUE self)
+{
+        return CBOOL2RVAL(g_inet_address_get_is_mc_link_local(_SELF(self)));
+}
+
+static VALUE
+inetaddress_get_is_mc_node_local(VALUE self)
+{
+        return CBOOL2RVAL(g_inet_address_get_is_mc_node_local(_SELF(self)));
+}
+
+static VALUE
+inetaddress_get_is_mc_site_local(VALUE self)
+{
+        return CBOOL2RVAL(g_inet_address_get_is_mc_site_local(_SELF(self)));
+}
+
+static VALUE
+inetaddress_get_is_mc_global(VALUE self)
+{
+        return CBOOL2RVAL(g_inet_address_get_is_mc_global(_SELF(self)));
+}
+
+void
+Init_ginetaddress(VALUE glib)
+{
+        VALUE inetaddress = G_DEF_INTERFACE(G_TYPE_INET_ADDRESS, "InetAddress", glib);
+
+        rb_define_singleton_method(inetaddress, "new_from_string", inetaddress_new_from_string, 1);
+        rb_define_singleton_method(inetaddress, "new_from_bytes", inetaddress_new_from_bytes, -1);
+        rb_define_singleton_method(inetaddress, "new_any", inetaddress_new_any, 1);
+        rb_define_singleton_method(inetaddress, "new_loopback", inetaddress_new_loopback, 1);
+
+        rb_undef_alloc_func(inetaddress);
+
+        rb_define_method(inetaddress, "to_bytes", inetaddress_to_bytes, 0);
+        rb_define_method(inetaddress, "get_native_size", inetaddress_get_native_size, 0);
+        rb_define_method(inetaddress, "to_string", inetaddress_to_string, 0);
+        rb_define_alias(inetaddress, "to_str", "to_string");
+        rb_define_alias(inetaddress, "to_s", "to_string");
+        rb_define_method(inetaddress, "family", inetaddress_get_family, 0);
+        rb_define_method(inetaddress, "any?", inetaddress_get_is_any, 0);
+        rb_define_method(inetaddress, "loopback?", inetaddress_get_is_loopback, 0);
+        rb_define_method(inetaddress, "link_local?", inetaddress_get_is_link_local, 0);
+        rb_define_method(inetaddress, "site_local?", inetaddress_get_is_site_local, 0);
+        rb_define_method(inetaddress, "multicast?", inetaddress_get_is_multicast, 0);
+        rb_define_method(inetaddress, "mc_link_local?", inetaddress_get_is_mc_link_local, 0);
+        rb_define_method(inetaddress, "mc_node_local?", inetaddress_get_is_mc_node_local, 0);
+        rb_define_method(inetaddress, "mc_site_local?", inetaddress_get_is_mc_site_local, 0);
+        rb_define_method(inetaddress, "mc_global?", inetaddress_get_is_mc_global, 0);
+}

data/ext/gio2/ginetsocketaddress.c

@@ -0,0 +1,54 @@
+/* -*- 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_INET_SOCKET_ADDRESS(RVAL2GOBJ(value))
+
+static VALUE
+inetsocketaddress_initialize(VALUE self, VALUE address, VALUE port)
+{
+        G_INITIALIZE(self, g_inet_socket_address_new(RVAL2GINETADDRESS(address),
+                                                     RVAL2GUINT16(port)));
+
+        return Qnil;
+}
+
+static VALUE
+inetsocketaddress_get_address(VALUE self)
+{
+        return GOBJ2RVAL(g_inet_socket_address_get_address(_SELF(self)));
+}
+
+static VALUE
+inetsocketaddress_get_port(VALUE self)
+{
+        return GUINT162RVAL(g_inet_socket_address_get_port(_SELF(self)));
+}
+
+void
+Init_ginetsocketaddress(VALUE glib)
+{
+        VALUE inetsocketaddress = G_DEF_CLASS(G_TYPE_INET_SOCKET_ADDRESS, "InetSocketAddress", glib);
+
+        rb_define_method(inetsocketaddress, "initialize", inetsocketaddress_initialize, 2);
+        rb_define_method(inetsocketaddress, "address", inetsocketaddress_get_address, 0);
+        rb_define_method(inetsocketaddress, "port", inetsocketaddress_get_port, 0);
+}

data/ext/gio2/ginitable.c

@@ -0,0 +1,195 @@
+/* -*- 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_INITABLE(RVAL2GOBJ(value))
+
+static VALUE
+initable_init(int argc, VALUE *argv, VALUE self)
+{
+        VALUE cancellable;
+        GError *error = NULL;
+
+        rb_scan_args(argc, argv, "01", &cancellable);
+        if (!g_initable_init(_SELF(self),
+                             RVAL2GCANCELLABLE(cancellable),
+                             &error))
+                rbgio_raise_error(error);
+
+        return self;
+}
+
+struct rbgio_ginitable_new_data {
+        GObjectClass *gclass;
+        GCancellable *cancellable;
+        VALUE rbparameters;
+        guint index;
+        guint n_parameters;
+        GParameter *parameters;
+        GError *error;
+};
+
+static VALUE
+rbgio_ginitiable_new_parameters_initialize(VALUE key_value,
+                                           struct rbgio_ginitable_new_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_ginitable_new_body(struct rbgio_ginitable_new_data *data)
+{
+        rb_iterate(rb_each,
+                   data->rbparameters,
+                   rbgio_ginitiable_new_parameters_initialize,
+                   (VALUE)data);
+
+        return (VALUE)g_initable_newv(G_TYPE_FROM_CLASS(data->gclass),
+                                      data->n_parameters,
+                                      data->parameters,
+                                      data->cancellable,
+                                      &data->error);
+}
+
+static VALUE
+rbgio_ginitable_new_ensure(struct rbgio_ginitable_new_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;
+}
+
+GObject *
+rbgio_ginitable_new(GType type, VALUE parameters, VALUE cancellable)
+{
+        static ID s_id_length;
+        GError *error = NULL;
+        GObject *object;
+        struct rbgio_ginitable_new_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)) {
+                object = g_initable_newv(type,
+                                         0,
+                                         NULL,
+                                         RVAL2GCANCELLABLE(cancellable),
+                                         &error);
+                if (object == NULL)
+                        rbgio_raise_error(error);
+
+                return object;
+        } else {
+                parameters = rb_convert_type(parameters,
+                                             T_HASH,
+                                             "Hash",
+                                             "to_hash");
+        }
+
+        data.gclass = G_OBJECT_CLASS(g_type_class_ref(type));
+        data.cancellable = RVAL2GCANCELLABLE(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.error = NULL;
+
+        object = (GObject *)rb_ensure(rbgio_ginitable_new_body, (VALUE)&data,
+                                      rbgio_ginitable_new_ensure, (VALUE)&data);
+        if (object == NULL)
+                rbgio_raise_error(data.error);
+
+        return object;
+}
+
+/* NOTE: We don’t implement g_initable_new. */
+
+/* NOTE: We don’t implement g_initable_new_valist. */
+
+static VALUE
+initable_initialize(int argc, VALUE *argv, VALUE self)
+{
+        const RGObjClassInfo* info;
+        VALUE cancellable, parameters;
+        GObject *object;
+        VALUE result;
+
+        rb_scan_args(argc, argv, "02", &cancellable, &parameters);
+
+        info = CLASS2CINFO(self);
+        if (info->klass != self)
+                rb_raise(rb_eTypeError,
+                         "%s: class not registered with GLib",
+                         rb_class2name(self));
+
+        object = rbgio_ginitable_new(info->gtype, parameters, cancellable);
+        result = GOBJ2RVAL(object);
+        g_object_unref(object);
+
+        return result;
+}
+
+void
+Init_ginitable(VALUE glib)
+{
+        VALUE initable = G_DEF_INTERFACE(G_TYPE_INITABLE, "Initable", glib);
+
+        rb_define_module_function(initable, "new", initable_initialize, -1);
+
+        rb_define_method(initable, "init", initable_init, -1);
+}