static void _lambda4_ (GtkTreeSelection* sender, EaseSlideButtonPanel* self) {
#line 102 "ease-slide-button-panel.vala"
	g_return_if_fail (sender != NULL);
#line 103 "ease-slide-button-panel.vala"
	gtk_tree_selection_selected_foreach (gtk_tree_view_get_selection (self->priv->slides), __lambda5__gtk_tree_selection_foreach_func, self);
#line 178 "ease-slide-button-panel.c"
}
Beispiel #2
0
/*Handles menu item clicks in a general way.*/
static void handle_selected_event(GtkMenuItem *menuitem, gpointer user_data, GtkTreeSelectionForeachFunc func, const char *action){
    (void)menuitem;
    gint ihost=GPOINTER_TO_INT(user_data);
    GtkWidget *view=views[ihost];
    GtkTreeSelection *selection=gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
    int nsel=gtk_tree_selection_count_selected_rows(selection);
    if(nsel<1) {
	warning("nsel=%d\n", nsel);
	return;
    }
    int result=GTK_RESPONSE_YES;
    /*Alert user in Kill or Restart event*/
    if(!strcmp(action, "Kill") || !strcmp(action, "Restart")){
	GtkWidget *dia=gtk_message_dialog_new
	    (NULL, GTK_DIALOG_DESTROY_WITH_PARENT,
	     GTK_MESSAGE_QUESTION,
	     GTK_BUTTONS_YES_NO,
	     "%s %d jobs?", action, nsel);
	result=gtk_dialog_run(GTK_DIALOG(dia));
	gtk_widget_destroy (dia);
    }
    if(result==GTK_RESPONSE_YES){
	gtk_tree_selection_selected_foreach(selection, func, GINT_TO_POINTER(ihost));
    }
}
Beispiel #3
0
static void act_browse( GtkAction *action, GtkTreeView *view )
{
	GtkWidget *win;
	t_curids ids = {
		.artist	= -1,
		.album	= -1,
		.track	= -1,
	};
	GtkTreeSelection *sel;

	(void)action;

	sel = gtk_tree_view_get_selection( view );
	gtk_tree_selection_selected_foreach( sel,
		(GtkTreeSelectionForeachFunc)act_browse_each, &ids );

	win = browse_window( ids.artist, ids.album, ids.track );
	gtk_widget_show( win );
}

static void act_queuealbum( GtkAction *action, gpointer *data )
{
	(void)action;
	track_list_select_queuealbum( GTK_TREE_VIEW(data) );
}
Beispiel #4
0
extern void select_admin_front_end(GtkTreeModel *model, GtkTreeIter *iter,
				   display_data_t *display_data,
				   GtkTreeView *treeview)
{
	if (treeview) {
		char *node_list;
		hostlist_t hl = NULL;
		front_end_user_data_t user_data;

		memset(&user_data, 0, sizeof(front_end_user_data_t));
		gtk_tree_selection_selected_foreach(
			gtk_tree_view_get_selection(treeview),
			_process_each_front_end, &user_data);

		hl = hostlist_create(user_data.node_list);
		hostlist_uniq(hl);
		hostlist_sort(hl);
		xfree(user_data.node_list);
		node_list = hostlist_ranged_string_xmalloc(hl);
		hostlist_destroy(hl);

		_admin_front_end(model, iter, display_data->name, node_list);
		xfree(node_list);
	}
}
static gboolean
ephy_node_view_key_press_cb (GtkTreeView *treeview,
			     GdkEventKey *event,
			     EphyNodeView *view)
{
	gboolean handled = FALSE;

	if (event->keyval == GDK_KEY_space ||
	    event->keyval == GDK_KEY_Return ||
	    event->keyval == GDK_KEY_KP_Enter ||
	    event->keyval == GDK_KEY_ISO_Enter)
	{
		if (view->priv->toggle_column >= 0)
		{
			GtkTreeSelection *selection;

			selection = gtk_tree_view_get_selection (treeview);
			gtk_tree_selection_selected_foreach
					(selection, path_toggled, view);
			handled = TRUE;
		}
	}

	return handled;
}
Beispiel #6
0
G_MODULE_EXPORT void clear_errors(GtkWidget *wiggy, gpointer data)
{
	gtk_tree_selection_selected_foreach(sel
			,do_clear_errors
			,NULL);
	refresh_data(NULL);
}
Beispiel #7
0
static void
banlist_crop (GtkWidget * wid, banlist_info *banl)
{
	session *sess = banl->sess;
	GtkTreeSelection *select;
	GSList *list = NULL, *node;
	int num_sel;

	/* remember which bans are selected */
	select = gtk_tree_view_get_selection (get_view (sess));
	/* gtk_tree_selected_get_selected_rows() isn't present in gtk 2.0.x */
	gtk_tree_selection_selected_foreach (select, banlist_add_selected_cb,
	                                     &list);

	num_sel = g_slist_length (list);
	/* select all, then unselect those that we remembered */
	if (num_sel)
	{
		gtk_tree_selection_select_all (select);

		for (node = list; node; node = node->next)
			gtk_tree_selection_unselect_iter (select, node->data);

		g_slist_foreach (list, (GFunc)g_free, NULL);
		g_slist_free (list);

		banlist_unban (NULL, banl);
	} else
		fe_message (_("You must select some bans."), FE_MSG_ERROR);
}
/**
 * uploads_cancel_cb:
 *
 * Obtains the current selection and calls an API to cancel each one.
 **/
