comparison layer/RegionLayer.cpp @ 1428:c9fa16e41664 single-point

Update RegionLayer to updated RegionModel

     m_distributionMap.clear();
     if (!m_model) return;
 
 //    SVDEBUG << "RegionLayer::recalcSpacing" << endl;
 
-    for (RegionModel::PointList::const_iterator i = m_model->getPoints().begin();
-         i != m_model->getPoints().end(); ++i) {
-        m_distributionMap[i->value]++;
-//        SVDEBUG << "RegionLayer::recalcSpacing: value found: " << i->value << " (now have " << m_distributionMap[i->value] << " of this value)" <<  endl;
+    EventVector allEvents = m_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;
     }
 
     int n = 0;
 
     for (SpacingMap::const_iterator i = m_distributionMap.begin();

     max = m_model->getValueMaximum();
 
     return true;
 }
 
-RegionModel::PointList
+EventVector
 RegionLayer::getLocalPoints(LayerGeometryProvider *v, int x) const
 {
-    if (!m_model) return RegionModel::PointList();
+    if (!m_model) return EventVector();
 
     sv_frame_t frame = v->getFrameForX(x);
 
-    RegionModel::PointList onPoints =
-        m_model->getPoints(frame);
-
-    if (!onPoints.empty()) {
-        return onPoints;
-    }
-
-    RegionModel::PointList prevPoints =
-        m_model->getPreviousPoints(frame);
-    RegionModel::PointList nextPoints =
-        m_model->getNextPoints(frame);
-
-    RegionModel::PointList usePoints = prevPoints;
-
-    if (prevPoints.empty()) {
-        usePoints = nextPoints;
-    } else if (long(prevPoints.begin()->frame) < v->getStartFrame() &&
-               !(nextPoints.begin()->frame > v->getEndFrame())) {
-        usePoints = nextPoints;
-    } else if (long(nextPoints.begin()->frame) - frame <
-               frame - long(prevPoints.begin()->frame)) {
-        usePoints = nextPoints;
-    }
-
-    if (!usePoints.empty()) {
-        int fuzz = ViewManager::scalePixelSize(2);
-        int px = v->getXForFrame(usePoints.begin()->frame);
-        if ((px > x && px - x > fuzz) ||
-            (px < x && x - px > fuzz + 1)) {
-            usePoints.clear();
-        }
-    }
-
-    return usePoints;
+    EventVector local = m_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);
+    if (!local.empty()) return local;
+
+    local = m_model->getEventsSpanning(start, frame - start);
+    if (!local.empty()) return local;
+
+    return {};
 }
 
 bool
