comparison layer/TimeRulerLayer.cpp @ 944:78c152e4db95

Merge from branch tonioni

     m_model = model;
     emit modelReplaced();
 }
 
 bool
-TimeRulerLayer::snapToFeatureFrame(View *v, int &frame,
+TimeRulerLayer::snapToFeatureFrame(View *v, sv_frame_t &frame,
                                    int &resolution, SnapType snap) const
 {
     if (!m_model) {
         resolution = 1;
         return false;
     }
 
     bool q;
     int tick = getMajorTickSpacing(v, q);
     RealTime rtick = RealTime::fromMilliseconds(tick);
-    int rate = m_model->getSampleRate();
+    sv_samplerate_t rate = m_model->getSampleRate();
     
     RealTime rt = RealTime::frame2RealTime(frame, rate);
     double ratio = rt / rtick;
 
     int rounded = int(ratio);
     RealTime rdrt = rtick * rounded;
 
-    int left = RealTime::realTime2Frame(rdrt, rate);
-    resolution = RealTime::realTime2Frame(rtick, rate);
-    int right = left + resolution;
+    sv_frame_t left = RealTime::realTime2Frame(rdrt, rate);
+    resolution = int(RealTime::realTime2Frame(rtick, rate));
+    sv_frame_t right = left + resolution;
 
 //    SVDEBUG << "TimeRulerLayer::snapToFeatureFrame: type "
 //              << int(snap) << ", frame " << frame << " (time "
 //              << rt << ", tick " << rtick << ", rounded " << rdrt << ") ";
 

         frame = right;
         break;
         
     case SnapNearest:
     {
-        if (abs(frame - left) > abs(right - frame)) {
+        if (labs(frame - left) > labs(right - frame)) {
             frame = right;
         } else {
             frame = left;
         }
         break;

 {
     // return value is in milliseconds
 
     if (!m_model || !v) return 1000;
 
-    int sampleRate = m_model->getSampleRate();
+    sv_samplerate_t sampleRate = m_model->getSampleRate();
     if (!sampleRate) return 1000;
 
-    long startFrame = v->getStartFrame();
-    long endFrame = v->getEndFrame();
+    sv_frame_t startFrame = v->getStartFrame();
+    sv_frame_t endFrame = v->getEndFrame();
 
     int minPixelSpacing = 50;
 
     RealTime rtStart = RealTime::frame2RealTime(startFrame, sampleRate);
     RealTime rtEnd = RealTime::frame2RealTime(endFrame, sampleRate);

 	      << ") [" << rect.width() << "x" << rect.height() << "]" << endl;
 #endif
     
     if (!m_model || !m_model->isOK()) return;
 
-    int sampleRate = m_model->getSampleRate();
+    sv_samplerate_t sampleRate = m_model->getSampleRate();
     if (!sampleRate) return;
 
-    long startFrame = v->getFrameForX(rect.x() - 50);
+    sv_frame_t startFrame = v->getFrameForX(rect.x() - 50);
 
 #ifdef DEBUG_TIME_RULER_LAYER
     cerr << "start frame = " << startFrame << endl;
 #endif
 
     bool quarter = false;
     int incms = getMajorTickSpacing(v, quarter);
 
-    int ms = lrint(1000.0 * (double(startFrame) / double(sampleRate)));
+    int ms = int(lrint(1000.0 * (double(startFrame) / double(sampleRate))));
     ms = (ms / incms) * incms - incms;
 
 #ifdef DEBUG_TIME_RULER_LAYER
     cerr << "start ms = " << ms << " at step " << incms << endl;
 #endif

     // values for x and frame counts here will do, no rounding issue.
     // We always use the exact incms in our calculations for where to
     // draw the actual ticks or lines.
 
     int minPixelSpacing = 50;
-    long incFrame = (incms * sampleRate) / 1000;
-    int incX = incFrame / v->getZoomLevel();
+    sv_frame_t incFrame = lrint((incms * sampleRate) / 1000);
+    int incX = int(incFrame / v->getZoomLevel());
     int ticks = 10;
     if (incX < minPixelSpacing * 2) {
 	ticks = quarter ? 4 : 5;
     }
 

         // needs to correspond to an exact pixel (so that we don't get
         // a different pixel when scrolling a small amount and
         // re-drawing with a different start frame).
 
         double dms = ms;
-        long frame = lrint((dms * sampleRate) / 1000.0);
+        sv_frame_t frame = lrint((dms * sampleRate) / 1000.0);
         frame /= v->getZoomLevel();
         frame *= v->getZoomLevel(); // so frame corresponds to an exact pixel
 
         int x = v->getXForFrame(frame);