예제 #1
0
        //internal static void Update(Chart chart, RenderAs currentRenderAs, List<DataSeries> selectedDataSeries4Rendering, VcProperties property, object newValue)
        //{
        //    Boolean is3D = chart.View3D;
        //    ChartArea chartArea = chart.ChartArea;
        //    Canvas ChartVisualCanvas = chart.ChartArea.ChartVisualCanvas;

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

        //    Panel preExistingPanel = null;
        //    Dictionary<RenderAs, Panel> RenderedCanvasList = chart.ChartArea.RenderedCanvasList;

        //    if (chartArea.RenderedCanvasList.ContainsKey(currentRenderAs))
        //    {
        //        preExistingPanel = RenderedCanvasList[currentRenderAs];
        //    }

        //    Panel renderedChart = chartArea.RenderSeriesFromList(preExistingPanel, selectedDataSeries4Rendering);

        //    if (preExistingPanel == null)
        //    {
        //        chartArea.RenderedCanvasList.Add(currentRenderAs, renderedChart);
        //        ChartVisualCanvas.Children.Add(renderedChart);
        //    }
        //}

        /// <summary>
        ///
        /// </summary>
        /// <param name="dataPoint"></param>
        /// <param name="property"></param>
        /// <param name="newValue"></param>
        /// <param name="isAxisChanged"></param>
        private static void UpdateDataPoint(DataPoint dataPoint, VcProperties property, object newValue, Boolean isAxisChanged)
        {
            Chart       chart       = dataPoint.Chart as Chart;
            PlotDetails plotDetails = chart.PlotDetails;
            Marker      marker      = dataPoint.Marker;
            DataSeries  dataSeries  = dataPoint.Parent;

            Canvas pointChartCanvas = dataSeries.Faces.Visual as Canvas;

            Double plotHeight = chart.ChartArea.ChartVisualCanvas.Height;
            Double plotWidth  = chart.ChartArea.ChartVisualCanvas.Width;

            ColumnChart.UpdateParentVisualCanvasSize(chart, pointChartCanvas);

            if (property == VcProperties.Enabled)
            {
                CreateOrUpdateAPointDataPoint(pointChartCanvas, dataPoint, plotWidth, plotHeight);
                return;
            }

            if (dataPoint.Faces == null)
            {
                return;
            }

            Grid bubbleVisual = dataPoint.Faces.Visual as Grid;

            switch (property)
            {
            case VcProperties.Bevel:
                break;

            case VcProperties.Cursor:
                break;

            case VcProperties.Href:
                dataPoint.SetHref2DataPointVisualFaces();
                break;

            case VcProperties.HrefTarget:
                dataPoint.SetHref2DataPointVisualFaces();
                break;

            case VcProperties.LabelBackground:
                if (marker != null)
                {
                    marker.TextBackground = dataPoint.LabelBackground;
                }
                break;

            case VcProperties.LabelEnabled:
                CreateOrUpdateAPointDataPoint(pointChartCanvas, dataPoint, plotWidth, plotHeight);
                //if (marker != null)
                //    marker.LabelEnabled = (Boolean)dataPoint.LabelEnabled;
                break;

            case VcProperties.LabelFontColor:
                if (marker != null)
                {
                    marker.FontColor = dataPoint.LabelFontColor;
                }

                break;

            case VcProperties.LabelFontFamily:
                if (marker != null)
                {
                    marker.FontFamily = dataPoint.LabelFontFamily;
                }
                break;

            case VcProperties.LabelFontStyle:
                if (marker != null)
                {
                    marker.FontStyle = (FontStyle)dataPoint.LabelFontStyle;
                }
                break;

            //case VcProperties.LabelFontSize:
            //    if (marker != null)
            //        marker.FontSize = (Double)dataPoint.LabelFontSize;
            //    break;

            case VcProperties.LabelFontWeight:
                if (marker != null)
                {
                    marker.FontWeight = (FontWeight)dataPoint.LabelFontWeight;
                }
                break;

            case VcProperties.LabelAngle:
                if (marker != null)
                {
                    marker.FontWeight = (FontWeight)dataPoint.LabelFontWeight;
                }
                break;

            case VcProperties.LegendText:
                chart.InvokeRender();
                break;

            case VcProperties.Color:
            case VcProperties.LightingEnabled:
                if (marker != null)
                {
                    marker.MarkerShape.Fill = (chart.View3D ? Graphics.Get3DBrushLighting(dataPoint.Color, (Boolean)dataPoint.LightingEnabled) : ((Boolean)dataPoint.LightingEnabled ? Graphics.GetLightingEnabledBrush(dataPoint.Color, "Linear", null) : dataPoint.Color));
                }
                break;

            case VcProperties.MarkerBorderColor:
                if (marker != null)
                {
                    marker.BorderColor = dataPoint.MarkerBorderColor;
                }
                break;

            case VcProperties.MarkerBorderThickness:
                if (marker != null)
                {
                    marker.BorderThickness = dataPoint.MarkerBorderThickness.Value.Left;
                }
                break;

            case VcProperties.MarkerColor:
                if (marker != null)
                {
                    marker.MarkerFillColor = dataPoint.MarkerColor;
                }
                break;

            case VcProperties.LabelFontSize:
            case VcProperties.LabelStyle:
            case VcProperties.LabelText:
            case VcProperties.MarkerScale:
            case VcProperties.MarkerSize:
            case VcProperties.MarkerType:
                CreateOrUpdateAPointDataPoint(pointChartCanvas, dataPoint, plotWidth, plotHeight);
                break;

            case VcProperties.ShadowEnabled:
                if (marker != null)
                {
                    marker.ShadowEnabled = (Boolean)dataPoint.ShadowEnabled;
                    marker.ApplyRemoveShadow();
                }

                break;

            case VcProperties.Opacity:
                if (marker != null)
                {
                    marker.Visual.Opacity = dataPoint.Opacity * dataSeries.Opacity;
                }
                break;

            case VcProperties.ShowInLegend:
                chart.InvokeRender();
                break;

            case VcProperties.ToolTipText:
                dataPoint._parsedToolTipText = dataPoint.TextParser(dataPoint.ToolTipText);
                break;

            case VcProperties.XValueFormatString:
            case VcProperties.YValueFormatString:
                dataPoint._parsedToolTipText = dataPoint.TextParser(dataPoint.ToolTipText);
                CreateOrUpdateAPointDataPoint(pointChartCanvas, dataPoint, plotWidth, plotHeight);
                break;

            case VcProperties.XValueType:
                chart.InvokeRender();
                break;

            case VcProperties.XValue:
            case VcProperties.YValue:
                if (isAxisChanged)
                {
                    UpdateDataSeries(dataSeries, property, newValue, false);
                }
                else
                if (marker != null)
                {
                    dataPoint._parsedToolTipText = dataPoint.TextParser(dataPoint.ToolTipText);

                    if ((Boolean)dataPoint.LabelEnabled)
                    {
                        marker.Text = dataPoint.TextParser(dataPoint.LabelText);
                    }

                    BubbleChart.UpdateBubblePositionAccording2XandYValue(dataPoint, plotWidth, plotHeight, chart.AnimatedUpdate, marker.MarkerShape.Width, marker.MarkerShape.Width);
                }

                break;
            }

            if (pointChartCanvas.Parent != null)
            {
                Double tickLengthOfAxisX = (from tick in chart.AxesX[0].Ticks
                                            where (Boolean)chart.AxesX[0].Enabled && (Boolean)tick.Enabled
                                            select tick.TickLength).Sum();

                if (tickLengthOfAxisX == 0)
                {
                    tickLengthOfAxisX = 5;
                }

                Double tickLengthOfPrimaryAxisY = (from axis in chart.AxesY
                                                   where axis.AxisType == AxisTypes.Primary
                                                   from tick in axis.Ticks
                                                   where (Boolean)axis.Enabled && (Boolean)tick.Enabled
                                                   select tick.TickLength).Sum();

                if (tickLengthOfPrimaryAxisY == 0)
                {
                    tickLengthOfPrimaryAxisY = 8;
                }

                Double tickLengthOfSecondaryAxisY = (from axis in chart.AxesY
                                                     where axis.AxisType == AxisTypes.Secondary
                                                     from tick in axis.Ticks
                                                     where (Boolean)axis.Enabled && (Boolean)tick.Enabled
                                                     select tick.TickLength).Sum();

                if (tickLengthOfSecondaryAxisY == 0)
                {
                    tickLengthOfSecondaryAxisY = 8;
                }

                Double plotGroupCount = (from c in chart.PlotDetails.PlotGroups
                                         where c.AxisY.AxisType == AxisTypes.Secondary
                                         select c).Count();

                RectangleGeometry clipRectangle = new RectangleGeometry();
                clipRectangle.Rect = new Rect(-tickLengthOfPrimaryAxisY, -chart.ChartArea.PLANK_DEPTH - 4, plotWidth + tickLengthOfSecondaryAxisY + (plotGroupCount > 0 ? tickLengthOfPrimaryAxisY : 8) + chart.ChartArea.PLANK_OFFSET, plotHeight + chart.ChartArea.PLANK_DEPTH + chart.ChartArea.PLANK_THICKNESS + tickLengthOfAxisX + 4);
                (pointChartCanvas.Parent as Canvas).Clip = clipRectangle;
            }
        }
