Example #1
0
static void update_popup_menu(G_GNUC_UNUSED GtkWidget *popup_menu)
{
	gboolean cur_file_exists;
	gboolean badd_file;
	GeanyDocument *doc;
	GtkTreeSelection *treesel;
	gboolean bremove_file;

	doc = document_get_current();

	cur_file_exists = doc && doc->file_name != NULL && g_path_is_absolute(doc->file_name);

	badd_file = (g_current_project ? TRUE : FALSE) &&
		!g_current_project->regenerate &&
		cur_file_exists && !g_hash_table_lookup(g_current_project->tags, doc->file_name);

	treesel = gtk_tree_view_get_selection(GTK_TREE_VIEW(file_view));
	bremove_file = (g_current_project ? TRUE : FALSE) &&
		!g_current_project->regenerate &&
		(gtk_tree_selection_count_selected_rows(treesel) > 0);

	gtk_widget_set_sensitive(popup_items.new_project, TRUE);
	gtk_widget_set_sensitive(popup_items.delete_project, g_current_project ? TRUE : FALSE);

	gtk_widget_set_sensitive(popup_items.add_file, badd_file);
	gtk_widget_set_sensitive(popup_items.remove_files, bremove_file);

	gtk_widget_set_sensitive(popup_items.preferences, g_current_project ? TRUE : FALSE);

	gtk_widget_set_sensitive(popup_items.find_in_files, g_current_project ? TRUE : FALSE);
}
Example #2
0
static void selection_cb(GtkTreeSelection *selection, GtkTreeModel *model)
{
	GtkTreeIter iter;
	GValue value = {0, };
	GtkTreePath *path;

	int nr_selected = gtk_tree_selection_count_selected_rows(selection);

	if (selected_dives) {
		g_list_foreach (selected_dives, (GFunc) gtk_tree_path_free, NULL);
		g_list_free (selected_dives);
	}
	selected_dives = gtk_tree_selection_get_selected_rows(selection, NULL);

	switch (nr_selected) {
	case 0: /* keep showing the last selected dive */
		return;
	case 1:	
		/* just pick that dive as selected */
		path = g_list_nth_data(selected_dives, 0);
		if (gtk_tree_model_get_iter(model, &iter, path)) {
			gtk_tree_model_get_value(model, &iter, DIVE_INDEX, &value);
			selected_dive = g_value_get_int(&value);
			repaint_dive();
		}
		return;
	default: /* multiple selections - what now? At this point I
		  * don't want to change the selected dive unless
		  * there is exactly one dive selected; not sure this
		  * is the most intuitive solution.
		  * I do however want to keep around which dives have
		  * been selected */
		return;
	}
}
Example #3
0
static gboolean rc_gui_list2_popup_menu(GtkWidget *widget,
    GdkEventButton *event, gpointer data)
{
    GtkTreePath *path = NULL;
    rc_gui_list2_block_selection(widget, TRUE, -1, -1);
    if(event->button!=3 && event->button!=1) return FALSE;
    if(event->button==1)
    {
        if(event->state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK)) return FALSE;
        if(!gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(
            rc_ui->list2_tree_view), event->x, event->y, &path, NULL,
            NULL, NULL))
            return FALSE;
        if(gtk_tree_selection_path_is_selected(rc_ui->list2_selection,
            path))
        {
            rc_gui_list2_block_selection(rc_ui->list2_tree_view, FALSE, 
                event->x, event->y);
        }
        if(path!=NULL) gtk_tree_path_free(path);
        return FALSE;
    }
    if(gtk_tree_selection_count_selected_rows(rc_ui->list2_selection)>1)
        return TRUE;
    else return FALSE;
}
Example #4
0
File: ui.c Project: scorpp/db-vk
static void
show_popup_menu (GtkTreeView *treeview, GdkEventButton *event) {
    GtkTreeSelection *selection;
    GtkWidget *menu, *item;
    char label_buf[200];

    selection = gtk_tree_view_get_selection (treeview);
    if (!gtk_tree_selection_count_selected_rows (selection)) {
        // don't show menu on empty tree view
        return;
    }

    menu = gtk_menu_new ();

    sprintf(label_buf, "Add to playlist '%s'", last_search_query);
    item = gtk_menu_item_new_with_label (label_buf);
    g_signal_connect (item, "activate", G_CALLBACK (on_menu_item_add_to_new_playlist), treeview);
    gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);

    item = gtk_menu_item_new_with_label ("Add to current playlist");
    g_signal_connect (item, "activate", G_CALLBACK (on_menu_item_add_to_playlist), treeview);
    gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);

    item = gtk_menu_item_new_with_label ("Copy URL(s)");
    g_signal_connect (item, "activate", G_CALLBACK (on_menu_item_copy_url), treeview);
    gtk_menu_shell_append (GTK_MENU_SHELL(menu), item);

    gtk_widget_show_all (menu);
    gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, 0,
                    gdk_event_get_time ((GdkEvent *) event));
}
Example #5
0
static void display_calendar_for_selected_row(struct commodity_register *commodity_register) {
    if (gtk_tree_selection_count_selected_rows(COMMODITY_REGISTER_CORE.selection)  == 1) {
        GtkTreeIter iter;
        GtkTreeModel *model;

        if (gtk_tree_selection_get_selected(COMMODITY_REGISTER_CORE.selection, &model, &iter)) {
            gchar *current_timestamp = get_string_column_via_iter(model, &iter, STORE_TIMESTAMP), *new_date;
            gchar current_date[DATE_SIZE];

            strncpy(current_date, current_timestamp, DATE_SIZE-1);
            current_date[DATE_SIZE-1] = NULL_CHARACTER;

            new_date = display_calendar(current_date, GTK_WIDGET(COMMODITY_REGISTER_CORE.window));
            /* Did we get a date back? */
            if (new_date != NULL) {
                gchar *path_string = gtk_tree_model_get_string_from_iter(model, &iter);
                gchar *new_time_stamp = g_strdup_printf("%s 00:00:00", new_date);
                timestamp_edited(GTK_CELL_RENDERER_TEXT(commodity_register->timestamp_renderer), path_string, new_time_stamp, commodity_register);
                g_free(path_string);
                g_free(new_date);
                g_free(new_time_stamp);
            }
        } else {
            fprintf(stderr, "mouse_button_pressed: gtk_tree_selection_get_selected failed\n");
            exit(EXIT_FAILURE);
        }
    } else
        display_message_dialog("Improper selection", GTK_MESSAGE_WARNING, COMMODITY_REGISTER_CORE.window);
}
Example #6
0
/****************************************************************
  Selection from destination
*****************************************************************/
static void dst_selection_callback(GtkTreeSelection *selection, gpointer data)
{
  struct worklist_data *ptr;

  ptr = data;

  /* update widget sensitivity. */
  if (gtk_tree_selection_count_selected_rows(selection) > 0) {
    int num_rows = 0;
    GtkTreeIter it;
    
    gtk_widget_set_sensitive(ptr->up_cmd, TRUE);
    gtk_widget_set_sensitive(ptr->down_cmd, TRUE);
    if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(ptr->dst), &it)) {
      do {
	num_rows++;
      } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(ptr->dst), &it));
    }
    if (num_rows > 1) {
      gtk_widget_set_sensitive(ptr->remove_cmd, TRUE);      
    } else {
      gtk_widget_set_sensitive(ptr->remove_cmd, FALSE);
    }
  } else {
    gtk_widget_set_sensitive(ptr->up_cmd, FALSE);
    gtk_widget_set_sensitive(ptr->down_cmd, FALSE);
    gtk_widget_set_sensitive(ptr->remove_cmd, FALSE);
  }
}
Example #7
0
void on_tlbDel_clicked(GtkWidget *btMedialib,
                       InterFace *ui)
{
	GValue value = {0};
	GtkTreeIter iter = {0};
	GtkListStore *liststore;
	GtkTreeSelection *selection;
	char filename[MAX_FILE_LENGTH];
	GtkWidget *dialog;
	liststore = (GtkListStore *)gtk_tree_view_get_model(GTK_TREE_VIEW(ui->treeMedialib));
	selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ui->treeMedialib));
	if (gtk_tree_selection_count_selected_rows (selection)) {
		gtk_tree_selection_get_selected(selection, (GtkTreeModel**) &liststore, &iter);
		gtk_tree_model_get_value(GTK_TREE_MODEL(liststore), &iter, 5, &value);
		strcpy(filename, g_value_get_string(&value));
		main_core(MEDIALIB_DEL, filename);
	   main_core(MEDIALIB_BRUSH, ui);
	}
	else {
		dialog = gtk_message_dialog_new (GTK_WINDOW(ui->diaMedialib),
				                             GTK_DIALOG_MODAL,
		                                  GTK_MESSAGE_ERROR,
		                                  GTK_BUTTONS_CLOSE,
		                                                   "未选择媒体文件");
		 gtk_dialog_run (GTK_DIALOG (dialog));
		 gtk_widget_destroy (dialog);
	}
}
Example #8
0
static gboolean
on_log_view_button_press_event (GtkWidget *log_view, GdkEventButton *event,
                                GitLogPane *self)
{
	GtkMenu *menu;
	GtkTreeSelection *selection;
	AnjutaPlugin *plugin;
	AnjutaUI *ui;

	if (event->type == GDK_BUTTON_PRESS && event->button == 3)
	{
		selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (log_view));

		if (gtk_tree_selection_count_selected_rows (selection) > 0)
		{
			plugin = anjuta_dock_pane_get_plugin (ANJUTA_DOCK_PANE (self));
			ui = anjuta_shell_get_ui (plugin->shell, NULL);

			menu = GTK_MENU (gtk_ui_manager_get_widget (GTK_UI_MANAGER (ui),
			                                            "/GitLogPopup"));

			gtk_menu_popup (menu, NULL, NULL, NULL, NULL, event->button, 
			                event->time);
		}
	}

	return FALSE;
}
void CAirMassDlg::Execute()
{
	m_Updating = true;

	CObjectCoords obj = *g_Project->ObjectCoords();
	if (!obj.Valid())
		obj = CConfig::LastObject();
	if (obj.RA())
		gtk_entry_set_text(GTK_ENTRY(m_RA), obj.RA());
	else
		gtk_entry_set_text(GTK_ENTRY(m_RA), "");
	if (obj.Dec())
		gtk_entry_set_text(GTK_ENTRY(m_Dec), obj.Dec());
	else
		gtk_entry_set_text(GTK_ENTRY(m_Dec), "");
	
	CLocation loc = *g_Project->Location();
	if (!loc.Valid())
		loc = CConfig::LastLocation();
	if (loc.Lon())
		gtk_entry_set_text(GTK_ENTRY(m_Lon), loc.Lon());
	else
		gtk_entry_set_text(GTK_ENTRY(m_Lon), "");
	if (loc.Lat())
		gtk_entry_set_text(GTK_ENTRY(m_Lat), loc.Lat());
	else
		gtk_entry_set_text(GTK_ENTRY(m_Lat), "");

	GtkTreeSelection *pSel = g_MainWnd->GetSelection();
	if (gtk_tree_selection_count_selected_rows(pSel)>0) {
		GtkTreeModel *model;
		GList *rrlist = gtk_tree_selection_get_selected_rows(pSel, &model);
		double jd = g_Project->GetJulDate((GtkTreePath*)rrlist->data);
		gchar val[256];
		sprintf(val, "%.7f", jd);
		gtk_entry_set_text(GTK_ENTRY(m_JD), val);
		g_list_foreach (rrlist, (GFunc)gtk_tree_path_free, NULL);
		g_list_free(rrlist);
	} else {
		gtk_entry_set_text(GTK_ENTRY(m_JD), "");
	}

	m_Updating = false;

	OnEntryChanged(m_JD);
	Refresh(true);

	gtk_dialog_run(GTK_DIALOG(m_pDlg));

	// Store last parameters
	obj.Clear();
	obj.SetRA(gtk_entry_get_text(GTK_ENTRY(m_RA)));
	obj.SetDec(gtk_entry_get_text(GTK_ENTRY(m_Dec)));
	CConfig::SetLastObject(obj);

	loc.Clear();
	loc.SetLon(gtk_entry_get_text(GTK_ENTRY(m_Lon)));
	loc.SetLat(gtk_entry_get_text(GTK_ENTRY(m_Lat)));
	CConfig::SetLastLocation(loc);
}
Example #10
0
static gboolean
about_plugins_callback(GtkWidget *widget, GdkEventButton *event, gint id _U_)
{
  GtkTreeSelection *tree_selection;
  GtkTreeModel *model;
  GtkTreeIter  iter;
  gchar        *type;
  gchar        *file;

  tree_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(widget));

  if (gtk_tree_selection_count_selected_rows (tree_selection) == 0)
    return FALSE;

  if (event->type != GDK_2BUTTON_PRESS)
    /* not a double click */
    return FALSE;

  if (gtk_tree_selection_get_selected (tree_selection, &model, &iter)) {
     gtk_tree_model_get (model, &iter, 2, &type, -1);
     if (strcmp (type, "lua script") == 0) {
        gtk_tree_model_get (model, &iter, 3, &file, -1);
        browser_open_data_file (file);
        g_free (file);
     }
     g_free (type);
  }

  return TRUE;
}
Example #11
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));
    }
}
Example #12
0
/**
@brief create a list of selected rows in @a treeview

This is recursive, to handle descendants of any selected row, too

@param treeview the treeview to be processed

@return the list of arrays, or NULL if nothing is selected
*/
GList *e2_tree_copy (GtkTreeView *treeview)
{
	GList *rowscopied = NULL;
	GtkTreeSelection *sel = gtk_tree_view_get_selection (treeview);
	if (gtk_tree_selection_count_selected_rows (sel) > 0)
	{
		GtkTreeModel *model;
		GList *rowpath;
		GList *selpaths = gtk_tree_selection_get_selected_rows (sel, &model);
		gint columns = gtk_tree_model_get_n_columns (model);

		//copy the selected rows and their descendants
		for (rowpath = selpaths; rowpath != NULL; rowpath = rowpath->next)
		{
			GtkTreeIter iter;
			if (gtk_tree_model_get_iter (model, &iter, (GtkTreePath *) rowpath->data))
				_e2_tree_copy_branch (model, &iter, columns, &rowscopied);
			gtk_tree_path_free ((GtkTreePath *) rowpath->data);
		}

		g_list_free (selpaths);

		printd (DEBUG, "copied %d rows", g_list_length (rowscopied));
	}
	return rowscopied;
}
Example #13
0
static gboolean button_pressed(GtkWidget *widget,
				GdkEventButton *event, gpointer user_data)
{
	GtkTreeSelection *selection;
	GtkTreePath *path;

	if (event->type != GDK_BUTTON_PRESS)
		return FALSE;

	if (event->button != 3)
		return FALSE;

	selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));

	if (gtk_tree_selection_count_selected_rows(selection) != 1)
		return FALSE;

	if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget),
					(gint) event->x, (gint) event->y,
					&path, NULL, NULL, NULL) == FALSE)
		return FALSE;

	gtk_tree_selection_unselect_all(selection);
	gtk_tree_selection_select_path(selection, path);

	gtk_tree_path_free(path);

	show_popup(widget, event, selection);

	return TRUE;
}
Example #14
0
/*
 * If double clicking the PictureEntryView :
 *  - over a selected row : opens properties window
 *  - over an empty area : open the adding window
 */
