using Resources;
using SmartCoalApplication.Annotation;
using SmartCoalApplication.Annotation.Command;
using SmartCoalApplication.Annotation.Enum;
using SmartCoalApplication.Annotation.FieldView;
using SmartCoalApplication.Annotation.Label;
using SmartCoalApplication.Annotation.Measure;
using SmartCoalApplication.Annotation.Other;
using SmartCoalApplication.Base;
using SmartCoalApplication.Base.Enum;
using SmartCoalApplication.Base.SettingModel;
using SmartCoalApplication.Core.DbOpreate.DbModel;
using SmartCoalApplication.Core.Threading;
using SmartCoalApplication.SystemLayer;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Windows.Forms;

namespace SmartCoalApplication.Core
{
    public class DocumentView : UserControl,ISurfaceBox, DocumentDirtyObserver
    {
        #region 控件

        /// <summary>
        /// 【标注、测量、视场、其它】当前激活的工具
        /// </summary>
        public DrawToolType activeTool;

        /// <summary>
        /// 【标注、测量】用于保存测量、标注等的历史记录，用于撤销
        /// </summary>
        public UndoManager undoManager;

        /// <summary>
        /// 【标注、测量】list of draw objects
        /// </summary>
        private GraphicsList graphicsList;

        private IContainer components = null;
        /// <summary>
        /// 左侧刻度标尺
        /// </summary>
        public Ruler leftRuler;
        /// <summary>
        /// 中心画布
        /// </summary>
        public PanelEx panel;
        /// <summary>
        /// 顶部刻度标尺
        /// </summary>
        public Ruler topRuler;
        /// <summary>
        /// 右键菜单
        /// </summary>
        private ContextMenuStrip contextMenuStrip1;
        private ToolStripMenuItem toolStripMenuItem1;
        private ToolStripMenuItem toolStripMenuItem2;
        private ToolStripMenuItem toolStripMenuItem3;
        private ToolStripMenuItem toolStripMenuItem4;
        #endregion

        private bool raiseFirstInputAfterGotFocus = false;
        private int refreshSuspended = 0;
        private bool hookedMouseEvents = false;
        public bool previewMeasure = false;

        private static Base.WeakReference<Surface> doubleBufferSurfaceWeakRef = null;
        private Surface doubleBufferSurface = null;
        /// <summary>
        /// 绘制线程
        /// </summary>
        private Threading.ThreadPool threadPool = new Threading.ThreadPool();
        private RenderContext renderContext;

        /// <summary>
        /// 换算完的标尺信息，包含所有系统内得单位
        /// </summary>
        public Dictionary<MeasurementUnit, double> rules = new Dictionary<MeasurementUnit, double>();
        public mic_rulers xmlSaveModel;//存储标尺信息（xml或者预览拍摄选中标尺）
        public bool existenceXML = false;//当前图片是否存在对应的xml

        /// <summary>
        /// AppWorkspace接口
        /// </summary>
        private IAppWorkspaceForSurfaceBox appWorkspace;

        /// <summary>
        /// 辅助线的横线和竖线
        /// </summary>
        GraphicsPath path, path1;

        /// <summary>
        /// 初始化标记
        /// </summary>
        private bool initialized;

        public bool auxiliaryLineEnabled = false;

        /// <summary>
        /// 为了保证图片绘制在画布中心
        /// 设置的偏移量
        /// </summary>
        private int offsetW = 0;
        private int offsetH = 0;
        private int offsetHalfW = 0;
        private int offsetHalfH = 0;

        /// <summary>
        /// 满屏网格是否显示，默认不显示
        /// </summary>
        private bool gridLineFullEnabled = false;
        /// <summary>
        /// 网格是否显示，默认不显示
        /// </summary>
        private bool gridLineEnabled = false;
        /// <summary>
        /// 矩形网格是否显示，默认不显示
        /// </summary>
        private bool gridRectangleEnabled = false;
        /// <summary>
        /// 圆形网格是否显示，默认不显示
        /// </summary>
        private bool gridRoundEnabled = false;
        /// <summary>
        /// 十字线是否显示，默认不显示
        /// </summary>
        private bool gridCrossCurveEnabled = false;
        /// <summary>
        /// 视图标尺是否显示，默认显示
        /// </summary>
        private bool rulersEnabled = false;
        /// <summary>
        /// 标记连续绘制
        /// </summary>
        private bool continuousDrawingLabel = false;
        /// <summary>
        /// 测量连续绘制
        /// </summary>
        private bool continuousDrawingMeasure = false;

        /// <summary>
        /// 视场连续绘制
        /// </summary>
        private bool continuousDrawingView = false;
        /// <summary>
        /// 二值提取\连续操作
        /// </summary>
        private bool continuousBinaryAction = false;
        /// <summary>
        /// 实际大小标记
        /// </summary>
        private bool actualsize = false;
        /// <summary>
        /// 合适大小标记
        /// </summary>
        private bool suitableSize = false;
        /// <summary>
        /// 合适高度标记
        /// </summary>
        private bool suitableHeight = false;
        /// <summary>
        /// 合适宽度标记
        /// </summary>
        private bool suitableWidth = false;
        /// <summary>
        /// 锁定扩缩
        /// </summary>
        private bool lockZoom = false;
        /// <summary>
        /// 定倍显示
        /// </summary>
        private bool fixedMultiple = false;
        /// <summary>
        /// 合并视场
        /// </summary>
        private bool mergeFieldOfView = false;
        /// <summary>
        /// 删除视场
        /// </summary>
        private bool deleteFieldOfView = false;
        /// <summary>
        /// 图层及文档信息
        /// </summary>
        private Document document;
        /// <summary>
        /// 图像内存块及其属性
        /// </summary>
        private Surface compositionSurface;
        ///// <summary>
        ///// 【标注、测量】用于保存测量、标注等的历史记录，用于撤销
        ///// </summary>
        //public UndoManager undoManager;
        ///// <summary>
        ///// 【标注、测量】list of draw objects
        ///// </summary>
        //private GraphicsList graphicsList;
        ///// <summary>
        ///// 【标注、测量、视场、其它】当前激活的工具
        ///// </summary>
        //public DrawToolType activeTool;
        /// <summary>
        /// 工具的集合
        /// </summary>
        public Type[] tools;
        /// <summary>
        /// 目前用于修改视场，如果是鼠标保持按下的状态，比如按下不抬起状态，
        /// 按下拖动状态，则不响应修改视场界面的相应numericUpDown等控件的值变化事件，
        /// 以避免事件的冲突
        /// </summary>
        public bool mouseStatus;
        /// <summary>
        /// 待渲染的列表
        /// </summary>
        private SurfaceBoxRendererList rendererList;
        private SurfaceBoxBaseRenderer baseRenderer;
        /// <summary>
        /// 窗体状态
        /// </summary>
        private FormWindowState oldWindowState = FormWindowState.Minimized;
        /// <summary>
        /// 缩放比例
        /// </summary>
        private ScaleFactor scaleFactor = new ScaleFactor(1, 1);
        /// <summary>
        /// 每像素多少微米
        /// </summary>
        private double micronRatio;
        /// <summary>
        /// 是否允许像素跟踪
        /// </summary>
        public bool pixelTrackingEnabled = true;
        /// <summary>
        /// 是否允许刷新公共的底部的放大缩小的进度条和值
        /// </summary>
        public bool refueshZoomTrackValue = true;
        private int toolNumber = -1;
        /// <summary>
        /// 如果是false，则是弹窗的DocumentWorkspaceWindow
        /// </summary>
        public bool rightDown = true;
        /// <summary>
        /// ctrl按下事件
        /// </summary>
        public bool controlPress = false;
        /// <summary>
        /// 在toolPointer的工具下，是否绘制鼠标划选的矩形
        /// </summary>
        public bool drawRectangle = false;
        /// <summary>
        /// 在toolPointer的工具下，鼠标划选的矩形
        /// </summary>
        public Rectangle rectangle;

        /// <summary>
        /// 当前的视场行为标记，合并或删除
        /// </summary>
        private CombineMode combineMode = CombineMode.Union;

        public bool keepDraw = true;

        /// <summary>
        /// 结果页面标尺信息
        /// </summary>
        public double unitNum = 1;

        public string aliasName;

        public int decimalPlaces = 2;

        #region 直方图操作数据缓存
        /// <summary>
        /// 亮度
        /// </summary>
        private double histogramBeta = -0.5;
        /// <summary>
        /// 对比度
        /// </summary>
        private double histogramAlpha = 1.0;
        /// <summary>
        /// gamma值
        /// </summary>
        private double histogramGamma = 1.0;
        /// <summary>
        /// 最佳算法的数值，范围0-499
        /// </summary>
        private int histogramPercent = 200;
        /// <summary>
        /// 是否选中了log
        /// </summary>
        private bool histogramLogEnabled;
        /// <summary>
        /// 是否选中了skip
        /// </summary>
        private bool histogramSkipEnabled;

        public Bitmap BoxBitmap;

        /// <summary>
        /// 辅助线线条样式
        /// </summary>
        public int girdLineStyle = 0;

        /// <summary>
        /// 辅助线颜色
        /// </summary>
        public int girdLineColour = 1;

        /// <summary>
        /// 辅助线线宽
        /// </summary>
        public int girdLineWidth = 5;

        #endregion

        #region 直方图操作数据缓存
        /// <summary>
        /// 亮度
        /// </summary>
        public double HistogramBeta
        {
            set
            {
                this.histogramBeta = value;
            }
            get
            {
                return this.histogramBeta;
            }
        }

        /// <summary>
        /// 对比度
        /// </summary>
        public double HistogramAlpha
        {
            set
            {
                this.histogramAlpha = value;
            }
            get
            {
                return this.histogramAlpha;
            }
        }

        public double HistogramGamma
        {
            set
            {
                this.histogramGamma = value;
            }
            get
            {
                return this.histogramGamma;
            }
        }

        public int HistogramPercent
        {
            set
            {
                this.histogramPercent = value;
            }
            get
            {
                return this.histogramPercent;
            }
        }

        public bool HistogramLogEnabled
        {
            set
            {
                this.histogramLogEnabled = value;
            }
            get
            {
                return this.histogramLogEnabled;
            }
        }

        public bool HistogramSkipEnabled
        {
            set
            {
                this.histogramSkipEnabled = value;
            }
            get
            {
                return this.histogramSkipEnabled;
            }
        }
        #endregion

        public DocumentView()
        {
            InitializeComponent();
            this.document = null;
            this.compositionSurface = null;
            this.panel.ScaleFactor = this.scaleFactor;
            this.panel.Paint += new PaintEventHandler(this.panelPaint);
            this.panel.MouseMove += new MouseEventHandler(this.MouseEvent_Move);
            this.panel.MouseDown += new MouseEventHandler(this.MouseEvent_Down);
            this.panel.MouseUp += new MouseEventHandler(this.MouseEvent_Up);
            this.panel.MouseClick += new MouseEventHandler(this.MouseEvent_Click);
            this.panel.MouseDoubleClick += new MouseEventHandler(this.MouseEvent_DoubleClick);

            this.rendererList = new SurfaceBoxRendererList(this.panel.Size, this.panel.Size);
            this.rendererList.Invalidated += new InvalidateEventHandler(Renderers_Invalidated);
            this.baseRenderer = new SurfaceBoxBaseRenderer(this.rendererList, null);
            this.rendererList.Add(this.baseRenderer, false);

            this.initialized = true;
        }

        public OpenCvSharp.Mat OldMat
        {
            get
            {
                //备注：待调试->>200827 add by scc
                if (this.CompositionSurface != null)
                    return OpenCvSharp.Extensions.BitmapConverter.ToMat(this.CompositionSurface.Thumborigin/*CreateAliasedBitmap()*/);
                else
                    return null;
            }
        }

        public OpenCvSharp.Mat BoxMat
        {
            get
            {
                //备注：待调试
                //if (this.AppWorkspace.ActiveDocumentWorkspace != null)
                //{
                return OpenCvSharp.Extensions.BitmapConverter.ToMat(this.BoxBitmap);
                //}
            }
        }

        public Rectangle DrawRectangle
        {
            get
            {
                return this.rectangle;
            }

            set
            {
                this.rectangle = value;
            }
        }

