using DevExpress.Utils;
using DevExpress.XtraCharts;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;

namespace IStation.WinFrmUI.Curve
{
    /// <summary>
    ///  
    /// </summary>
    public partial class CurveExpressEditChart : DevExpress.XtraEditors.XtraUserControl
    {
        public CurveExpressEditChart()
        {
            InitializeComponent();
            InitialChart();
            this.chartControl1.RuntimeHitTesting = true;
        }

        #region Private Variable

        private XYDiagram _mainChartDiagram;
        private AxisX _axisXQ;
        private AxisY _axisYQH;
        private SecondaryAxisY _axisYQE, _axisYQP;

        private Series _seriesCurveQH, _seriesCurveQE, _seriesCurveQP;
        private Series _seriesPointQH, _seriesPointQE, _seriesPointQP;

        Model.eCurveFitType _fitTypeQH = Model.eCurveFitType.CubicCurve;
        Model.eCurveFitType _fitTypeQE = Model.eCurveFitType.CubicCurve;
        Model.eCurveFitType _fitTypeQP = Model.eCurveFitType.CubicCurve;


        private List<Model.CurvePoint> _definePointsQH;
        private List<Model.CurvePoint> _definePointsQE;
        private List<Model.CurvePoint> _definePointsQP;


        private List<Model.CurvePoint> _curvePointsQH;
        private List<Model.CurvePoint> _curvePointsQE;
        private List<Model.CurvePoint> _curvePointsQP;

        private Model.CurveCoordinateParas _coordinateParas;
        private bool _initialData = false;

        private Model.eFeatCurveType _editCurveType = Model.eFeatCurveType.QH;

        #endregion

        #region Public Evnet

        public event Action<Model.CurveCoordinateParas> OnCurveCoordinateParasChanged;

        public event Action<Model.eFeatCurveType, List<Model.CurvePoint>> OnDefinePointChanged;

        #endregion

        #region Initial

        /// <summary>
        /// 初始化图表
        /// </summary>
        private void InitialChart()
        {
            this.chartControl1.SetChartDisplay();
            this.chartControl1.Legend.Visibility = DevExpress.Utils.DefaultBoolean.False;
            this.chartControl1.SeriesSelectionMode = SeriesSelectionMode.Point;
            this.chartControl1.SelectionMode = ElementSelectionMode.Single;

            _mainChartDiagram = (XYDiagram)chartControl1.Diagram;


            _axisXQ = _mainChartDiagram.AxisX;
            _axisXQ.SetAxisXQDisplay();
            _axisYQH = _mainChartDiagram.AxisY;
            _axisYQH.SetAxisYQHDisplay();
            _axisYQE = _mainChartDiagram.SecondaryAxesY.GetAxisByName("AxisYQE");
            _axisYQE.SetSecondaryAxisYQEDisplay();
            _axisYQP = _mainChartDiagram.SecondaryAxesY.GetAxisByName("AxisYQP");
            _axisYQP.SetSecondaryAxisYQPDisplay();


            _seriesCurveQH = this.chartControl1.GetSeriesByName("SeriesCurveQH");
            _seriesCurveQH.SetCurveQHDisplay();
            _seriesCurveQH.Tag = (int)Model.eFeatCurveType.QH;

            _seriesCurveQE = this.chartControl1.GetSeriesByName("SeriesCurveQE");
            _seriesCurveQE.SetCurveQEDisplay();
            _seriesCurveQE.Tag = (int)Model.eFeatCurveType.QE;

            _seriesCurveQP = this.chartControl1.GetSeriesByName("SeriesCurveQP");
            _seriesCurveQP.SetCurveQPDisplay();
            _seriesCurveQP.Tag = (int)Model.eFeatCurveType.QP;


            _seriesPointQH = this.chartControl1.GetSeriesByName("SeriesPointQH");
            _seriesPointQH.SetPointQHDisplay();
            _seriesPointQH.Tag = (int)Model.eFeatCurveType.QH;

            _seriesPointQE = this.chartControl1.GetSeriesByName("SeriesPointQE");
            _seriesPointQE.SetPointQEDisplay();
            _seriesPointQE.Tag = (int)Model.eFeatCurveType.QE;

            _seriesPointQP = this.chartControl1.GetSeriesByName("SeriesPointQP");
            _seriesPointQP.SetPointQPDisplay();
            _seriesPointQP.Tag = (int)Model.eFeatCurveType.QP;


            _axisXQ.Visibility = DefaultBoolean.False;
            _axisXQ.GridLines.Visible = false;
            _axisYQH.Visibility = DefaultBoolean.False;
            _axisYQH.GridLines.Visible = false;
            _axisYQE.Visibility = DefaultBoolean.False;
            _axisYQE.GridLines.Visible = false;
            _axisYQP.Visibility = DefaultBoolean.False;
            _axisYQP.GridLines.Visible = false;


            _seriesPointQH.Visible = false;
            _seriesPointQE.Visible = false;
            _seriesPointQP.Visible = false;


            this.chartControl1.SetChartMonoColorDisplay();


            this.chartControl1.MouseMove += new System.Windows.Forms.MouseEventHandler(this.chartControl1_MouseMove);
            this.chartControl1.MouseUp += new System.Windows.Forms.MouseEventHandler(this.chartControl1_MouseUp);
            this.chartControl1.MouseDown += new System.Windows.Forms.MouseEventHandler(this.chartControl1_MouseDown);
            this.chartControl1.KeyUp += new System.Windows.Forms.KeyEventHandler(this.chartControl1_KeyUp);
        }



