[sigrok-gtk.git] / devselect.c

/*
 * This file is part of the sigrok-gtk project.
 *
 * Copyright (C) 2011 Gareth McMullin <gareth@blacksphere.co.nz>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <libsigrok/libsigrok.h>
#include <gtk/gtk.h>
#include "sigrok-gtk.h"

static void dev_selected(GtkComboBox *devbox, GObject *parent)
{
	GtkTreeModel *devlist = gtk_combo_box_get_model(devbox);
	GtkEntry *timesamples = g_object_get_data(parent, "timesamples");
	GtkComboBox *timeunit = g_object_get_data(parent, "timeunit");
	GtkTreeIter iter;
	const gchar *name;
	GtkCheckMenuItem *menuitem;
	struct sr_dev_inst *sdi;

	if (!gtk_combo_box_get_active_iter(devbox, &iter)) {
		g_object_set_data(parent, "sdi", NULL);
		return;
	}
	gtk_tree_model_get(devlist, &iter, 0, &name, 1, &sdi,
				2, &menuitem, -1);

	gtk_check_menu_item_set_active(menuitem, TRUE);

	sr_session_dev_remove_all();
	if (sr_session_dev_add(sdi) != SR_OK) {
		g_critical("Failed to use device.");
		sr_session_destroy();
		sdi = NULL;
	}
	g_object_set_data(parent, "sdi", sdi);

	/*
	 * Grey out the time unless the device is valid,
	 * and it supports sample limiting
	 */
	const gboolean limit_samples = sdi &&
		sr_driver_hwcap_exists(sdi->driver, SR_HWCAP_LIMIT_SAMPLES);
	gtk_widget_set_sensitive((GtkWidget*)timesamples, limit_samples);
	gtk_widget_set_sensitive((GtkWidget*)timeunit, limit_samples);
}

static void dev_menuitem_toggled(GtkMenuItem *item, GtkComboBox *combo)
{
	GtkTreeModel *model = gtk_combo_box_get_model(combo);
	GtkTreeIter iter;

	if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(item)))
		return;
	
	if (gtk_tree_model_get_iter_first(model, &iter)) do {
		gchar *name;
		gtk_tree_model_get(model, &iter, 0, &name, -1);
		if (g_str_equal(name, gtk_menu_item_get_label(item))) {
			gtk_combo_box_set_active_iter(combo, &iter);
			return;
		}
	} while (gtk_tree_model_iter_next(model, &iter));
}

void dev_select_rescan(GtkAction *action, GtkWindow *parent)
{
	GtkComboBox *devbox = g_object_get_data(G_OBJECT(parent), "devcombo");
	g_return_if_fail(devbox != NULL);
	GtkListStore *devlist = GTK_LIST_STORE(gtk_combo_box_get_model(devbox));
	GtkTreeIter iter;
	const struct sr_dev_inst *sdi;
	gchar *sdevname = NULL;
	GtkUIManager *ui = g_object_get_data(G_OBJECT(parent), "ui_manager");
	GtkWidget *menuitem = gtk_ui_manager_get_widget(ui,
					"/menubar/DevMenu/DevSelectMenu");
	GtkMenuShell *devmenu = GTK_MENU_SHELL(gtk_menu_item_get_submenu(GTK_MENU_ITEM(menuitem)));
	GSList *radiolist = NULL;
	struct sr_dev_driver **drivers;
	GSList *l, *tmpdevs, *devices;
	int num_devs, i;

	(void)action;

	/* Make a copy of the selected device's short name for comparison.
	 * We wish to select the same device after the refresh if possible.
	 */
	if (gtk_combo_box_get_active_iter(devbox, &iter)) {
		gtk_tree_model_get(GTK_TREE_MODEL(devlist), &iter, 1, &sdi, -1);
		/* FIXME: Use something other than sdi->driver->name */
		sdevname = g_strdup(sdi->driver->name);
	}

	/* Destroy the old menu items */
	if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(devlist), &iter)) do {
		GtkMenuItem *item;
		gtk_tree_model_get(GTK_TREE_MODEL(devlist), &iter, 2, &item, -1);
		gtk_object_destroy(GTK_OBJECT(item));
	} while (gtk_tree_model_iter_next(GTK_TREE_MODEL(devlist), &iter));

	gtk_list_store_clear(devlist);

	/* Scan for new devices and update our list */
