Sonic Lineup

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

/*

    Vect

    An experimental audio player for plural recordings of a work

    Centre for Digital Music, Queen Mary, University of London.

    This file copyright 2006-2019 Chris Cannam and QMUL.

    This program is free software; you can redistribute it and/or

    modify it under the terms of the GNU General Public License as

    published by the Free Software Foundation; either version 2 of the

    License, or (at your option) any later version.  See the file

    COPYING included with this distribution for more information.

*/

#include "../version.h"

#include "MainWindow.h"

#include "framework/Document.h"

#include "framework/VersionTester.h"

#include "PreferencesDialog.h"

#include "NetworkPermissionTester.h"

#include "IntroDialog.h"

#include "view/Pane.h"

#include "view/PaneStack.h"

#include "data/model/WaveFileModel.h"

#include "data/model/SparseOneDimensionalModel.h"

#include "data/model/AlignmentModel.h"

#include "data/model/SparseOneDimensionalModel.h"

#include "base/StorageAdviser.h"

#include "base/Exceptions.h"

#include "base/TempDirectory.h"

#include "base/RecordDirectory.h"

#include "view/ViewManager.h"

#include "base/Preferences.h"

#include "layer/WaveformLayer.h"

#include "layer/TimeRulerLayer.h"

#include "layer/TimeInstantLayer.h"

#include "layer/TimeValueLayer.h"

#include "layer/Colour3DPlotLayer.h"

#include "layer/SliceLayer.h"

#include "layer/SliceableLayer.h"

#include "layer/SpectrogramLayer.h"

#include "view/Overview.h"

#include "widgets/PropertyBox.h"

#include "widgets/PropertyStack.h"

#include "widgets/AudioDial.h"

#include "widgets/LevelPanWidget.h"

#include "widgets/LevelPanToolButton.h"

#include "widgets/IconLoader.h"

#include "widgets/LayerTree.h"

#include "widgets/ListInputDialog.h"

#include "widgets/SubdividingMenu.h"

#include "widgets/NotifyingPushButton.h"

#include "widgets/KeyReference.h"

#include "audio/AudioCallbackPlaySource.h"

#include "audio/AudioCallbackRecordTarget.h"

#include "audio/PlaySpeedRangeMapper.h"

#include "data/fileio/DataFileReaderFactory.h"

#include "data/fileio/PlaylistFileReader.h"

#include "data/fileio/WavFileWriter.h"

#include "data/fileio/CSVFileWriter.h"

#include "data/fileio/BZipFileDevice.h"

#include "data/fileio/FileSource.h"

#include "base/RecentFiles.h"

#include "transform/TransformFactory.h"

#include "transform/ModelTransformerFactory.h"

#include "base/PlayParameterRepository.h"

#include "base/XmlExportable.h"

#include "widgets/CommandHistory.h"

#include "base/Profiler.h"

#include "base/Clipboard.h"

#include "base/UnitDatabase.h"

#include "layer/ColourDatabase.h"

#include "data/osc/OSCQueue.h"

//!!!

#include "data/model/AggregateWaveModel.h"

// For version information

#include "vamp/vamp.h"

#include "vamp-sdk/PluginBase.h"

#include "plugin/api/ladspa.h"

#include "plugin/api/dssi.h"

#include <bqaudioio/SystemPlaybackTarget.h>

#include <bqaudioio/SystemAudioIO.h>

#include <QApplication>

#include <QMessageBox>

#include <QGridLayout>

#include <QLabel>

#include <QAction>

#include <QMenuBar>

#include <QToolBar>

#include <QToolButton>

#include <QButtonGroup>

#include <QInputDialog>

#include <QStatusBar>

#include <QTreeView>

#include <QFile>

#include <QFileInfo>

#include <QDir>

#include <QTextStream>

#include <QProcess>

#include <QShortcut>

#include <QSettings>

#include <QDateTime>

#include <QProcess>

#include <QCheckBox>

#include <QRegExp>

#include <QScrollArea>

#include <QCloseEvent>

#include <QDialogButtonBox>

#include <QTextEdit>

#include <iostream>

#include <cstdio>

#include <errno.h>

using std::cerr;

using std::endl;

using std::vector;

using std::map;

using std::set;

using std::pair;

MainWindow::MainWindow(SoundOptions options) :

    MainWindowBase(options),

    m_mainMenusCreated(false),

    m_playbackMenu(0),

    m_recentSessionsMenu(0),

    m_deleteSelectedAction(0),

    m_ffwdAction(0),

    m_rwdAction(0),

    m_recentSessions("RecentSessions", 20),

    m_exiting(false),

    m_preferencesDialog(0),

    m_layerTreeView(0),

    m_keyReference(new KeyReference()),

    m_displayMode(OutlineWaveformMode),

    m_salientCalculating(false),

    m_salientColour(0),

    m_sessionState(NoSession)

