static void thunar_uca_chooser_up_clicked (ThunarUcaChooser *uca_chooser) { GtkTreeSelection *selection; GtkTreeModel *model; GtkTreePath *path; GtkTreeIter iter_a; GtkTreeIter iter_b; g_return_if_fail (THUNAR_UCA_IS_CHOOSER (uca_chooser)); /* determine the currently selected item */ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (uca_chooser->treeview)); if (gtk_tree_selection_get_selected (selection, &model, &iter_a)) { /* determine the tree path to the iter */ path = gtk_tree_model_get_path (model, &iter_a); if (gtk_tree_path_prev (path)) { /* determine the iter for the previous item */ gtk_tree_model_get_iter (model, &iter_b, path); /* perform the exchange operation */ thunar_uca_chooser_exchange (uca_chooser, selection, model, &iter_a, &iter_b); } /* release the path */ gtk_tree_path_free (path); } }
static void epif_remove_header_clicked (GtkButton *button, EPImapFeaturesData *ui) { GtkTreeSelection *select; GtkTreeModel *model; GtkTreeIter iter, first; GtkTreePath *path; gboolean valid = TRUE; select = gtk_tree_view_get_selection (ui->custom_headers_tree); if (gtk_tree_selection_get_selected (select, &model, &iter)) { path = gtk_tree_model_get_path (model, &iter); gtk_tree_store_remove(GTK_TREE_STORE(model), &iter); if (gtk_tree_path_prev (path)) { gtk_tree_model_get_iter (model, &iter, path); } else { valid = gtk_tree_model_get_iter_first (model, &iter); } if (valid) gtk_tree_selection_select_iter (select, &iter); } if (gtk_tree_model_get_iter_first (model, &first)==FALSE) gtk_widget_set_sensitive (GTK_WIDGET (button), FALSE); epif_add_sensitivity (ui); }
static void move_up_clicked_callback (GtkWidget *button, gpointer user_data) { NautilusColumnChooser *chooser; GtkTreeIter iter; GtkTreeSelection *selection; chooser = NAUTILUS_COLUMN_CHOOSER (user_data); selection = gtk_tree_view_get_selection (chooser->details->view); if (gtk_tree_selection_get_selected (selection, NULL, &iter)) { GtkTreePath *path; GtkTreeIter prev; path = gtk_tree_model_get_path (GTK_TREE_MODEL (chooser->details->store), &iter); gtk_tree_path_prev (path); if (gtk_tree_model_get_iter (GTK_TREE_MODEL (chooser->details->store), &prev, path)) { gtk_list_store_move_before (chooser->details->store, &iter, &prev); } gtk_tree_path_free (path); } list_changed (chooser); }
static void sequence_prev (void) { GtkTreeIter iter; GtkTreePath *path; GtkTreeSelection *selection; selection = gtk_tree_view_get_selection (sequence_view); if (!gtk_tree_selection_get_selected (selection, NULL, &iter)) return; path = gtk_tree_model_get_path (GTK_TREE_MODEL (sequence_store), &iter); if (!gtk_tree_path_prev (path)) return; if (sequence_source_id > 0) { current_step->progress = 0; gtk_tree_model_get (GTK_TREE_MODEL (sequence_store), &iter, COLUMN_DATA, ¤t_step, -1); current_step->progress = 0; } gtk_tree_selection_select_path (selection, path); sequence_scroll_to_selected (); }
void on_btn_up_clicked (GtkButton *button, gpointer user_data) { GtkTreeModel *treemodel; GtkTreeIter iter, previous; GtkTreeSelection *sel; GtkTreePath *path; gint i, *indice; GList *launcher; sel = gtk_tree_view_get_selection( GTK_TREE_VIEW(_dlg->treeview1) ); if ( gtk_tree_selection_get_selected(sel, &treemodel, &iter) ) { path = gtk_tree_model_get_path(treemodel, &iter); if ( gtk_tree_path_prev(path) ) { if (gtk_tree_model_get_iter(treemodel, &previous, path)) gtk_list_store_swap(GTK_LIST_STORE(treemodel), &iter, &previous); indice = gtk_tree_path_get_indices(path); launcher = g_list_nth(_quicklauncher->launchers, indice[0]+1); _quicklauncher->launchers = g_list_remove_link(_quicklauncher->launchers, launcher); _quicklauncher->launchers = g_list_insert(_quicklauncher->launchers, launcher->data, indice[0]); quicklauncher_empty_widgets(); quicklauncher_organize(); g_list_free(launcher); } gtk_tree_path_free(path); } }
void dat_moveup_templ_cb(GtkButton *button, gpointer user_data) { GncABTransDialog *td = user_data; GtkTreeSelection *selection; GtkTreeModel *model; GtkTreeIter iter; GtkTreePath *prev_path; GtkTreeIter prev_iter; g_return_if_fail(td); selection = gtk_tree_view_get_selection(td->template_gtktreeview); if (!gtk_tree_selection_get_selected(selection, &model, &iter)) return; prev_path = gtk_tree_model_get_path(model, &iter); if (gtk_tree_path_prev(prev_path)) { if (gtk_tree_model_get_iter(model, &prev_iter, prev_path)) { gtk_list_store_move_before(GTK_LIST_STORE(model), &iter, &prev_iter); td->templ_changed = TRUE; } } gtk_tree_path_free(prev_path); }
static bool iopen_other_keys(editor_t *editor, bool shift, bool ctrl, bool alt, bool super, guint keyval) { if (!shift && !ctrl && !alt && !super) { GtkTreePath *path; switch (keyval) { case GDK_KEY_Up: gtk_tree_view_get_cursor(GTK_TREE_VIEW(results_tree), &path, NULL); if (path == NULL) { path = gtk_tree_path_new_first(); } else { gtk_tree_path_prev(path); } gtk_tree_view_set_cursor(GTK_TREE_VIEW(results_tree), path, NULL, FALSE); gtk_tree_path_free(path); return true; case GDK_KEY_Down: gtk_tree_view_get_cursor(GTK_TREE_VIEW(results_tree), &path, NULL); if (path == NULL) { path = gtk_tree_path_new_first(); } else { gtk_tree_path_next(path); } gtk_tree_view_set_cursor(GTK_TREE_VIEW(results_tree), path, NULL, FALSE); gtk_tree_path_free(path); return true; } } return false; }
/** * Try to select the bookmark before the current one. * If none is selected the last in the list is picked. * Wraps around. */ void AP_UnixDialog_Goto::_selectPrevBookmark () { UT_DEBUGMSG (("ROB: AP_UnixDialog_Goto::_selectPrevBookmark ()\n")); GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (m_lvBookmarks)); UT_return_if_fail (model != NULL); GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (m_lvBookmarks)); GtkTreeIter iter; // try to select prev gboolean haveSelected = gtk_tree_selection_get_selected (selection, &model, &iter); if (haveSelected) { GtkTreePath *path = gtk_tree_model_get_path (model, &iter); gtk_tree_path_prev (path); gboolean havePrev = gtk_tree_model_get_iter (model, &iter, path); if (havePrev) { gtk_tree_selection_select_path (selection, path); gtk_tree_path_free (path); return; } gtk_tree_path_free (path); } // select last UT_uint32 idx = getExistingBookmarksCount () - 1; GtkTreePath *path = gtk_tree_path_new_from_indices (idx); gtk_tree_selection_select_path (selection, path); UT_DEBUGMSG (("ROB: AP_UnixDialog_Goto::_selectPrevBookmark () select last '%d'\n", gtk_tree_model_get_iter (model, &iter, path))); gtk_tree_path_free (path); }
/**************************************************************** Move item up in worklist *****************************************************************/ static void queue_bubble_up(struct worklist_data *ptr) { GtkTreePath *path; GtkTreeViewColumn *col; GtkTreeModel *model; if (!gtk_widget_is_sensitive(ptr->dst_view)) { return; } model = GTK_TREE_MODEL(ptr->dst); gtk_tree_view_get_cursor(GTK_TREE_VIEW(ptr->dst_view), &path, &col); if (path) { GtkTreeIter it, it_prev; if (gtk_tree_path_prev(path)) { gtk_tree_model_get_iter(model, &it_prev, path); it = it_prev; gtk_tree_model_iter_next(model, &it); gtk_list_store_swap(GTK_LIST_STORE(model), &it, &it_prev); gtk_tree_view_set_cursor(GTK_TREE_VIEW(ptr->dst_view), path, col, FALSE); commit_worklist(ptr); } } gtk_tree_path_free(path); }
void list_store_remove_selected_cb(GtkWidget *w, gpointer client_data) { GtkTreeSelection *sel; GList *selected, *data; GtkTreeModel *model; gboolean found; GtkTreeIter iter; GtkTreePath *first_path = NULL; sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(client_data)); selected = gtk_tree_selection_get_selected_rows(sel, &model); if (selected == NULL) return; for (data = g_list_last(selected); data; data = data->prev) { found = gtk_tree_model_get_iter(model, &iter, data->data); if (found) { gtk_list_store_remove(GTK_LIST_STORE(model), &iter); } first_path = data->data; } if (first_path) { if (! gtk_tree_model_get_iter(model, &iter, first_path)) { gtk_tree_path_prev(first_path); } gtk_tree_view_set_cursor(GTK_TREE_VIEW(client_data), first_path, NULL, FALSE); } g_list_foreach(selected, free_tree_path_cb, NULL); g_list_free(selected); }
static void clue_check_isempty (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, UIData *ui) { GtkTreeSelection *selection; gchar *keyword = NULL; gboolean valid; selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (ui->treeview)); /* move to the previous node */ valid = gtk_tree_path_prev (path); gtk_tree_model_get (model, iter, CLUE_KEYWORD_COLUMN, &keyword, -1); if ((keyword) && !(g_utf8_strlen (g_strstrip (keyword), -1) > 0)) gtk_list_store_remove (ui->store, iter); /* Check if we have a valid row to select. If not, then select * the previous row */ if (gtk_list_store_iter_is_valid (GTK_LIST_STORE (model), iter)) { gtk_tree_selection_select_iter (selection, iter); } else { if (path && valid) { gtk_tree_model_get_iter (model, iter, path); gtk_tree_selection_select_iter (selection, iter); } } gtk_widget_grab_focus (ui->treeview); g_free (keyword); }
static void remove_selected_input (GtkButton *button, gpointer data) { GtkBuilder *builder = data; GtkTreeModel *model; GtkTreeIter iter; GtkTreePath *path; g_debug ("remove selected input source"); if (get_selected_iter (builder, &model, &iter) == FALSE) 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); set_selected_path (builder, path); gtk_tree_path_free (path); update_button_sensitivity (builder); update_configuration (model); }
static void dict_list_up_clicked_cb (GtkButton *button, gpointer userdata) { GtkTreeView *view = GTK_TREE_VIEW(userdata); GtkTreeModel *model = gtk_tree_view_get_model(view); GtkTreeSelection *selection = gtk_tree_view_get_selection(view); GtkTreeIter iter; if (gtk_tree_selection_get_selected(selection, NULL, &iter)) { GtkTreePath *path; GtkTreeIter prev_iter; int i; path = gtk_tree_model_get_path(model, &iter); i = gtk_tree_path_get_indices(path)[0]; if (i != 0) { vector<String>::iterator it = __config_sysdicts.begin() + i; vector<String>::iterator it2 = it - 1; iter_swap(it, it2); __have_changed = true; } if (gtk_tree_path_prev(path) && gtk_tree_model_get_iter(model, &prev_iter, path)) { gtk_list_store_move_before(GTK_LIST_STORE(model), &iter, &prev_iter); } gtk_tree_path_free(path); } }
static void delete_log_cb(gpointer *data) { if (!purple_log_delete((PurpleLog *)data[2])) { purple_notify_error(NULL, NULL, _("Log Deletion Failed"), _("Check permissions and try again.")); } else { GtkTreeStore *treestore = data[0]; GtkTreeIter *iter = (GtkTreeIter *)data[1]; GtkTreePath *path = gtk_tree_model_get_path(GTK_TREE_MODEL(treestore), iter); gboolean first = !gtk_tree_path_prev(path); #if GTK_CHECK_VERSION(2,2,0) if (!gtk_tree_store_remove(treestore, iter) && first) { /* iter was the last child at its level */ if (gtk_tree_path_up(path)) { gtk_tree_model_get_iter(GTK_TREE_MODEL(treestore), iter, path); gtk_tree_store_remove(treestore, iter); } } #else gtk_tree_store_remove(treestore, iter); #endif gtk_tree_path_free(path); } delete_log_cleanup_cb(data); }
static void gdvd_button_delete_callback(GtkWidget *widget, GalDefineViewsDialog *dialog) { int row; GtkTreeIter iter; GtkTreePath *path; GtkTreeSelection *selection; GalViewCollectionItem *item; selection = gtk_tree_view_get_selection (dialog->treeview); if (gtk_tree_selection_get_selected (selection, &dialog->model, &iter)) { gtk_tree_model_get (dialog->model, &iter, COL_GALVIEW_DATA, &item, -1); for (row=0; row<dialog->collection->view_count; row++) { if (item == dialog->collection->view_data[row]) { gal_view_collection_delete_view (dialog->collection, row); path = gtk_tree_model_get_path (dialog->model, &iter); gtk_list_store_remove (GTK_LIST_STORE (dialog->model), &iter); if (gtk_tree_path_prev (path)) { gtk_tree_model_get_iter (dialog->model, &iter, path); } else { gtk_tree_model_get_iter_first (dialog->model, &iter); } gtk_tree_selection_select_iter (selection, &iter); break; } } } }
static void move_row (chan *ch, int delta, GtkTreeIter *parent) { GtkTreeStore *store = ch->cv->store; GtkTreeIter *src = &ch->iter; GtkTreeIter dest = ch->iter; GtkTreePath *dest_path; if (delta < 0) /* down */ { if (gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &dest)) gtk_tree_store_swap (store, src, &dest); else /* move to top */ gtk_tree_store_move_after (store, src, NULL); } else { dest_path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &dest); if (gtk_tree_path_prev (dest_path)) { gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &dest, dest_path); gtk_tree_store_swap (store, src, &dest); } else { /* move to bottom */ gtk_tree_store_move_before (store, src, NULL); } gtk_tree_path_free (dest_path); } }
static void prefs_dialog_sensor_up_button_clicked(GtkButton *button, PrefsDialog *prefs_dialog) { GtkTreeModel *model; GtkTreeIter iter; GtkTreePath *path; if (gtk_tree_selection_get_selected(prefs_dialog->sensors_applet->selection, &model, &iter)) { /* if has no prev node set up button insentive */ path = gtk_tree_model_get_path(model, &iter); if (gtk_tree_path_prev(path)) { GtkTreeIter prev_iter; /* check is a valid node in out model */ if (gtk_tree_model_get_iter(model, &prev_iter, path)) { gtk_tree_store_move_before(GTK_TREE_STORE(model), &iter, &prev_iter); g_signal_emit_by_name(prefs_dialog->sensors_applet->selection, "changed"); sensors_applet_reorder_sensors(prefs_dialog->sensors_applet); } } gtk_tree_path_free(path); } }
static void prefs_custom_header_up(void) { GtkTreePath *prev, *sel; GtkTreeIter isel; GtkListStore *store = NULL; GtkTreeModel *model = NULL; GtkTreeIter iprev; if (!gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW(customhdr.list_view)), &model, &isel)) return; store = (GtkListStore *)model; sel = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &isel); if (!sel) return; /* no move if we're at row 0... */ prev = gtk_tree_path_copy(sel); if (!gtk_tree_path_prev(prev)) { gtk_tree_path_free(prev); gtk_tree_path_free(sel); return; } gtk_tree_model_get_iter(GTK_TREE_MODEL(store), &iprev, prev); gtk_tree_path_free(sel); gtk_tree_path_free(prev); gtk_list_store_swap(store, &iprev, &isel); prefs_custom_header_set_list(cur_ac); }
/* * Shift entry up */ gboolean shift_entry_up() { GtkTreePath *entry_path = NULL; GtkTreeView *entry_view = NULL; GtkTreeModel *entry_model = NULL; GtkTreeSelection *entry_selection = NULL; GtkTreeViewColumn *entry_column = NULL; GtkTreeIter entry_iter; book_data *book = NULL; section_data *section = NULL; entry_data *entry = NULL; guint entry_index = 0; // Assert master exists g_assert_nonnull(master); // Get currently selected book = get_current_book_or_return_with_warning(); section = get_current_section_or_return_with_warning(); // Get entry model and view entry_view = get_entry_view(book); entry_model = gtk_tree_view_get_model(entry_view); sn_trace0("Shifting entry up."); // Make sure we are not at the top gtk_tree_view_get_cursor (entry_view, &entry_path, &entry_column); if(entry_path != NULL) { if(gtk_tree_path_prev(entry_path)) { // Get the entry to move up entry_selection = gtk_tree_view_get_selection(entry_view); if(gtk_tree_selection_get_selected (entry_selection, &entry_model, &entry_iter)) { gtk_tree_model_get(entry_model, &entry_iter, ENTRY_ITEM, &entry, END_OF_LIST); // Move entry up if(entry != NULL) { entry_index = g_list_index(section->entry_list, entry); section->entry_list = g_list_remove(section->entry_list, entry); section->entry_list = g_list_insert (section->entry_list, entry, --entry_index); // Write book write_book(book, note_dir); } } // Populate entries populate_entries(book, section); gtk_tree_view_set_cursor (entry_view, entry_path, entry_column, FALSE); } gtk_tree_path_free(entry_path); } return TRUE; } // Shift entry up
/** * Advance selection to previous/next item in list. * \param list_view List to process. * \param forward Set to <i>TRUE</i> to select next or <i>FALSE</i> for * previous entry. */ static void completion_window_advance_selection(GtkTreeView *list_view, gboolean forward) { GtkTreeSelection *selection; GtkTreeIter iter; GtkTreeModel *model; cm_return_if_fail(list_view != NULL); selection = gtk_tree_view_get_selection(list_view); if (!gtk_tree_selection_get_selected(selection, &model, &iter)) return; if (forward) { forward = gtk_tree_model_iter_next(model, &iter); if (forward) gtk_tree_selection_select_iter(selection, &iter); } else { GtkTreePath *prev; prev = gtk_tree_model_get_path(model, &iter); if (!prev) return; if (gtk_tree_path_prev(prev)) gtk_tree_selection_select_path(selection, prev); gtk_tree_path_free(prev); } }
/* 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); }
static void gimp_path_editor_move_clicked (GtkWidget *widget, GimpPathEditor *editor) { GtkTreePath *path; GtkTreeModel *model; GtkTreeIter iter1, iter2; gchar *utf81, *utf82; gchar *dir1, *dir2; gboolean writable1, writable2; if (editor->sel_path == NULL) return; path = gtk_tree_path_copy (editor->sel_path); if (widget == editor->up_button) gtk_tree_path_prev (path); else gtk_tree_path_next (path); model = GTK_TREE_MODEL (editor->dir_list); gtk_tree_model_get_iter (model, &iter1, editor->sel_path); gtk_tree_model_get_iter (model, &iter2, path); gtk_tree_model_get (model, &iter1, COLUMN_UTF8, &utf81, COLUMN_DIRECTORY, &dir1, COLUMN_WRITABLE, &writable1, -1); gtk_tree_model_get (model, &iter2, COLUMN_UTF8, &utf82, COLUMN_DIRECTORY, &dir2, COLUMN_WRITABLE, &writable2, -1); gtk_list_store_set (editor->dir_list, &iter1, COLUMN_UTF8, utf82, COLUMN_DIRECTORY, dir2, COLUMN_WRITABLE, writable2, -1); gtk_list_store_set (editor->dir_list, &iter2, COLUMN_UTF8, utf81, COLUMN_DIRECTORY, dir1, COLUMN_WRITABLE, writable1, -1); g_free (utf81); g_free (utf82); g_free (dir2); g_free (dir1); gtk_tree_selection_select_iter (editor->sel, &iter2); g_signal_emit (editor, gimp_path_editor_signals[PATH_CHANGED], 0); }
static void tree_view_move_focus (GtkTreeView *view, GtkMovementStep step, gint amount) { GtkTreeIter iter; GtkTreePath *path; GtkTreeModel *model = gtk_tree_view_get_model (view); gboolean valid = FALSE; gtk_tree_view_get_cursor (view, &path, NULL); if (! path) { valid = gtk_tree_model_get_iter_first (model, &iter); } else { switch (step) { case GTK_MOVEMENT_BUFFER_ENDS: valid = gtk_tree_model_get_iter_first (model, &iter); if (valid && amount > 0) { GtkTreeIter prev; do { prev = iter; } while (gtk_tree_model_iter_next (model, &iter)); iter = prev; } break; case GTK_MOVEMENT_PAGES: /* FIXME: move by page */ case GTK_MOVEMENT_DISPLAY_LINES: gtk_tree_model_get_iter (model, &iter, path); if (amount > 0) { while ((valid = gtk_tree_model_iter_next (model, &iter)) && --amount > 0) ; } else if (amount < 0) { while ((valid = gtk_tree_path_prev (path)) && --amount > 0) ; if (valid) { gtk_tree_model_get_iter (model, &iter, path); } } break; default: g_assert_not_reached (); } gtk_tree_path_free (path); } if (valid) { tree_view_set_cursor_from_iter (view, &iter); } else { gtk_widget_error_bell (GTK_WIDGET (view)); } }
static void gimp_path_editor_delete_clicked (GtkWidget *widget, GimpPathEditor *editor) { GtkTreeIter iter; gboolean dir_writable; if (editor->sel_path == NULL) return; gtk_tree_model_get_iter (GTK_TREE_MODEL (editor->dir_list), &iter, editor->sel_path); gtk_tree_model_get (GTK_TREE_MODEL (editor->dir_list), &iter, COLUMN_WRITABLE, &dir_writable, -1); gtk_list_store_remove (editor->dir_list, &iter); editor->num_items--; if (editor->num_items == 0) { gtk_tree_path_free (editor->sel_path); editor->sel_path = NULL; g_signal_handlers_block_by_func (editor->file_entry, gimp_path_editor_file_entry_changed, editor); gimp_file_entry_set_filename (GIMP_FILE_ENTRY (editor->file_entry), ""); g_signal_handlers_unblock_by_func (editor->file_entry, gimp_path_editor_file_entry_changed, editor); gtk_widget_set_sensitive (editor->delete_button, FALSE); gtk_widget_set_sensitive (editor->up_button, FALSE); gtk_widget_set_sensitive (editor->down_button, FALSE); gtk_widget_set_sensitive (editor->file_entry, FALSE); } else { gint *indices; indices = gtk_tree_path_get_indices (editor->sel_path); if ((indices[0] == editor->num_items) && (indices[0] > 0)) gtk_tree_path_prev (editor->sel_path); gtk_tree_selection_select_path (editor->sel, editor->sel_path); } g_signal_emit (editor, gimp_path_editor_signals[PATH_CHANGED], 0); if (dir_writable) g_signal_emit (editor, gimp_path_editor_signals[WRITABLE_CHANGED], 0); }
/* Test whether the iter addresses the first row. */ static gboolean tp_list_iter_is_first(GtkWidget * list, GtkTreeIter * iter) { GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(list)); GtkTreePath *path = gtk_tree_model_get_path(model, iter); gboolean ret_val = !gtk_tree_path_prev(path); gtk_tree_path_free(path); return ret_val; }
/** * Move account in list depending on direction and selected account */ static void account_move(gboolean move_up, gpointer data) { // Get view, model and selection of account GtkTreeView *tree_view = GTK_TREE_VIEW(data); GtkTreeModel *model = gtk_tree_view_get_model(tree_view); GtkTreeSelection *selection = gtk_tree_view_get_selection(tree_view); // Find selected iteration and create a copy GtkTreeIter iter; gtk_tree_selection_get_selected(selection, &model, &iter); GtkTreeIter *iter_copy; iter_copy = gtk_tree_iter_copy(&iter); // Find path of iteration gchar *path = gtk_tree_model_get_string_from_iter(model, &iter); // The first real account in the list can't move up because of the IP2IP account // It can still move down though if (g_strcmp0(path, "1") == 0 && move_up) return; GtkTreePath *tree_path = gtk_tree_path_new_from_string(path); gint *indices = gtk_tree_path_get_indices(tree_path); const gint pos = indices[0] - 1; /* black magic : gtk tree order is not account queue order */ // Depending on button direction get new path if (move_up) gtk_tree_path_prev(tree_path); else gtk_tree_path_next(tree_path); gtk_tree_model_get_iter(model, &iter, tree_path); // Swap iterations if valid if (gtk_list_store_iter_is_valid(GTK_LIST_STORE(model), &iter)) gtk_list_store_swap(GTK_LIST_STORE(model), &iter, iter_copy); // Scroll to new position gtk_tree_view_scroll_to_cell(tree_view, tree_path, NULL, FALSE, 0, 0); // Free resources gtk_tree_path_free(tree_path); gtk_tree_iter_free(iter_copy); g_free(path); // Perpetuate changes in account queue if (move_up) account_list_move_up(pos); else account_list_move_down(pos); // Set the order in the configuration file gchar *ordered_account_list = account_list_get_ordered_list(); dbus_set_accounts_order(ordered_account_list); g_free(ordered_account_list); }
/** @brief delete selected row(s), if any, from @a treeview @param treeview where the action is to occur @return */ void e2_tree_delete (GtkTreeView *treeview) { GtkTreeSelection *sel = gtk_tree_view_get_selection (treeview); if (gtk_tree_selection_count_selected_rows (sel) > 0) { GtkTreeModel *model; GList *tmp, *rowrefs = NULL; GList *selpaths = gtk_tree_selection_get_selected_rows (sel, &model); //identify a place to goto after the deletion //(current place, if we're at the start of the tree) GtkTreePath *newpath = gtk_tree_path_copy (selpaths->data); if (!gtk_tree_path_prev (newpath)) if (gtk_tree_path_get_depth (newpath) > 1) gtk_tree_path_up (newpath); GtkTreePath *path; GtkTreeIter iter; //create treerowrefs for all selected rows for (tmp = selpaths; tmp!=NULL; tmp=tmp->next) { path = (GtkTreePath *) tmp->data; if (gtk_tree_model_get_iter (model, &iter, path)) _e2_tree_reference_treerow (model, &iter, &rowrefs); gtk_tree_path_free (path); } g_list_free (selpaths); for (tmp = rowrefs; tmp != NULL; tmp = tmp->next) { path = gtk_tree_row_reference_get_path ((GtkTreeRowReference *) tmp->data); if (path != NULL) { if (gtk_tree_model_get_iter (model, &iter, path)) { //gtk_tree_selection_unselect_path (sel, path); //needed ? //this deletes all children too gtk_tree_store_remove (GTK_TREE_STORE (model), &iter); } gtk_tree_path_free (path); } gtk_tree_row_reference_free ((GtkTreeRowReference *) tmp->data); } g_list_free (rowrefs); //go to the new place if (!gtk_tree_model_get_iter (model, &iter, newpath) && gtk_tree_model_get_iter_first (model, &iter)) { gtk_tree_path_free (newpath); newpath = gtk_tree_model_get_path (model, &iter); } gtk_tree_view_set_cursor (treeview, newpath, gtk_tree_view_get_column (treeview, 0), FALSE); gtk_tree_path_free (newpath); } }
static gboolean acwin_move_selection(BluefishTextView * btv, gint keyval) { GtkTreeSelection *selection; GtkTreeIter it; GtkTreeModel *model; GtkTreePath *path; selection = gtk_tree_view_get_selection(ACWIN(btv->autocomp)->tree); if (gtk_tree_selection_get_selected(selection, &model, &it)) { gboolean retval = TRUE; gint i, rows = 12, *indices = NULL; path = gtk_tree_model_get_path(model, &it); indices = gtk_tree_path_get_indices(path); switch (keyval) { case GDK_Up: /* move the selection one up */ retval = gtk_tree_path_prev(path); break; case GDK_Down: gtk_tree_path_next(path); break; case GDK_Page_Down: i = MIN(gtk_tree_model_iter_n_children(model, NULL) - 1, indices[0] + rows); gtk_tree_path_free(path); path = gtk_tree_path_new_from_indices(i, -1); break; case GDK_Page_Up: i = MAX(indices[0] - rows, 0); gtk_tree_path_free(path); path = gtk_tree_path_new_from_indices(i, -1); break; case GDK_Home: gtk_tree_path_free(path); path = gtk_tree_path_new_first(); break; case GDK_End: gtk_tree_path_free(path); i = gtk_tree_model_iter_n_children(model, NULL); path = gtk_tree_path_new_from_indices(i - 1, -1); break; default: return FALSE; break; } if (gtk_tree_model_get_iter(model, &it, path)) { gtk_tree_selection_select_iter(selection, &it); gtk_tree_view_scroll_to_cell(ACWIN(btv->autocomp)->tree, path, NULL, FALSE, 0, 0); } else retval = FALSE; gtk_tree_path_free(path); return retval; } else { /* set selection */ } return FALSE; }
/** @brief find previous iter in a tree model This is because gtk doesn't have one. On entry, @a iter is assumed valid Sets @a iter to point to the node preceding it at the current level. @param model the tree model being interrogated @param iter pointer to reference iter @return TRUE if a prior node was found, and iter was set accordingly */ gboolean e2_tree_iter_previous (GtkTreeModel *model, GtkTreeIter *iter) { GtkTreePath *path = gtk_tree_model_get_path (model, iter); gboolean retval = gtk_tree_path_prev (path); if (retval) retval = gtk_tree_model_get_iter (model, iter, path); gtk_tree_path_free (path); return retval; }
static void codec_moved_cb (GtkWidget *widget, gpointer data) { CodecsBox *self = NULL; GtkTreeIter iter; GtkTreeIter *iter2 = NULL; GtkTreeModel *model = NULL; GtkTreeSelection *selection = NULL; GtkTreePath *tree_path = NULL; std::list<std::string> list; gchar *path_str = NULL; self = CODECS_BOX (data); model = gtk_tree_view_get_model (GTK_TREE_VIEW (self->priv->codecs_list)); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self->priv->codecs_list)); if (!gtk_tree_selection_get_selected (GTK_TREE_SELECTION (selection), NULL, &iter)) return; /* Update the tree view */ iter2 = gtk_tree_iter_copy (&iter); path_str = gtk_tree_model_get_string_from_iter (GTK_TREE_MODEL (model), &iter); tree_path = gtk_tree_path_new_from_string (path_str); if (!g_strcmp0 ((gchar *) g_object_get_data (G_OBJECT (widget), "operation"), "up")) gtk_tree_path_prev (tree_path); else gtk_tree_path_next (tree_path); gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter, tree_path); if (gtk_list_store_iter_is_valid (GTK_LIST_STORE (model), &iter) && gtk_list_store_iter_is_valid (GTK_LIST_STORE (model), iter2)) gtk_list_store_swap (GTK_LIST_STORE (model), &iter, iter2); /* Scroll to the new position */ gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (self->priv->codecs_list), tree_path, NULL, FALSE, 0, 0); gtk_tree_path_free (tree_path); gtk_tree_iter_free (iter2); g_free (path_str); /* Update the key */ list = codecs_box_to_list (self); if (self->priv->type == Ekiga::Call::Audio) self->priv->audio_settings->set_string_list ("media-list", list); else if (self->priv->type == Ekiga::Call::Video) self->priv->video_settings->set_string_list ("media-list", list); }