예제 #2
0
        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
        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
        internal static Panel GetVisualObject(Panel preExistingPanel, RenderAs chartType, Double width, Double height, PlotDetails plotDetails, List <DataSeries> dataSeriesList4Rendering, Chart chart, Double plankDepth, bool animationEnabled)
        {
            Panel renderedCanvas = null;

            switch (chartType)
            {
            case RenderAs.Column:
                renderedCanvas = ColumnChart.GetVisualObjectForColumnChart(preExistingPanel, width, height, plotDetails, dataSeriesList4Rendering, chart, plankDepth, animationEnabled);
                break;

            case RenderAs.Bar:
                renderedCanvas = ColumnChart.GetVisualObjectForColumnChart(preExistingPanel, width, height, plotDetails, dataSeriesList4Rendering, chart, plankDepth, animationEnabled);

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

            case RenderAs.Line:
                renderedCanvas = LineChart.GetVisualObjectForLineChart(preExistingPanel, width, height, plotDetails, dataSeriesList4Rendering, chart, plankDepth, animationEnabled);
                break;

            case RenderAs.Point:
                renderedCanvas = PointChart.GetVisualObjectForPointChart(preExistingPanel, width, height, plotDetails, dataSeriesList4Rendering, chart, plankDepth, animationEnabled);
                break;

            case RenderAs.Bubble:
                renderedCanvas = BubbleChart.GetVisualObjectForBubbleChart(preExistingPanel, width, height, plotDetails, dataSeriesList4Rendering, chart, plankDepth, animationEnabled);
                break;

            case RenderAs.Area:
                renderedCanvas = AreaChart.GetVisualObjectForAreaChart(preExistingPanel, width, height, plotDetails, dataSeriesList4Rendering, chart, plankDepth, animationEnabled);
                break;

            case RenderAs.StackedColumn:
                renderedCanvas = ColumnChart.GetVisualObjectForStackedColumnChart(chartType, preExistingPanel, width, height, plotDetails, chart, plankDepth, animationEnabled);
                break;

            case RenderAs.StackedColumn100:
                renderedCanvas = ColumnChart.GetVisualObjectForStackedColumnChart(chartType, preExistingPanel, width, height, plotDetails, chart, plankDepth, animationEnabled);

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

            case RenderAs.StackedBar:
                renderedCanvas = BarChart.GetVisualObjectForStackedBarChart(chartType, preExistingPanel, width, height, plotDetails, chart, plankDepth, animationEnabled);
                break;

            case RenderAs.StackedBar100:
                renderedCanvas = BarChart.GetVisualObjectForStackedBarChart(chartType, preExistingPanel, width, height, plotDetails, chart, plankDepth, animationEnabled);

                // 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(preExistingPanel, width, height, plotDetails, dataSeriesList4Rendering, chart, plankDepth, animationEnabled);
                break;

            case RenderAs.StackedArea100:
                renderedCanvas = AreaChart.GetVisualObjectForStackedArea100Chart(preExistingPanel, 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:
                renderedCanvas = StockChart.GetVisualObjectForStockChart(preExistingPanel, width, height, plotDetails, dataSeriesList4Rendering, chart, plankDepth, animationEnabled);
                break;

            case RenderAs.CandleStick:
                renderedCanvas = CandleStick.GetVisualObjectForCandleStick(preExistingPanel, width, height, plotDetails, dataSeriesList4Rendering, chart, plankDepth, animationEnabled);
                break;
            }

            return(renderedCanvas);
        }
예제 #5
0
        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();
        }