gio2 1.0.3-x86-mingw32 → 1.1.0-x86-mingw32

data/ext/gio2/{gdrive.c → rbgiodrive.c}

@@ -1,92 +1,91 @@
-/* -*- c-file-style: "ruby" -*- */
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- * Ruby/GIO: a Ruby binding of gio-2.0.x.
- * Copyright (C) 2008-2009  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  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 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, or (at your option) any later version.
  *
- * 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.
+ *  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
+ *  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., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
  */
 
-#include "gio2.h"
+#include "rbgio2private.h"
 
-#define _SELF(value) G_DRIVE(RVAL2GOBJ(value))
-
-#define GDRIVESTARTSTOPTYPE2RVAL(value) \
-        GENUM2RVAL((value), G_TYPE_DRIVE_START_STOP_TYPE)
+#define RG_TARGET_NAMESPACE mDrive
+#define _SELF(value) RVAL2GDRIVE(value)
 
 static VALUE
-drive_get_name(VALUE self)
+rg_name(VALUE self)
 {
         return CSTR2RVAL_FREE(g_drive_get_name(_SELF(self)));
 }
 
 static VALUE
-drive_get_icon(VALUE self)
+rg_icon(VALUE self)
 {
         return GOBJ2RVAL_UNREF(g_drive_get_icon(_SELF(self)));
 }
 
 static VALUE
-drive_has_volumes(VALUE self)
+rg_has_volumes_p(VALUE self)
 {
         return CBOOL2RVAL(g_drive_has_volumes(_SELF(self)));
 }
 
 static VALUE
-drive_get_volumes(VALUE self)
+rg_volumes(VALUE self)
 {
         return GLIST2ARY_FREE(g_drive_get_volumes(_SELF(self)));
 }
 
 static VALUE
-drive_can_eject(VALUE self)
+rg_can_eject_p(VALUE self)
 {
         return CBOOL2RVAL(g_drive_can_eject(_SELF(self)));
 }
 
 static VALUE
-drive_get_start_stop_type(VALUE self)
+rg_start_stop_type(VALUE self)
 {
         return GDRIVESTARTSTOPTYPE2RVAL(g_drive_get_start_stop_type(_SELF(self)));
 }
 
 static VALUE
-drive_can_start(VALUE self)
+rg_can_start_p(VALUE self)
 {
         return CBOOL2RVAL(g_drive_can_start(_SELF(self)));
 }
 
 static VALUE
-drive_can_start_degraded(VALUE self)
+rg_can_start_degraded_p(VALUE self)
 {
         return CBOOL2RVAL(g_drive_can_start_degraded(_SELF(self)));
 }
 
 static VALUE
-drive_can_stop(VALUE self)
+rg_can_stop_p(VALUE self)
 {
         return CBOOL2RVAL(g_drive_can_stop(_SELF(self)));
 }
 
 static VALUE
-drive_can_poll_for_media(VALUE self)
+rg_can_poll_for_media_p(VALUE self)
 {
         return CBOOL2RVAL(g_drive_can_poll_for_media(_SELF(self)));
 }
 
 static VALUE
-drive_poll_for_media(int argc, VALUE *argv, VALUE self)
+rg_poll_for_media(int argc, VALUE *argv, VALUE self)
 {
         VALUE rbcancellable, block;
         GCancellable *cancellable;
@@ -115,25 +114,25 @@ boolean_finish_method(BooleanFinishMethod method, VALUE self, VALUE result)
 }
 
 static VALUE
-drive_poll_for_media_finish(VALUE self, VALUE result)
+rg_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)
+rg_has_media_p(VALUE self)
 {
         return CBOOL2RVAL(g_drive_has_media(_SELF(self)));
 }
 
 static VALUE
-drive_is_media_check_automatic(VALUE self)
+rg_media_check_automatic_p(VALUE self)
 {
         return CBOOL2RVAL(g_drive_is_media_check_automatic(_SELF(self)));
 }
 
 static VALUE
-drive_is_media_removable(VALUE self)
+rg_media_removable_p(VALUE self)
 {
         return CBOOL2RVAL(g_drive_is_media_removable(_SELF(self)));
 }
@@ -169,19 +168,19 @@ eject_stop_method(EjectStopMethod method, int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-drive_eject_with_operation(int argc, VALUE *argv, VALUE self)
+rg_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)
+rg_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)
+rg_start(int argc, VALUE *argv, VALUE self)
 {
         VALUE rbflags, rbmount_operation, rbcancellable, block;
         GDriveStartFlags flags;
@@ -200,68 +199,68 @@ drive_start(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-drive_start_finish(VALUE self, VALUE result)
+rg_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)
+rg_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)
+rg_stop_finish(VALUE self, VALUE result)
 {
         return boolean_finish_method(g_drive_stop_finish, self, result);
 }
 
 static VALUE
-drive_enumerate_identifiers(VALUE self)
+rg_enumerate_identifiers(VALUE self)
 {
-        return STRVECTOR2ARY_FREE(g_drive_enumerate_identifiers(_SELF(self)));
+        return STRV2RVAL_FREE(g_drive_enumerate_identifiers(_SELF(self)));
 }
 
 static VALUE
-drive_get_identifier(VALUE self, VALUE kind)
+rg_get_identifier(VALUE self, VALUE kind)
 {
         return CSTR2RVAL_FREE(g_drive_get_identifier(_SELF(self), RVAL2CSTR(kind)));
 }
 
 void
