static void
remove_network (EmpathyIrcNetworkChooserDialog *self)
{
EmpathyIrcNetworkChooserDialogPriv *priv = GET_PRIV (self);
EmpathyIrcNetwork *network;
GtkTreeIter iter;
network = dup_selected_network (self, &iter);
if (network == NULL)
return;
/* Hide the search after picking the network to get the right one */
gtk_widget_hide (priv->search);
DEBUG ("Remove network %s", empathy_irc_network_get_name (network));
/* Delete network and select next network */
if (gtk_list_store_remove (priv->store, &iter))
{
GtkTreeIter filter_iter = iter_to_filter_iter (self, &iter);
select_iter (self, &filter_iter, TRUE);
}
else
{
/* this should only happen if the last network was deleted */
GtkTreeIter last, filter_iter;
gint n_elements;
n_elements = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (priv->store),
NULL);
if (n_elements > 0)
{
gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (priv->store), &last,
NULL, (n_elements-1));
filter_iter = iter_to_filter_iter (self, &last);
select_iter (self, &filter_iter, TRUE);
}
}
empathy_irc_network_manager_remove (priv->network_manager, network);
gtk_widget_grab_focus (priv->treeview);
g_object_unref (network);
}
void
on_remove_button_clicked (GtkButton *button,
gpointer user_data) {
GtkTreeView *treeview = GTK_TREE_VIEW(lookup_widget(conf_dlg, "command_treeview"));
GtkTreeModel *treemodel = gtk_tree_view_get_model(treeview);
GtkTreeIter iter;
GtkTreeSelection *selection;
selection = gtk_tree_view_get_selection(treeview);
if(gtk_tree_selection_get_selected(selection, &treemodel, &iter)) {
// ask confirmation
GtkWidget *confirm_dlg = gtk_message_dialog_new (GTK_WINDOW(conf_dlg), GTK_DIALOG_MODAL,
GTK_MESSAGE_WARNING, GTK_BUTTONS_YES_NO,
_("Delete"));
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (confirm_dlg),
"%s", _("This action will delete the selected shell command. Are you sure?"));
gtk_window_set_transient_for(GTK_WINDOW (confirm_dlg), GTK_WINDOW (conf_dlg));
gtk_window_set_title (GTK_WINDOW (confirm_dlg), _("Confirm Remove"));
int response = gtk_dialog_run (GTK_DIALOG (confirm_dlg));
gtk_widget_destroy(confirm_dlg);
if(response == GTK_RESPONSE_NO) {
return;
}
Shx_action_t *action;
gtk_tree_model_get(treemodel, &iter, COL_META, &action, -1);
//remove action from list
shellexec_plugin->action_remove (action);
actions = (Shx_action_t *)shellexec_plugin->misc.plugin.get_actions(NULL);
GtkTreeIter next_iter = iter;
if(gtk_tree_model_iter_next(treemodel, &next_iter)) {
gtk_tree_selection_select_iter(selection, &next_iter);
}
else {
int count = gtk_tree_model_iter_n_children(treemodel, NULL);
if(count >= 2) {
GtkTreePath *last = gtk_tree_path_new_from_indices(count-2, -1);
gtk_tree_selection_select_path(selection, last);
}
}
gtk_list_store_remove(GTK_LIST_STORE(treemodel), &iter);
shellexec_plugin->save_actions();
deadbeef->sendmessage (DB_EV_ACTIONSCHANGED, 0, 0, 0);
}
}
static void
save_dialog_response (GtkWidget *save_dialog,
gint response_id,
AppearanceData *data)
{
if (response_id == GTK_RESPONSE_OK) {
GtkWidget *entry;
GtkWidget *text_view;
GtkTextBuffer *buffer;
GtkTextIter start_iter;
GtkTextIter end_iter;
gchar *buffer_text;
GnomeThemeMetaInfo *theme_info;
gchar *theme_description = NULL;
gchar *theme_name = NULL;
gboolean save_background;
GError *error = NULL;
entry = glade_xml_get_widget (data->xml, "save_dialog_entry");
theme_name = escape_string_and_dup (gtk_entry_get_text (GTK_ENTRY (entry)));
text_view = glade_xml_get_widget (data->xml, "save_dialog_textview");
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
gtk_text_buffer_get_start_iter (buffer, &start_iter);
gtk_text_buffer_get_end_iter (buffer, &end_iter);
buffer_text = gtk_text_buffer_get_text (buffer, &start_iter, &end_iter, FALSE);
theme_description = escape_string_and_dup (buffer_text);
g_free (buffer_text);
theme_info = (GnomeThemeMetaInfo *) g_object_get_data (G_OBJECT (save_dialog), "meta-theme-info");
save_background = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (
glade_xml_get_widget (data->xml, "save_background_checkbutton")));
if (save_theme_to_disk (theme_info, theme_name, theme_description, save_background, &error)) {
/* remove the custom theme */
GtkTreeIter iter;
if (theme_find_in_model (GTK_TREE_MODEL (data->theme_store), "__custom__", &iter))
gtk_list_store_remove (data->theme_store, &iter);
}
g_free (theme_name);
g_free (theme_description);
g_clear_error (&error);
}
gtk_widget_hide (save_dialog);
}
static void delete_mail_folder_cb( GtkWidget *widget,
gpointer data )
{
GtkTreeSelection *selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW(data) );
GtkTreeModel *model;
GtkTreeIter iter;
GList *list;
int nRemoved;
int ipath;
GString *fixed_path;
GtkTreePath *path;
if (gtk_tree_selection_count_selected_rows(selection) == 0){
g_print("no selection\n");
return;
}
list = gtk_tree_selection_get_selected_rows( selection, &model );
g_folders = GTK_LIST_STORE ( model );
if (!list){
g_print("no list\n");
return;
}
nRemoved = 0;
while(list) {
ipath = atoi(gtk_tree_path_to_string(list->data));
ipath-=nRemoved;
fixed_path = g_string_new("");
g_string_printf(fixed_path, "%d", ipath);
path = gtk_tree_path_new_from_string(fixed_path->str);
g_string_free(fixed_path, TRUE);
if (path) {
if ( gtk_tree_model_get_iter ( model, &iter, path) ) {
gtk_list_store_remove (g_folders, &iter );
nRemoved++;
}
gtk_tree_path_free (path);
}
list = list->next;
}
g_list_foreach (list, (GFunc)gtk_tree_path_free, NULL);
g_list_free (list);
}
static void delete_button_clicked(GtkWidget *widget, gpointer data)
{
GtkTreeIter iter;
char *file = get_selected_file(&iter);
if (file) {
char buf[64];
snprintf(buf, sizeof(buf), "Delete file:\n\n%s", file);
if (confirm_dialog(buf)) {
gtk_list_store_remove (filelist_store, &iter);
char buf[256];
char *path = get_full_path(buf, sizeof(buf), file);
unlink(path);
}
} else {
info_dialog("Delete: no file selected!");
}
}
void wxListBox::DoDeleteOneItem(unsigned int n)
{
wxCHECK_RET( m_treeview != NULL, wxT("invalid listbox") );
InvalidateBestSize();
GTKDisableEvents(); // just in case
GtkTreeIter iter;
wxCHECK_RET( GTKGetIteratorFor(n, &iter), wxT("wrong listbox index") );
// this returns false if iter is invalid (e.g. deleting item at end) but
// since we don't use iter, we ignore the return value
gtk_list_store_remove(m_liststore, &iter);
GTKEnableEvents();
}
void
go_gtk_combo_box_remove_text (GtkComboBox *combo, int position)
{
GtkTreeModel *model;
GtkListStore *store;
GtkTreeIter iter;
g_return_if_fail (GTK_IS_COMBO_BOX_TEXT (combo));
g_return_if_fail (position >= 0);
model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo));
store = GTK_LIST_STORE (model);
g_return_if_fail (GTK_IS_LIST_STORE (store));
if (gtk_tree_model_iter_nth_child (model, &iter, NULL, position))
gtk_list_store_remove (store, &iter);
}
static void remove_item( GtkWidget * widget, gpointer selection ) {
GtkListStore * store;
GtkTreeModel * model;
GtkTreeIter iter;
store = GTK_LIST_STORE( gtk_tree_view_get_model(GTK_TREE_VIEW(list)) );
model = gtk_tree_view_get_model( GTK_TREE_VIEW(list) );
if( gtk_tree_model_get_iter_first(model, &iter) == FALSE )
return;
if( gtk_tree_selection_get_selected(
GTK_TREE_SELECTION(selection), &model, &iter) ) {
gtk_list_store_remove( store, &iter );
}
}
/****************************************************************
Key press for destination
*****************************************************************/
static gboolean dst_key_press_callback(GtkWidget *w, GdkEventKey *ev,
gpointer data)
{
GtkTreeModel *model;
struct worklist_data *ptr;
ptr = data;
model = GTK_TREE_MODEL(ptr->dst);
if (ev->keyval == GDK_KEY_Delete) {
GtkTreeIter it, it_next;
bool deleted = FALSE;
if (gtk_tree_model_get_iter_first(model, &it)) {
bool more;
do {
it_next = it;
more = gtk_tree_model_iter_next(model, &it_next);
if (gtk_tree_selection_iter_is_selected(ptr->dst_selection, &it)) {
gtk_list_store_remove(GTK_LIST_STORE(model), &it);
deleted = TRUE;
}
it = it_next;
} while (more);
}
if (deleted) {
commit_worklist(ptr);
}
return TRUE;
} else if ((ev->state & GDK_MOD1_MASK) && ev->keyval == GDK_KEY_Up) {
queue_bubble_up(ptr);
return TRUE;
} else if ((ev->state & GDK_MOD1_MASK) && ev->keyval == GDK_KEY_Down) {
queue_bubble_down(ptr);
return TRUE;
} else {
return FALSE;
}
}
static void
remove_item (GtkWidget *widget, gpointer data)
{
GtkTreeIter iter;
GtkTreeView *treeview = (GtkTreeView *)data;
GtkTreeModel *model = gtk_tree_view_get_model (treeview);
GtkTreeSelection *selection = gtk_tree_view_get_selection (treeview);
if (gtk_tree_selection_get_selected (selection, NULL, &iter))
{
gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
}
guint next_level = 1;
gtk_tree_model_foreach(model, resequence_level_in_model, &next_level);
}
static void
remove_from_treeview (const gchar *tv_name,
const gchar *theme_name,
AppearanceData *data)
{
GtkTreeView *treeview;
GtkListStore *model;
GtkTreeIter iter;
treeview = GTK_TREE_VIEW (appearance_capplet_get_widget (data, tv_name));
model = GTK_LIST_STORE (
gtk_tree_model_sort_get_model (
GTK_TREE_MODEL_SORT (gtk_tree_view_get_model (treeview))));
if (theme_find_in_model (GTK_TREE_MODEL (model), theme_name, &iter))
gtk_list_store_remove (model, &iter);
}
static void
cb_delete_clicked (G_GNUC_UNUSED GtkWidget *ignore,
SheetManager *state)
{
GtkTreeSelection *selection = gtk_tree_view_get_selection (state->sheet_list);
GList *selected_rows, *l;
WorkbookSheetState *old_state;
WorkbookControl *wbc = GNM_WBC (state->wbcg);
Workbook *wb = wb_control_get_workbook (wbc);
g_return_if_fail (selection != NULL);
selected_rows = gtk_tree_selection_get_selected_rows (selection, NULL);
for (l = selected_rows; l != NULL; l = l->next)
l->data = gtk_tree_row_reference_new (GTK_TREE_MODEL (state->model),
(GtkTreePath *) l->data);
workbook_signals_block (state);
old_state = workbook_sheet_state_new (wb);
for (l = selected_rows; l != NULL; l = l->next) {
GtkTreeRowReference *ref = l->data;
if (gtk_tree_row_reference_valid (ref)) {
GtkTreePath *path = gtk_tree_row_reference_get_path (ref);
GtkTreeIter sel_iter;
Sheet *sheet;
gtk_tree_model_get_iter (GTK_TREE_MODEL (state->model), &sel_iter, path);
gtk_tree_path_free (path);
gtk_tree_model_get (GTK_TREE_MODEL (state->model), &sel_iter,
SHEET_POINTER, &sheet,
-1);
gtk_list_store_remove (state->model, &sel_iter);
workbook_sheet_delete (sheet);
}
}
cmd_reorganize_sheets (wbc, old_state, NULL);
update_undo (state, wbc);
workbook_signals_unblock (state);
populate_sheet_list (state);
cb_name_edited (NULL, NULL, NULL, state);
g_list_free_full (selected_rows, (GDestroyNotify) gtk_tree_row_reference_free);
}
static void
clamp_list_store (GtkListStore *store,
guint max)
{
GtkTreePath *path;
GtkTreeIter iter;
/* -1 because TreePath counts from 0 */
path = gtk_tree_path_new_from_indices (max - 1, -1);
if (gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, path))
while (1)
if (!gtk_list_store_remove (store, &iter))
break;
gtk_tree_path_free (path);
}
void
tasks_category_remove_cb (GtkWidget *widget, gpointer data) {
GtkTreeIter iter;
GtkTreePath *path;
GUI *appGUI = (GUI *)data;
gtk_tree_view_get_cursor (GTK_TREE_VIEW (appGUI->opt->tasks_category_treeview), &path, NULL);
if (path != NULL) {
gtk_tree_model_get_iter(GTK_TREE_MODEL(appGUI->opt->tasks_category_store), &iter, path);
gtk_list_store_remove(appGUI->opt->tasks_category_store, &iter);
gtk_tree_path_free(path);
refresh_tasks (appGUI);
}
}
void
mtscan_model_remove(mtscan_model_t *model,
GtkTreeIter *iter)
{
gint64 address;
signals_t *signals;
gtk_tree_model_get(GTK_TREE_MODEL(model->store), iter,
COL_ADDRESS, &address,
COL_SIGNALS, &signals,
-1);
g_hash_table_remove(model->active, &address);
g_hash_table_remove(model->map, &address);
signals_free(signals);
gtk_list_store_remove(model->store, iter);
}
void MainWindow::removeSelectedObj(){
GtkTreeIter iter;
std::string name;
if(!getSelectedObjName(name, &iter))
return;
try{
_world->removeObj(name);
gtk_list_store_remove(GTK_LIST_STORE(_mainModel), &iter);
gtk_widget_queue_draw(_mainWindow);
log("Objeto removido.\n");
}catch(MyException& e){
log(e.what());
}
}
void remove_button_clicked_cb(GtkWidget *widget, gpointer data) {
struct add_data *ad = (struct add_data *) data;
GtkTreeIter iter,temp_iter;
GtkTreeModel *model;
gboolean valid;
int index,nindices;
int i;
char buffer[512];
if (gtk_tree_selection_get_selected(ad->select, &model, &iter)) {
valid = gtk_tree_model_get_iter_first(model, &temp_iter);
index = 0;
nindices = 0;
while(valid) {
if (gtk_tree_selection_iter_is_selected(ad->select, &temp_iter)) {
#if DEBUG == 1
fprintf(stdout,"Index: %i\n",nindices);
#endif
index = nindices;
}
nindices++;
valid = gtk_tree_model_iter_next(model, &temp_iter);
}
for (i = index ; i < nindices ; i++) {
(*(ad->cw->lw->my_layer))->weight[i] =(*(ad->cw->lw->my_layer))->weight[i+1];
(*(ad->cw->lw->my_layer))->Z[i] =(*(ad->cw->lw->my_layer))->Z[i+1];
}
(*(ad->cw->lw->my_layer))->weight = (double *) realloc((*(ad->cw->lw->my_layer))->weight, sizeof(double)*((*(ad->cw->lw->my_layer))->n_elements-1));
(*(ad->cw->lw->my_layer))->Z = (int *) realloc((*(ad->cw->lw->my_layer))->Z, sizeof(int)*((*(ad->cw->lw->my_layer))->n_elements-1));
(*(ad->cw->lw->my_layer))->n_elements--;
gtk_list_store_remove(ad->store, &iter);
sprintf(buffer,"%g", xmi_sum_double((*(ad->cw->lw->my_layer))->weight,(*(ad->cw->lw->my_layer))->n_elements )*100.0);
gtk_entry_set_text(GTK_ENTRY(ad->cw->lw->sumEntry), buffer);
if ((*(ad->cw->lw->my_layer))->n_elements == 0)
gtk_widget_set_sensitive(ad->cw->lw->okButton, FALSE);
else{
//select next line if available
if (index == nindices -1)
gtk_tree_selection_select_path(ad->select,gtk_tree_path_new_from_indices(nindices-2,-1));
else
gtk_tree_selection_select_path(ad->select,gtk_tree_path_new_from_indices(index,-1));
}
}
}
static void thread_helper ( gpointer args[VIK_BG_NUM_ARGS], gpointer user_data )
{
/* unpack args */
vik_thr_func func = args[1];
gpointer userdata = args[2];
g_debug(__FUNCTION__);
func ( userdata, args );
gdk_threads_enter();
if ( ! args[0] )
gtk_list_store_remove ( bgstore, (GtkTreeIter *) args[5] );
gdk_threads_leave();
thread_die ( args );
}
static void on_bookmarks_changed(FmBookmarks* bm, gpointer user_data)
{
FmPlacesModel* model = FM_PLACES_MODEL(user_data);
FmFileInfoJob* job = fm_file_info_job_new(NULL, FM_FILE_INFO_JOB_FOLLOW_SYMLINK);
GtkTreeIter it = model->sep_it;
/* remove all old bookmarks */
if(gtk_tree_model_iter_next(GTK_TREE_MODEL(model), &it))
{
while(gtk_list_store_remove(GTK_LIST_STORE(model), &it))
continue;
}
add_bookmarks(model, job);
g_signal_connect(job, "finished", G_CALLBACK(on_file_info_job_finished), model);
model->jobs = g_slist_prepend(model->jobs, job);
fm_job_run_async(FM_JOB(job));
}
static void
subscribe_clicked_cb (GtkButton *button, RBPodcastAddDialog *dialog)
{
if (dialog->priv->have_selection == FALSE) {
rb_debug ("no selection");
return;
}
subscribe_selected_feed (dialog);
dialog->priv->clearing = TRUE;
gtk_list_store_remove (GTK_LIST_STORE (dialog->priv->feed_model), &dialog->priv->selected_feed);
dialog->priv->clearing = FALSE;
gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->priv->feed_view)));
gtk_widget_set_sensitive (dialog->priv->subscribe_button, FALSE);
}
static void remove_filter(GtkWidget *widget, gpointer *data)
{
GtkTreeIter iter;
GtkTreeSelection *selection;
LOG(LOG_DEBUG, "IN : remove_filter()");
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(filter_view));
if (gtk_tree_selection_get_selected(selection, NULL, &iter))
{
gtk_list_store_remove(GTK_LIST_STORE(filter_store), &iter);
}
LOG(LOG_DEBUG, "OUT : remove_filter()");
}
static void
scenarios_delete_clicked_cb (G_GNUC_UNUSED GtkWidget *button,
ScenariosState *state)
{
data_analysis_output_t dao;
GtkTreeSelection *selection;
GtkTreeIter iter;
GtkTreeModel *model;
gchar *value;
gboolean all_deleted;
GnmScenario *sc;
GList *l;
restore_old_values (state);
selection = gtk_tree_view_get_selection
(GTK_TREE_VIEW (state->scenarios_treeview));
dao_init_new_sheet (&dao);
dao.sheet = state->base.sheet;
if (!gtk_tree_selection_get_selected (selection, NULL, &iter))
return;
model = gtk_tree_view_get_model
(GTK_TREE_VIEW (state->scenarios_treeview));
gtk_tree_model_get (GTK_TREE_MODEL (model), &iter, 0, &value, -1);
gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
sc = gnm_sheet_scenario_find (state->base.sheet, value);
if (sc)
g_object_set_data (G_OBJECT (sc),
"marked_deleted", GUINT_TO_POINTER (TRUE));
set_selection_state (state, FALSE);
all_deleted = TRUE;
for (l = state->base.sheet->scenarios; l && all_deleted; l = l->next) {
GnmScenario *sc = l->data;
if (!g_object_get_data (G_OBJECT (sc), "marked_deleted"))
all_deleted = FALSE;
}
gtk_widget_set_sensitive
(state->summary_button, !all_deleted);
}
gboolean project_cell_edited(GtkCellRendererText* cell, gchar* path_string, gchar* new_text, ProjectList* projectList)
{
Project& project = projectList->m_project;
GtkTreePath* path = gtk_tree_path_new_from_string(path_string);
ASSERT_MESSAGE(gtk_tree_path_get_depth(path) == 1, "invalid path length");
GtkTreeIter iter;
gtk_tree_model_get_iter(GTK_TREE_MODEL(projectList->m_store), &iter, path);
Project::iterator i = Project_find(project, gtk_tree_path_get_indices(path)[0]);
if(i != project.end())
{
projectList->m_changed = true;
if(string_empty(new_text))
{
project.erase(i);
Build_refreshMenu(g_bsp_menu);
gtk_list_store_remove(projectList->m_store, &iter);
}
else
{
(*i).first = new_text;
Build_refreshMenu(g_bsp_menu);
gtk_list_store_set(projectList->m_store, &iter, 0, new_text, -1);
}
}
else if(!string_empty(new_text))
{
projectList->m_changed = true;
project.push_back(Project::value_type(new_text, Build()));
Build_refreshMenu(g_bsp_menu);
gtk_list_store_set(projectList->m_store, &iter, 0, new_text, -1);
GtkTreeIter lastIter;
gtk_list_store_append(projectList->m_store, &lastIter);
}
gtk_tree_path_free(path);
return FALSE;
}
void glist_remove(GtkListStore *ls, GtkTreeModel *tree, const char *item)
{
GtkTreeIter iter;
if(gtk_tree_model_get_iter_first(tree, &iter)){
do{
char *tmp;
gtk_tree_model_get(tree, &iter, 0, &tmp, -1);
if(!strcmp(tmp, item)){
gtk_list_store_remove(ls, &iter);
break;
}
}while(gtk_tree_model_iter_next(tree, &iter));
}else
g_warning("glist_remove: couldn't get iter_first");
}
static void
adblock_ui_remove_cb (GtkButton *button,
AdblockUI *dialog)
{
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreeSelection *selection;
selection = dialog->priv->selection;
if (gtk_tree_selection_get_selected (selection, &model, &iter))
{
gtk_list_store_remove (GTK_LIST_STORE(model), &iter);
gtk_entry_set_text (dialog->priv->new_filter, "");
dialog->priv->dirty = TRUE;
}
}
static void ug_selector_store_clear (GtkListStore* store)
{
UgSelectorItem* item;
GtkTreeModel* model;
GtkTreeIter iter;
model = GTK_TREE_MODEL (store);
while (gtk_tree_model_get_iter_first (model, &iter)) {
gtk_tree_model_get (model, &iter, 0, &item, -1);
gtk_list_store_remove (store, &iter);
if (item->dataset)
ug_dataset_unref (item->dataset);
else
g_free (item->uri);
g_slice_free1 (sizeof (UgSelectorItem), item);
}
}
void batch_dl_report_error(const char *url, const char *err)
{
static int i = 0;
if (i == 100) {
GtkTreeIter iter;
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(batchinfo_store), &iter);
gtk_list_store_remove(batchinfo_store, &iter);
} else {
++i;
}
GtkTreeIter iter;
gtk_list_store_append (batchinfo_store, &iter);
/* The value will be copied or referenced by the store if appropriate. */
gtk_list_store_set (batchinfo_store, &iter,
COL_BINFO_URL, url, COL_BINFO_ERR, err, -1);
}
static void
dict_list_delete_clicked_cb (GtkButton *button,
gpointer userdata)
{
GtkTreeView *view = GTK_TREE_VIEW(userdata);
GtkTreeModel *model = gtk_tree_view_get_model(view);
GtkTreeSelection *selection = gtk_tree_view_get_selection(view);
GtkTreeIter iter;
if (gtk_tree_selection_get_selected(selection, NULL, &iter)) {
gint i;
GtkTreePath *path = gtk_tree_model_get_path(model, &iter);
i = gtk_tree_path_get_indices(path)[0];
gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
__config_sysdicts.erase(__config_sysdicts.begin()+i);
__have_changed = true;
}
}
void discard_player_did(gint player_num)
{
GtkTreeIter iter;
enum TFindResult found;
/* check if the player was in the list. If not, it is not an error.
* That happens if the player auto-discards. */
found =
find_integer_in_tree(GTK_TREE_MODEL(discard_store), &iter,
DISCARD_COLUMN_PLAYER_NUM, player_num);
if (found == FIND_MATCH_EXACT) {
gtk_list_store_remove(discard_store, &iter);
if (player_num == my_player_num()) {
gtk_widget_destroy(discard.dlg);
discard.dlg = NULL;
}
}
}
static void
gimp_int_store_row_inserted (GtkTreeModel *model,
GtkTreePath *path,
GtkTreeIter *iter)
{
GimpIntStore *store = GIMP_INT_STORE (model);
if (parent_iface->row_inserted)
parent_iface->row_inserted (model, path, iter);
if (store->empty_iter &&
memcmp (iter, store->empty_iter, sizeof (GtkTreeIter)))
{
gtk_list_store_remove (GTK_LIST_STORE (store), store->empty_iter);
gtk_tree_iter_free (store->empty_iter);
store->empty_iter = NULL;
}
}
