comparison layer/TimeValueLayer.cpp @ 1408:c8a6fd3f9dff fix-static-analysis

Use nullptr throughout

 
 //#define DEBUG_TIME_VALUE_LAYER 1
 
 TimeValueLayer::TimeValueLayer() :
     SingleColourLayer(),
-    m_model(0),
+    m_model(nullptr),
     m_editing(false),
     m_originalPoint(0, 0.0, tr("New Point")),
     m_editingPoint(0, 0.0, tr("New Point")),
-    m_editingCommand(0),
+    m_editingCommand(nullptr),
     m_colourMap(0),
     m_colourInverted(false),
     m_plotStyle(PlotConnectedPoints),
     m_verticalScale(AutoAlignScale),
     m_drawSegmentDivisions(true),

 }
 
 RangeMapper *
 TimeValueLayer::getNewVerticalZoomRangeMapper() const
 {
-    if (!m_model) return 0;
+    if (!m_model) return nullptr;
     
     RangeMapper *mapper;
 
     double min, max;
     bool logarithmic;
     QString unit;
     getValueExtents(min, max, logarithmic, unit);
 
-    if (min == max) return 0;
+    if (min == max) return nullptr;
     
     if (logarithmic) {
         mapper = new LogRangeMapper(0, 100, min, max, unit);
     } else {
         mapper = new LinearRangeMapper(0, 100, min, max, unit);

 #ifdef DEBUG_TIME_VALUE_LAYER
     cerr << "TimeValueLayer::drawEnd" << endl;
 #endif
     if (!m_model || !m_editing) return;
     finish(m_editingCommand);
-    m_editingCommand = 0;
+    m_editingCommand = nullptr;
     m_editing = false;
 }
 
 void
 TimeValueLayer::eraseStart(LayerGeometryProvider *v, QMouseEvent *e)

 
     m_editingPoint = *points.begin();
 
     if (m_editingCommand) {
         finish(m_editingCommand);
-        m_editingCommand = 0;
+        m_editingCommand = nullptr;
     }
 
     m_editing = true;
 }
 

         (m_model, tr("Erase Point"));
 
     m_editingCommand->deletePoint(m_editingPoint);
 
     finish(m_editingCommand);
-    m_editingCommand = 0;
+    m_editingCommand = nullptr;
     m_editing = false;
 }
 
 void
 TimeValueLayer::editStart(LayerGeometryProvider *v, QMouseEvent *e)

     m_editingPoint = *points.begin();
     m_originalPoint = m_editingPoint;
 
     if (m_editingCommand) {
         finish(m_editingCommand);
-        m_editingCommand = 0;
+        m_editingCommand = nullptr;
     }
 
     m_editing = true;
 }
 

 
         m_editingCommand->setName(newName);
         finish(m_editingCommand);
     }
 
-    m_editingCommand = 0;
+    m_editingCommand = nullptr;
     m_editing = false;
 }
 
 bool
 TimeValueLayer::editOpen(LayerGeometryProvider *v, QMouseEvent *e)

 
             static int prevSelection = 0;
 
             bool ok = false;
             QString selected = ListInputDialog::getItem
-                (0, tr("Choose value calculation"),
+                (nullptr, tr("Choose value calculation"),
                  text, options, prevSelection, &ok);
 
             if (!ok) {
                 delete command;
                 return false;

             labeller.setType(generation);
 
             if (generation == Labeller::ValueFromCyclicalCounter ||
                 generation == Labeller::ValueFromTwoLevelCounter) {
                 int cycleSize = QInputDialog::getInt
-                    (0, tr("Select cycle size"),
+                    (nullptr, tr("Select cycle size"),
                      tr("Cycle size:"), 4, 2, 16, 1);
                 labeller.setCounterCycleSize(cycleSize);
             }
 
             prevSelection = selection;

             } else {
                 cerr << ", prev point is at " << prevPoint.frame << endl;
             }
 #endif
             labeller.setValue<SparseTimeValueModel::Point>
-                (newPoint, (i == points.begin()) ? 0 : &prevPoint);
+                (newPoint, (i == points.begin()) ? nullptr : &prevPoint);
 #ifdef DEBUG_TIME_VALUE_LAYER
             cerr << "New point value = " << newPoint.value << endl;
 #endif
             if (labeller.actingOnPrevPoint() && i != points.begin()) {
                 usePrev = true;