comparison layer/RegionLayer.cpp @ 1486:ac0a8addabcf

Merge from branch by-id

 #include <iostream>
 #include <cmath>
 
 RegionLayer::RegionLayer() :
     SingleColourLayer(),
-    m_model(nullptr),
     m_editing(false),
     m_dragPointX(0),
     m_dragPointY(0),
     m_dragStartX(0),
     m_dragStartY(0),

     m_plotStyle(PlotLines)
 {
     
 }
 
-void
-RegionLayer::setModel(RegionModel *model)
-{
-    if (m_model == model) return;
-    m_model = model;
-
-    connectSignals(m_model);
-
-    connect(m_model, SIGNAL(modelChanged()), this, SLOT(recalcSpacing()));
-    recalcSpacing();
-
-//    SVDEBUG << "RegionLayer::setModel(" << model << ")" << endl;
-
-    if (m_model && m_model->getRDFTypeURI().endsWith("Segment")) {
-        setPlotStyle(PlotSegmentation);
-    }
-    if (m_model && m_model->getRDFTypeURI().endsWith("Change")) {
-        setPlotStyle(PlotSegmentation);
-    }
-
+int
+RegionLayer::getCompletion(LayerGeometryProvider *) const
+{
+    auto model = ModelById::get(m_model);
+    if (model) return model->getCompletion();
+    else return 0;
+}
+
+void
+RegionLayer::setModel(ModelId modelId)
+{
+    auto oldModel = ModelById::getAs<RegionModel>(m_model);
+    auto newModel = ModelById::getAs<RegionModel>(modelId);
+    
+    if (!modelId.isNone() && !newModel) {
+        throw std::logic_error("Not a RegionModel");
+    }
+    
+    if (m_model == modelId) return;
+    m_model = modelId;
+
+    if (newModel) {
+    
+        connectSignals(m_model);
+
+        connect(newModel.get(), SIGNAL(modelChanged()),
+                this, SLOT(recalcSpacing()));
+    
+        recalcSpacing();
+
+        if (newModel->getRDFTypeURI().endsWith("Segment")) {
+            setPlotStyle(PlotSegmentation);
+        }
+        if (newModel->getRDFTypeURI().endsWith("Change")) {
+            setPlotStyle(PlotSegmentation);
+        }
+    }
+    
     emit modelReplaced();
 }
 
 Layer::PropertyList
 RegionLayer::getProperties() const

         val = int(m_verticalScale);
 
     } else if (name == "Scale Units") {
 
         if (deflt) *deflt = 0;
-        if (m_model) {
+        auto model = ModelById::getAs<RegionModel>(m_model);
+        if (model) {
             val = UnitDatabase::getInstance()->getUnitId
-                (getScaleUnits());
+                (model->getScaleUnits());
         }
 
     } else {
 
         val = SingleColourLayer::getPropertyRangeAndValue(name, min, max, deflt);

     } 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<RegionModel>(m_model);
+        if (model) {
+            model->setScaleUnits
                 (UnitDatabase::getInstance()->getUnitById(value));
-            emit modelChanged();
+            emit modelChanged(m_model);
         }
     } else {
         return SingleColourLayer::setProperty(name, value);
     }
 }

 void
 RegionLayer::recalcSpacing()
 {
     m_spacingMap.clear();
     m_distributionMap.clear();
-    if (!m_model) return;
+
+    auto model = ModelById::getAs<RegionModel>(m_model);
+    if (!model) return;
 
 //    SVDEBUG << "RegionLayer::recalcSpacing" << endl;
 
-    EventVector allEvents = m_model->getAllEvents();
+    EventVector allEvents = model->getAllEvents();
     for (const Event &e: allEvents) {
         m_distributionMap[e.getValue()]++;
 //        SVDEBUG << "RegionLayer::recalcSpacing: value found: " << e.getValue() << " (now have " << m_distributionMap[e.getValue()] << " of this value)" <<  endl;
     }
 

 
 bool
 RegionLayer::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<RegionModel>(m_model);
+    if (!model) return false;
+    min = model->getValueMinimum();
+    max = model->getValueMaximum();
     unit = getScaleUnits();
 
     if (m_verticalScale == LogScale) logarithmic = true;
 
     return true;
 }
 
 bool
 RegionLayer::getDisplayExtents(double &min, double &max) const
 {
-    if (!m_model ||
+    auto model = ModelById::getAs<RegionModel>(m_model);
+    if (!model ||
         m_verticalScale == AutoAlignScale ||
         m_verticalScale == EqualSpaced) return false;
 
-    min = m_model->getValueMinimum();
-    max = m_model->getValueMaximum();
+    min = model->getValueMinimum();
+    max = model->getValueMaximum();
 
     return true;
 }
 
 EventVector
 RegionLayer::getLocalPoints(LayerGeometryProvider *v, int x) const
 {
-    if (!m_model) return EventVector();
+    auto model = ModelById::getAs<RegionModel>(m_model);
+    if (!model) return EventVector();
 
     sv_frame_t frame = v->getFrameForX(x);
 
-    EventVector local = m_model->getEventsCovering(frame);
+    EventVector local = model->getEventsCovering(frame);
     if (!local.empty()) return local;
 
     int fuzz = ViewManager::scalePixelSize(2);
     sv_frame_t start = v->getFrameForX(x - fuzz);
     sv_frame_t end = v->getFrameForX(x + fuzz);
 
-    local = m_model->getEventsStartingWithin(frame, end - frame);
+    local = model->getEventsStartingWithin(frame, end - frame);
     if (!local.empty()) return local;
 
-    local = m_model->getEventsSpanning(start, frame - start);
+    local = model->getEventsSpanning(start, frame - start);
     if (!local.empty()) return local;
 
     return {};
 }
 
 bool
 RegionLayer::getPointToDrag(LayerGeometryProvider *v, int x, int y, Event &point) const
 {
-    if (!m_model) return false;
+    auto model = ModelById::getAs<RegionModel>(m_model);
+    if (!model) return false;
 
     sv_frame_t frame = v->getFrameForX(x);
 
-    EventVector onPoints = m_model->getEventsCovering(frame);
+    EventVector onPoints = model->getEventsCovering(frame);
     if (onPoints.empty()) return false;
 
     int nearestDistance = -1;
     for (const auto &p: onPoints) {
         int distance = getYForValue(v, p.getValue()) - y;

 }
 
 QString
 RegionLayer::getLabelPreceding(sv_frame_t frame) const
 {
-    if (!m_model) return "";
-    EventVector points = m_model->getEventsStartingWithin
-        (m_model->getStartFrame(), frame - m_model->getStartFrame());
+    auto model = ModelById::getAs<RegionModel>(m_model);
+    if (!model) return "";
+    EventVector points = model->getEventsStartingWithin
+        (model->getStartFrame(), frame - model->getStartFrame());
     if (!points.empty()) {
         for (auto i = points.rbegin(); i != points.rend(); ++i) {
             if (i->getLabel() != QString()) {
                 return i->getLabel();
             }

 QString
 RegionLayer::getFeatureDescription(LayerGeometryProvider *v, QPoint &pos) const
 {
     int x = pos.x();
 
-    if (!m_model || !m_model->getSampleRate()) return "";
+    auto model = ModelById::getAs<RegionModel>(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");
         }
     }

     for (i = points.begin(); i != points.end(); ++i) {
 
         int y = getYForValue(v, i->getValue());
         int h = 3;
 
-        if (m_model->getValueQuantization() != 0.0) {
+        if (model->getValueQuantization() != 0.0) {
             h = y - getYForValue
-                (v, i->getValue() + m_model->getValueQuantization());
+                (v, i->getValue() + model->getValueQuantization());
             if (h < 3) h = 3;
         }
 
         if (pos.y() >= y - h && pos.y() <= y) {
             region = *i;

     }
 
     if (i == points.end()) return tr("No local points");
 
     RealTime rt = RealTime::frame2RealTime(region.getFrame(),
-                                           m_model->getSampleRate());
+                                           model->getSampleRate());
     RealTime rd = RealTime::frame2RealTime(region.getDuration(),
-                                           m_model->getSampleRate());
+                                           model->getSampleRate());
     
     QString valueText;
 
     valueText = tr("%1 %2").arg(region.getValue()).arg(getScaleUnits());
 

 bool
 RegionLayer::snapToFeatureFrame(LayerGeometryProvider *v, sv_frame_t &frame,
                                 int &resolution,
                                 SnapType snap) const
 {
-    if (!m_model) {
+    auto model = ModelById::getAs<RegionModel>(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();

     // left is closer than the start frame of the next event to the
     // right, then we snap to that frame instead. Clear?
     
     Event left;
     bool haveLeft = false;
-    if (m_model->getNearestEventMatching
+    if (model->getNearestEventMatching
         (frame, [](Event) { return true; }, EventSeries::Backward, left)) {
         haveLeft = true;
     }
 
     if (snap == SnapLeft) {

         return haveLeft;
     }
 
     Event right;
     bool haveRight = false;
-    if (m_model->getNearestEventMatching
+    if (model->getNearestEventMatching
         (frame, [](Event) { return true; }, EventSeries::Forward, right)) {
         haveRight = true;
     }
 
     if (haveLeft) {

 bool
 RegionLayer::snapToSimilarFeature(LayerGeometryProvider *v, sv_frame_t &frame,
                                   int &resolution,
                                   SnapType snap) const
 {
-    if (!m_model) {
+    auto model = ModelById::getAs<RegionModel>(m_model);
+    if (!model) {
         return Layer::snapToSimilarFeature(v, frame, resolution, snap);
     }
 
     // snap is only permitted to be SnapLeft or SnapRight here.  We
     // don't do the same trick as in snapToFeatureFrame, of snapping
     // to the end of a feature sometimes.
     
-    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;
          },

 }
 
 QString
 RegionLayer::getScaleUnits() const
 {
-    if (m_model) return m_model->getScaleUnits();
+    auto model = ModelById::getAs<RegionModel>(m_model);
+    if (model) return model->getScaleUnits();
     else return "";
 }
 
 void
 RegionLayer::getScaleExtents(LayerGeometryProvider *v, double &min, double &max, bool &log) const
 {
     min = 0.0;
     max = 0.0;
     log = false;
 
+    auto model = ModelById::getAs<RegionModel>(m_model);
+    if (!model) return;
+
     QString queryUnits;
     queryUnits = getScaleUnits();
 
     if (m_verticalScale == AutoAlignScale) {
 
         if (!v->getValueExtents(queryUnits, min, max, log)) {
 
-            min = m_model->getValueMinimum();
-            max = m_model->getValueMaximum();
+            min = model->getValueMinimum();
+            max = model->getValueMaximum();
 
 //            cerr << "RegionLayer[" << this << "]::getScaleExtents: min = " << min << ", max = " << max << ", log = " << log << endl;
 
         } else if (log) {
 

 //            cerr << "RegionLayer[" << this << "]::getScaleExtents: equal spaced; min = " << min << ", max = " << max << ", log = " << log << endl;
         }
 
     } else {
 
-        min = m_model->getValueMinimum();
-        max = m_model->getValueMaximum();
+        min = model->getValueMinimum();
+        max = model->getValueMaximum();
 
         if (m_verticalScale == LogScale) {
             LogRange::mapRange(min, max);
             log = true;
         }

 }
 
 void
 RegionLayer::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<RegionModel>(m_model);
+    if (!model || !model->isOK()) return;
+
+    sv_samplerate_t sampleRate = model->getSampleRate();
     if (!sampleRate) return;
 
 //    Profiler profiler("RegionLayer::paint", true);
 
     int x0 = rect.left() - 40, x1 = rect.right();
 
     sv_frame_t wholeFrame0 = v->getFrameForX(0);
     sv_frame_t wholeFrame1 = v->getFrameForX(v->getPaintWidth());
 
-    EventVector points(m_model->getEventsSpanning(wholeFrame0,
+    EventVector points(model->getEventsSpanning(wholeFrame0,
                                                   wholeFrame1 - wholeFrame0));
     if (points.empty()) return;
 
     paint.setPen(getBaseQColor());
 
     QColor brushColour(getBaseQColor());
     brushColour.setAlpha(80);
 
 //    SVDEBUG << "RegionLayer::paint: resolution is "
-//              << m_model->getResolution() << " frames" << endl;
-
-    double min = m_model->getValueMinimum();
-    double max = m_model->getValueMaximum();
+//              << model->getResolution() << " frames" << endl;
+
+    double min = model->getValueMinimum();
+    double max = model->getValueMaximum();
     if (max == min) max = min + 1.0;
 
     QPoint localPos;
     Event illuminatePoint(0);
     bool shouldIlluminate = false;

             const Event &q(*j);
             int nx = v->getXForFrame(q.getFrame());
             if (nx < ex) ex = nx;
         }
 
-        if (m_model->getValueQuantization() != 0.0) {
+        if (model->getValueQuantization() != 0.0) {
             h = y - getYForValue
-                (v, p.getValue() + m_model->getValueQuantization());
+                (v, p.getValue() + model->getValueQuantization());
             if (h < 3) h = 3;
         }
 
         if (w < 1) w = 1;
 

 
             if (shouldIlluminate && illuminatePoint == p) {
 
                 paint.setPen(v->getForeground());
                 paint.setBrush(v->getForeground());
+
+                // 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"
 
                 QString vlabel =
                     QString("%1%2").arg(p.getValue()).arg(getScaleUnits());
                 PaintAssistant::drawVisibleText(v, paint, 
                                    x - paint.fontMetrics().width(vlabel) - gap,
                                    y + paint.fontMetrics().height()/2
                                    - paint.fontMetrics().descent(), 
                                    vlabel, PaintAssistant::OutlinedText);
                 
                 QString hlabel = RealTime::frame2RealTime
-                    (p.getFrame(), m_model->getSampleRate()).toText(true).c_str();
+                    (p.getFrame(), model->getSampleRate()).toText(true).c_str();
                 PaintAssistant::drawVisibleText(v, paint, 
                                    x,
                                    y - h/2 - paint.fontMetrics().descent() - gap,
                                    hlabel, PaintAssistant::OutlinedText);
             }

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

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

 }
 
 void
 RegionLayer::drawStart(LayerGeometryProvider *v, QMouseEvent *e)
 {
-    if (!m_model) return;
+    auto model = ModelById::getAs<RegionModel>(m_model);
+    if (!model) 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());
 
     m_editingPoint = Event(frame, float(value), 0, "");
     m_originalPoint = m_editingPoint;
 
     if (m_editingCommand) finish(m_editingCommand);
-    m_editingCommand = new ChangeEventsCommand(m_model,
-                                                    tr("Draw Region"));
+    m_editingCommand = new ChangeEventsCommand(m_model.untyped, tr("Draw Region"));
     m_editingCommand->add(m_editingPoint);
 
     recalcSpacing();
 
     m_editing = true;
 }
 
 void
 RegionLayer::drawDrag(LayerGeometryProvider *v, QMouseEvent *e)
 {
-    if (!m_model || !m_editing) return;
+    auto model = ModelById::getAs<RegionModel>(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 newValue = m_editingPoint.getValue();
     if (m_verticalScale != EqualSpaced) newValue = getValueForY(v, e->y());
 
     sv_frame_t newFrame = m_editingPoint.getFrame();

 }
 
 void
 RegionLayer::drawEnd(LayerGeometryProvider *, QMouseEvent *)
 {
-    if (!m_model || !m_editing) return;
+    auto model = ModelById::getAs<RegionModel>(m_model);
+    if (!model || !m_editing) return;
     finish(m_editingCommand);
     m_editingCommand = nullptr;
     m_editing = false;
 
     recalcSpacing();
 }
 
 void
 RegionLayer::eraseStart(LayerGeometryProvider *v, QMouseEvent *e)
 {
-    if (!m_model) return;
+    auto model = ModelById::getAs<RegionModel>(m_model);
+    if (!model) return;
 
     if (!getPointToDrag(v, e->x(), e->y(), m_editingPoint)) return;
 
     if (m_editingCommand) {
         finish(m_editingCommand);

 }
 
 void
 RegionLayer::eraseEnd(LayerGeometryProvider *v, QMouseEvent *e)
 {
-    if (!m_model || !m_editing) return;
+    auto model = ModelById::getAs<RegionModel>(m_model);
+    if (!model || !m_editing) return;
 
     m_editing = false;
 
     Event p(0);
     if (!getPointToDrag(v, e->x(), e->y(), p)) return;
     if (p.getFrame() != m_editingPoint.getFrame() ||
         p.getValue() != m_editingPoint.getValue()) return;
 
     m_editingCommand = new ChangeEventsCommand
-        (m_model, tr("Erase Region"));
+        (m_model.untyped, tr("Erase Region"));
 
     m_editingCommand->remove(m_editingPoint);
 
     finish(m_editingCommand);
     m_editingCommand = nullptr;

 }
 
 void
 RegionLayer::editStart(LayerGeometryProvider *v, QMouseEvent *e)
 {
-    if (!m_model) return;
+    auto model = ModelById::getAs<RegionModel>(m_model);
+    if (!model) return;
 
     if (!getPointToDrag(v, e->x(), e->y(), m_editingPoint)) {
         return;
     }
 

 }
 
 void
 RegionLayer::editDrag(LayerGeometryProvider *v, QMouseEvent *e)
 {
-    if (!m_model || !m_editing) return;
+    auto model = ModelById::getAs<RegionModel>(m_model);
+    if (!model || !m_editing) return;
 
     int xdist = e->x() - m_dragStartX;
     int ydist = e->y() - m_dragStartY;
     int newx = m_dragPointX + xdist;
     int newy = m_dragPointY + ydist;
 
     sv_frame_t frame = v->getFrameForX(newx);
     if (frame < 0) frame = 0;
-    frame = frame / m_model->getResolution() * m_model->getResolution();
+    frame = frame / model->getResolution() * model->getResolution();
 
     // Do not bisect between two values, if one of those values is
     // that of the point we're actually moving ...
     int avoid = m_spacingMap[m_editingPoint.getValue()];
 

     if (m_distributionMap[m_editingPoint.getValue()] > 1) avoid = -1;
 
     double value = getValueForY(v, newy, avoid);
 
     if (!m_editingCommand) {
-        m_editingCommand = new ChangeEventsCommand(m_model,
+        m_editingCommand = new ChangeEventsCommand(m_model.untyped,
                                                       tr("Drag Region"));
     }
 
     m_editingCommand->remove(m_editingPoint);
     m_editingPoint = m_editingPoint

 }
 
 void
 RegionLayer::editEnd(LayerGeometryProvider *, QMouseEvent *)
 {
-    if (!m_model || !m_editing) return;
+    auto model = ModelById::getAs<RegionModel>(m_model);
+    if (!model || !m_editing) return;
 
     if (m_editingCommand) {
 
         QString newName = m_editingCommand->getName();
 

 }
 
 bool
 RegionLayer::editOpen(LayerGeometryProvider *v, QMouseEvent *e)
 {
-    if (!m_model) return false;
+    auto model = ModelById::getAs<RegionModel>(m_model);
+    if (!model) return false;
 
     Event region(0);
     if (!getPointToDrag(v, e->x(), e->y(), region)) return false;
 
     ItemEditDialog *dialog = new ItemEditDialog
-        (m_model->getSampleRate(),
+        (model->getSampleRate(),
          ItemEditDialog::ShowTime |
          ItemEditDialog::ShowDuration |
          ItemEditDialog::ShowValue |
          ItemEditDialog::ShowText,
          getScaleUnits());

             .withValue(dialog->getValue())
             .withDuration(dialog->getFrameDuration())
             .withLabel(dialog->getText());
         
         ChangeEventsCommand *command = new ChangeEventsCommand
-            (m_model, tr("Edit Region"));
+            (m_model.untyped, tr("Edit Region"));
         command->remove(region);
         command->add(newRegion);
         finish(command);
     }
 

 }
 
 void
 RegionLayer::moveSelection(Selection s, sv_frame_t newStartFrame)
 {
-    if (!m_model) return;
+    auto model = ModelById::getAs<RegionModel>(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->getEventsStartingWithin(s.getStartFrame(), s.getDuration());
+        model->getEventsStartingWithin(s.getStartFrame(), s.getDuration());
 
     for (EventVector::iterator i = points.begin();
          i != points.end(); ++i) {
 
         Event newPoint = (*i)

 }
 
 void
 RegionLayer::resizeSelection(Selection s, Selection newSize)
 {
-    if (!m_model || !s.getDuration()) return;
+    auto model = ModelById::getAs<RegionModel>(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->getEventsStartingWithin(s.getStartFrame(), s.getDuration());
+        model->getEventsStartingWithin(s.getStartFrame(), s.getDuration());
 
     double ratio = double(newSize.getDuration()) / double(s.getDuration());
     double oldStart = double(s.getStartFrame());
     double newStart = double(newSize.getStartFrame());
     

 }
 
 void
 RegionLayer::deleteSelection(Selection s)
 {
-    if (!m_model) return;
+    auto model = ModelById::getAs<RegionModel>(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->getEventsStartingWithin(s.getStartFrame(), s.getDuration());
+        model->getEventsStartingWithin(s.getStartFrame(), s.getDuration());
 
     for (EventVector::iterator i = points.begin();
          i != points.end(); ++i) {
 
         if (s.contains(i->getFrame())) {

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

             realign = true;
         }
     }
 
     ChangeEventsCommand *command =
-        new ChangeEventsCommand(m_model, tr("Paste"));
+        new ChangeEventsCommand(m_model.untyped, tr("Paste"));
 
     for (EventVector::const_iterator i = points.begin();
          i != points.end(); ++i) {
         
         sv_frame_t frame = 0;

         }
 
         Event p = *i;
         Event newPoint = p;
         if (!p.hasValue()) {
-            newPoint = newPoint.withValue((m_model->getValueMinimum() +
-                                           m_model->getValueMaximum()) / 2);
+            newPoint = newPoint.withValue((model->getValueMinimum() +
+                                           model->getValueMaximum()) / 2);
         }
         if (!p.hasDuration()) {
             sv_frame_t nextFrame = frame;
             EventVector::const_iterator j = i;
             for (; j != points.end(); ++j) {

             }
             if (j != points.end()) {
                 nextFrame = j->getFrame();
             }
             if (nextFrame == frame) {
-                newPoint = newPoint.withDuration(m_model->getResolution());
+                newPoint = newPoint.withDuration(model->getResolution());
             } else {
                 newPoint = newPoint.withDuration(nextFrame - frame);
             }
         }