gio2 1.0.3 → 1.1.0

data/ext/gio2/rbgiofileattribute.c

@@ -0,0 +1,114 @@
+/* -*- 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 mFileAttribute
+
+void
+Init_gfileattribute(VALUE mGio)
+{
+        VALUE RG_TARGET_NAMESPACE;
+
+        RG_TARGET_NAMESPACE = rb_define_module_under(mGio, "FileAttribute");
+
+        rb_define_const(RG_TARGET_NAMESPACE, "STANDARD_TYPE", CSTR2RVAL(G_FILE_ATTRIBUTE_STANDARD_TYPE));
+        rb_define_const(RG_TARGET_NAMESPACE, "STANDARD_IS_HIDDEN", CSTR2RVAL(G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN));
+        rb_define_const(RG_TARGET_NAMESPACE, "STANDARD_IS_BACKUP", CSTR2RVAL(G_FILE_ATTRIBUTE_STANDARD_IS_BACKUP));
+        rb_define_const(RG_TARGET_NAMESPACE, "STANDARD_IS_SYMLINK", CSTR2RVAL(G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK));
+        rb_define_const(RG_TARGET_NAMESPACE, "STANDARD_IS_VIRTUAL", CSTR2RVAL(G_FILE_ATTRIBUTE_STANDARD_IS_VIRTUAL));
+        rb_define_const(RG_TARGET_NAMESPACE, "STANDARD_NAME", CSTR2RVAL(G_FILE_ATTRIBUTE_STANDARD_NAME));
+        rb_define_const(RG_TARGET_NAMESPACE, "STANDARD_DISPLAY_NAME", CSTR2RVAL(G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME));
+        rb_define_const(RG_TARGET_NAMESPACE, "STANDARD_EDIT_NAME", CSTR2RVAL(G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME));
+        rb_define_const(RG_TARGET_NAMESPACE, "STANDARD_COPY_NAME", CSTR2RVAL(G_FILE_ATTRIBUTE_STANDARD_COPY_NAME));
+        rb_define_const(RG_TARGET_NAMESPACE, "STANDARD_DESCRIPTION", CSTR2RVAL(G_FILE_ATTRIBUTE_STANDARD_DESCRIPTION));
+        rb_define_const(RG_TARGET_NAMESPACE, "STANDARD_ICON", CSTR2RVAL(G_FILE_ATTRIBUTE_STANDARD_ICON));
+        rb_define_const(RG_TARGET_NAMESPACE, "STANDARD_CONTENT_TYPE", CSTR2RVAL(G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE));
+        rb_define_const(RG_TARGET_NAMESPACE, "STANDARD_FAST_CONTENT_TYPE", CSTR2RVAL(G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE));
+        rb_define_const(RG_TARGET_NAMESPACE, "STANDARD_SIZE", CSTR2RVAL(G_FILE_ATTRIBUTE_STANDARD_SIZE));
+        rb_define_const(RG_TARGET_NAMESPACE, "STANDARD_ALLOCATED_SIZE", CSTR2RVAL(G_FILE_ATTRIBUTE_STANDARD_ALLOCATED_SIZE));
+        rb_define_const(RG_TARGET_NAMESPACE, "STANDARD_SYMLINK_TARGET", CSTR2RVAL(G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET));
+        rb_define_const(RG_TARGET_NAMESPACE, "STANDARD_TARGET_URI", CSTR2RVAL(G_FILE_ATTRIBUTE_STANDARD_TARGET_URI));
+        rb_define_const(RG_TARGET_NAMESPACE, "STANDARD_SORT_ORDER", CSTR2RVAL(G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER));
+        rb_define_const(RG_TARGET_NAMESPACE, "ETAG_VALUE", CSTR2RVAL(G_FILE_ATTRIBUTE_ETAG_VALUE));
+        rb_define_const(RG_TARGET_NAMESPACE, "ID_FILE", CSTR2RVAL(G_FILE_ATTRIBUTE_ID_FILE));
+        rb_define_const(RG_TARGET_NAMESPACE, "ID_FILESYSTEM", CSTR2RVAL(G_FILE_ATTRIBUTE_ID_FILESYSTEM));
+        rb_define_const(RG_TARGET_NAMESPACE, "ACCESS_CAN_READ", CSTR2RVAL(G_FILE_ATTRIBUTE_ACCESS_CAN_READ));
+        rb_define_const(RG_TARGET_NAMESPACE, "ACCESS_CAN_WRITE", CSTR2RVAL(G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE));
+        rb_define_const(RG_TARGET_NAMESPACE, "ACCESS_CAN_EXECUTE", CSTR2RVAL(G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE));
+        rb_define_const(RG_TARGET_NAMESPACE, "ACCESS_CAN_DELETE", CSTR2RVAL(G_FILE_ATTRIBUTE_ACCESS_CAN_DELETE));
+        rb_define_const(RG_TARGET_NAMESPACE, "ACCESS_CAN_TRASH", CSTR2RVAL(G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH));
+        rb_define_const(RG_TARGET_NAMESPACE, "ACCESS_CAN_RENAME", CSTR2RVAL(G_FILE_ATTRIBUTE_ACCESS_CAN_RENAME));
+        rb_define_const(RG_TARGET_NAMESPACE, "MOUNTABLE_CAN_MOUNT", CSTR2RVAL(G_FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT));
+        rb_define_const(RG_TARGET_NAMESPACE, "MOUNTABLE_CAN_UNMOUNT", CSTR2RVAL(G_FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT));
+        rb_define_const(RG_TARGET_NAMESPACE, "MOUNTABLE_CAN_EJECT", CSTR2RVAL(G_FILE_ATTRIBUTE_MOUNTABLE_CAN_EJECT));
+        rb_define_const(RG_TARGET_NAMESPACE, "MOUNTABLE_UNIX_DEVICE", CSTR2RVAL(G_FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE));
+        rb_define_const(RG_TARGET_NAMESPACE, "MOUNTABLE_UNIX_DEVICE_FILE", CSTR2RVAL(G_FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE_FILE));
+        rb_define_const(RG_TARGET_NAMESPACE, "MOUNTABLE_HAL_UDI", CSTR2RVAL(G_FILE_ATTRIBUTE_MOUNTABLE_HAL_UDI));
+        rb_define_const(RG_TARGET_NAMESPACE, "MOUNTABLE_CAN_POLL", CSTR2RVAL(G_FILE_ATTRIBUTE_MOUNTABLE_CAN_POLL));
+        rb_define_const(RG_TARGET_NAMESPACE, "MOUNTABLE_IS_MEDIA_CHECK_AUTOMATIC", CSTR2RVAL(G_FILE_ATTRIBUTE_MOUNTABLE_IS_MEDIA_CHECK_AUTOMATIC));
+        rb_define_const(RG_TARGET_NAMESPACE, "MOUNTABLE_CAN_START", CSTR2RVAL(G_FILE_ATTRIBUTE_MOUNTABLE_CAN_START));
+        rb_define_const(RG_TARGET_NAMESPACE, "MOUNTABLE_CAN_START_DEGRADED", CSTR2RVAL(G_FILE_ATTRIBUTE_MOUNTABLE_CAN_START_DEGRADED));
+        rb_define_const(RG_TARGET_NAMESPACE, "MOUNTABLE_CAN_STOP", CSTR2RVAL(G_FILE_ATTRIBUTE_MOUNTABLE_CAN_STOP));
+        rb_define_const(RG_TARGET_NAMESPACE, "MOUNTABLE_START_STOP_TYPE", CSTR2RVAL(G_FILE_ATTRIBUTE_MOUNTABLE_START_STOP_TYPE));
+        rb_define_const(RG_TARGET_NAMESPACE, "TIME_MODIFIED", CSTR2RVAL(G_FILE_ATTRIBUTE_TIME_MODIFIED));
+        rb_define_const(RG_TARGET_NAMESPACE, "TIME_MODIFIED_USEC", CSTR2RVAL(G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC));
+        rb_define_const(RG_TARGET_NAMESPACE, "TIME_ACCESS", CSTR2RVAL(G_FILE_ATTRIBUTE_TIME_ACCESS));
+        rb_define_const(RG_TARGET_NAMESPACE, "TIME_ACCESS_USEC", CSTR2RVAL(G_FILE_ATTRIBUTE_TIME_ACCESS_USEC));
+        rb_define_const(RG_TARGET_NAMESPACE, "TIME_CHANGED", CSTR2RVAL(G_FILE_ATTRIBUTE_TIME_CHANGED));
+        rb_define_const(RG_TARGET_NAMESPACE, "TIME_CHANGED_USEC", CSTR2RVAL(G_FILE_ATTRIBUTE_TIME_CHANGED_USEC));
+        rb_define_const(RG_TARGET_NAMESPACE, "TIME_CREATED", CSTR2RVAL(G_FILE_ATTRIBUTE_TIME_CREATED));
+        rb_define_const(RG_TARGET_NAMESPACE, "TIME_CREATED_USEC", CSTR2RVAL(G_FILE_ATTRIBUTE_TIME_CREATED_USEC));
+        rb_define_const(RG_TARGET_NAMESPACE, "UNIX_DEVICE", CSTR2RVAL(G_FILE_ATTRIBUTE_UNIX_DEVICE));
+        rb_define_const(RG_TARGET_NAMESPACE, "UNIX_INODE", CSTR2RVAL(G_FILE_ATTRIBUTE_UNIX_INODE));
+        rb_define_const(RG_TARGET_NAMESPACE, "UNIX_MODE", CSTR2RVAL(G_FILE_ATTRIBUTE_UNIX_MODE));
+        rb_define_const(RG_TARGET_NAMESPACE, "UNIX_NLINK", CSTR2RVAL(G_FILE_ATTRIBUTE_UNIX_NLINK));
+        rb_define_const(RG_TARGET_NAMESPACE, "UNIX_UID", CSTR2RVAL(G_FILE_ATTRIBUTE_UNIX_UID));
+        rb_define_const(RG_TARGET_NAMESPACE, "UNIX_GID", CSTR2RVAL(G_FILE_ATTRIBUTE_UNIX_GID));
+        rb_define_const(RG_TARGET_NAMESPACE, "UNIX_RDEV", CSTR2RVAL(G_FILE_ATTRIBUTE_UNIX_RDEV));
+        rb_define_const(RG_TARGET_NAMESPACE, "UNIX_BLOCK_SIZE", CSTR2RVAL(G_FILE_ATTRIBUTE_UNIX_BLOCK_SIZE));
+        rb_define_const(RG_TARGET_NAMESPACE, "UNIX_BLOCKS", CSTR2RVAL(G_FILE_ATTRIBUTE_UNIX_BLOCKS));
+        rb_define_const(RG_TARGET_NAMESPACE, "UNIX_IS_MOUNTPOINT", CSTR2RVAL(G_FILE_ATTRIBUTE_UNIX_IS_MOUNTPOINT));
+        rb_define_const(RG_TARGET_NAMESPACE, "DOS_IS_ARCHIVE", CSTR2RVAL(G_FILE_ATTRIBUTE_DOS_IS_ARCHIVE));
+        rb_define_const(RG_TARGET_NAMESPACE, "DOS_IS_SYSTEM", CSTR2RVAL(G_FILE_ATTRIBUTE_DOS_IS_SYSTEM));
+        rb_define_const(RG_TARGET_NAMESPACE, "OWNER_USER", CSTR2RVAL(G_FILE_ATTRIBUTE_OWNER_USER));
+        rb_define_const(RG_TARGET_NAMESPACE, "OWNER_USER_REAL", CSTR2RVAL(G_FILE_ATTRIBUTE_OWNER_USER_REAL));
+        rb_define_const(RG_TARGET_NAMESPACE, "OWNER_GROUP", CSTR2RVAL(G_FILE_ATTRIBUTE_OWNER_GROUP));
+        rb_define_const(RG_TARGET_NAMESPACE, "THUMBNAIL_PATH", CSTR2RVAL(G_FILE_ATTRIBUTE_THUMBNAIL_PATH));
+        rb_define_const(RG_TARGET_NAMESPACE, "THUMBNAILING_FAILED", CSTR2RVAL(G_FILE_ATTRIBUTE_THUMBNAILING_FAILED));
+        rb_define_const(RG_TARGET_NAMESPACE, "PREVIEW_ICON", CSTR2RVAL(G_FILE_ATTRIBUTE_PREVIEW_ICON));
+        rb_define_const(RG_TARGET_NAMESPACE, "FILESYSTEM_SIZE", CSTR2RVAL(G_FILE_ATTRIBUTE_FILESYSTEM_SIZE));
+        rb_define_const(RG_TARGET_NAMESPACE, "FILESYSTEM_FREE", CSTR2RVAL(G_FILE_ATTRIBUTE_FILESYSTEM_FREE));
+        rb_define_const(RG_TARGET_NAMESPACE, "FILESYSTEM_TYPE", CSTR2RVAL(G_FILE_ATTRIBUTE_FILESYSTEM_TYPE));
+        rb_define_const(RG_TARGET_NAMESPACE, "FILESYSTEM_READONLY", CSTR2RVAL(G_FILE_ATTRIBUTE_FILESYSTEM_READONLY));
+        rb_define_const(RG_TARGET_NAMESPACE, "FILESYSTEM_USE_PREVIEW", CSTR2RVAL(G_FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW));
+        rb_define_const(RG_TARGET_NAMESPACE, "GVFS_BACKEND", CSTR2RVAL(G_FILE_ATTRIBUTE_GVFS_BACKEND));
+        rb_define_const(RG_TARGET_NAMESPACE, "SELINUX_CONTEXT", CSTR2RVAL(G_FILE_ATTRIBUTE_SELINUX_CONTEXT));
+        rb_define_const(RG_TARGET_NAMESPACE, "TRASH_ITEM_COUNT", CSTR2RVAL(G_FILE_ATTRIBUTE_TRASH_ITEM_COUNT));
+        rb_define_const(RG_TARGET_NAMESPACE, "TRASH_DELETION_DATE", CSTR2RVAL(G_FILE_ATTRIBUTE_TRASH_DELETION_DATE));
+        rb_define_const(RG_TARGET_NAMESPACE, "TRASH_ORIG_PATH", CSTR2RVAL(G_FILE_ATTRIBUTE_TRASH_ORIG_PATH));
+
+        G_DEF_CLASS(G_TYPE_FILE_ATTRIBUTE_TYPE, "Type", RG_TARGET_NAMESPACE);
+        G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, G_TYPE_FILE_ATTRIBUTE_TYPE, "G_FILE_ATTRIBUTE_");
+
+        G_DEF_CLASS(G_TYPE_FILE_ATTRIBUTE_STATUS, "Status", RG_TARGET_NAMESPACE);
+        G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, G_TYPE_FILE_ATTRIBUTE_STATUS, "G_FILE_ATTRIBUTE_");
+}

data/ext/gio2/rbgiofileattributeinfo.c

@@ -0,0 +1,86 @@
+/* -*- 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 cFileAttributeInfo
+
+static GFileAttributeInfo *
+fileattributeinfo_copy(const GFileAttributeInfo *info)
+{
+        return (GFileAttributeInfo *)info;
+}
+
+static void
+fileattributeinfo_free(G_GNUC_UNUSED GFileAttributeInfo *info)
+{
+        return;
+}
+
+GType
+g_file_attribute_info_get_type(void)
+{
+        static GType our_type = 0;
+
+        if (our_type == 0)
+                our_type = g_boxed_type_register_static("GFileAttributeInfo",
+                                                        (GBoxedCopyFunc)fileattributeinfo_copy,
+                                                        (GBoxedFreeFunc)fileattributeinfo_free);
+
+        return our_type;
+}
+
+#define _SELF(value) RVAL2GFILEATTRIBUTEINFO(value)
+
+static VALUE
+rg_name(VALUE self)
+{
+        return CSTR2RVAL(_SELF(self)->name);
+}
+
+static VALUE
+rg_type(VALUE self)
+{
+        return GFILEATTRIBUTETYPE2RVAL(_SELF(self)->type);
+}
+
+static VALUE
+rg_flags(VALUE self)
+{
+        return GFILEATTRIBUTEINFOFLAGS2RVAL(_SELF(self)->flags);
+}
+
+void
+Init_gfileattributeinfo(VALUE mGio)
+{
+        VALUE RG_TARGET_NAMESPACE;
+
+        RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_FILE_ATTRIBUTE_INFO, "FileAttributeInfo", mGio);
+
+        G_DEF_CLASS(G_TYPE_FILE_ATTRIBUTE_INFO_FLAGS, "Flags", RG_TARGET_NAMESPACE);
+        G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, G_TYPE_FILE_ATTRIBUTE_INFO_FLAGS, "G_FILE_ATTRIBUTE_INFO_");
+
+        rbgobj_boxed_not_copy_obj(G_TYPE_FILE_ATTRIBUTE_INFO);
+
+        RG_DEF_METHOD(name, 0);
+        RG_DEF_METHOD(type, 0);
+        RG_DEF_METHOD(flags, 0);
+}

data/ext/gio2/rbgiofileattributeinfolist.c

@@ -0,0 +1,106 @@
+/* -*- 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 cFileAttributeInfoList
+
+#define RVAL2GFILEATTRIBUTEINFOFLAGSDEFAULT(value) \
+        RVAL2TYPE_WITH_DEFAULT((value), \
+                               RVAL2GFILEATTRIBUTEINFOFLAGS, \
+                               G_FILE_ATTRIBUTE_INFO_NONE)
+
+GType
+g_file_attribute_info_list_get_type(void)
+{
+        static GType our_type = 0;
+        if (our_type == 0)
+                our_type = g_boxed_type_register_static("GFileAttributeInfoList",
+                                                        (GBoxedCopyFunc)g_file_attribute_info_list_ref,
+                                                        (GBoxedFreeFunc)g_file_attribute_info_list_unref);
+        return our_type;
+}
+
+#define _SELF(value) RVAL2GFILEATTRIBUTEINFOLIST(value)
+
+static VALUE
+rg_initialize(VALUE self)
+{
+        G_INITIALIZE(self, g_file_attribute_info_list_new());
+
+        return Qnil;
+}
+
+static VALUE
+rg_dup(VALUE self)
+{
+        return GFILEATTRIBUTEINFOLIST2RVAL(g_file_attribute_info_list_dup(_SELF(self)));
+}
+
+static VALUE
+rg_lookup(VALUE self, VALUE name)
+{
+        /* TODO: How do we deal with the const? */
+        return GFILEATTRIBUTEINFO2RVAL((GFileAttributeInfo *)g_file_attribute_info_list_lookup(_SELF(self),
+                                                                                               RVAL2CSTR(name)));
+}
+
+static VALUE
+rg_add(int argc, VALUE *argv, VALUE self)
+{
+        VALUE name, type, flags;
+
+        rb_scan_args(argc, argv, "21", &name, &type, &flags);
+
+        g_file_attribute_info_list_add(_SELF(self),
+                                       RVAL2CSTR(name),
+                                       RVAL2GFILEATTRIBUTETYPE(type),
+                                       RVAL2GFILEATTRIBUTEINFOFLAGSDEFAULT(flags));
+
+        return self;
+}
+
+static VALUE
+rg_each(VALUE self)
+{
+        GFileAttributeInfoList *list = RVAL2GFILEATTRIBUTEINFOLIST(self);
+        int i;
+
+        for (i = 0; i < list->n_infos; i++)
+                rb_yield(GFILEATTRIBUTEINFO2RVAL(&list->infos[i]));
+
+        return self;
+}
+
+void
+Init_fileattributeinfolist(VALUE mGio)
+{
+        VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_FILE_ATTRIBUTE_INFO_LIST, "FileAttributeInfoList", mGio);
+
+        rb_include_module(RG_TARGET_NAMESPACE, rb_mEnumerable);
+
+        RG_DEF_METHOD(initialize, 0);
+        RG_DEF_METHOD(dup, 0);
+        RG_DEF_METHOD(lookup, 1);
+        RG_DEF_ALIAS("[]", "lookup");
+        RG_DEF_METHOD(add, 3);
+        RG_DEF_METHOD(each, 0);
+}

