comparison layer/TimeValueLayer.cpp @ 66:e9eac9368e29

* basics of selectable vertical scale in time value layer
* clear selection when closing session

 #include "base/Profiler.h"
 #include "base/View.h"
 
 #include "model/SparseTimeValueModel.h"
 
+#include "SpectrogramLayer.h" // for optional frequency alignment
+
 #include <QPainter>
 #include <QPainterPath>
 #include <QMouseEvent>
 
 #include <iostream>

     m_editing(false),
     m_originalPoint(0, 0.0, tr("New Point")),
     m_editingPoint(0, 0.0, tr("New Point")),
     m_editingCommand(0),
     m_colour(Qt::black),
-    m_plotStyle(PlotConnectedPoints)
+    m_plotStyle(PlotConnectedPoints),
+    m_verticalScale(LinearScale)
 {
     
 }
 
 void

 TimeValueLayer::getProperties() const
 {
     PropertyList list;
     list.push_back(tr("Colour"));
     list.push_back(tr("Plot Type"));
+    list.push_back(tr("Vertical Scale"));
     return list;
 }
 
 Layer::PropertyType
 TimeValueLayer::getPropertyType(const PropertyName &name) const

 	
 	if (min) *min = 0;
 	if (max) *max = 5;
 	
 	deft = int(m_plotStyle);
+
+    } else if (name == tr("Vertical Scale")) {
+	
+	if (min) *min = 0;
+	if (max) *max = 3;
+	
+	deft = int(m_verticalScale);
 
     } else {
 	
 	deft = Layer::getPropertyRangeAndValue(name, min, max);
     }

 	case 2: return tr("Connected Points");
 	case 3: return tr("Lines");
 	case 4: return tr("Curve");
 	case 5: return tr("Segmentation");
 	}
+    } else if (name == tr("Vertical Scale")) {
+	switch (value) {
+	default:
+	case 0: return tr("Linear Scale");
+	case 1: return tr("Log Scale");
+	case 2: return tr("+/-1 Scale");
+	case 3: return tr("Frequency Scale");
+	}
     }
     return tr("<unknown>");
 }
 
 void

 	case 4: setBaseColour(QColor(200, 50, 255)); break;
 	case 5: setBaseColour(QColor(255, 150, 50)); break;
 	}
     } else if (name == tr("Plot Type")) {
 	setPlotStyle(PlotStyle(value));
+    } else if (name == tr("Vertical Scale")) {
+	setVerticalScale(VerticalScale(value));
     }
 }
 
 void
 TimeValueLayer::setBaseColour(QColor colour)

 void
 TimeValueLayer::setPlotStyle(PlotStyle style)
 {
     if (m_plotStyle == style) return;
     m_plotStyle = style;
+    emit layerParametersChanged();
+}
+
+void
+TimeValueLayer::setVerticalScale(VerticalScale scale)
+{
+    if (m_verticalScale == scale) return;
+    m_verticalScale = scale;
     emit layerParametersChanged();
 }
 
 bool
 TimeValueLayer::isLayerScrollable(const View *v) const

     frame = snapped;
     return found;
 }
 
 int
-TimeValueLayer::getYForValue(View *v, float value) const
+TimeValueLayer::getYForValue(View *v, float val) const
 {
     float min = m_model->getValueMinimum();
     float max = m_model->getValueMaximum();
     if (max == min) max = min + 1.0;
 
     int h = v->height();
 
-    return int(h - ((value - min) * h) / (max - min));
+    if (m_verticalScale == FrequencyScale || m_verticalScale == LogScale) {
+        
+        if (m_verticalScale == FrequencyScale) {
+            // If we have a spectrogram layer on the same view as us, align
+            // ourselves with it...
+            for (int i = 0; i < v->getLayerCount(); ++i) {
+                SpectrogramLayer *spectrogram = dynamic_cast<SpectrogramLayer *>
+                    (v->getLayer(i));
+                if (spectrogram) {
+                    return spectrogram->getYForFrequency(v, val);
+                }
+            }
+        }
+
+        min = (min < 0.0) ? -log10(-min) : (min == 0.0) ? 0.0 : log10(min);
+        max = (max < 0.0) ? -log10(-max) : (max == 0.0) ? 0.0 : log10(max);
+        val = (val < 0.0) ? -log10(-val) : (val == 0.0) ? 0.0 : log10(val);
+
+    } else if (m_verticalScale == PlusMinusOneScale) {
+        min = -1.0;
+        max = 1.0;
+    }
+
+    return int(h - ((val - min) * h) / (max - min));
 }
 
 float
 TimeValueLayer::getValueForY(View *v, int y) const
 {
+    //!!!
+
     float min = m_model->getValueMinimum();
     float max = m_model->getValueMaximum();
     if (max == min) max = min + 1.0;
 
     int h = v->height();