comparison layer/TextLayer.cpp @ 44:ad214997dddb

* Refactor Layer classes so as no longer to store a single View pointer;
  instead they need to be able to draw themselves on any View on demand.
  Layers with caches (e.g. spectrogram) will need to be further refactored
  so as to maintain a per-View cache

* Begin refactoring MainWindow by pulling out the document stuff (set of
  layers, models etc) into a Document class.  Not yet in use.

This revision is fairly unstable.

 #include <QInputDialog>
 
 #include <iostream>
 #include <cmath>
 
-TextLayer::TextLayer(View *w) :
-    Layer(w),
+TextLayer::TextLayer() :
+    Layer(),
     m_model(0),
     m_editing(false),
     m_originalPoint(0, 0.0, tr("Empty Label")),
     m_editingPoint(0, 0.0, tr("Empty Label")),
     m_editingCommand(0),
     m_colour(255, 150, 50) // orange
 {
-    m_view->addLayer(this);
+    
 }
 
 void
 TextLayer::setModel(TextModel *model)
 {

     m_colour = colour;
     emit layerParametersChanged();
 }
 
 bool
-TextLayer::isLayerScrollable() const
+TextLayer::isLayerScrollable(const View *v) const
 {
     QPoint discard;
-    return !m_view->shouldIlluminateLocalFeatures(this, discard);
+    return !v->shouldIlluminateLocalFeatures(this, discard);
 }
 
 
 TextModel::PointList
