devselect.c

   1 /*
   2  * This file is part of the sigrok-gtk project.
   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
  20 #include <libsigrok/libsigrok.h>
  21 #include <gtk/gtk.h>
  22 #include "sigrok-gtk.h"
  23
  24 static void dev_selected(GtkComboBox *devbox, GObject *parent)
  25 {
  26         GtkTreeModel *devlist = gtk_combo_box_get_model(devbox);
  27         GtkEntry *timesamples = g_object_get_data(parent, "timesamples");
  28         GtkComboBox *timeunit = g_object_get_data(parent, "timeunit");
  29         GtkTreeIter iter;
  30         const gchar *name;
  31         GtkCheckMenuItem *menuitem;
  32         struct sr_dev_inst *sdi;
  33
  34         if (!gtk_combo_box_get_active_iter(devbox, &iter)) {
  35                 g_object_set_data(parent, "sdi", NULL);
  36                 return;
  37         }
  38         gtk_tree_model_get(devlist, &iter, 0, &name, 1, &sdi,
  39                                 2, &menuitem, -1);
  40
  41         gtk_check_menu_item_set_active(menuitem, TRUE);
  42
  43         sr_session_dev_remove_all();
  44         if (sr_session_dev_add(sdi) != SR_OK) {
  45                 g_critical("Failed to use device.");
  46                 sr_session_destroy();
  47                 sdi = NULL;
  48         }
  49         g_object_set_data(parent, "sdi", sdi);
  50
  51         /*
  52          * Grey out the time unless the device is valid,
  53          * and it supports sample limiting
  54          */
  55         const gboolean limit_samples = sdi &&
  56                 sr_driver_hwcap_exists(sdi->driver, SR_HWCAP_LIMIT_SAMPLES);
  57         gtk_widget_set_sensitive((GtkWidget*)timesamples, limit_samples);
  58         gtk_widget_set_sensitive((GtkWidget*)timeunit, limit_samples);
  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
  79 void dev_select_rescan(GtkAction *action, GtkWindow *parent)
  80 {
  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));
  84         GtkTreeIter iter;
  85         const struct sr_dev_inst *sdi;
  86         gchar *sdevname = NULL;
  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;
  92         struct sr_dev_driver **drivers;
  93         GSList *l, *tmpdevs, *devices;
  94         int num_devs, i;
  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          */
 101         if (gtk_combo_box_get_active_iter(devbox, &iter)) {
 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);
 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 */
 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;
 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",
 148                                 G_CALLBACK(dev_menuitem_toggled), devbox);
 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,
 154                                 1, sdi,
 155                                 2, menuitem,
 156                                 -1);
 157
 158                 if (sdevname && g_str_equal(sdevname, sdi->driver->name))
 159                         gtk_combo_box_set_active_iter(devbox, &iter);
 160         }
 161         if (sdevname)
 162                 g_free(sdevname);
 163
 164         /* Select a default if nothing selected */
 165         if (!gtk_combo_box_get_active_iter(devbox, &iter)) {
 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))
 171                         gtk_combo_box_set_active_iter(devbox, &iter);
 172                 else
 173                         gtk_combo_box_set_active_iter(devbox, &first);
 174         }
 175 }
 176
 177 GtkWidget *dev_select_combo_box_new(GtkWindow *parent)
 178 {
 179         GtkWidget *devbox = gtk_combo_box_new();
 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();
 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);
 189
 190         g_object_set_data(G_OBJECT(parent), "devcombo", devbox);
 191         dev_select_rescan(NULL, parent);
 192
 193         return devbox;
 194 }
 195