static void
uploads_cancel_cb (GtkWidget *cancel_button, XviewerPostasaPlugin *plugin)
{
	GtkTreeSelection *selection;
	selection = gtk_tree_view_get_selection (plugin->priv->uploads_view); /* don't unref */

	gtk_tree_selection_selected_foreach (selection, (GtkTreeSelectionForeachFunc)uploads_cancel_row, plugin);
}
Beispiel #9
0
static GList *get_selected_refs (GtkTreeSelection *sel)
  {
  GList *llRet = NULL ;

  gtk_tree_selection_selected_foreach (sel, (GtkTreeSelectionForeachFunc)get_selected_refs_foreach_func, &llRet) ;

  return llRet ;
  }
int main( int argc, char **argv ) {
    gtk_init( &argc, &argv );

    /* create and set properties for main window */
    GtkWidget *window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
    gtk_window_set_title( GTK_WINDOW( window ), "Grocery List" );
    gtk_container_set_border_width( GTK_CONTAINER( window ), 10 );
    gtk_widget_set_size_request( window, 240, 320 );

    /* create and set up a tree view */
    GtkWidget *treeview = gtk_tree_view_new();
    setup_tree_view( treeview );

    /* create a new tree model with three columns, as string, gint and guint */
    GtkListStore *store = gtk_list_store_new( COLUMNS, G_TYPE_BOOLEAN,
                          G_TYPE_INT, G_TYPE_STRING );

    /* add all of the products to the GtkListStore */
    GtkTreeIter iter;
    int i = 0;
    while ( list[i].product != NULL ) {
        gtk_list_store_append( store, &iter );
        /* Here you must use an -1 to indicate an end, No other alternatives */
        gtk_list_store_set( store, &iter, BUY_IT, list[i].buy, QUANTITY,
                            list[i].quantity, PRODUCT, list[i].product, -1 );
        i++;
    }

    /* Make the tree view selectable */
    /*
     * first retrieve the selection object and then add an callback
     * for the selected rows.
     */
    GtkTreeSelection *selection = gtk_tree_view_get_selection(
                                      GTK_TREE_VIEW( treeview ) );
    /* set the selection mode: signle, mutlitple or others */
    gtk_tree_selection_set_mode( selection, GTK_SELECTION_MULTIPLE );
    gtk_tree_selection_selected_foreach( selection, foreach_func, NULL );

    /*
     * Add the tree model to the tree view and unreference it so that the
     * model will be destroyed along with the tree view
     */
    gtk_tree_view_set_model( GTK_TREE_VIEW( treeview ), GTK_TREE_MODEL( store ) );
    g_object_unref( store );

    GtkWidget *scrolled_window = gtk_scrolled_window_new( NULL, NULL );
    gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolled_window ),
                                    GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );

    g_signal_connect( G_OBJECT( window ), "destroy", G_CALLBACK( gtk_main_quit ),
                      NULL );
    gtk_container_add( GTK_CONTAINER( scrolled_window ), treeview );
    gtk_container_add( GTK_CONTAINER( window ), scrolled_window );
    gtk_widget_show_all( window );
    gtk_main();
    return 0;
}
Beispiel #11
0
static void extract_tracks() {
	GtkWidget *prog = gtk_progress_bar_new();
	gtk_box_pack_end(GTK_BOX(g_stat), prog, TRUE, TRUE, 0);
	gtk_widget_show(prog);
	set_status("extracting..");
	gtk_tree_selection_selected_foreach(g_sels[TAB_TRACKS], extract_selected_iter, prog);
	gtk_widget_destroy(prog); // NB: automatically removed from container
	set_status("done!");
}
Beispiel #12
0
G_MODULE_EXPORT void rerun_nodes(GtkWidget *wiggy, gpointer data)
{
	int		bit=NODE_RRUN;

	gtk_tree_selection_selected_foreach(sel
			,toggle_node_bits
			,&bit);
	refresh_data(NULL);
}
Beispiel #13
0
/*
 * Given an price tree view, return a list of the selected commodities. The
 * price tree must be in multiple selection mode.
 *
 * Note: It is the responsibility of the caller to free the returned
 * list.
 */
