comparison document/Document.cpp @ 45:6b6bca31ad53

* When setting a new model on a layer, don't delete the old one until after
  the new one has been set (a layer's setModel may want to compare against the
  old one, as WaveformLayer does)

     for (LayerSet::iterator i = m_layers.begin(); i != m_layers.end(); ++i) {
 
 	Layer *layer = *i;
 	Model *model = layer->getModel();
 
+        std::cerr << "Document::setMainModel: inspecting model "
+                  << (model ? model->objectName().toStdString() : "(null)") << " in layer "
+                  << layer->objectName().toStdString() << std::endl;
+
 	if (model == oldMainModel) {
+            std::cerr << "... it uses the old main model, replacing" << std::endl;
 	    LayerFactory::getInstance()->setModel(layer, m_mainModel);
 	    continue;
 	}
 
 	if (m_models.find(model) == m_models.end()) {

 	    obsoleteLayers.push_back(layer);
 	    continue;
 	}
 	    
 	if (m_models[model].source == oldMainModel) {
+
+            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.
 	    
 	    TransformName transform = m_models[model].transform;

                                                  transform);
                     failedTransforms.insert(transform);
                 }
 		obsoleteLayers.push_back(layer);
 	    } else {
+                std::cerr << "Replacing model " << model << " (type "
+                          << typeid(*model).name() << ") with model "
+                          << replacementModel << " (type "
+                          << typeid(*replacementModel).name() << ") in layer "
+                          << layer << " (name " << layer->objectName().toStdString() << ")"
+                          << std::endl;
+                RangeSummarisableTimeValueModel *rm =
+                    dynamic_cast<RangeSummarisableTimeValueModel *>(replacementModel);
+                if (rm) {
+                    std::cerr << "new model has " << rm->getChannelCount() << " channels " << std::endl;
+                } else {
+                    std::cerr << "new model is not a RangeSummarisableTimeValueModel!" << std::endl;
+                }
 		setModel(layer, replacementModel);
 	    }
 	}	    
     }
 

 		  << ": register the layer's model before setting it!"
 		  << std::endl;
 	return;
     }
 
-    if (layer->getModel()) {
-	if (layer->getModel() == model) {
-	    std::cerr << "WARNING: Document::setModel: Layer is already set to this model" << std::endl;
-	    return;
-	}
-	releaseModel(layer->getModel());
+    Model *previousModel = layer->getModel();
+
+    if (previousModel == model) {
+        std::cerr << "WARNING: Document::setModel: Layer is already set to this model" << std::endl;
+        return;
     }
 
     if (model && model != m_mainModel) {
 	m_models[model].refcount ++;
     }
 
     LayerFactory::getInstance()->setModel(layer, model);
+
+    if (previousModel) {
+        releaseModel(previousModel);
+    }
 }
 
 void
 Document::setChannel(Layer *layer, int channel)
 {