gtk2 0.20.0

data/src/rbgtktreerowreference.c

@@ -0,0 +1,168 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtktreerowreference.c -
+
+  $Author: mutoh $
+  $Date: 2006/10/21 16:58:00 $
+
+  Copyright (C) 2002-2006 Masao Mutoh
+************************************************/
+
+#include "global.h"
+
+/*****************************************/
+
+#ifndef GTK_TYPE_TREE_ROW_REFERENCE
+static GtkTreeRowReference*
+treerowref_copy(ref)
+    const GtkTreeRowReference* ref;
+{
+    return (GtkTreeRowReference*)ref;
+}
+
+GType
+rbgtk_tree_row_reference_get_type()
+{
+  static GType our_type = 0;
+  if (our_type == 0)
+    our_type = g_boxed_type_register_static ("GtkTreeRowReference",
+                    (GBoxedCopyFunc)treerowref_copy,
+                    (GBoxedFreeFunc)gtk_tree_row_reference_free);
+  return our_type;
+}
+
+GtkTreeRowReference *
+rbgtk_get_tree_row_reference(obj)
+    VALUE obj;
+{
+    return (GtkTreeRowReference*)RVAL2BOXED(obj, GTK_TYPE_TREE_ROW_REFERENCE);
+}
+#endif
+
+/*****************************************/
+
+#define _SELF(s) RVAL2TREEROWREFERENCE(s)
+
+/*****************************************/
+
+static ID id_proxy;
+static ID id_model;
+static ID id_path;
+
+static VALUE
+treerowref_initialize(argc, argv, self)
+    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),
+                                           GTK_TREE_MODEL(RVAL2GOBJ(model)), 
+                                           RVAL2GTKTREEPATH(path));
+  } else {
+    rb_scan_args(argc, argv, "2", &model, &path);
+    ref = gtk_tree_row_reference_new(GTK_TREE_MODEL(RVAL2GOBJ(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
+treerowref_get_path(self)
+    VALUE self;
+{
+    VALUE ret = GTKTREEPATH2RVAL(gtk_tree_row_reference_get_path(_SELF(self)));
+    G_CHILD_SET(self, id_path, ret);
+    return ret;
+}
+
+#if GTK_CHECK_VERSION(2,8,0)
+static VALUE
+treerowref_get_model(self)
+    VALUE self;
+{
+    VALUE ret = GOBJ2RVAL(gtk_tree_row_reference_get_model(_SELF(self)));
+    G_CHILD_SET(self, id_model, ret);
+    return ret;
+}
+#endif
+
+static VALUE
+treerowref_valid(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(gtk_tree_row_reference_valid(_SELF(self)));
+}
+
+static VALUE
+treerowref_s_inserted(self, proxy, path)
+    VALUE self, proxy, path;
+{
+    gtk_tree_row_reference_inserted(RVAL2GOBJ(proxy), RVAL2GTKTREEPATH(path));
+    return self;
+}
+
+static VALUE
+treerowref_s_deleted(self, proxy, path)
+    VALUE self, proxy, path;
+{
+    gtk_tree_row_reference_deleted(RVAL2GOBJ(proxy), RVAL2GTKTREEPATH(path));
+    return self;
+}
+
+static VALUE
+treerowref_s_reordered(self, proxy, path, iter, new_orders)
+    VALUE self, proxy, path, iter, new_orders;
+{
+    gint i, len;
+    gint* orders;
+
+    Check_Type(new_orders, T_ARRAY);
+
+    len = RARRAY_LEN(new_orders);
+    orders = ALLOCA_N(gint, len);
+
+    for (i = 0; i < len; i++) {
+        orders[i] = RARRAY_PTR(new_orders)[i];
+    }
+  
+    gtk_tree_row_reference_reordered(RVAL2GOBJ(proxy), RVAL2GTKTREEPATH(path), 
+                                     RVAL2GTKTREEITER(iter), orders);
+    return self;
+}
+
+void 
+Init_gtk_treerowreference()
+{
+    id_proxy = rb_intern("proxy");
+    id_model = rb_intern("model");
+    id_path = rb_intern("path");
+
+    VALUE gTreeref = G_DEF_CLASS(GTK_TYPE_TREE_ROW_REFERENCE, "TreeRowReference", mGtk);
+  
+    rb_define_method(gTreeref, "initialize", treerowref_initialize, -1);
+    rb_define_method(gTreeref, "path", treerowref_get_path, 0);
+#if GTK_CHECK_VERSION(2,8,0)
+    rb_define_method(gTreeref, "model", treerowref_get_model, 0);
+#endif
+    rb_define_method(gTreeref, "valid?", treerowref_valid, 0);
+    
+    rb_define_singleton_method(gTreeref, "inserted", treerowref_s_inserted, 2);
+    rb_define_singleton_method(gTreeref, "deleted", treerowref_s_deleted, 2);
+    rb_define_singleton_method(gTreeref, "reordered", treerowref_s_reordered, 4);
+}
+

data/src/rbgtktreeselection.c

@@ -0,0 +1,235 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtktreeselection.c -
+
+  $Author: ggc $ 
+  $Date: 2007/07/13 16:07:32 $
+
+  Copyright (C) 2002-2006 Masao Mutoh
+************************************************/
+
+#include "global.h"
+
+#define _SELF(s) (GTK_TREE_SELECTION(RVAL2GOBJ(s)))
+#define RVAL2TREEMODEL(s) (GTK_TREE_MODEL(RVAL2GOBJ(s)))
+
+static VALUE
+treeselection_set_mode(self, type)
+    VALUE self, type;
+{
+    gtk_tree_selection_set_mode(_SELF(self), RVAL2GENUM(type, GTK_TYPE_SELECTION_MODE));
+    return self;
+}
+
+static VALUE
+treeselection_get_mode(self)
+    VALUE self;
+{
+    return GENUM2RVAL(gtk_tree_selection_get_mode(_SELF(self)), GTK_TYPE_SELECTION_MODE);
+}
+
+static gboolean
+selection_func(selection, model, path, path_currently_selected, 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
+treeselection_set_select_function(self)
+    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;
+}
+
+/* We don't need this(?)
+gpointer    gtk_tree_selection_get_user_data
+(GtkTreeSelection *selection);
+*/
+
+static VALUE
+treeselection_get_tree_view(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(gtk_tree_selection_get_tree_view(_SELF(self)));
+}
+
+static VALUE
+treeselection_get_selected(self)
+    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(model, path, iter, data)
+    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
+treeselection_selected_foreach(self)
+    VALUE self;
+{
+    volatile VALUE func = rb_block_proc();
+    gtk_tree_selection_selected_foreach(_SELF(self), 
+                                        (GtkTreeSelectionForeachFunc)foreach_func, 
+                                        (gpointer)func);
+    return self;
+}
+
+static VALUE
+treeselection_select_path(self, path)
+    VALUE self, path;
+{
+    gtk_tree_selection_select_path(_SELF(self), RVAL2GTKTREEPATH(path));
+    return self;
+}
+
+static VALUE
+treeselection_unselect_path(self, path)
+    VALUE self, path;
+{
+    gtk_tree_selection_unselect_path(_SELF(self), RVAL2GTKTREEPATH(path));
+    return self;
+}
+
+static VALUE
+treeselection_path_is_selected(self, path)
+    VALUE self, path;
+{
+    return CBOOL2RVAL(gtk_tree_selection_path_is_selected(_SELF(self), RVAL2GTKTREEPATH(path)));
+}
+
+static VALUE
+treeselection_select_iter(self, iter)
+    VALUE self, iter;
+{
+    gtk_tree_selection_select_iter(_SELF(self), RVAL2GTKTREEITER(iter));
+    return self;
+}
+
+static VALUE
+treeselection_unselect_iter(self, iter)
+    VALUE self, iter;
+{
+    gtk_tree_selection_unselect_iter(_SELF(self), RVAL2GTKTREEITER(iter));
+    return self;
+}
+
+static VALUE
+treeselection_iter_is_selected(self, iter)
+    VALUE self, iter;
+{
+    return CBOOL2RVAL(gtk_tree_selection_iter_is_selected(_SELF(self), RVAL2GTKTREEITER(iter)));
+}
+
+static VALUE
+treeselection_select_all(self)
+    VALUE self;
+{
+    gtk_tree_selection_select_all(_SELF(self));
+    return self;
+}
+
+static VALUE
+treeselection_unselect_all(self)
+    VALUE self;
+{
+    gtk_tree_selection_unselect_all(_SELF(self));
+    return self;
+}
+
+static VALUE
+treeselection_select_range(self, start_path, end_path)
+    VALUE self, start_path, end_path;
+{
+    gtk_tree_selection_select_range(_SELF(self), RVAL2GTKTREEPATH(start_path), 
+                                    RVAL2GTKTREEPATH(end_path));
+    return self;
+}
+
+#if GTK_CHECK_VERSION(2,2,0)
+static VALUE
+treeselection_get_selected_rows(self)
+    VALUE self;
+{
+    GtkTreeModel* model;
+    GList* list = gtk_tree_selection_get_selected_rows(_SELF(self), &model);
+    VALUE ret = GLIST2ARY2(list, GTK_TYPE_TREE_PATH);
+    g_list_foreach(list, (GFunc)gtk_tree_path_free, (gpointer)NULL);
+    g_list_free(list);
+    return ret;
+}
+
+static VALUE
+treeselection_count_selected_rows(self)
+    VALUE self;
+{
+    return INT2NUM(gtk_tree_selection_count_selected_rows(_SELF(self)));
+}
+
+static VALUE
+treeselection_unselect_range(self, start_path, end_path)
+    VALUE self, start_path, end_path;
+{
+    gtk_tree_selection_unselect_range(_SELF(self), RVAL2GTKTREEPATH(start_path), 
+                                      RVAL2GTKTREEPATH(end_path));
+    return self;
+}
+#endif
+
+void
+Init_gtk_treeselection()
+{
+    VALUE gTs = G_DEF_CLASS(GTK_TYPE_TREE_SELECTION, "TreeSelection", mGtk); 
+    
+    rb_define_method(gTs, "set_mode", treeselection_set_mode, 1);
+    rb_define_method(gTs, "mode", treeselection_get_mode, 0);
+    rb_define_method(gTs, "set_select_function", treeselection_set_select_function, 0);
+    rb_define_method(gTs, "tree_view", treeselection_get_tree_view, 0);
+    rb_define_method(gTs, "selected", treeselection_get_selected, 0);
+    rb_define_method(gTs, "selected_each", treeselection_selected_foreach, 0);
+    rb_define_method(gTs, "select_path", treeselection_select_path, 1);
+    rb_define_method(gTs, "unselect_path", treeselection_unselect_path, 1);
+    rb_define_method(gTs, "path_is_selected?", treeselection_path_is_selected, 1);
+    rb_define_method(gTs, "select_iter", treeselection_select_iter, 1);
+    rb_define_method(gTs, "unselect_iter", treeselection_unselect_iter, 1);
+    rb_define_method(gTs, "iter_is_selected?", treeselection_iter_is_selected, 1);
+    rb_define_method(gTs, "select_all", treeselection_select_all, 0);
+    rb_define_method(gTs, "unselect_all", treeselection_unselect_all, 0);
+    rb_define_method(gTs, "select_range", treeselection_select_range, 2);
+#if GTK_CHECK_VERSION(2,2,0)
+    rb_define_method(gTs, "selected_rows", treeselection_get_selected_rows, 0);
+    rb_define_method(gTs, "count_selected_rows", treeselection_count_selected_rows, 0);
+    rb_define_method(gTs, "unselect_range", treeselection_unselect_range, 2);
+#endif
+
+    G_DEF_SETTERS(gTs);
+}
+
+

data/src/rbgtktreesortable.c

@@ -0,0 +1,127 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtktreesortable.c -
+
+  $Author: ggc $
+
+  $Date: 2007/07/13 16:07:32 $
+
+  Copyright (C) 2002,2003 Ruby-GNOME2 Project Team
+************************************************/
+
+#include "global.h"
+
+#define _SELF(s)	(GTK_TREE_SORTABLE(RVAL2GOBJ(s)))
+
+static VALUE
+treesortable_sort_column_changed(self)
+    VALUE self;
+{
+    gtk_tree_sortable_sort_column_changed(_SELF(self));
+    return self;
+}
+
+static VALUE
+treesortable_get_sort_column_id(self)
+    VALUE self;
+{
+    gint sort_column_id;
+    GtkSortType order;
+
+    if (gtk_tree_sortable_get_sort_column_id(_SELF(self), &sort_column_id,
+					     &order)) {
+	VALUE ary;
+
+	ary = rb_ary_new2(2);
+	rb_ary_push(ary, INT2NUM(sort_column_id));
+	rb_ary_push(ary, GENUM2RVAL(order, GTK_TYPE_SORT_TYPE));
+	return ary;
+    } else {
+	return Qnil;	/* XXX: or something else? exception? */
+    }
+}
+
+static VALUE
+treesortable_set_sort_column_id(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    gint sort_column_id;
+    GtkSortType order;
+
+    if (argc == 1 || argc == 2) {
+	sort_column_id = NUM2INT(argv[0]);
+	order = (argc == 2) ? RVAL2GENUM(argv[1], GTK_TYPE_SORT_TYPE) : GTK_SORT_ASCENDING;
+    } else {
+	rb_raise(rb_eArgError, "need 1 or 2 arguments.");
+    }
+
+    gtk_tree_sortable_set_sort_column_id(_SELF(self), sort_column_id,
+					 order);
+    return self;
+}
+
+static gint
+sort_func(model, a, b, func)
+    GtkTreeModel *model;
+    GtkTreeIter *a, *b;
+    gpointer func;
+{
+    a->user_data3 = model;
+    b->user_data3 = model;
+    return NUM2INT(rb_funcall((VALUE)func, id_call, 2, GTKTREEITER2RVAL(a),
+			      GTKTREEITER2RVAL(b)));
+}
+
+static VALUE
+treesortable_set_sort_func(self, sort_column_id)
+    VALUE self, sort_column_id;
+{
+    volatile VALUE func = rb_block_proc();
+    G_RELATIVE(self, func);
+    gtk_tree_sortable_set_sort_func(_SELF(self), NUM2INT(sort_column_id),
+				    (GtkTreeIterCompareFunc)sort_func,
+				    (gpointer)func, NULL);
+    return self;
+}
+
+static VALUE
+treesortable_set_default_sort_func(self)
+    VALUE self;
+{
+    volatile VALUE func = rb_block_proc();
+    G_RELATIVE(self, func);
+    gtk_tree_sortable_set_default_sort_func(_SELF(self),
+					    (GtkTreeIterCompareFunc)sort_func,
+					    (gpointer)func, NULL);
+    return self;
+}
+
+static VALUE
+treesortable_has_default_sort_func(self)
+    VALUE self;
+{
+    return RVAL2CBOOL(gtk_tree_sortable_has_default_sort_func(_SELF(self)));
+}
+
+void
+Init_gtk_treesortable()
+{
+    VALUE mts = G_DEF_INTERFACE(GTK_TYPE_TREE_SORTABLE, "TreeSortable", mGtk);
+
+    rb_define_method(mts, "sort_column_changed", treesortable_sort_column_changed, 0);
+    rb_define_method(mts, "sort_column_id", treesortable_get_sort_column_id, 0);
+    rb_define_method(mts, "set_sort_column_id", treesortable_set_sort_column_id, -1);
+    rb_define_method(mts, "set_sort_func", treesortable_set_sort_func, 1);
+    rb_define_method(mts, "set_default_sort_func", treesortable_set_default_sort_func, 0);
+    rb_define_method(mts, "has_default_sort_func?", treesortable_has_default_sort_func, 0);
+
+    G_DEF_SETTERS(mts);
+
+    rb_undef_method(mts, "sort_func=");
+    rb_define_const(mts, "DEFAULT_SORT_COLUMN_ID", GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID);
+}
+
+/* vim: set sts=4 sw=4 ts=8: */