comparison framework/Document.cpp @ 595:b23bebfdfaba

Untabify

     
 #ifdef DEBUG_DOCUMENT
     SVDEBUG << "Document::~Document: about to delete layers" << endl;
 #endif
     while (!m_layers.empty()) {
-	deleteLayer(*m_layers.begin(), true);
+        deleteLayer(*m_layers.begin(), true);
     }
 
     if (!m_models.empty()) {
-	SVDEBUG << "Document::~Document: WARNING: " 
-		  << m_models.size() << " model(s) still remain -- "
-		  << "should have been garbage collected when deleting layers"
-		  << endl;
-	while (!m_models.empty()) {
+        SVDEBUG << "Document::~Document: WARNING: " 
+                  << m_models.size() << " model(s) still remain -- "
+                  << "should have been garbage collected when deleting layers"
+                  << endl;
+        while (!m_models.empty()) {
             Model *model = m_models.begin()->first;
-	    if (model == m_mainModel) {
-		// just in case!
-		SVDEBUG << "Document::~Document: WARNING: Main model is also"
-			  << " in models list!" << endl;
-	    } else if (model) {
+            if (model == m_mainModel) {
+                // just in case!
+                SVDEBUG << "Document::~Document: WARNING: Main model is also"
+                          << " in models list!" << endl;
+            } else if (model) {
                 model->aboutToDelete();
-		emit modelAboutToBeDeleted(model);
-		delete model;
-	    }
-	    m_models.erase(m_models.begin());
-	}
+                emit modelAboutToBeDeleted(model);
+                delete model;
+            }
+            m_models.erase(m_models.begin());
+        }
     }
 
 #ifdef DEBUG_DOCUMENT
     SVDEBUG << "Document::~Document: About to get rid of main model"
