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;
}
/*
If m is not a base TreeModel type (ie, is a filter or sorter) then
convert OP to a TreePath for the base and return it.
The return value must be freed by the caller.
*/
static GtkTreePath *
get_base_tree_path (GtkTreeModel *m, GtkTreePath *op)
{
GtkTreePath *p = gtk_tree_path_copy (op);
while ( ! PSPPIRE_IS_DICT (m))
{
GtkTreePath *oldp = p;
if (GTK_IS_TREE_MODEL_FILTER (m))
{
p = gtk_tree_model_filter_convert_path_to_child_path (GTK_TREE_MODEL_FILTER (m), oldp);
m = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (m));
}
else if (GTK_IS_TREE_MODEL_SORT (m))
{
p = gtk_tree_model_sort_convert_path_to_child_path (GTK_TREE_MODEL_SORT (m), oldp);
m = gtk_tree_model_sort_get_model (GTK_TREE_MODEL_SORT (m));
}
else
{
g_error ("Unexpected model type: %s", G_OBJECT_TYPE_NAME (m));
}
gtk_tree_path_free (oldp);
}
return p;
}
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)));
}
GncOwner *
gnc_tree_view_owner_get_owner_from_iter (GtkTreeModel *s_model,
GtkTreeIter *s_iter)
{
GtkTreeModel *model, *f_model;
GtkTreeIter iter, f_iter;
GncOwner *owner;
g_return_val_if_fail (GTK_IS_TREE_MODEL_SORT(s_model), NULL);
g_return_val_if_fail (s_iter != NULL, NULL);
ENTER("model %p, iter %p", s_model, s_iter);
gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT(s_model),
&f_iter,
s_iter);
f_model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(s_model));
gtk_tree_model_filter_convert_iter_to_child_iter (
GTK_TREE_MODEL_FILTER(f_model), &iter, &f_iter);
model = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(f_model));
owner = gnc_tree_model_owner_get_owner (
GNC_TREE_MODEL_OWNER(model), &iter);
LEAVE("owner %p (%s)", owner, gncOwnerGetName (owner));
return owner;
}
/* Try to find our key store given a tree model */
static CryptUIKeyStore*
key_store_from_model (GtkTreeModel *model)
{
/* Sort models are what's set on the tree */
g_assert (GTK_IS_TREE_MODEL_SORT (model));
g_assert (CRYPTUI_IS_KEY_STORE (model));
return CRYPTUI_KEY_STORE (model);
}
static void col_source_helper(GtkTreeViewColumn *col, GtkCellRenderer *cell,
GtkTreeModel *s_model, GtkTreeIter *s_iter,
gpointer _col_source_cb)
{
GncOwner *owner;
gchar *text;
GncTreeViewOwnerColumnSource col_source_cb;
g_return_if_fail (GTK_IS_TREE_MODEL_SORT (s_model));
col_source_cb = (GncTreeViewOwnerColumnSource) _col_source_cb;
owner = gnc_tree_view_owner_get_owner_from_iter(s_model, s_iter);
text = col_source_cb(owner, col, cell);
g_object_set (G_OBJECT (cell), "text", text, "xalign", 1.0, NULL);
g_free(text);
}
static gboolean
set_selection_foreach (GtkTreeModel *model,
GtkTreePath *path,
GtkTreeIter *iter,
gpointer user_data)
{
gboolean selection = GPOINTER_TO_INT (user_data);
GtkTreeModel *actual_model;
GtkTreeIter real_iter;
if (GTK_IS_TREE_MODEL_FILTER (model))
{
actual_model = 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),
&real_iter, iter);
}
else if (GTK_IS_TREE_MODEL_SORT (model))
{
actual_model = 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),
&real_iter, iter);
}
else
{
actual_model = model;
real_iter = *iter;
}
if (GTK_IS_LIST_STORE (actual_model))
{
gtk_list_store_set (GTK_LIST_STORE (actual_model), &real_iter,
GD_MAIN_COLUMN_SELECTED, selection,
-1);
}
else
{
gtk_tree_store_set (GTK_TREE_STORE (actual_model), &real_iter,
GD_MAIN_COLUMN_SELECTED, selection,
-1);
}
return FALSE;
}
/* This function implements a custom mapping between an owner's KVP
* and the cell renderer's 'text' property. */
static void
owner_cell_kvp_data_func (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell,
GtkTreeModel *s_model,
GtkTreeIter *s_iter,
gpointer key)
{
GncOwner *owner;
kvp_frame * frame;
g_return_if_fail (GTK_IS_TREE_MODEL_SORT (s_model));
owner = gnc_tree_view_owner_get_owner_from_iter(s_model, s_iter);
frame = gncOwnerGetSlots(owner);
g_object_set (G_OBJECT (cell),
"text", kvp_frame_get_string(frame, (gchar *)key),
"xalign", 0.0,
NULL);
}
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;
}
