Sonic Segmenter

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

/*

    Sonic Visualiser

    An audio file viewer and annotation editor.

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

    This file copyright 2006 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/FFTModel.h"

#include "base/StorageAdviser.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 "widgets/Fader.h"

#include "view/Overview.h"

#include "widgets/PropertyBox.h"

#include "widgets/PropertyStack.h"

#include "widgets/AudioDial.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 "audioio/AudioCallbackPlaySource.h"

#include "audioio/AudioCallbackPlayTarget.h"

#include "audioio/AudioTargetFactory.h"

#include "audioio/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 "data/fft/FFTDataServer.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 "rdf/PluginRDFDescription.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 <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 <iostream>

#include <cstdio>

#include <errno.h>

using std::cerr;

using std::endl;

using std::vector;

using std::map;

using std::set;

MainWindow::MainWindow(bool withAudioOutput, bool withOSCSupport) :

    MainWindowBase(withAudioOutput, withOSCSupport, false),

    m_overview(0),

    m_mainMenusCreated(false),

    m_playbackMenu(0),

    m_recentFilesMenu(0),

    m_rightButtonMenu(0),

    m_rightButtonPlaybackMenu(0),

    m_segmentersMenu(0),

    m_deleteSelectedAction(0),

    m_ffwdAction(0),

    m_rwdAction(0),

    m_preferencesDialog(0),

    m_layerTreeView(0),

    m_keyReference(new KeyReference()),

    m_displayMode(WaveformMode)

{

    setWindowTitle(QApplication::applicationName());

    StorageAdviser::setFixedRecommendation

        (StorageAdviser::Recommendation(StorageAdviser::UseDisc |

                                        StorageAdviser::ConserveSpace));

    UnitDatabase *udb = UnitDatabase::getInstance();

    udb->registerUnit("Hz");

    udb->registerUnit("dB");

    udb->registerUnit("s");

    ColourDatabase *cdb = ColourDatabase::getInstance();

    cdb->addColour(Qt::black, tr("Black"));

    cdb->addColour(Qt::darkRed, tr("Red"));

    cdb->addColour(Qt::darkBlue, tr("Blue"));

    cdb->addColour(Qt::darkGreen, tr("Green"));

    cdb->addColour(QColor(200, 50, 255), tr("Purple"));

    cdb->addColour(QColor(255, 150, 50), tr("Orange"));

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

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

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

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

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

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

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

    Preferences::getInstance()->setSpectrogramSmoothing

        (Preferences::SpectrogramInterpolated);

    QSettings settings;

    settings.beginGroup("LayerDefaults");

    settings.setValue("waveform",

                      QString("<layer scale=\"%1\" channelMode=\"%2\"/>")

//                      .arg(int(WaveformLayer::MeterScale))

                      .arg(int(WaveformLayer::LinearScale))

                      .arg(int(WaveformLayer::MergeChannels)));

    settings.setValue("timevalues",

                      QString("<layer plotStyle=\"%1\"/>")

//                      .arg(int(TimeValueLayer::PlotStems)));

                      .arg(int(TimeValueLayer::PlotCurve)));

    settings.setValue("spectrogram",

                      QString("<layer channel=\"-1\" windowSize=\"2048\" windowHopLevel=\"2\"/>"));

    settings.setValue("melodicrange",

                      QString("<layer channel=\"-1\" gain=\"10\" normalizeVisibleArea=\"false\" normalizeColumns=\"false\" minFrequency=\"100\" maxFrequency=\"1200\" windowSize=\"4096\" windowOverlap=\"75\" binDisplay=\"0\" />"));

    settings.endGroup();

    settings.beginGroup("MainWindow");

    settings.setValue("showstatusbar", 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);

#ifndef __APPLE__

    m_viewManager->setGlobalDarkBackground(true);

#endif

    QFrame *frame = new QFrame;

    setCentralWidget(frame);

    QGridLayout *layout = new QGridLayout;

    m_descriptionLabel = new QLabel;

    QScrollArea *scroll = new QScrollArea(frame);

    scroll->setWidgetResizable(true);

    scroll->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

    scroll->setFrameShape(QFrame::NoFrame);

    m_paneStack->setLayoutStyle(PaneStack::NoPropertyStacks);

    scroll->setWidget(m_paneStack);

    QButtonGroup *bg = new QButtonGroup;

    IconLoader il;

    QFrame *buttonFrame = new QFrame;

    QHBoxLayout *buttonLayout = new QHBoxLayout;

    buttonLayout->setSpacing(0);

    buttonLayout->setMargin(0);

    buttonFrame->setLayout(buttonLayout);

    QToolButton *button = new QToolButton;

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

    button->setCheckable(true);

    button->setChecked(true);

    button->setAutoRaise(true);

    bg->addButton(button);

    buttonLayout->addWidget(button);

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

    button = new QToolButton;

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

    button->setCheckable(true);

    button->setChecked(false);

    button->setAutoRaise(true);

    bg->addButton(button);

    buttonLayout->addWidget(button);

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

    button = new QToolButton;

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

    button->setCheckable(true);

    button->setChecked(false);

    button->setAutoRaise(true);

    bg->addButton(button);

    buttonLayout->addWidget(button);

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

    button = new QToolButton;

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

    button->setCheckable(true);

    button->setChecked(false);

    button->setAutoRaise(true);

    bg->addButton(button);

    buttonLayout->addWidget(button);

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

    layout->addWidget(buttonFrame, 1, 0);

    m_overview = new Overview(frame);

    m_overview->setViewManager(m_viewManager);

    m_overview->setFixedHeight(40);

#ifndef _WIN32

    // For some reason, the contents of the overview never appear if we

    // make this setting on Windows.  I have no inclination at the moment

    // to track down the reason why.

    m_overview->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);

#endif

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

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

    m_overview->hide();

    m_panLayer = new WaveformLayer;

    m_panLayer->setChannelMode(WaveformLayer::MergeChannels);

    m_panLayer->setAggressiveCacheing(true);

    m_overview->addLayer(m_panLayer);

    if (m_viewManager->getGlobalDarkBackground()) {

        m_panLayer->setBaseColour

            (ColourDatabase::getInstance()->getColourIndex(tr("Bright Green")));

    } else {

        m_panLayer->setBaseColour

            (ColourDatabase::getInstance()->getColourIndex(tr("Green")));

    }        

    m_fader = new Fader(frame, false);

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

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

    m_playSpeed = new AudioDial(frame);

    m_playSpeed->setMinimum(0);

    m_playSpeed->setMaximum(200);

    m_playSpeed->setValue(100);

    m_playSpeed->setFixedWidth(24);

    m_playSpeed->setFixedHeight(24);

    m_playSpeed->setNotchesVisible(true);

    m_playSpeed->setPageStep(10);

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

    m_playSpeed->setDefaultValue(100);

    m_playSpeed->setRangeMapper(new PlaySpeedRangeMapper(0, 200));

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

    layout->setSpacing(4);

    layout->addWidget(scroll, 0, 0, 1, 6);

    layout->addWidget(m_overview, 1, 1);

    layout->addWidget(m_fader, 1, 2);

    layout->addWidget(m_playSpeed, 1, 3);

    m_paneStack->setPropertyStackMinWidth

        (m_fader->width() + m_playSpeed->width() +

         layout->spacing() * 4);

    layout->setColumnStretch(1, 10);

    frame->setLayout(layout);

    findSegmentationTransforms();

    setupMenus();

    setupToolbars();

    setupHelpMenu();

    statusBar();

    newSession();

}

MainWindow::~MainWindow()

{

    delete m_keyReference;

    delete m_preferencesDialog;

    delete m_layerTreeView;

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

}

void

MainWindow::setupMenus()

{

    if (!m_mainMenusCreated) {

        m_rightButtonMenu = new QMenu();

        // No -- we don't want tear-off enabled on the right-button

        // menu.  If it is enabled, then simply right-clicking and

        // releasing will pop up the menu, activate the tear-off, and

        // leave the torn-off menu window in front of the main window.

        // That isn't desirable.  I'm not sure it ever would be, in a

        // context menu -- perhaps technically a Qt bug?

//        m_rightButtonMenu->setTearOffEnabled(true);

    }

    if (!m_mainMenusCreated) {

        CommandHistory::getInstance()->registerMenu(m_rightButtonMenu);

        m_rightButtonMenu->addSeparator();

    }

    setupFileMenu();

//    setupEditMenu();

    setupViewMenu();

    setupSegmentersMenu();

    m_mainMenusCreated = true;

}

void

MainWindow::setupFileMenu()

{

    if (m_mainMenusCreated) return;

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

    menu->setTearOffEnabled(true);

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

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

    IconLoader il;

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

    icon.addPixmap(il.loadPixmap("filenew-22"));

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

    icon.addPixmap(il.loadPixmap("fileopen-22"));

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

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

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

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

    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_recentFilesMenu = menu->addMenu(tr("&Recent Locations"));

    m_recentFilesMenu->setTearOffEnabled(true);

    setupRecentFilesMenu();

    connect(&m_recentFiles, SIGNAL(recentChanged()),

            this, SLOT(setupRecentFilesMenu()));

/*

    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 %1").arg(QApplication::applicationName()));

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

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

}

void

MainWindow::setupEditMenu()

{

    if (m_mainMenusCreated) return;

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

    menu->setTearOffEnabled(true);

    CommandHistory::getInstance()->registerMenu(menu);

}

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

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

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

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

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

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

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

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

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

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

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

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

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

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

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

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

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

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

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

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

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

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

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

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

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

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

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

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

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

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

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

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

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

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

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

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

    menu->addSeparator();

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

    QActionGroup *overlayGroup = new QActionGroup(this);

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

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

    action->setStatusTip(tr("Hide centre indicator, frame 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 centre indicator only"));

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

    action->setCheckable(true);

    action->setChecked(false);

    overlayGroup->addAction(action);

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

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

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

    action->setStatusTip(tr("Show centre indicator, frame times and scale"));

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

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

    action->setStatusTip(tr("Show all texts 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();

    action = new QAction(tr("Show &Zoom Wheels"), this);

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

    action->setStatusTip(tr("Show thumbwheels for zooming horizontally and vertically"));

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

    action->setCheckable(true);

    action->setChecked(m_viewManager->getZoomWheelsEnabled());

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

    action = new QAction(tr("Show Property Bo&xes"), this);

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

    action->setStatusTip(tr("Show the layer property boxes at the side of the main window"));

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

    action->setCheckable(true);

    action->setChecked(false); //!!!

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

    action = new QAction(tr("Show Status &Bar"), this);

    action->setStatusTip(tr("Show context help information in the status bar at the bottom of the window"));

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

    action->setCheckable(true);

    action->setChecked(true);

    menu->addAction(action);

    QSettings settings;

    settings.beginGroup("MainWindow");

    bool sb = settings.value("showstatusbar", true).toBool();

    if (!sb) {

        action->setChecked(false);

        statusBar()->hide();

    }

    settings.endGroup();

    menu->addSeparator();

    action = new QAction(tr("Show La&yer Hierarchy"), this);

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

    action->setStatusTip(tr("Open a window displaying the hierarchy of panes and layers in this session"));

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

    m_keyReference->registerShortcut(action);

    menu->addAction(action);

}

void

MainWindow::setupSegmentersMenu()

{

    if (m_segmentersMenu) {

        m_segmenterActions.clear();

        m_segmentersMenu->clear();

    } else {

        m_segmentersMenu = menuBar()->addMenu(tr("&Segmenters")); 

        m_segmentersMenu->setTearOffEnabled(true);

        m_segmentersMenu->setSeparatorsCollapsible(true);

    }

    std::set<QString> seenNames, duplicateNames, seenPluginNames, duplicatePluginNames;

    for (unsigned int i = 0; i < m_segmentationTransforms.size(); ++i) {

        QString name = m_segmentationTransforms[i].name;

        QString pluginName = name.section(": ", 0, 0);

        if (seenNames.find(name) != seenNames.end()) {

            duplicateNames.insert(name);

        } else {

            seenNames.insert(name);

        }

        if (seenPluginNames.find(pluginName) != seenPluginNames.end()) {

            duplicatePluginNames.insert(pluginName);

        } else {

            seenPluginNames.insert(pluginName);

        }

    }

    for (unsigned int i = 0; i < m_segmentationTransforms.size(); ++i) {

        QString name = m_segmentationTransforms[i].name;

        if (name == "") name = m_segmentationTransforms[i].identifier;

        QString maker = m_segmentationTransforms[i].maker;

        if (maker == "") maker = tr("Unknown");

        maker.replace(QRegExp(tr(" [\\(<].*$")), "");

        QString pluginName = name.section(": ", 0, 0);

        QString output = name.section(": ", 1);

        if (duplicateNames.find(pluginName) != duplicateNames.end()) {

            pluginName = QString("%1 <%2>")

                .arg(pluginName)

                .arg(m_segmentationTransforms[i].identifier.section(':', 1, 1));

            if (output == "") {

                name = pluginName;

            } else {

                name = QString("%1: %2")

                    .arg(pluginName)

                    .arg(output);

            }

        } else if (duplicatePluginNames.find(pluginName) ==

                   duplicatePluginNames.end()) {

            name = pluginName;

        }            

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

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

        m_segmenterActions[action] = m_segmentationTransforms[i].identifier;

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

        action->setStatusTip(m_segmentationTransforms[i].longDescription);

        m_segmentersMenu->addAction(action);

    }

}

void

MainWindow::setupHelpMenu()

{

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

    menu->setTearOffEnabled(true);

    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 Visualiser on the &Web"), this); 

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

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

    menu->addAction(action);

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

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

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

    menu->addAction(action);

}

void

MainWindow::setupRecentFilesMenu()

{

    m_recentFilesMenu->clear();

    vector<QString> files = m_recentFiles.getRecent();

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

        QAction *action = new QAction(files[i], this);

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

        if (i == 0) {

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

            m_keyReference->registerShortcut

                (tr("Re-open"),

                 action->shortcut(),

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

        }

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

    m_rightButtonMenu->addSeparator();

    m_rightButtonPlaybackMenu = m_rightButtonMenu->addMenu(tr("Playback"));

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

    QAction *playAction = toolbar->addAction(il.load("playpause"),

                                             tr("Play / Pause"));

    playAction->setCheckable(true);

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

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

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

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

            playAction, SLOT(setChecked(bool)));

    connect(this, SIGNAL(canPlay(bool)), 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)));

/*

    toolbar = addToolBar(tr("Play Mode Toolbar"));

    QAction *psAction = toolbar->addAction(il.load("playselection"),

                                           tr("Constrain Playback to Selection"));

    psAction->setCheckable(true);

    psAction->setChecked(m_viewManager->getPlaySelectionMode());

    psAction->setShortcut(tr("s"));

    psAction->setStatusTip(tr("Constrain playback to the selected regions"));

    connect(m_viewManager, SIGNAL(playSelectionModeChanged(bool)),

            psAction, SLOT(setChecked(bool)));

    connect(psAction, SIGNAL(triggered()), this, SLOT(playSelectionToggled()));

    connect(this, SIGNAL(canPlaySelection(bool)), psAction, SLOT(setEnabled(bool)));

    QAction *plAction = toolbar->addAction(il.load("playloop"),

                                           tr("Loop Playback"));

    plAction->setCheckable(true);

    plAction->setChecked(m_viewManager->getPlayLoopMode());

    plAction->setShortcut(tr("l"));

    plAction->setStatusTip(tr("Loop playback"));

    connect(m_viewManager, SIGNAL(playLoopModeChanged(bool)),

            plAction, SLOT(setChecked(bool)));

    connect(plAction, SIGNAL(triggered()), this, SLOT(playLoopToggled()));

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

    QAction *soAction = toolbar->addAction(il.load("solo"),

                                           tr("Solo Current Pane"));

    soAction->setCheckable(true);

    soAction->setChecked(m_viewManager->getPlaySoloMode());

    soAction->setShortcut(tr("o"));

    soAction->setStatusTip(tr("Solo the current pane during playback"));

    connect(m_viewManager, SIGNAL(playSoloModeChanged(bool)),

            soAction, SLOT(setChecked(bool)));

    connect(soAction, SIGNAL(triggered()), this, SLOT(playSoloToggled()));

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

    m_keyReference->registerShortcut(psAction);

    m_keyReference->registerShortcut(plAction);

    m_keyReference->registerShortcut(soAction);

*/

    m_keyReference->registerShortcut(playAction);

    m_keyReference->registerShortcut(m_rwdAction);

    m_keyReference->registerShortcut(m_ffwdAction);

    m_keyReference->registerShortcut(rwdStartAction);

    m_keyReference->registerShortcut(ffwdEndAction);

