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

namespace PaintDotNet.Annotation.Measure
{
    using PointList = List<PointF>;

    /// <summary>
    /// 测量->对准度->两线中垂线距离
    /// </summary>
    public class MeasureTwoLineVLDistance : MeasureDrawObject
    {
        public PointList pointArray;
        private const string entryLength = "Length";
        private const string entryPoint = "Point";

        /// <summary>
        ///  Graphic objects for hit test
        /// </summary>
        private GraphicsPath areaPath = null;
        private Pen areaPen = null;
        private Region areaRegion = null;
        /// <summary>
        /// 总长度
        /// </summary>
        private double Length = 0.0;
        /// <summary>
        /// 测量信息矩形定义
        /// </summary>
        private RectangleF rectangleF1 = new RectangleF();
        private RectangleF rectangleF2 = new RectangleF();
        private RectangleF rectangleF3 = new RectangleF();
        private RectangleF rectangleF4 = new RectangleF();
        private RectangleF rectangleF5 = new RectangleF();
        private RectangleF rectangleF6 = new RectangleF();
        private RectangleF rectangleF7 = new RectangleF();
        private RectangleF rectangleF8 = new RectangleF();
        private RectangleF rectangleF9 = new RectangleF();
        /// <summary>
        /// 文本上用于拖动的点
        /// </summary>
        private Point pointL = new Point();
        /// <summary>
        /// 绘制限制(第一次绘制时)
        /// </summary>
        public bool pointChange = true;
        /// <summary>
        /// 区分移动文本
        /// </summary>
        private int moveKb;
        /// <summary>
        /// 绘制限制(从配置文件加载)
        /// </summary>
        public bool configurationFile = false;
        /// <summary>
        /// 绘制限制(更改属性时)
        /// </summary>
        private bool SavePointChange;
        /// <summary>
        /// 绘制属性
        /// </summary>
        private string[] drawingPropertiesList;
        /// <summary>
        /// 绘制属性(克隆)
        /// </summary>
        private string[] drawingPropertiesListClone;
        private bool drawing;
        /// <summary>
        /// 旋转角度
        /// </summary>
        private double angle;
        /// <summary>
        /// 属性绘制点
        /// </summary>
        private PointF rotationPoint;
        private PointF rotationPoint1;
        /// <summary>
        /// 限制绘制(绘制中)
        /// </summary>
        public bool mouseUpPointChange = false;
        /// <summary>
        /// 测量样式信息model
        /// </summary>
        private MeasureStyleModel.MeasureTwoLineVLDistance measureStyleModel;

        public MeasureStyleModel.MeasureTwoLineVLDistance MeasureStyleModel
        {
            get
            {
                return measureStyleModel;
            }
            set
            {
                this.measureStyleModel = value;
            }
        }

        public MeasureTwoLineVLDistance(ISurfaceBox surfaceBox, int x1, int y1, bool clone) : base(surfaceBox)
        {
            this.objectType = DrawClass.Measure;
            this.drawToolType = DrawToolType.MeasureTwoLineVLDistance;

            measureStyleModel = surfaceBox.GetMeasureStyleModel().measureTwoLineVLDistance;
            pointArray = new PointList();
            startPoint.X = x1;
            startPoint.Y = y1;
            if (clone)
            {
                drawing = true;
                pointArray.Add(new Point(x1, y1));
            }
            this.measurementUnit = (MeasurementUnit)System.Enum.Parse(typeof(MeasurementUnit), surfaceBox.GetPxPerUnit()[0]);
            this.unitString = surfaceBox.GetPxPerUnit()[1];
            this.unit = surfaceBox.GetPxPerUnit()[2];

            Initialize();
        }
        /// <summary>
        /// 测量属性
        /// </summary>
        /// <returns></returns>
        public override Dictionary<System.Enum, object> GetData()
        {
            if (data.ContainsKey(MeasureAttributes.MeasureMethod))
                data[MeasureAttributes.MeasureMethod] = PdnResources.GetString("Menu.MeasureAction.LengthMeasurement.Text");
            else
                data.Add(MeasureAttributes.MeasureMethod, PdnResources.GetString("Menu.MeasureAction.LengthMeasurement.Text"));

            if (data.ContainsKey(MeasureAttributes.MeasureUnitCN))
                data[MeasureAttributes.MeasureUnitCN] = this.unitString;
            else
                data.Add(MeasureAttributes.MeasureUnitCN, this.unitString);

            if (data.ContainsKey(MeasureAttributes.MeasureUnitEN))
                data[MeasureAttributes.MeasureUnitEN] = this.unit;
            else
                data.Add(MeasureAttributes.MeasureUnitEN, this.unit);

            if (data.ContainsKey(MeasureAttributes.PixelStartX))
                data[MeasureAttributes.PixelStartX] = startPoint.X;
            else
                data.Add(MeasureAttributes.PixelStartX, startPoint.X);

            if (data.ContainsKey(MeasureAttributes.PixelStartY))
                data[MeasureAttributes.PixelStartY] = startPoint.Y;
            else
                data.Add(MeasureAttributes.PixelStartY, startPoint.Y);

            if (data.ContainsKey(MeasureAttributes.PhysicalStartX))
                data[MeasureAttributes.PhysicalStartX] = Math.Round(startPoint.X * unitLength, decimalPlaces);
            else
                data.Add(MeasureAttributes.PhysicalStartX, Math.Round(startPoint.X * unitLength, decimalPlaces));

            if (data.ContainsKey(MeasureAttributes.PhysicalStartY))
                data[MeasureAttributes.PhysicalStartY] = Math.Round(startPoint.Y * unitLength, decimalPlaces);
            else
                data.Add(MeasureAttributes.PhysicalStartY, Math.Round(startPoint.Y * unitLength, decimalPlaces));

            if (data.ContainsKey(MeasureAttributes.PixelLength))
                data[MeasureAttributes.PixelLength] = Math.Round(Length, decimalPlaces);
            else
                data.Add(MeasureAttributes.PixelLength, Math.Round(Length, decimalPlaces));

            string s = Math.Round(Length * unitLength, decimalPlaces).ToString();
            if (s.IndexOf(".") == -1)
            {
                for (int i = 0; i < decimalPlaces; i++)
                {
                    if (i == 0)
                        s += ".";
                    s += "0";
                }
            }
            else
            {
                int a = s.Length - s.IndexOf(".") - 1;
                if (a < decimalPlaces)
                {
                    for (int i = 0; i < decimalPlaces - a; i++)
                    {
                        s += "0";
                    }
                }
            }
            if (data.ContainsKey(MeasureAttributes.PhysicalLength))
                data[MeasureAttributes.PhysicalLength] = s;
            else
                data.Add(MeasureAttributes.PhysicalLength, s);
            return data;
        }

