gtk2 0.20.0

data/src/rbgtktreemodelfilter.c

@@ -0,0 +1,214 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtktreemodelfilter.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 16:07:32 $
+
+  Copyright (C) 2004,2005 Masao Mutoh
+************************************************/
+
+#include "global.h"
+                                                                                
+#if GTK_CHECK_VERSION(2,4,0)
+#define _SELF(s) (GTK_TREE_MODEL_FILTER(RVAL2GOBJ(s)))
+
+static ID id_child_model;
+static ID id_root;
+
+static VALUE
+treemodelfilter_initialize(argc, argv, self)
+    int argc;
+    VALUE* argv;
+    VALUE self;
+{
+    VALUE child_model, root;
+    GtkTreeModel* widget;
+
+    rb_scan_args(argc, argv, "11", &child_model, &root);
+
+    G_CHILD_SET(self, id_child_model, child_model);
+    if (NIL_P(root)){
+        widget = gtk_tree_model_filter_new(GTK_TREE_MODEL(RVAL2GOBJ(child_model)), 
+                                           (GtkTreePath*)NULL);
+    } else {
+        G_CHILD_SET(self, id_root, root);
+        widget = gtk_tree_model_filter_new(GTK_TREE_MODEL(RVAL2GOBJ(child_model)), 
+                                           (GtkTreePath*)RVAL2GTKTREEPATH(root));
+    }
+
+    G_INITIALIZE(self, widget);
+    return Qnil;
+}
+
+static gboolean
+visible_func(model, iter, func)
+    GtkTreeModel* model;
+    GtkTreeIter* iter;
+    gpointer func;
+{
+    VALUE ret;
+
+    iter->user_data3 = model;
+    ret = rb_funcall((VALUE)func, id_call, 2, GOBJ2RVAL(model), GTKTREEITER2RVAL(iter));
+    return RVAL2CBOOL(ret);
+}
+
+static VALUE
+treemodelfilter_set_visible_func(self)
+    VALUE self;
+{
+    VALUE func = rb_block_proc();
+    G_RELATIVE(self, func);
+    gtk_tree_model_filter_set_visible_func(_SELF(self), 
+                                           (GtkTreeModelFilterVisibleFunc)visible_func, 
+                                           (gpointer)func, NULL);
+    return self;
+}
+
+static void
+modify_func(model, iter, value, column, func)
+    GtkTreeModel* model;
+    GtkTreeIter* iter;
+    GValue* value;
+    gint column;
+    gpointer func;
+{
+    VALUE ret;
+    iter->user_data3 = model;
+    ret = rb_funcall((VALUE)func, id_call, 3, GOBJ2RVAL(model), GTKTREEITER2RVAL(iter),
+                     INT2NUM(column));
+    rbgobj_rvalue_to_gvalue(ret, value);
+}
+
+/*
+ * Should return value
+ *
+ * e.g. 
+ * filter.set_modify_func(String) do |model, iter, column|
+ *   "foo"
+ * end
+ */
+static VALUE
+treemodelfilter_set_modify_func(argc, argv, self)
+    int argc;
+    VALUE* argv;
+    VALUE  self;
+{
+    VALUE func = rb_block_proc();
+    gint i;
+    GType* types;
+
+    if (argc == 0) rb_raise(rb_eArgError, "need more than 1 class type.");
+
+    types = ALLOCA_N(GType, argc);  
+
+    G_RELATIVE(self, func);
+
+    for (i = 0; i < argc; i++){
+        types[i] = CLASS2GTYPE(argv[i]);
+    }
+    gtk_tree_model_filter_set_modify_func(_SELF(self),
+                                          argc, types, 
+                                          (GtkTreeModelFilterModifyFunc)modify_func,
+                                          (gpointer)func, NULL);
+    return self;
+}
+
+static VALUE
+treemodelfilter_set_visible_column(self, column)
+    VALUE self, column;
+{
+    gtk_tree_model_filter_set_visible_column(_SELF(self), NUM2INT(column));
+    return self;
+}
+
+static VALUE
+treemodelfilter_get_model(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(gtk_tree_model_filter_get_model(_SELF(self)));
+}
+
+static VALUE
+treemodelfilter_convert_child_iter_to_iter(self, child_iter)
+    VALUE self, child_iter;
+{
+    GtkTreeIter filter_iter;
+    GtkTreeModelFilter* modelfilter = _SELF(self);
+    gtk_tree_model_filter_convert_child_iter_to_iter(modelfilter, &filter_iter,
+                                                     RVAL2GTKTREEITER(child_iter));
+    filter_iter.user_data3 = gtk_tree_model_filter_get_model(modelfilter);
+    return GTKTREEITER2RVAL(&filter_iter);
+}
+
+static VALUE
+treemodelfilter_convert_iter_to_child_iter(self, filtered_iter)
+    VALUE self, filtered_iter;
+{
+    GtkTreeIter child_iter;
+    GtkTreeModelFilter* modelfilter = _SELF(self);
+    gtk_tree_model_filter_convert_iter_to_child_iter(modelfilter, &child_iter,
+                                                     RVAL2GTKTREEITER(filtered_iter));
+    child_iter.user_data3 = gtk_tree_model_filter_get_model(modelfilter);
+    return GTKTREEITER2RVAL(&child_iter);
+} 
+
+static VALUE
+treemodelfilter_convert_child_path_to_path(self, child_path)
+    VALUE self, child_path;
+{
+    return GTKTREEPATH2RVAL(gtk_tree_model_filter_convert_child_path_to_path(
+                             _SELF(self),
+                             RVAL2GTKTREEPATH(child_path)));
+}
+static VALUE
+treemodelfilter_convert_path_to_child_path(self, filter_path)
+    VALUE self, filter_path;
+{
+    return GTKTREEPATH2RVAL(gtk_tree_model_filter_convert_path_to_child_path(
+                             _SELF(self),
+                             RVAL2GTKTREEPATH(filter_path)));
+}
+
+static VALUE
+treemodelfilter_refilter(self)
+    VALUE self;
+{
+    gtk_tree_model_filter_refilter(_SELF(self));
+    return self;
+}
+
+static VALUE
+treemodelfilter_clear_cache(self)
+    VALUE self;
+{
+    gtk_tree_model_filter_clear_cache(_SELF(self));
+    return self;
+}
+#endif
+
+void 
+Init_gtk_treemodelfilter()
+{
+#if GTK_CHECK_VERSION(2,4,0)
+    VALUE tmf = G_DEF_CLASS(GTK_TYPE_TREE_MODEL_FILTER, "TreeModelFilter", mGtk);
+
+    id_child_model = rb_intern("child_model");
+    id_root = rb_intern("root");
+
+    rb_define_method(tmf, "initialize", treemodelfilter_initialize, -1);
+    rb_define_method(tmf, "set_visible_func", treemodelfilter_set_visible_func, 0);
+    rb_define_method(tmf, "set_modify_func", treemodelfilter_set_modify_func, -1);
+    rb_define_method(tmf, "set_visible_column", treemodelfilter_set_visible_column, 1);
+    rb_define_method(tmf, "model", treemodelfilter_get_model, 0);
+    rb_define_method(tmf, "convert_child_iter_to_iter", treemodelfilter_convert_child_iter_to_iter, 1);
+    rb_define_method(tmf, "convert_iter_to_child_iter", treemodelfilter_convert_iter_to_child_iter, 1);
+    rb_define_method(tmf, "convert_child_path_to_path", treemodelfilter_convert_child_path_to_path, 1);
+    rb_define_method(tmf, "convert_path_to_child_path", treemodelfilter_convert_path_to_child_path, 1);
+    rb_define_method(tmf, "refilter", treemodelfilter_refilter, 0);
+    rb_define_method(tmf, "clear_cache", treemodelfilter_clear_cache, 0);
+    G_DEF_SETTERS(tmf);
+#endif
+}