{

    setWindowTitle(QApplication::applicationName());

    setUnifiedTitleAndToolBarOnMac(true);

    UnitDatabase *udb = UnitDatabase::getInstance();

    udb->registerUnit("Hz");

    udb->registerUnit("dB");

    udb->registerUnit("s");

    ColourDatabase *cdb = ColourDatabase::getInstance();

    cdb->setUseDarkBackground(cdb->addColour(Qt::white, tr("White")), true);

    cdb->setUseDarkBackground(cdb->addColour(QColor(30, 150, 255), tr("Bright Blue")), true);

    cdb->setUseDarkBackground(cdb->addColour(Qt::red, tr("Bright Red")), true);

    cdb->setUseDarkBackground(cdb->addColour(Qt::green, tr("Bright Green")), true);

    cdb->setUseDarkBackground(cdb->addColour(QColor(255, 188, 80), tr("Bright Orange")), true);

    cdb->setUseDarkBackground(cdb->addColour(QColor(225, 74, 255), tr("Bright Purple")), true);

    cdb->setUseDarkBackground(cdb->addColour(Qt::yellow, tr("Bright Yellow")), true);

    Preferences::getInstance()->setResampleOnLoad(true);

    Preferences::getInstance()->setSpectrogramSmoothing

        (Preferences::SpectrogramInterpolated);

    Preferences::getInstance()->setSpectrogramXSmoothing

        (Preferences::SpectrogramXInterpolated);

    QSettings settings;

    settings.beginGroup("LayerDefaults");

    settings.setValue("spectrogram",

                      QString("<layer channel=\"-1\" windowSize=\"1024\" colourMap=\"White on Black\" windowHopLevel=\"2\"/>"));

    settings.setValue("melodicrange",

                      QString("<layer channel=\"-1\" gain=\"1\" normalizeVisibleArea=\"false\" columnNormalization=\"hybrid\" colourMap=\"Ice\" minFrequency=\"80\" maxFrequency=\"1500\" windowSize=\"8192\" windowOverlap=\"75\" binDisplay=\"0\" />"));

    settings.endGroup();

    settings.beginGroup("MainWindow");

    settings.setValue("showstatusbar", false);

    settings.endGroup();

    settings.beginGroup("IconLoader");

    settings.setValue("invert-icons-on-dark-background", true);

    settings.endGroup();

    settings.beginGroup("View");

    settings.setValue("showcancelbuttons", false);

    settings.endGroup();

    settings.beginGroup("Alignment");

    if (!settings.contains("align-pitch-aware")) {

        settings.setValue("align-pitch-aware", true);

    }

    settings.endGroup();

    m_viewManager->setAlignMode(true);

    m_viewManager->setPlaySoloMode(true);

    m_viewManager->setToolMode(ViewManager::NavigateMode);

    m_viewManager->setZoomWheelsEnabled(false);

    m_viewManager->setIlluminateLocalFeatures(false);

    m_viewManager->setShowWorkTitle(true);

    m_viewManager->setOpportunisticEditingEnabled(false);

    loadStyle();

    QFrame *mainFrame = new QFrame;

    QGridLayout *mainLayout = new QGridLayout;

    setCentralWidget(mainFrame);

    m_mainScroll = new QScrollArea(mainFrame);

    m_mainScroll->setWidgetResizable(true);

    m_mainScroll->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

    m_mainScroll->setFrameShape(QFrame::NoFrame);

    m_paneStack->setResizeMode(PaneStack::AutoResizeOnly);

    m_paneStack->setLayoutStyle(PaneStack::NoPropertyStacks);

    m_paneStack->setShowCloseButtonOnFirstPane(false);

    m_paneStack->setShowAlignmentViews(true);

    m_mainScroll->setWidget(m_paneStack);

    QFrame *bottomFrame = new QFrame(mainFrame);

    bottomFrame->setObjectName("BottomFrame");

    QGridLayout *bottomLayout = new QGridLayout;

    int bottomElementHeight = m_viewManager->scalePixelSize(45);

    if (bottomElementHeight < 40) bottomElementHeight = 40;

    int bottomButtonHeight = (bottomElementHeight * 3) / 4;

    QButtonGroup *bg = new QButtonGroup;

    IconLoader il;

    QFrame *buttonFrame = new QFrame(bottomFrame);

    QHBoxLayout *buttonLayout = new QHBoxLayout;

    buttonLayout->setSpacing(0);

    buttonLayout->setMargin(0);

    buttonFrame->setLayout(buttonLayout);

    QPushButton *button = new QPushButton;

    button->setIcon(il.load("waveform"));

    button->setText(tr("Outline waveform"));

    button->setCheckable(true);

    button->setChecked(true);

    button->setFixedHeight(bottomButtonHeight);

    bg->addButton(button);

    buttonLayout->addWidget(button);

    connect(button, SIGNAL(clicked()), this, SLOT(outlineWaveformModeSelected()));

    m_modeButtons[OutlineWaveformMode] = button;

    m_modeLayerNames[OutlineWaveformMode] = "Outline Waveform"; // not to be translated

    m_modeDisplayOrder.push_back(OutlineWaveformMode);

    button = new QPushButton;

    button->setIcon(il.load("waveform"));

    button->setText(tr("Waveform"));

    button->setCheckable(true);

    button->setChecked(false);

    button->setFixedHeight(bottomButtonHeight);

    bg->addButton(button);

    buttonLayout->addWidget(button);

    connect(button, SIGNAL(clicked()), this, SLOT(standardWaveformModeSelected()));

    m_modeButtons[WaveformMode] = button;

    m_modeLayerNames[WaveformMode] = "Waveform"; // not to be translated

    m_modeDisplayOrder.push_back(WaveformMode);

    button = new QPushButton;

    button->setIcon(il.load("colour3d"));

    button->setText(tr("Melodic spectrogram"));

    button->setCheckable(true);

    button->setChecked(false);

    button->setFixedHeight(bottomButtonHeight);

    bg->addButton(button);

    buttonLayout->addWidget(button);

    connect(button, SIGNAL(clicked()), this, SLOT(melodogramModeSelected()));

    m_modeButtons[MelodogramMode] = button;

    m_modeLayerNames[MelodogramMode] = "Melodogram"; // not to be translated

    m_modeDisplayOrder.push_back(MelodogramMode);

    button = new QPushButton;

    button->setIcon(il.load("colour3d"));

    button->setText(tr("Spectrogram"));

    button->setCheckable(true);

    button->setChecked(false);

    button->setFixedHeight(bottomButtonHeight);

    bg->addButton(button);

    buttonLayout->addWidget(button);

    connect(button, SIGNAL(clicked()), this, SLOT(spectrogramModeSelected()));

    m_modeButtons[SpectrogramMode] = button;

    m_modeLayerNames[SpectrogramMode] = "Spectrogram"; // not to be translated

    m_modeDisplayOrder.push_back(SpectrogramMode);

    button = new QPushButton;

    button->setIcon(il.load("values"));

    button->setText(tr("Sung pitch"));

    button->setCheckable(true);

    button->setChecked(false);

    button->setFixedHeight(bottomButtonHeight);

    bg->addButton(button);

    buttonLayout->addWidget(button);

    connect(button, SIGNAL(clicked()), this, SLOT(pitchModeSelected()));

    m_modeButtons[PitchMode] = button;

    m_modeLayerNames[PitchMode] = "Pitch"; // not to be translated

    m_modeDisplayOrder.push_back(PitchMode);

    button = new QPushButton;

    button->setIcon(il.load("colour3d"));

    button->setText(tr("Key"));

    button->setCheckable(true);

    button->setChecked(false);

    button->setFixedHeight(bottomButtonHeight);

    bg->addButton(button);

    buttonLayout->addWidget(button);

    connect(button, SIGNAL(clicked()), this, SLOT(keyModeSelected()));

    m_modeButtons[KeyMode] = button;

    m_modeLayerNames[KeyMode] = "Key"; // not to be translated

    m_modeDisplayOrder.push_back(KeyMode);

    button = new QPushButton;

    button->setIcon(il.load("colour3d"));

    button->setText(tr("Stereo azimuth"));

    button->setCheckable(true);

    button->setChecked(false);

    button->setFixedHeight(bottomButtonHeight);

    bg->addButton(button);

    buttonLayout->addWidget(button);

    connect(button, SIGNAL(clicked()), this, SLOT(azimuthModeSelected()));

    m_modeButtons[AzimuthMode] = button;

    m_modeLayerNames[AzimuthMode] = "Azimuth"; // not to be translated

    m_modeDisplayOrder.push_back(AzimuthMode);

    m_playSpeed = new AudioDial(bottomFrame);

    m_playSpeed->setMinimum(0);

    m_playSpeed->setMaximum(120);

    m_playSpeed->setValue(60);

    m_playSpeed->setFixedWidth(int(bottomElementHeight * 0.9));

    m_playSpeed->setFixedHeight(int(bottomElementHeight * 0.9));

    m_playSpeed->setNotchesVisible(true);

    m_playSpeed->setPageStep(10);

    m_playSpeed->setObjectName(tr("Playback Speed"));

    m_playSpeed->setRangeMapper(new PlaySpeedRangeMapper);

    m_playSpeed->setDefaultValue(60);

    m_playSpeed->setShowToolTip(true);

    connect(m_playSpeed, SIGNAL(valueChanged(int)),

            this, SLOT(playSpeedChanged(int)));

    connect(m_playSpeed, SIGNAL(mouseEntered()), this, SLOT(mouseEnteredWidget()));

    connect(m_playSpeed, SIGNAL(mouseLeft()), this, SLOT(mouseLeftWidget()));

    m_mainLevelPan = new LevelPanToolButton(bottomFrame);

    connect(m_mainLevelPan, SIGNAL(mouseEntered()), this, SLOT(mouseEnteredWidget()));

    connect(m_mainLevelPan, SIGNAL(mouseLeft()), this, SLOT(mouseLeftWidget()));

    m_mainLevelPan->setFixedHeight(bottomElementHeight);

    m_mainLevelPan->setFixedWidth(bottomElementHeight);

    m_mainLevelPan->setImageSize((bottomElementHeight * 3) / 4);

    m_mainLevelPan->setBigImageSize(bottomElementHeight * 3);

    int spacing = m_viewManager->scalePixelSize(4);

    bottomLayout->setSpacing(spacing);

    bottomLayout->setMargin(spacing);

    bottomLayout->addWidget(buttonFrame, 0, 0);

    bottomLayout->setColumnStretch(1, 10);

    bottomLayout->addWidget(m_playSpeed, 0, 2);

    bottomLayout->addWidget(m_mainLevelPan, 0, 3);

    bottomFrame->setLayout(bottomLayout);

    mainLayout->setSpacing(spacing);

    mainLayout->setMargin(spacing);

    mainLayout->addWidget(m_mainScroll, 0, 0);

    mainLayout->addWidget(bottomFrame, 1, 0);

    mainFrame->setLayout(mainLayout);

    setupMenus();

    setupToolbars();

    setupHelpMenu();

    statusBar()->hide();

    setIconsVisibleInMenus(false);

    finaliseMenus();

    NetworkPermissionTester tester;

    bool networkPermission = tester.havePermission();

    if (networkPermission) {

        m_versionTester = new VersionTester

            ("sonicvisualiser.org", "latest-vect-version.txt", VECT_VERSION);

        connect(m_versionTester, SIGNAL(newerVersionAvailable(QString)),

                this, SLOT(newerVersionAvailable(QString)));

    } else {

        m_versionTester = 0;

    }

    reopenLastSession();

    QTimer::singleShot(400, this, SLOT(introDialog()));

//    QTimer::singleShot(500, this, SLOT(betaReleaseWarning()));

}

