コード例 #1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="obj">Object may be DataSeries or DataPoint</param>
        /// <param name="property"></param>
        /// <param name="newValue"></param>
        private static void UpdateDataSeries(ObservableObject obj, VcProperties property, object newValue)
        {
            DataPoint  dataPoint   = null;
            DataSeries dataSeries  = obj as DataSeries;
            Boolean    isDataPoint = false;

            if (dataSeries == null)
            {
                isDataPoint = true;
                dataPoint   = obj as DataPoint;
                dataSeries  = dataPoint.Parent;
            }

            Chart chart = dataSeries.Chart as Chart;

            if (chart == null)
            {
                return;
            }

            PlotGroup plotGroup      = dataSeries.PlotGroup;
            Canvas    line2dCanvas   = null;
            Canvas    label2dCanvas  = null;
            Path      linePath       = null;
            Path      lineShadowPath = null;

            if (dataSeries.Faces != null)
            {
                if (dataSeries.Faces.Parts.Count > 0)
                {
                    linePath = dataSeries.Faces.Parts[0] as Path;

                    if (dataSeries.Faces.Parts.Count > 1)
                    {
                        lineShadowPath = dataSeries.Faces.Parts[1] as Path;
                    }
                }

                line2dCanvas  = dataSeries.Faces.Visual as Canvas;
                label2dCanvas = dataSeries.Faces.LabelCanvas as Canvas;
            }
            else if (dataSeries.Faces == null && property == VcProperties.Enabled && (Boolean)newValue == true)
            {
                ColumnChart.Update(chart, dataSeries.RenderAs, (from ds in chart.InternalSeries where ds.RenderAs == RenderAs.QuickLine select ds).ToList());
                return;
            }
            else
            {
                return;
            }

            Double height = chart.ChartArea.ChartVisualCanvas.Height;
            Double width  = chart.ChartArea.ChartVisualCanvas.Width;

            switch (property)
            {
            case VcProperties.Color:
                if (linePath != null)
                {
                    Brush lineColorValue = (newValue != null) ? newValue as Brush : dataSeries.Color;

                    linePath.Stroke = ((Boolean)dataSeries.LightingEnabled) ? Graphics.GetLightingEnabledBrush(lineColorValue, "Linear", new Double[] { 0.65, 0.55 }) : lineColorValue;     //dataPoint.Color;
                }
                break;

            case VcProperties.LightingEnabled:
                if (linePath != null)
                {
                    linePath.Stroke = ((Boolean)newValue) ? Graphics.GetLightingEnabledBrush(dataSeries.Color, "Linear", new Double[] { 0.65, 0.55 }) : dataSeries.Color;
                }

                break;

            case VcProperties.Opacity:
                if (linePath != null)
                {
                    linePath.Opacity = (Double)dataSeries.Opacity;
                }
                break;

            case VcProperties.LineStyle:
            case VcProperties.LineThickness:

                if (lineShadowPath != null)
                {
                    lineShadowPath.StrokeThickness = (Double)dataSeries.LineThickness;
                }
                if (linePath != null)
                {
                    linePath.StrokeThickness = (Double)dataSeries.LineThickness;
                }

                if (lineShadowPath != null)
                {
                    lineShadowPath.StrokeDashArray = ExtendedGraphics.GetDashArray(dataSeries.LineStyle);
                }
                if (linePath != null)
                {
                    linePath.StrokeDashArray = ExtendedGraphics.GetDashArray(dataSeries.LineStyle);
                }

                break;

            case VcProperties.Enabled:

                if (!isDataPoint && line2dCanvas != null)
                {
                    if ((Boolean)newValue == false)
                    {
                        line2dCanvas.Visibility  = Visibility.Collapsed;
                        label2dCanvas.Visibility = Visibility.Collapsed;
                    }
                    else
                    {
                        if (line2dCanvas.Parent == null)
                        {
                            ColumnChart.Update(chart, dataSeries.RenderAs, (from ds in chart.InternalSeries where ds.RenderAs == RenderAs.QuickLine select ds).ToList());
                            return;
                        }

                        line2dCanvas.Visibility  = Visibility.Visible;
                        label2dCanvas.Visibility = Visibility.Visible;
                    }

                    chart._toolTip.Hide();

                    break;
                }

                goto RENDER_SERIES;

            case VcProperties.ShadowEnabled:
            case VcProperties.DataPoints:
            case VcProperties.YValue:
            case VcProperties.YValues:
            case VcProperties.XValue:
            case VcProperties.ViewportRangeEnabled:
            case VcProperties.DataPointUpdate:
RENDER_SERIES:

                LineChart.UpdateLineSeries(dataSeries, width, height, label2dCanvas);

                break;
            }
        }
