comparison framework/Document.cpp @ 54:a798f5e6fc5e

* 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 "base/CommandHistory.h"
 #include "base/Command.h"
 #include "view/View.h"
 #include "base/PlayParameterRepository.h"
 #include "base/PlayParameters.h"
-#include "plugin/transform/TransformerFactory.h"
+#include "plugin/transform/TransformFactory.h"
+#include "plugin/transform/ModelTransformerFactory.h"
 #include <QApplication>
 #include <QTextStream>
 #include <iostream>
 
 // For alignment:

 Document::Document() :
     m_mainModel(0),
     m_autoAlignment(false)
 {
     connect(this, SIGNAL(modelAboutToBeDeleted(Model *)),
-            TransformerFactory::getInstance(),
+            ModelTransformerFactory::getInstance(),
             SLOT(modelAboutToBeDeleted(Model *)));
 }
 
 Document::~Document()
 {

     return newLayer;
 }
 
 Layer *
 Document::createDerivedLayer(LayerFactory::LayerType type,
-			     TransformerId transform)
+			     TransformId transform)
 {
     Layer *newLayer = createLayer(type);
     if (!newLayer) return 0;
 
     newLayer->setObjectName(getUniqueLayerName
-                            (TransformerFactory::getInstance()->
-                             getTransformerFriendlyName(transform)));
+                            (TransformFactory::getInstance()->
+                             getTransformFriendlyName(transform)));
 
     return newLayer;
 }
 
 Layer *
-Document::createDerivedLayer(TransformerId transform,
+Document::createDerivedLayer(TransformId transform,
                              Model *inputModel, 
                              const PluginTransformer::ExecutionContext &context,
                              QString configurationXml)
 {
     Model *newModel = addDerivedModel(transform, inputModel,

     // work quickly.  That means we need to put the same physical
     // model pointer in both layers, so they can't actually be cloned.
     
     if (newLayer) {
 	newLayer->setObjectName(getUniqueLayerName
-                                (TransformerFactory::getInstance()->
-                                 getTransformerFriendlyName(transform)));
+                                (TransformFactory::getInstance()->
+                                 getTransformFriendlyName(transform)));
     }
 
     emit layerAdded(newLayer);
     return newLayer;
 }

 //            std::cerr << "... it uses a model derived from the old main model, regenerating" << std::endl;
 
 	    // This model was derived from the previous main
 	    // model: regenerate it.
 	    
-	    TransformerId transform = m_models[model].transform;
+	    TransformId transform = m_models[model].transform;
             PluginTransformer::ExecutionContext context = m_models[model].context;
 	    
 	    Model *replacementModel =
                 addDerivedModel(transform,
                                 m_mainModel,

     // we already emitted modelAboutToBeDeleted for this
     delete oldMainModel;
 }
 
 void
-Document::addDerivedModel(TransformerId transform,
+Document::addDerivedModel(TransformId transform,
                           Model *inputModel,
                           const PluginTransformer::ExecutionContext &context,
                           Model *outputModelToAdd,
                           QString configurationXml)
 {

 
     emit modelAdded(model);
 }
 
 Model *
-Document::addDerivedModel(TransformerId transform,
+Document::addDerivedModel(TransformId transform,
                           Model *inputModel,
                           const PluginTransformer::ExecutionContext &context,
                           QString configurationXml)
 {
     Model *model = 0;

             i->second.configurationXml == configurationXml) {
 	    return i->first;
 	}
     }
 
-    model = TransformerFactory::getInstance()->transform
+    model = ModelTransformerFactory::getInstance()->transform
 	(transform, inputModel, context, configurationXml);
 
     if (!model) {
 	std::cerr << "WARNING: Document::addDerivedModel: no output model for transform " << transform.toStdString() << std::endl;
     } else {

 }
 
 bool
 Document::canAlign() 
 {
-    TransformerId id = "vamp:match-vamp-plugin:match:path";
-    TransformerFactory *factory = TransformerFactory::getInstance();
-    return factory->haveTransformer(id);
+    TransformId id = "vamp:match-vamp-plugin:match:path";
+    TransformFactory *factory = TransformFactory::getInstance();
+    return factory->haveTransform(id);
 }
 
 void
 Document::alignModel(Model *model)
 {

     components.push_back(AggregateWaveModel::ModelChannelSpec
                          (rm, -1));
 
     Model *aggregate = new AggregateWaveModel(components);
 
-    TransformerId id = "vamp:match-vamp-plugin:match:path";
+    TransformId id = "vamp:match-vamp-plugin:match:path";
     
-    TransformerFactory *factory = TransformerFactory::getInstance();
+    ModelTransformerFactory *factory = ModelTransformerFactory::getInstance();
 
     Model *transformOutput = factory->transform
         (id, aggregate,
          factory->getDefaultContextForTransformer(id, aggregate),
          "<plugin param-serialise=\"1\"/>");