        /// <summary>
        /// 初始化图表数据
        /// </summary>
        public void InitialChartData()
        {
            _initialData = false;

            _curvePointsQH = null;
            _curvePointsQE = null;
            _curvePointsQP = null;

            _definePointsQH = null;
            _definePointsQE = null;
            _definePointsQP = null;

            _coordinateParas = null;

            UpdateChart(false);
        }

        #endregion

        #region SetBindingData
        /// <summary>
        /// 绑定数据
        /// </summary>
        /// <param name="curveQH"></param>
        /// <param name="curveQE"></param>
        /// <param name="curveQP"></param> 
        /// <param name="calcCoordinate"></param> 
        public void SetBindingData(Model.CurveExpress curveQH,
                                   Model.CurveExpress curveQE,
                                   Model.CurveExpress curveQP,
                                   Model.CurveCoordinateParas coordinateParas = null,
                                   bool calcCoordinate = false)
        {
            if (curveQH == null)
            {
                InitialChartData();
                return;
            }
            Model.eCurveFitType fitTypeQH = curveQH.FitType,
                                fitTypeQE = Model.eCurveFitType.CubicCurve,
                                fitTypeQP = Model.eCurveFitType.CubicCurve;
            List<Model.CurvePoint> qhPoints, qePoints = null, qpPoints = null;

            if (curveQH.DefinePoints != null)
                qhPoints = curveQH.DefinePoints;
            else
                qhPoints = curveQH.GetFitPoints(12);

            if (curveQE != null)
            {
                fitTypeQE = curveQE.FitType;
                if (curveQE.DefinePoints != null)
                    qePoints = curveQE.DefinePoints;
                else
                    qePoints = curveQE.GetFitPoints(12);
            }


            if (curveQP != null)
            {
                fitTypeQP = curveQP.FitType;
                if (curveQP?.DefinePoints != null)
                    qpPoints = curveQP.DefinePoints;
                else
                    qpPoints = curveQP.GetFitPoints(12);
            }

            SetBindingData(qhPoints, qePoints, qpPoints, fitTypeQH, fitTypeQE, fitTypeQP, coordinateParas, calcCoordinate);
        }

