comparison layer/Layer.h @ 904:e0f08e108064 cxx11

Move to using double rather than float for floating-point calculations (float only for storage); more build fixes

      * Return true if a suitable feature was found and frame adjusted
      * accordingly.  Return false if no suitable feature was available
      * (and leave frame unmodified).  If returning true, also return
      * the resolution of the model in this layer in sample frames.
      */
-    virtual bool snapToFeatureFrame(View *   /* v */,
-				    int &    /* frame */,
+    virtual bool snapToFeatureFrame(View * /* v */,
+				    sv_frame_t & /* frame */,
 				    int &resolution,
 				    SnapType /* snap */) const {
 	resolution = 1;
 	return false;
     }

      * Return true if a suitable feature was found and frame adjusted
      * accordingly.  Return false if no suitable feature was available
      * (and leave frame unmodified).  If returning true, also return
      * the resolution of the model in this layer in sample frames.
      */
-    virtual bool snapToSimilarFeature(View *   /* v */,
-                                      int &    /* source frame */,
+    virtual bool snapToSimilarFeature(View * /* v */,
+                                      sv_frame_t & /* source frame */,
                                       int &resolution,
                                       SnapType /* snap */) const {
 	resolution = 1;
 	return false;
     }

      * return false if the user cancelled the paste operation.  This
      * function should return true if a paste actually occurred.
      */
     virtual bool paste(View *,
                        const Clipboard & /* from */,
-                       int /* frameOffset */,
+                       sv_frame_t /* frameOffset */,
                        bool /* interactive */) { return false; }
 
     // Text mode:
     //
     // Label nearest feature.  We need to get the feature coordinates

      * these values if known.
      *
      * This function returns the "normal" extents for the layer, not
      * necessarily the extents actually in use in the display.
      */
-    virtual bool getValueExtents(float &min, float &max,
+    virtual bool getValueExtents(double &min, double &max,
                                  bool &logarithmic, QString &unit) const = 0;
 
     /**
      * Return the minimum and maximum values within the displayed
      * range for the y axis, if only a subset of the whole range of
      * the model (returned by getValueExtents) is being displayed.
      * Return false if the layer is not imposing a particular display
      * extent (using the normal layer extents or deferring to whatever
      * is in use for the same units elsewhere in the view).
      */
-    virtual bool getDisplayExtents(float & /* min */,
-                                   float & /* max */) const {
+    virtual bool getDisplayExtents(double & /* min */,
+                                   double & /* max */) const {
         return false;
     }
 
     /**
      * Set the displayed minimum and maximum values for the y axis to
      * the given range, if supported.  Return false if not supported
      * on this layer (and set nothing).  In most cases, layers that
      * return false for getDisplayExtents should also return false for
      * this function.
      */
-    virtual bool setDisplayExtents(float /* min */,
-                                   float /* max */) {
+    virtual bool setDisplayExtents(double /* min */,
+                                   double /* max */) {
         return false;
     }
 
     /**
      * Return the value and unit at the given x coordinate in the
      * given view.  This is for descriptive purposes using the
      * measurement tool.  The default implementation works correctly
      * if the layer hasTimeXAxis().
      */
     virtual bool getXScaleValue(const View *v, int x,
-                                float &value, QString &unit) const;
+                                double &value, QString &unit) const;
 
     /** 
      * Return the value and unit at the given y coordinate in the
      * given view.
      */
     virtual bool getYScaleValue(const View *, int /* y */,
-                                float &/* value */, QString &/* unit */) const {
+                                double &/* value */, QString &/* unit */) const {
         return false;
     }
 
     /**
      * Return the difference between the values at the given y
      * coordinates in the given view, and the unit of the difference.
      * The default implementation just calls getYScaleValue twice and
      * returns the difference, with the same unit.
      */
     virtual bool getYScaleDifference(const View *v, int y0, int y1,
-                                     float &diff, QString &unit) const;
+                                     double &diff, QString &unit) const;
         
     /**
      * Get the number of vertical zoom steps available for this layer.
      * If vertical zooming is not available, return 0.  The meaning of
      * "zooming" is entirely up to the layer -- changing the zoom

     void verticalZoomChanged();
 
 protected:
     void connectSignals(const Model *);
 
-    virtual int alignToReference(View *v, int frame) const;
-    virtual int alignFromReference(View *v, int frame) const;
+    virtual sv_frame_t alignToReference(View *v, sv_frame_t frame) const;
+    virtual sv_frame_t alignFromReference(View *v, sv_frame_t frame) const;
     bool clipboardHasDifferentAlignment(View *v, const Clipboard &clip) const;
 
     struct MeasureRect {
 
         mutable QRect pixrect;