protected override void OnInitializeOriginalChartSettings()
        {
            base.OnInitializeOriginalChartSettings();
            if (SupportChartView != null && OriginalChartView != null)
            {
                /*
                 * Properties could not set
                 * DrawRoundedSlices
                 * AbsoluteAngles
                 * DrawAngles
                 */
                if (SupportChartView.DrawEntryLabels.HasValue)
                {
                    OriginalChartView.SetDrawEntryLabels(SupportChartView.DrawEntryLabels.Value);
                }

                if (SupportChartView.DrawHole.HasValue)
                {
                    OriginalChartView.DrawHoleEnabled = SupportChartView.DrawHole.Value;
                }

                if (SupportChartView.DrawSlicesUnderHole.HasValue)
                {
                    OriginalChartView.SetDrawSlicesUnderHole(SupportChartView.DrawSlicesUnderHole.Value);
                }

                if (SupportChartView.UsePercentValues.HasValue)
                {
                    OriginalChartView.SetUsePercentValues(SupportChartView.UsePercentValues.Value);
                }

                OriginalChartView.CenterText = (SupportChartView.CenterText);

                if (SupportChartView.HoleRadiusPercent.HasValue)
                {
                    OriginalChartView.HoleRadius = (SupportChartView.HoleRadiusPercent.Value);
                }

                if (SupportChartView.TransparentCircleRadiusPercent.HasValue)
                {
                    OriginalChartView.TransparentCircleRadius = (SupportChartView.TransparentCircleRadiusPercent.Value);
                }

                if (SupportChartView.CenterTextRadiusPercent.HasValue)
                {
                    OriginalChartView.CenterTextRadiusPercent = (SupportChartView.CenterTextRadiusPercent.Value);
                }

                if (SupportChartView.MaxAngle.HasValue)
                {
                    OriginalChartView.MaxAngle = (SupportChartView.MaxAngle.Value);
                }

                if (SupportChartView.DrawCenterText.HasValue)
                {
                    OriginalChartView.SetDrawCenterText(SupportChartView.DrawCenterText.Value);
                }
            }
        }
Exemple #2
0
 protected override void OnInitializeChartData()
 {
     base.OnInitializeChartData();
     if (OriginalChartView != null && SupportChartView != null && SupportChartView.ChartData != null)
     {
         OriginalChartView.Data = Export.ExportBubbleData(SupportChartView.ChartData);
         OriginalChartView.Invalidate();
     }
 }
 protected override void OnInitializeChartData()
 {
     base.OnInitializeChartData();
     if (OriginalChartView != null && SupportChartView != null && SupportChartView.ChartData != null)
     {
         OriginalChartView.Data = Export.ExportCandleStickData(SupportChartView.ChartData);
         OriginalChartView.ReloadInputViews();
         OriginalChartView.SetNeedsDisplay();
     }
 }
        protected override void OnInitializeOriginalChartSettings()
        {
            base.OnInitializeOriginalChartSettings();
            if (SupportChartView != null && OriginalChartView != null)
            {
                /*
                 * Properties could not set
                 */
                if (SupportChartView.WebLineWidth.HasValue)
                {
                    OriginalChartView.WebLineWidth = (SupportChartView.WebLineWidth.Value);
                }

                if (SupportChartView.InnerWebLineWidth.HasValue)
                {
                    OriginalChartView.WebLineWidthInner = SupportChartView.InnerWebLineWidth.Value;
                }

                if (SupportChartView.WebColor.HasValue)
                {
                    OriginalChartView.WebColor = (SupportChartView.WebColor.Value.ToAndroid());
                }

                if (SupportChartView.WebColorInner.HasValue)
                {
                    OriginalChartView.WebColorInner = (SupportChartView.WebColorInner.Value.ToAndroid());
                }

                if (SupportChartView.WebAlpha.HasValue)
                {
                    OriginalChartView.WebAlpha = (SupportChartView.WebAlpha.Value);
                }

                if (SupportChartView.DrawWeb.HasValue)
                {
                    OriginalChartView.SetDrawWeb(SupportChartView.DrawWeb.Value);
                }

                if (SupportChartView.SkipWebLineCount.HasValue)
                {
                    OriginalChartView.SkipWebLineCount = (SupportChartView.SkipWebLineCount.Value);
                }
            }
        }
        protected override void OnInitializeChartData()
        {
            base.OnInitializeChartData();
            if (OriginalChartView != null && SupportChartView != null && SupportChartView.ChartData != null)
            {
                var dataSupport   = SupportChartView.ChartData;
                var dataSetSource = dataSupport.DataSets.FirstOrDefault();

                if (dataSetSource != null)
                {
                    var        entryOriginal = dataSetSource.IF_GetValues().Select(item => new PieEntry(item.GetPercent(), item.GetText()));
                    PieDataSet dataSet       = new PieDataSet(entryOriginal.ToArray(), dataSetSource.IF_GetLabel());
                    OnIntializeDataSet(dataSetSource, dataSet);
                    var data = new PieData(dataSet);
                    OriginalChartView.Data = data;
                }
                OriginalChartView.Invalidate();
            }
        }
        protected override void OnInitializeChartData()
        {
            base.OnInitializeChartData();
            if (OriginalChartView != null && SupportChartView != null && SupportChartView.ChartData != null)
            {
                var dataSetItems     = SupportChartView.ChartData.DataSets;
                var listDataSetItems = new List <RadarDataSet>();

                foreach (var itemChild in dataSetItems)
                {
                    var          entryOriginal = itemChild.IF_GetValues().Select(item => new RadarEntry(item.GetValue()));
                    RadarDataSet dataSet       = new RadarDataSet(entryOriginal.ToArray(), itemChild.IF_GetLabel());
                    OnIntializeDataSet(itemChild, dataSet);
                    listDataSetItems.Add(dataSet);
                }

                RadarData data = new RadarData(listDataSetItems.ToArray());
                OriginalChartView.Data = data;
                OriginalChartView.Invalidate();
            }
        }