コード例 #2
0
ファイル: RenderHelper.cs プロジェクト: tmpkus/openvss
        internal static void UpdateVisualObject(RenderAs chartType, Visifire.Commons.ObservableObject sender, VcProperties property, object newValue, Boolean isAXisChanged)
        {
            Boolean   isDataPoint = sender.GetType().Equals(typeof(DataPoint));
            DataPoint dataPoint   = sender as DataPoint;
            Chart     chart       = (sender as ObservableObject).Chart as Chart;

            switch (chartType)
            {
            case RenderAs.Column:
            case RenderAs.Bar:
                ColumnChart.Update(sender, property, newValue, isAXisChanged);
                //ColumnChart.GetVisualObjectForColumnChart(width, height, plotDetails, dataSeriesList4Rendering, chart, plankDepth, animationEnabled);
                break;

            // renderedCanvas = BarChart.GetVisualObjectForBarChart(width, height, plotDetails, dataSeriesList4Rendering, chart, plankDepth, animationEnabled);

            case RenderAs.Line:

                //if (isAXisChanged && isDataPoint && chart._partialUpdateAnimation)
                //{   foreach (DataSeries ds in chart.Series)
                //    {
                //        //if (ds == dataPoint.Parent)
                //        //    continue;

                //        foreach (DataPoint dp in ds.DataPoints)
                //        {
                //            RenderHelper.UpdateVisualObject(ds.RenderAs, dp, property, newValue, false);
                //        }
                //    }
                //}
                //else
                //    LineChart.Update(sender, property, newValue);

                LineChart.Update(sender, property, newValue, isAXisChanged);

                break;

            case RenderAs.Point:
                PointChart.Update(sender, property, newValue, isAXisChanged);
                //renderedCanvas = PointChart.GetVisualObjectForPointChart(width, height, plotDetails, dataSeriesList4Rendering, chart, plankDepth, animationEnabled);
                break;

            case RenderAs.Bubble:
                BubbleChart.Update(sender, property, newValue, isAXisChanged);
                //renderedCanvas = BubbleChart.GetVisualObjectForBubbleChart(width, height, plotDetails, dataSeriesList4Rendering, chart, plankDepth, animationEnabled);
                break;

            case RenderAs.Area:
                AreaChart.Update(sender, property, newValue, isAXisChanged);
                //renderedCanvas = AreaChart.GetVisualObjectForAreaChart(width, height, plotDetails, dataSeriesList4Rendering, chart, plankDepth, animationEnabled);
                break;

            case RenderAs.StackedColumn:
                ColumnChart.Update(sender, property, newValue, isAXisChanged);
                //renderedCanvas = ColumnChart.GetVisualObjectForStackedColumnChart(width, height, plotDetails, chart, plankDepth, animationEnabled);
                break;

            case RenderAs.StackedColumn100:
                ColumnChart.Update(sender, property, newValue, isAXisChanged);
                // renderedCanvas = ColumnChart.GetVisualObjectForStackedColumn100Chart(width, height, plotDetails, chart, plankDepth, animationEnabled);
                break;

            case RenderAs.StackedBar:
                ColumnChart.Update(sender, property, newValue, isAXisChanged);
                //renderedCanvas = BarChart.GetVisualObjectForStackedBarChart(width, height, plotDetails, chart, plankDepth, animationEnabled);
                break;

            case RenderAs.StackedBar100:
                ColumnChart.Update(sender, property, newValue, isAXisChanged);
                //renderedCanvas = BarChart.GetVisualObjectForStackedBar100Chart(width, height, plotDetails, chart, plankDepth, animationEnabled);
                break;

            case RenderAs.Pie:
                //renderedCanvas = PieChart.GetVisualObjectForPieChart(width, height, plotDetails, dataSeriesList4Rendering, chart, animationEnabled);
                break;

            case RenderAs.Doughnut:
                //renderedCanvas = PieChart.GetVisualObjectForDoughnutChart(width, height, plotDetails, dataSeriesList4Rendering, chart, animationEnabled);
                break;

            case RenderAs.StackedArea:
                //renderedCanvas = AreaChart.GetVisualObjectForStackedAreaChart(width, height, plotDetails, dataSeriesList4Rendering, chart, plankDepth, animationEnabled);
                break;

            case RenderAs.StackedArea100:
                //renderedCanvas = AreaChart.GetVisualObjectForStackedArea100Chart(width, height, plotDetails, dataSeriesList4Rendering, chart, plankDepth, animationEnabled);
                break;

            case RenderAs.SectionFunnel:
                //renderedCanvas = FunnelChart.GetVisualObjectForFunnelChart(width, height, plotDetails, dataSeriesList4Rendering, chart, animationEnabled, false);
                break;

            case RenderAs.StreamLineFunnel:
                //renderedCanvas = FunnelChart.GetVisualObjectForFunnelChart(width, height, plotDetails, dataSeriesList4Rendering, chart, animationEnabled, true);
                break;

            case RenderAs.Stock:
                StockChart.Update(sender, property, newValue, isAXisChanged);
                //renderedCanvas = StockChart.GetVisualObjectForStockChart(width, height, plotDetails, dataSeriesList4Rendering, chart, plankDepth, animationEnabled);
                break;

            case RenderAs.CandleStick:
                CandleStick.Update(sender, property, newValue, isAXisChanged);
                //renderedCanvas = CandleStick.GetVisualObjectForCandleStick(width, height, plotDetails, dataSeriesList4Rendering, chart, plankDepth, animationEnabled);
                break;
            }

            chart.ChartArea.AttachScrollEvents();
        }
