comparison framework/MainWindowBase.cpp @ 644:6fd0ebfd2bbe

Merge from branch fix-static-analysis

 }
 #undef Window
 #endif
 
 MainWindowBase::MainWindowBase(SoundOptions options) :
-    m_document(0),
-    m_paneStack(0),
-    m_viewManager(0),
-    m_timeRulerLayer(0),
+    m_document(nullptr),
+    m_paneStack(nullptr),
+    m_viewManager(nullptr),
+    m_timeRulerLayer(nullptr),
     m_soundOptions(options),
-    m_playSource(0),
-    m_recordTarget(0),
-    m_resamplerWrapper(0),
-    m_playTarget(0),
-    m_audioIO(0),
-    m_oscQueue(0),
-    m_oscQueueStarter(0),
-    m_midiInput(0),
+    m_playSource(nullptr),
+    m_recordTarget(nullptr),
+    m_resamplerWrapper(nullptr),
+    m_playTarget(nullptr),
+    m_audioIO(nullptr),
+    m_oscQueue(nullptr),
+    m_oscQueueStarter(nullptr),
+    m_midiInput(nullptr),
     m_recentFiles("RecentFiles", 20),
     m_recentTransforms("RecentTransforms", 20),
     m_documentModified(false),
     m_openingAudioFile(false),
     m_abandoning(false),
-    m_labeller(0),
+    m_labeller(nullptr),
     m_lastPlayStatusSec(0),
     m_initialDarkBackground(false),
     m_defaultFfwdRwdStep(2, 0),
     m_audioRecordMode(RecordCreateAdditionalModel),
-    m_statusLabel(0),
+    m_statusLabel(nullptr),
     m_iconsVisibleInMenus(true),
-    m_menuShortcutMapper(0)
+    m_menuShortcutMapper(nullptr)
 {
     Profiler profiler("MainWindowBase::MainWindowBase");
 
     SVDEBUG << "MainWindowBase::MainWindowBase" << endl;
 

         m_viewManager->setGlobalDarkBackground
             (mode == Preferences::DarkBackground);
     }
 #endif
 
