comparison data/model/AlignmentModel.cpp @ 929:59e7fe1b1003 warnfix_no_size_t

Unsigned removals and warning fixes in data/

     if (m_rawPath) {
 
         connect(m_rawPath, SIGNAL(modelChanged()),
                 this, SLOT(pathChanged()));
 
-        connect(m_rawPath, SIGNAL(modelChanged(size_t, size_t)),
-                this, SLOT(pathChanged(size_t, size_t)));
+        connect(m_rawPath, SIGNAL(modelChanged(int, int)),
+                this, SLOT(pathChanged(int, int)));
         
         connect(m_rawPath, SIGNAL(completionChanged()),
                 this, SLOT(pathCompletionChanged()));
 
         constructPath();

 {
     if (m_rawPath) return m_rawPath->isOK();
     else return true;
 }
 
-size_t
+int
 AlignmentModel::getStartFrame() const
 {
-    size_t a = m_reference->getStartFrame();
-    size_t b = m_aligned->getStartFrame();
+    int a = m_reference->getStartFrame();
+    int b = m_aligned->getStartFrame();
     return std::min(a, b);
 }
 
-size_t
+int
 AlignmentModel::getEndFrame() const
 {
-    size_t a = m_reference->getEndFrame();
-    size_t b = m_aligned->getEndFrame();
+    int a = m_reference->getEndFrame();
+    int b = m_aligned->getEndFrame();
     return std::max(a, b);
 }
 
-size_t
+int
 AlignmentModel::getSampleRate() const
 {
     return m_reference->getSampleRate();
 }
 

 AlignmentModel::getAlignedModel() const
 {
     return m_aligned;
 }
 
-size_t
-AlignmentModel::toReference(size_t frame) const
+int
+AlignmentModel::toReference(int frame) const
 {
 #ifdef DEBUG_ALIGNMENT_MODEL
     SVDEBUG << "AlignmentModel::toReference(" << frame << ")" << endl;
 #endif
     if (!m_path) {

         constructPath();
     }
     return align(m_path, frame);
 }
 
-size_t
-AlignmentModel::fromReference(size_t frame) const
+int
+AlignmentModel::fromReference(int frame) const
 {
 #ifdef DEBUG_ALIGNMENT_MODEL
     SVDEBUG << "AlignmentModel::fromReference(" << frame << ")" << endl;
 #endif
     if (!m_reversePath) {

         m_rawPath = 0;
     }
 }
 
 void
-AlignmentModel::pathChanged(size_t, size_t)
+AlignmentModel::pathChanged(int, int)
 {
     if (!m_pathComplete) return;
     constructPath();
     constructReversePath();
 }    

 #ifdef DEBUG_ALIGNMENT_MODEL
     SVDEBUG << "AlignmentModel::constructReversePath: " << m_reversePath->getPointCount() << " points, at least " << (2 * m_reversePath->getPointCount() * (3 * sizeof(void *) + sizeof(int) + sizeof(PathPoint))) << " bytes" << endl;
 #endif
 }
 
-size_t
-AlignmentModel::align(PathModel *path, size_t frame) const
+int
+AlignmentModel::align(PathModel *path, int frame) const
 {
     if (!path) return frame;
 
     // The path consists of a series of points, each with frame equal
     // to the frame on the source model and mapframe equal to the

 #endif
     }        
 
     if (foundMapFrame < 0) return 0;
 
-    size_t resultFrame = foundMapFrame;
+    int resultFrame = foundMapFrame;
 
     if (followingFrame != foundFrame && long(frame) > foundFrame) {
         float interp =
             float(frame - foundFrame) /
             float(followingFrame - foundFrame);