comparison layer/RegionLayer.cpp @ 550:d666f5f8b154

* Make a better job of picking the proper point to drag, edit, delete etc
  in note and region layers
* Some work to do with region dragging, but this still needs more thought

 	    usePoints.clear();
 	}
     }
 
     return usePoints;
+}
+
+bool
+RegionLayer::getPointToDrag(View *v, int x, int y, RegionModel::Point &p) const
+{
+    if (!m_model) return false;
+
+    long frame = v->getFrameForX(x);
+
+    RegionModel::PointList onPoints = m_model->getPoints(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;
+        if (distance < 0) distance = -distance;
+        if (nearestDistance == -1 || distance < nearestDistance) {
+            nearestDistance = distance;
+            p = *i;
+        }
+    }
+
+    return true;
 }
 
 QString
 RegionLayer::getFeatureDescription(View *v, QPoint &pos) const
 {

     int textY = 0;
     if (m_plotStyle == PlotSegmentation) {
         textY = v->getTextLabelHeight(this, paint);
     }
     
+    int fontHeight = paint.fontMetrics().height();
+    int fontAscent = paint.fontMetrics().ascent();
+
     for (RegionModel::PointList::const_iterator i = points.begin();
 	 i != points.end(); ++i) {
 
 	const RegionModel::Point &p(*i);
 

 	    int nx = v->getXForFrame(q.frame);
             if (nx < ex) ex = nx;
         }
 
         if (m_plotStyle != PlotSegmentation) {
-            textY = y - paint.fontMetrics().height()
-                      + paint.fontMetrics().ascent();
-            if (textY < paint.fontMetrics().ascent() + 1) {
-                textY = paint.fontMetrics().ascent() + 1;
+            textY = y - fontHeight + fontAscent;
+            if (textY < fontAscent + 1) {
+                textY = fontAscent + 1;
             }
         }
 
 	if (m_model->getValueQuantization() != 0.0) {
 	    h = y - getYForValue(v, p.value + m_model->getValueQuantization());

             paint.drawLine(x, y+1, x + w, y+1);
             paint.drawLine(x, y - h/2, x, y + h/2);
             paint.drawLine(x+w, y - h/2, x + w, y + h/2);
         }
 
-	if (p.label != "") {
-//            if (ex > x + 6 + paint.fontMetrics().width(p.label)) {
-                paint.drawText(x + 5, textY, p.label);
-//            }
-	}
+        QString label = p.label;
+	if (label == "") {
+            label = QString("[%1]").arg(p.value);
+        }
+        v->drawVisibleText(paint, x + 5, textY, label, View::OutlinedText);
     }
 
     paint.restore();
 }
 

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

     m_editingCommand->deletePoint(m_editingPoint);
     m_editingPoint.frame = newFrame;
     m_editingPoint.value = newValue;
     m_editingPoint.duration = newDuration;
     m_editingCommand->addPoint(m_editingPoint);
