Exemplo n.º 1
0
        /// <summary>
        /// Get Minimum value for X and Radius Y2 ( used for bubble chart )
        /// </summary>
        /// <param name="area">Chart Area</param>
        /// <param name="series">Series IDs</param>
        /// <returns>Minimum X value</returns>
        internal double GetMinXWithRadiusValue(ChartArea area, params string[] series)
        {
            double returnValue = Double.MaxValue;

            foreach (string seriesName in series)
            {
                foreach (DataPoint seriesPoint in this._series[seriesName].Points)
                {
                    // The empty point
                    if (IsPointSkipped(seriesPoint))
                    {
                        continue;
                    }

                    if (!double.IsNaN(seriesPoint.XValue))
                    {
                        if (seriesPoint.YValues.Length > 1)
                        {
                            returnValue = Math.Min(returnValue, seriesPoint.XValue - BubbleChart.AxisScaleBubbleSize(area.Common, area, seriesPoint.YValues[1], false));
                        }
                        else
                        {
                            returnValue = Math.Min(returnValue, seriesPoint.XValue);
                        }
                    }
                }
            }
            return(returnValue);
        }
Exemplo n.º 2
0
 protected override void Dispose(bool disposing)
 {
     if (BubbleChart != null)
     {
         BubbleChart.Dispose();
         BubbleChart = null;
     }
     base.Dispose(disposing);
 }
Exemplo n.º 3
0
        public static object getBubbleChart(string str)
        {
            // create a list, which can hold linechart instances
            List<BubbleChart> bubblechartList = new List<BubbleChart>();

            //convert to correct date format
            //DateTime date = DateTime.Parse(str);
            DateTime date = DateTime.ParseExact(str, "MM/dd/yyyy", null);
            string str1 = date.ToString("yyyy'-'MM'-'dd");

            // create a linechart class instance so that i
            // can talk to database
            BubbleChart bubble = new BubbleChart();
            bubblechartList = bubble.getOverallBubbleData(str1);
            //System.Diagnostics.Debug.Write();
            //testing/printout date
            System.Diagnostics.Debug.WriteLine(str1);

            // assign the linechartList to the response object
            object response = bubblechartList;

            return response;
        }