-Init_gdrive(VALUE glib)
+Init_gdrive(VALUE mGio)
 {
-        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);
+        VALUE RG_TARGET_NAMESPACE = G_DEF_INTERFACE(G_TYPE_DRIVE, "Drive", mGio);
+
+        G_DEF_CLASS(G_TYPE_DRIVE_START_FLAGS, "StartFlags", RG_TARGET_NAMESPACE);
+        G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, G_TYPE_DRIVE_START_FLAGS, "G_DRIVE_");
+
+        G_DEF_CLASS(G_TYPE_DRIVE_START_STOP_TYPE, "StartStopType", RG_TARGET_NAMESPACE);
+        G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, G_TYPE_DRIVE_START_STOP_TYPE, "G_DRIVE_");
+
+        RG_DEF_METHOD(name, 0);
+        RG_DEF_METHOD(icon, 0);
+        RG_DEF_METHOD_P(has_volumes, 0);
+        RG_DEF_METHOD(volumes, 0);
+        RG_DEF_METHOD_P(can_eject, 0);
+        RG_DEF_METHOD(start_stop_type, 0);
+        RG_DEF_METHOD_P(can_start, 0);
+        RG_DEF_METHOD_P(can_start_degraded, 0);
+        RG_DEF_METHOD_P(can_stop, 0);
+        RG_DEF_METHOD_P(can_poll_for_media, 0);
+        RG_DEF_METHOD(poll_for_media, -1);
+        RG_DEF_METHOD(poll_for_media_finish, 1);
+        RG_DEF_METHOD_P(has_media, 0);
+        RG_DEF_METHOD_P(media_check_automatic, 0);
+        RG_DEF_METHOD_P(media_removable, 0);
+        RG_DEF_METHOD(eject_with_operation, -1);
+        RG_DEF_METHOD(eject_with_operation_finish, 1);
+        RG_DEF_METHOD(start, -1);
+        RG_DEF_METHOD(start_finish, 1);
+        RG_DEF_METHOD(stop, -1);
+        RG_DEF_METHOD(stop_finish, 1);
+        RG_DEF_METHOD(enumerate_identifiers, -1);
+        RG_DEF_ALIAS("identifiers", "enumerate_identifiers");
+        RG_DEF_METHOD(get_identifier, 1);
 }

data/ext/gio2/rbgioemblem.c

@@ -0,0 +1,52 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  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, or (at your option) any later version.
+ *
+ *  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., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#include "rbgio2private.h"
+
+#define RG_TARGET_NAMESPACE cEmblem
+
+static VALUE
+rg_initialize(int argc, VALUE *argv, VALUE self)
+{
+        VALUE rbicon, origin;
+        GIcon *icon;
+        GEmblem *emblem;
+
+        rb_scan_args(argc, argv, "11", &rbicon, &origin);
+        icon = RVAL2GICON(rbicon);
+        emblem = NIL_P(origin) ?
+                g_emblem_new(icon) :
+                g_emblem_new_with_origin(icon, RVAL2GEMBLEMORIGIN(origin));
+        G_INITIALIZE(self, emblem);
+
+        return Qnil;
+}
+
+void
+Init_gemblem(VALUE mGio)
+{
+        VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_EMBLEM, "Emblem", mGio);
+
+        G_DEF_CLASS(G_TYPE_EMBLEM_ORIGIN, "Origin", RG_TARGET_NAMESPACE);
+        G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, G_TYPE_EMBLEM_ORIGIN, "G_EMBLEM_");
+
+        RG_DEF_METHOD(initialize, -1);
+}

data/ext/gio2/rbgioemblemedicon.c

@@ -0,0 +1,65 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  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, or (at your option) any later version.
+ *
+ *  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., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#include "rbgio2private.h"
+
+#define RG_TARGET_NAMESPACE cEmblemedIcon
+#define _SELF(value) RVAL2GEMBLEMEDICON(value)
+
+static VALUE
+rg_initialize(VALUE self, VALUE icon, VALUE emblem)
+{
+        G_INITIALIZE(self, g_emblemed_icon_new(RVAL2GICON(icon), RVAL2GEMBLEM(emblem)));
+
+        return Qnil;
+}
+
+static VALUE
+rg_icon(VALUE self)
+{
+        return GOBJ2RVAL(g_emblemed_icon_get_icon(_SELF(self)));
+}
+
+static VALUE
+rg_emblems(VALUE self)
+{
+        return GLIST2ARY_FREE(g_emblemed_icon_get_emblems(_SELF(self)));
+}
+
+static VALUE
+rg_add_emblem(VALUE self, VALUE emblem)
+{
+        g_emblemed_icon_add_emblem(_SELF(self), RVAL2GEMBLEM(emblem));
+
+        return self;
+}
+
+void
+Init_gemblemedicon(VALUE mGio)
+{
+        VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_EMBLEMED_ICON, "EmblemedIcon", mGio);
+
+        RG_DEF_METHOD(initialize, 2);
+        RG_DEF_METHOD(icon, 0);
+        RG_DEF_METHOD(emblems, 0);
+        RG_DEF_METHOD(add_emblem, 1);
+        RG_DEF_ALIAS("<<", "add_emblem");
+}