static void scroll_both_realize (ScrollFixture *fixture, GtkTreePath *path, gboolean use_align, gdouble row_align) { GtkTreePath *end; gtk_widget_show_all (fixture->window); /* Scroll to end */ end = gtk_tree_path_new_from_indices (999, -1); gtk_tree_view_set_cursor (GTK_TREE_VIEW (fixture->tree_view), end, NULL, FALSE); gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (fixture->tree_view), end, NULL, use_align, row_align, 0.0); gtk_tree_path_free (end); while (gtk_events_pending ()) gtk_main_iteration (); /* Scroll to final position */ gtk_tree_view_set_cursor (GTK_TREE_VIEW (fixture->tree_view), path, NULL, FALSE); gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (fixture->tree_view), path, NULL, use_align, row_align, 0.0); ensure_layout (); test_position (GTK_TREE_VIEW (fixture->tree_view), path, use_align, row_align); }
static void select_created_user (UmUser *user, UmUserPanelPrivate *d) { GtkTreeView *tv; GtkTreeModel *model; GtkTreeSelection *selection; GtkTreeIter iter; UmUser *current; GtkTreePath *path; tv = (GtkTreeView *)get_widget (d, "list-treeview"); model = gtk_tree_view_get_model (tv); selection = gtk_tree_view_get_selection (tv); gtk_tree_model_get_iter_first (model, &iter); do { gtk_tree_model_get (model, &iter, USER_COL, ¤t, -1); if (user == current) { path = gtk_tree_model_get_path (model, &iter); gtk_tree_view_scroll_to_cell (tv, path, NULL, FALSE, 0.0, 0.0); gtk_tree_selection_select_path (selection, path); gtk_tree_path_free (path); g_object_unref (current); break; } if (current) g_object_unref (current); } while (gtk_tree_model_iter_next (model, &iter)); }
void item_list_view_select (ItemListView *ilv, itemPtr item) { GtkTreeView *treeview = ilv->priv->treeview; GtkTreeSelection *selection; selection = gtk_tree_view_get_selection (treeview); if (item) { GtkTreeIter iter; GtkTreePath *path; if (!item_list_view_id_to_iter(ilv, item->id, &iter)) /* This is an evil hack to fix SF #1870052: crash upon hitting <enter> when no headline selected. FIXME: This code is rotten! Rewrite it! Now! */ itemlist_selection_changed (NULL); path = gtk_tree_model_get_path (gtk_tree_view_get_model (treeview), &iter); gtk_tree_view_set_cursor (treeview, path, NULL, FALSE); gtk_tree_view_scroll_to_cell (treeview, path, NULL, FALSE, 0.0, 0.0); gtk_tree_path_free (path); } else { gtk_tree_selection_unselect_all (selection); } }
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); } }
/** * 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); }
/** * Logs a status message *without* setting the status bar. * (Use ui_set_statusbar() to display text on the statusbar) * * @param format @c printf()-style format string. * @param ... Arguments for the @c format string. **/ GEANY_API_SYMBOL void msgwin_status_add(const gchar *format, ...) { GtkTreeIter iter; gchar *string; gchar *statusmsg, *time_str; va_list args; va_start(args, format); string = g_strdup_vprintf(format, args); va_end(args); /* add a timestamp to status messages */ time_str = utils_get_current_time_string(); statusmsg = g_strconcat(time_str, ": ", string, NULL); g_free(time_str); g_free(string); /* add message to Status window */ gtk_list_store_append(msgwindow.store_status, &iter); gtk_list_store_set(msgwindow.store_status, &iter, 0, statusmsg, -1); g_free(statusmsg); if (G_LIKELY(main_status.main_window_realized)) { GtkTreePath *path = gtk_tree_model_get_path(gtk_tree_view_get_model(GTK_TREE_VIEW(msgwindow.tree_status)), &iter); gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(msgwindow.tree_status), path, NULL, FALSE, 0.0, 0.0); if (prefs.switch_to_status) gtk_notebook_set_current_page(GTK_NOTEBOOK(msgwindow.notebook), MSG_STATUS); gtk_tree_path_free(path); } }
static void on_panel_show (GtkWidget *widget, gpointer dummy) { GtkTreePath *path; GtkTreeView *view = GTK_TREE_VIEW (plugin_data.view); fill_store (plugin_data.store); gtk_widget_grab_focus (plugin_data.entry); if (plugin_data.last_path) { gtk_tree_view_set_cursor (view, plugin_data.last_path, NULL, FALSE); gtk_tree_view_scroll_to_cell (view, plugin_data.last_path, NULL, TRUE, 0.5, 0.5); } /* make sure the cursor is set (e.g. if plugin_data.last_path wasn't valid) */ gtk_tree_view_get_cursor (view, &path, NULL); if (path) { gtk_tree_path_free (path); } else { GtkTreeIter iter; if (gtk_tree_model_get_iter_first (gtk_tree_view_get_model (view), &iter)) { tree_view_set_cursor_from_iter (GTK_TREE_VIEW (plugin_data.view), &iter); } } }
/* Expand trees (and any subtrees they may have) whose ett_ shows them as * expanded. * Callers should block calls to expand_tree() to avoid useless recursion. */ static void check_expand_trees(GtkTreeView *tree_view, GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gboolean scroll_it, gboolean expand_parent) { /* code inspired by gtk_tree_model_foreach_helper */ field_info *fi; do { GtkTreeIter child; if (gtk_tree_model_iter_children(model, &child, iter)) { gtk_tree_model_get(model, iter, 1, &fi, -1); if (tree_expanded(fi->tree_type)) { if (expand_parent) gtk_tree_view_expand_row(tree_view, path, FALSE); if (scroll_it) gtk_tree_view_scroll_to_cell(tree_view, path, NULL, TRUE, (prefs.gui_auto_scroll_percentage/100.0f), 0.0f); /* try to expand children only when parent is expanded */ gtk_tree_path_down(path); check_expand_trees(tree_view, model, path, &child, scroll_it, TRUE); gtk_tree_path_up(path); } } gtk_tree_path_next(path); } while (gtk_tree_model_iter_next(model, iter)); }
/* Remove an item from the page's current list. */ static void tp_page_remove_selected(ToolbarPage * page) { GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(page->current)); GtkTreeModel *model; GtkTreeIter iter; GtkTreePath *path; if (!gtk_tree_selection_get_selected(selection, &model, &iter)) return; path = gtk_tree_model_get_path(model, &iter); gtk_list_store_remove(GTK_LIST_STORE(model), &iter); if (gtk_tree_model_get_iter(model, &iter, path) || gtk_tree_path_prev(path)) { gtk_tree_selection_select_path(selection, path); gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(page->current), path, NULL, FALSE, 0, 0); } gtk_tree_path_free(path); gtk_widget_set_sensitive(page->standard_button, TRUE); tp_page_refresh_preview(page); #ifndef BALSA_TOOLBAR_DEBUG_ACTIONS tp_page_refresh_available(page); #else /* BALSA_TOOLBAR_DEBUG_ACTIONS */ tp_page_refresh_available(page, NULL); #endif /* BALSA_TOOLBAR_DEBUG_ACTIONS */ balsa_toolbar_model_changed(page->model); }
/* compose_add_field */ void compose_add_field(Compose * compose, char const * field, char const * value) { GtkTreeIter iter; GtkTreeIter iter2; gboolean valid; GtkTreePath * path; gtk_list_store_append(compose->h_store, &iter); gtk_list_store_set(compose->h_store, &iter, CHC_VISIBLE, TRUE, -1); if(field != NULL) gtk_list_store_set(compose->h_store, &iter, CHC_HEADER, field, -1); if(value != NULL) gtk_list_store_set(compose->h_store, &iter, CHC_VALUE, value, -1); valid = gtk_tree_model_filter_convert_child_iter_to_iter( GTK_TREE_MODEL_FILTER(compose->h_store_filter), &iter2, &iter); if(valid) { path = gtk_tree_model_get_path(GTK_TREE_MODEL( compose->h_store_filter), &iter2); gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(compose->h_view), path, NULL, TRUE, 0.0, 0.5); gtk_tree_path_free(path); } }
void list_moveto_case(list_t *list, char *name) { filter_item_t *fi; list_item_t *item = NULL; int i = 0; /* Retrieve first line of Test Case */ fi = filter_retrieve(list->fl_case.filter, name); if ( fi != NULL ) item = fi->ptr; /* Retrieve first non-filtered line of this test case */ while ( (item != NULL) && (item->flags & LIST_FLAG_FILTER) ) { if ( item->flags & LIST_FLAG_DONE ) { item = NULL; } else { i++; item = list->items[i]; } } /* Jump to the line if not filtered */ if ( (item != NULL) && (item->path != NULL) ) { gtk_tree_view_scroll_to_cell(list->tree, item->path, NULL, FALSE, 0, 0); } }
static void vdlist_scroll_to_row(ViewDir *vd, FileData *fd, gfloat y_align) { GtkTreeIter iter; #if GTK_CHECK_VERSION(2,20,0) if (gtk_widget_get_realized(vd->view) && vd_find_row(vd, fd, &iter)) #else if (GTK_WIDGET_REALIZED(vd->view) && vd_find_row(vd, fd, &iter)) #endif { GtkTreeModel *store; GtkTreePath *tpath; store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view)); tpath = gtk_tree_model_get_path(store, &iter); gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(vd->view), tpath, NULL, TRUE, y_align, 0.0); gtk_tree_view_set_cursor(GTK_TREE_VIEW(vd->view), tpath, NULL, FALSE); gtk_tree_path_free(tpath); #if GTK_CHECK_VERSION(2,20,0) if (!gtk_widget_has_focus(vd->view)) gtk_widget_grab_focus(vd->view); #else if (!GTK_WIDGET_HAS_FOCUS(vd->view)) gtk_widget_grab_focus(vd->view); #endif } }
static void mem_jmp (GtkTreeView *view, GtkEntry *entry, guint32 base_addr, gsize size, GError **err) { GtkTreeModel *model; guint32 jmp_addr; GtkTreeIter iter; jmp_addr = hexstr_to_guint32 (gtk_entry_get_text (entry), err); if (err && *err) { return; } if (jmp_addr < base_addr || jmp_addr > base_addr + size) { g_set_error (err, g_quark_from_string ("mem_jmp"), 1, "Invalid address"); return; } model = gtk_tree_view_get_model (view); if (!model) { return; } if (gtk_tree_model_get_iter_first (model, &iter)) { do { guint32 addr; GValue value = G_VALUE_INIT; GError *err = NULL; gtk_tree_model_get_value (model, &iter, 0, &value); if (G_VALUE_HOLDS_STRING (&value)) { addr = hexstr_to_guint32 (g_value_get_string (&value), &err); if (!err) { if (addr == (jmp_addr & 0xFFFFFFF0)) { GtkTreeSelection *selection; GtkTreePath *path; selection = gtk_tree_view_get_selection (view); path = gtk_tree_model_get_path (model, &iter); gtk_tree_selection_select_iter (selection, &iter); gtk_tree_view_scroll_to_cell (view, path, NULL, TRUE, 0.0, 0.0); gtk_tree_path_free (path); } } } g_value_unset (&value); } while (gtk_tree_model_iter_next (model, &iter)); } }
static void update_cb (void * data, void * user) { g_return_if_fail (treeview); GtkTreeModel * model; GtkTreeIter iter; GtkTreePath * path = NULL; if (GPOINTER_TO_INT (data) <= PLAYLIST_UPDATE_SELECTION) return; if (cache != NULL) { ui_jump_to_track_cache_free (cache); cache = NULL; } /* If it's only a metadata update, save and restore the cursor position. */ if (GPOINTER_TO_INT (data) <= PLAYLIST_UPDATE_METADATA && gtk_tree_selection_get_selected (gtk_tree_view_get_selection ((GtkTreeView *) treeview), & model, & iter)) path = gtk_tree_model_get_path (model, & iter); fill_list (); if (path != NULL) { gtk_tree_selection_select_path (gtk_tree_view_get_selection ((GtkTreeView *) treeview), path); gtk_tree_view_scroll_to_cell ((GtkTreeView *) treeview, path, NULL, TRUE, 0.5, 0); gtk_tree_path_free (path); } }
void feed_list_view_select (nodePtr node) { GtkTreeModel *model = gtk_tree_view_get_model (flv->treeview); if (model && node && node != feedlist_get_root ()) { GtkTreePath *path; /* in filtered mode we need to convert the iterator */ if (flv->feedlist_reduced_unread) { GtkTreeIter iter; gtk_tree_model_filter_convert_child_iter_to_iter (GTK_TREE_MODEL_FILTER (flv->filter), &iter, feed_list_view_to_iter (node->id)); path = gtk_tree_model_get_path (model, &iter); } else { path = gtk_tree_model_get_path (model, feed_list_view_to_iter (node->id)); } if (node->parent) feed_list_view_expand (node->parent); if (path) { gtk_tree_view_scroll_to_cell (flv->treeview, path, NULL, FALSE, 0.0, 0.0); gtk_tree_view_set_cursor (flv->treeview, path, NULL, FALSE); gtk_tree_path_free (path); } } else { GtkTreeSelection *selection = gtk_tree_view_get_selection (flv->treeview); gtk_tree_selection_unselect_all (selection); } }
G_MODULE_EXPORT void queue_list_selection_changed_cb(GtkTreeSelection *selection, signal_user_data_t *ud) { GtkTreeModel *store; GtkTreeIter iter, piter; g_debug("queue_list_selection_changed_cb ()"); // A queue entry is made up of a parent and multiple // children that are visible when expanded. When and entry // is selected, I want the parent to be selected. // This is purely cosmetic. if (gtk_tree_selection_get_selected(selection, &store, &iter)) { GtkWidget *widget = GHB_WIDGET (ud->builder, "queue_edit"); gtk_widget_set_sensitive (widget, TRUE); if (gtk_tree_model_iter_parent (store, &piter, &iter)) { GtkTreePath *path; GtkTreeView *treeview; gtk_tree_selection_select_iter (selection, &piter); path = gtk_tree_model_get_path (store, &piter); treeview = gtk_tree_selection_get_tree_view (selection); // Make the parent visible in scroll window if it is not. gtk_tree_view_scroll_to_cell (treeview, path, NULL, FALSE, 0, 0); gtk_tree_path_free(path); } } else { GtkWidget *widget = GHB_WIDGET (ud->builder, "queue_edit"); gtk_widget_set_sensitive (widget, FALSE); } }
static void cv_tree_focus(chan * ch) { GtkTreeView *tree = ((treeview *) ch->cv)->tree; GtkTreeModel *model = gtk_tree_view_get_model(tree); GtkTreePath *path; GtkTreeIter parent; /* expand the parent node */ if (gtk_tree_model_iter_parent(model, &parent, &ch->iter)) { path = gtk_tree_model_get_path(model, &parent); if (path) { /*if (!gtk_tree_view_row_expanded (tree, path)) { gtk_tree_path_free (path); return; } */ gtk_tree_view_expand_row(tree, path, FALSE); gtk_tree_path_free(path); } } path = gtk_tree_model_get_path(model, &ch->iter); if (path) { gtk_tree_view_scroll_to_cell(tree, path, NULL, TRUE, 0.5, 0.5); gtk_tree_view_set_cursor(tree, path, NULL, FALSE); gtk_tree_path_free(path); } }
void mdm_lang_set (char *language) { char *locale; GtkTreeSelection *selection; GtkTreeIter iter = {0}; g_free (current_language); current_language = g_strdup (language); if (dialog == NULL) mdm_lang_setup_treeview (); if (language == NULL) return; lang_set_custom_callback (language); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tv)); gtk_tree_selection_unselect_all (selection); if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (lang_model), &iter)) { do { gtk_tree_model_get (GTK_TREE_MODEL (lang_model), &iter, LOCALE_COLUMN, &locale, -1); if (locale != NULL && strcmp (locale, language) == 0) { GtkTreePath *path = gtk_tree_model_get_path (GTK_TREE_MODEL (lang_model), &iter); gtk_tree_selection_select_iter (selection, &iter); gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (tv), path, NULL, FALSE, 0.0, 0.0); gtk_tree_path_free (path); break; } } while (gtk_tree_model_iter_next (GTK_TREE_MODEL (lang_model), &iter)); } }
static void expand_tree(GtkTreeView *tree_view, GtkTreeIter *iter, GtkTreePath *path, gpointer user_data _U_) { field_info *finfo; GtkTreeModel *model; model = gtk_tree_view_get_model(tree_view); gtk_tree_model_get(model, iter, 1, &finfo, -1); g_assert(finfo); /* scroll the expanded item to reduce the need to do a manual scroll down * and provide faster navigation of deeper trees */ if(prefs.gui_auto_scroll_on_expand) gtk_tree_view_scroll_to_cell(tree_view, path, NULL, TRUE, (prefs.gui_auto_scroll_percentage/100.0f), 0.0f); /* * Nodes with "finfo->tree_type" of -1 have no ett_ value, and * are thus presumably leaf nodes and cannot be expanded. */ if (finfo->tree_type != -1) tree_expanded_set(finfo->tree_type, TRUE); if (finfo->tree_type != -1 && path) { /* Expand any subtrees that the user had left open */ g_signal_handlers_block_by_func(tree_view, expand_tree, NULL); check_expand_trees(tree_view, model, path, iter, FALSE, FALSE); g_signal_handlers_unblock_by_func(tree_view, expand_tree, NULL); } }
void wxListBox::DoSetSelection( int n, bool select ) { wxCHECK_RET( m_treeview != NULL, wxT("invalid listbox") ); wxGtkEventsDisabler<wxListBox> noEvents(this); GtkTreeSelection* selection = gtk_tree_view_get_selection(m_treeview); // passing -1 to SetSelection() is documented to deselect all items if ( n == wxNOT_FOUND ) { gtk_tree_selection_unselect_all(selection); return; } wxCHECK_RET( IsValid(n), wxT("invalid index in wxListBox::SetSelection") ); GtkTreeIter iter; wxCHECK_RET( GTKGetIteratorFor(n, &iter), wxT("Invalid index") ); if (select) gtk_tree_selection_select_iter(selection, &iter); else gtk_tree_selection_unselect_iter(selection, &iter); wxGtkTreePath path( gtk_tree_model_get_path(GTK_TREE_MODEL(m_liststore), &iter)); gtk_tree_view_scroll_to_cell(m_treeview, path, NULL, FALSE, 0.0f, 0.0f); }
void msgwin_compiler_add_string(gint msg_color, const gchar *msg) { GtkTreeIter iter; GtkTreePath *path; const GdkColor *color = get_color(msg_color); gchar *utf8_msg; if (! g_utf8_validate(msg, -1, NULL)) utf8_msg = utils_get_utf8_from_locale(msg); else utf8_msg = (gchar *) msg; gtk_list_store_append(msgwindow.store_compiler, &iter); gtk_list_store_set(msgwindow.store_compiler, &iter, COMPILER_COL_COLOR, color, COMPILER_COL_STRING, utf8_msg, -1); if (ui_prefs.msgwindow_visible && interface_prefs.compiler_tab_autoscroll) { path = gtk_tree_model_get_path( gtk_tree_view_get_model(GTK_TREE_VIEW(msgwindow.tree_compiler)), &iter); gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(msgwindow.tree_compiler), path, NULL, TRUE, 0.5, 0.5); gtk_tree_path_free(path); } /* calling build_menu_update for every build message would be overkill, TODO really should call it once when all done */ gtk_widget_set_sensitive(build_get_menu_items(-1)->menu_item[GBG_FIXED][GBF_NEXT_ERROR], TRUE); gtk_widget_set_sensitive(build_get_menu_items(-1)->menu_item[GBG_FIXED][GBF_PREV_ERROR], TRUE); if (utf8_msg != msg) g_free(utf8_msg); }
static void changed(GtkTreeSelection *treeselection, gpointer user_data) { GtkWidget *list = static_cast<GtkWidget *>(user_data); list_priv_t *priv = static_cast<list_priv_t *>(g_object_get_data(G_OBJECT(list), "priv")); GtkTreeModel *model; GtkTreeIter iter; bool selected = list_get_selected(list, &model, &iter); /* scroll to selected entry if exactly one is selected */ if(selected) { /* check if the entry isn't already visible */ GtkTreePath *start = nullptr, *end = nullptr; tree_path_guard path(gtk_tree_model_get_path(model, &iter)); gtk_tree_view_get_visible_range(priv->view, &start, &end); tree_path_guard sguard(start), eguard(end); /* check if path is before start of visible area or behin end of it */ if((sguard && (gtk_tree_path_compare(path.get(), sguard.get())) < 0) || (eguard && (gtk_tree_path_compare(path.get(), eguard.get()) > 0))) gtk_tree_view_scroll_to_cell(priv->view, path.get(), nullptr, TRUE, 0.5, 0.5); } /* the change event handler is overridden */ priv->change(treeselection, priv->callback_context); }
static void search_selection_changed(GtkTreeSelection * treeselection, gpointer user_data) { GtkTreeIter iter; GtkTreePath * path; GtkTreePath * path_up; gpointer gptr1; gpointer gptr2; playlist_t * pl; if (!gtk_tree_selection_get_selected(search_select, NULL, &iter)) { return; } gtk_tree_model_get(GTK_TREE_MODEL(search_store), &iter, 1, &gptr1, 3, &gptr2, -1); path = (GtkTreePath *)gptr1; path_up = gtk_tree_path_copy(path); pl = (playlist_t *)gptr2; if (gtk_tree_path_up(path_up)) { gtk_tree_view_expand_row(GTK_TREE_VIEW(pl->view), path_up, FALSE); } gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(pl->view), path, NULL, TRUE, 0.5f, 0.5f); gtk_tree_view_set_cursor(GTK_TREE_VIEW(pl->view), path, NULL, FALSE); playlist_set_current(pl); gtk_tree_path_free(path_up); }
static void showed_message_cb (GtrTab * tab, GtrMsg * msg, GtrMessageTable * table) { GtkTreePath *path; GtkTreeSelection *selection; GtkTreeIter iter, child_iter; GtrMessageTablePrivate *priv; priv = gtr_message_table_get_instance_private (table); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview)); gtr_message_table_get_message_iter (priv->store, msg, &child_iter); gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (priv->sort_model), &iter, &child_iter); gtk_tree_selection_select_iter (selection, &iter); path = gtk_tree_model_get_path (priv->sort_model, &iter); gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (priv->treeview), path, NULL, TRUE, 0.5, 0.0); gtk_tree_path_free (path); }
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 tourney_result(PIECE win, int moves) { GtkTreeIter iter; GtkTreePath *path; int game = tourney_total - tournament + 1; char *filename; tourney_wins[win]++; /* Add game to list */ gtk_list_store_append(tourney_store, &iter); gtk_list_store_set(tourney_store, &iter, 0, piece_to_string(win), 1, moves, 2, game, -1); /* Scroll games list down */ path = gtk_tree_model_get_path(GTK_TREE_MODEL(tourney_store), &iter); gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(tourney_view), path, NULL, FALSE, 0., 0.); gtk_tree_path_free(path); /* Save the tournament game */ if (tourney_prefix_str) { filename = g_strdup(va("%s%d", tourney_prefix_str, game)); save_moves_list(filename); g_free(filename); } if (--tournament > 0) { new_game(board_size); return; } tourney_dialog_stop(NULL); }
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 AP_UnixDialog_Stylist::setStyleInGUI(void) { UT_sint32 row,col; UT_UTF8String sCurStyle = *getCurStyle(); if((getStyleTree() == NULL) || (sCurStyle.size() == 0)) updateDialog(); if(m_wStyleList == NULL) return; if(isStyleTreeChanged()) _fillTree(); getStyleTree()->findStyle(sCurStyle,row,col); UT_DEBUGMSG(("After findStyle row %d col %d col \n",row,col)); UT_UTF8String sPathFull = UT_UTF8String_sprintf("%d:%d",row,col); UT_UTF8String sPathRow = UT_UTF8String_sprintf("%d",row); UT_DEBUGMSG(("Full Path string is %s \n",sPathFull.utf8_str())); GtkTreePath * gPathRow = gtk_tree_path_new_from_string (sPathRow.utf8_str()); GtkTreePath * gPathFull = gtk_tree_path_new_from_string (sPathFull.utf8_str()); gtk_tree_view_expand_row( GTK_TREE_VIEW(m_wStyleList),gPathRow,TRUE); gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(m_wStyleList),gPathFull,NULL,TRUE,0.5,0.5); gtk_tree_view_set_cursor(GTK_TREE_VIEW(m_wStyleList),gPathFull,NULL,TRUE); setStyleChanged(false); gtk_tree_path_free(gPathRow); gtk_tree_path_free(gPathFull); }
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 void remmina_main_select_file(RemminaMain *remminamain, const gchar *filename) { GtkTreeIter iter; GtkTreePath *path; gchar *item_filename; gboolean cmp; if (!gtk_tree_model_get_iter_first(remminamain->priv->file_model_sort, &iter)) return; while (1) { gtk_tree_model_get(remminamain->priv->file_model_sort, &iter, FILENAME_COLUMN, &item_filename, -1); cmp = g_strcmp0(item_filename, filename); g_free(item_filename); if (cmp == 0) { gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(remminamain->priv->file_list)), &iter); path = gtk_tree_model_get_path(remminamain->priv->file_model_sort, &iter); gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(remminamain->priv->file_list), path, NULL, TRUE, 0.5, 0.0); gtk_tree_path_free(path); return; } if (!gtk_tree_model_iter_next(remminamain->priv->file_model_sort, &iter)) return; } }