gio2 0.90.3

data/ext/gio2/gdataoutputstream.c

@@ -0,0 +1,202 @@
+/* -*- 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_DATA_OUTPUT_STREAM(RVAL2GOBJ(value))
+
+static VALUE
+dataoutputstream_initialize(int argc, VALUE *argv, VALUE self)
+{
+        VALUE base_stream,
+              byte_order;
+
+        rb_scan_args(argc, argv, "11", &base_stream, &byte_order);
+
+        G_INITIALIZE(self, g_data_output_stream_new(RVAL2GOUTPUTSTREAM(base_stream)));
+
+        if (!NIL_P(byte_order))
+                g_data_output_stream_set_byte_order(_SELF(self),
+                                                    RVAL2GDATASTREAMBYTEORDER(byte_order));
+
+        return Qnil;
+}
+
+static VALUE
+dataoutputstream_get_byte_order(VALUE self)
+{
+        return GDATASTREAMBYTEORDER2RVAL(g_data_output_stream_get_byte_order(_SELF(self)));
+}
+
+static VALUE
+dataoutputstream_set_byte_order(VALUE self, VALUE value)
+{
+        g_data_output_stream_set_byte_order(_SELF(self),
+                                            RVAL2GDATASTREAMBYTEORDER(value));
+
+        return self;
+}
+
+static VALUE
+dataoutputstream_put_byte(int argc, VALUE *argv, VALUE self)
+{
+        VALUE value, cancellable;
+        GError *error = NULL;
+
+        rb_scan_args(argc, argv, "11", &value, &cancellable);
+        if (!g_data_output_stream_put_byte(_SELF(self),
+                                           RVAL2GUCHAR(value),
+                                           RVAL2GCANCELLABLE(cancellable),
+                                           &error))
+                rbgio_raise_error(error);
+
+        return self;
+}
+
+static VALUE
+dataoutputstream_put_int16(int argc, VALUE *argv, VALUE self)
+{
+        VALUE value, cancellable;
+        GError *error = NULL;
+
+        rb_scan_args(argc, argv, "11", &value, &cancellable);
+        if (!g_data_output_stream_put_int16(_SELF(self),
+                                            RVAL2GINT16(value),
+                                            RVAL2GCANCELLABLE(cancellable),
+                                            &error))
+                rbgio_raise_error(error);
+
+        return self;
+}
+
+static VALUE
+dataoutputstream_put_uint16(int argc, VALUE *argv, VALUE self)
+{
+        VALUE value, cancellable;
+        GError *error = NULL;
+
+        rb_scan_args(argc, argv, "11", &value, &cancellable);
+        if (!g_data_output_stream_put_uint16(_SELF(self),
+                                             RVAL2GUINT16(value),
+                                             RVAL2GCANCELLABLE(cancellable),
+                                             &error))
+                rbgio_raise_error(error);
+
+        return self;
+}
+
+static VALUE
+dataoutputstream_put_int32(int argc, VALUE *argv, VALUE self)
+{
+        VALUE value, cancellable;
+        GError *error = NULL;
+
+        rb_scan_args(argc, argv, "11", &value, &cancellable);
+        if (!g_data_output_stream_put_int32(_SELF(self),
+                                            RVAL2GINT32(value),
+                                            RVAL2GCANCELLABLE(cancellable),
+                                            &error))
+                rbgio_raise_error(error);
+
+        return self;
+}
+
+static VALUE
+dataoutputstream_put_uint32(int argc, VALUE *argv, VALUE self)
+{
+        VALUE value, cancellable;
+        GError *error = NULL;
+
+        rb_scan_args(argc, argv, "11", &value, &cancellable);
+        if (!g_data_output_stream_put_uint32(_SELF(self),
+                                             RVAL2GINT32(value),
+                                             RVAL2GCANCELLABLE(cancellable),
+                                             &error))
+                rbgio_raise_error(error);
+
+        return self;
+}
+
+static VALUE
+dataoutputstream_put_int64(int argc, VALUE *argv, VALUE self)
+{
+        VALUE value, cancellable;
+        GError *error = NULL;
+
+        rb_scan_args(argc, argv, "11", &value, &cancellable);
+        if (!g_data_output_stream_put_int64(_SELF(self),
+                                            RVAL2GINT64(value),
+                                            RVAL2GCANCELLABLE(cancellable),
+                                            &error))
+                rbgio_raise_error(error);
+
+        return self;
+}
+
+static VALUE
+dataoutputstream_put_uint64(int argc, VALUE *argv, VALUE self)
+{
+        VALUE value, cancellable;
+        GError *error = NULL;
+
+        rb_scan_args(argc, argv, "11", &value, &cancellable);
+        if (!g_data_output_stream_put_uint64(_SELF(self),
+                                             RVAL2GUINT64(value),
+                                             RVAL2GCANCELLABLE(cancellable),
+                                             &error))
+                rbgio_raise_error(error);
+
+        return self;
+}
+
+static VALUE
+dataoutputstream_put_string(int argc, VALUE *argv, VALUE self)
+{
+        VALUE value, cancellable;
+        GError *error = NULL;
+
+        rb_scan_args(argc, argv, "11", &value, &cancellable);
+        if (!g_data_output_stream_put_string(_SELF(self),
+                                             RVAL2CSTR(value),
+                                             RVAL2GCANCELLABLE(cancellable),
+                                             &error))
+                rbgio_raise_error(error);
+
+        return self;
+}
+
+void
+Init_gdataoutputstream(VALUE glib)
+{
+        VALUE dataoutputstream = G_DEF_CLASS(G_TYPE_DATA_OUTPUT_STREAM, "DataOutputStream", glib);
+
+        rb_define_method(dataoutputstream, "initialize", dataoutputstream_initialize, -1);
+        rb_define_method(dataoutputstream, "byte_order", dataoutputstream_get_byte_order, 0);
+        rb_define_method(dataoutputstream, "set_byte_order", dataoutputstream_set_byte_order, 1);
+        G_DEF_SETTER(dataoutputstream, "byte_order");
+        rb_define_method(dataoutputstream, "put_byte", dataoutputstream_put_byte, -1);
+        rb_define_method(dataoutputstream, "put_int16", dataoutputstream_put_int16, -1);
+        rb_define_method(dataoutputstream, "put_uint16", dataoutputstream_put_uint16, -1);
+        rb_define_method(dataoutputstream, "put_int32", dataoutputstream_put_int32, -1);
+        rb_define_method(dataoutputstream, "put_uint32", dataoutputstream_put_uint32, -1);
+        rb_define_method(dataoutputstream, "put_int64", dataoutputstream_put_int64, -1);
+        rb_define_method(dataoutputstream, "put_uint64", dataoutputstream_put_uint64, -1);
+        rb_define_method(dataoutputstream, "put_string", dataoutputstream_put_string, -1);
+}

data/ext/gio2/gdesktopappinfo.c

@@ -0,0 +1,90 @@
+/* -*- 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"
+
+#ifdef HAVE_GIO_UNIX
+#include <gio/gdesktopappinfo.h>
+
+#define _SELF(value) G_DESKTOP_APP_INFO(RVAL2GOBJ(value))
+
+#define RVAL2GKEYFILE(value) \
+        ((GKeyFile *)(RVAL2BOXED((value), G_TYPE_KEY_FILE)))
+
+static VALUE
+desktopappinfo_new_from_filename(G_GNUC_UNUSED VALUE self, VALUE filename)
+{
+        return GOBJ2RVAL_UNREF(g_desktop_app_info_new_from_filename(RVAL2CSTR(filename)));
+}
+
+static VALUE
+desktopappinfo_new_from_keyfile(G_GNUC_UNUSED VALUE self, VALUE keyfile)
+{
+        return GOBJ2RVAL_UNREF(g_desktop_app_info_new_from_keyfile(RVAL2GKEYFILE(keyfile)));
+}
+
+static VALUE
+desktopappinfo_initialize(VALUE self, VALUE desktop_id)
+{
+        G_INITIALIZE(self, g_desktop_app_info_new(RVAL2CSTR(desktop_id)));
+
+        return Qnil;
+}
+
+static VALUE
+desktopappinfo_get_filename(VALUE self)
+{
+        return CSTR2RVAL(g_desktop_app_info_get_filename(_SELF(self)));
+}
+
+static VALUE
+desktopappinfo_get_is_hidden(VALUE self)
+{
+        return CBOOL2RVAL(g_desktop_app_info_get_is_hidden(_SELF(self)));
+}
+
+static VALUE
+desktopappinfo_set_desktop_env(G_GNUC_UNUSED VALUE self, VALUE desktop_env)
+{
+        g_desktop_app_info_set_desktop_env(RVAL2CSTR(desktop_env));
+
+        return self;
+}
+
+/* TODO: g_desktop_app_info_lookup_get_default_for_uri_scheme ()? */
+#endif
+
+void
+Init_gdesktopappinfo(G_GNUC_UNUSED VALUE glib)
+{
+#ifdef HAVE_GIO_UNIX
+        VALUE desktopappinfo = G_DEF_CLASS(G_TYPE_DESKTOP_APP_INFO, "DesktopAppInfo", glib);
+
+        rb_define_const(desktopappinfo, "LOOKUP_EXTENSION_POINT_NAME", CSTR2RVAL(G_DESKTOP_APP_INFO_LOOKUP_EXTENSION_POINT_NAME));
+
+        rb_define_singleton_method(desktopappinfo, "new_from_filename", desktopappinfo_new_from_filename, 1);
+        rb_define_singleton_method(desktopappinfo, "new_from_keyfile", desktopappinfo_new_from_keyfile, 1);
+        rb_define_singleton_method(desktopappinfo, "set_desktop_env", desktopappinfo_set_desktop_env, 1);
+
+        rb_define_method(desktopappinfo, "initialize", desktopappinfo_initialize, 1);
+        rb_define_method(desktopappinfo, "filename", desktopappinfo_get_filename, 0);
+        rb_define_method(desktopappinfo, "hidden?", desktopappinfo_get_is_hidden, 0);
+#endif
+}

