comparison layer/FlexiNoteLayer.cpp @ 620:fde7e2fae256 tonioni

updated names in FlexiNote source -- will need to make new FlexiNoteModel source

     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.  See the file
     COPYING included with this distribution for more information.
 */
 
-#include "NoteLayer.h"
+#include "FlexiNoteLayer.h"
 
 #include "data/model/Model.h"
 #include "base/RealTime.h"
 #include "base/Profiler.h"
 #include "base/Pitch.h"
 #include "base/LogRange.h"
 #include "base/RangeMapper.h"
 #include "ColourDatabase.h"
 #include "view/View.h"
 
-#include "data/model/NoteModel.h"
+#include "data/model/FlexiNoteModel.h"
 
 #include "widgets/ItemEditDialog.h"
 
 #include <QPainter>
 #include <QPainterPath>

 
 #include <iostream>
 #include <cmath>
 #include <utility>
 
-NoteLayer::NoteLayer() :
+FlexiNoteLayer::FlexiNoteLayer() :
     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")),

 {
     
 }
 
 void
-NoteLayer::setModel(NoteModel *model)
+FlexiNoteLayer::setModel(FlexiNoteModel *model)
 {
     if (m_model == model) return;
     m_model = model;
 
     connectSignals(m_model);
 
-//    SVDEBUG << "NoteLayer::setModel(" << model << ")" << endl;
+//    SVDEBUG << "FlexiNoteLayer::setModel(" << model << ")" << endl;
 
     m_scaleMinimum = 0;
     m_scaleMaximum = 0;
 
     emit modelReplaced();
 }
 
 Layer::PropertyList
-NoteLayer::getProperties() const
+FlexiNoteLayer::getProperties() const
 {
     PropertyList list = SingleColourLayer::getProperties();
     list.push_back("Vertical Scale");
     list.push_back("Scale Units");
     return list;
 }
 
 QString
-NoteLayer::getPropertyLabel(const PropertyName &name) const
+FlexiNoteLayer::getPropertyLabel(const PropertyName &name) const
 {
     if (name == "Vertical Scale") return tr("Vertical Scale");
     if (name == "Scale Units") return tr("Scale Units");
     return SingleColourLayer::getPropertyLabel(name);
 }
 
 Layer::PropertyType
-NoteLayer::getPropertyType(const PropertyName &name) const
+FlexiNoteLayer::getPropertyType(const PropertyName &name) const
 {
     if (name == "Scale Units") return UnitsProperty;
     if (name == "Vertical Scale") return ValueProperty;
     return SingleColourLayer::getPropertyType(name);
 }
 
 QString
-NoteLayer::getPropertyGroupName(const PropertyName &name) const
+FlexiNoteLayer::getPropertyGroupName(const PropertyName &name) const
 {
     if (name == "Vertical Scale" || name == "Scale Units") {
         return tr("Scale");
     }
     return SingleColourLayer::getPropertyGroupName(name);
 }
 
 int