Exemplo n.º 4
0
        // Acción que determina que clase utilitzar para crear los "Charts"
        public void CrearChart(Button button, Label label = null)
        {
            ClearLastElements();

            BaseChart.Chart.Series.RemoveAllSeries();

            //Themes.RefreshTheme();
            Themes.BasicAxes(BaseChart.Chart.Axes.Left, BaseChart.Chart.Axes.Right);
            Themes.AplicarTheme(BaseChart);

            switch (button.Text)
            {
            case "Line":
                lineChart = new LineChart(BaseChart);
                break;

            case "Column Bar":
                columnBarChart = new ColumnBarChart(BaseChart);
                break;

            case "Area":
                areaChart = new AreaChart(BaseChart);
                break;

            case "Pie":
                pieChart = new PieChart(BaseChart);
                break;

            case "Fast Line":
                fastLineChart = new FastLineChart(BaseChart);
                break;

            case "Horizontal Area":
                horizAreaChart = new HorizontalAreaChart(BaseChart);
                break;

            case "Horizontal Bar":
                horizBarChart = new HorizontalBarChart(BaseChart);
                break;

            case "Horizontal Line":
                horizLineChart = new HorizontalLineChart(BaseChart);
                break;

            case "Donut":
                donutChart = new DonutChart(BaseChart);
                break;

            case "Bubble":
                bubbleChart = new BubbleChart(BaseChart);
                break;

            case "Shape":
                shapeChart = new ShapeChart(BaseChart);
                break;

            case "Gantt":
                gantChart = new GanttChart(BaseChart);
                break;

            case "Point/Scatter":
                point_scatterChart = new Point_ScatterChart(BaseChart);
                break;

            case "Interpolating Line":
                interpolatingChart = new InterpolatingChartFeatures(BaseChart);
                break;

            case "Bar Styles":
                coneBarChart = new BarStylesChartFeatures(BaseChart);
                break;

            case "Zoom & Panning":
                zoomPaningArrowChart = new ZoomPanningChartFeatures(BaseChart);
                break;

            case "Bar Gradient":
                gradientBarChart = new GradientBarChartFeatures(BaseChart);
                break;

            case "Bubble Transparent":
                bubbleTranspChart = new BubbleTransparencyChartFeatures(BaseChart);
                break;

            case "Real Time":
                fLineRealTimeChart = new FLineRealTimeChartFeatures(BaseChart);
                break;

            case "Stack Area":
                stackAreaChart = new StackAreaChartFeatures(BaseChart);
                break;

            case "Multiple Pies":
                multiPiesChart = new MultiplePiesChartFeatures(BaseChart);
                break;

            case "Semi-Pie":
                semiPieChart = new Semi_PieChartFeatures(BaseChart);
                break;

            case "Semi-Donut":
                semiDonutChart = new Semi_DonutChartFeatures(BaseChart);
                break;

            case "Arrow":
                arrowChart = new ArrowChart(BaseChart);
                break;

            case "Polar":
                polarChart = new PolarChart(BaseChart);
                break;

            case "Radar":
                radarChart = new RadarChart(BaseChart);
                break;

            case "Pyramid":
                pyramidChart = new PyramidChart(BaseChart);
                break;

            case "Candle":
                candleChart = new CandleChart(BaseChart);
                break;

            case "Histogram":
                histogramChart = new HistogramChart(BaseChart);
                break;

            case "Error":
                errorChart = new ErrorChart(BaseChart);
                break;

            case "ErrorBar":
                errorBarChart = new ErrorBarChart(BaseChart);
                break;

            case "Funnel":
                funnelChart = new FunnelChart(BaseChart);
                break;

            case "Smith":
                smithChart = new SmithChart(BaseChart);
                break;

            case "Bezier":
                bezierChart = new BezierChart(BaseChart);
                break;

            case "HighLow":
                highLowChart = new HighLowChart(BaseChart);
                break;

            case "Speed Time":
                realTimeChart = new SpeedTimeChart(BaseChart);
                break;

            case "Waterfall":
                waterfallChart = new WaterfallChart(BaseChart);
                break;

            case "Volume":
                volumeChart = new VolumeChart(BaseChart);
                break;

            case "Color Grid":
                colorGridChart = new ColorGridChart(BaseChart);
                break;

            case "Polar Bar":
                polarBarChart = new PolarBarChart(BaseChart);
                break;

            case "Inverted Pyramid":
                invertedPyramidChart = new InvertedPyramidChart(BaseChart);
                break;

            case "Horizontal Histogram":
                horizHistogramChart = new HorizHistogramChart(BaseChart);
                break;

            case "Circular Gauge":
                basicCircGaugeChart = new BasicCircularGaugeChart(BaseChart);
                break;

            case "Car Fuel":
                carFuelChart = new CarFuelChart(BaseChart);
                break;

            case "Custom Hand":
                custPointerGaugeChart = new CustomPointerChart(BaseChart);
                break;

            case "Acceleration":
                accelerationCircularGaugeChart = new AccelerationCircularGaugeChart(BaseChart);
                break;

            case "Knob Gauge":
                basicKnobGaugeChart = new BasicKnobGaugeChart(BaseChart);
                break;

            case "Temperature Knob":
                temperatureKnobChart = new TemperatureKnobChart(BaseChart);
                break;

            case "Compass":
                try { compassChart = new CompassChart(BaseChart); }
                catch (Exception e) {  }
                break;

            case "Map GIS":
                mapGSIChart = new MapGISChart(BaseChart);
                break;

            case "World Map":
                worldMapChart = new WorldMapChart(BaseChart);
                break;

            case "TreeMap":
                treeMapChart = new TreeMapChart(BaseChart);
                break;

            case "Basic Clock":
                basicClockChart = new BasicClockChart(BaseChart);
                break;

            case "Custom Clock":
                customClockChart = new CustomClockChart(BaseChart);
                break;

            case "Organizational Chart":
                basicOrganizationalChart = new BasicOrganizationalChart(BaseChart);
                break;

            case "Numeric Gauge":
                numericGaugeChart = new NumericGaugeChart(BaseChart);
                break;

            case "Linear Gauge":
                linearGaugeChart = new LinearGaugeChart(BaseChart);
                break;

            case "Scales":
                scalesLinearChart = new ScalesLinearChart(BaseChart);
                break;

            case "SubLines":
                moreLinesLinearChart = new MoreLinesLinearChart(BaseChart);
                break;

            case "Mobile Battery":
                batteryLinearChart = new BatteryLinearChart(BaseChart);
                break;

            case "Basic Calendar":
                basicCalendarChart = new BasicCalendarChart(BaseChart, label);
                break;

            case "Special Dates":
                specialDatesChart = new SpecialDatesChart(BaseChart, label);
                break;

            case "TagCloud":
                tagCloudChart = new TagCloudChart(BaseChart);
                break;

            case "Add":
                addStdFunctionsChart = new AddStdFunctionsChart(BaseChart);
                break;

            case "Subtract":
                subtStdFunctionsChart = new SubtStdFunctionsChart(BaseChart);
                break;

            case "Multiply":
                multStdFunctionsChart = new MultStdFunctionsChart(BaseChart);
                break;

            case "Divide":
                divStdFunctionsChart = new DivStdFunctionsChart(BaseChart);
                break;

            case "Count":
                countStdFunctionsChart = new CountStdFunctionsChart(BaseChart);
                break;

            case "Average":
                avgStdFunctionsChart = new AvgStdFunctionsChart(BaseChart);
                break;

            case "High":
                highStdFunctionsChart = new HighStdFunctionsChart(BaseChart);
                break;

            case "Low":
                lowStdFunctionsChart = new LowStdFunctionsChart(BaseChart);
                break;

            case "Median Function":
                medianStdFunctionsChart = new MedianStdFunctionsChart(BaseChart);
                break;

            case "Percent Change":
                percentStdFunctionsChart = new PercentStdFunctionsChart(BaseChart);
                break;

            case "ADX":
                adxProFunctionChart = new ADXProFunctionChart(BaseChart);
                break;

            case "AC":
                acProFunctionChart = new ACProFunctionChart(BaseChart);
                break;

            case "Alligator":
                alligatorProFunctionChart = new AlligatorProFunctionChart(BaseChart);
                break;

            case "AO":
                aoProFunctionChart = new AOProFunctionChart(BaseChart);
                break;

            case "ATR":
                atrProFunctionChart = new ATRProFunctionChart(BaseChart);
                break;

            case "Bollinger Bands":
                bollingerProFunctionChart = new BollingerProFunctionChart(BaseChart);
                break;

            case "CCI":
                cciProFunctionChart = new CCIProFunctionChart(BaseChart);
                break;

            case "CLV":
                clvProFunctionChart = new CLVProFunctionChart(BaseChart);
                break;

            case "Compression OHLC":
                compressionOHLCProFunctionChart = new CompressionOHLCProFunctionChart(BaseChart);
                break;

            case "Exp. Average":
                expAverageProFunctionChart = new ExpAverageProFunctionChart(BaseChart);
                break;

            case "Exp. Moving Average":
                expMovAverageProFunctionChart = new ExpMovAverageProFunctionChart(BaseChart);
                break;

            case "Gator Oscillator":
                gatorOscillProFunctionChart = new GatorOscillProFunctionChart(BaseChart);
                break;

            case "Kurtosis":
                kurtosisProFunctionChart = new KurtosisProFunctionChart(BaseChart);
                break;

            case "MACD":
                macdProFunctionChart = new MACDProFunctionChart(BaseChart);
                break;

            case "Momentum":
                momentumProFunctionChart = new MomentumProFunctionChart(BaseChart);
                break;

            case "Momentum Div.":
                momentumDivProFunctionChart = new MomentumDivProFunctionChart(BaseChart);
                break;

            case "Money Flow":
                moneyFlowProFunctionChart = new MoneyFlowProFunctionChart(BaseChart);
                break;

            case "OBV":
                obvProFunctionChart = new OBVProFunctionChart(BaseChart);
                break;

            case "PVO":
                pvoProFunctionChart = new PVOProFunctionChart(BaseChart);
                break;

            case "RSI":
                rsiProFunctionChart = new RSIProFunctionChart(BaseChart);
                break;

            case "RVI":
                rviProFunctionChart = new RVIProFunctionChart(BaseChart);
                break;

            case "Slope":
                slopeProFunctionChart = new SlopeProFunctionChart(BaseChart);
                break;

            case "Smoothed Mov Avg":
                smoothMovAvgProFunctionChart = new SmoothMovAvgProFunctionChart(BaseChart);
                break;

            case "S.A.R.":
                sarProFunctionChart = new SARProFunctionChart(BaseChart);
                break;

            case "Cross Point":
                crossPointsProFunctionsChart = new CrossPointsProFunctionsChart(BaseChart);
                break;

            case "Correlation":
                correlationProFunctionChart = new CorrelationProFunctionChart(BaseChart);
                break;

            case "Cumulative":
                cumulativeProFunctionChart = new CumulativeProFunctionChart(BaseChart);
                break;

            case "Custom Function":
                calculateEventProFunctionChart = new CalculateEventProFunctionChart(BaseChart);
                break;

            case "Exponential Trend":
                exponentialTrendProFunctionChart = new ExponentialTrendProFunctionChart(BaseChart);
                break;

            case "Fitting Linearizable":
                fittingProFunctionChart = new FittingProFunctionChart(BaseChart);
                break;

            case "Performance":
                performanceProFunctionChart = new PerformanceProFunctionChart(BaseChart);
                break;

            case "Perimeter":
                perimeterProFunctionChart = new PerimeterProFunctionChart(BaseChart);
                break;

            case "Finding Coefficients":
                findCoeffProFunctionChart = new FindCoeffProFunctionChart(BaseChart);
                break;

            case "Down Sampling":
                downSamplingProFunctionChart = new DownSamplingProFunctionChart(BaseChart);
                break;

            case "RMS":
                rmsProFunctionChart = new RMSProFunctionChart(BaseChart);
                break;

            case "Smoothing Function":
                smoothingProFunctionChart = new SmoothingProFunctionChart(BaseChart);
                break;

            case "Standard Deviation":
                stdDeviationProFunctionChart = new StdDeviationProFunctionChart(BaseChart);
                break;

            case "Trendline":
                trendlineProFunctionChart = new TrendlineProFunctionChart(BaseChart);
                break;

            case "Variance":
                varianceProFunctionChart = new VarianceProFunctionChart(BaseChart);
                break;

            case "SPC":
                spcProFunctionChart = new SPCProFunctionChart(BaseChart);
                break;

            case "Cumulative Histogram":
                cumulativeHistogProFunctionChart = new CumulativeHistogProFunctionChart(BaseChart);
                break;

            case "Skewness":
                skewnessProFunctionChart = new SkewnessProFunctionChart(BaseChart);
                break;
            }

            Themes.AplicarOptions(BaseChart);
        }
