comparison view/Pane.cpp @ 810:b68af2be4545 tonioni

Merge from branch warnfix_no_size_t

     }
 
     paint.end();
 }
 
-size_t
+int
 Pane::getVerticalScaleWidth() const
 {
     if (m_scaleWidth > 0) return m_scaleWidth;
     else return 0;
 }

 void
 Pane::drawEditingSelection(QPainter &paint)
 {
     int offset = m_mousePos.x() - m_clickPos.x();
 
-    long origStart = m_editingSelection.getStartFrame();
+    int origStart = m_editingSelection.getStartFrame();
 
     int p0 = getXForFrame(origStart) + offset;
     int p1 = getXForFrame(m_editingSelection.getEndFrame()) + offset;
 
     if (m_editingSelectionEdge < 0) {
         p1 = getXForFrame(m_editingSelection.getEndFrame());
     } else if (m_editingSelectionEdge > 0) {
         p0 = getXForFrame(m_editingSelection.getStartFrame());
     }
     
-    long newStart = getFrameForX(p0);
-    long newEnd = getFrameForX(p1);
+    int newStart = getFrameForX(p0);
+    int newEnd = getFrameForX(p1);
     
     paint.save();
     paint.setPen(QPen(getForeground(), 2));
 
     int fontHeight = paint.fontMetrics().height();

     int fontHeight = paint.fontMetrics().height();
     int fontAscent = paint.fontMetrics().ascent();
 
     if (r.y() + r.height() < height() - fontHeight - 6) return;
 
-    size_t modelRate = waveformModel->getSampleRate();
-    size_t nativeRate = waveformModel->getNativeRate();
-    size_t playbackRate = m_manager->getPlaybackSampleRate();
-    size_t outputRate = m_manager->getOutputSampleRate();
+    int modelRate = waveformModel->getSampleRate();
+    int nativeRate = waveformModel->getNativeRate();
+    int playbackRate = m_manager->getPlaybackSampleRate();
+    int outputRate = m_manager->getOutputSampleRate();
         
     QString srNote = "";
 
     // Show (R) for waveform models that have been resampled or will
     // be resampled on playback, and (X) for waveform models that will

                         desc, OutlinedText);
     }
 }
 
 bool
-Pane::render(QPainter &paint, int xorigin, size_t f0, size_t f1)
+Pane::render(QPainter &paint, int xorigin, int f0, int f1)
 {
     if (!View::render(paint, xorigin + m_scaleWidth, f0, f1)) {
         return false;
     }
 

 
     return true;
 }
 
 QImage *
-Pane::toNewImage(size_t f0, size_t f1)
-{
-    size_t x0 = f0 / getZoomLevel();
-    size_t x1 = f1 / getZoomLevel();
+Pane::toNewImage(int f0, int f1)
+{
+    int x0 = f0 / getZoomLevel();
+    int x1 = f1 / getZoomLevel();
 
     QImage *image = new QImage(x1 - x0 + m_scaleWidth,
                                height(), QImage::Format_RGB32);
 
     int formerScaleWidth = m_scaleWidth;

         return image;
     }
 }
 
 QSize
-Pane::getImageSize(size_t f0, size_t f1)
+Pane::getImageSize(int f0, int f1)
 {
     QSize s = View::getImageSize(f0, f1);
     QImage *image = new QImage(100, 100, QImage::Format_RGB32);
     QPainter paint(image);
 

     }
     
     return QSize(sw + s.width(), s.height());
 }
 
