Example #1
0
        internal override void OnPropertyChanged(RadPropertyEventArgs e)
        {
            // update local value first and then call base to raise the PropertyChanged event (if needed)
            if (e.Key == PlotModePropertyKey)
            {
                this.plotMode = (AxisPlotMode)e.NewValue;
            }

            base.OnPropertyChanged(e);
        }
Example #2
0
        public DateTimeContinuousAxisModel()
        {
            this.actualRange = ValueRange <DateTime> .Empty;

            this.visibleTicks   = new ValueRange <decimal>(-1, -1);
            this.tickZoomFactor = 1m;
            this.gapLength      = 0.3m;
            this.plotMode       = AxisPlotMode.BetweenTicks;

            this.values = new List <DateTimePoint>(16);

            this.maxTickCount = 31;
        }
Example #3
0
        internal override void OnPropertyChanged(RadPropertyEventArgs e)
        {
            // update local values first and then call base to raise the PropertyChanged event (if needed)
            if (e.Key == GapLengthPropertyKey)
            {
                this.gapLength = (decimal)((double)e.NewValue);
            }
            else if (e.Key == PlotModePropertyKey)
            {
                this.plotMode = (AxisPlotMode)e.NewValue;
            }
            else if (e.Key == MaximumTicksPropertyKey)
            {
                this.maxTickCount = (int)e.NewValue;
            }

            base.OnPropertyChanged(e);
        }
Example #4
0
        internal override void UpdateTicksVisibility(RadRect clipRect)
        {
            AxisPlotMode plotMode = this.owner.ActualPlotMode;

            foreach (AxisTickModel tick in this.owner.ticks)
            {
                bool visible = tick.layoutSlot.Center.X >= clipRect.X && tick.layoutSlot.Center.X <= clipRect.Right;
                tick.isVisible = visible;
                if (tick.associatedLabel != null && tick.associatedLabel.isVisible)
                {
                    if (plotMode == AxisPlotMode.OnTicks)
                    {
                        tick.associatedLabel.isVisible = visible;
                    }
                    else if (!visible)
                    {
                        tick.associatedLabel.isVisible = tick.associatedLabel.layoutSlot.X >= clipRect.X && tick.associatedLabel.layoutSlot.Right <= clipRect.Right;
                    }
                }
            }
        }
Example #5
0
        internal virtual IEnumerable <AxisLabelModel> GenerateLabels()
        {
            AxisPlotMode plotMode       = this.ActualPlotMode;
            int          labelIndex     = 0;
            int          startIndex     = this.LabelOffset;
            int          labelStep      = this.LabelInterval;
            int          skipLabelCount = 1;

            IContentFormatter labelFormatter = this.ContentFormatter;
            object            owner          = this.Presenter;
            string            format         = this.GetLabelFormat();

            // generate label for each major tick
            foreach (AxisTickModel tick in this.ticks)
            {
                if (labelIndex < startIndex)
                {
                    labelIndex++;
                    continue;
                }

                // skip minor ticks
                if (tick.Type == TickType.Minor)
                {
                    continue;
                }

                if (skipLabelCount > 1)
                {
                    skipLabelCount--;
                    continue;
                }

                // no need to process last tick if we are plotting between ticks
                if (plotMode == AxisPlotMode.BetweenTicks && RadMath.IsOne(this.IsInverse ? 1 - tick.normalizedValue : tick.normalizedValue))
                {
                    break;
                }

                AxisLabelModel label   = new AxisLabelModel();
                object         content = this.GetLabelContent(tick);
                if (labelFormatter != null)
                {
                    content = labelFormatter.Format(owner, content);
                }
                else if (!string.IsNullOrEmpty(format))
                {
                    content = string.Format(CultureInfo.CurrentUICulture, format, content);
                }
                label.Content        = content;
                tick.associatedLabel = label;

                if (plotMode == AxisPlotMode.BetweenTicks)
                {
                    decimal length = tick.NormalizedForwardLength;
                    if (length == 0)
                    {
                        length = tick.NormalizedBackwardLength;
                    }
                    tick.associatedLabel.normalizedPosition = tick.normalizedValue + (length / 2);
                }
                else
                {
                    tick.associatedLabel.normalizedPosition = tick.normalizedValue;
                }

                yield return(label);

                skipLabelCount = labelStep;
            }
        }
Example #6
0
 internal static bool IsRisersPositionEqualToPlotMode(AxisPlotMode axisActualPlotMode, StepSeriesRisersPosition risersActualPosition)
 {
     return((axisActualPlotMode == AxisPlotMode.BetweenTicks && risersActualPosition == StepSeriesRisersPosition.BetweenTicks) ||
            ((axisActualPlotMode == AxisPlotMode.OnTicksPadded || axisActualPlotMode == AxisPlotMode.OnTicks) && risersActualPosition == StepSeriesRisersPosition.OnTicks));
 }
Example #7
0
        internal static StepSeriesRisersPosition GetActualRisersPosition(StepSeriesRisersPosition stepSeriesRisersPosition, AxisPlotMode axisPlotMode)
        {
            StepSeriesRisersPosition risersActualPosition = stepSeriesRisersPosition;

            if (risersActualPosition == StepSeriesRisersPosition.Default)
            {
                risersActualPosition = axisPlotMode == AxisPlotMode.BetweenTicks ? StepSeriesRisersPosition.OnTicks : StepSeriesRisersPosition.BetweenTicks;
            }

            return(risersActualPosition);
        }
Example #8
0
 public CategoricalAxisModel()
 {
     this.categories = new List <AxisCategory>();
     this.plotMode   = AxisPlotMode.BetweenTicks;
 }