comparison layer/TimeValueLayer.cpp @ 1486:ac0a8addabcf

Merge from branch by-id

 
 //#define DEBUG_TIME_VALUE_LAYER 1
 
 TimeValueLayer::TimeValueLayer() :
     SingleColourLayer(),
-    m_model(nullptr),
     m_editing(false),
     m_originalPoint(0, 0.0, tr("New Point")),
     m_editingPoint(0, 0.0, tr("New Point")),
     m_editingCommand(nullptr),
     m_colourMap(0),

     m_scaleMaximum(0)
 {
     
 }
 
-void
-TimeValueLayer::setModel(SparseTimeValueModel *model)
-{
-    if (m_model == model) return;
-    m_model = model;
-
-    connectSignals(m_model);
-
-    m_scaleMinimum = 0;
-    m_scaleMaximum = 0;
-
-    if (m_model && m_model->getRDFTypeURI().endsWith("Segment")) {
-        setPlotStyle(PlotSegmentation);
-    }
-    if (m_model && m_model->getRDFTypeURI().endsWith("Change")) {
-        setPlotStyle(PlotSegmentation);
-    }
-
-#ifdef DEBUG_TIME_VALUE_LAYER
-    cerr << "TimeValueLayer::setModel(" << model << ")" << endl;
-#endif
-
+int
+TimeValueLayer::getCompletion(LayerGeometryProvider *) const
+{
+    auto model = ModelById::get(m_model);
+    if (model) return model->getCompletion();
+    else return 0;
+}
+
+void
+TimeValueLayer::setModel(ModelId modelId)
+{
+    auto newModel = ModelById::getAs<SparseTimeValueModel>(modelId);
+    
+    if (!modelId.isNone() && !newModel) {
+        throw std::logic_error("Not a SparseTimeValueModel");
+    }
+    
+    if (m_model == modelId) return;
+    m_model = modelId;
+
+    if (newModel) {
+        
+        connectSignals(m_model);
+
+        m_scaleMinimum = 0;
+        m_scaleMaximum = 0;
+
+        if (newModel->getRDFTypeURI().endsWith("Segment")) {
+            setPlotStyle(PlotSegmentation);
+        }
+        if (newModel->getRDFTypeURI().endsWith("Change")) {
+            setPlotStyle(PlotSegmentation);
+        }
+    }
+    
     emit modelReplaced();
 }
 
 Layer::PropertyList
 TimeValueLayer::getProperties() const

         return tr("Plot Type");
     }
     return SingleColourLayer::getPropertyGroupName(name);
 }
 