MainWindow::~MainWindow()

{

    delete m_keyReference;

    delete m_preferencesDialog;

    delete m_layerTreeView;

    Profiles::getInstance()->dump();

}

void

MainWindow::setupMenus()

{

    if (!m_mainMenusCreated) {

#ifdef Q_OS_LINUX

        // In Ubuntu 14.04 the window's menu bar goes missing entirely

        // if the user is running any desktop environment other than Unity

        // (in which the faux single-menubar appears). The user has a

        // workaround, to remove the appmenu-qt5 package, but that is

        // awkward and the problem is so severe that it merits disabling

        // the system menubar integration altogether. Like this:

        menuBar()->setNativeMenuBar(false);

#endif

    }

    setupFileMenu();

    setupViewMenu();

    m_mainMenusCreated = true;

}

void

MainWindow::goFullScreen()

{

    if (!m_viewManager) return;

    if (m_viewManager->getZoomWheelsEnabled()) {

        // The wheels seem to end up in the wrong place in full-screen mode

        toggleZoomWheels();

    }

    QWidget *ps = m_mainScroll->takeWidget();

    ps->setParent(0);

    QShortcut *sc;

    sc = new QShortcut(QKeySequence("Esc"), ps);

    connect(sc, SIGNAL(activated()), this, SLOT(endFullScreen()));

    sc = new QShortcut(QKeySequence("F11"), ps);

    connect(sc, SIGNAL(activated()), this, SLOT(endFullScreen()));

    QAction *acts[] = {

        m_playAction, m_zoomInAction, m_zoomOutAction, m_zoomFitAction,

        m_scrollLeftAction, m_scrollRightAction,

        m_selectPreviousPaneAction, m_selectNextPaneAction,

        m_selectPreviousDisplayModeAction, m_selectNextDisplayModeAction

    };

    for (int i = 0; i < int(sizeof(acts)/sizeof(acts[0])); ++i) {

        sc = new QShortcut(acts[i]->shortcut(), ps);

        connect(sc, SIGNAL(activated()), acts[i], SLOT(trigger()));

    }

    ps->showFullScreen();

}

