MainBar: Support having no selected device

[pulseview.git] / pv / toolbars / mainbar.cpp

diff --git a/pv/toolbars/mainbar.cpp b/pv/toolbars/mainbar.cpp
index 50a90643d71f406919172827350318a8517b5056..4bb39fac824795a56228baa32d90a476a43b4b41 100644 (file)
--- a/pv/toolbars/mainbar.cpp
+++ b/pv/toolbars/mainbar.cpp
@@ -32,12 +32,15 @@
 #include "mainbar.hpp"
 
 #include <pv/devicemanager.hpp>
+#include <pv/devices/hardwaredevice.hpp>
 #include <pv/mainwindow.hpp>
 #include <pv/popups/deviceoptions.hpp>
 #include <pv/popups/channels.hpp>
 #include <pv/util.hpp>
+#include <pv/widgets/exportmenu.hpp>
+#include <pv/widgets/importmenu.hpp>
 
-#include <libsigrok/libsigrok.hpp>
+#include <libsigrokcxx/libsigrokcxx.hpp>
 
 using std::back_inserter;
 using std::copy;
@@ -51,8 +54,8 @@ using std::vector;
 
 using sigrok::Capability;
 using sigrok::ConfigKey;
-using sigrok::Device;
 using sigrok::Error;
+using sigrok::InputFormat;
 
 namespace pv {
 namespace toolbars {
@@ -68,8 +71,9 @@ MainBar::MainBar(Session &session, MainWindow &main_window) :
        device_selector_(this, session.device_manager(),
                main_window.action_connect()),
        configure_button_(this),
-       configure_button_action_(NULL),
+       configure_button_action_(nullptr),
        channels_button_(this),
+       channels_button_action_(nullptr),
        sample_count_(" samples", this),
        sample_rate_("Hz", this),
        updating_sample_rate_(false),
@@ -79,12 +83,44 @@ MainBar::MainBar(Session &session, MainWindow &main_window) :
        icon_green_(":/icons/status-green.svg"),
        icon_grey_(":/icons/status-grey.svg"),
        run_stop_button_(this),
+       run_stop_button_action_(nullptr),
        menu_button_(this)
 {
        setObjectName(QString::fromUtf8("MainBar"));
 
        setMovable(false);
        setFloatable(false);
+       setContextMenuPolicy(Qt::PreventContextMenu);
+
+       // Open button
+       QToolButton *const open_button = new QToolButton(this);
+
+       widgets::ImportMenu *import_menu = new widgets::ImportMenu(this,
+               session.device_manager().context(),
+               main_window.action_open());
+       connect(import_menu,
+               SIGNAL(format_selected(std::shared_ptr<sigrok::InputFormat>)),
+               &main_window_,
+               SLOT(import_file(std::shared_ptr<sigrok::InputFormat>)));
+
+       open_button->setMenu(import_menu);
+       open_button->setDefaultAction(main_window.action_open());
+       open_button->setPopupMode(QToolButton::MenuButtonPopup);
+
+       // Save button
+       QToolButton *const save_button = new QToolButton(this);
+
+       widgets::ExportMenu *export_menu = new widgets::ExportMenu(this,
+               session.device_manager().context(),
+               main_window.action_save_as());
+       connect(export_menu,
+               SIGNAL(format_selected(std::shared_ptr<sigrok::OutputFormat>)),
+               &main_window_,
+               SLOT(export_file(std::shared_ptr<sigrok::OutputFormat>)));
+
+       save_button->setMenu(export_menu);
+       save_button->setDefaultAction(main_window.action_save_as());
+       save_button->setPopupMode(QToolButton::MenuButtonPopup);
 
        // Device selector menu
        connect(&device_selector_, SIGNAL(device_selected()),
@@ -116,8 +152,8 @@ MainBar::MainBar(Session &session, MainWindow &main_window) :
                QIcon(":/icons/menu.svg")));
 
        // Setup the toolbar
-       addAction(main_window.action_open());
-       addAction(main_window.action_save_as());
+       addWidget(open_button);
+       addWidget(save_button);
        addSeparator();
        addAction(main_window.action_view_zoom_in());
        addAction(main_window.action_view_zoom_out());
@@ -148,10 +184,10 @@ MainBar::MainBar(Session &session, MainWindow &main_window) :
 
        addWidget(&device_selector_);
        configure_button_action_ = addWidget(&configure_button_);
-       addWidget(&channels_button_);
+       channels_button_action_ = addWidget(&channels_button_);
        addWidget(&sample_count_);
        addWidget(&sample_rate_);
-       addWidget(&run_stop_button_);
+       run_stop_button_action_ = addWidget(&run_stop_button_);
 #ifdef ENABLE_DECODE
        addSeparator();
        addWidget(add_decoder_button);
@@ -170,14 +206,13 @@ MainBar::MainBar(Session &session, MainWindow &main_window) :
 void MainBar::update_device_list()
 {
        DeviceManager &mgr = session_.device_manager();
-       shared_ptr<Device> selected_device = session_.device();
-       list< shared_ptr<Device> > devs;
+       shared_ptr<devices::Device> selected_device = session_.device();
+       list< shared_ptr<devices::Device> > devs;
 
        copy(mgr.devices().begin(), mgr.devices().end(), back_inserter(devs));
 
        if (std::find(devs.begin(), devs.end(), selected_device) == devs.end())
                devs.push_back(selected_device);
-       assert(selected_device);
 
        device_selector_.set_device_list(devs, selected_device);
        update_device_config_widgets();
@@ -197,34 +232,41 @@ void MainBar::update_sample_rate_selector()
 {
        Glib::VariantContainerBase gvar_dict;
        GVariant *gvar_list;
-       const uint64_t *elements = NULL;
+       const uint64_t *elements = nullptr;
        gsize num_elements;
+       map< const ConfigKey*, std::set<Capability> > keys;
 
-       if (updating_sample_rate_)
+       if (updating_sample_rate_) {
+               sample_rate_.show_none();
                return;
+       }
 
-       const shared_ptr<Device> device = device_selector_.selected_device();
+       const shared_ptr<devices::Device> device =
+               device_selector_.selected_device();
        if (!device)
                return;
 
        assert(!updating_sample_rate_);
        updating_sample_rate_ = true;
 
-       const auto keys = device->config_keys(ConfigKey::DEVICE_OPTIONS);
+       const shared_ptr<sigrok::Device> sr_dev = device->device();
+
+       try {
+               keys = sr_dev->config_keys(ConfigKey::DEVICE_OPTIONS);
+       } catch (Error) {}
+
        const auto iter = keys.find(ConfigKey::SAMPLERATE);
        if (iter != keys.end() &&
                (*iter).second.find(sigrok::LIST) != (*iter).second.end()) {
-               const auto keys = device->config_keys(
-                       ConfigKey::DEVICE_OPTIONS);
                try {
-                       gvar_dict = device->config_list(ConfigKey::SAMPLERATE);
+                       gvar_dict = sr_dev->config_list(ConfigKey::SAMPLERATE);
                } catch(const sigrok::Error &e) {
                        // Failed to enunmerate samplerate
                        (void)e;
                }
        }
 
-       if (!gvar_dict) {
+       if (!gvar_dict.gobj()) {
                sample_rate_.show_none();
                updating_sample_rate_ = false;
                return;
@@ -276,12 +318,13 @@ void MainBar::update_sample_rate_selector_value()
        if (updating_sample_rate_)
                return;
 
-       const shared_ptr<Device> device = device_selector_.selected_device();
+       const shared_ptr<devices::Device> device =
+               device_selector_.selected_device();
        if (!device)
                return;
 
        try {
-               auto gvar = device->config_get(ConfigKey::SAMPLERATE);
+               auto gvar = device->device()->config_get(ConfigKey::SAMPLERATE);
                uint64_t samplerate =
                        Glib::VariantBase::cast_dynamic<Glib::Variant<guint64>>(gvar).get();
                assert(!updating_sample_rate_);
@@ -299,10 +342,13 @@ void MainBar::update_sample_count_selector()
        if (updating_sample_count_)
                return;
 
-       const shared_ptr<Device> device = device_selector_.selected_device();
+       const shared_ptr<devices::Device> device =
+               device_selector_.selected_device();
        if (!device)
                return;
 
+       const shared_ptr<sigrok::Device> sr_dev = device->device();
+
        assert(!updating_sample_count_);
        updating_sample_count_ = true;
 
@@ -320,14 +366,14 @@ void MainBar::update_sample_count_selector()
        if (sample_count == 0)
                sample_count = DefaultSampleCount;
 
-       const auto keys = device->config_keys(ConfigKey::DEVICE_OPTIONS);
+       const auto keys = sr_dev->config_keys(ConfigKey::DEVICE_OPTIONS);
        const auto iter = keys.find(ConfigKey::LIMIT_SAMPLES);
        if (iter != keys.end() &&
                (*iter).second.find(sigrok::LIST) != (*iter).second.end()) {
                try {
                        auto gvar =
-                               device->config_list(ConfigKey::LIMIT_SAMPLES);
-                       if (gvar)
+                               sr_dev->config_list(ConfigKey::LIMIT_SAMPLES);
+                       if (gvar.gobj())
                                g_variant_get(gvar.gobj(), "(tt)",
                                        &min_sample_count, &max_sample_count);
                } catch(const sigrok::Error &e) {
@@ -343,7 +389,7 @@ void MainBar::update_sample_count_selector()
                min_sample_count, max_sample_count);
 
        try {
-               auto gvar = device->config_get(ConfigKey::LIMIT_SAMPLES);
+               auto gvar = sr_dev->config_get(ConfigKey::LIMIT_SAMPLES);
                sample_count = g_variant_get_uint64(gvar.gobj());
                if (sample_count == 0)
                        sample_count = DefaultSampleCount;
@@ -360,12 +406,25 @@ void MainBar::update_device_config_widgets()
 {
        using namespace pv::popups;
 
-       const shared_ptr<Device> device = device_selector_.selected_device();
-       if (!device)
+       const shared_ptr<devices::Device> device =
+               device_selector_.selected_device();
+
+       // Hide the widgets if no device is selected
+       channels_button_action_->setVisible(!!device);
+       run_stop_button_action_->setVisible(!!device);
+       if (!device) {
+               configure_button_action_->setVisible(false);
+               sample_count_.show_none();
+               sample_rate_.show_none();
+               return;
+       }
+
+       const shared_ptr<sigrok::Device> sr_dev = device->device();
+       if (!sr_dev)
                return;
 
        // Update the configure popup
-       DeviceOptions *const opts = new DeviceOptions(device, this);
+       DeviceOptions *const opts = new DeviceOptions(sr_dev, this);
        configure_button_action_->setVisible(
                !opts->binding().properties().empty());
        configure_button_.set_popup(opts);
@@ -378,7 +437,7 @@ void MainBar::update_device_config_widgets()
        sample_count_supported_ = false;
 
        try {
-               for (auto entry : device->config_keys(ConfigKey::DEVICE_OPTIONS))
+               for (auto entry : sr_dev->config_keys(ConfigKey::DEVICE_OPTIONS))
                {
                        auto key = entry.first;
                        auto capabilities = entry.second;
@@ -390,7 +449,7 @@ void MainBar::update_device_config_widgets()
                        case SR_CONF_LIMIT_FRAMES:
                                if (capabilities.count(Capability::SET))
                                {
-                                       device->config_set(ConfigKey::LIMIT_FRAMES,
+                                       sr_dev->config_set(ConfigKey::LIMIT_FRAMES,
                                                Glib::Variant<guint64>::create(1));
                                        on_config_changed();
                                }
@@ -418,10 +477,13 @@ void MainBar::commit_sample_count()
        if (updating_sample_count_)
                return;
 
-       const shared_ptr<Device> device = device_selector_.selected_device();
+       const shared_ptr<devices::Device> device =
+               device_selector_.selected_device();
        if (!device)
                return;
 
+       const shared_ptr<sigrok::Device> sr_dev = device->device();
+
        sample_count = sample_count_.value();
 
        // Set the sample count
@@ -430,7 +492,7 @@ void MainBar::commit_sample_count()
        if (sample_count_supported_)
        {
                try {
-                       device->config_set(ConfigKey::LIMIT_SAMPLES,
+                       sr_dev->config_set(ConfigKey::LIMIT_SAMPLES,
                                Glib::Variant<guint64>::create(sample_count));
                        on_config_changed();
                } catch (Error error) {
@@ -448,10 +510,13 @@ void MainBar::commit_sample_rate()
        if (updating_sample_rate_)
                return;
 
-       const shared_ptr<Device> device = device_selector_.selected_device();
+       const shared_ptr<devices::Device> device =
+               device_selector_.selected_device();
        if (!device)
                return;
 
+       const shared_ptr<sigrok::Device> sr_dev = device->device();
+
        sample_rate = sample_rate_.value();
        if (sample_rate == 0)
                return;
@@ -460,7 +525,7 @@ void MainBar::commit_sample_rate()
        assert(!updating_sample_rate_);
        updating_sample_rate_ = true;
        try {
-               device->config_set(ConfigKey::SAMPLERATE,
+               sr_dev->config_set(ConfigKey::SAMPLERATE,
                        Glib::Variant<guint64>::create(sample_rate));
                on_config_changed();
        } catch (Error error) {
@@ -472,7 +537,7 @@ void MainBar::commit_sample_rate()
 
 void MainBar::on_device_selected()
 {
-       shared_ptr<Device> device = device_selector_.selected_device();
+       shared_ptr<devices::Device> device = device_selector_.selected_device();
        if (!device)
                return;