static int
pygtk_tree_model_row_setitem(PyGtkTreeModelRow *self, Py_ssize_t column,
PyObject *pyvalue)
{
gint n_columns;
GValue value = { 0, };
if (!GTK_IS_LIST_STORE(self->model) && !GTK_IS_TREE_STORE(self->model)) {
PyErr_SetString(PyExc_TypeError,
"can not set cells in this tree model");
return -1;
}
n_columns = gtk_tree_model_get_n_columns(self->model);
if (column < 0 || column >= n_columns) {
PyErr_SetString(PyExc_IndexError, "column index out of range");
return -1;
}
g_value_init(&value, gtk_tree_model_get_column_type(self->model, column));
if (pyg_value_from_pyobject(&value, pyvalue)) {
PyErr_SetString(PyExc_TypeError,
"value is of wrong type for this column");
return -1;
}
if (GTK_IS_LIST_STORE(self->model))
gtk_list_store_set_value(GTK_LIST_STORE(self->model), &self->iter,
column, &value);
else if (GTK_IS_TREE_STORE(self->model))
gtk_tree_store_set_value(GTK_TREE_STORE(self->model), &self->iter,
column, &value);
g_value_unset(&value);
return 0;
}
static void
edited_callback (GtkCellRendererText *renderer,
const gchar *path_string,
const gchar *new_text,
GtkTreeView *tree_view)
{
GtkTreeModel *model = NULL;
GtkTreeModelSort *sort_model = NULL;
GtkTreePath *path;
GtkTreeIter iter;
guint value = atoi (new_text);
g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
model = gtk_tree_view_get_model (tree_view);
if (GTK_IS_TREE_MODEL_SORT (model))
{
sort_model = GTK_TREE_MODEL_SORT (model);
model = gtk_tree_model_sort_get_model (sort_model);
}
if (model == NULL)
return;
if (sort_model)
{
g_warning ("FIXME implement conversion from TreeModelSort iter to child model iter");
return;
}
path = gtk_tree_path_new_from_string (path_string);
if (!gtk_tree_model_get_iter (model,
&iter, path))
{
g_warning ("%s: bad path?", G_STRLOC);
return;
}
gtk_tree_path_free (path);
if (GTK_IS_LIST_STORE (model))
{
gtk_list_store_set (GTK_LIST_STORE (model),
&iter,
4,
value,
-1);
}
else if (GTK_IS_TREE_STORE (model))
{
gtk_tree_store_set (GTK_TREE_STORE (model),
&iter,
4,
value,
-1);
}
else
g_warning ("don't know how to actually toggle value for model type %s",
g_type_name (G_TYPE_FROM_INSTANCE (model)));
}
/******************************************************************************
* gtk_TreeStoreIterDepth(tree, path_string)-->gint depth
******************************************************************************/
int
clip_GTK_TREESTOREITERDEPTH(ClipMachine * ClipMachineMemory)
{
C_object *cstree = _fetch_co_arg(ClipMachineMemory);
gchar *path = _clip_parc(ClipMachineMemory, 2);
GtkTreeIter iter;
gint ret;
CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJ(cstree, GTK_IS_TREE_STORE(cstree->object));
CHECKARG(2, CHARACTER_type_of_ClipVarType);
CHECKARG(3, CHARACTER_type_of_ClipVarType);
gtk_tree_model_get_iter(GTK_TREE_MODEL(GTK_TREE_STORE(cstree->object)), &iter, gtk_tree_path_new_from_string(path));
ret = gtk_tree_store_iter_depth(GTK_TREE_STORE(cstree->object), &iter);
_clip_retni(ClipMachineMemory, ret);
return 0;
err:
return 1;
}
/******************************************************************************
* gtk_TreeStoreIsAncestor(tree, ancestor_path_string, descendant_path_string)-->TRUE or FALSE
******************************************************************************/
int
clip_GTK_TREESTOREISANCESTOR(ClipMachine * ClipMachineMemory)
{
C_object *cstree = _fetch_co_arg(ClipMachineMemory);
gchar *ancestor = _clip_parc(ClipMachineMemory, 2);
gchar *descendant = _clip_parc(ClipMachineMemory, 3);
GtkTreeIter aiter;
GtkTreeIter diter;
gboolean ret;
CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJ(cstree, GTK_IS_TREE_STORE(cstree->object));
CHECKARG(2, CHARACTER_type_of_ClipVarType);
CHECKARG(3, CHARACTER_type_of_ClipVarType);
gtk_tree_model_get_iter(GTK_TREE_MODEL(GTK_TREE_STORE(cstree->object)), &aiter, gtk_tree_path_new_from_string(ancestor));
gtk_tree_model_get_iter(GTK_TREE_MODEL(GTK_TREE_STORE(cstree->object)), &diter, gtk_tree_path_new_from_string(descendant));
ret = gtk_tree_store_is_ancestor(GTK_TREE_STORE(cstree->object), &aiter, &diter);
_clip_retl(ClipMachineMemory, ret);
return 0;
err:
return 1;
}
int
_pygtk_tree_model_remove_row(GtkTreeModel *model, GtkTreeIter *iter)
{
GtkTreeModel *child;
GtkTreeIter citer;
if (GTK_IS_LIST_STORE(model)) {
gtk_list_store_remove(GTK_LIST_STORE(model), iter);
return 0;
}
if (GTK_IS_TREE_STORE(model)) {
gtk_tree_store_remove(GTK_TREE_STORE(model), iter);
return 0;
}
if (GTK_IS_TREE_MODEL_SORT(model)) {
child = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(model));
gtk_tree_model_sort_convert_iter_to_child_iter(
GTK_TREE_MODEL_SORT(model), &citer, iter);
return _pygtk_tree_model_remove_row(child, &citer);
}
if (GTK_IS_TREE_MODEL_FILTER(model)) {
child = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
gtk_tree_model_filter_convert_iter_to_child_iter(
GTK_TREE_MODEL_FILTER(model), &citer, iter);
return _pygtk_tree_model_remove_row(child, &citer);
}
PyErr_SetString(PyExc_TypeError,
"cannot remove rows in this tree model");
return -1;
}
/******************************************************************************
* gtk_TreeStoreSetColumnTypes(tree, ncolumns, type1, ...)
******************************************************************************/
int
clip_GTK_TREESTORESETCOLUMNTYPES(ClipMachine * ClipMachineMemory)
{
C_object *cstree = _fetch_co_arg(ClipMachineMemory);
gint ncolumns = _clip_parni(ClipMachineMemory, 2);
GType types[ncolumns];
ClipVar *utypes;
CHECKOPT(1, MAP_type_of_ClipVarType);
CHECKCOBJ(cstree, GTK_IS_TREE_STORE(cstree->object));
CHECKARG(2, NUMERIC_type_of_ClipVarType);
memset(types, 0, sizeof(types));
utypes = NEW(ClipVar);
__tree_store_set_types(ClipMachineMemory, ncolumns, types, utypes);
gtk_tree_store_set_column_types(GTK_TREE_STORE(cstree->object), ncolumns, types);
_clip_madd(ClipMachineMemory, &cstree->obj, HASH_UTYPES, utypes);
return 0;
err:
return 1;
}
int
clip_GTK_TREESTOREREORDER(ClipMachine * ClipMachineMemory)
{
C_object *cstree = _fetch_co_arg(ClipMachineMemory);
C_object *citer = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
ClipArrVar *arr = (ClipArrVar *) _clip_vptr(_clip_spar(ClipMachineMemory, 3));
gint n;
CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJ(cstree, GTK_IS_TREE_STORE(cstree->object));
CHECKCOBJ(citer, GTK_IS_TREE_ITER(citer->object));
CHECKARG(3, ARRAY_type_of_ClipVarType);
n = arr->count_of_ClipArrVar;
if (arr)
{
gint *order, i;
order = malloc(n * sizeof(gint));
for (i = 0; i < n; i++)
order[i] = arr->ClipVar_items_of_ClipArrVar[i].ClipNumVar_n_of_ClipVar.double_of_ClipNumVar;
gtk_tree_store_reorder(GTK_TREE_STORE(cstree->object), GTK_TREE_ITER(citer->object), order);
free(order);
}
return 0;
err:
return 1;
}
static gboolean
panel_addto_filter_func (GtkTreeModel *model,
GtkTreeIter *iter,
gpointer userdata)
{
PanelAddtoDialog *dialog;
PanelAddtoItemInfo *data;
dialog = (PanelAddtoDialog *) userdata;
if (!dialog->search_text || !dialog->search_text[0])
return TRUE;
gtk_tree_model_get (model, iter, COLUMN_DATA, &data, -1);
if (data == NULL)
return FALSE;
/* This is more a workaround than anything else: show all the root
* items in a tree store */
if (GTK_IS_TREE_STORE (model) &&
gtk_tree_store_iter_depth (GTK_TREE_STORE (model), iter) == 0)
return TRUE;
return (panel_g_utf8_strstrcase (data->name,
dialog->search_text) != NULL ||
panel_g_utf8_strstrcase (data->description,
dialog->search_text) != NULL);
}
/* Frees model returned from @mateweather_xml_load_locations. It contains allocated
WeatherLocation-s, thus this takes care of the freeing of that memory. */
void
mateweather_xml_free_locations (GtkTreeModel *locations)
{
if (locations && GTK_IS_TREE_STORE (locations)) {
gtk_tree_model_foreach (locations, free_locations, NULL);
g_object_unref (locations);
}
}
static void add_print_plugins(GtkTreeView *plugins_tree_view,Sven *sven)
{
GtkTreeIter iter;
GtkTreeIter selected;
GtkTreeModel *model;
GSList *l = NULL;
gtk_tree_store_clear(GTK_TREE_STORE (plugins_model));
for (l = sven->plugin->list; l; l=l->next)
{
SvenPluginPriv *plug = (SvenPluginPriv *)l->data;
if((plug!=NULL))
{
model = gtk_tree_view_get_model (plugins_tree_view);
if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (plugins_tree_view)), NULL, &selected))
{
if (GTK_IS_TREE_STORE (model))
{
gtk_tree_store_append (GTK_TREE_STORE (model), &iter, NULL);
print_plugins_list (&iter,plug->name,plug->filename,plug->enable);
}
}
else
{
if (GTK_IS_TREE_STORE (model))
{
gtk_tree_store_append (GTK_TREE_STORE (model), &iter, NULL);
print_plugins_list (&iter,plug->name,plug->filename,plug->enable);
}
}
}
}
gtk_widget_set_sensitive(prefs_plugins_config_wid, 0);
gtk_widget_set_sensitive(prefs_plugins_about_wid, 0);
gtk_label_set_markup(GTK_LABEL(infotext),_("Not information"));
}
static void remmina_main_save_expanded_group(RemminaMain *remminamain)
{
if (GTK_IS_TREE_STORE(remminamain->priv->file_model))
{
if (remminamain->priv->expanded_group)
{
remmina_string_array_free(remminamain->priv->expanded_group);
}
remminamain->priv->expanded_group = remmina_string_array_new();
gtk_tree_view_map_expanded_rows(GTK_TREE_VIEW(remminamain->priv->file_list),
(GtkTreeViewMappingFunc) remmina_main_save_expanded_group_func, remminamain);
}
}
/******************************************************************************
* gtk_TreeStoreInsertAfter(tree, parent_path_string/NULL, sibling_path_string/NULL, ncol, val, ....)-->path_string
******************************************************************************/
int
clip_GTK_TREESTOREINSERTAFTER(ClipMachine * ClipMachineMemory)
{
C_object *cstree = _fetch_co_arg(ClipMachineMemory);
gchar *parent = _clip_parc(ClipMachineMemory, 2);
gchar *sibling = _clip_parc(ClipMachineMemory, 3);
GtkTreeIter iter;
GtkTreeIter parentiter;
GtkTreeIter siblingiter;
GtkTreePath *path;
gchar *path_string;
CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJ(cstree, GTK_IS_TREE_STORE(cstree->object));
CHECKOPT(2, CHARACTER_type_of_ClipVarType);
CHECKOPT(3, CHARACTER_type_of_ClipVarType);
if (parent)
gtk_tree_model_get_iter(GTK_TREE_MODEL(GTK_TREE_STORE(cstree->object)),
&parentiter, gtk_tree_path_new_from_string(parent));
if (sibling)
gtk_tree_model_get_iter(GTK_TREE_MODEL(GTK_TREE_STORE(cstree->object)),
&siblingiter, gtk_tree_path_new_from_string(sibling));
gtk_tree_store_insert_after(GTK_TREE_STORE(cstree->object), &iter,
(parent ? &parentiter : NULL), (sibling ? &siblingiter : NULL));
__tree_store_set(ClipMachineMemory, &iter, 4);
path = gtk_tree_model_get_path(GTK_TREE_MODEL(GTK_TREE_STORE(cstree->object)), &iter);
path_string = gtk_tree_path_to_string(path);
_clip_retc(ClipMachineMemory, path_string);
g_free(path_string);
return 0;
err:
return 1;
}
int
clip_GTK_TREESTORECLEAR(ClipMachine * ClipMachineMemory)
{
C_object *cstree = _fetch_co_arg(ClipMachineMemory);
CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJ(cstree, GTK_IS_TREE_STORE(cstree->object));
gtk_tree_store_clear(GTK_TREE_STORE(cstree->object));
return 0;
err:
return 1;
}
static void
glade_tree_view_editor_load (GladeEditable * editable, GladeWidget * widget)
{
GladeTreeViewEditor *view_editor = GLADE_TREE_VIEW_EDITOR (editable);
GladeWidget *model_widget;
/* Chain up to default implementation */
parent_editable_iface->load (editable, widget);
/* load the embedded editable... */
if (view_editor->embed)
glade_editable_load (GLADE_EDITABLE (view_editor->embed), widget);
if (view_editor->embed_list_store && view_editor->embed_tree_store)
{
gtk_widget_hide (view_editor->no_model_message);
gtk_widget_hide (view_editor->embed_list_store);
gtk_widget_hide (view_editor->embed_tree_store);
glade_editable_load (GLADE_EDITABLE (view_editor->embed_list_store),
NULL);
glade_editable_load (GLADE_EDITABLE (view_editor->embed_tree_store),
NULL);
/* Finalize safe code here... */
if (widget && (model_widget = get_model_widget (widget)))
{
if (GTK_IS_LIST_STORE (glade_widget_get_object (model_widget)))
{
gtk_widget_show (view_editor->embed_list_store);
glade_editable_load (GLADE_EDITABLE
(view_editor->embed_list_store),
model_widget);
}
else if (GTK_IS_TREE_STORE (glade_widget_get_object (model_widget)))
{
gtk_widget_show (view_editor->embed_tree_store);
glade_editable_load (GLADE_EDITABLE
(view_editor->embed_tree_store),
model_widget);
}
else
gtk_widget_show (view_editor->no_model_message);
}
else
gtk_widget_show (view_editor->no_model_message);
}
}
int
clip_GTK_TREESTOREITERISVALID(ClipMachine * ClipMachineMemory)
{
C_object *cstree = _fetch_co_arg(ClipMachineMemory);
C_object *citer = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJ(cstree, GTK_IS_TREE_STORE(cstree->object));
CHECKCOBJ(citer, GTK_IS_TREE_ITER(citer->object));
gtk_tree_store_iter_is_valid(GTK_TREE_STORE(cstree->object), GTK_TREE_ITER(citer->object));
return 0;
err:
return 1;
}
int
clip_GTK_TREESTORESWAP(ClipMachine * ClipMachineMemory)
{
C_object *cstree = _fetch_co_arg(ClipMachineMemory);
C_object *citer1 = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
C_object *citer2 = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 3));
CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJ(cstree, GTK_IS_TREE_STORE(cstree->object));
CHECKCOBJ(citer1, GTK_IS_TREE_ITER(citer1->object));
CHECKCOBJ(citer2, GTK_IS_TREE_ITER(citer2->object));
gtk_tree_store_swap(GTK_TREE_STORE(cstree->object), GTK_TREE_ITER(citer1->object), GTK_TREE_ITER(citer2->object));
return 0;
err:
return 1;
}
int
clip_GTK_TREESTOREAPPEND(ClipMachine * ClipMachineMemory)
{
C_object *cstree = _fetch_co_arg(ClipMachineMemory);
gchar *parent = _clip_parc(ClipMachineMemory, 2);
GtkTreeIter iter;
GtkTreeIter parentiter;
GtkTreePath *path;
gchar *path_string;
CHECKCOBJ(cstree, GTK_IS_TREE_STORE(cstree->object));
CHECKOPT(2, CHARACTER_type_of_ClipVarType);
memset(&parentiter, 0, sizeof(parentiter));
if (parent)
gtk_tree_model_get_iter(GTK_TREE_MODEL(GTK_TREE_STORE(cstree->object)),
&parentiter, gtk_tree_path_new_from_string(parent));
gtk_tree_store_append(GTK_TREE_STORE(cstree->object), &iter, (parent ? &parentiter : NULL));
__tree_store_set(ClipMachineMemory, &iter, 3);
path = gtk_tree_model_get_path(GTK_TREE_MODEL(GTK_TREE_STORE(cstree->object)), &iter);
path_string = gtk_tree_path_to_string(path);
_clip_retc(ClipMachineMemory, path_string);
g_free(path_string);
return 0;
err:
return 1;
}
GtkWidget *
pgd_layers_create_widget (PopplerDocument *document)
{
PgdLayersDemo *demo;
GtkWidget *swindow;
GtkWidget *treeview;
GtkTreeModel *model;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkWidget *hpaned, *viewer;
demo = g_new0 (PgdLayersDemo, 1);
demo->doc = g_object_ref (document);
hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
viewer = pgd_layers_create_viewer (demo);
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
model = pgd_layers_create_model (document);
treeview = gtk_tree_view_new_with_model (model);
demo->treeview = treeview;
g_object_unref (model);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
0, "Layer",
renderer,
"markup", LAYERS_TITLE_COLUMN,
NULL);
g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
g_object_set (G_OBJECT (gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), 0)),
"expand", TRUE, NULL);
if (GTK_IS_TREE_STORE (model)) {
renderer = gtk_cell_renderer_toggle_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
1, "Show/Hide",
renderer,
"active", LAYERS_VISIBILITY_COLUMN,
"activatable", LAYERS_ENABLE_COLUMN,
"visible", LAYERS_SHOWTOGGLE_COLUMN,
NULL);
g_signal_connect (renderer, "toggled",
G_CALLBACK (pgd_layers_visibility_changed),
(gpointer)demo);
gtk_tree_view_column_set_clickable (gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), 1),
TRUE);
}
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)),
GTK_SELECTION_NONE);
gtk_container_add (GTK_CONTAINER (swindow), treeview);
gtk_widget_show (treeview);
gtk_paned_add1 (GTK_PANED (hpaned), swindow);
gtk_widget_show (swindow);
gtk_paned_add2 (GTK_PANED (hpaned), viewer);
gtk_widget_show (viewer);
gtk_paned_set_position (GTK_PANED (hpaned), 150);
g_object_weak_ref (G_OBJECT (hpaned),
(GWeakNotify)pgd_layers_free,
(gpointer)demo);
return hpaned;
}
static void
glade_sheet_editor_load (GladeEditable *editable, GladeWidget *widget)
{
GladeSheetEditor *view_editor = GLADE_SHEET_EDITOR (editable);
GladeWidget *model_widget;
/* Since we watch the project*/
if (view_editor->loaded_widget)
{
g_signal_handlers_disconnect_by_func (G_OBJECT (view_editor->loaded_widget->project),
G_CALLBACK (project_changed), view_editor);
/* The widget could die unexpectedly... */
g_object_weak_unref (G_OBJECT (view_editor->loaded_widget->project),
(GWeakNotify)project_finalized,
view_editor);
}
/* Mark our widget... */
view_editor->loaded_widget = widget;
if (view_editor->loaded_widget)
{
/* This fires for undo/redo */
g_signal_connect (G_OBJECT (view_editor->loaded_widget->project), "changed",
G_CALLBACK (project_changed), view_editor);
/* The widget/project could die unexpectedly... */
g_object_weak_ref (G_OBJECT (view_editor->loaded_widget->project),
(GWeakNotify) project_finalized,
view_editor);
}
/* load the embedded editable... */
if (view_editor->embed)
glade_editable_load (GLADE_EDITABLE (view_editor->embed), widget);
if (view_editor->embed_list_store && view_editor->embed_tree_store)
{
gtk_widget_hide (view_editor->no_model_message);
gtk_widget_hide (view_editor->embed_list_store);
gtk_widget_hide (view_editor->embed_tree_store);
glade_editable_load (GLADE_EDITABLE (view_editor->embed_list_store), NULL);
glade_editable_load (GLADE_EDITABLE (view_editor->embed_tree_store), NULL);
/* Finalize safe code here... */
if (widget && (model_widget = get_model_widget (widget)))
{
if (GTK_IS_LIST_STORE (model_widget->object))
{
gtk_widget_show (view_editor->embed_list_store);
glade_editable_load (GLADE_EDITABLE (view_editor->embed_list_store), model_widget);
}
else if (GTK_IS_TREE_STORE (model_widget->object))
{
gtk_widget_show (view_editor->embed_tree_store);
glade_editable_load (GLADE_EDITABLE (view_editor->embed_tree_store), model_widget);
}
else
gtk_widget_show (view_editor->no_model_message);
}
else
gtk_widget_show (view_editor->no_model_message);
}
}
int
_pygtk_tree_model_set_row(GtkTreeModel *model, GtkTreeIter *iter,
PyObject *items)
{
gint n_columns, i;
GtkTreeModel *child;
GtkTreeIter citer;
if (!GTK_IS_LIST_STORE(model) && !GTK_IS_TREE_STORE(model) &&
!GTK_IS_TREE_MODEL_SORT(model) && !GTK_IS_TREE_MODEL_FILTER(model)) {
PyErr_SetString(PyExc_TypeError,
"cannot set cells in this tree model");
return -1;
}
if (GTK_IS_TREE_MODEL_SORT(model)) {
child = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(model));
gtk_tree_model_sort_convert_iter_to_child_iter(
GTK_TREE_MODEL_SORT(model), &citer, iter);
return _pygtk_tree_model_set_row(child, &citer, items);
}
if (GTK_IS_TREE_MODEL_FILTER(model)) {
child = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
gtk_tree_model_filter_convert_iter_to_child_iter(
GTK_TREE_MODEL_FILTER(model), &citer, iter);
return _pygtk_tree_model_set_row(child, &citer, items);
}
if (!PySequence_Check(items)) {
PyErr_SetString(PyExc_TypeError, "expecting a sequence");
return -1;
}
n_columns = gtk_tree_model_get_n_columns(model);
if (PySequence_Length(items) != n_columns) {
PyErr_SetString(PyExc_ValueError, "row sequence has wrong length");
return -1;
}
for (i = 0; i < n_columns; i++) {
GValue value = { 0, };
PyObject *item;
item = PySequence_GetItem(items, i);
if (!item)
return -1;
g_value_init(&value, gtk_tree_model_get_column_type(model, i));
if (pyg_value_from_pyobject(&value, item)) {
Py_DECREF(item);
PyErr_SetString(PyExc_TypeError,
"value is of wrong type for this column");
return -1;
}
if (GTK_IS_LIST_STORE(model))
gtk_list_store_set_value(GTK_LIST_STORE(model), iter, i, &value);
else if (GTK_IS_TREE_STORE(model))
gtk_tree_store_set_value(GTK_TREE_STORE(model), iter, i, &value);
g_value_unset(&value);
Py_DECREF(item);
}
return 0;
}
/******************************************************************************
* gtk_TreeStoreSetValue(tree,path_string, ncol, val)
******************************************************************************/
int
clip_GTK_TREESTORESETVALUE(ClipMachine * ClipMachineMemory)
{
C_object *cstree = _fetch_co_arg(ClipMachineMemory);
gchar *path = _clip_parc(ClipMachineMemory, 2);
gint column = _clip_parni(ClipMachineMemory, 3);
ClipVar *val = _clip_par(ClipMachineMemory, 4);;
GtkTreeIter iter;
ClipArrVar *utypes;
GValue value;
C_object *cobj;
gchar *str;
int j, n;
double d;
CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJ(cstree, GTK_IS_TREE_STORE(cstree->object));
CHECKARG(2, CHARACTER_type_of_ClipVarType);
CHECKARG(3, NUMERIC_type_of_ClipVarType);
gtk_tree_model_get_iter(GTK_TREE_MODEL(GTK_TREE_STORE(cstree->object)), &iter, gtk_tree_path_new_from_string(path));
utypes = (ClipArrVar *) _clip_vptr(_clip_mget(ClipMachineMemory, &cstree->obj, HASH_UTYPES));
column--;
memset(&value, 0, sizeof(value));
switch ((int) utypes->ClipVar_items_of_ClipArrVar[column].ClipNumVar_n_of_ClipVar.double_of_ClipNumVar)
{
case TREE_TYPE_NUMERIC:
g_value_init(&value, G_TYPE_INT);
if (val->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType == NUMERIC_type_of_ClipVarType)
g_value_set_int(&value, (int) val->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar);
else
{
n = _clip_strtod(val->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf, &j);
g_value_set_int(&value, n);
}
break;
case TREE_TYPE_NUMERIC_FLOAT:
g_value_init(&value, G_TYPE_FLOAT);
if (val->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType == NUMERIC_type_of_ClipVarType)
g_value_set_float(&value, val->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar);
else
{
d = _clip_strtod(val->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf, &j);
g_value_set_float(&value, d);
}
break;
case TREE_TYPE_STRING:
str = val->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf;
LOCALE_TO_UTF(str);
g_value_init(&value, G_TYPE_STRING);
g_value_set_string(&value, str);
FREE_TEXT(str);
break;
case TREE_TYPE_LOGICAL:
g_value_init(&value, G_TYPE_BOOLEAN);
g_value_set_boolean(&value, val->ClipLogVar_l_of_ClipVar.value_of_ClipLogVar);
break;
case TREE_TYPE_DATE:
g_value_init(&value, G_TYPE_STRING);
if (val->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType == DATE_type_of_ClipVarType)
str = _clip_date_to_str(val->ClipLongVar_lv_of_ClipVar.long_of_ClipLongVar, ClipMachineMemory->date_format);
else
str =
_clip_date_to_str(_clip_str_to_date
(val->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf,
ClipMachineMemory->date_format, ClipMachineMemory->epoch), ClipMachineMemory->date_format);
g_value_set_string(&value, str);
break;
case TREE_TYPE_PIXBUF:
g_value_init(&value, GDK_TYPE_PIXBUF);
cobj = _fetch_cobject(ClipMachineMemory, val);
g_value_set_object(&value, cobj->object);
break;
}
gtk_tree_store_set_value(GTK_TREE_STORE(cstree->object), &iter, column, &value);
return 0;
err:
return 1;
}
int static
__tree_store_set(ClipMachine * ClipMachineMemory, GtkTreeIter * iter, gint startDataParam)
{
C_object *cstree = _fetch_co_arg(ClipMachineMemory);
ClipArrVar *utypes;
gint i;
CHECKCOBJ(cstree, GTK_IS_TREE_STORE(cstree->object));
utypes = (ClipArrVar *) _clip_vptr(_clip_mget(ClipMachineMemory, &cstree->obj, HASH_UTYPES));
for (i = startDataParam; i <= _clip_parinfo(ClipMachineMemory, 0); i += 2)
{
gint column = _clip_parni(ClipMachineMemory, i);
ClipVar *val;
GValue value;
C_object *cobj;
gchar *str;
int j, n;
double d;
CHECKARG(i, NUMERIC_type_of_ClipVarType);
if (column == -1)
break;
column--;
val = _clip_par(ClipMachineMemory, i + 1);
memset(&value, 0, sizeof(value));
switch ((int) utypes->ClipVar_items_of_ClipArrVar[column].ClipNumVar_n_of_ClipVar.double_of_ClipNumVar)
{
case TREE_TYPE_NUMERIC:
g_value_init(&value, G_TYPE_INT);
if (val->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType == NUMERIC_type_of_ClipVarType)
g_value_set_int(&value, (int) val->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar);
else
{
n = _clip_strtod(val->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf, &j);
g_value_set_int(&value, n);
}
break;
case TREE_TYPE_NUMERIC_FLOAT:
g_value_init(&value, G_TYPE_FLOAT);
if (val->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType == NUMERIC_type_of_ClipVarType)
g_value_set_float(&value, val->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar);
else
{
d = _clip_strtod(val->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf, &j);
g_value_set_float(&value, d);
}
break;
case TREE_TYPE_STRING:
str = val->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf;
LOCALE_TO_UTF(str);
g_value_init(&value, G_TYPE_STRING);
g_value_set_string(&value, str);
FREE_TEXT(str);
break;
case TREE_TYPE_LOGICAL:
g_value_init(&value, G_TYPE_BOOLEAN);
g_value_set_boolean(&value, val->ClipLogVar_l_of_ClipVar.value_of_ClipLogVar);
break;
case TREE_TYPE_DATE:
g_value_init(&value, G_TYPE_STRING);
if (val->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType == DATE_type_of_ClipVarType)
str = _clip_date_to_str(val->ClipLongVar_lv_of_ClipVar.long_of_ClipLongVar, ClipMachineMemory->date_format);
else
str =
_clip_date_to_str(_clip_str_to_date
(val->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf,
ClipMachineMemory->date_format, ClipMachineMemory->epoch), ClipMachineMemory->date_format);
g_value_set_string(&value, str);
break;
case TREE_TYPE_PIXBUF:
g_value_init(&value, GDK_TYPE_PIXBUF);
cobj = _fetch_cobject(ClipMachineMemory, val);
g_value_set_object(&value, cobj->object);
break;
}
gtk_tree_store_set_value(GTK_TREE_STORE(cstree->object), iter, column, &value);
}
return 0;
err:
return 1;
}
