comparison framework/Align.cpp @ 665:e19c609a7bec

Update so Document owns the alignment model's input aggregate model

     License, or (at your option) any later version.  See the file
     COPYING included with this distribution for more information.
 */
 
 #include "Align.h"
+#include "Document.h"
 
 #include "data/model/WaveFileModel.h"
 #include "data/model/ReadOnlyWaveFileModel.h"
 #include "data/model/AggregateWaveModel.h"
 #include "data/model/RangeSummarisableTimeValueModel.h"

 #include <QProcess>
 #include <QSettings>
 #include <QApplication>
 
 bool
-Align::alignModel(Model *ref, Model *other)
+Align::alignModel(Document *doc, Model *ref, Model *other)
 {
     QSettings settings;
     settings.beginGroup("Preferences");
     bool useProgram = settings.value("use-external-alignment", false).toBool();
     QString program = settings.value("external-alignment-program", "").toString();
     settings.endGroup();
 
     if (useProgram && (program != "")) {
-        return alignModelViaProgram(ref, other, program);
+        return alignModelViaProgram(doc, ref, other, program);
     } else {
-        return alignModelViaTransform(ref, other);
+        return alignModelViaTransform(doc, ref, other);
     }
 }
 
 QString
 Align::getAlignmentTransformName()

     TransformFactory *factory = TransformFactory::getInstance();
     return factory->haveTransform(id);
 }
 
 bool
-Align::alignModelViaTransform(Model *ref, Model *other)
+Align::alignModelViaTransform(Document *doc, Model *ref, Model *other)
 {
     RangeSummarisableTimeValueModel *reference = qobject_cast
         <RangeSummarisableTimeValueModel *>(ref);
     
     RangeSummarisableTimeValueModel *rm = qobject_cast

                          (reference, -1));
 
     components.push_back(AggregateWaveModel::ModelChannelSpec
                          (rm, -1));
 
-    Model *aggregateModel = new AggregateWaveModel(components);
+    AggregateWaveModel *aggregateModel = new AggregateWaveModel(components);
+    doc->addAggregateModel(aggregateModel);
+    
     ModelTransformer::Input aggregate(aggregateModel);
 
     TransformId id = getAlignmentTransformName();
     
     TransformFactory *tf = TransformFactory::getInstance();

     }
 
     path->setCompletion(0);
 
     AlignmentModel *alignmentModel = new AlignmentModel
-        (reference, other, aggregateModel, path);
+        (reference, other, path);
 
     connect(alignmentModel, SIGNAL(completionChanged()),
             this, SLOT(alignmentCompletionChanged()));
     
     rm->setAlignment(alignmentModel);

         emit alignmentComplete(am);
     }
 }
 
 bool
-Align::alignModelViaProgram(Model *ref, Model *other, QString program)
+Align::alignModelViaProgram(Document *, Model *ref, Model *other, QString program)
 {
     WaveFileModel *reference = qobject_cast<WaveFileModel *>(ref);
     WaveFileModel *rm = qobject_cast<WaveFileModel *>(other);
 
     if (!reference || !rm) {

         return false;
     }
 
     m_error = "";
     
-    AlignmentModel *alignmentModel = new AlignmentModel(reference, other, nullptr, nullptr);
+    AlignmentModel *alignmentModel =
+        new AlignmentModel(reference, other, nullptr);
     rm->setAlignment(alignmentModel);
 
     QProcess *process = new QProcess;
     QStringList args;
     args << refPath << otherPath;