        /// <summary>
        /// 绑定数据
        /// </summary> 
        /// <param name="definePointsQH"></param>
        /// <param name="definePointsQE"></param>
        /// <param name="definePointsQP"></param>
        /// <param name="coordinateParas"></param>
        /// <param name="calcCoordinate"></param> 
        public void SetBindingData(List<Model.CurvePoint> definePointsQH,
                                   List<Model.CurvePoint> definePointsQE,
                                   List<Model.CurvePoint> definePointsQP,
                                   Model.eCurveFitType fitTypeQH,
                                   Model.eCurveFitType fitTypeQE,
                                   Model.eCurveFitType fitTypeQP,
                                   Model.CurveCoordinateParas coordinateParas = null,
                                   bool calcCoordinate = false)
        {
            if (definePointsQH == null)
            {
                InitialChartData();
                return;
            }
            _initialData = true;

            _fitTypeQH = fitTypeQH;
            _fitTypeQE = fitTypeQE;
            _fitTypeQP = fitTypeQP;

            _definePointsQH = definePointsQH;
            _definePointsQE = definePointsQE;
            _definePointsQP = definePointsQP;

            _curvePointsQH = Model.FitCurveHelper.GetFitPoints(definePointsQH, _fitTypeQH);
            _curvePointsQE = Model.FitCurveHelper.GetFitPoints(definePointsQE, _fitTypeQE);
            _curvePointsQP = Model.FitCurveHelper.GetFitPoints(definePointsQP, _fitTypeQP);

            _coordinateParas = coordinateParas;

            UpdateChart(calcCoordinate);
        }

        #endregion

        #region Update

        /// <summary>
        /// 更新曲线
        /// </summary>
        /// <param name="curveType"></param>
        /// <param name="curvePoints"></param>
        public void UpdateCurve(Model.eFeatCurveType curveType, List<Model.CurvePoint> curvePoints)
        {
            if (curvePoints == null || !curvePoints.Any())
                return;
            _editCurveType = curveType;
            switch (_editCurveType)
            {
                case Model.eFeatCurveType.QH: UpdateCurve(curveType, _fitTypeQH, curvePoints); break;
                case Model.eFeatCurveType.QE: UpdateCurve(curveType, _fitTypeQE, curvePoints); break;
                case Model.eFeatCurveType.QP: UpdateCurve(curveType, _fitTypeQP, curvePoints); break;
                default:
                    break;
            }

        }

        /// <summary>
        /// 更新曲线
        /// </summary>
        /// <param name="curveType"></param>
        /// <param name="fitType"></param>
        /// <param name="curvePoints"></param>
        public void UpdateCurve(Model.eFeatCurveType curveType, Model.eCurveFitType fitType, List<Model.CurvePoint> curvePoints)
        {
            if (curvePoints == null || !curvePoints.Any())
                return;
            _editCurveType = curveType;
            switch (_editCurveType)
            {
                case Model.eFeatCurveType.QH:
                    {
                        _fitTypeQH = fitType;
                        _definePointsQH = curvePoints;
                        _curvePointsQH = Model.FitCurveHelper.GetFitPoints(curvePoints, fitType);
                        _axisYQH.SetAxisYQHColorDisplay(_seriesCurveQH, _seriesPointQH, true);
                        _axisYQE.SetSecondaryAxisYQEColorDisplay(_seriesCurveQE, _seriesPointQE, false);
                        _axisYQP.SetSecondaryAxisYQPColorDisplay(_seriesCurveQP, _seriesPointQP, false);
                    }
                    break;
                case Model.eFeatCurveType.QE:
                    {
                        _fitTypeQE = fitType;
                        _definePointsQE = curvePoints;
                        _curvePointsQE = Model.FitCurveHelper.GetFitPoints(curvePoints, fitType);
                        _axisYQH.SetAxisYQHColorDisplay(_seriesCurveQH, _seriesPointQH, false);
                        _axisYQE.SetSecondaryAxisYQEColorDisplay(_seriesCurveQE, _seriesPointQE, true);
                        _axisYQP.SetSecondaryAxisYQPColorDisplay(_seriesCurveQP, _seriesPointQP, false);
                    }
                    break;
                case Model.eFeatCurveType.QP:
                    {
                        _fitTypeQP = fitType;
                        _definePointsQP = curvePoints;
                        _curvePointsQP = Model.FitCurveHelper.GetFitPoints(curvePoints, fitType);
                        _axisYQH.SetAxisYQHColorDisplay(_seriesCurveQH, _seriesPointQH, false);
                        _axisYQE.SetSecondaryAxisYQEColorDisplay(_seriesCurveQE, _seriesPointQE, false);
                        _axisYQP.SetSecondaryAxisYQPColorDisplay(_seriesCurveQP, _seriesPointQP, true);
                    }
                    break;
                default:
                    break;
            }

            UpdateChart(true);
        }

