static VALUE
lstore_move_before(VALUE self, VALUE iter, VALUE position)
{
gtk_list_store_move_before(_SELF(self), RVAL2GTKTREEITER(iter),
NIL_P(position) ? NULL : RVAL2GTKTREEITER(position));
return self;
}
static VALUE
rg_move_after(VALUE self, VALUE iter, VALUE position)
{
gtk_tree_store_move_after(_SELF(self), RVAL2GTKTREEITER(iter),
NIL_P(position) ? NULL : RVAL2GTKTREEITER(position));
return self;
}
static VALUE
rg_remove(VALUE self, VALUE iter)
{
G_CHILD_REMOVE(self, iter);
#if GTK_CHECK_VERSION(2,2,0)
return CBOOL2RVAL(gtk_tree_store_remove(_SELF(self), RVAL2GTKTREEITER(iter)));
#else
gtk_tree_store_remove(_SELF(self), RVAL2GTKTREEITER(iter));
return Qtrue;
#endif
}
static VALUE
rg_insert_before(VALUE self, VALUE parent, VALUE sibling)
{
VALUE ret;
GtkTreeIter iter;
GtkTreeStore* model = _SELF(self);
gtk_tree_store_insert_before(model, &iter,
NIL_P(parent) ? NULL : RVAL2GTKTREEITER(parent),
NIL_P(sibling) ? NULL : RVAL2GTKTREEITER(sibling));
iter.user_data3 = model;
ret = GTKTREEITER2RVAL(&iter);
G_CHILD_ADD(self, ret);
return ret;
}
static VALUE
rg_convert_iter_to_child_iter(VALUE self, VALUE 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
tvc_cell_set_cell_data(VALUE self, VALUE model, VALUE iter, VALUE is_expander, VALUE is_expanded)
{
gtk_tree_view_column_cell_set_cell_data(_SELF(self),
GTK_TREE_MODEL(RVAL2GOBJ(model)),
RVAL2GTKTREEITER(iter),
RVAL2CBOOL(is_expander),
RVAL2CBOOL(is_expanded));
return self;
}
static VALUE
rg_insert_after(VALUE self, VALUE sibling)
{
VALUE ret;
GtkTreeIter iter;
GtkListStore* model = _SELF(self);
gtk_list_store_insert_after(model, &iter, NIL_P(sibling) ? NULL : RVAL2GTKTREEITER(sibling));
iter.user_data3 = model;
ret = GTKTREEITER2RVAL(&iter);
return ret;
}
static VALUE
rg_get_value(VALUE self, VALUE iter, VALUE column)
{
GValue value = G_VALUE_INIT;
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;
}
static VALUE
rg_append(VALUE self, VALUE parent)
{
VALUE ret;
GtkTreeIter iter;
GtkTreeStore* model = _SELF(self);
gtk_tree_store_append(model, &iter,
NIL_P(parent)?NULL:RVAL2GTKTREEITER(parent));
iter.user_data3 = model;
ret = GTKTREEITER2RVAL(&iter);
G_CHILD_ADD(self, ret);
return ret;
}
static VALUE
tstore_reorder(VALUE self, VALUE parent, VALUE new_order)
{
gint i;
gint len = RARRAY_LEN(new_order);
gint* gnew_order = g_new(gint, len);
for (i = 0; i < len; i++){
gnew_order[i] = NUM2INT(RARRAY_PTR(new_order)[i]);
}
gtk_tree_store_reorder(_SELF(self), RVAL2GTKTREEITER(parent), gnew_order);
g_free(gnew_order);
return self;
}
static VALUE
rg_set_value(VALUE self, VALUE iter, VALUE column, VALUE value)
{
GType gtype = gtk_tree_model_get_column_type(RVAL2GTKTREEMODEL(self), NUM2INT(column));
GValue gval = G_VALUE_INIT;
g_value_init(&gval, gtype);
rbgobj_rvalue_to_gvalue(value, &gval);
G_CHILD_ADD(iter, value);
gtk_list_store_set_value(_SELF(self), RVAL2GTKTREEITER(iter), NUM2INT(column), &gval);
g_value_unset(&gval);
return self;
}
static VALUE
tstore_set_value(VALUE self, VALUE iter, VALUE column, VALUE value)
{
GType gtype = gtk_tree_model_get_column_type(GTK_TREE_MODEL(RVAL2GOBJ(self)), NUM2INT(column));
GValue gval = {0,};
g_value_init(&gval, gtype);
rbgobj_rvalue_to_gvalue(value, &gval);
G_CHILD_ADD(self, iter);
G_CHILD_ADD(iter, value);
gtk_tree_store_set_value(_SELF(self), RVAL2GTKTREEITER(iter), NUM2INT(column), &gval);
g_value_unset(&gval);
return self;
}
static VALUE
treerowref_s_reordered(VALUE self, VALUE proxy, VALUE path, VALUE iter, VALUE 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;
}
static VALUE
lstore_set_valuesv(VALUE self, VALUE iter, VALUE values)
{
GValue *g_values;
GtkListStore *store;
GtkTreeModel *model;
gint *g_columns;
gint i, length;
length = NUM2INT(rb_funcall(values, id_size, 0));
if (length == 0)
return self;
g_columns = ALLOCA_N(gint, length);
g_values = ALLOCA_N(GValue, length);
MEMZERO(g_values, GValue, length);
G_CHILD_ADD(self, iter);
store = _SELF(self);
model = GTK_TREE_MODEL(store);
if (RVAL2CBOOL(rb_obj_is_kind_of(values, rb_cHash))) {
hash_to_values(values, iter, model, g_columns, g_values, length);
}
else if (RVAL2CBOOL(rb_obj_is_kind_of(values, rb_cArray))) {
array_to_values(values, iter, model, g_columns, g_values, length);
}
else {
rb_raise(rb_eArgError, "must be array or hash of values");
}
gtk_list_store_set_valuesv(store, RVAL2GTKTREEITER(iter),
g_columns, g_values, length);
for (i = 0; i < length; i++)
g_value_unset(&g_values[i]);
return self;
}
static VALUE
rg_reorder(VALUE self, VALUE rbparent, VALUE rbnew_order)
{
GtkTreeStore *store = _SELF(self);
GtkTreeIter *parent = RVAL2GTKTREEITER(rbparent);
gint columns = gtk_tree_model_get_n_columns(GTK_TREE_MODEL(store));
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_store_reorder(store, parent, new_order);
g_free(new_order);
return self;
}
static VALUE
rg_rows_reordered(VALUE self, VALUE rbpath, VALUE rbiter, VALUE rbnew_order)
{
GtkTreeModel *proxy = _SELF(self);
GtkTreePath *path = RVAL2GTKTREEPATH(rbpath);
GtkTreeIter *iter = RVAL2GTKTREEITER(rbiter);
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_model_rows_reordered(proxy, path, iter, new_order);
g_free(new_order);
return self;
}
static VALUE
rg_swap(VALUE self, VALUE iter1, VALUE iter2)
{
gtk_tree_store_swap(_SELF(self), RVAL2GTKTREEITER(iter1), RVAL2GTKTREEITER(iter2));
return self;
}
static VALUE
rg_iter_is_valid_p(VALUE self, VALUE iter)
{
return (NIL_P(iter)) ? Qfalse :
CBOOL2RVAL(gtk_tree_store_iter_is_valid(_SELF(self), RVAL2GTKTREEITER(iter)));
}
static VALUE
rg_iter_depth(VALUE self, VALUE iter)
{
return INT2NUM(gtk_tree_store_iter_depth(_SELF(self), RVAL2GTKTREEITER(iter)));
}
static VALUE
rg_ancestor_p(VALUE self, VALUE iter, VALUE descendant)
{
return gtk_tree_store_is_ancestor(_SELF(self), RVAL2GTKTREEITER(iter),
RVAL2GTKTREEITER(descendant));
}
static VALUE
rg_set_active_iter(VALUE self, VALUE iter)
{
gtk_combo_box_set_active_iter(_SELF(self), RVAL2GTKTREEITER(iter));
return self;
}
static VALUE
rg_remove(VALUE self, VALUE iter)
{
G_CHILD_REMOVE(self, iter);
return CBOOL2RVAL(gtk_list_store_remove(_SELF(self), RVAL2GTKTREEITER(iter)));
}
static VALUE
rg_insert(int argc, VALUE *argv, VALUE self)
{
VALUE parent, position, values, ret;
GtkTreeIter iter;
GtkTreeStore* model = _SELF(self);
rb_scan_args(argc, argv, "21", &parent, &position, &values);
if (NIL_P(values)){
gtk_tree_store_insert(model, &iter,
NIL_P(parent) ? NULL : RVAL2GTKTREEITER(parent),
NUM2INT(position));
iter.user_data3 = model;
ret = GTKTREEITER2RVAL(&iter);
G_CHILD_ADD(self, ret);
} else {
#if GTK_CHECK_VERSION(2,10,0)
gint *c_columns;
GValue *c_values;
long size, i;
size = NUM2INT(rb_funcall(values, rb_intern("size"), 0));
c_columns = ALLOCA_N(gint, size);
c_values = ALLOCA_N(GValue, size);
if(TYPE(values)==T_ARRAY) {
for(i=0; i<size; i++) {
GType gtype;
GValue gval = G_VALUE_INIT;
c_columns[i] = i;
gtype = gtk_tree_model_get_column_type(GTK_TREE_MODEL(RVAL2GOBJ(self)),
c_columns[i]);
g_value_init(&gval, gtype);
rbgobj_rvalue_to_gvalue(rb_ary_shift(values), &gval);
c_values[i] = gval;
}
} else if(TYPE(values)==T_HASH) {
VALUE r_columns;
r_columns = rb_funcall(values, rb_intern("keys"), 0);
for(i=0; i<size; i++) {
GType gtype;
GValue gval = G_VALUE_INIT;
c_columns[i] = NUM2INT (rb_ary_entry(r_columns, i));
gtype = gtk_tree_model_get_column_type(GTK_TREE_MODEL(RVAL2GOBJ(self)),
c_columns[i]);
g_value_init(&gval, gtype);
rbgobj_rvalue_to_gvalue(rb_hash_aref(values, INT2NUM(c_columns[i])), &gval);
c_values[i] = gval;
}
} else {
rb_raise(rb_eArgError, "values must be of type Hash or Array");
}
gtk_tree_store_insert_with_valuesv(model, &iter,
NIL_P(parent) ? NULL : RVAL2GTKTREEITER(parent),
NUM2INT(position),
c_columns,
c_values,
size);
iter.user_data3 = model;
ret = GTKTREEITER2RVAL(&iter);
G_CHILD_ADD(self, ret);
for(i=0; i<size; i++) {
G_CHILD_ADD(ret, rbgobj_gvalue_to_rvalue(&(c_values[i])));
g_value_unset(&(c_values[i]));
}
#else
rb_warn("Gtk::TreeStore#insert(parent, position, values) requires GTK+-2.10.0 or later");
gtk_tree_store_insert(model, &iter,
NIL_P(parent) ? NULL : RVAL2GTKTREEITER(parent),
NUM2INT(position));
iter.user_data3 = model;
ret = GTKTREEITER2RVAL(&iter);
G_CHILD_ADD(self, ret);
#endif
}
return ret;
}
static VALUE
rg_row_has_child_toggled(VALUE self, VALUE path, VALUE iter)
{
gtk_tree_model_row_has_child_toggled(_SELF(self), RVAL2GTKTREEPATH(path), RVAL2GTKTREEITER(iter));
return self;
}
