/* * deallocate data */ void envtree_destroy(void) { gtk_tree_row_reference_free(empty_row); empty_row = NULL; }
static void repopulate (void) { CajaBookmark *selected; GtkListStore *store; GtkTreePath *path; GtkTreeRowReference *reference; guint index; g_assert (GTK_IS_TREE_VIEW (bookmark_list_widget)); g_assert (CAJA_IS_BOOKMARK_LIST (bookmarks)); store = GTK_LIST_STORE (bookmark_list_store); selected = get_selected_bookmark (); g_signal_handler_block (bookmark_selection, selection_changed_id); g_signal_handler_block (bookmark_list_store, row_deleted_signal_id); g_signal_handler_block (bookmark_list_widget, row_activated_signal_id); g_signal_handler_block (bookmark_list_widget, key_pressed_signal_id); g_signal_handler_block (bookmark_list_widget, button_pressed_signal_id); gtk_list_store_clear (store); g_signal_handler_unblock (bookmark_list_widget, row_activated_signal_id); g_signal_handler_unblock (bookmark_list_widget, key_pressed_signal_id); g_signal_handler_unblock (bookmark_list_widget, button_pressed_signal_id); g_signal_handler_unblock (bookmark_list_store, row_deleted_signal_id); g_signal_handler_unblock (bookmark_selection, selection_changed_id); /* Fill the list in with the bookmark names. */ g_signal_handler_block (store, row_changed_signal_id); reference = NULL; for (index = 0; index < caja_bookmark_list_length (bookmarks); ++index) { CajaBookmark *bookmark; char *bookmark_name; GdkPixbuf *bookmark_pixbuf; GtkTreeIter iter; bookmark = caja_bookmark_list_item_at (bookmarks, index); bookmark_name = caja_bookmark_get_name (bookmark); bookmark_pixbuf = caja_bookmark_get_pixbuf (bookmark, GTK_ICON_SIZE_MENU); gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, BOOKMARK_LIST_COLUMN_ICON, bookmark_pixbuf, BOOKMARK_LIST_COLUMN_NAME, bookmark_name, BOOKMARK_LIST_COLUMN_BOOKMARK, bookmark, BOOKMARK_LIST_COLUMN_STYLE, PANGO_STYLE_NORMAL, -1); if (bookmark == selected) { /* save old selection */ GtkTreePath *path; path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &iter); reference = gtk_tree_row_reference_new (GTK_TREE_MODEL (store), path); gtk_tree_path_free (path); } g_free (bookmark_name); g_object_unref (bookmark_pixbuf); } g_signal_handler_unblock (store, row_changed_signal_id); if (reference != NULL) { /* restore old selection */ /* bookmarks_set_empty() will call the selection change handler, * so we block it here in case of selection change. */ g_signal_handler_block (bookmark_selection, selection_changed_id); g_assert (index != 0); g_assert (gtk_tree_row_reference_valid (reference)); path = gtk_tree_row_reference_get_path (reference); gtk_tree_selection_select_path (bookmark_selection, path); gtk_tree_row_reference_free (reference); gtk_tree_path_free (path); g_signal_handler_unblock (bookmark_selection, selection_changed_id); } bookmarks_set_empty (index == 0); }
void gimp_action_view_set_filter (GimpActionView *view, const gchar *filter) { GtkTreeSelection *sel; GtkTreeModel *filtered_model; GtkTreeModel *model; GtkTreeIter iter; gboolean iter_valid; GtkTreeRowReference *selected_row = NULL; g_return_if_fail (GIMP_IS_ACTION_VIEW (view)); filtered_model = gtk_tree_view_get_model (GTK_TREE_VIEW (view)); model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (filtered_model)); if (filter && ! strlen (filter)) filter = NULL; g_free (view->filter); view->filter = NULL; if (filter) view->filter = g_utf8_casefold (filter, -1); sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (view)); if (gtk_tree_selection_get_selected (sel, NULL, &iter)) { GtkTreePath *path = gtk_tree_model_get_path (filtered_model, &iter); selected_row = gtk_tree_row_reference_new (filtered_model, path); } for (iter_valid = gtk_tree_model_get_iter_first (model, &iter); iter_valid; iter_valid = gtk_tree_model_iter_next (model, &iter)) { GtkTreeIter child_iter; gboolean child_valid; gint n_children = 0; for (child_valid = gtk_tree_model_iter_children (model, &child_iter, &iter); child_valid; child_valid = gtk_tree_model_iter_next (model, &child_iter)) { gboolean visible = TRUE; if (view->filter) { gchar *label; gchar *name; gtk_tree_model_get (model, &child_iter, GIMP_ACTION_VIEW_COLUMN_LABEL_CASEFOLD, &label, GIMP_ACTION_VIEW_COLUMN_NAME, &name, -1); visible = label && name && (strstr (label, view->filter) != NULL || strstr (name, view->filter) != NULL); g_free (label); g_free (name); } gtk_tree_store_set (GTK_TREE_STORE (model), &child_iter, GIMP_ACTION_VIEW_COLUMN_VISIBLE, visible, -1); if (visible) n_children++; } gtk_tree_store_set (GTK_TREE_STORE (model), &iter, GIMP_ACTION_VIEW_COLUMN_VISIBLE, n_children > 0, -1); } if (view->filter) gtk_tree_view_expand_all (GTK_TREE_VIEW (view)); else gtk_tree_view_collapse_all (GTK_TREE_VIEW (view)); gtk_tree_view_columns_autosize (GTK_TREE_VIEW (view)); if (selected_row) { if (gtk_tree_row_reference_valid (selected_row)) { GtkTreePath *path = gtk_tree_row_reference_get_path (selected_row); gimp_action_view_select_path (view, path); gtk_tree_path_free (path); } gtk_tree_row_reference_free (selected_row); } }
static void transfer_model_data(int iflag_if_add, GtkTreeView *tree_view_to_del, GtkTreeView *tree_view_to_add) { GtkTreeModel *model_to_del; GtkTreeModel *child_model_to_del; GtkTreeModel *model_to_add; GtkTreeModel *child_model_to_add; GtkTreeSelection *selection; GList *list; GList *reference_list; GList *cur; gchar *field_name; gchar *field_math; int index_field; int iflag_viz, iflag_monitor, num_comp, iflag_quad; /* 選択されている行のパスを取得する */ /* パスはツリーモデルソートのもの */ model_to_del = gtk_tree_view_get_model(tree_view_to_del); child_model_to_del = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(model_to_del)); model_to_add = gtk_tree_view_get_model(tree_view_to_add); child_model_to_add = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(model_to_add)); selection = gtk_tree_view_get_selection(tree_view_to_del); list = gtk_tree_selection_get_selected_rows(selection, NULL); /* 最初にパスからリファレンスを作成する */ /* データの削除を行なうと取得済みのパスが(大抵の場合)無効になる */ reference_list = NULL; for (cur = g_list_first(list); cur != NULL; cur = g_list_next(cur)) { GtkTreePath *child_path; GtkTreeRowReference *child_reference; /* ツリーモデルソートのパスをツリーモデルのパスに変換する */ child_path = gtk_tree_model_sort_convert_path_to_child_path(GTK_TREE_MODEL_SORT(model_to_del), (GtkTreePath *)cur->data); child_reference = gtk_tree_row_reference_new(child_model_to_del, child_path); reference_list = g_list_append(reference_list, child_reference); gtk_tree_path_free(child_path); gtk_tree_path_free((GtkTreePath *)cur->data); } g_list_free(list); /* GtkTreeSelectionのchangedシグナルを一時的にブロックする */ block_changed_signal(G_OBJECT(child_model_to_del)); block_changed_signal(G_OBJECT(child_model_to_add)); /* リファレンスをパスに戻して削除 */ for (cur = g_list_first(reference_list); cur != NULL; cur = g_list_next(cur)) { GtkTreePath *tree_path; GtkTreeIter iter; tree_path = gtk_tree_row_reference_get_path((GtkTreeRowReference *)cur->data); gtk_tree_model_get_iter(child_model_to_del, &iter, tree_path); gtk_tree_model_get(child_model_to_del, &iter, COLUMN_FIELD_INDEX, &index_field, -1); gtk_tree_model_get(child_model_to_del, &iter, COLUMN_FIELD_NAME, &field_name, -1); gtk_tree_model_get(child_model_to_del, &iter, COLUMN_FIELD_MATH, &field_math, -1); gtk_tree_model_get(child_model_to_del, &iter, COLUMN_VIZ_FLAG, &iflag_viz, -1); gtk_tree_model_get(child_model_to_del, &iter, COLUMN_MONITOR_FLAG, &iflag_monitor, -1); gtk_tree_model_get(child_model_to_del, &iter, COLUMN_NUM_COMP, &num_comp, -1); gtk_tree_model_get(child_model_to_del, &iter, COLUMN_QUADRATURE, &iflag_quad, -1); printf("To be moved: %d, %s: %s\n", index_field, field_name, all_fld_list[index_field]->field_name); /* Delete */ gtk_list_store_remove(GTK_LIST_STORE(child_model_to_del), &iter); /* Add */ append_model_data(index_field, child_model_to_add); gtk_tree_path_free(tree_path); gtk_tree_row_reference_free((GtkTreeRowReference *)cur->data); /* Update control data */ if(iflag_if_add == 1){ printf("Add field list \n"); add_field_to_ctl(all_fld_list[index_field], &mhd_ctl->model_ctl->fld_ctl->field_list); } else { printf("Delete field list \n"); delete_field_in_ctl(all_fld_list[index_field], &mhd_ctl->model_ctl->fld_ctl->field_list); }; } g_list_free(reference_list); /* changedシグナルのブロックを解除する */ unblock_changed_signal(G_OBJECT(child_model_to_del)); unblock_changed_signal(G_OBJECT(child_model_to_add)); /* check_field_ctl_list(&mhd_ctl->model_ctl->fld_ctl->field_list); */ }
static void remove_model_data(GtkButton *button, gpointer user_data) { GtkTreeView *tree_view = GTK_TREE_VIEW(user_data); GtkTreeModel *model; GtkTreeModel *child_model; GtkTreeSelection *selection; GList *list; GList *reference_list; GList *cur; gchar *row_string; int index_field; /* 選択されている行のパスを取得する */ /* パスはツリーモデルソートのもの */ model = gtk_tree_view_get_model(tree_view); selection = gtk_tree_view_get_selection(tree_view); list = gtk_tree_selection_get_selected_rows(selection, NULL); child_model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(model)); /* 最初にパスからリファレンスを作成する */ /* データの削除を行なうと取得済みのパスが(大抵の場合)無効になる */ reference_list = NULL; for (cur = g_list_first(list); cur != NULL; cur = g_list_next(cur)) { GtkTreePath *child_path; GtkTreeRowReference *child_reference; /* ツリーモデルソートのパスをツリーモデルのパスに変換する */ child_path = gtk_tree_model_sort_convert_path_to_child_path(GTK_TREE_MODEL_SORT(model), (GtkTreePath *)cur->data); child_reference = gtk_tree_row_reference_new(child_model, child_path); reference_list = g_list_append(reference_list, child_reference); gtk_tree_path_free(child_path); gtk_tree_path_free((GtkTreePath *)cur->data); } g_list_free(list); /* GtkTreeSelectionのchangedシグナルを一時的にブロックする */ block_changed_signal(G_OBJECT(child_model)); /* リファレンスをパスに戻して削除 */ for (cur = g_list_first(reference_list); cur != NULL; cur = g_list_next(cur)) { GtkTreePath *tree_path; GtkTreeIter iter; tree_path = gtk_tree_row_reference_get_path((GtkTreeRowReference *)cur->data); gtk_tree_model_get_iter(child_model, &iter, tree_path); gtk_tree_model_get(child_model, &iter, COLUMN_FIELD_INDEX, &index_field, -1); gtk_tree_model_get(child_model, &iter, COLUMN_FIELD_NAME, &row_string, -1); printf("To be deleted: %d, %s: %s\n", index_field, row_string, all_fld_list[index_field]->field_name); /* Delete */ gtk_list_store_remove(GTK_LIST_STORE(child_model), &iter); delete_field_in_ctl(all_fld_list[index_field], &mhd_ctl->model_ctl->fld_ctl->field_list); gtk_tree_path_free(tree_path); gtk_tree_row_reference_free((GtkTreeRowReference *)cur->data); } g_list_free(reference_list); /* changedシグナルのブロックを解除する */ unblock_changed_signal(G_OBJECT(child_model)); /* check_field_ctl_list(&mhd_ctl->model_ctl->fld_ctl->field_list); */ }
void seahorse_object_model_set_row_object (SeahorseObjectModel *self, GtkTreeIter *iter, GObject *object) { SeahorseObjectRow *skrow; GtkTreePath *path; GtkTreePath *ipath; guint i; g_return_if_fail (SEAHORSE_IS_OBJECT_MODEL (self)); g_return_if_fail (G_IS_OBJECT (object) || object == NULL); g_return_if_fail (self->data_column >= 0); /* Add the row/key association */ if (object) { /* Do we already have a row for this key? */ skrow = (SeahorseObjectRow*)g_hash_table_lookup (self->rows, object); if (!skrow) { skrow = key_row_new (self, object); /* Put it in our row cache */ g_hash_table_replace (self->rows, object, skrow); } path = gtk_tree_model_get_path (GTK_TREE_MODEL (self), iter); g_ptr_array_add (skrow->refs, gtk_tree_row_reference_new (GTK_TREE_MODEL (self), path)); gtk_tree_path_free (path); /* Remove the row/key association */ } else { gtk_tree_model_get (GTK_TREE_MODEL (self), iter, self->data_column, &skrow, -1); if (skrow) { ipath = gtk_tree_model_get_path (GTK_TREE_MODEL (self), iter); g_return_if_fail (ipath != NULL); for (i = 0; i < skrow->refs->len; i++) { path = gtk_tree_row_reference_get_path (g_ptr_array_index (skrow->refs, i)); /* Check if they're the same or invalid, remove */ if (!path || gtk_tree_path_compare (path, ipath) == 0) { gtk_tree_row_reference_free (g_ptr_array_index (skrow->refs, i)); g_ptr_array_remove_index_fast (skrow->refs, i); i--; } if (path) gtk_tree_path_free (path); } /* If we no longer have rows associated with this key, then remove */ if (skrow->refs->len == 0) g_hash_table_remove (self->rows, skrow->object); } } gtk_tree_store_set (GTK_TREE_STORE (self), iter, self->data_column, object ? skrow : NULL, -1); if (object) key_notify (object, self); }
static void ref_count_row_ref (void) { GtkTreeIter grandparent1, grandparent2, parent1, parent2; GtkTreeIter iter_parent1, iter_parent2; GtkTreeModel *model; GtkTreeModelRefCount *ref_model; GtkTreeModel *sort_model; GtkWidget *tree_view; GtkTreePath *path; GtkTreeRowReference *row_ref; model = gtk_tree_model_ref_count_new (); ref_model = GTK_TREE_MODEL_REF_COUNT (model); /* + grandparent1 * + grandparent2 * + parent1 * + iter_parent1 * + parent2 * + iter_parent2 * + iter_parent2 */ gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent1, NULL); gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent2, NULL); gtk_tree_store_append (GTK_TREE_STORE (model), &parent1, &grandparent2); gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent1, &parent1); gtk_tree_store_append (GTK_TREE_STORE (model), &parent2, &grandparent2); gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2); gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2); sort_model = gtk_tree_model_sort_new_with_model (model); tree_view = gtk_tree_view_new_with_model (sort_model); path = gtk_tree_path_new_from_indices (1, 1, 1, -1); row_ref = gtk_tree_row_reference_new (sort_model, path); gtk_tree_path_free (path); assert_node_ref_count (ref_model, &grandparent1, 1); /* Referenced because the node is visible, its child level is built * and referenced by the row ref. */ assert_node_ref_count (ref_model, &grandparent2, 3); assert_node_ref_count (ref_model, &parent1, 0); /* Referenced by the row ref and because its child level is built. */ assert_node_ref_count (ref_model, &parent2, 2); assert_node_ref_count (ref_model, &iter_parent1, 0); assert_node_ref_count (ref_model, &iter_parent2, 1); gtk_tree_row_reference_free (row_ref); assert_node_ref_count (ref_model, &grandparent1, 1); assert_node_ref_count (ref_model, &grandparent2, 2); assert_node_ref_count (ref_model, &parent1, 0); assert_node_ref_count (ref_model, &parent2, 1); assert_node_ref_count (ref_model, &iter_parent1, 0); assert_node_ref_count (ref_model, &iter_parent2, 0); path = gtk_tree_path_new_from_indices (1, 1, 1, -1); row_ref = gtk_tree_row_reference_new (sort_model, path); gtk_tree_path_free (path); assert_node_ref_count (ref_model, &grandparent1, 1); /* Referenced because the node is visible, its child level is built * and referenced by the row ref. */ assert_node_ref_count (ref_model, &grandparent2, 3); assert_node_ref_count (ref_model, &parent1, 0); /* Referenced by the row ref and because its child level is built. */ assert_node_ref_count (ref_model, &parent2, 2); assert_node_ref_count (ref_model, &iter_parent1, 0); assert_node_ref_count (ref_model, &iter_parent2, 1); gtk_tree_store_remove (GTK_TREE_STORE (model), &parent2); assert_node_ref_count (ref_model, &grandparent1, 1); assert_node_ref_count (ref_model, &grandparent2, 1); assert_node_ref_count (ref_model, &parent1, 0); assert_node_ref_count (ref_model, &iter_parent1, 0); gtk_tree_row_reference_free (row_ref); assert_node_ref_count (ref_model, &grandparent1, 1); assert_node_ref_count (ref_model, &grandparent2, 1); assert_node_ref_count (ref_model, &parent1, 0); assert_node_ref_count (ref_model, &iter_parent1, 0); gtk_widget_destroy (tree_view); g_object_unref (sort_model); assert_entire_model_unreferenced (ref_model); g_object_unref (ref_model); }
/* * delete selected rows from env variables page */ void delete_selected_rows() { /* path to select after deleting finishes */ GtkTreeRowReference *reference_to_select = NULL; /* empty row path */ GtkTreePath *empty_path = gtk_tree_row_reference_get_path(empty_row); /* get selected rows */ GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(envtree)); GList *rows = gtk_tree_selection_get_selected_rows(selection, &model); /* check whether only empty row was selected */ if (1 != gtk_tree_selection_count_selected_rows(selection) || gtk_tree_path_compare((GtkTreePath*)rows->data, empty_path)) { /* get references to the selected rows and find out what to select after deletion */ GList *references = NULL; GList *iter = rows; while (iter) { GtkTreePath *path = (GtkTreePath*)iter->data; if (!reference_to_select) { /* select upper sibling of the upper selected row that has unselected upper sibling */ GtkTreePath *sibling = gtk_tree_path_copy(path); if(gtk_tree_path_prev(sibling)) { if (!gtk_tree_selection_path_is_selected(selection, sibling)) reference_to_select = gtk_tree_row_reference_new(gtk_tree_view_get_model(GTK_TREE_VIEW(envtree)), sibling); } else if (gtk_tree_path_next(sibling), gtk_tree_path_compare(path, sibling)) reference_to_select = gtk_tree_row_reference_new(gtk_tree_view_get_model(GTK_TREE_VIEW(envtree)), sibling); } if (gtk_tree_path_compare(path, empty_path)) references = g_list_append(references, gtk_tree_row_reference_new(model, path)); iter = iter->next; } /* if all (with or without empty row) was selected - set empty row as a path to be selected after deleting */ if (!reference_to_select) reference_to_select = gtk_tree_row_reference_copy (empty_row); iter = references; while (iter) { GtkTreeRowReference *reference = (GtkTreeRowReference*)iter->data; GtkTreePath *path = gtk_tree_row_reference_get_path(reference); GtkTreeIter titer; gtk_tree_model_get_iter(model, &titer, path); gtk_list_store_remove(store, &titer); iter = iter->next; } /* set selection */ gtk_tree_selection_unselect_all(selection); GtkTreePath *path = gtk_tree_row_reference_get_path(reference_to_select); gtk_tree_selection_select_path(selection, path); gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(envtree), path, NULL, TRUE, 0.5, 0.5); /* free references list */ g_list_foreach (references, (GFunc)gtk_tree_row_reference_free, NULL); g_list_free (references); } /* free selection reference */ gtk_tree_row_reference_free(reference_to_select); /* free rows list */ g_list_foreach (rows, (GFunc)gtk_tree_path_free, NULL); g_list_free (rows); }
// Create a new bus from the current selection static void create_bus_button_clicked (GtkWidget *widget, gpointer data) { int row_type = -1 ; bus_layout_D *dialog = (bus_layout_D *)data ; GList *llTreeRefs = NULL, *llItr = NULL ; GtkTreeStore *ts = GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (dialog->tview))) ; GtkTreeIter itrBus, itr, itrSrc, itrSrcParent ; GtkTreeRowReference *refBus = NULL, *refSrcParent = NULL ; GtkTreePath *tp = NULL, *tpSrcParent = NULL ; llTreeRefs = get_selected_refs (gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tview))) ; if (NULL == llTreeRefs) return ; gtk_tree_model_get_iter (GTK_TREE_MODEL (ts), &itr, tp = gtk_tree_row_reference_get_path (llTreeRefs->data)) ; gtk_tree_model_get (GTK_TREE_MODEL (ts), &itr, BUS_LAYOUT_MODEL_COLUMN_TYPE, &row_type, -1) ; gtk_tree_path_free (tp) ; gtk_tree_store_prepend (ts, &itrBus, NULL) ; gtk_tree_store_set (ts, &itrBus, BUS_LAYOUT_MODEL_COLUMN_ICON, (row_type & ROW_TYPE_INPUT) ? QCAD_STOCK_BUS_INPUT : QCAD_STOCK_BUS_OUTPUT, BUS_LAYOUT_MODEL_COLUMN_NAME, _("Untitled Bus"), BUS_LAYOUT_MODEL_COLUMN_TYPE, (row_type & ROW_TYPE_INPUT) ? ROW_TYPE_BUS_INPUT : ROW_TYPE_BUS_OUTPUT, BUS_LAYOUT_MODEL_COLUMN_INDEX, -1, -1) ; refBus = gtk_tree_row_reference_new (GTK_TREE_MODEL (ts), tp = gtk_tree_model_get_path (GTK_TREE_MODEL (ts), &itrBus)) ; gtk_tree_path_free (tp) ; for (llItr = g_list_last (llTreeRefs) ; llItr != NULL ; llItr = llItr->prev) { gtk_tree_model_get_iter (GTK_TREE_MODEL (ts), &itrBus, tp = gtk_tree_row_reference_get_path (refBus)) ; gtk_tree_path_free (tp) ; gtk_tree_store_append (ts, &itr, &itrBus) ; gtk_tree_model_get_iter (GTK_TREE_MODEL (ts), &itrSrc, tp = gtk_tree_row_reference_get_path (llItr->data)) ; gtk_tree_path_free (tp) ; swap_model_iters_contents (GTK_TREE_MODEL (ts), &itrSrc, &itr) ; gtk_tree_model_get_iter (GTK_TREE_MODEL (ts), &itrSrc, tp = gtk_tree_row_reference_get_path (llItr->data)) ; if (gtk_tree_path_get_depth (tp) > 1) { gtk_tree_path_up (tpSrcParent = gtk_tree_path_copy (tp)) ; refSrcParent = (1 == gtk_tree_model_path_n_children (GTK_TREE_MODEL (ts), tpSrcParent)) ? gtk_tree_row_reference_new (GTK_TREE_MODEL (ts), tpSrcParent) : NULL ; gtk_tree_path_free (tpSrcParent) ; } gtk_tree_path_free (tp) ; gtk_tree_row_reference_free (llItr->data) ; // Remove cell from old location gtk_tree_store_remove (ts, &itrSrc) ; // The bus that owned the row we just moved has become empty - delete it if (NULL != refSrcParent) { tpSrcParent = gtk_tree_row_reference_get_path (refSrcParent) ; gtk_tree_model_get_iter (GTK_TREE_MODEL (ts), &itrSrcParent, tpSrcParent) ; gtk_tree_store_remove (ts, &itrSrcParent) ; gtk_tree_path_free (tpSrcParent) ; gtk_tree_row_reference_free (refSrcParent) ; refSrcParent = NULL ; } } gtk_tree_selection_select_path (gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tview)), tp = gtk_tree_row_reference_get_path (refBus)) ; gtk_tree_path_free (tp) ; gtk_tree_row_reference_free (refBus) ; g_list_free (llTreeRefs) ; }
static void update_enabled_disabled_cardinality (BrowserData *data) { GtkTreeModel *tree_model; GtkTreeIter iter; GtkTreeRowReference *enabled_iter = NULL; GtkTreeRowReference *disabled_iter = NULL; GtkTreePath *path; if (! data->enabled_disabled_cardinality_changed) return; tree_model = GTK_TREE_MODEL (GET_WIDGET ("category_liststore")); if (gtk_tree_model_get_iter_first (tree_model, &iter)) { do { char *category_id; gtk_tree_model_get (tree_model, &iter, CATEGORY_ID_COLUMN, &category_id, -1); if (g_strcmp0 (category_id, EXTENSION_CATEGORY_ENABLED) == 0) { path = gtk_tree_model_get_path (tree_model, &iter); enabled_iter = gtk_tree_row_reference_new (tree_model, path); gtk_tree_path_free (path); } if (g_strcmp0 (category_id, EXTENSION_CATEGORY_DISABLED) == 0) { path = gtk_tree_model_get_path (tree_model, &iter); disabled_iter = gtk_tree_row_reference_new (tree_model, path); gtk_tree_path_free (path); } g_free (category_id); } while (gtk_tree_model_iter_next (tree_model, &iter)); } path = gtk_tree_row_reference_get_path (enabled_iter); if (path != NULL) { if (gtk_tree_model_get_iter (tree_model, &iter, path)) { char *s; s = g_strdup_printf (CARDINALITY_FORMAT, get_category_cardinality (data, EXTENSION_CATEGORY_ENABLED)); gtk_list_store_set (GTK_LIST_STORE (tree_model), &iter, CATEGORY_CARDINALITY_COLUMN, s, -1); g_free (s); } gtk_tree_path_free (path); } path = gtk_tree_row_reference_get_path (disabled_iter); if (path != NULL) { if (gtk_tree_model_get_iter (tree_model, &iter, path)) { char *s; s = g_strdup_printf (CARDINALITY_FORMAT, get_category_cardinality (data, EXTENSION_CATEGORY_DISABLED)); gtk_list_store_set (GTK_LIST_STORE (tree_model), &iter, CATEGORY_CARDINALITY_COLUMN, s, -1); g_free (s); } gtk_tree_path_free (path); } gtk_tree_row_reference_free (enabled_iter); gtk_tree_row_reference_free (disabled_iter); data->enabled_disabled_cardinality_changed = FALSE; }
/* * key pressed event */ static gboolean on_key_pressed(GtkWidget *widget, GdkEvent *event, gpointer user_data) { /* do not process event is page is readonly (debug is running) */ if (readonly) return FALSE; guint keyval = ((GdkEventKey*)event)->keyval; /* get selected rows */ GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)); GList *rows = gtk_tree_selection_get_selected_rows(selection, &model); rows = g_list_sort(rows, (GCompareFunc)gtk_tree_path_compare); if (keyval == GDK_Delete && rows && g_list_length(rows)) { /* "delete selected rows" */ /* get new selection */ GtkTreeRowReference *new_selection = NULL; GtkTreePath *first_path = (GtkTreePath*)rows->data; if (gtk_tree_path_get_depth(first_path) > 1) { new_selection = get_unselected_sibling(first_path); } if (!new_selection) { GtkTreePath *file_path = gtk_tree_path_copy(first_path); if (gtk_tree_path_get_depth(file_path) > 1) { gtk_tree_path_up(file_path); } new_selection = get_unselected_sibling(file_path); gtk_tree_path_free(file_path); } /* collect GList of breakpoints to remove if file row is met - add all unselected breaks to the list as well */ GList *iter = rows; GList *breaks = NULL; while (iter) { GtkTreePath *path = (GtkTreePath*)iter->data; GtkTreeIter titer; gtk_tree_model_get_iter(model, &titer, path); if (1 == gtk_tree_path_get_depth(path)) { GtkTreeIter citer; gtk_tree_model_iter_children(model, &citer, &titer); do { if (!gtk_tree_selection_iter_is_selected(selection, &citer)) { gchar *file = NULL; gint line; gtk_tree_model_get(model, &titer, FILEPATH, &file, -1); gtk_tree_model_get(model, &citer, LINE, &line, -1); breakpoint *bp = breaks_lookup_breakpoint(file, line); breaks = g_list_append(breaks, bp); g_free(file); } } while(gtk_tree_model_iter_next(model, &citer)); } else { GtkTreeIter piter; gtk_tree_model_iter_parent(model, &piter, &titer); gchar *file = NULL; gtk_tree_model_get(model, &piter, FILEPATH, &file, -1); gint line; gtk_tree_model_get(model, &titer, LINE, &line, -1); breakpoint *bp = breaks_lookup_breakpoint(file, line); breaks = g_list_append(breaks, bp); g_free(file); } iter = iter->next; } if (1 == g_list_length(breaks)) { breakpoint *bp = (breakpoint*)breaks->data; g_list_free(breaks); breaks_remove(bp->file, bp->line); } else { breaks_remove_list(breaks); } if (new_selection) { /* get path to select */ GtkTreePath *path = NULL; path = gtk_tree_row_reference_get_path(new_selection); gtk_tree_selection_select_path(selection, path); gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(widget), path, NULL, TRUE, 0.5, 0.5); gtk_tree_path_free(path); gtk_tree_row_reference_free(new_selection); } } /* free rows list */ g_list_foreach (rows, (GFunc)gtk_tree_path_free, NULL); g_list_free (rows); return FALSE; }
static int fill_account_list (StockSplitInfo *info, Account *selected_account) { GtkTreeRowReference *reference = NULL; GtkTreeView *view; GtkListStore *list; GtkTreeIter iter; GtkTreePath *path; GList *accounts; GList *node; gint rows = 0; gchar *full_name; view = GTK_TREE_VIEW(info->account_view); list = GTK_LIST_STORE(gtk_tree_view_get_model(view)); gtk_list_store_clear (list); accounts = gnc_account_get_descendants_sorted (gnc_get_current_root_account ()); for (node = accounts; node; node = node->next) { Account *account = node->data; GNCPrintAmountInfo print_info; const gnc_commodity *commodity; gnc_numeric balance; if (!xaccAccountIsPriced(account)) continue; balance = xaccAccountGetBalance (account); if (gnc_numeric_zero_p (balance)) continue; if (xaccAccountGetPlaceholder (account)) continue; commodity = xaccAccountGetCommodity (account); full_name = gnc_account_get_full_name (account); print_info = gnc_account_print_info (account, FALSE); gtk_list_store_append(list, &iter); gtk_list_store_set(list, &iter, SPLIT_COL_ACCOUNT, account, SPLIT_COL_FULLNAME, full_name, SPLIT_COL_MNEMONIC, gnc_commodity_get_mnemonic(commodity), SPLIT_COL_SHARES, xaccPrintAmount(balance, print_info), -1); if (account == selected_account) { path = gtk_tree_model_get_path(GTK_TREE_MODEL(list), &iter); reference = gtk_tree_row_reference_new(GTK_TREE_MODEL(list), path); gtk_tree_path_free(path); } g_free (full_name); rows++; } g_list_free(accounts); if (reference) { GtkTreeSelection* selection = gtk_tree_view_get_selection(view); path = gtk_tree_row_reference_get_path(reference); gtk_tree_row_reference_free(reference); if (path) { gtk_tree_selection_select_path(selection, path); gtk_tree_view_scroll_to_cell(view, path, NULL, TRUE, 0.5, 0.0); gtk_tree_path_free(path); } } return rows; }