        public bool DrawRectangleFlag
        {
            get
            {
                return this.drawRectangle;
            }
            set
            {
                this.drawRectangle = value;
            }
        }

        void AdjustRendering()
        {
            Size docSize;

            if (this.GraphicsList != null)
            {
                docSize = this.GraphicsList.GetSize();
                //AutoScrollMinSize = docSize;
            }
            else
            {
                //AutoScrollMinSize = new Size(0, 0);
            }
            Invalidate();
        }

        public CombineMode CombineMode
        {
            get
            {
                return this.combineMode;
            }
            set
            {
                this.combineMode = value;
            }
        }

        public Surface CompositionSurface
        {
            get
            {
                return this.compositionSurface;
            }
            set
            {
                if (value != null)
                {
                    this.compositionSurface = value;
                    this.Refresh();
                }
            }
        }

        public void ResetBoxBitmap()
        {
            this.BoxBitmap = this.CompositionSurface.CreateAliasedBitmap();
        }

        public bool GridLineEnabled
        {
            get
            {
                return this.gridLineEnabled;
            }
            set
            {
                this.gridLineEnabled = value;
            }
        }

        public bool GridLineFullEnabled
        {
            get
            {
                return this.gridLineFullEnabled;
            }
            set
            {
                this.gridLineFullEnabled = value;
            }
        }

        public bool GridRectangleEnabled
        {
            get
            {
                return this.gridRectangleEnabled;
            }
            set
            {
                this.gridRectangleEnabled = value;
            }
        }

        public bool GridRoundEnabled
        {
            get
            {
                return this.gridRoundEnabled;
            }
            set
            {
                this.gridRoundEnabled = value;
            }
        }

        public bool GridCrossCurveEnabled
        {
            get
            {
                return this.gridCrossCurveEnabled;
            }
            set
            {
                this.gridCrossCurveEnabled = value;
            }
        }

        public double MicronRatio
        {
            get
            {
                return this.micronRatio;
            }
            set
            {
                this.micronRatio = value;
            }
        }

        public bool ContinuousDrawingLabel
        {
            get
            {
                return continuousDrawingLabel;
            }
            set
            {
                this.continuousDrawingLabel = value;
            }
        }

        public bool ContinuousDrawingMeasure
        {
            get
            {
                return continuousDrawingMeasure;
            }
            set
            {
                this.continuousDrawingMeasure = value;
            }
        }

        public bool ContinuousDrawingView
        {
            get
            {
                return continuousDrawingView;
            }
            set
            {
                this.continuousDrawingView = value;
            }
        }

        public bool ContinuousBinaryAction
        {
            get
            {
                return continuousBinaryAction;
            }
            set
            {
                this.continuousBinaryAction = value;
            }
        }
        public bool ActualSize
        {
            get
            {
                return actualsize;
            }
            set
            {
                this.actualsize = value;
            }
        }
        public bool SuitableSize
        {
            get
            {
                return suitableSize;
            }
            set
            {
                this.suitableSize = value;
            }
        }
        public bool SuitableWidth
        {
            get
            {
                return suitableWidth;
            }
            set
            {
                this.suitableWidth = value;
            }
        }
        public bool SuitableHeight
        {
            get
            {
                return suitableHeight;
            }
            set
            {
                this.suitableHeight = value;
            }
        }
        public bool LockZoom
        {
            get
            {
                return lockZoom;
            }
            set
            {
                this.lockZoom = value;
            }
        }
        public bool FixedMultiple
        {
            get
            {
                return fixedMultiple;
            }
            set
            {
                this.fixedMultiple = value;
            }
        }
        public bool MergeFieldOfView
        {
            get
            {
                return mergeFieldOfView;
            }
            set
            {
                this.mergeFieldOfView = value;
            }
        }
        public bool DeleteFieldOfView
        {
            get
            {
                return deleteFieldOfView;
            }
            set
            {
                this.deleteFieldOfView = value;
            }
        }

        public bool RulersEnabled
        {
            get
            {
                return rulersEnabled;
            }

            set
            {
                //if (this.rulersEnabled != value)
                {
                    this.rulersEnabled = value;

                    if (this.topRuler != null)
                    {
                        this.topRuler.Enabled = value;
                        this.topRuler.Visible = value;
                    }

                    if (this.leftRuler != null)
                    {
                        this.leftRuler.Enabled = value;
                        this.leftRuler.Visible = value;
                    }

                    this.OnResize(EventArgs.Empty);
                    OnRulersEnabledChanged();
                }
            }
        }

        public SurfaceBoxRendererList RendererList
        {
            get
            {
                return this.rendererList;
            }
        }

        public IAppWorkspaceForSurfaceBox AppWorkspaceTop
        {
            set
            {
                this.appWorkspace = value;
            }
            get
            {
                return this.appWorkspace;
            }
        }

        /// <summary>
        /// 初始化工具
        /// </summary>
        protected void InitToolsAndManager()
        {
            //TODO 全局判断 
            activeTool = appWorkspace.GetDrawToolType();

            // 创建graphic list
            // 一是用于存储，二是用于调整层级
            GraphicsList = new GraphicsList(this);
            // 创建管理器，用于前进后退
            undoManager = new UndoManager(GraphicsList);
            // init Tools
            //tools = new Tool[(int)DrawToolType.NumberOfDrawTools];
            tools = new Type[(int)DrawToolType.NumberOfDrawTools];
            tools[(int)DrawToolType.Pointer] = typeof(ToolPointer);

            //
            //测量
            //
            tools[(int)DrawToolType.MeasureLine] = typeof(ToolMeasureLine);
            tools[(int)DrawToolType.MeasureHLine] = typeof(ToolMeasureHLine);
            tools[(int)DrawToolType.MeasureVLine] = typeof(ToolMeasureVLine);

            tools[(int)DrawToolType.DrawLine] = typeof(ToolLine);

            //
            //视场
            //
            tools[(int)DrawToolType.ViewRectangle] = typeof(ToolViewRectangle);
            tools[(int)DrawToolType.MoveMode] = typeof(PanTool);
        }

        public DrawToolType ActiveTool
        {
            get => this.activeTool;
            set
            {
                tools[(int)activeTool].InvokeMember("beginWithNewObject",
                          BindingFlags.Public |
                          BindingFlags.Static |
                          BindingFlags.InvokeMethod,
                          null,
                          null,
                          new object[0] { });
                //tools[(int)this.activeTool].beginWithNewObject();
                this.activeTool = value;
                appWorkspace.SetDrawToolType(this.activeTool);
            }
        }

        public GraphicsList GraphicsList
        {
            get
            {
                return graphicsList;
            }
            set
            {
                graphicsList = value;
                if (this.GraphicsList != null)
                {
                    this.AdjustRendering();
                    //this.graphicsList.AddObserver(this);
                }
            }
        }

        /// <summary>
        /// 添加到标注测量历史
        /// </summary>
        /// <param name="c"></param>
        public void AddCommandToHistory(Command c)
        {
            this.undoManager.AddCommandToHistory(c);
        }

        /// <summary>
        /// 初始化标注测量管理
        /// </summary>
        public void ResetUndoManager()
        {
            this.undoManager = new UndoManager(this.GraphicsList);
        }

        public MeasurementUnit Units
        {
            get
            {
                return this.leftRuler.MeasurementUnit;
            }

            set
            {
                OnUnitsChanging();
                this.leftRuler.MeasurementUnit = value;
                this.topRuler.MeasurementUnit = value;
                DocumentMetaDataChangedHandler(this, EventArgs.Empty);
                OnUnitsChanged();
            }
        }

        protected virtual void OnUnitsChanging()
        {
        }

        protected virtual void OnUnitsChanged()
        {
        }

        public bool DrawGrid
        {
            get
            {
                return true;
            }

            set
            {
                /**
                if (this.gridRenderer.Visible != value)
                {
                    this.gridRenderer.Visible = value;
                    OnDrawGridChanged();
                }**/
            }
        }

        [Browsable(false)]
        public override bool Focused
        {
            get
            {
                return base.Focused || panel.Focused || leftRuler.Focused || topRuler.Focused;
            }
        }

        private void Renderers_Invalidated(object sender, InvalidateEventArgs e)
        {
            Rectangle rect = SurfaceToClient(e.InvalidRect);
            rect.Inflate(1, 1);
            Invalidate(rect);
        }

        /// <summary>
        /// 计算像素跟踪的点
        /// </summary>
        /// <param name="point"></param>
        /// <returns></returns>
        public Point CalcPixelPoint(Point point)
        {
            Rectangle rc = this.panel.ClientRectangle;
            int width = (int)(this.compositionSurface.Width * this.scaleFactor.Ratio);
            int height = (int)(this.compositionSurface.Height * this.scaleFactor.Ratio);
            int x = (rc.Width < width) ? this.panel.AutoScrollPosition.X + offsetHalfW : (rc.Width - width) / 2;
            int y = (rc.Height < height) ? this.panel.AutoScrollPosition.Y + offsetHalfH : (rc.Height - height) / 2;
            point.X -= x;
            point.Y -= y;
            return this.ScaleFactor.UnscalePoint(point);
        }

        public Surface GetDoubleBuffer(Size size)
        {
            Surface localDBSurface = null;
            Size oldSize = new Size(0, 0);

            // If we already have a double buffer surface reference, but if that surface
            // is already disposed then don't worry about it.
            if (this.doubleBufferSurface != null && this.doubleBufferSurface.IsDisposed)
            {
                oldSize = this.doubleBufferSurface.Size;
                this.doubleBufferSurface = null;
            }

            // If we already have a double buffer surface reference, but if that surface
            // is too small, then nuke it.
            if (this.doubleBufferSurface != null &&
                (this.doubleBufferSurface.Width < size.Width || this.doubleBufferSurface.Height < size.Height))
            {
                oldSize = this.doubleBufferSurface.Size;
                this.doubleBufferSurface.Dispose();
                this.doubleBufferSurface = null;
                doubleBufferSurfaceWeakRef = null;
            }

            // If we don't have a double buffer, then we'd better get one.
            if (this.doubleBufferSurface != null)
            {
                // Got one!
                localDBSurface = this.doubleBufferSurface;
            }
            else if (doubleBufferSurfaceWeakRef != null)
            {
                // First, try to get the one that's already shared amongst all SurfaceBox instances.
                localDBSurface = doubleBufferSurfaceWeakRef.Target;

                // If it's disposed, then forget about it.
                if (localDBSurface != null && localDBSurface.IsDisposed)
                {
                    oldSize = localDBSurface.Size;
                    localDBSurface = null;
                    doubleBufferSurfaceWeakRef = null;
                }
            }

            // Make sure the surface is big enough.
            if (localDBSurface != null && (localDBSurface.Width < size.Width || localDBSurface.Height < size.Height))
            {
                oldSize = localDBSurface.Size;
                localDBSurface.Dispose();
                localDBSurface = null;
                doubleBufferSurfaceWeakRef = null;
            }

            // So, do we have a surface? If not then we'd better make one.
            if (localDBSurface == null)
            {
                Size newSize = new Size(Math.Max(size.Width, oldSize.Width), Math.Max(size.Height, oldSize.Height));
                localDBSurface = new Surface(newSize.Width, newSize.Height);
                doubleBufferSurfaceWeakRef = new Base.WeakReference<Surface>(localDBSurface);
            }

            this.doubleBufferSurface = localDBSurface;
            Surface window = localDBSurface.CreateWindow(0, 0, size.Width, size.Height);
            return window;
        }

        private class RenderContext
        {
            public Surface[] windows;
            public Point[] offsets;
            public Rectangle[] rects;
            public DocumentView owner;
            public WaitCallback waitCallback;

            public void RenderThreadMethod(object indexObject)
            {
                int index = (int)indexObject;
                this.owner.rendererList.Render(windows[index], offsets[index]);
                this.windows[index].Dispose();
                this.windows[index] = null;
            }
        }

