comparison layer/TimeInstantLayer.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 <QPainter>
 #include <QMouseEvent>
 
 #include <iostream>
 
-TimeInstantLayer::TimeInstantLayer(View *w) :
-    Layer(w),
+TimeInstantLayer::TimeInstantLayer() :
+    Layer(),
     m_model(0),
     m_editing(false),
     m_editingPoint(0, tr("New Point")),
     m_editingCommand(0),
     m_colour(QColor(200, 50, 255)),
     m_plotStyle(PlotInstants)
 {
-    m_view->addLayer(this);
+    
 }
 
 void
 TimeInstantLayer::setModel(SparseOneDimensionalModel *model)
 {

     m_plotStyle = style;
     emit layerParametersChanged();
 }
 
 bool
-TimeInstantLayer::isLayerScrollable() const
+TimeInstantLayer::isLayerScrollable(const View *v) const
 {
     QPoint discard;
-    return !m_view->shouldIlluminateLocalFeatures(this, discard);
+    return !v->shouldIlluminateLocalFeatures(this, discard);
 }
 
 SparseOneDimensionalModel::PointList
-TimeInstantLayer::getLocalPoints(int x) const
+TimeInstantLayer::getLocalPoints(View *v, int x) const
 {
     // Return a set of points that all have the same frame number, the
     // nearest to the given x coordinate, and that are within a
     // certain fuzz distance of that x coordinate.
 
     if (!m_model) return SparseOneDimensionalModel::PointList();
 
-    long frame = getFrameForX(x);
+    long frame = v->getFrameForX(x);
 
     SparseOneDimensionalModel::PointList onPoints =
 	m_model->getPoints(frame);
 
     if (!onPoints.empty()) {

 
     SparseOneDimensionalModel::PointList usePoints = prevPoints;
 
     if (prevPoints.empty()) {
 	usePoints = nextPoints;
-    } else if (prevPoints.begin()->frame < m_view->getStartFrame() &&
-	       !(nextPoints.begin()->frame > m_view->getEndFrame())) {
+    } else if (prevPoints.begin()->frame < v->getStartFrame() &&
+	       !(nextPoints.begin()->frame > v->getEndFrame())) {
 	usePoints = nextPoints;
     } else if (nextPoints.begin()->frame - frame <
 	       frame - prevPoints.begin()->frame) {
 	usePoints = nextPoints;
     }
 
     if (!usePoints.empty()) {
 	int fuzz = 2;
-	int px = getXForFrame(usePoints.begin()->frame);
+	int px = v->getXForFrame(usePoints.begin()->frame);
 	if ((px > x && px - x > fuzz) ||
 	    (px < x && x - px > fuzz + 1)) {
 	    usePoints.clear();
 	}
     }
 
     return usePoints;
 }
 
 QString
-TimeInstantLayer::getFeatureDescription(QPoint &pos) const
+TimeInstantLayer::getFeatureDescription(View *v, QPoint &pos) const
 {
     int x = pos.x();
 
     if (!m_model || !m_model->getSampleRate()) return "";
 
-    SparseOneDimensionalModel::PointList points = getLocalPoints(x);
+    SparseOneDimensionalModel::PointList points = getLocalPoints(v, x);
 
     if (points.empty()) {
 	if (!m_model->isReady()) {
 	    return tr("In progress");
 	} else {

 	text = QString(tr("Time:\t%1\nLabel:\t%2"))
 	    .arg(rt.toText(true).c_str())
 	    .arg(points.begin()->label);
     }
 
-    pos = QPoint(getXForFrame(useFrame), pos.y());
+    pos = QPoint(v->getXForFrame(useFrame), pos.y());
     return text;
 }
 
 bool
-TimeInstantLayer::snapToFeatureFrame(int &frame,
+TimeInstantLayer::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();
     SparseOneDimensionalModel::PointList points;
 
     if (snap == SnapNeighbouring) {
 	
-	points = getLocalPoints(getXForFrame(frame));
+	points = getLocalPoints(v, v->getXForFrame(frame));
 	if (points.empty()) return false;
 	frame = points.begin()->frame;
 	return true;
     }    
 

     frame = snapped;
     return found;
 }
 
 void
-TimeInstantLayer::paint(QPainter &paint, QRect rect) const
+TimeInstantLayer::paint(View *v, QPainter &paint, QRect rect) const
 {
     if (!m_model || !m_model->isOK()) return;
 
 //    Profiler profiler("TimeInstantLayer::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);
 
     SparseOneDimensionalModel::PointList points(m_model->getPoints
 						(frame0, frame1));
 
     bool odd = false;

 //	      << m_model->getResolution() << " frames" << std::endl;
 
     QPoint localPos;
     long illuminateFrame = -1;
 
-    if (m_view->shouldIlluminateLocalFeatures(this, localPos)) {
+    if (v->shouldIlluminateLocalFeatures(this, localPos)) {
 	SparseOneDimensionalModel::PointList localPoints =
-	    getLocalPoints(localPos.x());
+	    getLocalPoints(v, localPos.x());
 	if (!localPoints.empty()) illuminateFrame = localPoints.begin()->frame;
     }
 	
     int prevX = -1;
 

 
 	const SparseOneDimensionalModel::Point &p(*i);
 	SparseOneDimensionalModel::PointList::const_iterator j = i;
 	++j;
 
-	int x = getXForFrame(p.frame);
+	int x = v->getXForFrame(p.frame);
 	if (x == prevX && p.frame != illuminateFrame) continue;
 
-	int iw = getXForFrame(p.frame + m_model->getResolution()) - x;
+	int iw = v->getXForFrame(p.frame + m_model->getResolution()) - x;
 	if (iw < 2) {
 	    if (iw < 1) {
 		iw = 2;
 		if (j != points.end()) {
-		    int nx = getXForFrame(j->frame);
+		    int nx = v->getXForFrame(j->frame);
 		    if (nx < x + 3) iw = 1;
 		}
 	    } else {
 		iw = 2;
 	    }

 	    paint.setPen(brushColour);
 	}
 
 	if (m_plotStyle == PlotInstants) {
 	    if (iw > 1) {
-		paint.drawRect(x, 0, iw - 1, m_view->height() - 1);
+		paint.drawRect(x, 0, iw - 1, v->height() - 1);
 	    } else {
-		paint.drawLine(x, 0, x, m_view->height() - 1);
+		paint.drawLine(x, 0, x, v->height() - 1);
 	    }
 	} else {
 
 	    if (odd) paint.setBrush(oddBrushColour);
 	    else paint.setBrush(brushColour);
 	    
 	    int nx;
 	    
 	    if (j != points.end()) {
 		const SparseOneDimensionalModel::Point &q(*j);
-		nx = getXForFrame(q.frame);
+		nx = v->getXForFrame(q.frame);
 	    } else {
-		nx = getXForFrame(m_model->getEndFrame());
+		nx = v->getXForFrame(m_model->getEndFrame());
 	    }
 
 	    if (nx >= x) {
 		
 		if (illuminateFrame != p.frame &&
-		    (nx < x + 5 || x >= m_view->width() - 1)) {
+		    (nx < x + 5 || x >= v->width() - 1)) {
 		    paint.setPen(Qt::NoPen);
 		}
 
-		paint.drawRect(x, -1, nx - x, m_view->height() + 1);
+		paint.drawRect(x, -1, nx - x, v->height() + 1);
 	    }
 
 	    odd = !odd;
 	}
 

 
 	    int lw = paint.fontMetrics().width(p.label);
 	    bool good = true;
 
 	    if (j != points.end()) {
-		int nx = getXForFrame(j->frame);
+		int nx = v->getXForFrame(j->frame);
 		if (nx >= x && nx - x - iw - 3 <= lw) good = false;
 	    }
 
 	    if (good) {
 		paint.drawText(x + iw + 2,
-			       m_view->height() - paint.fontMetrics().height(),
+			       v->height() - paint.fontMetrics().height(),
 			       p.label);
 	    }
 	}
 
 	prevX = x;
     }
 }
 
 void
-TimeInstantLayer::drawStart(QMouseEvent *e)
+TimeInstantLayer::drawStart(View *v, QMouseEvent *e)
 {
     std::cerr << "TimeInstantLayer::drawStart(" << e->x() << ")" << std::endl;
 
     if (!m_model) 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();
 
     m_editingPoint = SparseOneDimensionalModel::Point(frame, tr("New Point"));
 

 
     m_editing = true;
 }
 
 void
-TimeInstantLayer::drawDrag(QMouseEvent *e)
+TimeInstantLayer::drawDrag(View *v, QMouseEvent *e)
 {
     std::cerr << "TimeInstantLayer::drawDrag(" << e->x() << ")" << 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();
     m_editingCommand->deletePoint(m_editingPoint);
     m_editingPoint.frame = frame;
     m_editingCommand->addPoint(m_editingPoint);
 }
 
 void
-TimeInstantLayer::drawEnd(QMouseEvent *e)
+TimeInstantLayer::drawEnd(View *v, QMouseEvent *e)
 {
     std::cerr << "TimeInstantLayer::drawEnd(" << e->x() << ")" << std::endl;
     if (!m_model || !m_editing) return;
     QString newName = tr("Add Point at %1 s")
 	.arg(RealTime::frame2RealTime(m_editingPoint.frame,

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

 
     m_editing = true;
 }
 
 void
-TimeInstantLayer::editDrag(QMouseEvent *e)
+TimeInstantLayer::editDrag(View *v, QMouseEvent *e)
 {
     std::cerr << "TimeInstantLayer::editDrag(" << e->x() << ")" << 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();
 
     if (!m_editingCommand) {
 	m_editingCommand = new SparseOneDimensionalModel::EditCommand(m_model,

     m_editingPoint.frame = frame;
     m_editingCommand->addPoint(m_editingPoint);
 }
 
 void
-TimeInstantLayer::editEnd(QMouseEvent *e)
+TimeInstantLayer::editEnd(View *v, QMouseEvent *e)
 {
     std::cerr << "TimeInstantLayer::editEnd(" << e->x() << ")" << std::endl;
     if (!m_model || !m_editing) return;
     if (m_editingCommand) {
 	QString newName = tr("Move Point to %1 s")