        public MeasureTwoLineVLDistance(ISurfaceBox surfaceBox, List<PointF> points, ParentStyleModel parentStyleModel, Object content) : base()
        {
            this.objectType = DrawClass.Measure;
            this.drawToolType = DrawToolType.MeasureTwoLineVLDistance;
            this.ISurfaceBox = surfaceBox;
            measureStyleModel = (MeasureStyleModel.MeasureTwoLineVLDistance)parentStyleModel;
            pointArray = DrawRulerHelper.DeepCopyListByReflect(points);
            startPoint = points[0];
            this.measurementUnit = (MeasurementUnit)System.Enum.Parse(typeof(MeasurementUnit), surfaceBox.GetPxPerUnit()[0]);
            this.unitString = surfaceBox.GetPxPerUnit()[1];
            this.unit = surfaceBox.GetPxPerUnit()[2];

            this.configurationFile = true;
        }

        /// <summary>
        /// Clone this instance
        /// </summary>
        public override DrawObject Clone()
        {
            MeasureTwoLineVLDistance drawPolygon = new MeasureTwoLineVLDistance(ISurfaceBox, (int)pointArray[0].X, (int)pointArray[0].Y, false);
            drawPolygon.ISurfaceBox = ISurfaceBox;
            foreach (PointF p in this.pointArray)
            {
                drawPolygon.pointArray.Add(p);
            }
            if (drawingPropertiesList != null)
                drawPolygon.drawingPropertiesListClone = drawingPropertiesList;
            FillDrawObjectFields(drawPolygon);
            return drawPolygon;
        }

        public override DrawObject Clone(ISurfaceBox surfaceBox)
        {
            MeasureTwoLineVLDistance drawPolygon = new MeasureTwoLineVLDistance(surfaceBox, this.GetPoints(), this.measureStyleModel, null);
            if (drawingPropertiesList != null)
                drawPolygon.drawingPropertiesListClone = drawingPropertiesList;
            FillDrawObjectFields(drawPolygon);
            return drawPolygon;
        }