-    m_paneStack = new PaneStack(0, m_viewManager);
+    m_paneStack = new PaneStack(nullptr, m_viewManager);
     connect(m_paneStack, SIGNAL(currentPaneChanged(Pane *)),
             this, SLOT(currentPaneChanged(Pane *)));
     connect(m_paneStack, SIGNAL(currentLayerChanged(Pane *, Layer *)),
             this, SLOT(currentLayerChanged(Pane *, Layer *)));
     connect(m_paneStack, SIGNAL(rightButtonMenuRequested(Pane *, QPoint)),

     
     delete m_viewManager;
     delete m_midiInput;
 
     if (m_oscQueueStarter) {
-        disconnect(m_oscQueueStarter, 0, 0, 0);
+        disconnect(m_oscQueueStarter, nullptr, nullptr, nullptr);
         m_oscQueueStarter->wait(1000);
         if (m_oscQueueStarter->isRunning()) {
             m_oscQueueStarter->terminate();
             m_oscQueueStarter->wait(1000);
         }

 MainWindowBase::finaliseMenus()
 {
     SVDEBUG << "MainWindowBase::finaliseMenus called" << endl;
 
     delete m_menuShortcutMapper;
-    m_menuShortcutMapper = 0;
+    m_menuShortcutMapper = nullptr;
 
     foreach (QShortcut *sc, m_appShortcuts) {
         delete sc;
     }
     m_appShortcuts.clear();

 MainWindowBase::getOpenFileName(FileFinder::FileType type)
 {
     FileFinder *ff = FileFinder::getInstance();
 
     if (type == FileFinder::AnyFile) {
-        if (getMainModel() != 0 &&
-            m_paneStack != 0 &&
-            m_paneStack->getCurrentPane() != 0) { // can import a layer
+        if (getMainModel() != nullptr &&
+            m_paneStack != nullptr &&
+            m_paneStack->getCurrentPane() != nullptr) { // can import a layer
             return ff->getOpenFileName(FileFinder::AnyFile, m_sessionFile);
         } else {
             return ff->getOpenFileName(FileFinder::SessionOrAudioFile,
                                        m_sessionFile);
         }

 }    
 
 void
 MainWindowBase::updateMenuStates()
 {
-    Pane *currentPane = 0;
-    Layer *currentLayer = 0;
+    Pane *currentPane = nullptr;
+    Layer *currentLayer = nullptr;
 
     if (m_paneStack) currentPane = m_paneStack->getCurrentPane();
     if (currentPane) currentLayer = currentPane->getSelectedLayer();
 
     bool havePrevPane = false, haveNextPane = false;

             haveNextLayer = true;
         }
     }        
 
     bool haveCurrentPane =
-        (currentPane != 0);
+        (currentPane != nullptr);
     bool haveCurrentLayer =
         (haveCurrentPane &&
-         (currentLayer != 0));
+         (currentLayer != nullptr));
     bool haveMainModel =
-        (getMainModel() != 0);
+        (getMainModel() != nullptr);
     bool havePlayTarget =
-        (m_playTarget != 0 || m_audioIO != 0);
+        (m_playTarget != nullptr || m_audioIO != nullptr);
     bool haveSelection = 
         (m_viewManager &&
          !m_viewManager->getSelections().empty());
     bool haveCurrentEditableLayer =
         (haveCurrentLayer &&

     }
 
     if (m_viewManager->getPlaySoloMode()) {
         currentPaneChanged(m_paneStack->getCurrentPane());
     } else {
-        m_viewManager->setPlaybackModel(0);
+        m_viewManager->setPlaybackModel(nullptr);
         if (m_playSource) {
             m_playSource->clearSoloModelSet();
         }
     }
 }

     if (!p) return;
 
     if (!(m_viewManager &&
           m_playSource &&
           m_viewManager->getPlaySoloMode())) {
-        if (m_viewManager) m_viewManager->setPlaybackModel(0);
+        if (m_viewManager) m_viewManager->setPlaybackModel(nullptr);
         return;
     }
 
     Model *prevPlaybackModel = m_viewManager->getPlaybackModel();
 

                 if (m_labeller->actingOnPrevPoint() && havePrevPoint) {
                     command->deletePoint(prevPoint);
                 }
 
                 m_labeller->label<SparseOneDimensionalModel::Point>
-                    (point, havePrevPoint ? &prevPoint : 0);
+                    (point, havePrevPoint ? &prevPoint : nullptr);
 
                 if (m_labeller->actingOnPrevPoint() && havePrevPoint) {
                     command->addPoint(prevPoint);
                 }
             }

     sv_frame_t alignedStart = pane->alignFromReference(frame);
     sv_frame_t alignedEnd = pane->alignFromReference(frame + duration);
     if (alignedStart >= alignedEnd) return;
     sv_frame_t alignedDuration = alignedEnd - alignedStart;
 
-    Command *c = 0;
+    Command *c = nullptr;
 
     QString name = tr("Add Item at %1 s")
         .arg(RealTime::frame2RealTime
              (alignedStart,
               getMainModel()->getSampleRate())

     FileOpenStatus status;
 
     if (!source.isAvailable()) return FileOpenFailed;
     source.waitForData();
 
-    bool canImportLayer = (getMainModel() != 0 &&
-                           m_paneStack != 0 &&
-                           m_paneStack->getCurrentPane() != 0);
+    bool canImportLayer = (getMainModel() != nullptr &&
+                           m_paneStack != nullptr &&
+                           m_paneStack->getCurrentPane() != nullptr);
 
     bool rdf = (source.getExtension().toLower() == "rdf" ||
                 source.getExtension().toLower() == "n3" ||
                 source.getExtension().toLower() == "ttl");
 

         // the current pane does not contain the main model, otherwise
         // we would have reset it to ReplaceMainModel.  But we don't
         // know whether the pane contains a waveform model at all.
         
         Pane *pane = m_paneStack->getCurrentPane();
-        Layer *replace = 0;
+        Layer *replace = nullptr;
 
         for (int i = 0; i < pane->getLayerCount(); ++i) {
             Layer *layer = pane->getLayer(i);
             if (dynamic_cast<WaveformLayer *>(layer)) {
                 replace = layer;

         } else {
             return FileOpenFailed;
         }
     }
 
-    QXmlInputSource *inputSource = 0;
-    BZipFileDevice *bzFile = 0;
-    QFile *rawFile = 0;
+    QXmlInputSource *inputSource = nullptr;
+    BZipFileDevice *bzFile = nullptr;
+    QFile *rawFile = nullptr;
 
     if (source.getExtension().toLower() == sessionExt) {
         bzFile = new BZipFileDevice(source.getLocalFilename());
         if (!bzFile->open(QIODevice::ReadOnly)) {
             delete bzFile;

     cerr << "MainWindowBase::openSessionTemplate(" << source.getLocation() << ")" << endl;
 
     if (!source.isAvailable()) return FileOpenFailed;
     source.waitForData();
 
-    QXmlInputSource *inputSource = 0;
-    QFile *file = 0;
+    QXmlInputSource *inputSource = nullptr;
+    QFile *file = nullptr;
 
     file = new QFile(source.getLocalFilename());
     inputSource = new QXmlInputSource(file);
 
     if (!checkSaveModified()) {

         WaveFileModel *w = dynamic_cast<WaveFileModel *>(m);
 
         if (w) {
 
             Pane *pane = addPaneToStack();
-            Layer *layer = 0;
+            Layer *layer = nullptr;
 
             if (m_timeRulerLayer) {
                 m_document->addLayerToView(pane, m_timeRulerLayer);
             }
 

 void
 MainWindowBase::deleteAudioIO()
 {
     // First prevent this trying to call target.
     if (m_playSource) {
-        m_playSource->setSystemPlaybackTarget(0);
-        m_playSource->setResamplerWrapper(0);
+        m_playSource->setSystemPlaybackTarget(nullptr);
+        m_playSource->setResamplerWrapper(nullptr);
     }
 
     // Then delete the breakfastquay::System object.
     // Only one of these two exists!
     delete m_audioIO;

     // And the breakfastquay resampler wrapper. We need to
     // delete/recreate this if the channel count changes, which is one
     // of the use cases for recreateAudioIO() calling this
     delete m_resamplerWrapper;
 
-    m_audioIO = 0;
-    m_playTarget = 0;
-    m_resamplerWrapper = 0;
+    m_audioIO = nullptr;
+    m_playTarget = nullptr;
+    m_resamplerWrapper = nullptr;
 }
 
 void
 MainWindowBase::recreateAudioIO()
 {

 }
 
 WaveFileModel *
 MainWindowBase::getMainModel()
 {
-    if (!m_document) return 0;
+    if (!m_document) return nullptr;
     return m_document->getMainModel();
 }
 
 const WaveFileModel *
 MainWindowBase::getMainModel() const
 {
-    if (!m_document) return 0;
+    if (!m_document) return nullptr;
     return m_document->getMainModel();
 }
 
 void
 MainWindowBase::createDocument()

         }
     }
     if (m_timeRulerLayer) {
         SVCERR << "WARNING: Time ruler layer was not reset to 0 before session template loaded?" << endl;
         delete m_timeRulerLayer;
-        m_timeRulerLayer = 0;
+        m_timeRulerLayer = nullptr;
     }
 }
 
 void
 MainWindowBase::toggleTimeRulers()

 
 Layer *
 MainWindowBase::getSnapLayer() const
 {
     Pane *pane = m_paneStack->getCurrentPane();
-    if (!pane) return 0;
+    if (!pane) return nullptr;
 
     Layer *layer = pane->getSelectedLayer();
 
     if (!dynamic_cast<TimeInstantLayer *>(layer) &&
         !dynamic_cast<TimeValueLayer *>(layer) &&
         !dynamic_cast<RegionLayer *>(layer) &&
         !dynamic_cast<TimeRulerLayer *>(layer)) {
 
-        layer = 0;
+        layer = nullptr;
 
         for (int i = pane->getLayerCount(); i > 0; --i) {
             Layer *l = pane->getLayer(i-1);
             if (dynamic_cast<TimeRulerLayer *>(l)) {
                 layer = l;

     }
 }
 
 MainWindowBase::AddPaneCommand::AddPaneCommand(MainWindowBase *mw) :
     m_mw(mw),
-    m_pane(0),
-    m_prevCurrentPane(0),
+    m_pane(nullptr),
+    m_prevCurrentPane(nullptr),
     m_added(false)
 {
 }
 
 MainWindowBase::AddPaneCommand::~AddPaneCommand()

 }
 
 MainWindowBase::RemovePaneCommand::RemovePaneCommand(MainWindowBase *mw, Pane *pane) :
     m_mw(mw),
     m_pane(pane),
-    m_prevCurrentPane(0),
+    m_prevCurrentPane(nullptr),
     m_added(true)
 {
 }
 
 MainWindowBase::RemovePaneCommand::~RemovePaneCommand()

 }
 
 void
 MainWindowBase::editCurrentLayer()
 {
-    Layer *layer = 0;
+    Layer *layer = nullptr;
     Pane *pane = m_paneStack->getCurrentPane();
     if (pane) layer = pane->getSelectedLayer();
     if (!layer) return;
 
     Model *model = layer->getModel();

     } else {
         for (int i = 0; i < count; ++i) {
             if (currentPane->getFixedOrderLayer(i) == currentLayer) {
                 if (i == 0) {
                     m_paneStack->setCurrentLayer
-                        (currentPane, 0); // pane
+                        (currentPane, nullptr); // pane
                 } else {
                     m_paneStack->setCurrentLayer
                         (currentPane, currentPane->getFixedOrderLayer(i-1));
                 }
                 break;

     } else {
         for (int i = 0; i < count; ++i) {
             if (currentPane->getFixedOrderLayer(i) == currentLayer) {
                 if (i == currentPane->getLayerCount()-1) {
                     m_paneStack->setCurrentLayer
-                        (currentPane, 0); // pane
+                        (currentPane, nullptr); // pane
                 } else {
                     m_paneStack->setCurrentLayer
                         (currentPane, currentPane->getFixedOrderLayer(i+1));
                 }
                 break;

 
 void
 MainWindowBase::globalCentreFrameChanged(sv_frame_t )
 {
     if ((m_playSource && m_playSource->isPlaying()) || !getMainModel()) return;
-    Pane *p = 0;
+    Pane *p = nullptr;
     if (!m_paneStack || !(p = m_paneStack->getCurrentPane())) return;
     if (!p->getFollowGlobalPan()) return;
     updateVisibleRangeDisplay(p);
 }
 

              i != m_viewDataDialogMap[v].end(); ++i) {
             (*i)->userScrolledToFrame(frame);
         }
     }
     if ((m_playSource && m_playSource->isPlaying()) || !getMainModel()) return;
-    Pane *p = 0;
+    Pane *p = nullptr;
     if (!m_paneStack || !(p = m_paneStack->getCurrentPane())) return;
     if (v == p) updateVisibleRangeDisplay(p);
 }
 
 void
 MainWindowBase::viewZoomLevelChanged(View *v, ZoomLevel, bool )
 {
     if ((m_playSource && m_playSource->isPlaying()) || !getMainModel()) return;
-    Pane *p = 0;
+    Pane *p = nullptr;
     if (!m_paneStack || !(p = m_paneStack->getCurrentPane())) return;
     if (v == p) updateVisibleRangeDisplay(p);
 }
 
 void

 
     removeLayerEditDialog(layer);
 
     if (m_timeRulerLayer && (layer == m_timeRulerLayer)) {
 //        cerr << "(this is the time ruler layer)" << endl;
-        m_timeRulerLayer = 0;
+        m_timeRulerLayer = nullptr;
     }
 }
 
 void
 MainWindowBase::layerInAView(Layer *layer, bool inAView)

 void
 MainWindowBase::modelAboutToBeDeleted(Model *model)
 {
 //    SVDEBUG << "MainWindowBase::modelAboutToBeDeleted(" << model << ")" << endl;
     if (model == m_viewManager->getPlaybackModel()) {
-        m_viewManager->setPlaybackModel(0);
+        m_viewManager->setPlaybackModel(nullptr);
     }
     m_playSource->removeModel(model);
 }
 
 void

 }
 
 void
 MainWindowBase::inProgressSelectionChanged()
 {
-    Pane *currentPane = 0;
+    Pane *currentPane = nullptr;
     if (m_paneStack) currentPane = m_paneStack->getCurrentPane();
     if (currentPane) {
         //cerr << "JTEST: mouse event on selection pane" << endl;
         updateVisibleRangeDisplay(currentPane);
     }