kev/Drawer/UCDraw/PcgDrawR_wellPole/WellAndSection/WellPoleMainView.cs

// <copyright file="MainView.cs" company="PlaceholderCompany">.Dock = DockStyle.Right;
// Copyright (c) PlaceholderCompany. All rights reserved.
// </copyright>
using DevExpress.XtraGrid;
using DevExpress.XtraGrid.Columns;
using DevExpress.XtraGrid.Views.Base;
using DevExpress.XtraGrid.Views.Grid;
using DevExpress.XtraGrid.Views.Grid.ViewInfo;
using DevExpress.XtraReports.UI;
using DQ.Construction.NewLook.Result;
using GeoSigma.SigmaDrawerStyle;
using GeoSigma.SigmaDrawerUtil;
using GeoSigma.UCDraw.Drawtool;
using GeoSigma.UCDraw.Tool;
using GeoSigma.UCDraw.UC;
using GeoSigmaDrawLib;
using Krypton.Docking;
using Krypton.Navigator;
using SigmaDrawerElement;
using SymbolLibInterface;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Xml;
using UCDraw;
using UCDraw.Print;
using UCDraw.Tool;
using UCDraw.UC;



namespace GeoSigma.UCDraw
{
    //    public delegate void XyStatusEventHandler(string xyInfo);

    //    public delegate void FileModifyEventHandle(object sender, bool isModified);

    //    public delegate void ToolStatusChangedHandler(string toolName, bool enable);

    //    public delegate void ReloadFileHandler();

    //    public delegate void SaveFileEventHandle(CancelEventArgs e);

    //    public delegate void ButtonStatusChangeEventHanler(DrawToolType toolType, bool bChecked);

    /// <summary>
    /// 绘图模块的视图管理类
    /// </summary>
    public partial class WellPoleMainView : Form
    {
        /// <summary>
        /// 鼠标移动事件
        /// </summary>
        public event XyStatusEventHandler MouseMoveXYEvent;

        /// <summary>
        /// 提示消息事件
        /// </summary>
        public event MainTipMessageHandler TipMessageHandler;

        /// <summary>
        /// 编辑状态切换事件
        /// </summary>
        public event ButtonStatusChangeEventHanler ButtonStatusChangeEvent;

        /// <summary>
        /// 获得长度和角度事件
        /// </summary>
        public event MainFrameHandle GetLengthAngleEvent;

        public EventHandler<EventArgs> DrawerGotFocus { get; set; }

        /// <summary>
        /// 图层选中
        /// </summary>
        public EventHandler<PropertyChangedEventArgs> LayerSelected { get; set; }

        /// <summary>
        /// 显示统计结果
        /// </summary>
        public event EventHandler<EventArgs> ShowStatisticResult;

        /// <summary>
        /// 图层可见性变化事件
        /// </summary>
        public event ChangeControlVisible LayerVisibleChanged;

        public event ChangeControlVisible PanelVisibleChanged;

        /// <summary>
        /// 文件保存前
        /// </summary>
        public event SaveFileEventHandle BeforeSaveFileEvent;

        public event ToolStatusChangedHandler ToolStatusChandedEvent;

        public event ReloadFileHandler ReloadFileEvent;

        public static readonly string POSITION = "Position";

        public DrawerMouseMoveEventHandler DrawerOnMouseMoveEvent
        {
            get { return this.viewer?.DrawerOnMouseMoveEvent; }
            set { this.viewer.DrawerOnMouseMoveEvent = value; }
        }

        /// <summary>
        /// 设置是否自动释放 pView 资源，如果设置为 false，需要手工负责资源的释放
        /// </summary>
        public bool AutoReleaseView { get; set; } = true;

        /// <summary>
        /// 等待事件.
        /// </summary>
        public WaitProgressEventHandler WaitProgressEvent
        {
            get
            {
                return this.viewer?.WaitProgressEvent;
            }
            set
            {
                if (this.viewer != null)
                {
                    this.viewer.WaitProgressEvent = value;
                }
            }
        }

        /// <summary>
        /// 文件修改状态变化事件
        /// </summary>
        public event FileModifyEventHandle FileModifyEvent;

        private bool isNewDocument = false;

        /// <summary>
        /// 是否新建文件
        /// </summary>
        public bool IsNewDocument
        {
            get { return this.isNewDocument; }
        }

        //  private LayerTree layerTree;

        /// <summary>
        /// 图层树控件
        /// </summary>
        //  public LayerTree LayerTreeControl => layerTree;

        /// <summary>
        /// 井类对象属性页控件
        /// </summary>
        private WellPolePanelProperty pnlWellProperty;

        /// <summary>
        /// 图形属性控件
        /// </summary>
        public WellPolePanelProperty PropertyWellControl => pnlWellProperty;

        /// <summary>
        /// 普通图元对象属性页控件
        /// </summary>
        private PanelEleProperty pnlProperty;

        public PanelEleProperty PropertyEleControl => pnlProperty;
        // private WellPoleDrawViewer viewer;
        private WellBaseDrawView viewer;
        /// <summary>
        /// 绘图区控件
        /// </summary>
        // public WellPoleDrawViewer ViewControl => viewer;
        public WellBaseDrawView ViewControl => viewer;
        /// <summary>
        /// 数据统计控件
        /// </summary>
        //public DataGridView StaticsControl => dgvStatics;
        //  private PanelControl staticsPanel = new PanelControl();

        /// <summary>
        /// 数据统计控件
        /// </summary>
        // public PanelControl StaticsControl => staticsPanel;

        /// <summary>
        /// 当前图层
        /// </summary>
        //public string CurrentLayer
        //{
        //    get
        //    {
        //        return ViewControl.GetCurrentLayer();
        //    }
        //    set
        //    {
        //        ViewControl.SetCurrentLayer(value);
        //    }
        //}

        /// <summary>
        /// 启动抗锯齿补丁
        /// </summary>
        public bool EnableMeshPack { get; set; } = true;
        private GridControl dgvStatics = new GridControl();

        // 当前的统计数据
        private DataTable StaticsDataTable { get; set; } = new DataTable();

        /// <summary>
        /// 显示图层面板
        /// </summary>
        public bool EnableLayerPanel { get; set; } = true;
        private bool layerVisible = true;

        /// <summary>
        /// 图层面板是否可见
        /// </summary>
        public bool LayerVisible
        {
            get
            {
                if (EnableLayerPanel)
                {
                    layerVisible = kryptonDockingManager.IsPageShowing("图层");
                }
                return layerVisible;
            }
            set
            {
                layerVisible = value;
                if (EnableLayerPanel)
                {
                    if (layerVisible)
                    {
                        kryptonDockingManager.ShowPages(new string[] { "图层" });
                        kryptonDockingManager.MakeDockedRequest("图层");
                    }
                    else
                    {
                        kryptonDockingManager.HidePages(new string[] { "图层" });
                    }
                }
            }
        }


        //   public GeoSigmaWellPoleXY.NewWellInfo mNewWellInfo = new GeoSigmaWellPoleXY.NewWellInfo();
        /// <summary>
        /// 显示属性面板
        /// </summary>
        public bool EnablePropertyPanel { get; set; } = true;
        private bool propertyVisible = true;

        /// <summary>
        /// 属性面板是否可见 
        /// </summary>
        public bool PropertyVisible
        {
            get
            {
                if (EnablePropertyPanel)
                {
                    bool bShowing = kryptonDockingManager.IsPageShowing("属性");
                    if (bShowing)
                    {
                        propertyVisible = true;
                    }
                    else
                    {
                        propertyVisible = false;
                    }
                }
                return propertyVisible;
            }
            set
            {
                propertyVisible = value;
                if (EnableLayerPanel)
                {
                    if (propertyVisible == true)
                    {
                        kryptonDockingManager.ShowPages(new string[] { "属性" });
                        // kryptonDockingManager.MakeDockedRequest("属性");
                        kryptonDockingManager.SwitchAutoHiddenGroupToDockedCellRequest("属性");
                    }
                    else
                    {
                        kryptonDockingManager.HidePages(new string[] { "属性" });
                    }
                }
            }
        }

        /// <summary>
        /// 显示统计面板
        /// </summary>
        public bool EnableStatisticPanel { get; set; } = true;
        private bool statisticVisble = true;

        /// <summary>
        /// 统计面板是否可见
        /// </summary>
        public bool StatisticVisble
        {
            get
            {
                if (EnableStatisticPanel)
                {
                    bool bShowing = kryptonDockingManager.IsPageShowing("统计");
                    if (bShowing)
                    {
                        statisticVisble = true;
                    }
                    else
                    {
                        statisticVisble = false;
                    }
                }
                return statisticVisble;
            }
            set
            {
                statisticVisble = value;
                if (EnableStatisticPanel)
                {
                    if (statisticVisble == true)
                    {
                        kryptonDockingManager.ShowPages(new string[] { "统计" });
                        kryptonDockingManager.MakeDockedRequest("统计");
                    }
                    else
                    {
                        kryptonDockingManager.HidePages(new string[] { "统计" });
                    }
                }
            }
        }

        private bool toolElementVisible = true;

        /// <summary>
        /// 文件是否被修改
        /// </summary>
        public bool IsFileDirty { get; set; } = false;

        public bool ToolElementVisible
        {
            get
            {
                return toolElementVisible;
            }
            set
            {
                toolElementVisible = value;
                tspElement.Visible = value;
            }
        }

        /// <summary>
        /// 选择的图元变化事件.
        /// </summary>
        public EventHandler<ElementArgs> SelectedElementChanged
        {
            get
            {
                if (this.viewer == null)
                {
                    return null;
                }
                return this.viewer.SelectedElementChanged;
            }
            set
            {
                if (this.viewer.SelectedElementChanged != null)
                {
                    this.viewer.SelectedElementChanged = value;
                }
            }
        }

        public EventHandler<MultiElementArgs> SelectedMultiElements
        {
            get
            {
                if (viewer == null)
                {
                    return null;
                }
                return viewer.SelectedMultiElements;
            }
            set
            {
                if (viewer != null)
                {
                    viewer.SelectedMultiElements = value;
                }
            }
        }

        /// <summary>
        /// 图元工具条
        /// </summary>
        public ToolStrip ToolstripElements
        {
            get
            {
                return tspElement;
            }
        }

        /// <summary>
        /// 视图工具条
        /// </summary>
        public ToolStrip ToolstripView
        {
            get
            {
                return tspArrange;
            }
        }

        public bool ToolMainVisible
        {
            get
            {
                return this.tsbtnSave.Visible;
            }
            set
            {
                this.tsbtnSave.Visible = value;
                this.tsbtnLayerPanel.Visible = value;
                tssepMain.Visible = value;
            }
        }

        public int ID
        {
            get
            {
                if (viewer != null)
                {
                    return viewer.ID;
                }
                return 0;
            }
        }

        public IntPtr DrawerXY
        {
            get => viewer.DrawerXY;
        }

        private string fileFullName;

        /// <summary>
        /// 文件的全路径
        /// </summary>
        public string FileFullName
        {
            get
            {
                return fileFullName;
            }
            set
            {
                fileFullName = value;
            }
        }

        public bool IsElementSelected
        {
            get
            {
                return viewer.SelectedElementPosition > 0;
            }
        }

        public double ZColorWidth { get; set; } = 25;
        private string symbolPath;

        /// <summary>
        /// 符号库所在路径
        /// </summary>
        public string SymbolPath
        {
            get
            {
                return symbolPath;
            }
            set
            {
                if (value == null)
                {
                    return;
                }
                if (!value.Equals(this.symbolPath))
                {
                    this.symbolPath = value;
                    string strNodeData = string.Empty;
                    GeoSigmaDrawLib.GeoSigmaXY.InitLibrary(symbolPath, ref strNodeData);
                }
            }
        }

        public CommandExecutionHandler ViewerCommandStart
        {
            get
            {
                return this.viewer?.ViewerCommandStart;
            }
            set
            {
                if (this.viewer != null)
                {
                    this.viewer.ViewerCommandStart = value;
                }
            }
        }

        public CommandExecutionHandler ViewerCommandFinish
        {
            get
            {
                return this.viewer?.ViewerCommandFinish;
            }
            set
            {
                if (this.viewer != null)
                {
                    this.viewer.ViewerCommandFinish = value;
                }
            }
        }

        /// <summary>
        /// 显示导航信息事件.
        /// </summary>
        /// <param name="elementTypes">图元类型.</param>
        /// <param name="eventHandler">处理事件.</param>
        public void SetNavigationEvent(List<DrawElementType> elementTypes, ShowNavigationEventHandler eventHandler)
        {
            if (elementTypes == null)
            {
                throw new ArgumentNullException(nameof(elementTypes));
            }

            if (eventHandler == null)
            {
                throw new ArgumentNullException(nameof(eventHandler));
            }

            this.viewer?.SetNavigationEvent(elementTypes, eventHandler);
        }

        /// <summary>
        /// 获得图层的数据
        /// </summary>
        /// <param name="layerName">图层名称</param>
        /// <returns>数据列表</returns>
        public List<DrawerElementProperty> GetDataByLayer(string layerName)
        {
            if (layerName == null)
            {
                throw new ArgumentNullException(nameof(layerName));
            }

            return viewer?.GetDataByLayer(layerName);
        }

        /// <summary>
        /// 获得图层的所有曲线
        /// </summary>
        /// <param name="layerName">图层名称</param>
        /// <returns>曲线数据</returns>
        public List<DrawerElementProperty> LayerGetCurves(string layerName)
        {
            if (layerName == null)
            {
                throw new ArgumentNullException(nameof(layerName));
            }

            return viewer?.GetLayerCurve(layerName);
        }

        /// <summary>
        /// 根据名称选中图元
        /// </summary>
        /// <param name="nameData">图元名称，多个图元名称以逗号分割</param>
        /// <returns>选中图元个数</returns>
        public int SelectByNames(string nameData)
        {
            if (nameData == null)
            {
                throw new ArgumentNullException(nameof(nameData));
            }

            return viewer.SelectByNames(nameData);
        }

        /// <summary>
        /// 根据名称查找并激活图元
        /// </summary>
        /// <param name="content">图元名称</param>
        /// <param name="matchAll">全字匹配</param>
        /// <param name="matchCase">匹配大小写</param>
        /// <param name="elementType">图元类型</param>
        /// <param name="editableOnly">是否只查找可编辑图元</param>
        /// <returns>查找结果</returns>
        public int FindElementByName(string content, bool matchAll = false, bool matchCase = false, int elementType = 0, bool editableOnly = true)
        {
            if (content == null)
            {
                throw new ArgumentNullException(nameof(content));
            }

            return viewer.FindElementByName(content, matchAll, matchCase, elementType, editableOnly);
        }

        /// <summary>
        /// position 转 DrawerElement
        /// </summary>
        /// <param name="positions">position列表</param>
        /// <returns>DrawerElementProperty列表</returns>
        public List<Tuple<long, DrawerElementProperty>> PositionsToDrawerElements(List<long> positions)
        {
            return positions.Select((pos) =>
            {
                return Tuple.Create(pos, PositionToDrawerElement(pos));
            })
                .ToList();
        }

        /// <summary>
        /// 搜索元素
        /// </summary>
        /// <param name="name">搜索的内容</param>
        /// <param name="ignoreCase">忽略大小写</param>
        /// <param name="matchWholeWord">完全匹配</param>
        /// <returns>position列表</returns>
        /// <exception cref="ArgumentNullException">name参数不能为null</exception>
        public List<long> SearchElementPositions(string name, bool ignoreCase = false, bool matchWholeWord = false)
        {
            if (name == null)
            {
                throw new ArgumentNullException(nameof(name));
            }

            return viewer.Geo.SearchElement(name, ignoreCase, matchWholeWord);
        }

        /// <summary>
        /// 搜索元素
        /// </summary>
        /// <param name="name">搜索的内容</param>
        /// <param name="ignoreCase">忽略大小写</param>
        /// <param name="matchWholeWord">完全匹配</param>
        /// <returns>position列表</returns>
        /// <returns>元素列表，注意：有的 DrawerElementProperty 可能为 null</returns>
        public List<Tuple<long, DrawerElementProperty>> SearchElements(string name, bool ignoreCase = false, bool matchWholeWord = false)
        {
            List<long> positions = SearchElementPositions(name, ignoreCase, matchWholeWord);
            return PositionsToDrawerElements(positions);
        }

