# HG changeset patch
# User gyorgyf
# Date 1371312243 -3600
# Node ID ba76130ed7e5104f1f04478be6ddfbbcd3fd42c2
# Parent  c8f45afb83d550b75e6d92b1fdbb7cd548938bd2
added context sensitive mouse pointers in note edit tool mode

diff -r c8f45afb83d5 -r ba76130ed7e5 layer/FlexiNoteLayer.cpp
--- a/layer/FlexiNoteLayer.cpp	Sat Jun 15 16:16:24 2013 +0100
+++ b/layer/FlexiNoteLayer.cpp	Sat Jun 15 17:04:03 2013 +0100
@@ -39,16 +39,16 @@
 #include <utility>
 
 FlexiNoteLayer::FlexiNoteLayer() :
-	SingleColourLayer(),
+    SingleColourLayer(),
 
-		// m_model(0),
-		// m_editing(false),
-		// m_originalPoint(0, 0.0, 0, 1.f, tr("New Point")),
-		// m_editingPoint(0, 0.0, 0, 1.f, tr("New Point")),
-		// m_editingCommand(0),
-		// m_verticalScale(AutoAlignScale),
-		// m_scaleMinimum(0),
-		// m_scaleMaximum(0)
+        // m_model(0),
+        // m_editing(false),
+        // m_originalPoint(0, 0.0, 0, 1.f, tr("New Point")),
+        // m_editingPoint(0, 0.0, 0, 1.f, tr("New Point")),
+        // m_editingCommand(0),
+        // m_verticalScale(AutoAlignScale),
+        // m_scaleMinimum(0),
+        // m_scaleMaximum(0)
 
     m_model(0),
     m_editing(false),
@@ -116,12 +116,12 @@
     int val = 0;
 
     if (name == "Vertical Scale") {
-	
-	if (min) *min = 0;
-	if (max) *max = 3;
+    
+    if (min) *min = 0;
+    if (max) *max = 3;
         if (deflt) *deflt = int(AutoAlignScale);
-	
-	val = int(m_verticalScale);
+    
+    val = int(m_verticalScale);
 
     } else if (name == "Scale Units") {
 
@@ -133,7 +133,7 @@
 
     } else {
 
-	val = SingleColourLayer::getPropertyRangeAndValue(name, min, max, deflt);
+    val = SingleColourLayer::getPropertyRangeAndValue(name, min, max, deflt);
     }
 
     return val;
@@ -144,13 +144,13 @@
                                  int value) const
 {
     if (name == "Vertical Scale") {
-	switch (value) {
-	default:
-	case 0: return tr("Auto-Align");
-	case 1: return tr("Linear");
-	case 2: return tr("Log");
-	case 3: return tr("MIDI Notes");
-	}
+    switch (value) {
+    default:
+    case 0: return tr("Auto-Align");
+    case 1: return tr("Linear");
+    case 2: return tr("Log");
+    case 3: return tr("MIDI Notes");
+    }
     }
     return SingleColourLayer::getPropertyValueLabel(name, value);
 }