GList *
gnc_tree_view_price_get_selected_prices (GncTreeViewPrice *view)
{
    GtkTreeSelection *selection;
    GList *return_list = NULL;

    selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(view));
    gtk_tree_selection_selected_foreach(selection, get_selected_prices_helper, &return_list);
    return return_list;
}
Beispiel #14
0
static void enqueue_cb(GtkButton *button, gpointer ptr)
{
	struct playlist_page *page = page_playlist();

	UNUSED(button);
	UNUSED(ptr);
	gtk_tree_selection_selected_foreach(
		gtk_tree_view_get_selection(GTK_TREE_VIEW(page->view)),
		enqueue_one_file, NULL);
}
Beispiel #15
0
int
_gtk_count_selected (GtkTreeSelection *selection)
{
	int n = 0;

	if (selection == NULL)
		return 0;
	gtk_tree_selection_selected_foreach (selection, count_selected, &n);
	return n;
}
Beispiel #16
0
static GList *
get_selection (FMListView *view)
{
    GList *list = NULL;

    gtk_tree_selection_selected_foreach (gtk_tree_view_get_selection (view->tree),
                                         get_selection_foreach_func, &list);

    return g_list_reverse (list);
}
static gboolean
egg_tree_multi_drag_motion_event (GtkWidget      *widget,
				  GdkEventMotion *event,
				  gpointer        data)
{
  EggTreeMultiDndData *priv_data;

  priv_data = g_object_get_data (G_OBJECT (widget), EGG_TREE_MULTI_DND_STRING);

  if (gtk_drag_check_threshold (widget,
				priv_data->x,
				priv_data->y,
				event->x,
				event->y))
    {
      GList *path_list = NULL;
      GtkTreeSelection *selection;
      GtkTreeModel *model;
      GdkDragContext *context;
      TreeViewDragInfo *di;

      di = get_info (GTK_TREE_VIEW (widget));

      if (di == NULL)
	return FALSE;
      
      selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
      stop_drag_check (widget);
      gtk_tree_selection_selected_foreach (selection, selection_foreach, &path_list);
      path_list = g_list_reverse (path_list);
      model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget));
      if (egg_tree_multi_drag_source_row_draggable (EGG_TREE_MULTI_DRAG_SOURCE (model), path_list))
	{

	  context = gtk_drag_begin (widget,
#if GTK_CHECK_VERSION (2, 14, 0)
                                    gtk_drag_source_get_target_list (widget),
#else
				    di->source_target_list,
#endif
				    di->source_actions,
				    priv_data->pressed_button,
				    (GdkEvent*)event);
	  set_context_data (context, path_list);
	  gtk_drag_set_icon_default (context);

	}
      else
	{
	  path_list_free (path_list);
	}
    }

  return TRUE;
}
Beispiel #18
0
void ctree_selection_get(void)
{
	GtkTreeView *view = GTK_TREE_VIEW(gfm_widget.tree);
	GtkTreeSelection *selection = gtk_tree_view_get_selection(view);

	// destroy selection
	ctree_selection_destroy();

	// create a new selection
	gtk_tree_selection_selected_foreach(selection, get_selection, NULL);
}
Beispiel #19
0
static void
account_selected_cb(GtkTreeSelection *sel, AccountsWindow *dialog)
{
  gboolean selected = FALSE;

#if GTK_CHECK_VERSION(2,2,0)
  selected = (gtk_tree_selection_count_selected_rows(sel) > 0);
#else
  gtk_tree_selection_selected_foreach(sel, get_selected_helper, &selected);
#endif
}
Beispiel #20
0
/**
 * Performs a reverse lookup for all selected nodes.
 */
