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-2012 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 "PreferencesDialog.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/TempDirectory.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 "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/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 <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(bool withAudioOutput) :

    MainWindowBase(withAudioOutput ? WithAudioOutput : WithNothing),

    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());

    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();

    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);

    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->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;

    button = new QPushButton;

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

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

    button->setCheckable(true);

    button->setChecked(true);

    button->setFixedHeight(bottomButtonHeight);

    bg->addButton(button);

    buttonLayout->addWidget(button);

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

    m_modeButtons[WaveformMode] = button;

    button = new QPushButton;

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

    button->setText(tr("Spectral flux"));

    button->setCheckable(true);

    button->setChecked(false);

    button->setFixedHeight(bottomButtonHeight);

    bg->addButton(button);

    buttonLayout->addWidget(button);

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

    m_modeButtons[CurveMode] = button;

    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;

    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;

    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;

    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_playSpeed = new AudioDial(bottomFrame);

    m_playSpeed->setMinimum(0);

    m_playSpeed->setMaximum(120);

    m_playSpeed->setValue(60);

    m_playSpeed->setFixedWidth(bottomElementHeight);

    m_playSpeed->setFixedHeight(bottomElementHeight);

    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();

    openMostRecentSession();

}

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_showPropertyBoxesAction

    };

    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();

    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 Vector"));

    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();

    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);

    menu->addSeparator();

    QActionGroup *overlayGroup = new QActionGroup(this);

    action = new QAction(tr("Show &No Overlays"), this);

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

    action->setStatusTip(tr("Hide times, layer names, and scale"));

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

    action->setCheckable(true);

    action->setChecked(false);

    overlayGroup->addAction(action);

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

    action = new QAction(tr("Show &Minimal Overlays"), this);

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

    action->setStatusTip(tr("Show times and basic scale"));

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

    action->setCheckable(true);

    action->setChecked(true);

    overlayGroup->addAction(action);

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

    action = new QAction(tr("Show &All Overlays"), this);

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

    action->setStatusTip(tr("Show times, layer names, and scale"));

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

    action->setCheckable(true);

    action->setChecked(false);

    overlayGroup->addAction(action);

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

    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);

    action = new QAction(tr("Sonic Vector on the &Web"), this); 

    action->setStatusTip(tr("Open the Sonic Vector website")); 

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

    menu->addAction(action);

    action = new QAction(tr("&About Sonic Vector"), this); 

    action->setStatusTip(tr("Show information about Sonic Vector")); 

    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 *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("Adjust for Tuning Differences when Aligning"));

    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()));

    m_keyReference->registerShortcut(m_playAction);

    m_keyReference->registerShortcut(m_rwdAction);

    m_keyReference->registerShortcut(m_ffwdAction);

    m_keyReference->registerShortcut(rwdStartAction);

    m_keyReference->registerShortcut(ffwdEndAction);

    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(alAction);

    menu->addAction(tdAction);

    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);

    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());

    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::newSession()

{

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

    closeSession();

    createDocument();

    // Reset to a waveform mode; this is because it takes less time to

    // process & render than other modes, so we will be able to

    // checkpoint sooner - the result of starting out in e.g. pitch

    // mode can be quite strange because of the near-eternity before a

    // safe checkpoint can be made

    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();

}

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 Vector"));

    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);

    m_sessionState = SessionActive;

    for (QString path: paths) {

        FileOpenStatus status = openPath(path, CreateAdditionalModel);

        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;

    settings.setValue("lastremote", text);

    if (text.isEmpty()) return;

    m_sessionState = SessionActive;

    FileOpenStatus status = openPath(text, CreateAdditionalModel);

    if (status == FileOpenFailed) {

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

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

    } else if (status == FileOpenWrongMode) {

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

                              tr("<b>Audio required</b><p>Please load at least one audio file before importing annotation data"));

    } else {

        configureNewPane(m_paneStack->getCurrentPane());

    }

}

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;

    }

    m_sessionFile = path;

    m_sessionState = SessionLoading;

    SVDEBUG << "MainWindow::openRecentSession: m_sessionFile is now "

            << m_sessionFile << endl;

    FileOpenStatus status = openPath(path, ReplaceSession);

    if (status == FileOpenSucceeded) {

        m_sessionState = SessionActive;

        updateModeFromLayers(); // get the mode from session, then...

        reselectMode();         // ...ensure there are no stragglers

    } else {

        m_sessionFile = "";

        m_sessionState = NoSession;

        if (status == FileOpenFailed) {

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

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

        } else if (status == FileOpenWrongMode) {

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

                                  tr("<b>Audio required</b><p>Please load at least one audio file before importing annotation data"));

        }

    }

}

