void
userlist_select (session *sess, char *name)
{
GtkTreeIter iter;
GtkTreeView *treeview = GTK_TREE_VIEW (sess->gui->user_tree);
GtkTreeModel *model = gtk_tree_view_get_model (treeview);
GtkTreeSelection *selection = gtk_tree_view_get_selection (treeview);
struct User *row_user;
if (gtk_tree_model_get_iter_first (model, &iter))
{
do
{
gtk_tree_model_get (model, &iter, COL_USER, &row_user, -1);
if (sess->server->p_cmp (row_user->nick, name) == 0)
{
if (gtk_tree_selection_iter_is_selected (selection, &iter))
gtk_tree_selection_unselect_iter (selection, &iter);
else
gtk_tree_selection_select_iter (selection, &iter);
/* and make sure it's visible */
scroll_to_iter (&iter, treeview, model);
return;
}
}
while (gtk_tree_model_iter_next (model, &iter));
}
}
LIBGLADE_SIGNAL_FUNC void ChangeSaturationABGRValue(GtkWidget *menuitem, gpointer user_data)
{
int data;
if (strcmp(glade_get_widget_name(menuitem), "menuRPlus") == 0) {
data = 0x0001;
} else if (strcmp(glade_get_widget_name(menuitem), "menuRMinus") == 0) {
data = 0x0000;
} else if (strcmp(glade_get_widget_name(menuitem), "menuGPlus") == 0) {
data = 0x0101;
} else if (strcmp(glade_get_widget_name(menuitem), "menuGMinus") == 0) {
data = 0x0100;
} else if (strcmp(glade_get_widget_name(menuitem), "menuBPlus") == 0) {
data = 0x0201;
} else if (strcmp(glade_get_widget_name(menuitem), "menuBMinus") == 0) {
data = 0x0200;
} else if (strcmp(glade_get_widget_name(menuitem), "menuAPlus") == 0) {
data = 0x0301;
} else if (strcmp(glade_get_widget_name(menuitem), "menuAMinus") == 0) {
data = 0x0300;
}
int type = (data >> 8) & 0xFF;
bool plus = data & 1 ? true : false;
gchar *buf;
DWORD sat;
BYTE v;
DWORD mask, mask1, mask2;
mask1 = 0xFFFFFF00;
mask1 <<= type*8;
mask2 = 0x00FFFFFF;
mask2 >>= (3-type)*8;
mask = mask1 | mask2;
int max = actor->GetNumSprites(actor->curAct, actor->curPat);
GtkTreeView *table = (GtkTreeView *)glade_xml_get_widget(windowXML, "table");
GtkTreeModel *model = gtk_tree_view_get_model(table);
GtkTreeSelection *selection = gtk_tree_view_get_selection(table);
GtkTreeIter iter;
if (gtk_tree_model_get_iter_first(model, &iter) == FALSE) return;
for (int i=0; i<max; i++) {
if (gtk_tree_selection_iter_is_selected(selection, &iter)) {
gtk_tree_model_get(model, &iter, SAT_COLUMN, &buf, -1);
// AABBGGRR
sat = HexToDWORD(buf);
v = (BYTE)((sat & (~mask)) >> (type*8));
if (plus) {
v = SaturateByte5(v, true);
} else {
v = SaturateByte5(v, false);
}
sat &= mask;
sat |= v << (type*8);
sprintf(buf, "%08X", sat);
SetTableFromEdit(buf, i, SAT_COLUMN);
// iter is broken
if (gtk_tree_model_get_iter_first(model, &iter) == FALSE) return;
for (int j=0; j<i; j++) gtk_tree_model_iter_next(model, &iter);
}
if (gtk_tree_model_iter_next(model, &iter) == FALSE) break;
}
Php::Value GtkTreeSelection_::iter_is_selected(Php::Parameters ¶meters)
{
Php::Value object_iter = parameters[0];
GtkTreeIter_ *phpgtk_iter = (GtkTreeIter_ *)object_iter.implementation();
GtkTreeIter iter = phpgtk_iter->get_instance();
gboolean ret = gtk_tree_selection_iter_is_selected (GTK_TREE_SELECTION(instance), &iter);
return ret;
}
bool gTree::rowSelected(char *key)
{
GtkTreeSelection *sel;
gTreeRow *row=(gTreeRow*)g_hash_table_lookup(datakey,(gconstpointer)key);
if (!row) return false;
sel=gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
if (!sel) return false;
return gtk_tree_selection_iter_is_selected(sel,row->dataiter);
}
bool wxListBox::IsSelected( int n ) const
{
wxCHECK_MSG( m_treeview != NULL, false, wxT("invalid listbox") );
GtkTreeSelection* selection = gtk_tree_view_get_selection(m_treeview);
GtkTreeIter iter;
wxCHECK_MSG( GTKGetIteratorFor(n, &iter), false, wxT("Invalid index") );
return gtk_tree_selection_iter_is_selected(selection, &iter) != 0;
}
static void
pkg_window_label_data_func (GtkTreeViewColumn *column,
GtkCellRenderer *cell,
GtkTreeModel *model,
GtkTreeIter *iter,
gpointer user_data)
{
PkgWindowPrivate *priv;
PkgWindow *window = user_data;
GtkTreeSelection *selection;
gchar *title;
gchar *subtitle;
gchar *markup;
gchar color[12] = { 0 };
GtkStateType state = GTK_STATE_NORMAL;
g_return_if_fail(PKG_IS_WINDOW(window));
priv = window->priv;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->treeview));
if (gtk_tree_selection_iter_is_selected(selection, iter)) {
state = GTK_STATE_SELECTED;
}
gtk_tree_model_get(model, iter,
COLUMN_TITLE, &title,
COLUMN_SUBTITLE, &subtitle, -1);
if (!title) {
g_object_set(cell,
"markup",
_("<span size=\"smaller\"><i>Loading ...</i></span>"),
NULL);
return;
}
pkg_util_get_mix_color(GTK_WIDGET(window), state, color, sizeof(color));
if (title && !subtitle) {
markup = g_markup_printf_escaped("<span size=\"smaller\">"
"<b>%s</b>"
"</span>",
title);
} else {
markup = g_markup_printf_escaped("<span size=\"smaller\">"
"<b>%s</b>\n"
"<span color=\"%s\">%s</span>"
"</span>",
title, color, STR_OR_EMPTY(subtitle));
}
g_object_set(cell, "markup", markup, NULL);
g_free(markup);
}
static int
banlist_unban_inner (gpointer none, banlist_info *banl, int mode_num)
{
session *sess = banl->sess;
GtkTreeModel *model;
GtkTreeSelection *sel;
GtkTreeIter iter;
char tbuf[2048];
char **masks, *mask, *type;
int num_sel, i;
/* grab the list of selected items */
model = GTK_TREE_MODEL (get_store (sess));
sel = gtk_tree_view_get_selection (get_view (sess));
if (!gtk_tree_model_get_iter_first (model, &iter))
return 0;
masks = g_malloc (sizeof (char *) * banl->line_ct);
num_sel = 0;
do
{
if (gtk_tree_selection_iter_is_selected (sel, &iter))
{
/* Get the mask part of this selected line */
gtk_tree_model_get (model, &iter, TYPE_COLUMN, &type, MASK_COLUMN, &mask, -1);
/* If it's the wrong type of mask, just continue */
if (strcmp (_(modes[mode_num].type), type) != 0)
continue;
/* Otherwise add it to our array of mask pointers */
masks[num_sel++] = g_strdup (mask);
g_free (mask);
g_free (type);
}
}
while (gtk_tree_model_iter_next (model, &iter));
/* and send to server */
if (num_sel)
send_channel_modes (sess, tbuf, masks, 0, num_sel, '-', modes[mode_num].letter, 0);
/* now free everything */
for (i=0; i < num_sel; i++)
g_free (masks[i]);
g_free (masks);
return num_sel;
}
std::vector<std::string>
userlist_selection_list (GtkWidget *widget)
{
GtkTreeIter iter;
GtkTreeView *treeview = GTK_TREE_VIEW(widget);
GtkTreeSelection *selection = gtk_tree_view_get_selection (treeview);
GtkTreeModel *model = gtk_tree_view_get_model (treeview);
/* first, count the number of selections */
int num_sel = 0;
if (gtk_tree_model_get_iter_first (model, &iter))
{
do
{
if (gtk_tree_selection_iter_is_selected (selection, &iter))
num_sel++;
}
while (gtk_tree_model_iter_next (model, &iter));
}
std::vector<std::string> nicks;
if (num_sel < 1)
return nicks;
gtk_tree_model_get_iter_first (model, &iter);
do
{
if (gtk_tree_selection_iter_is_selected (selection, &iter))
{
struct User *user;
gtk_tree_model_get (model, &iter, COL_USER, &user, -1);
nicks.emplace_back(user->nick);
}
}
while (gtk_tree_model_iter_next (model, &iter));
return nicks;
}
static int find_current_selection(void)
{
int i;
for (i = 0; i < MAX_ITEMS; i++)
{
if (gtk_tree_selection_iter_is_selected(selection, &treeiters[i]))
{
return i;
}
}
return -1;
}
void edit_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;
gchar *element;
double weight;
char buffer[512];
//get selection
//the olde switcharooooo
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);
}
//get data from selected
gtk_tree_model_get(model, &iter, SYMBOL_COLUMN, &element, WEIGHT_COLUMN, &weight, -1 );
//put it in dialog
#if DEBUG == 1
fprintf(stdout,"Editing element: %s and weight: %lf\n",element, weight);
#endif
gtk_widget_set_sensitive(ad->cw->okButton,TRUE);
gtk_entry_set_editable(GTK_ENTRY(ad->cw->compoundEntry), FALSE);
ad->cw->kind = CW_EDIT;
sprintf(buffer,"%g", weight);
gtk_entry_set_text(GTK_ENTRY(ad->cw->compoundEntry), element);
g_free(element);
gtk_entry_set_text(GTK_ENTRY(ad->cw->weightEntry), buffer);
ad->cw->index = index;
gtk_widget_show_all(ad->cw->dialog);
}
return;
}
/****************************************************************
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
toggle_selection_window (GdkWindow *window)
{
GtkTreeSelection *selection;
GtkTreeIter iter;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
if (window != NULL &&
find_window (window, &iter))
{
if (gtk_tree_selection_iter_is_selected (selection, &iter))
gtk_tree_selection_unselect_iter (selection, &iter);
else
gtk_tree_selection_select_iter (selection, &iter);
}
}
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));
}
}
}
void GetSelectedTableItem(int *sel)
{
GtkTreeView *table = (GtkTreeView *)glade_xml_get_widget(windowXML, "table");
GtkTreeModel *model = gtk_tree_view_get_model(table);
GtkTreeSelection *selection = gtk_tree_view_get_selection(table);
GtkTreeIter iter;
if (gtk_tree_model_get_iter_first(model, &iter) == FALSE) return;
int i=0, j=0;
do {
if (gtk_tree_selection_iter_is_selected(selection, &iter)) {
*(sel + j) = i;
j++;
}
i++;
} while (gtk_tree_model_iter_next(model, &iter));
}
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
ft_manager_remove_file_from_model (EmpathyFTManager *manager,
EmpathyFTHandler *handler)
{
GtkTreeRowReference *row_ref;
GtkTreeSelection *selection;
GtkTreePath *path = NULL;
GtkTreeIter iter;
gboolean update_selection;
EmpathyFTManagerPriv *priv = GET_PRIV (manager);
row_ref = ft_manager_get_row_from_handler (manager, handler);
g_return_if_fail (row_ref);
DEBUG ("Removing file transfer from window: contact=%s, filename=%s",
empathy_contact_get_alias (empathy_ft_handler_get_contact (handler)),
empathy_ft_handler_get_filename (handler));
/* Get the iter from the row_ref */
path = gtk_tree_row_reference_get_path (row_ref);
gtk_tree_model_get_iter (priv->model, &iter, path);
gtk_tree_path_free (path);
/* We have to update the selection only if we are removing the selected row */
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
update_selection = gtk_tree_selection_iter_is_selected (selection, &iter);
/* Remove tp_file's row. After that iter points to the next row */
if (!gtk_list_store_remove (GTK_LIST_STORE (priv->model), &iter))
{
gint n_row;
/* There is no next row, set iter to the last row */
n_row = gtk_tree_model_iter_n_children (priv->model, NULL);
if (n_row > 0)
gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, n_row - 1);
else
update_selection = FALSE;
}
if (update_selection)
gtk_tree_selection_select_iter (selection, &iter);
}
static gboolean
update_field(gpointer data)
{
ShellFieldUpdate *fu = (ShellFieldUpdate *) data;
/* if the entry is still selected, update it */
if (fu->entry->selected && fu->entry->fieldfunc) {
gchar *value = fu->entry->fieldfunc(fu->field_name);
GtkTreeIter *iter = g_hash_table_lookup(update_tbl, fu->field_name);
/* this function is also used to feed the load graph when ViewType =
SHELL_VIEW_LOAD_GRAPH */
if (fu->loadgraph && shell->view_type == SHELL_VIEW_LOAD_GRAPH) {
GtkTreeSelection *ts;
ts = gtk_tree_view_get_selection(GTK_TREE_VIEW
(shell->info->view));
if (iter && gtk_tree_selection_iter_is_selected(ts, iter)) {
load_graph_update(shell->loadgraph, atoi(value));
}
g_free(value);
return TRUE;
}
if (iter) {
GtkTreeStore *store = GTK_TREE_STORE(shell->info->model);
gtk_tree_store_set(store, iter, INFO_TREE_COL_VALUE, value, -1);
g_free(value);
return TRUE;
}
}
/* otherwise, cleanup and destroy the timeout */
g_free(fu->field_name);
g_free(fu);
return FALSE;
}
void
item_list_view_remove_item (ItemListView *ilv, itemPtr item)
{
GtkTreeIter *iter;
g_assert (NULL != item);
iter = g_hash_table_lookup (ilv->priv->item_id_to_iter, GUINT_TO_POINTER (item->id));
if (iter) {
/* Using the GtkTreeIter check if it is currently selected. If yes,
scroll down by one in the sorted GtkTreeView to ensure something
is selected after removing the GtkTreeIter */
if (gtk_tree_selection_iter_is_selected (gtk_tree_view_get_selection (ilv->priv->treeview), iter))
ui_common_treeview_move_cursor (ilv->priv->treeview, 1);
gtk_tree_store_remove (GTK_TREE_STORE (gtk_tree_view_get_model (ilv->priv->treeview)), iter);
g_hash_table_remove (ilv->priv->item_id_to_iter, GUINT_TO_POINTER (item->id));
} else {
g_warning ("Fatal: item to be removed not found in iter lookup hash!");
}
}
void DeleteHashes(GtkWidget *empty)
{
GtkTreeSelection *selection;
int i;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(gui.hash.tree));
for (i = db.hashes.size(); i--;)
{
if (gtk_tree_selection_iter_is_selected(selection, &gui.hash.iter[i]))
{
gtk_list_store_remove(gui.hash.store, &gui.hash.iter[i]);
UpdateHashIters(i);
db.hashes.erase(db.hashes.begin()+i);
db.n_hashes--;
}
}
return;
}
void
on_button_config_remove_dir_clicked(GtkButton *unused_button,
gpointer unused_udata)
{
GtkTreeView *tv;
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreeSelection *selection;
pslist_t *sl, *pl_dirs = NULL;
char *dirs;
(void) unused_button;
(void) unused_udata;
tv = GTK_TREE_VIEW(gui_dlg_prefs_lookup("treeview_shared_dirs"));
model = gtk_tree_view_get_model(tv);
if (!gtk_tree_model_get_iter_first(model, &iter))
return;
/* Regenerate the string property holding a list of paths */
selection = gtk_tree_view_get_selection(tv);
do {
char *pathname = NULL;
/* Skip items selected for removal */
if (gtk_tree_selection_iter_is_selected(selection, &iter))
continue;
gtk_tree_model_get(model, &iter, 0, &pathname, (-1));
pl_dirs = pslist_prepend(pl_dirs, pathname);
} while (gtk_tree_model_iter_next(model, &iter));
dirs = dirlist_to_string(pl_dirs);
gnet_prop_set_string(PROP_SHARED_DIRS_PATHS, dirs);
HFREE_NULL(dirs);
PSLIST_FOREACH(pl_dirs, sl) {
G_FREE_NULL(sl->data);
}
void fm_folder_view_select_invert(FmFolderView* fv)
{
switch(fv->mode)
{
case FM_FV_LIST_VIEW:
{
GtkTreeSelection *tree_sel;
GtkTreeIter it;
if(!gtk_tree_model_get_iter_first(fv->model, &it))
return;
tree_sel = gtk_tree_view_get_selection((GtkTreeView*)fv->view);
do
{
if(gtk_tree_selection_iter_is_selected(tree_sel, &it))
gtk_tree_selection_unselect_iter(tree_sel, &it);
else
gtk_tree_selection_select_iter(tree_sel, &it);
}while( gtk_tree_model_iter_next(fv->model, &it ));
break;
}
case FM_FV_ICON_VIEW:
case FM_FV_COMPACT_VIEW:
case FM_FV_THUMBNAIL_VIEW:
{
GtkTreePath* path;
int i, n;
n = gtk_tree_model_iter_n_children(fv->model, NULL);
if(n == 0)
return;
path = gtk_tree_path_new_first();
for( i=0; i<n; ++i, gtk_tree_path_next(path) )
{
if ( exo_icon_view_path_is_selected((ExoIconView*)fv->view, path))
exo_icon_view_unselect_path((ExoIconView*)fv->view, path);
else
exo_icon_view_select_path((ExoIconView*)fv->view, path);
}
break;
}
}
}
static void
gimp_component_editor_active_changed (GimpImage *image,
GimpChannelType channel,
GimpComponentEditor *editor)
{
GtkTreeIter iter;
if (gimp_component_editor_get_iter (editor, channel, &iter))
{
gboolean active = gimp_image_get_component_active (image, channel);
if (gtk_tree_selection_iter_is_selected (editor->selection, &iter) !=
active)
{
if (active)
gtk_tree_selection_select_iter (editor->selection, &iter);
else
gtk_tree_selection_unselect_iter (editor->selection, &iter);
}
}
}
void
on_button_config_remove_dir_clicked(GtkButton *unused_button,
gpointer unused_udata)
{
GtkTreeView *tv;
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreeSelection *selection;
str_t *s;
(void) unused_button;
(void) unused_udata;
tv = GTK_TREE_VIEW(gui_dlg_prefs_lookup("treeview_shared_dirs"));
model = gtk_tree_view_get_model(tv);
if (!gtk_tree_model_get_iter_first(model, &iter))
return;
/* Regenerate the string property holding a list of paths */
selection = gtk_tree_view_get_selection(tv);
s = str_new(0);
do {
gchar *dir = NULL;
/* Skip items selected for removal */
if (gtk_tree_selection_iter_is_selected(selection, &iter))
continue;
gtk_tree_model_get(model, &iter, 0, &dir, (-1));
if (str_len(s) > 0)
str_putc(s, ':');
str_cat(s, dir);
G_FREE_NULL(dir);
} while (gtk_tree_model_iter_next(model, &iter));
gnet_prop_set_string(PROP_SHARED_DIRS_PATHS, str_2c(s));
str_destroy(s);
}
static GSList *
treeview_get_selected (GtkTreeModel *model, GtkTreeSelection *sel, int column)
{
GtkTreeIter iter;
GSList *list = NULL;
void *ptr;
if (gtk_tree_model_get_iter_first (model, &iter))
{
do
{
if (gtk_tree_selection_iter_is_selected (sel, &iter))
{
gtk_tree_model_get (model, &iter, column, &ptr, -1);
list = g_slist_prepend (list, ptr);
}
}
while (gtk_tree_model_iter_next (model, &iter));
}
return g_slist_reverse (list);
}
int wxListBox::GetSelections( wxArrayInt& aSelections ) const
{
wxCHECK_MSG( m_treeview != NULL, wxNOT_FOUND, wxT("invalid listbox") );
aSelections.Empty();
int i = 0;
GtkTreeIter iter;
GtkTreeSelection* selection = gtk_tree_view_get_selection(m_treeview);
if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(m_liststore), &iter))
{ //gtk_tree_selection_get_selected_rows is GTK 2.2+ so iter instead
do
{
if (gtk_tree_selection_iter_is_selected(selection, &iter))
aSelections.Add(i);
i++;
} while(gtk_tree_model_iter_next(GTK_TREE_MODEL(m_liststore), &iter));
}
return aSelections.GetCount();
}
/*
* gets tree row reference for an unsected row at the same depth
*/
GtkTreeRowReference* get_unselected_sibling(GtkTreePath *path)
{
GtkTreeRowReference *sibling = NULL;
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
/* move down find first unselected sibling */
GtkTreeIter titer;
gtk_tree_model_get_iter(model, &titer, path);
while (gtk_tree_model_iter_next(model, &titer))
{
if (!gtk_tree_selection_iter_is_selected(selection, &titer))
{
GtkTreePath *sibling_path = gtk_tree_model_get_path(model, &titer);
sibling = gtk_tree_row_reference_new(model, sibling_path);
gtk_tree_path_free(sibling_path);
break;
}
}
if (!sibling)
{
/* move up find first unselected sibling */
GtkTreePath *sibling_path = gtk_tree_path_copy(path);
while (gtk_tree_path_prev(sibling_path))
{
if (!gtk_tree_selection_path_is_selected(selection, sibling_path))
{
sibling = gtk_tree_row_reference_new(model, sibling_path);
break;
}
}
gtk_tree_path_free(sibling_path);
}
return sibling;
}
static void
selection_changed(GwyCoordsView *view,
GtkTreeSelection *selection)
{
CoordsView *priv = view->priv;
// Not having coords can occur during destruction.
if (priv->sync_shapes_to_view || !priv->shapes_selection || !priv->coords)
return;
guint n = gwy_coords_size(priv->coords);
gint *indices = g_slice_alloc(sizeof(gint)*n);
guint len = 0;
for (guint i = 0; i < n; i++) {
GtkTreeIter iter;
// We know that this is actually very efficient.
gwy_list_store_get_iter(priv->store, i, &iter);
if (gtk_tree_selection_iter_is_selected(selection, &iter))
indices[len++] = i;
}
priv->sync_view_to_shapes = TRUE;
gwy_int_set_update(priv->shapes_selection, indices, len);
priv->sync_view_to_shapes = FALSE;
g_slice_free1(sizeof(gint)*n, indices);
}
/*
* key pressed event
*/
static gboolean on_key_pressed(GtkWidget *widget, GdkEvent *event, gpointer user_data)
{
guint keyval = ((GdkEventKey*)event)->keyval;
GtkTreeSelection *selection;
GList *rows;
/* do not process event is page is readonly (debug is running) */
if (readonly)
return FALSE;
/* get selected rows */
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
rows = gtk_tree_selection_get_selected_rows(selection, &model);
rows = g_list_sort(rows, (GCompareFunc)gtk_tree_path_compare);
if (keyval == GDK_Delete && rows && g_list_length(rows))
{
GList *breaks, *iter;
GtkTreeRowReference *new_selection = NULL;
GtkTreePath *first_path = (GtkTreePath*)rows->data;
/* "delete selected rows" */
/* get new selection */
if (gtk_tree_path_get_depth(first_path) > 1)
{
new_selection = get_unselected_sibling(first_path);
}
if (!new_selection)
{
GtkTreePath *file_path = gtk_tree_path_copy(first_path);
if (gtk_tree_path_get_depth(file_path) > 1)
{
gtk_tree_path_up(file_path);
}
new_selection = get_unselected_sibling(file_path);
gtk_tree_path_free(file_path);
}
/* collect GList of breakpoints to remove
if file row is met - add all unselected breaks to the list as well */
breaks = NULL;
for (iter = rows; iter; iter = iter->next)
{
GtkTreePath *path = (GtkTreePath*)iter->data;
GtkTreeIter titer;
gtk_tree_model_get_iter(model, &titer, path);
if (1 == gtk_tree_path_get_depth(path))
{
GtkTreeIter citer;
gtk_tree_model_iter_children(model, &citer, &titer);
do
{
if (!gtk_tree_selection_iter_is_selected(selection, &citer))
{
gchar *file = NULL;
gint line;
breakpoint *bp;
gtk_tree_model_get(model, &titer, FILEPATH, &file, -1);
gtk_tree_model_get(model, &citer, LINE, &line, -1);
bp = breaks_lookup_breakpoint(file, line);
breaks = g_list_append(breaks, bp);
g_free(file);
}
}
while(gtk_tree_model_iter_next(model, &citer));
}
else
{
GtkTreeIter piter;
gchar *file = NULL;
gint line;
breakpoint *bp;
gtk_tree_model_iter_parent(model, &piter, &titer);
gtk_tree_model_get(model, &piter, FILEPATH, &file, -1);
gtk_tree_model_get(model, &titer, LINE, &line, -1);
bp = breaks_lookup_breakpoint(file, line);
breaks = g_list_append(breaks, bp);
g_free(file);
}
}
if (1 == g_list_length(breaks))
{
breakpoint *bp = (breakpoint*)breaks->data;
g_list_free(breaks);
breaks_remove(bp->file, bp->line);
}
else
{
breaks_remove_list(breaks);
}
if (new_selection)
{
/* get path to select */
GtkTreePath *path = NULL;
path = gtk_tree_row_reference_get_path(new_selection);
gtk_tree_selection_select_path(selection, path);
gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(widget), path, NULL, TRUE, 0.5, 0.5);
gtk_tree_path_free(path);
gtk_tree_row_reference_free(new_selection);
}
}
/* free rows list */
g_list_foreach (rows, (GFunc)gtk_tree_path_free, NULL);
g_list_free (rows);
return FALSE;
}
static GList *select_from_list (GtkWindow *parent, GList *list, const gchar *title, const gchar *msg )
{
GtkTreeIter iter;
GtkCellRenderer *renderer;
GtkWidget *view;
gchar *latlon_string;
int column_runner;
GtkWidget *dialog = gtk_dialog_new_with_buttons (title,
parent,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
NULL);
/* When something is selected then OK */
gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
GtkWidget *response_w = NULL;
#if GTK_CHECK_VERSION (2, 20, 0)
/* Default to not apply - as initially nothing is selected! */
response_w = gtk_dialog_get_widget_for_response ( GTK_DIALOG(dialog), GTK_RESPONSE_REJECT );
#endif
GtkWidget *label = gtk_label_new ( msg );
GtkTreeStore *store = gtk_tree_store_new ( 6, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN );
GList *list_runner = list;
while (list_runner) {
gpx_meta_data_t *gpx_meta_data = (gpx_meta_data_t *)list_runner->data;
// To keep display compact three digits of precision for lat/lon should be plenty
latlon_string = g_strdup_printf("(%.3f,%.3f)", gpx_meta_data->ll.lat, gpx_meta_data->ll.lon);
gtk_tree_store_append(store, &iter, NULL);
gtk_tree_store_set ( store, &iter,
0, gpx_meta_data->name,
1, gpx_meta_data->desc,
2, gpx_meta_data->timestamp,
3, latlon_string,
4, gpx_meta_data->vis,
5, gpx_meta_data->in_current_view,
-1 );
list_runner = g_list_next ( list_runner );
g_free ( latlon_string );
}
view = gtk_tree_view_new();
renderer = gtk_cell_renderer_text_new();
column_runner = 0;
GtkTreeViewColumn *column;
column = gtk_tree_view_column_new_with_attributes ( _("Name"), renderer, "text", column_runner, NULL);
gtk_tree_view_column_set_sort_column_id (column, column_runner);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
column_runner++;
column = gtk_tree_view_column_new_with_attributes ( _("Description"), renderer, "text", column_runner, NULL);
gtk_tree_view_column_set_sort_column_id (column, column_runner);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
column_runner++;
column = gtk_tree_view_column_new_with_attributes ( _("Time"), renderer, "text", column_runner, NULL);
gtk_tree_view_column_set_sort_column_id (column, column_runner);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
column_runner++;
column = gtk_tree_view_column_new_with_attributes ( _("Lat/Lon"), renderer, "text", column_runner, NULL);
gtk_tree_view_column_set_sort_column_id (column, column_runner);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
column_runner++;
column = gtk_tree_view_column_new_with_attributes ( _("Privacy"), renderer, "text", column_runner, NULL); // AKA Visibility
gtk_tree_view_column_set_sort_column_id (column, column_runner);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
GtkCellRenderer *renderer_toggle = gtk_cell_renderer_toggle_new ();
g_object_set (G_OBJECT (renderer_toggle), "activatable", FALSE, NULL); // No user action - value is just for display
column_runner++;
column = gtk_tree_view_column_new_with_attributes ( _("Within Current View"), renderer_toggle, "active", column_runner, NULL);
gtk_tree_view_column_set_sort_column_id (column, column_runner);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));
gtk_tree_selection_set_mode( gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), GTK_SELECTION_MULTIPLE );
g_object_unref(store);
GtkWidget *scrolledwindow = gtk_scrolled_window_new ( NULL, NULL );
gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC );
gtk_container_add ( GTK_CONTAINER(scrolledwindow), view );
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), scrolledwindow, TRUE, TRUE, 0);
// Ensure a reasonable number of items are shown, but let the width be automatically sized
gtk_widget_set_size_request ( dialog, -1, 400) ;
gtk_widget_show_all ( dialog );
if ( response_w )
gtk_widget_grab_focus ( response_w );
while ( gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT ) {
// Possibily not the fastest method but we don't have thousands of entries to process...
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
GList *selected = NULL;
// because we don't store the full data in the gtk model, we have to scan & look it up
if ( gtk_tree_model_get_iter_first( GTK_TREE_MODEL(store), &iter) ) {
do {
if ( gtk_tree_selection_iter_is_selected ( selection, &iter ) ) {
// For every selected item,
// compare the name from the displayed view to every gpx entry to find the gpx this selection represents
gchar* name;
gtk_tree_model_get (GTK_TREE_MODEL(store), &iter, 0, &name, -1 );
// I believe the name of these items to be always unique
list_runner = list;
while (list_runner) {
if ( !strcmp ( ((gpx_meta_data_t*)list_runner->data)->name, name ) ) {
gpx_meta_data_t *copied = copy_gpx_meta_data_t (list_runner->data);
selected = g_list_prepend (selected, copied);
break;
}
list_runner = g_list_next ( list_runner );
}
}
}
while ( gtk_tree_model_iter_next ( GTK_TREE_MODEL(store), &iter ) );
}
if ( selected ) {
gtk_widget_destroy ( dialog );
return selected;
}
a_dialog_error_msg(parent, _("Nothing was selected"));
}
gtk_widget_destroy ( dialog );
return NULL;
}
/****************************************************************
Return whether current itree item is selected
*****************************************************************/
gboolean itree_is_selected(GtkTreeSelection *selection, ITree *it)
{
return gtk_tree_selection_iter_is_selected(selection, &it->it);
}
