comparison layer/TimeValueLayer.cpp @ 1429:8a7c82282fbc single-point

Update TimeValueLayer etc

     }
 
     return mapper;
 }
 
-SparseTimeValueModel::PointList
+EventVector
 TimeValueLayer::getLocalPoints(LayerGeometryProvider *v, int x) const
 {
-    if (!m_model) return SparseTimeValueModel::PointList();
+    if (!m_model) return {};
 
     sv_frame_t frame = v->getFrameForX(x);
 
-    SparseTimeValueModel::PointList onPoints =
-        m_model->getPoints(frame);
-
-    if (!onPoints.empty()) {
-        return onPoints;
-    }
+    //!!! this is not going to be right - we want "nearby" points and
+    //!!! there's no api for that
+    
+    EventVector local = m_model->getEventsCovering(frame);
+    if (!local.empty()) return local;
+
+    return {};
+/*!!!
 
     SparseTimeValueModel::PointList prevPoints =
         m_model->getPreviousPoints(frame);
     SparseTimeValueModel::PointList nextPoints =
         m_model->getNextPoints(frame);

             usePoints.clear();
         }
     }
 
     return usePoints;
+*/
 }
 
 QString
-TimeValueLayer::getLabelPreceding(sv_frame_t frame) const
-{
-    if (!m_model) return "";
-    SparseTimeValueModel::PointList points = m_model->getPreviousPoints(frame);
-    for (SparseTimeValueModel::PointList::const_iterator i = points.begin();
+TimeValueLayer::getLabelPreceding(sv_frame_t /* frame */) const
+{
+    if (!m_model || !m_model->hasTextLabels()) return "";
+/*!!! no corresponding api yet
+    EventVector points = m_model->getPreviousPoints(frame);
+    for (EventVector::const_iterator i = points.begin();
          i != points.end(); ++i) {
-        if (i->label != "") return i->label;
-    }
+        if (i->getLabel() != "") return i->getLabel();
+    }
+*/
     return "";
 }
 
 QString
 TimeValueLayer::getFeatureDescription(LayerGeometryProvider *v, QPoint &pos) const
 {
     int x = pos.x();
 
     if (!m_model || !m_model->getSampleRate()) return "";
 
-    SparseTimeValueModel::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");
         }
     }
 
-    sv_frame_t useFrame = points.begin()->frame;
+    sv_frame_t useFrame = points.begin()->getFrame();
 
     RealTime rt = RealTime::frame2RealTime(useFrame, m_model->getSampleRate());
     
     QString valueText;
-    float value = points.begin()->value;
+    float value = points.begin()->getValue();
     QString unit = getScaleUnits();
 
     if (unit == "Hz") {
         valueText = tr("%1 Hz (%2, %3)")
             .arg(value)

         valueText = tr("%1").arg(value);
     }
     
     QString text;
 
-    if (points.begin()->label == "") {
+    if (points.begin()->getLabel() == "") {
         text = QString(tr("Time:\t%1\nValue:\t%2\nNo label"))
             .arg(rt.toText(true).c_str())
             .arg(valueText);
     } else {
         text = QString(tr("Time:\t%1\nValue:\t%2\nLabel:\t%4"))
             .arg(rt.toText(true).c_str())
             .arg(valueText)
-            .arg(points.begin()->label);
+            .arg(points.begin()->getLabel());
     }
 
     pos = QPoint(v->getXForFrame(useFrame),
-                 getYForValue(v, points.begin()->value));
+                 getYForValue(v, points.begin()->getValue()));
     return text;
 }
 
 bool
