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);
}
