comparison layer/TimeValueLayer.cpp @ 698:ad7623c39396

Pull out log and linear vertical scales into their own classes, make some improvements to log numbering

 #include "widgets/ItemEditDialog.h"
 #include "widgets/ListInputDialog.h"
 
 #include "ColourMapper.h"
 #include "PianoScale.h"
+#include "LinearNumericalScale.h"
+#include "LogNumericalScale.h"
 
 #include <QPainter>
 #include <QPainterPath>
 #include <QMouseEvent>
 #include <QRegExp>

         return tr("Plot Type");
     }
     return SingleColourLayer::getPropertyGroupName(name);
 }
 
+QString
+TimeValueLayer::getScaleUnits() const
+{
+    if (m_model) return m_model->getScaleUnits();
+    else return "";
+}
+
 int
 TimeValueLayer::getPropertyRangeAndValue(const PropertyName &name,
 					 int *min, int *max, int *deflt) const
 {
     int val = 0;

     } else if (name == "Scale Units") {
 
         if (deflt) *deflt = 0;
         if (m_model) {
             val = UnitDatabase::getInstance()->getUnitId
-                (m_model->getScaleUnits());
+                (getScaleUnits());
         }
 
     } else if (name == "Draw Segment Division Lines") {
 
         if (min) *min = 0;

     min = m_model->getValueMinimum();
     max = m_model->getValueMaximum();
 
     logarithmic = (m_verticalScale == LogScale);
 
-    unit = m_model->getScaleUnits();
+    unit = getScaleUnits();
 
     if (m_derivative) {
         max = std::max(fabsf(min), fabsf(max));
         min = -max;
     }

     long useFrame = points.begin()->frame;
 
     RealTime rt = RealTime::frame2RealTime(useFrame, m_model->getSampleRate());
     
     QString text;
-    QString unit = m_model->getScaleUnits();
+    QString unit = getScaleUnits();
     if (unit != "") unit = " " + unit;
 
     if (points.begin()->label == "") {
 	text = QString(tr("Time:\t%1\nValue:\t%2%3\nNo label"))
 	    .arg(rt.toText(true).c_str())

     max = 0.0;
     log = false;
 
     if (shouldAutoAlign()) {
 
-        if (!v->getValueExtents(m_model->getScaleUnits(), min, max, log)) {
+        if (!v->getValueExtents(getScaleUnits(), min, max, log)) {
             min = m_model->getValueMinimum();
             max = m_model->getValueMaximum();
         } else if (log) {
             LogRange::mapRange(min, max);
         }

 
 bool
 TimeValueLayer::shouldAutoAlign() const
 {
     if (!m_model) return false;
-    QString unit = m_model->getScaleUnits();
+    QString unit = getScaleUnits();
     return (m_verticalScale == AutoAlignScale && unit != "");
 }
 
 QColor
 TimeValueLayer::getColourForValue(View *v, float val) const

     // looks like save/restore doesn't deal with this:
     paint.setRenderHint(QPainter::Antialiasing, false);
 }
 
 int
-TimeValueLayer::getVerticalScaleWidth(View *, bool, QPainter &paint) const
+TimeValueLayer::getVerticalScaleWidth(View *v, bool, QPainter &paint) const
 {
     if (!m_model || shouldAutoAlign()) return 0;
-    int w = paint.fontMetrics().width("-000.000");
+    int w = 0;
+    if (m_verticalScale == LogScale) {
+        w = LogNumericalScale().getWidth(v, paint);
+    } else {
+        w = LinearNumericalScale().getWidth(v, paint);
+    }
     if (m_plotStyle == PlotSegmentation) return w + 20;
     else return w + 10;
 }
 
 void
 TimeValueLayer::paintVerticalScale(View *v, bool, QPainter &paint, QRect) const
 {
     if (!m_model) return;
 
+/*
     int h = v->height();
 
     int n = 10;
 
     float min, max;

     int w = getVerticalScaleWidth(v, false, paint);
 
     int tx = 5;
 
     int boxx = 5, boxy = 5;
-    if (m_model->getScaleUnits() != "") {
+    if (getScaleUnits() != "") {
         boxy += paint.fontMetrics().height();
     }
     int boxw = 10, boxh = h - boxy - 5;
 
     if (m_plotStyle == PlotSegmentation) {

             y = boxy + int(boxh - ((val - min) * boxh) / (max - min));
             ty = y;
         } else {
             if (i == n-1 &&
                 v->height() < paint.fontMetrics().height() * (n*2)) {
-                if (m_model->getScaleUnits() != "") drawText = false;
+                if (getScaleUnits() != "") drawText = false;
             }
             dispval = lrintf(val / round) * round;
 #ifdef DEBUG_TIME_VALUE_LAYER
             cerr << "val = " << val << ", dispval = " << dispval << endl;
 #endif

         }
 
         prevy = y;
 	val += inc;
     }
-    
-    if (m_model->getScaleUnits() != "") {
+*/
+    float min, max;
+    bool logarithmic;
+    getScaleExtents(v, min, max, logarithmic);
+
+    int w = getVerticalScaleWidth(v, false, paint);
+    int h = v->height();
+
+    if (m_plotStyle == PlotSegmentation) {
+
+        //!!! todo!
+
+    } else {
+
+        if (logarithmic) {
+            LogNumericalScale().paintVertical(v, this, paint, 0, min, max);
+        } else {
+            LinearNumericalScale().paintVertical(v, this, paint, 0, min, max);
+        }
+
+        if (logarithmic && (getScaleUnits() == "Hz")) {
+            PianoScale().paintPianoVertical
+                (v, paint, QRect(w - 10, 0, 10, h), 
+                 LogRange::unmap(min), 
+                 LogRange::unmap(max));
+            paint.drawLine(w, 0, w, h);
+        }
+    }
+        
+    if (getScaleUnits() != "") {
         paint.drawText(5, 5 + paint.fontMetrics().ascent(),
-                       m_model->getScaleUnits());
-    }
-
-    if (logarithmic &&
-        (m_model->getScaleUnits() == "Hz") &&
-        (m_plotStyle != PlotSegmentation)) {
-        float fmin, fmax;
-        getDisplayExtents(fmin, fmax);
-        PianoScale().paintPianoVertical
-            (v, paint, QRect(w, 0, 10, h), fmin, fmax);
-        paint.drawLine(w + 10, 0, w + 10, h);
+                       getScaleUnits());
     }
 }
 
 void
 TimeValueLayer::drawStart(View *v, QMouseEvent *e)

     ItemEditDialog *dialog = new ItemEditDialog
         (m_model->getSampleRate(),
          ItemEditDialog::ShowTime |
          ItemEditDialog::ShowValue |
          ItemEditDialog::ShowText,
-         m_model->getScaleUnits());
+         getScaleUnits());
 
     dialog->setFrameTime(point.frame);
     dialog->setValue(point.value);
     dialog->setText(point.label);