        /// <summary>
        /// 更新图表
        /// </summary>
        /// <param name="calcCoordinate">计算坐标</param>
        public void UpdateChart(bool calcCoordinate = false)
        {
            if (calcCoordinate || _coordinateParas == null)
            {
                //不强迫计算,就用上次更新的坐标系
                CalcCoordinate();
            }

            CalcChartAxis();

            CalcSeries();
        }

        #endregion

        #region Calc

        /// <summary>
        /// 计算坐标
        /// </summary>
        public void CalcCoordinate()
        {
            if (_curvePointsQH == null || _curvePointsQH.Count < 4)
            {
                //设置成白板坐标
                _coordinateParas = new Model.CurveCoordinateParas();
                _coordinateParas.GridNumberX = 30;
                _coordinateParas.GridNumberY = 16;
                //显示的坐标线号
                _coordinateParas.StartLineNoH = 10;
                _coordinateParas.EndLineNoH = 15;
                _coordinateParas.StartLineNoE = 0;
                _coordinateParas.EndLineNoE = 10;
                _coordinateParas.StartLineNoP = 2;
                _coordinateParas.EndLineNoP = 9;
                //坐标最小值和间隔
                _coordinateParas.CoordMinQ = 0; _coordinateParas.CoordSpaceQ = 1000;
                _coordinateParas.CoordMinH = 10; _coordinateParas.CoordSpaceH = 100;
                _coordinateParas.CoordMinE = 0; _coordinateParas.CoordSpaceE = 100;
                _coordinateParas.CoordMinP = 10; _coordinateParas.CoordSpaceP = 100;
                return;
            }

            _coordinateParas = Model.CurveCoordinateParas.CalcCoordinate(_curvePointsQH, _curvePointsQE, _curvePointsQP);
        }

