AutoScale and Zoom

Feel free to use this class in future examples. I set the Viewport of my chart to use this class and provided for some functions to help manage the state I needed the chart to plot under. I was able to implement this from Andrew’s examples above.

    /// <summary>
/// This provides the ability to override axis ranges to the chart to meet our requirements.
/// 
/// Current requirement is to have the Y axis to be fixed from 0 to 105.  If a data point is
/// to be plotted above 105 then we should scale as necessary.  If the user is zooming to any
/// place in the chart we don't want to enforce the scaling rules above.  we will only enforce
/// these rules when ZoomExtents() has been called/raised by the user.  This happens when the
/// user double clicks on the chart.
/// 
/// There is also a case where we can have a 3rd axis (2nd y axis) and in that case we
/// will just scale that range to be based on the actual values on that axis.
/// </summary>
public class AutoScrollingViewportManager : DefaultViewportManager
{
    /// <summary>
    /// Constructor
    /// </summary>
    /// <param name="windowSize">what is the initial window size?</param>
    /// <param name="low">what is our default low end for the Y axis range?  I.e. zero.</param>
    /// <param name="high">what is our default high end for the Y axis range before any auto-resizing?</param>
    /// <param name="min">what is our default low end X axis range before any auto-resizing?</param>
    /// <param name="max">what is our default high end X axis range before any auto-resizing?</param>
    public AutoScrollingViewportManager(double low = -5d, double high = 105d, double min = -10d, double max = 10d)
    {
        DefaultMaxY = High = high;
        DefaultMinY = Low = low;

        DefaultMinX = MinX = min;
        DefaultMaxX = MaxX = max;
    }

    #region Establishes Surface
    /// <summary>
    /// We're being told about the SciChart surface to which this viewport belongs.
    /// We need to keep track of it as there is valuable information we can
    /// use later on
    /// </summary>
    /// <param name="surface">which SciChart?</param>
    public override void AttachSciChartSurface(ISciChartSurface surface)
    {
        base.AttachSciChartSurface(surface);
        ParentSurface = surface;
    }

    /// <summary>
    /// What is the current SciChart to which this viewport belongs?
    /// </summary>
    public ISciChartSurface ParentSurface { get; private set; }
    #endregion




    #region Proposed Range Adjustements
    /// <summary>
    /// Handles when the Y axis range is about to be updated
    /// </summary>
    /// <param name="yAxis">pointer to the Y axis proposed adjustment</param>
    /// <param name="renderPassInfo"></param>
    /// <returns></returns>
    protected override IRange OnCalculateNewYRange(IAxis yAxis, RenderPassInfo renderPassInfo)
    {            
        DoubleRange result = null;

        // if the user has zoomed we aren't going to apply our rules
        if (ParentSurface.ZoomState == ZoomStates.UserZooming)
            result = yAxis.VisibleRange.AsDoubleRange();

        // the user is not currently involved in sizing the Y axis, we're
        // going to get involved now and enforce our rules
        else if (ParentSurface.ZoomState == ZoomStates.AtExtents)
        {
            // is this the 2nd axis?  it will be managed a little different as we won't assume the 1st
            // series to be the guy who dictates height
            if (yAxis.Id.ToLower() == "yaxis2")
            {
                // in my implementation I know that I'm adding the 2nd axis data series last
                // so I can use this logic to just fetch the 2nd axis series and define my
                // min and max based on it's values.
                XyDataSeries<double, double> last = renderPassInfo.DataSeries.Last() as XyDataSeries<double, double>;
                double minY = Convert.ToDouble(last.YMin);
                double maxY = Convert.ToDouble(last.YMax);
                result = new DoubleRange(minY * 1.05d, maxY * 1.05d);
            }
            else
            {
                // get the actual series.  not likely I won't have a series but good to check
                // regardless.
                XyDataSeries<double, double> series = renderPassInfo.DataSeries[0] as XyDataSeries<double, double>;
                if (null != series)                    
                    result = new DoubleRange(Low < DefaultMinY ? Low * 1.05d : DefaultMinY, High > DefaultMaxY ? High * 1.05d : DefaultMaxY);                    
            }               
        }

        // respond with how the chart range should be defined
        return result;
    }

    /// <summary>
    /// Handles when the X axis range is about to be updated
    /// </summary>
    /// <param name="xAxis">point to the X axis proposed adjustment</param>
    /// <returns></returns>
    protected override IRange OnCalculateNewXRange(IAxis xAxis)
    {
        DoubleRange result = null;

        DoubleRange range = xAxis.VisibleRange.AsDoubleRange();

        // if the user has zoomed we aren't going to apply our rules
        if (ParentSurface.ZoomState == ZoomStates.UserZooming)
            result = range;

        // the user is not currently involved in sizing the Y axis, we're
        // going to get involved now and enforce our rules
        else if (ParentSurface.ZoomState == ZoomStates.AtExtents)
            result = new DoubleRange(MinX, MaxX);            

        // respond with how the chart range should be defined
        return result;
    }
    #endregion





    #region High/Low Y range that we will enforce

    /// <summary>
    /// This is the low end of the range we want to use unless the user is zooming.
    /// </summary>
    private double Low { get; set; }

    /// <summary>
    /// Don't let the Y range get any lower than this value unless the
    /// user is zooming
    /// </summary>
    private double High { get; set; }


    /// <summary>
    /// Default value to be used when a reset happens.
    /// </summary>
    private double DefaultMinY { get; set; }

    /// <summary>
    /// Default value to be used when a reset happens
    /// </summary>
    private double DefaultMaxY { get; set; }

    #endregion

    #region Min/Max X range that we will enforce

    /// <summary>
    /// Don't let the X axis get any smaller than this unless the user is zooming
    /// </summary>
    private double MinX { get; set; }

    /// <summary>
    /// Don't let the X range get any less than this value unless the user is zooming
    /// </summary>
    private double MaxX { get; set; }

    /// <summary>
    /// Default value to be used when a reset happens.
    /// </summary>
    private double DefaultMinX { get; set; }

    /// <summary>
    /// Default value to be used when a reset happens
    /// </summary>
    private double DefaultMaxX { get; set; }

    /// <summary>
    /// Provides for the ability to update the X axis range
    /// </summary>
    /// <param name="minX">what is the new minimum allowed?</param>
    /// <param name="maxX">what is the new maximum allowed?</param>
    /// <param name="minY">what is the new minimum allowed (if less than default of zero)?</param>
    /// <param name="maxY">what is the new maximum allowed (if greater than default of zero)?</param>
    public void UpdateRange(double minX, double maxX, double minY, double maxY) 
    { 
        MinX = minX; 
        MaxX = maxX;

        Low = minY;
        High = maxY;
    }

    /// <summary>
    /// Reset the X axis back to the initial defaults assigned to the chart
    /// </summary>
    public void ResetXAxisRange() { MinX = DefaultMinX; MaxX = DefaultMaxX; }

    #endregion
}

OK Chris so that I’ve got this right:

• You want to set the YAxis VisibleRange to 0,105 initially
• If the data exceeds that you want to zoom to fit

then what? Is that all there is to it?

If you can write the rules as a set of logical steps then I can suggest a solution for you.

Best regards,
Andrew