        public unsafe void DrawArea(RenderArgs ra, Point offset)
        {
            if (compositionSurface == null)
            {
                return;
            }

            if (renderContext == null || (renderContext.windows != null && renderContext.windows.Length != Processor.LogicalCpuCount))
            {
                renderContext = new RenderContext();
                //这里需要计算宽高
                renderContext.owner = this;
                renderContext.waitCallback = new WaitCallback(renderContext.RenderThreadMethod);
                renderContext.windows = new Surface[Processor.LogicalCpuCount];
                renderContext.offsets = new Point[Processor.LogicalCpuCount];
                renderContext.rects = new Rectangle[Processor.LogicalCpuCount];
            }

            Utility.SplitRectangle(ra.Bounds, renderContext.rects);

            for (int i = 0; i < renderContext.rects.Length; ++i)
            {
                if (renderContext.rects[i].Width > 0 && renderContext.rects[i].Height > 0)
                {
                    renderContext.offsets[i] = new Point(renderContext.rects[i].X + offset.X, renderContext.rects[i].Y + offset.Y);
                    renderContext.windows[i] = ra.Surface.CreateWindow(renderContext.rects[i]);
                    //renderContext.windows[i] = ra.Surface.CreateWindow(new Rectangle(renderContext.offsets[i], renderContext.rects[i].Size));
                }
                else
                {
                    renderContext.windows[i] = null;
                }
            }

            for (int i = 0; i < renderContext.windows.Length; ++i)
            {
                if (renderContext.windows[i] != null)
                {
                    this.threadPool.QueueUserWorkItem(renderContext.waitCallback, BoxedConstants.GetInt32(i));
                }
            }

            this.threadPool.Drain();
        }

        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);

            // Sometimes OnLoad() gets called *twice* for some reason.
            // See bug #1415 for the symptoms.
            /**if (!this.hookedMouseEvents)
            {
                this.hookedMouseEvents = true;
                foreach (Control c in Controls)
                {
                    HookMouseEvents(c);
                }
            }**/