        /// <summary>
        /// 计算图表轴
        /// </summary>
        public void CalcChartAxis()
        {
            if (_coordinateParas == null)
            {
                _axisXQ.Visibility = DefaultBoolean.False;
                _axisXQ.GridLines.Visible = false;
                _axisYQH.Visibility = DefaultBoolean.False;
                _axisYQH.GridLines.Visible = false;
                _axisYQE.Visibility = DefaultBoolean.False;
                _axisYQE.GridLines.Visible = false;
                _axisYQP.Visibility = DefaultBoolean.False;
                _axisYQP.GridLines.Visible = false;
                return;
            }

            //流量
            if (_curvePointsQH != null)
            {
                //计算刻度
                var labels = new List<CustomAxisLabel>();
                var disQ = _coordinateParas.CoordMinQ;
                for (int i = 0; i < _coordinateParas.GridNumberX + 1; i++)
                {
                    labels.Add(new CustomAxisLabel(disQ.ToString("N0"), disQ));
                    disQ = disQ + _coordinateParas.CoordSpaceQ;
                }

                //坐标刻度
                _axisXQ.CustomLabels.Clear();
                _axisXQ.CustomLabels.AddRange(labels.ToArray());
                _axisXQ.Visibility = DefaultBoolean.True;
                _axisXQ.GridLines.Visible = true;
                _axisXQ.SetAxisRange(_coordinateParas.CoordMinQ, _coordinateParas.CoordMinQ + _coordinateParas.GridNumberX * _coordinateParas.CoordSpaceQ);
            }

            //扬程
            if (_curvePointsQH != null)
            {
                //计算刻度
                var labels = new List<CustomAxisLabel>();
                var disH = _coordinateParas.CoordMinH + _coordinateParas.CoordSpaceH * _coordinateParas.StartLineNoH;
                for (int i = _coordinateParas.StartLineNoH; i < _coordinateParas.EndLineNoH + 1; i++)
                {
                    labels.Add(new CustomAxisLabel(disH.ToString(), disH));
                    disH = disH + _coordinateParas.CoordSpaceH;
                }

                _axisYQH.CustomLabels.Clear();
                _axisYQH.CustomLabels.AddRange(labels.ToArray());
                _axisYQH.Visibility = DefaultBoolean.True;
                _axisYQH.GridLines.Visible = true;
            }

            //效率
            if (_curvePointsQE != null)
            {
                //计算刻度
                var labels = new List<CustomAxisLabel>();
                var disE = _coordinateParas.CoordMinE + _coordinateParas.CoordSpaceE * _coordinateParas.StartLineNoE;
                for (int i = _coordinateParas.StartLineNoE; i < _coordinateParas.EndLineNoE + 1; i++)
                {
                    labels.Add(new CustomAxisLabel(disE.ToString(), disE));
                    disE = disE + _coordinateParas.CoordSpaceE;
                }

                _axisYQE.CustomLabels.Clear();
                _axisYQE.CustomLabels.AddRange(labels.ToArray());
                _axisYQE.Visibility = DefaultBoolean.True;
                _axisYQE.GridLines.Visible = true;
            }

            //功率
            if (_curvePointsQP != null)
            {
                //计算刻度
                var labels = new List<CustomAxisLabel>();
                double disP = _coordinateParas.CoordMinP + _coordinateParas.CoordSpaceP * _coordinateParas.StartLineNoP;
                for (int i = _coordinateParas.StartLineNoP; i < _coordinateParas.EndLineNoP + 1; i++)
                {
                    labels.Add(new CustomAxisLabel(disP.ToString(), disP));
                    disP = disP + _coordinateParas.CoordSpaceP;
                }

                _axisYQP.CustomLabels.Clear();
                _axisYQP.CustomLabels.AddRange(labels.ToArray());
                _axisYQP.Visibility = DefaultBoolean.True;
                _axisYQP.GridLines.Visible = true;
            }


            _axisXQ.SetAxisRange(_coordinateParas.CoordMinQ, _coordinateParas.CoordMinQ + _coordinateParas.GridNumberX * _coordinateParas.CoordSpaceQ);
            if (_curvePointsQE == null && _curvePointsQP == null)
            {
                _axisYQH.SetAxisRange(_coordinateParas.DispMinH(), _coordinateParas.DispMaxH());
            }
            else
            {
                _axisYQH.SetAxisRange(_coordinateParas.CoordMinH, _coordinateParas.CoordMinH + _coordinateParas.GridNumberY * _coordinateParas.CoordSpaceH);
            }
            _axisYQE.SetAxisRange(_coordinateParas.CoordMinE, _coordinateParas.CoordMinE + _coordinateParas.GridNumberY * _coordinateParas.CoordSpaceE);
            _axisYQP.SetAxisRange(_coordinateParas.CoordMinP, _coordinateParas.CoordMinP + _coordinateParas.GridNumberY * _coordinateParas.CoordSpaceP);


        }