gboolean Picture_Entry_View_Button_Pressed (GtkTreeView *treeview, GdkEventButton *event, gpointer data)
{
    if (event->type == GDK_BUTTON_PRESS && event->button == 1)
    {
        if (event->window == gtk_tree_view_get_bin_window (treeview))
        {
            if (!gtk_tree_view_get_path_at_pos (treeview, event->x, event->y,
                                                NULL, NULL, NULL, NULL))
            {
                gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (treeview));
            }
        }
    }

    if (event->type==GDK_2BUTTON_PRESS && event->button==1)
    {
        GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(PictureEntryView));

        if (gtk_tree_selection_count_selected_rows (GTK_TREE_SELECTION (selection)) >= 1)
            Picture_Properties_Button_Clicked (G_OBJECT (image_properties_toolitem));
        else
            Picture_Add_Button_Clicked (G_OBJECT (add_image_toolitem));

        return TRUE;
    }

    return FALSE;
}
Example #15
0
/* Selection in list changed */
void _nojs_preferences_changed_selection(NoJSPreferences *self,
											GtkTreeSelection *inSelection)
{
	gboolean	selected=(gtk_tree_selection_count_selected_rows(inSelection)>0 ? TRUE: FALSE);

	gtk_widget_set_sensitive(self->priv->deleteButton, selected);
}
Example #16
0
static void
on_log_view_drag_data_get (GtkWidget *log_view, 
                           GdkDragContext *drag_context,
                           GtkSelectionData *data,
                           guint info, guint time,
                           GitLogPane *self)
{
	GtkTreeSelection *selection;
	GtkTreeIter iter;
	GitRevision *revision;
	gchar *sha;

	selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (log_view));

	if (gtk_tree_selection_count_selected_rows (selection) > 0)
	{
		gtk_tree_selection_get_selected (selection, NULL, &iter);

		gtk_tree_model_get (GTK_TREE_MODEL (self->priv->log_model), &iter, 
		                    0, &revision, -1);
		
		sha = git_revision_get_sha (revision);

		gtk_selection_data_set_text (data, sha, -1);

		g_object_unref (revision);
		g_free (sha);
	}
}
Example #17
0
gboolean on_button_pressed(GtkWidget * treeview, GdkEventButton * event, gpointer UNUSED(userdata))
{
  /* single click with the right mouse button? */
  if (event->type == GDK_BUTTON_PRESS && event->button == 3)
  {
    /* select row if no row is selected or only one other row is selected */
    {
      GtkTreeSelection *selection;

      selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));

      /* Note: gtk_tree_selection_count_selected_rows() does not exist in gtk+-2.0, only in gtk+ >= v2.2 ! */
      if (gtk_tree_selection_count_selected_rows(selection) <= 1)
      {
        GtkTreePath *path;

        /* Get tree path for row that was clicked */
        if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(treeview), (gint)event->x, (gint)event->y, &path, NULL, NULL, NULL))
        {
          gtk_tree_selection_unselect_all(selection);
          gtk_tree_selection_select_path(selection, path);
          gtk_tree_path_free(path);
        }
      }
    }

    popup_menu(treeview, event);

    return TRUE; /* we handled this */
  }

  return FALSE; /* we did not handle this */
}
Example #18
0
/* Rombrowser right click context menu. */
gboolean callback_rombrowser_context(GtkWidget* widget, GdkEventButton* event, gpointer data)
{
    GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(g_MainWindow.romDisplay));

    if(event->type==GDK_BUTTON_PRESS)
        {
        if(event->button==3) /* Right click. */
            {
            if(gtk_tree_selection_count_selected_rows(selection)>0)
                {
                gtk_widget_set_sensitive(g_MainWindow.playRomItem, TRUE);
                gtk_widget_set_sensitive(g_MainWindow.romPropertiesItem, TRUE);
                }
            else
                {
                gtk_widget_set_sensitive(g_MainWindow.playRomItem, FALSE);
                gtk_widget_set_sensitive(g_MainWindow.romPropertiesItem, FALSE);
                }
            gtk_menu_popup(GTK_MENU(data), NULL, NULL, NULL, NULL,
            event->button, event->time);

            return TRUE;
            }
        }

    return FALSE;
}
Example #19
0
static void cb_file_selection_changed(GtkTreeSelection *selection, gpointer data)
{
	GtkTreeModel *model;
	GtkTreeIter iter;
	gchar *new_name;

	update_file_count();

	if (gtk_tree_selection_count_selected_rows(selection) != 1) {
		if (editing_file != NULL) {
			et_unload_file();
			editing_file = NULL;
		}
		return;
	}

	if (gtk_tree_view_get_first_selected(tv_files, &model, &iter)) {
		gtk_tree_model_get(model, &iter, 4, &new_name, -1);
		if (new_name != NULL && (editing_file == NULL || strcmp(new_name, editing_file) != 0)) {
			et_unload_file();
			editing_file = new_name;
			et_load_file(editing_file);
		}
	}
}
Example #20
0
GList *ex_tree_view_get_rows(GtkTreeView *treeview)
{
	GList *iter_list = NULL;

	GtkTreeSelection *sel = gtk_tree_view_get_selection(treeview);

	if (gtk_tree_selection_count_selected_rows(sel) == 0)
      return NULL;
	
	GList *path_list = gtk_tree_selection_get_selected_rows(sel, NULL);

	
	while(path_list) 
	{
		GtkTreeIter iter;
		GtkTreeIter *it;

		gtk_tree_model_get_iter(gtk_tree_view_get_model (treeview), &iter, path_list -> data);

		it = gtk_tree_iter_copy (&iter);		
		iter_list = g_list_append(iter_list, it);
		path_list = path_list -> next;
	}

	g_list_foreach (path_list, (GFunc) gtk_tree_path_free, NULL);	
	g_list_free(path_list);	
	
	return iter_list;

}
Example #21
0
static gboolean menu_cardview_button_press_event(GtkWidget *treeview, GdkEventButton *event, gpointer userdata)
{
    GtkTreeSelection *selection;
    GtkTreePath *path;

    if (event->type == GDK_BUTTON_PRESS  &&  event->button == 3)
    {
        selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));

        if (gtk_tree_selection_count_selected_rows(selection)  <= 1)
        {

            /* Get tree path for row that was clicked */
            if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(treeview),
                                              (gint) event->x,
                                              (gint) event->y,
                                              &path, NULL, NULL, NULL))
            {
                gtk_tree_selection_unselect_all(selection);
                gtk_tree_selection_select_path(selection, path);
                gtk_tree_path_free(path);
            }
        }
        menu_cardview_context_menu(treeview,event,userdata);
        return TRUE;
    }
    /*
    else if (event->type == GDK_2BUTTON_PRESS  &&  event->button == 1)
    {
      g_printf("double click\n");
    }
    */
    return FALSE;
}
static void
addr_delete_clicked (GtkButton *button, gpointer user_data)
{
	GtkTreeView *treeview = GTK_TREE_VIEW (user_data);
	GtkTreeSelection *selection;
	GList *selected_rows;
	GtkTreeModel *model = NULL;
	GtkTreeIter iter;
	int num_rows;

	selection = gtk_tree_view_get_selection (treeview);
	if (gtk_tree_selection_count_selected_rows (selection) != 1)
		return;

	selected_rows = gtk_tree_selection_get_selected_rows (selection, &model);
	if (!selected_rows)
		return;

	if (gtk_tree_model_get_iter (model, &iter, (GtkTreePath *) selected_rows->data))
		gtk_list_store_remove (GTK_LIST_STORE (model), &iter);

	g_list_foreach (selected_rows, (GFunc) gtk_tree_path_free, NULL);
	g_list_free (selected_rows);

	num_rows = gtk_tree_model_iter_n_children (model, NULL);
	if (num_rows && gtk_tree_model_iter_nth_child (model, &iter, NULL, num_rows - 1)) {
		selection = gtk_tree_view_get_selection (treeview);
		gtk_tree_selection_select_iter (selection, &iter);
	}
}
Example #23
0
static gboolean table_onButtonPressed(GtkWidget *treeview, GdkEventButton *event, gpointer userdata){
	dataToSend_ *dataToSend;
	/* single click with the right mouse button? */
    if (event->type == GDK_BUTTON_PRESS  &&  event->button == 3){
		g_print ("Single right click on the tree view.\n");
		if (1){
			GtkTreeSelection *selection;
			selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
			//! Note: gtk_tree_selection_count_selected_rows() does not exist in gtk+-2.0, only in gtk+ >= v2.2
			if (gtk_tree_selection_count_selected_rows(selection)  <= 1){
				GtkTreePath *path;
				//! Get tree path for row that was clicked
				if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(treeview),(gint) event->x, (gint) event->y,&path, NULL, NULL, NULL)){
					gtk_tree_selection_unselect_all(selection);
					gtk_tree_selection_select_path(selection, path);
					gtk_tree_path_free(path);
					
					GtkTreeModel     *model;
					GtkTreeIter       iter;
					if (gtk_tree_selection_get_selected(selection, &model, &iter)){
						dataToSend = struct_new(dataToSend_);
						gtk_tree_model_get (model, &iter, 0, &dataToSend->id, -1);    
						gtk_tree_model_get (model, &iter, 5, &dataToSend->file, -1);    
					}
				}
			}
		}
		table_popup_menu(treeview, event, dataToSend);
		return TRUE; /* we handled this */
	}
	return FALSE; /* we did not handle this */
}
Example #24
0
/**
 * cryptui_key_store_have_selected_keys:
 * @ckstore: a libcryptui key store
 * @view: a GtkTreeView
 *
 * Determines whether keys are selected or not.
 *
 * Returns: TRUE if keys have been selected, FALSE otherwise
 */