        private DrawerElementProperty PositionToDrawerElement(long pos)
        {
            string strElementData = string.Empty;
            if (viewer.Geo.Select_GetElementByPosition(ref strElementData, pos))
            {
                return DrawerElementHelp.Deserialize(strElementData);
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        /// 添加点
        /// </summary>
        /// <param name="layerName">图层名称</param>
        /// <param name="pt">点</param>
        public void AddDrawPoint(string layerName, DrawerPoint pt)
        {
            if (layerName == null)
            {
                throw new ArgumentNullException(nameof(layerName));
            }

            if (pt == null)
            {
                throw new ArgumentNullException(nameof(pt));
            }

            viewer?.AddDrawPoint(layerName, pt);
        }

        /// <summary>
        /// 通过字符串添加元素，这个 api 内部没对字符串格式做验证
        /// </summary>
        /// <param name="data">字符串</param>
        /// <exception cref="ArgumentNullException">null或空string异常</exception>
        public void AddBufferData(string data)
        {
            if (data == null)
            {
                throw new ArgumentNullException(nameof(data));
            }

            viewer?.Drawer?.AddBufferData(data);
        }


        /// <summary>
        /// 重新设置线样式
        /// </summary>
        /// <param name="curveName">名称</param>
        /// <param name="layerName">图层</param>
        /// <param name="curveStyle">样式</param>
        /// <returns>应用数量</returns>
        public int ResetCurveStyle(string curveName, string layerName, CurveView curveStyle)
        {
            if (curveName == null)
            {
                throw new ArgumentNullException(nameof(curveName));
            }

            if (layerName == null)
            {
                throw new ArgumentNullException(nameof(layerName));
            }

            if (curveStyle == null)
            {
                throw new ArgumentNullException(nameof(curveStyle));
            }

            int nCount = viewer.ResetCurveStyle(curveName, layerName, curveStyle);

            return nCount;
        }

        /// <summary>
        /// 获取图层的样式
        /// </summary>
        /// <param name="layerName">图层名称</param>
        /// <returns>图层样式</returns>
        public DrawerStyle GetLayerLayerStyle(string layerName)
        {
            if (layerName == null)
            {
                throw new ArgumentNullException(nameof(layerName));
            }

            string strCurveData = string.Empty;
            string strPointData = string.Empty;
            viewer.GetLayerStyleData(layerName, ref strCurveData, ref strPointData);

            DrawerStyle drawerStyle = new DrawerStyle();
            if (strCurveData != string.Empty)
            {
                drawerStyle.DeserializeCurve(strCurveData);
            }
            if (strPointData != string.Empty)
            {
                drawerStyle.DeserializePoint(strPointData);
            }
            return drawerStyle;
        }

        /// <summary>
        /// 获得选中的所有图元
        /// </summary>
        /// <returns>选中图元的列表</returns>
        public List<DrawerElementProperty> GetSelectedElements()
        {
            return viewer?.GetSelectedElements();
        }

        /// <summary>
        /// 设置光标位置
        /// </summary>
        /// <param name="dx">x</param>
        /// <param name="dy">y</param>
        public void SetDrawerMouseLocation(double dx, double dy)
        {
            viewer?.SetDrawerMouseLocation(dx, dy);
        }

        /// <summary>
        /// 为图层树节点添加自定义命令
        /// </summary>
        /// <param name="text">命令名称</param>
        /// <param name="handler">事件句柄</param>
        public void InsertLayerCommand(string text, EventHandler handler)
        {
            if (text == null)
            {
                throw new ArgumentNullException(nameof(text));
            }

            if (handler == null)
            {
                throw new ArgumentNullException(nameof(handler));
            }

            //  layerTree.InsertCommand(text, handler);
        }

        #region 对外接口
        /// <summary>
        /// 将全部内容当前分辨率保存到指定输出文件.
        /// </summary>
        /// <param name="outputFile">The output file.</param>
        /// <param name="left"></param>
        /// <param name="top"></param>
        /// <param name="right"></param>
        /// <param name="bottom"></param>
        public void Draw2Image(string outputFile, double left = 0, double top = 0, double right = 0, double bottom = 0)
        {
            viewer?.Draw2Image(outputFile, left, top, right, bottom);
        }

        /// <summary>
        /// 添加地震剖面
        /// </summary>
        /// <param name="sectionData">属性数据</param>
        /// <returns>图元索引</returns>
        public long AddSeismicSection(string sectionData, float[] values)
        {
            if (viewer == null)
            {
                return -1;
            }
            return viewer.Drawer.AddSeismicSection(sectionData, values);
        }

        /// <summary>
        /// 添加点数据
        /// </summary>
        /// <param name="layerName">图层名</param>
        /// <param name="points">点列表</param>
        public void AddDrawPoints(string layerName, List<DrawerPoint> points)
        {
            if (viewer == null)
            {
                return;
            }
            viewer.AddDrawPoints(layerName, points);
        }

        /// <summary>
        /// 删除点数据
        /// </summary>
        /// <param name="layerName">图层名称</param>
        /// <param name="ptName">点名称</param>
        public void DeleteDrawPoint(string layerName, string ptName)
        {
            if (layerName == null)
            {
                throw new ArgumentNullException(nameof(layerName));
            }

            if (ptName == null)
            {
                throw new ArgumentNullException(nameof(ptName));
            }

            viewer?.DeletePoint(layerName, ptName);
        }

        /// <summary>
        /// 删除点数据
        /// </summary>
        /// <param name="layerName">图层</param>
        /// <param name="ptNames">名称列表</param>
        public void DeleteDrawPoints(string layerName, List<string> ptNames)
        {
            if (layerName == null)
            {
                throw new ArgumentNullException(nameof(layerName));
            }

            if (ptNames == null)
            {
                throw new ArgumentNullException(nameof(ptNames));
            }

            viewer?.DeletePoints(layerName, ptNames);
        }

        /// <summary>
        /// 删除点数据
        /// </summary>
        /// <param name="layerName">图层</param>
        /// <param name="eleNames">名称列表</param>
        public void DeleteDrawPoints(string layerName, List<DrawerPoint> eleNames)
        {
            if (layerName == null)
            {
                throw new ArgumentNullException(nameof(layerName));
            }

            this.viewer?.DeletePoints(layerName, eleNames);
        }

        /// <summary>
        /// 添加线
        /// </summary>
        /// <param name="layerName">图层</param>
        /// <param name="name">线名</param>
        /// <param name="pts">坐标点</param>
        public void AddDrawCurve(string layerName, string name, List<PointD> pts)
        {
            if (layerName == null)
            {
                throw new ArgumentNullException(nameof(layerName));
            }

            if (name == null)
            {
                throw new ArgumentNullException(nameof(name));
            }

            if (pts == null)
            {
                throw new ArgumentNullException(nameof(pts));
            }

            viewer?.Drawer.AddCurve(layerName, name, pts);
        }

        /// <summary>
        /// 删除图层
        /// </summary>
        /// <param name="layers">图层列表</param>
        /// <param name="withSublayer">是否删除子层</param>
        public void DeleteLayers(List<string> layers, bool withSublayer = false)
        {
            if (layers == null)
            {
                throw new ArgumentNullException(nameof(layers));
            }

            viewer?.DeleteLayer(layers, withSublayer);
        }

        /// <summary>
        /// 设置图层曲线属性
        /// </summary>
        /// <param name="layerName">图层名称</param>
        /// <param name="curveView">曲线修饰</param>
        /// <param name="index">下标，曲线修饰可以有很多个，这个表示设置第几个</param>
        /// <returns>成功/失败</returns>
        public bool SetLayerCurveStyle(string layerName, CurveView curveView, int index)
        {
            if (layerName == null)
            {
                throw new ArgumentNullException(nameof(layerName));
            }

            if (curveView == null)
            {
                throw new ArgumentNullException(nameof(curveView));
            }

            if (index < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(index));
            }

            return viewer.SetLayerStyle(curveView, layerName, index);
        }

        /// <summary>
        /// 设置点属性
        /// </summary>
        /// <param name="layerName">图层名称</param>
        /// <param name="pointStyle">属性</param>
        /// <param name="replace">是否替换已有样式</param>
        /// <returns>成功/失败</returns>
        public bool SetLayerPointStyle(string layerName, DrawerPointStyle pointStyle, bool replace)
        {
            if (layerName == null)
            {
                throw new ArgumentNullException(nameof(layerName));
            }

            if (pointStyle == null)
            {
                throw new ArgumentNullException(nameof(pointStyle));
            }

            string strPointStyle = pointStyle.SerialXml();
            return viewer.SetLayerHowtoViewPoint(layerName, strPointStyle, replace);
        }

        /// <summary>
        /// 显示符号管理
        /// </summary>
        /// <param name="symbolPath">符号库的路径</param>
        public void ShowSymbolManager(string symbolPath)
        {
            if (!string.IsNullOrEmpty(symbolPath))
            {
                SymbolPath = symbolPath;
            }
            SymbolHelp.ShowSymbolUI(this, symbolPath);
        }

        /// <summary>
        /// Adds the data as symble.
        /// </summary>
        /// <param name="data">The data.</param>
        /// <param name="symbolName">The symbol name.</param>
        /// <param name="overwrite">If true, overwrite.</param>
        /// <returns>An int.</returns>
        public int AddDataAsSymble(string data, string symbolName, bool overwrite = false)
        {
            return viewer.AddDataAsSymble(data, symbolName, overwrite);
        }

        #endregion 对外接口

        //private readonly KryptonPage pageStatistic;

        GeoSigmaXY.eViewType mViewType;

        /// <summary>
        /// Initializes a new instance of the <see cref="MainView"/> class.
        /// </summary>
        public WellPoleMainView(GeoSigmaXY.eViewType vType = GeoSigmaXY.eViewType.plane)
        {
            //.mNewWellInfo = new GeoSigmaWellPoleXY.newWellInfo();
            mViewType = vType;
            this.TopLevel = false;
            InitializeComponent();

            // Setup docking functionality
            KryptonDockingWorkspace w = kryptonDockingManager.ManageWorkspace(kryptonDockableWorkspace);
            kryptonDockingManager.ManageControl(kryptonPanel1, w);
            kryptonDockingManager.ManageFloating(this);
            // Add docking pages
            // kryptonDockingManager.AddDockspace("Control", DockingEdge.Left, new KryptonPage[] { MakeLayerTreePanel() });
            //pageStatistic = MakeStatisticPanel();
            //kryptonDockingManager.AddDockspace("Control", DockingEdge.Bottom, new KryptonPage[] { pageStatistic });
            kryptonDockingManager.AddDockspace("Control", DockingEdge.Left, new KryptonPage[] { MakePropertyPanel() });//生成最终用到的属性页
            kryptonDockingManager.AddAutoHiddenGroup("Control", DockingEdge.Right, new KryptonPage[] { MakeWellPropertyPanel() });//生成最终用到的属性页
            this.kryptonWorkspaceCell1.Pages.Clear();
            this.kryptonWorkspaceCell1.Pages.AddRange(
                new Krypton.Navigator.KryptonPage[] { MakeViewerDoc() });

            pnlProperty.Viewer = this.viewer;
            // this.TopLevel = false;
            //this.sbtnEllipse.Tag = this.sbtnEllipse.DropDownItems[0];

            BindEvent();

            // layerTree.AutoAdjustDirectionEvent += OnAutoAdjustDirection;

            //  InitStatisticPanel();

            //GradientColorManager.LoadTemplate(false);
        }

        private void MainView_Load(object sender, EventArgs e)
        {
            //kryptonDockingManager.HidePages(new string[] { "统计" });

            //tspElement.Visible = ToolElementVisible;
            //if (!string.IsNullOrEmpty(CurrentLayer))
            //{
            //    layerTree_LayerSelect("Layer:\\" + CurrentLayer);
            //}
        }

        /// <summary>
        /// 关闭断层编辑弹框
        /// </summary>
        public void CloseFaultEditor()
        {
            faultEditForm?.Close();
            faultEditForm = null;
        }

        /// <inheritdoc/>
        protected override void OnClosed(EventArgs e)
        {
            CloseFaultEditor();

            base.OnClosed(e);
        }

        /// <inheritdoc/>
        protected override void OnParentVisibleChanged(EventArgs e)
        {
            if (!this.Visible)
            {
                CloseFaultEditor();
            }

            base.OnParentVisibleChanged(e);
        }

        private KryptonPage MakeViewerDoc()
        {
            if (mViewType == GeoSigmaXY.eViewType.wellsection)
                this.viewer = new WellSectionDrawViewer(mViewType);
            else
                this.viewer = new WellPoleDrawViewer(mViewType);

            this.viewer.BackColor = System.Drawing.Color.White;
            this.viewer.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
            // this.viewer.EnableMeshPack = true;
            this.viewer.Geo = null;

            this.viewer.Location = new System.Drawing.Point(219, 23);
            this.viewer.Margin = new System.Windows.Forms.Padding(4);
            this.viewer.Name = "viewer";
            this.viewer.Size = new System.Drawing.Size(517, 132);
            this.viewer.TabIndex = 7;
            this.viewer.Dock = DockStyle.Fill;

            KryptonPage p = new KryptonPage();
            p.Text = "绘图";
            p.TextTitle = p.Text;
            p.TextDescription = p.Text;
            p.UniqueName = p.Text;
            //p.ImageSmall = imageListSmall.Images[image];

            // Add the control for display inside the page
            p.Controls.Add(viewer);
            return p;
        }


        /// <summary>
        /// 初始化统计面板
        /// </summary>
        private void InitStatisticPanel()
        {
            if (dgvStatics.MainView == null)
            {
                GridView gridView = new GridView(dgvStatics);
                dgvStatics.MainView = gridView;
                gridView.OptionsView.ShowGroupPanel = false;
                gridView.OptionsBehavior.Editable = false;
                gridView.VertScrollVisibility = ScrollVisibility.Always;
                gridView.KeyDown += DvgStatics_KeyDown;
                gridView.DoubleClick += DgvStatisc_DoubleClick;

                dgvStatics.DataSourceChanged += (sender, e) =>
                {
                    GridView view = dgvStatics.MainView as GridView;
                    view.OptionsSelection.MultiSelect = true;
                    view.PopulateColumns();

                    // 隐藏 Position 列，该列是用来定位的
                    var column = view.Columns.Cast<GridColumn>()
                        .FirstOrDefault(col => col.FieldName.Equals(POSITION, StringComparison.OrdinalIgnoreCase));
                    if (column != null)
                    {
                        column.Visible = false;
                    }
                };
            }
        }

        private ToolStripButton CreateExportButton(string name, string text, Image image)
        {
            ToolStripButton button = new System.Windows.Forms.ToolStripButton
            {
                DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image,
                Image = image,
                ImageScaling = System.Windows.Forms.ToolStripItemImageScaling.None,
                ImageTransparentColor = System.Drawing.Color.Silver,
                Name = name,
                Size = new System.Drawing.Size(23, 24),
                Text = text,
            };

            return button;
        }

        private void BtnDelete_Click(object sender, EventArgs e)
        {
            GridView view = dgvStatics.MainView as GridView;
            int[] rows = view.GetSelectedRows();

            var positions = new List<long>();

            for (int i = rows.Length - 1; i >= 0; i--)
            {
                int rowIndex = rows[i];

                string value = view.GetRowCellValue(rowIndex, POSITION) as string;
                if (long.TryParse(value, out long position))
                {
                    positions.Add(position);
                    view.DeleteRow(rowIndex);
                }
            }

            RemoveElement(positions.ToArray());
            this.viewer.Redraw();
        }

        private void BtnLocation_Click(object sender, EventArgs e)
        {
            List<long> positions = new List<long>();

            GridView view = dgvStatics.MainView as GridView;
            int[] rows = view.GetSelectedRows();

            foreach (int row in rows)
            {
                string value = view.GetRowCellValue(row, POSITION) as string;
                if (Int64.TryParse(value, out Int64 position))
                {
                    positions.Add(position);
                }
            }

            ActiveElements(positions.ToArray());
            viewer.Redraw();
        }

        private bool CurrentStatsicPanelIsResourceComment()
        {
            GridView view = dgvStatics.MainView as GridView;
            return view?.Columns.ColumnByFieldName("WKT") != null;
        }

        private bool ExportResourceComment(string path)
        {
            int posIndex = StaticsDataTable.Columns.IndexOf("Position");
            return DataTableExporter.ExportCsv(StaticsDataTable, path, new[] { posIndex });
        }

        private void BtnExport_Click(object sender, EventArgs e)
        {
            SaveFileDialog sfd = new SaveFileDialog
            {
                Filter = "*.csv|*.csv|*.*|*.*",
                AddExtension = true,
                OverwritePrompt = true,
                RestoreDirectory = true,
            };

            if (sfd.ShowDialog(this) != DialogResult.OK)
            {
                return;
            }

            string strFile = sfd.FileName;
            GridView view = dgvStatics.MainView as GridView;
            if (view.Columns.Count() == 0)
            {
                MessageBox.Show("导出失败，数据为空！");
                return;
            }

            // 矿权统计界面显示的不是完整内容，要从数据里面去导，
            // 实际上按照良好的设计来说，本来也该从 model 去导数据
            // 因为界面呈现方式本来就是可以灵活调整的
            if (CurrentStatsicPanelIsResourceComment())
            {
                if (ExportResourceComment(strFile))
                {
                    MessageBox.Show("导出表格成功！");
                }
                else
                {
                    MessageBox.Show($"导出表格失败！\r\n");
                }
                return;
            }

            try
            {
                if (ExportGrid2Csv(dgvStatics, strFile))
                {
                    MessageBox.Show("导出表格成功！");
                }
                else
                {
                    MessageBox.Show($"导出表格失败！\r\n");
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show($"导出表格失败！\r\n{ex.Message}");
            }
        }

        private void DvgStatics_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Delete)
            {
                BtnDelete_Click(sender, e);
                return;
            }

            OnKeyDown(e);
        }

        //private KryptonPage MakeStatisticPanel()
        //{
        //    KryptonPage p = new KryptonPage
        //    {
        //        Text = "统计",
        //    };
        //    p.TextTitle = p.Text;
        //    p.TextDescription = p.Text;
        //    p.UniqueName = p.Text;


        //    var btnDelete = CreateExportButton("btnStatisticDelete", "删除", global::GeoSigma.UCDraw.Properties.Resources.shanchu1);
        //    btnDelete.Click += BtnDelete_Click;

        //    var btnSelectAll = CreateExportButton("btnStatisticSelectall", "全选", global::GeoSigma.UCDraw.Properties.Resources.quanxuan1);
        //    btnSelectAll.Click += (sender, e) =>
        //    {
        //        GridView view = dgvStatics.MainView as GridView;
        //        view?.SelectAll();
        //    };

        //    // 定位按钮
        //    var btnLocation = CreateExportButton("btnStatisticLocation", "定位图元", global::GeoSigma.UCDraw.Properties.Resources.xuanzetuyuan);
        //    btnLocation.Click += BtnLocation_Click;

        //    var btnExport = CreateExportButton("btnStatisticExport", "导出", global::GeoSigma.UCDraw.Properties.Resources.daochu);
        //    btnExport.Click += BtnExport_Click;

        //    ToolStrip tspStatistic = new ToolStrip();
        //    tspStatistic.Items.AddRange(new System.Windows.Forms.ToolStripItem[]
        //    {
        //        btnSelectAll,
        //        btnLocation,
        //        btnDelete,
        //        btnExport,
        //    });

        //    tspStatistic.LayoutStyle = ToolStripLayoutStyle.VerticalStackWithOverflow;
        //    dgvStatics.Dock = DockStyle.Fill;
        //    tspStatistic.Dock = DockStyle.Right;
        //    staticsPanel.AddControl(dgvStatics);
        //    staticsPanel.AddControl(tspStatistic);
        //    // Add the control for display inside the page
        //    staticsPanel.Dock = DockStyle.Fill;
        //    p.Controls.Add(staticsPanel);
        //    return p;
        //}

        private void DgvStatics_Sorted(object sender, EventArgs e)
        {
            throw new NotImplementedException();
        }

        private bool isAscending = true; // 表示是否是升序排序
        private DataGridViewColumn clickedColumn = null; // 记录点击的列

        // 移除排序标识
        private string RemoveOrderIndicator(string title)
        {
            if (title.EndsWith("↑") || title.EndsWith("↓"))
            {
                return title.Remove(title.Length - 1);
            }

            return title;
        }

        private void DataGridViewColumnHeader_MouseClick(object sender, DataGridViewCellMouseEventArgs e)
        {
            DataGridView dataGridView = sender as DataGridView;

            DataGridViewColumn newClickedColumn = dataGridView.Columns[e.ColumnIndex];

            // 判断是否点击的同一列
            if (clickedColumn != null && clickedColumn == newClickedColumn)
            {
                // 切换排序方式
                isAscending = !isAscending;
            }
            else
            {
                // 默认为升序排序
                isAscending = true;
                clickedColumn = newClickedColumn;
            }

            // 设置排序图标
            dataGridView.Columns.Cast<DataGridViewColumn>().ToList().ForEach(column =>
            {
                if (column.SortMode != DataGridViewColumnSortMode.NotSortable)
                {
                    // 去掉前面附加的箭头
                    column.HeaderCell.Value = RemoveOrderIndicator(column.HeaderCell.Value.ToString());
                }
            });

            DataGridViewColumnHeaderCell currentHeaderCell = newClickedColumn.HeaderCell;

            // 设置当前列的排序标识
            if (isAscending)
            {
                currentHeaderCell.SortGlyphDirection = SortOrder.Ascending;
                currentHeaderCell.Value = currentHeaderCell.Value.ToString() + "↑";
            }
            else
            {
                currentHeaderCell.SortGlyphDirection = SortOrder.Descending;
                currentHeaderCell.Value = currentHeaderCell.Value.ToString() + "↓";
            }

            // 排序
            ListSortDirection direction = isAscending ? ListSortDirection.Ascending : ListSortDirection.Descending;
            dataGridView.Sort(newClickedColumn, direction);
        }

