Settings: About: alpha-sort list of protocol decoders
[pulseview.git] / 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 <QDockWidget>
34 #include <QHBoxLayout>
35 #include <QMessageBox>
36 #include <QSettings>
37 #include <QShortcut>
38 #include <QWidget>
39
40 #include "mainwindow.hpp"
41
42 #include "devicemanager.hpp"
43 #include "devices/hardwaredevice.hpp"
44 #include "dialogs/settings.hpp"
45 #include "globalsettings.hpp"
46 #include "toolbars/mainbar.hpp"
47 #include "util.hpp"
48 #include "view/view.hpp"
49 #include "views/trace/standardbar.hpp"
50
51 #include <libsigrokcxx/libsigrokcxx.hpp>
52
53 using std::bind;
54 using std::dynamic_pointer_cast;
55 using std::make_shared;
56 using std::map;
57 using std::placeholders::_1;
58 using std::shared_ptr;
59 using std::string;
60
61 namespace pv {
62
63 namespace view {
64 class ViewItem;
65 }
66
67 using toolbars::MainBar;
68
69 const QString MainWindow::WindowTitle = tr("PulseView");
70
71 MainWindow::MainWindow(DeviceManager &device_manager,
72         string open_file_name, string open_file_format,
73         QWidget *parent) :
74         QMainWindow(parent),
75         device_manager_(device_manager),
76         session_selector_(this),
77         session_state_mapper_(this),
78         icon_red_(":/icons/status-red.svg"),
79         icon_green_(":/icons/status-green.svg"),
80         icon_grey_(":/icons/status-grey.svg")
81 {
82         qRegisterMetaType<util::Timestamp>("util::Timestamp");
83         qRegisterMetaType<uint64_t>("uint64_t");
84
85         GlobalSettings::register_change_handler(GlobalSettings::Key_View_ColouredBG,
86                 bind(&MainWindow::on_settingViewColouredBg_changed, this, _1));
87
88         GlobalSettings::register_change_handler(GlobalSettings::Key_View_ShowSamplingPoints,
89                 bind(&MainWindow::on_settingViewShowSamplingPoints_changed, this, _1));
90
91         GlobalSettings::register_change_handler(GlobalSettings::Key_View_ShowAnalogMinorGrid,
92                 bind(&MainWindow::on_settingViewShowAnalogMinorGrid_changed, this, _1));
93
94         setup_ui();
95         restore_ui_settings();
96
97         if (!open_file_name.empty()) {
98                 shared_ptr<Session> session = add_session();
99                 session->load_init_file(open_file_name, open_file_format);
100         }
101
102         // Add empty default session if there aren't any sessions
103         if (sessions_.size() == 0) {
104                 shared_ptr<Session> session = add_session();
105
106                 map<string, string> dev_info;
107                 shared_ptr<devices::HardwareDevice> other_device, demo_device;
108
109                 // Use any available device that's not demo
110                 for (shared_ptr<devices::HardwareDevice> dev : device_manager_.devices()) {
111                         if (dev->hardware_device()->driver()->name() == "demo") {
112                                 demo_device = dev;
113                         } else {
114                                 other_device = dev;
115                         }
116                 }
117
118                 // ...and if there isn't any, just use demo then
119                 session->select_device(other_device ? other_device : demo_device);
120         }
121 }
122
123 MainWindow::~MainWindow()
124 {
125         while (!sessions_.empty())
126                 remove_session(sessions_.front());
127 }
128
129 shared_ptr<views::ViewBase> MainWindow::get_active_view() const
130 {
131         // If there's only one view, use it...
132         if (view_docks_.size() == 1)
133                 return view_docks_.begin()->second;
134
135         // ...otherwise find the dock widget the widget with focus is contained in
136         QObject *w = QApplication::focusWidget();
137         QDockWidget *dock = nullptr;
138
139         while (w) {
140                 dock = qobject_cast<QDockWidget*>(w);
141                 if (dock)
142                         break;
143                 w = w->parent();
144         }
145
146         // Get the view contained in the dock widget
147         for (auto entry : view_docks_)
148                 if (entry.first == dock)
149                         return entry.second;
150
151         return nullptr;
152 }
153
154 shared_ptr<views::ViewBase> MainWindow::add_view(const QString &title,
155         views::ViewType type, Session &session)
156 {
157         GlobalSettings settings;
158         shared_ptr<views::ViewBase> v;
159
160         QMainWindow *main_window = nullptr;
161         for (auto entry : session_windows_)
162                 if (entry.first.get() == &session)
163                         main_window = entry.second;
164
165         assert(main_window);
166
167         shared_ptr<MainBar> main_bar = session.main_bar();
168
169         QDockWidget* dock = new QDockWidget(title, main_window);
170         dock->setObjectName(title);
171         main_window->addDockWidget(Qt::TopDockWidgetArea, dock);
172
173         // Insert a QMainWindow into the dock widget to allow for a tool bar
174         QMainWindow *dock_main = new QMainWindow(dock);
175         dock_main->setWindowFlags(Qt::Widget);  // Remove Qt::Window flag
176
177         if (type == views::ViewTypeTrace)
178                 // This view will be the main view if there's no main bar yet
179                 v = make_shared<views::TraceView::View>(session,
180                         (main_bar ? false : true), dock_main);
181
182         if (!v)
183                 return nullptr;
184
185         view_docks_[dock] = v;
186         session.register_view(v);
187
188         dock_main->setCentralWidget(v.get());
189         dock->setWidget(dock_main);
190
191         dock->setFeatures(QDockWidget::DockWidgetMovable |
192                 QDockWidget::DockWidgetFloatable | QDockWidget::DockWidgetClosable);
193
194         QAbstractButton *close_btn =
195                 dock->findChildren<QAbstractButton*>
196                         ("qt_dockwidget_closebutton").front();
197
198         connect(close_btn, SIGNAL(clicked(bool)),
199                 this, SLOT(on_view_close_clicked()));
200
201         connect(&session, SIGNAL(trigger_event(util::Timestamp)),
202                 qobject_cast<views::ViewBase*>(v.get()),
203                 SLOT(trigger_event(util::Timestamp)));
204
205         if (type == views::ViewTypeTrace) {
206                 views::TraceView::View *tv =
207                         qobject_cast<views::TraceView::View*>(v.get());
208
209                 tv->enable_coloured_bg(settings.value(GlobalSettings::Key_View_ColouredBG).toBool());
210                 tv->enable_show_sampling_points(settings.value(GlobalSettings::Key_View_ShowSamplingPoints).toBool());
211                 tv->enable_show_analog_minor_grid(settings.value(GlobalSettings::Key_View_ShowAnalogMinorGrid).toBool());
212
213                 if (!main_bar) {
214                         /* Initial view, create the main bar */
215                         main_bar = make_shared<MainBar>(session, this, tv);
216                         dock_main->addToolBar(main_bar.get());
217                         session.set_main_bar(main_bar);
218
219                         connect(main_bar.get(), SIGNAL(new_view(Session*)),
220                                 this, SLOT(on_new_view(Session*)));
221
222                         main_bar->action_view_show_cursors()->setChecked(tv->cursors_shown());
223
224                         /* For the main view we need to prevent the dock widget from
225                          * closing itself when its close button is clicked. This is
226                          * so we can confirm with the user first. Regular views don't
227                          * need this */
228                         close_btn->disconnect(SIGNAL(clicked()), dock, SLOT(close()));
229                 } else {
230                         /* Additional view, create a standard bar */
231                         pv::views::trace::StandardBar *standard_bar =
232                                 new pv::views::trace::StandardBar(session, this, tv);
233                         dock_main->addToolBar(standard_bar);
234
235                         standard_bar->action_view_show_cursors()->setChecked(tv->cursors_shown());
236                 }
237         }
238
239         return v;
240 }
241
242 void MainWindow::remove_view(shared_ptr<views::ViewBase> view)
243 {
244         for (shared_ptr<Session> session : sessions_) {
245                 if (!session->has_view(view))
246                         continue;
247
248                 // Find the dock the view is contained in and remove it
249                 for (auto entry : view_docks_)
250                         if (entry.second == view) {
251                                 // Remove the view from the session
252                                 session->deregister_view(view);
253
254                                 // Remove the view from its parent; otherwise, Qt will
255                                 // call deleteLater() on it, which causes a double free
256                                 // since the shared_ptr in view_docks_ doesn't know
257                                 // that Qt keeps a pointer to the view around
258                                 view->setParent(nullptr);
259
260                                 // Delete the view's dock widget and all widgets inside it
261                                 entry.first->deleteLater();
262
263                                 // Remove the dock widget from the list and stop iterating
264                                 view_docks_.erase(entry.first);
265                                 break;
266                         }
267         }
268 }
269
270 shared_ptr<Session> MainWindow::add_session()
271 {
272         static int last_session_id = 1;
273         QString name = tr("Session %1").arg(last_session_id++);
274
275         shared_ptr<Session> session = make_shared<Session>(device_manager_, name);
276
277         connect(session.get(), SIGNAL(add_view(const QString&, views::ViewType, Session*)),
278                 this, SLOT(on_add_view(const QString&, views::ViewType, Session*)));
279         connect(session.get(), SIGNAL(name_changed()),
280                 this, SLOT(on_session_name_changed()));
281         session_state_mapper_.setMapping(session.get(), session.get());
282         connect(session.get(), SIGNAL(capture_state_changed(int)),
283                 &session_state_mapper_, SLOT(map()));
284
285         sessions_.push_back(session);
286
287         QMainWindow *window = new QMainWindow();
288         window->setWindowFlags(Qt::Widget);  // Remove Qt::Window flag
289         session_windows_[session] = window;
290
291         int index = session_selector_.addTab(window, name);
292         session_selector_.setCurrentIndex(index);
293         last_focused_session_ = session;
294
295         window->setDockNestingEnabled(true);
296
297         shared_ptr<views::ViewBase> main_view =
298                 add_view(name, views::ViewTypeTrace, *session);
299
300         return session;
301 }
302
303 void MainWindow::remove_session(shared_ptr<Session> session)
304 {
305         int h = new_session_button_->height();
306
307         for (shared_ptr<views::ViewBase> view : session->views())
308                 remove_view(view);
309
310         QMainWindow *window = session_windows_.at(session);
311         session_selector_.removeTab(session_selector_.indexOf(window));
312
313         session_windows_.erase(session);
314
315         if (last_focused_session_ == session)
316                 last_focused_session_.reset();
317
318         sessions_.remove_if([&](shared_ptr<Session> s) {
319                 return s == session; });
320
321         if (sessions_.empty()) {
322                 // When there are no more tabs, the height of the QTabWidget
323                 // drops to zero. We must prevent this to keep the static
324                 // widgets visible
325                 for (QWidget *w : static_tab_widget_->findChildren<QWidget*>())
326                         w->setMinimumHeight(h);
327
328                 int margin = static_tab_widget_->layout()->contentsMargins().bottom();
329                 static_tab_widget_->setMinimumHeight(h + 2 * margin);
330                 session_selector_.setMinimumHeight(h + 2 * margin);
331
332                 // Update the window title if there is no view left to
333                 // generate focus change events
334                 setWindowTitle(WindowTitle);
335         }
336 }
337
338 void MainWindow::setup_ui()
339 {
340         setObjectName(QString::fromUtf8("MainWindow"));
341
342         setCentralWidget(&session_selector_);
343
344         // Set the window icon
345         QIcon icon;
346         icon.addFile(QString(":/icons/sigrok-logo-notext.png"));
347         setWindowIcon(icon);
348
349         view_sticky_scrolling_shortcut_ = new QShortcut(QKeySequence(Qt::Key_S), this, SLOT(on_view_sticky_scrolling_shortcut()));
350         view_sticky_scrolling_shortcut_->setAutoRepeat(false);
351
352         view_show_sampling_points_shortcut_ = new QShortcut(QKeySequence(Qt::Key_Period), this, SLOT(on_view_show_sampling_points_shortcut()));
353         view_show_sampling_points_shortcut_->setAutoRepeat(false);
354
355         view_show_analog_minor_grid_shortcut_ = new QShortcut(QKeySequence(Qt::Key_G), this, SLOT(on_view_show_analog_minor_grid_shortcut()));
356         view_show_analog_minor_grid_shortcut_->setAutoRepeat(false);
357
358         view_coloured_bg_shortcut_ = new QShortcut(QKeySequence(Qt::Key_B), this, SLOT(on_view_coloured_bg_shortcut()));
359         view_coloured_bg_shortcut_->setAutoRepeat(false);
360
361         // Set up the tab area
362         new_session_button_ = new QToolButton();
363         new_session_button_->setIcon(QIcon::fromTheme("document-new",
364                 QIcon(":/icons/document-new.png")));
365         new_session_button_->setToolTip(tr("Create New Session"));
366         new_session_button_->setAutoRaise(true);
367
368         run_stop_button_ = new QToolButton();
369         run_stop_button_->setAutoRaise(true);
370         run_stop_button_->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
371         run_stop_button_->setToolTip(tr("Start/Stop Acquisition"));
372
373         run_stop_shortcut_ = new QShortcut(QKeySequence(Qt::Key_Space), run_stop_button_, SLOT(click()));
374         run_stop_shortcut_->setAutoRepeat(false);
375
376         settings_button_ = new QToolButton();
377         settings_button_->setIcon(QIcon::fromTheme("configure",
378                 QIcon(":/icons/configure.png")));
379         settings_button_->setToolTip(tr("Settings"));
380         settings_button_->setAutoRaise(true);
381
382         QFrame *separator1 = new QFrame();
383         separator1->setFrameStyle(QFrame::VLine | QFrame::Raised);
384         QFrame *separator2 = new QFrame();
385         separator2->setFrameStyle(QFrame::VLine | QFrame::Raised);
386
387         QHBoxLayout* layout = new QHBoxLayout();
388         layout->setContentsMargins(2, 2, 2, 2);
389         layout->addWidget(new_session_button_);
390         layout->addWidget(separator1);
391         layout->addWidget(run_stop_button_);
392         layout->addWidget(separator2);
393         layout->addWidget(settings_button_);
394
395         static_tab_widget_ = new QWidget();
396         static_tab_widget_->setLayout(layout);
397
398         session_selector_.setCornerWidget(static_tab_widget_, Qt::TopLeftCorner);
399         session_selector_.setTabsClosable(true);
400
401         close_application_shortcut_ = new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_Q), this, SLOT(close()));
402         close_application_shortcut_->setAutoRepeat(false);
403
404         close_current_tab_shortcut_ = new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_W), this, SLOT(on_close_current_tab()));
405
406         connect(new_session_button_, SIGNAL(clicked(bool)),
407                 this, SLOT(on_new_session_clicked()));
408         connect(run_stop_button_, SIGNAL(clicked(bool)),
409                 this, SLOT(on_run_stop_clicked()));
410         connect(&session_state_mapper_, SIGNAL(mapped(QObject*)),
411                 this, SLOT(on_capture_state_changed(QObject*)));
412         connect(settings_button_, SIGNAL(clicked(bool)),
413                 this, SLOT(on_settings_clicked()));
414
415         connect(&session_selector_, SIGNAL(tabCloseRequested(int)),
416                 this, SLOT(on_tab_close_requested(int)));
417         connect(&session_selector_, SIGNAL(currentChanged(int)),
418                 this, SLOT(on_tab_changed(int)));
419
420
421         connect(static_cast<QApplication *>(QCoreApplication::instance()),
422                 SIGNAL(focusChanged(QWidget*, QWidget*)),
423                 this, SLOT(on_focus_changed()));
424 }
425
426 void MainWindow::save_ui_settings()
427 {
428         QSettings settings;
429         int id = 0;
430
431         settings.beginGroup("MainWindow");
432         settings.setValue("state", saveState());
433         settings.setValue("geometry", saveGeometry());
434         settings.endGroup();
435
436         for (shared_ptr<Session> session : sessions_) {
437                 // Ignore sessions using the demo device or no device at all
438                 if (session->device()) {
439                         shared_ptr<devices::HardwareDevice> device =
440                                 dynamic_pointer_cast< devices::HardwareDevice >
441                                 (session->device());
442
443                         if (device &&
444                                 device->hardware_device()->driver()->name() == "demo")
445                                 continue;
446
447                         settings.beginGroup("Session" + QString::number(id++));
448                         settings.remove("");  // Remove all keys in this group
449                         session->save_settings(settings);
450                         settings.endGroup();
451                 }
452         }
453
454         settings.setValue("sessions", id);
455 }
456
457 void MainWindow::restore_ui_settings()
458 {
459         QSettings settings;
460         int i, session_count;
461
462         settings.beginGroup("MainWindow");
463
464         if (settings.contains("geometry")) {
465                 restoreGeometry(settings.value("geometry").toByteArray());
466                 restoreState(settings.value("state").toByteArray());
467         } else
468                 resize(1000, 720);
469
470         settings.endGroup();
471
472         session_count = settings.value("sessions", 0).toInt();
473
474         for (i = 0; i < session_count; i++) {
475                 settings.beginGroup("Session" + QString::number(i));
476                 shared_ptr<Session> session = add_session();
477                 session->restore_settings(settings);
478                 settings.endGroup();
479         }
480 }
481
482 shared_ptr<Session> MainWindow::get_tab_session(int index) const
483 {
484         // Find the session that belongs to the tab's main window
485         for (auto entry : session_windows_)
486                 if (entry.second == session_selector_.widget(index))
487                         return entry.first;
488
489         return nullptr;
490 }
491
492 void MainWindow::closeEvent(QCloseEvent *event)
493 {
494         bool data_saved = true;
495
496         for (auto entry : session_windows_)
497                 if (!entry.first->data_saved())
498                         data_saved = false;
499
500         if (!data_saved && (QMessageBox::question(this, tr("Confirmation"),
501                 tr("There is unsaved data. Close anyway?"),
502                 QMessageBox::Yes | QMessageBox::No) == QMessageBox::No)) {
503                 event->ignore();
504         } else {
505                 save_ui_settings();
506                 event->accept();
507         }
508 }
509
510 QMenu* MainWindow::createPopupMenu()
511 {
512         return nullptr;
513 }
514
515 bool MainWindow::restoreState(const QByteArray &state, int version)
516 {
517         (void)state;
518         (void)version;
519
520         // Do nothing. We don't want Qt to handle this, or else it
521         // will try to restore all the dock widgets and create havoc.
522
523         return false;
524 }
525
526 void MainWindow::session_error(const QString text, const QString info_text)
527 {
528         QMetaObject::invokeMethod(this, "show_session_error",
529                 Qt::QueuedConnection, Q_ARG(QString, text),
530                 Q_ARG(QString, info_text));
531 }
532
533 void MainWindow::show_session_error(const QString text, const QString info_text)
534 {
535         QMessageBox msg(this);
536         msg.setText(text);
537         msg.setInformativeText(info_text);
538         msg.setStandardButtons(QMessageBox::Ok);
539         msg.setIcon(QMessageBox::Warning);
540         msg.exec();
541 }
542
543 void MainWindow::on_add_view(const QString &title, views::ViewType type,
544         Session *session)
545 {
546         // We get a pointer and need a reference
547         for (shared_ptr<Session> s : sessions_)
548                 if (s.get() == session)
549                         add_view(title, type, *s);
550 }
551
552 void MainWindow::on_focus_changed()
553 {
554         shared_ptr<views::ViewBase> view = get_active_view();
555
556         if (view) {
557                 for (shared_ptr<Session> session : sessions_) {
558                         if (session->has_view(view)) {
559                                 if (session != last_focused_session_) {
560                                         // Activate correct tab if necessary
561                                         shared_ptr<Session> tab_session = get_tab_session(
562                                                 session_selector_.currentIndex());
563                                         if (tab_session != session)
564                                                 session_selector_.setCurrentWidget(
565                                                         session_windows_.at(session));
566
567                                         on_focused_session_changed(session);
568                                 }
569
570                                 break;
571                         }
572                 }
573         }
574
575         if (sessions_.empty())
576                 setWindowTitle(WindowTitle);
577 }
578
579 void MainWindow::on_focused_session_changed(shared_ptr<Session> session)
580 {
581         last_focused_session_ = session;
582
583         setWindowTitle(session->name() + " - " + WindowTitle);
584
585         // Update the state of the run/stop button, too
586         on_capture_state_changed(session.get());
587 }
588
589 void MainWindow::on_new_session_clicked()
590 {
591         add_session();
592 }
593
594 void MainWindow::on_run_stop_clicked()
595 {
596         shared_ptr<Session> session = last_focused_session_;
597
598         if (!session)
599                 return;
600
601         switch (session->get_capture_state()) {
602         case Session::Stopped:
603                 session->start_capture([&](QString message) {
604                         session_error("Capture failed", message); });
605                 break;
606         case Session::AwaitingTrigger:
607         case Session::Running:
608                 session->stop_capture();
609                 break;
610         }
611 }
612
613 void MainWindow::on_settings_clicked()
614 {
615         dialogs::Settings dlg(device_manager_);
616         dlg.exec();
617 }
618
619 void MainWindow::on_session_name_changed()
620 {
621         // Update the corresponding dock widget's name(s)
622         Session *session = qobject_cast<Session*>(QObject::sender());
623         assert(session);
624
625         for (shared_ptr<views::ViewBase> view : session->views()) {
626                 // Get the dock that contains the view
627                 for (auto entry : view_docks_)
628                         if (entry.second == view) {
629                                 entry.first->setObjectName(session->name());
630                                 entry.first->setWindowTitle(session->name());
631                         }
632         }
633
634         // Update the tab widget by finding the main window and the tab from that
635         for (auto entry : session_windows_)
636                 if (entry.first.get() == session) {
637                         QMainWindow *window = entry.second;
638                         const int index = session_selector_.indexOf(window);
639                         session_selector_.setTabText(index, session->name());
640                 }
641
642         // Refresh window title if the affected session has focus
643         if (session == last_focused_session_.get())
644                 setWindowTitle(session->name() + " - " + WindowTitle);
645 }
646
647 void MainWindow::on_capture_state_changed(QObject *obj)
648 {
649         Session *caller = qobject_cast<Session*>(obj);
650
651         // Ignore if caller is not the currently focused session
652         // unless there is only one session
653         if ((sessions_.size() > 1) && (caller != last_focused_session_.get()))
654                 return;
655
656         int state = caller->get_capture_state();
657
658         const QIcon *icons[] = {&icon_grey_, &icon_red_, &icon_green_};
659         run_stop_button_->setIcon(*icons[state]);
660         run_stop_button_->setText((state == pv::Session::Stopped) ?
661                 tr("Run") : tr("Stop"));
662 }
663
664 void MainWindow::on_new_view(Session *session)
665 {
666         // We get a pointer and need a reference
667         for (shared_ptr<Session> s : sessions_)
668                 if (s.get() == session)
669                         add_view(session->name(), views::ViewTypeTrace, *s);
670 }
671
672 void MainWindow::on_view_close_clicked()
673 {
674         // Find the dock widget that contains the close button that was clicked
675         QObject *w = QObject::sender();
676         QDockWidget *dock = nullptr;
677
678         while (w) {
679             dock = qobject_cast<QDockWidget*>(w);
680             if (dock)
681                 break;
682             w = w->parent();
683         }
684
685         // Get the view contained in the dock widget
686         shared_ptr<views::ViewBase> view;
687
688         for (auto entry : view_docks_)
689                 if (entry.first == dock)
690                         view = entry.second;
691
692         // Deregister the view
693         for (shared_ptr<Session> session : sessions_) {
694                 if (!session->has_view(view))
695                         continue;
696
697                 // Also destroy the entire session if its main view is closing...
698                 if (view == session->main_view()) {
699                         // ...but only if data is saved or the user confirms closing
700                         if (session->data_saved() || (QMessageBox::question(this, tr("Confirmation"),
701                                 tr("This session contains unsaved data. Close it anyway?"),
702                                 QMessageBox::Yes | QMessageBox::No) == QMessageBox::Yes))
703                                 remove_session(session);
704                         break;
705                 } else
706                         // All other views can be closed at any time as no data will be lost
707                         remove_view(view);
708         }
709 }
710
711 void MainWindow::on_tab_changed(int index)
712 {
713         shared_ptr<Session> session = get_tab_session(index);
714
715         if (session)
716                 on_focused_session_changed(session);
717 }
718
719 void MainWindow::on_tab_close_requested(int index)
720 {
721         shared_ptr<Session> session = get_tab_session(index);
722
723         assert(session);
724
725         if (session->data_saved() || (QMessageBox::question(this, tr("Confirmation"),
726                 tr("This session contains unsaved data. Close it anyway?"),
727                 QMessageBox::Yes | QMessageBox::No) == QMessageBox::Yes))
728                 remove_session(session);
729 }
730
731 void MainWindow::on_view_coloured_bg_shortcut()
732 {
733         GlobalSettings settings;
734
735         bool state = settings.value(GlobalSettings::Key_View_ColouredBG).toBool();
736         settings.setValue(GlobalSettings::Key_View_ColouredBG, !state);
737 }
738
739 void MainWindow::on_view_sticky_scrolling_shortcut()
740 {
741         GlobalSettings settings;
742
743         bool state = settings.value(GlobalSettings::Key_View_StickyScrolling).toBool();
744         settings.setValue(GlobalSettings::Key_View_StickyScrolling, !state);
745 }
746
747 void MainWindow::on_view_show_sampling_points_shortcut()
748 {
749         GlobalSettings settings;
750
751         bool state = settings.value(GlobalSettings::Key_View_ShowSamplingPoints).toBool();
752         settings.setValue(GlobalSettings::Key_View_ShowSamplingPoints, !state);
753 }
754
755 void MainWindow::on_view_show_analog_minor_grid_shortcut()
756 {
757         GlobalSettings settings;
758
759         bool state = settings.value(GlobalSettings::Key_View_ShowAnalogMinorGrid).toBool();
760         settings.setValue(GlobalSettings::Key_View_ShowAnalogMinorGrid, !state);
761 }
762
763 void MainWindow::on_settingViewColouredBg_changed(const QVariant new_value)
764 {
765         bool state = new_value.toBool();
766
767         for (auto entry : view_docks_) {
768                 shared_ptr<views::ViewBase> viewbase = entry.second;
769
770                 // Only trace views have this setting
771                 views::TraceView::View* view =
772                                 qobject_cast<views::TraceView::View*>(viewbase.get());
773                 if (view)
774                         view->enable_coloured_bg(state);
775         }
776 }
777
778 void MainWindow::on_settingViewShowSamplingPoints_changed(const QVariant new_value)
779 {
780         bool state = new_value.toBool();
781
782         for (auto entry : view_docks_) {
783                 shared_ptr<views::ViewBase> viewbase = entry.second;
784
785                 // Only trace views have this setting
786                 views::TraceView::View* view =
787                                 qobject_cast<views::TraceView::View*>(viewbase.get());
788                 if (view)
789                         view->enable_show_sampling_points(state);
790         }
791 }
792
793 void MainWindow::on_settingViewShowAnalogMinorGrid_changed(const QVariant new_value)
794 {
795         bool state = new_value.toBool();
796
797         for (auto entry : view_docks_) {
798                 shared_ptr<views::ViewBase> viewbase = entry.second;
799
800                 // Only trace views have this setting
801                 views::TraceView::View* view =
802                                 qobject_cast<views::TraceView::View*>(viewbase.get());
803                 if (view)
804                         view->enable_show_analog_minor_grid(state);
805         }
806 }
807
808 void MainWindow::on_close_current_tab()
809 {
810         int tab = session_selector_.currentIndex();
811
812         on_tab_close_requested(tab);
813 }
814
815 } // namespace pv