static void simple_get_variable_row (GtkTreeModel *model, GtkTreeIter *base_iter, GtkTreeIter *dest_iter) { GtkTreeIter iter; iter = *base_iter; if (!gtk_tree_model_iter_previous (model, &iter) || !gtk_tree_model_iter_previous (model, &iter) || !simple_row_separator_cb (model, &iter, NULL)) { /* Create two new rows if it does not exist */ GtkListStore *store; store = GTK_LIST_STORE (model); gtk_list_store_insert_before (store, dest_iter, base_iter); gtk_list_store_insert_before (store, &iter, dest_iter); gtk_list_store_set (store, &iter, SIMPLE_COL_FORMAT, 0, SIMPLE_COL_FILTER, 0, SIMPLE_COL_DESCRIPTION, "", -1); } else { /* Use the existing row */ iter = *base_iter; gtk_tree_model_iter_previous (model, &iter); *dest_iter = iter; } }
orcaData orcaGtkIter::ex_insert(orcaVM* vm, int n)/*{{{*/ { if (n < 1) vm->need_param(); GtkTreeIter iter; if (m_type == GUI_LIST) gtk_list_store_insert_before(GTK_LIST_STORE(m_gp->store), &iter, &m_iter); else { GtkTreeIter parent; GtkTreeIter* pp = NULL; if (gtk_tree_model_iter_parent(m_gp->store, &parent, &m_iter)) pp = &parent; gtk_tree_store_insert_before(GTK_TREE_STORE(m_gp->store), &iter, pp, &m_iter); } orcaList* lp = castobj<orcaList>(vm->get_param(0)); if (lp == NULL) { throw orcaException(vm, "orca.type", "list type is required"); } set_list_to_store(lp, m_gp->store, &iter, m_type); return NIL; }
static void move_to_left (GtkTreeModel *src, GtkTreeIter *src_iter, GtkTreeIter *dest_iter) { GtkTreeIter iter; GtkTreeViewColumn *column; GtkTreeSelection *selection; gchar *label; gtk_tree_model_get (src, src_iter, 0, &label, 1, &column, -1); if (src == top_right_tree_model) gtk_tree_view_remove_column (GTK_TREE_VIEW (sample_tree_view_top), column); else gtk_tree_view_remove_column (GTK_TREE_VIEW (sample_tree_view_bottom), column); /* gtk_list_store_remove (GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (data))), &iter);*/ /* Put it back on the left */ if (dest_iter) gtk_list_store_insert_before (GTK_LIST_STORE (left_tree_model), &iter, dest_iter); else gtk_list_store_append (GTK_LIST_STORE (left_tree_model), &iter); gtk_list_store_set (GTK_LIST_STORE (left_tree_model), &iter, 0, label, 1, column, -1); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (left_tree_view)); gtk_tree_selection_select_iter (selection, &iter); g_free (label); }
static void tb_editor_btn_add_clicked_cb(GtkWidget *button, TBEditorWidget *tbw) { GtkTreeModel *model_available; GtkTreeSelection *selection_available, *selection_used; GtkTreeIter iter_available, iter_new, iter_selected; gchar *action_name; selection_available = gtk_tree_view_get_selection(tbw->tree_available); if (gtk_tree_selection_get_selected(selection_available, &model_available, &iter_available)) { gtk_tree_model_get(model_available, &iter_available, TB_EDITOR_COL_ACTION, &action_name, -1); if (g_strcmp0(action_name, "Separator") != 0) { if (gtk_list_store_remove(tbw->store_available, &iter_available)) gtk_tree_selection_select_iter(selection_available, &iter_available); } selection_used = gtk_tree_view_get_selection(tbw->tree_used); if (gtk_tree_selection_get_selected(selection_used, NULL, &iter_selected)) { gtk_list_store_insert_before(tbw->store_used, &iter_new, &iter_selected); tb_editor_set_item_values(tbw, action_name, tbw->store_used, &iter_new); } else { gtk_list_store_append(tbw->store_used, &iter_new); tb_editor_set_item_values(tbw, action_name, tbw->store_used, &iter_new); } tb_editor_scroll_to_iter(tbw->tree_used, &iter_new); g_free(action_name); } }
/** * gimp_color_profile_store_add_file: * @store: a #GimpColorProfileStore * @file: file of the profile to add (or %NULL) * @label: label to use for the profile * (may only be %NULL if @filename is %NULL) * * Adds a color profile item to the #GimpColorProfileStore. Items * added with this function will be kept at the top, separated from * the history of last used color profiles. * * This function is often used to add a selectable item for the %NULL * file. If you pass %NULL for both @file and @label, the @label will * be set to the string "None" for you (and translated for the user). * * Since: 2.10 **/ void gimp_color_profile_store_add_file (GimpColorProfileStore *store, GFile *file, const gchar *label) { GtkTreeIter separator; GtkTreeIter iter; g_return_if_fail (GIMP_IS_COLOR_PROFILE_STORE (store)); g_return_if_fail (label != NULL || file == NULL); g_return_if_fail (file == NULL || G_IS_FILE (file)); if (! file && ! label) label = C_("profile", "None"); gimp_color_profile_store_get_separator (store, &separator, TRUE); gtk_list_store_insert_before (GTK_LIST_STORE (store), &iter, &separator); gtk_list_store_set (GTK_LIST_STORE (store), &iter, GIMP_COLOR_PROFILE_STORE_ITEM_TYPE, GIMP_COLOR_PROFILE_STORE_ITEM_FILE, GIMP_COLOR_PROFILE_STORE_FILE, file, GIMP_COLOR_PROFILE_STORE_LABEL, label, GIMP_COLOR_PROFILE_STORE_INDEX, -1, -1); }
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 add_vol(GVolume* vol) { GtkTreeIter it; PlaceItem* item; item = g_slice_new0(PlaceItem); item->type = PLACE_VOL; item->vol = (GVolume*)g_object_ref(vol); gtk_list_store_insert_before(model, &it, &sep_it); gtk_list_store_set(model, &it, COL_INFO, item, -1); update_vol(item, &it); }
static VALUE rg_insert_before(VALUE self, VALUE sibling) { VALUE ret; GtkTreeIter iter; GtkListStore* model = _SELF(self); gtk_list_store_insert_before(model, &iter, NIL_P(sibling) ? NULL : RVAL2GTKTREEITER(sibling)); iter.user_data3 = model; ret = GTKTREEITER2RVAL(&iter); return ret; }
static void add_vol(FmPlacesModel* model, GVolume* vol, FmFileInfoJob* job) { GtkTreeIter it; FmPlaceItem* item; item = g_slice_new0(FmPlaceItem); item->fi = fm_file_info_new(); item->type = FM_PLACES_ITEM_VOL; item->vol = (GVolume*)g_object_ref(vol); gtk_list_store_insert_before(GTK_LIST_STORE(model), &it, &model->sep_it); gtk_list_store_set(GTK_LIST_STORE(model), &it, FM_PLACES_MODEL_COL_INFO, item, -1); update_vol(model, item, &it, job); }
static void move_account_before(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_before(store, &new_iter, position); set_account(store, &new_iter, account); gtk_list_store_remove(store, iter); }
/** Player <I>player_num</I> has rejected trade */ void quote_view_reject(QuoteView * qv, gint player_num) { Player *player = player_get(player_num); QuoteInfo *quote; GtkTreeIter iter; enum TFindResult found; GdkPixbuf *pixbuf; if (qv->quote_list == NULL) return; while ((quote = quotelist_find_domestic(qv->quote_list, player_num, -1)) != NULL) { remove_quote(qv, quote); } quote_found_flag = FALSE; gtk_tree_model_foreach(GTK_TREE_MODEL(qv->store), trade_locate_reject, player); if (quote_found_flag) /* Already removed */ return; /* work out where to put the reject row */ for (quote = quotelist_first(qv->quote_list); quote != NULL; quote = quotelist_next(quote)) if (!quote->is_domestic) continue; else if (quote->var.d.player_num >= player_num) break; found = find_integer_in_tree(GTK_TREE_MODEL(qv->store), &iter, TRADE_COLUMN_PLAYER_NUM, player_num); if (found != FIND_NO_MATCH) gtk_list_store_insert_before(qv->store, &iter, &iter); else gtk_list_store_append(qv->store, &iter); pixbuf = player_create_icon(GTK_WIDGET(qv), player_num, TRUE); gtk_list_store_set(qv->store, &iter, TRADE_COLUMN_PLAYER, pixbuf, TRADE_COLUMN_POSSIBLE, cross_pixbuf, /* Trade: a player has rejected trade */ TRADE_COLUMN_DESCRIPTION, _("Rejected trade"), TRADE_COLUMN_QUOTE, NULL, TRADE_COLUMN_REJECT, player, TRADE_COLUMN_PLAYER_NUM, player_num, -1); g_object_unref(pixbuf); }
static void cb_merge_add_clicked (G_GNUC_UNUSED GtkWidget *ignore, MergeState *state) { GtkTreeIter iter; GtkTreeIter sel_iter; GtkTreeSelection *selection = gtk_tree_view_get_selection (state->list); if (!gtk_tree_selection_get_selected (selection, NULL, &sel_iter)) gtk_list_store_append (state->model, &iter); else gtk_list_store_insert_before (state->model, &iter, &sel_iter); merge_store_info_in_list (&iter, state); }
static void append_row(uat_t *uat, guint idx) { void *rec = UAT_INDEX_PTR(uat, idx); uat_field_t *f = uat->fields; guint colnum; GtkTreeIter iter; gchar* tmp_str; if (! uat->rep) return; gtk_list_store_insert_before(uat->rep->list_store, &iter, NULL); for ( colnum = 0; colnum < uat->ncols; colnum++ ) { tmp_str = fld_tostr(rec, &(f[colnum])); gtk_list_store_set(uat->rep->list_store, &iter, colnum, tmp_str, -1); g_free(tmp_str); } }
static void append_row(uat_t *uat, guint idx) { GPtrArray *a = g_ptr_array_new(); void *rec = UAT_INDEX_PTR(uat, idx); uat_field_t *f = uat->fields; guint colnum; GtkTreeIter iter; if (! uat->rep) return; gtk_list_store_insert_before(uat->rep->list_store, &iter, NULL); for ( colnum = 0; colnum < uat->ncols; colnum++ ) { g_ptr_array_add(a, fld_tostr(rec, &(f[colnum]))); gtk_list_store_set(uat->rep->list_store, &iter, colnum, fld_tostr(rec, &(f[colnum])), -1); } g_ptr_array_free(a, TRUE); }
static void get_first_iter (GtkListStore *store, GtkTreeIter *iter) { GtkTreeIter iter2; if (!gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), iter)) { /* the model is empty, append */ gtk_list_store_append (store, iter); } else { gtk_list_store_insert_before (store, &iter2, iter); *iter = iter2; } }
static void on_encoding_changed(GtkComboBox* combo, GtkDialog* dialog) { GtkTreeStore* store; GtkTreeModel* model; GtkTreeIter iter; char* encoding; gboolean res; model = gtk_combo_box_get_model(combo); res = gtk_combo_box_get_active_iter(combo, &iter); if (!res) return; encoding = NULL; gtk_tree_model_get(model, &iter, ENCODING_COLUMN_ENCODING, &encoding, -1); if (encoding == NULL) { GtkDialog* encoding_dialog; char* other_encoding; encoding_dialog = encoding_dialog_new(GTK_WINDOW(dialog)); other_encoding = encoding_dialog_run(encoding_dialog); gtk_widget_destroy(GTK_WIDGET(encoding_dialog)); if (other_encoding != NULL) { GtkTreeIter iter2; gtk_list_store_insert_before(GTK_LIST_STORE(model), &iter2, &iter); gtk_list_store_set(GTK_LIST_STORE(model), &iter2, ENCODING_COLUMN_LABEL, other_encoding, ENCODING_COLUMN_ENCODING, other_encoding, -1); gtk_combo_box_set_active_iter(combo, &iter2); g_free(other_encoding); } else { select_default_encoding(combo, model); } } else { store = repair_dialog_get_file_list_model(dialog); res = file_list_model_update_new_names(store, encoding); repair_dialog_set_conversion_state(dialog, res); g_free(encoding); } }
static void cb_add_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; int index = -1; WorkbookSheetState *old_state; WorkbookControl *wbc = GNM_WBC (state->wbcg); Workbook *wb = wb_control_get_workbook (wbc); Sheet *sheet, *old_sheet = NULL; 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, &old_sheet, -1); index = old_sheet->index_in_wb; workbook_signals_block (state); old_state = workbook_sheet_state_new (wb); workbook_sheet_add (wb, index, gnm_sheet_get_max_cols (old_sheet), gnm_sheet_get_max_rows (old_sheet)); 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); sheet = workbook_sheet_by_index (wb, index); gtk_list_store_insert_before (state->model, &iter, &sel_iter); g_signal_handler_unblock (state->model, state->model_row_insertion_listener); set_sheet_info_at_iter (state, &iter, sheet); cb_selection_changed (NULL, state); }
int wxListBox::DoInsertItems(const wxArrayStringsAdapter& items, unsigned int pos, void **clientData, wxClientDataType type) { wxCHECK_MSG( m_treeview != NULL, wxNOT_FOUND, wxT("invalid listbox") ); InvalidateBestSize(); GtkTreeIter* pIter = NULL; // append by default GtkTreeIter iter; if ( pos != GetCount() ) { wxCHECK_MSG( GTKGetIteratorFor(pos, &iter), wxNOT_FOUND, wxT("internal wxListBox error in insertion") ); pIter = &iter; } const unsigned int numItems = items.GetCount(); for ( unsigned int i = 0; i < numItems; ++i ) { GtkTreeEntry* entry = gtk_tree_entry_new(); gtk_tree_entry_set_label(entry, wxGTK_CONV(items[i])); gtk_tree_entry_set_destroy_func(entry, (GtkTreeEntryDestroy)gtk_tree_entry_destroy_cb, this); GtkTreeIter itercur; gtk_list_store_insert_before(m_liststore, &itercur, pIter); GTKSetItem(itercur, entry); g_object_unref (entry); if (clientData) AssignNewItemClientData(GTKGetIndexFor(itercur), clientData, i, type); } UpdateOldSelections(); return pos + numItems - 1; }
/** Add a quote from a player */ void quote_view_add_quote(QuoteView * qv, gint player_num, gint quote_num, const gint * supply, const gint * receive) { GtkTreeIter iter; enum TFindResult found; QuoteInfo *quote; gchar quote_desc[128]; GdkPixbuf *pixbuf; if (qv->quote_list == NULL) quotelist_new(&qv->quote_list); /* If the trade is already listed, don't duplicate */ if (quotelist_find_domestic(qv->quote_list, player_num, quote_num) != NULL) return; quote = quotelist_add_domestic(qv->quote_list, player_num, quote_num, supply, receive); trade_format_quote(quote, quote_desc); found = find_integer_in_tree(GTK_TREE_MODEL(qv->store), &iter, TRADE_COLUMN_PLAYER_NUM, player_num + 1); if (found != FIND_NO_MATCH) gtk_list_store_insert_before(qv->store, &iter, &iter); else gtk_list_store_append(qv->store, &iter); pixbuf = player_create_icon(GTK_WIDGET(qv), player_num, TRUE); gtk_list_store_set(qv->store, &iter, TRADE_COLUMN_PLAYER, pixbuf, TRADE_COLUMN_POSSIBLE, qv->check_quote_func(quote) ? qv-> true_pixbuf : qv->false_pixbuf, TRADE_COLUMN_DESCRIPTION, quote_desc, TRADE_COLUMN_QUOTE, quote, TRADE_COLUMN_PLAYER_NUM, player_num, -1); g_object_unref(pixbuf); }
static void gimp_color_profile_store_create_separator (GimpColorProfileStore *store, GtkTreeIter *iter, gboolean top) { if (top) { gtk_list_store_prepend (GTK_LIST_STORE (store), iter); } else { GtkTreeModel *model = GTK_TREE_MODEL (store); GtkTreeIter sibling; gboolean iter_valid; for (iter_valid = gtk_tree_model_get_iter_first (model, &sibling); iter_valid; iter_valid = gtk_tree_model_iter_next (model, &sibling)) { gint type; gtk_tree_model_get (model, &sibling, GIMP_COLOR_PROFILE_STORE_ITEM_TYPE, &type, -1); if (type == GIMP_COLOR_PROFILE_STORE_ITEM_DIALOG) break; } if (iter_valid) gtk_list_store_insert_before (GTK_LIST_STORE (store), iter, &sibling); } gtk_list_store_set (GTK_LIST_STORE (store), iter, GIMP_COLOR_PROFILE_STORE_ITEM_TYPE, top ? GIMP_COLOR_PROFILE_STORE_ITEM_SEPARATOR_TOP : GIMP_COLOR_PROFILE_STORE_ITEM_SEPARATOR_BOTTOM, GIMP_COLOR_PROFILE_STORE_INDEX, -1, -1); }
/* Add an item to the current list. */ static void tp_page_add_selected(ToolbarPage * page) { gint item = 0; GtkTreeSelection *selection; GtkTreeModel *model; GtkTreeIter iter; GtkTreeIter sibling; GtkTreePath *path; selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(page->available)); if (!gtk_tree_selection_get_selected(selection, &model, &iter)) return; gtk_tree_model_get(model, &iter, TP_ITEM_COLUMN, &item, -1); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(page->current)); if (gtk_tree_selection_get_selected(selection, &model, &sibling)) gtk_list_store_insert_before(GTK_LIST_STORE(model), &iter, &sibling); else gtk_list_store_append(GTK_LIST_STORE(model), &iter); tp_store_set(GTK_LIST_STORE(model), &iter, item); path = gtk_tree_model_get_path(model, &iter); 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 dcc_insert_row_from_task (GtkListStore *model, GtkTreeIter *tree_iter, GtkTreeIter *insert_before, struct dcc_task_state *task_iter) { struct dcc_history *history; history = dcc_history_new(); dcc_history_push(history, task_iter->curr_phase); gtk_list_store_insert_before(chart_model, tree_iter, insert_before); gtk_list_store_set(model, tree_iter, COLUMN_HOST, task_iter->host, COLUMN_SLOT, task_iter->slot, COLUMN_FILE, task_iter->file, COLUMN_STATE, dcc_get_phase_name(task_iter->curr_phase), COLUMN_HISTORY, history, -1); }
void discard_player_must(gint player_num, gint num) { GtkTreeIter iter; GdkPixbuf *pixbuf; enum TFindResult found; /* Search for a place to add information about the player */ found = find_integer_in_tree(GTK_TREE_MODEL(discard_store), &iter, DISCARD_COLUMN_PLAYER_NUM, player_num); switch (found) { case FIND_NO_MATCH: gtk_list_store_append(discard_store, &iter); break; case FIND_MATCH_INSERT_BEFORE: gtk_list_store_insert_before(discard_store, &iter, &iter); break; case FIND_MATCH_EXACT: break; default: g_error("unknown case in discard_player_must"); }; pixbuf = player_create_icon(discard_widget, player_num, TRUE); gtk_list_store_set(discard_store, &iter, DISCARD_COLUMN_PLAYER_ICON, pixbuf, DISCARD_COLUMN_PLAYER_NUM, player_num, DISCARD_COLUMN_PLAYER_NAME, player_name(player_num, TRUE), DISCARD_COLUMN_AMOUNT, num, -1); g_object_unref(pixbuf); if (player_num != my_player_num()) return; discard_create_dlg(num); }
static void cb_pm_button_rescan_directories_clicked (PluginManagerGUI *pm_gui) { GOErrorInfo *error; GSList *new_plugins, *l; GtkTreeModel *model = GTK_TREE_MODEL (pm_gui->model_plugins); GtkTreeIter iter, new_iter; gboolean has_iter; go_plugins_rescan (&error, &new_plugins); if (error != NULL) { go_cmd_context_error_info (pm_gui->cc, error); go_error_info_free (error); } GO_SLIST_SORT (new_plugins, plugin_compare_name); for (has_iter = gtk_tree_model_get_iter_first (model, &iter), l = new_plugins; has_iter && l != NULL; has_iter = gtk_tree_model_iter_next (model, &iter)) { GOPlugin *old_plugin, *new_plugin; gtk_tree_model_get (model, &iter, PLUGIN_POINTER, &old_plugin, -1); while (new_plugin = l->data, plugin_compare_name (old_plugin, new_plugin) > 0) { gtk_list_store_insert_before (pm_gui->model_plugins, &new_iter, &iter); set_plugin_model_row (pm_gui, &new_iter, new_plugin); l = l->next; if (l == NULL) break; } } while (l != NULL) { gtk_list_store_append (pm_gui->model_plugins, &new_iter); set_plugin_model_row (pm_gui, &new_iter, GO_PLUGIN (l->data)); l = l->next; } g_slist_free (new_plugins); }
/****************************************************************************** * gtk_ListStoreInsertBefore(list, sibling_path_string/NULL, ncol, val, ....)-->path_string ******************************************************************************/ int clip_GTK_LISTSTOREINSERTBEFORE(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_before(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 build_channel_list(void) { GtkTreeIter iter, iter2, iter3; unsigned int enabled; char *device, *device2; gboolean first = FALSE, iter3_valid = FALSE, loop, loop2, all = FALSE; char dev_ch[256]; loop = gtk_tree_model_get_iter_first(GTK_TREE_MODEL (device_list_store), &iter); gtk_list_store_clear(channel_list_store); while (loop) { gtk_tree_model_get(GTK_TREE_MODEL (device_list_store), &iter, 0, &device, 1, &enabled, -1); if (enabled) { struct iio_device *dev; unsigned int i, nb_channels; all = true; /* is it already in the list? */ loop2 = gtk_tree_model_get_iter_first(GTK_TREE_MODEL (channel_list_store), &iter2); if (loop2) { first = TRUE; iter3 = iter2; iter3_valid = TRUE; } while (loop2) { gtk_tree_model_get(GTK_TREE_MODEL (channel_list_store), &iter2, 2, &device2, -1); if (!strcmp(device, device2)) break; if (strcmp(device, device2) >= 0) { first = FALSE; iter3 = iter2; } g_free(device2); loop2 = gtk_tree_model_iter_next(GTK_TREE_MODEL (channel_list_store), &iter2); } /* it is, so skip the rest */ if (loop2) { loop = gtk_tree_model_iter_next(GTK_TREE_MODEL (device_list_store), &iter); continue; } dev = get_device(device); if (!dev) continue; nb_channels = iio_device_get_channels_count(dev); for (i = 0; i < nb_channels; i++) { struct iio_channel *chn = iio_device_get_channel(dev, i); const char *name, *id, *devid; /* Must be input */ if (!is_valid_dmm_channel(chn)) continue; /* find the name */ devid = iio_device_get_id(dev); name = iio_channel_get_name(chn); id = iio_channel_get_id(chn); if (!name) name = id; if (iter3_valid) { if (first) { gtk_list_store_insert_before(channel_list_store, &iter2, &iter3); first = FALSE; } else if(gtk_tree_model_iter_next(GTK_TREE_MODEL (channel_list_store), &iter3)) gtk_list_store_insert_before(channel_list_store, &iter2, &iter3); else gtk_list_store_append(channel_list_store, &iter2); } else { gtk_list_store_append(channel_list_store, &iter2); iter3_valid = TRUE; } snprintf(dev_ch, sizeof(dev_ch), "%s:%s", device, name); gtk_list_store_set(channel_list_store, &iter2, 0, dev_ch, /* device & channel name */ 1, 0, /* On/Off */ 2, devid, /* device ID */ 3, id, /* channel ID */ -1); iter3 = iter2; } } else { loop2 = gtk_tree_model_get_iter_first(GTK_TREE_MODEL (channel_list_store), &iter2); while (loop2) { gtk_tree_model_get(GTK_TREE_MODEL (channel_list_store), &iter2, 2, &device2, -1); if (!strcmp(device, device2)) { loop2 = gtk_list_store_remove(channel_list_store, &iter2); continue; } loop2 = gtk_tree_model_iter_next(GTK_TREE_MODEL (channel_list_store), &iter2); } } loop = gtk_tree_model_iter_next(GTK_TREE_MODEL (device_list_store), &iter); } gtk_tree_sortable_set_sort_column_id( GTK_TREE_SORTABLE(GTK_TREE_MODEL(channel_list_store)), 0, GTK_SORT_ASCENDING); if (all) gtk_widget_show(select_all_channels); else gtk_widget_hide(select_all_channels); }
static gboolean gimp_color_profile_store_history_insert (GimpColorProfileStore *store, GtkTreeIter *iter, GFile *file, const gchar *label, gint index) { GtkTreeModel *model = GTK_TREE_MODEL (store); GtkTreeIter sibling; gboolean iter_valid; g_return_val_if_fail (G_IS_FILE (file), FALSE); g_return_val_if_fail (label != NULL, FALSE); g_return_val_if_fail (index > -1, FALSE); gimp_color_profile_store_get_separator (store, iter, FALSE); for (iter_valid = gtk_tree_model_get_iter_first (model, &sibling); iter_valid; iter_valid = gtk_tree_model_iter_next (model, &sibling)) { gint type; gint this_index; gtk_tree_model_get (model, &sibling, GIMP_COLOR_PROFILE_STORE_ITEM_TYPE, &type, GIMP_COLOR_PROFILE_STORE_INDEX, &this_index, -1); if (type == GIMP_COLOR_PROFILE_STORE_ITEM_SEPARATOR_BOTTOM) { gtk_list_store_insert_before (GTK_LIST_STORE (store), iter, &sibling); break; } if (type == GIMP_COLOR_PROFILE_STORE_ITEM_FILE && this_index > -1) { gchar *this_label; gtk_tree_model_get (model, &sibling, GIMP_COLOR_PROFILE_STORE_LABEL, &this_label, -1); if (this_label && g_utf8_collate (label, this_label) < 0) { gtk_list_store_insert_before (GTK_LIST_STORE (store), iter, &sibling); g_free (this_label); break; } g_free (this_label); } } if (iter_valid) gtk_list_store_set (GTK_LIST_STORE (store), iter, GIMP_COLOR_PROFILE_STORE_ITEM_TYPE, GIMP_COLOR_PROFILE_STORE_ITEM_FILE, GIMP_COLOR_PROFILE_STORE_FILE, file, GIMP_COLOR_PROFILE_STORE_LABEL, label, GIMP_COLOR_PROFILE_STORE_INDEX, index, -1); return iter_valid; }
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 gimp_scale_combo_box_set_scale (GimpScaleComboBox *combo_box, gdouble scale) { GtkTreeModel *model; GtkListStore *store; GtkTreeIter iter; gboolean iter_valid; gboolean persistent; g_return_if_fail (GIMP_IS_SCALE_COMBO_BOX (combo_box)); g_return_if_fail (scale > 0.0); model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo_box)); store = GTK_LIST_STORE (model); for (iter_valid = gtk_tree_model_get_iter_first (model, &iter); iter_valid; iter_valid = gtk_tree_model_iter_next (model, &iter)) { gdouble this; gtk_tree_model_get (model, &iter, COLUMN_SCALE, &this, -1); if (fabs (this - scale) < 0.0001) break; } if (! iter_valid) { GtkTreeIter sibling; for (iter_valid = gtk_tree_model_get_iter_first (model, &sibling); iter_valid; iter_valid = gtk_tree_model_iter_next (model, &sibling)) { gdouble this; gtk_tree_model_get (model, &sibling, COLUMN_SCALE, &this, -1); if (this < scale) break; } gtk_list_store_insert_before (store, &iter, iter_valid ? &sibling : NULL); gimp_scale_combo_box_scale_iter_set (store, &iter, scale, FALSE); } gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo_box), &iter); gtk_tree_model_get (model, &iter, COLUMN_PERSISTENT, &persistent, -1); if (! persistent) { gimp_scale_combo_box_mru_add (combo_box, &iter); if (gtk_tree_model_iter_n_children (model, NULL) > MAX_ITEMS) gimp_scale_combo_box_mru_remove_last (combo_box); } }