        private bool ExportGrid2Csv(GridControl grid, string fileName, string columnExcept = "Position")
        {
            Stream stream = null;
            StreamWriter sw = null;
            try
            {
                stream = File.Open(fileName, FileMode.OpenOrCreate, FileAccess.Write, FileShare.ReadWrite);
                sw = new StreamWriter(stream, System.Text.Encoding.UTF8);

                GridView gridView = grid.MainView as GridView;

                // Write column headers
                string columnTitle = string.Empty;
                for (int i = 0; i < gridView.Columns.Count; i++)
                {
                    if (gridView.Columns[i].FieldName.Equals(columnExcept, StringComparison.CurrentCultureIgnoreCase))
                    {
                        continue;
                    }
                    if (!string.IsNullOrEmpty(columnTitle))
                    {
                        columnTitle += ",";
                    }
                    columnTitle += gridView.Columns[i].FieldName;
                }
                sw.WriteLine(columnTitle);

                // Write rows data
                for (int j = 0; j < gridView.RowCount; j++)
                {
                    string columnValue = string.Empty;
                    for (int k = 0; k < gridView.Columns.Count; k++)
                    {
                        if (gridView.Columns[k].FieldName.Equals(columnExcept, StringComparison.CurrentCultureIgnoreCase))
                        {
                            continue;
                        }
                        if (!string.IsNullOrEmpty(columnValue))
                        {
                            columnValue += ",";
                        }
                        object cellValue = gridView.GetRowCellValue(j, gridView.Columns[k]);
                        string strValue = cellValue?.ToString() ?? string.Empty;

                        if (strValue.Contains(","))
                        {
                            // Escape commas by wrapping value in quotes
                            columnValue += "\"" + strValue + "\"";
                        }
                        else
                        {
                            columnValue += strValue;
                        }
                    }
                    sw.WriteLine(columnValue);
                }

                return true;
            }
            catch (Exception e)
            {
                throw new Exception("Failed to export grid data", e);
            }
            finally
            {
                sw?.Close();
                stream?.Close();
            }
        }

        private KryptonPage MakeWellPropertyPanel()
        {
            this.pnlWellProperty = new WellPolePanelProperty();
            this.pnlWellProperty.Dock = System.Windows.Forms.DockStyle.Fill;
            this.pnlWellProperty.Location = new System.Drawing.Point(0, 0);
            this.pnlWellProperty.Margin = new System.Windows.Forms.Padding(4);
            this.pnlWellProperty.Name = "pnlWellProperty";
            this.pnlWellProperty.Size = new System.Drawing.Size(381, 257);
            this.pnlWellProperty.TabIndex = 0;
            this.pnlWellProperty.ElementChanged += PnlWellProperty_ElementChanged;

            KryptonPage p = new KryptonPage();
            p.Width = 400;
            p.Text = "属性";
            p.TextTitle = p.Text;
            p.TextDescription = p.Text;
            p.UniqueName = p.Text;
            //p.ImageSmall = imageListSmall.Images[image];

            // Add the control for display inside the page
            p.Controls.Add(pnlWellProperty);
            return p;
        }


        private KryptonPage MakePropertyPanel()
        {
            this.pnlProperty = new PanelEleProperty();
            this.pnlProperty.CurrentStyle = null;
            this.pnlProperty.Dock = System.Windows.Forms.DockStyle.Fill;
            this.pnlProperty.ElementProperty = null;
            this.pnlProperty.LayerName = null;
            this.pnlProperty.Location = new System.Drawing.Point(0, 0);
            this.pnlProperty.Margin = new System.Windows.Forms.Padding(4);
            this.pnlProperty.Name = "pnlProperty";
            this.pnlProperty.Size = new System.Drawing.Size(381, 257);
            this.pnlProperty.TabIndex = 0;
            this.pnlProperty.Viewer = null;

            KryptonPage p = new KryptonPage();
            p.Width = 400;
            p.Text = "属性1";
            p.TextTitle = p.Text;
            p.TextDescription = p.Text;
            p.UniqueName = p.Text;
            //p.ImageSmall = imageListSmall.Images[image];

            // Add the control for display inside the page
            p.Controls.Add(pnlProperty);
            return p;
        }

        //private KryptonPage MakeLayerTreePanel()
        //{
        //    this.layerTree = new LayerTree();
        //    this.layerTree.AutoSizeMode = System.Windows.Forms.AutoSizeMode.GrowAndShrink;
        //    this.layerTree.CurrentNode = null;
        //    this.layerTree.Dock = System.Windows.Forms.DockStyle.Fill;
        //    this.layerTree.DrawViewer = null;
        //    this.layerTree.LayerActiveEvent = null;
        //    this.layerTree.Location = new System.Drawing.Point(0, 0);
        //    this.layerTree.Margin = new System.Windows.Forms.Padding(4);
        //    this.layerTree.Name = "layerTree";
        //    this.layerTree.Size = new System.Drawing.Size(215, 369);
        //    this.layerTree.TabIndex = 0;

        //    KryptonPage p = new KryptonPage();
        //    p.Text = "图层";
        //    p.TextTitle = p.Text;
        //    p.TextDescription = p.Text;
        //    p.UniqueName = p.Text;
        //    //p.ImageSmall = imageListSmall.Images[image];

        //    // Add the control for display inside the page
        //    p.Controls.Add(layerTree);
        //    return p;
        //}

        public void GetLengthAngle(string info)
        {
            GetLengthAngleEvent?.Invoke(info);
        }

        private void Application_Idle(object sender, EventArgs e)
        {
            if (viewer == null)
            {
                return;
            }
            GeoSigmaXY geo = viewer.GetGeoSigma();
            if (geo == null)
            {
                return;
            }

            SetStatusOfControls();
            SetStatusFileDirty();
        }

        private void SetStatusFileDirty()
        {
            GeoSigmaXY geo = viewer.GetGeoSigma();
            bool isModified = geo.Sigma_IsDocumentModified();
            if (this.IsFileDirty != isModified)
            {
                this.IsFileDirty = isModified;

                string strTitleOld = this.Text;
                if (string.IsNullOrEmpty(strTitleOld))
                {
                    this.FileModifyEvent?.Invoke(this, this.IsFileDirty);
                    return;
                }
                if (isModified)
                {
                    if (strTitleOld[0] != '*')
                    {
                        strTitleOld = $"*{strTitleOld}";
                    }
                }
                else
                {
                    if (strTitleOld[0] == '*')
                    {
                        strTitleOld = strTitleOld.Remove(0, 1);
                    }
                }
                this.Text = strTitleOld;
                this.FileModifyEvent?.Invoke(this, this.IsFileDirty);
            }
        }

        private void SetStatusOfControls()
        {
            GeoSigmaXY geo = viewer.GetGeoSigma();
            bool bCanUndo = geo.GeoSigma_CanUndo();

            bool bIsEdit = false;
            if( this.ViewControl.Drawer.ActiveTool == DrawToolType.SelectWellPole)
            {  
                DrawToolWellPole drawToolWellPole = (DrawToolWellPole)this.ViewControl.Drawer.ActiveDrawTool;
                if(drawToolWellPole.IsEditStatus)
                {//当处于文本框编辑状态时，不要使用undo/redo
                    bIsEdit = true;
                }
            }
            if (this.ViewControl.Drawer.ActiveTool == DrawToolType.SelectWellSection)
            {
                DrawToolWellSection drawToolWellSection = (DrawToolWellSection)this.ViewControl.Drawer.ActiveDrawTool;
                if (drawToolWellSection.IsEditStatus)
                {//当处于文本框编辑状态时，不要使用undo/redo
                    bIsEdit = true;
                }
            }

            if (bIsEdit)
            {
                bCanUndo = false;
            }

            if (bCanUndo != undoButton.Enabled)
            {
                undoButton.Enabled = bCanUndo;
                ToolStatusChandedEvent?.Invoke("undo", bCanUndo);
            }

            bool bCanRedo = geo.GeoSigma_CanRedo();
            if(bIsEdit)
            {
                bCanRedo = false;
            }
            if (bCanRedo != redoButton.Enabled)
            {
                redoButton.Enabled = bCanRedo;
                ToolStatusChandedEvent?.Invoke("redo", bCanRedo);
            }

            bool bCanUndoView = geo.GeoSigma_GetZoomStackCount() > 0;
            if (bCanUndoView != undoViewButton.Enabled)
            {
                undoViewButton.Enabled = bCanUndoView;
                ToolStatusChandedEvent?.Invoke("undoView", bCanUndoView);
            }
        }

        private void DgvStatisc_DoubleClick(object sender, EventArgs e)
        {
            try
            {
                GridView view = sender as GridView;

                Point mousePosition = view.GridControl.PointToClient(Control.MousePosition);

                GridHitInfo hitInfo = view.CalcHitInfo(mousePosition);
                int rowHandle = hitInfo.RowHandle; // 行索引

                string cellValue = view.GetRowCellValue(rowHandle, POSITION) as string;
                if (long.TryParse(cellValue, out long position))
                {
                    ActiveElement(position);
                    this.viewer.Redraw();
                }
            }
            catch (Exception ex)
            {
                Trace.WriteLine(ex.Message);
            }
        }

        /// <summary>
        /// 激活某图元，选中并显示属性.
        /// </summary>
        /// <param name="position">The position.</param>
        public void ActiveElement(long position)
        {
            if (position <= 0)
            {
                throw new ArgumentOutOfRangeException(nameof(position));
            }

            ToolSelect();
            viewer.GetGeoSigma().ActiveEelement(position);
            viewer.Drawer.RefreshProperty();
        }

        /// <summary>
        /// 激活某图元，选中并显示属性.
        /// </summary>
        /// <param name="positions">选中的 position 集合</param>
        public void ActiveElements(long[] positions)
        {
            if (positions == null)
            {
                throw new ArgumentNullException(nameof(positions));
            }

            ToolSelect();
            viewer.GetGeoSigma().ActiveElements(positions);
        }

        /// <summary>
        /// 删除某图元
        /// </summary>
        /// <param name="positions">The position.</param>
        public void RemoveElement(long[] positions)
        {
            if (positions == null)
            {
                throw new ArgumentNullException(nameof(positions));
            }

            viewer.GetGeoSigma().DeleteElement(positions);
        }

        public void ShowMouseInfo(string mouseXY)
        {
            MouseMoveXYEvent?.Invoke(mouseXY);
        }

        public void ShowTipMessage(string tipMessage)
        {
            TipMessageHandler?.Invoke(tipMessage);
        }

        public bool SelectWriteTemplate(string outputFile)
        {
            return viewer.SelectWriteTemplate(outputFile);
        }

        #region 文件操作

        /// <summary>
        /// 合并图片文件
        /// </summary>
        /// <param name="fileName">输入文件</param>
        /// <param name="onBottom">是否插入到最底层</param>
        /// <param name="locationX">起始坐标X</param>
        /// <param name="locationY">起始坐标Y</param>
        /// <param name="endX">终止坐标X</param>
        /// <param name="endY">终止坐标Y</param>
        /// <param name="layerName">图层名称</param>
        public void ImageFileMerge(string fileName, bool onBottom,
                double locationX, double locationY, double endX, double endY, string layerName)
        {
            if (fileName == null)
            {
                throw new ArgumentNullException(nameof(fileName));
            }

            viewer.Geo.ImageFileMerge(fileName, onBottom,
                locationX, locationY, endX, endY, layerName);
        }

        /// <summary>
        /// 合并平面图文件
        /// </summary>
        /// <param name="fileName">文件名称</param>
        /// <param name="onBottom">是否在最底层</param>
        /// <returns>是否成功</returns>
        public bool FileMerge(string fileName, bool onBottom = false)
        {
            if (fileName == null)
            {
                throw new ArgumentNullException(nameof(fileName));
            }

            viewer.Geo.FileMerge(fileName, onBottom);
            // viewer.Redraw();
            LoadLayerTree();
            return true;
        }

        /// <summary>
        /// 合并单井图文件
        /// </summary>
        /// <param name="fileName">文件名称</param>
        /// <param name="onBottom">是否在最底层</param>
        /// <returns>是否成功</returns>
        public bool WellPoleFileMerge(string fileName, bool onBottom = false)
        {
            if (fileName == null)
            {
                throw new ArgumentNullException(nameof(fileName));
            }

            viewer.Geo.WellPoleFileMerge(fileName, onBottom);
            // viewer.Redraw();
            LoadLayerTree();
            return true;
        }

        /// <summary>
        /// 合并剖面图文件
        /// </summary>
        /// <param name="fileName">文件名称</param>
        /// <param name="onBottom">是否在最底层</param>
        /// <returns>是否成功</returns>
        public bool MultiWellSectionFileMerge(string fileName, bool onBottom = false)
        {
            if (fileName == null)
            {
                throw new ArgumentNullException(nameof(fileName));
            }

            viewer.Geo.MultiWellSectionFileMerge(fileName, onBottom);
            // viewer.Redraw();
            LoadLayerTree();
            return true;
        }

        /// <summary>
        /// 在指定层位前合并文件.
        /// </summary>
        /// <param name="fileName">Name of the file.</param>
        /// <param name="layerBefore">The layer before.</param>
        /// <returns>是否成功</returns>
        public bool FileMergeBefore(string fileName, string layerBefore)
        {
            if (fileName == null)
            {
                throw new ArgumentNullException(nameof(fileName));
            }

            if (layerBefore == null)
            {
                throw new ArgumentNullException(layerBefore);
            }

            viewer.Geo.FileMergeBefore(fileName, layerBefore);
            // viewer.Redraw();
            LoadLayerTree();
            return true;
        }

        /// <summary>
        /// 在指定层位后合并文件.
        /// </summary>
        /// <param name="fileName">Name of the file.</param>
        /// <param name="layerAfter">The layer after.</param>
        /// <returns>是否成功</returns>
        public bool FileMergeAfter(string fileName, string layerAfter)
        {
            if (fileName == null)
            {
                throw new ArgumentNullException(nameof(fileName));
            }

            if (layerAfter == null)
            {
                throw new ArgumentNullException(layerAfter);
            }

            viewer.Geo.FileMergeAfter(fileName, layerAfter);
            LoadLayerTree();
            return true;
        }

        /// <summary>
        /// 保存显示数据
        /// </summary>
        /// <param name="fileName">文件路径</param>
        /// <returns>是否成功</returns>
        public bool FileSaveView(string fileName)
        {
            if (fileName == null)
            {
                throw new ArgumentNullException(nameof(fileName));
            }

            viewer.Geo.FileSaveView(fileName);
            return true;
        }

        /// <summary>
        /// 保存选择的数据
        /// </summary>
        /// <param name="fileName">文件名</param>
        /// <returns>成功/失败</returns>
        public bool FileSaveSelect(string fileName)
        {
            if (fileName == null)
            {
                throw new ArgumentNullException(nameof(fileName));
            }

            viewer.Geo.FileSaveSelect(fileName);
            return true;
        }

        /// <summary>
        /// 保存点
        /// </summary>
        /// <param name="fileName">文件路径名</param>
        /// <returns>成功/失败</returns>
        public bool FileSavePoint(string fileName)
        {
            if (fileName == null)
            {
                throw new ArgumentNullException(nameof(fileName));
            }

            viewer.Geo.FileSavePoint(fileName);
            return true;
        }

        /// <summary>
        /// 保存曲线
        /// </summary>
        /// <param name="fileName">文件路径名</param>
        /// <returns>成功/失败</returns>
        public bool FileSaveCurve(string fileName)
        {
            if (fileName == null)
            {
                throw new ArgumentNullException(nameof(fileName));
            }

            viewer.Geo.FileSaveCurve(fileName);
            return true;
        }

        public bool FileSaveSolid(string fileName)
        {
            if (fileName == null)
            {
                throw new ArgumentNullException(nameof(fileName));
            }

            viewer.Geo.FileSaveSolid(fileName);
            return true;
        }

        public bool FileSaveText(string fileName)
        {
            if (fileName == null)
            {
                throw new ArgumentNullException(nameof(fileName));
            }

            viewer.Geo.FileSaveText(fileName);
            return true;
        }

        public bool FileSaveCleanCurve(string fileName)
        {
            if (fileName == null)
            {
                throw new ArgumentNullException(nameof(fileName));
            }

            viewer.Geo.FileSaveCleanCurve(fileName);
            return true;
        }

        public bool FileSaveToXyz(string fileName)
        {
            if (fileName == null)
            {
                throw new ArgumentNullException(nameof(fileName));
            }

            viewer.Geo.FileSaveToXyz(fileName);
            return true;
        }

        public bool FileSaveToMark()
        {
            //viewer.Drawer.Cursor = CustomDrawCursors.Range;
            //if (ViewControl.Drawer.ActiveTool != DrawToolType.SaveAsSymbol)
            //{
            //    viewer.Drawer.ActiveTool = DrawToolType.SaveAsSymbol;
            //}
            //viewer.Geo.FileSaveToMark(string.Empty);
            return true;
        }