+bool
+TimeValueLayer::needsTextLabelHeight() const
+{
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model) return false;
+    return m_plotStyle == PlotSegmentation && model->hasTextLabels();
+}
+
 QString
 TimeValueLayer::getScaleUnits() const
 {
-    if (m_model) return m_model->getScaleUnits();
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (model) return model->getScaleUnits();
     else return "";
 }
 
 int
 TimeValueLayer::getPropertyRangeAndValue(const PropertyName &name,

         val = int(m_verticalScale);
 
     } else if (name == "Scale Units") {
 
         if (deflt) *deflt = 0;
-        if (m_model) {
+        auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+        if (model) {
             val = UnitDatabase::getInstance()->getUnitId
                 (getScaleUnits());
         }
 
     } else if (name == "Draw Segment Division Lines") {

     } else if (name == "Plot Type") {
         setPlotStyle(PlotStyle(value));
     } else if (name == "Vertical Scale") {
         setVerticalScale(VerticalScale(value));
     } else if (name == "Scale Units") {
-        if (m_model) {
-            m_model->setScaleUnits
+        auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+        if (model) {
+            model->setScaleUnits
                 (UnitDatabase::getInstance()->getUnitById(value));
-            emit modelChanged();
+            emit modelChanged(m_model);
         }
     } else if (name == "Draw Segment Division Lines") {
         setDrawSegmentDivisions(value > 0.5);
     } else if (name == "Show Derivative") {
         setShowDerivative(value > 0.5);

 
 bool
 TimeValueLayer::getValueExtents(double &min, double &max,
                                 bool &logarithmic, QString &unit) const
 {
-    if (!m_model) return false;
-
-    min = m_model->getValueMinimum();
-    max = m_model->getValueMaximum();
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model) return false;
+
+    min = model->getValueMinimum();
+    max = model->getValueMaximum();
 
     logarithmic = (m_verticalScale == LogScale);
 
     unit = getScaleUnits();
 

 }
 
 bool
 TimeValueLayer::getDisplayExtents(double &min, double &max) const
 {
-    if (!m_model || shouldAutoAlign()) return false;
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model || shouldAutoAlign()) return false;
 
     if (m_scaleMinimum == m_scaleMaximum) {
         bool log;
         QString unit;
         getValueExtents(min, max, log, unit);

 }
 
 bool
 TimeValueLayer::setDisplayExtents(double min, double max)
 {
-    if (!m_model) return false;
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model) return false;
 
     if (min == max) {
         if (min == 0.f) {
             max = 1.f;
         } else {

 
 int
 TimeValueLayer::getVerticalZoomSteps(int &defaultStep) const
 {
     if (shouldAutoAlign()) return 0;
-    if (!m_model) return 0;
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model) return 0;
 
     defaultStep = 0;
     return 100;
 }
 
 int
 TimeValueLayer::getCurrentVerticalZoomStep() const
 {
     if (shouldAutoAlign()) return 0;
-    if (!m_model) return 0;
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model) return 0;
 
     RangeMapper *mapper = getNewVerticalZoomRangeMapper();
     if (!mapper) return 0;
 
     double dmin, dmax;

 
 void
 TimeValueLayer::setVerticalZoomStep(int step)
 {
     if (shouldAutoAlign()) return;
-    if (!m_model) return;
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model) return;
 
     RangeMapper *mapper = getNewVerticalZoomRangeMapper();
     if (!mapper) return;
     
     double min, max;

 }
 
 RangeMapper *
 TimeValueLayer::getNewVerticalZoomRangeMapper() const
 {
-    if (!m_model) return nullptr;
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model) return nullptr;
     
     RangeMapper *mapper;
 
     double min, max;
     bool logarithmic;

 }
 
 EventVector
 TimeValueLayer::getLocalPoints(LayerGeometryProvider *v, int x) const
 {
-    if (!m_model) return {};
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model) return {};
 
     // Return all points at a frame f, where f is the closest frame to
     // pixel coordinate x whose pixel coordinate is both within a
     // small (but somewhat arbitrary) fuzz distance from x and within
     // the current view. If there is no such frame, return an empty
     // vector.
     
     sv_frame_t frame = v->getFrameForX(x);
     
-    EventVector exact = m_model->getEventsStartingAt(frame);
+    EventVector exact = model->getEventsStartingAt(frame);
     if (!exact.empty()) return exact;
 
     // overspill == 1, so one event either side of the given span
-    EventVector neighbouring = m_model->getEventsWithin
-        (frame, m_model->getResolution(), 1);
+    EventVector neighbouring = model->getEventsWithin
+        (frame, model->getResolution(), 1);
 
     double fuzz = v->scaleSize(2);
     sv_frame_t suitable = 0;
     bool have = false;
     

             suitable = f;
         }
     }
 
     if (have) {
-        return m_model->getEventsStartingAt(suitable);
+        return model->getEventsStartingAt(suitable);
     } else {
         return {};
     }
 }
 
 QString
 TimeValueLayer::getLabelPreceding(sv_frame_t frame) const
 {
-    if (!m_model || !m_model->hasTextLabels()) return "";
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model || !model->hasTextLabels()) return "";
 
     Event e;