コード例 #3
0
ファイル: RenderHelper.cs プロジェクト: zhangzy0193/visifire
        internal static void UpdateVisualObject(RenderAs chartType, Visifire.Commons.ObservableObject sender, VcProperties property, object newValue, Boolean isAXisChanged)
        {
            Boolean   isDataPoint = sender.GetType().Equals(typeof(DataPoint));
            DataPoint dataPoint   = sender as DataPoint;
            Chart     chart       = (sender as ObservableObject).Chart as Chart;

            switch (chartType)
            {
            case RenderAs.Column:
            case RenderAs.Bar:
                ColumnChart.Update(sender, property, newValue, isAXisChanged);
                break;

            case RenderAs.Line:
            case RenderAs.Spline:
                LineChart.Update(sender, property, newValue, isAXisChanged);

                break;

            case RenderAs.QuickLine:
                QuickLineChart.Update(sender, property, newValue, isAXisChanged);

                break;

            case RenderAs.StepLine:
                StepLineChart.Update(sender, property, newValue, isAXisChanged);

                break;

            case RenderAs.Point:
                PointChart.Update(sender, property, newValue, isAXisChanged);
                break;

            case RenderAs.Bubble:
                BubbleChart.Update(sender, property, newValue, isAXisChanged);
                break;

            case RenderAs.Area:
                AreaChart.Update(sender, property, newValue, isAXisChanged);
                break;

            case RenderAs.StackedColumn:
                ColumnChart.Update(sender, property, newValue, isAXisChanged);
                break;

            case RenderAs.StackedColumn100:
                ColumnChart.Update(sender, property, newValue, isAXisChanged);
                break;

            case RenderAs.StackedBar:
                ColumnChart.Update(sender, property, newValue, isAXisChanged);
                break;

            case RenderAs.StackedBar100:
                ColumnChart.Update(sender, property, newValue, isAXisChanged);
                break;

            case RenderAs.Pie:
                //renderedCanvas = PieChart.GetVisualObjectForPieChart(width, height, plotDetails, dataSeriesList4Rendering, chart, animationEnabled);
                break;

            case RenderAs.Doughnut:
                //renderedCanvas = PieChart.GetVisualObjectForDoughnutChart(width, height, plotDetails, dataSeriesList4Rendering, chart, animationEnabled);
                break;

            case RenderAs.StackedArea:
                List <DataSeries> stackedAreaList = (from ds in chart.Series where ds.RenderAs == RenderAs.StackedArea select ds).ToList();

                if (stackedAreaList.Count > 0)
                {
                    ColumnChart.Update(chart, stackedAreaList[0].RenderAs, stackedAreaList);
                }

                chart.ChartArea.AttachEventsToolTipHref2DataSeries();

                break;

            case RenderAs.StackedArea100:
                List <DataSeries> stackedArea100List = (from ds in chart.Series where ds.RenderAs == RenderAs.StackedArea select ds).ToList();

                if (stackedArea100List.Count > 0)
                {
                    ColumnChart.Update(chart, stackedArea100List[0].RenderAs, stackedArea100List);
                }

                chart.ChartArea.AttachEventsToolTipHref2DataSeries();
                break;

            case RenderAs.SectionFunnel:
            case RenderAs.StreamLineFunnel:
            case RenderAs.Pyramid:
                //renderedCanvas = FunnelChart.GetVisualObjectForFunnelChart(width, height, plotDetails, dataSeriesList4Rendering, chart, animationEnabled, true);
                break;

            case RenderAs.Stock:
                StockChart.Update(sender, property, newValue, isAXisChanged);
                break;

            case RenderAs.CandleStick:
                CandleStick.Update(sender, property, newValue, isAXisChanged);
                break;
            }

            //chart.ChartArea.AttachScrollEvents();
        }