-RegionLayer::getPointToDrag(LayerGeometryProvider *v, int x, int y, RegionModel::Point &p) const
+RegionLayer::getPointToDrag(LayerGeometryProvider *v, int x, int y, Event &point) const
 {
     if (!m_model) return false;
 
     sv_frame_t frame = v->getFrameForX(x);
 
-    RegionModel::PointList onPoints = m_model->getPoints(frame);
+    EventVector onPoints = m_model->getEventsCovering(frame);
     if (onPoints.empty()) return false;
 
     int nearestDistance = -1;
-
-    for (RegionModel::PointList::const_iterator i = onPoints.begin();
-         i != onPoints.end(); ++i) {
-        
-        int distance = getYForValue(v, (*i).value) - y;
+    for (const auto &p: onPoints) {
+        int distance = getYForValue(v, p.getValue()) - y;
         if (distance < 0) distance = -distance;
         if (nearestDistance == -1 || distance < nearestDistance) {
             nearestDistance = distance;
-            p = *i;
+            point = p;
         }
     }
 
     return true;
 }
 
 QString
 RegionLayer::getLabelPreceding(sv_frame_t frame) const
 {
     if (!m_model) return "";
-    RegionModel::PointList points = m_model->getPreviousPoints(frame);
-    for (RegionModel::PointList::const_iterator i = points.begin();
-         i != points.end(); ++i) {
-        if (i->label != "") return i->label;
-    }
-    return "";
+    EventVector points = m_model->getEventsStartingWithin
+        (m_model->getStartFrame(), frame - m_model->getStartFrame());
+    if (!points.empty()) {
+        for (auto i = points.rbegin(); i != points.rend(); ++i) {
+            if (i->getLabel() != QString()) {
+                return i->getLabel();
+            }
+        }
+    }
+    return QString();
 }
 
 QString
 RegionLayer::getFeatureDescription(LayerGeometryProvider *v, QPoint &pos) const
 {
     int x = pos.x();
 
     if (!m_model || !m_model->getSampleRate()) return "";
 
-    RegionModel::PointList points = getLocalPoints(v, x);
+    EventVector points = getLocalPoints(v, x);
 
     if (points.empty()) {
         if (!m_model->isReady()) {
             return tr("In progress");
         } else {
             return tr("No local points");
         }
     }
 
-    RegionRec region(0);
-    RegionModel::PointList::iterator i;
+    Event region;
+    EventVector::iterator i;
 
     //!!! harmonise with whatever decision is made about point y
     //!!! coords in paint method
 
     for (i = points.begin(); i != points.end(); ++i) {
 
-        int y = getYForValue(v, i->value);
+        int y = getYForValue(v, i->getValue());
         int h = 3;
 
         if (m_model->getValueQuantization() != 0.0) {
-            h = y - getYForValue(v, i->value + m_model->getValueQuantization());
+            h = y - getYForValue
+                (v, i->getValue() + m_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.frame,
+    RealTime rt = RealTime::frame2RealTime(region.getFrame(),
                                            m_model->getSampleRate());
-    RealTime rd = RealTime::frame2RealTime(region.duration,
+    RealTime rd = RealTime::frame2RealTime(region.getDuration(),
                                            m_model->getSampleRate());
     
     QString valueText;
 
-    valueText = tr("%1 %2").arg(region.value).arg(getScaleUnits());
+    valueText = tr("%1 %2").arg(region.getValue()).arg(getScaleUnits());
 
     QString text;
 
-    if (region.label == "") {
+    if (region.getLabel() == "") {
         text = QString(tr("Time:\t%1\nValue:\t%2\nDuration:\t%3\nNo label"))
             .arg(rt.toText(true).c_str())
             .arg(valueText)
             .arg(rd.toText(true).c_str());
     } else {
         text = QString(tr("Time:\t%1\nValue:\t%2\nDuration:\t%3\nLabel:\t%4"))
             .arg(rt.toText(true).c_str())
             .arg(valueText)
             .arg(rd.toText(true).c_str())
-            .arg(region.label);
-    }
-
-    pos = QPoint(v->getXForFrame(region.frame),
-                 getYForValue(v, region.value));
+            .arg(region.getLabel());
+    }
+
+    pos = QPoint(v->getXForFrame(region.getFrame()),
+                 getYForValue(v, region.getValue()));
     return text;
 }
 
 bool
 RegionLayer::snapToFeatureFrame(LayerGeometryProvider *v, sv_frame_t &frame,

     if (!m_model) {
         return Layer::snapToFeatureFrame(v, frame, resolution, snap);
     }
 
     resolution = m_model->getResolution();
-    RegionModel::PointList points;
+    EventVector points;
 
     if (snap == SnapNeighbouring) {
         
         points = getLocalPoints(v, v->getXForFrame(frame));
         if (points.empty()) return false;
-        frame = points.begin()->frame;
+        frame = points.begin()->getFrame();
         return true;
     }    
 
-    points = m_model->getPoints(frame, frame);
+    //!!! I think this is not quite right - we want to be able to snap
+    //!!! to events that are nearby but not covering the given frame,
+    //!!! and I think that worked with the old code. Compare and
+    //!!! revise.
+    
+    points = m_model->getEventsCovering(frame);
     sv_frame_t snapped = frame;
     bool found = false;
 
-    for (RegionModel::PointList::const_iterator i = points.begin();
+    for (EventVector::const_iterator i = points.begin();
          i != points.end(); ++i) {
 
         if (snap == SnapRight) {
 
             // The best frame to snap to is the end frame of whichever
             // feature we would have snapped to the start frame of if
             // we had been snapping left.
 
-            if (i->frame <= frame) {
-                if (i->frame + i->duration > frame) {
-                    snapped = i->frame + i->duration;
+            if (i->getFrame() <= frame) {
+                if (i->getFrame() + i->getDuration() > frame) {
+                    snapped = i->getFrame() + i->getDuration();
                     found = true; // don't break, as the next may be better
                 }
             } else {
                 if (!found) {
-                    snapped = i->frame;
+                    snapped = i->getFrame();
                     found = true;
                 }
                 break;
             }
 
         } else if (snap == SnapLeft) {
 
-            if (i->frame <= frame) {
-                snapped = i->frame;
+            if (i->getFrame() <= frame) {
+                snapped = i->getFrame();
                 found = true; // don't break, as the next may be better
             } else {
                 break;
             }
 
         } else { // nearest
 
-            RegionModel::PointList::const_iterator j = i;
+            EventVector::const_iterator j = i;
             ++j;
 
             if (j == points.end()) {
 
-                snapped = i->frame;
+                snapped = i->getFrame();
                 found = true;
                 break;
 
-            } else if (j->frame >= frame) {
-
-                if (j->frame - frame < frame - i->frame) {
-                    snapped = j->frame;
+            } else if (j->getFrame() >= frame) {
+
+                if (j->getFrame() - frame < frame - i->getFrame()) {
+                    snapped = j->getFrame();
                 } else {
-                    snapped = i->frame;
+                    snapped = i->getFrame();
                 }
                 found = true;
                 break;
             }
         }

         return Layer::snapToSimilarFeature(v, frame, resolution, snap);
     }
 
     resolution = m_model->getResolution();
 
-    const RegionModel::PointList &points = m_model->getPoints();
-    RegionModel::PointList close = m_model->getPoints(frame, frame);
-
-    RegionModel::PointList::const_iterator i;
+    /*!!! todo: overhaul the logic of this function (and supporting
+          apis in EventSeries / RegionModel)
+
+    const EventVector &points = m_model->getPoints();
+    EventVector close = m_model->getPoints(frame, frame);
+    */
+    EventVector points = m_model->getAllEvents();
+    EventVector close = {};
+    
+    EventVector::const_iterator i;
 
     sv_frame_t matchframe = frame;
     double matchvalue = 0.f;
 
     for (i = close.begin(); i != close.end(); ++i) {
-        if (i->frame > frame) break;
-        matchvalue = i->value;
-        matchframe = i->frame;
+        if (i->getFrame() > frame) break;
+        matchvalue = i->getValue();
+        matchframe = i->getFrame();
     }
 
     sv_frame_t snapped = frame;
     bool found = false;
     bool distant = false;

             }
         }
 
         if (snap == SnapRight) {
 
-            if (i->frame > matchframe &&
-                fabs(i->value - matchvalue) < epsilon) {
-                snapped = i->frame;
+            if (i->getFrame() > matchframe &&
+                fabs(i->getValue() - matchvalue) < epsilon) {
+                snapped = i->getFrame();
                 found = true;
                 break;
             }
 
         } else if (snap == SnapLeft) {
 
-            if (i->frame < matchframe) {
-                if (fabs(i->value - matchvalue) < epsilon) {
-                    snapped = i->frame;
+            if (i->getFrame() < matchframe) {
+                if (fabs(i->getValue() - matchvalue) < epsilon) {
+                    snapped = i->getFrame();
                     found = true; // don't break, as the next may be better
                 }
             } else if (found || distant) {
                 break;
             }

     int x0 = rect.left() - 40, x1 = rect.right();
 
     sv_frame_t wholeFrame0 = v->getFrameForX(0);
     sv_frame_t wholeFrame1 = v->getFrameForX(v->getPaintWidth());
 
-    RegionModel::PointList points(m_model->getPoints(wholeFrame0, wholeFrame1));
+    EventVector points(m_model->getEventsSpanning(wholeFrame0,
+                                                  wholeFrame1 - wholeFrame0));
     if (points.empty()) return;
 
     paint.setPen(getBaseQColor());
 
     QColor brushColour(getBaseQColor());

     double min = m_model->getValueMinimum();
     double max = m_model->getValueMaximum();
     if (max == min) max = min + 1.0;
 
     QPoint localPos;
-    RegionModel::Point illuminatePoint(0);
+    Event illuminatePoint(0);
     bool shouldIlluminate = false;
 
     if (v->shouldIlluminateLocalFeatures(this, localPos)) {
         shouldIlluminate = getPointToDrag(v, localPos.x(), localPos.y(),
                                           illuminatePoint);

     //!!! if it does have distinct values, we should still ensure y
     //!!! coord is never completely flat on the top or bottom
 
     int fontHeight = paint.fontMetrics().height();
 
-    for (RegionModel::PointList::const_iterator i = points.begin();
+    for (EventVector::const_iterator i = points.begin();
          i != points.end(); ++i) {
 
-        const RegionModel::Point &p(*i);
-
-        int x = v->getXForFrame(p.frame);
-        int w = v->getXForFrame(p.frame + p.duration) - x;
-        int y = getYForValue(v, p.value);
+        const Event &p(*i);
+
+        int x = v->getXForFrame(p.getFrame());
+        int w = v->getXForFrame(p.getFrame() + p.getDuration()) - x;
+        int y = getYForValue(v, p.getValue());
         int h = 9;
         int ex = x + w;
 
         int gap = v->scalePixelSize(2);
         
-        RegionModel::PointList::const_iterator j = i;
+        EventVector::const_iterator j = i;
         ++j;
 
         if (j != points.end()) {
-            const RegionModel::Point &q(*j);
-            int nx = v->getXForFrame(q.frame);
+            const Event &q(*j);
+            int nx = v->getXForFrame(q.getFrame());
             if (nx < ex) ex = nx;
         }
 
         if (m_model->getValueQuantization() != 0.0) {
-            h = y - getYForValue(v, p.value + m_model->getValueQuantization());
+            h = y - getYForValue
+                (v, p.getValue() + m_model->getValueQuantization());
             if (h < 3) h = 3;
         }
 
         if (w < 1) w = 1;
 
         if (m_plotStyle == PlotSegmentation) {
             paint.setPen(getForegroundQColor(v->getView()));
-            paint.setBrush(getColourForValue(v, p.value));
+            paint.setBrush(getColourForValue(v, p.getValue()));
         } else {
             paint.setPen(getBaseQColor());
             paint.setBrush(brushColour);
         }
 
         if (m_plotStyle == PlotSegmentation) {
 
             if (ex <= x) continue;
 
-            if (!shouldIlluminate ||
-                // "illuminatePoint != p"
-                RegionModel::Point::Comparator()(illuminatePoint, p) ||
-                RegionModel::Point::Comparator()(p, illuminatePoint)) {
+            if (!shouldIlluminate || illuminatePoint != p) {
 
                 paint.setPen(QPen(getForegroundQColor(v->getView()), 1));
                 paint.drawLine(x, 0, x, v->getPaintHeight());
                 paint.setPen(Qt::NoPen);
 

 
             paint.drawRect(x, -1, ex - x, v->getPaintHeight() + gap);
 
         } else {
 
-            if (shouldIlluminate &&
-                // "illuminatePoint == p"
-                !RegionModel::Point::Comparator()(illuminatePoint, p) &&
-                !RegionModel::Point::Comparator()(p, illuminatePoint)) {
+            if (shouldIlluminate && illuminatePoint == p) {
 
                 paint.setPen(v->getForeground());
                 paint.setBrush(v->getForeground());
 
-                QString vlabel = QString("%1%2").arg(p.value).arg(getScaleUnits());
+                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.frame, m_model->getSampleRate()).toText(true).c_str();
+                    (p.getFrame(), m_model->getSampleRate()).toText(true).c_str();
                 PaintAssistant::drawVisibleText(v, paint, 
                                    x,
                                    y - h/2 - paint.fontMetrics().descent() - gap,
                                    hlabel, PaintAssistant::OutlinedText);
             }

     }
 
     int nextLabelMinX = -100;
     int lastLabelY = 0;
 
-    for (RegionModel::PointList::const_iterator i = points.begin();
+    for (EventVector::const_iterator i = points.begin();
          i != points.end(); ++i) {
 
-        const RegionModel::Point &p(*i);
-
-        int x = v->getXForFrame(p.frame);
-        int w = v->getXForFrame(p.frame + p.duration) - x;
-        int y = getYForValue(v, p.value);
-
-        QString label = p.label;
+        const Event &p(*i);
+
+        int x = v->getXForFrame(p.getFrame());
+        int w = v->getXForFrame(p.getFrame() + p.getDuration()) - x;
+        int y = getYForValue(v, p.getValue());
+
+        QString label = p.getLabel();
         if (label == "") {
-            label = QString("%1%2").arg(p.value).arg(getScaleUnits());
+            label = QString("%1%2").arg(p.getValue()).arg(getScaleUnits());
         }
         int labelWidth = paint.fontMetrics().width(label);
 
         int gap = v->scalePixelSize(2);
 

         }
         
         bool illuminated = false;
 
         if (m_plotStyle != PlotSegmentation) {
-
-            if (shouldIlluminate &&
-                // "illuminatePoint == p"
-                !RegionModel::Point::Comparator()(illuminatePoint, p) &&
-                !RegionModel::Point::Comparator()(p, illuminatePoint)) {
-
+            if (shouldIlluminate && illuminatePoint == p) {
                 illuminated = true;
             }
         }
 
         if (!illuminated) {

 }
 
 void
 RegionLayer::paintVerticalScale(LayerGeometryProvider *v, bool, QPainter &paint, QRect) const
 {
-    if (!m_model || m_model->getPoints().empty()) return;
+    if (!m_model || m_model->isEmpty()) return;
 
     QString unit;
     double min, max;
     bool logarithmic;
 

     if (frame < 0) frame = 0;
     frame = frame / m_model->getResolution() * m_model->getResolution();
 
     double value = getValueForY(v, e->y());
 
-    m_editingPoint = RegionModel::Point(frame, float(value), 0, "");
+    m_editingPoint = Event(frame, float(value), 0, "");
     m_originalPoint = m_editingPoint;
 
     if (m_editingCommand) finish(m_editingCommand);
-    m_editingCommand = new RegionModel::EditCommand(m_model,
+    m_editingCommand = new ChangeEventsCommand(m_model,
                                                     tr("Draw Region"));
-    m_editingCommand->addPoint(m_editingPoint);
+    m_editingCommand->add(m_editingPoint);
 
     recalcSpacing();
 
     m_editing = true;
 }

 
     sv_frame_t frame = v->getFrameForX(e->x());
     if (frame < 0) frame = 0;
     frame = frame / m_model->getResolution() * m_model->getResolution();
 
-    double newValue = m_editingPoint.value;
+    double newValue = m_editingPoint.getValue();
     if (m_verticalScale != EqualSpaced) newValue = getValueForY(v, e->y());
 
-    sv_frame_t newFrame = m_editingPoint.frame;
+    sv_frame_t newFrame = m_editingPoint.getFrame();
     sv_frame_t newDuration = frame - newFrame;
     if (newDuration < 0) {
         newFrame = frame;
         newDuration = -newDuration;
     } else if (newDuration == 0) {
         newDuration = 1;
     }
 
-    m_editingCommand->deletePoint(m_editingPoint);
-    m_editingPoint.frame = newFrame;
-    m_editingPoint.value = float(newValue);
-    m_editingPoint.duration = newDuration;
-    m_editingCommand->addPoint(m_editingPoint);
+    m_editingCommand->remove(m_editingPoint);
+    m_editingPoint = m_editingPoint
+        .withFrame(newFrame)
+        .withValue(float(newValue))
+        .withDuration(newDuration);
+    m_editingCommand->add(m_editingPoint);
 
     recalcSpacing();
 }
 
 void

 {
     if (!m_model || !m_editing) return;
 
     m_editing = false;
 
-    RegionModel::Point p(0);
+    Event p(0);
     if (!getPointToDrag(v, e->x(), e->y(), p)) return;
-    if (p.frame != m_editingPoint.frame || p.value != m_editingPoint.value) return;
-
-    m_editingCommand = new RegionModel::EditCommand
+    if (p.getFrame() != m_editingPoint.getFrame() ||
+        p.getValue() != m_editingPoint.getValue()) return;
+
+    m_editingCommand = new ChangeEventsCommand
         (m_model, tr("Erase Region"));
 
-    m_editingCommand->deletePoint(m_editingPoint);
+    m_editingCommand->remove(m_editingPoint);
 
     finish(m_editingCommand);
     m_editingCommand = nullptr;
     m_editing = false;
     recalcSpacing();

 
     if (!getPointToDrag(v, e->x(), e->y(), m_editingPoint)) {
         return;
     }
 
-    m_dragPointX = v->getXForFrame(m_editingPoint.frame);
-    m_dragPointY = getYForValue(v, m_editingPoint.value);
+    m_dragPointX = v->getXForFrame(m_editingPoint.getFrame());
+    m_dragPointY = getYForValue(v, m_editingPoint.getValue());
 
     m_originalPoint = m_editingPoint;
 
     if (m_editingCommand) {
         finish(m_editingCommand);

     if (frame < 0) frame = 0;
     frame = frame / m_model->getResolution() * m_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.value];
+    int avoid = m_spacingMap[m_editingPoint.getValue()];
 
     // ... unless there are other points with the same value
-    if (m_distributionMap[m_editingPoint.value] > 1) avoid = -1;
+    if (m_distributionMap[m_editingPoint.getValue()] > 1) avoid = -1;
 
     double value = getValueForY(v, newy, avoid);
 
     if (!m_editingCommand) {
-        m_editingCommand = new RegionModel::EditCommand(m_model,
+        m_editingCommand = new ChangeEventsCommand(m_model,
                                                       tr("Drag Region"));
     }
 
-    m_editingCommand->deletePoint(m_editingPoint);
-    m_editingPoint.frame = frame;
-    m_editingPoint.value = float(value);
-    m_editingCommand->addPoint(m_editingPoint);
+    m_editingCommand->remove(m_editingPoint);
+    m_editingPoint = m_editingPoint
+        .withFrame(frame)
+        .withValue(float(value));
+    m_editingCommand->add(m_editingPoint);
     recalcSpacing();
 }
 
 void
 RegionLayer::editEnd(LayerGeometryProvider *, QMouseEvent *)

 
     if (m_editingCommand) {
 
         QString newName = m_editingCommand->getName();
 
-        if (m_editingPoint.frame != m_originalPoint.frame) {
-            if (m_editingPoint.value != m_originalPoint.value) {
+        if (m_editingPoint.getFrame() != m_originalPoint.getFrame()) {
+            if (m_editingPoint.getValue() != m_originalPoint.getValue()) {
                 newName = tr("Edit Region");
             } else {
                 newName = tr("Relocate Region");
             }
         } else {

 bool
 RegionLayer::editOpen(LayerGeometryProvider *v, QMouseEvent *e)
 {
     if (!m_model) return false;
 
-    RegionModel::Point region(0);
+    Event region(0);
     if (!getPointToDrag(v, e->x(), e->y(), region)) return false;
 
     ItemEditDialog *dialog = new ItemEditDialog
         (m_model->getSampleRate(),
          ItemEditDialog::ShowTime |
          ItemEditDialog::ShowDuration |
          ItemEditDialog::ShowValue |
          ItemEditDialog::ShowText,
          getScaleUnits());
 
-    dialog->setFrameTime(region.frame);
-    dialog->setValue(region.value);
-    dialog->setFrameDuration(region.duration);
-    dialog->setText(region.label);
+    dialog->setFrameTime(region.getFrame());
+    dialog->setValue(region.getValue());
+    dialog->setFrameDuration(region.getDuration());
+    dialog->setText(region.getLabel());
 
     if (dialog->exec() == QDialog::Accepted) {
 
-        RegionModel::Point newRegion = region;
-        newRegion.frame = dialog->getFrameTime();
-        newRegion.value = dialog->getValue();
-        newRegion.duration = dialog->getFrameDuration();
-        newRegion.label = dialog->getText();
+        Event newRegion = region
+            .withFrame(dialog->getFrameTime())
+            .withValue(dialog->getValue())
+            .withDuration(dialog->getFrameDuration())
+            .withLabel(dialog->getText());
         
-        RegionModel::EditCommand *command = new RegionModel::EditCommand
+        ChangeEventsCommand *command = new ChangeEventsCommand
             (m_model, tr("Edit Region"));
-        command->deletePoint(region);
-        command->addPoint(newRegion);
+        command->remove(region);
+        command->add(newRegion);
         finish(command);
     }
 
     delete dialog;
     recalcSpacing();

 void
 RegionLayer::moveSelection(Selection s, sv_frame_t newStartFrame)
 {
     if (!m_model) return;
 
-    RegionModel::EditCommand *command =
-        new RegionModel::EditCommand(m_model, tr("Drag Selection"));
-
-    RegionModel::PointList points =
-        m_model->getPoints(s.getStartFrame(), s.getEndFrame());
-
-    for (RegionModel::PointList::iterator i = points.begin();
+    ChangeEventsCommand *command =
+        new ChangeEventsCommand(m_model, tr("Drag Selection"));
+
+    EventVector points =
+        m_model->getEventsStartingWithin(s.getStartFrame(), s.getDuration());
+
+    for (EventVector::iterator i = points.begin();
          i != points.end(); ++i) {
 
-        if (s.contains(i->frame)) {
-            RegionModel::Point newPoint(*i);
-            newPoint.frame = i->frame + newStartFrame - s.getStartFrame();
-            command->deletePoint(*i);
-            command->addPoint(newPoint);
+        if (s.contains(i->getFrame())) {
+            Event newPoint = (*i)
+                .withFrame(i->getFrame() + newStartFrame - s.getStartFrame());
+            command->remove(*i);
+            command->add(newPoint);
         }
     }
 
     finish(command);
     recalcSpacing();
 }
 
 void
 RegionLayer::resizeSelection(Selection s, Selection newSize)
 {
-    if (!m_model) return;
-
-    RegionModel::EditCommand *command =
-        new RegionModel::EditCommand(m_model, tr("Resize Selection"));
-
-    RegionModel::PointList points =
-        m_model->getPoints(s.getStartFrame(), s.getEndFrame());
-
-    double ratio =
-        double(newSize.getEndFrame() - newSize.getStartFrame()) /
-        double(s.getEndFrame() - s.getStartFrame());
-
-    for (RegionModel::PointList::iterator i = points.begin();
-         i != points.end(); ++i) {
-
-        if (s.contains(i->frame)) {
-
-            double targetStart = double(i->frame);
-            targetStart = double(newSize.getStartFrame()) +
-                targetStart - double(s.getStartFrame()) * ratio;
-
-            double targetEnd = double(i->frame + i->duration);
-            targetEnd = double(newSize.getStartFrame()) +
-                targetEnd - double(s.getStartFrame()) * ratio;
-
-            RegionModel::Point newPoint(*i);
-            newPoint.frame = lrint(targetStart);
-            newPoint.duration = lrint(targetEnd - targetStart);
-            command->deletePoint(*i);
-            command->addPoint(newPoint);
-        }
+    if (!m_model || !s.getDuration()) return;
+
+    ChangeEventsCommand *command =
+        new ChangeEventsCommand(m_model, tr("Resize Selection"));
+
+    EventVector points =
+        m_model->getEventsStartingWithin(s.getStartFrame(), s.getDuration());
+
+    double ratio = double(newSize.getDuration()) / double(s.getDuration());
+    double oldStart = double(s.getStartFrame());
+    double newStart = double(newSize.getStartFrame());
+    
+    for (Event p: points) {
+
+        double newFrame = (double(p.getFrame()) - oldStart) * ratio + newStart;
+        double newDuration = double(p.getDuration()) * ratio;
+
+        Event newPoint = p
+            .withFrame(lrint(newFrame))
+            .withDuration(lrint(newDuration));
+        command->remove(p);
+        command->add(newPoint);
     }
 
     finish(command);
     recalcSpacing();
 }

 void
 RegionLayer::deleteSelection(Selection s)
 {
     if (!m_model) return;
 
-    RegionModel::EditCommand *command =
-        new RegionModel::EditCommand(m_model, tr("Delete Selected Points"));
-
-    RegionModel::PointList points =
-        m_model->getPoints(s.getStartFrame(), s.getEndFrame());
-
-    for (RegionModel::PointList::iterator i = points.begin();
+    ChangeEventsCommand *command =
+        new ChangeEventsCommand(m_model, tr("Delete Selected Points"));
+
+    EventVector points =
+        m_model->getEventsStartingWithin(s.getStartFrame(), s.getDuration());
+
+    for (EventVector::iterator i = points.begin();
          i != points.end(); ++i) {
 
-        if (s.contains(i->frame)) {
-            command->deletePoint(*i);
+        if (s.contains(i->getFrame())) {
+            command->remove(*i);
         }
     }
 
     finish(command);
     recalcSpacing();

 void
 RegionLayer::copy(LayerGeometryProvider *v, Selection s, Clipboard &to)
 {
     if (!m_model) return;
 
-    RegionModel::PointList points =
-        m_model->getPoints(s.getStartFrame(), s.getEndFrame());
-
-    for (RegionModel::PointList::iterator i = points.begin();
-         i != points.end(); ++i) {
-        if (s.contains(i->frame)) {
-            Event point(i->frame, i->value, i->duration, i->label);
-            to.addPoint(point.withReferenceFrame(alignToReference(v, i->frame)));
-        }
+    EventVector points =
+        m_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 (button == QMessageBox::Yes) {
             realign = true;
         }
     }
 
-    RegionModel::EditCommand *command =
-        new RegionModel::EditCommand(m_model, tr("Paste"));
+    ChangeEventsCommand *command =
+        new ChangeEventsCommand(m_model, tr("Paste"));
 
     for (EventVector::const_iterator i = points.begin();
          i != points.end(); ++i) {
         
         sv_frame_t frame = 0;

             } else {
                 frame = i->getFrame();
             }
         }
 
-        RegionModel::Point newPoint(frame);
-  
-        if (i->hasLabel()) newPoint.label = i->getLabel();
-        if (i->hasValue()) newPoint.value = i->getValue();
-        else newPoint.value = (m_model->getValueMinimum() +
-                               m_model->getValueMaximum()) / 2;
-        if (i->hasDuration()) newPoint.duration = i->getDuration();
-        else {
+        Event p = *i;
+        Event newPoint = p;
+        if (!p.hasValue()) {
+            newPoint = newPoint.withValue((m_model->getValueMinimum() +
+                                           m_model->getValueMaximum()) / 2);
+        }
+        if (!p.hasDuration()) {
             sv_frame_t nextFrame = frame;
             EventVector::const_iterator j = i;
             for (; j != points.end(); ++j) {
                 if (j != i) break;
             }
             if (j != points.end()) {
                 nextFrame = j->getFrame();
             }
             if (nextFrame == frame) {
-                newPoint.duration = m_model->getResolution();
+                newPoint = newPoint.withDuration(m_model->getResolution());
             } else {
-                newPoint.duration = nextFrame - frame;
+                newPoint = newPoint.withDuration(nextFrame - frame);
             }
         }
         
-        command->addPoint(newPoint);
+        command->add(newPoint);
     }
 
     finish(command);
     recalcSpacing();
     return true;