        /// <summary>
        /// 计算系列
        /// </summary>
        public void CalcSeries()
        {
            if (_curvePointsQH != null && _curvePointsQH.Count > 3)
            {
                _seriesCurveQH.Visible = true;
                _seriesCurveQH.Points.Clear();
                foreach (var curvePoint in _curvePointsQH)
                {
                    var seriesPoint = new SeriesPoint(curvePoint.X, curvePoint.Y);
                    _seriesCurveQH.Points.Add(seriesPoint);
                }
            }
            else
            {
                _seriesCurveQH.Points.Clear();
                _seriesCurveQH.Visible = false;
            }

            if (_curvePointsQE != null && _curvePointsQE.Count > 3)
            {
                _seriesCurveQE.Visible = true;
                _seriesCurveQE.Points.Clear();
                foreach (var curvePoint in _curvePointsQE)
                {
                    var seriesPoint = new SeriesPoint(curvePoint.X, curvePoint.Y);
                    _seriesCurveQE.Points.Add(seriesPoint);
                }
            }
            else
            {
                _seriesCurveQE.Points.Clear();
                _seriesCurveQE.Visible = false;
            }

            if (_curvePointsQP != null && _curvePointsQP.Count > 3)
            {
                _seriesCurveQP.Visible = true;
                _seriesCurveQP.Points.Clear();
                foreach (var curvePoint in _curvePointsQP)
                {
                    var seriesPoint = new SeriesPoint(curvePoint.X, curvePoint.Y);
                    _seriesCurveQP.Points.Add(seriesPoint);
                }
            }
            else
            {
                _seriesCurveQP.Points.Clear();
                _seriesCurveQP.Visible = false;
            }

            if (_definePointsQH != null && _definePointsQH.Any())
            {
                _seriesPointQH.Points.Clear();
                for (int i = 0; i < _definePointsQH.Count; i++)
                {
                    var definePoint = _definePointsQH[i];
                    var seriesPoint = new SeriesPoint(definePoint.X, definePoint.Y);
                    seriesPoint.Tag = i;
                    _seriesPointQH.Points.Add(seriesPoint);
                }
                _seriesPointQH.Visible = true;
            }
            else
            {
                _seriesPointQH.Visible = false;
            }

            if (_definePointsQE != null && _definePointsQE.Any())
            {
                _seriesPointQE.Points.Clear();
                for (int i = 0; i < _definePointsQE.Count; i++)
                {
                    var definePoint = _definePointsQE[i];
                    var seriesPoint = new SeriesPoint(definePoint.X, definePoint.Y);
                    seriesPoint.Tag = i;
                    _seriesPointQE.Points.Add(seriesPoint);
                }
                _seriesPointQE.Visible = true;
            }
            else
            {
                _seriesPointQE.Visible = false;
            }

            if (_definePointsQP != null && _definePointsQP.Any())
            {
                _seriesPointQP.Points.Clear();
                for (int i = 0; i < _definePointsQP.Count; i++)
                {
                    var definePoint = _definePointsQP[i];
                    var seriesPoint = new SeriesPoint(definePoint.X, definePoint.Y);
                    seriesPoint.Tag = i;
                    _seriesPointQP.Points.Add(seriesPoint);
                }
                _seriesPointQP.Visible = true;
            }
            else
            {
                _seriesPointQP.Visible = false;
            }
        }

        #endregion

        #region  ChartEvent