Exemplo n.º 5
0
        public double GetMinYWithRadiusValue(ChartArea area, params string[] series)
        {
            double num = 1.7976931348623157E+308;

            foreach (string parameter in series)
            {
                foreach (DataPoint point in this.series[parameter].Points)
                {
                    if (!this.IsPointSkipped(point) && !double.IsNaN(point.YValues[0]))
                    {
                        num = ((point.YValues.Length <= 1) ? Math.Min(num, point.YValues[0]) : Math.Min(num, point.YValues[0] - BubbleChart.AxisScaleBubbleSize(area.Common.graph, area.Common, area, point.YValues[1], true)));
                    }
                }
            }
            return(num);
        }
Exemplo n.º 6
0
        public double GetMaxXWithRadiusValue(ChartArea area, params string[] series)
        {
            double num = -1.7976931348623157E+308;

            foreach (string parameter in series)
            {
                foreach (DataPoint point in this.series[parameter].Points)
                {
                    if (!point.EmptyX && (!this.series[parameter].EmptyX || point.XValue != 0.0) && !this.IsPointSkipped(point) && !double.IsNaN(point.XValue))
                    {
                        num = ((point.YValues.Length <= 1) ? Math.Max(num, point.XValue) : Math.Max(num, point.XValue + BubbleChart.AxisScaleBubbleSize(area.Common.graph, area.Common, area, point.XValue, false)));
                    }
                }
            }
            return(num);
        }
        /// <summary>
        /// 初始化方法
        /// </summary>
        /// <remarks></remarks>
        private void Bind()
        {
            try {
                COMSSmobilerDemo.common.ReimbursementInfo ReimbursementInfo = new COMSSmobilerDemo.common.ReimbursementInfo();
                switch (Mode)
                {
                case 1:
                    TitleText = "消费记录月份趋势分析";
                    DataTable table = new DataTable();
                    switch (TextTabBar1.SelectItemIndex)
                    {
                    case 0:
                        //趋势 按消费月份统计
                        TextTabBar2.Visible = false;
                        table = ReimbursementInfo.GetSanalysis(TextTabBar1.SelectItemIndex, "xiaofei");
                        this.GridView1.Rows.Clear();
                        this.GridView1.DataSource = table;
                        this.GridView1.DataBind();
                        //创建BarChart
                        BarChart BarChart1 = new BarChart();
                        chartObj                   = BarChart1;
                        BarChart1.Size             = new System.Drawing.Size(450, 250);
                        BarChart1.Location         = new System.Drawing.Point(25, 63);
                        BarChart1.XAxisLabelMember = "XMember";
                        BarChart1.YAxisValueMember = "YMember";
                        this.Controls.Add(BarChart1);
                        if (table.Rows.Count > 0)
                        {
                            System.Data.DataTable matTable = new DataTable();
                            matTable.Columns.Add("XMember", typeof(string));
                            matTable.Columns.Add("YMember", typeof(int));
                            foreach (GridViewRow ROW in GridView1.Rows)
                            {
                                string  XMember = ROW.Cell.Items["lblName"].Value.ToString();
                                decimal YMember = Convert.ToDecimal(ROW.Cell.Items["lblAmount"].Value);
                                matTable.Rows.Add(XMember, YMember);
                            }
                            BarChart1.DataSource = matTable;
                            BarChart1.DataBind();
                        }
                        else
                        {
                            this.GridView1.Rows.Clear();
                        }
                        break;

                    case 1:
                        //分布 按消费类型统计
                        TextTabBar2.Visible = true;
                        TitleText           = "消费记录趋势分析";
                        table = ReimbursementInfo.GetSanalysis(TextTabBar1.SelectItemIndex, "xiaofei");
                        this.GridView1.Rows.Clear();
                        this.GridView1.DataSource = table;
                        this.GridView1.DataBind();
                        if (table.Rows.Count > 0)
                        {
                            switch (TextTabBar2.SelectItemIndex)
                            {
                            case 0:
                                //创建BubbleChart
                                BubbleChart BubbleChart1 = new BubbleChart();
                                chartObj                      = BubbleChart1;
                                BubbleChart1.Size             = new System.Drawing.Size(450, 225);
                                BubbleChart1.Location         = new System.Drawing.Point(25, 80);
                                BubbleChart1.XAxisLabelMember = "XMember";
                                BubbleChart1.YAxisValueMember = "YMember";
                                this.Controls.Add(BubbleChart1);

                                DataTable matTable = new DataTable();
                                matTable.Columns.Add("XMember", typeof(string));
                                matTable.Columns.Add("YMember", typeof(int));
                                foreach (GridViewRow ROW in GridView1.Rows)
                                {
                                    string  XMember = ROW.Cell.Items["lblName"].Value.ToString();
                                    decimal YMember = Convert.ToDecimal(ROW.Cell.Items["lblAmount"].Value);
                                    matTable.Rows.Add(XMember, YMember);
                                }
                                BubbleChart1.DataSource = matTable;
                                BubbleChart1.DataBind();
                                break;

                            case 1:
                                //创建ScatterChart
                                ScatterChart ScatterChart1 = new ScatterChart();
                                chartObj                       = ScatterChart1;
                                ScatterChart1.Size             = new System.Drawing.Size(450, 225);
                                ScatterChart1.Location         = new System.Drawing.Point(25, 80);
                                ScatterChart1.SeriesMember     = "XMember";
                                ScatterChart1.SeriesShapMember = "Shape";
                                ScatterChart1.XAxisLabelMember = "XMember";
                                ScatterChart1.YAxisValueMember = "YMember";
                                Controls.Add(ScatterChart1);

                                DataTable matTable2 = new DataTable();
                                matTable2.Columns.Add("XMember", typeof(string));
                                matTable2.Columns.Add("YMember", typeof(int));
                                matTable2.Columns.Add("Shape", typeof(int));
                                int Shape = 0;
                                foreach (GridViewRow ROW in GridView1.Rows)
                                {
                                    string  XMember = ROW.Cell.Items["lblName"].Value.ToString();
                                    decimal YMember = Convert.ToDecimal(ROW.Cell.Items["lblAmount"].Value);
                                    matTable2.Rows.Add(XMember, YMember, Shape);
                                    if (Shape <= 4)
                                    {
                                        Shape += 1;
                                    }
                                    else
                                    {
                                        Shape = 0;
                                    }
                                }
                                ScatterChart1.DataSource = matTable2;
                                ScatterChart1.DataBind();
                                break;

                            case 2:
                                //创建RadarChart
                                RadarChart RadarChart1 = new RadarChart();
                                chartObj                     = RadarChart1;
                                RadarChart1.Size             = new System.Drawing.Size(450, 225);
                                RadarChart1.Location         = new System.Drawing.Point(25, 80);
                                RadarChart1.SeriesMember     = "XMember";
                                RadarChart1.XAxisLabelMember = "XMember";
                                RadarChart1.YAxisValueMember = "YMember";
                                this.Controls.Add(RadarChart1);

                                DataTable matTable3 = new DataTable();
                                matTable3.Columns.Add("XMember", typeof(string));
                                matTable3.Columns.Add("YMember", typeof(int));
                                foreach (GridViewRow ROW in GridView1.Rows)
                                {
                                    string  XMember = ROW.Cell.Items["lblName"].Value.ToString();
                                    decimal YMember = Convert.ToDecimal(ROW.Cell.Items["lblAmount"].Value);
                                    matTable3.Rows.Add(XMember, YMember);
                                }
                                RadarChart1.DataSource = matTable3;
                                RadarChart1.DataBind();
                                break;
                            }
                        }
                        else
                        {
                            this.GridView1.Rows.Clear();
                        }
                        break;
                    }

                    break;

                case 2:
                    switch (TextTabBar1.SelectItemIndex)
                    {
                    case 0:
                        TextTabBar2.Visible = false;
                        //趋势 按报销月份统计
                        table = ReimbursementInfo.GetSanalysis(TextTabBar1.SelectItemIndex, "baoxiao");
                        this.GridView1.Rows.Clear();
                        this.GridView1.DataSource = table;
                        this.GridView1.DataBind();

                        //创建LineChart
                        LineChart LineChart1 = new LineChart();
                        chartObj                    = LineChart1;
                        LineChart1.Size             = new System.Drawing.Size(450, 250);
                        LineChart1.Location         = new System.Drawing.Point(25, 63);
                        LineChart1.XAxisLabelMember = "XMember";
                        LineChart1.YAxisValueMember = "YMember";
                        this.Controls.Add(LineChart1);
                        if (table.Rows.Count > 0)
                        {
                            DataTable matTable = new DataTable();
                            matTable.Columns.Add("XMember", typeof(string));
                            matTable.Columns.Add("YMember", typeof(int));
                            foreach (GridViewRow ROW in GridView1.Rows)
                            {
                                string  XMember = ROW.Cell.Items["lblName"].Value.ToString();
                                decimal YMember = Convert.ToDecimal(ROW.Cell.Items["lblAmount"].Value);
                                matTable.Rows.Add(XMember, YMember);
                            }
                            LineChart1.DataSource = matTable;
                            LineChart1.DataBind();
                        }
                        else
                        {
                            this.GridView1.Rows.Clear();
                        }
                        break;

                    case 1:
                        //分布 按报销状态统计
                        table = ReimbursementInfo.GetSanalysis(TextTabBar1.SelectItemIndex, "baoxiao");
                        this.GridView1.Rows.Clear();
                        this.GridView1.DataSource = table;
                        this.GridView1.DataBind();

                        //创建PieChart
                        PieChart PieChart1 = new PieChart();
                        chartObj = PieChart1;

                        PieChart1.Size             = new System.Drawing.Size(450, 250);
                        PieChart1.Location         = new System.Drawing.Point(25, 63);
                        PieChart1.XAxisLabelMember = "XMember";
                        PieChart1.YAxisValueMember = "YMember";
                        this.Controls.Add(PieChart1);
                        //报销状态分布统计表
                        if (table.Rows.Count > 0)
                        {
                            DataTable matTable = new DataTable();
                            matTable.Columns.Add("XMember", typeof(string));
                            matTable.Columns.Add("YMember", typeof(int));
                            foreach (GridViewRow ROW in GridView1.Rows)
                            {
                                string  XMember = ROW.Cell.Items["lblName"].Value.ToString();
                                decimal YMember = Convert.ToDecimal(ROW.Cell.Items["lblAmount"].Value);
                                matTable.Rows.Add(XMember, YMember);
                            }
                            PieChart1.DataSource = matTable;
                            PieChart1.DataBind();
                        }
                        else
                        {
                            this.GridView1.Rows.Clear();
                        }
                        break;
                    }

                    break;
                }
            } catch (Exception ex) {
                MessageBox.Show(ex.Message);
            }
        }
