comparison main/MainWindow.cpp @ 211:11ca12902c6a

* Further naming change: Transformer -> ModelTransformer.
  The Transform class now describes a thing that can be done, and the
  ModelTransformer does it to a Model.

 #include "data/fileio/MIDIFileWriter.h"
 #include "data/fileio/BZipFileDevice.h"
 #include "data/fileio/FileSource.h"
 #include "data/fft/FFTDataServer.h"
 #include "base/RecentFiles.h"
-#include "plugin/transform/TransformerFactory.h"
+#include "plugin/transform/TransformFactory.h"
+#include "plugin/transform/ModelTransformerFactory.h"
 #include "base/PlayParameterRepository.h"
 #include "base/XmlExportable.h"
 #include "base/CommandHistory.h"
 #include "base/Profiler.h"
 #include "base/Clipboard.h"

     m_transformsMenu(0),
     m_playbackMenu(0),
     m_existingLayersMenu(0),
     m_sliceMenu(0),
     m_recentFilesMenu(0),
-    m_recentTransformersMenu(0),
+    m_recentTransformsMenu(0),
     m_rightButtonMenu(0),
     m_rightButtonLayerMenu(0),
-    m_rightButtonTransformersMenu(0),
+    m_rightButtonTransformsMenu(0),
     m_rightButtonPlaybackMenu(0),
     m_soloAction(0),
     m_soloModified(false),
     m_prevSolo(false),
     m_ffwdAction(0),

         m_rightButtonLayerMenu = m_rightButtonMenu->addMenu(tr("&Layer"));
         m_rightButtonLayerMenu->setTearOffEnabled(true);
         m_rightButtonMenu->addSeparator();
     }
 
-    if (m_rightButtonTransformersMenu) {
-        m_rightButtonTransformersMenu->clear();
+    if (m_rightButtonTransformsMenu) {
+        m_rightButtonTransformsMenu->clear();
     } else {
-        m_rightButtonTransformersMenu = m_rightButtonMenu->addMenu(tr("&Transformer"));
-        m_rightButtonTransformersMenu->setTearOffEnabled(true);
+        m_rightButtonTransformsMenu = m_rightButtonMenu->addMenu(tr("&Transform"));
+        m_rightButtonTransformsMenu->setTearOffEnabled(true);
         m_rightButtonMenu->addSeparator();
     }
 
     if (!m_mainMenusCreated) {
         CommandHistory::getInstance()->registerMenu(m_rightButtonMenu);

 
     setupFileMenu();
     setupEditMenu();
     setupViewMenu();
     setupPaneAndLayerMenus();
-    setupTransformersMenu();
+    setupTransformsMenu();
 
     m_mainMenusCreated = true;
 }
 
 void

 
     m_keyReference->registerShortcut(raction); // rename after delete, so delete layer goes next to delete pane
 }
 
 void
