gtk3 2.2.4-x64-mingw32

data/ext/gtk3/rbgtk-tree-path.c

@@ -0,0 +1,191 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002-2004 Ruby-GNOME2 Project Team
+ *  Copyright (C) 2003,2004 Masao Mutoh
+ *
+ *  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 "rbgtk3private.h"
+
+#define RG_TARGET_NAMESPACE cTreePath
+#define _SELF(s) (RVAL2GTKTREEPATH(s))
+
+static ID id_equal;
+
+static VALUE
+rg_initialize(int argc, VALUE *argv, VALUE self)
+{
+    VALUE path;
+    GtkTreePath* widget;
+
+    if (argc == 1) {
+        path = argv[0];
+        if (TYPE(path) == T_STRING){
+            widget = gtk_tree_path_new_from_string(RVAL2CSTR(path));
+        } else {
+            widget = gtk_tree_path_new();
+            gtk_tree_path_append_index(widget, NUM2INT(path));
+        }
+        if (widget == NULL)
+            rb_raise(rb_eArgError, "Invalid path %s was passed.", RVAL2CSTR(path));
+    } else {
+        int i;
+        widget = gtk_tree_path_new();
+        for (i = 0; i < argc; i++)
+            gtk_tree_path_append_index(widget, NUM2INT(argv[i]));
+    }
+
+    G_INITIALIZE(self, widget);
+    return Qnil;
+}
+
+static VALUE
+rg_to_str(VALUE self)
+{
+    gchar* s = gtk_tree_path_to_string(_SELF(self));
+    VALUE result = CSTR2RVAL(s);
+    g_free(s);
+    return result;
+}
+
+/* Do we need this ? 
+GtkTreePath* gtk_tree_path_new_first (void);
+
+Deprecated
+#define     gtk_tree_path_new_root ()
+*/
+
+static VALUE
+rg_append_index(VALUE self, VALUE index)
+{
+    gtk_tree_path_append_index(_SELF(self), NUM2INT(index));
+    return self;
+}
+
+static VALUE
+rg_prepend_index(VALUE self, VALUE index)
+{
+    gtk_tree_path_prepend_index(_SELF(self), NUM2INT(index));
+    return self;
+}
+
+static VALUE
+rg_depth(VALUE self)
+{
+    return INT2NUM(gtk_tree_path_get_depth(_SELF(self)));
+}
+
+static VALUE
+rg_indices(VALUE self)
+{
+    VALUE ary;
+    gint i, length;
+    gint* indices;
+
+    length = gtk_tree_path_get_depth(_SELF(self));
+    indices = gtk_tree_path_get_indices(_SELF(self));
+
+    if (indices != NULL) {
+        ary = rb_ary_new2(length);
+        for (i = 0; i < length; i++) {
+            rb_ary_push(ary, INT2NUM(indices[i]));
+        }
+
+        return ary;
+    } else {
+        return Qnil;
+    }
+}
+
+static VALUE
+rg_operator_treepath_compare(VALUE self, VALUE other)
+{
+    return INT2NUM(gtk_tree_path_compare(_SELF(self), _SELF(other)));
+}
+
+static VALUE
+rg_operator_treepath_equal(VALUE self, VALUE other)
+{
+    if (!RVAL2CBOOL(rb_funcall(CLASS_OF(self), id_equal, 1, CLASS_OF(other)))) {
+        return Qfalse;
+    }
+
+    return CBOOL2RVAL(gtk_tree_path_compare(_SELF(self), _SELF(other)) == 0);
+}
+
+static VALUE
+rg_next_bang(VALUE self)
+{
+    gtk_tree_path_next(_SELF(self));
+    return self;
+}
+
+static VALUE
+rg_prev_bang(VALUE self)
+{
+    return CBOOL2RVAL(gtk_tree_path_prev(_SELF(self)));
+}
+
+static VALUE
+rg_up_bang(VALUE self)
+{
+    return CBOOL2RVAL(gtk_tree_path_up(_SELF(self)));
+}
+
+static VALUE
+rg_down_bang(VALUE self)
+{
+    gtk_tree_path_down(_SELF(self));
+    return Qtrue;
+}
+
+static VALUE
+rg_ancestor_p(VALUE self, VALUE descendant)
+{
+    return CBOOL2RVAL(gtk_tree_path_is_ancestor(_SELF(self), _SELF(descendant)));
+}
+
+static VALUE
+rg_descendant_p(VALUE self, VALUE ancestor)
+{
+    return CBOOL2RVAL(gtk_tree_path_is_descendant(_SELF(self), _SELF(ancestor)));
+}
+
+void
+Init_gtk_treepath(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_TREE_PATH, "TreePath", mGtk);
+
+    id_equal = rb_intern("==");
+
+    RG_DEF_METHOD(initialize, -1);
+    RG_DEF_METHOD(to_str, 0);
+    RG_DEF_ALIAS("to_s", "to_str");
+    RG_DEF_METHOD(append_index, 1);
+    RG_DEF_METHOD(prepend_index, 1);
+    RG_DEF_METHOD(depth, 0);
+    RG_DEF_METHOD(indices, 0);
+    RG_DEF_METHOD_OPERATOR("<=>", treepath_compare, 1);
+    RG_DEF_METHOD_OPERATOR("==", treepath_equal, 1);
+    RG_DEF_METHOD_BANG(next, 0);
+    RG_DEF_METHOD_BANG(prev, 0);
+    RG_DEF_METHOD_BANG(up, 0);
+    RG_DEF_METHOD_BANG(down, 0);
+    RG_DEF_METHOD_P(ancestor, 1);
+    RG_DEF_METHOD_P(descendant, 1);
+}