        public override void Draw(Graphics g)
        {
            measureStyleModel = this.ISurfaceBox.GetMeasureStyleModel().measureTwoLineVLDistance;
            drawingProperties.TryGetValue(this.drawToolType, out drawingPropertiesList);
            if (drawingPropertiesList == null)
            {
                drawingPropertiesList = drawingPropertiesListClone;
                if (!this.drawing)
                    this.configurationFile = true;
            }
            float width = ISurfaceBox.GetDocumentSize().Width;
            float height = ISurfaceBox.GetDocumentSize().Height;
            pointChangeObject.TryGetValue(this.drawToolType, out SavePointChange);

            string frontStr = string.Empty;

            if (this.measureStyleModel.showSuffix)
            {
                frontStr = this.measureStyleModel.suffixName;
            }

            if (this.measureStyleModel.showSerial)
            {

                #region [获取序号]

                List<DrawObject> newGraphicsList = new List<DrawObject>();

                int n = ISurfaceBox.GraphicsList.Count;

                int num = 0;

                for (int i = n - 1; i >= 0; i--)
                {
                    newGraphicsList.Add(ISurfaceBox.GraphicsList[i].Clone());
                }

                var newGraphics = newGraphicsList.Where(m => m.ID.Equals(this.ID)).FirstOrDefault();

                if (newGraphics != null)
                {
                    num = newGraphicsList.IndexOf(newGraphics) + 1;
                }

                #endregion

                frontStr = $"[{ num }]{frontStr}";
            }

            if (this.measureStyleModel.showAlias)
            {

                frontStr = this.measureStyleModel.aliasName + frontStr;
            }


            if (HandleCount - 1 >= 2)
            {
                Font textfont = new Font(measureStyleModel.font, measureStyleModel.fontSize);
                Brush textbrush = new SolidBrush(Color.FromArgb(measureStyleModel.textColor));
                g.SmoothingMode = SmoothingMode.AntiAlias;
                Color color = Color.FromArgb(this.measureStyleModel.lineColor);
                Pen pen = new Pen(color, this.measureStyleModel.lineWidth);
                pen.DashStyle = (DashStyle)this.measureStyleModel.lineStyle;

                if (this.Selected)
                {
                    if (measureStyleModel.chooseStyle != null)
                    {
                        textfont = new Font(measureStyleModel.chooseStyle.font, measureStyleModel.chooseStyle.fontSize);
                        textbrush = new SolidBrush(Color.FromArgb(measureStyleModel.chooseStyle.textColor));
                        pen = new Pen(Color.FromArgb(measureStyleModel.chooseStyle.lineColor), measureStyleModel.chooseStyle.lineWidth);
                        pen.DashStyle = (DashStyle)measureStyleModel.chooseStyle.lineStyle;
                    }
                }

                if (!this.Selected)
                {
                    this.pointChange = true;
                    rectangleF1 = new RectangleF();
                    rectangleF2 = new RectangleF();
                    rectangleF3 = new RectangleF();
                    rectangleF4 = new RectangleF();
                    rectangleF5 = new RectangleF();
                    rectangleF6 = new RectangleF();
                    rectangleF7 = new RectangleF();
                    rectangleF8 = new RectangleF();
                    rectangleF9 = new RectangleF();
                }

                g.DrawLine(pen, pointArray[0], pointArray[1]);
                PointList pointFs2 = new PointList();
                if (HandleCount - 1 == 2 || HandleCount - 1 == 3)
                {
                    g.DrawLine(pen, pointArray[0], pointArray[1]);
                    PointF center = new PointF((pointArray[0].X + pointArray[1].X) / 2, (pointArray[0].Y + pointArray[1].Y) / 2);


                    // A点
                    PointF pointFA = pointArray[0];
                    // B点
                    PointF pointFB = pointArray[1];
                    // 中垂线x坐标
                    float x = 0;
                    // 中垂线y坐标
                    float y = 0;
                    // 中垂线方程
                    y = -(pointFA.X - pointFB.X) / (pointFA.Y - pointFB.Y) * x + (pointFA.Y + pointFB.Y) / 2 + (pointFA.X - pointFB.X) / (pointFA.Y - pointFB.Y) * (pointFA.X + pointFB.X) / 2;
                    x = (y - ((pointFA.Y + pointFB.Y) / 2 + (pointFA.X - pointFB.X) / (pointFA.Y - pointFB.Y) * (pointFA.X + pointFB.X) / 2)) / (-(pointFA.X - pointFB.X) / (pointFA.Y - pointFB.Y));
                    List<PointF> pointFs = new PointList();
                    List<PointF> pointFs1 = new PointList();
                    // 求出可能的图片四个边的交点
                    PointF pointFL;
                    x = 0;
                    y = -(pointFA.X - pointFB.X) / (pointFA.Y - pointFB.Y) * x + (pointFA.Y + pointFB.Y) / 2 + (pointFA.X - pointFB.X) / (pointFA.Y - pointFB.Y) * (pointFA.X + pointFB.X) / 2;
                    pointFL = new PointF(x, y);
                    pointFs.Add(pointFL);
                    y = 0;
                    x = (y - ((pointFA.Y + pointFB.Y) / 2 + (pointFA.X - pointFB.X) / (pointFA.Y - pointFB.Y) * (pointFA.X + pointFB.X) / 2)) / (-(pointFA.X - pointFB.X) / (pointFA.Y - pointFB.Y));
                    pointFL = new PointF(x, y);
                    pointFs.Add(pointFL);
                    x = width;
                    y = -(pointFA.X - pointFB.X) / (pointFA.Y - pointFB.Y) * x + (pointFA.Y + pointFB.Y) / 2 + (pointFA.X - pointFB.X) / (pointFA.Y - pointFB.Y) * (pointFA.X + pointFB.X) / 2;
                    pointFL = new PointF(x, y);
                    pointFs.Add(pointFL);
                    y = height;
                    x = (y - ((pointFA.Y + pointFB.Y) / 2 + (pointFA.X - pointFB.X) / (pointFA.Y - pointFB.Y) * (pointFA.X + pointFB.X) / 2)) / (-(pointFA.X - pointFB.X) / (pointFA.Y - pointFB.Y));
                    pointFL = new PointF(x, y);
                    pointFs.Add(pointFL);

                    RectangleF rectangleF = new RectangleF(-10, -10, width + 10, height + 10);
                    foreach (PointF item in pointFs)
                    {
                        if (item.X >= 0 && item.X <= rectangleF.Width && item.Y >= 0 && item.Y <= rectangleF.Height)
                        {
                            pointFs1.Add(item);
                        }
                    }
                    if (pointFs1.Count == 2)
                        g.DrawLines(pen, pointFs1.ToArray());
                }
                if (HandleCount - 1 == 4)
                {
                    g.DrawLine(pen, pointArray[0], pointArray[1]);
                    g.DrawLine(pen, pointArray[2], pointArray[3]);

                    for (int i = 0; i < 2; i++)
                    {
                        // A点
                        PointF pointFA;
                        // B点
                        PointF pointFB;
                        if (i == 0)
                        {
                            // A点
                            pointFA = pointArray[0];
                            if (pointArray[0].X == pointArray[1].X)
                                pointArray[1] = new PointF(pointArray[1].X + 1, pointArray[1].Y);
                            if (pointArray[0].Y == pointArray[1].Y)
                                pointArray[1] = new PointF(pointArray[1].X, pointArray[1].Y + 1);
                            // B点
                            pointFB = pointArray[1];
                        }
                        else
                        {
                            // A点
                            pointFA = pointArray[2];
                            if (pointArray[2].X == pointArray[3].X)
                                pointArray[3] = new PointF(pointArray[3].X + 1, pointArray[3].Y);
                            if (pointArray[2].Y == pointArray[3].Y)
                                pointArray[3] = new PointF(pointArray[3].X, pointArray[3].Y + 1);
                            // B点
                            pointFB = pointArray[3];
                        }
                        // 中垂线x坐标
                        float x = 0;
                        // 中垂线y坐标
                        float y = 0;
                        // 中垂线方程
                        List<PointF> pointFs = new PointList();
                        List<PointF> pointFs1 = new PointList();
                        // 求出可能的图片四个边的交点
                        PointF pointFL;
                        x = 0;
                        y = -(pointFA.X - pointFB.X) / (pointFA.Y - pointFB.Y) * x + (pointFA.Y + pointFB.Y) / 2 + (pointFA.X - pointFB.X) / (pointFA.Y - pointFB.Y) * (pointFA.X + pointFB.X) / 2;
                        if (pointFA.Y == pointFB.Y)
                            y = 0;
                        pointFL = new PointF(x, y);
                        pointFs.Add(pointFL);
                        y = 0;
                        x = (y - ((pointFA.Y + pointFB.Y) / 2 + (pointFA.X - pointFB.X) / (pointFA.Y - pointFB.Y) * (pointFA.X + pointFB.X) / 2)) / (-(pointFA.X - pointFB.X) / (pointFA.Y - pointFB.Y));
                        pointFL = new PointF(x, y);
                        pointFs.Add(pointFL);
                        x = width;
                        y = -(pointFA.X - pointFB.X) / (pointFA.Y - pointFB.Y) * x + (pointFA.Y + pointFB.Y) / 2 + (pointFA.X - pointFB.X) / (pointFA.Y - pointFB.Y) * (pointFA.X + pointFB.X) / 2;
                        if (pointFA.Y == pointFB.Y)
                            y = height;
                        pointFL = new PointF(x, y);
                        pointFs.Add(pointFL);
                        y = height;
                        x = (y - ((pointFA.Y + pointFB.Y) / 2 + (pointFA.X - pointFB.X) / (pointFA.Y - pointFB.Y) * (pointFA.X + pointFB.X) / 2)) / (-(pointFA.X - pointFB.X) / (pointFA.Y - pointFB.Y));


                        pointFL = new PointF(x, y);
                        pointFs.Add(pointFL);

                        foreach (PointF item in pointFs)
                        {
                            if (item.X >= 0 && item.X <= width && item.Y >= 0 && item.Y <= height)
                            {
                                pointFs1.Add(item);
                            }
                        }
                        PointF pointF = new PointF();
                        if (pointFs1.Count == 3)
                        {
                            int add = 0;
                            foreach (var item in pointFs1)
                            {
                                if (add == 0)
                                    pointF = item;
                                else
                                {
                                    if (item.X == pointF.X && item.Y == pointF.Y)
                                    {
                                        pointFs1.Remove(item);
                                        break;
                                    }
                                }
                                add++;
                            }
                        }
                        if (pointFs1.Count == 2)
                        {
                            g.DrawLines(pen, pointFs1.ToArray());
                            if (i == 0)
                                pointFs2.Add(new PointF((pointFs1[0].X + pointFs1[1].X) / 2, (pointFs1[0].Y + pointFs1[1].Y) / 2));
                            else
                            {
                                PointF footPoint = new PointF();
                                if (pointFs2.Count > 0)
                                {
                                    footPoint = BasicCalculationHelper.GetDropFeet(pointFs1[1], pointFs1[0], pointFs2[0]);
                                    pointFs2.Add(footPoint);
                                }
                            }
                        }
                    }
                    if (pointFs2.Count == 2)
                    {
                        g.DrawLines(pen, pointFs2.ToArray());
                        startPoint = pointFs2[0];
                        endPoint = pointFs2[1];
                        // 垂足坐标
                        SizeF sizeF = new SizeF();
                        // 点到直线距离
                        Length = BasicCalculationHelper.GetDistance(pointFs2[0], pointFs2[1], 10);
                        //计算需要旋转的角度
                        angle = BasicCalculationHelper.Angle(pointFs2[0], pointFs2[1], new PointF(pointFs2[0].X, pointFs2[1].Y));
                        Matrix mtxSave = g.Transform;
                        Matrix matrix = g.Transform;
                        // 求线上面三个点
                        int offsetValuePoint = measureStyleModel.fontSize + measureStyleModel.fontSize / 2;
                        int offsetValue1Point = measureStyleModel.lineWidth * 2 / 3;
                        int offsetPoint = offsetValue1Point;
                        if (drawingPropertiesList != null)
                        {
                            // 像素长度
                            if (drawingPropertiesList.Contains(MeasureAttributes.PixelLength.ToString()))
                            {
                                offsetPoint += offsetValuePoint;
                            }
                            // 物理长度
                            if (drawingPropertiesList.Contains(MeasureAttributes.PhysicalLength.ToString()))
                            {
                                offsetPoint += offsetValuePoint;
                            }
                            // 测量方式
                            if (drawingPropertiesList.Contains(MeasureAttributes.MeasureMethod.ToString()))
                            {
                                offsetPoint += offsetValuePoint;
                            }
                            // 测量单位(中文)
                            if (drawingPropertiesList.Contains(MeasureAttributes.MeasureUnitCN.ToString()))
                            {
                                offsetPoint += offsetValuePoint;
                            }
                            // 测量单位(英文)
                            if (drawingPropertiesList.Contains(MeasureAttributes.MeasureUnitEN.ToString()))
                            {
                                offsetPoint += offsetValuePoint;
                            }
                            // 像素起始点X
                            if (drawingPropertiesList.Contains(MeasureAttributes.PixelStartX.ToString()))
                            {
                                offsetPoint += offsetValuePoint;
                            }
                            // 像素起始点Y
                            if (drawingPropertiesList.Contains(MeasureAttributes.PixelStartY.ToString()))
                            {
                                offsetPoint += offsetValuePoint;
                            }
                            // 物理起始点X
                            if (drawingPropertiesList.Contains(MeasureAttributes.PhysicalStartX.ToString()))
                            {
                                offsetPoint += offsetValuePoint;
                            }
                            // 物理起始点Y
                            if (drawingPropertiesList.Contains(MeasureAttributes.PhysicalStartY.ToString()))
                            {
                                offsetPoint += offsetValuePoint;
                            }
                        }
                        PointF pointF1;
                        PointF pointF2;

                        if (angle < 90)
                            pointF1 = BasicCalculationHelper.GetAnglePoint(new Point((int)pointFs2[0].X + offsetPoint + offsetValue1Point, (int)pointFs2[0].Y), pointFs2[0], angle - 90);
                        else
                            pointF1 = BasicCalculationHelper.GetAnglePoint(new Point((int)pointFs2[0].X + offsetPoint + offsetValue1Point, (int)pointFs2[0].Y), pointFs2[0], angle + 90);
                        if (angle < 90)
                            pointF2 = BasicCalculationHelper.GetAnglePoint(new Point((int)pointFs2[1].X + offsetPoint + offsetValue1Point, (int)pointFs2[1].Y), pointFs2[1], angle - 90);
                        else
                            pointF2 = BasicCalculationHelper.GetAnglePoint(new Point((int)pointFs2[1].X + offsetPoint + offsetValue1Point, (int)pointFs2[1].Y), pointFs2[1], angle + 90);
                        PointF pointF3 = new PointF((pointF1.X + pointF2.X) / 2, (pointF1.Y + pointF2.Y) / 2);

                        if (measureStyleModel.linePosition == 0)
                            this.rotationPoint = pointF1;
                        else if (measureStyleModel.linePosition == 1)
                            this.rotationPoint = pointF3;
                        else if (measureStyleModel.linePosition == 2)
                            this.rotationPoint = pointF2;
                        else if (measureStyleModel.linePosition == 3)
                            this.rotationPoint = pointFs2[0];
                        else if (measureStyleModel.linePosition == 4)
                            this.rotationPoint = new PointF((pointFs2[0].X + pointFs2[1].X) / 2, (pointFs2[0].Y + pointFs2[1].Y) / 2);
                        else if (measureStyleModel.linePosition == 5)
                            this.rotationPoint = pointFs2[1];
                        // 画布旋转
                        if (angle < 90)
                        {
                            matrix.RotateAt((float)angle, new PointF(this.rotationPoint.X, this.rotationPoint.Y));
                            g.Transform = matrix;
                        }
                        else
                        {
                            angle = BasicCalculationHelper.Angle(pointFs2[1], pointFs2[0], new PointF(pointFs2[1].X, pointFs2[0].Y));
                            matrix.RotateAt((float)angle, new PointF(this.rotationPoint.X, this.rotationPoint.Y));
                            g.Transform = matrix;
                        }
                        // 是否绘制
                        if (this.pointChange || this.SavePointChange || this.mouseUpPointChange || this.mouseUpAttribute)
                        {
                            // 属性文本的间隔定义
                            int offsetValue = measureStyleModel.fontSize + measureStyleModel.fontSize / 2;
                            int offsetValue1 = measureStyleModel.lineWidth * 2 / 3;
                            int offset = offsetValue1;
                            this.pointL = new Point((int)this.rotationPoint.X, (int)this.rotationPoint.Y);
                            if (drawingPropertiesList != null)
                            {
                                // 像素长度
                                if (drawingPropertiesList.Contains(MeasureAttributes.PixelLength.ToString()))
                                {
                                    sizeF = g.MeasureString(frontStr + "" + Math.Round(Length, decimalPlaces) + "px", textfont);
                                    rectangleF8.Location = new Point((int)this.rotationPoint.X + offsetValue1 - (int)sizeF.Width / 2, (int)this.rotationPoint.Y + offset);
                                    offset += offsetValue;
                                }
                                // 物理长度
                                if (drawingPropertiesList.Contains(MeasureAttributes.PhysicalLength.ToString()))
                                {
                                    string s = Math.Round(Length * unitLength, decimalPlaces).ToString();
                                    if (s.IndexOf(".") == -1)
                                    {
                                        for (int i = 0; i < decimalPlaces; i++)
                                        {
                                            if (i == 0)
                                                s += ".";
                                            s += "0";
                                        }
                                    }
                                    else
                                    {
                                        int a = s.Length - s.IndexOf(".") - 1;
                                        if (a < decimalPlaces)
                                        {
                                            for (int i = 0; i < decimalPlaces - a; i++)
                                            {
                                                s += "0";
                                            }
                                        }
                                    }

                                    sizeF = g.MeasureString(frontStr + s + this.unit, textfont);
                                    rectangleF9.Location = new Point((int)this.rotationPoint.X + offsetValue1 - (int)sizeF.Width / 2, (int)this.rotationPoint.Y + offset);
                                    offset += offsetValue;
                                }
                                // 测量方式
                                if (drawingPropertiesList.Contains(MeasureAttributes.MeasureMethod.ToString()))
                                {
                                    sizeF = g.MeasureString(frontStr + "" + PdnResources.GetString("Menu.MeasureAction.LengthMeasurement.Text"), textfont);
                                    rectangleF1.Location = new Point((int)this.rotationPoint.X + offsetValue1 - (int)sizeF.Width / 2, (int)this.rotationPoint.Y + offset);
                                    offset += offsetValue;
                                }
                                // 测量单位(中文)
                                if (drawingPropertiesList.Contains(MeasureAttributes.MeasureUnitCN.ToString()))
                                {
                                    sizeF = g.MeasureString(frontStr + "" + this.unitString, textfont);
                                    rectangleF2.Location = new Point((int)this.rotationPoint.X + offsetValue1 - (int)sizeF.Width / 2, (int)this.rotationPoint.Y + offset);
                                    offset += offsetValue;
                                }
                                // 测量单位(英文)
                                if (drawingPropertiesList.Contains(MeasureAttributes.MeasureUnitEN.ToString()))
                                {
                                    sizeF = g.MeasureString(frontStr + "" + this.unit, textfont);
                                    rectangleF3.Location = new Point((int)this.rotationPoint.X + offsetValue1 - (int)sizeF.Width / 2, (int)this.rotationPoint.Y + offset);
                                    offset += offsetValue;
                                }
                                // 像素起始点X
                                if (drawingPropertiesList.Contains(MeasureAttributes.PixelStartX.ToString()))
                                {
                                    sizeF = g.MeasureString(frontStr + "" + pointFs2[0].X, textfont);
                                    rectangleF4.Location = new Point((int)this.rotationPoint.X + offsetValue1 - (int)sizeF.Width / 2, (int)this.rotationPoint.Y + offset);
                                    offset += offsetValue;
                                }
                                // 像素起始点Y
                                if (drawingPropertiesList.Contains(MeasureAttributes.PixelStartY.ToString()))
                                {
                                    sizeF = g.MeasureString(frontStr + "" + pointFs2[0].Y, textfont);
                                    rectangleF5.Location = new Point((int)this.rotationPoint.X + offsetValue1 - (int)sizeF.Width / 2, (int)this.rotationPoint.Y + offset);
                                    offset += offsetValue;
                                }
                                // 物理起始点X
                                if (drawingPropertiesList.Contains(MeasureAttributes.PhysicalStartX.ToString()))
                                {
                                    sizeF = g.MeasureString(frontStr + "" + Math.Round(pointFs2[0].X * unitLength, decimalPlaces), textfont);
                                    rectangleF6.Location = new Point((int)this.rotationPoint.X + offsetValue1 - (int)sizeF.Width / 2, (int)this.rotationPoint.Y + offset);
                                    offset += offsetValue;
                                }
                                // 物理起始点Y
                                if (drawingPropertiesList.Contains(MeasureAttributes.PhysicalStartY.ToString()))
                                {
                                    sizeF = g.MeasureString(frontStr + "" + Math.Round(pointFs2[0].Y * unitLength, decimalPlaces), textfont);
                                    rectangleF7.Location = new Point((int)this.rotationPoint.X + offsetValue1 - (int)sizeF.Width / 2, (int)this.rotationPoint.Y + offset);
                                    offset += offsetValue;
                                }
                            }
                        }
                        if (drawingPropertiesList != null)
                        {
                            // 测量方式
                            if (drawingPropertiesList.Contains(MeasureAttributes.MeasureMethod.ToString()))
                            {
                                sizeF = g.MeasureString(frontStr + "" + PdnResources.GetString("Menu.MeasureAction.LengthMeasurement.Text"), textfont);
                                rectangleF1.Width = sizeF.Width;
                                rectangleF1.Height = sizeF.Height;
                                g.DrawString(frontStr + "" + PdnResources.GetString("Menu.MeasureAction.LengthMeasurement.Text"), textfont, textbrush, rectangleF1);
                            }
                            else
                            {
                                rectangleF1 = new RectangleF();
                            }
                            // 测量单位(中文)
                            if (drawingPropertiesList.Contains(MeasureAttributes.MeasureUnitCN.ToString()))
                            {
                                sizeF = g.MeasureString(frontStr + "" + this.unitString, textfont);
                                rectangleF2.Width = sizeF.Width;
                                rectangleF2.Height = sizeF.Height;
                                g.DrawString(frontStr + "" + this.unitString, textfont, textbrush, rectangleF2);
                            }
                            else
                            {
                                rectangleF2 = new RectangleF();
                            }
                            // 测量单位(英文)
                            if (drawingPropertiesList.Contains(MeasureAttributes.MeasureUnitEN.ToString()))
                            {
                                sizeF = g.MeasureString(frontStr + "" + this.unit, textfont);
                                rectangleF3.Width = sizeF.Width;
                                rectangleF3.Height = sizeF.Height;
                                g.DrawString(frontStr + "" + this.unit, textfont, textbrush, rectangleF3);
                            }
                            else
                            {
                                rectangleF3 = new RectangleF();
                            }
                            // 像素起始点X
                            if (drawingPropertiesList.Contains(MeasureAttributes.PixelStartX.ToString()))
                            {
                                sizeF = g.MeasureString(frontStr + "" + pointFs2[0].X, textfont);
                                rectangleF4.Width = sizeF.Width;
                                rectangleF4.Height = sizeF.Height;
                                g.DrawString(frontStr + "" + pointFs2[0].X, textfont, textbrush, rectangleF4);
                            }
                            else
                            {
                                rectangleF4 = new RectangleF();
                            }
                            // 像素起始点Y
                            if (drawingPropertiesList.Contains(MeasureAttributes.PixelStartY.ToString()))
                            {
                                sizeF = g.MeasureString(frontStr + "" + pointFs2[0].Y, textfont);
                                rectangleF5.Width = sizeF.Width;
                                rectangleF5.Height = sizeF.Height;
                                g.DrawString(frontStr + "" + pointFs2[0].Y, textfont, textbrush, rectangleF5);
                            }
                            else
                            {
                                rectangleF5 = new RectangleF();
                            }
                            // 物理起始点X
                            if (drawingPropertiesList.Contains(MeasureAttributes.PhysicalStartX.ToString()))
                            {
                                sizeF = g.MeasureString(frontStr + "" + Math.Round(pointFs2[0].X * unitLength, decimalPlaces), textfont);
                                rectangleF6.Width = sizeF.Width;
                                rectangleF6.Height = sizeF.Height;
                                g.DrawString(frontStr + "" + Math.Round(pointFs2[0].X * unitLength, decimalPlaces), textfont, textbrush, rectangleF6);
                            }
                            else
                            {
                                rectangleF6 = new RectangleF();
                            }
                            // 物理起始点Y
                            if (drawingPropertiesList.Contains(MeasureAttributes.PhysicalStartY.ToString()))
                            {
                                sizeF = g.MeasureString(frontStr + "" + Math.Round(pointFs2[0].Y * unitLength, decimalPlaces), textfont);
                                rectangleF7.Width = sizeF.Width;
                                rectangleF7.Height = sizeF.Height;
                                g.DrawString(frontStr + "" + Math.Round(pointFs2[0].Y * unitLength, decimalPlaces), textfont, textbrush, rectangleF7);
                            }
                            else
                            {
                                rectangleF7 = new RectangleF();
                            }
                            // 像素长度
                            if (drawingPropertiesList.Contains(MeasureAttributes.PixelLength.ToString()))
                            {
                                sizeF = g.MeasureString(frontStr + "" + Math.Round(Length, decimalPlaces) + "px", textfont);
                                rectangleF8.Width = sizeF.Width;
                                rectangleF8.Height = sizeF.Height;
                                g.DrawString(frontStr + "" + Math.Round(Length, decimalPlaces) + "px", textfont, textbrush, rectangleF8);
                            }
                            else
                            {
                                rectangleF8 = new RectangleF();
                            }
                            // 物理长度
                            if (drawingPropertiesList.Contains(MeasureAttributes.PhysicalLength.ToString()))
                            {
                                string s = Math.Round(Length * unitLength, decimalPlaces).ToString();
                                if (s.IndexOf(".") == -1)
                                {
                                    for (int i = 0; i < decimalPlaces; i++)
                                    {
                                        if (i == 0)
                                            s += ".";
                                        s += "0";
                                    }
                                }
                                else
                                {
                                    int a = s.Length - s.IndexOf(".") - 1;
                                    if (a < decimalPlaces)
                                    {
                                        for (int i = 0; i < decimalPlaces - a; i++)
                                        {
                                            s += "0";
                                        }
                                    }
                                }

                                sizeF = g.MeasureString(frontStr + s + this.unit, textfont);
                                rectangleF9.Width = sizeF.Width;
                                rectangleF9.Height = sizeF.Height;
                                g.DrawString(frontStr + s + this.unit, textfont, textbrush, rectangleF9);
                            }
                            else
                            {
                                rectangleF9 = new RectangleF();
                            }
                        }
                        //还原为原始旋转矩阵
                        g.Transform = mtxSave;
                        matrix.Dispose();
                    }
                    pen.Dispose();
                }
            }
            if (this.configurationFile)
                this.pointChange = false;
            this.mouseUpAttribute = false;
            pointChangeObject.Remove(this.drawToolType);
        }
        /// <summary>
        /// 停止绘制时
        /// </summary>
        /// <param name="up"></param>
        public override void MouseUp(bool up)
        {
            mouseUpPointChange = up;
        }
        public void AddPoint(Point point)
        {
            pointArray.Add(point);
        }