@@ -159,7 +159,7 @@
 FlexiNoteLayer::setProperty(const PropertyName &name, int value)
 {
     if (name == "Vertical Scale") {
-	setVerticalScale(VerticalScale(value));
+    setVerticalScale(VerticalScale(value));
     } else if (name == "Scale Units") {
         if (m_model) {
             m_model->setScaleUnits
@@ -221,9 +221,9 @@
 FlexiNoteLayer::getDisplayExtents(float &min, float &max) const
 {
     if (!m_model || shouldAutoAlign()) {
-		std::cerr << "No model or shouldAutoAlign()" << std::endl;
-		return false;
-	}
+        std::cerr << "No model or shouldAutoAlign()" << std::endl;
+        return false;
+    }
 
     if (m_verticalScale == MIDIRangeScale) {
         min = Pitch::getFrequencyForPitch(0);
@@ -380,36 +380,36 @@
     long frame = v->getFrameForX(x);
 
     FlexiNoteModel::PointList onPoints =
-	m_model->getPoints(frame);
+    m_model->getPoints(frame);
 
     if (!onPoints.empty()) {
-	return onPoints;
+    return onPoints;
     }
 
     FlexiNoteModel::PointList prevPoints =
-	m_model->getPreviousPoints(frame);
+    m_model->getPreviousPoints(frame);
     FlexiNoteModel::PointList nextPoints =
-	m_model->getNextPoints(frame);
+    m_model->getNextPoints(frame);
 
     FlexiNoteModel::PointList usePoints = prevPoints;
 
     if (prevPoints.empty()) {
-	usePoints = nextPoints;
+    usePoints = nextPoints;
     } else if (long(prevPoints.begin()->frame) < v->getStartFrame() &&
-	       !(nextPoints.begin()->frame > v->getEndFrame())) {
-	usePoints = nextPoints;
+           !(nextPoints.begin()->frame > v->getEndFrame())) {
+    usePoints = nextPoints;
     } else if (long(nextPoints.begin()->frame) - frame <
-	       frame - long(prevPoints.begin()->frame)) {
-	usePoints = nextPoints;
+           frame - long(prevPoints.begin()->frame)) {
+    usePoints = nextPoints;
     }
 
     if (!usePoints.empty()) {
-	int fuzz = 2;
-	int px = v->getXForFrame(usePoints.begin()->frame);
-	if ((px > x && px - x > fuzz) ||
-	    (px < x && x - px > fuzz + 1)) {
-	    usePoints.clear();
-	}
+    int fuzz = 2;
+    int px = v->getXForFrame(usePoints.begin()->frame);
+    if ((px > x && px - x > fuzz) ||
+        (px < x && x - px > fuzz + 1)) {
+        usePoints.clear();
+    }
     }
 
     return usePoints;
@@ -443,6 +443,34 @@
     return true;
 }
 
+bool
+FlexiNoteLayer::getNoteToEdit(View *v, int x, int y, FlexiNoteModel::Point &p) const
+{
+    if (!m_model) return false;
+
+    long frame = v->getFrameForX(x);
+
+    FlexiNoteModel::PointList onPoints = m_model->getPoints(frame);
+    if (onPoints.empty()) return false;
+
+//    std::cerr << "frame " << frame << ": " << onPoints.size() << " candidate points" << std::endl;
+
+    int nearestDistance = -1;
+
+    for (FlexiNoteModel::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
 FlexiNoteLayer::getFeatureDescription(View *v, QPoint &pos) const
 {
@@ -453,11 +481,11 @@
     FlexiNoteModel::PointList points = getLocalPoints(v, x);
 
     if (points.empty()) {
-	if (!m_model->isReady()) {
-	    return tr("In progress");
-	} else {
-	    return tr("No local points");
-	}
+    if (!m_model->isReady()) {
+        return tr("In progress");
+    } else {
+        return tr("No local points");
+    }
     }
 
     FlexiNote note(0);
@@ -465,26 +493,26 @@
 
     for (i = points.begin(); i != points.end(); ++i) {
 
-	int y = getYForValue(v, i->value);
-	int h = 3;
+    int y = getYForValue(v, i->value);
+    int h = 3;
 
-	if (m_model->getValueQuantization() != 0.0) {
-	    h = y - getYForValue(v, i->value + m_model->getValueQuantization());
-	    if (h < 3) h = 3;
-	}
+    if (m_model->getValueQuantization() != 0.0) {
+        h = y - getYForValue(v, i->value + m_model->getValueQuantization());
+        if (h < 3) h = 3;
+    }
 
-	if (pos.y() >= y - h && pos.y() <= y) {
-	    note = *i;
-	    break;
-	}
+    if (pos.y() >= y - h && pos.y() <= y) {
+        note = *i;
+        break;
+    }
     }
 
     if (i == points.end()) return tr("No local points");
 
     RealTime rt = RealTime::frame2RealTime(note.frame,
-					   m_model->getSampleRate());
+                       m_model->getSampleRate());
     RealTime rd = RealTime::frame2RealTime(note.duration,
-					   m_model->getSampleRate());
+                       m_model->getSampleRate());
     
     QString pitchText;
 
@@ -513,41 +541,41 @@
     QString text;
 
     if (note.label == "") {
-	text = QString(tr("Time:\t%1\nPitch:\t%2\nDuration:\t%3\nNo label"))
-	    .arg(rt.toText(true).c_str())
-	    .arg(pitchText)
-	    .arg(rd.toText(true).c_str());
+    text = QString(tr("Time:\t%1\nPitch:\t%2\nDuration:\t%3\nNo label"))
+        .arg(rt.toText(true).c_str())
+        .arg(pitchText)
+        .arg(rd.toText(true).c_str());
     } else {
-	text = QString(tr("Time:\t%1\nPitch:\t%2\nDuration:\t%3\nLabel:\t%4"))
-	    .arg(rt.toText(true).c_str())
-	    .arg(pitchText)
-	    .arg(rd.toText(true).c_str())
-	    .arg(note.label);
+    text = QString(tr("Time:\t%1\nPitch:\t%2\nDuration:\t%3\nLabel:\t%4"))
+        .arg(rt.toText(true).c_str())
+        .arg(pitchText)
+        .arg(rd.toText(true).c_str())
+        .arg(note.label);
     }
 
     pos = QPoint(v->getXForFrame(note.frame),
-		 getYForValue(v, note.value));
+         getYForValue(v, note.value));
     return text;
 }
 
 bool
 FlexiNoteLayer::snapToFeatureFrame(View *v, int &frame,
-			      size_t &resolution,
-			      SnapType snap) const
+                  size_t &resolution,
+                  SnapType snap) const
 {
     if (!m_model) {
-	return Layer::snapToFeatureFrame(v, frame, resolution, snap);
+    return Layer::snapToFeatureFrame(v, frame, resolution, snap);
     }
 
     resolution = m_model->getResolution();
     FlexiNoteModel::PointList points;
 
     if (snap == SnapNeighbouring) {
-	
-	points = getLocalPoints(v, v->getXForFrame(frame));
-	if (points.empty()) return false;
-	frame = points.begin()->frame;
-	return true;
+    
+    points = getLocalPoints(v, v->getXForFrame(frame));
+    if (points.empty()) return false;
+    frame = points.begin()->frame;
+    return true;
     }    
 
     points = m_model->getPoints(frame, frame);
@@ -555,47 +583,47 @@
     bool found = false;
 
     for (FlexiNoteModel::PointList::const_iterator i = points.begin();
-	 i != points.end(); ++i) {
+     i != points.end(); ++i) {
 
-	if (snap == SnapRight) {
+    if (snap == SnapRight) {
 
-	    if (i->frame > frame) {
-		snapped = i->frame;
-		found = true;
-		break;
-	    }
+        if (i->frame > frame) {
+        snapped = i->frame;
+        found = true;
+        break;
+        }
 
-	} else if (snap == SnapLeft) {
+    } else if (snap == SnapLeft) {
 
-	    if (i->frame <= frame) {
-		snapped = i->frame;
-		found = true; // don't break, as the next may be better
-	    } else {
-		break;
-	    }
+        if (i->frame <= frame) {
+        snapped = i->frame;
+        found = true; // don't break, as the next may be better
+        } else {
+        break;
+        }
 
-	} else { // nearest
+    } else { // nearest
 
-	    FlexiNoteModel::PointList::const_iterator j = i;
-	    ++j;
+        FlexiNoteModel::PointList::const_iterator j = i;
+        ++j;
 
-	    if (j == points.end()) {
+        if (j == points.end()) {
 
-		snapped = i->frame;
-		found = true;
-		break;
+        snapped = i->frame;
+        found = true;
+        break;
 
-	    } else if (j->frame >= frame) {
+        } else if (j->frame >= frame) {
 
-		if (j->frame - frame < frame - i->frame) {
-		    snapped = j->frame;
-		} else {
-		    snapped = i->frame;
-		}
-		found = true;
-		break;
-	    }
-	}
+        if (j->frame - frame < frame - i->frame) {
+            snapped = j->frame;
+        } else {
+            snapped = i->frame;
+        }
+        found = true;
+        break;
+        }
+    }
     }
 
     frame = snapped;
@@ -735,7 +763,7 @@
     brushColour.setAlpha(80);
 
 //    SVDEBUG << "FlexiNoteLayer::paint: resolution is "
-//	      << m_model->getResolution() << " frames" << endl;
+//        << m_model->getResolution() << " frames" << endl;
 
     float min = m_model->getValueMinimum();
     float max = m_model->getValueMaximum();
@@ -754,25 +782,25 @@
     paint.setRenderHint(QPainter::Antialiasing, false);
     
     for (FlexiNoteModel::PointList::const_iterator i = points.begin();
-	 i != points.end(); ++i) {
+     i != points.end(); ++i) {
 
-	const FlexiNoteModel::Point &p(*i);
+    const FlexiNoteModel::Point &p(*i);
 
-	int x = v->getXForFrame(p.frame);
-	int y = getYForValue(v, p.value);
-	int w = v->getXForFrame(p.frame + p.duration) - x;
-	int h = 8; //GF: larger notes
-	
-	if (m_model->getValueQuantization() != 0.0) {
-	    h = y - getYForValue(v, p.value + m_model->getValueQuantization());
-	    if (h < 3) h = 8; //GF: larger notes
-	}
+    int x = v->getXForFrame(p.frame);
+    int y = getYForValue(v, p.value);
+    int w = v->getXForFrame(p.frame + p.duration) - x;
+    int h = 8; //GF: larger notes
+    
+    if (m_model->getValueQuantization() != 0.0) {
+        h = y - getYForValue(v, p.value + m_model->getValueQuantization());
+        if (h < 3) h = 8; //GF: larger notes
+    }
 
-	if (w < 1) w = 1;
-	paint.setPen(getBaseQColor());
-	paint.setBrush(brushColour);
+    if (w < 1) w = 1;
+    paint.setPen(getBaseQColor());
+    paint.setBrush(brushColour);
 
-	if (shouldIlluminate &&
+    if (shouldIlluminate &&
             // "illuminatePoint == p"
             !FlexiNoteModel::Point::Comparator()(illuminatePoint, p) &&
             !FlexiNoteModel::Point::Comparator()(p, illuminatePoint)) {
@@ -793,9 +821,9 @@
                                x,
                                y - h/2 - paint.fontMetrics().descent() - 2,
                                hlabel, View::OutlinedText);
-	}
-	
-	paint.drawRect(x, y - h/2, w, h);
+    }
+    
+    paint.drawRect(x, y - h/2, w, h);
     }
 
     paint.restore();
@@ -819,7 +847,7 @@
 
     if (m_editingCommand) finish(m_editingCommand);
     m_editingCommand = new FlexiNoteModel::EditCommand(m_model,
-						  tr("Draw Point"));
+                          tr("Draw Point"));
     m_editingCommand->addPoint(m_editingPoint);
 
     m_editing = true;
