Example #1
0
 public ChartSeriesCombineStrategy()
 {
     this.CombinedSeries    = new List <CombinedSeries>();
     this.NonCombinedSeries = new List <ChartSeriesModel>();
     this.StackValueAxes    = new List <AxisModel>();
     this.MaximumStackSums  = new ReferenceDictionary <AxisModel, double>();
     this.MinimumStackSums  = new ReferenceDictionary <AxisModel, double>();
 }
        /// <summary>
        /// Initializes a new instance of the <see cref="ChartAreaModelWithAxes"/> class.
        /// </summary>
        public ChartAreaModelWithAxes()
        {
            this.SeriesCombineStrategies = new ReferenceDictionary <AxisModel, ChartSeriesCombineStrategy>();
            this.FirstAxes   = new List <AxisModel>();
            this.SecondAxes  = new List <AxisModel>();
            this.Annotations = new List <ChartAnnotationModel>();

            this.axesUpdateNeeded = true;
        }
        private void UpdateAxes()
        {
            if (this.Series.Count == 0)
            {
                this.ResetAxes();
                return;
            }

            this.AssertSeriesAxisAssociation();

            ReferenceDictionary <AxisModel, List <ChartSeriesModel> > seriesByStackAxis = new ReferenceDictionary <AxisModel, List <ChartSeriesModel> >();
            ReferenceDictionary <AxisModel, List <ChartSeriesModel> > seriesByValueAxis = new ReferenceDictionary <AxisModel, List <ChartSeriesModel> >();

            foreach (ChartSeriesModel series in this.Series)
            {
                IPlotAreaElementModelWithAxes seriesWithAxes = series as IPlotAreaElementModelWithAxes;
                AxisModel firstAxis  = seriesWithAxes.FirstAxis;
                AxisModel secondAxis = seriesWithAxes.SecondAxis;
                List <ChartSeriesModel> seriesModelsByFirstAxis;
                List <ChartSeriesModel> seriesModelsBySecondAxis;

                if (firstAxis.SupportsCombinedPlot)
                {
                    if (!seriesByStackAxis.TryGetValue(firstAxis, out seriesModelsByFirstAxis))
                    {
                        seriesModelsByFirstAxis = new List <ChartSeriesModel>();
                        seriesByStackAxis.Set(firstAxis, seriesModelsByFirstAxis);
                    }
                    seriesModelsByFirstAxis.Add(series);
                }
                else
                {
                    if (!seriesByValueAxis.TryGetValue(firstAxis, out seriesModelsByFirstAxis))
                    {
                        seriesModelsByFirstAxis = new List <ChartSeriesModel>();
                        seriesByValueAxis.Set(firstAxis, seriesModelsByFirstAxis);
                    }
                    seriesModelsByFirstAxis.Add(series);
                }

                if (secondAxis.SupportsCombinedPlot)
                {
                    if (!seriesByStackAxis.TryGetValue(secondAxis, out seriesModelsBySecondAxis))
                    {
                        seriesModelsBySecondAxis = new List <ChartSeriesModel>();
                        seriesByStackAxis.Set(secondAxis, seriesModelsBySecondAxis);
                    }
                    seriesModelsBySecondAxis.Add(series);
                }
                else
                {
                    if (!seriesByValueAxis.TryGetValue(secondAxis, out seriesModelsBySecondAxis))
                    {
                        seriesModelsBySecondAxis = new List <ChartSeriesModel>();
                        seriesByValueAxis.Set(secondAxis, seriesModelsBySecondAxis);
                    }
                    seriesModelsBySecondAxis.Add(series);
                }
            }

            // NOTE: All stack axes (i.e. their associated combine strategies) should be updated first
            // as the stack value axes' ranges can be affected by multiple combine strategies.
            foreach (var pair in seriesByStackAxis)
            {
                this.UpdateCombineStrategy(pair.Key, pair.Value);
                this.UpdateAxis(pair.Key, pair.Value);
            }

            foreach (var pair in seriesByValueAxis)
            {
                this.UpdateAxis(pair.Key, pair.Value);
            }

            // Update primary axes if they are not associated with series
            if (this.primaryFirstAxis != null && !this.primaryFirstAxis.isUpdated)
            {
                this.UpdateAxis(this.primaryFirstAxis, null);
            }

            if (this.primarySecondAxis != null && !this.primarySecondAxis.isUpdated)
            {
                this.UpdateAxis(this.primarySecondAxis, null);
            }
        }