        public override int HandleCount
        {
            get
            {
                return pointArray.Count + 1;
            }
        }

        /// <summary>
        /// Get handle pointscroll by 1-based number
        /// </summary>
        /// <param name="handleNumber"></param>
        /// <returns></returns>
        public override PointF GetHandle(int handleNumber)
        {
            if (handleNumber < 1)
                handleNumber = 1;

            if (handleNumber > pointArray.Count && handleNumber != pointArray.Count + 1)
                handleNumber = pointArray.Count;
            if (handleNumber == pointArray.Count + 1)
                return this.pointL;
            else
                return pointArray[handleNumber - 1];
        }

        public override Cursor GetHandleCursor(int handleNumber)
        {
            return handleCursor;
        }
        private Point GetInsectPoint(Point pt1, Point pt2, int insectPtY)
        {
            Point pt = new Point();

            float k = 0f;
            if (pt1.X == pt2.X)//不存在斜率x=x1为直线方程90度
            {
                pt.X = pt1.X;
                pt.Y = insectPtY;
                return pt;
            }
            else if (pt1.Y == pt2.Y && pt1.Y != insectPtY)//y=y1为直线方程,0度,两条直线平行没有交点
            {
                return pt;
            }
            else if (pt1.Y == pt2.Y && pt1.Y == insectPtY)//0度，两条直线重合，任意点即为交点
            {
                pt.X = pt1.X;
                pt.Y = insectPtY;
                return pt;
            }
            else
            {
                k = (float)(pt2.Y - pt1.Y) / (float)(pt2.X - pt1.X);
                float b = pt1.Y - k * pt1.X;

                float x = (insectPtY - b) / k;
                pt.X = (int)x;
                pt.Y = insectPtY;
            }
            return pt;
        }
        public override void MoveHandleTo(Point point, int handleNumber)
        {
            double k = 0.0;
            if (handleNumber < 1)
                handleNumber = 1;

            if (handleNumber > pointArray.Count && handleNumber != pointArray.Count + 1)
                handleNumber = pointArray.Count;
            if (handleNumber == pointArray.Count + 1)
            {
                point = SetOffsetAfterRotation(point, this.rotationPoint, angle);
                if (this.moveKb == 1)
                    this.rectangleF1.Offset(point.X - this.pointL.X, point.Y - this.pointL.Y);
                else if (this.moveKb == 2)
                    this.rectangleF2.Offset(point.X - this.pointL.X, point.Y - this.pointL.Y);
                else if (this.moveKb == 3)
                    this.rectangleF3.Offset(point.X - this.pointL.X, point.Y - this.pointL.Y);
                else if (this.moveKb == 4)
                    this.rectangleF4.Offset(point.X - this.pointL.X, point.Y - this.pointL.Y);
                else if (this.moveKb == 5)
                    this.rectangleF5.Offset(point.X - this.pointL.X, point.Y - this.pointL.Y);
                else if (this.moveKb == 6)
                    this.rectangleF6.Offset(point.X - this.pointL.X, point.Y - this.pointL.Y);
                else if (this.moveKb == 7)
                    this.rectangleF7.Offset(point.X - this.pointL.X, point.Y - this.pointL.Y);
                else if (this.moveKb == 8)
                    this.rectangleF8.Offset(point.X - this.pointL.X, point.Y - this.pointL.Y);
                else if (this.moveKb == 9)
                    this.rectangleF9.Offset(point.X - this.pointL.X, point.Y - this.pointL.Y);
                this.pointL = point;
            }
            else
            {
                this.mouseUpPointChange = true;
                if (handleNumber == 1)
                {
                    this.rectangleF1.Offset(point.X - this.rotationPoint.X, point.Y - this.rotationPoint.Y);
                    this.rectangleF2.Offset(point.X - this.rotationPoint.X, point.Y - this.rotationPoint.Y);
                    this.rectangleF3.Offset(point.X - this.rotationPoint.X, point.Y - this.rotationPoint.Y);
                    this.rectangleF4.Offset(point.X - this.rotationPoint.X, point.Y - this.rotationPoint.Y);
                    this.rectangleF5.Offset(point.X - this.rotationPoint.X, point.Y - this.rotationPoint.Y);
                    this.rectangleF6.Offset(point.X - this.rotationPoint.X, point.Y - this.rotationPoint.Y);
                    this.rectangleF7.Offset(point.X - this.rotationPoint.X, point.Y - this.rotationPoint.Y);
                    this.rectangleF8.Offset(point.X - this.rotationPoint.X, point.Y - this.rotationPoint.Y);
                    this.rectangleF9.Offset(point.X - this.rotationPoint.X, point.Y - this.rotationPoint.Y);
                    //double angle = BasicCalculationHelper.Angle(pointArray[0], pointArray[1], new PointF(pointArray[0].X, pointArray[1].Y));
                    pointArray[handleNumber - 1] = point;
                    //double angle1 = BasicCalculationHelper.Angle(pointArray[0], pointArray[1], new PointF(pointArray[0].X, pointArray[1].Y));
                    //PointF pointF = BasicCalculationHelper.GetAnglePoint(pointArray[3], pointArray[2],  - (angle - angle1));
                    //pointArray[3] = pointF;
                    MoveHandleTo(point, 4);
                }
                else if (handleNumber == 2)
                {
                    //double angle = BasicCalculationHelper.Angle(pointArray[1], pointArray[0], new PointF(pointArray[1].X, pointArray[0].Y));
                    pointArray[handleNumber - 1] = point;
                    //double angle1 = BasicCalculationHelper.Angle(pointArray[1], pointArray[0], new PointF(pointArray[1].X, pointArray[0].Y));
                    //PointF pointF = BasicCalculationHelper.GetAnglePoint(pointArray[2], pointArray[3],  - (angle - angle1));
                    //pointArray[2] = pointF;
                    MoveHandleTo(point, 3);
                }
                else if (handleNumber == 4)
                {
                    k = (double)(pointArray[1].Y - pointArray[0].Y) / (pointArray[1].X - pointArray[0].X);
                    double y = 0;
                    double x = 0;
                    if (Math.Abs(k) >= 1)
                    {
                        y = point.Y;
                        x = (point.Y - pointArray[2].Y) / k + pointArray[2].X;
                    }
                    else
                    {
                        x = point.X;
                        y = k * (point.X - pointArray[2].X) + pointArray[2].Y;
                    }
                    point = new Point((int)x, (int)y);
                    pointArray[handleNumber - 1] = point;
                }
                else if (handleNumber == 3)
                {
                    k = (double)(pointArray[1].Y - pointArray[0].Y) / (pointArray[1].X - pointArray[0].X);
                    double y = 0;
                    double x = 0;
                    if (Math.Abs(k) >= 1)
                    {
                        y = point.Y;
                        x = (point.Y - pointArray[3].Y) / k + pointArray[3].X;
                    }
                    else
                    {
                        x = point.X;
                        y = k * (point.X - pointArray[3].X) + pointArray[3].Y;
                    }
                    point = new Point((int)x, (int)y);
                    pointArray[handleNumber - 1] = point;
                }
            }

            Invalidate();
        }

