comparison layer/TimeValueLayer.cpp @ 663:1a0fdad4af4d tonioni

Merge from the default branch

     if (m_model && m_model->getRDFTypeURI().endsWith("Change")) {
         setPlotStyle(PlotSegmentation);
     }
 
 #ifdef DEBUG_TIME_VALUE_LAYER
-    SVDEBUG << "TimeValueLayer::setModel(" << model << ")" << endl;
+    std::cerr << "TimeValueLayer::setModel(" << model << ")" << std::endl;
 #endif
 
     emit modelReplaced();
 }
 

     unit = m_model->getScaleUnits();
     if (m_derivative) {
         max = std::max(fabsf(min), fabsf(max));
         min = -max;
     }
+
+#ifdef DEBUG_TIME_VALUE_LAYER
+    std::cerr << "TimeValueLayer::getValueExtents: min = " << min << ", max = " << max << std::endl;
+#endif
+
     return true;
 }
 
 bool
 TimeValueLayer::getDisplayExtents(float &min, float &max) const

         max = std::max(fabsf(min), fabsf(max));
         min = -max;
     }
 
 #ifdef DEBUG_TIME_VALUE_LAYER
-    SVDEBUG << "TimeValueLayer::getDisplayExtents: min = " << min << ", max = " << max << endl;
+    std::cerr << "TimeValueLayer::getDisplayExtents: min = " << min << ", max = " << max << std::endl;
 #endif
 
     return true;
 }
 

 
     m_scaleMinimum = min;
     m_scaleMaximum = max;
 
 #ifdef DEBUG_TIME_VALUE_LAYER
-    SVDEBUG << "TimeValueLayer::setDisplayExtents: min = " << min << ", max = " << max << endl;
+    std::cerr << "TimeValueLayer::setDisplayExtents: min = " << min << ", max = " << max << std::endl;
 #endif
     
     emit layerParametersChanged();
     return true;
 }

     getDisplayExtents(dmin, dmax);
 
     int nr = mapper->getPositionForValue(dmax - dmin);
 
 #ifdef DEBUG_TIME_VALUE_LAYER
-    SVDEBUG << "TimeValueLayer::getCurrentVerticalZoomStep: dmin = " << dmin << ", dmax = " << dmax << ", nr = " << nr << endl;
+    std::cerr << "TimeValueLayer::getCurrentVerticalZoomStep: dmin = " << dmin << ", dmax = " << dmax << ", nr = " << nr << std::endl;
 #endif
 
     delete mapper;
 
     return 100 - nr;

     if (newmax > max) {
         newmax = max;
     }
     
 #ifdef DEBUG_TIME_VALUE_LAYER
-    SVDEBUG << "TimeValueLayer::setVerticalZoomStep: " << step << ": " << newmin << " -> " << newmax << " (range " << newdist << ")" << endl;
+    std::cerr << "TimeValueLayer::setVerticalZoomStep: " << step << ": " << newmin << " -> " << newmax << " (range " << newdist << ")" << std::endl;
 #endif
 
     setDisplayExtents(newmin, newmax);
 }
 

 
     SparseTimeValueModel::PointList usePoints = prevPoints;
 
     if (prevPoints.empty()) {
 	usePoints = nextPoints;
+    } else if (nextPoints.empty()) {
+        // stick with prevPoints
     } else if (long(prevPoints.begin()->frame) < v->getStartFrame() &&
 	       !(nextPoints.begin()->frame > v->getEndFrame())) {
 	usePoints = nextPoints;
     } else if (nextPoints.begin()->frame - frame <
 	       frame - prevPoints.begin()->frame) {

 
     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)) {
+	    (px < x && x - px > fuzz + 3)) {
 	    usePoints.clear();
 	}
     }
 
     return usePoints;

         max = 1.0;
 
     } else {
 
         getDisplayExtents(min, max);
-
+        
         if (m_verticalScale == LogScale) {
             LogRange::mapRange(min, max);
             log = true;
         }
     }
 