void

MainWindow::endFullScreen()

{

    // these were only created in goFullScreen:

    QObjectList cl = m_paneStack->children();

    foreach (QObject *o, cl) {

        QShortcut *sc = qobject_cast<QShortcut *>(o);

        if (sc) delete sc;

    }

    m_paneStack->showNormal();

    m_mainScroll->setWidget(m_paneStack);

}

void

MainWindow::setupFileMenu()

{

    if (m_mainMenusCreated) return;

    QMenu *menu = menuBar()->addMenu(tr("&File"));

    menu->setTearOffEnabled(false);

    QToolBar *toolbar = addToolBar(tr("File Toolbar"));

    m_keyReference->setCategory(tr("File and Session Management"));

    IconLoader il;

    QIcon icon = il.load("filenew");

    QAction *action = new QAction(icon, tr("&Clear Session"), this);

    action->setShortcut(tr("Ctrl+N"));

    action->setStatusTip(tr("Abandon the current session and start a new one"));

    connect(action, SIGNAL(triggered()), this, SLOT(newSession()));

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

    toolbar->addAction(action);

    icon = il.load("fileopen");

    action = new QAction(icon, tr("&Add Files..."), this);

    action->setShortcut(tr("Ctrl+O"));

    action->setStatusTip(tr("Add one or more audio files"));

    connect(action, SIGNAL(triggered()), this, SLOT(openFiles()));

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

    toolbar->addAction(action);

    action = new QAction(tr("Add Lo&cation..."), this);

    action->setShortcut(tr("Ctrl+Shift+O"));

    action->setStatusTip(tr("Add a file from a remote URL"));

    connect(action, SIGNAL(triggered()), this, SLOT(openLocation()));

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

    menu->addSeparator();

    action = new QAction(tr("Browse Recorded Audio"), this);

    action->setStatusTip(tr("Open the Recorded Audio folder in the system file browser"));

    connect(action, SIGNAL(triggered()), this, SLOT(browseRecordedAudio()));

    menu->addAction(action);

    menu->addSeparator();

    m_recentSessionsMenu = menu->addMenu(tr("&Recent Sessions"));

    m_recentSessionsMenu->setTearOffEnabled(false);

    setupRecentSessionsMenu();

    connect(&m_recentSessions, SIGNAL(recentChanged()),

            this, SLOT(setupRecentSessionsMenu()));

    /*

    menu->addSeparator();

    action = new QAction(tr("&Preferences..."), this);

    action->setStatusTip(tr("Adjust the application preferences"));

    connect(action, SIGNAL(triggered()), this, SLOT(preferences()));

    menu->addAction(action);

    */

    menu->addSeparator();

    action = new QAction(il.load("exit"), tr("&Quit"), this);

    action->setShortcut(tr("Ctrl+Q"));

    action->setStatusTip(tr("Exit Sonic Lineup"));

    connect(action, SIGNAL(triggered()), this, SLOT(close()));

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

}

void

MainWindow::setupViewMenu()