data/ext/gtk3/rbgtk-tree-rowreference.c

@@ -0,0 +1,140 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002-2006 Masao Mutoh
+ *
+ *  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 "rbgtk3private.h"
+
+#define RG_TARGET_NAMESPACE cTreeRowReference
+#define _SELF(s) RVAL2GTKTREEROWREFERENCE(s)
+
+static ID id_proxy;
+static ID id_model;
+static ID id_path;
+
+static VALUE
+rg_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE proxy, model, path;
+  GtkTreeRowReference* ref;
+
+  if (argc == 3){
+    rb_scan_args(argc, argv, "3", &proxy, &model, &path);
+    G_CHILD_SET(self, id_proxy, proxy);
+    ref = gtk_tree_row_reference_new_proxy(RVAL2GOBJ(proxy),
+                                           RVAL2GTKTREEMODEL(model), 
+                                           RVAL2GTKTREEPATH(path));
+  } else {
+    rb_scan_args(argc, argv, "2", &model, &path);
+    ref = gtk_tree_row_reference_new(RVAL2GTKTREEMODEL(model), 
+                                     RVAL2GTKTREEPATH(path));
+  }
+  if (ref == NULL)
+      rb_raise(rb_eArgError, "Invalid arguments were passed.");
+
+  G_CHILD_SET(self, id_model, model);
+  G_CHILD_SET(self, id_path, path);
+
+  G_INITIALIZE(self, ref);
+  return Qnil;
+}
+
+static VALUE
+rg_path(VALUE self)
+{
+    VALUE ret = GTKTREEPATH2RVAL(gtk_tree_row_reference_get_path(_SELF(self)));
+    G_CHILD_SET(self, id_path, ret);
+    return ret;
+}
+
+static VALUE
+rg_model(VALUE self)
+{
+    VALUE ret = GOBJ2RVAL(gtk_tree_row_reference_get_model(_SELF(self)));
+    G_CHILD_SET(self, id_model, ret);
+    return ret;
+}
+
+static VALUE
+rg_valid_p(VALUE self)
+{
+    return CBOOL2RVAL(gtk_tree_row_reference_valid(_SELF(self)));
+}
+
+static VALUE
+rg_s_inserted(VALUE self, VALUE proxy, VALUE path)
+{
+    gtk_tree_row_reference_inserted(RVAL2GOBJ(proxy), RVAL2GTKTREEPATH(path));
+    return self;
+}
+
+static VALUE
+rg_s_deleted(VALUE self, VALUE proxy, VALUE path)
+{
+    gtk_tree_row_reference_deleted(RVAL2GOBJ(proxy), RVAL2GTKTREEPATH(path));
+    return self;
+}
+
+static VALUE
+rg_s_reordered(VALUE self, VALUE rbproxy, VALUE rbpath, VALUE rbiter, VALUE rbnew_order)
+{
+    GObject *proxy = RVAL2GOBJ(rbproxy);
+    GtkTreePath *path = RVAL2GTKTREEPATH(rbpath);
+    GtkTreeIter *iter = RVAL2GTKTREEITER(rbiter);
+    /* TODO: How do we implement this check?
+    gint columns = gtk_tree_model_get_n_columns(proxy);
+    */
+    long n;
+    gint *new_order = RVAL2GINTS(rbnew_order, n);
+
+    /*
+    if (n != columns) {
+        g_free(new_order);
+
+        rb_raise(rb_eArgError,
+                 "new order array must contain same number of elements as the number of columns in the store: %ld != %d",
+                 n, columns);
+    }
+    */
+
+    gtk_tree_row_reference_reordered(proxy, path, iter, new_order);
+
+    g_free(new_order);
+
+    return self;
+}
+
+void
+Init_gtk_treerowreference(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_TREE_ROW_REFERENCE, "TreeRowReference", mGtk);
+
+    RG_DEF_METHOD(initialize, -1);
+    RG_DEF_METHOD(path, 0);
+    RG_DEF_METHOD(model, 0);
+    RG_DEF_METHOD_P(valid, 0);
+
+    RG_DEF_SMETHOD(inserted, 2);
+    RG_DEF_SMETHOD(deleted, 2);
+    RG_DEF_SMETHOD(reordered, 4);
+
+    id_proxy = rb_intern("proxy");
+    id_model = rb_intern("model");
+    id_path = rb_intern("path");
+}