-    if (m_model->getNearestEventMatching
+    if (model->getNearestEventMatching
         (frame,
          [](Event e) { return e.hasLabel() && e.getLabel() != ""; },
          EventSeries::Backward,
          e)) {
         return e.getLabel();

 QString
 TimeValueLayer::getFeatureDescription(LayerGeometryProvider *v, QPoint &pos) const
 {
     int x = pos.x();
 
-    if (!m_model || !m_model->getSampleRate()) return "";
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model || !model->getSampleRate()) return "";
 
     EventVector points = getLocalPoints(v, x);
 
     if (points.empty()) {
-        if (!m_model->isReady()) {
+        if (!model->isReady()) {
             return tr("In progress");
         } else {
             return tr("No local points");
         }
     }
 
     sv_frame_t useFrame = points.begin()->getFrame();
 
-    RealTime rt = RealTime::frame2RealTime(useFrame, m_model->getSampleRate());
+    RealTime rt = RealTime::frame2RealTime(useFrame, model->getSampleRate());
     
     QString valueText;
     float value = points.begin()->getValue();
     QString unit = getScaleUnits();
 

 TimeValueLayer::snapToFeatureFrame(LayerGeometryProvider *v,
                                    sv_frame_t &frame,
                                    int &resolution,
                                    SnapType snap) const
 {
-    if (!m_model) {
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model) {
         return Layer::snapToFeatureFrame(v, frame, resolution, snap);
     }
 
     // SnapLeft / SnapRight: return frame of nearest feature in that
     // direction no matter how far away
     //
     // SnapNeighbouring: return frame of feature that would be used in
     // an editing operation, i.e. closest feature in either direction
     // but only if it is "close enough"
     
-    resolution = m_model->getResolution();
+    resolution = model->getResolution();
 
     if (snap == SnapNeighbouring) {
         EventVector points = getLocalPoints(v, v->getXForFrame(frame));
         if (points.empty()) return false;
         frame = points.begin()->getFrame();
         return true;
     }
 
     Event e;
-    if (m_model->getNearestEventMatching
+    if (model->getNearestEventMatching
         (frame,
          [](Event) { return true; },
          snap == SnapLeft ? EventSeries::Backward : EventSeries::Forward,
          e)) {
         frame = e.getFrame();

 TimeValueLayer::snapToSimilarFeature(LayerGeometryProvider *v,
                                      sv_frame_t &frame,
                                      int &resolution,
                                      SnapType snap) const
 {
-    if (!m_model) {
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model) {
         return Layer::snapToSimilarFeature(v, frame, resolution, snap);
     }
 
     // snap is only permitted to be SnapLeft or SnapRight here.
     
-    resolution = m_model->getResolution();
+    resolution = model->getResolution();
 
     Event ref;
     Event e;
     float matchvalue;
     bool found;
 
-    found = m_model->getNearestEventMatching
+    found = model->getNearestEventMatching
         (frame, [](Event) { return true; }, EventSeries::Backward, ref);
 
     if (!found) {
         return false;
     }
 
     matchvalue = ref.getValue();
     
-    found = m_model->getNearestEventMatching
+    found = model->getNearestEventMatching
         (frame,
          [matchvalue](Event e) {
              double epsilon = 0.0001;
              return fabs(e.getValue() - matchvalue) < epsilon;
          },

 {
     min = 0.0;
     max = 0.0;
     log = false;
 
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model) return;
+
     if (shouldAutoAlign()) {
 
         if (!v->getValueExtents(getScaleUnits(), min, max, log)) {
-            min = m_model->getValueMinimum();
-            max = m_model->getValueMaximum();
+            min = model->getValueMinimum();
+            max = model->getValueMaximum();
         } else if (log) {
             LogRange::mapRange(min, max);
         }
 
     } else if (m_verticalScale == PlusMinusOneScale) {

 }
 
 bool
 TimeValueLayer::shouldAutoAlign() const
 {
-    if (!m_model) return false;
     QString unit = getScaleUnits();
     return (m_verticalScale == AutoAlignScale && unit != "");
 }
 
 QColor

 }
 
 void
 TimeValueLayer::paint(LayerGeometryProvider *v, QPainter &paint, QRect rect) const
 {
-    if (!m_model || !m_model->isOK()) return;
-
-    sv_samplerate_t sampleRate = m_model->getSampleRate();
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model || !model->isOK()) return;
+
+    sv_samplerate_t sampleRate = model->getSampleRate();
     if (!sampleRate) return;
 
     paint.setRenderHint(QPainter::Antialiasing, false);
 
 //    Profiler profiler("TimeValueLayer::paint", true);

     int x0 = rect.left(), x1 = rect.right();
     sv_frame_t frame0 = v->getFrameForX(x0);
     sv_frame_t frame1 = v->getFrameForX(x1);
     if (m_derivative) --frame0;
 
-    EventVector points(m_model->getEventsWithin(frame0, frame1 - frame0, 1));
+    EventVector points(model->getEventsWithin(frame0, frame1 - frame0, 1));
     if (points.empty()) return;
 
     paint.setPen(getBaseQColor());
 
     QColor brushColour(getBaseQColor());
     brushColour.setAlpha(80);
     paint.setBrush(brushColour);
 
 #ifdef DEBUG_TIME_VALUE_LAYER
     cerr << "TimeValueLayer::paint: resolution is "
-         << m_model->getResolution() << " frames" << endl;
-#endif
-
-    double min = m_model->getValueMinimum();
-    double max = m_model->getValueMaximum();
+         << model->getResolution() << " frames" << endl;
+#endif
+
+    double min = model->getValueMinimum();
+    double max = model->getValueMaximum();
     if (max == min) max = min + 1.0;
 
     int origin = int(nearbyint(v->getPaintHeight() -
                                (-min * v->getPaintHeight()) / (max - min)));
 

             illuminateFrame = localPoints.begin()->getFrame();
         }
     }
 
     int w =
-        v->getXForFrame(frame0 + m_model->getResolution()) -
+        v->getXForFrame(frame0 + model->getResolution()) -
         v->getXForFrame(frame0);
 
     if (m_plotStyle == PlotStems) {
         if (w < 2) w = 2;
     } else {

             if (value == 0.0) {
                 // Treat zeros as gaps
                 continue;
             }
             gap = (p.getFrame() > prevFrame &&
-                   (p.getFrame() - prevFrame >= m_model->getResolution() * 2));
+                   (p.getFrame() - prevFrame >= model->getResolution() * 2));
         }
 
         if (m_plotStyle != PlotSegmentation) {
             textY = y - paint.fontMetrics().height()
                       + paint.fontMetrics().ascent() - 1;

                     double y1 = ny;
 
                     if (m_plotStyle == PlotDiscreteCurves) {
                         bool nextGap =
                             (nvalue == 0.0) ||
-                            (nf - p.getFrame() >= m_model->getResolution() * 2);
+                            (nf - p.getFrame() >= model->getResolution() * 2);
                         if (nextGap) {
                             x1 = x0;
                             y1 = y0;
                         }
                     }

                 char lc[20];
                 snprintf(lc, 20, "%.3g", p.getValue());
                 label = lc;
                 italic = true;
             }
+
+    // Qt 5.13 deprecates QFontMetrics::width(), but its suggested
+    // replacement (horizontalAdvance) was only added in Qt 5.11
+    // which is too new for us
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 
             if (label != "") {
                 // Quick test for 20px before we do the slower test using metrics
                 bool haveRoom = (nx > x + 20);
                 haveRoom = (haveRoom &&

 }
 
 int
 TimeValueLayer::getVerticalScaleWidth(LayerGeometryProvider *v, bool, QPainter &paint) const
 {
-    if (!m_model) {
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model) {
         return 0;
     } else if (shouldAutoAlign() && !valueExtentsMatchMine(v)) {
         return 0;
     } else if (m_plotStyle == PlotSegmentation) {
         if (m_verticalScale == LogScale) {

 }
 
 void
 TimeValueLayer::paintVerticalScale(LayerGeometryProvider *v, bool, QPainter &paint, QRect) const
 {
-    if (!m_model || m_model->isEmpty()) return;
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model || model->isEmpty()) return;
 
     QString unit;
     double min, max;
     bool logarithmic;
 

 {
 #ifdef DEBUG_TIME_VALUE_LAYER
     cerr << "TimeValueLayer::drawStart(" << e->x() << "," << e->y() << ")" << endl;
 #endif
 
-    if (!m_model) return;
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model) return;
 
     sv_frame_t frame = v->getFrameForX(e->x());
-    int resolution = m_model->getResolution();
+    int resolution = model->getResolution();
     if (frame < 0) frame = 0;
     frame = (frame / resolution) * resolution;
 
     double value = getValueForY(v, e->y());
 

     }
 
     m_originalPoint = m_editingPoint;
 
     if (m_editingCommand) finish(m_editingCommand);
-    m_editingCommand = new ChangeEventsCommand(m_model, tr("Draw Point"));
+    m_editingCommand = new ChangeEventsCommand(m_model.untyped, tr("Draw Point"));
     if (!havePoint) {
         m_editingCommand->add(m_editingPoint);
     }
 
     m_editing = true;

 {
 #ifdef DEBUG_TIME_VALUE_LAYER
     cerr << "TimeValueLayer::drawDrag(" << e->x() << "," << e->y() << ")" << endl;
 #endif
 
-    if (!m_model || !m_editing) return;
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model || !m_editing) return;
 
     sv_frame_t frame = v->getFrameForX(e->x());
-    int resolution = m_model->getResolution();
+    int resolution = model->getResolution();
     if (frame < 0) frame = 0;
     frame = (frame / resolution) * resolution;
 
     double value = getValueForY(v, e->y());
 

 TimeValueLayer::drawEnd(LayerGeometryProvider *, QMouseEvent *)
 {
 #ifdef DEBUG_TIME_VALUE_LAYER
     cerr << "TimeValueLayer::drawEnd" << endl;
 #endif
-    if (!m_model || !m_editing) return;
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model || !m_editing) return;
     finish(m_editingCommand);
     m_editingCommand = nullptr;
     m_editing = false;
 }
 
 void
 TimeValueLayer::eraseStart(LayerGeometryProvider *v, QMouseEvent *e)
 {
-    if (!m_model) return;
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model) return;
 
     EventVector points = getLocalPoints(v, e->x());
     if (points.empty()) return;
 
     m_editingPoint = *points.begin();

 }
 
 void
 TimeValueLayer::eraseEnd(LayerGeometryProvider *v, QMouseEvent *e)
 {
-    if (!m_model || !m_editing) return;
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model || !m_editing) return;
 
     m_editing = false;
 
     EventVector points = getLocalPoints(v, e->x());
     if (points.empty()) return;
     if (points.begin()->getFrame() != m_editingPoint.getFrame() ||
         points.begin()->getValue() != m_editingPoint.getValue()) return;
 
-    m_editingCommand = new ChangeEventsCommand(m_model, tr("Erase Point"));
+    m_editingCommand = new ChangeEventsCommand(m_model.untyped, tr("Erase Point"));
     m_editingCommand->remove(m_editingPoint);
     finish(m_editingCommand);
     m_editingCommand = nullptr;
     m_editing = false;
 }

 {
 #ifdef DEBUG_TIME_VALUE_LAYER
     cerr << "TimeValueLayer::editStart(" << e->x() << "," << e->y() << ")" << endl;
 #endif
 
-    if (!m_model) return;
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model) return;
 
     EventVector points = getLocalPoints(v, e->x());
     if (points.empty()) return;
 
     m_editingPoint = *points.begin();

 {
 #ifdef DEBUG_TIME_VALUE_LAYER
     cerr << "TimeValueLayer::editDrag(" << e->x() << "," << e->y() << ")" << endl;
 #endif
 
-    if (!m_model || !m_editing) return;
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model || !m_editing) return;
 
     sv_frame_t frame = v->getFrameForX(e->x());
     if (frame < 0) frame = 0;
-    frame = frame / m_model->getResolution() * m_model->getResolution();
+    frame = frame / model->getResolution() * model->getResolution();
 
     double value = getValueForY(v, e->y());
 
     if (!m_editingCommand) {
-        m_editingCommand = new ChangeEventsCommand(m_model, tr("Drag Point"));
+        m_editingCommand = new ChangeEventsCommand(m_model.untyped, tr("Drag Point"));
     }
 
     m_editingCommand->remove(m_editingPoint);
     m_editingPoint = m_editingPoint
         .withFrame(frame)

 TimeValueLayer::editEnd(LayerGeometryProvider *, QMouseEvent *)
 {
 #ifdef DEBUG_TIME_VALUE_LAYER
     cerr << "TimeValueLayer::editEnd" << endl;
 #endif
-    if (!m_model || !m_editing) return;
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model || !m_editing) return;
 
     if (m_editingCommand) {
 
         QString newName = m_editingCommand->getName();
 

 }
 
 bool
 TimeValueLayer::editOpen(LayerGeometryProvider *v, QMouseEvent *e)
 {
-    if (!m_model) return false;
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model) return false;
 
     EventVector points = getLocalPoints(v, e->x());
     if (points.empty()) return false;
 
     Event point = *points.begin();
 
     ItemEditDialog *dialog = new ItemEditDialog
-        (m_model->getSampleRate(),
+        (model->getSampleRate(),
          ItemEditDialog::ShowTime |
          ItemEditDialog::ShowValue |
          ItemEditDialog::ShowText,
          getScaleUnits());
 

             .withFrame(dialog->getFrameTime())
             .withValue(dialog->getValue())
             .withLabel(dialog->getText());
         
         ChangeEventsCommand *command =
-            new ChangeEventsCommand(m_model, tr("Edit Point"));
+            new ChangeEventsCommand(m_model.untyped, tr("Edit Point"));
         command->remove(point);
         command->add(newPoint);
         finish(command);
     }
 

 }
 
 void
 TimeValueLayer::moveSelection(Selection s, sv_frame_t newStartFrame)
 {
-    if (!m_model) return;
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model) return;
 
     ChangeEventsCommand *command =
-        new ChangeEventsCommand(m_model, tr("Drag Selection"));
+        new ChangeEventsCommand(m_model.untyped, tr("Drag Selection"));
 
     EventVector points =
-        m_model->getEventsWithin(s.getStartFrame(), s.getDuration());
+        model->getEventsWithin(s.getStartFrame(), s.getDuration());
 
     for (Event p: points) {
 
         Event newPoint = p.withFrame
             (p.getFrame() + newStartFrame - s.getStartFrame());

 }
 
 void
 TimeValueLayer::resizeSelection(Selection s, Selection newSize)
 {
-    if (!m_model || !s.getDuration()) return;
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model || !s.getDuration()) return;
 
     ChangeEventsCommand *command =
-        new ChangeEventsCommand(m_model, tr("Resize Selection"));
+        new ChangeEventsCommand(m_model.untyped, tr("Resize Selection"));
 
     EventVector points =
-        m_model->getEventsWithin(s.getStartFrame(), s.getDuration());
+        model->getEventsWithin(s.getStartFrame(), s.getDuration());
 
     double ratio = double(newSize.getDuration()) / double(s.getDuration());
     double oldStart = double(s.getStartFrame());
     double newStart = double(newSize.getStartFrame());
 

 }
 
 void
 TimeValueLayer::deleteSelection(Selection s)
 {
-    if (!m_model) return;
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model) return;
 
     ChangeEventsCommand *command =
-        new ChangeEventsCommand(m_model, tr("Delete Selected Points"));
+        new ChangeEventsCommand(m_model.untyped, tr("Delete Selected Points"));
 
     EventVector points =
-        m_model->getEventsWithin(s.getStartFrame(), s.getDuration());
+        model->getEventsWithin(s.getStartFrame(), s.getDuration());
 
     for (Event p: points) {
         command->remove(p);
     }
 

 }    
 
 void
 TimeValueLayer::copy(LayerGeometryProvider *v, Selection s, Clipboard &to)
 {
-    if (!m_model) return;
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model) return;
 
     EventVector points =