        private bool _mouseMode = false;//鼠标模式
        private SeriesPoint _pickPoint = null;// 选中点    
        private void chartControl1_MouseDown(object sender, MouseEventArgs e)
        {
            if (!_initialData)
                return;
            var hitInfo = chartControl1.CalcHitInfo(e.Location);
            if (e.Button == MouseButtons.Left)
            {
                if (hitInfo.InSeriesPoint)
                {
                    if ((int)hitInfo.Series.Tag != (int)_editCurveType)
                    {
                        _pickPoint = null;
                        return;
                    }
                    _pickPoint = hitInfo.SeriesPoint;
                }
                else
                {
                    _pickPoint = null;
                }
            }
            else if (e.Button == MouseButtons.Right)
            {
                _pickPoint = null;
                this.popMenuChart.ShowPopup(MousePosition);
            }
        }
        private void chartControl1_MouseMove(object sender, MouseEventArgs e)
        {
            if (!_initialData)
                return;
            if (!_mouseMode)
                return;
            if (_pickPoint == null)
                return;
            var diagramCoordinates = _mainChartDiagram.PointToDiagram(e.Location);
            switch (_editCurveType)
            {
                case Model.eFeatCurveType.QH:
                    {
                        var axisValue = diagramCoordinates.GetAxisValue(_axisYQH);
                        if (axisValue == null)
                            return;
                        _pickPoint.Values[0] = axisValue.NumericalValue;
                        _pickPoint.NumericalArgument = diagramCoordinates.NumericalArgument;
                    }
                    break;
                case Model.eFeatCurveType.QE:
                    {
                        var axisValue = diagramCoordinates.GetAxisValue(_axisYQE);
                        if (axisValue == null)
                            return;
                        _pickPoint.Values[0] = axisValue.NumericalValue;
                        _pickPoint.NumericalArgument = diagramCoordinates.NumericalArgument;
                    }
                    break;
                case Model.eFeatCurveType.QP:
                    {
                        var axisValue = diagramCoordinates.GetAxisValue(_axisYQP);
                        if (axisValue == null)
                            return;
                        _pickPoint.Values[0] = axisValue.NumericalValue;
                        _pickPoint.NumericalArgument = diagramCoordinates.NumericalArgument;
                    }
                    break;
            }
        }
        private void chartControl1_MouseUp(object sender, MouseEventArgs e)
        {
            if (!_initialData)
                return;
            if (_mouseMode)
            {
                _pickPoint = null;
                ChartUpdateCurve();
            }
        }
        private void chartControl1_KeyUp(object sender, KeyEventArgs e)
        {
            if (!_initialData)
                return;
            if (_pickPoint == null)
                return;
            double spaceX = _coordinateParas.CoordSpaceQ / 50;
            double spaceY = 0;
            switch (_editCurveType)
            {
                case Model.eFeatCurveType.QH:
                    {
                        spaceY = _coordinateParas.CoordSpaceH / 50;
                    }
                    break;
                case Model.eFeatCurveType.QE:
                    {
                        spaceY = _coordinateParas.CoordSpaceE / 50;
                    }
                    break;
                case Model.eFeatCurveType.QP:
                    {
                        spaceY = _coordinateParas.CoordSpaceP / 50;
                    }
                    break;
                default:
                    break;
            }
            double x = _pickPoint.NumericalArgument;
            double y = _pickPoint.Values[0];
            if (e.KeyCode == Keys.Up)
            {
                y += spaceY;
            }
            else if (e.KeyCode == Keys.Down)
            {
                y -= spaceY;
            }
            else if (e.KeyCode == Keys.Left)
            {
                x -= spaceX;
            }
            else if (e.KeyCode == Keys.Right)
            {
                x += spaceX;
            }
            _pickPoint.Values[0] = y;
            _pickPoint.NumericalArgument = x;
            ChartUpdateCurve();
        }