-TimeValueLayer::snapToFeatureFrame(LayerGeometryProvider *v, sv_frame_t &frame,
+TimeValueLayer::snapToFeatureFrame(LayerGeometryProvider *v,
+                                   sv_frame_t &frame,
                                    int &resolution,
                                    SnapType snap) const
 {
     if (!m_model) {
         return Layer::snapToFeatureFrame(v, frame, resolution, snap);
     }
 
     resolution = m_model->getResolution();
-    SparseTimeValueModel::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);
+    //!!! again, wrong api - correct one is not here yet
+    points = m_model->getEventsCovering(frame);
     sv_frame_t snapped = frame;
     bool found = false;
 
-    for (SparseTimeValueModel::PointList::const_iterator i = points.begin();
+    for (EventVector::const_iterator i = points.begin();
          i != points.end(); ++i) {
 
         if (snap == SnapRight) {
 
-            if (i->frame > frame) {
-                snapped = i->frame;
+            if (i->getFrame() > 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
 
-            SparseTimeValueModel::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 SparseTimeValueModel::PointList &points = m_model->getPoints();
-    SparseTimeValueModel::PointList close = m_model->getPoints(frame, frame);
-
-    SparseTimeValueModel::PointList::const_iterator i;
+    /*!!! todo: overhaul the logic of this function (and supporting
+          apis in EventSeries / SparseTimeValueModel)
+
+    const EventVector &points = m_model->getPoints();
+    EventVector close = m_model->getPoints(frame, frame);
+    */
+    const EventVector &points = m_model->getAllEvents();
+    EventVector close = {};
+
+    EventVector::const_iterator i;
 
     sv_frame_t matchframe = frame;
     double matchvalue = 0.0;
 
     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(), x1 = rect.right();
     sv_frame_t frame0 = v->getFrameForX(x0);
     sv_frame_t frame1 = v->getFrameForX(x1);
     if (m_derivative) --frame0;
 
-    SparseTimeValueModel::PointList points(m_model->getPoints
-                                           (frame0, frame1));
+    EventVector points(m_model->getEventsWithin(frame0, frame1 - frame0));
     if (points.empty()) return;
 
     paint.setPen(getBaseQColor());
 
     QColor brushColour(getBaseQColor());

 
     QPoint localPos;
     sv_frame_t illuminateFrame = -1;
 
     if (v->shouldIlluminateLocalFeatures(this, localPos)) {
-        SparseTimeValueModel::PointList localPoints =
-            getLocalPoints(v, localPos.x());
+        EventVector localPoints = getLocalPoints(v, localPos.x());
 #ifdef DEBUG_TIME_VALUE_LAYER
         cerr << "TimeValueLayer: " << localPoints.size() << " local points" << endl;
 #endif
-        if (!localPoints.empty()) illuminateFrame = localPoints.begin()->frame;
+        if (!localPoints.empty()) {
+            illuminateFrame = localPoints.begin()->getFrame();
+        }
     }
 
     int w =
         v->getXForFrame(frame0 + m_model->getResolution()) -
         v->getXForFrame(frame0);

         }
     }
     
     sv_frame_t prevFrame = 0;
 
-    for (SparseTimeValueModel::PointList::const_iterator i = points.begin();
+    for (EventVector::const_iterator i = points.begin();
          i != points.end(); ++i) {
 
         if (m_derivative && i == points.begin()) continue;
 
-        const SparseTimeValueModel::Point &p(*i);
-
-        double value = p.value;
+        Event p(*i);
+
+        double value = p.getValue();
         if (m_derivative) {
-            SparseTimeValueModel::PointList::const_iterator j = i;
+            EventVector::const_iterator j = i;
             --j;
-            value -= j->value;
-        }
-
-        int x = v->getXForFrame(p.frame);
+            value -= j->getValue();
+        }
+
+        int x = v->getXForFrame(p.getFrame());
         int y = getYForValue(v, value);
 
         bool gap = false;
         if (m_plotStyle == PlotDiscreteCurves) { 
             if (value == 0.0) {
                 // Treat zeros as gaps
                 continue;
             }
-            gap = (p.frame > prevFrame &&
-                   (p.frame - prevFrame >= m_model->getResolution() * 2));
+            gap = (p.getFrame() > prevFrame &&
+                   (p.getFrame() - prevFrame >= m_model->getResolution() * 2));
         }
 
         if (m_plotStyle != PlotSegmentation) {
             textY = y - paint.fontMetrics().height()
                       + paint.fontMetrics().ascent() - 1;

         double nvalue = 0.f;
         sv_frame_t nf = v->getModelsEndFrame();
         int nx = v->getXForFrame(nf);
         int ny = y;
 
-        SparseTimeValueModel::PointList::const_iterator j = i;
+        EventVector::const_iterator j = i;
         ++j;
 
         if (j != points.end()) {
-            const SparseTimeValueModel::Point &q(*j);
-            nvalue = q.value;
-            if (m_derivative) nvalue -= p.value;
-            nf = q.frame;
+            Event q(*j);
+            nvalue = q.getValue();
+            if (m_derivative) nvalue -= p.getValue();
+            nf = q.getFrame();
             nx = v->getXForFrame(nf);
             ny = getYForValue(v, nvalue);
             haveNext = true;
         }
 
-//        cout << "frame = " << p.frame << ", x = " << x << ", haveNext = " << haveNext 
+//        cout << "frame = " << p.getFrame() << ", x = " << x << ", haveNext = " << haveNext 
 //                  << ", nx = " << nx << endl;
 
         QPen pen(getBaseQColor());
         QBrush brush(brushColour);
         

             }
         }
 
         bool illuminate = false;
 
-        if (illuminateFrame == p.frame) {
+        if (illuminateFrame == p.getFrame()) {
 
             // not equipped to illuminate the right section in line
             // or curve mode
 
             if (m_plotStyle != PlotCurve &&

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

             paint.drawRect(x, -1, nx - x, v->getPaintHeight() + 1);
         }
 
         if (v->shouldShowFeatureLabels()) {
 
-            QString label = p.label;
+            QString label = p.getLabel();
             bool italic = false;
 
             if (label == "" &&
                 (m_plotStyle == PlotPoints ||
                  m_plotStyle == PlotSegmentation ||
                  m_plotStyle == PlotConnectedPoints)) {
                 char lc[20];
-                snprintf(lc, 20, "%.3g", p.value);
+                snprintf(lc, 20, "%.3g", p.getValue());
                 label = lc;
                 italic = true;
             }
 
             if (label != "") {

                 haveRoom = (haveRoom &&
                             (nx > x + 6 + paint.fontMetrics().width(label)));
                 if (haveRoom ||
                     (!haveNext &&
                      (pointCount == 0 || !italic))) {
-                    PaintAssistant::drawVisibleText(v, paint, x + 5, textY, label,
-                                       italic ?
-                                       PaintAssistant::OutlinedItalicText :
-                                       PaintAssistant::OutlinedText);
+                    PaintAssistant::drawVisibleText
+                        (v, paint, x + 5, textY, label,
+                         italic ?
+                         PaintAssistant::OutlinedItalicText :
+                         PaintAssistant::OutlinedText);
                 }
             }
         }
 
-        prevFrame = p.frame;
+        prevFrame = p.getFrame();
         ++pointCount;
     }
 
     if (m_plotStyle == PlotDiscreteCurves) {
         paint.setRenderHint(QPainter::Antialiasing, true);

 }
 
 void
 TimeValueLayer::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;
 

 
     double value = getValueForY(v, e->y());
 
     bool havePoint = false;
 
-    SparseTimeValueModel::PointList points = getLocalPoints(v, e->x());
+    EventVector points = getLocalPoints(v, e->x());
     if (!points.empty()) {
-        for (SparseTimeValueModel::PointList::iterator i = points.begin();
+        for (EventVector::iterator i = points.begin();
              i != points.end(); ++i) {
-            if (((i->frame / resolution) * resolution) != frame) {
-#ifdef DEBUG_TIME_VALUE_LAYER
-                cerr << "ignoring out-of-range frame at " << i->frame << endl;
+            if (((i->getFrame() / resolution) * resolution) != frame) {
+#ifdef DEBUG_TIME_VALUE_LAYER
+                cerr << "ignoring out-of-range frame at " << i->getFrame() << endl;
 #endif
                 continue;
             }
             m_editingPoint = *i;
             havePoint = true;
         }
     }
 
     if (!havePoint) {
-        m_editingPoint = SparseTimeValueModel::Point
-            (frame, float(value), tr("New Point"));
+        m_editingPoint = Event(frame, float(value), tr("New Point"));
     }
 
     m_originalPoint = m_editingPoint;
 
     if (m_editingCommand) finish(m_editingCommand);
-    m_editingCommand = new SparseTimeValueModel::EditCommand(m_model,
-                                                             tr("Draw Point"));
+    m_editingCommand = new ChangeEventsCommand(m_model, tr("Draw Point"));
     if (!havePoint) {
-        m_editingCommand->addPoint(m_editingPoint);
+        m_editingCommand->add(m_editingPoint);
     }
 
     m_editing = true;
 }
 

     if (frame < 0) frame = 0;
     frame = (frame / resolution) * resolution;
 
     double value = getValueForY(v, e->y());
 
-    SparseTimeValueModel::PointList points = getLocalPoints(v, e->x());
+    EventVector points = getLocalPoints(v, e->x());
 
 #ifdef DEBUG_TIME_VALUE_LAYER
     cerr << points.size() << " points" << endl;
 #endif
 
     bool havePoint = false;
 
     if (!points.empty()) {
-        for (SparseTimeValueModel::PointList::iterator i = points.begin();
+        for (EventVector::iterator i = points.begin();
              i != points.end(); ++i) {
-            if (i->frame == m_editingPoint.frame &&
-                i->value == m_editingPoint.value) {
-#ifdef DEBUG_TIME_VALUE_LAYER
-                cerr << "ignoring current editing point at " << i->frame << ", " << i->value << endl;
+            if (i->getFrame() == m_editingPoint.getFrame() &&
+                i->getValue() == m_editingPoint.getValue()) {
+#ifdef DEBUG_TIME_VALUE_LAYER
+                cerr << "ignoring current editing point at " << i->getFrame() << ", " << i->getValue() << endl;
 #endif
                 continue;
             }
-            if (((i->frame / resolution) * resolution) != frame) {
-#ifdef DEBUG_TIME_VALUE_LAYER
-                cerr << "ignoring out-of-range frame at " << i->frame << endl;
+            if (((i->getFrame() / resolution) * resolution) != frame) {
+#ifdef DEBUG_TIME_VALUE_LAYER
+                cerr << "ignoring out-of-range frame at " << i->getFrame() << endl;
 #endif
                 continue;
             }
 #ifdef DEBUG_TIME_VALUE_LAYER
-            cerr << "adjusting to new point at " << i->frame << ", " << i->value << endl;
+            cerr << "adjusting to new point at " << i->getFrame() << ", " << i->getValue() << endl;
 #endif
             m_editingPoint = *i;
             m_originalPoint = m_editingPoint;
-            m_editingCommand->deletePoint(m_editingPoint);
+            m_editingCommand->remove(m_editingPoint);
             havePoint = true;
         }
     }
 
     if (!havePoint) {
-        if (frame == m_editingPoint.frame) {
-            m_editingCommand->deletePoint(m_editingPoint);
-        }
-    }
-
-//    m_editingCommand->deletePoint(m_editingPoint);
-    m_editingPoint.frame = frame;
-    m_editingPoint.value = float(value);
-    m_editingCommand->addPoint(m_editingPoint);
+        if (frame == m_editingPoint.getFrame()) {
+            m_editingCommand->remove(m_editingPoint);
+        }
+    }
+
+    m_editingPoint = m_editingPoint
+        .withFrame(frame)
+        .withValue(float(value));
+    m_editingCommand->add(m_editingPoint);
 }
 
 void
 TimeValueLayer::drawEnd(LayerGeometryProvider *, QMouseEvent *)
 {

 void
 TimeValueLayer::eraseStart(LayerGeometryProvider *v, QMouseEvent *e)
 {
     if (!m_model) return;
 
-    SparseTimeValueModel::PointList points = getLocalPoints(v, e->x());
+    EventVector points = getLocalPoints(v, e->x());
     if (points.empty()) return;
 
     m_editingPoint = *points.begin();
 
     if (m_editingCommand) {

 {
     if (!m_model || !m_editing) return;
 
     m_editing = false;
 
-    SparseTimeValueModel::PointList points = getLocalPoints(v, e->x());
+    EventVector points = getLocalPoints(v, e->x());
     if (points.empty()) return;
-    if (points.begin()->frame != m_editingPoint.frame ||
-        points.begin()->value != m_editingPoint.value) return;
-
-    m_editingCommand = new SparseTimeValueModel::EditCommand
-        (m_model, tr("Erase Point"));
-
-    m_editingCommand->deletePoint(m_editingPoint);
-
+    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->remove(m_editingPoint);
     finish(m_editingCommand);
     m_editingCommand = nullptr;
     m_editing = false;
 }
 

     cerr << "TimeValueLayer::editStart(" << e->x() << "," << e->y() << ")" << endl;
 #endif
 
     if (!m_model) return;
 
-    SparseTimeValueModel::PointList points = getLocalPoints(v, e->x());
+    EventVector points = getLocalPoints(v, e->x());
     if (points.empty()) return;
 
     m_editingPoint = *points.begin();
     m_originalPoint = m_editingPoint;
 

     frame = frame / m_model->getResolution() * m_model->getResolution();
 
     double value = getValueForY(v, e->y());
 
     if (!m_editingCommand) {
-        m_editingCommand = new SparseTimeValueModel::EditCommand(m_model,
-                                                                 tr("Drag Point"));
-    }
-
-    m_editingCommand->deletePoint(m_editingPoint);
-    m_editingPoint.frame = frame;
-    m_editingPoint.value = float(value);
-    m_editingCommand->addPoint(m_editingPoint);
+        m_editingCommand = new ChangeEventsCommand(m_model, tr("Drag Point"));
+    }
+
+    m_editingCommand->remove(m_editingPoint);
+    m_editingPoint = m_editingPoint
+        .withFrame(frame)
+        .withValue(float(value));
+    m_editingCommand->add(m_editingPoint);
 }
 
 void
 TimeValueLayer::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 Point");
             } else {
                 newName = tr("Relocate Point");
             }
         } else {

 bool
 TimeValueLayer::editOpen(LayerGeometryProvider *v, QMouseEvent *e)
 {
     if (!m_model) return false;
 
-    SparseTimeValueModel::PointList points = getLocalPoints(v, e->x());
+    EventVector points = getLocalPoints(v, e->x());
     if (points.empty()) return false;
 
-    SparseTimeValueModel::Point point = *points.begin();
+    Event point = *points.begin();
 
     ItemEditDialog *dialog = new ItemEditDialog
         (m_model->getSampleRate(),
          ItemEditDialog::ShowTime |
          ItemEditDialog::ShowValue |
          ItemEditDialog::ShowText,
          getScaleUnits());
 
-    dialog->setFrameTime(point.frame);
-    dialog->setValue(point.value);
-    dialog->setText(point.label);
+    dialog->setFrameTime(point.getFrame());
+    dialog->setValue(point.getValue());
+    dialog->setText(point.getLabel());
 
     if (dialog->exec() == QDialog::Accepted) {
 
-        SparseTimeValueModel::Point newPoint = point;
-        newPoint.frame = dialog->getFrameTime();
-        newPoint.value = dialog->getValue();
-        newPoint.label = dialog->getText();
+        Event newPoint = point
+            .withFrame(dialog->getFrameTime())
+            .withValue(dialog->getValue())
+            .withLabel(dialog->getText());
         
-        SparseTimeValueModel::EditCommand *command =
-            new SparseTimeValueModel::EditCommand(m_model, tr("Edit Point"));
-        command->deletePoint(point);
-        command->addPoint(newPoint);
+        ChangeEventsCommand *command =
+            new ChangeEventsCommand(m_model, tr("Edit Point"));
+        command->remove(point);
+        command->add(newPoint);
         finish(command);
     }
 
     delete dialog;
     return true;

 void
 TimeValueLayer::moveSelection(Selection s, sv_frame_t newStartFrame)
 {
     if (!m_model) return;
 
-    SparseTimeValueModel::EditCommand *command =
-        new SparseTimeValueModel::EditCommand(m_model,
-                                              tr("Drag Selection"));
-
-    SparseTimeValueModel::PointList points =
-        m_model->getPoints(s.getStartFrame(), s.getEndFrame());
-
-    for (SparseTimeValueModel::PointList::iterator i = points.begin();
-         i != points.end(); ++i) {
-
-        if (s.contains(i->frame)) {
-            SparseTimeValueModel::Point newPoint(*i);
-            newPoint.frame = i->frame + newStartFrame - s.getStartFrame();
-            command->deletePoint(*i);
-            command->addPoint(newPoint);
-        }
+    ChangeEventsCommand *command =
+        new ChangeEventsCommand(m_model, tr("Drag Selection"));
+
+    EventVector points =
+        m_model->getEventsWithin(s.getStartFrame(), s.getDuration());
+
+    for (Event p: points) {
+
+        Event newPoint = p.withFrame
+            (p.getFrame() + newStartFrame - s.getStartFrame());
+        command->remove(p);
+        command->add(newPoint);
     }
 
     finish(command);
 }
 
 void
 TimeValueLayer::resizeSelection(Selection s, Selection newSize)
 {
+    if (!m_model || !s.getDuration()) return;
+
+    ChangeEventsCommand *command =
+        new ChangeEventsCommand(m_model, tr("Resize Selection"));
+
+    EventVector points =
+        m_model->getEventsWithin(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;
+
+        Event newPoint = p
+            .withFrame(lrint(newFrame));
+        command->remove(p);
+        command->add(newPoint);
+    }
+
+    finish(command);
+}
+
+void
+TimeValueLayer::deleteSelection(Selection s)
+{
     if (!m_model) return;
 
-    SparseTimeValueModel::EditCommand *command =
-        new SparseTimeValueModel::EditCommand(m_model,
-                                              tr("Resize Selection"));
-
-    SparseTimeValueModel::PointList points =
-        m_model->getPoints(s.getStartFrame(), s.getEndFrame());
-
-    double ratio =
-        double(newSize.getEndFrame() - newSize.getStartFrame()) /
-        double(s.getEndFrame() - s.getStartFrame());
-
-    for (SparseTimeValueModel::PointList::iterator i = points.begin();
-         i != points.end(); ++i) {
-
-        if (s.contains(i->frame)) {
-
-            double target = double(i->frame);
-            target = double(newSize.getStartFrame()) +
-                target - double(s.getStartFrame()) * ratio;
-
-            SparseTimeValueModel::Point newPoint(*i);
-            newPoint.frame = lrint(target);
-            command->deletePoint(*i);
-            command->addPoint(newPoint);
-        }
-    }
-
-    finish(command);
-}
-
-void
-TimeValueLayer::deleteSelection(Selection s)
-{
-    if (!m_model) return;
-
-    SparseTimeValueModel::EditCommand *command =
-        new SparseTimeValueModel::EditCommand(m_model,
-                                              tr("Delete Selected Points"));
-
-    SparseTimeValueModel::PointList points =
-        m_model->getPoints(s.getStartFrame(), s.getEndFrame());
-
-    for (SparseTimeValueModel::PointList::iterator i = points.begin();
-         i != points.end(); ++i) {
-
-        if (s.contains(i->frame)) {
-            command->deletePoint(*i);
-        }
+    ChangeEventsCommand *command =
+        new ChangeEventsCommand(m_model, tr("Delete Selected Points"));
+
+    EventVector points =
+        m_model->getEventsWithin(s.getStartFrame(), s.getDuration());
+
+    for (Event p: points) {
+        command->remove(p);
     }
 
     finish(command);
 }    
 
 void
 TimeValueLayer::copy(LayerGeometryProvider *v, Selection s, Clipboard &to)
 {
     if (!m_model) return;
 
-    SparseTimeValueModel::PointList points =
-        m_model->getPoints(s.getStartFrame(), s.getEndFrame());
-
-    for (SparseTimeValueModel::PointList::iterator i = points.begin();
-         i != points.end(); ++i) {
-        if (s.contains(i->frame)) {
-            Event point(i->frame, i->value, i->label);
-            to.addPoint(point.withReferenceFrame(alignToReference(v, i->frame)));
-        }
+    EventVector points =
+        m_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 */,

         if (button == QMessageBox::Yes) {
             realign = true;
         }
     }
 
-    SparseTimeValueModel::EditCommand *command =
-        new SparseTimeValueModel::EditCommand(m_model, tr("Paste"));
+    ChangeEventsCommand *command =
+        new ChangeEventsCommand(m_model, tr("Paste"));
 
     enum ValueAvailability {
         UnknownAvailability,
         NoValues,
         SomeValues,

 
             prevSelection = selection;
         }
     }
 
-    SparseTimeValueModel::Point prevPoint(0);
+    Event prevPoint;
 
     for (EventVector::const_iterator i = points.begin();
          i != points.end(); ++i) {
         
         sv_frame_t frame = 0;

             } else {
                 frame = i->getFrame();
             }
         }
 
-        SparseTimeValueModel::Point newPoint(frame);
-  
-        if (i->hasLabel()) {
-            newPoint.label = i->getLabel();
-        } else if (i->hasValue()) {
-            newPoint.label = QString("%1").arg(i->getValue());
+        Event newPoint = *i;
+        if (!i->hasLabel() && i->hasValue()) {
+            newPoint = newPoint.withLabel(QString("%1").arg(i->getValue()));
         }
 
         bool usePrev = false;
-        SparseTimeValueModel::Point formerPrevPoint = prevPoint;
-
-        if (i->hasValue()) {
-            newPoint.value = i->getValue();
-        } else {
-#ifdef DEBUG_TIME_VALUE_LAYER
-            cerr << "Setting value on point at " << newPoint.frame << " from labeller";
+        Event formerPrevPoint = prevPoint;
+
+        if (!i->hasValue()) {
+#ifdef DEBUG_TIME_VALUE_LAYER
+            cerr << "Setting value on point at " << newPoint.getFrame() << " from labeller";
             if (i == points.begin()) {
                 cerr << ", no prev point" << endl;
             } else {
-                cerr << ", prev point is at " << prevPoint.frame << endl;
-            }
-#endif
-            labeller.setValue<SparseTimeValueModel::Point>
+                cerr << ", prev point is at " << prevPoint.getFrame() << endl;
+            }
+#endif
+
+            Labeller::Revaluing valuing = 
+                labeller.revalue
                 (newPoint, (i == points.begin()) ? nullptr : &prevPoint);
-#ifdef DEBUG_TIME_VALUE_LAYER
-            cerr << "New point value = " << newPoint.value << endl;
-#endif
-            if (labeller.actingOnPrevPoint() && i != points.begin()) {
+            
+#ifdef DEBUG_TIME_VALUE_LAYER
+            cerr << "New point value = " << newPoint.getValue() << endl;
+#endif
+            if (valuing.first == Labeller::AppliesToPreviousEvent) {
                 usePrev = true;
+                prevPoint = valuing.second;
+            } else {
+                newPoint = valuing.second;
             }
         }
 
         if (usePrev) {
-            command->deletePoint(formerPrevPoint);
-            command->addPoint(prevPoint);
+            command->remove(formerPrevPoint);
+            command->add(prevPoint);
         }
 
         prevPoint = newPoint;
-        command->addPoint(newPoint);
+        command->add(newPoint);
     }
 
     finish(command);
     return true;
 }