gboolean
cryptui_key_store_have_selected_keys (CryptUIKeyStore *ckstore, GtkTreeView *view)
{
    GtkTreeSelection *selection;

    g_return_val_if_fail (CRYPTUI_IS_KEY_STORE (ckstore), FALSE);
    g_return_val_if_fail (GTK_IS_TREE_VIEW (view), FALSE);

    if (ckstore->priv->use_checks) {
        GtkTreeModel* model = GTK_TREE_MODEL (ckstore->priv->store);
        GtkTreeIter iter;
        gboolean check;

        if (gtk_tree_model_get_iter_first (model, &iter)) {
            do {
                check = FALSE;
                gtk_tree_model_get (model, &iter, CRYPTUI_KEY_STORE_CHECK, &check, -1);
                if (check)
                    return TRUE;
            } while (gtk_tree_model_iter_next (model, &iter));
        }
    } else {
        /* Fall back if none checked, or not using checks */
        selection = gtk_tree_view_get_selection (view);
        if (gtk_tree_selection_count_selected_rows (selection))
            return TRUE;
    }

    return FALSE;
}
static void remove_button_clicked(GtkButton *button, XmiMsimGuiLayerDialog *dialog) {
  GtkTreeModel *model;
  GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dialog->compositionTreeView));
  GList *selected_rows = gtk_tree_selection_get_selected_rows(selection, &model);
  gint n_selected_rows = gtk_tree_selection_count_selected_rows(selection);

  GtkTreeRowReference **refs = (GtkTreeRowReference**) g_malloc(sizeof(GtkTreeRowReference*)*n_selected_rows);
  int i;
  // the following really needs two for loops!!!
  // paths change while rows are being added or removed, while references never change
  for (i = 0 ; i < n_selected_rows ; i++) {
    refs[i] = gtk_tree_row_reference_new(model, (GtkTreePath *) g_list_nth_data(selected_rows, i));
  }
  for (i = 0 ; i < n_selected_rows ; i++) {
    GtkTreePath *path = gtk_tree_row_reference_get_path(refs[i]);
    GtkTreeIter iter;
    gtk_tree_model_get_iter(model, &iter, path);
    //delete row happens here
    gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
    gtk_tree_path_free(path);
    gtk_tree_row_reference_free(refs[i]);
  }

  g_list_free_full(selected_rows, (GDestroyNotify) gtk_tree_path_free);
  g_free(refs);

  //the sum needs to be updated
  update_sum(dialog);

  return;
}
Example #26
0
static void nsgtk_download_do(nsgtk_download_selection_action action)
{
	GList *rows, *dls = NULL;
	GtkTreeModel *model = GTK_TREE_MODEL(nsgtk_download_store);
	gboolean selection_exists = gtk_tree_selection_count_selected_rows(
		nsgtk_download_selection);

	if (selection_exists) {
		rows = gtk_tree_selection_get_selected_rows(
			nsgtk_download_selection, &model);
		while (rows != NULL) {
			struct gui_download_window *dl;
			gtk_tree_model_get_iter(GTK_TREE_MODEL(
							nsgtk_download_store),
						&nsgtk_download_iter,
						(GtkTreePath*)rows->data);
			gtk_tree_model_get(GTK_TREE_MODEL(nsgtk_download_store),
					   &nsgtk_download_iter, NSGTK_DOWNLOAD,
					   &dl, -1);
			dls = g_list_prepend(dls, dl);

			rows = rows->next;
		}
		g_list_foreach(rows, (GFunc)gtk_tree_path_free, NULL);
		g_list_foreach(rows, (GFunc)g_free, NULL);
		g_list_free(rows);
	} else
		dls = g_list_copy(nsgtk_downloads_list);

	g_list_foreach(dls, (GFunc)action, NULL);
	g_list_free(dls);
}
Example #27
0
static void nsgtk_download_sensitivity_evaluate(GtkTreeSelection *selection)
{
	GtkTreeIter iter;
	GList *rows;
	gboolean selected = gtk_tree_selection_count_selected_rows(selection);
	GtkTreeModel *model = GTK_TREE_MODEL(nsgtk_download_store);
	nsgtk_download_actions sensitivity = 0;
	struct gui_download_window *dl;

	if (selected) {
		rows = gtk_tree_selection_get_selected_rows(selection, &model);
		while (rows != NULL) {
			gtk_tree_model_get_iter(model, &iter,
						(GtkTreePath*)rows->data);
			gtk_tree_model_get(model, &iter, NSGTK_DOWNLOAD,
					   &dl, -1);
			sensitivity |= dl->sensitivity;
			rows = rows->next;
		}
	} else {
		rows = nsgtk_downloads_list;
		while (rows != NULL) {
			dl = rows->data;
			sensitivity |= (dl->sensitivity & NSGTK_DOWNLOAD_CLEAR);
			rows = rows->next;
		}
	}


	nsgtk_download_sensitivity_update_buttons(sensitivity);
}
Example #28
0
gint
gnc_reconcile_view_num_selected (GNCReconcileView  *view )
{
    GNCQueryView      *qview = GNC_QUERY_VIEW(view);
    GtkTreeSelection  *selection;

    selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (qview));
    return gtk_tree_selection_count_selected_rows (selection);
}
Example #29
0
void update_userlist_sensitive_callback(GtkTreeSelection *wiggy, gpointer data)
{
	GtkWidget	*w;
	int selected;

	w=glade_xml_get_widget(lxml, "bUserListEditUser");
	selected=gtk_tree_selection_count_selected_rows(wiggy);
	gtk_widget_set_sensitive(w, selected==1);
}
Example #30
0
G_MODULE_EXPORT void update_userlist_sensitive_callback(GtkTreeSelection *wiggy, gpointer data)
{
	GtkWidget	*w;
	int selected;

	w=GTK_WIDGET(gtk_builder_get_object(builder, "bUserListEditUser"));
	selected=gtk_tree_selection_count_selected_rows(wiggy);
	gtk_widget_set_sensitive(w, selected==1);
}