{

    if (m_mainMenusCreated) return;

    IconLoader il;

    QAction *action = 0;

    m_keyReference->setCategory(tr("Panning and Navigation"));

    QMenu *menu = menuBar()->addMenu(tr("&View"));

    menu->setTearOffEnabled(false);

    m_scrollLeftAction = new QAction(tr("Scroll &Left"), this);

    m_scrollLeftAction->setShortcut(tr("Left"));

    m_scrollLeftAction->setStatusTip(tr("Scroll the current pane to the left"));

    connect(m_scrollLeftAction, SIGNAL(triggered()), this, SLOT(scrollLeft()));

    connect(this, SIGNAL(canScroll(bool)), m_scrollLeftAction, SLOT(setEnabled(bool)));

    m_keyReference->registerShortcut(m_scrollLeftAction);

    menu->addAction(m_scrollLeftAction);

    m_scrollRightAction = new QAction(tr("Scroll &Right"), this);

    m_scrollRightAction->setShortcut(tr("Right"));

    m_scrollRightAction->setStatusTip(tr("Scroll the current pane to the right"));

    connect(m_scrollRightAction, SIGNAL(triggered()), this, SLOT(scrollRight()));

    connect(this, SIGNAL(canScroll(bool)), m_scrollRightAction, SLOT(setEnabled(bool)));

    m_keyReference->registerShortcut(m_scrollRightAction);

    menu->addAction(m_scrollRightAction);

    action = new QAction(tr("&Jump Left"), this);

    action->setShortcut(tr("Ctrl+Left"));

    action->setStatusTip(tr("Scroll the current pane a big step to the left"));

    connect(action, SIGNAL(triggered()), this, SLOT(jumpLeft()));

    connect(this, SIGNAL(canScroll(bool)), action, SLOT(setEnabled(bool)));

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

    action = new QAction(tr("J&ump Right"), this);

    action->setShortcut(tr("Ctrl+Right"));

    action->setStatusTip(tr("Scroll the current pane a big step to the right"));

    connect(action, SIGNAL(triggered()), this, SLOT(jumpRight()));

    connect(this, SIGNAL(canScroll(bool)), action, SLOT(setEnabled(bool)));

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

    menu->addSeparator();

    action = new QAction(tr("Switch to Previous Pane"), this);

    action->setShortcut(tr("["));

    action->setStatusTip(tr("Make the next pane up in the pane stack current"));

    connect(action, SIGNAL(triggered()), this, SLOT(previousPane()));

    connect(this, SIGNAL(canSelectPreviousPane(bool)), action, SLOT(setEnabled(bool)));

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

    m_selectPreviousPaneAction = action;

    action = new QAction(tr("Switch to Next Pane"), this);

    action->setShortcut(tr("]"));

    action->setStatusTip(tr("Make the next pane down in the pane stack current"));

    connect(action, SIGNAL(triggered()), this, SLOT(nextPane()));

    connect(this, SIGNAL(canSelectNextPane(bool)), action, SLOT(setEnabled(bool)));

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

    m_selectNextPaneAction = action;

    menu->addSeparator();

    action = new QAction(tr("Switch to Previous View Mode"), this);

    action->setShortcut(tr("{"));

    action->setStatusTip(tr("Make the next view mode current"));

    connect(action, SIGNAL(triggered()), this, SLOT(previousDisplayMode()));

    connect(this, SIGNAL(canSelectPreviousDisplayMode(bool)), action, SLOT(setEnabled(bool)));

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

    m_selectPreviousDisplayModeAction = action;

    action = new QAction(tr("Switch to Next View Mode"), this);

    action->setShortcut(tr("}"));

    action->setStatusTip(tr("Make the next view mode current"));

    connect(action, SIGNAL(triggered()), this, SLOT(nextDisplayMode()));

    connect(this, SIGNAL(canSelectNextDisplayMode(bool)), action, SLOT(setEnabled(bool)));

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

    m_selectNextDisplayModeAction = action;

    menu->addSeparator();

    m_keyReference->setCategory(tr("Zoom"));

    m_zoomInAction = new QAction(il.load("zoom-in"),

                                 tr("Zoom &In"), this);

    m_zoomInAction->setShortcut(tr("Up"));

    m_zoomInAction->setStatusTip(tr("Increase the zoom level"));

    connect(m_zoomInAction, SIGNAL(triggered()), this, SLOT(zoomIn()));

    connect(this, SIGNAL(canZoom(bool)), m_zoomInAction, SLOT(setEnabled(bool)));

    m_keyReference->registerShortcut(m_zoomInAction);

    menu->addAction(m_zoomInAction);

    m_zoomOutAction = new QAction(il.load("zoom-out"),

                                  tr("Zoom &Out"), this);

    m_zoomOutAction->setShortcut(tr("Down"));

    m_zoomOutAction->setStatusTip(tr("Decrease the zoom level"));

    connect(m_zoomOutAction, SIGNAL(triggered()), this, SLOT(zoomOut()));

    connect(this, SIGNAL(canZoom(bool)), m_zoomOutAction, SLOT(setEnabled(bool)));

    m_keyReference->registerShortcut(m_zoomOutAction);

    menu->addAction(m_zoomOutAction);

    action = new QAction(tr("Restore &Default Zoom"), this);

    action->setStatusTip(tr("Restore the zoom level to the default"));

    connect(action, SIGNAL(triggered()), this, SLOT(zoomDefault()));

    connect(this, SIGNAL(canZoom(bool)), action, SLOT(setEnabled(bool)));

    menu->addAction(action);

    m_zoomFitAction = new QAction(il.load("zoom-fit"),

                                  tr("Zoom to &Fit"), this);

    m_zoomFitAction->setShortcut(tr("F"));

    m_zoomFitAction->setStatusTip(tr("Zoom to show the whole file"));

    connect(m_zoomFitAction, SIGNAL(triggered()), this, SLOT(zoomToFit()));

    connect(this, SIGNAL(canZoom(bool)), m_zoomFitAction, SLOT(setEnabled(bool)));

    m_keyReference->registerShortcut(m_zoomFitAction);

    menu->addAction(m_zoomFitAction);

    menu->addSeparator();

    m_keyReference->setCategory(tr("Display Features"));

    action = new QAction(tr("Show &Centre Line"), this);

    action->setShortcut(tr("'"));

    action->setStatusTip(tr("Show or hide the centre line"));

    connect(action, SIGNAL(triggered()), this, SLOT(toggleCentreLine()));

    action->setCheckable(true);

    action->setChecked(true);

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

    action = new QAction(tr("Show Salient Feature Layers"), this);

    action->setShortcut(tr("#"));

    action->setStatusTip(tr("Show or hide all salient-feature layers"));

    connect(action, SIGNAL(triggered()), this, SLOT(toggleSalientFeatures()));

    action->setCheckable(true);

    action->setChecked(true);

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

    action = new QAction(tr("Show Vertical Scales"), this);

    action->setShortcut(tr("S"));

    action->setStatusTip(tr("Show or hide all vertical scales"));

    connect(action, SIGNAL(triggered()), this, SLOT(toggleVerticalScales()));

    action->setCheckable(true);

    action->setChecked(false);

    m_viewManager->setOverlayMode(ViewManager::NoOverlays);

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

    // We need this separator even if not adding the full-screen

    // option ourselves, as the Mac automatic full-screen entry

    // doesn't include a separator first

    menu->addSeparator();

#ifndef Q_OS_MAC

    // Only on non-Mac platforms -- on the Mac this interacts very

    // badly with the "native" full-screen mode

    action = new QAction(tr("Go Full-Screen"), this);

    action->setShortcut(tr("F11"));

    action->setStatusTip(tr("Expand the pane area to the whole screen"));

    connect(action, SIGNAL(triggered()), this, SLOT(goFullScreen()));

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

#endif

}

void

MainWindow::setupHelpMenu()