data/src/rbgtktreemodelsort.c

@@ -0,0 +1,113 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtktreemodelsort.c -
+
+  $Author: mutoh $
+  $Date: 2005/11/06 04:44:24 $
+
+  Copyright (C) 2003-2005 Masao Mutoh
+************************************************/
+
+#include "global.h"
+
+#define _SELF(s) (GTK_TREE_MODEL_SORT(RVAL2GOBJ(s)))
+
+static ID id_model;
+
+static VALUE
+tmodelsort_initialize(self, model)
+    VALUE self, model;
+{
+    G_CHILD_SET(self, id_model, model);
+    G_INITIALIZE(self, 
+                 gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(RVAL2GOBJ(model))));
+    return Qnil;
+}
+
+static VALUE
+tmodelsort_convert_child_path_to_path(self, child_path)
+    VALUE self, child_path;
+{
+    return GTKTREEPATH2RVAL(gtk_tree_model_sort_convert_child_path_to_path(
+                             _SELF(self),
+                             RVAL2GTKTREEPATH(child_path)));
+}
+
+static VALUE
+tmodelsort_convert_child_iter_to_iter(self, child_iter)
+    VALUE self, child_iter;
+{
+    GtkTreeIter sort_iter;
+    GtkTreeModelSort* modelsort = _SELF(self);
+    gtk_tree_model_sort_convert_child_iter_to_iter(modelsort, &sort_iter,
+                                                   RVAL2GTKTREEITER(child_iter));
+    sort_iter.user_data3 = gtk_tree_model_sort_get_model(modelsort);
+    return GTKTREEITER2RVAL(&sort_iter);
+}
+
+static VALUE
+tmodelsort_convert_path_to_child_path(self, sorted_path)
+    VALUE self, sorted_path;
+{
+    return GTKTREEPATH2RVAL(gtk_tree_model_sort_convert_path_to_child_path(
+                             _SELF(self),
+                             RVAL2GTKTREEPATH(sorted_path)));
+}
+
+static VALUE
+tmodelsort_convert_iter_to_child_iter(self, sorted_iter)
+    VALUE self, sorted_iter;
+{
+    GtkTreeIter child_iter;
+    GtkTreeModelSort* modelsort = _SELF(self);
+    gtk_tree_model_sort_convert_iter_to_child_iter(modelsort, &child_iter,
+                                                   RVAL2GTKTREEITER(sorted_iter));
+    child_iter.user_data3 = gtk_tree_model_sort_get_model(modelsort);
+    return GTKTREEITER2RVAL(&child_iter);
+} 
+
+static VALUE
+tmodelsort_reset_default_sort_func(self)
+    VALUE self;
+{
+    gtk_tree_model_sort_reset_default_sort_func(_SELF(self));
+    return self;
+}
+
+static VALUE
+tmodelsort_clear_cache(self)
+    VALUE self;
+{
+    gtk_tree_model_sort_clear_cache(_SELF(self));
+    return self;
+}
+
+#if GTK_CHECK_VERSION(2,2,0)
+static VALUE
+tmodelsort_iter_is_valid(self, iter)
+    VALUE self, iter;
+{
+    return CBOOL2RVAL(gtk_tree_model_sort_iter_is_valid(_SELF(self), RVAL2GTKTREEITER(iter)));
+}
+#endif
+
+void 
+Init_gtk_tmodelsort()
+{
+    VALUE gTMSort = G_DEF_CLASS(GTK_TYPE_TREE_MODEL_SORT, "TreeModelSort", mGtk);
+
+    id_model = rb_intern("model");
+
+    rb_define_method(gTMSort, "initialize", tmodelsort_initialize, 1);
+    rb_define_method(gTMSort, "convert_child_path_to_path", tmodelsort_convert_child_path_to_path, 1);
+    rb_define_method(gTMSort, "convert_child_iter_to_iter", tmodelsort_convert_child_iter_to_iter, 1);
+    rb_define_method(gTMSort, "convert_path_to_child_path", tmodelsort_convert_path_to_child_path, 1);
+    rb_define_method(gTMSort, "convert_iter_to_child_iter", tmodelsort_convert_iter_to_child_iter, 1);
+    rb_define_method(gTMSort, "reset_default_sort_func", tmodelsort_reset_default_sort_func, 0);
+    rb_define_method(gTMSort, "clear_cache", tmodelsort_clear_cache, 0);
+#if GTK_CHECK_VERSION(2,2,0)
+    rb_define_method(gTMSort, "iter_is_valid?", tmodelsort_iter_is_valid, 1);
+#endif
+
+}

