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