2 * This file is part of the PulseView project.
4 * Copyright (C) 2012 Joel Holdsworth <joel@airwebreathe.org.uk>
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 2 of the License, or
9 * (at your option) any later version.
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.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
24 #include <libsigrokdecode/libsigrokdecode.h>
30 #include <boost/algorithm/string/join.hpp>
33 #include <QApplication>
34 #include <QButtonGroup>
35 #include <QCloseEvent>
36 #include <QFileDialog>
37 #include <QMessageBox>
42 #include <QVBoxLayout>
45 #include <QDockWidget>
47 #include "mainwindow.hpp"
49 #include "devicemanager.hpp"
51 #include "data/segment.hpp"
52 #include "devices/hardwaredevice.hpp"
53 #include "devices/inputfile.hpp"
54 #include "devices/sessionfile.hpp"
55 #include "dialogs/about.hpp"
56 #include "dialogs/connect.hpp"
57 #include "dialogs/inputoutputoptions.hpp"
58 #include "dialogs/storeprogress.hpp"
59 #include "toolbars/mainbar.hpp"
60 #include "view/logicsignal.hpp"
61 #include "view/view.hpp"
62 #include "widgets/exportmenu.hpp"
63 #include "widgets/importmenu.hpp"
65 #include "widgets/decodermenu.hpp"
72 #include <libsigrokcxx/libsigrokcxx.hpp>
77 using std::make_shared;
81 using std::shared_ptr;
85 using boost::algorithm::join;
88 using sigrok::OutputFormat;
89 using sigrok::InputFormat;
97 const char *MainWindow::SettingOpenDirectory = "MainWindow/OpenDirectory";
98 const char *MainWindow::SettingSaveDirectory = "MainWindow/SaveDirectory";
100 MainWindow::MainWindow(DeviceManager &device_manager,
101 string open_file_name, string open_file_format,
104 device_manager_(device_manager),
105 session_(device_manager),
106 action_open_(new QAction(this)),
107 action_save_as_(new QAction(this)),
108 action_save_selection_as_(new QAction(this)),
109 action_connect_(new QAction(this)),
110 action_quit_(new QAction(this)),
111 action_view_zoom_in_(new QAction(this)),
112 action_view_zoom_out_(new QAction(this)),
113 action_view_zoom_fit_(new QAction(this)),
114 action_view_zoom_one_to_one_(new QAction(this)),
115 action_view_sticky_scrolling_(new QAction(this)),
116 action_view_coloured_bg_(new QAction(this)),
117 action_view_show_cursors_(new QAction(this)),
118 action_about_(new QAction(this))
120 , menu_decoders_add_(new pv::widgets::DecoderMenu(this, true))
123 qRegisterMetaType<util::Timestamp>("util::Timestamp");
126 restore_ui_settings();
127 if (open_file_name.empty())
128 select_init_device();
130 load_init_file(open_file_name, open_file_format);
133 MainWindow::~MainWindow()
135 for (auto entry : view_docks_) {
136 const std::shared_ptr<QDockWidget> dock = entry.first;
138 const std::shared_ptr<pv::view::View> view = entry.second;
139 session_.deregister_view(view);
143 QAction* MainWindow::action_open() const
148 QAction* MainWindow::action_save_as() const
150 return action_save_as_;
153 QAction* MainWindow::action_save_selection_as() const
155 return action_save_selection_as_;
158 QAction* MainWindow::action_connect() const
160 return action_connect_;
163 QAction* MainWindow::action_quit() const
168 QAction* MainWindow::action_view_zoom_in() const
170 return action_view_zoom_in_;
173 QAction* MainWindow::action_view_zoom_out() const
175 return action_view_zoom_out_;
178 QAction* MainWindow::action_view_zoom_fit() const
180 return action_view_zoom_fit_;
183 QAction* MainWindow::action_view_zoom_one_to_one() const
185 return action_view_zoom_one_to_one_;
188 QAction* MainWindow::action_view_sticky_scrolling() const
190 return action_view_sticky_scrolling_;
193 QAction* MainWindow::action_view_coloured_bg() const
195 return action_view_coloured_bg_;
198 QAction* MainWindow::action_view_show_cursors() const
200 return action_view_show_cursors_;
203 QAction* MainWindow::action_about() const
205 return action_about_;
209 QMenu* MainWindow::menu_decoder_add() const
211 return menu_decoders_add_;
215 shared_ptr<pv::view::View> MainWindow::get_active_view() const
217 // If there's only one view, use it...
218 if (view_docks_.size() == 1)
219 return view_docks_.begin()->second;
221 // ...otherwise find the dock widget the widget with focus is contained in
222 QObject *w = QApplication::focusWidget();
223 QDockWidget *dock = 0;
226 dock = qobject_cast<QDockWidget*>(w);
232 // Get the view contained in the dock widget
233 for (auto entry : view_docks_)
234 if (entry.first.get() == dock)
237 return shared_ptr<pv::view::View>();
240 shared_ptr<pv::view::View> MainWindow::add_view(const QString &title,
241 view::ViewType type, Session &session)
243 shared_ptr<pv::view::View> v;
245 if (type == pv::view::TraceView)
246 v = make_shared<pv::view::View>(session, this);
249 shared_ptr<QDockWidget> dock = make_shared<QDockWidget>(title, this);
250 dock->setWidget(v.get());
251 dock->setObjectName(title);
252 addDockWidget(Qt::TopDockWidgetArea, dock.get());
253 view_docks_[dock] = v;
255 dock->setFeatures(QDockWidget::DockWidgetMovable |
256 QDockWidget::DockWidgetFloatable);
258 if (type == view::TraceView) {
259 connect(&session, SIGNAL(trigger_event(util::Timestamp)), v.get(),
260 SLOT(trigger_event(util::Timestamp)));
261 connect(v.get(), SIGNAL(sticky_scrolling_changed(bool)), this,
262 SLOT(sticky_scrolling_changed(bool)));
263 connect(v.get(), SIGNAL(always_zoom_to_fit_changed(bool)), this,
264 SLOT(always_zoom_to_fit_changed(bool)));
266 v->enable_sticky_scrolling(action_view_sticky_scrolling_->isChecked());
267 v->enable_coloured_bg(action_view_coloured_bg_->isChecked());
268 action_view_show_cursors_->setChecked(v->cursors_shown());
271 session.register_view(v);
277 void MainWindow::run_stop()
279 switch (session_.get_capture_state()) {
280 case Session::Stopped:
281 session_.start_capture([&](QString message) {
282 session_error("Capture failed", message); });
284 case Session::AwaitingTrigger:
285 case Session::Running:
286 session_.stop_capture();
291 void MainWindow::select_device(shared_ptr<devices::Device> device)
295 session_.set_device(device);
297 session_.set_default_device();
298 } catch (const QString &e) {
299 QMessageBox msg(this);
301 msg.setInformativeText(tr("Failed to Select Device"));
302 msg.setStandardButtons(QMessageBox::Ok);
303 msg.setIcon(QMessageBox::Warning);
308 void MainWindow::export_file(shared_ptr<OutputFormat> format,
311 using pv::dialogs::StoreProgress;
313 // Make sure there's a view selected to pull the data from
314 shared_ptr<pv::view::View> view = get_active_view();
316 show_session_error(tr("No View Selected"), tr("Please click on the " \
317 "view whose data you want to save and try again."));
321 // Stop any currently running capture session
322 session_.stop_capture();
325 const QString dir = settings.value(SettingSaveDirectory).toString();
327 std::pair<uint64_t, uint64_t> sample_range;
329 // Selection only? Verify that the cursors are active and fetch their values
330 if (selection_only) {
331 if (!view->cursors()->enabled()) {
332 show_session_error(tr("Missing Cursors"), tr("You need to set the " \
333 "cursors before you can save the data enclosed by them " \
334 "to a session file (e.g. using ALT-V - Show Cursors)."));
338 const double samplerate = session_.get_samplerate();
340 const pv::util::Timestamp& start_time = view->cursors()->first()->time();
341 const pv::util::Timestamp& end_time = view->cursors()->second()->time();
343 const uint64_t start_sample =
344 std::max((double)0, start_time.convert_to<double>() * samplerate);
345 const uint64_t end_sample = end_time.convert_to<double>() * samplerate;
347 sample_range = std::make_pair(start_sample, end_sample);
349 sample_range = std::make_pair(0, 0);
352 // Construct the filter
353 const vector<string> exts = format->extensions();
354 QString filter = tr("%1 files ").arg(
355 QString::fromStdString(format->description()));
360 filter += QString("(*.%1);;%2 (*.*)").arg(
361 QString::fromStdString(join(exts, ", *.")),
364 // Show the file dialog
365 const QString file_name = QFileDialog::getSaveFileName(
366 this, tr("Save File"), dir, filter);
368 if (file_name.isEmpty())
371 const QString abs_path = QFileInfo(file_name).absolutePath();
372 settings.setValue(SettingSaveDirectory, abs_path);
374 // Show the options dialog
375 map<string, Glib::VariantBase> options;
376 if (!format->options().empty()) {
377 dialogs::InputOutputOptions dlg(
378 tr("Export %1").arg(QString::fromStdString(
379 format->description())),
380 format->options(), this);
383 options = dlg.options();
386 StoreProgress *dlg = new StoreProgress(file_name, format, options,
387 sample_range, session_, this);
391 void MainWindow::import_file(shared_ptr<InputFormat> format)
396 const QString dir = settings.value(SettingOpenDirectory).toString();
398 // Construct the filter
399 const vector<string> exts = format->extensions();
400 const QString filter = exts.empty() ? "" :
401 tr("%1 files (*.%2)").arg(
402 QString::fromStdString(format->description()),
403 QString::fromStdString(join(exts, ", *.")));
405 // Show the file dialog
406 const QString file_name = QFileDialog::getOpenFileName(
407 this, tr("Import File"), dir, tr(
408 "%1 files (*.*);;All Files (*.*)").arg(
409 QString::fromStdString(format->description())));
411 if (file_name.isEmpty())
414 // Show the options dialog
415 map<string, Glib::VariantBase> options;
416 if (!format->options().empty()) {
417 dialogs::InputOutputOptions dlg(
418 tr("Import %1").arg(QString::fromStdString(
419 format->description())),
420 format->options(), this);
423 options = dlg.options();
426 load_file(file_name, format, options);
428 const QString abs_path = QFileInfo(file_name).absolutePath();
429 settings.setValue(SettingOpenDirectory, abs_path);
432 void MainWindow::setup_ui()
434 setObjectName(QString::fromUtf8("MainWindow"));
436 // Set the window icon
438 icon.addFile(QString(":/icons/sigrok-logo-notext.png"));
441 action_open_->setText(tr("&Open..."));
442 action_open_->setIcon(QIcon::fromTheme("document-open",
443 QIcon(":/icons/document-open.png")));
444 action_open_->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_O));
445 action_open_->setObjectName(QString::fromUtf8("actionOpen"));
447 action_save_as_->setText(tr("&Save As..."));
448 action_save_as_->setIcon(QIcon::fromTheme("document-save-as",
449 QIcon(":/icons/document-save-as.png")));
450 action_save_as_->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_S));
451 action_save_as_->setObjectName(QString::fromUtf8("actionSaveAs"));
453 action_save_selection_as_->setText(tr("Save Selected &Range As..."));
454 action_save_selection_as_->setIcon(QIcon::fromTheme("document-save-as",
455 QIcon(":/icons/document-save-as.png")));
456 action_save_selection_as_->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_R));
457 action_save_selection_as_->setObjectName(QString::fromUtf8("actionSaveSelectionAs"));
459 widgets::ExportMenu *menu_file_export = new widgets::ExportMenu(this,
460 device_manager_.context());
461 menu_file_export->setTitle(tr("&Export"));
462 connect(menu_file_export,
463 SIGNAL(format_selected(std::shared_ptr<sigrok::OutputFormat>)),
464 this, SLOT(export_file(std::shared_ptr<sigrok::OutputFormat>)));
466 widgets::ImportMenu *menu_file_import = new widgets::ImportMenu(this,
467 device_manager_.context());
468 menu_file_import->setTitle(tr("&Import"));
469 connect(menu_file_import,
470 SIGNAL(format_selected(std::shared_ptr<sigrok::InputFormat>)),
471 this, SLOT(import_file(std::shared_ptr<sigrok::InputFormat>)));
473 action_connect_->setText(tr("&Connect to Device..."));
474 action_connect_->setObjectName(QString::fromUtf8("actionConnect"));
476 action_quit_->setText(tr("&Quit"));
477 action_quit_->setIcon(QIcon::fromTheme("application-exit",
478 QIcon(":/icons/application-exit.png")));
479 action_quit_->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_Q));
480 action_quit_->setObjectName(QString::fromUtf8("actionQuit"));
482 action_view_zoom_in_->setText(tr("Zoom &In"));
483 action_view_zoom_in_->setIcon(QIcon::fromTheme("zoom-in",
484 QIcon(":/icons/zoom-in.png")));
485 // simply using Qt::Key_Plus shows no + in the menu
486 action_view_zoom_in_->setShortcut(QKeySequence::ZoomIn);
487 action_view_zoom_in_->setObjectName(
488 QString::fromUtf8("actionViewZoomIn"));
490 action_view_zoom_out_->setText(tr("Zoom &Out"));
491 action_view_zoom_out_->setIcon(QIcon::fromTheme("zoom-out",
492 QIcon(":/icons/zoom-out.png")));
493 action_view_zoom_out_->setShortcut(QKeySequence::ZoomOut);
494 action_view_zoom_out_->setObjectName(
495 QString::fromUtf8("actionViewZoomOut"));
497 action_view_zoom_fit_->setCheckable(true);
498 action_view_zoom_fit_->setText(tr("Zoom to &Fit"));
499 action_view_zoom_fit_->setIcon(QIcon::fromTheme("zoom-fit",
500 QIcon(":/icons/zoom-fit.png")));
501 action_view_zoom_fit_->setShortcut(QKeySequence(Qt::Key_F));
502 action_view_zoom_fit_->setObjectName(
503 QString::fromUtf8("actionViewZoomFit"));
505 action_view_zoom_one_to_one_->setText(tr("Zoom to O&ne-to-One"));
506 action_view_zoom_one_to_one_->setIcon(QIcon::fromTheme("zoom-original",
507 QIcon(":/icons/zoom-original.png")));
508 action_view_zoom_one_to_one_->setShortcut(QKeySequence(Qt::Key_O));
509 action_view_zoom_one_to_one_->setObjectName(
510 QString::fromUtf8("actionViewZoomOneToOne"));
512 action_view_sticky_scrolling_->setCheckable(true);
513 action_view_sticky_scrolling_->setChecked(true);
514 action_view_sticky_scrolling_->setShortcut(QKeySequence(Qt::Key_S));
515 action_view_sticky_scrolling_->setObjectName(
516 QString::fromUtf8("actionViewStickyScrolling"));
517 action_view_sticky_scrolling_->setText(tr("&Sticky Scrolling"));
519 action_view_coloured_bg_->setCheckable(true);
520 action_view_coloured_bg_->setChecked(true);
521 action_view_coloured_bg_->setShortcut(QKeySequence(Qt::Key_B));
522 action_view_coloured_bg_->setObjectName(
523 QString::fromUtf8("actionViewColouredBg"));
524 action_view_coloured_bg_->setText(tr("Use &coloured backgrounds"));
526 action_view_show_cursors_->setCheckable(true);
527 action_view_show_cursors_->setIcon(QIcon::fromTheme("show-cursors",
528 QIcon(":/icons/show-cursors.svg")));
529 action_view_show_cursors_->setShortcut(QKeySequence(Qt::Key_C));
530 action_view_show_cursors_->setObjectName(
531 QString::fromUtf8("actionViewShowCursors"));
532 action_view_show_cursors_->setText(tr("Show &Cursors"));
535 menu_decoders_add_->setTitle(tr("&Add"));
536 connect(menu_decoders_add_, SIGNAL(decoder_selected(srd_decoder*)),
537 this, SLOT(add_decoder(srd_decoder*)));
540 action_about_->setObjectName(QString::fromUtf8("actionAbout"));
541 action_about_->setText(tr("&About..."));
543 QMetaObject::connectSlotsByName(this);
546 main_bar_ = new toolbars::MainBar(session_, *this);
548 // Set up the initial view
549 add_view(tr("Untitled"), pv::view::TraceView, session_);
551 // Populate the device list and select the initially selected device
552 update_device_list();
554 addToolBar(main_bar_);
557 setWindowTitle(tr("PulseView"));
559 // Setup session_ events
560 connect(&session_, SIGNAL(capture_state_changed(int)), this,
561 SLOT(capture_state_changed(int)));
562 connect(&session_, SIGNAL(device_selected()), this,
563 SLOT(device_selected()));
566 void MainWindow::select_init_device()
569 map<string, string> dev_info;
570 list<string> key_list;
571 shared_ptr<devices::HardwareDevice> device;
573 // Re-select last used device if possible but only if it's not demo
574 settings.beginGroup("Device");
575 key_list.push_back("vendor");
576 key_list.push_back("model");
577 key_list.push_back("version");
578 key_list.push_back("serial_num");
579 key_list.push_back("connection_id");
581 for (string key : key_list) {
582 const QString k = QString::fromStdString(key);
583 if (!settings.contains(k))
586 const string value = settings.value(k).toString().toStdString();
588 dev_info.insert(std::make_pair(key, value));
591 if (dev_info.count("model") > 0)
592 if (dev_info.at("model").find("Demo device") == std::string::npos)
593 device = device_manager_.find_device_from_info(dev_info);
595 // When we can't find a device similar to the one we used last
596 // time and there is at least one device aside from demo, use it
598 for (shared_ptr<devices::HardwareDevice> dev : device_manager_.devices()) {
599 dev_info = device_manager_.get_device_info(dev);
601 if (dev_info.count("model") > 0)
602 if (dev_info.at("model").find("Demo device") == std::string::npos) {
609 select_device(device);
610 update_device_list();
615 void MainWindow::load_init_file(const std::string &file_name,
616 const std::string &format)
618 shared_ptr<InputFormat> input_format;
620 if (!format.empty()) {
621 const map<string, shared_ptr<InputFormat> > formats =
622 device_manager_.context()->input_formats();
623 const auto iter = find_if(formats.begin(), formats.end(),
624 [&](const pair<string, shared_ptr<InputFormat> > f) {
625 return f.first == format; });
626 if (iter == formats.end()) {
627 cerr << "Unexpected input format: " << format << endl;
631 input_format = (*iter).second;
634 load_file(QString::fromStdString(file_name), input_format);
638 void MainWindow::save_ui_settings()
642 map<string, string> dev_info;
643 list<string> key_list;
645 settings.beginGroup("MainWindow");
646 settings.setValue("state", saveState());
647 settings.setValue("geometry", saveGeometry());
650 if (session_.device()) {
651 settings.beginGroup("Device");
652 key_list.push_back("vendor");
653 key_list.push_back("model");
654 key_list.push_back("version");
655 key_list.push_back("serial_num");
656 key_list.push_back("connection_id");
658 dev_info = device_manager_.get_device_info(
661 for (string key : key_list) {
662 if (dev_info.count(key))
663 settings.setValue(QString::fromUtf8(key.c_str()),
664 QString::fromUtf8(dev_info.at(key).c_str()));
666 settings.remove(QString::fromUtf8(key.c_str()));
673 void MainWindow::restore_ui_settings()
677 settings.beginGroup("MainWindow");
679 if (settings.contains("geometry")) {
680 restoreGeometry(settings.value("geometry").toByteArray());
681 restoreState(settings.value("state").toByteArray());
688 void MainWindow::session_error(
689 const QString text, const QString info_text)
691 QMetaObject::invokeMethod(this, "show_session_error",
692 Qt::QueuedConnection, Q_ARG(QString, text),
693 Q_ARG(QString, info_text));
696 void MainWindow::update_device_list()
698 main_bar_->update_device_list();
701 void MainWindow::load_file(QString file_name,
702 std::shared_ptr<sigrok::InputFormat> format,
703 const std::map<std::string, Glib::VariantBase> &options)
705 const QString errorMessage(
706 QString("Failed to load file %1").arg(file_name));
710 session_.set_device(shared_ptr<devices::Device>(
711 new devices::InputFile(
712 device_manager_.context(),
713 file_name.toStdString(),
716 session_.set_device(shared_ptr<devices::Device>(
717 new devices::SessionFile(
718 device_manager_.context(),
719 file_name.toStdString())));
721 show_session_error(tr("Failed to load ") + file_name, e.what());
722 session_.set_default_device();
723 update_device_list();
727 update_device_list();
729 session_.start_capture([&, errorMessage](QString infoMessage) {
730 session_error(errorMessage, infoMessage); });
733 void MainWindow::closeEvent(QCloseEvent *event)
739 void MainWindow::keyReleaseEvent(QKeyEvent *event)
741 if (event->key() == Qt::Key_Alt) {
742 menuBar()->setHidden(!menuBar()->isHidden());
743 menuBar()->setFocus();
745 QMainWindow::keyReleaseEvent(event);
748 QMenu* MainWindow::createPopupMenu()
753 bool MainWindow::restoreState(const QByteArray &state, int version)
758 // Do nothing. We don't want Qt to handle this, or else it
759 // will try to restore all the dock widgets and create havoc.
764 void MainWindow::show_session_error(
765 const QString text, const QString info_text)
767 QMessageBox msg(this);
769 msg.setInformativeText(info_text);
770 msg.setStandardButtons(QMessageBox::Ok);
771 msg.setIcon(QMessageBox::Warning);
775 void MainWindow::on_actionOpen_triggered()
778 const QString dir = settings.value(SettingOpenDirectory).toString();
781 const QString file_name = QFileDialog::getOpenFileName(
782 this, tr("Open File"), dir, tr(
783 "Sigrok Sessions (*.sr);;"
786 if (!file_name.isEmpty()) {
787 load_file(file_name);
789 const QString abs_path = QFileInfo(file_name).absolutePath();
790 settings.setValue(SettingOpenDirectory, abs_path);
794 void MainWindow::on_actionSaveAs_triggered()
796 export_file(device_manager_.context()->output_formats()["srzip"]);
799 void MainWindow::on_actionSaveSelectionAs_triggered()
801 export_file(device_manager_.context()->output_formats()["srzip"], true);
804 void MainWindow::on_actionConnect_triggered()
806 // Stop any currently running capture session
807 session_.stop_capture();
809 dialogs::Connect dlg(this, device_manager_);
811 // If the user selected a device, select it in the device list. Select the
812 // current device otherwise.
814 select_device(dlg.get_selected_device());
816 update_device_list();
819 void MainWindow::on_actionQuit_triggered()
824 void MainWindow::on_actionViewZoomIn_triggered()
826 shared_ptr<pv::view::View> view = get_active_view();
831 void MainWindow::on_actionViewZoomOut_triggered()
833 shared_ptr<pv::view::View> view = get_active_view();
838 void MainWindow::on_actionViewZoomFit_triggered()
840 shared_ptr<pv::view::View> view = get_active_view();
842 view->zoom_fit(action_view_zoom_fit_->isChecked());
845 void MainWindow::on_actionViewZoomOneToOne_triggered()
847 shared_ptr<pv::view::View> view = get_active_view();
849 view->zoom_one_to_one();
852 void MainWindow::on_actionViewStickyScrolling_triggered()
854 shared_ptr<pv::view::View> view = get_active_view();
856 view->enable_sticky_scrolling(action_view_sticky_scrolling_->isChecked());
859 void MainWindow::on_actionViewColouredBg_triggered()
861 shared_ptr<pv::view::View> view = get_active_view();
863 view->enable_coloured_bg(action_view_coloured_bg_->isChecked());
866 void MainWindow::on_actionViewShowCursors_triggered()
868 shared_ptr<pv::view::View> view = get_active_view();
872 const bool show = !view->cursors_shown();
874 view->centre_cursors();
876 view->show_cursors(show);
879 void MainWindow::on_actionAbout_triggered()
881 dialogs::About dlg(device_manager_.context(), this);
885 void MainWindow::sticky_scrolling_changed(bool state)
887 action_view_sticky_scrolling_->setChecked(state);
890 void MainWindow::always_zoom_to_fit_changed(bool state)
892 action_view_zoom_fit_->setChecked(state);
895 void MainWindow::add_decoder(srd_decoder *decoder)
899 session_.add_decoder(decoder);
905 void MainWindow::capture_state_changed(int state)
907 main_bar_->set_capture_state((pv::Session::capture_state)state);
910 void MainWindow::device_selected()
912 // Set the title to include the device/file name
913 const shared_ptr<devices::Device> device = session_.device();
916 main_bar_->reset_device_selector();
920 const string display_name = device->display_name(device_manager_);
921 setWindowTitle(tr("%1 - PulseView").arg(display_name.c_str()));