Sonic Segmenter

#include "rdf/PluginRDFDescription.h"

    m_segmentersMenu(0),

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

                      .arg(int(WaveformLayer::LinearScale))

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

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

//    m_viewManager->setAlignMode(true);

//    m_viewManager->setPlaySoloMode(true);

    findSegmentationTransforms();

    setupSegmentersMenu();

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

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

    }

bool

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

        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;

    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;

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

    if (newLayer) {

        AddPaneCommand *command = new AddPaneCommand(this);

        CommandHistory::getInstance()->addCommand(command);

        Pane *pane = command->getPane();

        if (!pane) return;

        // Set the source model to NULL to avoid us treating it as a

        // different visualisation for the main model and replacing it

        // when one of the visualisation mode toggles is activated

        newLayer->getModel()->setSourceModel(0);

        m_document->addLayerToView(pane, newLayer);

        m_document->setChannel(newLayer, input.getChannel());

//        m_paneStack->setCurrentLayer(pane, newLayer);

    }

    updateMenuStates();

}

void

MainWindow::findSegmentationTransforms()

{

    m_segmentationTransforms.clear();

    TransformList all = 

        TransformFactory::getInstance()->getAllTransformDescriptions();

    for (TransformList::iterator i = all.begin(); i != all.end(); ++i) {

        if (i->type != Transform::FeatureExtraction) continue;

        Transform t;

        t.setIdentifier(i->identifier);

        QString pluginId = t.getPluginIdentifier();

        QString outputId = t.getOutput();

        PluginRDFDescription desc(pluginId);

        if (!desc.haveDescription()) continue;

        QString feature = desc.getOutputEventTypeURI(outputId);

        if (feature == "") continue;

        std::cerr << "Feature: " << feature.toStdString() << std::endl;

        //!!! This is grotesque

        if (feature.endsWith("Segment") || feature.endsWith("Change")) {

            m_segmentationTransforms.push_back(*i);

        }

    }

    std::cerr << "MainWindow::findSegmentationTransforms: Found "

              << m_segmentationTransforms.size() << " transforms" << std::endl;

        if (!selectExistingModeLayer(pane, name)) continue;

        Model *model = m_document->getMainModel();

            Layer *newLayer = m_document->createDerivedLayer

                (transform, model);

            std::cerr << "No QM onset detector plugin available" << std::endl;

        if (!selectExistingModeLayer(pane, name)) continue;

        Model *model = m_document->getMainModel();

        if (!selectExistingModeLayer(pane, name)) continue;

        Model *model = m_document->getMainModel();

        if (!selectExistingModeLayer(pane, name)) continue;

        Model *model = m_document->getMainModel();

#include "transform/TransformDescription.h"

    virtual void addSegmentation();

    QMenu                   *m_segmentersMenu;

    TransformList            m_segmentationTransforms;

    void findSegmentationTransforms();

    virtual void setupSegmentersMenu();

    typedef std::map<QAction *, TransformId> TransformActionMap;

    TransformActionMap m_segmenterActions;

    virtual bool selectExistingModeLayer(Pane *, QString);