        public override void Move(int deltaX, int deltaY)
        {
            int n = pointArray.Count;
            for (int i = 0; i < n; i++)
            {
                PointF point = new PointF(pointArray[i].X + ISurfaceBox.UnscaleScalar(deltaX), pointArray[i].Y + ISurfaceBox.UnscaleScalar(deltaY));

                pointArray[i] = point;
            }
            this.startPoint = pointArray[0];
            int x = ISurfaceBox.UnscaleScalar(deltaX);
            int y = ISurfaceBox.UnscaleScalar(deltaY);
            pointL.X += x;
            pointL.Y += y;
            this.mouseUpPointChange = true;
            Invalidate();
        }

        /// <summary>
        /// 用于创建一个路径或者是闭合的范围
        /// 用于响应点击选中
        /// 需要咨询用户是仅点击线还是矩形选择
        /// </summary>
        protected virtual void CreateObjects()
        {
            if (AreaPath != null)
                return;

            AreaPath = new GraphicsPath();
            AreaPath.AddRectangle(GetBoundingBox());
            AreaPath.CloseFigure();
            AreaRegion = new Region(AreaPath);
        }

        /// <summary>
        /// Invalidate object.
        /// When object is invalidated, path used for hit test
        /// is released and should be created again.
        /// </summary>
        protected void Invalidate()
        {
            if (AreaPath != null)
            {
                AreaPath.Dispose();
                AreaPath = null;
            }

            if (AreaPen != null)
            {
                AreaPen.Dispose();
                AreaPen = null;
            }

            if (AreaRegion != null)
            {
                AreaRegion.Dispose();
                AreaRegion = null;
            }
        }
        protected GraphicsPath AreaPath
        {
            get
            {
                return areaPath;
            }
            set
            {
                areaPath = value;
            }
        }

