gtk2 0.20.0

data/src/rbgtktreedragsource.c

@@ -0,0 +1,19 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtktreedragsource.c -
+
+  $Author: mutoh $
+
+  $Date: 2003/07/11 19:39:08 $
+
+  Copyright (C) 2003 Masao Mutoh
+************************************************/
+
+#include "global.h"
+
+void
+Init_gtk_treedragsource()
+{
+    G_DEF_INTERFACE(GTK_TYPE_TREE_DRAG_SOURCE, "TreeDragSource", mGtk);
+}

data/src/rbgtktreeiter.c

@@ -0,0 +1,259 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtktreeiter.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 14:27:10 $
+
+  Copyright (C) 2002-2004 Ruby-GNOME2 Project Team
+  Copyright (C) 2002,2003 Masao Mutoh
+************************************************/
+
+#include "global.h"
+
+#define _SELF(i) ((GtkTreeIter*)RVAL2BOXED(i, GTK_TYPE_TREE_ITER))
+
+void
+rbgtk_register_treeiter_set_value_func(gtype, func)
+    GType gtype;
+    rbgtkiter_set_value_func func;
+{
+    rb_hash_aset(treeiter_set_value_table, INT2NUM(gtype), 
+                 Data_Wrap_Struct(rb_cData, NULL, NULL, func));
+}
+
+static VALUE
+treeiter_first(self)
+    VALUE self;
+{
+    GtkTreeIter* iter = _SELF(self);
+    GtkTreeModel* model = (GtkTreeModel*)iter->user_data3;
+    VALUE ret = CBOOL2RVAL(gtk_tree_model_get_iter_first(model, iter));
+    iter->user_data3 = model;
+    return ret;
+}
+
+static VALUE
+treeiter_next(self)
+    VALUE self;
+{
+    GtkTreeIter* iter = _SELF(self);
+    GtkTreeModel* model = (GtkTreeModel*)iter->user_data3;
+    gboolean ret = gtk_tree_model_iter_next(model, iter);
+    if (! ret){
+        gtk_tree_model_get_iter_first(model, iter);
+    }
+    iter->user_data3 = model;
+
+    return CBOOL2RVAL(ret);
+}
+
+static VALUE
+treeiter_get_value(self, column)
+    VALUE self, column;
+{
+    GValue value = {0, };
+    GtkTreeIter* iter = _SELF(self);
+    GtkTreeModel* model = (GtkTreeModel*)iter->user_data3;
+    VALUE ret = Qnil;
+
+    gtk_tree_model_get_value(model, iter, NUM2INT(column), &value);
+    if (G_VALUE_TYPE(&value) != G_TYPE_INVALID){
+        ret = GVAL2RVAL(&value);
+        g_value_unset(&value);
+    } 
+    return ret;
+}
+
+static VALUE
+treeiter_children(self)
+    VALUE self;
+{
+    GtkTreeIter child;
+    GtkTreeIter* iter = _SELF(self);
+    GtkTreeModel* model = (GtkTreeModel*)iter->user_data3;
+    gboolean ret = gtk_tree_model_iter_children(model, &child, iter);
+    child.user_data3 = model;
+    return ret ? GTKTREEITER2RVAL(&child) : Qnil;
+}
+
+static VALUE
+treeiter_get_path(self)
+    VALUE self;
+{
+    VALUE retval = Qnil;
+    GtkTreeIter* iter = _SELF(self);
+    GtkTreeModel* model = (GtkTreeModel*)iter->user_data3;
+    GtkTreePath* path = gtk_tree_model_get_path(model, iter);
+    retval= GTKTREEPATH2RVAL(path);
+    gtk_tree_path_free(path);
+    return retval;
+}
+
+static VALUE
+treeiter_has_child(self)
+    VALUE self;
+{
+    GtkTreeIter* iter = _SELF(self);
+    GtkTreeModel* model = (GtkTreeModel*)iter->user_data3;
+    return CBOOL2RVAL(gtk_tree_model_iter_has_child(model, iter));
+}
+
+static VALUE
+treeiter_n_children(self)
+    VALUE self;
+{
+    GtkTreeIter* iter = _SELF(self);
+    GtkTreeModel* model = (GtkTreeModel*)iter->user_data3;
+    return INT2NUM(gtk_tree_model_iter_n_children(model, iter));
+}
+
+static VALUE
+treeiter_nth_child(self, n)
+    VALUE self, n;
+{
+    GtkTreeIter child;
+    GtkTreeIter* iter = _SELF(self);
+    GtkTreeModel* model = (GtkTreeModel*)iter->user_data3;
+    gboolean ret = gtk_tree_model_iter_nth_child(model, &child, iter, NUM2INT(n));
+    child.user_data3 = model;
+    return ret ? GTKTREEITER2RVAL(&child) : Qnil;
+}
+
+static VALUE
+treeiter_parent(self)
+    VALUE self;
+{
+    GtkTreeIter parent;
+    GtkTreeIter* iter = _SELF(self);
+    GtkTreeModel* model = (GtkTreeModel*)iter->user_data3;
+    gboolean ret = gtk_tree_model_iter_parent(model, &parent, iter);
+    parent.user_data3 = model;
+    return ret ? GTKTREEITER2RVAL(&parent) : Qnil;
+}
+
+static VALUE
+treeiter_set_value(self, column, value)
+    VALUE self, column, value;
+{
+    GtkTreeIter* iter = _SELF(self);
+    GtkTreeModel* model = (GtkTreeModel*)iter->user_data3;
+
+    VALUE obj = rb_hash_aref(treeiter_set_value_table, INT2NUM(G_TYPE_FROM_INSTANCE(model)));
+    rbgtkiter_set_value_func func;
+    GType gtype = gtk_tree_model_get_column_type(model, NUM2INT(column));
+    GValue gval = {0,};
+
+    if (NIL_P(obj))
+        rb_raise(rb_eTypeError, "Gtk::TreeModel is invalid.");
+
+    Data_Get_Struct(obj, void, func);
+
+    g_value_init(&gval, gtype);
+    rbgobj_rvalue_to_gvalue(value, &gval);
+    func(model, iter, NUM2INT(column), &gval);
+    g_value_unset(&gval);
+
+    return self;
+}
+
+static VALUE
+treeiter_set_value_eql(self, column, value)
+    VALUE self, column, value;
+{
+    treeiter_set_value(self, column, value);
+    return value;
+}
+
+static VALUE
+treeiter_eql(self, other)
+    VALUE self, other;
+{
+    gint i, num1, num2;
+    GtkTreeIter* iter1 = _SELF(self);
+    GtkTreeIter* iter2;
+    GtkTreeModel* model1;
+    GtkTreeModel* model2;
+    GtkTreePath* path1;
+    GtkTreePath* path2;
+
+    if (!rb_obj_is_kind_of(other, GTYPE2CLASS(GTK_TYPE_TREE_ITER)))
+        return Qfalse;
+
+    iter2 = _SELF(other);
+
+    model1 = (GtkTreeModel*)iter1->user_data3;
+    model2 = (GtkTreeModel*)iter2->user_data3;
+    if (model1 != model2) return Qfalse;
+
+    num1 = gtk_tree_model_get_n_columns(model1);
+    num2 = gtk_tree_model_get_n_columns(model2);
+    if (num1 != num2) return Qfalse;
+
+    path1 = gtk_tree_model_get_path(model1, iter1);
+    path2 = gtk_tree_model_get_path(model2, iter2);
+    if (gtk_tree_path_compare(path1, path2) != 0) {
+        gtk_tree_path_free(path1);
+        gtk_tree_path_free(path2);
+        return Qfalse;
+    } else {
+        gtk_tree_path_free(path1);
+        gtk_tree_path_free(path2);
+    }
+
+    for (i = 0; i < num1; i++){
+        GValue gval1 = {0,};
+        GValue gval2 = {0,};
+        VALUE ret1, ret2;
+        gtk_tree_model_get_value(model1, iter1, i, &gval1);
+        gtk_tree_model_get_value(model2, iter2, i, &gval2);
+        
+        ret1 = GVAL2RVAL(&gval1);
+        ret2 = GVAL2RVAL(&gval2);
+        g_value_unset(&gval1);
+        g_value_unset(&gval2);
+        if (rb_equal(ret1, ret2) == Qfalse) 
+            return Qfalse;
+    }
+    return Qtrue;
+}
+
+#if GTK_CHECK_VERSION(2,2,0)
+static VALUE
+treeiter_to_string(self)
+    VALUE self;
+{
+    GtkTreeIter* iter = _SELF(self);
+    GtkTreeModel* model = (GtkTreeModel*)iter->user_data3;
+
+    gchar* s = gtk_tree_model_get_string_from_iter (model, iter);
+    VALUE result = CSTR2RVAL(s);
+    g_free(s);
+    return result;
+}
+#endif
+
+void 
+Init_gtk_treeiter()
+{
+    VALUE gTreeIter = G_DEF_CLASS(GTK_TYPE_TREE_ITER, "TreeIter", mGtk);
+
+    rb_define_method(gTreeIter, "first!", treeiter_first, 0);
+    rb_define_method(gTreeIter, "next!", treeiter_next, 0);
+    rb_define_method(gTreeIter, "get_value", treeiter_get_value, 1);
+    rb_define_alias(gTreeIter, "[]", "get_value");
+    rb_define_method(gTreeIter, "first_child", treeiter_children, 0);
+    rb_define_method(gTreeIter, "path", treeiter_get_path, 0);
+    rb_define_method(gTreeIter, "has_child?", treeiter_has_child, 0);
+    rb_define_method(gTreeIter, "n_children", treeiter_n_children, 0);
+    rb_define_method(gTreeIter, "nth_child", treeiter_nth_child, 1);
+    rb_define_method(gTreeIter, "parent", treeiter_parent, 0);
+    rb_define_method(gTreeIter, "set_value", treeiter_set_value, 2);
+    rb_define_method(gTreeIter, "[]=", treeiter_set_value_eql, 2);
+    rb_define_method(gTreeIter, "==", treeiter_eql, 1);
+#if GTK_CHECK_VERSION(2,2,0)
+    rb_define_method(gTreeIter, "to_str", treeiter_to_string, 0);
+    rb_define_alias(gTreeIter, "to_s", "to_str");
+#endif
+}