void
nodes_gui_reverse_lookup_selected(void)
{
	GtkTreeView *tv;
	GtkTreeSelection *selection;

	tv = GTK_TREE_VIEW(gui_main_window_lookup("treeview_nodes"));
	selection = gtk_tree_view_get_selection(tv);
	gtk_tree_selection_selected_foreach(selection,
		nodes_gui_reverse_lookup_selected_helper, NULL);
}
Beispiel #21
0
G_MODULE_EXPORT void chatwith_node(GtkWidget *wiggy, gpointer data)
{
	char	str[MAX_PATH+1];
	int		i;

	gtk_tree_selection_selected_foreach(sel
			,get_lastselected_node
			,&i);
	sprintf(str,"gtkchat %d",i);
	run_external(cfg.exec_dir,str);
}
Beispiel #22
0
GSList *
search_gui_get_selected_searches(void)
{
	GSList *sl = NULL;
	GtkTreeView *tv;

    tv = GTK_TREE_VIEW(gui_main_window_lookup("tree_view_search"));
	gtk_tree_selection_selected_foreach(gtk_tree_view_get_selection(tv),
		search_gui_get_selected_searches_helper, &sl);
	return sl;
}
Beispiel #23
0
/* User wants to remove selected rows */
G_MODULE_EXPORT void
on_prefs_keyserver_remove_clicked (GtkWidget *button,
                                   gpointer user_data)
{
    SeahorseWidget *swidget = SEAHORSE_WIDGET (user_data);
    GtkTreeView *treeview;
    GtkTreeSelection *selection;
    
    treeview = GTK_TREE_VIEW (seahorse_widget_get_widget (swidget, "keyservers"));
    selection = gtk_tree_view_get_selection (treeview);
    gtk_tree_selection_selected_foreach (selection, remove_row, NULL);
}
Beispiel #24
0
void onAddFileToPlaylist(GtkButton *button, gpointer user_data)
{
    GtkTreeView       *p_treeview = NULL;

    p_treeview = (GtkTreeView *) lookup_widget( GTK_WIDGET(button), "tvFileList");
    if (p_treeview)
    {
        GtkTreeSelection *p_selection = gtk_tree_view_get_selection(p_treeview);

        gtk_tree_selection_selected_foreach(p_selection, (GtkTreeSelectionForeachFunc) &addSelectedToPlaylist, (gpointer) p_treeview);    
    }
}
Beispiel #25
0
static gboolean
egg_tree_multi_drag_motion_event (GtkWidget      *widget,
				  GdkEventMotion *event,
				  gpointer        data)
{
  EggTreeMultiDndData *priv_data;

  priv_data = g_object_get_data (G_OBJECT (widget), EGG_TREE_MULTI_DND_STRING);

  if (gtk_drag_check_threshold (widget,
				priv_data->x,
				priv_data->y,
				event->x,
				event->y))
    {
      GList            *path_list = NULL;
      GtkTreeSelection *selection;
      GtkTreeModel     *model;
      GdkDragContext   *context;

      stop_drag_check (widget);

      selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
      gtk_tree_selection_selected_foreach (selection, selection_foreach, &path_list);
      if (path_list == NULL)
	      return FALSE;

      path_list = g_list_reverse (path_list);

      model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget));
      if (egg_tree_multi_drag_source_row_draggable (EGG_TREE_MULTI_DRAG_SOURCE (model), path_list))
	{
	  GtkTargetList *target_list = gtk_target_list_new (target_table,
							    G_N_ELEMENTS (target_table));

	  context = gtk_drag_begin (widget,
				    target_list,
				    GDK_ACTION_COPY,
				    priv_data->pressed_button,
				    (GdkEvent*)event);
	  set_context_data (context, path_list);
	  gtk_drag_set_icon_default (context);

	  gtk_target_list_unref (target_list);
	}
      else
	{
	  path_list_free (path_list);
	}
    }

  return TRUE;
}
Beispiel #26
0
/**
 * treeview_get_selection: get a list of selected iters
 */
