comparison view/View.cpp @ 1475:84c4ddb38415 by-id

Further layer updates

     bool widgetLight =
         (widgetbg.red() + widgetbg.green() + widgetbg.blue()) > 384;
 
     if (widgetLight == light) {
         if (widgetLight) {
-            return widgetbg.light();
+            return widgetbg.lighter();
         } else {
-            return widgetbg.dark();
+            return widgetbg.darker();
         }
     }
     else if (light) return Qt::white;
     else return Qt::black;
 }

 }
 
 void
 View::modelChanged()
 {
-    QObject *obj = sender();
-
 #ifdef DEBUG_VIEW_WIDGET_PAINT
     cerr << "View(" << this << ")::modelChanged()" << endl;
 #endif
+
+    QObject *obj = sender();
+    
+    ModelId model;
+    if (Model *modelPtr = qobject_cast<Model *>(obj)) {
+        model = modelPtr->getId();
+    } else if (Layer *layerPtr = qobject_cast<Layer *>(obj)) {
+        model = layerPtr->getModel();
+    } else {
+        return;
+    }
     
     // If the model that has changed is not used by any of the cached
     // layers, we won't need to recreate the cache
     
     bool recreate = false;
 
     bool discard;
     LayerList scrollables = getScrollableBackLayers(false, discard);
     for (LayerList::const_iterator i = scrollables.begin();
          i != scrollables.end(); ++i) {
-        if (*i == obj || (*i)->getModel() == obj) {
+        if ((*i)->getModel() == model) {
             recreate = true;
             break;
         }
     }
 

 
 void
 View::modelChangedWithin(sv_frame_t startFrame, sv_frame_t endFrame)
 {
     QObject *obj = sender();
+    
+    ModelId model;
+    if (Model *modelPtr = qobject_cast<Model *>(obj)) {
+        model = modelPtr->getId();
+    } else if (Layer *layerPtr = qobject_cast<Layer *>(obj)) {
+        model = layerPtr->getModel();
+    } else {
+        return;
+    }
 
     sv_frame_t myStartFrame = getStartFrame();
     sv_frame_t myEndFrame = getEndFrame();
 
 #ifdef DEBUG_VIEW_WIDGET_PAINT

 
     bool discard;
     LayerList scrollables = getScrollableBackLayers(false, discard);
     for (LayerList::const_iterator i = scrollables.begin();
          i != scrollables.end(); ++i) {
-        if (*i == obj || (*i)->getModel() == obj) {
+        if ((*i)->getModel() == model) {
             recreate = true;
             break;
         }
     }
 

 View::getModelsStartFrame() const
 {
     bool first = true;
     sv_frame_t startFrame = 0;
 
-    for (LayerList::const_iterator i = m_layerStack.begin(); i != m_layerStack.end(); ++i) {
-
-        if ((*i)->getModel() && (*i)->getModel()->isOK()) {
-
-            sv_frame_t thisStartFrame = (*i)->getModel()->getStartFrame();
+    for (Layer *layer: m_layerStack) {
+
+        auto model = ModelById::get(layer->getModel());
+
+        if (model && model->isOK()) {
+
+            sv_frame_t thisStartFrame = model->getStartFrame();
 
             if (first || thisStartFrame < startFrame) {
                 startFrame = thisStartFrame;
             }
             first = false;
         }
     }
+    
     return startFrame;
 }
 
 sv_frame_t
 View::getModelsEndFrame() const
 {
     bool first = true;
     sv_frame_t endFrame = 0;
 
-    for (LayerList::const_iterator i = m_layerStack.begin(); i != m_layerStack.end(); ++i) {
-
-        if ((*i)->getModel() && (*i)->getModel()->isOK()) {
-
-            sv_frame_t thisEndFrame = (*i)->getModel()->getEndFrame();
+    for (Layer *layer: m_layerStack) {
+
+        auto model = ModelById::get(layer->getModel());
+
+        if (model && model->isOK()) {
+
+            sv_frame_t thisEndFrame = model->getEndFrame();
 
             if (first || thisEndFrame > endFrame) {
                 endFrame = thisEndFrame;
             }
             first = false;

     // 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_layerStack.begin(); i != m_layerStack.end(); ++i) {
-        if ((*i)->getModel() && (*i)->getModel()->isOK()) {
-            return (*i)->getModel()->getSampleRate();
-        }
-    }
+    for (Layer *layer: m_layerStack) {
+
+        auto model = ModelById::get(layer->getModel());
+
+        if (model && model->isOK()) {
+            return model->getSampleRate();
+        }
+    }
+
     return 0;
 }
 
 View::ModelSet
 View::getModels()

 
         if (dynamic_cast<TimeRulerLayer *>(layer)) {
             continue;
         }
 
-        if (layer && layer->getModel()) {
-            Model *model = layer->getModel();
-            models.insert(model);
+        if (layer && !layer->getModel().isNone()) {
+            models.insert(layer->getModel());
         }
     }
 
     return models;
 }
 
-Model *
+ModelId
 View::getAligningModel() const
 {
     if (!m_manager ||
         !m_manager->getAlignMode() ||
         !m_manager->getPlaybackModel()) {
-        return nullptr;
-    }
-
-    Model *anyModel = nullptr;
-    Model *alignedModel = nullptr;
-    Model *goodModel = nullptr;
-
-    for (LayerList::const_iterator i = m_layerStack.begin();
-         i != m_layerStack.end(); ++i) {
-
-        Layer *layer = *i;
+        return {};
+    }
+
+    ModelId anyModel;
+    ModelId alignedModel;
+    ModelId goodModel;
+
+    for (auto layer: m_layerStack) {
 
         if (!layer) continue;
         if (dynamic_cast<TimeRulerLayer *>(layer)) continue;
 
-        Model *model = (*i)->getModel();
+        auto model = ModelById::get(layer->getModel());
         if (!model) continue;
 
-        anyModel = model;
-
-        if (model->getAlignmentReference()) {
-            alignedModel = model;
+        anyModel = model->getId();
+
+        if (!model->getAlignmentReference().isNone()) {
+            alignedModel = model->getId();
             if (layer->isLayerOpaque() ||
-                dynamic_cast<RangeSummarisableTimeValueModel *>(model)) {
-                goodModel = model;
-            }
-        }
-    }
-
-    if (goodModel) return goodModel;
-    else if (alignedModel) return alignedModel;
+                std::dynamic_pointer_cast
+                <RangeSummarisableTimeValueModel>(model)) {
+                goodModel = model->getId();
+            }
+        }
+    }
+
+    if (!goodModel.isNone()) return goodModel;
+    else if (!alignedModel.isNone()) return alignedModel;
     else return anyModel;
 }
 
 sv_frame_t
 View::alignFromReference(sv_frame_t f) const
 {
     if (!m_manager || !m_manager->getAlignMode()) return f;
-    Model *aligningModel = getAligningModel();
+    auto aligningModel = ModelById::get(getAligningModel());
     if (!aligningModel) return f;
     return aligningModel->alignFromReference(f);
 }
 
 sv_frame_t
 View::alignToReference(sv_frame_t f) const
 {
     if (!m_manager->getAlignMode()) return f;
-    Model *aligningModel = getAligningModel();
+    auto aligningModel = ModelById::get(getAligningModel());
     if (!aligningModel) return f;
     return aligningModel->alignToReference(f);
 }
 
 sv_frame_t

 {
     if (!m_manager) return 0;
     sv_frame_t pf = m_manager->getPlaybackFrame();
     if (!m_manager->getAlignMode()) return pf;
 
-    Model *aligningModel = getAligningModel();
+    auto aligningModel = ModelById::get(getAligningModel());
     if (!aligningModel) return pf;
 
     sv_frame_t af = aligningModel->alignFromReference(pf);
 
     return af;

          i != m_progressBars.end(); ++i) {
 
         if (i->second.cancel == cancel) {
 
             Layer *layer = i->first;
-            Model *model = layer->getModel();
-
+/*!!!            Model *model = layer->getModel();
+
+            //!!! todo: restore this behaviour
             if (model) model->abandon();
+*/
         }
     }
 }
 
 void