void

MainWindow::openMostRecentSession()

{

    vector<QString> files = m_recentSessions.getRecentIdentifiers();

    if (files.empty()) return;

    QString path = files[0];

    if (path == "") return;

    m_sessionFile = path;

    m_sessionState = SessionLoading;

    SVDEBUG << "MainWindow::openMostRecentSession: m_sessionFile is now "

            << m_sessionFile << endl;

    FileOpenStatus status = openPath(path, ReplaceSession);

    if (status == FileOpenSucceeded) {

        m_sessionState = SessionActive;

        updateModeFromLayers(); // get the mode from session, then...

        reselectMode();         // ...ensure there are no stragglers

    } else {

        m_sessionFile = "";

        m_sessionState = NoSession;

        if (status == FileOpenFailed) {

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

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

        } else if (status == FileOpenWrongMode) {

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

                                  tr("<b>Audio required</b><p>Please load at least one audio file before importing annotation data"));

        }

    }

}

bool

MainWindow::selectExistingLayerForMode(Pane *pane,

                                       QString modeName,

                                       Model **createFrom)

{

    // Search the given pane for any layer whose object name matches

    // modeName, showing it if it exists, and hiding all other layers

    // (except for time-instants layers, which are assumed to be used

    // for persistent segment display and are left unmodified).

    // In the case where no such layer is found and false is returned,

    // then if the return parameter createFrom is non-null, the value

    // it points to will be set to a pointer to the model from which

    // such a layer should be constructed.

    Model *model = 0;

    bool have = false;

    for (int i = 0; i < pane->getLayerCount(); ++i) {

        Layer *layer = pane->getLayer(i);

        if (!layer || qobject_cast<TimeInstantLayer *>(layer)) {

            continue;

        }

        Model *lm = layer->getModel();

        while (lm && lm->getSourceModel()) lm = lm->getSourceModel();

        if (qobject_cast<WaveFileModel *>(lm)) model = lm;

        QString ln = layer->objectName();

        if (ln == modeName) {

            layer->showLayer(pane, true);

            have = true;

        } else {

            layer->showLayer(pane, false);

        }

    }

    if (have) return true;

    if (createFrom) {

        *createFrom = model;

    }

    return false;

}

void

MainWindow::addSalientFeatureLayer(Pane *pane, WaveFileModel *model)

{

    //!!! what if there already is one? could have changed the main

    //!!! model for example

    if (!model) {

        cerr << "MainWindow::addSalientFeatureLayer: No model" << endl;

        return;

    }

    TransformFactory *tf = TransformFactory::getInstance();

    if (!tf) {

        cerr << "Failed to locate a transform factory!" << endl;

        return;

    }

    TransformId id = "vamp:nnls-chroma:chordino:simplechord";

    if (!tf->haveTransform(id)) {

        cerr << "No plugin available for salient feature layer; transform is: "

             << id << endl;

        return;

    }

    if (!model) {

        return;

    }

    m_salientCalculating = true;

    Transform transform = tf->getDefaultTransformFor

        (id, model->getSampleRate());

    ModelTransformer::Input input(model, -1);

    Layer *newLayer = m_document->createDerivedLayer(transform, model);

    if (newLayer) {

        TimeInstantLayer *til = qobject_cast<TimeInstantLayer *>(newLayer);

        if (til) {

            til->setPlotStyle(TimeInstantLayer::PlotInstants);

            til->setBaseColour(m_salientColour);

        }

        PlayParameters *params = newLayer->getPlayParameters();

        if (params) {

            params->setPlayAudible(false);

        }

        connect(til, SIGNAL(modelCompletionChanged()),

                this, SLOT(salientLayerCompletionChanged()));

        m_document->addLayerToView(pane, newLayer);

        m_paneStack->setCurrentLayer(pane, newLayer);

    }

}

void

MainWindow::salientLayerCompletionChanged()

{

    Layer *layer = qobject_cast<Layer *>(sender());

    if (layer && layer->getCompletion(0) == 100) {

        m_salientCalculating = false;

        foreach (AlignmentModel *am, m_salientPending) {

            mapSalientFeatureLayer(am);