GList *
gul_gui_treeview_get_selection_refs (GtkTreeView *treeview)
{
        GtkTreeSelection *selection = gtk_tree_view_get_selection (treeview);
        GList *list = NULL;

        gtk_tree_selection_selected_foreach (selection,
                                             (GtkTreeSelectionForeachFunc) make_selection_list,
                                             &list);

        return list;
}
Beispiel #27
0
static GList *
get_selected_windows (void)
{
    GtkTreeSelection *sel;
    GList *selected;

    sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));

    selected = NULL;
    gtk_tree_selection_selected_foreach (sel, add_window_cb, &selected);

    return selected;
}
Beispiel #28
0
extern void highlight_grid(GtkTreeView *tree_view,
			   int node_inx_id, int color_inx_id, List button_list)
{
	ListIterator itr = NULL;
	grid_button_t *grid_button = NULL;
	grid_foreach_t grid_foreach;

	if (!button_list || !tree_view)
		return;

	/*first clear all grid buttons*/
	itr = list_iterator_create(button_list);
	while ((grid_button = list_next(itr))) {
		/* clear everyone */
		if ((GTK_WIDGET_STATE(grid_button->button)
		     != GTK_STATE_ACTIVE)) {
			gtk_widget_set_state(grid_button->button,
					     GTK_STATE_ACTIVE);
		}
	}
	list_iterator_destroy(itr);

	/* for each currently selected row,go back & ensure the
	 * corresponding grid button is highlighted */
	memset(&grid_foreach, 0, sizeof(grid_foreach_t));
	grid_foreach.node_inx_id = node_inx_id;
	grid_foreach.color_inx_id = color_inx_id;
	grid_foreach.button_list = button_list;
	if (grid_foreach.color_inx_id != (int)NO_VAL)
		gtk_tree_selection_selected_foreach(
			gtk_tree_view_get_selection(tree_view),
			_each_highlightd, &grid_foreach);
	else
		gtk_tree_selection_selected_foreach(
			gtk_tree_view_get_selection(tree_view),
			_each_highlight_selected, &grid_foreach);

	return;
}
static GList *
get_selection_refs (GtkTreeView *tree_view)
{
	GtkTreeSelection *selection;
	GList *ref_list = NULL;

	selection = gtk_tree_view_get_selection (tree_view);
	gtk_tree_selection_selected_foreach (selection,
					     selection_foreach,
					     &ref_list);
	ref_list = g_list_reverse (ref_list);
	return ref_list;
}
Beispiel #30
0
static GList *
fm_list_view_get_selection_for_file_transfer (FMDirectoryView *view)
{
    struct SelectionForeachData selection_data;

    selection_data.list = NULL;
    selection_data.selection = gtk_tree_view_get_selection (FM_LIST_VIEW (view)->tree);

    gtk_tree_selection_selected_foreach (selection_data.selection,
                                         fm_list_view_get_selection_for_file_transfer_foreach_func, &selection_data);

    return g_list_reverse (selection_data.list);
}