comparison layer/FlexiNoteLayer.cpp @ 702:ceb9a2992d96 tonioni

Merge from default branch

 #include "base/Pitch.h"
 #include "base/LogRange.h"
 #include "base/RangeMapper.h"
 #include "ColourDatabase.h"
 #include "view/View.h"
+
 #include "PianoScale.h"
+#include "LinearNumericalScale.h"
+#include "LogNumericalScale.h"
 
 #include "data/model/FlexiNoteModel.h"
 
 #include "widgets/ItemEditDialog.h"
+#include "widgets/TextAbbrev.h"
 
 #include <QPainter>
 #include <QPainterPath>
 #include <QMouseEvent>
 #include <QTextStream>

         return tr("Scale");
     }
     return SingleColourLayer::getPropertyGroupName(name);
 }
 
+QString
+NoteLayer::getScaleUnits() const
+{
+    if (m_model) return m_model->getScaleUnits();
+    else return "";
+}
+
 int
 FlexiNoteLayer::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 {
 
     val = SingleColourLayer::getPropertyRangeAndValue(name, min, max, deflt);

 }
 
 bool
 FlexiNoteLayer::shouldConvertMIDIToHz() const
 {
-    QString unit = m_model->getScaleUnits();
+    QString unit = getScaleUnits();
     return (unit != "Hz");
 //    if (unit == "" ||
 //        unit.startsWith("MIDI") ||
 //        unit.startsWith("midi")) return true;
 //    return false;

 
     if (shouldConvertMIDIToHz()) {
         unit = "Hz";
         min = Pitch::getFrequencyForPitch(lrintf(min));
         max = Pitch::getFrequencyForPitch(lrintf(max + 1));
-    } else unit = m_model->getScaleUnits();
+    } else unit = getScaleUnits();
 
     if (m_verticalScale == MIDIRangeScale ||
         m_verticalScale == LogScale) logarithmic = true;
 
     return true;

         pitchText = tr("%1 (%2, %3 Hz)")
             .arg(Pitch::getPitchLabel(mnote, cents))
             .arg(mnote)
             .arg(freq);
 
-    } else if (m_model->getScaleUnits() == "Hz") {
+    } else if (getScaleUnits() == "Hz") {
 
         pitchText = tr("%1 Hz (%2, %3)")
             .arg(note.value)
             .arg(Pitch::getPitchLabelForFrequency(note.value))
             .arg(Pitch::getPitchForFrequency(note.value));
 
     } else {
         pitchText = tr("%1 %2")
-            .arg(note.value).arg(m_model->getScaleUnits());
+            .arg(note.value).arg(getScaleUnits());
     }
 
     QString text;
 
     if (note.label == "") {

     max = 0.0;
     log = false;
 
     QString queryUnits;
     if (shouldConvertMIDIToHz()) queryUnits = "Hz";
-    else queryUnits = m_model->getScaleUnits();
+    else queryUnits = getScaleUnits();
 
     if (shouldAutoAlign()) {
 
         if (!v->getValueExtents(queryUnits, min, max, log)) {
 

 
     paint.restore();
 }
 
 int
-FlexiNoteLayer::getVerticalScaleWidth(View *, bool, QPainter &paint) const
-{
-    if (m_verticalScale == LinearScale ||
-        m_verticalScale == AutoAlignScale) {
+FlexiNoteLayer::getVerticalScaleWidth(View *v, bool, QPainter &paint) const
+{
+    if (!m_model || shouldAutoAlign()) {
         return 0;
+    } else  {
+        if (m_verticalScale == LogScale || m_verticalScale == MIDIRangeScale) {
+            return LogNumericalScale().getWidth(v, paint) + 10; // for piano
+        } else {
+            return LinearNumericalScale().getWidth(v, paint);
+        }
+    }
+}
+
+void
+FlexiNoteLayer::paintVerticalScale(View *v, bool, QPainter &paint, QRect) const
+{
+    if (!m_model) return;
+
+    QString unit;
+    float min, max;
+    bool logarithmic;
+
+    int w = getVerticalScaleWidth(v, false, paint);
+    int h = v->height();
+
+    getScaleExtents(v, min, max, logarithmic);
+
+    if (logarithmic) {
+        LogNumericalScale().paintVertical(v, this, paint, 0, min, max);
     } else {
-        return 10;
-    }
-}
-
-void
-FlexiNoteLayer::paintVerticalScale(View *v, bool, QPainter &paint, QRect) const
-{
-    if (m_verticalScale == LinearScale ||
-        m_verticalScale == AutoAlignScale) {
-        return;
-    } else {
-        float fmin, fmax;
-        bool log;
-        QString unit;
-        if (!getValueExtents(fmin, fmax, log, unit)) return;
+        LinearNumericalScale().paintVertical(v, this, paint, 0, min, max);
+    }
+    
+    if (logarithmic && (getScaleUnits() == "Hz")) {
         PianoScale().paintPianoVertical
-            (v, paint, QRect(0, 0, 10, v->height()), fmin, fmax);
-        paint.drawLine(10, 0, 10, v->height());
+            (v, paint, QRect(w - 10, 0, 10, h), 
+             LogRange::unmap(min), 
+             LogRange::unmap(max));
+        paint.drawLine(w, 0, w, h);
+    }
+        
+    if (getScaleUnits() != "") {
+        int mw = w - 5;
+        paint.drawText(5,
+                       5 + paint.fontMetrics().ascent(),
+                       TextAbbrev::abbreviate(getScaleUnits(),
+                                              paint.fontMetrics(),
+                                              mw));
     }
 }
 
 void
 FlexiNoteLayer::drawStart(View *v, QMouseEvent *e)

         (m_model->getSampleRate(),
          ItemEditDialog::ShowTime |
          ItemEditDialog::ShowDuration |
          ItemEditDialog::ShowValue |
          ItemEditDialog::ShowText,
-         m_model->getScaleUnits());
+         getScaleUnits());
 
     dialog->setFrameTime(note.frame);
     dialog->setValue(note.value);
     dialog->setFrameDuration(note.duration);
     dialog->setText(note.label);