#if 0
	if (devices) {
		/* TODO: tell drivers to clean up all instances */
		g_free(devices);
	}
#endif
	devices = NULL;

	/* Scan all drivers for all devices. */
	drivers = sr_driver_list();
	for (i = 0; drivers[i]; i++) {
		tmpdevs = sr_driver_scan(drivers[i], NULL);
		for (l = tmpdevs; l; l = l->next)
			devices = g_slist_append(devices, l->data);
		g_slist_free(tmpdevs);
	}
	num_devs = g_slist_length(devices);

	for (i = 0; i < num_devs; ++i) {
		sdi = (struct sr_dev_inst *)g_slist_nth_data(devices, i);

		gchar *name = sdi->driver->name;
		if (!name)
			name = "(unknown)";

		menuitem = gtk_radio_menu_item_new_with_label(radiolist, name);
		gtk_widget_show(GTK_WIDGET(menuitem));
		if (!radiolist)
			radiolist = gtk_radio_menu_item_get_group(
					GTK_RADIO_MENU_ITEM(menuitem));
		g_signal_connect(menuitem, "toggled",
				G_CALLBACK(dev_menuitem_toggled), devbox);
		gtk_menu_shell_prepend(devmenu, menuitem);

		gtk_list_store_append(devlist, &iter);
		gtk_list_store_set(devlist, &iter,
				0, name,
				1, sdi,
				2, menuitem,
				-1);

		if (sdevname && g_str_equal(sdevname, sdi->driver->name))
			gtk_combo_box_set_active_iter(devbox, &iter);
	}
	if (sdevname)
		g_free(sdevname);

	/* Select a default if nothing selected */
	if (!gtk_combo_box_get_active_iter(devbox, &iter)) {
		if (!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(devlist), &iter))
			return;
		/* Skip demo if there's another available */
		GtkTreeIter first = iter;
		if (gtk_tree_model_iter_next(GTK_TREE_MODEL(devlist), &iter))
			gtk_combo_box_set_active_iter(devbox, &iter);
		else
			gtk_combo_box_set_active_iter(devbox, &first);
	}
}

GtkWidget *dev_select_combo_box_new(GtkWindow *parent)
{
	GtkWidget *devbox = gtk_combo_box_new();

	/* Populate device list */
	GtkListStore *devlist = gtk_list_store_new(3,
			G_TYPE_STRING, G_TYPE_POINTER, GTK_TYPE_CHECK_MENU_ITEM);
	GtkCellRenderer *cel = gtk_cell_renderer_text_new();
	gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(devbox), cel, TRUE);
	gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(devbox), cel, "text", 0);
	gtk_combo_box_set_model(GTK_COMBO_BOX(devbox), GTK_TREE_MODEL(devlist));
	g_signal_connect(devbox, "changed", G_CALLBACK(dev_selected), parent);

	g_object_set_data(G_OBJECT(parent), "devcombo", devbox);
	dev_select_rescan(NULL, parent);

	return devbox;
}
Commit	Line	Data
3f63165c	1	/*
47475c51	2	* This file is part of the sigrok-gtk project.
3f63165c UH	3	*
	4	* Copyright (C) 2011 Gareth McMullin <gareth@blacksphere.co.nz>
	5	*
	6	* This program is free software: you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation, either version 3 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	18	*/
	19
2d4a0d9c	20	#include <libsigrok/libsigrok.h>
3f63165c UH	21	#include <gtk/gtk.h>
	22	#include "sigrok-gtk.h"
	23
