示例#1
0
        /// <summary>
        /// Method implementation for Set points to given index
        /// </summary>
        /// <param name="index"></param>
        /// <param name="obj"></param>
        /// <param name="replace"></param>
        protected override void SetIndividualPoint(int index, object obj, bool replace)
        {
            // Updating summary value of the series.
            if (SummaryBindingPath != null)
            {
                object summaryValue = GetArrayPropertyValue(obj, new string[] { SummaryBindingPath });
                if (replace && SummaryValues.Count > index)
                {
                    SummaryValues[index] = Convert.ToBoolean(summaryValue);
                }
                else
                {
                    SummaryValues.Insert(index, Convert.ToBoolean(summaryValue));
                }
            }

            // Updating x and y value of the series.
            base.SetIndividualPoint(index, obj, replace);

            // Updating segment's SegmentType property based on yvalue.
            if (SummaryValues != null && index < Segments.Count && index < YValues.Count)
            {
                WaterfallSegment segment = Segments[index] as WaterfallSegment;
                if (SummaryValues[index] == false)
                {
                    if (YValues[index] < 0)
                    {
                        segment.SegmentType = WaterfallSegmentType.Negative;
                    }
                    else
                    {
                        segment.SegmentType = WaterfallSegmentType.Positive;
                    }
                }
                else
                {
                    segment.SegmentType = WaterfallSegmentType.Sum;
                }

                // Updating changed segment interior property.
                segment.BindProperties();
            }
        }
示例#2
0
        /// <summary>
        /// Creates the segments of WaterfallSeries.
        /// </summary>
        public override void CreateSegments()
        {
            List <double> xValues = GetXValues();
            double        median  = 0d;
            DoubleRange   sbsInfo = this.GetSideBySideInfo(this);

            median = sbsInfo.Delta / 2;
            double origin = ActualXAxis != null ? ActualXAxis.Origin : 0;

            if (ActualXAxis != null && ActualXAxis.Origin == 0 &&
                ActualYAxis is LogarithmicAxis &&
                (ActualYAxis as LogarithmicAxis).Minimum != null)
            {
                origin = (double)(ActualYAxis as LogarithmicAxis).Minimum;
            }

            if (xValues != null)
            {
                double x1, x2, y1, y2;
                ClearUnUsedSegments(this.DataCount);
                ClearUnUsedAdornments(this.DataCount);

                for (int i = 0; i < this.DataCount; i++)
                {
                    if (i < this.DataCount)
                    {
                        // Calculate the waterfall segment rendering values.
                        OnCalculateSegmentValues(
                            out x1,
                            out x2,
                            out y1,
                            out y2,
                            i,
                            origin,
                            xValues[i]);

                        WaterfallSegment segment = null;
                        bool             isSum   = false;
                        if (i < Segments.Count)
                        {
                            segment = Segments[i] as WaterfallSegment;

                            segment.SetData(x1, y1, x2, y2);
                            segment.XData = xValues[i];
                            segment.YData = YValues[i];
                            segment.Item  = ActualData[i];

                            if (segment.SegmentType == WaterfallSegmentType.Sum)
                            {
                                isSum = true;
                            }

                            // Update sum segment values.
                            OnUpdateSumSegmentValues(segment, i, isSum, origin);

                            segment.BindProperties();
                        }
                        else
                        {
                            segment = new WaterfallSegment(x1, y1, x2, y2, this)
                            {
                                XData = xValues[i],
                                YData = YValues[i],
                                Item  = ActualData[i]
                            };

                            // Raise segment created event.
                            isSum = RaiseSegmentCreatedEvent(segment, i);

                            // Update sum segment values.
                            OnUpdateSumSegmentValues(segment, i, isSum, origin);

                            Segments.Add(segment);
                        }

                        #region Adornment calculation

                        if (AdornmentsInfo != null)
                        {
                            if (segment.SegmentType == WaterfallSegmentType.Sum)
                            {
                                if (Segments.IndexOf(segment) > 0 && AllowAutoSum)
                                {
                                    if (this.AdornmentsInfo.AdornmentsPosition == AdornmentsPosition.TopAndBottom)
                                    {
                                        AddColumnAdornments(xValues[i], segment.WaterfallSum, x1, segment.WaterfallSum / 2, i, median);
                                    }
                                    else if (segment.WaterfallSum >= 0)
                                    {
                                        AddColumnAdornments(xValues[i], segment.WaterfallSum, x1, segment.Top, i, median);
                                    }
                                    else
                                    {
                                        AddColumnAdornments(xValues[i], segment.WaterfallSum, x1, segment.Bottom, i, median);
                                    }
                                }
                                else
                                {
                                    if (this.AdornmentsInfo.AdornmentsPosition == AdornmentsPosition.TopAndBottom)
                                    {
                                        AddColumnAdornments(xValues[i], YValues[i], x1, y1 + (y2 - y1) / 2, i, median);
                                    }
                                    else if (YValues[i] >= 0)
                                    {
                                        AddColumnAdornments(xValues[i], YValues[i], x1, segment.Top, i, median);
                                    }
                                    else
                                    {
                                        AddColumnAdornments(xValues[i], YValues[i], x1, segment.Bottom, i, median);
                                    }
                                }
                            }
                            else if (this.AdornmentsInfo.AdornmentsPosition == AdornmentsPosition.Top)
                            {
                                if (segment.SegmentType == WaterfallSegmentType.Positive)
                                {
                                    AddColumnAdornments(xValues[i], YValues[i], x1, y1, i, median);
                                }
                                else
                                {
                                    AddColumnAdornments(xValues[i], YValues[i], x1, y2, i, median);
                                }
                            }
                            else if (this.AdornmentsInfo.AdornmentsPosition == AdornmentsPosition.Bottom)
                            {
                                if (segment.SegmentType == WaterfallSegmentType.Positive)
                                {
                                    AddColumnAdornments(xValues[i], YValues[i], x1, y2, i, median);
                                }
                                else
                                {
                                    AddColumnAdornments(xValues[i], YValues[i], x1, y1, i, median);
                                }
                            }
                            else
                            {
                                AddColumnAdornments(xValues[i], YValues[i], x1, y1 + (y2 - y1) / 2, i, median);
                            }
                        }

                        #endregion
                    }
                }
            }

            this.ActualArea.IsUpdateLegend = true;
        }