Exemple #1
0
        /// <summary>
        /// Apply padding based on interval
        /// </summary>
        /// <param name="axis">The axis.</param>
        /// <param name="range">The range.</param>
        /// <param name="interval">The interval.</param>
        /// <param name="rangePadding">The range padding.</param>
        /// <returns></returns>
        internal static DoubleRange ApplyRangePadding(ChartAxis axis, DoubleRange range, double interval, NumericalPadding rangePadding)
        {
            if (rangePadding == NumericalPadding.Normal)
            {
                double minimum = 0,
                       remaining,
                       start = range.Start;

                if (range.Start < 0)
                {
                    start   = 0;
                    minimum = range.Start + (range.Start / 20);

                    remaining = interval + (minimum % interval);

                    if ((0.365 * interval) >= remaining)
                    {
                        minimum -= interval;
                    }

                    if (minimum % interval < 0)
                    {
                        minimum = (minimum - interval) - (minimum % interval);
                    }
                }
                else
                {
                    minimum = range.Start < ((5.0 / 6.0) * range.End)
                                         ? 0
                                         : (range.Start - (range.End - range.Start) / 2);
                    if (minimum % interval > 0)
                    {
                        minimum -= (minimum % interval);
                    }
                }

                double maximum = (range.End + (range.End - start) / 20);

                remaining = interval - (maximum % interval);

                if ((0.365 * interval) >= remaining)
                {
                    maximum += interval;
                }

                if (maximum % interval > 0)
                {
                    maximum = (maximum + interval) - (maximum % interval);
                }

                range = new DoubleRange(minimum, maximum);

                if (minimum == 0d)
                {
                    axis.ActualInterval = axis.CalculateActualInterval(range, axis.AvailableSize);
                    return(new DoubleRange(0, Math.Ceiling(maximum / axis.ActualInterval) * axis.ActualInterval));
                }
            }
            else if (rangePadding == NumericalPadding.Round ||
                     rangePadding == NumericalPadding.Additional)
            {
                double minimum = Math.Floor(range.Start / interval) * interval;
                double maximum = Math.Ceiling(range.End / interval) * interval;

                if (rangePadding == NumericalPadding.Additional)
                {
                    minimum -= interval;
                    maximum += interval;
                }

                return(new DoubleRange(minimum, maximum));
            }

            return(range);
        }