data/ext/gio2/rbgiofileattributematcher.c

@@ -0,0 +1,93 @@
+/* -*- 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 cFileAttributeMatcher
+
+GType
+g_file_attribute_matcher_get_type(void)
+{
+        static GType our_type = 0;
+        if (our_type == 0)
+                our_type = g_boxed_type_register_static("GFileAttributeMatcher",
+                                                        (GBoxedCopyFunc)g_file_attribute_matcher_ref,
+                                                        (GBoxedFreeFunc)g_file_attribute_matcher_unref);
+        return our_type;
+}
+
+#define _SELF(value) RVAL2GFILEATTRIBUTEMATCHER(value)
+
+static VALUE
+rg_initialize(VALUE self, VALUE attributes)
+{
+        G_INITIALIZE(self, g_file_attribute_matcher_new(RVAL2CSTR(attributes)));
+
+        return Qnil;
+}
+
+static VALUE
+rg_matches_p(VALUE self, VALUE attribute)
+{
+        return CBOOL2RVAL(g_file_attribute_matcher_matches(_SELF(self), RVAL2CSTR(attribute)));
+}
+
+static VALUE
+rg_matches_only_p(VALUE self, VALUE attribute)
+{
+        return CBOOL2RVAL(g_file_attribute_matcher_matches_only(_SELF(self), RVAL2CSTR(attribute)));
+}
+
+static VALUE
+rg_enumerate_namespace(VALUE self, VALUE ns)
+{
+        const char *match;
+        gboolean matches_all = g_file_attribute_matcher_enumerate_namespace(_SELF(self),
+                                                                            RVAL2CSTR(ns));
+        if (!rb_block_given_p())
+                return CBOOL2RVAL(matches_all);
+
+        while ((match = g_file_attribute_matcher_enumerate_next(_SELF(self))) != NULL)
+                rb_yield(CSTR2RVAL(match));
+
+        return self;
+}
+
+static VALUE
+rg_enumerate_next(VALUE self)
+{
+        return CSTR2RVAL(g_file_attribute_matcher_enumerate_next(_SELF(self)));
+}
+
+void
+Init_gfileattributematcher(VALUE mGio)
+{
+        VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_FILE_ATTRIBUTE_MATCHER, "FileAttributeMatcher", mGio);
+
+        RG_DEF_METHOD(initialize, 1);
+        RG_DEF_METHOD_P(matches, 1);
+        /* TODO: Is this confusing when we have both #matches and
+         * #matches_only?  What does #=~ call? */
+        RG_DEF_ALIAS("=~", "matches?");
+        RG_DEF_METHOD_P(matches_only, 1);
+        RG_DEF_METHOD(enumerate_namespace, 1);
+        RG_DEF_METHOD(enumerate_next, 0);
+}