/*

    menu->addAction(psAction);

    menu->addAction(plAction);

    menu->addAction(soAction);

*/

    menu->addAction(playAction);

    menu->addSeparator();

    menu->addAction(m_rwdAction);

    menu->addAction(m_ffwdAction);

    menu->addSeparator();

    menu->addAction(rwdStartAction);

    menu->addAction(ffwdEndAction);

    menu->addSeparator();

    m_rightButtonPlaybackMenu->addAction(playAction);

/*

    m_rightButtonPlaybackMenu->addAction(psAction);

    m_rightButtonPlaybackMenu->addAction(plAction);

    m_rightButtonPlaybackMenu->addAction(soAction);

*/

    m_rightButtonPlaybackMenu->addSeparator();

    m_rightButtonPlaybackMenu->addAction(m_rwdAction);

    m_rightButtonPlaybackMenu->addAction(m_ffwdAction);

    m_rightButtonPlaybackMenu->addSeparator();

    m_rightButtonPlaybackMenu->addAction(rwdStartAction);

    m_rightButtonPlaybackMenu->addAction(ffwdEndAction);

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

    m_rightButtonPlaybackMenu->addAction(fastAction);

    m_rightButtonPlaybackMenu->addAction(slowAction);

    m_rightButtonPlaybackMenu->addAction(normalAction);