コード例 #4
0
ファイル: RenderHelper.cs プロジェクト: tmpkus/openvss
        internal static void UpdateVisualObject(Chart chart, VcProperties property, object newValue, Boolean partialUpdate)
        {
            if (partialUpdate && chart._datapoint2UpdatePartially.Count <= 500)
            {
                chart.PARTIAL_DP_RENDER_LOCK = false;
                Boolean isNeed2UpdateAllSeries = false;

                foreach (KeyValuePair <DataPoint, VcProperties> dpInfo in chart._datapoint2UpdatePartially)
                {
                    DataPoint dp = dpInfo.Key;

                    if (dpInfo.Value == VcProperties.XValue)
                    {
                        isNeed2UpdateAllSeries = true;
                        break;
                    }

                    PropertyInfo pInfo = dp.GetType().GetProperty(dpInfo.Value.ToString());
                    newValue = pInfo.GetValue(dp, null);

                    isNeed2UpdateAllSeries = dpInfo.Key.UpdateVisual(dpInfo.Value, newValue, true);

                    if (isNeed2UpdateAllSeries)
                    {
                        break;
                    }
                }

                if (!isNeed2UpdateAllSeries)
                {
                    return;
                }
            }

            chart.ChartArea.PrePartialUpdateConfiguration(chart, VcProperties.None, null, null, false, true, true, AxisRepresentations.AxisY, true);

            //chart.ChartArea.RenderSeries();
            Int32 renderedSeriesCount = 0;      // Contain count of series that have been already rendered

            // Contains a list of serties as per the drawing order generated in the plotdetails
            List <DataSeries> dataSeriesListInDrawingOrder = chart.PlotDetails.SeriesDrawingIndex.Keys.ToList();

            List <DataSeries> selectedDataSeries4Rendering;         // Contains a list of serries to be rendered in a rendering cycle
            Int32             currentDrawingIndex;                  // Drawing index of the selected series
            RenderAs          currentRenderAs;                      // Rendereas type of the selected series

            // This loop will select series for rendering and it will repeat until all series have been rendered
            while (renderedSeriesCount < chart.InternalSeries.Count)
            {
                selectedDataSeries4Rendering = new List <DataSeries>();

                currentRenderAs = dataSeriesListInDrawingOrder[renderedSeriesCount].RenderAs;

                currentDrawingIndex = chart.PlotDetails.SeriesDrawingIndex[dataSeriesListInDrawingOrder[renderedSeriesCount]];

                for (Int32 i = renderedSeriesCount; i < chart.InternalSeries.Count; i++)
                {
                    DataSeries ds = dataSeriesListInDrawingOrder[i];
                    if (currentRenderAs == ds.RenderAs && currentDrawingIndex == chart.PlotDetails.SeriesDrawingIndex[ds])
                    {
                        selectedDataSeries4Rendering.Add(ds);
                    }
                }

                if (selectedDataSeries4Rendering.Count == 0)
                {
                    break;
                }

                chart._toolTip.Hide();

                switch (currentRenderAs)
                {
                case RenderAs.Column:
                case RenderAs.Bar:
                    ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering);
                    //ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering, property, newValue);
                    break;

                //renderedCanvas = BarChart.GetVisualObjectForBarChart(width, height, plotDetails, dataSeriesList4Rendering, chart, plankDepth, animationEnabled);

                case RenderAs.Line:

                    if (property == VcProperties.Enabled)
                    {
                        ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering);
                    }
                    //LineChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering, property, newValue);
                    else
                    {
                        //ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering);

                        foreach (DataSeries ds in selectedDataSeries4Rendering)
                        {
                            LineChart.Update(ds, property, newValue, false);
                        }
                    }
                    break;

                case RenderAs.Point:

                    foreach (DataSeries ds in selectedDataSeries4Rendering)
                    {
                        foreach (DataPoint dp in ds.InternalDataPoints)
                        {
                            RenderHelper.UpdateVisualObject(ds.RenderAs, dp, property, newValue, false);
                        }
                    }

                    // ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering);

                    break;

                case RenderAs.Bubble:

                    foreach (DataSeries ds in selectedDataSeries4Rendering)
                    {
                        foreach (DataPoint dp in ds.InternalDataPoints)
                        {
                            RenderHelper.UpdateVisualObject(ds.RenderAs, dp, property, newValue, false);
                        }
                    }

                    // ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering);

                    // BubbleChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering, property, newValue);

                    //renderedCanvas = BubbleChart.GetVisualObjectForBubbleChart(width, height, plotDetails, dataSeriesList4Rendering, chart, plankDepth, animationEnabled);
                    break;

                case RenderAs.Area:
                    ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering);

                    // AreaChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering, property, newValue);
                    //renderedCanvas = AreaChart.GetVisualObjectForAreaChart(width, height, plotDetails, dataSeriesList4Rendering, chart, plankDepth, animationEnabled);
                    break;

                case RenderAs.StackedColumn:
                    ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering);

                    //ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering, property, newValue);
                    //renderedCanvas = ColumnChart.GetVisualObjectForStackedColumnChart(width, height, plotDetails, chart, plankDepth, animationEnabled);
                    break;

                case RenderAs.StackedColumn100:
                    ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering);

                    //ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering, property, newValue);

                    //renderedCanvas = ColumnChart.GetVisualObjectForStackedColumn100Chart(width, height, plotDetails, chart, plankDepth, animationEnabled);
                    break;

                case RenderAs.StackedBar:
                    ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering);

                    //ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering, property, newValue);
                    //renderedCanvas = BarChart.GetVisualObjectForStackedBarChart(width, height, plotDetails, chart, plankDepth, animationEnabled);
                    break;

                case RenderAs.StackedBar100:
                    ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering);

                    //ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering, property, newValue);

                    //renderedCanvas = BarChart.GetVisualObjectForStackedBar100Chart(width, height, plotDetails, chart, plankDepth, animationEnabled);
                    break;

                case RenderAs.Pie:
                    //renderedCanvas = PieChart.GetVisualObjectForPieChart(width, height, plotDetails, dataSeriesList4Rendering, chart, animationEnabled);
                    break;

                case RenderAs.Doughnut:
                    //renderedCanvas = PieChart.GetVisualObjectForDoughnutChart(width, height, plotDetails, dataSeriesList4Rendering, chart, animationEnabled);
                    break;

                case RenderAs.StackedArea:
                    //renderedCanvas = AreaChart.GetVisualObjectForStackedAreaChart(width, height, plotDetails, dataSeriesList4Rendering, chart, plankDepth, animationEnabled);
                    break;

                case RenderAs.StackedArea100:
                    //renderedCanvas = AreaChart.GetVisualObjectForStackedArea100Chart(width, height, plotDetails, dataSeriesList4Rendering, chart, plankDepth, animationEnabled);
                    break;

                case RenderAs.SectionFunnel:
                    // renderedCanvas = FunnelChart.GetVisualObjectForFunnelChart(width, height, plotDetails, dataSeriesList4Rendering, chart, animationEnabled, false);

                    break;

                case RenderAs.StreamLineFunnel:
                    //renderedCanvas = FunnelChart.GetVisualObjectForFunnelChart(width, height, plotDetails, dataSeriesList4Rendering, chart, animationEnabled, true);
                    break;

                case RenderAs.Stock:
                    ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering);

                    //StockChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering, property, newValue);
                    // renderedCanvas = StockChart.GetVisualObjectForStockChart(width, height, plotDetails, dataSeriesList4Rendering, chart, plankDepth, animationEnabled);
                    break;

                case RenderAs.CandleStick:
                    ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering);
                    // CandleStick.Update(chart, currentRenderAs, selectedDataSeries4Rendering, property, newValue);
                    // renderedCanvas = CandleStick.GetVisualObjectForCandleStick(width, height, plotDetails, dataSeriesList4Rendering, chart, plankDepth, animationEnabled);
                    break;
                }

                //renderedChart = RenderSeriesFromList(selectedDataSeries4Rendering);

                renderedSeriesCount += selectedDataSeries4Rendering.Count;
            }

            chart.ChartArea.AttachScrollEvents();
            Visifire.Charts.Chart.SelectDataPoints(chart);
            //AttachEventsToolTipHref2DataSeries();
        }