        public void ImportDataFile()
        {
            var import = new ImportFileDialog()
            {
                StartPosition = FormStartPosition.CenterScreen,
                GeoObj = this.viewer.Geo,
            };

            // 要考虑数据本身就有问题的情况，导入模块可能无法分析出所有情况，所以这个异常捕捉不要移除
            try
            {
                if (import.ShowDialog(this) == DialogResult.OK)
                {
                    this.LoadLayerTree();
                }
                viewer.Redraw();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        /// <summary>
        /// 导出文件
        /// </summary>
        public void ExportDataFile()
        {
            var exportFile = new ExporFilesDialog
            {
                Geo = this.viewer.Geo,
                StartPosition = FormStartPosition.CenterScreen,
            };
            if (exportFile.ShowDialog(this) == DialogResult.OK)
            {
                this.LoadLayerTree();
            }
        }

        public bool ReloadFile()
        {
            if (viewer.ReloadFile() == false)
            {
                return false;
            }

            ReloadFileEvent?.Invoke();

            LoadLayerTree();

            // FIXME: 重新加载之后，统计界面元素的 position 已经全部失效了，这里先把这个界面清空，后续有需要的话，再刷新一下上次的操作
            if (dgvStatics != null)
            {
                dgvStatics.DataSource = null;
            }

            return true;
        }

        public void ClearGeo()
        {
            viewer.ClearGeo();
        }

        public void SetBackColor(int r, int g, int b)
        {
            viewer.SetBackColor(r, g, b);
        }

        public void SetSymbolView(bool isSymbolView)
        {
            viewer.SetSymbolView(isSymbolView);
        }

        /// <summary>
        /// 保存文档
        /// </summary>
        /// <returns>成功、失败，如果在 cancelEvent 里面设置了取消，将不会保存文件，并返回成功</returns>
        public bool SaveFile()
        {
            if (BeforeSaveFileEvent != null)
            {
                var cancelEventArgs = new CancelEventArgs();
                BeforeSaveFileEvent.Invoke(cancelEventArgs);
                if (cancelEventArgs.Cancel)
                {
                    return true;
                }
            }
            if (viewer == null)
            {
                return false;
            }
            if (string.IsNullOrEmpty(FileFullName))
            {
                FileFullName = DocHelper.SaveDialog(this.Text);
                if (string.IsNullOrEmpty(FileFullName))
                {
                    return false;
                }
            }
            return viewer.SaveFile(FileFullName);
        }

        private double pdfLeftMargin = 0;
        private double pdfRightMargin = 0;
        private double pdfTopMargin = 0;
        private double pdfBottomMargin = 0;
        /// <summary>
        /// 另存为
        /// </summary>
        /// <returns>是否成功</returns>
        public bool SaveAs()
        {
            if (viewer == null)
            {
                return false;
            }
            string strFileName = DocHelper.SaveDialog(FileFullName);
            if (string.IsNullOrEmpty(strFileName))
            {
                return false;
            }
            FileFullName = strFileName;
            FileInfo fi = new FileInfo(FileFullName);

            bool bSuccess = false;
            string fileExtension = fi.Extension;
            if (fileExtension == ".pdf")
            {
                FrmPdfExport frmPafSetting = new FrmPdfExport(FileFullName);
                if (frmPafSetting.ShowDialog(this) != DialogResult.OK)
                {
                    return false;
                }
                FileFullName = frmPafSetting.FilePath;
                int pdfPaperType = frmPafSetting.PaperType;
                pdfLeftMargin = frmPafSetting.LeftMargin;
                pdfRightMargin = frmPafSetting.RightMargin;
                pdfTopMargin = frmPafSetting.TopMargin;
                pdfBottomMargin = frmPafSetting.BottomMargin;
                int pdfRgpAHIndex = frmPafSetting.RgpAHIndex;
                int pdfRgpPaperIndex = frmPafSetting.RgpPaperIndex;

                bSuccess = viewer.SaveFile(FileFullName, pdfLeftMargin, pdfRightMargin,
                    pdfTopMargin, pdfBottomMargin, pdfPaperType, pdfRgpAHIndex, pdfRgpPaperIndex);

                if (bSuccess)
                {
                    this.Text = fi.Name;
                    this.isNewDocument = false;
                }
                return bSuccess;
            }

            bSuccess = viewer.SaveFile(FileFullName);
            if (bSuccess)
            {
                this.Text = fi.Name;
                this.isNewDocument = false;
            }
            return bSuccess;
        }

        /// <summary>
        /// 另存到新文件
        /// </summary>
        /// <param name="newFile">文件名</param>
        /// <returns>是否成功</returns>
        public bool SaveTo(string newFile)
        {
            if (viewer == null)
            {
                return false;
            }
            FileInfo fi = new FileInfo(newFile);
            bool bSuccess = viewer.SaveFile(newFile);
            if (bSuccess)
            {
                this.Text = fi.Name;
                this.isNewDocument = false;
            }
            return bSuccess;
        }

        public bool NewFile(string fileName, GeoSigmaXY.eViewType vType = GeoSigmaXY.eViewType.plane)
        {
            if (viewer == null)
            {
                return false;
            }
            FileFullName = fileName;
            //viewer.
            viewer.NewFile(fileName, vType);
            this.Text = fileName;
            LoadLayerTree();
            this.isNewDocument = true;
            tspElement.Enabled = true;
            return true;
        }

        /// <summary>
        /// 打开文件
        /// </summary>
        /// <param name="filePath">文件全路径</param>
        /// <param name="setZColor">是否以色块显示点数据</param>
        /// <returns>是否成功</returns>
        public bool OpenFile(string filePath, bool setZColor = false, GeoSigmaXY.eViewType vType = GeoSigmaXY.eViewType.plane)
        {
            // viewer.EnableMeshPack = this.EnableMeshPack;
            if (viewer.OpenFile(filePath, vType) == false)
            {
                return false;
            }
            if (setZColor)
            {
                this.SetZColorDefault(this.ZColorWidth);
            }
            this.isNewDocument = false;
            FileFullName = filePath;
            this.Text = Path.GetFileName(filePath);
            string extention = Path.GetExtension(filePath);
            extention = extention.ToUpper();
            if (extention == ".JPG" || extention == ".BMP" || extention == ".PNG")
            {
                this.isNewDocument = true;
                string directory = Path.GetDirectoryName(filePath);
                string fileName = Path.GetFileNameWithoutExtension(filePath);
                string newExtension = "kev";
                FileFullName = Path.Combine(directory, $"{fileName}.{newExtension}");
            }
            LoadLayerTree();
            tspElement.Enabled = true;
            return true;
        }

        /// <summary>
        /// 删除文件
        /// </summary>
        /// <param name="fileFullPath">文件全路径</param>
        /// <returns>是否成功</returns>
        public bool DeleteFile(string fileFullPath)
        {
            try
            {
                if (File.Exists(fileFullPath))
                {
                    File.Delete(fileFullPath);
                }
                else
                {
                    return false;
                }
            }
            catch (Exception e)
            {
                return false;
            }
            return true;
        }

        /// <summary>
        /// 导出到图片
        /// </summary>
        /// <param name="fileFullPath">文件全路径</param>
        /// <returns>是否成功</returns>
        public bool Export2Image(string fileFullPath)
        {
            return viewer.Export2Image(fileFullPath);
        }

        private void BindEvent()
        {
            //layerTree.LayerActiveEvent += layerTree_LayerSelect;
            //layerTree.StatiscElementLoadEvent += LoadElementData;
            //layerTree.StatiscTrapsLoadEvent += LoadTrapsData;
            //layerTree.StatiscFaultLoadEvent += LoadFaultDataNew;
            //layerTree.StatiscSurveyLoadEvent += LoadSurveyData;
            //layerTree.StatiscLayerLoadEvent += LoadLayerData;
            //layerTree.StatiscWellsLoadEvent += LoadWellsData;
            //layerTree.StatiscVolumnLoadEvent += LoadVolumnData;
            //layerTree.StatiscResourceAnalysisEvent += LoadResourcComment;
            //layerTree.StatiscRangeEvent += LoadRangeRation;
            //layerTree.StatiscCurveCrossPointEvent += StatiscCurveCrossPoints;
            //layerTree.StatiscWellInclinationPointEvent += LoadWellInclination;

            //layerTree.StatiscBlockElementsEvent += StatiscBlockElements;
            //layerTree.StatiscAzimuthElementsEvent += StatiscAzimuthElements;

            //layerTree.BeginStatisticsEvent += LayerTree_BeginStatisticsEvent;
            //layerTree.EndStatisticsEvent += LayerTree_EndStatisticsEvent;

            //layerTree.DrawerGotFocus += (sender, ea) =>
            //{
            //    DrawerGotFocus?.Invoke(sender, ea);
            //};

            viewer.ENCurveLoadHandler += LoadElementData;

            viewer.DrawerGotFocus += (obj, ea) =>
            {
                DrawerGotFocus?.Invoke(obj, ea);
            };
            if (this.viewer.ViewerCommandStart == null)
            {
                this.viewer.ViewerCommandStart += OnCommandStart;
            }
            if (this.viewer.ViewerCommandFinish == null)
            {
                this.viewer.ViewerCommandFinish += OnCommandFinish;
            }
            this.viewer.MouseMoveEvent += ShowMouseInfo;
            if (this.viewer.SelectedElementChanged == null)
            {
                this.viewer.SelectedElementChanged += viewer_SelectedElementChanged;
            }

            if (this.viewer.Drawer.SelectedWell == null)
            {
                this.viewer.Drawer.SelectedWell += viewer_SelectedWell;
            }

            this.viewer.ChangeLayerEvent += OnChangeLayer;
            this.viewer.GetLengthAngleEvent += GetLengthAngle;
            Application.Idle += Application_Idle;
        }

        private WellTrackAccessor trackAccessor;  //井道属性界面与数据的关联器

        private void viewer_SelectedWell(object sender, EventArgs e) //选中井或剖面的事件函数
        {
            GeoSigmaWellPoleXY wellGeo = (GeoSigmaWellPoleXY)this.viewer.Geo;
            try
            {
                trackAccessor = new WellTrackAccessor(wellGeo);
                trackAccessor.bOpenWorkArea = PcgDrawR.FormMain.s_bOpenWorkArea;

                object obj = trackAccessor.LoadWellTrack(this.viewer.mViewType);
                PropertyWellControl.SelectedObject = obj;
                PropertyWellControl.ExpandPropertyGridValueColumn();
                PropertyWellControl.Visible = true;
            }
            catch (Exception ex)
            {

            }
        }

        private void PnlWellProperty_ElementChanged(object sender, EventArgs e)
        {
            if (trackAccessor != null)
            {
                trackAccessor.SaveWellTrack(pnlWellProperty.SelectedObject, this.viewer.mViewType);

                if (pnlWellProperty.SelectedObject is SigmaDrawerElement.WellPole)
                {//井柱发生变化，如果深度发生变化，需要更改VScroll
                    this.ViewControl.ViewExtendWidth();
                }

                viewer.Drawer.EnableRedraw = true;
                viewer.Drawer.ReDraw();
            }
        }

        private void LayerTree_EndStatisticsEvent(string title)
        {
            WaitProgressEvent?.Invoke(this, new ProgressEventArgs(title, 0, false));
        }

        private void LayerTree_BeginStatisticsEvent(string title)
        {
            WaitProgressEvent?.Invoke(this, new ProgressEventArgs(title, 0, true));
        }

        private object ConvertToType(string value, Type targetType)
        {
            if (string.IsNullOrWhiteSpace(value))
            {
                return DBNull.Value;
            }

            try
            {
                if (targetType == typeof(int))
                {
                    return int.Parse(value);
                }
                if (targetType == typeof(double))
                {
                    return double.Parse(value);
                }
                if (targetType == typeof(long))
                {
                    return long.Parse(value);
                }
                if (targetType == typeof(string))
                {
                    return value;
                }

                throw new InvalidCastException($"不支持的目标类型: {targetType}");
            }
            catch (Exception ex)
            {
                throw new FormatException($"无法将值 '{value}' 转换为类型 {targetType}: {ex.Message}");
            }
        }

        private void StatiscCurveCrossPoints(string xml)
        {

        }
        private void LoadWellInclination(string xml)
        {
            if (string.IsNullOrEmpty(xml))
            {
                dgvStatics.DataSource = null;
                ShowStatisticResult?.Invoke(this, new DataControlArgs("井点倾角统计"));
                return;
            }

            // 创建表
            DataTable dtStatistic = new DataTable("ROOT");
            dtStatistic.Columns.AddRange(new DataColumn[]
            {
                    new DataColumn("序号", Type.GetType("System.Int32")),
                    new DataColumn("井名", Type.GetType("System.String")),
                    new DataColumn("倾角", Type.GetType("System.Double")),
                    new DataColumn("井点X", Type.GetType("System.Double")),
                    new DataColumn("井点Y", Type.GetType("System.Double")),
                    new DataColumn("井点Z", Type.GetType("System.Double")),
                    new DataColumn("目标X", Type.GetType("System.Double")),
                    new DataColumn("目标Y", Type.GetType("System.Double")),
                    new DataColumn("目标Z", Type.GetType("System.Double")),
                    new DataColumn("Position", Type.GetType("System.String")),
            });

            try
            {
                XmlDocument doc = new XmlDocument();
                doc.LoadXml(xml);
                foreach (XmlNode currNode in doc.DocumentElement.ChildNodes)
                {
                    DataRow newRow = dtStatistic.NewRow();
                    foreach (XmlNode childNode in currNode.ChildNodes)
                    {
                        string columnName = childNode.Name;
                        string cellValue = childNode.InnerText;

                        if (dtStatistic.Columns.Contains(columnName))
                        {
                            DataColumn column = dtStatistic.Columns[columnName];
                            newRow[columnName] = ConvertToType(cellValue, column.DataType);
                        }
                    }

                    dtStatistic.Rows.Add(newRow);
                }
                dgvStatics.DataSource = dtStatistic;
                ShowStatisticResult?.Invoke(this, new DataControlArgs("井点倾角统计"));
            }
            catch (Exception ex)
            {
                MessageBox.Show($"加载统计数据失败: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
        public bool OpenXy(IntPtr pXy)
        {
            if (pXy == IntPtr.Zero)
            {
                return false;
            }
            //viewer.EnableMeshPack = this.EnableMeshPack;
            if (viewer.OpenXy(pXy) == false)
            {
                return false;
            }

            viewer.Drawer.Geo.AutoReleaseView = AutoReleaseView;

            FileFullName = string.Empty;

            LoadLayerTree();
            this.isNewDocument = false;
            return true;
        }

        /// <summary>
        /// 设置标题
        /// </summary>
        /// <param name="filePath">文件全路径或文件名</param>
        private void SetTitle(string filePath)
        {
            this.Text = Path.GetFileName(filePath);
        }

        /// <summary>
        /// 查找并激活图元
        /// </summary>
        /// <param name="elementName">图元名称</param>
        /// <returns>查找结果</returns>
        public int ActiveElementByName(string elementName)
        {
            if (elementName == null)
            {
                throw new ArgumentNullException(nameof(elementName));
            }

            int nReturn = viewer.Geo.ActiveElementByName(elementName);
            this.ToolRedraw();
            return nReturn;
        }

        /// <summary>
        /// 激活图元
        /// </summary>
        /// <param name="elementName">图元名称</param>
        /// <param name="x">x</param>
        /// <param name="y">y</param>
        /// <param name="layerName">图层名称</param>
        public void ActiveElement(string elementName, double x, double y, string layerName)
        {
            if (elementName == null)
            {
                throw new ArgumentNullException(nameof(elementName));
            }

            if (layerName == null)
            {
                throw new ArgumentNullException(nameof(layerName));
            }

            //int nReturn = viewer.Geo.ActiveElementByName(elementName);
            long pos = viewer.Geo.FindPointByInfo(elementName, x, y, layerName);
            if (pos > 0)
            {
                this.ActiveElement(pos);
                this.ToolRedraw();
            }
            return;
        }

        /// <summary>
        /// 点类数据修改.
        /// </summary>
        /// <param name="elementName">Name of the element.</param>
        /// <param name="x">The x.</param>
        /// <param name="y">The y.</param>
        /// <param name="layerName">Name of the layer.</param>
        /// <param name="newName">The new name.</param>
        /// <param name="newX">The new x.</param>
        /// <param name="newY">The new y.</param>
        /// <returns></returns>
        public bool ReplacePoint(string elementName, double x, double y, string layerName
                                 , string newName, double newX, double newY)
        {
            long pos = viewer.Geo.FindPointByInfo(elementName, x, y, layerName);
            string strElementData = viewer.Geo.GetElementByPosition(pos);
            //DrawerElementHelp elementHelp = new DrawerElementHelp();
            DrawerElementProperty property = DrawerElementHelp.Deserialize(strElementData);
            if (property == null)
            {
                return false;
            }
            else if (property.ElementType == DrawElementType.ELEMENT_POINT)
            {
                DrawerPoint dp = property.Element as DrawerPoint;
                if (dp != null)
                {
                    dp.Name = newName;
                    dp.X = newX;
                    dp.Y = newY;
                    string strData = DrawerElementHelp.Serialize(property);
                    if (viewer.Geo.SelectSetElement(strData, pos))
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        private void btnTest_Click(object sender, EventArgs e)
        {
            ActiveElementByName("Point");
        }

        #endregion 文件操作

        public bool IsDocumentModified()
        {
            if (viewer == null || viewer.Geo == null)
            {
                return false;
            }

            return viewer.GetGeoSigma().Sigma_IsDocumentModified();
        }

        public void SetDocumentModified(bool isModified)
        {
            if (viewer == null || viewer.Geo == null)
            {
                return;
            }
            viewer.GetGeoSigma().Sigma_SetDocumentModified(isModified);
        }

        public void PrintDraw()
        {
            FormPrintPreview frmPrint = new FormPrintPreview(viewer.GetGeoSigma())
            {
                StartPosition = FormStartPosition.CenterScreen,
            };
            frmPrint.ShowDialog(this);
            viewer.Redraw();
        }

        /// <summary>
        /// 处理Esc按键事件.
        /// </summary>
        public void Escape()
        {
            if (viewer == null)
            {
                return;
            }

            viewer.ActiveTool = DrawToolType.Finsih;
            viewer.Redraw();
        }

        /// <summary>
        /// 清理图层树
        /// </summary>
        public void ClearLayerTree()
        {
            //if (layerTree != null)
            //{
            //    layerTree.ResetLayers(string.Empty);
            //}
        }

        /// <summary>
        /// 增加树控件
        /// </summary>
        public void LoadLayerTree()
        {
            //if (viewer == null)
            //{
            //    layerTree.ResetLayers(string.Empty);
            //    return;
            //}
            //string strLayers = viewer.GetLayers(true);

            //CurrentLayer = viewer.GetCurrentLayer();

            //layerTree.DrawViewer = this.viewer;
            //layerTree.ResetLayers(strLayers);
            //layerTree.SetCurrentLayer(CurrentLayer);
            // CurrentLayer = CurrentLayer;

            // this.navigatorLeft.Pages[0].Text = "当前图层-" + CurrentLayer;
        }

        public void ReActiveCurrentLayer()
        {
            if (viewer != null)
            {
                //CurrentLayer = viewer.GetCurrentLayer();
                //layerTree.SetCurrentLayer(CurrentLayer);
            }
        }

        public void OnChangeLayer(string eventKind)
        {
            if (eventKind == "update layer")
            {
                LoadLayerTree();
            }
            else if (eventKind == "change current layer")
            {
                // LoadLayerTree();
                string layerName = viewer.Geo.GetCurrentLayer();
                //layerTree.SetCurrentLayer(layerName);
            }
            else if (eventKind == "change element layer")
            {
            }
        }

        /// <summary>
        /// 设置图层的曲线样式
        /// </summary>
        /// <param name="curveStyle">样式</param>
        /// <param name="layerName">图层名称</param>
        /// <param name="propertyIndex">样式的索引号</param>
        public void SetLayerStyle(CurveView curveStyle, string layerName, int propertyIndex)
        {
            if (curveStyle == null)
            {
                throw new ArgumentNullException(nameof(curveStyle));
            }

            if (layerName == null)
            {
                throw new ArgumentNullException(nameof(layerName));
            }

            if (propertyIndex < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(propertyIndex));
            }

            //string strCurveStyle = ((CurveView)curveStyle).SerialXml();
            //strCurveStyle = strCurveStyle.Replace("true", "1");
            //strCurveStyle = strCurveStyle.Replace("false", "0");
            viewer.SetLayerStyle(curveStyle, layerName, propertyIndex);
        }

        /// <summary>
        /// 重命名图元
        /// </summary>
        /// <param name="oldName">旧名称</param>
        /// <param name="newName">新名称</param>
        /// <param name="layerName">图层</param>
        /// <returns>替换的数量</returns>
        public int RenameElement(string oldName, string newName, string layerName)
        {
            if (oldName == null)
            {
                throw new ArgumentNullException(nameof(oldName));
            }

            if (newName == null)
            {
                throw new ArgumentNullException(nameof(newName));
            }

            if (layerName == null)
            {
                throw new ArgumentNullException(nameof(layerName));
            }

            int nCount = viewer.RenameElement(oldName, newName, layerName);
            return nCount;
        }

        ///// <summary>
        ///// 重新设置线样式
        ///// </summary>
        ///// <param name="curveName">名称</param>
        ///// <param name="layerName">图层</param>
        ///// <param name="curveStyle">样式</param>
        ///// <returns>应用数量</returns>
        //public int ResetCurveStyle(string curveName, string layerName, CurveView curveStyle)
        //{
        //    int nCount = viewer.ResetCurveStyle(curveName, layerName, curveStyle);

        //    return nCount;
        //}
        ///// <summary>
        ///// 获取图层的样式
        ///// </summary>
        ///// <param name="layerName">图层名称</param>
        ///// <returns>图层样式</returns>
        //public DrawerStyle GetLayerLayerStyle(string layerName)
        //{
        //    string strCurveData = string.Empty;
        //    string strPointData = string.Empty;
        //    viewer.GetLayerStyleData(layerName, ref strCurveData, ref strPointData);

        //    DrawerStyle drawerStyle = new DrawerStyle();
        //    if (strCurveData != string.Empty)
        //    {
        //        drawerStyle.DeserializeCurve(strCurveData);
        //    }
        //    if (strPointData != string.Empty)
        //    {
        //        drawerStyle.DeserializePoint(strPointData);
        //    }
        //    return drawerStyle;
        //}

        private void layerTree_LayerSelect(string layerName)
        {
            // DrawerGotFocus?.Invoke(layerName, EventArgs.Empty);
            string strCurveData = string.Empty;
            string strPointData = string.Empty;
            viewer.GetLayerStyleData(layerName, ref strCurveData, ref strPointData);
            string strLayerText = layerName.Replace("Layer:\\", string.Empty);
            // this.navigatorLeft.Pages[0].Text = layerName.Replace("Layer:\\", string.Empty);
            // 当前层位设置事件
            LayerSelected?.Invoke(this, new PropertyChangedEventArgs(strLayerText));
            DrawerStyle drawerStyle = new DrawerStyle();
            if (strCurveData != string.Empty)
            {
                drawerStyle.DeserializeCurve(strCurveData);
                for (int i = 0; i < drawerStyle.CurveStyle.Properties.Count; i++)
                {
                    drawerStyle.CurveStyle.Properties[i].Geo = this.viewer.GetGeoSigma();
                }
            }
            if (strPointData != string.Empty)
            {
                drawerStyle.DeserializePoint(strPointData);
                drawerStyle.PontStyle.Geo = this.viewer.GetGeoSigma();
            }
        }

        private void UpdateDrawerElementPropertyGeo(DrawerElementProperty property)
        {
            if (property.PointStyle != null)
            {
                property.PointStyle.Geo = viewer.Geo;
            }

            if (property.CurveStyle != null)
            {
                foreach (var curveView in property.CurveStyle.Properties)
                {
                    curveView.Geo = viewer.Geo;
                }
            }
        }

        /// <summary>
        /// 设置图元属性（通用图元）
        /// </summary>
        /// <param name="sender">事件按钮</param>
        /// <param name="e">事件参数</param>
        private void viewer_SelectedElementChanged(object sender, ElementArgs e)
        {
            if (e == null)
            {
                return;
            }

            DrawerElementProperty property = e.Data;

            UpdateDrawerElementPropertyGeo(property);

            pnlProperty.ShowElementProperty(property, e.Position);
            // string strLayerName = string.Empty;
            if (this.viewer.SelectGetLayerName(out string strLayerName))
            {
                //this.layerTree.SelectLayer(strLayerName);
            }
        }

        #region 工具栏操作

        public void GridGeneraterContour()
        {
            viewer.GridGenerateContour();
        }

        /// <summary>
        /// 当前绘图状态
        /// </summary>
        public DrawToolType ActiveTool
        {
            get
            {
                return viewer.ActiveTool;
            }
        }

        public ViewOperationKind ViewStatus
        {
            get
            {
                return this.viewer.GetViewOperationKind();
            }
        }

        public void ToolGridSmooth()
        {
            viewer.GridSmooth();
        }

        /// <summary>
        /// 放大
        /// </summary>
        /// <param name="sender">sender</param>
        /// <param name="e">e</param>
        private void btnZoomIn_Click(object sender, EventArgs e)
        {
            viewer.ZoomIn();
        }

        public void ToolZoomIn()
        {
            viewer.ZoomIn();
        }

        /// <summary>
        /// 缩小
        /// </summary>
        /// <param name="sender">sender</param>
        /// <param name="e">e</param>
        private void btnZoomOut_Click(object sender, EventArgs e)
        {
            viewer.ZoomOut();
        }

        public void ToolZoomOut()
        {
            viewer.ZoomOut();
        }

        private void tsbPan_Click(object sender, EventArgs e)
        {
            tsbPan.Checked = !tsbPan.Checked;
            if (tsbPan.Checked == true)
            {
                viewer.SetViewOperationKind(ViewOperationKind.ViewPan);
            }
            else
            {
                viewer.SetViewOperationKind(ViewOperationKind.Invalid);
            }
            tsbViewWindow.Checked = false; //去掉窗口缩放按钮的选中图标
        }

        /// <summary>
        /// 设置浏览方式，窗口方式、拖动方式、取消浏览
        /// </summary>
        /// <param name="operationKind">浏览方式</param>
        public void SetViewOperation(ViewOperationKind operationKind)
        {
            viewer.SetViewOperationKind(operationKind);
        }

        private void tsbViewWindow_Click(object sender, EventArgs e)
        {
            tsbViewWindow.Checked = !tsbViewWindow.Checked;
            if (tsbViewWindow.Checked == true)
            {
                viewer.SetViewOperationKind(ViewOperationKind.ViewWindow);
            }
            else
            {
                viewer.SetViewOperationKind(ViewOperationKind.Invalid);
            }
            this.tsbPan.Checked = false; //去掉平移按钮的选中状态
        }

        private void tsbViewAll_Click(object sender, EventArgs e)
        {
            ToolViewAll();
        }

        /// <summary>
        /// 全图显示
        /// </summary>
        public void ToolViewAll()
        {
            viewer.ViewAll();
        }

        /// <summary>
        /// 扩展矩形范围大小到全屏
        /// </summary>
        /// <param name="rect">范围</param>
        public void Extend(RectangleF rect)
        {
            viewer.Extend(rect);
        }

        public void InitlizePaint(RectangleF rect)
        {
            viewer.InitlizePaint(rect);
        }

        /// <summary>
        /// 重绘
        /// </summary>
        /// <param name="sender">sender</param>
        /// <param name="e">e</param>
        private void tsbRedraw_Click(object sender, EventArgs e)
        {
            ToolRedraw();
        }

        public void ToolRedraw()
        {
            viewer.Redraw();
        }

        private void tsbToolDefault_Click(object sender, EventArgs e)
        {
            ToolDefault();
        }

        public void ToolRestore()
        {
            viewer.ToolRestore();
        }

        public void RestoreToolDefault()
        {
            viewer.RestoreToolDefault();
        }

        /// <summary>
        /// 默认状态
        /// </summary>
        public void ToolDefault()
        {
            viewer.ActiveTool = DrawToolType.Default;
        }

        private void tsbSelect_Click(object sender, EventArgs e)
        {
            if (ToolSelect())
            {
                //CancelSelectedStatusOfButton(tsbSelect);
            }
        }

        /// <summary>
        /// 选择工具
        /// </summary>
        /// <returns>成功/失败</returns>
        public bool ToolSelect()
        {
            if (viewer.ActiveTool == DrawToolType.Select)
            {
                tsbSelect.Checked = true;
                return false;
            }
            viewer.ActiveTool = DrawToolType.Select;
            return true;
        }

        public bool ToolWellGroupEdit()
        {
            if (viewer.ActiveTool == DrawToolType.WellGroupEdit)
            {
                //tsbSelect.Checked = true;
                return false;
            }
            viewer.ActiveTool = DrawToolType.WellGroupEdit;
            return true;
        }

        //public bool ToolWellBranchCurve()
        //{
        //    if (viewer.ActiveTool == DrawToolType.EditWellGroupBranchCurveNode)
        //    {
        //        //tsbSelect.Checked = true;
        //        return false;
        //    }
        //    viewer.ActiveTool = DrawToolType.EditWellGroupBranchCurveNode;
        //    return true;
        //}
        private void tsbPointAdd_Click(object sender, EventArgs e)
        {
            ToolAddPoint();
            //CancelSelectedStatusOfButton(null);
            /*
            List<Point2D> pts = new List<Point2D>();

            Point2D pt1 = new Point2D();
            pt1.pointName = "pt1";
            pt1.x = 100;
            pt1.y = 200;

            Point2D pt2 = new Point2D();
            pt2.pointName = "pt1";
            pt2.x = 200;
            pt2.y = 300;

            pts.Add(pt1);
            pts.Add(pt2);

            viewer.Drawer.AddPoints("图层0", pts);
            */
        }

        private void crossPointButton_Click(object sender, EventArgs e)
        {
            ToolAddCrossPoint();
        }

        /// <summary>
        /// 加点工具
        /// </summary>
        public void ToolAddPoint()
        {
            viewer.ActiveTool = DrawToolType.Point;
        }

        /// <summary>
        /// 绘制十字点
        /// </summary>
        public void ToolAddCrossPoint()
        {
            viewer.ActiveTool = DrawToolType.CrossPoint;
        }

        private void tsbCurveAdd_Click(object sender, EventArgs e)
        {
            ToolAddCurve();
        }

        /// <summary>
        /// 画线工具
        /// </summary>
        public void ToolAddCurve()
        {
            viewer.ActiveTool = DrawToolType.Curve;
        }

        private void tsbProportionAdd_Click(object sender, EventArgs e)
        {
            ToolAddProportion();
        }

        /// <summary>
        /// 画比例尺
        /// </summary>
        public void ToolAddProportion()
        {
            viewer.ActiveTool = DrawToolType.Proportion;
        }

        private void rectangularCSGridButton_Click(object sender, EventArgs e)
        {
            ToolCSGrid();
        }

        /// <summary>
        /// 坐标网工具
        /// </summary>
        public void ToolCSGrid()
        {
            viewer.ActiveTool = DrawToolType.RectangularCSGrid;
        }

        private void drawRectangleButton_Click(object sender, EventArgs e)
        {
            ToolRectangle();
        }

        /// <summary>
        /// 矩形绘制工具
        /// </summary>
        public void ToolRectangle()
        {
            viewer.ActiveTool = DrawToolType.Rectangle;
        }

        private void sbtnEllipse_ButtonClick(object sender, EventArgs e)
        {
            ToolStripMenuItem item = sbtnEllipse.Tag as ToolStripMenuItem;
            item.PerformClick();
        }

        private void drawEllipseButton_Click(object sender, EventArgs e)
        {
            sbtnEllipse.Tag = sender;
            ToolEllipse();
            sbtnEllipse.Image = ((ToolStripMenuItem)sender).Image;
            sbtnEllipse.ToolTipText = ((ToolStripMenuItem)sender).ToolTipText;
        }

        /// <summary>
        /// 椭圆工具
        /// </summary>
        public void ToolEllipse()
        {
            viewer.ActiveTool = DrawToolType.Ellipse;
        }

        private void drawArcButton_Click(object sender, EventArgs e)
        {
            sbtnEllipse.Tag = sender;
            ToolAcr();
            sbtnEllipse.Image = ((ToolStripMenuItem)sender).Image;
            sbtnEllipse.ToolTipText = ((ToolStripMenuItem)sender).ToolTipText;
        }

        /// <summary>
        /// 弧工具
        /// </summary>
        public void ToolAcr()
        {
            viewer.ActiveTool = DrawToolType.Arc;
        }

        private void drawChordButton_Click(object sender, EventArgs e)
        {
            sbtnEllipse.Tag = sender;
            ToolChord();
            sbtnEllipse.Image = ((ToolStripMenuItem)sender).Image;
            sbtnEllipse.ToolTipText = ((ToolStripMenuItem)sender).ToolTipText;
        }

        /// <summary>
        /// 玄工具
        /// </summary>
        public void ToolChord()
        {
            viewer.ActiveTool = DrawToolType.Chord;
        }

        private void drawPieButton_Click(object sender, EventArgs e)
        {
            sbtnEllipse.Tag = sender;
            ToolPie();
            sbtnEllipse.Image = ((ToolStripMenuItem)sender).Image;
            sbtnEllipse.ToolTipText = ((ToolStripMenuItem)sender).ToolTipText;
        }

        /// <summary>
        /// 饼状工具
        /// </summary>
        public void ToolPie()
        {
            viewer.ActiveTool = DrawToolType.Pie;
        }

        private void drawEquilateralButton_Click(object sender, EventArgs e)
        {
            sbtnEllipse.Tag = sender;
            ToolEquilateral();
            sbtnEllipse.Image = ((ToolStripMenuItem)sender).Image;
            sbtnEllipse.ToolTipText = ((ToolStripMenuItem)sender).ToolTipText;
        }

        /// <summary>
        /// 等边多边形工具
        /// </summary>
        public void ToolEquilateral()
        {
            viewer.ActiveTool = DrawToolType.Equilateral;
        }

        private void drawTextButton_Click(object sender, EventArgs e)
        {
            ToolText();
        }

        /// <summary>
        /// 文本绘制工具
        /// </summary>
        public void ToolText()
        {
            if (viewer.ActiveTool == DrawToolType.Text)
            {
                viewer.ActiveTool = DrawToolType.Finsih;
            }
            else
            {
                viewer.ActiveTool = DrawToolType.Text;
            }
        }

        private void breakDirectButton_Click(object sender, EventArgs e)
        {
            ToolBreakDirect();
        }

        /// <summary>
        /// 直接打断
        /// </summary>
        public void ToolBreakDirect()
        {
            viewer.ActiveTool = DrawToolType.BreakDirect;
        }

        private void breakCurveButton_Click(object sender, EventArgs e)
        {
            ToolBreakCurve();
        }

        /// <summary>
        /// 曲线打断
        /// </summary>
        public void ToolBreakCurve()
        {
            viewer.ActiveTool = DrawToolType.Break;
        }

        private void deleteNormalButton_Click(object sender, EventArgs e)
        {
            ToolDeleteNormal();
        }

        public void ToolDeleteNormal()
        {
            viewer.ActiveTool = DrawToolType.Delete;
        }

        private void deleteInButton_Click(object sender, EventArgs e)
        {
            ToolDeleteIn();
        }

        /// <summary>
        /// 区域内删除
        /// </summary>
        public void ToolDeleteIn()
        {
            viewer.ActiveTool = DrawToolType.DeleteIn;
        }

        private void deleteOutButton_Click(object sender, EventArgs e)
        {
            ToolDeleteOut();
        }

        /// <summary>
        /// 区域外删除
        /// </summary>
        public void ToolDeleteOut()
        {
            viewer.ActiveTool = DrawToolType.DeleteOut;
        }

        private void extendCurveButton_Click(object sender, EventArgs e)
        {
            //ToolExtendCurve();
        }

        private void extendCurveTSSButton_Click(object sender, EventArgs e)
        {
            ToolExtendCurve();
        }

        /// <summary>
        /// 延伸曲线
        /// </summary>
        public void ToolExtendCurve()
        {
            viewer.ActiveTool = DrawToolType.ExtendCurve;
        }

        private void trimCurveButton_Click(object sender, EventArgs e)
        {
            ToolTrimCurve();
        }

        /// <summary>
        /// 曲线裁剪
        /// </summary>
        public void ToolTrimCurve()
        {
            viewer.ActiveTool = DrawToolType.TrimCurve;
        }

        private void closeCurveButton_Click(object sender, EventArgs e)
        {
            ToolCloseCurve();
        }

        /// <summary>
        /// 曲线闭合
        /// </summary>
        public void ToolCloseCurve()
        {
            viewer.ActiveTool = DrawToolType.CloseCurve;
        }

        private void moveCurveNameButton_Click(object sender, EventArgs e)
        {
            ToolMoveCurveName();
        }

        /// <summary>
        /// 移动曲线名字
        /// </summary>
        public void ToolMoveCurveName()
        {
            viewer.ActiveTool = DrawToolType.MoveCurveName;
        }

        private void linkCurveButton_Click(object sender, EventArgs e)
        {
            ToolJoinCurve();
        }

        /// <summary>
        /// 连接曲线
        /// </summary>
        public void ToolJoinCurve()
        {
            viewer.ActiveTool = DrawToolType.LinkCurve;
        }

        public void ToolMergeCurve()
        {
            var dialog = new MergeCurveDialog();
            if (dialog.ShowDialog() != DialogResult.OK)
            {
                return;
            }

            viewer.ActiveTool = DrawToolType.MergeCurve;
            viewer.Geo.SetLinkCurveMergeMode(dialog.Settings.MergeTypeNum, dialog.Settings.DeleteOld);
        }
        public void ToolAutoJoinCurves()
        {
            int nResult = viewer.AutoJoinCurves();
            if (nResult > 0)
            {
                viewer.Redraw();
            }
        }

        private void reverseCurveButton_Click(object sender, EventArgs e)
        {
            ToolReverseCurve();
        }

        /// <summary>
        /// 反转曲线工具
        /// </summary>
        public void ToolReverseCurve()
        {
            viewer.ActiveTool = DrawToolType.ReverseCurve;
        }

        private void nameToZButton_Click(object sender, EventArgs e)
        {
            ToolName2Z();
        }

        /// <summary>
        /// 名字转Z值
        /// </summary>
        public void ToolName2Z()
        {
            viewer.ActiveTool = DrawToolType.NameToZ;
        }

        #endregion 工具栏操作

        private void copybtn_Click(object sender, EventArgs e)
        {
            ToolCopy();
        }

        public void ToolCopy()
        {
            viewer.Copy();
        }

        private void pastebtn_Click(object sender, EventArgs e)
        {
            ToolPaste();
        }

        public void ToolPaste()
        {
            viewer.Paste();
        }

        private void cutbtn_Click(object sender, EventArgs e)
        {
            ToolCut();
        }

        public void ToolCut()
        {
            viewer.CutX();
        }

        //private void viewer_DrawerGotFocus(object sender, EventArgs e)
        //{
        //    if (DrawerGotFocus != null)
        //    {
        //        DrawerGotFocus(sender, e);
        //    }
        //}

        private void rangeToImageButton_Click(object sender, EventArgs e)
        {
            ToolImageCutRange();
        }

        public void ToolImageCutRange()
        {
            viewer.ActiveTool = DrawToolType.RangeToImage;
        }

        public void ToolImageCutRangeEx()
        {
            viewer.ActiveTool = DrawToolType.RangeToImageEx;
        }

        /// <summary>
        /// 多边形截图（任意边界截图）
        /// </summary>
        public void ToolImageCutPolygon()
        {
            long pos = viewer.Geo.SelectGetPolygon();
            if (pos <= 0)
            {
                MessageBox.Show("先选中一个多边形！");
                return;
            }

            viewer.ActiveTool = DrawToolType.PolygonToImage;
        }
        private void copyAllToImageButton_Click(object sender, EventArgs e)
        {
            ToolImageCutAll();
        }

        public void ToolImageCutAll()
        {
            viewer?.ImageCutAll();
        }
        private void copyWindowButton_Click(object sender, EventArgs e)
        {
            ToolImageCutWindow();
        }

        public void ToolImageCutWindow()
        {
            viewer.ImageCutWindow();
        }

        private void leftAlignButton_Click(object sender, EventArgs e)
        {
            ToolAlignLeft();
        }

        public void ToolAlignLeft()
        {
            viewer.ActiveTool = DrawToolType.LeftAlignment;
        }

        private void rightAlignButton_Click(object sender, EventArgs e)
        {
            ToolAlignRight();
        }

        public void ToolAlignRight()
        {
            viewer.ActiveTool = DrawToolType.RightAlignment;
        }

        private void topAlignButton_Click(object sender, EventArgs e)
        {
            ToolAlignTop();
        }

        public void ToolAlignTop()
        {
            viewer.ActiveTool = DrawToolType.TopAlignment;
        }

        private void bottomAlignButton_Click(object sender, EventArgs e)
        {
            ToolAlignBottom();
        }

        public void ToolAlignBottom()
        {
            viewer.ActiveTool = DrawToolType.BottomAlignment;
        }

        private void hCenterAlignButton_Click(object sender, EventArgs e)
        {
            ToolAlignCenterH();
        }

        public void ToolAlignCenterH()
        {
            viewer.ActiveTool = DrawToolType.HCenterAlignment;
        }

        private void vCenterAlignButton_Click(object sender, EventArgs e)
        {
            ToolAlignCenterV();
        }

        public void ToolAlignCenterV()
        {
            viewer.ActiveTool = DrawToolType.VCenterAlignment;
        }

        private void displaOrderTopButton_Click(object sender, EventArgs e)
        {
            ToolOrderTop();
        }

        /// <summary>
        /// 对选中图元进行排序
        /// </summary>
        /// <param name="type">O: 最上显示; 1: 最下显示;2: 上移一层; 3: 下移一层</param>
        private void ToolOrder(int type)
        {
            viewer.Geo.DisplayOrder_Set(type);
            viewer.Geo.EnableRedraw(true);
            viewer.Drawer.ReDraw();
        }

        public void ToolOrderTop()
        {
            ToolOrder(0);
        }

        public void ToolOrderBottom()
        {
            ToolOrder(1);
        }

        public void ToolOrderUp()
        {
            ToolOrder(2);
        }

        public void ToolOrderDown()
        {
            ToolOrder(3);
        }

        private void displayOrderBottomButton_Click(object sender, EventArgs e)
        {
            ToolOrderBottom();
        }

        private void displayOrderFrontButton_Click(object sender, EventArgs e)
        {
            ToolOrderUp();
        }

        private void displayOrderBackButton_Click(object sender, EventArgs e)
        {
            ToolOrderDown();
        }

        private void horizontalMirrorButton_Click(object sender, EventArgs e)
        {
            ToolMirrorH();
        }

        public void ToolMirrorH()
        {
            viewer.ActiveTool = DrawToolType.HorizontalMirror;
        }

        private void verticalMirrorButton_Click(object sender, EventArgs e)
        {
            ToolMirrorV();
        }

        public void ToolMirrorV()
        {
            viewer.ActiveTool = DrawToolType.VerticalMirror;
        }

        private void printButton_Click(object sender, EventArgs e)
        {
            viewer.PreviewPrint();
        }

        private void ratioButton_Click(object sender, EventArgs e)
        {
            ToolDisplayScale();
        }


        private void setProjectionButton_Click(object sender, EventArgs e)
        {
            ToolSetProjection();
        }

        private void changeProjectionButton_Click(object sender, EventArgs e)
        {
            ToolProjectionChange();
        }

        public void ToolDisplayScale()
        {
            double xs, ys;
            xs = ys = 0;
            viewer.GetGeoSigma().GetXYScale(out xs, out ys);

            int xUnit, yUnit;
            xUnit = yUnit = 0;
            viewer.GetGeoSigma().GetXYUnit(out xUnit, out yUnit);

            ScaleDialog dlg = new ScaleDialog()
            {
                StartPosition = FormStartPosition.CenterScreen,
            };
            dlg.Init(xs, ys, xUnit, yUnit);
            dlg.ShowDialog(this.viewer);
            if (dlg.IsOK == false)
            {
                return;
            }

            dlg.GetScaleAndUnit(out xs, out ys, out xUnit, out yUnit);

            viewer.GetGeoSigma().SetXYScale(xs, ys);
            viewer.GetGeoSigma().SetXYUnit(xUnit, yUnit);

            viewer.Redraw();
        }

        public void ToolSetProjection()
        {
            ProjectionParameterDialog dlg = new ProjectionParameterDialog(viewer.GetGeoSigma())
            {
                StartPosition = FormStartPosition.CenterScreen,
            };
            if (dlg.ShowDialog(this) == DialogResult.OK)
            {
                viewer.GetGeoSigma().Projection_SetParameter(dlg.ProjectParameter);
                viewer.Redraw();
            }
        }

        /// <summary>
        /// 生成龟背图.
        /// </summary>
        public void ToolVoronoi()
        {
            if (viewer.CreateVoronoi() > 0)
            {
                viewer.Redraw();
                LoadLayerTree();
            }
            else
            {
                MessageBox.Show("先选中生成范围线，并且范围内至少有两个点数据！");
            }
        }
        /// <summary>
        /// Tools the voronoi2.
        /// </summary>
        public void ToolVoronoi2()
        {
            if (viewer.CreateVoronoi2() > 0)
            {
                viewer.Redraw();
                LoadLayerTree();
            }
            else
            {
                MessageBox.Show("先选中生成范围线，并且范围内至少有两个点数据！");
            }
        }
        /// <summary>
        /// 生成三角网
        /// </summary>
        public void ToolDelaunay()
        {
            if (viewer.CreateDelaunay() > 0)
            {
                viewer.Redraw();
                LoadLayerTree();
            }
            else
            {
                MessageBox.Show("先选中生成范围线，并且范围内至少有两个点数据！");
            }
        }
        /// <summary>
        /// 生成三角网
        /// </summary>
        public void ToolDelaunayConstraint()
        {
            if (viewer.CreateDelaunayConstraint() > 0)
            {
                viewer.Redraw();
                LoadLayerTree();
            }
            else
            {
                MessageBox.Show("先选中生成范围线，并且范围内至少有两个点数据！");
            }
        }

        /// <summary>
        /// 是否有选中区域
        /// </summary>
        /// <returns>bool</returns>
        public bool HasSelectedArea()
        {
            return viewer?.Geo.SelectGetCount() != -1;
        }

        private int SelectedWellsCount()
        {
            if (viewer.Geo == null)
            {
                return -1;
            }

            return viewer.Geo.Select_PointCount();
        }

        /// <summary>
        /// 抽稀
        /// </summary>
        public void ToolSimplify()
        {
            // 获取选中的点
            if (!HasSelectedArea())
            {
                MessageBox.Show("请先选中一个区域");
                return;
            }

            if (SelectedWellsCount() <= 0)
            {
                MessageBox.Show("选中区域不包含任何点，无法抽稀");
                return;
            }

            var dialog = new SimplifyDialog
            {
                StartPosition = FormStartPosition.CenterScreen,
            };
            DialogResult result = dialog.ShowDialog(this);
            if (result == DialogResult.OK)
            {
                viewer?.GetGeoSigma().SimplifySelectPoints(dialog.Value);
                viewer?.Redraw();
            }
        }

        private void zoominDecorationButton_Click(object sender, EventArgs e)
        {
            PropertyZoomIn();
        }

        public void PropertyZoomIn()
        {
            viewer.GetGeoSigma().GeoSigma_ScaleFont(true);
            viewer.Redraw();
        }

        private void zoomoutDecorationButton_Click(object sender, EventArgs e)
        {
            PropertyZoomOut();
        }

        public void PropertyZoomOut()
        {
            viewer.GetGeoSigma().GeoSigma_ScaleFont(false);
            viewer.Redraw();
        }

        private void curveDensityNodeButton_Click(object sender, EventArgs e)
        {
            ToolCurveDensity();
            //viewer.ActiveTool = DrawToolType.CurveDensityNode;
            //CancelSelectedStatusOfButton(null);
        }
        /// <summary>
        /// 曲线节点加密处理
        /// </summary>
        public void ToolCurveConnect(bool deleteOrignalCurves = false)
        {
            int nCount = viewer.CurveConnect(deleteOrignalCurves);
            if (nCount > 0)
            {
                // 如果添加了新的图层，则需要刷新图层树
            }
        }
        /// <summary>
        /// 曲线节点加密处理
        /// </summary>
        public void ToolCurveDensity()
        {
            viewer.CurveExcuteDensity();
        }

        /// <summary>
        /// 曲线冗余处理事件
        /// </summary>
        /// <param name="sender">事件按钮</param>
        /// <param name="e">事件参数</param>
        private void curveRedundancyButton_Click(object sender, EventArgs e)
        {
            //viewer.ActiveTool = DrawToolType.CurveRedundancy;
            //CancelSelectedStatusOfButton(null);
            ToolCurveRedundancy();
        }

        /// <summary>
        /// 曲线冗余处理
        /// </summary>
        public void ToolCurveRedundancy()
        {
            //viewer.ActiveTool = DrawToolType.CurveRedundancy;
            viewer.CurveRedundancy();
        }

        private void smoothCurveButton_Click(object sender, EventArgs e)
        {
            viewer.ActiveTool = DrawToolType.CurveSmooth;
            //CancelSelectedStatusOfButton(null);
        }

        public void ToolCurveSmooth()
        {
            viewer.ActiveTool = DrawToolType.CurveSmooth;
        }

        private void cutOutByRectButton_Click(object sender, EventArgs e)
        {
            ToolCutOutByRect();
        }

        public void ToolCutOutByRect()
        {
            viewer.ActiveTool = DrawToolType.CutOutByRect;
        }

        private void cutInByRectButton_Click(object sender, EventArgs e)
        {
            ToolCutInByRect();
        }

        public void ToolCutInByRect()
        {
            viewer.ActiveTool = DrawToolType.CutInByRect;
        }

        private void pickupCutOutButton_Click(object sender, EventArgs e)
        {
            ToolCutOutByPickup();
        }

        public void ToolCutOutByPickup()
        {
            viewer.ActiveTool = DrawToolType.CutOutByPickup;
        }

        private void pickupCutInButton_Click(object sender, EventArgs e)
        {
            ToolCutInByPickup();
        }

        public void ToolCutInByPickup()
        {
            viewer.ActiveTool = DrawToolType.CutInByPickup;
        }

        private void calcVolumeStripMenuItem_Click(object sender, EventArgs e)
        {
            ToolGridVolumeCalculate();
        }

        public void ToolGridVolumeCalculate()
        {
            viewer.ActiveTool = DrawToolType.CalculateVolume;
        }

        private void setZOfSurfaceMenuItem_Click(object sender, EventArgs e)
        {
            ToolGridSetZValue();
        }

        public void ToolGridSetZValue()
        {
            viewer.ActiveTool = DrawToolType.SetZValueOfSurface;
        }

        public void ToolGridStatics()
        {
            viewer.GridStatics();
        }
        /// <summary>
        /// 由数据重新生成网格.
        /// </summary>
        /// <returns>A System.Threading.Tasks.Task.</returns>
        public async System.Threading.Tasks.Task CreateMeshByDataAsync()
        {
            await viewer.CreateMeshByDataAsync();
        }
        /// <summary>
        /// 由图片生成网格.
        /// </summary>
        /// <returns>A System.Threading.Tasks.Task.</returns>
        public async System.Threading.Tasks.Task CreateMeshByImageAsync()
        {
            await viewer.CreateMeshByImageAsync();
        }
        private void changeCoordinateMenuItem_Click(object sender, EventArgs e)
        {
            ToolCoordinateChange();
        }

        public void ToolProjectionChange()
        {
            ProjectionParameterDialog dlg = new ProjectionParameterDialog(viewer.GetGeoSigma())
            {
                StartPosition = FormStartPosition.CenterScreen,
            };
            if (dlg.ShowDialog(this) != DialogResult.OK)
            {
                return;
            }

            SigmaProjectionParameter parameter = default(SigmaProjectionParameter);
            dlg.GetResult(ref parameter);

            viewer.GetGeoSigma().Projection_Change(ref parameter);
            viewer.Redraw();
        }

        /// <summary>
        /// 交互XY坐标
        /// </summary>
        /// <param name="sender">菜单</param>
        /// <param name="e">事件参数</param>
        private void xyChangeMenuItem_Click(object sender, EventArgs e)
        {
            ToolCoordinateExchange();
        }

        public void ToolCoordinateExchange()
        {
            viewer.GetGeoSigma().GeoSigma_ExchangeXY();
            viewer.Redraw();
        }

        private void undoButton_Click(object sender, EventArgs e)
        {
            ToolUndo();
        }

        private bool IsLayerOperation(int type)
        {
            var actionTypes = new List<ActionType>()
            {
                ActionType.ActionTypeLayerRename,
                ActionType.ActionTypeLayerAdd,
                ActionType.ActionTypeLayerDelete,
                ActionType.ActionTypeLayerDragDrop,
            };

            if (Enum.IsDefined(typeof(ActionType), type))
            {
                return actionTypes.Contains((ActionType)type);
            }
            return false;
        }

        private bool IsLayerEmbellishOperation(int type)
        {
            var actionTypes = new List<ActionType>()
            {
                ActionType.ActionTypeLayerCurveAdd,
                ActionType.ActionTypeLayerCurveDelete,
                ActionType.ActionTypeLayerCurveMoveUp,
                ActionType.ActionTypeLayerCurveMoveDown,
                ActionType.ActionTypeLayerPointAdd,
                ActionType.ActionTypeLayerPointDelete,
            };
            if (Enum.IsDefined(typeof(ActionType), type))
            {
                return actionTypes.Contains((ActionType)type);
            }
            return false;
        }

        public void ToolUndo()
        {
            int nActionType = viewer.Undo();
            viewer.Redraw();

            RefreshLayer(nActionType);
        }

        private void redoButton_Click(object sender, EventArgs e)
        {
            ToolRedo();
        }

        public void ToolRedo()
        {
            int nActionType = viewer.Redo();
            viewer.Redraw();

            // 重新设置图层树
            RefreshLayer(nActionType);
        }

        // 重新设置图层树
        private void RefreshLayer(int actionType)
        {
            if (IsLayerOperation(actionType))
            {
                LoadLayerTree();
            }

            if (IsLayerEmbellishOperation(actionType))
            {
                ReActiveCurrentLayer();
            }
        }

        public void ToolCoordinateChange()
        {
            CoordinateChangeDialog dlg = new CoordinateChangeDialog()
            {
                StartPosition = FormStartPosition.CenterScreen,
            };
            DialogResult result = dlg.ShowDialog(this);
            if (result == DialogResult.Cancel)
            {
                return;
            }

            int kind = dlg.GetOperationObjectKind();
            string xExpression = dlg.GetXExpression().ToLower();
            string yExpression = dlg.GetYExpression().ToLower();
            string zExpression = dlg.GetZExpression().ToLower();
            string lExpression = dlg.GetLExpression().ToLower();

            viewer.GetGeoSigma().Coordinate_ChangeByExpression(kind, xExpression, yExpression, zExpression, lExpression);
            viewer.Redraw();
        }

        private void OnCommandStart(DrawToolType toolType)
        {
            ChangeButtonStatus(toolType, true);
        }

        private void OnCommandFinish(DrawToolType toolType)
        {
            ChangeButtonStatus(toolType, false);
        }

        public void ChangeButtonStatus(DrawToolType toolType, bool bChecked)
        {
            tsbPan.Checked = false;
            tsbViewWindow.Checked = false;
            viewer.SetViewOperationKind(ViewOperationKind.Invalid);

            switch (toolType)
            {
                case DrawToolType.Default:
                    tsbToolDefault.Checked = bChecked;
                    break;
                //case DrawToolType.ViewPan:
                //    tsbPan.Checked = bChecked;
                //    break;
                case DrawToolType.ViewWindow:
                    tsbViewWindow.Checked = bChecked;
                    break;

                case DrawToolType.Select:
                    tsbSelect.Checked = bChecked;
                    break;

                case DrawToolType.Point:
                    tsbPointAdd.Checked = bChecked;
                    break;

                case DrawToolType.Curve:
                    tsbCurveAdd.Checked = bChecked;
                    break;

                case DrawToolType.Proportion:
                    tsbProportionAdd.Checked = bChecked;
                    break;

                case DrawToolType.RectangularCSGrid:
                    rectangularCSGridButton.Checked = bChecked;
                    break;

                case DrawToolType.Rectangle:
                    drawRectangleButton.Checked = bChecked;
                    break;

                case DrawToolType.Ellipse:
                    sbtnEllipse.Checked = btnEllipse.Checked = bChecked;
                    break;

                case DrawToolType.Arc:
                    sbtnEllipse.Checked = btnArc.Checked = bChecked;
                    break;

                case DrawToolType.Chord:
                    sbtnEllipse.Checked = btnChord.Checked = bChecked;
                    break;

                case DrawToolType.Pie:
                    sbtnEllipse.Checked = btnPie.Checked = bChecked;
                    break;

                case DrawToolType.Equilateral:
                    sbtnEllipse.Checked = btnEquilateral.Checked = bChecked;
                    break;

                case DrawToolType.Text:
                    drawTextButton.Checked = bChecked;
                    break;

                case DrawToolType.BreakDirect:
                    breakDirectButton.Checked = bChecked;
                    break;

                case DrawToolType.Break:
                    breakCurveButton.Checked = bChecked;
                    break;

                case DrawToolType.Delete: //?是不是立刻就执行完的命令
                    deleteNormalButton.Checked = bChecked;
                    break;

                case DrawToolType.DeleteIn:
                    deleteInButton.Checked = bChecked;
                    break;

                case DrawToolType.DeleteOut:
                    deleteOutButton.Checked = bChecked;
                    break;

                case DrawToolType.DeleteCondition:
                    conditionButton.Checked = bChecked;
                    break;

                case DrawToolType.TrimCurve:
                    trimCurveButton.Checked = bChecked;
                    break;

                case DrawToolType.CloseCurve:
                    closeCurveButton.Checked = bChecked;
                    break;

                case DrawToolType.MoveCurveName:
                    moveCurveNameButton.Checked = bChecked;
                    break;

                case DrawToolType.LinkCurve:
                    linkCurveButton.Checked = bChecked;
                    break;

                case DrawToolType.ReverseCurve:
                    reverseCurveButton.Checked = bChecked;
                    break;

                case DrawToolType.NameToZ:
                    nameToZButton.Checked = bChecked;
                    break;

                case DrawToolType.RangeToImage:
                    //tsbCopyImageAll.Checked = bChecked;
                    break;

                case DrawToolType.WindowToImage:
                    //tsbCopyImageWindow.Checked = bChecked;
                    break;

                case DrawToolType.CrossPoint:
                    crossPointButton.Checked = bChecked;
                    break;

                case DrawToolType.CurvePropertySet:
                    tsbSetCurveProperty.Checked = bChecked;
                    break;

                case DrawToolType.CurvePropertyClear:
                    tsbClearCurveProperty.Checked = bChecked;
                    break;

                case DrawToolType.CurveNameSetting:
                    tsbClearCurveProperty.Checked = bChecked;
                    break;
                case DrawToolType.FaultSymply:
                    btnFaultSimplyfy.Checked = bChecked;
                    break;

                default:
                    break;
            }

            ButtonStatusChangeEvent?.Invoke(toolType, bChecked);
        }

        private void kdnStatiscResult_CloseAction(object sender, CloseActionEventArgs e)
        {
            // this.kdnStatiscResult.Height = 50;
        }

        /// <summary>
        /// 为常用菜单添加自定义命令.
        /// </summary>
        /// <param name="text">The text.</param>
        /// <param name="handler">The handler.</param>
        /// <param name="needElement">if set to <c>true</c> [need element].</param>
        /// <param name="elementType">操作的图元类型.</param>
        public void InsertCommonCommand(string text, EventHandler handler, bool needElement = true
            , DrawElementType elementType = DrawElementType.ELEMENT_UNKNOWN)
        {
            if (text == null)
            {
                throw new ArgumentNullException(nameof(text));
            }

            if (handler == null)
            {
                throw new ArgumentNullException(nameof(handler));
            }

            viewer?.InsertCommonCommand(text, handler, needElement, elementType);
        }

        /// <summary>
        /// 加载统计元素数据
        /// </summary>
        /// <param name="xml">数据</param>
        public void LoadElementData(string xml)
        {
            dgvStatics.DataSource = null;
            if (!string.IsNullOrEmpty(xml))
            {
                double realLength = 0;
                double area = 0;
                int nCurveCount = 0;
                int nPointCount = 0;

                DataTable dtStatistic = new DataTable("ROOT");
                dtStatistic.Columns.AddRange(new DataColumn[]
                {
                    new DataColumn("序号", Type.GetType("System.Int32")),
                    new DataColumn("名称", Type.GetType("System.String")),
                    new DataColumn("类型", Type.GetType("System.String")),
                    new DataColumn("层位", Type.GetType("System.String")),
                    new DataColumn("所用符号", Type.GetType("System.String")),
                    new DataColumn("实际长度", Type.GetType("System.Double")),
                    new DataColumn("面积", Type.GetType("System.Double")),
                    new DataColumn("方位角", Type.GetType("System.Double")),
                    new DataColumn("Position", Type.GetType("System.String")),
                    new DataColumn("X", Type.GetType("System.Double")),
                    new DataColumn("Y", Type.GetType("System.Double")),
                    new DataColumn("Z", Type.GetType("System.Double")),
                });
                XmlDocument doc = new XmlDocument();
                doc.LoadXml(xml);
                XmlNode currNode = doc.DocumentElement.FirstChild;
                while (currNode != null)
                {
                    DataRow drNew = dtStatistic.NewRow();
                    for (int i = 0; i < currNode.ChildNodes.Count; i++)
                    {
                        string strEle = currNode.ChildNodes[i].InnerText;
                        if (string.IsNullOrEmpty(strEle))
                        {
                            continue;
                        }
                        if (i == 0)
                        {
                            drNew[i] = Convert.ToInt32(strEle);
                        }
                        else if (i == 2)
                        {
                            drNew[i] = strEle;
                            if (strEle.Equals("曲线"))
                            {
                                nCurveCount++;
                            }
                            else if (strEle.Equals("点"))
                            {
                                nPointCount++;
                            }
                        }
                        else if (i == 5)
                        {
                            if (double.TryParse(strEle, out double dValue))
                            {
                                drNew[i] = dValue;
                                realLength += dValue;
                            }
                            else
                            {
                                drNew[i] = DBNull.Value;
                            }
                        }
                        else if (i == 6)
                        {
                            if (double.TryParse(strEle, out double dValue))
                            {
                                drNew[i] = dValue;
                                realLength += dValue;
                                area += dValue;
                            }
                            else
                            {
                                drNew[i] = DBNull.Value;
                            }
                        }
                        else if (i == 7)
                        {
                            if (double.TryParse(strEle, out double dValue))
                            {
                                drNew[i] = dValue;
                                realLength += dValue;
                            }
                            else
                            {
                                drNew[i] = DBNull.Value;
                            }
                        }
                        else
                        {
                            drNew[i] = strEle;
                        }
                    }
                    dtStatistic.Rows.Add(drNew);
                    currNode = currNode.NextSibling;
                }

                for (int i = 0; i < dtStatistic.Columns.Count; i++)
                {
                    dtStatistic.Columns[i].ReadOnly = true;
                }

                dgvStatics.DataSource = dtStatistic;

                DataRow drStatis = dtStatistic.NewRow();
                drStatis[0] = dtStatistic.Rows.Count + 1;
                drStatis[1] = "合计";
                drStatis[2] = "曲线:" + nCurveCount + "点:" + nPointCount;
                drStatis[5] = realLength;
                drStatis[6] = area;
                dtStatistic.Rows.Add(drStatis);
            }

            if (ShowStatisticResult != null)
            {
                ShowStatisticResult(this, new DataControlArgs("元素统计"));
            }
            this.StatisticVisble = true;
        }

        /// <summary>
        /// 如果文字过长，截断并在末尾添加省略号
        /// </summary>
        /// <param name="str">要截断的文字</param>
        /// <param name="maxLength">最大长度</param>
        /// <returns>返回新的字符串</returns>
        private string TruncateLongString(string str, int maxLength)
        {
            if (str.Length > maxLength)
            {
                return str.Substring(0, maxLength) + "...";
            }

            return str;
        }

        /// <summary>
        /// 反转曲线的网格的Z值
        /// </summary>
        public void ReverseCurveAndMeshZValue()
        {
            viewer.GetGeoSigma().ReverseCurveAndMeshZValue();
            viewer.Redraw();
        }

        /// <summary>
        /// 删除重复元素
        /// </summary>
        public void DeleteDuplicationElements()
        {
            //var dialog = new DeduplicationDialog();
            //if (dialog.ShowDialog() == DialogResult.OK)
            //{
            //    var serializer = new XmlSerializer(typeof(DeduplicationConfig));
            //    var writer = new StringWriter();
            //    serializer.Serialize(writer, dialog.DeduplicationConfig);
            //    string xml = writer.ToString();

            //    viewer.GetGeoSigma().XyDeleteDupElements(xml);
            //    viewer.Redraw();
            //}
        }

        /// <summary>
        /// 加载资源评价统计数据
        /// </summary>
        /// <param name="xml">xml</param>
        public void LoadResourcComment(string xml)
        {

        }
        /// <summary>
        /// 加载范围关系统计数据
        /// </summary>
        /// <param name="xml">xml</param>
        public void LoadRangeRation(string xml)
        {

        }
        /// <summary>
        /// 加载统计测线数据
        /// </summary>
        /// <param name="xml">数据</param>
        public void LoadSurveyData(string xml)
        {

        }

        /// <summary>
        /// 加载统计圈闭数据
        /// </summary>
        /// <param name="xml">数据内容</param>
        public void LoadTrapsData(string xml)
        {

        }

        /// <summary>
        /// 断层统计
        /// </summary>
        public void LoadFaultDataNew(string strFileOut)
        {

        }

        //#if DEBUG
        //        const string DLL_FILE_Fault = "FaultStatisticsLibD.dll";
        //#else
        //        const string DLL_FILE_Fault = "FaultStatisticsLib.dll";
        //#endif
        //        /// <summary>
        //        /// 断层统计.
        //        /// </summary>
        //        /// <param name="inputFile">The input file.</param>
        //        /// <param name="resultFile">The result file.</param>
        //        /// <param name="statisticFile">The statistic file.</param>
        //        /// <param name="faultLayer">The fault layer.</param>
        //        /// <param name="pillarStep">The pillar step.</param>
        //        /// <param name="textHeight">Height of the text.</param>
        //        /// <param name="markColor">Color of the mark.</param>
        //        /// <param name="markType">Type of the mark.</param>
        //        /// <returns>是否成功</returns>
        //        [DllImport(DLL_FILE_Fault, EntryPoint = "CreateFaultStatistic", ExactSpelling = false, CallingConvention = CallingConvention.Cdecl)]
        //        private static extern bool CreateFaultStatistic(string inputFile, string resultFile, string statisticFile,
        //            string faultLayer, double pillarStep, double textHeight
        //           , int markColor, int markType);

        /// <summary>
        /// 断层统计
        /// </summary>
        /// <param name="xml">数据内容</param>
        public void LoadFaultData(string xml)
        {

        }

        /// <summary>
        /// 获得曲面上点的Z值
        /// </summary>
        /// <param name="x">点坐标X</param>
        /// <param name="y">点坐标Y</param>
        /// <param name="dZValue">点坐标Z</param>
        /// <returns>是否成功</returns>
        public bool GetGridPointValue(double x, double y, ref double dZValue)
        {
            return viewer.Geo.GetGridPointValue(x, y, ref dZValue);
        }

        /// <summary>
        /// 层位统计
        /// </summary>
        /// <param name="xml">统计数据</param>
        public void LoadLayerData(string xml)
        {

        }

        /// <summary>
        /// 井位统计
        /// </summary>
        /// <param name="xml">统计数据</param>
        public void LoadWellsData(string xml)
        {

        }

        /// <summary>
        /// 体积统计
        /// </summary>
        /// <param name="xml">数据内容</param>
        public void LoadVolumnData(string xml)
        {

        }

        /// <summary>
        /// 区块内元素统计.
        /// </summary>
        /// <param name="xml">统计数据.</param>
        public void StatiscBlockElements(string xml)
        {

        }

        private void StatiscAzimuthElements(string statiscResult)
        {

        }

        /// <summary>
        /// 区域内井位统计.
        /// </summary>
        /// <param name="blockLine">The block line.</param>
        /// <returns>井位数据，Xml格式:序号,名称,图层,X,Y,Z,Position </returns>
        public string StaticBlockWells(string blockLine)
        {
            if (blockLine == null)
            {
                throw new ArgumentNullException(nameof(blockLine));
            }

            return viewer.Drawer.Geo.StaticBlockWells(blockLine);
        }

        /// <summary>
        /// 统计范围内的区块.
        /// </summary>
        /// <param name="blockLine">The block line.</param>
        /// <returns>区块的数据</returns>
        public string StaticBlocks(string blockLine)
        {
            if (blockLine == null)
            {
                throw new ArgumentNullException(nameof(blockLine));
            }

            return viewer.Drawer.Geo.StaticBlocks(blockLine);
        }

        public string StaticBlocksInfo(string blockLine)
        {
            return viewer.Drawer.Geo.StaticBlocksInfo(blockLine);
        }

        public string CutStaticBlocks(string positionData, string blockLine)
        {
            return viewer.Drawer.Geo.CutStaticBlocks(positionData, blockLine);
        }

        public double CaculateBlockArea(string position)
        {
            return viewer.Drawer.Geo.CaculateBlockArea(position);
        }

        public void ResetLayerByOther(string pos, string posRefer, string suffix)
        {
            viewer.Drawer.Geo.ResetLayerByOther(pos, posRefer, suffix);
        }

        #region 个性处理

        /// <summary>
        /// 清除点类元素个性
        /// </summary>
        /// <param name="sender">事件按钮</param>
        /// <param name="e">事件参数</param>
        private void tsbClearPointProperty_Click(object sender, EventArgs e)
        {
            ToolClearPointProperty();
        }

        public void ToolClearPointProperty()
        {
            viewer.ActiveTool = DrawToolType.PointPropertyClear;
        }

        /// <summary>
        /// 设置点类图元个性
        /// </summary>
        /// <param name="sender">按钮</param>
        /// <param name="e">事件参数</param>
        private void tsbSetPointProperty_Click(object sender, EventArgs e)
        {
            ToolSetPointProperty();
        }

        public void ToolSetPointProperty()
        {
            viewer.ActiveTool = DrawToolType.PointPropertySet;
        }

        private void gridBtn_Click(object sender, EventArgs e)
        {
            //viewer.EnableGrid(gridBtn.Checked);
        }

        private void highLightTipBtn_Click(object sender, EventArgs e)
        {
            ToolEnableHighLight(this.highLightTipBtn.Checked);
        }

        public void ToolEnableHighLight(bool enable)
        {
            this.viewer.EnableHeighLight(enable);
        }

        private void extendCurveTSSButton_ButtonClick(object sender, EventArgs e)
        {
            ToolExtendCurve();
        }

        private void setExtendLengthMenuItem_Click(object sender, EventArgs e)
        {
            ToolCurveExtendSetting();
        }

        public void ToolCurveExtendSetting()
        {
            ExtensionLengthDialog dlg = new ExtensionLengthDialog(viewer.Drawer)
            {
                StartPosition = FormStartPosition.CenterScreen,
            };
            dlg.ShowDialog(this.viewer);
        }

        private void gridTSSButton_ButtonClick(object sender, EventArgs e)
        {
            viewer.SwitchGrid();
        }

        /// <summary>
        /// 显示背景网格
        /// </summary>
        /// <param name="show">是/否</param>
        public void DisplayBackgroundGrid(bool show)
        {
            viewer.DisplayBackgroundGrid(show);
        }

        private void settingGridTSMenuItem_Click(object sender, EventArgs e)
        {
            ToolSetBKGridSize();
        }

        public void ToolSetBKGridSize()
        {
            GridSettingDialog dlg = new GridSettingDialog(viewer.Geo)
            {
                StartPosition = FormStartPosition.CenterScreen,
            };
            if (dlg.ShowDialog(this) == DialogResult.OK)
            {
                viewer.Redraw();
            }
        }

        private void arcToCurveMenuItem_Click(object sender, EventArgs e)
        {
            ToolShape2Curve();
            //CancelSelectedStatusOfButton(null);
        }

        public void ToolShape2Curve()
        {
            viewer.ActiveTool = DrawToolType.ArcToCurve;
        }

        public void ToolCurveZFromSuface()
        {
            viewer.ActiveTool = DrawToolType.CurveZFromSurface;
        }

        private void mathFindMenuItem_Click(object sender, EventArgs e)
        {
            ToolFilter();
        }

        public void ToolFilter()
        {
            //MathFindAssistor assistor = new MathFindAssistor();
            //assistor.Execute(viewer.Geo, dgvStatics);
            //if (ShowStatisticResult != null)
            //{
            //    ShowStatisticResult(this, new DataControlArgs("筛选"));
            //}
            //this.StatisticVisble = true;
        }

        private void findMenuItem_Click(object sender, EventArgs e)
        {
            ToolFind(false);
        }

        /// <summary>
        /// 显示查找窗口.
        /// </summary>
        public void ToolFind(bool isReplace)
        {
            var findReplaceDlg = new FindReplaceDialog(viewer.Drawer);
            if (isReplace)
            {
                findReplaceDlg.ChangeToReplaceTab();
            }
            findReplaceDlg.StartPosition = FormStartPosition.CenterScreen;
            findReplaceDlg.FindAll += FindAll;
            findReplaceDlg.Show();
        }

        private bool Match(string text1, string text2, bool exactMatch, bool ignoreCase)
        {
            if (text1 == null || text2 == null)
            {
                return false;
            }

            if (ignoreCase)
            {
                text1 = text1.ToLower();
                text2 = text2.ToLower();
            }

            if (exactMatch)
            {
                return text1 == text2;
            }

            return text1.Contains(text2);
        }

        /// <summary>
        /// 查找所有
        /// 原先查找所有逻辑和现在不同，现在要求查找所有和统计元素显示在同一面板，这里干脆先统计元素，再剔除不匹配的行
        /// </summary>
        /// <param name="text">查找时的文本</param>
        /// <param name="exactMatch">完全匹配</param>
        /// <param name="ignoreCase">忽略大小写</param>
        private void FindAll(string text, bool exactMatch, bool ignoreCase)
        {
            GeoSigmaXY geo = viewer.GetGeoSigma();
            string xml = geo.Statisc(null, true, 0, -1);
            LoadElementData(xml);

            DataTable dataTable = dgvStatics.DataSource as DataTable;

            // 删除最后的合计一行
            int lastRowIndex = dataTable.Rows.Count - 1;
            if (lastRowIndex >= 0)
            {
                dataTable.Rows.RemoveAt(lastRowIndex);
            }

            // 剔除名称不匹配的元素
            var exactMatches = dataTable.AsEnumerable()
                .Where(row => !Match(row.Field<string>("名称"), text, exactMatch, ignoreCase))
                .ToList();
            foreach (var row in exactMatches)
            {
                dataTable.Rows.Remove(row);
            }
        }

        /// <summary>
        /// 切换到测量模式
        /// </summary>
        public void ToolMeasure()
        {
            viewer.ActiveTool = DrawToolType.Measure;
        }

        /// <summary>
        /// 旋转图件
        /// </summary>
        /// <param name="x">旋转原点 x 坐标</param>
        /// <param name="y">旋转原点 y 坐标</param>
        /// <param name="angle">旋转角度</param>
        public void Rotation(int x, int y, double angle)
        {
            viewer.Geo.Rotation(x, y, angle);
            viewer.Redraw();
        }

        ///// <summary>
        ///// Elements the find next.
        ///// </summary>
        ///// <param name="content">The content.</param>
        ///// <param name="matchAll">if set to <c>true</c> [match all].</param>
        ///// <param name="matchCase">if set to <c>true</c> [match case].</param>
        ///// <param name="elementType">Type of the element.</param>
        ///// <param name="editableOnly">if set to <c>true</c> [editable only].</param>
        ///// <returns>-1--出错, 0--找到了, 1--第一次查找 但没找到, 2--已经搜索完了</returns>
        //public int ElementFindNext(string content, bool matchAll, bool matchCase, int elementType = 0, bool editableOnly = true)
        //{
        //    return viewer.Drawer.Geo.FindReplacement_FindNext(
        //        content, matchAll ? 1 : 0, matchCase ? 1 : 0
        //        , elementType, editableOnly);
        //}
        //public void ElementFindActive()
        //{
        //    long lPos = viewer.Drawer.Geo.FindReplace_GetCurrentPostion();
        //    if (lPos > 0)
        //    {
        //        this.ActiveElement(lPos);
        //    }
        //}
        ///// <summary>
        ///// 替换上次查找到的结果.
        ///// </summary>
        ///// <param name="strFind">The string find.</param>
        ///// <param name="strReplace">The string replace.</param>
        ///// <param name="bMatch">if set to <c>true</c> [b match].</param>
        ///// <param name="bCapitalLower">if set to <c>true</c> [b capital lower].</param>
        ///// <returns>执行结果</returns>
        //public int ElementFindReplace(string strFind, string strReplace, bool bMatch, bool bCapitalLower)
        //{
        //    return viewer.Drawer.Geo.FindReplacement_Replace(
        //        strFind, strReplace, bMatch ? 1 : 0, bCapitalLower ? 1 : 0);
        //}
        //public int ElementFindReplaceAll(string strFind, string strReplace, bool bMatch, bool bCapitalLower)
        //{
        //    return viewer.Drawer.Geo.FindReplacement_ReplaceAll(strFind, strReplace, bMatch ? 1 : 0, bCapitalLower ? 1 : 0);
        //}
        //public void ElementFindStart()
        //{
        //    viewer.Drawer.Geo.FindReplacement_Start();
        //}
        //public void ElementFindAll(string findContent, bool bMatch, bool bCapitalLower)
        //{
        //    viewer.Drawer.Geo.FindReplacement_FindAll(findContent, bMatch ? 1 : 0, bCapitalLower ? 1 : 0);
        //    FindAllResultDialog dlg = new FindAllResultDialog(viewer.Drawer.Geo);
        //    dlg.Show();
        //}
        private void findAndReplaceButton_ButtonClick(object sender, EventArgs e)
        {
            this.ToolFind(true);
        }

        //public void DrawHandleFrameInDrawer(Graphics g)
        //{
        //    IntPtr hdc = g.GetHdc()

        //    viewer.Drawer.Geo.FindReplacement_Draw(hdc);
        //    g.ReleaseHdc(hdc);
        //}
        //public void ToolFindReplace()
        //{
        //    ShowFindReplace();
        //}
        private void replaceMenuItem_Click(object sender, EventArgs e)
        {
            ToolFind(true);
        }

        /// <summary>
        /// 全选事件.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
        private void selectAllMenuItem_Click(object sender, EventArgs e)
        {
            ToolSelectAll();
        }

        /// <summary>
        /// 选中所有图元
        /// </summary>
        public void ToolSelectAll()
        {
            viewer.SelectAll();
        }

        private void selectAllPointMenuItem_Click(object sender, EventArgs e)
        {
            ToolSelectAllPoint();
        }

        /// <summary>
        /// 选中所有点
        /// </summary>
        public void ToolSelectAllPoint()
        {
            viewer.SelectAllPoint();
        }

        private void selectAllCurveMenuItem_Click(object sender, EventArgs e)
        {
            ToolSelectAllCurve();
        }

        public void ToolSelectAllCurve()
        {
            viewer.SelectAllCurve();
        }

        private void undoViewButton_Click(object sender, EventArgs e)
        {
            ToolZoomBack();
        }

        public void ToolZoomBack()
        {
            viewer.Geo.Sigma_UndoView();
            viewer.Redraw();
        }

        private void crossLineButton_Click(object sender, EventArgs e)
        {
            if (crossLineButton.CheckState == CheckState.Checked)
            {
                ToolCrossEnable(true);
                //viewer.Redraw();
            }
            else
            {
                ToolCrossEnable(false);
                //viewer.Redraw();
            }
            //viewer.GeoSigma.EnableCrossLine(true);
        }

        public void ToolCrossEnable(bool enable)
        {
            viewer.EnableCrossLine(enable);
        }

        private void fourCalibrationMenuItem_Click(object sender, EventArgs e)
        {
            viewer.ActiveTool = DrawToolType.Calibration4;
        }

        public void ToolCalibration4()
        {
            viewer.ActiveTool = DrawToolType.Calibration4;
        }

        private void twoCalibrationMenuItem_Click(object sender, EventArgs e)
        {
            viewer.ActiveTool = DrawToolType.Calibration2;
        }

        public void ToolCalibration2()
        {
            viewer.ActiveTool = DrawToolType.Calibration2;
        }

        private void fillByPointMenuItem_Click(object sender, EventArgs e)
        {
            ToolCurveConnectFill();
        }

        public void ToolCurveConnectFill()
        {
            viewer.ActiveTool = DrawToolType.ConnectCurveFilling;
        }

        public void ToolSolidLink()
        {
            viewer.ActiveTool = DrawToolType.SolidLink;
        }

        public void ToolSolidAuto()
        {
            viewer.ActiveTool = DrawToolType.SolidAuto;
        }

        public void ToolWellGroup()
        {
            viewer.ActiveTool = DrawToolType.WellGroup;
        }

        private void zPositiveNegativeMenuItem_Click(object sender, EventArgs e)
        {
            viewer.ActiveTool = DrawToolType.PositiveNegativeSign;
        }

        private void conditionButton_Click(object sender, EventArgs e)
        {
            viewer.ActiveTool = DrawToolType.DeleteCondition;
        }

        private void fractionPointMenuItem_Click(object sender, EventArgs e)
        {
            ToolDrawFractionPoint();
        }

        public void ToolDrawFractionPoint()
        {
            viewer.ActiveTool = DrawToolType.FractionPoint;
        }

        /// <summary>
        /// 启动橡皮擦
        /// </summary>
        public void ToolEraser()
        {
            viewer.ActiveTool = DrawToolType.Eraser;
        }

        /// <summary>
        /// 断层外扩.
        /// </summary>
        public void ToolFaultBroaden()
        {
            viewer.ActiveTool = DrawToolType.CurveBroaden;
        }
        public void ToolFaultSimply()
        {
            viewer.ActiveTool = DrawToolType.FaultSymply;
        }
        private void CurveNameSettingMenuItem_Click(object sender, EventArgs e)
        {
            ToolCurveNameSet();
        }

        public void ToolCurveNameSet()
        {
            viewer.ActiveTool = DrawToolType.CurveNameSetting;
        }

        public void ToolSetContourName()
        {
            viewer.ActiveTool = DrawToolType.SetContourName;
        }

        private void NameToZMenuItem_Click(object sender, EventArgs e)
        {
            ToolCurveName2z();
        }

        public void ToolCurveName2z()
        {
            viewer.ActiveTool = DrawToolType.NameToZ;
        }

        private void ZToNameToolStripMenuItem_Click(object sender, EventArgs e)
        {
            ToolCurveZ2Name();
        }

        public void ToolCurveZ2Name()
        {
            viewer.ActiveTool = DrawToolType.ZToName;
        }

        private void EmptyNameCurveToolStripMenuItem_Click(object sender, EventArgs e)
        {
            ToolCurveFindEmptyName();
        }

        public void ToolCurveFindEmptyName()
        {
            viewer.ActiveTool = DrawToolType.FindCurveOfEmptyName;
        }

        private void BatchCutImageToolStripMenuItem_Click(object sender, EventArgs e)
        {
            BatchFilesCutImageDialog dlg = new BatchFilesCutImageDialog(viewer.Geo)
            {
                StartPosition = FormStartPosition.CenterScreen,
            };
            dlg.ShowDialog(this);
        }

        private void batchFileTransformationMenuItem_Click(object sender, EventArgs e)
        {
            BatchFileTransformationDialog dlg = new BatchFileTransformationDialog(viewer.Geo)
            {
                StartPosition = FormStartPosition.CenterScreen,
            };
            dlg.ShowDialog(this);
        }

        private void tsbtnSave_Click(object sender, EventArgs e)
        {
            this.SaveFile();
        }

        private void tsbtnLayerPanel_Click(object sender, EventArgs e)
        {
            LayerVisibleChanged?.Invoke(null, true);
            LayerVisible = !LayerVisible;
        }

        //private void CancelSelectedStatusOfButton(ToolStripButton currentButton)
        //{
        //    if (highLightTipBtn != currentButton)
        //    {
        //        highLightTipBtn.Checked = false;
        //    }
        //}
        private void tspElement_MouseMove(object sender, MouseEventArgs e)
        {
            if (tspElement.Focused != true && tspElement.CanFocus)
            {
                tspElement.Focus();
            }
        }

        private void tspArrange_MouseMove(object sender, MouseEventArgs e)
        {
            if (!tspArrange.Focused && tspArrange.CanFocus)
            {
                tspArrange.Focus();
            }
        }

        private void tsbEnableMeshPackage_Click(object sender, EventArgs e)
        {
            //   ToolGridEnablePack(tsbEnableMeshPackage.Checked);
        }

        public void ToolGridEnablePack(bool enable)
        {
            if (viewer.Geo == null)
            {
                return;
            }
            viewer.Geo.EnableMeshPackage(enable, ForceMeshPack);
            viewer.Redraw();
        }

        /// <summary>
        /// 反走样
        /// </summary>
        /// <param name="enable">是否进行反走样</param>
        public void ToolAntiAlias(bool enable)
        {
            viewer.Geo.SetAntiAlias(enable);
            viewer.Redraw();
        }

        public bool ForceMeshPack { get; set; } = false;

        public string FaultLayer
        {
            get
            {
                return viewer.Geo.GetFaultLayer();
            }
            set
            {
                viewer.Geo.SetFaultLayer(value);
            }
        }

        public string BorderLayer
        {
            get
            {
                return viewer.Geo.GetBorderLayer();
            }
            set
            {
                viewer.Geo.SetBorderLayer(value);
            }
        }

        public string FaultLayer3D
        {
            get
            {
                return viewer.Geo.GetFaultLayer3D();
            }
            set
            {
                viewer.Geo.SetFaultLayer3D(value);
            }
        }

        public string BorderLayer3D
        {
            get
            {
                return viewer.Geo.GetBorderLayer3D();
            }
            set
            {
                viewer.Geo.SetBorderLayer3D(value);
            }
        }

        public string WellLayer3D
        {
            get
            {
                return viewer.Geo.GetWellLayer3D();
            }
            set
            {
                viewer.Geo.SetWellLayer3D(value);
            }
        }

        public string MainMeshLayer3D
        {
            get
            {
                return viewer.Geo.GetMainMeshLayer3D();
            }
            set
            {
                viewer.Geo.SetMainMeshLayer3D(value);
            }
        }

        public long MainMeshId3D
        {
            get
            {
                return viewer.Geo.GetMainMeshId3D();
            }
            set
            {
                viewer.Geo.SetMainMeshId3D(value);
            }
        }

        /// <summary>
        /// 根据Z值设置色块显示
        /// </summary>
        /// <param name="sender">按钮</param>
        /// <param name="e">事件参数</param>
        private void tsbtnZColor_Click(object sender, EventArgs e)
        {
            ToolZColor();
        }

        public void ToolZColor()
        {
            viewer.SetPointZColor();
            viewer.Redraw();
        }

        /// <summary>
        /// 点类数据根据Z值进行色块显示
        /// </summary>
        /// <param name="zColorSize">colorSize</param>
        /// <returns>是否成功</returns>
        public bool SetZColorDefault(double zColorSize)
        {
            double dMin = 0, dMax = 0;
            bool bFound = viewer.Geo.GetPointsZRange(ref dMin, ref dMax);
            if (!bFound)
            {
                return false;
            }
            StringBuilder strbColors = new StringBuilder();

            GradientColorTemplate mesh = new GradientColorTemplate { Name = "ZColor" };
            mesh.AddColor(255, 0, 0);
            mesh.AddColor(255, 255, 0);
            mesh.AddColor(70, 255, 255);
            mesh.AddColor(192, 255, 255);
            mesh.AddColor(0, 128, 251);
            mesh.CreateZAverage(0, 100);
            mesh.EnableAllContinue(true);

            List<GradientColorItem> items = mesh.Generate(dMin, dMax);

            foreach (GradientColorItem item in items)
            {
                int bContnue = item.Smooth == GradientColorItem.SmoothMode.M ? 1 : 0;
                strbColors.AppendLine($"{item.Z},{item.R},{item.G},{item.B},{item.T},{bContnue}");
            }
            if (strbColors.Length > 0)
            {
                viewer.Geo.SetPointsColor(strbColors.ToString().Trim(), zColorSize, zColorSize);
            }
            return true;
        }

        /// <summary>
        /// 清除线类图元个性
        /// </summary>
        /// <param name="sender">事件按钮</param>
        /// <param name="e">事件参数</param>
        private void tsbClearCurveProperty_Click(object sender, EventArgs e)
        {
            ToolClearCurveProperty();
        }

        public void ToolClearCurveProperty()
        {
            viewer.ActiveTool = DrawToolType.CurvePropertyClear;
        }

        /// <summary>
        /// 设置线类图元个性
        /// </summary>
        /// <param name="sender">事件按钮</param>
        /// <param name="e">事件参数</param>
        private void tsbSetCurveProperty_Click(object sender, EventArgs e)
        {
            ToolSetCurveProperty();
        }

        public void ToolSetCurveProperty()
        {
            viewer.ActiveTool = DrawToolType.CurvePropertySet;
        }

        #endregion 个性处理

        /// <summary>
        /// 抗锯齿
        /// </summary>
        /// <param name="sender">事件按钮</param>
        /// <param name="e">事件参数</param>
        private void tsbAntiAlias_CheckStateChanged(object sender, EventArgs e)
        {
            ToolAntiAlias(tsbAntiAlias.Checked);
        }

        /// <summary>
        /// 形状转换为曲线
        /// </summary>
        /// <param name="sender">事件按钮</param>
        /// <param name="e">事件参数</param>
        private void tsbtnShape2Curve_Click(object sender, EventArgs e)
        {
            ToolShape2Curve();
        }

        /// <summary>
        /// 自动调整方向
        /// </summary>
        private void OnAutoAdjustDirection()
        {
            viewer.Geo.AdjustDirectionAutomatically(0);
            viewer.Redraw();
        }

        /// <summary>
        /// 获取当前画布范围的实际范围
        /// </summary>
        /// <returns>范围</returns>
        public GeoSigmaDrawLib.RectangleD GetRealViewRect()
        {
            double left = 0;
            double top = 0;
            double right = 0;
            double bottom = 0;

            viewer.Geo.GetRealViewRect(ref left, ref top, ref right, ref bottom);

            return new GeoSigmaDrawLib.RectangleD(left, top, Math.Abs(right - left), Math.Abs(bottom - top));
        }

        /// <summary>
        /// 设置画布显示的实际范围，这个功能尚无法工作
        /// </summary>
        /// <param name="rect">范围</param>
        public void SetRealViewRect(GeoSigmaDrawLib.RectangleD rect)
        {
            if (rect == null)
            {
                throw new ArgumentNullException(nameof(rect));
            }

            viewer.Geo.SetRealViewRect(rect.Left, rect.Top, rect.Right, rect.Y - rect.Height);
            viewer.Refresh();
        }

        /// <summary>
        /// 图件当前缩放比
        /// </summary>
        public SizeD ScaleSize
        {
            get
            {
                return viewer.Geo.GetScaleSize();
            }

            set
            {
                viewer.Geo.SetScaleSize(value);
            }
        }

        /// <summary>
        /// Mains the view_ form closing.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The e.</param>
        private void MainView_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (viewer.Geo != null && viewer.ActiveTool != DrawToolType.Default)
            {
                this.ToolDefault();
            }
        }

        private void btnMergeCurve_Click(object sender, EventArgs e)
        {
            ToolMergeCurve();
        }

        private void btnJoinCurves_Click(object sender, EventArgs e)
        {
            ToolAutoJoinCurves();
        }

        private void btnFaultBroaden_Click(object sender, EventArgs e)
        {
            ToolFaultBroaden();
        }

        private void btnFaultSimplyfy_Click(object sender, EventArgs e)
        {
            if (btnFaultSimplyfy.Checked)
            {
                ToolFaultSimply();
            }
        }

        /// <summary>
        /// 清理图件内容。
        /// </summary>
        public void ClearAll()
        {
            // ViewControl.Geo.ClearAll(false);
            viewer.Geo.ClearAll(false);
        }

        private FaultEditForm faultEditForm;
        private void btnFaultEdit_Click(object sender, EventArgs e)
        {
            //if (faultEditForm == null) // 防止用户点多次出来多个弹框
            //{
            //    faultEditForm = new FaultEditForm(this);
            //    faultEditForm.TopMost = true;
            //    faultEditForm.Show();
            //    faultEditForm.FormClosed += (s, _) => faultEditForm = null; // 关闭时置 null，为了下次能够启动起来
            //}
        }


        public void ViewExtendWidth()
        {
            viewer.ViewExtendWidth();
        }

        public void ViewExtendCenter()
        {
            viewer.ViewExtendCenter();
        }

        public void AddPictureToWellTrack()
        {
            viewer.AddPictureToWellTrack();
        }

        public void testWellObjProperties()
        {
            //viewer.testGetWellObjectProperties();
        }

        public void SetLockWellHead()
        {
            viewer.SetLockWellHead();
        }
        //public void AddTrack()
        //{
        //    this.viewer.AddTrack();
        //}

        //public void DeleteSelectedWellObject()
        //{
        //    viewer.DeleteSelectedWellObject();
        //}

        List<WellLineTypeItem> GetLineTypeItems()
        {
            List<WellLineTypeItem> items = new List<WellLineTypeItem>();

            var geo = viewer.GetGeoSigma();
            if (geo is GeoSigmaWellPoleXY geoPole)
            {
                if (GeoSigmaWellPoleXY.GetWellCurveLineNames(out string[] names))
                {
                    foreach (var name in names)
                    {
                        int nWidth = 160;
                        int nHeight = 20;
                        Bitmap bitmap = new Bitmap(nWidth, nHeight);
                        Graphics image = Graphics.FromImage(bitmap);
                        IntPtr hdc = image.GetHdc();
                        if (!GeoSigmaWellPoleXY.GetDrawWellCurveLine(name, hdc, nWidth, nHeight))
                        {
                            continue;
                        }

                        var item = new WellLineTypeItem();
                        item.Name = name;
                        item.Image = bitmap;
                        items.Add(item);

                        image.ReleaseHdc();
                    }
                }
            }

            return items;
        }

        public void TestWellTrack()
        {
            //WellTrack track = new WellTrack();

            //var form = new WellTrackPropertyForm();
            //form.SelectObject(track);
            //form.Show();
        }

        public void TestCurveTrack()
        {
            TestTrack<WellCurveTrack>("E:/Downloads/curveTrack_jsonfile.json");
        }

        public void TestDepthTrack()
        {
            //TestTrack<WellDepthTrack>("E:/Downloads/depthTrack_JSONFile.json");
        }

        private void TestTrack<T>(string path)
            where T : class, new()
        {
            //string str = File.ReadAllText(path);
            //JObject jsonObj = JObject.Parse(str);
            //T wellTrack = WellSerializer.Deserialize<T>(jsonObj);


            //var form = new WellTrackPropertyForm();
            //form.SelectObject(wellTrack);
            //form.Show();
        }

    }
}