-    if (max == min) max = min + 1.0;
+#ifdef DEBUG_TIME_VALUE_LAYER
+    std::cerr << "TimeValueLayer::getScaleExtents: min = " << min << ", max = " << max << std::endl;
+#endif
+
+    if (max == min) {
+        max = max + 0.5;
+        min = min - 0.5;
+    } else {
+        float margin = (max - min) / 10.0;
+        max = max + margin;
+        min = min - margin;
+    }
+
+#ifdef DEBUG_TIME_VALUE_LAYER
+    std::cerr << "TimeValueLayer::getScaleExtents: min = " << min << ", max = " << max << " (after adjustment)" << std::endl;
+#endif
 }
 
 int
 TimeValueLayer::getYForValue(View *v, float val) const
 {

     if (log) {
         val = LogRange::map(val);
     }
 
 #ifdef DEBUG_TIME_VALUE_LAYER
-    SVDEBUG << "TimeValueLayer::getColourForValue: min " << min << ", max "
-              << max << ", log " << log << ", value " << val << endl;
+    std::cerr << "TimeValueLayer::getColourForValue: min " << min << ", max "
+              << max << ", log " << log << ", value " << val << std::endl;
 #endif
 
     QColor solid = ColourMapper(m_colourMap, min, max).map(val);
     return QColor(solid.red(), solid.green(), solid.blue(), 120);
 }

     QColor brushColour(getBaseQColor());
     brushColour.setAlpha(80);
     paint.setBrush(brushColour);
 
 #ifdef DEBUG_TIME_VALUE_LAYER
-    SVDEBUG << "TimeValueLayer::paint: resolution is "
-	      << m_model->getResolution() << " frames" << endl;
+    std::cerr << "TimeValueLayer::paint: resolution is "
+	      << m_model->getResolution() << " frames" << std::endl;
 #endif
 
     float min = m_model->getValueMinimum();
     float max = m_model->getValueMaximum();
     if (max == min) max = min + 1.0;

     }
 
     int w =
 	v->getXForFrame(frame0 + m_model->getResolution()) -
 	v->getXForFrame(frame0);
+
+    if (m_plotStyle == PlotStems) {
+        if (w < 2) w = 2;
+    } else {
+        if (w < 1) w = 1;
+    }
 
     paint.save();
 
     QPainterPath path;
     int pointCount = 0;

                    (p.frame - prevFrame >= m_model->getResolution() * 2));
         }
 
         if (m_plotStyle != PlotSegmentation) {
             textY = y - paint.fontMetrics().height()
-                      + paint.fontMetrics().ascent();
+                      + paint.fontMetrics().ascent() - 1;
             if (textY < paint.fontMetrics().ascent() + 1) {
                 textY = paint.fontMetrics().ascent() + 1;
             }
         }
 

 	    haveNext = true;
         }
 
 //        std::cout << "frame = " << p.frame << ", x = " << x << ", haveNext = " << haveNext 
 //                  << ", nx = " << nx << std::endl;
-
-	if (w < 1) w = 1;
 
         if (m_plotStyle == PlotDiscreteCurves) {
             paint.setPen(QPen(getBaseQColor(), 3));
             paint.setBrush(Qt::NoBrush);
         } else if (m_plotStyle == PlotSegmentation) {

 	    } else if (y > origin + 1) {
 		paint.drawLine(x + w/2, origin, x + w/2, y - 1);
 	    }
 	}
 
+        bool illuminate = false;
+
 	if (illuminateFrame == p.frame) {
 
-	    //!!! aside from the problem of choosing a colour, it'd be
-	    //better to save the highlighted rects and draw them at
-	    //the end perhaps
-
-	    //!!! not equipped to illuminate the right section in line
-	    //or curve mode
+	    // not equipped to illuminate the right section in line
+	    // or curve mode
 
 	    if (m_plotStyle != PlotCurve &&
                 m_plotStyle != PlotDiscreteCurves &&
 		m_plotStyle != PlotLines) {
-		paint.setPen(getForegroundQColor(v));
-	    }	    
-	}
+                illuminate = true;
+            }
+        }
 
 	if (m_plotStyle != PlotLines &&
 	    m_plotStyle != PlotCurve &&
             m_plotStyle != PlotDiscreteCurves &&
 	    m_plotStyle != PlotSegmentation) {
+            if (illuminate) {
+                paint.save();
+		paint.setPen(getForegroundQColor(v));
+                paint.setBrush(getForegroundQColor(v));
+            }
             if (m_plotStyle != PlotStems ||
                 w > 1) {
                 paint.drawRect(x, y - 1, w, 2);
+            }
+            if (illuminate) {
+                paint.restore();
             }
 	}
 
 	if (m_plotStyle == PlotConnectedPoints ||
 	    m_plotStyle == PlotLines ||

 		} else if (m_plotStyle == PlotLines) {
                     
                     if (pointCount == 0) {
                         path.moveTo(x + w/2, y);
                     }
-                    ++pointCount;
 
 //		    paint.drawLine(x + w/2, y, nx + w/2, ny);
                     path.lineTo(nx + w/2, ny);
 
 		} else {

                     }
 
 		    if (pointCount == 0 || gap) {
 			path.moveTo((x0 + x1) / 2, (y0 + y1) / 2);
 		    }