-NoteLayer::getPropertyRangeAndValue(const PropertyName &name,
+FlexiNoteLayer::getPropertyRangeAndValue(const PropertyName &name,
                                     int *min, int *max, int *deflt) const
 {
     int val = 0;
 
     if (name == "Vertical Scale") {

 
     return val;
 }
 
 QString
-NoteLayer::getPropertyValueLabel(const PropertyName &name,
+FlexiNoteLayer::getPropertyValueLabel(const PropertyName &name,
                                  int value) const
 {
     if (name == "Vertical Scale") {
 	switch (value) {
 	default:

     }
     return SingleColourLayer::getPropertyValueLabel(name, value);
 }
 
 void
-NoteLayer::setProperty(const PropertyName &name, int value)
+FlexiNoteLayer::setProperty(const PropertyName &name, int value)
 {
     if (name == "Vertical Scale") {
 	setVerticalScale(VerticalScale(value));
     } else if (name == "Scale Units") {
         if (m_model) {

         return SingleColourLayer::setProperty(name, value);
     }
 }
 
 void
-NoteLayer::setVerticalScale(VerticalScale scale)
+FlexiNoteLayer::setVerticalScale(VerticalScale scale)
 {
     if (m_verticalScale == scale) return;
     m_verticalScale = scale;
     emit layerParametersChanged();
 }
 
 bool
-NoteLayer::isLayerScrollable(const View *v) const
+FlexiNoteLayer::isLayerScrollable(const View *v) const
 {
     QPoint discard;
     return !v->shouldIlluminateLocalFeatures(this, discard);
 }
 
 bool
-NoteLayer::shouldConvertMIDIToHz() const
+FlexiNoteLayer::shouldConvertMIDIToHz() const
 {
     QString unit = m_model->getScaleUnits();
     return (unit != "Hz");
 //    if (unit == "" ||
 //        unit.startsWith("MIDI") ||
 //        unit.startsWith("midi")) return true;
 //    return false;
 }
 
 bool
-NoteLayer::getValueExtents(float &min, float &max,
+FlexiNoteLayer::getValueExtents(float &min, float &max,
                            bool &logarithmic, QString &unit) const
 {
     if (!m_model) return false;
     min = m_model->getValueMinimum();
     max = m_model->getValueMaximum();

 
     return true;
 }
 
 bool
-NoteLayer::getDisplayExtents(float &min, float &max) const
+FlexiNoteLayer::getDisplayExtents(float &min, float &max) const
 {
     if (!m_model || shouldAutoAlign()) return false;
 
     if (m_verticalScale == MIDIRangeScale) {
         min = Pitch::getFrequencyForPitch(0);

 
     return true;
 }
 
 bool
-NoteLayer::setDisplayExtents(float min, float max)
+FlexiNoteLayer::setDisplayExtents(float min, float max)
 {
     if (!m_model) return false;
 
     if (min == max) {
         if (min == 0.f) {

     }
 
     m_scaleMinimum = min;
     m_scaleMaximum = max;
 
-//    SVDEBUG << "NoteLayer::setDisplayExtents: min = " << min << ", max = " << max << endl;
+//    SVDEBUG << "FlexiNoteLayer::setDisplayExtents: min = " << min << ", max = " << max << endl;
     
     emit layerParametersChanged();
     return true;
 }
 
 int
-NoteLayer::getVerticalZoomSteps(int &defaultStep) const
+FlexiNoteLayer::getVerticalZoomSteps(int &defaultStep) const
 {
     if (shouldAutoAlign()) return 0;
     if (!m_model) return 0;
 
     defaultStep = 0;
     return 100;
 }
 
 int
-NoteLayer::getCurrentVerticalZoomStep() const
+FlexiNoteLayer::getCurrentVerticalZoomStep() const
 {
     if (shouldAutoAlign()) return 0;
     if (!m_model) return 0;
 
     RangeMapper *mapper = getNewVerticalZoomRangeMapper();

 }
 
 //!!! lots of duplication with TimeValueLayer
 
 void
-NoteLayer::setVerticalZoomStep(int step)
+FlexiNoteLayer::setVerticalZoomStep(int step)
 {
     if (shouldAutoAlign()) return;
     if (!m_model) return;
 
     RangeMapper *mapper = getNewVerticalZoomRangeMapper();

     }
     if (newmax > max) {
         newmax = max;
     }
     
-    SVDEBUG << "NoteLayer::setVerticalZoomStep: " << step << ": " << newmin << " -> " << newmax << " (range " << newdist << ")" << endl;
+    SVDEBUG << "FlexiNoteLayer::setVerticalZoomStep: " << step << ": " << newmin << " -> " << newmax << " (range " << newdist << ")" << endl;
 
     setDisplayExtents(newmin, newmax);
 }
 
 RangeMapper *
-NoteLayer::getNewVerticalZoomRangeMapper() const
+FlexiNoteLayer::getNewVerticalZoomRangeMapper() const
 {
     if (!m_model) return 0;
     
     RangeMapper *mapper;
 

     }
 
     return mapper;
 }
 
-NoteModel::PointList
-NoteLayer::getLocalPoints(View *v, int x) const
-{
-    if (!m_model) return NoteModel::PointList();
+FlexiNoteModel::PointList
+FlexiNoteLayer::getLocalPoints(View *v, int x) const
+{
+    if (!m_model) return FlexiNoteModel::PointList();
 
     long frame = v->getFrameForX(x);
 
-    NoteModel::PointList onPoints =
+    FlexiNoteModel::PointList onPoints =
 	m_model->getPoints(frame);
 
     if (!onPoints.empty()) {
 	return onPoints;
     }
 
-    NoteModel::PointList prevPoints =
+    FlexiNoteModel::PointList prevPoints =
 	m_model->getPreviousPoints(frame);
-    NoteModel::PointList nextPoints =
+    FlexiNoteModel::PointList nextPoints =
 	m_model->getNextPoints(frame);
 
-    NoteModel::PointList usePoints = prevPoints;
+    FlexiNoteModel::PointList usePoints = prevPoints;
 
     if (prevPoints.empty()) {
 	usePoints = nextPoints;
     } else if (long(prevPoints.begin()->frame) < v->getStartFrame() &&
 	       !(nextPoints.begin()->frame > v->getEndFrame())) {

 
     return usePoints;
 }
 
 bool
-NoteLayer::getPointToDrag(View *v, int x, int y, NoteModel::Point &p) const
+FlexiNoteLayer::getPointToDrag(View *v, int x, int y, NoteModel::Point &p) const
 {
     if (!m_model) return false;
 
     long frame = v->getFrameForX(x);
 
-    NoteModel::PointList onPoints = m_model->getPoints(frame);
+    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 (NoteModel::PointList::const_iterator i = onPoints.begin();
+    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) {

 
     return true;
 }
 
 QString
-NoteLayer::getFeatureDescription(View *v, QPoint &pos) const
+FlexiNoteLayer::getFeatureDescription(View *v, QPoint &pos) const
 {
     int x = pos.x();
 
     if (!m_model || !m_model->getSampleRate()) return "";
 
-    NoteModel::PointList points = getLocalPoints(v, x);
+    FlexiNoteModel::PointList points = getLocalPoints(v, x);
 
     if (points.empty()) {
 	if (!m_model->isReady()) {
 	    return tr("In progress");
 	} else {
 	    return tr("No local points");
 	}
     }
 
-    Note note(0);
-    NoteModel::PointList::iterator i;
+    FlexiNote note(0);
+    FlexiNoteModel::PointList::iterator i;
 
     for (i = points.begin(); i != points.end(); ++i) {
 
 	int y = getYForValue(v, i->value);
 	int h = 3;

 		 getYForValue(v, note.value));
     return text;
 }
 
 bool
-NoteLayer::snapToFeatureFrame(View *v, int &frame,
+FlexiNoteLayer::snapToFeatureFrame(View *v, int &frame,
 			      size_t &resolution,
 			      SnapType snap) const
 {
     if (!m_model) {
 	return Layer::snapToFeatureFrame(v, frame, resolution, snap);
     }
 
     resolution = m_model->getResolution();
-    NoteModel::PointList points;
+    FlexiNoteModel::PointList points;
 
     if (snap == SnapNeighbouring) {
 	
 	points = getLocalPoints(v, v->getXForFrame(frame));
 	if (points.empty()) return false;

 
     points = m_model->getPoints(frame, frame);
     int snapped = frame;
     bool found = false;
 
-    for (NoteModel::PointList::const_iterator i = points.begin();
+    for (FlexiNoteModel::PointList::const_iterator i = points.begin();
 	 i != points.end(); ++i) {
 
 	if (snap == SnapRight) {
 
 	    if (i->frame > frame) {

 		break;
 	    }
 
 	} else { // nearest
 
-	    NoteModel::PointList::const_iterator j = i;
+	    FlexiNoteModel::PointList::const_iterator j = i;
 	    ++j;
 
 	    if (j == points.end()) {
 
 		snapped = i->frame;

     frame = snapped;
     return found;
 }
 
 void
-NoteLayer::getScaleExtents(View *v, float &min, float &max, bool &log) const
+FlexiNoteLayer::getScaleExtents(View *v, float &min, float &max, bool &log) const
 {
     min = 0.0;
     max = 0.0;
     log = false;
 

             if (shouldConvertMIDIToHz()) {
                 min = Pitch::getFrequencyForPitch(lrintf(min));
                 max = Pitch::getFrequencyForPitch(lrintf(max + 1));
             }
 
-            std::cerr << "NoteLayer[" << this << "]::getScaleExtents: min = " << min << ", max = " << max << ", log = " << log << std::endl;
+            std::cerr << "FlexiNoteLayer[" << this << "]::getScaleExtents: min = " << min << ", max = " << max << ", log = " << log << std::endl;
 
         } else if (log) {
 
             LogRange::mapRange(min, max);
 
-            std::cerr << "NoteLayer[" << this << "]::getScaleExtents: min = " << min << ", max = " << max << ", log = " << log << std::endl;
+            std::cerr << "FlexiNoteLayer[" << this << "]::getScaleExtents: min = " << min << ", max = " << max << ", log = " << log << std::endl;
 
         }
 
     } else {
 

 
     if (max == min) max = min + 1.0;
 }
 
 int
-NoteLayer::getYForValue(View *v, float val) const
+FlexiNoteLayer::getYForValue(View *v, float val) const
 {
     float min = 0.0, max = 0.0;
     bool logarithmic = false;
     int h = v->height();
 
     getScaleExtents(v, min, max, logarithmic);
 
-//    std::cerr << "NoteLayer[" << this << "]::getYForValue(" << val << "): min = " << min << ", max = " << max << ", log = " << logarithmic << std::endl;
+//    std::cerr << "FlexiNoteLayer[" << this << "]::getYForValue(" << val << "): min = " << min << ", max = " << max << ", log = " << logarithmic << std::endl;
 
     if (shouldConvertMIDIToHz()) {
         val = Pitch::getFrequencyForPitch(lrintf(val),
                                           lrintf((val - lrintf(val)) * 100));
 //        std::cerr << "shouldConvertMIDIToHz true, val now = " << val << std::endl;

 //    std::cerr << "y = " << y << std::endl;
     return y;
 }
 
 float
-NoteLayer::getValueForY(View *v, int y) const
+FlexiNoteLayer::getValueForY(View *v, int y) const
 {
     float min = 0.0, max = 0.0;
     bool logarithmic = false;
     int h = v->height();
 

 
     return val;
 }
 
 bool
-NoteLayer::shouldAutoAlign() const
+FlexiNoteLayer::shouldAutoAlign() const
 {
     if (!m_model) return false;
     return (m_verticalScale == AutoAlignScale);
 }
 
 void
-NoteLayer::paint(View *v, QPainter &paint, QRect rect) const
+FlexiNoteLayer::paint(View *v, QPainter &paint, QRect rect) const
 {
     if (!m_model || !m_model->isOK()) return;
 
     int sampleRate = m_model->getSampleRate();
     if (!sampleRate) return;
 
-//    Profiler profiler("NoteLayer::paint", true);
+//    Profiler profiler("FlexiNoteLayer::paint", true);
 
     int x0 = rect.left(), x1 = rect.right();
     long frame0 = v->getFrameForX(x0);
     long frame1 = v->getFrameForX(x1);
 
-    NoteModel::PointList points(m_model->getPoints(frame0, frame1));
+    FlexiNoteModel::PointList points(m_model->getPoints(frame0, frame1));
     if (points.empty()) return;
 
     paint.setPen(getBaseQColor());
 
     QColor brushColour(getBaseQColor());
     brushColour.setAlpha(80);
 
-//    SVDEBUG << "NoteLayer::paint: resolution is "
+//    SVDEBUG << "FlexiNoteLayer::paint: resolution is "
 //	      << m_model->getResolution() << " frames" << endl;
 
     float min = m_model->getValueMinimum();
     float max = m_model->getValueMaximum();
     if (max == min) max = min + 1.0;
 
     QPoint localPos;
-    NoteModel::Point illuminatePoint(0);
+    FlexiNoteModel::Point illuminatePoint(0);
     bool shouldIlluminate = false;
 
     if (v->shouldIlluminateLocalFeatures(this, localPos)) {
         shouldIlluminate = getPointToDrag(v, localPos.x(), localPos.y(),
                                           illuminatePoint);
     }
 
     paint.save();
     paint.setRenderHint(QPainter::Antialiasing, false);
     
-    for (NoteModel::PointList::const_iterator i = points.begin();
+    for (FlexiNoteModel::PointList::const_iterator i = points.begin();
 	 i != points.end(); ++i) {
 
-	const NoteModel::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 = 3;

 	paint.setPen(getBaseQColor());
 	paint.setBrush(brushColour);
 
 	if (shouldIlluminate &&
             // "illuminatePoint == p"
-            !NoteModel::Point::Comparator()(illuminatePoint, p) &&
-            !NoteModel::Point::Comparator()(p, illuminatePoint)) {
+            !FlexiNoteModel::Point::Comparator()(illuminatePoint, p) &&
+            !FlexiNoteModel::Point::Comparator()(p, illuminatePoint)) {
 
             paint.setPen(v->getForeground());
             paint.setBrush(v->getForeground());
 
             QString vlabel = QString("%1%2").arg(p.value).arg(m_model->getScaleUnits());

 
     paint.restore();
 }
 
 void
-NoteLayer::drawStart(View *v, QMouseEvent *e)
-{
-//    SVDEBUG << "NoteLayer::drawStart(" << e->x() << "," << e->y() << ")" << endl;
+FlexiNoteLayer::drawStart(View *v, QMouseEvent *e)
+{
+//    SVDEBUG << "FlexiNoteLayer::drawStart(" << e->x() << "," << e->y() << ")" << endl;
 
     if (!m_model) 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());
 
-    m_editingPoint = NoteModel::Point(frame, value, 0, 0.8, tr("New Point"));
+    m_editingPoint = FlexiNoteModel::Point(frame, value, 0, 0.8, tr("New Point"));
     m_originalPoint = m_editingPoint;
 
     if (m_editingCommand) finish(m_editingCommand);
-    m_editingCommand = new NoteModel::EditCommand(m_model,
+    m_editingCommand = new FlexiNoteModel::EditCommand(m_model,
 						  tr("Draw Point"));
     m_editingCommand->addPoint(m_editingPoint);
 
     m_editing = true;
 }
 
 void
-NoteLayer::drawDrag(View *v, QMouseEvent *e)
-{
-//    SVDEBUG << "NoteLayer::drawDrag(" << e->x() << "," << e->y() << ")" << endl;
+FlexiNoteLayer::drawDrag(View *v, QMouseEvent *e)
+{
+//    SVDEBUG << "FlexiNoteLayer::drawDrag(" << e->x() << "," << e->y() << ")" << endl;
 
     if (!m_model || !m_editing) return;
 
     long frame = v->getFrameForX(e->x());
     if (frame < 0) frame = 0;

     m_editingPoint.duration = newDuration;
     m_editingCommand->addPoint(m_editingPoint);
 }
 
 void
-NoteLayer::drawEnd(View *, QMouseEvent *)
-{
-//    SVDEBUG << "NoteLayer::drawEnd(" << e->x() << "," << e->y() << ")" << endl;
+FlexiNoteLayer::drawEnd(View *, QMouseEvent *)
+{
+//    SVDEBUG << "FlexiNoteLayer::drawEnd(" << e->x() << "," << e->y() << ")" << endl;
     if (!m_model || !m_editing) return;
     finish(m_editingCommand);
     m_editingCommand = 0;
     m_editing = false;
 }
 
 void
-NoteLayer::eraseStart(View *v, QMouseEvent *e)
+FlexiNoteLayer::eraseStart(View *v, QMouseEvent *e)
 {
     if (!m_model) return;
 
     if (!getPointToDrag(v, e->x(), e->y(), m_editingPoint)) return;
 

 
     m_editing = true;
 }
 
 void
-NoteLayer::eraseDrag(View *v, QMouseEvent *e)
-{
-}
-
-void
-NoteLayer::eraseEnd(View *v, QMouseEvent *e)
+FlexiNoteLayer::eraseDrag(View *v, QMouseEvent *e)
+{
+}
+
+void
+FlexiNoteLayer::eraseEnd(View *v, QMouseEvent *e)
 {
     if (!m_model || !m_editing) return;
 
     m_editing = false;
 
-    NoteModel::Point p(0);
+    FlexiNoteModel::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 NoteModel::EditCommand(m_model, tr("Erase Point"));
+    m_editingCommand = new FlexiNoteModel::EditCommand(m_model, tr("Erase Point"));
 
     m_editingCommand->deletePoint(m_editingPoint);
 
     finish(m_editingCommand);
     m_editingCommand = 0;
     m_editing = false;
 }
 
 void
-NoteLayer::editStart(View *v, QMouseEvent *e)
-{
-//    SVDEBUG << "NoteLayer::editStart(" << e->x() << "," << e->y() << ")" << endl;
+FlexiNoteLayer::editStart(View *v, QMouseEvent *e)
+{
+//    SVDEBUG << "FlexiNoteLayer::editStart(" << e->x() << "," << e->y() << ")" << endl;
 
     if (!m_model) return;
 
     if (!getPointToDrag(v, e->x(), e->y(), m_editingPoint)) return;
     m_originalPoint = m_editingPoint;

     m_dragStartX = e->x();
     m_dragStartY = e->y();
 }
 
 void
-NoteLayer::editDrag(View *v, QMouseEvent *e)
-{
-//    SVDEBUG << "NoteLayer::editDrag(" << e->x() << "," << e->y() << ")" << endl;
+FlexiNoteLayer::editDrag(View *v, QMouseEvent *e)
+{
+//    SVDEBUG << "FlexiNoteLayer::editDrag(" << e->x() << "," << e->y() << ")" << endl;
 
     if (!m_model || !m_editing) return;
 
     int xdist = e->x() - m_dragStartX;
     int ydist = e->y() - m_dragStartY;

     frame = frame / m_model->getResolution() * m_model->getResolution();
 
     float value = getValueForY(v, newy);
 
     if (!m_editingCommand) {
-	m_editingCommand = new NoteModel::EditCommand(m_model,
+	m_editingCommand = new FlexiNoteModel::EditCommand(m_model,
 						      tr("Drag Point"));
     }
 
     m_editingCommand->deletePoint(m_editingPoint);
     m_editingPoint.frame = frame;
     m_editingPoint.value = value;
     m_editingCommand->addPoint(m_editingPoint);
 }
 
 void
-NoteLayer::editEnd(View *, QMouseEvent *)
-{
-//    SVDEBUG << "NoteLayer::editEnd(" << e->x() << "," << e->y() << ")" << endl;
+FlexiNoteLayer::editEnd(View *, QMouseEvent *)
+{
+//    SVDEBUG << "FlexiNoteLayer::editEnd(" << e->x() << "," << e->y() << ")" << endl;
     if (!m_model || !m_editing) return;
 
     if (m_editingCommand) {
 
 	QString newName = m_editingCommand->getName();

     m_editingCommand = 0;
     m_editing = false;
 }
 
 bool
-NoteLayer::editOpen(View *v, QMouseEvent *e)
+FlexiNoteLayer::editOpen(View *v, QMouseEvent *e)
 {
     if (!m_model) return false;
 
-    NoteModel::Point note(0);
+    FlexiNoteModel::Point note(0);
     if (!getPointToDrag(v, e->x(), e->y(), note)) return false;
 
-//    NoteModel::Point note = *points.begin();
+//    FlexiNoteModel::Point note = *points.begin();
 
     ItemEditDialog *dialog = new ItemEditDialog
         (m_model->getSampleRate(),
          ItemEditDialog::ShowTime |
          ItemEditDialog::ShowDuration |

     dialog->setFrameDuration(note.duration);
     dialog->setText(note.label);
 
     if (dialog->exec() == QDialog::Accepted) {
 
-        NoteModel::Point newNote = note;
+        FlexiNoteModel::Point newNote = note;
         newNote.frame = dialog->getFrameTime();
         newNote.value = dialog->getValue();
         newNote.duration = dialog->getFrameDuration();
         newNote.label = dialog->getText();
         
-        NoteModel::EditCommand *command = new NoteModel::EditCommand
+        FlexiNoteModel::EditCommand *command = new FlexiNoteModel::EditCommand
             (m_model, tr("Edit Point"));
         command->deletePoint(note);
         command->addPoint(newNote);
         finish(command);
     }

     delete dialog;
     return true;
 }
 
 void
-NoteLayer::moveSelection(Selection s, size_t newStartFrame)
+FlexiNoteLayer::moveSelection(Selection s, size_t newStartFrame)
 {
     if (!m_model) return;
 
-    NoteModel::EditCommand *command =
-	new NoteModel::EditCommand(m_model, tr("Drag Selection"));
-
-    NoteModel::PointList points =
+    FlexiNoteModel::EditCommand *command =
+	new FlexiNoteModel::EditCommand(m_model, tr("Drag Selection"));
+
+    FlexiNoteModel::PointList points =
 	m_model->getPoints(s.getStartFrame(), s.getEndFrame());
 
-    for (NoteModel::PointList::iterator i = points.begin();
+    for (FlexiNoteModel::PointList::iterator i = points.begin();
 	 i != points.end(); ++i) {
 
 	if (s.contains(i->frame)) {
-	    NoteModel::Point newPoint(*i);
+	    FlexiNoteModel::Point newPoint(*i);
 	    newPoint.frame = i->frame + newStartFrame - s.getStartFrame();
 	    command->deletePoint(*i);
 	    command->addPoint(newPoint);
 	}
     }
 
     finish(command);
 }
 
 void
-NoteLayer::resizeSelection(Selection s, Selection newSize)
+FlexiNoteLayer::resizeSelection(Selection s, Selection newSize)
 {
     if (!m_model) return;
 
-    NoteModel::EditCommand *command =
-	new NoteModel::EditCommand(m_model, tr("Resize Selection"));
-
-    NoteModel::PointList points =
+    FlexiNoteModel::EditCommand *command =
+	new FlexiNoteModel::EditCommand(m_model, tr("Resize Selection"));
+
+    FlexiNoteModel::PointList points =
 	m_model->getPoints(s.getStartFrame(), s.getEndFrame());
 
     double ratio =
 	double(newSize.getEndFrame() - newSize.getStartFrame()) /
 	double(s.getEndFrame() - s.getStartFrame());
 
-    for (NoteModel::PointList::iterator i = points.begin();
+    for (FlexiNoteModel::PointList::iterator i = points.begin();
 	 i != points.end(); ++i) {
 
 	if (s.contains(i->frame)) {
 
 	    double targetStart = i->frame;

 
 	    double targetEnd = i->frame + i->duration;
 	    targetEnd = newSize.getStartFrame() +
 		double(targetEnd - s.getStartFrame()) * ratio;
 
-	    NoteModel::Point newPoint(*i);
+	    FlexiNoteModel::Point newPoint(*i);
 	    newPoint.frame = lrint(targetStart);
 	    newPoint.duration = lrint(targetEnd - targetStart);
 	    command->deletePoint(*i);
 	    command->addPoint(newPoint);
 	}

 
     finish(command);
 }
 
 void
-NoteLayer::deleteSelection(Selection s)
+FlexiNoteLayer::deleteSelection(Selection s)
 {
     if (!m_model) return;
 
-    NoteModel::EditCommand *command =
-	new NoteModel::EditCommand(m_model, tr("Delete Selected Points"));
-
-    NoteModel::PointList points =
+    FlexiNoteModel::EditCommand *command =
+	new FlexiNoteModel::EditCommand(m_model, tr("Delete Selected Points"));
+
+    FlexiNoteModel::PointList points =
 	m_model->getPoints(s.getStartFrame(), s.getEndFrame());
 
-    for (NoteModel::PointList::iterator i = points.begin();
+    for (FlexiNoteModel::PointList::iterator i = points.begin();
 	 i != points.end(); ++i) {
 
         if (s.contains(i->frame)) {
             command->deletePoint(*i);
         }

 
     finish(command);
 }    
 
 void
-NoteLayer::copy(View *v, Selection s, Clipboard &to)
+FlexiNoteLayer::copy(View *v, Selection s, Clipboard &to)
 {
     if (!m_model) return;
 
-    NoteModel::PointList points =
+    FlexiNoteModel::PointList points =
 	m_model->getPoints(s.getStartFrame(), s.getEndFrame());
 
-    for (NoteModel::PointList::iterator i = points.begin();
+    for (FlexiNoteModel::PointList::iterator i = points.begin();
 	 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);
         }
     }
 }
 
 bool
-NoteLayer::paste(View *v, const Clipboard &from, int frameOffset, bool /* interactive */)
+FlexiNoteLayer::paste(View *v, const Clipboard &from, int frameOffset, bool /* interactive */)
 {
     if (!m_model) return false;
 
     const Clipboard::PointList &points = from.getPoints();
 

         if (button == QMessageBox::Yes) {
             realign = true;
         }
     }
 
-    NoteModel::EditCommand *command =
-	new NoteModel::EditCommand(m_model, tr("Paste"));
+    FlexiNoteModel::EditCommand *command =
+	new FlexiNoteModel::EditCommand(m_model, tr("Paste"));
 
     for (Clipboard::PointList::const_iterator i = points.begin();
          i != points.end(); ++i) {
         
         if (!i->haveFrame()) continue;

             } else {
                 frame = i->getFrame();
             }
         }
 
-        NoteModel::Point newPoint(frame);
+        FlexiNoteModel::Point newPoint(frame);
   
         if (i->haveLabel()) newPoint.label = i->getLabel();
         if (i->haveValue()) newPoint.value = i->getValue();
         else newPoint.value = (m_model->getValueMinimum() +
                                m_model->getValueMaximum()) / 2;

     finish(command);
     return true;
 }
 
 void
-NoteLayer::addNoteOn(long frame, int pitch, int velocity)
-{
-    m_pendingNoteOns.insert(Note(frame, pitch, 0, float(velocity) / 127.0, ""));
-}
-
-void
-NoteLayer::addNoteOff(long frame, int pitch)
-{
-    for (NoteSet::iterator i = m_pendingNoteOns.begin();
+FlexiNoteLayer::addNoteOn(long frame, int pitch, int velocity)
+{
+    m_pendingNoteOns.insert(FlexiNote(frame, pitch, 0, float(velocity) / 127.0, ""));
+}
+
+void
+FlexiNoteLayer::addNoteOff(long frame, int pitch)
+{
+    for (FlexiNoteSet::iterator i = m_pendingNoteOns.begin();
          i != m_pendingNoteOns.end(); ++i) {
         if (lrintf((*i).value) == pitch) {
-            Note note(*i);
+            FlexiNote note(*i);
             m_pendingNoteOns.erase(i);
             note.duration = frame - note.frame;
             if (m_model) {
-                NoteModel::AddPointCommand *c = new NoteModel::AddPointCommand
-                    (m_model, note, tr("Record Note"));
+                FlexiNoteModel::AddPointCommand *c = new FlexiNoteModel::AddPointCommand
+                    (m_model, note, tr("Record FlexiNote"));
                 // execute and bundle:
                 CommandHistory::getInstance()->addCommand(c, true, true);
             }
             break;
         }
     }
 }
 
 void
-NoteLayer::abandonNoteOns()
+FlexiNoteLayer::abandonNoteOns()
 {
     m_pendingNoteOns.clear();
 }
 
 int
-NoteLayer::getDefaultColourHint(bool darkbg, bool &impose)
+FlexiNoteLayer::getDefaultColourHint(bool darkbg, bool &impose)
 {
     impose = false;
     return ColourDatabase::getInstance()->getColourIndex
         (QString(darkbg ? "White" : "Black"));
 }
 
 void
-NoteLayer::toXml(QTextStream &stream,
+FlexiNoteLayer::toXml(QTextStream &stream,
                  QString indent, QString extraAttributes) const
 {
     SingleColourLayer::toXml(stream, indent, extraAttributes +
                              QString(" verticalScale=\"%1\" scaleMinimum=\"%2\" scaleMaximum=\"%3\" ")
                              .arg(m_verticalScale)
                              .arg(m_scaleMinimum)
                              .arg(m_scaleMaximum));
 }
 
 void
-NoteLayer::setProperties(const QXmlAttributes &attributes)
+FlexiNoteLayer::setProperties(const QXmlAttributes &attributes)
 {
     SingleColourLayer::setProperties(attributes);
 
     bool ok, alsoOk;
     VerticalScale scale = (VerticalScale)