static void gimp_enum_store_insert_value_after (GimpEnumStore *store, gint after, gint insert_value) { GtkTreeIter iter; g_return_if_fail (GIMP_IS_ENUM_STORE (store)); if (gimp_int_store_lookup_by_value (GTK_TREE_MODEL (store), after, &iter)) { GEnumValue *enum_value; enum_value = g_enum_get_value (store->enum_class, insert_value); if (enum_value) { GtkTreeIter value_iter; const gchar *desc; gtk_list_store_insert_after (GTK_LIST_STORE (store), &value_iter, &iter); desc = gimp_enum_value_get_desc (store->enum_class, enum_value); gtk_list_store_set (GTK_LIST_STORE (store), &value_iter, GIMP_INT_STORE_VALUE, enum_value->value, GIMP_INT_STORE_LABEL, desc, -1); } } }
static void on_add( GtkButton* btn, gpointer data ) { GtkWindow* parent = GTK_WINDOW(data); GtkTreeViewColumn* col; GtkTreeIter it, new_it, *pit; GtkTreePath* tree_path; GtkTreeView* view = (GtkTreeView*)g_object_get_data( G_OBJECT(data), "list_view" ); GtkTreeModel* model; GtkTreeSelection* sel = gtk_tree_view_get_selection( view ); GdkPixbuf* icon = gtk_icon_theme_load_icon( gtk_icon_theme_get_default(), "gnome-fs-directory", 20, 0, NULL ); GtkWidget* dlg; char *path = NULL, *basename = NULL; if( gtk_tree_selection_get_selected ( sel, &model, &it ) ) { tree_path = gtk_tree_model_get_path( model, &it ); gtk_tree_path_next( tree_path ); pit = ⁢ } else { tree_path = gtk_tree_path_new_first(); pit = NULL; } dlg = gtk_file_chooser_dialog_new( NULL, parent, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL ); if( gtk_dialog_run( (GtkDialog*) dlg ) == GTK_RESPONSE_OK ) { path = gtk_file_chooser_get_filename( (GtkFileChooser*)dlg ); basename = g_filename_display_basename( path ); } gtk_widget_destroy( dlg ); col = gtk_tree_view_get_column( view, 1 ); gtk_list_store_insert_after( GTK_LIST_STORE(model), &new_it, pit ); gtk_list_store_set( GTK_LIST_STORE(model), &new_it, COL_ICON, icon, COL_NAME, basename ? basename : _("New Item"), COL_DIRPATH, path, -1); g_free( path ); g_free( basename ); if( tree_path ) { gtk_tree_view_set_cursor_on_cell( view, tree_path, col, NULL, TRUE ); gtk_tree_path_free( tree_path ); } if( icon ) g_object_unref( icon ); }
void scan_define_model (Netinfo * netinfo, scan_data data) { GtkTreeIter iter, sibling; GList *columns; GtkTreePath *path; GtkTreeModel *model; GtkTreeView *widget; g_return_if_fail (netinfo != NULL); widget = (GTK_TREE_VIEW (netinfo->output)); /* Creation of GtkTreeView */ gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (widget), TRUE); columns = gtk_tree_view_get_columns (GTK_TREE_VIEW (widget)); if (g_list_length (columns) == 0) { model = scan_create_model (widget); gtk_tree_view_set_model (GTK_TREE_VIEW (widget), model); } g_list_free (columns); model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget)); gtk_tree_view_get_cursor (GTK_TREE_VIEW (widget), &path, NULL); if (path != NULL) { gtk_tree_model_get_iter (model, &sibling, path); gtk_list_store_insert_after (GTK_LIST_STORE (model), &iter, &sibling); } else { gtk_list_store_append (GTK_LIST_STORE (model), &iter); } gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, data.port, 1, data.state, 2, data.service, -1); gtk_tree_view_set_model (GTK_TREE_VIEW (widget), model); path = gtk_tree_model_get_path (model, &iter); gtk_tree_view_set_cursor (GTK_TREE_VIEW (widget), path, NULL, FALSE); gtk_tree_path_free (path); }
static void tb_editor_drag_data_rcvd_cb(GtkWidget *widget, GdkDragContext *context, gint x, gint y, GtkSelectionData *data, guint info, guint ltime, TBEditorWidget *tbw) { GtkTreeView *tree = GTK_TREE_VIEW(widget); gboolean del = FALSE; if (gtk_selection_data_get_target (data) != GDK_NONE ) { gboolean is_sep; const guchar *text = gtk_selection_data_get_data (data); is_sep = (g_strcmp0(text, "Separator") == 0); /* If the source of the action is equal to the target, we do just re-order and ** so need to delete the separator to get it moved, not just copied. */ if (is_sep && widget == tbw->drag_source) is_sep = FALSE; if (tree != tbw->tree_available || ! is_sep) { GtkTreeIter iter, iter_before, *iter_before_ptr; GtkListStore *store = GTK_LIST_STORE(gtk_tree_view_get_model(tree)); if (tbw->last_drag_path != NULL) { gtk_tree_model_get_iter(GTK_TREE_MODEL(store), &iter_before, tbw->last_drag_path); if (gtk_list_store_iter_is_valid(store, &iter_before)) iter_before_ptr = &iter_before; else iter_before_ptr = NULL; if (tbw->last_drag_pos == GTK_TREE_VIEW_DROP_BEFORE || tbw->last_drag_pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE) gtk_list_store_insert_before(store, &iter, iter_before_ptr); else gtk_list_store_insert_after(store, &iter, iter_before_ptr); tb_editor_set_item_values(tbw, text, store, &iter); } else { gtk_list_store_append(store, &iter); tb_editor_set_item_values(tbw, text, store, &iter); } tb_editor_scroll_to_iter(tree, &iter); } if (tree != tbw->tree_used || ! is_sep) del = TRUE; } tbw->drag_source = NULL; /* reset the value just to be sure */ tb_editor_free_path(tbw); gtk_drag_finish(context, TRUE, del, ltime); }
static void gtk_app_chooser_button_populate (GtkAppChooserButton *self) { GList *recommended_apps = NULL, *l; GAppInfo *app; GtkTreeIter iter, iter2; GIcon *icon; gboolean cycled_recommended; #ifndef G_OS_WIN32 if (self->priv->content_type) recommended_apps = g_app_info_get_recommended_for_type (self->priv->content_type); #endif cycled_recommended = FALSE; for (l = recommended_apps; l != NULL; l = l->next) { app = l->data; icon = g_app_info_get_icon (app); if (icon == NULL) icon = g_themed_icon_new ("application-x-executable"); else g_object_ref (icon); if (cycled_recommended) { gtk_list_store_insert_after (self->priv->store, &iter2, &iter); iter = iter2; } else { get_first_iter (self->priv->store, &iter); cycled_recommended = TRUE; } gtk_list_store_set (self->priv->store, &iter, COLUMN_APP_INFO, app, COLUMN_LABEL, g_app_info_get_name (app), COLUMN_ICON, icon, COLUMN_CUSTOM, FALSE, -1); g_object_unref (icon); } if (!cycled_recommended) gtk_app_chooser_button_ensure_dialog_item (self, NULL); else gtk_app_chooser_button_ensure_dialog_item (self, &iter); gtk_combo_box_set_active (GTK_COMBO_BOX (self), 0); }
static VALUE rg_insert_after(VALUE self, VALUE sibling) { VALUE ret; GtkTreeIter iter; GtkListStore* model = _SELF(self); gtk_list_store_insert_after(model, &iter, NIL_P(sibling) ? NULL : RVAL2GTKTREEITER(sibling)); iter.user_data3 = model; ret = GTKTREEITER2RVAL(&iter); return ret; }
static void gtk_app_chooser_button_ensure_dialog_item (GtkAppChooserButton *self, GtkTreeIter *prev_iter) { GtkTreeIter iter, iter2; if (!self->priv->show_dialog_item || !self->priv->content_type) return; if (prev_iter == NULL) gtk_list_store_append (self->priv->store, &iter); else gtk_list_store_insert_after (self->priv->store, &iter, prev_iter); real_insert_separator (self, FALSE, &iter); iter2 = iter; gtk_list_store_insert_after (self->priv->store, &iter, &iter2); real_insert_custom_item (self, CUSTOM_ITEM_OTHER_APP, _("Other application..."), NULL, FALSE, &iter); }
void ui_add_entry(struct playlist *playlist, struct playlist_entry *after, struct playlist_entry *entry) { struct playlist_ui_ctx *playlist_ctx = get_playlist_ui_ctx(playlist); struct song *song = get_entry_song(entry); struct entry_ui_ctx *ctx = get_entry_ui_ctx(entry); lock_ui(); GtkTreeIter sibling; if (after) { struct entry_ui_ctx *after_ctx = get_entry_ui_ctx(after); GtkTreePath *path = gtk_tree_row_reference_get_path(after_ctx->rowref); gtk_tree_model_get_iter(GTK_TREE_MODEL(playlist_ctx->store), &sibling, path); gtk_tree_path_free(path); } GtkTreeIter iter; if (after) gtk_list_store_insert_after(playlist_ctx->store, &iter, &sibling); else gtk_list_store_insert_after(playlist_ctx->store, &iter, NULL); char *name = get_display_name(song); char buf[32]; unsigned int length = get_song_length(song); if (length == -1) strcpy(buf, "-"); else sprintf(buf, "%d:%02d", length / (1000 * 60), (length / 1000) % 60); gtk_list_store_set(playlist_ctx->store, &iter, COL_ENTRY, entry, COL_NAME, name, COL_LENGTH, buf, COL_COLOR, NULL, -1); free(name); /* store row reference */ GtkTreePath *path = gtk_tree_model_get_path(GTK_TREE_MODEL(playlist_ctx->store), &iter); ctx->rowref = gtk_tree_row_reference_new(GTK_TREE_MODEL(playlist_ctx->store), path); gtk_tree_path_free(path); unlock_ui(); }
static void move_account_after(GtkListStore *store, GtkTreeIter *iter, GtkTreeIter *position) { GtkTreeIter new_iter; PurpleAccount *account; gtk_tree_model_get(GTK_TREE_MODEL(store), iter, COLUMN_DATA, &account, -1); gtk_list_store_insert_after(store, &new_iter, position); set_account(store, &new_iter, account); gtk_list_store_remove(store, iter); }
static void cb_duplicate_clicked (G_GNUC_UNUSED GtkWidget *ignore, SheetManager *state) { GtkTreeIter sel_iter, iter; GtkTreeSelection *selection = gtk_tree_view_get_selection (state->sheet_list); GList *selected_rows; WorkbookSheetState *old_state; int index; WorkbookControl *wbc = GNM_WBC (state->wbcg); Workbook *wb = wb_control_get_workbook (wbc); Sheet *new_sheet, *this_sheet; g_return_if_fail (selection != NULL); g_return_if_fail (gtk_tree_selection_count_selected_rows (selection) == 1); selected_rows = gtk_tree_selection_get_selected_rows (selection, NULL); gtk_tree_model_get_iter (GTK_TREE_MODEL (state->model), &sel_iter, (GtkTreePath *) selected_rows->data); g_list_free_full (selected_rows, (GDestroyNotify) gtk_tree_path_free); gtk_tree_model_get (GTK_TREE_MODEL (state->model), &sel_iter, SHEET_POINTER, &this_sheet, -1); workbook_signals_block (state); old_state = workbook_sheet_state_new (wb); index = this_sheet->index_in_wb; new_sheet = sheet_dup (this_sheet); workbook_sheet_attach_at_pos (wb, new_sheet, index + 1); g_signal_emit_by_name (G_OBJECT (wb), "sheet_added", 0); cmd_reorganize_sheets (wbc, old_state, NULL); update_undo (state, wbc); workbook_signals_unblock (state); g_signal_handler_block (state->model, state->model_row_insertion_listener); gtk_list_store_insert_after (state->model, &iter, &sel_iter); g_signal_handler_unblock (state->model, state->model_row_insertion_listener); set_sheet_info_at_iter (state, &iter, new_sheet); g_object_unref (new_sheet); cb_selection_changed (NULL, state); }
static void add_item (GtkWidget *button, gpointer data) { Item foo; GtkTreeIter current, iter; GtkTreePath *path; GtkTreeModel *model; GtkTreeViewColumn *column; GtkTreeView *treeview = (GtkTreeView *)data; g_return_if_fail (articles != NULL); foo.number = 0; foo.product = g_strdup ("Description here"); foo.yummy = 50; g_array_append_vals (articles, &foo, 1); /* Insert a new row below the current one */ gtk_tree_view_get_cursor (treeview, &path, NULL); model = gtk_tree_view_get_model (treeview); if (path) { gtk_tree_model_get_iter (model, ¤t, path); gtk_tree_path_free (path); gtk_list_store_insert_after (GTK_LIST_STORE (model), &iter, ¤t); } else { gtk_list_store_insert (GTK_LIST_STORE (model), &iter, -1); } /* Set the data for the new row */ gtk_list_store_set (GTK_LIST_STORE (model), &iter, COLUMN_ITEM_NUMBER, foo.number, COLUMN_ITEM_PRODUCT, foo.product, COLUMN_ITEM_YUMMY, foo.yummy, -1); /* Move focus to the new row */ path = gtk_tree_model_get_path (model, &iter); column = gtk_tree_view_get_column (treeview, 0); gtk_tree_view_set_cursor (treeview, path, column, FALSE); gtk_tree_path_free (path); }
void bmd_add_item (GtkWidget *button, gpointer data) { Item foo; GtkTreeIter current, iter; GtkTreePath *path; GtkTreeModel *model; GtkTreeViewColumn *column; GtkTreeView *treeview = (GtkTreeView *) data; g_return_if_fail (articles != NULL); foo.number = 0; foo.title = g_strdup ("Title here"); foo.author = g_strdup ("Author here"); foo.pages = 42; g_array_append_vals (articles, &foo, 1); /* Insert a new row below the current one */ gtk_tree_view_get_cursor (treeview, &path, NULL); model = gtk_tree_view_get_model (treeview); if (path) { gtk_tree_model_get_iter (model, ¤t, path); gtk_tree_path_free (path); gtk_list_store_insert_after (GTK_LIST_STORE (model), &iter, ¤t); } else { gtk_list_store_insert (GTK_LIST_STORE (model), &iter, -1); } /* Set the data for the new row */ gtk_list_store_set (GTK_LIST_STORE (model), &iter, COLUMN_ITEM_NUMBER, foo.number, COLUMN_ITEM_TITLE, foo.title, COLUMN_ITEM_AUTHOR, foo.author, COLUMN_ITEM_PAGES, foo.pages, -1); /* Move focus to the new row */ path = gtk_tree_model_get_path (model, &iter); column = gtk_tree_view_get_column (treeview, 0); gtk_tree_view_set_cursor (treeview, path, column, FALSE); gtk_tree_path_free (path); }
static void futz_row (void) { gint i; GtkTreePath *path; GtkTreeIter iter; GtkTreeIter iter2; i = g_rand_int_range (grand, 0, gtk_tree_model_iter_n_children (model, NULL)); path = gtk_tree_path_new (); gtk_tree_path_append_index (path, i); gtk_tree_model_get_iter (model, &iter, path); gtk_tree_path_free (path); if (gtk_tree_selection_iter_is_selected (selection, &iter)) return; switch (g_rand_int_range (grand, 0, 3)) { case 0: /* insert */ gtk_list_store_insert_after (GTK_LIST_STORE (model), &iter2, &iter); gtk_list_store_set (GTK_LIST_STORE (model), &iter2, TEXT_COLUMN, words[g_rand_int_range (grand, 0, NUM_WORDS)], -1); break; case 1: /* delete */ if (gtk_tree_model_iter_n_children (model, NULL) == 0) return; gtk_list_store_remove (GTK_LIST_STORE (model), &iter); break; case 2: /* modify */ return; if (gtk_tree_model_iter_n_children (model, NULL) == 0) return; gtk_list_store_set (GTK_LIST_STORE (model), &iter, TEXT_COLUMN, words[g_rand_int_range (grand, 0, NUM_WORDS)], -1); break; } }
static void gimp_int_store_insert_separator_after (GimpIntStore *store, gint after, gint separator_value) { GtkTreeIter iter; g_return_if_fail (GIMP_IS_INT_STORE (store)); if (gimp_int_store_lookup_by_value (GTK_TREE_MODEL (store), after, &iter)) { GtkTreeIter sep_iter; gtk_list_store_insert_after (GTK_LIST_STORE (store), &sep_iter, &iter); gtk_list_store_set (GTK_LIST_STORE (store), &sep_iter, GIMP_INT_STORE_VALUE, separator_value, -1); } }
/** Add a maritime trade */ static void add_maritime_trade(QuoteView * qv, G_GNUC_UNUSED gint ratio, G_GNUC_UNUSED Resource receive, G_GNUC_UNUSED Resource supply) { QuoteInfo *quote; QuoteInfo *prev; gchar quote_desc[128]; GtkTreeIter iter; for (quote = quotelist_first(qv->quote_list); quote != NULL; quote = quotelist_next(quote)) if (quote->is_domestic) break; else if (quote->var.m.ratio == ratio && quote->var.m.supply == supply && quote->var.m.receive == receive) return; quote = quotelist_add_maritime(qv->quote_list, ratio, supply, receive); trade_format_maritime(quote, quote_desc); prev = quotelist_prev(quote); quote_found_flag = FALSE; if (prev != NULL) gtk_tree_model_foreach(GTK_TREE_MODEL(qv->store), trade_locate_quote, prev); if (quote_found_flag) gtk_list_store_insert_after(qv->store, &iter, "e_found_iter); else gtk_list_store_prepend(qv->store, &iter); gtk_list_store_set(qv->store, &iter, TRADE_COLUMN_PLAYER, maritime_pixbuf, TRADE_COLUMN_POSSIBLE, NULL, TRADE_COLUMN_DESCRIPTION, quote_desc, TRADE_COLUMN_QUOTE, quote, TRADE_COLUMN_PLAYER_NUM, -1, /* Maritime trade */ -1); }
/****************************************************************************** * gtk_ListStoreInsertAfter(list, sibling_path_string/NULL, ncol, val, ....)-->path_string ******************************************************************************/ int clip_GTK_LISTSTOREINSERTAFTER(ClipMachine * cm) { C_object *cslist = _fetch_co_arg(cm); gchar *sibling = _clip_parc(cm, 2); GtkTreeIter iter; GtkTreeIter siblingiter; GtkTreePath *path; gchar *path_string; CHECKARG2(1, MAP_t, NUMERIC_t); CHECKCOBJ(cslist, GTK_IS_LIST_STORE(cslist->object)); CHECKOPT(2, CHARACTER_t); if (sibling) gtk_tree_model_get_iter(GTK_TREE_MODEL(GTK_LIST_STORE(cslist->object)), &siblingiter, gtk_tree_path_new_from_string(sibling)); gtk_list_store_insert_after(GTK_LIST_STORE(cslist->object), &iter, (sibling?&siblingiter:NULL)); __list_store_set(cm, &iter, 3); path = gtk_tree_model_get_path(GTK_TREE_MODEL(GTK_LIST_STORE(cslist->object)), &iter); path_string = gtk_tree_path_to_string(path); _clip_retc(cm, path_string); g_free(path_string); return 0; err: return 1; }
static void window_tab_added (PlumaWindow *window, PlumaTab *tab, PlumaDocumentsPanel *panel) { GtkTreeIter iter; GtkTreeIter sibling; GdkPixbuf *pixbuf; gchar *name; g_signal_connect (tab, "notify::name", G_CALLBACK (sync_name_and_icon), panel); g_signal_connect (tab, "notify::state", G_CALLBACK (sync_name_and_icon), panel); get_iter_from_tab (panel, tab, &sibling); panel->priv->adding_tab = TRUE; if (gtk_list_store_iter_is_valid (GTK_LIST_STORE (panel->priv->model), &sibling)) { gtk_list_store_insert_after (GTK_LIST_STORE (panel->priv->model), &iter, &sibling); } else { PlumaTab *active_tab; gtk_list_store_append (GTK_LIST_STORE (panel->priv->model), &iter); active_tab = pluma_window_get_active_tab (panel->priv->window); if (tab == active_tab) { GtkTreeSelection *selection; selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW (panel->priv->treeview)); gtk_tree_selection_select_iter (selection, &iter); } } name = tab_get_name (tab); pixbuf = _pluma_tab_get_icon (tab); gtk_list_store_set (GTK_LIST_STORE (panel->priv->model), &iter, PIXBUF_COLUMN, pixbuf, NAME_COLUMN, name, TAB_COLUMN, tab, -1); g_free (name); if (pixbuf != NULL) g_object_unref (pixbuf); panel->priv->adding_tab = FALSE; }
static void run_automated_tests (void) { g_print ("Running automated tests...\n"); /* FIXME TreePath basic verification */ /* FIXME generic consistency checks on the models */ { /* Make sure list store mutations don't crash anything */ GtkListStore *store; GtkTreeModel *model; gint i; GtkTreeIter iter; store = gtk_list_store_new (1, G_TYPE_INT); model = GTK_TREE_MODEL (store); i = 0; while (i < 100) { gtk_list_store_append (store, &iter); ++i; } while (gtk_tree_model_get_iter_first (model, &iter)) gtk_list_store_remove (store, &iter); gtk_list_store_append (store, &iter); /* inserts before last node in list */ i = 0; while (i < 100) { gtk_list_store_insert_before (store, &iter, &iter); ++i; } /* inserts after the node before the last node */ i = 0; while (i < 100) { gtk_list_store_insert_after (store, &iter, &iter); ++i; } /* inserts after the last node */ gtk_list_store_append (store, &iter); i = 0; while (i < 100) { gtk_list_store_insert_after (store, &iter, &iter); ++i; } /* remove everything again */ while (gtk_tree_model_get_iter_first (model, &iter)) gtk_list_store_remove (store, &iter); /* Prepends */ gtk_list_store_prepend (store, &iter); i = 0; while (i < 100) { gtk_list_store_prepend (store, &iter); ++i; } /* remove everything again */ while (gtk_tree_model_get_iter_first (model, &iter)) gtk_list_store_remove (store, &iter); g_object_unref (store); } { /* Make sure tree store mutations don't crash anything */ GtkTreeStore *store; GtkTreeIter root; store = gtk_tree_store_new (1, G_TYPE_INT); gtk_tree_store_append (GTK_TREE_STORE (store), &root, NULL); /* Remove test until it is rewritten to work */ /* treestore_torture_recurse (store, &root, 0);*/ g_object_unref (store); } g_print ("Passed.\n"); }
static void preferences_bookshelf_add_book_to_store (DhPreferences *prefs, DhBook *book, gboolean group_by_language) { DhPreferencesPrivate *priv = dh_preferences_get_instance_private (prefs); GtkTreeIter book_iter; /* If grouping by language we need to add the language categories */ if (group_by_language) { gchar *indented_title; GtkTreeIter language_iter; gboolean language_iter_found; GtkTreeIter next_language_iter; gboolean next_language_iter_found; const gchar *language_title; gboolean first_in_language = FALSE; language_title = dh_book_get_language (book); /* Look for the proper language group */ preferences_bookshelf_find_language_group (prefs, language_title, &language_iter, &language_iter_found, &next_language_iter, &next_language_iter_found); /* New language group needs to be created? */ if (!language_iter_found) { if (!next_language_iter_found) { gtk_list_store_append (priv->bookshelf_store, &language_iter); } else { gtk_list_store_insert_before (priv->bookshelf_store, &language_iter, &next_language_iter); } gtk_list_store_set (priv->bookshelf_store, &language_iter, COLUMN_ENABLED, dh_book_get_enabled (book), COLUMN_TITLE, language_title, COLUMN_BOOK, NULL, COLUMN_WEIGHT, PANGO_WEIGHT_BOLD, COLUMN_INCONSISTENT, FALSE, -1); first_in_language = TRUE; } /* If we got to add first book in a given language group, just append it. */ if (first_in_language) { gtk_list_store_insert_after (priv->bookshelf_store, &book_iter, &language_iter); } else { GtkTreeIter first_book_iter; GtkTreeIter next_book_iter; gboolean next_book_iter_found; gboolean language_inconsistent = FALSE; gboolean language_enabled = FALSE; /* We may need to reset the inconsistent status of the language item */ gtk_tree_model_get (GTK_TREE_MODEL (priv->bookshelf_store), &language_iter, COLUMN_ENABLED, &language_enabled, COLUMN_INCONSISTENT, &language_inconsistent, -1); /* If inconsistent already, do nothing */ if (!language_inconsistent) { if (language_enabled != dh_book_get_enabled (book)) { gtk_list_store_set (priv->bookshelf_store, &language_iter, COLUMN_INCONSISTENT, TRUE, -1); } } /* The language will have at least one book, so we move iter to it */ first_book_iter = language_iter; gtk_tree_model_iter_next (GTK_TREE_MODEL (priv->bookshelf_store), &first_book_iter); /* Find next possible book in language group */ preferences_bookshelf_find_book (prefs, book, &first_book_iter, NULL, NULL, &next_book_iter, &next_book_iter_found); if (!next_book_iter_found) { gtk_list_store_append (priv->bookshelf_store, &book_iter); } else { gtk_list_store_insert_before (priv->bookshelf_store, &book_iter, &next_book_iter); } } /* Add new item with indented title */ indented_title = g_strdup_printf (" %s", dh_book_get_title (book)); gtk_list_store_set (priv->bookshelf_store, &book_iter, COLUMN_ENABLED, dh_book_get_enabled (book), COLUMN_TITLE, indented_title, COLUMN_BOOK, book, COLUMN_WEIGHT, PANGO_WEIGHT_NORMAL, COLUMN_INCONSISTENT, FALSE, -1); g_free (indented_title); } else { /* No language grouping, just order by book title */ GtkTreeIter next_book_iter; gboolean next_book_iter_found; preferences_bookshelf_find_book (prefs, book, NULL, NULL, NULL, &next_book_iter, &next_book_iter_found); if (!next_book_iter_found) { gtk_list_store_append (priv->bookshelf_store, &book_iter); } else { gtk_list_store_insert_before (priv->bookshelf_store, &book_iter, &next_book_iter); } gtk_list_store_set (priv->bookshelf_store, &book_iter, COLUMN_ENABLED, dh_book_get_enabled (book), COLUMN_TITLE, dh_book_get_title (book), COLUMN_BOOK, book, COLUMN_WEIGHT, PANGO_WEIGHT_NORMAL, -1); } }
void dat_add_templ_cb(GtkButton *button, gpointer user_data) { GncABTransDialog *td = user_data; GtkBuilder *builder; GtkWidget *dialog; GtkWidget *entry; gint retval; const gchar *name; GncABTransTempl *templ; struct _FindTemplData data; GtkTreeSelection *selection; GtkTreeIter cur_iter; GtkTreeIter new_iter; g_return_if_fail(td); ENTER("td=%p", td); builder = gtk_builder_new(); gnc_builder_add_from_file (builder, "dialog-ab.glade", "Template Name Dialog"); dialog = GTK_WIDGET(gtk_builder_get_object (builder, "Template Name Dialog")); entry = GTK_WIDGET(gtk_builder_get_object (builder, "template_name")); /* Suggest recipient name as name of the template */ gtk_entry_set_text(GTK_ENTRY(entry), gtk_entry_get_text(GTK_ENTRY(td->recp_name_entry))); do { retval = gtk_dialog_run(GTK_DIALOG(dialog)); if (retval != GTK_RESPONSE_OK) break; name = gtk_entry_get_text(GTK_ENTRY(entry)); if (!*name) break; data.name = name; data.pointer = NULL; gtk_tree_model_foreach(GTK_TREE_MODEL(td->template_list_store), find_templ_helper, &data); if (data.pointer) { gnc_error_dialog(dialog, "%s", _("A template with the given name already exists. " "Please enter another name.")); continue; } /* Create a new template */ templ = gnc_ab_trans_templ_new_full( name, gtk_entry_get_text(GTK_ENTRY(td->recp_name_entry)), gtk_entry_get_text(GTK_ENTRY(td->recp_account_entry)), gtk_entry_get_text(GTK_ENTRY(td->recp_bankcode_entry)), gnc_amount_edit_get_amount(GNC_AMOUNT_EDIT(td->amount_edit)), gtk_entry_get_text(GTK_ENTRY(td->purpose_entry)), gtk_entry_get_text (GTK_ENTRY(td->purpose_cont_entry))); /* Insert it, either after the selected one or at the end */ selection = gtk_tree_view_get_selection(td->template_gtktreeview); if (gtk_tree_selection_get_selected(selection, NULL, &cur_iter)) { gtk_list_store_insert_after(td->template_list_store, &new_iter, &cur_iter); } else { gtk_list_store_append(td->template_list_store, &new_iter); } gtk_list_store_set(td->template_list_store, &new_iter, TEMPLATE_NAME, name, TEMPLATE_POINTER, templ, -1); td->templ_changed = TRUE; DEBUG("Added template with name %s", name); break; } while (TRUE); g_object_unref(G_OBJECT(builder)); gtk_widget_destroy(dialog); LEAVE(" "); }
static void gtk_app_chooser_button_populate (GtkAppChooserButton *self) { GList *recommended_apps = NULL, *l; GAppInfo *app, *default_app = NULL; GtkTreeIter iter, iter2; gboolean cycled_recommended; #ifndef G_OS_WIN32 if (self->priv->content_type) recommended_apps = g_app_info_get_recommended_for_type (self->priv->content_type); #endif cycled_recommended = FALSE; if (self->priv->show_default_item) { if (self->priv->content_type) default_app = g_app_info_get_default_for_type (self->priv->content_type, FALSE); if (default_app != NULL) { get_first_iter (self->priv->store, &iter); cycled_recommended = TRUE; insert_one_application (self, default_app, &iter); g_object_unref (default_app); } } for (l = recommended_apps; l != NULL; l = l->next) { app = l->data; if (default_app != NULL && g_app_info_equal (app, default_app)) continue; if (cycled_recommended) { gtk_list_store_insert_after (self->priv->store, &iter2, &iter); iter = iter2; } else { get_first_iter (self->priv->store, &iter); cycled_recommended = TRUE; } insert_one_application (self, app, &iter); } if (recommended_apps != NULL) g_list_free_full (recommended_apps, g_object_unref); if (!cycled_recommended) gtk_app_chooser_button_ensure_dialog_item (self, NULL); else gtk_app_chooser_button_ensure_dialog_item (self, &iter); gtk_combo_box_set_active (GTK_COMBO_BOX (self), 0); }