+
+//    recalcSpacing();
 }
 
 void
 RegionLayer::drawEnd(View *, QMouseEvent *)
 {
 //    std::cerr << "RegionLayer::drawEnd(" << e->x() << "," << e->y() << ")" << std::endl;
     if (!m_model || !m_editing) return;
     finish(m_editingCommand);
     m_editingCommand = 0;
     m_editing = false;
+
+    recalcSpacing();
 }
 
 void
 RegionLayer::eraseStart(View *v, QMouseEvent *e)
 {
     if (!m_model) return;
 
+    if (!getPointToDrag(v, e->x(), e->y(), m_editingPoint)) return;
+/*
     RegionModel::PointList points = getLocalPoints(v, e->x());
     if (points.empty()) return;
 
     m_editingPoint = *points.begin();
-
+*/
     if (m_editingCommand) {
 	finish(m_editingCommand);
 	m_editingCommand = 0;
     }
 
     m_editing = true;
+    recalcSpacing();
 }
 
 void
 RegionLayer::eraseDrag(View *v, QMouseEvent *e)
 {

 RegionLayer::eraseEnd(View *v, QMouseEvent *e)
 {
     if (!m_model || !m_editing) return;
 
     m_editing = false;
-
+/*
     RegionModel::PointList points = getLocalPoints(v, e->x());
     if (points.empty()) return;
     if (points.begin()->frame != m_editingPoint.frame ||
         points.begin()->value != m_editingPoint.value) return;
+*/
+    RegionModel::Point 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
         (m_model, tr("Erase Region"));
 
     m_editingCommand->deletePoint(m_editingPoint);
 
     finish(m_editingCommand);
     m_editingCommand = 0;
     m_editing = false;
+    recalcSpacing();
 }
 
 void
 RegionLayer::editStart(View *v, QMouseEvent *e)
 {
-//    std::cerr << "RegionLayer::editStart(" << e->x() << "," << e->y() << ")" << std::endl;
+    std::cerr << "RegionLayer::editStart(" << e->x() << "," << e->y() << ")" << std::endl;
 
     if (!m_model) return;
 
-    RegionModel::PointList points = getLocalPoints(v, e->x());
-    if (points.empty()) return;
-
-    m_editingPoint = *points.begin();
+//    OrderedPointList opoints = getNearbyPoints(v, e->x(), e->y());
+//    RegionLayer:
+
+//    RegionModel::PointList points = getLocalPoints(v, e->x());
+//    if (points.empty()) return;
+
+//    m_editingPoint = *points.begin();
+    
+    if (!getPointToDrag(v, e->x(), e->y(), m_editingPoint)) {
+        return;
+    }
+
     m_originalPoint = m_editingPoint;
 
     if (m_editingCommand) {
 	finish(m_editingCommand);
 	m_editingCommand = 0;
     }
 
     m_editing = true;
+    m_dragYOrigin = e->y();
+    m_dragYRebase = e->y();
+    recalcSpacing();
 }
 
 void
 RegionLayer::editDrag(View *v, QMouseEvent *e)
 {
-//    std::cerr << "RegionLayer::editDrag(" << e->x() << "," << e->y() << ")" << std::endl;
+    std::cerr << "RegionLayer::editDrag(" << e->x() << "," << e->y() << ")" << std::endl;
 
     if (!m_model || !m_editing) return;
 
     long frame = v->getFrameForX(e->x());
     if (frame < 0) frame = 0;
     frame = frame / m_model->getResolution() * m_model->getResolution();
 
-    float value = getValueForY(v, e->y());
+    int activeY = e->y() + (m_dragYRebase - m_dragYOrigin);
+    float value = getValueForY(v, activeY);
 
     if (!m_editingCommand) {
 	m_editingCommand = new RegionModel::EditCommand(m_model,
 						      tr("Drag Region"));
+    }
+
+    if (m_verticalScale == EqualSpaced) {
+        if (getYForValue(v, value) != getYForValue(v, m_editingPoint.value)) {
+            m_dragYRebase = e->y();
+        }
     }
 
     m_editingCommand->deletePoint(m_editingPoint);
     m_editingPoint.frame = frame;
     m_editingPoint.value = value;
     m_editingCommand->addPoint(m_editingPoint);
-}
-
-void
-RegionLayer::editEnd(View *, QMouseEvent *)
-{
-//    std::cerr << "RegionLayer::editEnd(" << e->x() << "," << e->y() << ")" << std::endl;
+    recalcSpacing();
+}
+
+void
+RegionLayer::editEnd(View *, QMouseEvent *e)
+{
+    std::cerr << "RegionLayer::editEnd(" << e->x() << "," << e->y() << ")" << std::endl;
     if (!m_model || !m_editing) return;
 
     if (m_editingCommand) {
 
 	QString newName = m_editingCommand->getName();

 	finish(m_editingCommand);
     }
 
     m_editingCommand = 0;
     m_editing = false;
+    recalcSpacing();
 }
 
 bool
 RegionLayer::editOpen(View *v, QMouseEvent *e)
 {
     if (!m_model) return false;
-
+/*
     RegionModel::PointList points = getLocalPoints(v, e->x());
     if (points.empty()) return false;
-
-    RegionModel::Point region = *points.begin();
+*/
+
+    RegionModel::Point region(0);
+    if (!getPointToDrag(v, e->x(), e->y(), region)) return false;
+
+//    RegionModel::Point region = *points.begin();
 
     ItemEditDialog *dialog = new ItemEditDialog
         (m_model->getSampleRate(),
          ItemEditDialog::ShowTime |
          ItemEditDialog::ShowDuration |

         command->addPoint(newRegion);
         finish(command);
     }
 
     delete dialog;
+    recalcSpacing();
     return true;
 }
 
 void
 RegionLayer::moveSelection(Selection s, size_t newStartFrame)

 	    command->addPoint(newPoint);
 	}
     }
 
     finish(command);
+    recalcSpacing();
 }
 
 void
 RegionLayer::resizeSelection(Selection s, Selection newSize)
 {

 	    command->addPoint(newPoint);
 	}
     }
 
     finish(command);
+    recalcSpacing();
 }
 
 void
 RegionLayer::deleteSelection(Selection s)
 {

             command->deletePoint(*i);
         }
     }
 
     finish(command);
+    recalcSpacing();
 }    
 
 void
 RegionLayer::copy(View *v, Selection s, Clipboard &to)
 {

         
         command->addPoint(newPoint);
     }
 
     finish(command);
+    recalcSpacing();
     return true;
 }
 
 void
 RegionLayer::toXml(QTextStream &stream,