-size_t
+int
 Pane::getFirstVisibleFrame() const
 {
-    long f0 = getFrameForX(m_scaleWidth);
-    size_t f = View::getFirstVisibleFrame();
+    int f0 = getFrameForX(m_scaleWidth);
+    int f = View::getFirstVisibleFrame();
     if (f0 < 0 || f0 < long(f)) return f;
     return f0;
 }
 
 Selection

 {
     closeToLeftEdge = closeToRightEdge = false;
 
     if (!m_manager) return Selection();
 
-    long testFrame = getFrameForX(x - 5);
+    int testFrame = getFrameForX(x - 5);
     if (testFrame < 0) {
     testFrame = getFrameForX(x);
     if (testFrame < 0) return Selection();
     }
 

             m_resizing = true;
             
         } else {
             
             int mouseFrame = getFrameForX(e->x());
-            size_t resolution = 1;
+            int resolution = 1;
             int snapFrame = mouseFrame;
     
             Layer *layer = getSelectedLayer();
             if (layer && !m_shiftPressed) {
                 layer->snapToFeatureFrame(this, snapFrame,

     int x1 = r.x() + r.width();
     int y1 = r.y() + r.height();
 
     int w = x1 - x0;
         
-    long newStartFrame = getFrameForX(x0);
-        
-    long visibleFrames = getEndFrame() - getStartFrame();
+    int newStartFrame = getFrameForX(x0);
+        
+    int visibleFrames = getEndFrame() - getStartFrame();
     if (newStartFrame <= -visibleFrames) {
         newStartFrame  = -visibleFrames + 1;
     }
         
     if (newStartFrame >= long(getModelsEndFrame())) {
         newStartFrame  = getModelsEndFrame() - 1;
     }
         
     float ratio = float(w) / float(width());
 //	cerr << "ratio: " << ratio << endl;
-    size_t newZoomLevel = (size_t)nearbyint(m_zoomLevel * ratio);
+    int newZoomLevel = (int)nearbyint(m_zoomLevel * ratio);
     if (newZoomLevel < 1) newZoomLevel = 1;
 
 //	cerr << "start: " << m_startFrame << ", level " << m_zoomLevel << endl;
     setZoomLevel(getZoomConstraintBlockSize(newZoomLevel));
     setStartFrame(newStartFrame);

          !(m_manager && m_manager->isPlaying())); // resist vert
 
     if (m_dragMode == HorizontalDrag ||
         m_dragMode == FreeDrag) {
 
-        long frameOff = getFrameForX(e->x()) - getFrameForX(m_clickPos.x());
-
-        size_t newCentreFrame = m_dragCentreFrame;
+        int frameOff = getFrameForX(e->x()) - getFrameForX(m_clickPos.x());
+        int newCentreFrame = m_dragCentreFrame;
         
         if (frameOff < 0) {
             newCentreFrame -= frameOff;
-        } else if (newCentreFrame >= size_t(frameOff)) {
+        } else if (newCentreFrame >= frameOff) {
             newCentreFrame -= frameOff;
         } else {
             newCentreFrame = 0;
         }
 

 
 void
 Pane::dragExtendSelection(QMouseEvent *e)
 {
     int mouseFrame = getFrameForX(e->x());
-    size_t resolution = 1;
+    int resolution = 1;
     int snapFrameLeft = mouseFrame;
     int snapFrameRight = mouseFrame;
     
     Layer *layer = getSelectedLayer();
     if (layer && !m_shiftPressed) {

 //	cerr << "snap: frame = " << mouseFrame << ", start frame = " << m_selectionStartFrame << ", left = " << snapFrameLeft << ", right = " << snapFrameRight << endl;
 
     if (snapFrameLeft < 0) snapFrameLeft = 0;
     if (snapFrameRight < 0) snapFrameRight = 0;
     
-    size_t min, max;
-    
-    if (m_selectionStartFrame > size_t(snapFrameLeft)) {
+    int min, max;
+    
+    if (m_selectionStartFrame > snapFrameLeft) {
         min = snapFrameLeft;
         max = m_selectionStartFrame;
-    } else if (size_t(snapFrameRight) > m_selectionStartFrame) {
+    } else if (snapFrameRight > m_selectionStartFrame) {
         min = m_selectionStartFrame;
         max = snapFrameRight;
     } else {
         min = snapFrameLeft;
         max = snapFrameRight;

         update();
     }
 
     if (relocate) {
 
-        long f = getFrameForX(e->x());
+        int f = getFrameForX(e->x());
 
         setCentreFrame(f);
 
         m_dragCentreFrame = f;
         m_dragStartMinValue = 0;

     // Scroll left or right, rapidly
 
     if (getStartFrame() < 0 && 
         getEndFrame() >= getModelsEndFrame()) return;
 
-    long delta = ((width() / 2) * count * m_zoomLevel);
-
-    if (int(m_centreFrame) < delta) {
+    int delta = ((width() / 2) * count * m_zoomLevel);
+
+    if (m_centreFrame < delta) {
         setCentreFrame(0);
-    } else if (int(m_centreFrame) - delta >= int(getModelsEndFrame())) {
+    } else if (m_centreFrame - delta >= getModelsEndFrame()) {
         setCentreFrame(getModelsEndFrame());
     } else {
         setCentreFrame(m_centreFrame - delta);
     }
 

         updateVerticalPanner();
     }
 }    
 
 void
-Pane::verticalPannerMoved(float x0, float y0, float w, float h)
+Pane::verticalPannerMoved(float , float y0, float , float h)
 {
     float vmin, vmax, dmin, dmax;
     if (!getTopLayerDisplayExtents(vmin, vmax, dmin, dmax)) return;
     float y1 = y0 + h;
     float newmax = vmin + ((1.0 - y0) * (vmax - vmin));

     }
 
     int p0 = getXForFrame(m_editingSelection.getStartFrame()) + offset;
     int p1 = getXForFrame(m_editingSelection.getEndFrame()) + offset;
 
-    long f0 = getFrameForX(p0);
-    long f1 = getFrameForX(p1);
+    int f0 = getFrameForX(p0);
+    int f1 = getFrameForX(p1);
 
     Selection newSelection(f0, f1);
     
     if (m_editingSelectionEdge == 0) {
     

     updateHeadsUpDisplay();
     update();
 }
 
 void
-Pane::viewZoomLevelChanged(View *v, unsigned long z, bool locked)
+Pane::viewZoomLevelChanged(View *v, int z, bool locked)
 {
 //    cerr << "Pane[" << this << "]::zoomLevelChanged (global now "
 //              << (m_manager ? m_manager->getGlobalZoom() : 0) << ")" << endl;
 
     View::viewZoomLevelChanged(v, z, locked);