MainBar: Only show "total sampling time" tooltip if supported by device.

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

diff --git a/pv/toolbars/mainbar.cpp b/pv/toolbars/mainbar.cpp
index 4bb39fac824795a56228baa32d90a476a43b4b41..06d4f409b718a77e9546d076d7ebe7b496d6debf 100644 (file)
--- a/pv/toolbars/mainbar.cpp
+++ b/pv/toolbars/mainbar.cpp
@@ -110,9 +110,13 @@ MainBar::MainBar(Session &session, MainWindow &main_window) :
        // Save button
        QToolButton *const save_button = new QToolButton(this);
 
+       vector<QAction *> open_actions;
+       open_actions.push_back(main_window.action_save_as());
+       open_actions.push_back(main_window.action_save_selection_as());
+
        widgets::ExportMenu *export_menu = new widgets::ExportMenu(this,
                session.device_manager().context(),
-               main_window.action_save_as());
+               open_actions);
        connect(export_menu,
                SIGNAL(format_selected(std::shared_ptr<sigrok::OutputFormat>)),
                &main_window_,
@@ -135,13 +139,19 @@ MainBar::MainBar(Session &session, MainWindow &main_window) :
        add_decoder_button->setMenu(main_window_.menu_decoder_add());
 #endif
 
-       // Setup the menu
+       // Setup the burger menu
        QMenu *const menu = new QMenu(this);
 
+       QMenu *const menu_view = new QMenu;
+       menu_view->setTitle(tr("&View"));
+       menu_view->addAction(main_window.action_view_sticky_scrolling());
+
        QMenu *const menu_help = new QMenu;
        menu_help->setTitle(tr("&Help"));
        menu_help->addAction(main_window.action_about());
 
+       menu->addAction(menu_view->menuAction());
+       menu->addSeparator();
        menu->addAction(menu_help->menuAction());
        menu->addSeparator();
        menu->addAction(main_window.action_quit());
@@ -226,6 +236,14 @@ void MainBar::set_capture_state(pv::Session::capture_state state)
        run_stop_button_.setText((state == pv::Session::Stopped) ?
                tr("Run") : tr("Stop"));
        run_stop_button_.setShortcut(QKeySequence(Qt::Key_Space));
+
+       bool ui_enabled = (state == pv::Session::Stopped) ? true : false;
+
+       device_selector_.setEnabled(ui_enabled);
+       configure_button_.setEnabled(ui_enabled);
+       channels_button_.setEnabled(ui_enabled);
+       sample_count_.setEnabled(ui_enabled);
+       sample_rate_.setEnabled(ui_enabled);
 }
 
 void MainBar::update_sample_rate_selector()
@@ -474,9 +492,6 @@ void MainBar::commit_sample_count()
 {
        uint64_t sample_count = 0;
 
-       if (updating_sample_count_)
-               return;
-
        const shared_ptr<devices::Device> device =
                device_selector_.selected_device();
        if (!device)
@@ -485,31 +500,28 @@ void MainBar::commit_sample_count()
        const shared_ptr<sigrok::Device> sr_dev = device->device();
 
        sample_count = sample_count_.value();
-
-       // Set the sample count
-       assert(!updating_sample_count_);
-       updating_sample_count_ = true;
        if (sample_count_supported_)
        {
                try {
                        sr_dev->config_set(ConfigKey::LIMIT_SAMPLES,
                                Glib::Variant<guint64>::create(sample_count));
-                       on_config_changed();
+                       update_sample_count_selector();
                } catch (Error error) {
                        qDebug() << "Failed to configure sample count.";
                        return;
                }
        }
-       updating_sample_count_ = false;
+
+       // Devices with built-in memory might impose limits on certain
+       // configurations, so let's check what sample rate the driver
+       // lets us use now.
+       update_sample_rate_selector();
 }
 
 void MainBar::commit_sample_rate()
 {
        uint64_t sample_rate = 0;
 
-       if (updating_sample_rate_)
-               return;
-
        const shared_ptr<devices::Device> device =
                device_selector_.selected_device();
        if (!device)
@@ -521,18 +533,19 @@ void MainBar::commit_sample_rate()
        if (sample_rate == 0)
                return;
 
-       // Set the samplerate
-       assert(!updating_sample_rate_);
-       updating_sample_rate_ = true;
        try {
                sr_dev->config_set(ConfigKey::SAMPLERATE,
                        Glib::Variant<guint64>::create(sample_rate));
-               on_config_changed();
+               update_sample_rate_selector();
        } catch (Error error) {
                qDebug() << "Failed to configure samplerate.";
                return;
        }
-       updating_sample_rate_ = false;
+
+       // Devices with built-in memory might impose limits on certain
+       // configurations, so let's check what sample count the driver
+       // lets us use now.
+       update_sample_count_selector();
 }
 
 void MainBar::on_device_selected()
@@ -548,12 +561,14 @@ void MainBar::on_device_selected()
 
 void MainBar::on_sample_count_changed()
 {
-       commit_sample_count();
+       if (!updating_sample_count_)
+               commit_sample_count();
 }
 
 void MainBar::on_sample_rate_changed()
 {
-       commit_sample_rate();
+       if (!updating_sample_rate_)
+               commit_sample_rate();
 }
 
 void MainBar::on_run_stop()
@@ -566,19 +581,19 @@ void MainBar::on_run_stop()
 void MainBar::on_config_changed()
 {
        commit_sample_count();
-       update_sample_count_selector(); 
        commit_sample_rate();   
-       update_sample_rate_selector();
 }
 
 bool MainBar::eventFilter(QObject *watched, QEvent *event)
 {
-       if ((watched == &sample_count_ || watched == &sample_rate_) &&
+       if (sample_count_supported_ &&
+               (watched == &sample_count_ || watched == &sample_rate_) &&
                (event->type() == QEvent::ToolTip)) {
-               double sec = (double)sample_count_.value() / sample_rate_.value();
+               auto sec = pv::util::Timestamp(sample_count_.value()) / sample_rate_.value();
                QHelpEvent *help_event = static_cast<QHelpEvent*>(event);
 
-               QString str = tr("Total sampling time: %1").arg(pv::util::format_second(sec));
+               QString str = tr("Total sampling time: %1").arg(
+                       pv::util::format_time_si(sec, pv::util::SIPrefix::unspecified, 0, "s", false));
                QToolTip::showText(help_event->globalPos(), str);
 
                return true;