QModelIndex
gtk_combo_box_get_index(GtkComboBox *box)
{
GtkTreeIter filter_iter;
GtkTreeIter child_iter;
GtkTreeModel *filter_model = gtk_combo_box_get_model(box);
GtkTreeModel *model = filter_model;
GtkTreeIter *iter = NULL;
if (GTK_IS_TREE_MODEL_FILTER(filter_model))
model = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(filter_model));
if (gtk_combo_box_get_active_iter(box, &filter_iter)) {
if (GTK_IS_TREE_MODEL_FILTER(filter_model)) {
gtk_tree_model_filter_convert_iter_to_child_iter(
GTK_TREE_MODEL_FILTER(filter_model),
&child_iter,
&filter_iter);
iter = &child_iter;
} else {
iter = &filter_iter;
}
if (GTK_IS_Q_TREE_MODEL(model))
return gtk_q_tree_model_get_source_idx(GTK_Q_TREE_MODEL(model), iter);
}
return QModelIndex();
}
/*
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;
}
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;
}
void
um_password_dialog_set_user (UmPasswordDialog *um,
UmUser *user)
{
GdkPixbuf *pixbuf;
GtkTreeModel *model;
if (um->user) {
g_object_unref (um->user);
um->user = NULL;
}
if (user) {
um->user = g_object_ref (user);
um->using_ecryptfs = is_using_ecryptfs (um_user_get_user_name (user));
pixbuf = um_user_render_icon (user, FALSE, 48);
gtk_image_set_from_pixbuf (GTK_IMAGE (um->user_icon), pixbuf);
g_object_unref (pixbuf);
gtk_label_set_label (GTK_LABEL (um->user_name),
um_user_get_real_name (user));
gtk_entry_set_text (GTK_ENTRY (um->password_entry), "");
gtk_entry_set_text (GTK_ENTRY (um->verify_entry), "");
gtk_entry_set_text (GTK_ENTRY (um->normal_hint_entry), "");
gtk_entry_set_text (GTK_ENTRY (um->old_password_entry), "");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (um->show_password_button), FALSE);
if (um_user_get_uid (um->user) == getuid () &&
um_user_get_password_mode (um->user) == UM_PASSWORD_MODE_REGULAR) {
gtk_widget_show (um->old_password_label);
gtk_widget_show (um->old_password_entry);
um->old_password_ok = FALSE;
}
else {
gtk_widget_hide (um->old_password_label);
gtk_widget_hide (um->old_password_entry);
um->old_password_ok = TRUE;
}
if (um_user_get_uid (um->user) == getuid()) {
if (um->passwd_handler != NULL)
passwd_destroy (um->passwd_handler);
um->passwd_handler = passwd_init ();
}
}
model = gtk_combo_box_get_model (GTK_COMBO_BOX (um->action_combo));
if (!GTK_IS_TREE_MODEL_FILTER (model)) {
model = gtk_tree_model_filter_new (model, NULL);
gtk_combo_box_set_model (GTK_COMBO_BOX (um->action_combo), model);
gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (model),
(GtkTreeModelFilterVisibleFunc) visible_func,
um, NULL);
}
gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (model));
gtk_combo_box_set_active (GTK_COMBO_BOX (um->action_combo), 0);
}
void
gtk_combo_box_set_active_index(GtkComboBox *box, const QModelIndex& idx)
{
if (idx.isValid()) {
GtkTreeIter new_iter;
GtkTreeModel *filter_model = gtk_combo_box_get_model(box);
g_return_if_fail(filter_model);
GtkTreeModel *model = filter_model;
if (GTK_IS_TREE_MODEL_FILTER(filter_model))
model = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(filter_model));
gboolean valid = FALSE;
if (GTK_IS_Q_TREE_MODEL(model))
valid = gtk_q_tree_model_source_index_to_iter(GTK_Q_TREE_MODEL(model), idx, &new_iter);
if (valid) {
if (GTK_IS_TREE_MODEL_FILTER(filter_model)) {
GtkTreeIter filter_iter;
if (gtk_tree_model_filter_convert_child_iter_to_iter(
GTK_TREE_MODEL_FILTER(filter_model),
&filter_iter,
&new_iter)
) {
gtk_combo_box_set_active_iter(box, &filter_iter);
} else {
g_warning("failed to convert iter from source model to filter model iter");
}
} else {
gtk_combo_box_set_active_iter(box, &new_iter);
}
} else {
g_warning("Given QModelIndex doesn't exist in GtkTreeModel");
}
}
}
/* Returns true iff the variable selected by SOURCE is numeric */
gboolean
numeric_only (GtkWidget *source, GtkWidget *dest)
{
gboolean retval = TRUE;
GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (source));
PsppireDict *dict;
GtkTreeSelection *selection;
GList *list, *l;
while (GTK_IS_TREE_MODEL_FILTER (model))
{
model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (model));
}
dict = PSPPIRE_DICT (model);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (source));
list = gtk_tree_selection_get_selected_rows (selection, &model);
/* Iterate through the selection of the source treeview */
for (l = list; l ; l = l->next)
{
GtkTreePath *path = l->data;
GtkTreePath *fpath = gtk_tree_model_filter_convert_path_to_child_path
(GTK_TREE_MODEL_FILTER (model), path);
gint *idx = gtk_tree_path_get_indices (fpath);
const struct variable *v = psppire_dict_get_variable (dict, idx[0]);
gtk_tree_path_free (fpath);
if ( var_is_alpha (v))
{
retval = FALSE;
break;
}
}
g_list_foreach (list, (GFunc) gtk_tree_path_free, NULL);
g_list_free (list);
return retval;
}
static void
notify_model_cb (GtkTreeView *view,
GParamSpec *pspec,
TestFixture *fixture)
{
fixture->model = gtk_tree_view_get_model (fixture->tree_view);
if (GTK_IS_TREE_MODEL_FILTER (fixture->model))
{
GtkTreeModelFilter *filter = GTK_TREE_MODEL_FILTER (fixture->model);
fixture->store = GTK_LIST_STORE (gtk_tree_model_filter_get_model (filter));
}
else
{
fixture->store = GTK_LIST_STORE (fixture->model);
}
}
/* Inserts the name of the selected variable into the destination widget.
The destination widget must be a GtkTextView
*/
static void
insert_source_row_into_text_view (GtkTreeIter iter,
GtkWidget *dest,
GtkTreeModel *model,
gpointer data
)
{
GtkTreePath *path;
PsppireDict *dict;
gint *idx;
struct variable *var;
GtkTreeIter dict_iter;
GtkTextBuffer *buffer;
g_return_if_fail (GTK_IS_TEXT_VIEW (dest));
if ( GTK_IS_TREE_MODEL_FILTER (model))
{
dict = PSPPIRE_DICT (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),
&dict_iter, &iter);
}
else
{
dict = PSPPIRE_DICT (model);
dict_iter = iter;
}
path = gtk_tree_model_get_path (GTK_TREE_MODEL (dict), &dict_iter);
idx = gtk_tree_path_get_indices (path);
var = psppire_dict_get_variable (dict, *idx);
gtk_tree_path_free (path);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (dest));
erase_selection (buffer);
gtk_text_buffer_insert_at_cursor (buffer, var_get_name (var), -1);
}
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;
}
static void
set_all_selection (GdMainViewGeneric *self,
GtkTreeModel *model,
gboolean selection)
{
GtkTreeModel *actual_model;
if (!model)
return;
if (GTK_IS_TREE_MODEL_FILTER (model))
actual_model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (model));
else
actual_model = model;
gtk_tree_model_foreach (actual_model,
set_selection_foreach,
GINT_TO_POINTER (selection));
g_signal_emit (self, signals[VIEW_SELECTION_CHANGED], 0);
}
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;
}
/* Returns FALSE if the variables represented by the union of the rows
currently selected by SOURCE widget, and contents of the DEST
widget, are of different types.
In other words, this function when passed as the argument to
psppire_selector_set_allow, ensures that the selector selects only
string variables, or only numeric variables, not a mixture.
*/
gboolean
homogeneous_types (GtkWidget *source, GtkWidget *dest)
{
gboolean ok;
GtkTreeIter iter;
gboolean retval = TRUE;
GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (source));
PsppireDict *dict;
GtkTreeSelection *selection;
enum val_type type = -1;
GList *list, *l;
while (GTK_IS_TREE_MODEL_FILTER (model))
{
model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (model));
}
dict = PSPPIRE_DICT (model);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (source));
list = gtk_tree_selection_get_selected_rows (selection, &model);
/* Iterate through the selection of the source treeview */
for (l = list; l ; l = l->next)
{
GtkTreePath *path = l->data;
GtkTreePath *fpath =
gtk_tree_model_filter_convert_path_to_child_path (GTK_TREE_MODEL_FILTER (model), path);
gint *idx = gtk_tree_path_get_indices (fpath);
const struct variable *v = psppire_dict_get_variable (dict, idx[0]);
gtk_tree_path_free (fpath);
if ( type != -1 )
{
if ( var_get_type (v) != type )
{
retval = FALSE;
break;
}
}
type = var_get_type (v);
}
g_list_foreach (list, (GFunc) gtk_tree_path_free, NULL);
g_list_free (list);
if ( retval == FALSE )
return FALSE;
/* now deal with the dest widget */
model = gtk_tree_view_get_model (GTK_TREE_VIEW (dest));
for (ok = gtk_tree_model_get_iter_first (model, &iter);
ok;
ok = gtk_tree_model_iter_next (model, &iter))
{
const struct variable *v;
gtk_tree_model_get (model, &iter, 0, &v, -1);
if ( type != -1 )
{
if ( var_get_type (v) != type )
{
retval = FALSE;
break;
}
}
type = var_get_type (v);
}
return retval;
}