@@ -872,8 +900,8 @@
     if (!getPointToDrag(v, e->x(), e->y(), m_editingPoint)) return;
 
     if (m_editingCommand) {
-	finish(m_editingCommand);
-	m_editingCommand = 0;
+    finish(m_editingCommand);
+    m_editingCommand = 0;
     }
 
     m_editing = true;
@@ -919,8 +947,8 @@
     m_dragPointY = getYForValue(v, m_editingPoint.value);
 
     if (m_editingCommand) {
-	finish(m_editingCommand);
-	m_editingCommand = 0;
+    finish(m_editingCommand);
+    m_editingCommand = 0;
     }
 
     m_editing = true;
@@ -948,8 +976,8 @@
     float value = getValueForY(v, newy);
 
     if (!m_editingCommand) {
-	m_editingCommand = new FlexiNoteModel::EditCommand(m_model,
-						      tr("Drag Point"));
+    m_editingCommand = new FlexiNoteModel::EditCommand(m_model,
+                              tr("Drag Point"));
     }
 
     m_editingCommand->deletePoint(m_editingPoint);
@@ -968,20 +996,20 @@
 
     if (m_editingCommand) {
 
-	QString newName = m_editingCommand->getName();
+    QString newName = m_editingCommand->getName();
 
-	if (m_editingPoint.frame != m_originalPoint.frame) {
-	    if (m_editingPoint.value != m_originalPoint.value) {
-		newName = tr("Edit Point");
-	    } else {
-		newName = tr("Relocate Point");
-	    }
-	} else {
-	    newName = tr("Change Point Value");
-	}
+    if (m_editingPoint.frame != m_originalPoint.frame) {
+        if (m_editingPoint.value != m_originalPoint.value) {
+        newName = tr("Edit Point");
+        } else {
+        newName = tr("Relocate Point");
+        }
+    } else {
+        newName = tr("Change Point Value");
+    }
 
-	m_editingCommand->setName(newName);
-	finish(m_editingCommand);
+    m_editingCommand->setName(newName);
+    finish(m_editingCommand);
     }
 
     m_editingCommand = 0;
