Metis_xctg/Annotation/Label/DrawPrestoredRuler.cs

using PaintDotNet.Base.SettingModel;
using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;
using PaintDotNet.Base.CommTool;
using System.IO;
using static PaintDotNet.Base.SettingModel.LabelStyleModel;
using PaintDotNet.Annotation.Enum;
using System.Collections.Generic;

namespace PaintDotNet.Annotation.Label
{
    /// <summary>
    /// 标注->预存标尺
    /// </summary>
    public class DrawPrestoredRuler : DrawObject
    {
        private static Cursor handleCursor = new Cursor(PdnResources.GetResourceStream("Cursors.AnnotationPolyHandle.cur"));

        /// <summary>
        /// 标注样式信息model
        /// </summary>
        public RulerModel rulerModel;

        public int lineLength = 0;//标尺长度

        private double micronRatio = 1;
        private decimal gainNumber = 0;
        private bool isFirstDraw = true;

        public DrawPrestoredRuler(ISurfaceBox surfaceBox) : base()
        {
            this.objectType = DrawClass.Label;
            this.drawToolType = DrawToolType.DrawPrestoredRuler;

            rulerModel = surfaceBox.GetRulerStyleModel();
            startPoint = new PointF(0, 0);

            //Dictionary<MeasurementUnit, double> measurementUnitDictionary = surfaceBox.getMeasureInfo();
            //this.micronRatio = measurementUnitDictionary[MeasurementUnit.Micron];//每像素多少纳米长度

            this.gainNumber = surfaceBox.GetMic_Rulers();//获取放大倍数
            if (this.gainNumber == 0)
                this.gainNumber = 1;

            Initialize();
        }

        public DrawPrestoredRuler(ISurfaceBox surfaceBox, List<PointF> points, ParentStyleModel parentStyleModel, Object content) : base()
        {
            this.objectType = DrawClass.Label;
            this.drawToolType = DrawToolType.DrawPrestoredRuler;
            this.ISurfaceBox = surfaceBox;
            this.isFirstDraw = false;

            this.gainNumber = surfaceBox.GetGainMultiple();//获取放大倍数
            if (this.gainNumber == 0)
                this.gainNumber = 20;

            rulerModel = (RulerModel)parentStyleModel;
            startPoint = points[0];
            lineLength = Convert.ToInt32(content.ToString());
        }

        /// <summary>
        /// Clone this instance
        /// </summary>
        public override DrawObject Clone()
        {
            DrawPrestoredRuler drawPrestoredRuler = new DrawPrestoredRuler(ISurfaceBox);
            drawPrestoredRuler.objectType = DrawClass.Label;
            drawPrestoredRuler.drawToolType = DrawToolType.DrawPrestoredRuler;
            drawPrestoredRuler.ISurfaceBox = ISurfaceBox;
            drawPrestoredRuler.isFirstDraw = false;
            drawPrestoredRuler.startPoint = this.startPoint;
            drawPrestoredRuler.lineLength = this.lineLength;
            FillDrawObjectFields(drawPrestoredRuler);
            return drawPrestoredRuler;
        }

        public override DrawObject Clone(ISurfaceBox surfaceBox)
        {
            DrawPrestoredRuler drawPrestoredRuler = new DrawPrestoredRuler(surfaceBox);
            drawPrestoredRuler.objectType = DrawClass.Label;
            drawPrestoredRuler.drawToolType = DrawToolType.DrawPrestoredRuler;
            drawPrestoredRuler.ISurfaceBox = surfaceBox;
            drawPrestoredRuler.isFirstDraw = false;
            drawPrestoredRuler.startPoint = this.startPoint;
            drawPrestoredRuler.lineLength = this.lineLength;
            FillDrawObjectFields(drawPrestoredRuler);
            return drawPrestoredRuler;
        }