{

    QMenu *menu = menuBar()->addMenu(tr("&Help"));

    menu->setTearOffEnabled(false);

    m_keyReference->setCategory(tr("Help"));

    IconLoader il;

    QAction *action = new QAction(il.load("help"),

                                  tr("&Help Reference"), this); 

    action->setShortcut(tr("F1"));

    action->setStatusTip(tr("Open the reference manual")); 

    connect(action, SIGNAL(triggered()), this, SLOT(help()));

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

    action = new QAction(tr("&Key and Mouse Reference"), this);

    action->setShortcut(tr("F2"));

    action->setStatusTip(tr("Open a window showing the keystrokes you can use"));

    connect(action, SIGNAL(triggered()), this, SLOT(keyReference()));

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

    QString name = QApplication::applicationName();

    action = new QAction(tr("What's &New In This Release?"), this); 

    action->setStatusTip(tr("List the changes in this release (and every previous release) of %1").arg(name)); 

    connect(action, SIGNAL(triggered()), this, SLOT(whatsNew()));

    menu->addAction(action);

    action = new QAction(tr("&About %1").arg(name), this); 

    action->setStatusTip(tr("Show information about %1").arg(name)); 

    connect(action, SIGNAL(triggered()), this, SLOT(about()));

    menu->addAction(action);

}

void

MainWindow::setupRecentSessionsMenu()

{

    m_recentSessionsMenu->clear();

    vector<pair<QString, QString>> sessions = m_recentSessions.getRecentEntries();

    for (size_t i = 0; i < sessions.size(); ++i) {

        QString path = sessions[i].first;

        QString label = sessions[i].second;

        if (label == "") label = path;

        QAction *action = new QAction(label, this);

        action->setObjectName(path);

        connect(action, SIGNAL(triggered()), this, SLOT(openRecentSession()));

        if (i == 0) {

            action->setShortcut(tr("Ctrl+R"));

            m_keyReference->registerShortcut

                (tr("Re-open"),

                 action->shortcut().toString(),

                 tr("Re-open the current or most recently opened session"));

        }

        m_recentSessionsMenu->addAction(action);

    }

}

void

MainWindow::setupToolbars()

{

    m_keyReference->setCategory(tr("Playback and Transport Controls"));

    IconLoader il;

    QMenu *menu = m_playbackMenu = menuBar()->addMenu(tr("Play&back"));

    menu->setTearOffEnabled(false);

    QToolBar *toolbar = addToolBar(tr("Playback Toolbar"));

    QAction *rwdStartAction = toolbar->addAction(il.load("rewind-start"),

                                                 tr("Rewind to Start"));

    rwdStartAction->setShortcut(tr("Home"));

    rwdStartAction->setStatusTip(tr("Rewind to the start"));

    connect(rwdStartAction, SIGNAL(triggered()), this, SLOT(rewindStart()));

    connect(this, SIGNAL(canPlay(bool)), rwdStartAction, SLOT(setEnabled(bool)));

    QAction *m_rwdAction = toolbar->addAction(il.load("rewind"),

                                              tr("Rewind"));

    m_rwdAction->setShortcut(tr("PgUp"));

    m_rwdAction->setStatusTip(tr("Rewind to the previous time instant or time ruler notch"));

    connect(m_rwdAction, SIGNAL(triggered()), this, SLOT(rewind()));

    connect(this, SIGNAL(canRewind(bool)), m_rwdAction, SLOT(setEnabled(bool)));

    m_playAction = toolbar->addAction(il.load("playpause"),

                                      tr("Play / Pause"));

    m_playAction->setCheckable(true);

    m_playAction->setShortcut(tr("Space"));

    m_playAction->setStatusTip(tr("Start or stop playback from the current position"));

    connect(m_playAction, SIGNAL(triggered()), this, SLOT(play()));

    connect(m_playSource, SIGNAL(playStatusChanged(bool)),

            m_playAction, SLOT(setChecked(bool)));

    connect(this, SIGNAL(canPlay(bool)), m_playAction, SLOT(setEnabled(bool)));

    m_ffwdAction = toolbar->addAction(il.load("ffwd"),

                                      tr("Fast Forward"));

    m_ffwdAction->setShortcut(tr("PgDown"));

    m_ffwdAction->setStatusTip(tr("Fast-forward to the next time instant or time ruler notch"));

    connect(m_ffwdAction, SIGNAL(triggered()), this, SLOT(ffwd()));

    connect(this, SIGNAL(canFfwd(bool)), m_ffwdAction, SLOT(setEnabled(bool)));

    QAction *ffwdEndAction = toolbar->addAction(il.load("ffwd-end"),

                                                tr("Fast Forward to End"));

    ffwdEndAction->setShortcut(tr("End"));

    ffwdEndAction->setStatusTip(tr("Fast-forward to the end"));

    connect(ffwdEndAction, SIGNAL(triggered()), this, SLOT(ffwdEnd()));

    connect(this, SIGNAL(canPlay(bool)), ffwdEndAction, SLOT(setEnabled(bool)));

    QAction *recordAction = toolbar->addAction(il.load("record"),

                                               tr("Record"));

    recordAction->setCheckable(true);

    recordAction->setShortcut(tr("Ctrl+Space"));

    recordAction->setStatusTip(tr("Record a new audio file"));

    connect(recordAction, SIGNAL(triggered()), this, SLOT(record()));

    connect(m_recordTarget, SIGNAL(recordStatusChanged(bool)),

            recordAction, SLOT(setChecked(bool)));

    connect(this, SIGNAL(canRecord(bool)),

            recordAction, SLOT(setEnabled(bool)));

    m_keyReference->registerShortcut(m_playAction);

    m_keyReference->registerShortcut(m_rwdAction);

    m_keyReference->registerShortcut(m_ffwdAction);

    m_keyReference->registerShortcut(rwdStartAction);

    m_keyReference->registerShortcut(ffwdEndAction);

    m_keyReference->registerShortcut(recordAction);

    menu->addAction(m_playAction);

    menu->addSeparator();

    menu->addAction(m_rwdAction);

    menu->addAction(m_ffwdAction);

    menu->addSeparator();

    menu->addAction(rwdStartAction);

    menu->addAction(ffwdEndAction);

    menu->addSeparator();

    menu->addAction(recordAction);

    menu->addSeparator();

    QAction *fastAction = menu->addAction(tr("Speed Up"));

    fastAction->setShortcut(tr("Ctrl+PgUp"));

    fastAction->setStatusTip(tr("Time-stretch playback to speed it up without changing pitch"));

    connect(fastAction, SIGNAL(triggered()), this, SLOT(speedUpPlayback()));

    connect(this, SIGNAL(canSpeedUpPlayback(bool)), fastAction, SLOT(setEnabled(bool)));

    QAction *slowAction = menu->addAction(tr("Slow Down"));

    slowAction->setShortcut(tr("Ctrl+PgDown"));

    slowAction->setStatusTip(tr("Time-stretch playback to slow it down without changing pitch"));

    connect(slowAction, SIGNAL(triggered()), this, SLOT(slowDownPlayback()));

    connect(this, SIGNAL(canSlowDownPlayback(bool)), slowAction, SLOT(setEnabled(bool)));

    QAction *normalAction = menu->addAction(tr("Restore Normal Speed"));

    normalAction->setShortcut(tr("Ctrl+Home"));

    normalAction->setStatusTip(tr("Restore non-time-stretched playback"));

    connect(normalAction, SIGNAL(triggered()), this, SLOT(restoreNormalPlayback()));

    connect(this, SIGNAL(canChangePlaybackSpeed(bool)), normalAction, SLOT(setEnabled(bool)));

    m_keyReference->registerShortcut(fastAction);

    m_keyReference->registerShortcut(slowAction);

    m_keyReference->registerShortcut(normalAction);

    QAction *alAction = 0;

    alAction = toolbar->addAction(il.load("align"),

                                  tr("Align File Timelines"));

    alAction->setCheckable(true);

    alAction->setChecked(m_viewManager->getAlignMode());

    alAction->setStatusTip(tr("Treat multiple audio files as versions of the same work, and align their timelines"));

    connect(m_viewManager, SIGNAL(alignModeChanged(bool)),

            alAction, SLOT(setChecked(bool)));

    connect(alAction, SIGNAL(triggered()), this, SLOT(alignToggled()));

    QSettings settings;

    QAction *tdAction = 0;

    tdAction = new QAction(tr("Allow for Pitch Difference when Aligning"), this);

    tdAction->setCheckable(true);

    settings.beginGroup("Alignment");

    tdAction->setChecked(settings.value("align-pitch-aware", false).toBool());

    settings.endGroup();

    tdAction->setStatusTip(tr("Compare relative pitch content of audio files before aligning, in order to correctly align recordings of the same material at different tuning pitches"));

    connect(tdAction, SIGNAL(triggered()), this, SLOT(tuningDifferenceToggled()));

    menu->addSeparator();

    menu->addAction(alAction);

    menu->addAction(tdAction);

    Pane::registerShortcuts(*m_keyReference);

}