        /// <summary>
        /// 更新曲线
        /// </summary>
        private void ChartUpdateCurve()
        {
            switch (_editCurveType)
            {
                case Model.eFeatCurveType.QH:
                    {
                        _definePointsQH = _seriesPointQH.Points.Select(x => new Model.CurvePoint(x.ArgumentX.NumericalArgument, x.NumericalValue)).ToList();
                        _curvePointsQH = Model.FitCurveHelper.GetFitPoints(_definePointsQH, _fitTypeQH);

                        _seriesCurveQH.Points.Clear();
                        foreach (var curvePoint in _curvePointsQH)
                        {
                            var seriesPoint = new SeriesPoint(curvePoint.X, curvePoint.Y);
                            _seriesCurveQH.Points.Add(seriesPoint);
                        }
                        OnDefinePointChanged?.Invoke(_editCurveType, _definePointsQH);
                    }
                    break;
                case Model.eFeatCurveType.QE:
                    {
                        _definePointsQE = _seriesPointQE.Points.Select(x => new Model.CurvePoint(x.ArgumentX.NumericalArgument, x.NumericalValue)).ToList();
                        _curvePointsQE = Model.FitCurveHelper.GetFitPoints(_definePointsQE, _fitTypeQE);

                        _seriesCurveQE.Points.Clear();
                        foreach (var curvePoint in _curvePointsQE)
                        {
                            var seriesPoint = new SeriesPoint(curvePoint.X, curvePoint.Y);
                            _seriesCurveQE.Points.Add(seriesPoint);
                        }
                        OnDefinePointChanged?.Invoke(_editCurveType, _definePointsQE);
                    }
                    break;
                case Model.eFeatCurveType.QP:
                    {
                        _definePointsQP = _seriesPointQP.Points.Select(x => new Model.CurvePoint(x.ArgumentX.NumericalArgument, x.NumericalValue)).ToList();
                        _curvePointsQP = Model.FitCurveHelper.GetFitPoints(_definePointsQP, _fitTypeQP);

                        _seriesCurveQP.Points.Clear();
                        foreach (var curvePoint in _curvePointsQP)
                        {
                            var seriesPoint = new SeriesPoint(curvePoint.X, curvePoint.Y);
                            _seriesCurveQP.Points.Add(seriesPoint);
                        }
                        OnDefinePointChanged?.Invoke(_editCurveType, _definePointsQP);
                    }
                    break;
            }

            CalcChartAxis();
        }
        #endregion

        #region Right Click Menu 

        #region Event  


        private void barCekChartEditMode_CheckedChanged(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            _mouseMode = this.barCekChartEditMode.Checked;
            var text = "修改模式:鼠标 / 键盘☑";
            if (_mouseMode)
            {
                text = "修改模式:鼠标☑ / 键盘";
            }
            _mainChartDiagram.DefaultPane.Title.Text = text;
        }

        private void BarBtnCalcCoordinate_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            CalcCoordinate();
            CalcChartAxis();
        }
        private void barCekLegendVisible_CheckedChanged(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            SetLegendVisible(this.barCekLegendVisible.Checked);
        }

        private void barCekSetAxisNameVisible_CheckedChanged(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            SetAxisNameVisible(this.barCekSetAxisNameVisible.Checked);
        }



        private void barBtnSetChartAxis_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            SetChartAxis();
        }

        #endregion


        /// <summary>
        /// 设置图例显示
        /// </summary>
        public void SetLegendVisible(bool visible)
        {
            this.chartControl1.Legend.Visibility = visible ? DefaultBoolean.True : DefaultBoolean.False;
        }

        /// <summary>
        /// 设置轴名称显示
        /// </summary>
        public void SetAxisNameVisible(bool visible)
        {
            _axisXQ.Title.Visibility = visible ? DefaultBoolean.True : DefaultBoolean.False;
            _axisYQH.Title.Visibility = visible ? DefaultBoolean.True : DefaultBoolean.False;
            _axisYQE.Title.Visibility = visible ? DefaultBoolean.True : DefaultBoolean.False;
            _axisYQP.Title.Visibility = visible ? DefaultBoolean.True : DefaultBoolean.False;
        }


        /// <summary>
        /// 设置坐标轴
        /// </summary>
        public void SetChartAxis()
        {
            var dlg = new ChartCoordinateDlg();
            var onlyQH = _curvePointsQE == null && _curvePointsQP == null;
            dlg.SetBindingData(_coordinateParas, onlyQH);
            dlg.OnChangedCoord += (rhs) =>
            {
                _coordinateParas = rhs;
                CalcChartAxis();
                this.OnCurveCoordinateParasChanged?.Invoke(_coordinateParas);
            };
            dlg.ShowDialog();
        }


        #endregion
    }
}