        public override void Draw(Graphics g)
        {
            g.SmoothingMode = SmoothingMode.AntiAlias;

            if(lineLength > 0)
            {

                Dictionary<MeasurementUnit, double> measurementUnitDictionary = ISurfaceBox.getMeasureInfo();

                #region[以微米为基础单位]
                double micron = measurementUnitDictionary[MeasurementUnit.Micron];//每像素多少微米长度
                double actualLineLength = lineLength;//除以放大倍数后的实际物理长度
                int pixelLength = Convert.ToInt32(actualLineLength / micron);//换算为像素长度
                #endregion

                MeasurementUnit unit = ISurfaceBox.GetMeasurementUnit();
                micronRatio = measurementUnitDictionary[unit];//每像素多少微米长度

                #region [单位缩写]

                string unitAbbreviation = string.Empty;

                switch (unit)
                {
                    case MeasurementUnit.Inch:
                        actualLineLength = actualLineLength * micronRatio  / micron;
                        unitAbbreviation = "in";
                        break;
                    case MeasurementUnit.Centimeter:
                        actualLineLength = actualLineLength * micronRatio / micron;
                        unitAbbreviation = "cm";
                        break;
                    case MeasurementUnit.Millimeter:
                        actualLineLength = actualLineLength * micronRatio / micron;
                        unitAbbreviation = "mm";
                        break;
                    case MeasurementUnit.Micron:
                        unitAbbreviation = "µm";
                        break;
                    case MeasurementUnit.Nano:
                        actualLineLength = actualLineLength * micronRatio / micron;
                        unitAbbreviation = "nm";
                        break;
                    case MeasurementUnit.Pixel:
                        unitAbbreviation = "PX";
                        break;
                    case MeasurementUnit.Mil:
                        actualLineLength = actualLineLength * micronRatio / micron;
                        unitAbbreviation = "mil";
                        break;
                }

                #endregion

              

                SizeF windowSize = this.ISurfaceBox.GetDocumentSize();//窗体尺寸

                //线样式
                Pen linePen = new Pen(Color.FromArgb(this.rulerModel.lineColor));
                linePen.Width = (int)this.rulerModel.lineWidth;

                //边框样式
                Pen borderPen = new Pen(Color.FromArgb(this.rulerModel.borderColor));
                borderPen.Width = (int)this.rulerModel.borderWidth;

                int lineWidthOffset = (int)this.rulerModel.lineWidth / 2 - 1;
                int offset = borderPen.Width > 0 ? (int)(borderPen.Width / 2) - 2 : 0;

                //背景大小
                decimal backLength = pixelLength * this.rulerModel.backgroundSize / 100;

                //垂线
                decimal verticalLength = pixelLength * this.rulerModel.verticalLineLength / 100;

                //文字
                string text = actualLineLength + unitAbbreviation;
                //string text = Math.Round(actualLineLength, MeasureDrawObject.decimalPlaces).ToString() + unitAbbreviation;//文字
                decimal textHeight = pixelLength * this.rulerModel.textHeight / 100;
                Font textFont = new Font(this.rulerModel.textFont, (float)this.rulerModel.textFontSize);
                int fontNewHeight = lineWidthOffset + (int)(textHeight + new Decimal(textFont.Height));

                int abc = fontNewHeight > ((int)verticalLength / 2 - 2) ? fontNewHeight : ((int)verticalLength / 2 - 2);

                //标尺最终尺寸
                int rulerWidth = pixelLength + (int)(backLength * 2) + (int)(linePen.Width * 2) + offset * 2;
                int rulerHeight = (int)verticalLength / 2 + abc + (int)(backLength * 2) + lineWidthOffset + 2 + offset * 2;

                int rulerPosition = this.rulerModel.rulerPosition;//标尺位置
                decimal rulerMargin = this.rulerModel.rulerMargin / 100;//标尺边距
                float marginLR = (float)rulerMargin * windowSize.Width;//左右边距
                float marginTB = (float)rulerMargin * windowSize.Height;//上下边距

                float offsetBorder = borderPen.Width > 0 ? borderPen.Width / 2 : 0;

                if (isFirstDraw)
                {
                    switch (rulerPosition)
                    {
                        case 1://左上
                            startPoint.X = rulerWidth / 2f - lineWidthOffset + offsetBorder + marginLR;
                            startPoint.Y = fontNewHeight + (float)backLength - lineWidthOffset + offsetBorder + marginTB;
                            break;
                        case 2://右上
                            startPoint.X = windowSize.Width - (rulerWidth / 2f - lineWidthOffset + offsetBorder) - marginLR;
                            startPoint.Y = fontNewHeight + (float)backLength - lineWidthOffset + offsetBorder + marginTB;
                            break;
                        case 3://左下
                            startPoint.X = rulerWidth / 2f - lineWidthOffset + offsetBorder + marginLR;
                            startPoint.Y = windowSize.Height - (rulerHeight - (fontNewHeight + (float)backLength)) - offsetBorder - marginTB;
                            break;
                        case 4://右下
                            startPoint.X = windowSize.Width - (rulerWidth / 2f - lineWidthOffset + offsetBorder) - marginLR;
                            startPoint.Y = windowSize.Height - (rulerHeight - (fontNewHeight + (float)backLength)) - offsetBorder - marginTB;
                            break;
                    }

                    isFirstDraw = false;
                }

                DrawRulerHelper.drawRuler(this.rulerModel, g, startPoint, pixelLength, text, out rectangle);
            } 
        }

        public override int HandleCount
        {
            get
            {
                return 1;
            }
        }

        /// <summary>
        /// Get handle pointscroll by 1-based number
        /// </summary>
        /// <param name="handleNumber"></param>
        /// <returns></returns>
        public override PointF GetHandle(int handleNumber)
        {
            return new PointF(rectangle.X, rectangle.Y);
        }

        /// <summary>
        /// Hit test.
        /// Return value: -1 - no hit
        ///                0 - hit anywhere
        ///                > 1 - handle number
        /// </summary>
        /// <param name="pointscroll"></param>
        /// <returns></returns>
        public override int HitTest(Point point)
        {
            if (Selected)
            {
                for (int i = 1; i <= HandleCount; i++)
                {
                    if (GetHandleRectangle(i).Contains(point))
                        return i;
                }
            }

            if (PointInObject(point))
                return 0;

            return -1;
        }

        protected override bool PointInObject(Point point)
        {
            return rectangle.Contains(point);
        }

        public override bool IntersectsWith(Rectangle rectangle)
        {
            return Rectangle.IntersectsWith(rectangle);
        }

        public override Cursor GetHandleCursor(int handleNumber)
        {
            return Cursors.Default;
        }

        public override void MoveHandleTo(Point point, int handleNumber)
        {
            startPoint = point;
        }

        public override void Move(int deltaX, int deltaY)
        {
            int x = ISurfaceBox.UnscaleScalar(deltaX);
            int y = ISurfaceBox.UnscaleScalar(deltaY);

            startPoint.X += x;
            startPoint.Y += y;

            rectangle.X += x;
            rectangle.Y += y;
        }

        public override RectangleF GetBoundingBox()
        {
            return rectangle;
        }

        public override List<PointF> GetPoints()
        {
            List<PointF> points = new List<PointF>();
            points.Add(startPoint);
            return points;
        }

        public override ParentStyleModel GetStyle()
        {
            return rulerModel;
        }

        public override string GetContent()
        {
            return lineLength.ToString();
        }
    }
}