comparison layer/ImageLayer.cpp @ 1459:42c87368287c

Merge from branch single-point

 
 ImageLayer::ImageLayer() :
     Layer(),
     m_model(nullptr),
     m_editing(false),
-    m_originalPoint(0, "", ""),
-    m_editingPoint(0, "", ""),
     m_editingCommand(nullptr)
 {
 }
 
 ImageLayer::~ImageLayer()

 ImageLayer::isLayerScrollable(const LayerGeometryProvider *) const
 {
     return true;
 }
 
-
-ImageModel::PointList
+EventVector
 ImageLayer::getLocalPoints(LayerGeometryProvider *v, int x, int ) const
 {
-    if (!m_model) return ImageModel::PointList();
+    if (!m_model) return {};
 
 //    SVDEBUG << "ImageLayer::getLocalPoints(" << x << "," << y << "):";
-    const ImageModel::PointList &points(m_model->getPoints());
-
-    ImageModel::PointList rv;
-
-    for (ImageModel::PointList::const_iterator i = points.begin();
-         i != points.end(); ) {
-
-        const ImageModel::Point &p(*i);
-        int px = v->getXForFrame(p.frame);
+    EventVector points(m_model->getAllEvents());
+
+    EventVector rv;
+
+    for (EventVector::const_iterator i = points.begin(); i != points.end(); ) {
+
+        Event p(*i);
+        int px = v->getXForFrame(p.getFrame());
         if (px > x) break;
 
         ++i;
         if (i != points.end()) {
-            int nx = v->getXForFrame((*i).frame);
+            int nx = v->getXForFrame(i->getFrame());
             if (nx < x) {
                 // as we aim not to overlap the images, if the following
                 // image begins to the left of a point then the current
                 // one may be assumed to end to the left of it as well.
                 continue;

         }
 
         // this image is a candidate, test it properly
 
         int width = 32;
-        if (m_scaled[v].find(p.image) != m_scaled[v].end()) {
-            width = m_scaled[v][p.image].width();
+        if (m_scaled[v].find(p.getURI()) != m_scaled[v].end()) {
+            width = m_scaled[v][p.getURI()].width();
 //            SVDEBUG << "scaled width = " << width << endl;
         }
 
         if (x >= px && x < px + width) {
-            rv.insert(p);
+            rv.push_back(p);
         }
     }
 
 //    cerr << rv.size() << " point(s)" << endl;
 

 {
     int x = pos.x();
 
     if (!m_model || !m_model->getSampleRate()) return "";
 
-    ImageModel::PointList points = getLocalPoints(v, x, pos.y());
+    EventVector points = getLocalPoints(v, x, pos.y());
 
     if (points.empty()) {
         if (!m_model->isReady()) {
             return tr("In progress");
         } else {

 
 //!!! too much overlap with TimeValueLayer/TimeInstantLayer/TextLayer
 
 bool
 ImageLayer::snapToFeatureFrame(LayerGeometryProvider *v, sv_frame_t &frame,
-                              int &resolution,
-                              SnapType snap) const
+                               int &resolution,
+                               SnapType snap) const
 {
     if (!m_model) {
         return Layer::snapToFeatureFrame(v, frame, resolution, snap);
     }
 
     resolution = m_model->getResolution();
-    ImageModel::PointList points;
 
     if (snap == SnapNeighbouring) {
-        
-        points = getLocalPoints(v, v->getXForFrame(frame), -1);
+        EventVector points = getLocalPoints(v, v->getXForFrame(frame), -1);
         if (points.empty()) return false;
-        frame = points.begin()->frame;
+        frame = points.begin()->getFrame();
         return true;
     }    
 
-    points = m_model->getPoints(frame, frame);
-    sv_frame_t snapped = frame;
-    bool found = false;
-
-    for (ImageModel::PointList::const_iterator i = points.begin();
-         i != points.end(); ++i) {
-
-        if (snap == SnapRight) {
-
-            if (i->frame > frame) {
-                snapped = i->frame;
-                found = true;
-                break;
-            }
-
-        } else if (snap == SnapLeft) {
-
-            if (i->frame <= frame) {
-                snapped = i->frame;
-                found = true; // don't break, as the next may be better
-            } else {
-                break;
-            }
-
-        } else { // nearest
-
-            ImageModel::PointList::const_iterator j = i;
-            ++j;
-
-            if (j == points.end()) {
-
-                snapped = i->frame;
-                found = true;
-                break;
-
-            } else if (j->frame >= frame) {
-
-                if (j->frame - frame < frame - i->frame) {
-                    snapped = j->frame;
-                } else {
-                    snapped = i->frame;
-                }
-                found = true;
-                break;
-            }
-        }
-    }
-
-    frame = snapped;
-    return found;
+    Event e;
+    if (m_model->getNearestEventMatching
+        (frame,
+         [](Event) { return true; },
+         snap == SnapLeft ? EventSeries::Backward : EventSeries::Forward,
+         e)) {
+        frame = e.getFrame();
+        return true;
+    }
+
+    return false;
 }
 
 void
 ImageLayer::paint(LayerGeometryProvider *v, QPainter &paint, QRect rect) const
 {

     int x0 = 0, x1 = v->getPaintWidth();
 
     sv_frame_t frame0 = v->getFrameForX(x0);
     sv_frame_t frame1 = v->getFrameForX(x1);
 
-    ImageModel::PointList points(m_model->getPoints(frame0, frame1));
+    EventVector points(m_model->getEventsWithin(frame0, frame1 - frame0, 2));
     if (points.empty()) return;
 
     paint.save();
     paint.setClipRect(rect.x(), 0, rect.width(), v->getPaintHeight());
 

 
     paint.setPen(penColour);
     paint.setBrush(brushColour);
     paint.setRenderHint(QPainter::Antialiasing, true);
 
-    for (ImageModel::PointList::const_iterator i = points.begin();
+    for (EventVector::const_iterator i = points.begin();
          i != points.end(); ++i) {
 
-        const ImageModel::Point &p(*i);
-
-        int x = v->getXForFrame(p.frame);
+        Event p(*i);
+
+        int x = v->getXForFrame(p.getFrame());
 
         int nx = x + 2000;
-        ImageModel::PointList::const_iterator j = i;
+        EventVector::const_iterator j = i;
         ++j;
         if (j != points.end()) {
-            int jx = v->getXForFrame(j->frame);
+            int jx = v->getXForFrame(j->getFrame());
             if (jx < nx) nx = jx;
         }
 
         drawImage(v, paint, p, x, nx);
     }

     paint.setRenderHint(QPainter::Antialiasing, false);
     paint.restore();
 }
 
 void
-ImageLayer::drawImage(LayerGeometryProvider *v, QPainter &paint, const ImageModel::Point &p,
+ImageLayer::drawImage(LayerGeometryProvider *v, QPainter &paint, const Event &p,
                       int x, int nx) const
 {
-    QString label = p.label;
-    QString imageName = p.image;
+    QString label = p.getLabel();
+    QString imageName = p.getURI();
 
     QImage image;
     QString additionalText;
 
     QSize imageSize;

 
     sv_frame_t frame = v->getFrameForX(e->x());
     if (frame < 0) frame = 0;
     frame = frame / m_model->getResolution() * m_model->getResolution();
 
-    m_editingPoint = ImageModel::Point(frame, "", "");
+    m_editingPoint = Event(frame);
     m_originalPoint = m_editingPoint;
 
     if (m_editingCommand) finish(m_editingCommand);
-    m_editingCommand = new ImageModel::EditCommand(m_model, "Add Image");
-    m_editingCommand->addPoint(m_editingPoint);
+    m_editingCommand = new ChangeEventsCommand(m_model, "Add Image");
+    m_editingCommand->add(m_editingPoint);
 
     m_editing = true;
 }
 
 void

 
     sv_frame_t frame = v->getFrameForX(e->x());
     if (frame < 0) frame = 0;
     frame = frame / m_model->getResolution() * m_model->getResolution();
 
-    m_editingCommand->deletePoint(m_editingPoint);
-    m_editingPoint.frame = frame;
-    m_editingCommand->addPoint(m_editingPoint);
+    m_editingCommand->remove(m_editingPoint);
+    m_editingPoint = m_editingPoint
+        .withFrame(frame);
+    m_editingCommand->add(m_editingPoint);
 }
 
 void
 ImageLayer::drawEnd(LayerGeometryProvider *, QMouseEvent *)
 {
 //    SVDEBUG << "ImageLayer::drawEnd(" << e->x() << "," << e->y() << ")" << endl;
     if (!m_model || !m_editing) return;
 
     ImageDialog dialog(tr("Select image"), "", "");
 
+    m_editingCommand->remove(m_editingPoint);
+
     if (dialog.exec() == QDialog::Accepted) {
 
         checkAddSource(dialog.getImage());
 
-        ImageModel::ChangeImageCommand *command =
-            new ImageModel::ChangeImageCommand
-            (m_model, m_editingPoint, dialog.getImage(), dialog.getLabel());
-        m_editingCommand->addCommand(command);
-    } else {
-        m_editingCommand->deletePoint(m_editingPoint);
+        m_editingPoint = m_editingPoint
+            .withURI(dialog.getImage())
+            .withLabel(dialog.getLabel());
+        m_editingCommand->add(m_editingPoint);
     }
 
     finish(m_editingCommand);
     m_editingCommand = nullptr;
     m_editing = false;

         delete m_fileSources[url];
         m_fileSources.erase(url);
         return false;
     }
 
-    ImageModel::Point point(frame, url, "");
-    ImageModel::EditCommand *command =
-        new ImageModel::EditCommand(m_model, "Add Image");
-    command->addPoint(point);
+    Event point = Event(frame).withURI(url);
+    ChangeEventsCommand *command =
+        new ChangeEventsCommand(m_model, "Add Image");
+    command->add(point);
     finish(command);
     return true;
 }
 
 void

 {
 //    SVDEBUG << "ImageLayer::editStart(" << e->x() << "," << e->y() << ")" << endl;
 
     if (!m_model) return;
 
-    ImageModel::PointList points = getLocalPoints(v, e->x(), e->y());
+    EventVector points = getLocalPoints(v, e->x(), e->y());
     if (points.empty()) return;
 
     m_editOrigin = e->pos();
     m_editingPoint = *points.begin();
     m_originalPoint = m_editingPoint;

 ImageLayer::editDrag(LayerGeometryProvider *v, QMouseEvent *e)
 {
     if (!m_model || !m_editing) return;
 
     sv_frame_t frameDiff = v->getFrameForX(e->x()) - v->getFrameForX(m_editOrigin.x());
-    sv_frame_t frame = m_originalPoint.frame + frameDiff;
+    sv_frame_t frame = m_originalPoint.getFrame() + frameDiff;
 
     if (frame < 0) frame = 0;
     frame = (frame / m_model->getResolution()) * m_model->getResolution();
 
     if (!m_editingCommand) {
-        m_editingCommand = new ImageModel::EditCommand(m_model, tr("Move Image"));
-    }
-
-    m_editingCommand->deletePoint(m_editingPoint);
-    m_editingPoint.frame = frame;
-    m_editingCommand->addPoint(m_editingPoint);
+        m_editingCommand = new ChangeEventsCommand(m_model, tr("Move Image"));
+    }
+
+    m_editingCommand->remove(m_editingPoint);
+    m_editingPoint = m_editingPoint
+        .withFrame(frame);
+    m_editingCommand->add(m_editingPoint);
 }
 
 void
 ImageLayer::editEnd(LayerGeometryProvider *, QMouseEvent *)
 {

 bool
 ImageLayer::editOpen(LayerGeometryProvider *v, QMouseEvent *e)
 {
     if (!m_model) return false;
 
-    ImageModel::PointList points = getLocalPoints(v, e->x(), e->y());
+    EventVector points = getLocalPoints(v, e->x(), e->y());
     if (points.empty()) return false;
 
-    QString image = points.begin()->image;
-    QString label = points.begin()->label;
+    QString image = points.begin()->getURI();
+    QString label = points.begin()->getLabel();
 
     ImageDialog dialog(tr("Select image"),
                        image,
                        label);
 
     if (dialog.exec() == QDialog::Accepted) {
 
         checkAddSource(dialog.getImage());
 
-        ImageModel::ChangeImageCommand *command =
-            new ImageModel::ChangeImageCommand
-            (m_model, *points.begin(), dialog.getImage(), dialog.getLabel());
-
-        CommandHistory::getInstance()->addCommand(command);
+        ChangeEventsCommand *command =
+            new ChangeEventsCommand(m_model, tr("Edit Image"));
+        command->remove(*points.begin());
+        command->add(points.begin()->
+                     withURI(dialog.getImage()).withLabel(dialog.getLabel()));
+        finish(command);
     }
 
     return true;
 }    
 
 void
 ImageLayer::moveSelection(Selection s, sv_frame_t newStartFrame)
 {
     if (!m_model) return;
 
-    ImageModel::EditCommand *command =
-        new ImageModel::EditCommand(m_model, tr("Drag Selection"));
-
-    ImageModel::PointList points =
-        m_model->getPoints(s.getStartFrame(), s.getEndFrame());
-
-    for (ImageModel::PointList::iterator i = points.begin();
-         i != points.end(); ++i) {
-
-        if (s.contains(i->frame)) {
-            ImageModel::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->getEventsStartingWithin(s.getStartFrame(), s.getDuration());
+
+    for (Event p: points) {
+        command->remove(p);
+        Event moved = p.withFrame(p.getFrame() +
+                                  newStartFrame - s.getStartFrame());
+        command->add(moved);
     }
 
     finish(command);
 }
 
 void
 ImageLayer::resizeSelection(Selection s, Selection newSize)
 {
     if (!m_model) return;
 
-    ImageModel::EditCommand *command =
-        new ImageModel::EditCommand(m_model, tr("Resize Selection"));
-
-    ImageModel::PointList points =
-        m_model->getPoints(s.getStartFrame(), s.getEndFrame());
-
-    double ratio =
-        double(newSize.getEndFrame() - newSize.getStartFrame()) /
-        double(s.getEndFrame() - s.getStartFrame());
-
-    for (ImageModel::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;
-
-            ImageModel::Point newPoint(*i);
-            newPoint.frame = lrint(target);
-            command->deletePoint(*i);
-            command->addPoint(newPoint);
-        }
+    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;
+
+        Event newPoint = p
+            .withFrame(lrint(newFrame));
+        command->remove(p);
+        command->add(newPoint);
     }
 
     finish(command);
 }
 
 void
 ImageLayer::deleteSelection(Selection s)
 {
     if (!m_model) return;
 
-    ImageModel::EditCommand *command =
-        new ImageModel::EditCommand(m_model, tr("Delete Selection"));
-
-    ImageModel::PointList points =
-        m_model->getPoints(s.getStartFrame(), s.getEndFrame());
-
-    for (ImageModel::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 Selection"));
+
+    EventVector points =
+        m_model->getEventsStartingWithin(s.getStartFrame(), s.getDuration());
+
+    for (Event p: points) {
+        command->remove(p);
     }
 
     finish(command);
 }
 
 void
 ImageLayer::copy(LayerGeometryProvider *v, Selection s, Clipboard &to)
 {
     if (!m_model) return;
 
-    ImageModel::PointList points =
-        m_model->getPoints(s.getStartFrame(), s.getEndFrame());
-
-    for (ImageModel::PointList::iterator i = points.begin();
-         i != points.end(); ++i) {
-        if (s.contains(i->frame)) {
-            Clipboard::Point point(i->frame, i->label);
-            point.setReferenceFrame(alignToReference(v, i->frame));
-            to.addPoint(point);
-        }
+    EventVector points =
+        m_model->getEventsStartingWithin(s.getStartFrame(), s.getDuration());
+
+    for (Event p: points) {
+        to.addPoint(p.withReferenceFrame(alignToReference(v, p.getFrame())));
     }
 }
 
 bool
 ImageLayer::paste(LayerGeometryProvider *v, const Clipboard &from, sv_frame_t /* frameOffset */, bool /* interactive */)
 {
     if (!m_model) return false;
 
-    const Clipboard::PointList &points = from.getPoints();
+    const EventVector &points = from.getPoints();
 
     bool realign = false;
 
     if (clipboardHasDifferentAlignment(v, from)) {
 

         if (button == QMessageBox::Yes) {
             realign = true;
         }
     }
 
-    ImageModel::EditCommand *command =
-        new ImageModel::EditCommand(m_model, tr("Paste"));
-
-    for (Clipboard::PointList::const_iterator i = points.begin();
+    ChangeEventsCommand *command =
+        new ChangeEventsCommand(m_model, tr("Paste"));
+
+    for (EventVector::const_iterator i = points.begin();
          i != points.end(); ++i) {
         
-        if (!i->haveFrame()) continue;
-
         sv_frame_t frame = 0;
 
         if (!realign) {
             
             frame = i->getFrame();
 
         } else {
 
-            if (i->haveReferenceFrame()) {
+            if (i->hasReferenceFrame()) {
                 frame = i->getReferenceFrame();
                 frame = alignFromReference(v, frame);
             } else {
                 frame = i->getFrame();
             }
         }
 
-        ImageModel::Point newPoint(frame);
+        Event p = *i;
+        Event newPoint = p;
 
         //!!! inadequate
         
-        if (i->haveLabel()) {
-            newPoint.label = i->getLabel();
-        } else if (i->haveValue()) {
-            newPoint.label = QString("%1").arg(i->getValue());
-        } else {
-            newPoint.label = tr("New Point");
+        if (!p.hasLabel()) {
+            if (p.hasValue()) {
+                newPoint = newPoint.withLabel(QString("%1").arg(p.getValue()));
+            } else {
+                newPoint = newPoint.withLabel(tr("New Point"));
+            }
         }
         
-        command->addPoint(newPoint);
+        command->add(newPoint);
     }
 
     finish(command);
     return true;
 }

 }
 
 void
 ImageLayer::checkAddSources()
 {
-    const ImageModel::PointList &points(m_model->getPoints());
-
-    for (ImageModel::PointList::const_iterator i = points.begin();
+    const EventVector &points(m_model->getAllEvents());
+
+    for (EventVector::const_iterator i = points.begin();
          i != points.end(); ++i) {
         
-        checkAddSource((*i).image);
+        checkAddSource((*i).getURI());
     }
 }
 
 void
 ImageLayer::fileSourceReady()