static gboolean compare_location(GtkTreeModel* model, GtkTreePath* path, GtkTreeIter* iter, gpointer user_data)
{
MateWeatherPref* pref = user_data;
WeatherLocation* loc;
GtkTreeView* view;
gtk_tree_model_get(model, iter, MATEWEATHER_XML_COL_POINTER, &loc, -1);
if (!loc)
{
return FALSE;
}
if (!weather_location_equal(loc, pref->priv->applet->mateweather_pref.location))
{
return FALSE;
}
view = GTK_TREE_VIEW(pref->priv->tree);
gtk_tree_view_expand_to_path(view, path);
gtk_tree_view_set_cursor(view, path, NULL, FALSE);
gtk_tree_view_scroll_to_cell(view, path, NULL, TRUE, 0.5, 0.5);
return TRUE;
}
void tree_gui_set_current(tree_gui_t *gui, unsigned long key)
{
if ( gui == NULL )
return;
/* Unpaint previous row */
if ( gui->current.object ) {
gui->current.object = NULL;
tree_gui_paint_iter(gui, &(gui->current.iter));
}
if ( (key != 0) && tree_gui_get_iter(gui, key, &(gui->current.iter)) ) {
GtkTreePath *path;
gtk_tree_model_get(GTK_TREE_MODEL(gui->tree_model), &(gui->current.iter),
TREE_GUI_COL_OBJECT, &(gui->current.object),
-1);
/* Expand tree to current path */
path = gtk_tree_model_get_path(GTK_TREE_MODEL(gui->tree_model), &(gui->current.iter));
gtk_tree_view_expand_to_path(gui->tree_view, path);
gtk_tree_path_free(path);
/* Paint row */
tree_gui_paint_iter(gui, &(gui->current.iter));
}
//fprintf(stderr, "-- CURRENT = %lu\n", key);
/* Update output dump display */
tree_gui_show_current(gui);
}
gboolean
vinagre_bookmarks_tree_select_entry (VinagreBookmarksTree *tree,
VinagreBookmarksEntry *entry)
{
GtkTreeModel *model;
struct _find_entry f;
if (!entry)
return FALSE;
g_return_val_if_fail (VINAGRE_IS_BOOKMARKS_TREE (tree), FALSE);
g_return_val_if_fail (VINAGRE_IS_BOOKMARKS_ENTRY (entry), FALSE);
model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree->priv->tree));
f.entry = entry;
f.found = FALSE;
gtk_tree_model_foreach (model, find_entry, &f);
if (f.found)
{
gtk_tree_view_expand_to_path (GTK_TREE_VIEW (tree->priv->tree), f.path);
gtk_tree_view_set_cursor (GTK_TREE_VIEW (tree->priv->tree), f.path, NULL, FALSE);
gtk_tree_path_free (f.path);
return TRUE;
}
else
return FALSE;
}
static void
select_index (const gchar *uri)
{
GtkTreeSelection *selection;
GtkTreeIter *iter = NULL;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
if (uri)
iter = g_hash_table_lookup (uri_hash_table, uri);
if (iter)
{
GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view));
GtkTreePath *path;
GtkTreePath *scroll_path;
path = gtk_tree_model_get_path (model, iter);
scroll_path = gtk_tree_path_copy (path);
gtk_tree_path_up (path);
gtk_tree_view_expand_to_path (GTK_TREE_VIEW (tree_view), path);
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (tree_view), scroll_path,
NULL, FALSE, 0.0, 0.0);
gtk_tree_path_free (path);
gtk_tree_path_free (scroll_path);
gtk_tree_selection_select_iter (selection, iter);
}
else
{
gtk_tree_selection_unselect_all (selection);
}
}
static gboolean cm_try_to_select(CMPathWalkFunc path_func, GtkTreeSelection *selection,
GtkTreeModel *model, GtkTreePath *path)
{
GtkTreeIter iter;
if (gtk_tree_path_get_depth(path) <= 0) /* sanity check */
return FALSE;
/* modify the path using the passed function */
if (path_func != NULL)
path_func(path);
if (gtk_tree_path_get_depth(path) <= 0) /* sanity check */
return FALSE;
/* check whether the path points to something valid and if so, select it */
if (gtk_tree_model_get_iter(model, &iter, path))
{
GtkTreeView *treeview = gtk_tree_selection_get_tree_view(selection);
gboolean was_expanded = gtk_tree_view_row_expanded(treeview, path);
/* to get gtk_tree_selection_select_path() working, we need to expand the row first
* if it isn't expanded yet, at least when the row is a parent item */
if (! was_expanded)
gtk_tree_view_expand_to_path(treeview, path);
gtk_tree_selection_select_path(selection, path);
if (! was_expanded) /* restore the previous state */
gtk_tree_view_collapse_row(treeview, path);
return TRUE;
}
return FALSE;
}
/**
* gwy_grain_value_tree_view_select:
* @treeview: A tree view with grain values.
* @gvalue: The grain value to select.
*
* Selects a particular grain value in a grain value tree view.
*
* If the @gvalue group is currently unexpanded, it will be expanded to
* show it, and the tree view may scroll to make it visible.
*
* Since: 2.8
**/
void
gwy_grain_value_tree_view_select(GtkTreeView *treeview,
GwyGrainValue *gvalue)
{
GtkTreeSelection *selection;
GtkTreeModel *model;
GtkTreePath *path;
GtkTreeIter iter;
g_return_if_fail(GTK_IS_TREE_VIEW(treeview));
g_return_if_fail(GWY_IS_GRAIN_VALUE(gvalue));
g_return_if_fail(priv_quark
&& g_object_get_qdata(G_OBJECT(treeview), priv_quark));
model = gtk_tree_view_get_model(treeview);
if (!find_grain_value(model, gvalue, &iter)) {
g_warning("Grain value not in tree model.");
return;
}
path = gtk_tree_model_get_path(model, &iter);
gtk_tree_view_expand_to_path(treeview, path);
gtk_tree_view_scroll_to_cell(treeview, path, NULL, FALSE, 0.0, 0.0);
gtk_tree_path_free(path);
selection = gtk_tree_view_get_selection(treeview);
gtk_tree_selection_select_iter(selection, &iter);
}
void gui_parse_bookmarks(GtkTreeView *tree, const xmlChar *file,
GtkTreeIter *parent)
{
xmlNodePtr cur = NULL;
BOOKMARK_DATA data, *p = NULL;
GtkTreeIter iter;
GtkTreePath *path;
p = &data;
cur = xml_load_bookmark_file(file);
//cur = cur->xmlChildrenNode;
while (cur != NULL) {
if (!xmlStrcmp(cur->name, (const xmlChar *)"Bookmark")) {
get_xml_bookmark_data(cur, p);
gui_add_item_to_tree(&iter, parent, p);
free_bookmark_data(p);
} else {
get_xml_folder_data(cur, p);
if (p->caption) {
gui_add_item_to_tree(&iter, parent, p);
}
free_bookmark_data(p);
add_node(cur, &iter);
}
if (cur->next)
cur = cur->next;
else
break;
}
xml_free_bookmark_doc();
path = gtk_tree_model_get_path(GTK_TREE_MODEL(model), parent);
gtk_tree_view_expand_to_path(tree, path);
gtk_tree_path_free(path);
}
static void find_entry_changed(GtkEditable* entry, MateWeatherPref* pref)
{
GtkTreeView *tree;
GtkTreeModel *model;
GtkTreeSelection *selection;
GtkTreeIter iter;
GtkTreePath *path;
const gchar *location;
tree = GTK_TREE_VIEW (pref->priv->tree);
model = gtk_tree_view_get_model (tree);
g_return_if_fail (model != NULL);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree));
gtk_tree_model_get_iter_first (model, &iter);
location = gtk_entry_get_text (GTK_ENTRY (entry));
if (find_location (model, &iter, location, TRUE))
{
gtk_widget_set_sensitive (pref->priv->find_next_btn, TRUE);
path = gtk_tree_model_get_path (model, &iter);
gtk_tree_view_expand_to_path (tree, path);
gtk_tree_selection_select_iter (selection, &iter);
gtk_tree_view_scroll_to_cell (tree, path, NULL, TRUE, 0.5, 0);
gtk_tree_path_free (path);
}
else
{
gtk_widget_set_sensitive (pref->priv->find_next_btn, FALSE);
}
}
void
find_entry_changed (GtkEditable *entry/*, GWeatherPref *pref*/)
{
GtkTreeModel *model;
GtkTreeSelection *selection;
GtkTreeIter iter;
GtkTreePath *path;
GtkWidget *nextbutton;
const gchar *location;
nextbutton = (GtkWidget *) glade_xml_get_widget(glade_xml, "findnextbutton");
model = gtk_tree_view_get_model (GTK_TREE_VIEW(locations_widgets->tree));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (locations_widgets->tree));
gtk_tree_model_get_iter_first (model, &iter);
location = gtk_entry_get_text (GTK_ENTRY (entry));
if (find_location (model, &iter, location, TRUE))
{
gtk_widget_set_sensitive (nextbutton , TRUE);
path = gtk_tree_model_get_path (model, &iter);
gtk_tree_view_expand_to_path (GTK_TREE_VIEW(locations_widgets->tree), path);
gtk_tree_selection_select_iter (selection, &iter);
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW(locations_widgets->tree), path, NULL, TRUE, 0.5, 0);
gtk_tree_path_free (path);
}
else
{
gtk_widget_set_sensitive (nextbutton, FALSE);
}
}
void TreeViewCategories_CategoryAdd(TreeViewCategories* c, const char* CatName, unsigned int IsRoot)
{
GtkTreeModel* model;
GtkTreePath* path;
GtkTreeIter iter;
GtkTreeIter iter_parent;
GtkTreeIter* iter_parent_ptr;
guint parent_id;
gchar* CategoryName2Str;
model = gtk_tree_view_get_model(GTK_TREE_VIEW(c->treeview));
if (IsRoot)
{
iter_parent_ptr = NULL;
path = NULL;
parent_id = 0;
}
else
{
gtk_tree_view_get_cursor(GTK_TREE_VIEW(c->treeview), &path, NULL);
if (path == NULL)
{
iter_parent_ptr = NULL;
parent_id = 0;
}
else
{
gtk_tree_model_get_iter(model, &iter_parent, path);
iter_parent_ptr = &iter_parent;
gtk_tree_model_get(model, iter_parent_ptr, COL_ID_ID, &parent_id, -1);
}
}
CategoryName2Str = TreeViewCategories_GetName2(model, iter_parent_ptr, CatName);
g_print("%s(): new category: id = %u, parent_id = %u, name = %s, name2 = %s.\n",
__func__, c->new_cat_id, parent_id, CatName, CategoryName2Str);
if (TreeViewCategories_CategoryAddToDatabase(c, c->new_cat_id, parent_id, CatName))
{
gtk_tree_store_append(GTK_TREE_STORE(model), &iter, iter_parent_ptr);
gtk_tree_store_set(GTK_TREE_STORE(model), &iter,
COL_ID_RECORD_STATE, REC_STATE_ADD,
COL_ID_ID, c->new_cat_id,
COL_ID_PARENT_ID, parent_id,
COL_ID_NAME, CatName,
COL_ID_NAME2, CategoryName2Str, -1);
++c->new_cat_id;
}
if (path != NULL)
{
gtk_tree_view_expand_to_path(GTK_TREE_VIEW(c->treeview), path);
gtk_tree_path_free(path);
}
g_free(CategoryName2Str);
}
void
parasite_widget_tree_select_widget(ParasiteWidgetTree *widget_tree,
GtkWidget *widget)
{
GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(widget_tree));
GList *parents = get_parents(widget, NULL);
GList *l;
GtkTreeIter iter, parent_iter = {0};
gboolean found = FALSE;
gboolean in_root = TRUE;
for (l = parents; l != NULL; l = l->next)
{
GtkWidget *cur_widget = GTK_WIDGET(l->data);
gboolean valid;
found = FALSE;
for (valid = gtk_tree_model_iter_children(model, &iter,
in_root ? NULL
: &parent_iter);
valid;
valid = gtk_tree_model_iter_next(model, &iter))
{
GtkWidget *iter_widget;
gtk_tree_model_get(model, &iter,
WIDGET, &iter_widget,
-1);
if (iter_widget == cur_widget)
{
parent_iter = iter;
in_root = FALSE;
found = TRUE;
break;
}
}
if (!found)
{
/* No good. Bail.. */
break;
}
}
if (found)
{
GtkTreePath *path = gtk_tree_model_get_path(model, &iter);
gtk_tree_view_expand_to_path(GTK_TREE_VIEW(widget_tree), path);
gtk_tree_selection_select_iter(
gtk_tree_view_get_selection(GTK_TREE_VIEW(widget_tree)),
&iter);
gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(widget_tree), path, NULL,
FALSE, 0, 0);
}
g_list_free(parents);
}
static void add_folder_button(void)
{
GtkTreeIter selected;
GtkTreeIter iter;
BOOKMARK_DATA *data;
GtkTreeSelection *selection;
char *t;
gint test;
GS_DIALOG *info;
GString *str;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
if (!gtk_tree_selection_get_selected(selection, NULL, &selected))
return;
t = "|";
str = g_string_new("");
info = gui_new_dialog();
//info->stock_icon = GTK_STOCK_OPEN;
info->title = _("Bookmark");
g_string_printf(str, "<span weight=\"bold\">%s</span>",
_("Enter Folder Name"));
info->label_top = str->str;
info->text1 = g_strdup(_("Folder Name"));
info->label1 = _("Folder: ");
info->ok = TRUE;
info->cancel = TRUE;
data = g_new(BOOKMARK_DATA, 1);
/*** open dialog to get name for new folder ***/
test = gui_gs_dialog(info);
if (test == GS_OK) {
char *buf = g_strdelimit(info->text1, t, ' ');
data->caption = g_strdup(buf);
data->key = NULL;
data->module = NULL;
data->module_desc = NULL;
data->description = NULL;
data->is_leaf = FALSE;
data->opened = bm_pixbufs->pixbuf_opened;
data->closed = bm_pixbufs->pixbuf_closed;
gui_add_item_to_tree(&iter, &selected, data);
bookmarks_changed = TRUE;
gui_save_bookmarks(NULL, NULL);
g_free(data->caption);
GtkTreePath *path =
gtk_tree_model_get_path(GTK_TREE_MODEL(model), &iter);
gtk_tree_view_expand_to_path(GTK_TREE_VIEW(treeview),
path);
gtk_tree_selection_select_path(selection, path);
gtk_tree_path_free(path);
}
g_free(data);
g_free(info->text1);
g_free(info);
g_string_free(str, TRUE);
}
void saa_tree_view_select_wing(SaaTreeView * treeview, SaaAile * ai) {
GtkTreeSelection * sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
int i = saa_solide_index_aile(treeview->visuel->solide, ai);
GtkTreePath * path = gtk_tree_path_new_from_indices(2, i, -1);
gtk_tree_view_expand_to_path (GTK_TREE_VIEW(treeview), path);
gtk_tree_selection_select_path(sel, path);
gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(treeview), path, NULL, TRUE, 0.5, 0);
gtk_tree_path_free (path);
}
static void find_next_clicked(GtkButton* button, MateWeatherPref* pref)
{
GtkTreeView *tree;
GtkTreeModel *model;
GtkEntry *entry;
GtkTreeSelection *selection;
GtkTreeIter iter;
GtkTreeIter iter_parent;
GtkTreePath *path;
const gchar *location;
tree = GTK_TREE_VIEW (pref->priv->tree);
model = gtk_tree_view_get_model (tree);
entry = GTK_ENTRY (pref->priv->find_entry);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree));
if (gtk_tree_selection_count_selected_rows (selection) >= 1)
{
gtk_tree_selection_get_selected (selection, &model, &iter);
/* Select next or select parent */
if (!gtk_tree_model_iter_next (model, &iter))
{
iter_parent = iter;
if (!gtk_tree_model_iter_parent (model, &iter, &iter_parent) || !gtk_tree_model_iter_next (model, &iter))
{
gtk_tree_model_get_iter_first (model, &iter);
}
}
}
else
{
gtk_tree_model_get_iter_first (model, &iter);
}
location = gtk_entry_get_text (entry);
if (find_location (model, &iter, location, TRUE))
{
gtk_widget_set_sensitive (pref->priv->find_next_btn, TRUE);
path = gtk_tree_model_get_path (model, &iter);
gtk_tree_view_expand_to_path (tree, path);
gtk_tree_selection_select_path (selection, path);
gtk_tree_view_scroll_to_cell (tree, path, NULL, TRUE, 0.5, 0);
gtk_tree_path_free (path);
}
else
{
gtk_widget_set_sensitive (pref->priv->find_next_btn, FALSE);
}
}
static void tree_gui_spot_path(tree_gui_t *gui, GtkTreePath *path)
{
/* Expand the node to spot to */
gtk_tree_view_expand_to_path(gui->tree_view, path);
/* Make the node viewable within the tree window */
gtk_tree_view_scroll_to_cell(gui->tree_view, path, NULL, TRUE, 0.5, 0);
/* Select focused row */
gtk_tree_selection_select_path(gui->tree_selection, path);
}
gboolean bar_keyword_tree_expand_if_set_cb(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
{
PaneKeywordsData *pkd = data;
gboolean set;
gtk_tree_model_get(model, iter, FILTER_KEYWORD_COLUMN_TOGGLE, &set, -1);
if (set && !gtk_tree_view_row_expanded(GTK_TREE_VIEW(pkd->keyword_treeview), path))
{
gtk_tree_view_expand_to_path(GTK_TREE_VIEW(pkd->keyword_treeview), path);
}
return FALSE;
}
static gboolean
set_current_action (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data) {
GValue val = {0,}, ctx_val = {0,};
gtk_tree_model_get_value (model, iter, 1, &val);
gtk_tree_model_get_value (model, iter, 2, &ctx_val);
actionbinding_t *binding = data;
const char *name = g_value_get_string (&val);
if (name && binding->name && !strcmp (binding->name, name) && binding->ctx == g_value_get_int (&ctx_val)) {
gtk_tree_view_expand_to_path (GTK_TREE_VIEW (binding->treeview), path);
gtk_tree_view_set_cursor (GTK_TREE_VIEW (binding->treeview), path, NULL, FALSE);
return TRUE;
}
return FALSE;
}
static void collapse(void)
{
GtkTreeIter iter;
GtkTreePath *tree_path;
GtkTreeModel *model = GTK_TREE_MODEL(s_file_store);
gtk_tree_view_collapse_all(GTK_TREE_VIEW(s_file_view));
/* expand the project folder */
gtk_tree_model_iter_children(model, &iter, NULL);
tree_path = gtk_tree_model_get_path (model, &iter);
gtk_tree_view_expand_to_path(GTK_TREE_VIEW(s_file_view), tree_path);
gtk_tree_path_free(tree_path);
}
static void
pkg_window_expand_to_iter (PkgWindow *window, /* IN */
GtkTreeIter *iter) /* IN */
{
PkgWindowPrivate *priv;
GtkTreePath *path;
g_return_if_fail(PKG_IS_WINDOW(window));
g_return_if_fail(iter != NULL);
priv = window->priv;
path = gtk_tree_model_get_path(GTK_TREE_MODEL(priv->model), iter);
gtk_tree_view_expand_to_path(GTK_TREE_VIEW(priv->treeview), path);
gtk_tree_path_free(path);
}
static void setup_treeview(void)
{
GtkTreePath *path;
GtkTreeIter iter;
GtkTreeSelection *selection = NULL;
gtk_tree_view_set_model(GTK_TREE_VIEW(treeview),
GTK_TREE_MODEL(model));
gui_add_columns(GTK_TREE_VIEW(treeview));
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(model), &iter);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
path = gtk_tree_model_get_path(GTK_TREE_MODEL(model), &iter);
gtk_tree_view_expand_to_path(GTK_TREE_VIEW(treeview), path);
gtk_tree_selection_select_path(selection, path);
gtk_tree_path_free(path);
}
static gboolean
edit_row_idle (RowEditData *data)
{
GtkTreePath *new_item_path;
new_item_path = gtk_tree_row_reference_get_path (data->row_ref);
gtk_widget_grab_focus (GTK_WIDGET (data->eprop->view));
gtk_tree_view_expand_to_path (data->eprop->view, new_item_path);
gtk_tree_view_set_cursor (data->eprop->view, new_item_path,
data->eprop->filename_column, TRUE);
gtk_tree_path_free (new_item_path);
gtk_tree_row_reference_free (data->row_ref);
g_slice_free (RowEditData, data);
return FALSE;
}
void last_mod_callback(GPid pid, gint status, gpointer data)
{
int * out_fd = (int *)data;
gchar * comma_pos = 0, * newline_pos = 0;
GString * msg = NULL;
tree_node n;
memset(&n, 0, sizeof(tree_node));
msg = util_get_output(*out_fd);
close(*out_fd);
free(out_fd);
if (!msg)
return;
if (g_str_has_prefix(msg->str, "Error:"))
{
g_string_truncate(msg, 2);
g_string_overwrite(msg, 0, "ra");
}
else if (NULL != (comma_pos = g_strstr_len(msg->str, -1, ",")))
*comma_pos = '\0';
else if (NULL != (newline_pos = g_strstr_len(msg->str, -1, "\n")))
*newline_pos = '\0';
n.key = msg->str;
gtk_tree_model_foreach(GTK_TREE_MODEL(tree_store), find_mod, &n);
if (n.node_path)
{
GtkTreePath * path;
path = gtk_tree_path_new_from_string(n.node_path);
if (path == NULL)
g_warning("Invalid Path");
gtk_tree_view_expand_to_path(tree, path);
gtk_tree_view_set_cursor(tree, path, NULL, FALSE);
gtk_tree_path_free(path);
g_free(n.node_path);
}
g_string_free(msg, TRUE);
}
void
find_next_clicked (GtkButton *button)
{
GtkTreeModel *model;
GtkEntry *entry;
GtkTreeSelection *selection;
GtkTreeIter iter;
GtkTreeIter iter_parent;
GtkTreePath *path;
const gchar *location;
model = gtk_tree_view_get_model (GTK_TREE_VIEW(locations_widgets->tree));
entry = GTK_ENTRY (glade_xml_get_widget(glade_xml, "location_search_entry"));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (locations_widgets->tree));
if (gtk_tree_selection_count_selected_rows (selection) >= 1) {
gtk_tree_selection_get_selected (selection, &model, &iter);
/* Select next or select parent */
if (!gtk_tree_model_iter_next (model, &iter)) {
iter_parent = iter;
if (!gtk_tree_model_iter_parent (model, &iter, &iter_parent) || !gtk_tree_model_iter_next (model, &iter))
gtk_tree_model_get_iter_first (model, &iter);
}
} else {
gtk_tree_model_get_iter_first (model, &iter);
}
location = gtk_entry_get_text (entry);
if (find_location (model, &iter, location, TRUE)) {
gtk_widget_set_sensitive ((GtkWidget *)button, TRUE);
path = gtk_tree_model_get_path (model, &iter);
gtk_tree_view_expand_to_path (GTK_TREE_VIEW(locations_widgets->tree), path);
gtk_tree_selection_select_path (selection, path);
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW(locations_widgets->tree), path, NULL, TRUE, 0.5, 0);
gtk_tree_path_free (path);
} else {
gtk_widget_set_sensitive ((GtkWidget * )button, FALSE);
}
}
void tree_gui_load(tree_gui_t *gui, tree_t *tree, output_t *out)
{
tree_item_t *head = tree->head;
char title[strlen(head->name)+24];
GtkTreePath *path;
if ( gui == NULL )
return;
/* Clear node selection/index */
gui->current.object = NULL;
gui->selected.object = NULL;
gui->exec_state = stRESET;
/* Build tree structure */
tree_gui_build_branch(gui, NULL, head->object);
/* Expand tree root */
path = gtk_tree_path_new_first();
gtk_tree_view_expand_to_path(gui->tree_view, path);
gtk_tree_path_free(path);
/* Clear selection */
tree_gui_unselect(gui);
/* Update window title */
snprintf(title, sizeof(title), "TestFarm Runner - %s", head->name);
gtk_window_set_title(GTK_WINDOW(gui->window), title);
/* Update button sensitivity */
tree_gui_sensitivity_brk_skip(gui, 1);
/* Init output and reporting stuffs */
output_gui_set(gui->og, out);
report_gui_load(gui->rg, tree, out);
/* Activate Service start/stop buttons */
if ( tree->system != NULL ) {
system_gui_set(gui->sg, tree->system);
system_gui_enable(gui->sg, 1);
}
}
static void
source_viewer_expand_to_source (ESourceViewer *viewer,
ESource *source)
{
GHashTable *source_index;
GtkTreeRowReference *reference;
GtkTreeView *tree_view;
GtkTreePath *path;
source_index = viewer->source_index;
reference = g_hash_table_lookup (source_index, source);
/* We show all sources, so the reference should be valid. */
g_return_if_fail (gtk_tree_row_reference_valid (reference));
/* Expand the tree view to the path containing the ESource. */
tree_view = GTK_TREE_VIEW (viewer->tree_view);
path = gtk_tree_row_reference_get_path (reference);
gtk_tree_view_expand_to_path (tree_view, path);
gtk_tree_path_free (path);
}
/****************************************************************
* build_acct_tree
*
* This function refreshes the contents of the account tree.
****************************************************************/
static void
build_acct_tree(QIFAccountPickerDialog * picker, QIFImportWindow * import)
{
SCM get_accts = scm_c_eval_string("qif-import:get-all-accts");
SCM acct_tree;
GtkTreeStore *store;
GtkTreePath *path;
GtkTreeSelection* selection;
GtkTreeRowReference *reference = NULL;
gchar *name_to_select;
g_return_if_fail(picker && import);
/* Get an account tree with all existing and to-be-imported accounts. */
acct_tree = scm_call_1(get_accts,
gnc_ui_qif_import_assistant_get_mappings(import));
/* Rebuild the store.
* NOTE: It is necessary to save a copy of the name to select, because
* when the store is cleared, everything becomes unselected. */
name_to_select = g_strdup(picker->selected_name);
store = GTK_TREE_STORE(gtk_tree_view_get_model(picker->treeview));
gtk_tree_store_clear(store);
acct_tree_add_accts(acct_tree, store, NULL, NULL, name_to_select, &reference);
g_free(name_to_select);
/* Select and display the indicated account (if it was found). */
if (reference)
{
selection = gtk_tree_view_get_selection(picker->treeview);
path = gtk_tree_row_reference_get_path(reference);
if (path)
{
gtk_tree_view_expand_to_path(picker->treeview, path);
gtk_tree_selection_select_path(selection, path);
gtk_tree_path_free(path);
}
gtk_tree_row_reference_free(reference);
}
}
static void
eprop_data_focus_editing_cell (GladeEPropModelData * eprop_data)
{
/* Focus and edit the first column of a newly added row */
if (!eprop_data->setting_focus && eprop_data->store && eprop_data->want_focus
&& eprop_data->editing_column >= 0 && eprop_data->editing_row >= 0)
{
GtkTreePath *item_path;
GtkTreeIter iter;
GtkTreeViewColumn *column;
gint row, col;
GList *column_list;
column_list = gtk_tree_view_get_columns (eprop_data->view);
g_list_free (column_list);
col = eprop_data->editing_column;
row = eprop_data->editing_row;
if ((column = gtk_tree_view_get_column (eprop_data->view, col)) != NULL &&
gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (eprop_data->store),
&iter, NULL, row))
{
item_path =
gtk_tree_model_get_path (GTK_TREE_MODEL (eprop_data->store),
&iter);
eprop_data->setting_focus = TRUE;
gtk_widget_grab_focus (GTK_WIDGET (eprop_data->view));
gtk_tree_view_expand_to_path (eprop_data->view, item_path);
gtk_tree_view_set_cursor (eprop_data->view, item_path, column, FALSE);
gtk_tree_path_free (item_path);
eprop_data->setting_focus = FALSE;
}
}
}
static void
eprop_data_focus_new (GladeEPropModelData * eprop_data)
{
/* Focus and edit the first column of a newly added row */
if (eprop_data->store)
{
GtkTreePath *new_item_path;
GtkTreeIter iter;
GtkTreeViewColumn *column;
gint n_children;
n_children =
gtk_tree_model_iter_n_children (GTK_TREE_MODEL (eprop_data->store),
NULL);
if ((column =
gtk_tree_view_get_column (eprop_data->view,
eprop_data->editing_column)) != NULL &&
n_children > 0 &&
gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (eprop_data->store),
&iter, NULL, n_children - 1))
{
new_item_path =
gtk_tree_model_get_path (GTK_TREE_MODEL (eprop_data->store), &iter);
eprop_data->setting_focus = TRUE;
gtk_widget_grab_focus (GTK_WIDGET (eprop_data->view));
gtk_tree_view_expand_to_path (eprop_data->view, new_item_path);
gtk_tree_view_set_cursor (eprop_data->view, new_item_path, column, FALSE);
eprop_data->setting_focus = FALSE;
gtk_tree_path_free (new_item_path);
}
}
}
static gboolean
expand_enabled(GtkTreeModel *model,
GtkTreePath *path,
G_GNUC_UNUSED GtkTreeIter *iter,
gpointer user_data)
{
GtkTreeView *treeview = (GtkTreeView*)user_data;
GwyGrainValue *gvalue;
gboolean enabled;
gtk_tree_model_get(model, iter,
GWY_GRAIN_VALUE_STORE_COLUMN_ITEM, &gvalue,
GWY_GRAIN_VALUE_STORE_COLUMN_ENABLED, &enabled,
-1);
if (gvalue) {
if (enabled)
gtk_tree_view_expand_to_path(treeview, path);
g_object_unref(gvalue);
}
return FALSE;
}
gboolean
giggle_tree_view_select_row_by_string (GtkWidget *treeview,
int column,
const char *pattern)
{
GtkTreeSelection *selection;
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreePath *path;
char *text;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
gtk_tree_model_get (model, &iter, column, &text, -1);
} else {
model = gtk_tree_view_get_model (GTK_TREE_VIEW (treeview));
text = NULL;
}
if (!g_strcmp0 (text, pattern)) {
g_free (text);
return TRUE;
}
if (tree_model_find_string (model, &iter, NULL, column, pattern)) {
path = gtk_tree_model_get_path (model, &iter);
gtk_tree_view_expand_to_path (GTK_TREE_VIEW (treeview), path);
gtk_tree_path_free (path);
gtk_tree_selection_select_iter (selection, &iter);
return TRUE;
}
return FALSE;
}