/*

    toolbar = addToolBar(tr("Edit Toolbar"));

    CommandHistory::getInstance()->registerToolbar(toolbar);

*/

    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 haveSelection = 

        (m_viewManager &&

         !m_viewManager->getSelections().empty());

    bool haveCurrentEditableLayer =

        (haveCurrentLayer &&

         currentLayer->isLayerEditable());

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

{

    if (!getMainModel()) {

        m_descriptionLabel->setText(tr("No audio file loaded."));

        return;

    }

    QString description;

    size_t ssr = getMainModel()->getSampleRate();

    size_t tsr = ssr;

    if (m_playSource) tsr = m_playSource->getTargetSampleRate();

    if (ssr != tsr) {

        description = tr("%1Hz (resampling to %2Hz)").arg(ssr).arg(tsr);

    } else {

        description = QString("%1Hz").arg(ssr);

    }

    description = QString("%1 - %2")

        .arg(RealTime::frame2RealTime(getMainModel()->getEndFrame(), ssr)

             .toText(false).c_str())

        .arg(description);

    m_descriptionLabel->setText(description);

}

void

MainWindow::documentModified()

{

    //!!!

    MainWindowBase::documentModified();

}

void

MainWindow::documentRestored()

{

    //!!!

    MainWindowBase::documentRestored();

}