コード例 #5
0
ファイル: RenderHelper.cs プロジェクト: zhangzy0193/visifire
        internal static void UpdateVisualObject(Chart chart, VcProperties property, object newValue, Boolean partialUpdate)
        {
            if (!chart._internalPartialUpdateEnabled || Double.IsNaN(chart.ActualWidth) || Double.IsNaN(chart.ActualHeight) || chart.ActualWidth == 0 || chart.ActualHeight == 0)
            {
                return;
            }

            if (partialUpdate && chart._datapoint2UpdatePartially.Count <= 500)
            {
                chart.PARTIAL_DP_RENDER_LOCK = false;
                Boolean isNeed2UpdateAllSeries = false;

                List <DataSeries> _dataSeries2UpdateAtSeriesWise = (from value in chart._datapoint2UpdatePartially
                                                                    where value.Key.Parent.RenderAs == RenderAs.Spline || value.Key.Parent.RenderAs == RenderAs.QuickLine
                                                                    select value.Key.Parent).Distinct().ToList();

                foreach (DataSeries splineDs in _dataSeries2UpdateAtSeriesWise)
                {
                    splineDs.UpdateVisual(VcProperties.DataPointUpdate, null);
                }

                List <KeyValuePair <DataPoint, VcProperties> > remainingDpInfo = (from dpInfo in chart._datapoint2UpdatePartially where !_dataSeries2UpdateAtSeriesWise.Contains(dpInfo.Key.Parent) select dpInfo).ToList();

                // If there is nothing to render anymore
                if (remainingDpInfo.Count == 0)
                {
                    return;
                }

                foreach (KeyValuePair <DataPoint, VcProperties> dpInfo in remainingDpInfo)
                {
                    DataPoint dp = dpInfo.Key;

                    if (dp.Parent.RenderAs == RenderAs.Spline || dp.Parent.RenderAs == RenderAs.QuickLine)
                    {
                        isNeed2UpdateAllSeries = false;
                        continue;
                    }

                    if (dpInfo.Value == VcProperties.XValue)
                    {
                        isNeed2UpdateAllSeries = true;
                        break;
                    }

                    PropertyInfo pInfo = dp.GetType().GetProperty(dpInfo.Value.ToString());
                    newValue = pInfo.GetValue(dp, null);

                    isNeed2UpdateAllSeries = dpInfo.Key.UpdateVisual(dpInfo.Value, newValue, true);

                    if (isNeed2UpdateAllSeries)
                    {
                        break;
                    }
                }

                if (!isNeed2UpdateAllSeries)
                {
                    return;
                }
            }

            chart.ChartArea.PrePartialUpdateConfiguration(chart, Visifire.Charts.ElementTypes.Chart, VcProperties.None, null, null, false, true, true, AxisRepresentations.AxisY, true);

            Int32 renderedSeriesCount = 0;      // Contain count of series that have been already rendered

            // Contains a list of serties as per the drawing order generated in the plotdetails
            List <DataSeries> dataSeriesListInDrawingOrder = chart.PlotDetails.SeriesDrawingIndex.Keys.ToList();

            List <DataSeries> selectedDataSeries4Rendering;         // Contains a list of serries to be rendered in a rendering cycle
            Int32             currentDrawingIndex;                  // Drawing index of the selected series
            RenderAs          currentRenderAs;                      // Rendereas type of the selected series

            // This loop will select series for rendering and it will repeat until all series have been rendered
            while (renderedSeriesCount < chart.InternalSeries.Count)
            {
                selectedDataSeries4Rendering = new List <DataSeries>();

                currentRenderAs = dataSeriesListInDrawingOrder[renderedSeriesCount].RenderAs;

                currentDrawingIndex = chart.PlotDetails.SeriesDrawingIndex[dataSeriesListInDrawingOrder[renderedSeriesCount]];

                for (Int32 i = renderedSeriesCount; i < chart.InternalSeries.Count; i++)
                {
                    DataSeries ds = dataSeriesListInDrawingOrder[i];
                    if (currentRenderAs == ds.RenderAs && currentDrawingIndex == chart.PlotDetails.SeriesDrawingIndex[ds])
                    {
                        selectedDataSeries4Rendering.Add(ds);
                    }
                }

                if (selectedDataSeries4Rendering.Count == 0)
                {
                    break;
                }

                chart._toolTip.Hide();

                if (selectedDataSeries4Rendering.Count > 0)
                {
                    if (selectedDataSeries4Rendering[0].ToolTipElement != null)
                    {
                        selectedDataSeries4Rendering[0].ToolTipElement.Hide();
                    }
                }

                chart.ChartArea.DisableIndicators();

                switch (currentRenderAs)
                {
                case RenderAs.Column:
                case RenderAs.Bar:
                    ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering);
                    break;

                case RenderAs.Spline:
                case RenderAs.QuickLine:
                    if (property == VcProperties.Enabled)
                    {
                        ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering);
                    }
                    else
                    {
                        foreach (DataSeries ds in selectedDataSeries4Rendering)
                        {
                            UpdateVisualObject(ds.RenderAs, ds, property, newValue, false);
                        }
                    }

                    break;

                case RenderAs.Line:
                    if (property == VcProperties.Enabled)
                    {
                        ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering);
                    }
                    else
                    {
                        foreach (DataSeries ds in selectedDataSeries4Rendering)
                        {
                            LineChart.Update(ds, property, newValue, false);
                        }
                    }
                    break;

                case RenderAs.StepLine:

                    if (property == VcProperties.Enabled)
                    {
                        ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering);
                    }
                    else
                    {
                        foreach (DataSeries ds in selectedDataSeries4Rendering)
                        {
                            StepLineChart.Update(ds, property, newValue, false);
                        }
                    }
                    break;


                case RenderAs.Point:
                    if (property == VcProperties.ViewportRangeEnabled)
                    {
                        ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering);
                    }
                    else
                    {
                        foreach (DataSeries ds in selectedDataSeries4Rendering)
                        {
                            PointChart.Update(ds, property, newValue, false);
                        }
                    }
                    break;

                case RenderAs.Bubble:
                    if (property == VcProperties.ViewportRangeEnabled)
                    {
                        ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering);
                    }
                    else
                    {
                        foreach (DataSeries ds in selectedDataSeries4Rendering)
                        {
                            BubbleChart.Update(ds, property, newValue, false);
                        }
                    }
                    break;

                case RenderAs.Area:
                    ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering);
                    break;

                case RenderAs.StackedColumn:
                    ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering);
                    break;

                case RenderAs.StackedColumn100:
                    ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering);
                    break;

                case RenderAs.StackedBar:
                    ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering);
                    break;

                case RenderAs.StackedBar100:
                    ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering);
                    break;

                case RenderAs.Pie:
                    //renderedCanvas = PieChart.GetVisualObjectForPieChart(width, height, plotDetails, dataSeriesList4Rendering, chart, animationEnabled);
                    break;

                case RenderAs.Doughnut:
                    //renderedCanvas = PieChart.GetVisualObjectForDoughnutChart(width, height, plotDetails, dataSeriesList4Rendering, chart, animationEnabled);
                    break;

                case RenderAs.StackedArea:
                    ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering);
                    chart.ChartArea.AttachEventsToolTipHref2DataSeries();
                    break;

                case RenderAs.StackedArea100:
                    ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering);
                    chart.ChartArea.AttachEventsToolTipHref2DataSeries();
                    break;

                case RenderAs.SectionFunnel:
                case RenderAs.StreamLineFunnel:
                case RenderAs.Pyramid:
                    //renderedCanvas = FunnelChart.GetVisualObjectForFunnelChart(width, height, plotDetails, dataSeriesList4Rendering, chart, animationEnabled, true);
                    break;

                case RenderAs.Stock:
                    ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering);
                    break;

                case RenderAs.CandleStick:
                    ColumnChart.Update(chart, currentRenderAs, selectedDataSeries4Rendering);
                    break;
                }

                renderedSeriesCount += selectedDataSeries4Rendering.Count;
            }

            chart.ChartArea.AttachScrollBarOffsetChangedEventWithAxes();

            chart.ChartArea.AttachOrDetachIntaractivity(chart.InternalSeries);
            Visifire.Charts.Chart.SelectDataPoints(chart);
            //AttachEventsToolTipHref2DataSeries();
        }