void

MainWindow::updateMenuStates()

{

    MainWindowBase::updateMenuStates();

    Pane *currentPane = 0;

    Layer *currentLayer = 0;

    if (m_paneStack) currentPane = m_paneStack->getCurrentPane();

    if (currentPane) currentLayer = currentPane->getSelectedLayer();

    bool haveCurrentPane =

        (currentPane != 0);

    bool haveCurrentLayer =

        (haveCurrentPane &&

         (currentLayer != 0));

    bool haveCurrentTimeInstantsLayer = 

        (haveCurrentLayer &&

         dynamic_cast<TimeInstantLayer *>(currentLayer));

    bool haveCurrentTimeValueLayer = 

        (haveCurrentLayer &&

         dynamic_cast<TimeValueLayer *>(currentLayer));

    emit canChangePlaybackSpeed(true);

    int v = m_playSpeed->value();

    emit canSpeedUpPlayback(v < m_playSpeed->maximum());

    emit canSlowDownPlayback(v > m_playSpeed->minimum());

    emit canSelectPreviousDisplayMode

        (!m_modeDisplayOrder.empty() &&

         (m_displayMode != m_modeDisplayOrder[0]));

    emit canSelectNextDisplayMode

        (!m_modeDisplayOrder.empty() &&

         (m_displayMode != m_modeDisplayOrder[m_modeDisplayOrder.size()-1]));

    if (m_ffwdAction && m_rwdAction) {

        if (haveCurrentTimeInstantsLayer) {

            m_ffwdAction->setText(tr("Fast Forward to Next Instant"));

            m_ffwdAction->setStatusTip(tr("Fast forward to the next time instant in the current layer"));

            m_rwdAction->setText(tr("Rewind to Previous Instant"));

            m_rwdAction->setStatusTip(tr("Rewind to the previous time instant in the current layer"));

        } else if (haveCurrentTimeValueLayer) {

            m_ffwdAction->setText(tr("Fast Forward to Next Point"));

            m_ffwdAction->setStatusTip(tr("Fast forward to the next point in the current layer"));

            m_rwdAction->setText(tr("Rewind to Previous Point"));

            m_rwdAction->setStatusTip(tr("Rewind to the previous point in the current layer"));

        } else {

            m_ffwdAction->setText(tr("Fast Forward"));

            m_ffwdAction->setStatusTip(tr("Fast forward"));

            m_rwdAction->setText(tr("Rewind"));

            m_rwdAction->setStatusTip(tr("Rewind"));

        }

    }

}

void

MainWindow::updateDescriptionLabel()

{

    // we don't actually have a description label

}

void

MainWindow::updateWindowTitle()

{

    QString title;

    QString sessionLabel = makeSessionLabel();

    if (sessionLabel != "") {

        title = tr("%1: %2")

            .arg(QApplication::applicationName())

            .arg(sessionLabel);

    } else {

        title = QApplication::applicationName();

    }

    setWindowTitle(title);

}

void

MainWindow::documentModified()

{

    MainWindowBase::documentModified();

}

void

MainWindow::documentRestored()

{

    MainWindowBase::documentRestored();

}

void

MainWindow::selectMainPane()

{

    if (m_paneStack && m_paneStack->getPaneCount() > 0) {

        m_paneStack->setCurrentPane(m_paneStack->getPane(0));

    }

}

void

MainWindow::browseRecordedAudio()

{

    QString path = RecordDirectory::getRecordContainerDirectory();

    if (path == "") path = RecordDirectory::getRecordDirectory();

    if (path == "") return;

    openLocalFolder(path);

}

