Esempio n. 1
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();
        }
Esempio n. 2
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();
        }