comparison src/Analyser.cpp @ 573:5c14493026da by-id

ModelById updates

 }
 
 void
 Analyser::layerCompletionChanged()
 {
-    if (getInitialAnalysisCompletion() == 100) {
-
-        emit initialAnalysisCompleted();
-
-        if (m_layers[Audio]) {
-
-            // Extend pitch-track and note layers so as to nominally
-            // end at the same time as the audio. This affects any
-            // time-filling done on export etc.
-            
-            sv_frame_t endFrame = m_layers[Audio]->getModel()->getEndFrame();
+    if (getInitialAnalysisCompletion() < 100) {
+        return;
+    }
+
+    emit initialAnalysisCompleted();
+
+    if (!m_layers[Audio]) {
+        return;
+    }
+
+    // Extend pitch-track and note layers so as to nominally end at
+    // the same time as the audio. This affects any time-filling done
+    // on export etc.
+
+    auto audioModel = ModelById::get(m_layers[Audio]->getModel());
+    sv_frame_t endFrame = audioModel->getEndFrame();
         
-            if (m_layers[PitchTrack]) {
-                SparseTimeValueModel *model = qobject_cast<SparseTimeValueModel *>
-                    (m_layers[PitchTrack]->getModel());
-                if (model) {
-                    model->extendEndFrame(endFrame);
-                }
-            }
-            if (m_layers[Notes]) {
-                NoteModel *model = qobject_cast<NoteModel *>
-                    (m_layers[Notes]->getModel());
-                if (model) {
-                    model->extendEndFrame(endFrame);
-                }
-            }
+    if (m_layers[PitchTrack]) {
+        auto model = ModelById::getAs<SparseTimeValueModel>
+            (m_layers[PitchTrack]->getModel());
+        if (model) {
+            model->extendEndFrame(endFrame);
+        }
+    }
+
+    if (m_layers[Notes]) {
+        auto model = ModelById::getAs<NoteModel>
+            (m_layers[Notes]->getModel());
+        if (model) {
+            model->extendEndFrame(endFrame);
         }
     }
 }
 
 QString

 
     waveform->setMiddleLineHeight(0.9);
     waveform->setShowMeans(false); // too small & pale for this
     waveform->setBaseColour
         (ColourDatabase::getInstance()->getColourIndex(tr("Grey")));
-    PlayParameters *params = waveform->getPlayParameters();
+    auto params = waveform->getPlayParameters();
     if (params) {
         params->setPlayPan(-1);
         params->setPlayGain(1);
     }
     

     
     TimeValueLayer *pitchLayer = 
         qobject_cast<TimeValueLayer *>(m_layers[PitchTrack]);
     if (pitchLayer) {
         pitchLayer->setBaseColour(cdb->getColourIndex(tr("Black")));
-        PlayParameters *params = pitchLayer->getPlayParameters();
+        auto params = pitchLayer->getPlayParameters();
         if (params) {
             params->setPlayPan(1);
             params->setPlayGain(0.5);
         }
         connect(pitchLayer, SIGNAL(modelCompletionChanged()),

     
     FlexiNoteLayer *flexiNoteLayer = 
         qobject_cast<FlexiNoteLayer *>(m_layers[Notes]);
     if (flexiNoteLayer) {
         flexiNoteLayer->setBaseColour(cdb->getColourIndex(tr("Bright Blue")));
-        PlayParameters *params = flexiNoteLayer->getPlayParameters();
+        auto params = flexiNoteLayer->getPlayParameters();
         if (params) {
             params->setPlayPan(1);
             params->setPlayGain(0.5);
         }
         connect(flexiNoteLayer, SIGNAL(modelCompletionChanged()),

     t.setDuration(duration);
 
     transforms.push_back(t);
     
     m_currentAsyncHandle =
-        m_document->createDerivedLayersAsync(transforms, ModelId, this);
+        m_document->createDerivedLayersAsync(transforms, m_fileModel, this);
 
     return "";
 }
 
 bool

         }
 
         for (int i = 0; i < (int)all.size(); ++i) {
             TimeValueLayer *t = qobject_cast<TimeValueLayer *>(all[i]);
             if (t) {
-                PlayParameters *params = t->getPlayParameters();
+                auto params = t->getPlayParameters();
                 if (params) {
                     params->setPlayAudible(false);
                 }
                 t->setBaseColour
                     (ColourDatabase::getInstance()->getColourIndex(tr("Bright Orange")));

 
 void
 Analyser::takePitchTrackFrom(Layer *otherLayer)
 {
     Layer *myLayer = m_layers[PitchTrack];
-    if (!myLayer) return;
+    if (!myLayer || !otherLayer) return;
+
+    auto myModel = ModelById::get(myLayer->getModel());
+    auto otherModel = ModelById::get(otherLayer->getModel());
+    if (!myModel || !otherModel) return;
 
     Clipboard clip;
-
-    Selection sel = Selection(myLayer->getModel()->getStartFrame(),
-                              myLayer->getModel()->getEndFrame());
+    
+    Selection sel = Selection(myModel->getStartFrame(),
+                              myModel->getEndFrame());
     myLayer->deleteSelection(sel);
 
-    sel = Selection(otherLayer->getModel()->getStartFrame(),
-                    otherLayer->getModel()->getEndFrame());
+    sel = Selection(otherModel->getStartFrame(),
+                    otherModel->getEndFrame());
     otherLayer->copy(m_pane, sel, clip);
 
     // Remove all pitches <= 0Hz -- we now save absent pitches as 0Hz
     // values when exporting a pitch track, so we need to exclude them
     // here when importing again

 
 bool
 Analyser::isAudible(Component c) const
 {
     if (m_layers[c]) {
-        PlayParameters *params = m_layers[c]->getPlayParameters();
+        auto params = m_layers[c]->getPlayParameters();
         if (!params) return false;
         return params->isPlayAudible();
     } else {
         return false;
     }

 
 void
 Analyser::setAudible(Component c, bool a)
 {
     if (m_layers[c]) {
-        PlayParameters *params = m_layers[c]->getPlayParameters();
+        auto params = m_layers[c]->getPlayParameters();
         if (!params) return;
         params->setPlayAudible(a);
         saveState(c);
     }
 }
 
 float
 Analyser::getGain(Component c) const
 {
     if (m_layers[c]) {
-        PlayParameters *params = m_layers[c]->getPlayParameters();
+        auto params = m_layers[c]->getPlayParameters();
         if (!params) return 1.f;
         return params->getPlayGain();
     } else {
         return 1.f;
     }

     
 void
 Analyser::setGain(Component c, float gain)
 {
     if (m_layers[c]) {
-        PlayParameters *params = m_layers[c]->getPlayParameters();
+        auto params = m_layers[c]->getPlayParameters();
         if (!params) return;
         params->setPlayGain(gain);
         saveState(c);
     }
 }
 
 float
 Analyser::getPan(Component c) const
 {
     if (m_layers[c]) {
-        PlayParameters *params = m_layers[c]->getPlayParameters();
+        auto params = m_layers[c]->getPlayParameters();
         if (!params) return 1.f;
         return params->getPlayPan();
     } else {
         return 1.f;
     }

     
 void
 Analyser::setPan(Component c, float pan)
 {
     if (m_layers[c]) {
-        PlayParameters *params = m_layers[c]->getPlayParameters();
+        auto params = m_layers[c]->getPlayParameters();
         if (!params) return;
         params->setPlayPan(pan);
         saveState(c);
     }
 }