comparison layer/SpectrogramLayer.cpp @ 1414:fa986b91d77f

Merge from branch fix-static-analysis

 //#define DEBUG_SPECTROGRAM_REPAINT 1
 
 using namespace std;
 
 SpectrogramLayer::SpectrogramLayer(Configuration config) :
-    m_model(0),
+    m_model(nullptr),
     m_channel(0),
     m_windowSize(1024),
     m_windowType(HanningWindow),
     m_windowHopLevel(2),
     m_oversampling(1),

     m_normalizeVisibleArea(false),
     m_lastEmittedZoomStep(-1),
     m_synchronous(false),
     m_haveDetailedScale(false),
     m_exiting(false),
-    m_fftModel(0),
-    m_wholeCache(0),
-    m_peakCache(0),
+    m_fftModel(nullptr),
+    m_wholeCache(nullptr),
+    m_peakCache(nullptr),
     m_peakCacheDivisor(8)
 {
     QString colourConfigName = "spectrogram-colour";
     int colourConfigDefault = int(ColourMapper::Green);
     

 
     delete m_fftModel;
     delete m_peakCache;
     delete m_wholeCache;
 
-    m_fftModel = 0;
-    m_peakCache = 0;
-    m_wholeCache = 0;
+    m_fftModel = nullptr;
+    m_peakCache = nullptr;
+    m_wholeCache = nullptr;
 }
 
 pair<ColourScaleType, double>
 SpectrogramLayer::convertToColourScale(int value)
 {

     }
     if (name == "Threshold") {
         return new LinearRangeMapper(-81, -1, -81, -1, tr("dB"), false,
                                      { { -81, Strings::minus_infinity } });
     }
-    return 0;
+    return nullptr;
 }
 
 void
 SpectrogramLayer::setProperty(const PropertyName &name, int value)
 {

 SpectrogramLayer::recreateFFTModel()
 {
     SVDEBUG << "SpectrogramLayer::recreateFFTModel called" << endl;
 
     if (!m_model || !m_model->isOK()) {
-        emit sliceableModelReplaced(m_fftModel, 0);
+        emit sliceableModelReplaced(m_fftModel, nullptr);
         deleteDerivedModels();
         return;
     }
 
     if (m_fftModel) m_fftModel->aboutToDelete();
     
     if (m_peakCache) m_peakCache->aboutToDelete();
     delete m_peakCache;
-    m_peakCache = 0;
+    m_peakCache = nullptr;
 
     if (m_wholeCache) m_wholeCache->aboutToDelete();
     delete m_wholeCache;
-    m_wholeCache = 0;
+    m_wholeCache = nullptr;
     
     FFTModel *newModel = new FFTModel(m_model,
                                       m_channel,
                                       m_windowType,
                                       m_windowSize,
                                       getWindowIncrement(),
                                       getFFTSize());
 
     if (!newModel->isOK()) {
         QMessageBox::critical
-            (0, tr("FFT cache failed"),
+            (nullptr, tr("FFT cache failed"),
              tr("Failed to create the FFT model for this spectrogram.\n"
                 "There may be insufficient memory or disc space to continue."));
         delete newModel;
         delete m_fftModel;
-        m_fftModel = 0;
+        m_fftModel = nullptr;
         return;
     }
 
     FFTModel *oldModel = m_fftModel;
     m_fftModel = newModel;

 {
 public:
     SpectrogramRangeMapper(sv_samplerate_t sr, int /* fftsize */) :
         m_dist(sr / 2),
         m_s2(sqrt(sqrt(2))) { }
-    ~SpectrogramRangeMapper() { }
-    
-    virtual int getPositionForValue(double value) const {
+    ~SpectrogramRangeMapper() override { }
+    
+    int getPositionForValue(double value) const override {
 
         double dist = m_dist;
     
         int n = 0;
 

         }
 
         return n;
     }
     
-    virtual int getPositionForValueUnclamped(double value) const {
+    int getPositionForValueUnclamped(double value) const override {
         // We don't really support this
         return getPositionForValue(value);
     }
 
-    virtual double getValueForPosition(int position) const {
+    double getValueForPosition(int position) const override {
 
         // Vertical zoom step 0 shows the entire range from DC ->
         // Nyquist frequency.  Step 1 shows 2^(1/4) of the range of
         // step 0, and so on until the visible range is smaller than
         // the frequency step between bins at the current fft size.

         }
 
         return dist;
     }
     
-    virtual double getValueForPositionUnclamped(int position) const {
+    double getValueForPositionUnclamped(int position) const override {
         // We don't really support this
         return getValueForPosition(position);
     }
 
-    virtual QString getUnit() const { return "Hz"; }
+    QString getUnit() const override { return "Hz"; }
 
 protected:
     double m_dist;
     double m_s2;
 };

 }
 
 RangeMapper *
 SpectrogramLayer::getNewVerticalZoomRangeMapper() const
 {
-    if (!m_model) return 0;
+    if (!m_model) return nullptr;
     return new SpectrogramRangeMapper(m_model->getSampleRate(), getFFTSize());
 }
 
 void
 SpectrogramLayer::updateMeasureRectYCoords(LayerGeometryProvider *v, const MeasureRect &r) const