data/ext/gio2/gdrive.c

@@ -0,0 +1,267 @@
+/* -*- 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_DRIVE(RVAL2GOBJ(value))
+
+#define GDRIVESTARTSTOPTYPE2RVAL(value) \
+        GENUM2RVAL((value), G_TYPE_DRIVE_START_STOP_TYPE)
+
+static VALUE
+drive_get_name(VALUE self)
+{
+        return CSTR2RVAL_FREE(g_drive_get_name(_SELF(self)));
+}
+
+static VALUE
+drive_get_icon(VALUE self)
+{
+        return GOBJ2RVAL_UNREF(g_drive_get_icon(_SELF(self)));
+}
+
+static VALUE
+drive_has_volumes(VALUE self)
+{
+        return CBOOL2RVAL(g_drive_has_volumes(_SELF(self)));
+}
+
+static VALUE
+drive_get_volumes(VALUE self)
+{
+        return GLIST2ARY_FREE(g_drive_get_volumes(_SELF(self)));
+}
+
+static VALUE
+drive_can_eject(VALUE self)
+{
+        return CBOOL2RVAL(g_drive_can_eject(_SELF(self)));
+}
+
+static VALUE
+drive_get_start_stop_type(VALUE self)
+{
+        return GDRIVESTARTSTOPTYPE2RVAL(g_drive_get_start_stop_type(_SELF(self)));
+}
+
+static VALUE
+drive_can_start(VALUE self)
+{
+        return CBOOL2RVAL(g_drive_can_start(_SELF(self)));
+}
+
+static VALUE
+drive_can_start_degraded(VALUE self)
+{
+        return CBOOL2RVAL(g_drive_can_start_degraded(_SELF(self)));
+}
+
+static VALUE
+drive_can_stop(VALUE self)
+{
+        return CBOOL2RVAL(g_drive_can_stop(_SELF(self)));
+}
+
+static VALUE
+drive_can_poll_for_media(VALUE self)
+{
+        return CBOOL2RVAL(g_drive_can_poll_for_media(_SELF(self)));
+}
+
+static VALUE
+drive_poll_for_media(int argc, VALUE *argv, VALUE self)
+{
+        VALUE rbcancellable, block;
+        GCancellable *cancellable;
+
+        rb_scan_args(argc, argv, "01&", &rbcancellable, &block);
+        cancellable = RVAL2GCANCELLABLE(rbcancellable);
+        g_drive_poll_for_media(_SELF(self),
+                               cancellable,
+                               rbgio_async_ready_callback,
+                               (gpointer)block);
+
+        return self;
+}
+
+typedef gboolean (*BooleanFinishMethod)(GDrive *, GAsyncResult *, GError **);
+
+static VALUE
+boolean_finish_method(BooleanFinishMethod method, VALUE self, VALUE result)
+{
+        GError *error = NULL;
+
+        if (!method(_SELF(self), RVAL2GASYNCRESULT(result), &error))
+                rbgio_raise_error(error);
+
+        return self;
+}
+
+static VALUE
+drive_poll_for_media_finish(VALUE self, VALUE result)
+{
+        return boolean_finish_method(g_drive_poll_for_media_finish, self, result);
+}
+
+static VALUE
+drive_has_media(VALUE self)
+{
+        return CBOOL2RVAL(g_drive_has_media(_SELF(self)));
+}
+
+static VALUE
+drive_is_media_check_automatic(VALUE self)
+{
+        return CBOOL2RVAL(g_drive_is_media_check_automatic(_SELF(self)));
+}
+
+static VALUE
+drive_is_media_removable(VALUE self)
+{
+        return CBOOL2RVAL(g_drive_is_media_removable(_SELF(self)));
+}
+
+typedef void (*EjectStopMethod)(GDrive *,
+                                GMountUnmountFlags,
+                                GMountOperation *,
+                                GCancellable *,
+                                GAsyncReadyCallback,
+                                gpointer);
+
+static VALUE
+eject_stop_method(EjectStopMethod method, int argc, VALUE *argv, VALUE self)
+{
+        VALUE rbflags, rbmount_operation, rbcancellable, block;
+        GMountUnmountFlags flags;
+        GMountOperation *mount_operation;
+        GCancellable *cancellable;
+
+        rb_scan_args(argc, argv, "03&", &rbflags, &rbmount_operation, &rbcancellable, &block);
+        flags = RVAL2GMOUNTUNMOUNTFLAGSDEFAULT(rbflags);
+        mount_operation = RVAL2GMOUNTOPERATION(rbmount_operation);
+        cancellable = RVAL2GCANCELLABLE(rbcancellable);
+        SAVE_BLOCK(block);
+        method(_SELF(self),
+               flags,
+               mount_operation,
+               cancellable,
+               rbgio_async_ready_callback,
+               (gpointer)block);
+
+        return self;
+}
+
+static VALUE
+drive_eject_with_operation(int argc, VALUE *argv, VALUE self)
+{
+        return eject_stop_method(g_drive_eject_with_operation, argc, argv, self);
+}
+
+static VALUE
+drive_eject_with_operation_finish(VALUE self, VALUE result)
+{
+        return boolean_finish_method(g_drive_eject_with_operation_finish, self, result);
+}
+
+static VALUE
+drive_start(int argc, VALUE *argv, VALUE self)
+{
+        VALUE rbflags, rbmount_operation, rbcancellable, block;
+        GDriveStartFlags flags;
+        GMountOperation *mount_operation;
+        GCancellable *cancellable;
+
+        rb_scan_args(argc, argv, "03", &rbflags, &rbmount_operation, &rbcancellable, &block);
+        flags = RVAL2GDRIVESTARTFLAGSDEFAULT(rbflags);
+        mount_operation = RVAL2GMOUNTOPERATION(rbmount_operation);
+        cancellable = RVAL2GCANCELLABLE(rbcancellable);
+        SAVE_BLOCK(block);
+        g_drive_start(_SELF(self), flags, mount_operation, cancellable,
+                      rbgio_async_ready_callback, (gpointer)block);
+
+        return self;
+}
+
+static VALUE
+drive_start_finish(VALUE self, VALUE result)
+{
+        return boolean_finish_method(g_drive_start_finish, self, result);
+}
+
+static VALUE
+drive_stop(int argc, VALUE *argv, VALUE self)
+{
+        return eject_stop_method(g_drive_stop, argc, argv, self);
+}
+
+static VALUE
+drive_stop_finish(VALUE self, VALUE result)
+{
+        return boolean_finish_method(g_drive_stop_finish, self, result);
+}
+
+static VALUE
+drive_enumerate_identifiers(VALUE self)
+{
+        return STRVECTOR2ARY_FREE(g_drive_enumerate_identifiers(_SELF(self)));
+}
+
+static VALUE
+drive_get_identifier(VALUE self, VALUE kind)
+{
+        return CSTR2RVAL_FREE(g_drive_get_identifier(_SELF(self), RVAL2CSTR(kind)));
+}
+
+void
+Init_gdrive(VALUE glib)
+{
+        VALUE drive = G_DEF_INTERFACE(G_TYPE_DRIVE, "Drive", glib);
+
+        G_DEF_CLASS(G_TYPE_DRIVE_START_FLAGS, "StartFlags", drive);
+        G_DEF_CONSTANTS(drive, G_TYPE_DRIVE_START_FLAGS, "G_DRIVE_");
+
+        G_DEF_CLASS(G_TYPE_DRIVE_START_STOP_TYPE, "StartStopType", drive);
+        G_DEF_CONSTANTS(drive, G_TYPE_DRIVE_START_STOP_TYPE, "G_DRIVE_");
+
+        rb_define_method(drive, "name", drive_get_name, 0);
+        rb_define_method(drive, "icon", drive_get_icon, 0);
+        rb_define_method(drive, "has_volumes?", drive_has_volumes, 0);
+        rb_define_method(drive, "volumes", drive_get_volumes, 0);
+        rb_define_method(drive, "can_eject?", drive_can_eject, 0);
+        rb_define_method(drive, "start_stop_type", drive_get_start_stop_type, 0);
+        rb_define_method(drive, "can_start?", drive_can_start, 0);
+        rb_define_method(drive, "can_start_degraded?", drive_can_start_degraded, 0);
+        rb_define_method(drive, "can_stop?", drive_can_stop, 0);
+        rb_define_method(drive, "can_poll_for_media?", drive_can_poll_for_media, 0);
+        rb_define_method(drive, "poll_for_media", drive_poll_for_media, -1);
+        rb_define_method(drive, "poll_for_media_finish", drive_poll_for_media_finish, 1);
+        rb_define_method(drive, "has_media?", drive_has_media, 0);
+        rb_define_method(drive, "media_check_automatic?", drive_is_media_check_automatic, 0);
+        rb_define_method(drive, "media_removable?", drive_is_media_removable, 0);
+        rb_define_method(drive, "eject_with_operation", drive_eject_with_operation, -1);
+        rb_define_method(drive, "eject_with_operation_finish", drive_eject_with_operation_finish, 1);
+        rb_define_method(drive, "start", drive_start, -1);
+        rb_define_method(drive, "start_finish", drive_start_finish, 1);
+        rb_define_method(drive, "stop", drive_stop, -1);
+        rb_define_method(drive, "stop_finish", drive_stop_finish, 1);
+        rb_define_method(drive, "enumerate_identifiers", drive_enumerate_identifiers, -1);
+        rb_define_alias(drive, "identifiers", "enumerate_identifiers");
+        rb_define_method(drive, "get_identifier", drive_get_identifier, 1);
+}