data/src/rbgtktreepath.c

@@ -0,0 +1,195 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtktreepath.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 14:27:10 $
+
+  Copyright (C) 2002-2004 Ruby-GNOME2 Project Team
+  Copyright (C) 2003,2004 Masao Mutoh
+************************************************/
+
+#include "global.h"
+
+#define _SELF(s) ((GtkTreePath*)RVAL2BOXED(s, GTK_TYPE_TREE_PATH))
+
+static ID id_equal;
+
+static VALUE
+treepath_initialize(argc, argv, self)
+    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
+treepath_to_string(self)
+    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
+treepath_append_index(self, index)
+    VALUE self, index;
+{
+    gtk_tree_path_append_index(_SELF(self), NUM2INT(index));
+    return self;
+}
+
+static VALUE
+treepath_prepend_index(self, index)
+    VALUE self, index;
+{
+    gtk_tree_path_prepend_index(_SELF(self), NUM2INT(index));
+    return self;
+}
+
+static VALUE
+treepath_get_depth(self)
+    VALUE self;
+{
+    return INT2NUM(gtk_tree_path_get_depth(_SELF(self)));
+}
+
+static VALUE
+treepath_get_indices(self)
+    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
+treepath_compare(self, other)
+    VALUE self, other;
+{
+    return INT2NUM(gtk_tree_path_compare(_SELF(self), _SELF(other)));
+}
+
+static VALUE
+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
+treepath_next(self)
+    VALUE self;
+{
+    gtk_tree_path_next(_SELF(self));
+    return self;
+}
+
+static VALUE
+treepath_prev(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(gtk_tree_path_prev(_SELF(self)));
+}
+
+static VALUE
+treepath_up(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(gtk_tree_path_up(_SELF(self)));
+}
+
+static VALUE
+treepath_down(self)
+    VALUE self;
+{
+    gtk_tree_path_down(_SELF(self));
+    return Qtrue;
+}
+
+static VALUE
+treepath_is_ancestor(self, descendant)
+    VALUE self, descendant;
+{
+    return CBOOL2RVAL(gtk_tree_path_is_ancestor(_SELF(self), _SELF(descendant)));
+}
+
+static VALUE
+treepath_is_descendant(self, ancestor)
+    VALUE self, ancestor;
+{
+    return CBOOL2RVAL(gtk_tree_path_is_descendant(_SELF(self), _SELF(ancestor)));
+}
+
+void 
+Init_gtk_treepath()
+{
+    VALUE gTreepath = G_DEF_CLASS(GTK_TYPE_TREE_PATH, "TreePath", mGtk);
+
+    id_equal = rb_intern("==");
+
+    rb_define_method(gTreepath, "initialize", treepath_initialize, -1);
+    rb_define_method(gTreepath, "to_str", treepath_to_string, 0);
+    rb_define_alias(gTreepath, "to_s", "to_str");
+    rb_define_method(gTreepath, "append_index", treepath_append_index, 1);
+    rb_define_method(gTreepath, "prepend_index", treepath_prepend_index, 1);
+    rb_define_method(gTreepath, "depth", treepath_get_depth, 0);
+    rb_define_method(gTreepath, "indices", treepath_get_indices, 0);
+    rb_define_method(gTreepath, "<=>", treepath_compare, 1);
+    rb_define_method(gTreepath, "==", treepath_equal, 1);
+    rb_define_method(gTreepath, "next!", treepath_next, 0);
+    rb_define_method(gTreepath, "prev!", treepath_prev, 0);
+    rb_define_method(gTreepath, "up!", treepath_up, 0);
+    rb_define_method(gTreepath, "down!", treepath_down, 0);
+    rb_define_method(gTreepath, "ancestor?", treepath_is_ancestor, 1);
+    rb_define_method(gTreepath, "descendant?", treepath_is_descendant, 1);
+}