ffe80b55	24	static void dev_selected(GtkComboBox devbox, GObject parent)
3f63165c	25	{
ffe80b55	26	GtkTreeModel *devlist = gtk_combo_box_get_model(devbox);
2fc7a44f	27	GtkEntry *timesamples = g_object_get_data(parent, "timesamples");
3cc6b11b	28	GtkComboBox *timeunit = g_object_get_data(parent, "timeunit");
3f63165c UH	29	GtkTreeIter iter;
	30	const gchar *name;
	31	GtkCheckMenuItem *menuitem;
ddea2e09	32	struct sr_dev_inst *sdi;
3f63165c	33
ffe80b55	34	if (!gtk_combo_box_get_active_iter(devbox, &iter)) {
ddea2e09	35	g_object_set_data(parent, "sdi", NULL);
3f63165c UH	36	return;
3f63165c UH	37	}
ddea2e09	38	gtk_tree_model_get(devlist, &iter, 0, &name, 1, &sdi,
3f63165c UH	39	2, &menuitem, -1);
	40
	41	gtk_check_menu_item_set_active(menuitem, TRUE);
	42
1fdc17b4	43	sr_session_dev_remove_all();
ddea2e09	44	if (sr_session_dev_add(sdi) != SR_OK) {
3f63165c UH	45	g_critical("Failed to use device.");
3f63165c UH	46	sr_session_destroy();
ddea2e09	47	sdi = NULL;
3f63165c	48	}
ddea2e09	49	g_object_set_data(parent, "sdi", sdi);
3cc6b11b	50
2fc7a44f JH	51	/*
	52	* Grey out the time unless the device is valid,
	53	* and it supports sample limiting
	54	*/
ddea2e09 UH	55	const gboolean limit_samples = sdi &&
ddea2e09 UH	56	sr_driver_hwcap_exists(sdi->driver, SR_HWCAP_LIMIT_SAMPLES);
2fc7a44f JH	57	gtk_widget_set_sensitive((GtkWidget*)timesamples, limit_samples);
2fc7a44f JH	58	gtk_widget_set_sensitive((GtkWidget*)timeunit, limit_samples);
3f63165c UH	59	}
	60
	61	static void dev_menuitem_toggled(GtkMenuItem item, GtkComboBox combo)
	62	{
	63	GtkTreeModel *model = gtk_combo_box_get_model(combo);
	64	GtkTreeIter iter;
	65
	66	if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(item)))
	67	return;
	68
	69	if (gtk_tree_model_get_iter_first(model, &iter)) do {
	70	gchar *name;
	71	gtk_tree_model_get(model, &iter, 0, &name, -1);
	72	if (g_str_equal(name, gtk_menu_item_get_label(item))) {
	73	gtk_combo_box_set_active_iter(combo, &iter);
	74	return;
	75	}
	76	} while (gtk_tree_model_iter_next(model, &iter));
	77	}
	78
3f63165c UH	79	void dev_select_rescan(GtkAction action, GtkWindow parent)
3f63165c UH	80	{
ffe80b55 UH	81	GtkComboBox *devbox = g_object_get_data(G_OBJECT(parent), "devcombo");
	82	g_return_if_fail(devbox != NULL);
	83	GtkListStore *devlist = GTK_LIST_STORE(gtk_combo_box_get_model(devbox));
3f63165c	84	GtkTreeIter iter;
834ea5d2	85	const struct sr_dev_inst *sdi;
3f63165c	86	gchar *sdevname = NULL;
3f63165c UH	87	GtkUIManager *ui = g_object_get_data(G_OBJECT(parent), "ui_manager");
	88	GtkWidget *menuitem = gtk_ui_manager_get_widget(ui,
	89	"/menubar/DevMenu/DevSelectMenu");
	90	GtkMenuShell *devmenu = GTK_MENU_SHELL(gtk_menu_item_get_submenu(GTK_MENU_ITEM(menuitem)));
	91	GSList *radiolist = NULL;
ddea2e09 UH	92	struct sr_dev_driver **drivers;
	93	GSList l, tmpdevs, *devices;
	94	int num_devs, i;
3f63165c UH	95
	96	(void)action;
	97
	98	/* Make a copy of the selected device's short name for comparison.
	99	* We wish to select the same device after the refresh if possible.
	100	*/
ffe80b55	101	if (gtk_combo_box_get_active_iter(devbox, &iter)) {
ddea2e09 UH	102	gtk_tree_model_get(GTK_TREE_MODEL(devlist), &iter, 1, &sdi, -1);
	103	/* FIXME: Use something other than sdi->driver->name */
	104	sdevname = g_strdup(sdi->driver->name);
3f63165c UH	105	}
	106
	107	/* Destroy the old menu items */
	108	if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(devlist), &iter)) do {
	109	GtkMenuItem *item;
	110	gtk_tree_model_get(GTK_TREE_MODEL(devlist), &iter, 2, &item, -1);
	111	gtk_object_destroy(GTK_OBJECT(item));
	112	} while (gtk_tree_model_iter_next(GTK_TREE_MODEL(devlist), &iter));
	113
	114	gtk_list_store_clear(devlist);
	115
	116	/* Scan for new devices and update our list */