            this.panel.Select();
        }

        public void HookMouseEvents()
        {
            if (!this.hookedMouseEvents)
            {
                this.hookedMouseEvents = true;
                foreach (Control c in Controls)
                {
                    HookMouseEvents(c);
                }
            }
        }

        public void PerformMouseWheel(Control sender, MouseEventArgs e)
        {
            HandleMouseWheel(sender, e);
        }

        protected override void OnMouseWheel(MouseEventArgs e)
        {
            HandleMouseWheel(this, e);
            base.OnMouseWheel(e);
        }

        /// <summary>
        /// 鼠标滚轮事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected virtual void HandleMouseWheel(Control sender, MouseEventArgs e)
        {
            double docDelta = (double)e.Delta / this.ScaleFactor.Ratio;
            double oldX = this.DocumentScrollPositionF.X;
            double oldY = this.DocumentScrollPositionF.Y;
            double newX;
            double newY;

            if (Control.ModifierKeys == Keys.Shift)
            {
                this.panel.Response = false;
                // scroll horizontally
                newX = this.DocumentScrollPositionF.X - docDelta;
                newY = this.DocumentScrollPositionF.Y;
            }
            else if (Control.ModifierKeys == Keys.None)
            {
                this.panel.Response = true;
                // scroll vertically
                newX = this.DocumentScrollPositionF.X;
                newY = this.DocumentScrollPositionF.Y - docDelta;
            }
            else
            {
                this.panel.Response = false;
                // no change
                newX = this.DocumentScrollPositionF.X;
                newY = this.DocumentScrollPositionF.Y;
            }

            if (newX != oldX || newY != oldY)
            {
                this.DocumentScrollPositionF = new PointF((float)newX, (float)newY);
                UpdateRulerOffsets();
            }
        }

        public bool IsMouseCaptured()
        {
            return panel.Capture || leftRuler.Capture || topRuler.Capture;//this.Capture || 
        }

        /// <summary>
        /// Get or set upper left of scroll location in document coordinates.
        /// </summary>
        [Browsable(false)]
        public PointF DocumentScrollPositionF
        {
            get
            {
                if (this.panel == null)
                {
                    return PointF.Empty;
                }
                else
                {
                    return this.panel.ScrollPosition;
                    //return VisibleDocumentRectangleF.Location;
                }
            }

            set
            {
                if (panel == null)
                {
                    return;
                }
                else
                {
                    this.panel.ScrollPosition = new Point((int)value.X, (int)value.Y);
                }

                /**
                PointF sbClientF = this.panel.SurfaceToClient(value);
                Point sbClient = Point.Round(sbClientF);

                if (this.panel.AutoScrollPosition != new Point(-sbClient.X, -sbClient.Y))
                {
                    this.panel.AutoScrollPosition = sbClient;
                    UpdateRulerOffsets();
                    this.topRuler.Invalidate();
                    this.leftRuler.Invalidate();
                }**/
            }
        }

        public Point PanelScrollPosition
        {
            get
            {
                return this.panel.ScrollPosition;
            }
            set
            {
                this.panel.ScrollPosition = value;
            }
        }

        [Browsable(false)]
        public PointF DocumentCenterPointF
        {
            get
            {
                RectangleF vsb = VisibleDocumentRectangleF;
                PointF centerPt = new PointF((vsb.Left + vsb.Right) / 2, (vsb.Top + vsb.Bottom) / 2);
                return centerPt;
            }

            set
            {
                RectangleF vsb = VisibleDocumentRectangleF;
                PointF newCornerPt = new PointF(value.X - (vsb.Width / 2), value.Y - (vsb.Height / 2));
                this.DocumentScrollPositionF = newCornerPt;
            }
        }

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (this.components != null)
                {
                    this.components.Dispose();
                    this.components = null;
                }

                if (this.compositionSurface != null)
                {
                    this.compositionSurface.Dispose();
                    this.compositionSurface = null;
                }
            }

            base.Dispose(disposing);
        }

        /// <summary>
        /// 缩放比例改变事件
        /// </summary>
        public event EventHandler ScaleFactorChanged;
        protected virtual void OnScaleFactorChanged()
        {
            if (ScaleFactorChanged != null)
            {
                ScaleFactorChanged(this, EventArgs.Empty);
            }
        }

        /// <summary>
        /// 像素网格是否绘制的bool标记改变事件
        /// </summary>
        public event EventHandler DrawGridChanged;
        protected virtual void OnDrawGridChanged()
        {
            if (DrawGridChanged != null)
            {
                DrawGridChanged(this, EventArgs.Empty);
            }
        }

        /// <summary>
        /// 合适大小
        /// </summary>
        public void ZoomToWindow()
        {
            if (this.document != null)
            {
                Rectangle max = ClientRectangleMax;

                ScaleFactor zoom = ScaleFactor.Min(max.Width - 10,
                                                   document.Width,
                                                   max.Height - 10,
                                                   document.Height,
                                                   ScaleFactor.MinValue);

                ScaleFactor min = ScaleFactor.Min(zoom, ScaleFactor.OneToOne);
                this.ScaleFactor = min;
            }
        }

        /// <summary>
        /// 合适宽度
        /// </summary>
        public void ZoomToWidth()
        {
            if (this.document != null)
            {
                Rectangle max = ClientRectangleMax;
                ScaleFactor zoom = ScaleFactor.UseIfValid(max.Width - 40, document.Width, ScaleFactor.MinValue);
                ScaleFactor min = ScaleFactor.Min(zoom, ScaleFactor.OneToOne);
                this.ScaleFactor = min;
            }
        }

        /// <summary>
        /// 合适高度
        /// </summary>
        public void ZoomToHeight()
        {
            if (this.document != null)
            {
                Rectangle max = ClientRectangleMax;
                ScaleFactor zoom = ScaleFactor.UseIfValid(max.Height - 20, document.Height, ScaleFactor.MinValue);
                ScaleFactor min = ScaleFactor.Min(zoom, ScaleFactor.OneToOne);
                this.ScaleFactor = min;
            }
        }

        private double GetZoomInFactorEpsilon()
        {
            double ratio = this.ScaleFactor.Ratio;
            return (ratio + 0.01) / ratio;

            /**
            // Increase ratio by 1 percentage point
            double currentRatio = this.ScaleFactor.Ratio;
            double factor1 = (currentRatio + 0.01) / currentRatio;

            // Increase ratio so that we increase our view by 1 pixel
            double ratioW = (double)(this.panel.Width + 1) / (double)this.compositionSurface.Width;
            double ratioH = (double)(this.panel.Height + 1) / (double)this.compositionSurface.Height;
            double ratio = Math.Max(ratioW, ratioH);
            double factor2 = ratio / currentRatio;

            double factor = Math.Max(factor1, factor2);

            return factor;
            **/
        }

        private double GetZoomOutFactorEpsilon()
        {
            double ratio = this.ScaleFactor.Ratio;
            return (ratio - 0.01) / ratio;
        }

        public virtual void ZoomIn(double factor)
        {
            ZoomInImpl(factor);
        }

        private void ZoomInImpl(double factor)
        {
            PointF centerPt = this.DocumentCenterPointF;

            ScaleFactor oldSF = this.ScaleFactor;
            ScaleFactor newSF = this.ScaleFactor;
            int countdown = 3;

            // At a minimum we want to increase the size of visible document by 1 pixel
            // Figure out what the ratio of ourSize : ourSize+1 is, and start out with that
            double zoomInEps = GetZoomInFactorEpsilon();
            double desiredFactor = Math.Max(factor, zoomInEps);
            double newFactor = desiredFactor;

            // Keep setting the ScaleFactor until it actually 'sticks'
            // Important for certain image sizes where not all zoom levels create distinct
            // screen sizes
            do
            {
                newSF = ScaleFactor.FromDouble(newSF.Ratio * newFactor);
                this.ScaleFactor = newSF;
                --countdown;
                newFactor *= 1.10;
            } while (this.ScaleFactor == oldSF && countdown > 0);

            this.DocumentCenterPointF = centerPt;
        }

        public virtual void ZoomIn()
        {
            ZoomInImpl();
        }

        private void ZoomInImpl()
        {
            PointF centerPt = this.DocumentCenterPointF;

            ScaleFactor oldSF = this.ScaleFactor;
            ScaleFactor newSF = this.ScaleFactor;
            int countdown = ScaleFactor.PresetValues.Length;

            // Keep setting the ScaleFactor until it actually 'sticks'
            // Important for certain image sizes where not all zoom levels create distinct
            // screen sizes
            do
            {
                newSF = newSF.GetNextLarger();
                this.ScaleFactor = newSF;
                --countdown;
            } while (this.ScaleFactor == oldSF && countdown > 0);

            this.DocumentCenterPointF = centerPt;
        }

        public virtual void ZoomOut(double factor)
        {
            ZoomOutImpl(factor);
        }

        private void ZoomOutImpl(double factor)
        {
            PointF centerPt = this.DocumentCenterPointF;

            ScaleFactor oldSF = this.ScaleFactor;
            ScaleFactor newSF = this.ScaleFactor;
            int countdown = 3;

            // At a minimum we want to decrease the size of visible document by 1 pixel (without dividing by zero of course)
            // Figure out what the ratio of ourSize : ourSize-1 is, and start out with that
            double zoomOutEps = GetZoomOutFactorEpsilon();
            double factorRecip = 1.0 / factor;
            double desiredFactor = Math.Min(factorRecip, zoomOutEps);
            double newFactor = desiredFactor;

            // Keep setting the ScaleFactor until it actually 'sticks'
            // Important for certain image sizes where not all zoom levels create distinct
            // screen sizes
            do
            {
                newSF = ScaleFactor.FromDouble(newSF.Ratio * newFactor);
                this.ScaleFactor = newSF;
                --countdown;
                newFactor *= 0.9;
            } while (this.ScaleFactor == oldSF && countdown > 0);

            this.DocumentCenterPointF = centerPt;
        }

        public virtual void ZoomOut()
        {
            ZoomOutImpl();
        }

        private void ZoomOutImpl()
        {
            PointF centerPt = this.DocumentCenterPointF;

            ScaleFactor oldSF = this.ScaleFactor;
            ScaleFactor newSF = this.ScaleFactor;
            int countdown = ScaleFactor.PresetValues.Length;

            // Keep setting the ScaleFactor until it actually 'sticks'
            // Important for certain image sizes where not all zoom levels create distinct
            // screen sizes
            do
            {
                newSF = newSF.GetNextSmaller();
                this.ScaleFactor = newSF;
                --countdown;
            } while (this.ScaleFactor == oldSF && countdown > 0);

            this.DocumentCenterPointF = centerPt;
        }

        [Browsable(false)]
        public ScaleFactor ScaleFactor
        {
            get
            {
                return this.scaleFactor;
            }

            set
            {
                UI.SuspendControlPainting(this);

                ScaleFactor newValue = ScaleFactor.Min(value, ScaleFactor.MaxValue);

                if (newValue == this.scaleFactor &&
                    this.scaleFactor == ScaleFactor.OneToOne)
                {
                    // this space intentionally left blank
                }
                else
                {
                    RectangleF visibleRect = this.VisibleDocumentRectangleF;
                    ScaleFactor oldSF = scaleFactor;
                    scaleFactor = newValue;

                    // This value is used later below to re-center the document on screen
                    PointF centerPt = new PointF(visibleRect.X + visibleRect.Width / 2,
                        visibleRect.Y + visibleRect.Height / 2);

                    if (compositionSurface != null)
                    {
                        Rectangle rc = this.panel.ClientRectangle;
                        int width = (int)(this.compositionSurface.Width * this.scaleFactor.Ratio);
                        int height = (int)(this.compositionSurface.Height * this.scaleFactor.Ratio);
                        if (rc.Width < width || rc.Height < height)
                        {
                            this.panel.AutoScrollMinSize = new Size((int)(this.compositionSurface.Width * scaleFactor.Ratio) + offsetW, (int)(this.compositionSurface.Height * scaleFactor.Ratio) + offsetH);

                            //////求因缩放产生的位移，进行补偿，实现锚点缩放的效果
                            ////VX = (int)((double)x * (ow - pictureBox1.Width) / ow);
                            ////VY = (int)((double)y * (oh - pictureBox1.Height) / oh);
                            ////pictureBox1.Location = new Point(pictureBox1.Location.X + VX, pictureBox1.Location.Y + VY);

                            //this.panel.AutoScrollPosition = new Point((int)(width - rc.Width) / 2 + 150, (int)(height - rc.Height) / 2 + 75);
                            //////this.panel.AutoScrollPosition = sbClient;
                            ////UpdateRulerOffsets();
                            ////this.topRuler.Invalidate();
                            ////this.leftRuler.Invalidate();
                        }
                        else
                        {
                            this.panel.AutoScrollMinSize = new Size((int)(this.compositionSurface.Width * scaleFactor.Ratio), (int)(this.compositionSurface.Height * scaleFactor.Ratio));
                            //this.panel.AutoScrollPosition = new Point((int)(width - rc.Width) / 2 + 0, (int)(height - rc.Height) / 2 + 0);

                            ////UpdateRulerOffsets();
                            ////this.topRuler.Invalidate();
                            ////this.leftRuler.Invalidate();
                        }

                        this.panel.ScaleFactor = this.scaleFactor;
                        if (leftRuler != null)
                        {
                            this.leftRuler.ScaleFactor = scaleFactor;
                        }

                        if (topRuler != null)
                        {
                            this.topRuler.ScaleFactor = scaleFactor;
                        }
                    }

                    // re center ourself
                    RectangleF visibleRect2 = this.VisibleDocumentRectangleF;
                    RecenterView(centerPt);
                }

                this.OnResize(EventArgs.Empty);
                this.OnScaleFactorChanged();

                if (this.appWorkspace != null && refueshZoomTrackValue && this.rightDown)
                {
                    this.appWorkspace.SetZoonTrackValue(newValue);
                }

                if (compositionSurface != null)
                    this.rendererList.DestinationSize = this.scaleFactor.ScaleSize(compositionSurface.Size);

                UI.ResumeControlPainting(this);
                Invalidate(true);
            }
        }

        /// <summary>
        /// Returns a rectangle for the bounding rectangle of what is currently visible on screen,
        /// in document coordinates.
        /// </summary>
        [Browsable(false)]
        public RectangleF VisibleDocumentRectangleF
        {
            get
            {
                Rectangle panelRect = this.panel.RectangleToScreen(this.panel.ClientRectangle); // screen coords coords
                Rectangle docScreenRect = panelRect; // screen coords
                Rectangle docClientRect = RectangleToClient(docScreenRect);
                RectangleF docDocRectF = ClientToDocument(docClientRect);
                return docDocRectF;
            }
        }

        public Rectangle PanelClientRectangle
        {
            get
            {
                return panel.ClientRectangle;
            }
        }

        public int SurfaceScrollableWidth
        {
            get
            {
                return (int)(this.compositionSurface.Width * this.scaleFactor.Ratio);
            }
        }

        public int SurfaceScrollableHeight
        {
            get
            {
                return (int)(this.compositionSurface.Height * this.scaleFactor.Ratio);
            }
        }

        public double ScaleRatio
        {
            get
            {
                return this.scaleFactor.Ratio;
            }
        }

        /// <summary>
        /// Returns a rectangle in <b>screen</b> coordinates that represents the space taken up
        /// by the document that is visible on screen.
        /// </summary>
        [Browsable(false)]
        public Rectangle VisibleDocumentBounds
        {
            get
            {
                // convert coordinates: document -> client -> screen
                return RectangleToScreen(Utility.RoundRectangle(DocumentToClient(VisibleDocumentRectangleF)));
            }
        }

        /// <summary>
        /// Returns a rectangle in client coordinates that denotes the space that the document
        /// may take up. This is essentially the ClientRectangle converted to screen coordinates
        /// and then with the rulers and scrollbars subtracted out.
        /// </summary>
        public Rectangle VisibleViewRectangle
        {
            get
            {
                Rectangle clientRect = this.panel.ClientRectangle;
                Rectangle screenRect = this.panel.RectangleToScreen(clientRect);
                Rectangle ourClientRect = RectangleToClient(screenRect);
                return ourClientRect;
            }
        }

        public Rectangle ClientRectangleMax
        {
            get
            {
                return RectangleToClient(this.panel.RectangleToScreen(this.panel.Bounds));
            }
        }

        public Rectangle ClientRectangleMin
        {
            get
            {
                Rectangle bounds = ClientRectangleMax;
                bounds.Width -= SystemInformation.VerticalScrollBarWidth;
                bounds.Height -= SystemInformation.HorizontalScrollBarHeight;
                return bounds;
            }
        }

        public void SetHighlightRectangle(RectangleF rectF)
        {
            if (rectF.Width == 0 || rectF.Height == 0)
            {
                this.leftRuler.HighlightEnabled = false;
                this.topRuler.HighlightEnabled = false;
            }
            else
            {
                if (this.topRuler != null)
                {
                    this.topRuler.HighlightEnabled = true;
                    this.topRuler.HighlightStart = rectF.Left;
                    this.topRuler.HighlightLength = rectF.Width;
                }

                if (this.leftRuler != null)
                {
                    this.leftRuler.HighlightEnabled = true;
                    this.leftRuler.HighlightStart = rectF.Top;
                    this.leftRuler.HighlightLength = rectF.Height;
                }
            }
        }

        /// <summary>
        /// Gets or sets the Document that is shown through this instance of DocumentView.
        /// </summary>
        /// <remarks>
        /// This property is thread safe and may be called from a non-UI thread. However,
        /// if the setter is called from a non-UI thread, then that thread will block as
        /// the call is marshaled to the UI thread.
        /// </remarks>
        [Browsable(false)]
        public Document Document
        {
            get
            {
                return document;
            }

            set
            {
                if (InvokeRequired)
                {
                    this.Invoke(new Procedure<Document, bool>(DocumentSetImpl), new object[2] { value, true });
                }
                else
                {
                    DocumentSetImpl(value, true);
                }
            }
        }

        private void DocumentSetImpl(Document value, bool toedit)
        {
            this.DoubleBuffered = true;
            SetStyle(ControlStyles.OptimizedDoubleBuffer | ControlStyles.UserPaint | ControlStyles.AllPaintingInWmPaint, true);

            PointF dspf = DocumentScrollPositionF;

            OnDocumentChanging(value);
            SuspendRefresh();

            try
            {
                if (this.document != null)
                {
                    this.document.Invalidated -= Document_Invalidated;
                }

                this.document = value;

                if (document != null)
                {
                    if (this.compositionSurface != null &&
                        this.compositionSurface.Size != document.Size)
                    {
                        this.compositionSurface.Dispose();
                        this.compositionSurface = null;
                    }

                    if (!toedit && this.compositionSurface.Thumborigin != null)
                        document.surface.Thumborigin = OpenCvSharp.Extensions.BitmapConverter.ToBitmap(OpenCvSharp.Extensions.BitmapConverter.ToMat(this.compositionSurface.Thumborigin));
                    this.compositionSurface = document.surface;
                    //生成缩略图
                    this.compositionSurface.CreateThumbnail();
                    //生成原图的备份
                    if (toedit)
                        this.compositionSurface.CreateThumborigin();

                    this.baseRenderer.Source = document.surface;

                    if (this.compositionSurface != null)
                    {
                        this.rendererList.SourceSize = this.compositionSurface.Size;
                        this.rendererList.DestinationSize = this.Size;
                    }

                    this.document.Invalidated += Document_Invalidated;
                }

                Invalidate(true);
                DocumentMetaDataChangedHandler(this, EventArgs.Empty);
                this.OnResize(EventArgs.Empty);
                OnDocumentChanged();
            }
            finally
            {
                ResumeRefresh();
            }

            DocumentScrollPositionF = dspf;
        }

        public bool PanelAutoScroll
        {
            get
            {
                return panel.AutoScroll;
            }

            set
            {
                if (panel.AutoScroll != value)
                {
                    panel.AutoScroll = value;
                }
            }
        }

        private void HookMouseEvents(Control c)
        {

        }

        private void UpdateRulerOffsets()
        {
            this.topRuler.Offset = ScaleFactor.UnscaleScalar(UI.ScaleWidth(-16.0f) - this.panel.Location.X);
            this.topRuler.Update();
            this.leftRuler.Offset = ScaleFactor.UnscaleScalar(0.0f - this.panel.Location.Y);
            this.leftRuler.Update();
        }

        private void DoLayout()
        {
            if (panel.ClientRectangle != new Rectangle(0, 0, 0, 0))
            {
                int newX = panel.AutoScrollPosition.X;
                int newY = panel.AutoScrollPosition.Y;

                if (panel.ClientRectangle.Width > this.panel.Width)
                {
                    newX = panel.AutoScrollPosition.X + ((panel.ClientRectangle.Width) / 2);
                }

                if (panel.ClientRectangle.Height > this.panel.Height)
                {
                    newY = panel.AutoScrollPosition.Y + ((panel.ClientRectangle.Height) / 2);
                }
            }

            //暂时注释掉，因为在预览窗口、位置导航等显示标尺的时候，会闪烁，不知道会不会有啥问题
            this.UpdateRulerOffsets();
            this.UpdateImgLocation();
        }

        private void CheckForFirstInputAfterGotFocus()
        {
            if (this.raiseFirstInputAfterGotFocus)
            {
                this.raiseFirstInputAfterGotFocus = false;
                OnFirstInputAfterGotFocus();
            }
        }

        private void Document_Invalidated(object sender, InvalidateEventArgs e)
        {
            if (this.ScaleFactor == ScaleFactor.OneToOne)
            {
                this.panel.Invalidate(e.InvalidRect);
            }
            else
            {
                Rectangle inflatedInvalidRect = Rectangle.Inflate(e.InvalidRect, 1, 1);
                Rectangle clientRect = this.panel.SurfaceToClient(inflatedInvalidRect);
                Rectangle inflatedClientRect = Rectangle.Inflate(clientRect, 1, 1);
                this.panel.Invalidate(inflatedClientRect);
            }
        }

        public void SuspendRefresh()
        {
            ++this.refreshSuspended;
        }

        public void ResumeRefresh()
        {
            --this.refreshSuspended;
        }

        /// <summary>
        /// 重新设置中心点
        /// </summary>
        /// <param name="newCenter"></param>
        public void RecenterView(PointF newCenter)
        {
            RectangleF visibleRect = VisibleDocumentRectangleF;

            PointF cornerPt = new PointF(
                newCenter.X - (visibleRect.Width / 2),
                newCenter.Y - (visibleRect.Height / 2));

            this.DocumentScrollPositionF = cornerPt;
        }

        /// <summary>
        /// 文档元数据改变事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void DocumentMetaDataChangedHandler(object sender, EventArgs e)
        {
            if (this.document != null)
            {
                this.leftRuler.Dpu = 1 / document.PixelToPhysicalY(1, this.leftRuler.MeasurementUnit);
                this.topRuler.Dpu = 1 / document.PixelToPhysicalY(1, this.topRuler.MeasurementUnit);
            }
        }

        protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
        {
            Keys keyCode = keyData & Keys.KeyCode;

            if (Utility.IsArrowKey(keyData) ||
                keyCode == Keys.Delete ||
                keyCode == Keys.Tab)
            {
                KeyEventArgs kea = new KeyEventArgs(keyData);

                // We only intercept WM_KEYDOWN because WM_KEYUP is not sent!
                switch (msg.Msg)
                {
                    case 0x100: //NativeMethods.WmConstants.WM_KEYDOWN:
                        if (this.ContainsFocus)
                        {
                            OnDocumentKeyDown(kea);
                            //OnDocumentKeyUp(kea);

                            if (Utility.IsArrowKey(keyData))
                            {
                                kea.Handled = true;
                            }
                        }

                        if (kea.Handled)
                        {
                            return true;
                        }

                        break;
                }
            }

            return base.ProcessCmdKey(ref msg, keyData);
        }

        #region 对外的各种事件委托

        public event EventHandler CompositionUpdated;
        private void OnCompositionUpdated()
        {
            if (CompositionUpdated != null)
            {
                CompositionUpdated(this, EventArgs.Empty);
            }
        }

        public event EventHandler RulersEnabledChanged;
        protected void OnRulersEnabledChanged()
        {
            if (RulersEnabledChanged != null)
            {
                RulersEnabledChanged(this, EventArgs.Empty);
            }
        }

        public event EventHandler<EventArgs<Document>> DocumentChanging;
        protected virtual void OnDocumentChanging(Document newDocument)
        {
            if (DocumentChanging != null)
            {
                DocumentChanging(this, new EventArgs<Document>(newDocument));
            }
        }

        public event EventHandler DocumentChanged;
        protected virtual void OnDocumentChanged()
        {
            if (DocumentChanged != null)
            {
                DocumentChanged(this, EventArgs.Empty);
            }
        }

        public event EventHandler FirstInputAfterGotFocus;
        protected virtual void OnFirstInputAfterGotFocus()
        {
            if (FirstInputAfterGotFocus != null)
            {
                FirstInputAfterGotFocus(this, EventArgs.Empty);
            }
        }

        /// <summary>
        /// Occurs when the mouse enters an element of the UI that is considered to be part of
        /// the document space.
        /// </summary>
        public event EventHandler DocumentMouseEnter;
        protected virtual void OnDocumentMouseEnter(EventArgs e)
        {
            if (DocumentMouseEnter != null)
            {
                DocumentMouseEnter(this, e);
            }
        }

        public event EventHandler DocumentMouseLeave;
        protected virtual void OnDocumentMouseLeave(EventArgs e)
        {
            if (DocumentMouseLeave != null)
            {
                DocumentMouseLeave(this, e);
            }
        }

        /// <summary>
        /// Occurs when the mouse or stylus point is moved over the document.
        /// </summary>
        /// <remarks>
        /// Note: This event will always be raised twice in succession. One will provide a 
        /// MouseEventArgs, and the other will provide a StylusEventArgs. It is up to consumers
        /// of this event to decide which one is pertinent and to then filter out the other
        /// type of event.
        /// </remarks>
        public event MouseEventHandler DocumentMouseMove;
        protected virtual void OnDocumentMouseMove(MouseEventArgs e)
        {
            if (DocumentMouseMove != null)
            {
                DocumentMouseMove(this, e);
            }
        }

        /// <summary>
        /// Occurs when the mouse or stylus point is over the document and a mouse button is released
        /// or the stylus is lifted.
        /// </summary>
        /// <remarks>
        /// Note: This event will always be raised twice in succession. One will provide a 
        /// MouseEventArgs, and the other will provide a StylusEventArgs. It is up to consumers
        /// of this event to decide which one is pertinent and to then filter out the other
        /// type of event.
        /// </remarks>
        public event MouseEventHandler DocumentMouseUp;

        protected virtual void OnDocumentMouseUp(MouseEventArgs e)
        {
            CheckForFirstInputAfterGotFocus();

            if (DocumentMouseUp != null)
            {
                DocumentMouseUp(this, e);
            }
        }

        /// <summary>
        /// Occurs when the mouse or stylus point is over the document and a mouse button or
        /// stylus is pressed.
        /// </summary>
        /// <remarks>
        /// Note: This event will always be raised twice in succession. One will provide a 
        /// MouseEventArgs, and the other will provide a StylusEventArgs. It is up to consumers
        /// of this event to decide which one is pertinent and to then filter out the other
        /// type of event.
        /// </remarks>
        public event MouseEventHandler DocumentMouseDown;

        protected virtual void OnDocumentMouseDown(MouseEventArgs e)
        {
            CheckForFirstInputAfterGotFocus();

            if (DocumentMouseDown != null)
            {
                DocumentMouseDown(this, e);
            }
        }

        public event EventHandler DocumentClick;
        protected void OnDocumentClick()
        {
            CheckForFirstInputAfterGotFocus();

            if (DocumentClick != null)
            {
                DocumentClick(this, EventArgs.Empty);
            }
        }

        public event KeyPressEventHandler DocumentKeyPress;
        protected void OnDocumentKeyPress(KeyPressEventArgs e)
        {
            CheckForFirstInputAfterGotFocus();

            if (DocumentKeyPress != null)
            {
                DocumentKeyPress(this, e);
            }
        }

        public event KeyEventHandler DocumentKeyDown;
        protected void OnDocumentKeyDown(KeyEventArgs e)
        {
            CheckForFirstInputAfterGotFocus();

            if (DocumentKeyDown != null)
            {
                DocumentKeyDown(this, e);
            }
        }

        public event KeyEventHandler DocumentKeyUp;
        protected void OnDocumentKeyUp(KeyEventArgs e)
        {
            CheckForFirstInputAfterGotFocus();

            if (DocumentKeyUp != null)
            {
                DocumentKeyUp(this, e);
            }
        }

        #endregion

        #region DocimentView的子控件的事件

        private void Panel_KeyPress(object sender, KeyPressEventArgs e)
        {
            OnDocumentKeyPress(e);
        }

        private void Panel_LostFocus(object sender, EventArgs e)
        {
            this.raiseFirstInputAfterGotFocus = false;
        }

        private void Panel_GotFocus(object sender, EventArgs e)
        {
            this.raiseFirstInputAfterGotFocus = true;
        }

        private void Panel_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyValue == 17)
            {
                this.controlPress = true;
            }

            CheckForFirstInputAfterGotFocus();

            OnDocumentKeyDown(e);

            if (!e.Handled)
            {
                PointF oldPt = this.DocumentScrollPositionF;
                PointF newPt = oldPt;
                RectangleF vdr = VisibleDocumentRectangleF;

                switch (e.KeyData)
                {
                    case Keys.Next:
                        newPt.Y += vdr.Height;
                        break;

                    case (Keys.Next | Keys.Shift):
                        newPt.X += vdr.Width;
                        break;

                    case Keys.Prior:
                        newPt.Y -= vdr.Height;
                        break;

                    case (Keys.Prior | Keys.Shift):
                        newPt.X -= vdr.Width;
                        break;

                    case Keys.Home:
                        if (oldPt.X == 0)
                        {
                            newPt.Y = 0;
                        }
                        else
                        {
                            newPt.X = 0;
                        }
                        break;

                    case Keys.End:
                        if (vdr.Right < this.document.Width - 1)
                        {
                            newPt.X = this.document.Width;
                        }
                        else
                        {
                            newPt.Y = this.document.Height;
                        }
                        break;

                    default:
                        break;
                }

                if (newPt != oldPt)
                {
                    DocumentScrollPositionF = newPt;
                    e.Handled = true;
                }
            }
        }

        private void Panel_Scroll(object sender, System.Windows.Forms.ScrollEventArgs e)
        {
            OnScroll(e);
            UpdateRulerOffsets();
        }

        private void Panel_KeyUp(object sender, KeyEventArgs e)
        {
            this.controlPress = false;
            OnDocumentKeyUp(e);
        }

        /// <summary>
        /// 鼠标按下事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void MouseEvent_Down(object sender, MouseEventArgs e)
        {
            if(keepDraw)
            {
                //tools[(int)activeTool].OnMouseDown(this, e);
                
                    tools[(int)activeTool].InvokeMember("OnMouseDown",
                              BindingFlags.Public |
                              BindingFlags.Static |
                              BindingFlags.InvokeMethod,
                              null,
                              null,
                              new object[2] { this, e });
                
                
                if (this.appWorkspace != null)
                {
                    this.appWorkspace.SetDrawNodes();
                    //this.appWorkspace.RefreshCameraPriview();
                }
            }
        }

        //private static extern int mouse_event(int dwFlags, int dx, int dy, int cButtons, int a);

        public void MouseEvent_Del(object sender, MouseEventArgs e)
        {
            try
            {
                tools[(int)activeTool].InvokeMember("beginWithNewObject",
                      BindingFlags.Public |
                      BindingFlags.Static |
                      BindingFlags.InvokeMethod,
                      null,
                      null,
                      new object[0] { });
            }
            catch (Exception ex)
            {
            }

            tools[0].InvokeMember("OnDelKeyDown",
                BindingFlags.Public |
                BindingFlags.Static |
                BindingFlags.InvokeMethod,
                null,
                null,
                new object[2] { this, e });

            //tools[(int)activeTool].OnDelKeyDown(this, e);
            //if (this.appWorkspace != null)
            //    this.appWorkspace.RefreshLabelListDialog();
        }

        /// <summary>
        /// 鼠标移动事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void MouseEvent_Move(object sender, MouseEventArgs e)
        {
            //
            // 像素跟踪，如果AppWorkspace不等于null，坐标不超范围，则设置像素跟踪
            //
            if (this.AppWorkspaceTop != null && this.compositionSurface != null && this.pixelTrackingEnabled)
            //&& e.Location.X>=0 && e.Location.Y>=0 
            //&& e.Location.X<=this.Surface.Width 
            //&& e.Location.Y <= this.Surface.Height)
            {
                //this.AppWorkspaceTop.SetImageAndData(this.ScaleFactor.UnscalePoint(e.Location));
                this.AppWorkspaceTop.SetImageAndData(this.CalcPixelPoint(e.Location));
            }

            //
            // 是否绘制辅助线
            //
            if (this.auxiliaryLineEnabled)
            {
                path = new GraphicsPath();
                path.AddLine(new Point(0, e.Y), new Point(Width, e.Y));
                path1 = new GraphicsPath();
                path1.AddLine(new Point(e.X, 0), new Point(e.X, Height));
                this.Refresh();
            }

            //
            // 处理标注测量
            //

            //右键绘制 是个坑 以后须谨慎

            if (!initialized)
                return;
            if (e.Button == MouseButtons.Left || e.Button == MouseButtons.Right || e.Button == MouseButtons.None)
               
                    tools[(int)activeTool].InvokeMember("OnMouseMove",
                          BindingFlags.Public |
                          BindingFlags.Static |
                          BindingFlags.InvokeMethod,
                          null,
                          null,
                          new object[2] { this, e });
                
                
            //tools[(int)activeTool].OnMouseMove(this, e);
            else
                this.Cursor = Cursors.Default;
        }

        /// <summary>
        /// 鼠标抬起事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void MouseEvent_Up(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left || e.Button == MouseButtons.Right)
               
                tools[(int)activeTool].InvokeMember("OnMouseUp",
                          BindingFlags.Public |
                          BindingFlags.Static |
                          BindingFlags.InvokeMethod,
                          null,
                          null,
                          new object[2] { this, e });
            //tools[(int)activeTool].OnMouseUp(this, e);
            if (this.appWorkspace != null)
            {
                //this.appWorkspace.RefreshLabelListDialog();
                this.appWorkspace.RefreshListView();
                //this.appWorkspace.RefreshOpticalDensity();
            }
        }

        /// <summary>
        /// 鼠标单击事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void MouseEvent_Click(object sender, MouseEventArgs e)
        {
            
                tools[(int)activeTool].InvokeMember("OnMouseClick",
                          BindingFlags.Public |
                          BindingFlags.Static |
                          BindingFlags.InvokeMethod,
                          null,
                          null,
                          new object[2] { this, e });
            
            
            //tools[(int)activeTool].OnMouseClick(this, e);
        }

        /// <summary>
        /// 鼠标双击事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void MouseEvent_DoubleClick(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left && e.Clicks == 2)
            {
                if (this.controlPress)
                {
                    List<DrawObject> list = this.graphicsList.GetDrawToolTypeList(DrawToolType.ImageCut);
                    if (list != null && list.Count > 0)
                    {
                        Point ene = GetScalePoint(e.Location);
                        RectangleF rect = list[0].Rectangle;
                        if (ene.X > rect.X && ene.X < (rect.X + rect.Width) && ene.Y > rect.Y && ene.Y < (rect.Y + rect.Height))
                        {
                            //this.appWorkspace.CopyAndPasteByControlAndDoubleClick();
                        }
                    }
                    this.controlPress = false;
                }
                else
                {
                   
                    tools[(int)activeTool].InvokeMember("OnMouseLeftDoubleClick",
                          BindingFlags.Public |
                          BindingFlags.Static |
                          BindingFlags.InvokeMethod,
                          null,
                          null,
                          new object[2] { this, e });
                }
            }
            //tools[(int)activeTool].OnMouseLeftDoubleClick(this, e);
        }

        /// <summary>
        /// 样式信息
        /// </summary>
        /// <summary>
        /// 绘制事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void panelPaint(object sender, PaintEventArgs e)
        {
            if (compositionSurface != null)
            {
                //
                // 以下是计算绘制图片的位置和大小并绘制图片
                //
                Rectangle rc = this.panel.ClientRectangle;
                int width = (int)(this.compositionSurface.Width * this.scaleFactor.Ratio);
                int height = (int)(this.compositionSurface.Height * this.scaleFactor.Ratio);
                int x = (rc.Width < width) ? this.panel.AutoScrollPosition.X + offsetHalfW : (rc.Width - width) / 2;
                int y = (rc.Height < height) ? this.panel.AutoScrollPosition.Y + offsetHalfH : (rc.Height - height) / 2;

                if (this.compositionSurface.CreateAliasedBitmap() != null)
                {
                    using (Surface doubleBuffer = GetDoubleBuffer(new Size((rc.Width < width) ? rc.Width : width, (rc.Height < height) ? rc.Height : height)))
                    {
                        using (RenderArgs renderArgs = new RenderArgs(doubleBuffer))
                        {
                            DrawArea(renderArgs, new Point((rc.Width < width) ? -x : 0, (rc.Height < height) ? -y : 0));
                            if (m_center)
                            {
                                e.Graphics.DrawImage(doubleBuffer.CreateAliasedBitmap(),
                                (rc.Width < width) ? 0 : (rc.Width - width) / 2,
                                (rc.Height < height) ? 0 : (rc.Height - height) / 2,
                                (rc.Width < width) ? rc.Width : width, (rc.Height < height) ? rc.Height : height);
                            }
                            else
                            {
                                e.Graphics.DrawImage(doubleBuffer.CreateAliasedBitmap(),
                                m_pLeft,
                                m_pTop,
                                (rc.Width < width) ? rc.Width : width, (rc.Height < height) ? rc.Height : height);
                            }
                        }
                    }
                }

                //
                // 绘制选择的矩形
                //
                if (drawRectangle)
                {
                    e.Graphics.DrawRectangle(new Pen(Color.Black), this.DrawRectangle);
                }

                //
                // 以下是绘制辅助线
                //
                if (this.auxiliaryLineEnabled)
                {
                    if (path != null && path1 != null)
                    {
                        Pen linePen = new Pen(Color.FromArgb(girdLineColour), girdLineWidth);
                        linePen.DashStyle = (DashStyle)this.girdLineStyle;

                        e.Graphics.DrawPath(linePen, path);
                        e.Graphics.DrawPath(linePen, path1);
                    }
                }

                //
                // 以下是绘制网格、标注、测量、视场等开始
                //
                e.Graphics.TranslateTransform(x, y);
                e.Graphics.ScaleTransform((float)this.scaleFactor.Ratio, (float)this.scaleFactor.Ratio);

                //
                // 以下是绘制标注、测量、视场
                //
                if (graphicsList != null)
                {
                    graphicsList.Draw(e.Graphics);
                }

                e.Graphics.ScaleTransform(1 / (float)this.scaleFactor.Ratio, 1 / (float)this.scaleFactor.Ratio);
                e.Graphics.TranslateTransform(-x, -y);
            }
        }

        #endregion

        /// <summary>
        /// 获取panel可见位置的图片
        /// </summary>
        /// <returns></returns>
        public Bitmap GetClientRangePic()
        {
            Rectangle rc = this.panel.ClientRectangle;
            int width = (int)(this.compositionSurface.Width * this.scaleFactor.Ratio);
            int height = (int)(this.compositionSurface.Height * this.scaleFactor.Ratio);
            int x = (rc.Width < width) ? this.panel.AutoScrollPosition.X + offsetHalfW : (rc.Width - width) / 2;
            int y = (rc.Height < height) ? this.panel.AutoScrollPosition.Y + offsetHalfH : (rc.Height - height) / 2;

            if (this.compositionSurface.CreateAliasedBitmap() != null)
            {
                using (Surface doubleBuffer = GetDoubleBuffer(new Size((rc.Width < width) ? rc.Width : width, (rc.Height < height) ? rc.Height : height)))
                {
                    using (RenderArgs renderArgs = new RenderArgs(doubleBuffer))
                    {
                        DrawArea(renderArgs, new Point((rc.Width < width) ? -x : 0, (rc.Height < height) ? -y : 0));
                        return doubleBuffer.CreateAliasedBitmap();
                    }
                }
            }
            return this.compositionSurface.CreateAliasedBitmap();
        }

        #region DocumentView的事件

        protected override void OnLayout(LayoutEventArgs e)
        {
            DoLayout();
            base.OnLayout(e);
        }

        public new void Focus()
        {
            this.panel.Focus();
        }

        protected override void OnResize(EventArgs e)
        {
            Form parentForm = ParentForm;

            if (parentForm != null)
            {
                if (parentForm.WindowState != this.oldWindowState)
                {
                    PerformLayout();
                }

                this.oldWindowState = parentForm.WindowState;
            }

            base.OnResize(e);
            DoLayout();
        }

        #endregion

        #region 坐标转换相关方法

        public PointF MouseToDocumentF(Control sender, Point mouse)
        {
            Point screenPoint = sender.PointToScreen(mouse);
            Point sbClient = this.panel.PointToClient(screenPoint);
            PointF docPoint = this.panel.ClientToSurface(new PointF(sbClient.X, sbClient.Y));
            return docPoint;
        }

        public Point MouseToDocument(Control sender, Point mouse)
        {
            Point screenPoint = sender.PointToScreen(mouse);
            Point sbClient = this.panel.PointToClient(screenPoint);
            Point docPoint = Point.Truncate(this.panel.ClientToSurface(sbClient));
            return docPoint;
        }

        public PointF ClientToDocument(Point clientPt)
        {
            Point screen = PointToScreen(clientPt);
            Point sbClient = this.panel.PointToClient(screen);
            return this.panel.ClientToSurface(sbClient);
        }

        public PointF ScreenToDocument(PointF screen)
        {
            Point offset = this.panel.PointToClient(new Point(0, 0));
            return this.panel.ClientToSurface(new PointF(screen.X + (float)offset.X, screen.Y + (float)offset.Y));
        }

        public Point ScreenToDocument(Point screen)
        {
            Point offset = this.panel.PointToClient(new Point(0, 0));
            return this.panel.ClientToSurface(new Point(screen.X + offset.X, screen.Y + offset.Y));
        }

        public PointF ClientToSurface(PointF clientPt)
        {
            return this.panel.ClientToSurface(clientPt);
        }

        public PointF DocumentToClient(PointF documentPt)
        {
            PointF sbClient = this.panel.SurfaceToClient(documentPt);
            Point screen = this.panel.PointToScreen(Point.Round(sbClient));
            return PointToClient(screen);
        }

        public RectangleF ClientToDocument(Rectangle clientRect)
        {
            Rectangle screen = RectangleToScreen(clientRect);
            screen.X = screen.X + offsetW;
            screen.Y = screen.Y + offsetH;
            Rectangle sbClient = this.panel.RectangleToClient(screen);
            return this.panel.ClientToSurface((RectangleF)sbClient);
        }

        public RectangleF DocumentToClient(RectangleF documentRect)
        {
            RectangleF sbClient = this.panel.SurfaceToClient(documentRect);
            Rectangle screen = this.panel.RectangleToScreen(Utility.RoundRectangle(sbClient));
            return RectangleToClient(screen);
        }

        public Rectangle SurfaceToClient(Rectangle surfaceRect)
        {
            return new Rectangle(SurfaceToClient(surfaceRect.Location), SurfaceToClient(surfaceRect.Size));
        }

        public Point SurfaceToClient(Point surfacePt)
        {
            return ScaleFactor.ScalePoint(surfacePt);
        }

        public Size SurfaceToClient(Size surfaceSize)
        {
            return Size.Round(SurfaceToClient((SizeF)surfaceSize));
        }

        public SizeF SurfaceToClient(SizeF surfaceSize)
        {
            return ScaleFactor.ScaleSize(surfaceSize);
        }

        #endregion

        #region 接口实现

        /// <summary>
        /// 获取原始坐标点
        /// </summary>
        /// <returns></returns>
        public Point GetCalcOriginPoint()
        {
            Rectangle rc = this.panel.ClientRectangle;
            int width = (int)(this.compositionSurface.Width * this.scaleFactor.Ratio);
            int height = (int)(this.compositionSurface.Height * this.scaleFactor.Ratio);
            int x = (rc.Width < width) ? this.panel.AutoScrollPosition.X + offsetHalfW : (rc.Width - width) / 2;
            int y = (rc.Height < height) ? this.panel.AutoScrollPosition.Y + offsetHalfH : (rc.Height - height) / 2;

            return new Point(x, y);
        }

        /// <summary>
        /// 获取未缩放的坐标点
        /// </summary>
        /// <param name="point"></param>
        /// <returns></returns>
        public Point GetScalePoint(PointF point)
        {
            Rectangle rc = this.panel.ClientRectangle;
            int width = this.compositionSurface == null ? 800 : (int)(this.compositionSurface.Width * this.scaleFactor.Ratio);
            int height = this.compositionSurface == null ? 600 : (int)(this.compositionSurface.Height * this.scaleFactor.Ratio);
            int x = (rc.Width < width) ? this.panel.AutoScrollPosition.X + offsetHalfW : (rc.Width - width) / 2;
            int y = (rc.Height < height) ? this.panel.AutoScrollPosition.Y + offsetHalfH : (rc.Height - height) / 2;

            return new Point(
                (int)((point.X - x) / this.scaleFactor.Ratio),
                (int)((point.Y - y) / this.scaleFactor.Ratio)
                );
        }

        /// <summary>
        /// 设置当前鼠标的状态
        /// </summary>
        /// <param name="status"></param>
        public void SetMouseStatus(bool status)
        {
            this.mouseStatus = status;
        }

        /// <summary>
        /// 获取当前鼠标的状态
        /// </summary>
        public bool GetMouseStatus()
        {
            return this.mouseStatus;
        }

        #endregion

        #region 初始化控件

        private void InitializeComponent()
        {
            this.components = new Container();
            this.contextMenuStrip1 = new System.Windows.Forms.ContextMenuStrip(this.components);
            this.topRuler = new Ruler();
            this.leftRuler = new Ruler();
            this.panel = new PanelEx();
            this.toolStripMenuItem1 = new System.Windows.Forms.ToolStripMenuItem();
            this.toolStripMenuItem2 = new System.Windows.Forms.ToolStripMenuItem();
            this.toolStripMenuItem3 = new System.Windows.Forms.ToolStripMenuItem();
            this.toolStripMenuItem4 = new System.Windows.Forms.ToolStripMenuItem();
            //this.panelBottom = new PanelBottom();
            //this.panelBottom.SuspendLayout();
            this.panel.SuspendLayout();
            this.contextMenuStrip1.SuspendLayout();
            this.SuspendLayout();

            // 
            // topRuler
            // 
            this.topRuler.BackColor = Color.White;
            this.topRuler.Dock = DockStyle.Top;
            this.topRuler.Location = new Point(0, 0);
            this.topRuler.Name = "topRuler";
            this.topRuler.Offset = -16;
            this.topRuler.Size = UI.ScaleSize(new Size(384, 16));
            this.topRuler.TabIndex = 3;
            // 
            // leftRuler
            // 
            this.leftRuler.BackColor = Color.White;
            this.leftRuler.Dock = DockStyle.Left;
            this.leftRuler.Location = new Point(0, 16);
            this.leftRuler.Name = "leftRuler";
            this.leftRuler.Orientation = Orientation.Vertical;
            this.leftRuler.Size = UI.ScaleSize(new Size(16, 304));
            this.leftRuler.TabIndex = 4;
            // 
            // panel
            // 
            this.panel.ContextMenuStrip = this.contextMenuStrip1;
            this.panel.AutoScroll = true;
            this.panel.Dock = DockStyle.Fill;
            this.panel.Location = new Point(16, 16);
            this.panel.Name = "panel";
            this.panel.ScrollPosition = new Point(0, 0);
            this.panel.Size = new Size(368, 304);
            this.panel.TabIndex = 5;
            this.panel.AllowDrop = false;
            this.panel.Scroll += new ScrollEventHandler(this.Panel_Scroll);
            this.panel.KeyDown += new KeyEventHandler(Panel_KeyDown);
            this.panel.KeyUp += new KeyEventHandler(Panel_KeyUp);
            this.panel.KeyPress += new KeyPressEventHandler(Panel_KeyPress);
            this.panel.GotFocus += new EventHandler(Panel_GotFocus);
            this.panel.LostFocus += new EventHandler(Panel_LostFocus);
            // 
            // contextMenuStrip1
            // 
            this.contextMenuStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
            this.toolStripMenuItem1,
            this.toolStripMenuItem2,
            this.toolStripMenuItem3,
            this.toolStripMenuItem4});
            this.contextMenuStrip1.Name = "contextMenuStrip1";
            this.contextMenuStrip1.Size = new System.Drawing.Size(69, 48);
            //this.contextMenuStrip1.Opening += new System.ComponentModel.CancelEventHandler(this.ContextMenuStrip1_Opening);
            this.contextMenuStrip1.Visible = false;
            //
            // 
            // toolStripMenuItem1
            // 
            this.toolStripMenuItem1.Name = "toolStripMenuItem1";
            this.toolStripMenuItem1.Text = "测量线设置";
            this.toolStripMenuItem1.Size = new System.Drawing.Size(68, 22);
            this.toolStripMenuItem1.Click += new System.EventHandler(this.ToolStripMenuItem1_Click);
            this.toolStripMenuItem1.Visible = false;
            // 
            // toolStripMenuItem2
            // 
            this.toolStripMenuItem2.Name = "toolStripMenuItem2";
            this.toolStripMenuItem2.Text = "测量区域设置";
            this.toolStripMenuItem2.Size = new System.Drawing.Size(68, 22);
            this.toolStripMenuItem2.Click += new System.EventHandler(this.ToolStripMenuItem2_Click);
            this.toolStripMenuItem2.Visible = false;
            // 
            // toolStripMenuItem3
            // 
            this.toolStripMenuItem3.Name = "toolStripMenuItem3";
            this.toolStripMenuItem3.Text = PdnResources.GetString("Menu.3celaing.Text");
            this.toolStripMenuItem3.Size = new System.Drawing.Size(68, 22);
            this.toolStripMenuItem3.Click += new System.EventHandler(this.ToolStripMenuItem3_Click);
            this.toolStripMenuItem3.Visible = false;
            // 
            // toolStripMenuItem4
            // 
            this.toolStripMenuItem4.Name = "toolStripMenuItem4";
            this.toolStripMenuItem4.Text = PdnResources.GetString("Menu.biaozhushuxing.Text");
            this.toolStripMenuItem4.Size = new System.Drawing.Size(68, 22);
            this.toolStripMenuItem4.Click += new System.EventHandler(this.ToolStripMenuItem4_Click);
            this.toolStripMenuItem4.Visible = false;
            // 底部的panelBottom
            //
            /*this.panelBottom.Size = new Size(384, 30);
            this.panelBottom.Anchor = AnchorStyles.Left | AnchorStyles.Right | AnchorStyles.Bottom;
            this.panelBottom.Dock = DockStyle.Bottom;
            this.panelBottom.trackBar.ValueChanged += new EventHandler(this.PanelBottom_trackBar_ValueChanged);
            this.panelBottom.BackColor = Color.FromArgb(240, 240, 240);*/
            // 
            // DocumentView
            // 
            this.Controls.Add(this.panel);
            this.Controls.Add(this.leftRuler);
            this.Controls.Add(this.topRuler);
            //this.Controls.Add(this.panelBottom);
            this.Name = "DocumentView";
            this.Size = new System.Drawing.Size(384, 320);
            this.panel.ResumeLayout(false);
            //this.panelBottom.ResumeLayout(false);
            this.contextMenuStrip1.ResumeLayout(false);
            this.ResumeLayout(false);
        }


        public void ShowContextMenuStrip1()
        {
            if (toolNumber == 0)
            {
                contextMenuStrip1.Visible = false;
                this.toolStripMenuItem1.Visible = false;
                this.toolStripMenuItem2.Visible = false;
                this.toolStripMenuItem3.Visible = false;
                this.toolStripMenuItem4.Visible = false;
            }
            else if (toolNumber == 1)
            {
                contextMenuStrip1.Visible = true;
                this.toolStripMenuItem1.Visible = true;
                this.toolStripMenuItem2.Visible = false;
                this.toolStripMenuItem3.Visible = false;
                this.toolStripMenuItem4.Visible = false;
            }
            else if (toolNumber == 2)
            {
                contextMenuStrip1.Visible = true;
                this.toolStripMenuItem1.Visible = false;
                this.toolStripMenuItem2.Visible = true;
                this.toolStripMenuItem3.Visible = false;
                this.toolStripMenuItem4.Visible = false;
            }
            else
            {
                contextMenuStrip1.Visible = false;
                this.toolStripMenuItem1.Visible = false;
                this.toolStripMenuItem2.Visible = false;
                this.toolStripMenuItem3.Visible = false;
                this.toolStripMenuItem4.Visible = false;
            }
        }
        #endregion

        #region 设定图片位置
        // add by maxb 20200716
        /// <summary>
        /// 图片位置坐标
        /// </summary>
        private bool m_center = true;
        private int m_pTop = 0;
        private int m_pLeft = 0;
        private int m_initTop = 0;
        private int m_initLeft = 0;

        public void SetDocumentPoint(int x, int y)
        {
            m_center = false;
            m_initLeft = x;
            m_initTop = y;
            UpdateImgLocation();
            this.Refresh();

        }

        public void SetCenter(bool center)
        {
            m_center = center;
        }

        private void UpdateImgLocation()
        {
            if (!m_center)
            {
                //Console.WriteLine("m_pLeft: " + m_initLeft + "  Ratio:" + this.scaleFactor.Ratio);
                m_pLeft = 16 + (int)(m_initLeft * this.scaleFactor.Ratio);
                m_pTop = 16 + (int)(m_initTop * this.scaleFactor.Ratio);
                //Console.WriteLine("Location: " + m_pLeft + " " + m_pTop);
            }

        }
        #endregion

        #region 工艺图比照

        private RectangleF m_artworkImageRectangle;
        private Bitmap m_selectedBitmap;

        /// <summary>
        /// 工艺比照定位点图像绘制
        /// </summary>
        /// <param name="bitmap"></param>
        /// <param name="rectangle"></param>
        public void SetSelectedBitmap(Bitmap bitmap, RectangleF rectangle)
        {
            m_selectedBitmap = bitmap;
            m_artworkImageRectangle = Rectangle.Ceiling(rectangle);
            this.Refresh();
        }

        #endregion

        #region 图像拼接
        /// <summary>
        /// 生成自定义拼图区域
        /// </summary>
        /// <param name="width"></param>
        /// <param name="height"></param>
        public void CreateStitchingRectangle(int width, int height)
        {
            int x = m_pLeft;
            int y = m_pTop;
        }

        /// <summary>
        /// 获取对应标尺上的坐标点
        /// </summary>
        /// <param name="point"></param>
        /// <returns></returns>
        public PointF GetRulerPointInPanel(PointF point)
        {
            return new PointF(
                (float)((point.X - 16) / this.scaleFactor.Ratio),
                (float)((point.Y - 16) / this.scaleFactor.Ratio)
                );
        }

        public PointF ScalePointToRulerPoint(PointF point)
        {
            Point originPoint = GetCalcOriginPoint();

            return new PointF(
                (float)((point.X * this.scaleFactor.Ratio + originPoint.X - 16) / this.scaleFactor.Ratio),
                (float)((point.Y * this.scaleFactor.Ratio + originPoint.Y - 16) / this.scaleFactor.Ratio)
                );
        }

        /// <summary>
        /// 是否开启鼠标左键双击移动视场
        /// </summary>
        public bool ViewMoveOnMouseLeftDoubleClickEnable
        {
            get; set;
        }

        #endregion

        #region 右键属性
        /// <summary>
        /// 判断右键的工具
        /// </summary>
        public int ToolNumber
        {
            set
            {
                this.toolNumber = value;
            }


        }

        public LabelStyleModel.DrawAnalysisModel AnalysisStyleModel { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }

        /// <summary>
        /// 设置右键菜单的选项
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ContextMenuStrip1_Opening(object sender, CancelEventArgs e)
        {
            if (toolNumber == 0)
            {
                contextMenuStrip1.Visible = false;
                this.toolStripMenuItem1.Visible = false;
                this.toolStripMenuItem2.Visible = false;
                this.toolStripMenuItem3.Visible = false;
                this.toolStripMenuItem4.Visible = false;
            }
            else if (toolNumber == 1)
            {
                contextMenuStrip1.Visible = true;
                this.toolStripMenuItem1.Visible = true;
                this.toolStripMenuItem2.Visible = false;
                this.toolStripMenuItem3.Visible = false;
                this.toolStripMenuItem4.Visible = false;
            }
            else if (toolNumber == 2)
            {
                contextMenuStrip1.Visible = true;
                this.toolStripMenuItem1.Visible = false;
                this.toolStripMenuItem2.Visible = true;
                this.toolStripMenuItem3.Visible = false;
                this.toolStripMenuItem4.Visible = false;
            }
            else
            {
                contextMenuStrip1.Visible = false;
                this.toolStripMenuItem1.Visible = false;
                this.toolStripMenuItem2.Visible = false;
                this.toolStripMenuItem3.Visible = false;
                this.toolStripMenuItem4.Visible = false;
            }
        }
        /// <summary>
        /// 右键菜单(测量设置)
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public virtual void ToolStripMenuItem1_Click(object sender, EventArgs e)
        {

        }

        /// <summary>
        /// 右键菜单(标注设置)
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public virtual void ToolStripMenuItem2_Click(object sender, EventArgs e)
        {
        }
        /// <summary>
        /// 右键菜单(测量属性)
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public virtual void ToolStripMenuItem3_Click(object sender, EventArgs e)
        {

        }
        /// <summary>
        /// 右键菜单(标注属性)
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public virtual void ToolStripMenuItem4_Click(object sender, EventArgs e)
        {
        }
        #endregion

        /// <summary>
        /// 初始化标尺信息，图片对应的xml中读取
        /// 然后根据标尺的单位，换算出所有单位的数据
        /// </summary>
        public void InitRulerInfo()
        {
            this.rules.Clear();
            if (this.xmlSaveModel != null && this.xmlSaveModel.pixel_length != 0)
            {
                //计算单位长度 比如0.05英寸/像素； 100纳米/像素；
                double unitLength = (double)(this.xmlSaveModel.physical_length / (decimal)this.xmlSaveModel.pixel_length);
                switch (this.xmlSaveModel.ruler_units)
                {
                    case (int)MeasurementUnit.Inch://英寸
                        this.rules.Add(MeasurementUnit.Inch, unitLength);                    //英寸
                        this.rules.Add(MeasurementUnit.Mil, 1000 * unitLength);              //米尔
                        this.rules.Add(MeasurementUnit.Centimeter, 2.54 * unitLength);       //厘米
                        this.rules.Add(MeasurementUnit.Millimeter, 25.4 * unitLength);       //毫米
                        this.rules.Add(MeasurementUnit.Micron, 25400 * unitLength);          //微米
                        this.rules.Add(MeasurementUnit.Nano, 25400000 * unitLength);         //纳米
                        break;
                    case (int)MeasurementUnit.Mil://米尔
                        this.rules.Add(MeasurementUnit.Inch, 0.001 * unitLength);            //英寸
                        this.rules.Add(MeasurementUnit.Mil, unitLength);                     //米尔
                        this.rules.Add(MeasurementUnit.Centimeter, 0.00254 * unitLength);    //厘米
                        this.rules.Add(MeasurementUnit.Millimeter, 0.0254 * unitLength);     //毫米
                        this.rules.Add(MeasurementUnit.Micron, 25.4 * unitLength);           //微米
                        this.rules.Add(MeasurementUnit.Nano, 25400 * unitLength);            //纳米
                        break;
                    case (int)MeasurementUnit.Centimeter://厘米
                        this.rules.Add(MeasurementUnit.Inch, 0.3937008 * unitLength);        //英寸
                        this.rules.Add(MeasurementUnit.Mil, 393.7008 * unitLength);          //米尔
                        this.rules.Add(MeasurementUnit.Centimeter, unitLength);              //厘米
                        this.rules.Add(MeasurementUnit.Millimeter, 10 * unitLength);         //毫米
                        this.rules.Add(MeasurementUnit.Micron, 10000 * unitLength);          //微米
                        this.rules.Add(MeasurementUnit.Nano, 10000000 * unitLength);         //纳米
                        break;
                    case (int)MeasurementUnit.Millimeter://毫米
                        this.rules.Add(MeasurementUnit.Inch, 0.0393701 * unitLength);        //英寸
                        this.rules.Add(MeasurementUnit.Mil, 39.3701 * unitLength);           //米尔
                        this.rules.Add(MeasurementUnit.Centimeter, 0.1 * unitLength);        //厘米
                        this.rules.Add(MeasurementUnit.Millimeter, unitLength);              //毫米
                        this.rules.Add(MeasurementUnit.Micron, 1000 * unitLength);           //微米
                        this.rules.Add(MeasurementUnit.Nano, 1000000 * unitLength);          //纳米
                        break;
                    case (int)MeasurementUnit.Micron://微米
                        this.rules.Add(MeasurementUnit.Inch, 0.00003937007874 * unitLength);        //英寸
                        this.rules.Add(MeasurementUnit.Mil, 0.03937007874 * unitLength);        //米尔
                        this.rules.Add(MeasurementUnit.Centimeter, 0.0001 * unitLength);     //厘米
                        this.rules.Add(MeasurementUnit.Millimeter, 0.001 * unitLength);      //毫米
                        this.rules.Add(MeasurementUnit.Micron, unitLength);                  //微米
                        this.rules.Add(MeasurementUnit.Nano, 1000 * unitLength);             //纳米
                        break;
                    case (int)MeasurementUnit.Nano://纳米
                        this.rules.Add(MeasurementUnit.Inch, 3.9370e-8 * unitLength);        //英寸
                        this.rules.Add(MeasurementUnit.Mil, 3.9370e-5 * unitLength);        //米尔
                        this.rules.Add(MeasurementUnit.Centimeter, 1e-7 * unitLength);       //厘米
                        this.rules.Add(MeasurementUnit.Millimeter, 1e-6 * unitLength);       //毫米
                        this.rules.Add(MeasurementUnit.Micron, 0.001 * unitLength);          //微米
                        this.rules.Add(MeasurementUnit.Nano, unitLength);                    //纳米
                        break;
                    default:
                        this.xmlSaveModel = null;
                        break;
                }
            }
            if (this.xmlSaveModel == null || this.xmlSaveModel.physical_length == 0)
            {
                //如果没有标尺的时候，默认1微米/像素
                this.rules.Add(MeasurementUnit.Inch, 0.0000394);     //英寸
                this.rules.Add(MeasurementUnit.Mil, 0.0394);     //米尔
                this.rules.Add(MeasurementUnit.Centimeter, 0.0001);  //厘米
                this.rules.Add(MeasurementUnit.Millimeter, 0.001);   //毫米
                this.rules.Add(MeasurementUnit.Micron, 1);           //微米
                this.rules.Add(MeasurementUnit.Nano, 1000);          //纳米

                this.xmlSaveModel = new mic_rulers();
                this.xmlSaveModel.ruler_name = PdnResources.GetString("Menu.Unselectedruler.Text");
                this.xmlSaveModel.gain_multiple = 1;
                this.xmlSaveModel.physical_length = 100;
                this.xmlSaveModel.pixel_length = 100;
                this.xmlSaveModel.ruler_units = (int)((MeasurementUnit)System.Enum.Parse(typeof(MeasurementUnit), this.getRulerList()[0]));
            }
            //设置文档标尺
            Document.defaultDpi = 1 / rules[MeasurementUnit.Inch];
        }

        /// <summary>
        /// 获取系统当前选中单位及每单位像素值
        /// </summary>
        /// <returns>3位字符串数组，
        /// 0：系统选中单位枚举字符串
        /// 1：系统选中单位名称字符串
        /// 2：系统选中单位符号字符串
        /// 3：系统选中单位每单位像素长度
        /// 4：系统选中单位每单位物理长度
        /// </returns>
        protected virtual string[] startUpRules(Dictionary<MeasurementUnit, double> rules)
        {
            return new string[] { };
        }

        /// <summary>
        /// 提供获取系统当前选中单位及每单位像素值公共方法
        /// </summary>
        /// <returns></returns>
        public string[] getRulerList()
        {
            return startUpRules(this.rules.Count > 0 ? this.rules : null);
        }
        /// <summary>
        /// 获取单位标尺
        /// </summary>
        /// <param name="measurementUnit">度量单位的枚举</param>
        /// <returns></returns>
        public double GetRuler(MeasurementUnit measurementUnit)
        {
            double unitLength = 0;
            //判断当前图片是否有对应的标尺
            if (this.rules.Count > 0)
            {
                this.rules.TryGetValue(measurementUnit, out unitLength);
            }
            else
            {
                this.appWorkspace.getMeasureInfo().TryGetValue(MeasurementUnit.Micron, out unitLength);
            }
            return unitLength;
        }
        /// <summary>
        /// 获取放大倍数
        /// </summary>
        /// <returns></returns>
        public double GetMultiple()
        {
            double multiple = 1;
            if (this.xmlSaveModel != null)
            {
                multiple = (double)this.xmlSaveModel.gain_multiple;
            }
            return multiple;
        }
        /// <summary>
        /// 获取单位标尺乘以放大倍数
        /// </summary>
        /// <param name="measurementUnit">度量单位的枚举</param>
        /// <returns></returns>
        public double GetRulerMultiple(MeasurementUnit measurementUnit)
        {
            double unitLength = 0;
            double multiple = 0;
            //判断当前图片是否有对应的标尺
            if (this.rules.Count > 0)
            {
                this.rules.TryGetValue(measurementUnit, out unitLength);
            }
            else
            {
                this.appWorkspace.getMeasureInfo().TryGetValue(MeasurementUnit.Micron, out unitLength);
            }
            if (this.xmlSaveModel != null)
            {
                multiple = (double)this.xmlSaveModel.gain_multiple;
            }
            return unitLength * multiple;
        }

        public void IsDirty(GraphicsList gList)
        {
            this.AdjustRendering();
        }

        public RectangleF GetVisibleDocumentRectangleF()
        {
            return this.VisibleDocumentRectangleF;
            //return this.AppWorkspaceTop.GetVisibleDocumentRectangleF();
        }

        public SizeF GetDocumentSize()
        {
            if (this.Document == null) {

                return new SizeF(0, 0);
            }
            return this.Document.Size;
            //return this.AppWorkspaceTop.GetDocumentSize();
        }

        public void SetDirty()
        {
            this.Document.Dirty = true;
        }

        public int UnscaleScalar(int deltaX)
        {
            return this.scaleFactor.UnscaleScalar(deltaX);
        }

        public PointF GetDocumentScrollPositionF()
        {
            return this.DocumentScrollPositionF;
        }

        public void SetDocumentScrollPositionF(PointF newScrollPos)
        {
            Point sbClient = Point.Round(newScrollPos);
            if (this.panel.AutoScrollPosition != new Point(-sbClient.X, -sbClient.Y))
            {
                this.panel.AutoScrollPosition = sbClient;
                UpdateRulerOffsets();
                //this.panelBottom.Invalidate();
                this.topRuler.Invalidate();
                this.leftRuler.Invalidate();
            }
        }

        public string[] GetPxPerUnit()
        {
            return this.AppWorkspaceTop.GetPxPerUnit();
        }

        public Dictionary<int, string> GetUnitsDictionary()
        {
            return InvariantData.unitsDictionary;
        }

        public Dictionary<int, string> GetUnitSymbolsDictionary()
        {
            return InvariantData.unitSymbolsDictionary;
        }

        public CombineMode GetCombineMode()
        {
            return this.AppWorkspaceTop.GetCombineMode();
        }

        bool ISurfaceBox.ContinuousDrawingMeasure()
        {
            return ContinuousDrawingMeasure;
        }

        bool ISurfaceBox.ContinuousDrawingView()
        {
            return ContinuousDrawingView;
        }

        public void SetContinuousDrawingVoid(bool v)
        {
            ContinuousDrawingView = v;
            appWorkspace.SetContinuousDrawingView(v);
        }


        public void SetContinuousDrawingMeasure(bool v)
        {
            ContinuousDrawingMeasure = v;
            appWorkspace.SetContinuousDrawingMeasure(v);
        }

        public LabelStyleModel GetLabelStyleModel()
        {
            throw new NotImplementedException();
        }

        public MeasureStyleModel GetMeasureStyleModel()
        {
            return this.AppWorkspaceTop.GetMeasureStyleModel();
        }

        public Dictionary<MeasurementUnit, double> getMeasureInfo()
        {
            if (this.rules.Count > 0)
                return this.rules;
            else
                return this.AppWorkspaceTop.getMeasureInfo();
        }
        public void UpdateContinueNum()
        {
            this.AppWorkspaceTop.UpdateContinueNum();
        }

        bool ISurfaceBox.DeleteFieldOfView()
        {
            return DeleteFieldOfView;
        }

        public MeasureAreaModel GetMeasureAreaModel()
        {
            return this.AppWorkspaceTop.GetMeasureAreaModel();
        }

        public mic_rulers RuleAttribute(PicConfigModel PicConfigModel)
        {
            this.xmlSaveModel = new mic_rulers();
            this.xmlSaveModel.ruler_name = PicConfigModel.rule.ruler_name;
            this.xmlSaveModel.gain_multiple = PicConfigModel.rule.gain_multiple;
            this.xmlSaveModel.pixel_length = PicConfigModel.rule.pixel_length;
            this.xmlSaveModel.physical_length = PicConfigModel.rule.physical_length;
            this.xmlSaveModel.ruler_units = PicConfigModel.rule.ruler_units;
            InitRulerInfo();
            this.existenceXML = true;
            return this.xmlSaveModel;
        }

        public double getUnitNum()
        {
            this.unitNum = this.AppWorkspaceTop.getUnitNum();
            return this.unitNum;
        }

        public string getAliasName()
        {
            this.aliasName = this.AppWorkspaceTop.getAliasName();
            return this.aliasName;
        }

        public int getDecimalPlaces()
        {
            this.decimalPlaces = this.AppWorkspaceTop.getDecimalPlaces();
            return this.decimalPlaces;
        }
    }
}