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