-        m_model->getEventsWithin(s.getStartFrame(), s.getDuration());
+        model->getEventsWithin(s.getStartFrame(), s.getDuration());
 
     for (Event p: points) {
         to.addPoint(p.withReferenceFrame(alignToReference(v, p.getFrame())));
     }
 }
 
 bool
 TimeValueLayer::paste(LayerGeometryProvider *v, const Clipboard &from, sv_frame_t /* frameOffset */,
                       bool interactive)
 {
-    if (!m_model) return false;
+    auto model = ModelById::getAs<SparseTimeValueModel>(m_model);
+    if (!model) return false;
 
     EventVector points = from.getPoints();
 
     bool realign = false;
 

             realign = true;
         }
     }
 
     ChangeEventsCommand *command =
-        new ChangeEventsCommand(m_model, tr("Paste"));
+        new ChangeEventsCommand(m_model.untyped, tr("Paste"));
 
     enum ValueAvailability {
         UnknownAvailability,
         NoValues,
         SomeValues,

 
     Labeller::ValueType generation = Labeller::ValueNone;
 
     bool haveUsableLabels = false;
     Labeller labeller;
-    labeller.setSampleRate(m_model->getSampleRate());
+    labeller.setSampleRate(model->getSampleRate());
 
     if (interactive) {
 
         ValueAvailability availability = UnknownAvailability;