        protected Pen AreaPen
        {
            get
            {
                return areaPen;
            }
            set
            {
                areaPen = value;
            }
        }

        protected Region AreaRegion
        {
            get
            {
                return areaRegion;
            }
            set
            {
                areaRegion = value;
            }
        }

        /// <summary>
        /// Draw tracker for selected object
        /// </summary>
        /// <param name="g"></param>
        public override void DrawTracker(Graphics g)
        {
            if (!Selected)
                return;

            SolidBrush brush = new SolidBrush(Color.FromArgb(MarkpointAreaColor));
            Pen pen = new Pen(Color.FromArgb(MarkpointLineColor), MarkpointLineWidth);
            for (int i = 1; i <= HandleCount; i++)
            {
                if (i == HandleCount)
                {
                    brush = new SolidBrush(Color.Transparent);
                    pen = new Pen(Color.Transparent);
                }
                switch (MarkpointStyle)
                {
                    case 0:
                        g.FillRectangle(brush, GetHandleRectangle(i));
                        g.DrawRectangle(pen, GetHandleRectangle(i));
                        break;
                    case 1:
                        g.FillEllipse(brush, GetHandleRectangle(i));
                        g.DrawEllipse(pen, GetHandleRectangle(i));
                        break;
                    case 2:
                        g.FillPolygon(brush, GetHandlePoint(i));
                        g.DrawPolygon(pen, GetHandlePoint(i));
                        break;
                }
            }

            brush.Dispose();
            pen.Dispose();
            RectangleF r = GetBoundingBox();
            //g.DrawRectangle(new Pen(Color.White), r.X, r.Y, r.Width, r.Height);
        }
        Point point = new Point();
        /// <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)
        {
            this.point = point;
            if (Selected)
            {
                for (int i = 1; i <= HandleCount; i++)
                {
                    if (GetHandleRectangle(i).Contains(point))
                        return i;
                }
                if (GetRectanglePosition(this.rectangleF1, point, rotationPoint, angle))
                {
                    this.pointL = SetOffsetAfterRotation(point, rotationPoint, angle);
                    moveKb = 1;
                    return this.pointArray.Count + 1;
                }
                else if (GetRectanglePosition(this.rectangleF2, point, rotationPoint, angle))
                {
                    this.pointL = SetOffsetAfterRotation(point, rotationPoint, angle);
                    moveKb = 2;
                    return this.pointArray.Count + 1;
                }
                else if (GetRectanglePosition(this.rectangleF3, point, rotationPoint, angle))
                {
                    this.pointL = SetOffsetAfterRotation(point, rotationPoint, angle);
                    moveKb = 3;
                    return this.pointArray.Count + 1;
                }
                else if (GetRectanglePosition(this.rectangleF4, point, rotationPoint, angle))
                {
                    this.pointL = SetOffsetAfterRotation(point, rotationPoint, angle);
                    moveKb = 4;
                    return this.pointArray.Count + 1;
                }
                else if (GetRectanglePosition(this.rectangleF5, point, rotationPoint, angle))
                {
                    this.pointL = SetOffsetAfterRotation(point, rotationPoint, angle);
                    moveKb = 5;
                    return this.pointArray.Count + 1;
                }
                else if (GetRectanglePosition(this.rectangleF6, point, rotationPoint, angle))
                {
                    this.pointL = SetOffsetAfterRotation(point, rotationPoint, angle);
                    moveKb = 6;
                    return this.pointArray.Count + 1;
                }
                else if (GetRectanglePosition(this.rectangleF7, point, rotationPoint, angle))
                {
                    this.pointL = SetOffsetAfterRotation(point, rotationPoint, angle);
                    moveKb = 7;
                    return this.pointArray.Count + 1;
                }
                else if (GetRectanglePosition(this.rectangleF8, point, rotationPoint, angle))
                {
                    this.pointL = SetOffsetAfterRotation(point, rotationPoint, angle);
                    moveKb = 8;
                    return this.pointArray.Count + 1;
                }
                else if (GetRectanglePosition(this.rectangleF9, point, rotationPoint, angle))
                {
                    this.pointL = SetOffsetAfterRotation(point, rotationPoint, angle);
                    moveKb = 9;
                    return this.pointArray.Count + 1;
                }
            }
            if (PointInObject(point))
                return 0;

            return -1;
        }