data/ext/gtk3/rbgtk-tree-selection.c

@@ -0,0 +1,190 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002-2006 Masao Mutoh
+ *
+ *  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 "rbgtk3private.h"
+
+#define RG_TARGET_NAMESPACE cTreeSelection
+#define _SELF(s) (RVAL2GTKTREESELECTION(s))
+
+static gboolean
+selection_func(GtkTreeSelection *selection, GtkTreeModel *model, GtkTreePath *path, gboolean path_currently_selected, gpointer func)
+{
+    return RVAL2CBOOL(rb_funcall((VALUE)func, id_call, 4,
+                            GOBJ2RVAL(selection),
+                            GOBJ2RVAL(model),
+                            GTKTREEPATH2RVAL(path),
+                            CBOOL2RVAL(path_currently_selected)));
+}
+
+static VALUE
+rg_set_select_function(VALUE self)
+{
+    volatile VALUE func = rb_block_proc();
+    G_RELATIVE(self, func);
+    gtk_tree_selection_set_select_function(_SELF(self),
+                                    (GtkTreeSelectionFunc)selection_func,
+                                    (gpointer)func, NULL);
+    return self;
+}
+
+static VALUE
+rg_tree_view(VALUE self)
+{
+    return GOBJ2RVAL(gtk_tree_selection_get_tree_view(_SELF(self)));
+}
+
+static VALUE
+rg_selected(VALUE self)
+{
+    GtkTreeIter iter;
+    GtkTreeModel* model;
+    gboolean ret = gtk_tree_selection_get_selected(_SELF(self), &model, &iter);
+    iter.user_data3 = model;
+    return ret ? GTKTREEITER2RVAL(&iter) : Qnil;
+}
+
+static void
+foreach_func(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
+{
+    iter->user_data3 = model;
+    rb_funcall((VALUE)data, id_call, 3, GOBJ2RVAL(model),
+               GTKTREEPATH2RVAL(path), GTKTREEITER2RVAL(iter));
+}
+
+static VALUE
+rg_selected_each(VALUE self)
+{
+    volatile VALUE func = rb_block_proc();
+    gtk_tree_selection_selected_foreach(_SELF(self),
+                                        (GtkTreeSelectionForeachFunc)foreach_func,
+                                        (gpointer)func);
+    return self;
+}
+
+static VALUE
+rg_select_path(VALUE self, VALUE path)
+{
+    gtk_tree_selection_select_path(_SELF(self), RVAL2GTKTREEPATH(path));
+    return self;
+}
+
+static VALUE
+rg_unselect_path(VALUE self, VALUE path)
+{
+    gtk_tree_selection_unselect_path(_SELF(self), RVAL2GTKTREEPATH(path));
+    return self;
+}
+
+static VALUE
+rg_path_is_selected_p(VALUE self, VALUE path)
+{
+    return CBOOL2RVAL(gtk_tree_selection_path_is_selected(_SELF(self), RVAL2GTKTREEPATH(path)));
+}
+
+static VALUE
+rg_select_iter(VALUE self, VALUE iter)
+{
+    gtk_tree_selection_select_iter(_SELF(self), RVAL2GTKTREEITER(iter));
+    return self;
+}
+
+static VALUE
+rg_unselect_iter(VALUE self, VALUE iter)
+{
+    gtk_tree_selection_unselect_iter(_SELF(self), RVAL2GTKTREEITER(iter));
+    return self;
+}
+
+static VALUE
+rg_iter_is_selected_p(VALUE self, VALUE iter)
+{
+    return CBOOL2RVAL(gtk_tree_selection_iter_is_selected(_SELF(self), RVAL2GTKTREEITER(iter)));
+}
+
+static VALUE
+rg_select_all(VALUE self)
+{
+    gtk_tree_selection_select_all(_SELF(self));
+    return self;
+}
+
+static VALUE
+rg_unselect_all(VALUE self)
+{
+    gtk_tree_selection_unselect_all(_SELF(self));
+    return self;
+}
+
+static VALUE
+rg_select_range(VALUE self, VALUE start_path, VALUE end_path)
+{
+    gtk_tree_selection_select_range(_SELF(self), RVAL2GTKTREEPATH(start_path),
+                                    RVAL2GTKTREEPATH(end_path));
+    return self;
+}
+
+static VALUE
+rg_selected_rows(VALUE self)
+{
+    GtkTreeModel* model;
+    GList* list = gtk_tree_selection_get_selected_rows(_SELF(self), &model);
+    VALUE ret = BOXEDGLIST2RVAL(list, GTK_TYPE_TREE_PATH);
+    g_list_foreach(list, (GFunc)gtk_tree_path_free, (gpointer)NULL);
+    g_list_free(list);
+    return ret;
+}
+
+static VALUE
+rg_count_selected_rows(VALUE self)
+{
+    return INT2NUM(gtk_tree_selection_count_selected_rows(_SELF(self)));
+}
+
+static VALUE
+rg_unselect_range(VALUE self, VALUE start_path, VALUE end_path)
+{
+    gtk_tree_selection_unselect_range(_SELF(self), RVAL2GTKTREEPATH(start_path),
+                                      RVAL2GTKTREEPATH(end_path));
+    return self;
+}
+
+void
+Init_gtk_treeselection(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_TREE_SELECTION, "TreeSelection", mGtk);
+
+    RG_DEF_METHOD(set_select_function, 0);
+    RG_DEF_METHOD(tree_view, 0);
+    RG_DEF_METHOD(selected, 0);
+    RG_DEF_METHOD(selected_each, 0);
+    RG_DEF_METHOD(select_path, 1);
+    RG_DEF_METHOD(unselect_path, 1);
+    RG_DEF_METHOD_P(path_is_selected, 1);
+    RG_DEF_METHOD(select_iter, 1);
+    RG_DEF_METHOD(unselect_iter, 1);
+    RG_DEF_METHOD_P(iter_is_selected, 1);
+    RG_DEF_METHOD(select_all, 0);
+    RG_DEF_METHOD(unselect_all, 0);
+    RG_DEF_METHOD(select_range, 2);
+    RG_DEF_METHOD(selected_rows, 0);
+    RG_DEF_METHOD(count_selected_rows, 0);
+    RG_DEF_METHOD(unselect_range, 2);
+}