comparison framework/Document.cpp @ 78:58bfaaed07ed

* Part of #1877436 transform fails to re-run when file loaded at different rate

 
 Layer *
 Document::createDerivedLayer(const Transform &transform,
                              const ModelTransformer::Input &input)
 {
-    Model *newModel = addDerivedModel(transform, input);
+    QString message;
+    Model *newModel = addDerivedModel(transform, input, message);
     if (!newModel) {
-        // error already printed to stderr by addDerivedModel
-        emit modelGenerationFailed(transform.getIdentifier());
+        emit modelGenerationFailed(transform.getIdentifier(), message);
         return 0;
+    } else if (message != "") {
+        emit modelGenerationWarning(transform.getIdentifier(), message);
     }
 
     LayerFactory::LayerTypeSet types =
 	LayerFactory::getInstance()->getValidLayerTypes(newModel);
 

             QString transformId = transform.getIdentifier();
 	    
             //!!! We have a problem here if the number of channels in
             //the main model has changed.
 
+            QString message;
 	    Model *replacementModel =
                 addDerivedModel(transform,
                                 ModelTransformer::Input
-                                (m_mainModel,
-                                 m_models[model].channel));
+                                (m_mainModel, m_models[model].channel),
+                                message);
 	    
 	    if (!replacementModel) {
 		std::cerr << "WARNING: Document::setMainModel: Failed to regenerate model for transform \""
 			  << transformId.toStdString() << "\"" << " in layer " << layer << std::endl;
                 if (failedTransformers.find(transformId)
                     == failedTransformers.end()) {
                     emit modelRegenerationFailed(layer->objectName(),
-                                                 transformId);
+                                                 transformId,
+                                                 message);
                     failedTransformers.insert(transformId);
                 }
 		obsoleteLayers.push_back(layer);
 	    } else {
+                if (message != "") {
+                    emit modelRegenerationWarning(layer->objectName(),
+                                                  transformId,
+                                                  message);
+                }
 #ifdef DEBUG_DOCUMENT
                 std::cerr << "Replacing model " << model << " (type "
                           << typeid(*model).name() << ") with model "
                           << replacementModel << " (type "
                           << typeid(*replacementModel).name() << ") in layer "

     emit modelAdded(model);
 }
 
 Model *
 Document::addDerivedModel(const Transform &transform,
-                          const ModelTransformer::Input &input)
+                          const ModelTransformer::Input &input,
+                          QString &message)
 {
     Model *model = 0;
 
     for (ModelMap::iterator i = m_models.begin(); i != m_models.end(); ++i) {
 	if (i->second.transform == transform &&

             i->second.channel == input.getChannel()) {
 	    return i->first;
 	}
     }
 
-    model = ModelTransformerFactory::getInstance()->transform(transform, input);
+    model = ModelTransformerFactory::getInstance()->transform
+        (transform, input, message);
 
     if (!model) {
 	std::cerr << "WARNING: Document::addDerivedModel: no output model for transform " << transform.getIdentifier().toStdString() << std::endl;
     } else {
 	addDerivedModel(transform, input, model);

 //!!!    QString args = "<plugin param-serialise=\"1\"/>";
 //    Model *transformOutput = factory->transform(id, aggregate, context, args);
 
     ModelTransformerFactory *mtf = ModelTransformerFactory::getInstance();
 
-    Model *transformOutput = mtf->transform(transform, aggregate);
+    QString message;
+    Model *transformOutput = mtf->transform(transform, aggregate, message);
 
     if (!transformOutput) {
         transform.setStepSize(0);
-        transformOutput = mtf->transform(transform, aggregate);
+        transformOutput = mtf->transform(transform, aggregate, message);
     }
 
     SparseTimeValueModel *path = dynamic_cast<SparseTimeValueModel *>
         (transformOutput);
 
     if (!path) {
         std::cerr << "Document::alignModel: ERROR: Failed to create alignment path (no MATCH plugin?)" << std::endl;
+        emit alignmentFailed(id, message);
         delete transformOutput;
         delete aggregate;
         return;
     }