-MainWindow::setupTransformersMenu()
+MainWindow::setupTransformsMenu()
 {
     if (m_transformsMenu) {
         m_transformActions.clear();
         m_transformActionsReverse.clear();
         m_transformsMenu->clear();

 	m_transformsMenu = menuBar()->addMenu(tr("&Transform")); 
         m_transformsMenu->setTearOffEnabled(true);
    }
 
     TransformList transforms =
-	TransformerFactory::getInstance()->getAllTransforms();
+	TransformFactory::getInstance()->getAllTransforms();
 
     vector<QString> types =
-        TransformerFactory::getInstance()->getAllTransformerTypes();
+        TransformFactory::getInstance()->getAllTransformTypes();
 
     map<QString, map<QString, SubdividingMenu *> > categoryMenus;
     map<QString, map<QString, SubdividingMenu *> > makerMenus;
 
     map<QString, SubdividingMenu *> byPluginNameMenus;
     map<QString, map<QString, QMenu *> > pluginNameMenus;
 
     set<SubdividingMenu *> pendingMenus;
 
-    m_recentTransformersMenu = m_transformsMenu->addMenu(tr("&Recent Transforms"));
-    m_recentTransformersMenu->setTearOffEnabled(true);
-    m_rightButtonTransformersMenu->addMenu(m_recentTransformersMenu);
-    connect(&m_recentTransformers, SIGNAL(recentChanged()),
-            this, SLOT(setupRecentTransformersMenu()));
+    m_recentTransformsMenu = m_transformsMenu->addMenu(tr("&Recent Transforms"));
+    m_recentTransformsMenu->setTearOffEnabled(true);
+    m_rightButtonTransformsMenu->addMenu(m_recentTransformsMenu);
+    connect(&m_recentTransforms, SIGNAL(recentChanged()),
+            this, SLOT(setupRecentTransformsMenu()));
 
     m_transformsMenu->addSeparator();
-    m_rightButtonTransformersMenu->addSeparator();
+    m_rightButtonTransformsMenu->addSeparator();
     
     for (vector<QString>::iterator i = types.begin(); i != types.end(); ++i) {
 
         if (i != types.begin()) {
             m_transformsMenu->addSeparator();
-            m_rightButtonTransformersMenu->addSeparator();
+            m_rightButtonTransformsMenu->addSeparator();
         }
 
         QString byCategoryLabel = tr("%1 by Category").arg(*i);
         SubdividingMenu *byCategoryMenu = new SubdividingMenu(byCategoryLabel,
                                                               20, 40);
         byCategoryMenu->setTearOffEnabled(true);
         m_transformsMenu->addMenu(byCategoryMenu);
-        m_rightButtonTransformersMenu->addMenu(byCategoryMenu);
+        m_rightButtonTransformsMenu->addMenu(byCategoryMenu);
         pendingMenus.insert(byCategoryMenu);
 
         vector<QString> categories = 
-            TransformerFactory::getInstance()->getTransformerCategories(*i);
+            TransformFactory::getInstance()->getTransformCategories(*i);
 
         for (vector<QString>::iterator j = categories.begin();
              j != categories.end(); ++j) {
 
             QString category = *j;

 
         QString byPluginNameLabel = tr("%1 by Plugin Name").arg(*i);
         byPluginNameMenus[*i] = new SubdividingMenu(byPluginNameLabel);
         byPluginNameMenus[*i]->setTearOffEnabled(true);
         m_transformsMenu->addMenu(byPluginNameMenus[*i]);
-        m_rightButtonTransformersMenu->addMenu(byPluginNameMenus[*i]);
+        m_rightButtonTransformsMenu->addMenu(byPluginNameMenus[*i]);
         pendingMenus.insert(byPluginNameMenus[*i]);
 
         QString byMakerLabel = tr("%1 by Maker").arg(*i);
         SubdividingMenu *byMakerMenu = new SubdividingMenu(byMakerLabel, 20, 40);
         byMakerMenu->setTearOffEnabled(true);
         m_transformsMenu->addMenu(byMakerMenu);
-        m_rightButtonTransformersMenu->addMenu(byMakerMenu);
+        m_rightButtonTransformsMenu->addMenu(byMakerMenu);
         pendingMenus.insert(byMakerMenu);
 
         vector<QString> makers = 
-            TransformerFactory::getInstance()->getTransformerMakers(*i);
+            TransformFactory::getInstance()->getTransformMakers(*i);
 
         for (vector<QString>::iterator j = makers.begin();
              j != makers.end(); ++j) {
 
             QString maker = *j;

         connect(action, SIGNAL(triggered()), this, SLOT(addLayer()));
         m_transformActions[action] = transforms[i].identifier;
         connect(this, SIGNAL(canAddLayer(bool)), action, SLOT(setEnabled(bool)));
         action->setStatusTip(transforms[i].description);
 
-//        cerr << "Transformer: \"" << name.toStdString() << "\": plugin name \"" << pluginName.toStdString() << "\"" << endl;
+//        cerr << "Transform: \"" << name.toStdString() << "\": plugin name \"" << pluginName.toStdString() << "\"" << endl;
 
         if (pluginNameMenus[type].find(pluginName) ==
             pluginNameMenus[type].end()) {
 
             SubdividingMenu *parentMenu = byPluginNameMenus[type];

     for (set<SubdividingMenu *>::iterator i = pendingMenus.begin();
          i != pendingMenus.end(); ++i) {
         (*i)->entriesAdded();
     }
 
-    setupRecentTransformersMenu();
+    setupRecentTransformsMenu();
 }
 
 void
 MainWindow::setupHelpMenu()
 {

 	m_recentFilesMenu->addAction(action);
     }
 }
 
 void
-MainWindow::setupRecentTransformersMenu()
-{
-    m_recentTransformersMenu->clear();
-    vector<QString> transforms = m_recentTransformers.getRecent();
+MainWindow::setupRecentTransformsMenu()
+{
+    m_recentTransformsMenu->clear();
+    vector<QString> transforms = m_recentTransforms.getRecent();
     for (size_t i = 0; i < transforms.size(); ++i) {
-        TransformerActionReverseMap::iterator ti =
+        TransformActionReverseMap::iterator ti =
             m_transformActionsReverse.find(transforms[i]);
         if (ti == m_transformActionsReverse.end()) {
-            std::cerr << "WARNING: MainWindow::setupRecentTransformersMenu: "
+            std::cerr << "WARNING: MainWindow::setupRecentTransformsMenu: "
                       << "Unknown transform \"" << transforms[i].toStdString()
                       << "\" in recent transforms list" << std::endl;
             continue;
         }
         if (i == 0) {
             ti->second->setShortcut(tr("Ctrl+T"));
             m_keyReference->registerShortcut
-                (tr("Repeat Transformer"),
+                (tr("Repeat Transform"),
                  ti->second->shortcut(),
                  tr("Re-select the most recently run transform"));
         }
-	m_recentTransformersMenu->addAction(ti->second);
+	m_recentTransformsMenu->addAction(ti->second);
     }
 }
 
 void
 MainWindow::setupExistingLayersMenus()

 	m_document->addLayerToView(pane, newLayer);
 	m_paneStack->setCurrentLayer(pane, newLayer);
 	return;
     }
 
-    TransformerActionMap::iterator i = m_transformActions.find(action);
+    TransformActionMap::iterator i = m_transformActions.find(action);
 
     if (i == m_transformActions.end()) {
 
 	LayerActionMap::iterator i = m_layerActions.find(action);
 	

 	m_paneStack->setCurrentLayer(pane, newLayer);
 
 	return;
     }
 
-    TransformerId transform = i->second;
-    TransformerFactory *factory = TransformerFactory::getInstance();
+    TransformId transform = i->second;
+    ModelTransformerFactory *factory = ModelTransformerFactory::getInstance();
 
     QString configurationXml;
 
     int channel = -1;
     // pick up the default channel from any existing layers on the same pane

     size_t endFrame = 0;
     m_viewManager->getSelection().getExtents(startFrame, endFrame);
     if (endFrame > startFrame) duration = endFrame - startFrame;
     else startFrame = 0;
 
-    Model *inputModel = factory->getConfigurationForTransformer(transform,
-                                                              candidateInputModels,
-                                                              context,
-                                                              configurationXml,
-                                                              m_playSource,
-                                                              startFrame,
-                                                              duration);
+    Model *inputModel = factory->getConfigurationForTransformer
+        (transform,
+         candidateInputModels,
+         context,
+         configurationXml,
+         m_playSource,
+         startFrame,
+         duration);
+
     if (!inputModel) return;
 
 //    std::cerr << "MainWindow::addLayer: Input model is " << inputModel << " \"" << inputModel->objectName().toStdString() << "\"" << std::endl;
 
     Layer *newLayer = m_document->createDerivedLayer(transform,

                                                      configurationXml);
 
     if (newLayer) {
         m_document->addLayerToView(pane, newLayer);
         m_document->setChannel(newLayer, context.channel);
-        m_recentTransformers.add(transform);
+        m_recentTransforms.add(transform);
         m_paneStack->setCurrentLayer(pane, newLayer);
     }
 
     updateMenuStates();
 }

         if (getMainModel() &&
             pane &&
             message.getArgCount() == 1 &&
             message.getArg(0).canConvert(QVariant::String)) {
 
-            TransformerId transform = message.getArg(0).toString();
+            TransformId transform = message.getArg(0).toString();
 
             Layer *newLayer = m_document->createDerivedLayer
                 (transform,
                  getMainModel(),
-                 TransformerFactory::getInstance()->getDefaultContextForTransformer
+                 ModelTransformerFactory::getInstance()->getDefaultContextForTransformer
                  (transform, getMainModel()),
                  "");
 
             if (newLayer) {
                 m_document->addLayerToView(pane, newLayer);
-                m_recentTransformers.add(transform);
+                m_recentTransforms.add(transform);
                 m_paneStack->setCurrentLayer(pane, newLayer);
             }
         }
 
     } else {