Exemplo n.º 8
0
        internal double GetMinXWithRadiusValue(ChartArea area, params string[] series)
        {
            double num = double.MaxValue;

            foreach (string parameter in series)
            {
                foreach (DataPoint point in this.series[parameter].Points)
                {
                    if (!point.EmptyX && (!this.series[parameter].EmptyX || point.XValue != 0.0) && !IsPointSkipped(point) && !double.IsNaN(point.XValue))
                    {
                        num = ((point.YValues.Length <= 1) ? Math.Min(num, point.XValue) : Math.Min(num, point.XValue - BubbleChart.AxisScaleBubbleSize(area.Common.graph, area.Common, area, point.YValues[1], yValue: false)));
                    }
                }
            }
            return(num);
        }
Exemplo n.º 9
0
        internal double GetMaxYWithRadiusValue(ChartArea area, params string[] series)
        {
            double num = double.MinValue;

            foreach (string parameter in series)
            {
                foreach (DataPoint point in this.series[parameter].Points)
                {
                    if (!IsPointSkipped(point) && !double.IsNaN(point.YValues[0]))
                    {
                        num = ((point.YValues.Length <= 1) ? Math.Max(num, point.YValues[0]) : Math.Max(num, point.YValues[0] + BubbleChart.AxisScaleBubbleSize(area.Common.graph, area.Common, area, point.YValues[1], yValue: true)));
                    }
                }
            }
            return(num);
        }