void

MainWindow::newSession()

{

    if (!checkSaveModified()) return;

    closeSession();

    createDocument();

    m_document->setAutoAlignment(true);

    Pane *pane;

    Layer *waveform;

    for (int i = 0; i < 2; ++i) {

        pane = m_paneStack->addPane();

        pane->setFollowGlobalPan(false);

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

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

        waveform = m_document->createMainModelLayer(LayerFactory::Waveform);

        m_document->addLayerToView(pane, waveform);

        m_overview->registerView(pane);

    }

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

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

    documentRestored();

    updateMenuStates();

}

void

MainWindow::closeSession()

{

    if (!checkSaveModified()) return;

    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_overview->unregisterView(pane);

        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_overview->unregisterView(pane);

        m_paneStack->deletePane(pane);

    }

    delete m_document;

    m_document = 0;

    m_viewManager->clearSelections();

    m_timeRulerLayer = 0; // document owned this

    m_sessionFile = "";

    setWindowTitle(QApplication::applicationName());

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

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

    documentRestored();

}

void

MainWindow::openFile()

{

    QString orig = m_audioFile;

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

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

    QString path = getOpenFileName(FileFinder::AnyFile);

    if (path.isEmpty()) return;

    FileOpenStatus status = open(path, CreateAdditionalModel);

    if (status == FileOpenFailed) {

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

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

    } else if (status == FileOpenWrongMode) {

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

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

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

    FileOpenStatus status = open(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::openRecentFile()

{

    QObject *obj = sender();

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

    if (!action) {

        std::cerr << "WARNING: MainWindow::openRecentFile: sender is not an action"

                  << std::endl;

        return;

    }

    QString path = action->text();

    if (path == "") return;

    FileOpenStatus status = open(path, CreateAdditionalModel);

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

    } else {

        configureNewPane(m_paneStack->getCurrentPane());

    }

}

bool

MainWindow::selectExistingModeLayer(Pane *pane, QString name)

{   

    // return false if we do not need to go on and create a new layer

    // -- either because a suitable hidden one has been dredged up, or

    // because no layer that needed replacing was found in this pane

    if (!m_document) return false;

    bool required = false;

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

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

        if (!layer) continue;

        Model *lm = layer->getModel();

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

        if (dynamic_cast<WaveFileModel *>(lm)) {

            if (lm == m_document->getMainModel()) {

                required = true;

                break;

            }

        }

    }

    if (!required) return false;

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

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

        if (!layer) continue;

        QString ln = layer->objectName();

        if (ln != name) {

            m_hiddenLayers[pane].insert(layer);

            m_document->removeLayerFromView(pane, layer);

            continue;

        }

    }

    LayerSet &ls = m_hiddenLayers[pane];

    bool found = false;

    for (LayerSet::iterator i = ls.begin(); i != ls.end(); ++i) {

        if ((*i)->objectName() == name) {

            m_document->addLayerToView(pane, *i);

            ls.erase(i);

            found = true;

            break;

        }

    }

    return !found;

}

void

MainWindow::addSegmentation()

{

    QObject *s = sender();

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

    if (!action) {

        std::cerr << "WARNING: MainWindow::addSegmentation: sender is not an action"

                  << std::endl;

        return;

    }

    TransformActionMap::iterator i = m_segmenterActions.find(action);

    if (i == m_segmenterActions.end()) return;

    // We always ask for configuration, even if the plugin isn't

    // supposed to be configurable, because we need to let the user

    // change the execution context (block size etc).

    QString transformId = i->second;

    Transform transform = TransformFactory::getInstance()->

        getDefaultTransformFor(transformId);

    Model *defaultInputModel = m_document->getMainModel();

    std::vector<Model *> candidateInputModels;

    candidateInputModels.push_back(defaultInputModel);

    ModelTransformer::Input input = ModelTransformerFactory::getInstance()->

        getConfigurationForTransform

        (transform,

         candidateInputModels,

         defaultInputModel,

         m_playSource,

         0,

         0);

    if (!input.getModel()) return;

//    std::cerr << "MainWindow::addLayer: Input model is " << input.getModel() << " \"" << input.getModel()->objectName().toStdString() << "\"" << std::endl << "transform:" << std::endl << transform.toXmlString().toStdString() << std::endl;