data/ext/gio2/rbgiofiledescriptorbased.c

@@ -0,0 +1,45 @@
+/* -*- 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"
+
+#ifdef HAVE_GIO_UNIX
+#include <gio/gfiledescriptorbased.h>
+
+#define RG_TARGET_NAMESPACE mFileDescriptorBased
+#define _SELF(value) RVAL2GFILEDESCRIPTORBASED(value)
+
+static VALUE
+rg_fd(VALUE self)
+{
+        return FD2RVAL(g_file_descriptor_based_get_fd(_SELF(self)));
+}
+#endif
+
+void
+Init_gfiledescriptorbased(G_GNUC_UNUSED VALUE mGio)
+{
+#ifdef HAVE_GIO_UNIX
+        VALUE RG_TARGET_NAMESPACE = G_DEF_INTERFACE(G_TYPE_FILE_DESCRIPTOR_BASED, "FileDescriptorBased", mGio);
+
+        RG_DEF_METHOD(fd, 0);
+#endif
+}

data/ext/gio2/{gfileenumerator.c → rbgiofileenumerator.c}

@@ -1,29 +1,31 @@
-/* -*- 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_FILE_ENUMERATOR(RVAL2GOBJ(value))
+#define RG_TARGET_NAMESPACE cFileEnumerator
+#define _SELF(value) RVAL2GFILEENUMERATOR(value)
 
 static VALUE
-fileenumerator_next_file(int argc, VALUE *argv, VALUE self)
+rg_next_file(int argc, VALUE *argv, VALUE self)
 {
         VALUE cancellable;
         GError *error = NULL;
@@ -40,7 +42,7 @@ fileenumerator_next_file(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-fileenumerator_close(int argc, VALUE *argv, VALUE self)
+rg_close(int argc, VALUE *argv, VALUE self)
 {
         VALUE cancellable;
         GError *error = NULL;
@@ -53,7 +55,7 @@ fileenumerator_close(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-fileenumerator_next_files_async(int argc, VALUE *argv, VALUE self)
+rg_next_files_async(int argc, VALUE *argv, VALUE self)
 {
         VALUE rbnum_files, rbio_priority, rbcancellable, block;
         int num_files;
@@ -76,7 +78,7 @@ fileenumerator_next_files_async(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-fileenumerator_next_files_finish(VALUE self, VALUE result)
+rg_next_files_finish(VALUE self, VALUE result)
 {
         GError *error = NULL;
         GList *files = g_file_enumerator_next_files_finish(_SELF(self),
@@ -89,7 +91,7 @@ fileenumerator_next_files_finish(VALUE self, VALUE result)
 }
 
 static VALUE
-fileenumerator_close_async(int argc, VALUE *argv, VALUE self)
+rg_close_async(int argc, VALUE *argv, VALUE self)
 {
         VALUE rbio_priority, rbcancellable, block;
         int io_priority;
@@ -109,7 +111,7 @@ fileenumerator_close_async(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-fileenumerator_close_finish(VALUE self, VALUE result)
+rg_close_finish(VALUE self, VALUE result)
 {
         GError *error = NULL;
         if (!g_file_enumerator_close_finish(_SELF(self),
@@ -121,19 +123,19 @@ fileenumerator_close_finish(VALUE self, VALUE result)
 }
 
 static VALUE
-fileenumerator_is_closed(VALUE self)
+rg_closed_p(VALUE self)
 {
         return CBOOL2RVAL(g_file_enumerator_is_closed(_SELF(self)));
 }
 
 static VALUE
-fileenumerator_has_pending(VALUE self)
+rg_has_pending_p(VALUE self)
 {
         return CBOOL2RVAL(g_file_enumerator_has_pending(_SELF(self)));
 }
 
 static VALUE
-fileenumerator_set_pending(VALUE self, VALUE pending)
+rg_set_pending(VALUE self, VALUE pending)
 {
         g_file_enumerator_set_pending(_SELF(self), RVAL2CBOOL(pending));
 
@@ -141,25 +143,25 @@ fileenumerator_set_pending(VALUE self, VALUE pending)
 }
 
 static VALUE
-fileenumerator_get_container(VALUE self)
+rg_container(VALUE self)
 {
         return GOBJ2RVAL(g_file_enumerator_get_container(_SELF(self)));
 }
 
 void
-Init_gfileenumerator(VALUE glib)
+Init_gfileenumerator(VALUE mGio)
 {
-        VALUE fileenumerator = G_DEF_CLASS(G_TYPE_FILE_ENUMERATOR, "FileEnumerator", glib);
-
-        rb_define_method(fileenumerator, "next_file", fileenumerator_next_file, -1);
-        rb_define_method(fileenumerator, "close", fileenumerator_close, -1);
-        rb_define_method(fileenumerator, "next_files_async", fileenumerator_next_files_async, -1);
-        rb_define_method(fileenumerator, "next_files_finish", fileenumerator_next_files_finish, 1);
-        rb_define_method(fileenumerator, "close_async", fileenumerator_close_async, -1);
-        rb_define_method(fileenumerator, "close_finish", fileenumerator_close_finish, 1);
-        rb_define_method(fileenumerator, "closed?", fileenumerator_is_closed, 0);
-        rb_define_method(fileenumerator, "has_pending?", fileenumerator_has_pending, 0);
-        rb_define_method(fileenumerator, "set_pending", fileenumerator_set_pending, 1);
-        G_DEF_SETTER(fileenumerator, "pending");
-        rb_define_method(fileenumerator, "container", fileenumerator_get_container, 0);
+        VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_FILE_ENUMERATOR, "FileEnumerator", mGio);
+
+        RG_DEF_METHOD(next_file, -1);
+        RG_DEF_METHOD(close, -1);
+        RG_DEF_METHOD(next_files_async, -1);
+        RG_DEF_METHOD(next_files_finish, 1);
+        RG_DEF_METHOD(close_async, -1);
+        RG_DEF_METHOD(close_finish, 1);
+        RG_DEF_METHOD_P(closed, 0);
+        RG_DEF_METHOD_P(has_pending, 0);
+        RG_DEF_METHOD(set_pending, 1);
+        G_DEF_SETTER(RG_TARGET_NAMESPACE, "pending");
+        RG_DEF_METHOD(container, 0);
 }

data/ext/gio2/rbgiofileicon.c

@@ -0,0 +1,41 @@
+/* -*- 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 cFileIcon
+#define _SELF(value) RVAL2GFILEICON(value)
+
+static VALUE
+rg_initialize(VALUE self, VALUE file)
+{
+        G_INITIALIZE(self, g_file_icon_new(RVAL2GFILE(file)));
+
+        return Qnil;
+}
+
+void
+Init_gfileicon(VALUE mGio)
+{
+        VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_FILE_ICON, "FileIcon", mGio);
+
+        RG_DEF_METHOD(initialize, 1);
+}