ddea2e09 UH	117	#if 0
	118	if (devices) {
	119	/* TODO: tell drivers to clean up all instances */
	120	g_free(devices);
	121	}
	122	#endif
	123	devices = NULL;
	124
	125	/* Scan all drivers for all devices. */
	126	drivers = sr_driver_list();
	127	for (i = 0; drivers[i]; i++) {
	128	tmpdevs = sr_driver_scan(drivers[i], NULL);
	129	for (l = tmpdevs; l; l = l->next)
	130	devices = g_slist_append(devices, l->data);
	131	g_slist_free(tmpdevs);
	132	}
	133	num_devs = g_slist_length(devices);
	134
	135	for (i = 0; i < num_devs; ++i) {
	136	sdi = (struct sr_dev_inst *)g_slist_nth_data(devices, i);
	137
	138	gchar *name = sdi->driver->name;
3f63165c UH	139	if (!name)
	140	name = "(unknown)";
	141
	142	menuitem = gtk_radio_menu_item_new_with_label(radiolist, name);
	143	gtk_widget_show(GTK_WIDGET(menuitem));
	144	if (!radiolist)
	145	radiolist = gtk_radio_menu_item_get_group(
	146	GTK_RADIO_MENU_ITEM(menuitem));
	147	g_signal_connect(menuitem, "toggled",
ffe80b55	148	G_CALLBACK(dev_menuitem_toggled), devbox);
3f63165c UH	149	gtk_menu_shell_prepend(devmenu, menuitem);
	150
	151	gtk_list_store_append(devlist, &iter);
	152	gtk_list_store_set(devlist, &iter,
	153	0, name,
ddea2e09	154	1, sdi,
3f63165c UH	155	2, menuitem,
	156	-1);
	157
ddea2e09	158	if (sdevname && g_str_equal(sdevname, sdi->driver->name))
ffe80b55	159	gtk_combo_box_set_active_iter(devbox, &iter);
3f63165c UH	160	}
	161	if (sdevname)
	162	g_free(sdevname);
	163
	164	/* Select a default if nothing selected */
ffe80b55	165	if (!gtk_combo_box_get_active_iter(devbox, &iter)) {
3f63165c UH	166	if (!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(devlist), &iter))
	167	return;
	168	/* Skip demo if there's another available */
	169	GtkTreeIter first = iter;
	170	if (gtk_tree_model_iter_next(GTK_TREE_MODEL(devlist), &iter))
ffe80b55	171	gtk_combo_box_set_active_iter(devbox, &iter);
3f63165c	172	else
ffe80b55	173	gtk_combo_box_set_active_iter(devbox, &first);
3f63165c UH	174	}
	175	}
	176
	177	GtkWidget dev_select_combo_box_new(GtkWindow parent)
	178	{
ffe80b55	179	GtkWidget *devbox = gtk_combo_box_new();
3f63165c UH	180
	181	/* Populate device list */
	182	GtkListStore *devlist = gtk_list_store_new(3,
	183	G_TYPE_STRING, G_TYPE_POINTER, GTK_TYPE_CHECK_MENU_ITEM);
	184	GtkCellRenderer *cel = gtk_cell_renderer_text_new();
ffe80b55 UH	185	gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(devbox), cel, TRUE);
	186	gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(devbox), cel, "text", 0);
	187	gtk_combo_box_set_model(GTK_COMBO_BOX(devbox), GTK_TREE_MODEL(devlist));
	188	g_signal_connect(devbox, "changed", G_CALLBACK(dev_selected), parent);
3f63165c	189
ffe80b55	190	g_object_set_data(G_OBJECT(parent), "devcombo", devbox);
3f63165c UH	191	dev_select_rescan(NULL, parent);
3f63165c UH	192
ffe80b55	193	return devbox;
3f63165c UH	194	}
3f63165c UH	195