comparison framework/Document.cpp @ 687:e0b0f3e163ca by-id

Update for removal of (public) getId from Model

     }
     for (auto m: m_aggregateModels) {
         ModelById::release(m);
     }
 
-    auto mainModel = m_mainModel;
+    if (!m_mainModel.isNone()) {
+        ModelById::release(m_mainModel);
+    }
     m_mainModel = {};
-    emit mainModelChanged(m_mainModel);
-    ModelById::release(mainModel);
+    emit mainModelChanged({});
 }
 
 Layer *
 Document::createLayer(LayerFactory::LayerType type)
 {

     Layer *newLayer = createLayer(type);
     if (!newLayer) {
         return nullptr;
     }
 
-    ModelById::add(newModel);
-    addImportedModel(newModel->getId());
-    setModel(newLayer, newModel->getId());
+    auto newModelId = ModelById::add(newModel);
+    addImportedModel(newModelId);
+    setModel(newLayer, newModelId);
 
     return newLayer;
 }
 
 Layer *

         SVDEBUG << "Document::setMainModel: auto-alignment is off" << endl;
     }
 
     emit mainModelChanged(m_mainModel);
 
-    // Remove the playable explicitly - the main model's dtor will do
-    // this, but just in case something is still hanging onto a
-    // shared_ptr to the old main model so it doesn't get deleted yet
-    PlayParameterRepository::getInstance()->removePlayable
-        (oldMainModel.untyped);
-    
-    ModelById::release(oldMainModel);
+    if (!oldMainModel.isNone()) {
+
+        // Remove the playable explicitly - the main model's dtor will
+        // do this, but just in case something is still hanging onto a
+        // shared_ptr to the old main model so it doesn't get deleted
+        PlayParameterRepository::getInstance()->removePlayable
+            (oldMainModel.untyped);
+
+        ModelById::release(oldMainModel);
+    }
 }
 
 void
 Document::addAlreadyDerivedModel(const Transform &transform,
                                  const ModelTransformer::Input &input,

         // without also knowing what the main model is
         SVDEBUG << "Document::alignModel(" << modelId
                 << "): is main model, setting alignment to itself" << endl;
         auto alignment = std::make_shared<AlignmentModel>(modelId, modelId,
                                                           ModelId());
-        ModelById::add(alignment);
+        
         //!!! hang on, who tracks alignment models?
-        rm->setAlignment(alignment->getId());
+        rm->setAlignment(ModelById::add(alignment));
         return;
     }
 
     auto w = ModelById::getAs<WritableWaveFileModel>(modelId);
     if (w && w->getWriteProportion() < 100) {
         SVDEBUG << "Document::alignModel(" << modelId
                 << "): model write is not complete, deferring"
                 << endl;
-        connect(w.get(), SIGNAL(writeCompleted()),
-                this, SLOT(performDeferredAlignment()));
+        connect(w.get(), SIGNAL(writeCompleted(ModelId)),
+                this, SLOT(performDeferredAlignment(ModelId)));
         return;
     }
 
     SVDEBUG << "Document::alignModel: aligning..." << endl;
     if (!rm->getAlignmentReference().isNone()) {

         emit alignmentFailed(err);
     }
 }
 
 void
-Document::performDeferredAlignment()
-{
-    ModelId modelId;
-    if (Model *m = qobject_cast<Model *>(sender())) {
-        modelId = m->getId();
-    } else {
-        SVDEBUG << "Document::performDeferredAlignment: sender is not a Model" << endl;
-        return;
-    }
-
+Document::performDeferredAlignment(ModelId modelId)
+{
     SVDEBUG << "Document::performDeferredAlignment: aligning..." << endl;
     alignModel(modelId);
 }
 
 void