comparison data/model/AlignmentModel.cpp @ 1735:d91ff235e69d by-id

Some messing with Model and AlignmentModel

 
 #include "SparseTimeValueModel.h"
 
 //#define DEBUG_ALIGNMENT_MODEL 1
 
-AlignmentModel::AlignmentModel(Model *reference,
-                               Model *aligned,
-                               SparseTimeValueModel *path) :
+AlignmentModel::AlignmentModel(ModelId reference,
+                               ModelId aligned,
+                               ModelId pathSource) :
     m_reference(reference),
     m_aligned(aligned),
-    m_rawPath(path),
+    m_pathSource(pathSource),
     m_path(nullptr),
     m_reversePath(nullptr),
     m_pathBegun(false),
     m_pathComplete(false)
 {
-    if (m_rawPath) {
-
-        connect(m_rawPath, SIGNAL(modelChanged()),
-                this, SLOT(pathChanged()));
-
-        connect(m_rawPath, SIGNAL(modelChangedWithin(sv_frame_t, sv_frame_t)),
-                this, SLOT(pathChangedWithin(sv_frame_t, sv_frame_t)));
+    auto pathSourceModel = ModelById::getAs<SparseTimeValueModel>(pathSource);
+    
+    if (pathSourceModel) {
+
+        connect(pathSourceModel.get(), SIGNAL(modelChanged()),
+                this, SLOT(pathSourceChanged()));
+
+        connect(pathSourceModel.get(),
+                SIGNAL(modelChangedWithin(sv_frame_t, sv_frame_t)),
+                this, SLOT(pathSourceChangedWithin(sv_frame_t, sv_frame_t)));
         
-        connect(m_rawPath, SIGNAL(completionChanged()),
-                this, SLOT(pathCompletionChanged()));
+        connect(pathSourceModel.get(), SIGNAL(completionChanged()),
+                this, SLOT(pathSourceCompletionChanged()));
 
         constructPath();
         constructReversePath();
-    }
-
-    if (m_rawPath && m_rawPath->isReady()) {
-        pathCompletionChanged();
+
+        if (pathSourceModel->isReady()) {
+            pathSourceCompletionChanged();
+        }
     }
 
     if (m_reference == m_aligned) {
         // Trivial alignment, e.g. of main model to itself, which we
         // record so that we can distinguish the reference model for

 {
 #ifdef DEBUG_ALIGNMENT_MODEL
     SVCERR << "AlignmentModel(" << this << ")::~AlignmentModel()" << endl;
 #endif
 
-    if (m_rawPath) m_rawPath->aboutToDelete();
-    delete m_rawPath;
-
-    if (m_path) m_path->aboutToDelete();
-    delete m_path;
-
-    if (m_reversePath) m_reversePath->aboutToDelete();
-    delete m_reversePath;
+//!!!    if (m_pathSource) m_pathSource->aboutToDelete();
+//    delete m_pathSource;
+
+//    if (m_path) m_path->aboutToDelete();
+//    delete m_path;
+
+//    if (m_reversePath) m_reversePath->aboutToDelete();
+//    delete m_reversePath;
 }
 
 bool
 AlignmentModel::isOK() const
 {
     if (m_error != "") return false;
-    if (m_rawPath) return m_rawPath->isOK();
+    if (m_pathSource) return m_pathSource->isOK();
     return true;
 }
 
 sv_frame_t
 AlignmentModel::getStartFrame() const

 }
 
 bool
 AlignmentModel::isReady(int *completion) const
 {
-    if (!m_pathBegun && m_rawPath) {
+    if (!m_pathBegun && m_pathSource) {
         if (completion) *completion = 0;
 #ifdef DEBUG_ALIGNMENT_MODEL
         SVCERR << "AlignmentModel::isReady: path not begun" << endl;
 #endif
         return false;

 #ifdef DEBUG_ALIGNMENT_MODEL
         SVCERR << "AlignmentModel::isReady: path complete" << endl;
 #endif
         return true;
     }
-    if (!m_rawPath) {
+    if (!m_pathSource) {
         // lack of raw path could mean path is complete (in which case
         // m_pathComplete true above) or else no alignment has been
         // set at all yet (this case)
         if (completion) *completion = 0;
 #ifdef DEBUG_ALIGNMENT_MODEL
         SVCERR << "AlignmentModel::isReady: no raw path" << endl;
 #endif
         return false;
     }
-    return m_rawPath->isReady(completion);
+    return m_pathSource->isReady(completion);
 }
 
 const ZoomConstraint *
 AlignmentModel::getZoomConstraint() const
 {

 {
 #ifdef DEBUG_ALIGNMENT_MODEL
     cerr << "AlignmentModel::toReference(" << frame << ")" << endl;
 #endif
     if (!m_path) {
-        if (!m_rawPath) return frame;
+        if (!m_pathSource) return frame;
         constructPath();
     }
     return align(m_path, frame);
 }
 

 {
 #ifdef DEBUG_ALIGNMENT_MODEL
     cerr << "AlignmentModel::fromReference(" << frame << ")" << endl;
 #endif
     if (!m_reversePath) {
-        if (!m_rawPath) return frame;
+        if (!m_pathSource) return frame;
         constructReversePath();
     }
     return align(m_reversePath, frame);
 }
 
 void
-AlignmentModel::pathChanged()
+AlignmentModel::pathSourceChanged()
 {
     if (m_pathComplete) {
         cerr << "AlignmentModel: deleting raw path model" << endl;
-        if (m_rawPath) m_rawPath->aboutToDelete();
-        delete m_rawPath;
-        m_rawPath = nullptr;
-    }
-}
-
-void
-AlignmentModel::pathChangedWithin(sv_frame_t, sv_frame_t)
+        if (m_pathSource) m_pathSource->aboutToDelete();
+        delete m_pathSource;
+        m_pathSource = nullptr;
+    }
+}
+
+void
+AlignmentModel::pathSourceChangedWithin(sv_frame_t, sv_frame_t)
 {
     if (!m_pathComplete) return;
     constructPath();
     constructReversePath();
 }    
 
 void
-AlignmentModel::pathCompletionChanged()
-{
-    if (!m_rawPath) return;
+AlignmentModel::pathSourceCompletionChanged()
+{
+    if (!m_pathSource) return;
     m_pathBegun = true;
 
     if (!m_pathComplete) {
 
         int completion = 0;
-        m_rawPath->isReady(&completion);
+        m_pathSource->isReady(&completion);
 
 #ifdef DEBUG_ALIGNMENT_MODEL
         SVCERR << "AlignmentModel::pathCompletionChanged: completion = "
                << completion << endl;
 #endif

 
 void
 AlignmentModel::constructPath() const
 {
     if (!m_path) {
-        if (!m_rawPath) {
+        if (!m_pathSource) {
             cerr << "ERROR: AlignmentModel::constructPath: "
                       << "No raw path available" << endl;
             return;
         }
         m_path = new PathModel
-            (m_rawPath->getSampleRate(), m_rawPath->getResolution(), false);
+            (m_pathSource->getSampleRate(), m_pathSource->getResolution(), false);
     } else {
-        if (!m_rawPath) return;
+        if (!m_pathSource) return;
     }
         
     m_path->clear();
 
-    EventVector points = m_rawPath->getAllEvents();
+    EventVector points = m_pathSource->getAllEvents();
 
     for (const auto &p: points) {
         sv_frame_t frame = p.getFrame();
         double value = p.getValue();
         sv_frame_t rframe = lrint(value * m_aligned->getSampleRate());

 }
 
 void
 AlignmentModel::setPathFrom(SparseTimeValueModel *rawpath)
 {
-    if (m_rawPath) m_rawPath->aboutToDelete();
-    delete m_rawPath;
-
-    m_rawPath = rawpath;
-
-    if (!m_rawPath) {
+    if (m_pathSource) m_pathSource->aboutToDelete();
+    delete m_pathSource;
+
+    m_pathSource = rawpath;
+
+    if (!m_pathSource) {
         return;
     }
 
-    connect(m_rawPath, SIGNAL(modelChanged()),
+    connect(m_pathSource, SIGNAL(modelChanged()),
             this, SLOT(pathChanged()));
 
-    connect(m_rawPath, SIGNAL(modelChangedWithin(sv_frame_t, sv_frame_t)),
+    connect(m_pathSource, SIGNAL(modelChangedWithin(sv_frame_t, sv_frame_t)),
             this, SLOT(pathChangedWithin(sv_frame_t, sv_frame_t)));
         
-    connect(m_rawPath, SIGNAL(completionChanged()),
+    connect(m_pathSource, SIGNAL(completionChanged()),
             this, SLOT(pathCompletionChanged()));
     
     constructPath();
     constructReversePath();
 
-    if (m_rawPath->isReady()) {
+    if (m_pathSource->isReady()) {
         pathCompletionChanged();
     }        
 }
 
 void