comparison view/View.cpp @ 835:7792b7667f74

Introduce (but don't yet populate) the fixed layers vector; rename m_layers to m_layerStack to reflect its ordering by stacking

 }
 
 int
 View::getPropertyContainerCount() const
 {
-    return m_layers.size() + 1; // the 1 is for me
+    return m_layerStack.size() + 1; // the 1 is for me
 }
 
 const PropertyContainer *
 View::getPropertyContainer(int i) const
 {

 
 PropertyContainer *
 View::getPropertyContainer(int i)
 {
     if (i == 0) return m_propertyContainer;
-    return m_layers[i-1];
+    return m_layerStack[i-1];
 }
 
 bool
 View::getValueExtents(QString unit, float &min, float &max, bool &log) const
 {
     bool have = false;
 
-    for (LayerList::const_iterator i = m_layers.begin();
-         i != m_layers.end(); ++i) { 
+    for (LayerList::const_iterator i = m_layerStack.begin();
+         i != m_layerStack.end(); ++i) { 
 
         QString layerUnit;
         float layerMin = 0.0, layerMax = 0.0;
         float displayMin = 0.0, displayMax = 0.0;
         bool layerLog = false;

 int
 View::getTextLabelHeight(const Layer *layer, QPainter &paint) const
 {
     std::map<int, Layer *> sortedLayers;
 
-    for (LayerList::const_iterator i = m_layers.begin();
-         i != m_layers.end(); ++i) { 
+    for (LayerList::const_iterator i = m_layerStack.begin();
+         i != m_layerStack.end(); ++i) { 
         if ((*i)->needsTextLabelHeight()) {
             sortedLayers[getObjectExportId(*i)] = *i;
         }
     }
 

     delete m_cache;
     m_cache = 0;
 
     Layer *selectedLayer = 0;
 
-    for (LayerList::iterator i = m_layers.begin(); i != m_layers.end(); ++i) {
+    for (LayerList::iterator i = m_layerStack.begin(); i != m_layerStack.end(); ++i) {
 	if (*i == pc) {
 	    selectedLayer = *i;
-	    m_layers.erase(i);
+	    m_layerStack.erase(i);
 	    break;
 	}
     }
 
     if (selectedLayer) {
 	m_haveSelectedLayer = true;
-	m_layers.push_back(selectedLayer);
+	m_layerStack.push_back(selectedLayer);
 	update();
     } else {
 	m_haveSelectedLayer = false;
     }
 

     if (m_manager) darkPalette = m_manager->getGlobalDarkBackground();
 
     Layer::ColourSignificance maxSignificance = Layer::ColourAbsent;
     bool mostSignificantHasDarkBackground = false;
     
-    for (LayerList::const_iterator i = m_layers.begin();
-         i != m_layers.end(); ++i) {
+    for (LayerList::const_iterator i = m_layerStack.begin();
+         i != m_layerStack.end(); ++i) {
 
         Layer::ColourSignificance s = (*i)->getLayerColourSignificance();
         bool light = (*i)->hasLightBackground();
 
         if (int(s) > int(maxSignificance)) {

     m_cache = 0;
 
     SingleColourLayer *scl = dynamic_cast<SingleColourLayer *>(layer);
     if (scl) scl->setDefaultColourFor(this);
 
-    m_layers.push_back(layer);
+    m_layerStack.push_back(layer);
 
     QProgressBar *pb = new QProgressBar(this);
     pb->setMinimum(0);
     pb->setMaximum(0);
     pb->setFixedWidth(80);

     }
 
     delete m_cache;
     m_cache = 0;
 
-    for (LayerList::iterator i = m_layers.begin(); i != m_layers.end(); ++i) {
+    for (LayerList::iterator i = m_layerStack.begin(); i != m_layerStack.end(); ++i) {
 	if (*i == layer) {
-	    m_layers.erase(i);
+	    m_layerStack.erase(i);
 	    if (m_progressBars.find(layer) != m_progressBars.end()) {
 		delete m_progressBars[layer].bar;
                 delete m_progressBars[layer].cancel;
 		delete m_progressBars[layer].checkTimer;
 		m_progressBars.erase(layer);

 {
     Layer *sl = getSelectedLayer();
     if (sl && !(sl->isLayerDormant(this))) {
         return sl;
     }
-    if (!m_layers.empty()) {
+    if (!m_layerStack.empty()) {
         int n = getLayerCount();
         while (n > 0) {
             --n;
             Layer *layer = getLayer(n);
             if (!(layer->isLayerDormant(this))) {

 }
 
 Layer *
 View::getSelectedLayer()
 {
-    if (m_haveSelectedLayer && !m_layers.empty()) {
+    if (m_haveSelectedLayer && !m_layerStack.empty()) {
         int n = getLayerCount();
         while (n > 0) {
             --n;
             Layer *layer = getLayer(n);
             if (!(layer->isLayerDormant(this))) {

 View::getModelsStartFrame() const
 {
     bool first = true;
     int startFrame = 0;
 
-    for (LayerList::const_iterator i = m_layers.begin(); i != m_layers.end(); ++i) {
+    for (LayerList::const_iterator i = m_layerStack.begin(); i != m_layerStack.end(); ++i) {
 
 	if ((*i)->getModel() && (*i)->getModel()->isOK()) {
 
 	    int thisStartFrame = (*i)->getModel()->getStartFrame();
 

 View::getModelsEndFrame() const
 {
     bool first = true;
     int endFrame = 0;
 
-    for (LayerList::const_iterator i = m_layers.begin(); i != m_layers.end(); ++i) {
+    for (LayerList::const_iterator i = m_layerStack.begin(); i != m_layerStack.end(); ++i) {
 
 	if ((*i)->getModel() && (*i)->getModel()->isOK()) {
 
 	    int thisEndFrame = (*i)->getModel()->getEndFrame();
 

     // multiple samplerates, we'd probably want to do frame/time
     // conversion in the model
 
     //!!! nah, this wants to always return the sr of the main model!
 
-    for (LayerList::const_iterator i = m_layers.begin(); i != m_layers.end(); ++i) {
+    for (LayerList::const_iterator i = m_layerStack.begin(); i != m_layerStack.end(); ++i) {
 	if ((*i)->getModel() && (*i)->getModel()->isOK()) {
 	    return (*i)->getModel()->getSampleRate();
 	}
     }
     return 0;

 
     Model *anyModel = 0;
     Model *alignedModel = 0;
     Model *goodModel = 0;
 
-    for (LayerList::const_iterator i = m_layers.begin();
-         i != m_layers.end(); ++i) {
+    for (LayerList::const_iterator i = m_layerStack.begin();
+         i != m_layerStack.end(); ++i) {
 
         Layer *layer = *i;
 
         if (!layer) continue;
         if (dynamic_cast<TimeRulerLayer *>(layer)) continue;

 
 bool
 View::areLayersScrollable() const
 {
     // True iff all views are scrollable
-    for (LayerList::const_iterator i = m_layers.begin(); i != m_layers.end(); ++i) {
+    for (LayerList::const_iterator i = m_layerStack.begin(); i != m_layerStack.end(); ++i) {
 	if (!(*i)->isLayerScrollable(this)) return false;
     }
     return true;
 }
 

     // backmost non-scrollable layer.
 
     LayerList scrollables;
     bool metUnscrollable = false;
 
-    for (LayerList::const_iterator i = m_layers.begin(); i != m_layers.end(); ++i) {
+    for (LayerList::const_iterator i = m_layerStack.begin(); i != m_layerStack.end(); ++i) {
 //        SVDEBUG << "View::getScrollableBackLayers: calling isLayerDormant on layer " << *i << endl;
 //        cerr << "(name is " << (*i)->objectName() << ")"
 //                  << endl;
 //        SVDEBUG << "View::getScrollableBackLayers: I am " << this << endl;
 	if ((*i)->isLayerDormant(this)) continue;

     // Everything in front of the first non-scrollable from the back
     // should also be considered non-scrollable
 
     bool started = false;
 
-    for (LayerList::const_iterator i = m_layers.begin(); i != m_layers.end(); ++i) {
+    for (LayerList::const_iterator i = m_layerStack.begin(); i != m_layerStack.end(); ++i) {
 	if ((*i)->isLayerDormant(this)) continue;
 	if (!started && (*i)->isLayerScrollable(this)) {
 	    continue;
 	}
 	started = true;

     int candidate = blockSize;
     bool haveCandidate = false;
 
     PowerOfSqrtTwoZoomConstraint defaultZoomConstraint;
 
-    for (LayerList::const_iterator i = m_layers.begin(); i != m_layers.end(); ++i) {
+    for (LayerList::const_iterator i = m_layerStack.begin(); i != m_layerStack.end(); ++i) {
 
 	const ZoomConstraint *zoomConstraint = (*i)->getZoomConstraint();
 	if (!zoomConstraint) zoomConstraint = &defaultZoomConstraint;
 
 	int thisBlockSize =

 }
 
 bool
 View::areLayerColoursSignificant() const
 {
-    for (LayerList::const_iterator i = m_layers.begin(); i != m_layers.end(); ++i) {
+    for (LayerList::const_iterator i = m_layerStack.begin(); i != m_layerStack.end(); ++i) {
 	if ((*i)->getLayerColourSignificance() ==
             Layer::ColourHasMeaningfulValue) return true;
         if ((*i)->isLayerOpaque()) break;
     }
     return false;
 }
 
 bool
 View::hasTopLayerTimeXAxis() const
 {
-    LayerList::const_iterator i = m_layers.end();
-    if (i == m_layers.begin()) return false;
+    LayerList::const_iterator i = m_layerStack.end();
+    if (i == m_layerStack.begin()) return false;
     --i;
     return (*i)->hasTimeXAxis();
 }
 
 void

 View::paintEvent(QPaintEvent *e)
 {
 //    Profiler prof("View::paintEvent", false);
 //    cerr << "View::paintEvent: centre frame is " << m_centreFrame << endl;
 
-    if (m_layers.empty()) {
+    if (m_layerStack.empty()) {
 	QFrame::paintEvent(e);
 	return;
     }
 
     // ensure our constraints are met

 
     int origCentreFrame = m_centreFrame;
 
     bool someLayersIncomplete = false;
 
-    for (LayerList::iterator i = m_layers.begin();
-         i != m_layers.end(); ++i) {
+    for (LayerList::iterator i = m_layerStack.begin();
+         i != m_layerStack.end(); ++i) {
 
         int c = (*i)->getCompletion(this);
         if (c < 100) {
             someLayersIncomplete = true;
             break;

         
         int layerCompletion = 0;
 
         while (layerCompletion < 100) {
 
-            for (LayerList::iterator i = m_layers.begin();
-                 i != m_layers.end(); ++i) {
+            for (LayerList::iterator i = m_layerStack.begin();
+                 i != m_layerStack.end(); ++i) {
 
                 int c = (*i)->getCompletion(this);
-                if (i == m_layers.begin() || c < layerCompletion) {
+                if (i == m_layerStack.begin() || c < layerCompletion) {
                     layerCompletion = c;
                 }
             }
 
             if (layerCompletion >= 100) break;

 	paint.drawRect(QRect(xorigin + x, 0, width(), height()));
 
 	paint.setPen(getForeground());
 	paint.setBrush(Qt::NoBrush);
 
-	for (LayerList::iterator i = m_layers.begin();
-             i != m_layers.end(); ++i) {
+	for (LayerList::iterator i = m_layerStack.begin();
+             i != m_layerStack.end(); ++i) {
 		if(!((*i)->isLayerDormant(this))){
 
 		    paint.setRenderHint(QPainter::Antialiasing, false);
 
 		    paint.save();

 	     m_followPlay == PlaybackScrollPageWithCentre ? "page" :
 	     m_followPlay == PlaybackScrollPage ? "daw" :
              "ignore")
 	.arg(extraAttributes);
 
-    for (int i = 0; i < (int)m_layers.size(); ++i) {
-        bool visible = !m_layers[i]->isLayerDormant(this);
-        m_layers[i]->toBriefXml(stream, indent + "  ",
+    for (int i = 0; i < (int)m_layerStack.size(); ++i) {
+        bool visible = !m_layerStack[i]->isLayerDormant(this);
+        m_layerStack[i]->toBriefXml(stream, indent + "  ",
                                 QString("visible=\"%1\"")
                                 .arg(visible ? "true" : "false"));
     }
 
     stream << indent + "</view>\n";