pv/mainwindow.cpp

   1 /*
   2  * This file is part of the PulseView project.
   3  *
   4  * Copyright (C) 2012 Joel Holdsworth <joel@airwebreathe.org.uk>
   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 2 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 #ifdef ENABLE_DECODE
  21 #include <libsigrokdecode/libsigrokdecode.h>
  22 #endif
  23
  24 #include <algorithm>
  25 #include <cassert>
  26 #include <cstdarg>
  27 #include <cstdint>
  28 #include <iterator>
  29
  30 #include <QAction>
  31 #include <QApplication>
  32 #include <QCloseEvent>
  33 #include <QDebug>
  34 #include <QDockWidget>
  35 #include <QHBoxLayout>
  36 #include <QMessageBox>
  37 #include <QSettings>
  38 #include <QShortcut>
  39 #include <QWidget>
  40
  41 #include "mainwindow.hpp"
  42
  43 #include "application.hpp"
  44 #include "devicemanager.hpp"
  45 #include "devices/hardwaredevice.hpp"
  46 #include "dialogs/settings.hpp"
  47 #include "globalsettings.hpp"
  48 #include "toolbars/mainbar.hpp"
  49 #include "util.hpp"
  50 #include "views/trace/view.hpp"
  51 #include "views/trace/standardbar.hpp"
  52
  53 #ifdef ENABLE_DECODE
  54 #include "subwindows/decoder_selector/subwindow.hpp"
  55 #include "views/decoder_binary/view.hpp"
  56 #include "views/tabular_decoder/view.hpp"
  57 #endif
  58
  59 #include <libsigrokcxx/libsigrokcxx.hpp>
  60
  61 using std::dynamic_pointer_cast;
  62 using std::make_shared;
  63 using std::shared_ptr;
  64 using std::string;
  65
  66 namespace pv {
  67
  68 using toolbars::MainBar;
  69
  70 const QString MainWindow::WindowTitle = tr("PulseView");
  71
  72 MainWindow::MainWindow(DeviceManager &device_manager, QWidget *parent) :
  73         QMainWindow(parent),
  74         device_manager_(device_manager),
  75         session_selector_(this),
  76         icon_red_(":/icons/status-red.svg"),
  77         icon_green_(":/icons/status-green.svg"),
  78         icon_grey_(":/icons/status-grey.svg")
  79 {
  80         setup_ui();
  81         restore_ui_settings();
  82 }
  83
  84 MainWindow::~MainWindow()
  85 {
  86         // Make sure we no longer hold any shared pointers to widgets after the
  87         // destructor finishes (goes for sessions and sub windows alike)
  88
  89         while (!sessions_.empty())
  90                 remove_session(sessions_.front());
  91
  92         sub_windows_.clear();
  93 }
  94
  95 void MainWindow::show_session_error(const QString text, const QString info_text)
  96 {
  97         // TODO Emulate noquote()
  98         qDebug() << "Notifying user of session error:" << info_text;
  99
 100         QMessageBox msg;
 101         msg.setText(text + "\n\n" + info_text);
 102         msg.setStandardButtons(QMessageBox::Ok);
 103         msg.setIcon(QMessageBox::Warning);
 104         msg.exec();
 105 }
 106
 107 shared_ptr<views::ViewBase> MainWindow::get_active_view() const
 108 {
 109         // If there's only one view, use it...
 110         if (view_docks_.size() == 1)
 111                 return view_docks_.begin()->second;
 112
 113         // ...otherwise find the dock widget the widget with focus is contained in
 114         QObject *w = QApplication::focusWidget();
 115         QDockWidget *dock = nullptr;
 116
 117         while (w) {
 118                 dock = qobject_cast<QDockWidget*>(w);
 119                 if (dock)
 120                         break;
 121                 w = w->parent();
 122         }
 123
 124         // Get the view contained in the dock widget
 125         for (auto& entry : view_docks_)
 126                 if (entry.first == dock)
 127                         return entry.second;
 128
 129         return nullptr;
 130 }
 131
 132 shared_ptr<views::ViewBase> MainWindow::add_view(views::ViewType type,
 133         Session &session)
 134 {
 135         GlobalSettings settings;
 136         shared_ptr<views::ViewBase> v;
 137
 138         QMainWindow *main_window = nullptr;
 139         for (auto& entry : session_windows_)
 140                 if (entry.first.get() == &session)
 141                         main_window = entry.second;
 142
 143         assert(main_window);
 144
 145         shared_ptr<MainBar> main_bar = session.main_bar();
 146
 147         // Only use the view type in the name if it's not the main view
 148         QString title;
 149         if (main_bar)
 150                 title = QString("%1 (%2)").arg(session.name(), views::ViewTypeNames[type]);
 151         else
 152                 title = session.name();
 153
 154         QDockWidget* dock = new QDockWidget(title, main_window);
 155         dock->setObjectName(title);
 156         main_window->addDockWidget(Qt::TopDockWidgetArea, dock);
 157
 158         // Insert a QMainWindow into the dock widget to allow for a tool bar
 159         QMainWindow *dock_main = new QMainWindow(dock);
 160         dock_main->setWindowFlags(Qt::Widget);  // Remove Qt::Window flag
 161
 162         if (type == views::ViewTypeTrace)
 163                 // This view will be the main view if there's no main bar yet
 164                 v = make_shared<views::trace::View>(session, (main_bar ? false : true), dock_main);
 165 #ifdef ENABLE_DECODE
 166         if (type == views::ViewTypeDecoderBinary)
 167                 v = make_shared<views::decoder_binary::View>(session, false, dock_main);
 168         if (type == views::ViewTypeTabularDecoder)
 169                 v = make_shared<views::tabular_decoder::View>(session, false, dock_main);
 170 #endif
 171
 172         if (!v)
 173                 return nullptr;
 174
 175         view_docks_[dock] = v;
 176         session.register_view(v);
 177
 178         dock_main->setCentralWidget(v.get());
 179         dock->setWidget(dock_main);
 180
 181         dock->setContextMenuPolicy(Qt::PreventContextMenu);
 182         dock->setFeatures(QDockWidget::DockWidgetMovable |
 183                 QDockWidget::DockWidgetFloatable | QDockWidget::DockWidgetClosable);
 184
 185         QAbstractButton *close_btn =
 186                 dock->findChildren<QAbstractButton*>("qt_dockwidget_closebutton")  // clazy:exclude=detaching-temporary
 187                         .front();
 188
 189         connect(close_btn, SIGNAL(clicked(bool)),
 190                 this, SLOT(on_view_close_clicked()));
 191
 192         connect(&session, SIGNAL(trigger_event(int, util::Timestamp)),
 193                 qobject_cast<views::ViewBase*>(v.get()),
 194                 SLOT(trigger_event(int, util::Timestamp)));
 195
 196         if (type == views::ViewTypeTrace) {
 197                 views::trace::View *tv =
 198                         qobject_cast<views::trace::View*>(v.get());
 199
 200                 if (!main_bar) {
 201                         /* Initial view, create the main bar */
 202                         main_bar = make_shared<MainBar>(session, this, tv);
 203                         dock_main->addToolBar(main_bar.get());
 204                         session.set_main_bar(main_bar);
 205
 206                         connect(main_bar.get(), SIGNAL(new_view(Session*, int)),
 207                                 this, SLOT(on_new_view(Session*, int)));
 208                         connect(main_bar.get(), SIGNAL(show_decoder_selector(Session*)),
 209                                 this, SLOT(on_show_decoder_selector(Session*)));
 210
 211                         main_bar->action_view_show_cursors()->setChecked(tv->cursors_shown());
 212
 213                         /* For the main view we need to prevent the dock widget from
 214                          * closing itself when its close button is clicked. This is
 215                          * so we can confirm with the user first. Regular views don't
 216                          * need this */
 217                         close_btn->disconnect(SIGNAL(clicked()), dock, SLOT(close()));
 218                 } else {
 219                         /* Additional view, create a standard bar */
 220                         pv::views::trace::StandardBar *standard_bar =
 221                                 new pv::views::trace::StandardBar(session, this, tv);
 222                         dock_main->addToolBar(standard_bar);
 223
 224                         standard_bar->action_view_show_cursors()->setChecked(tv->cursors_shown());
 225                 }
 226         }
 227
 228         v->setFocus();
 229
 230         return v;
 231 }
 232
 233 void MainWindow::remove_view(shared_ptr<views::ViewBase> view)
 234 {
 235         for (shared_ptr<Session> session : sessions_) {
 236                 if (!session->has_view(view))
 237                         continue;
 238
 239                 // Find the dock the view is contained in and remove it
 240                 for (auto& entry : view_docks_)
 241                         if (entry.second == view) {
 242                                 // Remove the view from the session
 243                                 session->deregister_view(view);
 244
 245                                 // Remove the view from its parent; otherwise, Qt will
 246                                 // call deleteLater() on it, which causes a double free
 247                                 // since the shared_ptr in view_docks_ doesn't know
 248                                 // that Qt keeps a pointer to the view around
 249                                 view->setParent(nullptr);
 250
 251                                 // Delete the view's dock widget and all widgets inside it
 252                                 entry.first->deleteLater();
 253
 254                                 // Remove the dock widget from the list and stop iterating
 255                                 view_docks_.erase(entry.first);
 256                                 break;
 257                         }
 258         }
 259 }
 260
 261 shared_ptr<subwindows::SubWindowBase> MainWindow::add_subwindow(
 262         subwindows::SubWindowType type, Session &session)
 263 {
 264         GlobalSettings settings;
 265         shared_ptr<subwindows::SubWindowBase> w;
 266
 267         QMainWindow *main_window = nullptr;
 268         for (auto& entry : session_windows_)
 269                 if (entry.first.get() == &session)
 270                         main_window = entry.second;
 271
 272         assert(main_window);
 273
 274         QString title = "";
 275
 276         switch (type) {
 277 #ifdef ENABLE_DECODE
 278                 case subwindows::SubWindowTypeDecoderSelector:
 279                         title = tr("Decoder Selector");
 280                         break;
 281 #endif
 282                 default:
 283                         break;
 284         }
 285
 286         QDockWidget* dock = new QDockWidget(title, main_window);
 287         dock->setObjectName(title);
 288         main_window->addDockWidget(Qt::TopDockWidgetArea, dock);
 289
 290         // Insert a QMainWindow into the dock widget to allow for a tool bar
 291         QMainWindow *dock_main = new QMainWindow(dock);
 292         dock_main->setWindowFlags(Qt::Widget);  // Remove Qt::Window flag
 293
 294 #ifdef ENABLE_DECODE
 295         if (type == subwindows::SubWindowTypeDecoderSelector)
 296                 w = make_shared<subwindows::decoder_selector::SubWindow>(session, dock_main);
 297 #endif
 298
 299         if (!w)
 300                 return nullptr;
 301
 302         sub_windows_[dock] = w;
 303         dock_main->setCentralWidget(w.get());
 304         dock->setWidget(dock_main);
 305
 306         dock->setContextMenuPolicy(Qt::PreventContextMenu);
 307         dock->setFeatures(QDockWidget::DockWidgetMovable |
 308                 QDockWidget::DockWidgetFloatable | QDockWidget::DockWidgetClosable);
 309
 310         QAbstractButton *close_btn =
 311                 dock->findChildren<QAbstractButton*>  // clazy:exclude=detaching-temporary
 312                         ("qt_dockwidget_closebutton").front();
 313
 314         // Allow all subwindows to be closed via ESC.
 315         close_btn->setShortcut(QKeySequence(Qt::Key_Escape));
 316
 317         connect(close_btn, SIGNAL(clicked(bool)),
 318                 this, SLOT(on_sub_window_close_clicked()));
 319
 320         if (w->has_toolbar())
 321                 dock_main->addToolBar(w->create_toolbar(dock_main));
 322
 323         if (w->minimum_width() > 0)
 324                 dock->setMinimumSize(w->minimum_width(), 0);
 325
 326         return w;
 327 }
 328
 329 shared_ptr<Session> MainWindow::add_session()
 330 {
 331         static int last_session_id = 1;
 332         QString name = tr("Session %1").arg(last_session_id++);
 333
 334         shared_ptr<Session> session = make_shared<Session>(device_manager_, name);
 335
 336         connect(session.get(), SIGNAL(add_view(views::ViewType, Session*)),
 337                 this, SLOT(on_add_view(views::ViewType, Session*)));
 338         connect(session.get(), SIGNAL(name_changed()),
 339                 this, SLOT(on_session_name_changed()));
 340         connect(session.get(), SIGNAL(device_changed()),
 341                 this, SLOT(on_session_device_changed()));
 342         connect(session.get(), SIGNAL(capture_state_changed(int)),
 343                 this, SLOT(on_session_capture_state_changed(int)));
 344
 345         sessions_.push_back(session);
 346
 347         QMainWindow *window = new QMainWindow();
 348         window->setWindowFlags(Qt::Widget);  // Remove Qt::Window flag
 349         session_windows_[session] = window;
 350
 351         int index = session_selector_.addTab(window, name);
 352         session_selector_.setCurrentIndex(index);
 353         last_focused_session_ = session;
 354
 355         window->setDockNestingEnabled(true);
 356
 357         add_view(views::ViewTypeTrace, *session);
 358
 359         return session;
 360 }
 361
 362 void MainWindow::remove_session(shared_ptr<Session> session)
 363 {
 364         // Determine the height of the button before it collapses
 365         int h = new_session_button_->height();
 366
 367         // Stop capture while the session still exists so that the UI can be
 368         // updated in case we're currently running. If so, this will schedule a
 369         // call to our on_capture_state_changed() slot for the next run of the
 370         // event loop. We need to have this executed immediately or else it will
 371         // be dismissed since the session object will be deleted by the time we
 372         // leave this method and the event loop gets a chance to run again.
 373         session->stop_capture();
 374         QApplication::processEvents();
 375
 376         for (const shared_ptr<views::ViewBase>& view : session->views())
 377                 remove_view(view);
 378
 379         QMainWindow *window = session_windows_.at(session);
 380         session_selector_.removeTab(session_selector_.indexOf(window));
 381
 382         session_windows_.erase(session);
 383
 384         if (last_focused_session_ == session)
 385                 last_focused_session_.reset();
 386
 387         // Remove the session from our list of sessions (which also destroys it)
 388         sessions_.remove_if([&](shared_ptr<Session> s) {
 389                 return s == session; });
 390
 391         if (sessions_.empty()) {
 392                 // When there are no more tabs, the height of the QTabWidget
 393                 // drops to zero. We must prevent this to keep the static
 394                 // widgets visible
 395                 for (QWidget *w : static_tab_widget_->findChildren<QWidget*>())  // clazy:exclude=range-loop
 396                         w->setMinimumHeight(h);
 397
 398                 int margin = static_tab_widget_->layout()->contentsMargins().bottom();
 399                 static_tab_widget_->setMinimumHeight(h + 2 * margin);
 400                 session_selector_.setMinimumHeight(h + 2 * margin);
 401
 402                 // Update the window title if there is no view left to
 403                 // generate focus change events
 404                 setWindowTitle(WindowTitle);
 405         }
 406 }
 407
 408 void MainWindow::add_session_with_file(string open_file_name,
 409         string open_file_format, string open_setup_file_name)
 410 {
 411         shared_ptr<Session> session = add_session();
 412         session->load_init_file(open_file_name, open_file_format, open_setup_file_name);
 413 }
 414
 415 void MainWindow::add_default_session()
 416 {
 417         // Only add the default session if there would be no session otherwise
 418         if (sessions_.size() > 0)
 419                 return;
 420
 421         shared_ptr<Session> session = add_session();
 422
 423         // Check the list of available devices. Prefer the one that was
 424         // found with user supplied scan specs (if applicable). Then try
 425         // one of the auto detected devices that are not the demo device.
 426         // Pick demo in the absence of "genuine" hardware devices.
 427         shared_ptr<devices::HardwareDevice> user_device, other_device, demo_device;
 428         for (const shared_ptr<devices::HardwareDevice>& dev : device_manager_.devices()) {
 429                 if (dev == device_manager_.user_spec_device()) {
 430                         user_device = dev;
 431                 } else if (dev->hardware_device()->driver()->name() == "demo") {
 432                         demo_device = dev;
 433                 } else {
 434                         other_device = dev;
 435                 }
 436         }
 437         if (user_device)
 438                 session->select_device(user_device);
 439         else if (other_device)
 440                 session->select_device(other_device);
 441         else
 442                 session->select_device(demo_device);
 443 }
 444
 445 void MainWindow::save_sessions()
 446 {
 447         QSettings settings;
 448         int id = 0;
 449
 450         for (shared_ptr<Session>& session : sessions_) {
 451                 // Ignore sessions using the demo device or no device at all
 452                 if (session->device()) {
 453                         shared_ptr<devices::HardwareDevice> device =
 454                                 dynamic_pointer_cast< devices::HardwareDevice >
 455                                 (session->device());
 456
 457                         if (device &&
 458                                 device->hardware_device()->driver()->name() == "demo")
 459                                 continue;
 460
 461                         settings.beginGroup("Session" + QString::number(id++));
 462                         settings.remove("");  // Remove all keys in this group
 463                         session->save_settings(settings);
 464                         settings.endGroup();
 465                 }
 466         }
 467
 468         settings.setValue("sessions", id);
 469 }
 470
 471 void MainWindow::restore_sessions()
 472 {
 473         QSettings settings;
 474         int i, session_count;
 475
 476         session_count = settings.value("sessions", 0).toInt();
 477
 478         for (i = 0; i < session_count; i++) {
 479                 settings.beginGroup("Session" + QString::number(i));
 480                 shared_ptr<Session> session = add_session();
 481                 session->restore_settings(settings);
 482                 settings.endGroup();
 483         }
 484 }
 485
 486 void MainWindow::setup_ui()
 487 {
 488         setObjectName(QString::fromUtf8("MainWindow"));
 489
 490         setCentralWidget(&session_selector_);
 491
 492         // Set the window icon
 493         QIcon icon;
 494         icon.addFile(QString(":/icons/pulseview.png"));
 495         setWindowIcon(icon);
 496
 497         // Set up keyboard shortcuts that affect all views at once
 498         view_sticky_scrolling_shortcut_ = new QShortcut(QKeySequence(Qt::Key_S), this, SLOT(on_view_sticky_scrolling_shortcut()));
 499         view_sticky_scrolling_shortcut_->setAutoRepeat(false);
 500
 501         view_show_sampling_points_shortcut_ = new QShortcut(QKeySequence(Qt::Key_Period), this, SLOT(on_view_show_sampling_points_shortcut()));
 502         view_show_sampling_points_shortcut_->setAutoRepeat(false);
 503
 504         view_show_analog_minor_grid_shortcut_ = new QShortcut(QKeySequence(Qt::Key_G), this, SLOT(on_view_show_analog_minor_grid_shortcut()));
 505         view_show_analog_minor_grid_shortcut_->setAutoRepeat(false);
 506
 507         view_colored_bg_shortcut_ = new QShortcut(QKeySequence(Qt::Key_B), this, SLOT(on_view_colored_bg_shortcut()));
 508         view_colored_bg_shortcut_->setAutoRepeat(false);
 509
 510         // Set up the tab area
 511         new_session_button_ = new QToolButton();
 512         new_session_button_->setIcon(QIcon::fromTheme("document-new",
 513                 QIcon(":/icons/document-new.png")));
 514         new_session_button_->setToolTip(tr("Create New Session"));
 515         new_session_button_->setAutoRaise(true);
 516
 517         run_stop_button_ = new QToolButton();
 518         run_stop_button_->setAutoRaise(true);
 519         run_stop_button_->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
 520         run_stop_button_->setToolTip(tr("Start/Stop Acquisition"));
 521
 522         run_stop_shortcut_ = new QShortcut(QKeySequence(Qt::Key_Space), run_stop_button_, SLOT(click()));
 523         run_stop_shortcut_->setAutoRepeat(false);
 524
 525         settings_button_ = new QToolButton();
 526         settings_button_->setIcon(QIcon::fromTheme("preferences-system",
 527                 QIcon(":/icons/preferences-system.png")));
 528         settings_button_->setToolTip(tr("Settings"));
 529         settings_button_->setAutoRaise(true);
 530
 531         QFrame *separator1 = new QFrame();
 532         separator1->setFrameStyle(QFrame::VLine | QFrame::Raised);
 533         QFrame *separator2 = new QFrame();
 534         separator2->setFrameStyle(QFrame::VLine | QFrame::Raised);
 535
 536         QHBoxLayout* layout = new QHBoxLayout();
 537         layout->setContentsMargins(2, 2, 2, 2);
 538         layout->addWidget(new_session_button_);
 539         layout->addWidget(separator1);
 540         layout->addWidget(run_stop_button_);
 541         layout->addWidget(separator2);
 542         layout->addWidget(settings_button_);
 543
 544         static_tab_widget_ = new QWidget();
 545         static_tab_widget_->setLayout(layout);
 546
 547         session_selector_.setCornerWidget(static_tab_widget_, Qt::TopLeftCorner);
 548         session_selector_.setTabsClosable(true);
 549
 550         close_application_shortcut_ = new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_Q), this, SLOT(close()));
 551         close_application_shortcut_->setAutoRepeat(false);
 552
 553         close_current_tab_shortcut_ = new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_W), this, SLOT(on_close_current_tab()));
 554
 555         connect(new_session_button_, SIGNAL(clicked(bool)),
 556                 this, SLOT(on_new_session_clicked()));
 557         connect(run_stop_button_, SIGNAL(clicked(bool)),
 558                 this, SLOT(on_run_stop_clicked()));
 559         connect(settings_button_, SIGNAL(clicked(bool)),
 560                 this, SLOT(on_settings_clicked()));
 561
 562         connect(&session_selector_, SIGNAL(tabCloseRequested(int)),
 563                 this, SLOT(on_tab_close_requested(int)));
 564         connect(&session_selector_, SIGNAL(currentChanged(int)),
 565                 this, SLOT(on_tab_changed(int)));
 566
 567
 568         connect(static_cast<QApplication *>(QCoreApplication::instance()),
 569                 SIGNAL(focusChanged(QWidget*, QWidget*)),
 570                 this, SLOT(on_focus_changed()));
 571 }
 572
 573 void MainWindow::update_acq_button(Session *session)
 574 {
 575         int state;
 576         QString run_caption;
 577
 578         if (session) {
 579                 state = session->get_capture_state();
 580                 run_caption = session->using_file_device() ? tr("Reload") : tr("Run");
 581         } else {
 582                 state = Session::Stopped;
 583                 run_caption = tr("Run");
 584         }
 585
 586         const QIcon *icons[] = {&icon_grey_, &icon_red_, &icon_green_};
 587         run_stop_button_->setIcon(*icons[state]);
 588         run_stop_button_->setText((state == pv::Session::Stopped) ?
 589                 run_caption : tr("Stop"));
 590 }
 591
 592 void MainWindow::save_ui_settings()
 593 {
 594         QSettings settings;
 595
 596         settings.beginGroup("MainWindow");
 597         settings.setValue("state", saveState());
 598         settings.setValue("geometry", saveGeometry());
 599         settings.endGroup();
 600 }
 601
 602 void MainWindow::restore_ui_settings()
 603 {
 604         QSettings settings;
 605
 606         settings.beginGroup("MainWindow");
 607
 608         if (settings.contains("geometry")) {
 609                 restoreGeometry(settings.value("geometry").toByteArray());
 610                 restoreState(settings.value("state").toByteArray());
 611         } else
 612                 resize(1000, 720);
 613
 614         settings.endGroup();
 615 }
 616
 617 shared_ptr<Session> MainWindow::get_tab_session(int index) const
 618 {
 619         // Find the session that belongs to the tab's main window
 620         for (auto& entry : session_windows_)
 621                 if (entry.second == session_selector_.widget(index))
 622                         return entry.first;
 623
 624         return nullptr;
 625 }
 626
 627 void MainWindow::closeEvent(QCloseEvent *event)
 628 {
 629         bool data_saved = true;
 630
 631         for (auto& entry : session_windows_)
 632                 if (!entry.first->data_saved())
 633                         data_saved = false;
 634
 635         if (!data_saved && (QMessageBox::question(this, tr("Confirmation"),
 636                 tr("There is unsaved data. Close anyway?"),
 637                 QMessageBox::Yes | QMessageBox::No) == QMessageBox::No)) {
 638                 event->ignore();
 639         } else {
 640                 save_ui_settings();
 641                 save_sessions();
 642                 event->accept();
 643         }
 644 }
 645
 646 QMenu* MainWindow::createPopupMenu()
 647 {
 648         return nullptr;
 649 }
 650
 651 bool MainWindow::restoreState(const QByteArray &state, int version)
 652 {
 653         (void)state;
 654         (void)version;
 655
 656         // Do nothing. We don't want Qt to handle this, or else it
 657         // will try to restore all the dock widgets and create havoc.
 658
 659         return false;
 660 }
 661
 662 void MainWindow::on_add_view(views::ViewType type, Session *session)
 663 {
 664         // We get a pointer and need a reference
 665         for (shared_ptr<Session>& s : sessions_)
 666                 if (s.get() == session)
 667                         add_view(type, *s);
 668 }
 669
 670 void MainWindow::on_focus_changed()
 671 {
 672         shared_ptr<views::ViewBase> view = get_active_view();
 673
 674         if (view) {
 675                 for (shared_ptr<Session> session : sessions_) {
 676                         if (session->has_view(view)) {
 677                                 if (session != last_focused_session_) {
 678                                         // Activate correct tab if necessary
 679                                         shared_ptr<Session> tab_session = get_tab_session(
 680                                                 session_selector_.currentIndex());
 681                                         if (tab_session != session)
 682                                                 session_selector_.setCurrentWidget(
 683                                                         session_windows_.at(session));
 684
 685                                         on_focused_session_changed(session);
 686                                 }
 687
 688                                 break;
 689                         }
 690                 }
 691         }
 692
 693         if (sessions_.empty())
 694                 setWindowTitle(WindowTitle);
 695 }
 696
 697 void MainWindow::on_focused_session_changed(shared_ptr<Session> session)
 698 {
 699         last_focused_session_ = session;
 700
 701         setWindowTitle(session->name() + " - " + WindowTitle);
 702
 703         // Update the state of the run/stop button, too
 704         update_acq_button(session.get());
 705 }
 706
 707 void MainWindow::on_new_session_clicked()
 708 {
 709         add_session();
 710 }
 711
 712 void MainWindow::on_run_stop_clicked()
 713 {
 714         shared_ptr<Session> session = last_focused_session_;
 715
 716         if (!session)
 717                 return;
 718
 719         switch (session->get_capture_state()) {
 720         case Session::Stopped:
 721                 session->start_capture([&](QString message) {
 722                         show_session_error("Capture failed", message); });
 723                 break;
 724         case Session::AwaitingTrigger:
 725         case Session::Running:
 726                 session->stop_capture();
 727                 break;
 728         }
 729 }
 730
 731 void MainWindow::on_settings_clicked()
 732 {
 733         dialogs::Settings dlg(device_manager_);
 734         dlg.exec();
 735 }
 736
 737 void MainWindow::on_session_name_changed()
 738 {
 739         // Update the corresponding dock widget's name(s)
 740         Session *session = qobject_cast<Session*>(QObject::sender());
 741         assert(session);
 742
 743         for (const shared_ptr<views::ViewBase>& view : session->views()) {
 744                 // Get the dock that contains the view
 745                 for (auto& entry : view_docks_)
 746                         if (entry.second == view) {
 747                                 entry.first->setObjectName(session->name());
 748                                 entry.first->setWindowTitle(session->name());
 749                         }
 750         }
 751
 752         // Update the tab widget by finding the main window and the tab from that
 753         for (auto& entry : session_windows_)
 754                 if (entry.first.get() == session) {
 755                         QMainWindow *window = entry.second;
 756                         const int index = session_selector_.indexOf(window);
 757                         session_selector_.setTabText(index, session->name());
 758                 }
 759
 760         // Refresh window title if the affected session has focus
 761         if (session == last_focused_session_.get())
 762                 setWindowTitle(session->name() + " - " + WindowTitle);
 763 }
 764
 765 void MainWindow::on_session_device_changed()
 766 {
 767         Session *session = qobject_cast<Session*>(QObject::sender());
 768         assert(session);
 769
 770         // Ignore if caller is not the currently focused session
 771         // unless there is only one session
 772         if ((sessions_.size() > 1) && (session != last_focused_session_.get()))
 773                 return;
 774
 775         update_acq_button(session);
 776 }
 777
 778 void MainWindow::on_session_capture_state_changed(int state)
 779 {
 780         (void)state;
 781
 782         Session *session = qobject_cast<Session*>(QObject::sender());
 783         assert(session);
 784
 785         // Ignore if caller is not the currently focused session
 786         // unless there is only one session
 787         if ((sessions_.size() > 1) && (session != last_focused_session_.get()))
 788                 return;
 789
 790         update_acq_button(session);
 791 }
 792
 793 void MainWindow::on_new_view(Session *session, int view_type)
 794 {
 795         // We get a pointer and need a reference
 796         for (shared_ptr<Session>& s : sessions_)
 797                 if (s.get() == session)
 798                         add_view((views::ViewType)view_type, *s);
 799 }
 800
 801 void MainWindow::on_view_close_clicked()
 802 {
 803         // Find the dock widget that contains the close button that was clicked
 804         QObject *w = QObject::sender();
 805         QDockWidget *dock = nullptr;
 806
 807         while (w) {
 808             dock = qobject_cast<QDockWidget*>(w);
 809             if (dock)
 810                 break;
 811             w = w->parent();
 812         }
 813
 814         // Get the view contained in the dock widget
 815         shared_ptr<views::ViewBase> view;
 816
 817         for (auto& entry : view_docks_)
 818                 if (entry.first == dock)
 819                         view = entry.second;
 820
 821         // Deregister the view
 822         for (shared_ptr<Session> session : sessions_) {
 823                 if (!session->has_view(view))
 824                         continue;
 825
 826                 // Also destroy the entire session if its main view is closing...
 827                 if (view == session->main_view()) {
 828                         // ...but only if data is saved or the user confirms closing
 829                         if (session->data_saved() || (QMessageBox::question(this, tr("Confirmation"),
 830                                 tr("This session contains unsaved data. Close it anyway?"),
 831                                 QMessageBox::Yes | QMessageBox::No) == QMessageBox::Yes))
 832                                 remove_session(session);
 833                         break;
 834                 } else
 835                         // All other views can be closed at any time as no data will be lost
 836                         remove_view(view);
 837         }
 838 }
 839
 840 void MainWindow::on_tab_changed(int index)
 841 {
 842         shared_ptr<Session> session = get_tab_session(index);
 843
 844         if (session)
 845                 on_focused_session_changed(session);
 846 }
 847
 848 void MainWindow::on_tab_close_requested(int index)
 849 {
 850         shared_ptr<Session> session = get_tab_session(index);
 851
 852         if (!session)
 853                 return;
 854
 855         if (session->data_saved() || (QMessageBox::question(this, tr("Confirmation"),
 856                 tr("This session contains unsaved data. Close it anyway?"),
 857                 QMessageBox::Yes | QMessageBox::No) == QMessageBox::Yes))
 858                 remove_session(session);
 859
 860         if (sessions_.empty())
 861                 update_acq_button(nullptr);
 862 }
 863
 864 void MainWindow::on_show_decoder_selector(Session *session)
 865 {
 866 #ifdef ENABLE_DECODE
 867         // Close dock widget if it's already showing and return
 868         for (auto& entry : sub_windows_) {
 869                 QDockWidget* dock = entry.first;
 870                 shared_ptr<subwindows::SubWindowBase> decoder_selector =
 871                         dynamic_pointer_cast<subwindows::decoder_selector::SubWindow>(entry.second);
 872
 873                 if (decoder_selector && (&decoder_selector->session() == session)) {
 874                         sub_windows_.erase(dock);
 875                         dock->close();
 876                         return;
 877                 }
 878         }
 879
 880         // We get a pointer and need a reference
 881         for (shared_ptr<Session>& s : sessions_)
 882                 if (s.get() == session)
 883                         add_subwindow(subwindows::SubWindowTypeDecoderSelector, *s);
 884 #endif
 885 }
 886
 887 void MainWindow::on_sub_window_close_clicked()
 888 {
 889         // Find the dock widget that contains the close button that was clicked
 890         QObject *w = QObject::sender();
 891         QDockWidget *dock = nullptr;
 892
 893         while (w) {
 894             dock = qobject_cast<QDockWidget*>(w);
 895             if (dock)
 896                 break;
 897             w = w->parent();
 898         }
 899
 900         sub_windows_.erase(dock);
 901         dock->close();
 902
 903         // Restore focus to the last used main view
 904         if (last_focused_session_)
 905                 last_focused_session_->main_view()->setFocus();
 906 }
 907
 908 void MainWindow::on_view_colored_bg_shortcut()
 909 {
 910         GlobalSettings settings;
 911
 912         bool state = settings.value(GlobalSettings::Key_View_ColoredBG).toBool();
 913         settings.setValue(GlobalSettings::Key_View_ColoredBG, !state);
 914 }
 915
 916 void MainWindow::on_view_sticky_scrolling_shortcut()
 917 {
 918         GlobalSettings settings;
 919
 920         bool state = settings.value(GlobalSettings::Key_View_StickyScrolling).toBool();
 921         settings.setValue(GlobalSettings::Key_View_StickyScrolling, !state);
 922 }
 923
 924 void MainWindow::on_view_show_sampling_points_shortcut()
 925 {
 926         GlobalSettings settings;
 927
 928         bool state = settings.value(GlobalSettings::Key_View_ShowSamplingPoints).toBool();
 929         settings.setValue(GlobalSettings::Key_View_ShowSamplingPoints, !state);
 930 }
 931
 932 void MainWindow::on_view_show_analog_minor_grid_shortcut()
 933 {
 934         GlobalSettings settings;
 935
 936         bool state = settings.value(GlobalSettings::Key_View_ShowAnalogMinorGrid).toBool();
 937         settings.setValue(GlobalSettings::Key_View_ShowAnalogMinorGrid, !state);
 938 }
 939
 940 void MainWindow::on_close_current_tab()
 941 {
 942         int tab = session_selector_.currentIndex();
 943
 944         on_tab_close_requested(tab);
 945 }
 946
 947 } // namespace pv