Exemple #7
0
        protected override void OnInitializeChartData()
        {
            base.OnInitializeChartData();
            if (OriginalChartView != null && SupportChartView != null && SupportChartView.ChartData != null)
            {
                var dataSetItems = new List <BarChartDataSet>();

                foreach (var item in SupportChartView.ChartData.DataSets)
                {
                    var entryOriginal = item.IF_GetValues().Select(obj => new BarChartDataEntry(obj.GetXPosition(), obj.GetYPosition()));
                    var dataSet       = new BarChartDataSet(entryOriginal.ToArray(), item.IF_GetLabel());
                    OnIntializeDataSet(item, dataSet);
                    dataSetItems.Add(dataSet);
                }
                var data = new BarChartData(dataSetItems.ToArray());
                OriginalChartView.Data = data;

                OriginalChartView.ReloadInputViews();
                OriginalChartView.SetNeedsDisplay();
            }
        }
        protected override void OnInitializeChartData()
        {
            base.OnInitializeChartData();
            if (OriginalChartView != null && SupportChartView != null && SupportChartView.ChartData != null)
            {
                var data   = SupportChartView.ChartData;
                var combin = new CombinedChartData();

                if (data.BubbleChartData != null)
                {
                    combin.BubbleData = (Export.ExportBubbleData(data.BubbleChartData));
                }

                if (data.LineChartData != null)
                {
                    combin.LineData = (Export.ExportLineData(data.LineChartData));
                }

                if (data.BarChartData != null)
                {
                    combin.BarData = (Export.ExportBarData(data.BarChartData));
                }

                if (data.ScatterChartData != null)
                {
                    combin.ScatterData = (Export.ExportScatterData(data.ScatterChartData));
                }

                if (data.CandleStickChartData != null)
                {
                    combin.CandleData = (Export.ExportCandleStickData(data.CandleStickChartData));
                }

                OriginalChartView.Data = combin;
                OriginalChartView.ReloadInputViews();
                OriginalChartView.SetNeedsDisplay();
            }
        }
        protected override void OnInitializeChartData()
        {
            base.OnInitializeChartData();
            if (OriginalChartView != null && SupportChartView != null && SupportChartView.ChartData != null)
            {
                var data   = SupportChartView.ChartData;
                var combin = new CombinedData();

                if (data.BubbleChartData != null)
                {
                    combin.SetData(Export.ExportBubbleData(data.BubbleChartData));
                }

                if (data.LineChartData != null)
                {
                    combin.SetData(Export.ExportLineData(data.LineChartData));
                }

                if (data.BarChartData != null)
                {
                    combin.SetData(Export.ExportBarData(data.BarChartData));
                }

                if (data.ScatterChartData != null)
                {
                    combin.SetData(Export.ExportScatterData(data.ScatterChartData));
                }

                if (data.CandleStickChartData != null)
                {
                    combin.SetData(Export.ExportCandleStickData(data.CandleStickChartData));
                }

                OriginalChartView.Data = combin;
                OriginalChartView.Invalidate();
            }
        }
        protected override void OnInitializeOriginalChartSettings()
        {
            base.OnInitializeOriginalChartSettings();
            if (SupportChartView != null && OriginalChartView != null)
            {
                /*
                 * Properties could not set
                 */
                if (SupportChartView.AutoScaleMinMaxEnabled.HasValue)
                {
                    OriginalChartView.AutoScaleMinMaxEnabled = SupportChartView.AutoScaleMinMaxEnabled.Value;
                }

                if (SupportChartView.PinchZoomEnabled.HasValue)
                {
                    OriginalChartView.SetPinchZoom(SupportChartView.PinchZoomEnabled.Value);
                }

                if (SupportChartView.DoubleTapToZoomEnabled.HasValue)
                {
                    OriginalChartView.DoubleTapToZoomEnabled = SupportChartView.DoubleTapToZoomEnabled.Value;
                }

                if (SupportChartView.DragXEnabled.HasValue)
                {
                    OriginalChartView.DragEnabled = SupportChartView.DragXEnabled.Value;
                }

                if (SupportChartView.DragYEnabled.HasValue)
                {
                    OriginalChartView.DragEnabled = SupportChartView.DragYEnabled.Value;
                }

                if (SupportChartView.ScaleXEnabled.HasValue)
                {
                    OriginalChartView.ScaleXEnabled = SupportChartView.ScaleXEnabled.Value;
                }

                if (SupportChartView.ScaleYEnabled.HasValue)
                {
                    OriginalChartView.ScaleYEnabled = SupportChartView.ScaleYEnabled.Value;
                }

                if (SupportChartView.DrawGridBackground.HasValue)
                {
                    OriginalChartView.SetDrawGridBackground(SupportChartView.DrawGridBackground.Value);
                }

                if (SupportChartView.DrawBorders.HasValue)
                {
                    OriginalChartView.SetDrawBorders(SupportChartView.DrawBorders.Value);
                }

                if (SupportChartView.ClipValuesToContent.HasValue)
                {
                    OriginalChartView.SetClipValuesToContent(SupportChartView.ClipValuesToContent.Value);
                }

                if (SupportChartView.MaxVisibleCount.HasValue)
                {
                    OriginalChartView.SetMaxVisibleValueCount(SupportChartView.MaxVisibleCount.Value);
                }

                if (SupportChartView.AxisLeft != null && OriginalChartView.AxisLeft != null)
                {
                    var SupportAxisLeft  = SupportChartView.AxisLeft;
                    var OriginalLeftAxis = OriginalChartView.AxisLeft;

                    OriginalLeftAxis.SetupConfigBase(SupportAxisLeft);
                    OriginalLeftAxis.SetupAxisConfigBase(SupportAxisLeft);
                    OriginalLeftAxis.SetupYAxisConfig(SupportAxisLeft);
                }

                if (SupportChartView.AxisRight != null && OriginalChartView.AxisRight != null)
                {
                    var SupportAxisRight  = SupportChartView.AxisRight;
                    var OriginalRightAxis = OriginalChartView.AxisRight;

                    OriginalRightAxis.SetupConfigBase(SupportAxisRight);
                    OriginalRightAxis.SetupAxisConfigBase(SupportAxisRight);
                    OriginalRightAxis.SetupYAxisConfig(SupportAxisRight);
                }
            }
        }