-	      << endl;
+              << endl;
 #endif
     if (m_mainModel) {
         m_mainModel->aboutToDelete();
         emit modelAboutToBeDeleted(m_mainModel);
     }

 
 Layer *
 Document::createImportedLayer(Model *model)
 {
     LayerFactory::LayerTypeSet types =
-	LayerFactory::getInstance()->getValidLayerTypes(model);
+        LayerFactory::getInstance()->getValidLayerTypes(model);
 
     if (types.empty()) {
-	cerr << "WARNING: Document::importLayer: no valid display layer for model" << endl;
-	return 0;
+        cerr << "WARNING: Document::importLayer: no valid display layer for model" << endl;
+        return 0;
     }
 
     //!!! for now, just use the first suitable layer type
     LayerFactory::LayerType type = *types.begin();
 

 Document::createEmptyLayer(LayerFactory::LayerType type)
 {
     if (!m_mainModel) return 0;
 
     Model *newModel =
-	LayerFactory::getInstance()->createEmptyModel(type, m_mainModel);
+        LayerFactory::getInstance()->createEmptyModel(type, m_mainModel);
     if (!newModel) return 0;
 
     Layer *newLayer = createLayer(type);
     if (!newLayer) {
-	delete newModel;
-	return 0;
+        delete newModel;
+        return 0;
     }
 
     addImportedModel(newModel);
     setModel(newLayer, newModel);
 
     return newLayer;
 }
 
 Layer *
 Document::createDerivedLayer(LayerFactory::LayerType type,
-			     TransformId transform)
+                             TransformId transform)
 {
     Layer *newLayer = createLayer(type);
     if (!newLayer) return 0;
 
     newLayer->setObjectName(getUniqueLayerName

     cerr << "Old main model: " << oldMainModel << endl;
 #endif
 
     for (LayerSet::iterator i = m_layers.begin(); i != m_layers.end(); ++i) {
 
-	Layer *layer = *i;
-	Model *model = layer->getModel();
+        Layer *layer = *i;
+        Model *model = layer->getModel();
 
 #ifdef DEBUG_DOCUMENT
         cerr << "Document::setMainModel: inspecting model "
                   << (model ? model->objectName(): "(null)") << " in layer "
                   << layer->objectName() << endl;
 #endif
 
-	if (model == oldMainModel) {
+        if (model == oldMainModel) {
 #ifdef DEBUG_DOCUMENT
             cerr << "... it uses the old main model, replacing" << endl;
 #endif
-	    LayerFactory::getInstance()->setModel(layer, m_mainModel);
-	    continue;
-	}
+            LayerFactory::getInstance()->setModel(layer, m_mainModel);
+            continue;
+        }
 
         if (!model) {
             cerr << "WARNING: Document::setMainModel: Null model in layer "
                       << layer << endl;
-	    // get rid of this hideous degenerate
-	    obsoleteLayers.push_back(layer);
-	    continue;
-	}
-
-	if (m_models.find(model) == m_models.end()) {
-	    cerr << "WARNING: Document::setMainModel: Unknown model "
-		      << model << " in layer " << layer << endl;
-	    // and this one
-	    obsoleteLayers.push_back(layer);
-	    continue;
-	}
-	    
-	if (m_models[model].source &&
+            // get rid of this hideous degenerate
+            obsoleteLayers.push_back(layer);
+            continue;
+        }
+
+        if (m_models.find(model) == m_models.end()) {
+            cerr << "WARNING: Document::setMainModel: Unknown model "
+                      << model << " in layer " << layer << endl;
+            // and this one
+            obsoleteLayers.push_back(layer);
+            continue;
+        }
+            
+        if (m_models[model].source &&
             (m_models[model].source == oldMainModel)) {
 
 #ifdef DEBUG_DOCUMENT
             cerr << "... it uses a model derived from the old main model, regenerating" << endl;
 #endif
 
-	    // This model was derived from the previous main
-	    // model: regenerate it.
-	    
-	    const Transform &transform = m_models[model].transform;
+            // This model was derived from the previous main
+            // model: regenerate it.
+            
+            const Transform &transform = m_models[model].transform;
             QString transformId = transform.getIdentifier();
-	    
+            
             //!!! We have a problem here if the number of channels in
             //the main model has changed.
 
             QString message;
-	    Model *replacementModel =
+            Model *replacementModel =
                 addDerivedModel(transform,
                                 ModelTransformer::Input
                                 (m_mainModel, m_models[model].channel),
                                 message);
-	    
-	    if (!replacementModel) {
-		cerr << "WARNING: Document::setMainModel: Failed to regenerate model for transform \""
-			  << transformId << "\"" << " in layer " << layer << endl;
+            
+            if (!replacementModel) {
+                cerr << "WARNING: Document::setMainModel: Failed to regenerate model for transform \""
+                          << transformId << "\"" << " in layer " << layer << endl;
                 if (failedTransformers.find(transformId)
                     == failedTransformers.end()) {
                     emit modelRegenerationFailed(layer->objectName(),
                                                  transformId,
                                                  message);
                     failedTransformers.insert(transformId);
                 }
-		obsoleteLayers.push_back(layer);
-	    } else {
+                obsoleteLayers.push_back(layer);
+            } else {
                 if (message != "") {
                     emit modelRegenerationWarning(layer->objectName(),
                                                   transformId,
                                                   message);
                 }

                     cerr << "new model has " << rm->getChannelCount() << " channels " << endl;
                 } else {
                     cerr << "new model " << replacementModel << " is not a RangeSummarisableTimeValueModel!" << endl;
                 }
 #endif
-		setModel(layer, replacementModel);
-	    }
-	}	    
+                setModel(layer, replacementModel);
+            }
+        }            
     }
 
     for (size_t k = 0; k < obsoleteLayers.size(); ++k) {
-	deleteLayer(obsoleteLayers[k], true);
+        deleteLayer(obsoleteLayers[k], true);
     }
 
     for (ModelMap::iterator i = m_models.begin(); i != m_models.end(); ++i) {
         if (i->second.additional) {
             Model *m = i->first;

 Document::addAlreadyDerivedModel(const Transform &transform,
                                  const ModelTransformer::Input &input,
                                  Model *outputModelToAdd)
 {
     if (m_models.find(outputModelToAdd) != m_models.end()) {
-	cerr << "WARNING: Document::addAlreadyDerivedModel: Model already added"
-		  << endl;
-	return;
+        cerr << "WARNING: Document::addAlreadyDerivedModel: Model already added"
+                  << endl;
+        return;
     }
 
 #ifdef DEBUG_DOCUMENT
     if (input.getModel()) {
         cerr << "Document::addAlreadyDerivedModel: source is " << input.getModel() << " \"" << input.getModel()->objectName() << "\"" << endl;

 
 void
 Document::addImportedModel(Model *model)
 {
     if (m_models.find(model) != m_models.end()) {
-	cerr << "WARNING: Document::addImportedModel: Model already added"
-		  << endl;
-	return;
+        cerr << "WARNING: Document::addImportedModel: Model already added"
+                  << endl;
+        return;
     }
 
     ModelRecord rec;
     rec.source = 0;
     rec.channel = 0;

 
 void
 Document::addAdditionalModel(Model *model)
 {
     if (m_models.find(model) != m_models.end()) {
-	cerr << "WARNING: Document::addAdditionalModel: Model already added"
-		  << endl;
-	return;
+        cerr << "WARNING: Document::addAdditionalModel: Model already added"
+                  << endl;
+        return;
     }
 
     ModelRecord rec;
     rec.source = 0;
     rec.channel = 0;

             cerr << "WARNING: Document::addDerivedModel: no output model for transform " << applied.getIdentifier() << endl;
         } else {
             addAlreadyDerivedModel(applied, input, model);
         }
     }
-	
+        
     return mm;
 }
 
 void
 Document::releaseModel(Model *model) // Will _not_ release main model!
 {
     if (model == 0) {
-	return;
+        return;
     }
 
     if (model == m_mainModel) {
-	return;
+        return;
     }
 
     bool toDelete = false;
 
     if (m_models.find(model) != m_models.end()) {
-	if (m_models[model].refcount == 0) {
-	    SVCERR << "WARNING: Document::releaseModel: model " << model
+        if (m_models[model].refcount == 0) {
+            SVCERR << "WARNING: Document::releaseModel: model " << model
                    << " reference count is zero already!" << endl;
-	} else {
-	    if (--m_models[model].refcount == 0) {
-		toDelete = true;
-	    }
-	}
+        } else {
+            if (--m_models[model].refcount == 0) {
+                toDelete = true;
+            }
+        }
     } else if (m_aggregateModels.find(model) != m_aggregateModels.end()) {
         SVDEBUG << "Document::releaseModel: is an aggregate model" << endl;
         toDelete = true;
     } else { 
-	SVCERR << "WARNING: Document::releaseModel: Unfound model "
+        SVCERR << "WARNING: Document::releaseModel: Unfound model "
                << model << endl;
-	toDelete = true;
+        toDelete = true;
     }
 
     if (toDelete) {
 
-	int sourceCount = 0;
-
-	for (ModelMap::iterator i = m_models.begin(); i != m_models.end(); ++i) {
-	    if (i->second.source == model) {
-		++sourceCount;
-		i->second.source = 0;
-	    }
-	}
-
-	if (sourceCount > 0) {
-	    SVDEBUG << "Document::releaseModel: Deleting model "
+        int sourceCount = 0;
+
+        for (ModelMap::iterator i = m_models.begin(); i != m_models.end(); ++i) {
+            if (i->second.source == model) {
+                ++sourceCount;
+                i->second.source = 0;
+            }
+        }
+
+        if (sourceCount > 0) {
+            SVDEBUG << "Document::releaseModel: Deleting model "
                     << model << " even though it is source for "
                     << sourceCount << " other derived model(s) -- resetting "
                     << "their source fields appropriately" << endl;
-	}
+        }
 
         model->aboutToDelete();
-	emit modelAboutToBeDeleted(model);
-	m_models.erase(model);
+        emit modelAboutToBeDeleted(model);
+        m_models.erase(model);
 
 #ifdef DEBUG_DOCUMENT
         SVDEBUG << "Document::releaseModel: Deleted model " << model << endl;
         cerr << "Models now: ";
         for (ModelMap::const_iterator i = m_models.begin(); i != m_models.end(); ++i) {
             cerr << i->first << " ";
         } 
         cerr << endl;
 #endif
 
-	delete model;
+        delete model;
     }
 }
 
 void
 Document::deleteLayer(Layer *layer, bool force)
 {
     if (m_layerViewMap.find(layer) != m_layerViewMap.end() &&
-	m_layerViewMap[layer].size() > 0) {
-
-	cerr << "WARNING: Document::deleteLayer: Layer "
-		  << layer << " [" << layer->objectName() << "]"
-		  << " is still used in " << m_layerViewMap[layer].size()
-		  << " views!" << endl;
-
-	if (force) {
-
-#ifdef DEBUG_DOCUMENT
-	    cerr << "(force flag set -- deleting from all views)" << endl;
-#endif
-
-	    for (std::set<View *>::iterator j = m_layerViewMap[layer].begin();
-		 j != m_layerViewMap[layer].end(); ++j) {
-		// don't use removeLayerFromView, as it issues a command
-		layer->setLayerDormant(*j, true);
-		(*j)->removeLayer(layer);
-	    }
-	    
-	    m_layerViewMap.erase(layer);
-
-	} else {
-	    return;
-	}
+        m_layerViewMap[layer].size() > 0) {
+
+        cerr << "WARNING: Document::deleteLayer: Layer "
+                  << layer << " [" << layer->objectName() << "]"
+                  << " is still used in " << m_layerViewMap[layer].size()
+                  << " views!" << endl;
+
+        if (force) {
+
+#ifdef DEBUG_DOCUMENT
+            cerr << "(force flag set -- deleting from all views)" << endl;
+#endif
+
+            for (std::set<View *>::iterator j = m_layerViewMap[layer].begin();
+                 j != m_layerViewMap[layer].end(); ++j) {
+                // don't use removeLayerFromView, as it issues a command
+                layer->setLayerDormant(*j, true);
+                (*j)->removeLayer(layer);
+            }
+            
+            m_layerViewMap.erase(layer);
+
+        } else {
+            return;
+        }
     }
 
     if (m_layers.find(layer) == m_layers.end()) {
-	SVDEBUG << "Document::deleteLayer: Layer "
+        SVDEBUG << "Document::deleteLayer: Layer "
                   << layer << " (" << typeid(layer).name() <<
                   ") does not exist, or has already been deleted "
-		  << "(this may not be as serious as it sounds)" << endl;
-	return;
+                  << "(this may not be as serious as it sounds)" << endl;
+        return;
     }
 
     m_layers.erase(layer);
 
 #ifdef DEBUG_DOCUMENT

 
 void
 Document::setModel(Layer *layer, Model *model)
 {
     if (model && 
-	model != m_mainModel &&
-	m_models.find(model) == m_models.end()) {
-	cerr << "ERROR: Document::setModel: Layer " << layer
-		  << " (\"" << layer->objectName()
+        model != m_mainModel &&
+        m_models.find(model) == m_models.end()) {
+        cerr << "ERROR: Document::setModel: Layer " << layer
+                  << " (\"" << layer->objectName()
                   << "\") wants to use unregistered model " << model
-		  << ": register the layer's model before setting it!"
-		  << endl;
-	return;
+                  << ": register the layer's model before setting it!"
+                  << endl;
+        return;
     }
 
     Model *previousModel = layer->getModel();
 
     if (previousModel == model) {

                   << "\")" << endl;
         return;
     }
 
     if (model && model != m_mainModel) {
-	m_models[model].refcount ++;
+        m_models[model].refcount ++;
     }
 
     if (model && previousModel) {
         PlayParameterRepository::getInstance()->copyParameters
             (previousModel, model);
     }
 
     LayerFactory::getInstance()->setModel(layer, model);
-	// std::cerr << "layer type: " << LayerFactory::getInstance()->getLayerTypeName(LayerFactory::getInstance()->getLayerType(layer)) << std::endl;
+        // std::cerr << "layer type: " << LayerFactory::getInstance()->getLayerTypeName(LayerFactory::getInstance()->getLayerType(layer)) << std::endl;
 
     if (previousModel) {
         releaseModel(previousModel);
     }
 }

 Document::addLayerToView(View *view, Layer *layer)
 {
     Model *model = layer->getModel();
     if (!model) {
 #ifdef DEBUG_DOCUMENT
-	SVDEBUG << "Document::addLayerToView: Layer (\""
+        SVDEBUG << "Document::addLayerToView: Layer (\""
                   << layer->objectName()                  << "\") with no model being added to view: "
                   << "normally you want to set the model first" << endl;
 #endif
     } else {
-	if (model != m_mainModel &&
-	    m_models.find(model) == m_models.end()) {
-	    cerr << "ERROR: Document::addLayerToView: Layer " << layer
-		      << " has unregistered model " << model
-		      << " -- register the layer's model before adding the layer!" << endl;
-	    return;
-	}
+        if (model != m_mainModel &&
+            m_models.find(model) == m_models.end()) {
+            cerr << "ERROR: Document::addLayerToView: Layer " << layer
+                      << " has unregistered model " << model
+                      << " -- register the layer's model before adding the layer!" << endl;
+            return;
+        }
     }
 
     CommandHistory::getInstance()->addCommand
-	(new Document::AddLayerCommand(this, view, layer));
+        (new Document::AddLayerCommand(this, view, layer));
 }
 
 void
 Document::removeLayerFromView(View *view, Layer *layer)
 {
     CommandHistory::getInstance()->addCommand
-	(new Document::RemoveLayerCommand(this, view, layer));
+        (new Document::RemoveLayerCommand(this, view, layer));
 }
 
 void
 Document::addToLayerViewMap(Layer *layer, View *view)
 {
     bool firstView = (m_layerViewMap.find(layer) == m_layerViewMap.end() ||
                       m_layerViewMap[layer].empty());
 
     if (m_layerViewMap[layer].find(view) !=
-	m_layerViewMap[layer].end()) {
-	cerr << "WARNING: Document::addToLayerViewMap:"
-		  << " Layer " << layer << " -> view " << view << " already in"
-		  << " layer view map -- internal inconsistency" << endl;
+        m_layerViewMap[layer].end()) {
+        cerr << "WARNING: Document::addToLayerViewMap:"
+                  << " Layer " << layer << " -> view " << view << " already in"
+                  << " layer view map -- internal inconsistency" << endl;
     }
 
     m_layerViewMap[layer].insert(view);
 
     if (firstView) emit layerInAView(layer, true);

     
 void
 Document::removeFromLayerViewMap(Layer *layer, View *view)
 {
     if (m_layerViewMap[layer].find(view) ==
-	m_layerViewMap[layer].end()) {
-	cerr << "WARNING: Document::removeFromLayerViewMap:"
-		  << " Layer " << layer << " -> view " << view << " not in"
-		  << " layer view map -- internal inconsistency" << endl;
+        m_layerViewMap[layer].end()) {
+        cerr << "WARNING: Document::removeFromLayerViewMap:"
+                  << " Layer " << layer << " -> view " << view << " not in"
+                  << " layer view map -- internal inconsistency" << endl;
     }
 
     m_layerViewMap[layer].erase(view);
 
     if (m_layerViewMap[layer].empty()) {

     }
     alignModel(m_mainModel);
 }
 
 Document::AddLayerCommand::AddLayerCommand(Document *d,
-					   View *view,
-					   Layer *layer) :
+                                           View *view,
+                                           Layer *layer) :
     m_d(d),
     m_view(view),
     m_layer(layer),
     m_name(qApp->translate("AddLayerCommand", "Add %1 Layer").arg(layer->objectName())),
     m_added(false)

 {
 #ifdef DEBUG_DOCUMENT
     SVDEBUG << "Document::AddLayerCommand::~AddLayerCommand" << endl;
 #endif
     if (!m_added) {
-	m_d->deleteLayer(m_layer);
+        m_d->deleteLayer(m_layer);
     }
 }
 
 QString
 Document::AddLayerCommand::getName() const

 
 void
 Document::AddLayerCommand::execute()
 {
     for (int i = 0; i < m_view->getLayerCount(); ++i) {
-	if (m_view->getLayer(i) == m_layer) {
-	    // already there
-	    m_layer->setLayerDormant(m_view, false);
-	    m_added = true;
-	    return;
-	}
+        if (m_view->getLayer(i) == m_layer) {
+            // already there
+            m_layer->setLayerDormant(m_view, false);
+            m_added = true;
+            return;
+        }
     }
 
     m_view->addLayer(m_layer);
     m_layer->setLayerDormant(m_view, false);
 

     m_d->removeFromLayerViewMap(m_layer, m_view);
     m_added = false;
 }
 
 Document::RemoveLayerCommand::RemoveLayerCommand(Document *d,
-						 View *view,
-						 Layer *layer) :
+                                                 View *view,
+                                                 Layer *layer) :
     m_d(d),
     m_view(view),
     m_layer(layer),
     m_wasDormant(layer->isLayerDormant(view)),
     m_name(qApp->translate("RemoveLayerCommand", "Delete %1 Layer").arg(layer->objectName())),

 {
 #ifdef DEBUG_DOCUMENT
     SVDEBUG << "Document::RemoveLayerCommand::~RemoveLayerCommand" << endl;
 #endif
     if (!m_added) {
-	m_d->deleteLayer(m_layer);
+        m_d->deleteLayer(m_layer);
     }
 }
 
 QString
 Document::RemoveLayerCommand::getName() const

 void
 Document::RemoveLayerCommand::execute()
 {
     bool have = false;
     for (int i = 0; i < m_view->getLayerCount(); ++i) {
-	if (m_view->getLayer(i) == m_layer) {
-	    have = true;
-	    break;
-	}
+        if (m_view->getLayer(i) == m_layer) {
+            have = true;
+            break;
+        }
     }
 
     if (!have) { // not there!
-	m_layer->setLayerDormant(m_view, true);
-	m_added = false;
-	return;
+        m_layer->setLayerDormant(m_view, true);
+        m_added = false;
+        return;
     }
 
     m_view->removeLayer(m_layer);
     m_layer->setLayerDormant(m_view, true);
 

     }
 
     std::set<Model *> written;
 
     for (ModelMap::const_iterator i = m_models.begin();
-	 i != m_models.end(); ++i) {
+         i != m_models.end(); ++i) {
 
         Model *model = i->first;
-	const ModelRecord &rec = i->second;
+        const ModelRecord &rec = i->second;
 
         if (used.find(model) == used.end()) continue;
         
         // We need an intelligent way to determine which models need
         // to be streamed (i.e. have been edited, or are small) and

         if (writeModel) {
             model->toXml(out, indent + "  ");
             written.insert(model);
         }
 
-	if (haveDerivation) {
+        if (haveDerivation) {
             writeBackwardCompatibleDerivation(out, indent + "  ",
                                               model, rec);
-	}
+        }
 
         //!!! We should probably own the PlayParameterRepository
         PlayParameters *playParameters =
             PlayParameterRepository::getInstance()->getPlayParameters(model);
         if (playParameters) {

     // and aligned models, and then streams its path model.  Note that
     // this will only work when the alignment is complete, so we
     // should probably wait for it if it isn't already by this point.
 
     for (std::set<Model *>::const_iterator i = written.begin();
-	 i != written.end(); ++i) {
+         i != written.end(); ++i) {
 
         const Model *model = *i;
         const AlignmentModel *alignment = model->getAlignment();
         if (!alignment) continue;
 
         alignment->toXml(out, indent + "  ");
     }
 
     for (LayerSet::const_iterator i = m_layers.begin();
-	 i != m_layers.end(); ++i) {
-
-	(*i)->toXml(out, indent + "  ");
+         i != m_layers.end(); ++i) {
+
+        (*i)->toXml(out, indent + "  ");
     }
 
     out << indent + "</data>\n";
 }
 

             .arg(RealTime::realTime2Frame(transform.getStartTime(),
                                           targetModel->getSampleRate()))
             .arg(RealTime::realTime2Frame(transform.getDuration(),
                                           targetModel->getSampleRate()));
     }
-	    
+            
     out << indent;
     out << QString("<derivation type=\"transform\" source=\"%1\" "
                    "model=\"%2\" channel=\"%3\" domain=\"%4\" "
                    "stepSize=\"%5\" blockSize=\"%6\" %7windowType=\"%8\" "
                    "transform=\"%9\">\n")