void

MainWindow::newSession()

{

    cerr << "MainWindow::newSession" << endl;

    closeSession();

    createDocument();

    m_displayMode = OutlineWaveformMode;

    for (auto &bp : m_modeButtons) {

        bp.second->setChecked(false);

    }

    m_modeButtons[m_displayMode]->setChecked(true);

    // We need a pane, so that we have something to receive drop events

    Pane *pane = m_paneStack->addPane();

    connect(pane, SIGNAL(contextHelpChanged(const QString &)),

            this, SLOT(contextHelpChanged(const QString &)));

    m_document->setAutoAlignment(m_viewManager->getAlignMode());

    CommandHistory::getInstance()->clear();

    CommandHistory::getInstance()->documentSaved();

    documentRestored();

    updateMenuStates();

    // Record that the last (i.e. current, as of now) session is

    // empty, so that if we exit now and re-start, we get an empty

    // session as is proper instead of loading the last non-empty one

    QSettings settings;

    settings.beginGroup("MainWindow");

    settings.setValue("lastsession", "");

    settings.endGroup();

}

void

MainWindow::closeSession()

{

    checkpointSession();

    if (m_sessionState != SessionLoading) {

        m_sessionFile = "";

        m_sessionState = NoSession;

    }

    while (m_paneStack->getPaneCount() > 0) {

        Pane *pane = m_paneStack->getPane(m_paneStack->getPaneCount() - 1);

        while (pane->getLayerCount() > 0) {

            m_document->removeLayerFromView

                (pane, pane->getLayer(pane->getLayerCount() - 1));

        }

        m_paneStack->deletePane(pane);

    }

    while (m_paneStack->getHiddenPaneCount() > 0) {

        Pane *pane = m_paneStack->getHiddenPane

            (m_paneStack->getHiddenPaneCount() - 1);

        while (pane->getLayerCount() > 0) {

            m_document->removeLayerFromView

                (pane, pane->getLayer(pane->getLayerCount() - 1));

        }

        m_paneStack->deletePane(pane);

    }

    delete m_document;

    m_document = 0;

    m_viewManager->clearSelections();

    m_timeRulerLayer = 0; // document owned this

    setWindowTitle(tr("Sonic Lineup"));

    CommandHistory::getInstance()->clear();

    CommandHistory::getInstance()->documentSaved();

    documentRestored();

}

void

MainWindow::openFiles()

{

    QString orig = m_audioFile;

    if (orig == "") orig = ".";

    else orig = QFileInfo(orig).absoluteDir().canonicalPath();

    FileFinder *ff = FileFinder::getInstance();

    QStringList paths = ff->getOpenFileNames(FileFinder::AudioFile,

                                             m_audioFile);

    if (paths.empty()) return;

    m_sessionState = SessionActive;

    for (QString path: paths) {

        FileOpenStatus status = FileOpenFailed;

        FileSource source(path);

        if (source.isAvailable()) {

            source.waitForData();

            try {

                status = openAudio(source, CreateAdditionalModel);

            } catch (const InsufficientDiscSpace &e) {

                SVCERR << "MainWindowBase: Caught InsufficientDiscSpace in file open" << endl;

                QMessageBox::critical

                    (this, tr("Not enough disc space"),

                     tr("<b>Not enough disc space</b><p>There doesn't appear to be enough spare disc space to accommodate any necessary temporary files.</p><p>Please clear some space and try again.</p>").arg(e.what()));

                return;

            }

        }

        if (status != FileOpenSucceeded) {

            QMessageBox::critical(this, tr("Failed to open file"),

                                  tr("<b>File open failed</b><p>File \"%1\" could not be opened").arg(path));

        } else {

            configureNewPane(m_paneStack->getCurrentPane());

        }

    }

}

void

MainWindow::openLocation()

{

    QSettings settings;

    settings.beginGroup("MainWindow");

    QString lastLocation = settings.value("lastremote", "").toString();

    bool ok = false;

    QString text = QInputDialog::getText

        (this, tr("Open Location"),

         tr("Please enter the URL of the location to open:"),

         QLineEdit::Normal, lastLocation, &ok);

    if (!ok) return;

    if (text.isEmpty()) return;

    m_sessionState = SessionActive;

    FileOpenStatus status = FileOpenFailed;

    FileSource source(text);

    if (source.isAvailable()) {

        source.waitForData();

        try {

            status = openAudio(source, CreateAdditionalModel);

        } catch (const InsufficientDiscSpace &e) {

            SVCERR << "MainWindowBase: Caught InsufficientDiscSpace in file open" << endl;

            QMessageBox::critical

                (this, tr("Not enough disc space"),

                 tr("<b>Not enough disc space</b><p>There doesn't appear to be enough spare disc space to accommodate any necessary temporary files.</p><p>Please clear some space and try again.</p>").arg(e.what()));

            return;

        }

    }

    if (status != FileOpenSucceeded) {

        QMessageBox::critical(this, tr("Failed to open location"),

                              tr("<b>Open failed</b><p>URL \"%1\" could not be opened").arg(text));

    } else {

        configureNewPane(m_paneStack->getCurrentPane());

        settings.setValue("lastremote", text);

    }

}

void

MainWindow::openRecentSession()

{

    QObject *obj = sender();

    QAction *action = dynamic_cast<QAction *>(obj);

    if (!action) {

        cerr << "WARNING: MainWindow::openRecentSession: sender is not an action"

                  << endl;

        return;

    }

    QString path = action->objectName();

    if (path == "") {

        cerr << "WARNING: MainWindow::openRecentSession: action incorrectly named"

             << endl;

        return;

    }

    openSmallSessionFile(path);

}

void

MainWindow::reopenLastSession()

{

    QSettings settings;

    settings.beginGroup("MainWindow");

    QString lastSession = settings.value("lastsession", "").toString();

    settings.endGroup();

    if (lastSession != "") {

        openSmallSessionFile(lastSession);

    }

    if (m_sessionState == NoSession) {

        newSession(); // to ensure we have a drop target

    }