-TextLayer::getLocalPoints(int x, int y) const
+TextLayer::getLocalPoints(View *v, int x, int y) const
 {
     if (!m_model) return TextModel::PointList();
 
-    long frame0 = getFrameForX(-150);
-    long frame1 = getFrameForX(m_view->width() + 150);
+    long frame0 = v->getFrameForX(-150);
+    long frame1 = v->getFrameForX(v->width() + 150);
     
     TextModel::PointList points(m_model->getPoints(frame0, frame1));
 
     TextModel::PointList rv;
     QFontMetrics metrics = QPainter().fontMetrics();

     for (TextModel::PointList::iterator i = points.begin();
 	 i != points.end(); ++i) {
 
 	const TextModel::Point &p(*i);
 
-	int px = getXForFrame(p.frame);
-	int py = getYForHeight(p.height);
+	int px = v->getXForFrame(p.frame);
+	int py = getYForHeight(v, p.height);
 
 	QString label = p.label;
 	if (label == "") {
 	    label = tr("<no text>");
 	}
 
 	QRect rect = metrics.boundingRect
 	    (QRect(0, 0, 150, 200),
 	     Qt::AlignLeft | Qt::AlignTop | Qt::TextWordWrap, label);
 
-	if (py + rect.height() > m_view->height()) {
-	    if (rect.height() > m_view->height()) py = 0;
-	    else py = m_view->height() - rect.height() - 1;
+	if (py + rect.height() > v->height()) {
+	    if (rect.height() > v->height()) py = 0;
+	    else py = v->height() - rect.height() - 1;
 	}
 
 	if (x >= px && x < px + rect.width() &&
 	    y >= py && y < py + rect.height()) {
 	    rv.insert(p);

 
     return rv;
 }
 
 QString
-TextLayer::getFeatureDescription(QPoint &pos) const
+TextLayer::getFeatureDescription(View *v, QPoint &pos) const
 {
     int x = pos.x();
 
     if (!m_model || !m_model->getSampleRate()) return "";
 
-    TextModel::PointList points = getLocalPoints(x, pos.y());
+    TextModel::PointList points = getLocalPoints(v, x, pos.y());
 
     if (points.empty()) {
 	if (!m_model->isReady()) {
 	    return tr("In progress");
 	} else {

 	    .arg(rt.toText(true).c_str())
 	    .arg(points.begin()->height)
 	    .arg(points.begin()->label);
     }
 
-    pos = QPoint(getXForFrame(useFrame), getYForHeight(points.begin()->height));
+    pos = QPoint(v->getXForFrame(useFrame),
+		 getYForHeight(v, points.begin()->height));
     return text;
 }
 
 
 //!!! too much overlap with TimeValueLayer/TimeInstantLayer
 
 bool
-TextLayer::snapToFeatureFrame(int &frame,
+TextLayer::snapToFeatureFrame(View *v, int &frame,
 			      size_t &resolution,
 			      SnapType snap) const
 {
     if (!m_model) {
-	return Layer::snapToFeatureFrame(frame, resolution, snap);
+	return Layer::snapToFeatureFrame(v, frame, resolution, snap);
     }
 
     resolution = m_model->getResolution();
     TextModel::PointList points;
 
     if (snap == SnapNeighbouring) {
 	
-	points = getLocalPoints(getXForFrame(frame), -1);
+	points = getLocalPoints(v, v->getXForFrame(frame), -1);
 	if (points.empty()) return false;
 	frame = points.begin()->frame;
 	return true;
     }    
 

     frame = snapped;
     return found;
 }
 
 int
-TextLayer::getYForHeight(float height) const
-{
-    int h = m_view->height();
+TextLayer::getYForHeight(View *v, float height) const
+{
+    int h = v->height();
     return h - int(height * h);
 }
 
 float
-TextLayer::getHeightForY(int y) const
-{
-    int h = m_view->height();
+TextLayer::getHeightForY(View *v, int y) const
+{
+    int h = v->height();
     return float(h - y) / h;
 }
 
 void
-TextLayer::paint(QPainter &paint, QRect rect) const
+TextLayer::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("TextLayer::paint", true);
 
     int x0 = rect.left(), x1 = rect.right();
-    long frame0 = getFrameForX(x0);
-    long frame1 = getFrameForX(x1);
+    long frame0 = v->getFrameForX(x0);
+    long frame1 = v->getFrameForX(x1);
 
     TextModel::PointList points(m_model->getPoints(frame0, frame1));
     if (points.empty()) return;
 
     QColor brushColour(m_colour);
 
-    int h, s, v;
-    brushColour.getHsv(&h, &s, &v);
+    int h, s, val;
+    brushColour.getHsv(&h, &s, &val);
     brushColour.setHsv(h, s, 255, 100);
 
     QColor penColour;
-    if (m_view->hasLightBackground()) {
+    if (v->hasLightBackground()) {
 	penColour = Qt::black;
     } else {
 	penColour = Qt::white;
     }
 

 //	      << m_model->getResolution() << " frames" << std::endl;
 
     QPoint localPos;
     long illuminateFrame = -1;
 
-    if (m_view->shouldIlluminateLocalFeatures(this, localPos)) {
-	TextModel::PointList localPoints = getLocalPoints(localPos.x(),
+    if (v->shouldIlluminateLocalFeatures(this, localPos)) {
+	TextModel::PointList localPoints = getLocalPoints(v, localPos.x(),
 							  localPos.y());
 	if (!localPoints.empty()) illuminateFrame = localPoints.begin()->frame;
     }
 
     int boxMaxWidth = 150;
     int boxMaxHeight = 200;
 
     paint.save();
-    paint.setClipRect(rect.x(), 0, rect.width() + boxMaxWidth, m_view->height());
+    paint.setClipRect(rect.x(), 0, rect.width() + boxMaxWidth, v->height());
     
     for (TextModel::PointList::const_iterator i = points.begin();
 	 i != points.end(); ++i) {
 
 	const TextModel::Point &p(*i);
 
-	int x = getXForFrame(p.frame);
-	int y = getYForHeight(p.height);
+	int x = v->getXForFrame(p.frame);
+	int y = getYForHeight(v, p.height);
 
 	if (illuminateFrame == p.frame) {
 	    paint.setBrush(penColour);
-	    if (m_view->hasLightBackground()) {
+	    if (v->hasLightBackground()) {
 		paint.setPen(Qt::white);
 	    } else {
 		paint.setPen(Qt::black);
 	    }
 	} else {

 	     Qt::AlignLeft | Qt::AlignTop | Qt::TextWordWrap, label);
 
 	QRect textRect = QRect(3, 2, boxRect.width(), boxRect.height());
 	boxRect = QRect(0, 0, boxRect.width() + 6, boxRect.height() + 2);
 
-	if (y + boxRect.height() > m_view->height()) {
-	    if (boxRect.height() > m_view->height()) y = 0;
-	    else y = m_view->height() - boxRect.height() - 1;
+	if (y + boxRect.height() > v->height()) {
+	    if (boxRect.height() > v->height()) y = 0;
+	    else y = v->height() - boxRect.height() - 1;
 	}
 
 	boxRect = QRect(x, y, boxRect.width(), boxRect.height());
 	textRect = QRect(x + 3, y + 2, textRect.width(), textRect.height());
 

     // looks like save/restore doesn't deal with this:
     paint.setRenderHint(QPainter::Antialiasing, false);
 }
 
 void
-TextLayer::drawStart(QMouseEvent *e)
+TextLayer::drawStart(View *v, QMouseEvent *e)
 {
 //    std::cerr << "TextLayer::drawStart(" << e->x() << "," << e->y() << ")" << std::endl;
 
     if (!m_model) {
 	std::cerr << "TextLayer::drawStart: no model" << std::endl;
 	return;
     }
 
-    long frame = getFrameForX(e->x());
+    long frame = v->getFrameForX(e->x());
     if (frame < 0) frame = 0;
     frame = frame / m_model->getResolution() * m_model->getResolution();
 
-    float height = getHeightForY(e->y());
+    float height = getHeightForY(v, e->y());
 
     m_editingPoint = TextModel::Point(frame, height, "");
     m_originalPoint = m_editingPoint;
 
     if (m_editingCommand) m_editingCommand->finish();

 
     m_editing = true;
 }
 
 void
-TextLayer::drawDrag(QMouseEvent *e)
+TextLayer::drawDrag(View *v, QMouseEvent *e)
 {
 //    std::cerr << "TextLayer::drawDrag(" << e->x() << "," << e->y() << ")" << std::endl;
 
     if (!m_model || !m_editing) return;
 
-    long frame = getFrameForX(e->x());
+    long frame = v->getFrameForX(e->x());
     if (frame < 0) frame = 0;
     frame = frame / m_model->getResolution() * m_model->getResolution();
 
-    float height = getHeightForY(e->y());
+    float height = getHeightForY(v, e->y());
 
     m_editingCommand->deletePoint(m_editingPoint);
     m_editingPoint.frame = frame;
     m_editingPoint.height = height;
     m_editingCommand->addPoint(m_editingPoint);
 }
 
 void
-TextLayer::drawEnd(QMouseEvent *e)
+TextLayer::drawEnd(View *v, QMouseEvent *e)
 {
 //    std::cerr << "TextLayer::drawEnd(" << e->x() << "," << e->y() << ")" << std::endl;
     if (!m_model || !m_editing) return;
 
     bool ok = false;
-    QString label = QInputDialog::getText(m_view, tr("Enter label"),
+    QString label = QInputDialog::getText(v, tr("Enter label"),
 					  tr("Please enter a new label:"),
 					  QLineEdit::Normal, "", &ok);
 
     if (ok) {
 	TextModel::RelabelCommand *command =

     m_editingCommand = 0;
     m_editing = false;
 }
 
 void
-TextLayer::editStart(QMouseEvent *e)
+TextLayer::editStart(View *v, QMouseEvent *e)
 {
 //    std::cerr << "TextLayer::editStart(" << e->x() << "," << e->y() << ")" << std::endl;
 
     if (!m_model) return;
 
-    TextModel::PointList points = getLocalPoints(e->x(), e->y());
+    TextModel::PointList points = getLocalPoints(v, e->x(), e->y());
     if (points.empty()) return;
 
     m_editOrigin = e->pos();
     m_editingPoint = *points.begin();
     m_originalPoint = m_editingPoint;

 
     m_editing = true;
 }
 
 void
-TextLayer::editDrag(QMouseEvent *e)
+TextLayer::editDrag(View *v, QMouseEvent *e)
 {
     if (!m_model || !m_editing) return;
 
-    long frameDiff = getFrameForX(e->x()) - getFrameForX(m_editOrigin.x());
-    float heightDiff = getHeightForY(e->y()) - getHeightForY(m_editOrigin.y());
+    long frameDiff = v->getFrameForX(e->x()) - v->getFrameForX(m_editOrigin.x());
+    float heightDiff = getHeightForY(v, e->y()) - getHeightForY(v, m_editOrigin.y());
 
     long frame = m_originalPoint.frame + frameDiff;
     float height = m_originalPoint.height + heightDiff;
 
-//    long frame = getFrameForX(e->x());
+//    long frame = v->getFrameForX(e->x());
     if (frame < 0) frame = 0;
     frame = (frame / m_model->getResolution()) * m_model->getResolution();
 
-//    float height = getHeightForY(e->y());
+//    float height = getHeightForY(v, e->y());
 
     if (!m_editingCommand) {
 	m_editingCommand = new TextModel::EditCommand(m_model, tr("Drag Label"));
     }
 

     m_editingPoint.height = height;
     m_editingCommand->addPoint(m_editingPoint);
 }
 
 void
-TextLayer::editEnd(QMouseEvent *e)
+TextLayer::editEnd(View *v, QMouseEvent *e)
 {
 //    std::cerr << "TextLayer::editEnd(" << e->x() << "," << e->y() << ")" << std::endl;
     if (!m_model || !m_editing) return;
 
     if (m_editingCommand) {

     m_editingCommand = 0;
     m_editing = false;
 }
 
 void
-TextLayer::editOpen(QMouseEvent *e)
+TextLayer::editOpen(View *v, QMouseEvent *e)
 {
     std::cerr << "TextLayer::editOpen" << std::endl;
 
     if (!m_model) return;
 
-    TextModel::PointList points = getLocalPoints(e->x(), e->y());
+    TextModel::PointList points = getLocalPoints(v, e->x(), e->y());
     if (points.empty()) return;
 
     QString label = points.begin()->label;
 
     bool ok = false;
-    label = QInputDialog::getText(m_view, tr("Enter label"),
+    label = QInputDialog::getText(v, tr("Enter label"),
 				  tr("Please enter a new label:"),
 				  QLineEdit::Normal, label, &ok);
     if (ok && label != points.begin()->label) {
 	TextModel::RelabelCommand *command =
 	    new TextModel::RelabelCommand(m_model, *points.begin(), label);