        protected override bool PointInObject(Point point)
        {
            CreateObjects();

            return AreaRegion.IsVisible(point);
        }
        public override bool IntersectsWith(Rectangle rectangle)
        {
            CreateObjects();

            return AreaRegion.IsVisible(rectangle);
        }
        public override RectangleF GetBoundingBox()
        {
            float minx = 0, maxx = 0, miny = 0, maxy = 0;
            for (int i = 0; i < pointArray.Count; i++)
            {
                if (i == 0)
                {
                    minx = maxx = pointArray[i].X;
                    miny = maxy = pointArray[i].Y;
                }
                else
                {
                    if (pointArray[i].X > maxx) maxx = pointArray[i].X;
                    if (pointArray[i].X < minx) minx = pointArray[i].X;
                    if (pointArray[i].Y > maxy) maxy = pointArray[i].Y;
                    if (pointArray[i].Y < miny) miny = pointArray[i].Y;
                }
            }
            return new RectangleF(minx, miny, maxx - minx, maxy - miny);
        }

        internal void setNextPoint(Point p)
        {
            AddPoint(p);
            //startPoint = endPoint;
            //endPoint = p;
        }

        internal void setEndPoint(Point p)
        {
            endPoint = p;
        }
        public override List<PointF> GetPoints()
        {
            return pointArray;
        }

        public override ParentStyleModel GetStyle()
        {
            return measureStyleModel;
        }
    }
}