-		    ++pointCount;
 
 		    if (nx - x > 5) {
 			path.cubicTo(x0, y0,
 				     x0, y0,
 				     (x0 + x1) / 2, (y0 + y1) / 2);

 	}
 
 	if (m_plotStyle == PlotSegmentation) {
 
 #ifdef DEBUG_TIME_VALUE_LAYER
-            SVDEBUG << "drawing rect" << endl;
+            std::cerr << "drawing rect" << std::endl;
 #endif
 	    
 	    if (nx <= x) continue;
 
             paint.setPen(QPen(getForegroundQColor(v), 2));
 
-            if (illuminateFrame != p.frame) {
+            if (!illuminate) {
                 if (!m_drawSegmentDivisions ||
                     nx < x + 5 ||
                     x >= v->width() - 1) {
                     paint.setPen(Qt::NoPen);
                 }
 	    }
 
 	    paint.drawRect(x, -1, nx - x, v->height() + 1);
 	}
 
-	if (p.label != "") {
-            if (!haveNext || nx > x + 6 + paint.fontMetrics().width(p.label)) {
-                v->drawVisibleText(paint, x + 5, textY, p.label, View::OutlinedText);
-//                paint.drawText(x + 5, textY, p.label);
+        QString label = p.label;
+        bool italic = false;
+
+        if (label == "" &&
+            (m_plotStyle == PlotPoints ||
+             m_plotStyle == PlotSegmentation ||
+             m_plotStyle == PlotConnectedPoints)) {
+            char lc[20];
+            snprintf(lc, 20, "%.3g", p.value);
+            label = lc;
+            italic = true;
+        }
+
+	if (label != "") {
+            bool haveRoom = nx > x + 6 + paint.fontMetrics().width(label);
+            if (haveRoom ||
+                (!haveNext &&
+                 (pointCount == 0 || !italic))) {
+                v->drawVisibleText(paint, x + 5, textY, label,
+                                   italic ?
+                                   View::OutlinedItalicText :
+                                   View::OutlinedText);
             }
 	}
 
         prevFrame = p.frame;
+        ++pointCount;
     }
 
     if ((m_plotStyle == PlotCurve || m_plotStyle == PlotDiscreteCurves ||
          m_plotStyle == PlotLines)
         && !path.isEmpty()) {

 
 void
 TimeValueLayer::drawStart(View *v, QMouseEvent *e)
 {
 #ifdef DEBUG_TIME_VALUE_LAYER
-    SVDEBUG << "TimeValueLayer::drawStart(" << e->x() << "," << e->y() << ")" << endl;
+    std::cerr << "TimeValueLayer::drawStart(" << e->x() << "," << e->y() << ")" << std::endl;
 #endif
 
     if (!m_model) return;
 
     long frame = v->getFrameForX(e->x());

     if (!points.empty()) {
         for (SparseTimeValueModel::PointList::iterator i = points.begin();
              i != points.end(); ++i) {
             if (((i->frame / resolution) * resolution) != frame) {
 #ifdef DEBUG_TIME_VALUE_LAYER
-                SVDEBUG << "ignoring out-of-range frame at " << i->frame << endl;
+                std::cerr << "ignoring out-of-range frame at " << i->frame << std::endl;
 #endif
                 continue;
             }
             m_editingPoint = *i;
             havePoint = true;

 
 void
 TimeValueLayer::drawDrag(View *v, QMouseEvent *e)
 {
 #ifdef DEBUG_TIME_VALUE_LAYER
-    SVDEBUG << "TimeValueLayer::drawDrag(" << e->x() << "," << e->y() << ")" << endl;
+    std::cerr << "TimeValueLayer::drawDrag(" << e->x() << "," << e->y() << ")" << std::endl;
 #endif
 
     if (!m_model || !m_editing) return;
 
     long frame = v->getFrameForX(e->x());

         for (SparseTimeValueModel::PointList::iterator i = points.begin();
              i != points.end(); ++i) {
             if (i->frame == m_editingPoint.frame &&
                 i->value == m_editingPoint.value) {
 #ifdef DEBUG_TIME_VALUE_LAYER
-                SVDEBUG << "ignoring current editing point at " << i->frame << ", " << i->value << endl;
+                std::cerr << "ignoring current editing point at " << i->frame << ", " << i->value << std::endl;
 #endif
                 continue;
             }
             if (((i->frame / resolution) * resolution) != frame) {
 #ifdef DEBUG_TIME_VALUE_LAYER
-                SVDEBUG << "ignoring out-of-range frame at " << i->frame << endl;
+                std::cerr << "ignoring out-of-range frame at " << i->frame << std::endl;
 #endif
                 continue;
             }
 #ifdef DEBUG_TIME_VALUE_LAYER
-            SVDEBUG << "adjusting to new point at " << i->frame << ", " << i->value << endl;
+            std::cerr << "adjusting to new point at " << i->frame << ", " << i->value << std::endl;
 #endif
             m_editingPoint = *i;
             m_originalPoint = m_editingPoint;
             m_editingCommand->deletePoint(m_editingPoint);
             havePoint = true;

 
 void
 TimeValueLayer::drawEnd(View *, QMouseEvent *)
 {
 #ifdef DEBUG_TIME_VALUE_LAYER
-    SVDEBUG << "TimeValueLayer::drawEnd" << endl;
+    std::cerr << "TimeValueLayer::drawEnd" << std::endl;
 #endif
     if (!m_model || !m_editing) return;
     finish(m_editingCommand);
     m_editingCommand = 0;
     m_editing = false;

 
 void
 TimeValueLayer::editStart(View *v, QMouseEvent *e)
 {
 #ifdef DEBUG_TIME_VALUE_LAYER
-    SVDEBUG << "TimeValueLayer::editStart(" << e->x() << "," << e->y() << ")" << endl;
+    std::cerr << "TimeValueLayer::editStart(" << e->x() << "," << e->y() << ")" << std::endl;
 #endif
 
     if (!m_model) return;
 
     SparseTimeValueModel::PointList points = getLocalPoints(v, e->x());

 
 void
 TimeValueLayer::editDrag(View *v, QMouseEvent *e)
 {
 #ifdef DEBUG_TIME_VALUE_LAYER
-    SVDEBUG << "TimeValueLayer::editDrag(" << e->x() << "," << e->y() << ")" << endl;
+    std::cerr << "TimeValueLayer::editDrag(" << e->x() << "," << e->y() << ")" << std::endl;
 #endif
 
     if (!m_model || !m_editing) return;
 
     long frame = v->getFrameForX(e->x());

 
 void
 TimeValueLayer::editEnd(View *, QMouseEvent *)
 {
 #ifdef DEBUG_TIME_VALUE_LAYER
-    SVDEBUG << "TimeValueLayer::editEnd" << endl;
+    std::cerr << "TimeValueLayer::editEnd" << std::endl;
 #endif
     if (!m_model || !m_editing) return;
 
     if (m_editingCommand) {
 

             
             labeller.setType(generation);
 
             if (generation == Labeller::ValueFromCyclicalCounter ||
                 generation == Labeller::ValueFromTwoLevelCounter) {
-                int cycleSize = QInputDialog::getInteger
+                int cycleSize = QInputDialog::getInt
                     (0, tr("Select cycle size"),
                      tr("Cycle size:"), 4, 2, 16, 1);
                 labeller.setCounterCycleSize(cycleSize);
             }
 

 
         if (i->haveValue()) {
             newPoint.value = i->getValue();
         } else {
 #ifdef DEBUG_TIME_VALUE_LAYER
-            SVDEBUG << "Setting value on point at " << newPoint.frame << " from labeller";
+            std::cerr << "Setting value on point at " << newPoint.frame << " from labeller";
             if (i == points.begin()) {
-                SVDEBUG << ", no prev point" << endl;
+                std::cerr << ", no prev point" << std::endl;
             } else {
                 std::cerr << ", prev point is at " << prevPoint.frame << std::endl;
             }
 #endif
             labeller.setValue<SparseTimeValueModel::Point>