comparison layer/SliceLayer.cpp @ 538:3bf74851d93e

* A few minor fixes to SliceLayer based on using it for slices of key plots

-
 /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
 
 /*
     Sonic Visualiser
     An audio file viewer and annotation editor.

     switch (m_energyScale) {
 
     case dBScale:
     {
         float db = thresh;
-        if (value > 0.f) db = 10.f * log10f(value);
+        if (value > 0.f) db = 10.f * log10f(fabsf(value));
         if (db < thresh) db = thresh;
         norm = (db - thresh) / -thresh;
         y = yorigin - (float(h) * norm);
         break;
     }

         y = AudioLevel::multiplier_to_preview(value, h);
         norm = float(y) / float(h);
         y = yorigin - y;
         break;
         
+    case AbsoluteScale:
+        value = fabsf(value);
+        // and fall through
+        
     default:
-//        std::cerr << "thresh = " << m_threshold << std::endl;
-        norm = (fabsf(value) - m_threshold);
+        norm = (value - m_threshold);
         if (norm < 0) norm = 0;
         y = yorigin - (float(h) * norm);
         break;
     }
     

     }
 
     case MeterScale:
         value = AudioLevel::preview_to_multiplier(lrintf(y), h);
         break;
-
+    
     default:
         value = y / h + m_threshold;
     }
 
     return value / m_gain;

     if (!m_sliceableModel || !m_sliceableModel->isOK() ||
         !m_sliceableModel->isReady()) return;
 
     paint.save();
     paint.setRenderHint(QPainter::Antialiasing, false);
+    paint.setBrush(Qt::NoBrush);
 
     if (v->getViewManager() && v->getViewManager()->shouldShowScaleGuides()) {
         if (!m_scalePoints.empty()) {
             paint.setPen(QColor(240, 240, 240)); //!!! and dark background?
             for (size_t i = 0; i < m_scalePoints.size(); ++i) {

 }
 
 int
 SliceLayer::getVerticalScaleWidth(View *, QPainter &paint) const
 {
-    if (m_energyScale == LinearScale) {
+    if (m_energyScale == LinearScale || m_energyScale == AbsoluteScale) {
 	return std::max(paint.fontMetrics().width("0.0") + 13,
                         paint.fontMetrics().width("x10-10"));
     } else {
 	return std::max(paint.fontMetrics().width(tr("0dB")),
 			paint.fontMetrics().width(tr("-Inf"))) + 13;

 
 void
 SliceLayer::paintVerticalScale(View *v, QPainter &paint, QRect rect) const
 {
     float thresh = m_threshold;
-    if (m_energyScale != LinearScale) {
+    if (m_energyScale != LinearScale && m_energyScale != AbsoluteScale) {
         thresh = AudioLevel::dB_to_multiplier(getThresholdDb());
     }
     
 //    int h = (rect.height() * 3) / 4;
 //    int y = (rect.height() / 2) - (h / 2);

 
 Layer::PropertyList
 SliceLayer::getProperties() const
 {
     PropertyList list = SingleColourLayer::getProperties();
+    list.push_back("Bin Scale");
     list.push_back("Plot Type");
-//    list.push_back("Sampling Mode");
     list.push_back("Scale");
     list.push_back("Normalize");
     list.push_back("Threshold");
     list.push_back("Gain");
-    list.push_back("Bin Scale");
 
     return list;
 }
 
 QString

     if (name == "Scale") return tr("Scale");
     if (name == "Normalize") return tr("Normalize");
     if (name == "Threshold") return tr("Threshold");
     if (name == "Gain") return tr("Gain");
     if (name == "Sampling Mode") return tr("Sampling Mode");
-    if (name == "Bin Scale") return tr("Plot X Scale");
+    if (name == "Bin Scale") return tr("Bin Scale");
     return SingleColourLayer::getPropertyLabel(name);
 }
 
 QString
 SliceLayer::getPropertyIconName(const PropertyName &name) const

         name == "Normalize" ||
         name == "Sampling Mode" ||
         name == "Threshold" ||
         name == "Gain") return tr("Scale");
     if (name == "Plot Type" ||
-        name == "Bin Scale") return tr("Plot Type");
+        name == "Bin Scale") return tr("Bins");
     return SingleColourLayer::getPropertyGroupName(name);
 }
 
 int
 SliceLayer::getPropertyRangeAndValue(const PropertyName &name,

         val = m_colourMap;
 
     } else if (name == "Scale") {
 
 	*min = 0;
-	*max = 2;
+	*max = 3;
         *deflt = (int)dBScale;
 
 	val = (int)m_energyScale;
 
     } else if (name == "Sampling Mode") {

     if (name == "Scale") {
 	switch (value) {
 	default:
 	case 0: return tr("Linear");
 	case 1: return tr("Meter");
-	case 2: return tr("dB");
+	case 2: return tr("Log");
+	case 3: return tr("Absolute");
 	}
     }
     if (name == "Sampling Mode") {
 	switch (value) {
 	default:

 	}
     }
     if (name == "Bin Scale") {
 	switch (value) {
 	default:
-	case 0: return tr("Linear Bins");
-	case 1: return tr("Log Bins");
-	case 2: return tr("Rev Log Bins");
+	case 0: return tr("Linear");
+	case 1: return tr("Log");
+	case 2: return tr("Rev Log");
 	}
     }
     return SingleColourLayer::getPropertyValueLabel(name, value);
 }
 

 	switch (value) {
 	default:
 	case 0: setEnergyScale(LinearScale); break;
 	case 1: setEnergyScale(MeterScale); break;
 	case 2: setEnergyScale(dBScale); break;
+	case 3: setEnergyScale(AbsoluteScale); break;
 	}
     } else if (name == "Plot Type") {
 	setPlotStyle(PlotStyle(value));
     } else if (name == "Sampling Mode") {
 	switch (value) {