comparison view/View.h @ 902:a1226b3b7925 cxx11

Toward building with new sv types

 
 #include "base/ZoomConstraint.h"
 #include "base/PropertyContainer.h"
 #include "ViewManager.h"
 #include "base/XmlExportable.h"
+#include "base/BaseTypes.h"
 
 // #define DEBUG_VIEW_WIDGET_PAINT 1
 
 class Layer;
 class ViewPropertyContainer;

     /**
      * Retrieve the first visible sample frame on the widget.
      * This is a calculated value based on the centre-frame, widget
      * width and zoom level.  The result may be negative.
      */
-    int getStartFrame() const;
+    sv_frame_t getStartFrame() const;
 
     /**
      * Set the widget pan based on the given first visible frame.  The
      * frame value may be negative.
      */
-    void setStartFrame(int);
+    void setStartFrame(sv_frame_t);
 
     /**
      * Return the centre frame of the visible widget.  This is an
      * exact value that does not depend on the zoom block size.  Other
      * frame values (start, end) are calculated from this based on the
      * zoom and other factors.
      */
-    int getCentreFrame() const { return m_centreFrame; }
+    sv_frame_t getCentreFrame() const { return m_centreFrame; }
 
     /**
      * Set the centre frame of the visible widget.
      */
-    void setCentreFrame(int f) { setCentreFrame(f, true); }
+    void setCentreFrame(sv_frame_t f) { setCentreFrame(f, true); }
 
     /**
      * Retrieve the last visible sample frame on the widget.
      * This is a calculated value based on the centre-frame, widget
      * width and zoom level.
      */
-    int getEndFrame() const;
+    sv_frame_t getEndFrame() const;
 
     /**
      * Return the pixel x-coordinate corresponding to a given sample
      * frame (which may be negative).
      */
-    int getXForFrame(int frame) const;
+    int getXForFrame(sv_frame_t frame) const;
 
     /**
      * Return the closest frame to the given pixel x-coordinate.
      */
-    int getFrameForX(int x) const;
+    sv_frame_t getFrameForX(int x) const;
 
     /**
      * Return the pixel y-coordinate corresponding to a given
      * frequency, if the frequency range is as specified.  This does
      * not imply any policy about layer frequency ranges, but it might

 
     /**
      * Return the number of layers, regardless of whether visible or
      * dormant, i.e. invisible, in this view.
      */
-    virtual int getLayerCount() const { return m_layerStack.size(); }
+    virtual int getLayerCount() const { return int(m_layerStack.size()); }
 
     /**
      * Return the nth layer, counted in stacking order.  That is,
      * layer 0 is the bottom layer and layer "getLayerCount()-1" is
      * the top one. The returned layer may be visible or it may be
      * dormant, i.e. invisible.
      */
     virtual Layer *getLayer(int n) {
-        if (n < int(m_layerStack.size())) return m_layerStack[n];
+        if (in_range_for(m_layerStack, n)) return m_layerStack[n];
         else return 0;
     }
 
     /**
      * Return the nth layer, counted in the order they were

 
     virtual void toXml(QTextStream &stream, QString indent = "",
                        QString extraAttributes = "") const;
 
     // First frame actually in model, to right of scale, if present
-    virtual int getFirstVisibleFrame() const;
-    virtual int getLastVisibleFrame() const;
-
-    int getModelsStartFrame() const;
-    int getModelsEndFrame() const;
+    virtual sv_frame_t getFirstVisibleFrame() const;
+    virtual sv_frame_t getLastVisibleFrame() const;
+
+    sv_frame_t getModelsStartFrame() const;
+    sv_frame_t getModelsEndFrame() const;
 
     typedef std::set<Model *> ModelSet;
     ModelSet getModels();
 
     //!!!
     Model *getAligningModel() const;
-    int alignFromReference(int) const;
-    int alignToReference(int) const;
-    int getAlignedPlaybackFrame() const;
+    sv_frame_t alignFromReference(sv_frame_t) const;
+    sv_frame_t alignToReference(sv_frame_t) const;
+    sv_frame_t getAlignedPlaybackFrame() const;
 
 signals:
     void propertyContainerAdded(PropertyContainer *pc);
     void propertyContainerRemoved(PropertyContainer *pc);
     void propertyContainerPropertyChanged(PropertyContainer *pc);

     void propertyContainerSelected(PropertyContainer *pc);
     void propertyChanged(PropertyContainer::PropertyName);
 
     void layerModelChanged();
 
-    void centreFrameChanged(int frame,
+    void centreFrameChanged(sv_frame_t frame,
                             bool globalScroll,
                             PlaybackFollowMode followMode);
 
     void zoomLevelChanged(int, bool);
 
     void contextHelpChanged(const QString &);
 
 public slots:
     virtual void modelChanged();
-    virtual void modelChangedWithin(int startFrame, int endFrame);
+    virtual void modelChangedWithin(sv_frame_t startFrame, sv_frame_t endFrame);
     virtual void modelCompletionChanged();
     virtual void modelAlignmentCompletionChanged();
     virtual void modelReplaced();
     virtual void layerParametersChanged();
     virtual void layerParameterRangesChanged();
     virtual void layerMeasurementRectsChanged();
     virtual void layerNameChanged();
 
-    virtual void globalCentreFrameChanged(int);
-    virtual void viewCentreFrameChanged(View *, int);
-    virtual void viewManagerPlaybackFrameChanged(int);
+    virtual void globalCentreFrameChanged(sv_frame_t);
+    virtual void viewCentreFrameChanged(View *, sv_frame_t);
+    virtual void viewManagerPlaybackFrameChanged(sv_frame_t);
     virtual void viewZoomLevelChanged(View *, int, bool);
 
     virtual void propertyContainerSelected(View *, PropertyContainer *pc);
 
     virtual void selectionChanged();

     // is generally the case except for spectrum/slice layers).  It
     // will not be possible to make or display selections if this is
     // false.
     bool hasTopLayerTimeXAxis() const;
 
-    bool setCentreFrame(int f, bool doEmit);
-
-    void movePlayPointer(int f);
+    bool setCentreFrame(sv_frame_t f, bool doEmit);
+
+    void movePlayPointer(sv_frame_t f);
 
     void checkProgress(void *object);
     int getProgressBarWidth() const; // if visible
 
-    int              m_centreFrame;
+    sv_frame_t          m_centreFrame;
     int                 m_zoomLevel;
     bool                m_followPan;
     bool                m_followZoom;
     PlaybackFollowMode  m_followPlay;
     bool                m_followPlayIsDetached;
-    int                 m_playPointerFrame;
+    sv_frame_t          m_playPointerFrame;
     bool                m_lightBackground;
     bool                m_showProgress;
 
     QPixmap            *m_cache;
-    int                 m_cacheCentreFrame;
+    sv_frame_t          m_cacheCentreFrame;
     int                 m_cacheZoomLevel;
     bool                m_selectionCached;
 
     bool                m_deleting;