data/src/rbgtktreemodel.c

@@ -0,0 +1,256 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtktreemodel.c -
+
+  $Author: mutoh $
+  $Date: 2005/11/06 04:44:24 $
+
+  Copyright (C) 2002,2003 Masao Mutoh
+************************************************/
+
+#include "global.h"
+
+#define _SELF(s) (GTK_TREE_MODEL(RVAL2GOBJ(s)))
+
+static VALUE
+treemodel_get_flags(self)
+    VALUE self;
+{
+    return GFLAGS2RVAL(gtk_tree_model_get_flags(_SELF(self)), GTK_TYPE_TREE_MODEL_FLAGS);
+}
+
+static VALUE
+treemodel_get_n_columns(self)
+    VALUE self;
+{
+    return INT2NUM(gtk_tree_model_get_n_columns(_SELF(self)));
+}
+
+static VALUE
+treemodel_get_column_type(self, index)
+    VALUE self;
+{
+    return GTYPE2CLASS(gtk_tree_model_get_column_type(_SELF(self), 
+                                                      NUM2INT(index)));
+}
+
+static VALUE
+treemodel_get_iter_first(self)
+    VALUE self;
+{
+    VALUE val = Qnil;
+    GtkTreeIter iter;
+    GtkTreeModel* model = _SELF(self);
+    gboolean ret = (gtk_tree_model_get_iter_first(model, &iter));
+    iter.user_data3 = model;
+
+    if (ret) {
+        val = GTKTREEITER2RVAL(&iter);
+        G_CHILD_ADD(self, val);
+    }
+    
+    return val;
+}
+
+static VALUE
+treemodel_get_iter(self, path)
+    VALUE self, path;
+{
+    VALUE val = Qnil;
+    GtkTreeIter iter;
+    gboolean ret;
+    GtkTreeModel* model = _SELF(self);
+
+    if (TYPE(path) == T_STRING){
+        ret = gtk_tree_model_get_iter_from_string(model, &iter, 
+                                                  RVAL2CSTR(path));
+    } else {
+        ret = gtk_tree_model_get_iter(model, &iter, 
+                                      RVAL2GTKTREEPATH(path));
+    } 
+    iter.user_data3 = model;
+
+    if (ret) {
+        val = GTKTREEITER2RVAL(&iter);
+        G_CHILD_ADD(self, val);
+    }
+    
+    return val;
+}
+
+static VALUE
+treemodel_get_value(self, iter, column)
+    VALUE self, iter, column;
+{
+    GValue value = {0, };
+    VALUE ret = Qnil;
+    gtk_tree_model_get_value(_SELF(self), RVAL2GTKTREEITER(iter), NUM2INT(column), &value);
+    if (G_VALUE_TYPE(&value) != G_TYPE_INVALID){
+        ret = GVAL2RVAL(&value);
+        g_value_unset(&value);
+    } 
+    return ret;
+}
+
+/* These methods may be neededless.
+void        gtk_tree_model_ref_node (GtkTreeModel *tree_model,
+                                             GtkTreeIter *iter);
+void        gtk_tree_model_unref_node (GtkTreeModel *tree_model,
+                                             GtkTreeIter *iter);
+*/
+
+/* XXXX
+void        gtk_tree_model_get_valist (GtkTreeModel *tree_model,
+                                             GtkTreeIter *iter,
+                                             va_list var_args);
+*/
+
+static gboolean
+treemodel_foreach_func(model, path, iter, func)
+    GtkTreeModel* model;
+    GtkTreePath* path;
+    GtkTreeIter* iter;
+    gpointer func;
+{
+    iter->user_data3 = model;
+    rb_yield(rb_ary_new3(3, GOBJ2RVAL(model), GTKTREEPATH2RVAL(path), GTKTREEITER2RVAL(iter)));
+    return FALSE;
+}
+
+static VALUE
+treemodel_foreach(self)
+    VALUE self;
+{
+    gtk_tree_model_foreach(_SELF(self), 
+                           (GtkTreeModelForeachFunc)treemodel_foreach_func, 
+                           (gpointer)NULL);
+    return self;
+}
+
+static VALUE
+treemodel_row_changed(self, path, iter)
+    VALUE self, path, iter;
+{
+    gtk_tree_model_row_changed(_SELF(self), RVAL2GTKTREEPATH(path), RVAL2GTKTREEITER(iter));
+    return self;
+}
+
+static VALUE
+treemodel_row_inserted(self, path, iter)
+    VALUE self, path, iter;
+{
+    gtk_tree_model_row_inserted(_SELF(self), RVAL2GTKTREEPATH(path), RVAL2GTKTREEITER(iter));
+    return self;
+}
+
+static VALUE
+treemodel_row_has_child_toggled(self, path, iter)
+    VALUE self, path, iter;
+{
+    gtk_tree_model_row_has_child_toggled(_SELF(self), RVAL2GTKTREEPATH(path), RVAL2GTKTREEITER(iter));
+    return self;
+}
+
+static VALUE
+treemodel_row_deleted(self, path)
+    VALUE self, path;
+{
+    gtk_tree_model_row_deleted(_SELF(self), RVAL2GTKTREEPATH(path));
+    return self;
+}
+
+static VALUE
+treemodel_rows_reordered(self, path, iter, new_orders)
+    VALUE self, 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_model_rows_reordered(_SELF(self), RVAL2GTKTREEPATH(path), RVAL2GTKTREEITER(iter), orders);
+    return self;
+}
+
+static VALUE
+treemodel_iter_is_valid(self, iter)
+    VALUE self, iter;
+{
+    return Qtrue;
+}
+
+static VALUE
+signal_func(num, values)
+    guint num;
+    const GValue* values;
+{
+    GtkTreeModel* model = g_value_get_object(&values[0]);
+    GtkTreePath* path = g_value_get_boxed(&values[1]);
+    GtkTreeIter* iter = g_value_get_boxed(&values[2]);
+    iter->user_data3 = model;
+    
+    return rb_ary_new3(3, GOBJ2RVAL(model), GTKTREEPATH2RVAL(path), GTKTREEITER2RVAL(iter));
+}
+
+static VALUE
+signal_rows_reordered_func(num, values)
+    guint num;
+    const GValue* values;
+{
+    GtkTreeModel* model = g_value_get_object(&values[0]);
+    GtkTreePath* path = g_value_get_boxed(&values[1]);
+    GtkTreeIter* iter = g_value_get_boxed(&values[2]);
+    gint* new_orders = (gint*)g_value_get_pointer(&values[3]);
+    gint len = gtk_tree_model_iter_n_children(model, iter);
+    VALUE orders = Qnil;
+    int i;
+
+    iter->user_data3 = model;
+
+    orders = rb_ary_new2(len);
+    for (i = 0; i < len; i++, new_orders++) {
+        rb_ary_push(orders, INT2NUM(*new_orders));
+    }
+    return rb_ary_new3(4, GOBJ2RVAL(model), GTKTREEPATH2RVAL(path), GTKTREEITER2RVAL(iter), orders);
+}
+
+void 
+Init_gtk_treemodel()
+{
+    VALUE mTreeModel = G_DEF_INTERFACE(GTK_TYPE_TREE_MODEL, "TreeModel", mGtk);
+
+    rb_define_method(mTreeModel, "flags", treemodel_get_flags, 0);
+    rb_define_method(mTreeModel, "n_columns", treemodel_get_n_columns, 0);
+    rb_define_method(mTreeModel, "get_column_type", treemodel_get_column_type, 1);
+    rb_define_method(mTreeModel, "iter_first", treemodel_get_iter_first, 0);
+    rb_define_method(mTreeModel, "get_iter", treemodel_get_iter, 1);
+    rb_define_method(mTreeModel, "get_value", treemodel_get_value, 2);
+    rb_define_method(mTreeModel, "each", treemodel_foreach, 0);
+    rb_define_method(mTreeModel, "row_changed", treemodel_row_changed, 2);
+    rb_define_method(mTreeModel, "row_inserted", treemodel_row_inserted, 2);
+    rb_define_method(mTreeModel, "row_has_child_toggled", treemodel_row_has_child_toggled, 2);
+    rb_define_method(mTreeModel, "row_deleted", treemodel_row_deleted, 1);
+    rb_define_method(mTreeModel, "rows_reordered", treemodel_rows_reordered, 3);
+    rb_define_method(mTreeModel, "iter_is_valid?", treemodel_iter_is_valid, 1);
+
+    /* GtkTreeModelFlags */
+    G_DEF_CLASS(GTK_TYPE_TREE_MODEL_FLAGS, "Flags", mTreeModel);
+    G_DEF_CONSTANTS(mTreeModel, GTK_TYPE_TREE_MODEL_FLAGS, "GTK_TREE_MODEL_");
+
+    G_DEF_SIGNAL_FUNC(mTreeModel, "row_changed", (GValToRValSignalFunc)signal_func);
+    G_DEF_SIGNAL_FUNC(mTreeModel, "row_inserted", (GValToRValSignalFunc)signal_func);
+    G_DEF_SIGNAL_FUNC(mTreeModel, "row_has_child_toggled", (GValToRValSignalFunc)signal_func);
+    G_DEF_SIGNAL_FUNC(mTreeModel, "rows_reordered", (GValToRValSignalFunc)signal_rows_reordered_func);
+
+    G_DEF_SETTERS(mTreeModel);
+}
+
+