@@ -991,8 +1019,9 @@
 void
 FlexiNoteLayer::splitStart(View *v, QMouseEvent *e)
 {
-	std::cerr << "splitStart" << std::endl;
-	if (!m_model) return;
+    // GF: note splitting starts (!! remove printing soon)
+    std::cerr << "splitStart" << std::endl;
+    if (!m_model) return;
 
     if (!getPointToDrag(v, e->x(), e->y(), m_editingPoint)) return;
     // m_originalPoint = m_editingPoint;
@@ -1001,8 +1030,8 @@
     // m_dragPointY = getYForValue(v, m_editingPoint.value);
 
     if (m_editingCommand) {
-	finish(m_editingCommand);
-	m_editingCommand = 0;
+    finish(m_editingCommand);
+    m_editingCommand = 0;
     }
 
     m_editing = true;
@@ -1014,13 +1043,14 @@
 void
 FlexiNoteLayer::splitEnd(View *v, QMouseEvent *e)
 {
-	std::cerr << "splitEnd" << std::endl;
-	if (!m_model || !m_editing) return;
+    // GF: note splitting ends. (!! remove printing soon)
+    std::cerr << "splitEnd" << std::endl;
+    if (!m_model || !m_editing) return;
 
     int xdist = e->x() - m_dragStartX;
     int ydist = e->y() - m_dragStartY;
     if (xdist != 0 || ydist != 0) { 
-		std::cerr << "mouse moved" << std::endl;    
+        std::cerr << "mouse moved" << std::endl;    
         return; 
     }
 
@@ -1033,13 +1063,13 @@
     newNote1.frame = note.frame;
     newNote1.value = note.value;
     // newNote1.duration = note.duration+10000;
-	newNote1.duration = frame - note.frame - 100;
+    newNote1.duration = frame - note.frame - 100;
     newNote1.label = note.label;
 
     FlexiNoteModel::Point newNote2 = note;
     newNote2.frame = frame + 100;
     newNote2.value = note.value;
-	newNote2.duration = note.duration - (frame - note.frame - 100);
+    newNote2.duration = note.duration - (frame - note.frame - 100);
     newNote2.label = note.label;
 
 
@@ -1049,7 +1079,59 @@
     command->addPoint(newNote1);
     command->addPoint(newNote2);
     finish(command);
-	
+    
+}
+
+void 
+FlexiNoteLayer::mouseMoveEvent(View *v, QMouseEvent *e)
+{
+    // GF: context sensitive cursors
+    // v->setCursor(Qt::ArrowCursor);
+    FlexiNoteModel::Point note(0);
+    if (!getNoteToEdit(v, e->x(), e->y(), note)) { 
+        // v->setCursor(Qt::UpArrowCursor);
+        return; 
+    }
+
+    bool closeToLeft = false, closeToRight = false, closeToTop = false, closeToBottom = false;
+    getRelativeMousePosition(v, note, e->x(), e->y(), closeToLeft, closeToRight, closeToTop, closeToBottom);
+    // if (!closeToLeft) return;
+    if (closeToLeft || closeToRight) { v->setCursor(Qt::SizeHorCursor); return; }
+    // if (closeToTop) v->setCursor(Qt::SizeVerCursor);
+    if (closeToTop) { v->setCursor(Qt::CrossCursor); return; }
+    if (closeToBottom) { v->setCursor(Qt::UpArrowCursor); return; }
+    v->setCursor(Qt::ArrowCursor);
+
+
+    std::cerr << "Mouse moved in edit mode over FlexiNoteLayer" << std::endl;
+    // v->setCursor(Qt::SizeHorCursor);
+
+}
+
+void
+FlexiNoteLayer::getRelativeMousePosition(View *v, FlexiNoteModel::Point &note, int x, int y, bool &closeToLeft, bool &closeToRight, bool &closeToTop, bool &closeToBottom) const
+{
+    if (!m_model) return;
+
+    int ctol = 2;
+    int noteStartX = v->getXForFrame(note.frame);
+    int noteEndX = v->getXForFrame(note.frame + note.duration);
+    int noteValueY = getYForValue(v,note.value);
+    int noteStartY = noteValueY - (NOTE_HEIGHT / 2);
+    int noteEndY = noteValueY + (NOTE_HEIGHT / 2);
+    
+    bool closeToNote = false;
+    
+    if (y >= noteStartY-ctol && y <= noteEndY+ctol && x >= noteStartX-ctol && x <= noteEndX+ctol) closeToNote = true;
+    if (!closeToNote) return;
+    
+    int tol = 4;
+    
+    if (x >= noteStartX - tol && x <= noteStartX + tol) closeToLeft = true;
+    if (x >= noteEndX - tol && x <= noteEndX + tol) closeToRight = true;
+    if (y >= noteStartY - tol && y <= noteStartY + tol) closeToTop = true;
+    if (y >= noteEndY - tol && y <= noteEndY + tol) closeToBottom = true;
+    
 }
 
 
@@ -1102,20 +1184,20 @@
     if (!m_model) return;
 
     FlexiNoteModel::EditCommand *command =
-	new FlexiNoteModel::EditCommand(m_model, tr("Drag Selection"));
+    new FlexiNoteModel::EditCommand(m_model, tr("Drag Selection"));
 
     FlexiNoteModel::PointList points =
-	m_model->getPoints(s.getStartFrame(), s.getEndFrame());
+    m_model->getPoints(s.getStartFrame(), s.getEndFrame());
 
     for (FlexiNoteModel::PointList::iterator i = points.begin();
-	 i != points.end(); ++i) {
+     i != points.end(); ++i) {
 
-	if (s.contains(i->frame)) {
-	    FlexiNoteModel::Point newPoint(*i);
-	    newPoint.frame = i->frame + newStartFrame - s.getStartFrame();
-	    command->deletePoint(*i);
-	    command->addPoint(newPoint);
-	}
+    if (s.contains(i->frame)) {
+        FlexiNoteModel::Point newPoint(*i);
+        newPoint.frame = i->frame + newStartFrame - s.getStartFrame();
+        command->deletePoint(*i);
+        command->addPoint(newPoint);
+    }
     }
 
     finish(command);
@@ -1127,34 +1209,34 @@
     if (!m_model) return;
 
     FlexiNoteModel::EditCommand *command =
-	new FlexiNoteModel::EditCommand(m_model, tr("Resize Selection"));
+    new FlexiNoteModel::EditCommand(m_model, tr("Resize Selection"));
 
     FlexiNoteModel::PointList points =
-	m_model->getPoints(s.getStartFrame(), s.getEndFrame());
+    m_model->getPoints(s.getStartFrame(), s.getEndFrame());
 
     double ratio =
-	double(newSize.getEndFrame() - newSize.getStartFrame()) /
-	double(s.getEndFrame() - s.getStartFrame());
+    double(newSize.getEndFrame() - newSize.getStartFrame()) /
+    double(s.getEndFrame() - s.getStartFrame());
 
     for (FlexiNoteModel::PointList::iterator i = points.begin();
-	 i != points.end(); ++i) {
+     i != points.end(); ++i) {
 
-	if (s.contains(i->frame)) {
+    if (s.contains(i->frame)) {
 
-	    double targetStart = i->frame;
-	    targetStart = newSize.getStartFrame() + 
-		double(targetStart - s.getStartFrame()) * ratio;
+        double targetStart = i->frame;
+        targetStart = newSize.getStartFrame() + 
+        double(targetStart - s.getStartFrame()) * ratio;
 
-	    double targetEnd = i->frame + i->duration;
-	    targetEnd = newSize.getStartFrame() +
-		double(targetEnd - s.getStartFrame()) * ratio;
+        double targetEnd = i->frame + i->duration;
+        targetEnd = newSize.getStartFrame() +
+        double(targetEnd - s.getStartFrame()) * ratio;
 
-	    FlexiNoteModel::Point newPoint(*i);
-	    newPoint.frame = lrint(targetStart);
-	    newPoint.duration = lrint(targetEnd - targetStart);
-	    command->deletePoint(*i);
-	    command->addPoint(newPoint);
-	}
+        FlexiNoteModel::Point newPoint(*i);
+        newPoint.frame = lrint(targetStart);
+        newPoint.duration = lrint(targetEnd - targetStart);
+        command->deletePoint(*i);
+        command->addPoint(newPoint);
+    }
     }
 
     finish(command);
@@ -1166,13 +1248,13 @@
     if (!m_model) return;
 
     FlexiNoteModel::EditCommand *command =
-	new FlexiNoteModel::EditCommand(m_model, tr("Delete Selected Points"));
+    new FlexiNoteModel::EditCommand(m_model, tr("Delete Selected Points"));
 
     FlexiNoteModel::PointList points =
-	m_model->getPoints(s.getStartFrame(), s.getEndFrame());
+    m_model->getPoints(s.getStartFrame(), s.getEndFrame());
 
     for (FlexiNoteModel::PointList::iterator i = points.begin();
-	 i != points.end(); ++i) {
+     i != points.end(); ++i) {
 
         if (s.contains(i->frame)) {
             command->deletePoint(*i);
@@ -1188,11 +1270,11 @@
     if (!m_model) return;
 
     FlexiNoteModel::PointList points =
-	m_model->getPoints(s.getStartFrame(), s.getEndFrame());
+    m_model->getPoints(s.getStartFrame(), s.getEndFrame());
 
     for (FlexiNoteModel::PointList::iterator i = points.begin();
-	 i != points.end(); ++i) {
-	if (s.contains(i->frame)) {
+     i != points.end(); ++i) {
+    if (s.contains(i->frame)) {
             Clipboard::Point point(i->frame, i->value, i->duration, i->level, i->label);
             point.setReferenceFrame(alignToReference(v, i->frame));
             to.addPoint(point);
@@ -1227,7 +1309,7 @@
     }
 
     FlexiNoteModel::EditCommand *command =
-	new FlexiNoteModel::EditCommand(m_model, tr("Paste"));
+    new FlexiNoteModel::EditCommand(m_model, tr("Paste"));
 
     for (Clipboard::PointList::const_iterator i = points.begin();
          i != points.end(); ++i) {
@@ -1339,7 +1421,7 @@
 
     bool ok, alsoOk;
     VerticalScale scale = (VerticalScale)
-	attributes.value("verticalScale").toInt(&ok);
+    attributes.value("verticalScale").toInt(&ok);
     if (ok) setVerticalScale(scale);
 
     float min = attributes.value("scaleMinimum").toFloat(&ok);
diff -r c8f45afb83d5 -r ba76130ed7e5 layer/FlexiNoteLayer.h
--- a/layer/FlexiNoteLayer.h	Sat Jun 15 16:16:24 2013 +0100
+++ b/layer/FlexiNoteLayer.h	Sat Jun 15 17:04:03 2013 +0100
@@ -16,6 +16,8 @@
 #ifndef _FLEXINOTE_LAYER_H_
 #define _FLEXINOTE_LAYER_H_
 
+#define NOTE_HEIGHT 8
+
 #include "SingleColourLayer.h"
 #include "data/model/FlexiNoteModel.h"
 
@@ -37,8 +39,8 @@
     virtual QString getFeatureDescription(View *v, QPoint &) const;
 
     virtual bool snapToFeatureFrame(View *v, int &frame,
-				    size_t &resolution,
-				    SnapType snap) const;
+                    size_t &resolution,
+                    SnapType snap) const;
 
     virtual void drawStart(View *v, QMouseEvent *);
     virtual void drawDrag(View *v, QMouseEvent *);
@@ -55,6 +57,8 @@
     virtual void splitStart(View *v, QMouseEvent *);
     virtual void splitEnd(View *v, QMouseEvent *);
 
+    virtual void mouseMoveEvent(View *v, QMouseEvent *);
+
     virtual bool editOpen(View *v, QMouseEvent *);
 
     virtual void moveSelection(Selection s, size_t newStartFrame);
@@ -75,7 +79,7 @@
     virtual int getPropertyRangeAndValue(const PropertyName &,
                                          int *min, int *max, int *deflt) const;
     virtual QString getPropertyValueLabel(const PropertyName &,
-					  int value) const;
+                      int value) const;
     virtual void setProperty(const PropertyName &, int value);
 
     enum VerticalScale {
@@ -141,6 +145,8 @@
     FlexiNoteModel::PointList getLocalPoints(View *v, int) const;
 
     bool getPointToDrag(View *v, int x, int y, FlexiNoteModel::Point &) const;
+    bool getNoteToEdit(View *v, int x, int y, FlexiNoteModel::Point &) const;
+    void getRelativeMousePosition(View *v, FlexiNoteModel::Point &note, int x, int y, bool &closeToLeft, bool &closeToRight, bool &closeToTop, bool &closeToBottom) const;
 
     FlexiNoteModel *m_model;
     bool m_editing;
diff -r c8f45afb83d5 -r ba76130ed7e5 view/Pane.cpp
--- a/view/Pane.cpp	Sat Jun 15 16:16:24 2013 +0100
+++ b/view/Pane.cpp	Sat Jun 15 17:04:03 2013 +0100
@@ -25,6 +25,11 @@
 #include "base/Preferences.h"
 #include "layer/WaveformLayer.h"
 
+// GF: added so we can propagate the mouse move event to the note layer for context handling.
+#include "layer/LayerFactory.h"
+#include "layer/FlexiNoteLayer.h"
+
+
 //!!! ugh
 #include "data/model/WaveFileModel.h"
 
@@ -1559,15 +1564,23 @@
 
     if (!m_clickedInRange) {
     
-    if (mode == ViewManager::SelectMode && hasTopLayerTimeXAxis()) {
-        bool closeToLeft = false, closeToRight = false;
-        getSelectionAt(e->x(), closeToLeft, closeToRight);
-        if ((closeToLeft || closeToRight) && !(closeToLeft && closeToRight)) {
-        setCursor(Qt::SizeHorCursor);
-        } else {
-        setCursor(Qt::ArrowCursor);
+        // GF: handle mouse move for context sensitive cursor switching in NoteEditMode.
+        // GF: Propagate the event to FlexiNoteLayer. I somehow feel it's best handeled there rather than here, but perhaps not if this will be needed elsewhere too.
+        if (mode == ViewManager::NoteEditMode && LayerFactory::getInstance()->getLayerType(getTopLayer()) == LayerFactory::FlexiNotes) {
+        
+            dynamic_cast<FlexiNoteLayer *>(getTopLayer())->mouseMoveEvent(this, e);
+
+        }   
+    
+        if (mode == ViewManager::SelectMode && hasTopLayerTimeXAxis()) {
+            bool closeToLeft = false, closeToRight = false;
+            getSelectionAt(e->x(), closeToLeft, closeToRight);
+            if ((closeToLeft || closeToRight) && !(closeToLeft && closeToRight)) {
+                setCursor(Qt::SizeHorCursor);
+            } else {
+                setCursor(Qt::ArrowCursor);
+            }
         }
-    }
 
         if (!m_manager->isPlaying()) {