LIBMAS/Data/Preview/RulerPro.cs

using PaintDotNet.SystemLayer;
using System;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;

namespace PaintDotNet
{
    /// <summary>
    /// 顶部和左侧的标尺控件
    /// </summary>
    public sealed class RulerPro : UserControl
    {
        /// <summary>
        /// 默认单位，英寸
        /// </summary>
        private MeasurementUnit measurementUnit = MeasurementUnit.Inch;

        public MeasurementUnit MeasurementUnit
        {
            get
            {
                return measurementUnit;
            }

            set
            {
                if (value != measurementUnit)
                {
                    measurementUnit = value;
                    Invalidate();
                }
            }
        }

        /// <summary>
        /// 默认方向 水平
        /// </summary>
        private Orientation orientation = Orientation.Horizontal;

        [DefaultValue(Orientation.Horizontal)]
        public Orientation Orientation
        {
            get
            {
                return orientation;
            }

            set
            {
                if (orientation != value)
                {
                    orientation = value;
                    Invalidate();
                }
            }
        }

        /// <summary>
        /// 每英寸长度内的像素点数
        /// 默认写死的dpi，96没有实际意义
        /// 需要从标尺读取
        /// </summary>
        private double dpu = 96;

        [DefaultValue(96.0)]
        public double Dpu
        {
            get
            {
                return dpu;
            }

            set
            {
                if (value != dpu)
                {
                    dpu = value;
                    Invalidate();
                }
            }
        }

        /// <summary>
        /// 封装了缩放功能的结构体
        /// </summary>
        private ScaleFactor scaleFactor = ScaleFactor.OneToOne;

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

            set
            {
                if (scaleFactor != value)
                {
                    scaleFactor = value;
                    Invalidate();
                }
            }
        }

        private float offset = 0;

        [DefaultValue(0)]
        public float Offset
        {
            get
            {
                return offset;
            }

            set
            {
                if (offset != value)
                {
                    offset = value;
                    Invalidate();
                }
            }
        }

        private float rulerValue = 0.0f;

        [DefaultValue(0)]
        public float Value
        {
            get
            {
                return rulerValue;
            }

            set
            {
                if (this.rulerValue != value)
                {
                    float oldStart = this.scaleFactor.ScaleScalar(this.rulerValue - offset) - 1;
                    float oldEnd = this.scaleFactor.ScaleScalar(this.rulerValue + 1 - offset) + 1;
                    RectangleF oldRect;

                    if (this.orientation == Orientation.Horizontal)
                    {
                        oldRect = new RectangleF(oldStart, this.ClientRectangle.Top, oldEnd - oldStart, this.ClientRectangle.Height);
                    }
                    else // if (this.orientation == Orientation.Vertical)
                    {
                        oldRect = new RectangleF(this.ClientRectangle.Left, oldStart, this.ClientRectangle.Width, oldEnd - oldStart);
                    }

                    float newStart = this.scaleFactor.ScaleScalar(value - offset);
                    float newEnd = this.scaleFactor.ScaleScalar(value + 1 - offset);
                    RectangleF newRect;

                    if (this.orientation == Orientation.Horizontal)
                    {
                        newRect = new RectangleF(newStart, this.ClientRectangle.Top, newEnd - newStart, this.ClientRectangle.Height);
                    }
                    else // if (this.orientation == Orientation.Vertical)
                    {
                        newRect = new RectangleF(this.ClientRectangle.Left, newStart, this.ClientRectangle.Width, newEnd - newStart);
                    }

                    this.rulerValue = value;

                    Invalidate(Utility.RoundRectangle(oldRect));
                    Invalidate(Utility.RoundRectangle(newRect));
                }
            }
        }

        private float highlightStart = 2048.0f;
        public float HighlightStart
        {
            get
            {
                return this.highlightStart;
            }

            set
            {
                if (this.highlightStart != value)
                {
                    this.highlightStart = value;
                    Invalidate();
                }
            }
        }

        private float highlightLength = 2448.0f;
        public float HighlightLength
        {
            get
            {
                return this.highlightLength;
            }

            set
            {
                if (this.highlightLength != value)
                {
                    this.highlightLength = value;
                    Invalidate();
                }
            }
        }

        /// <summary>
        /// 构造方法
        /// </summary>
        public RulerPro()
        {
            SetStyle(ControlStyles.OptimizedDoubleBuffer | ControlStyles.UserPaint | ControlStyles.AllPaintingInWmPaint, true);
        }

        protected override void OnPaint(PaintEventArgs e)
        {

            float highlightStartPx = this.scaleFactor.ScaleScalar(this.highlightStart - offset);
            float highlightEndPx = this.scaleFactor.ScaleScalar(this.highlightStart + this.highlightLength - offset);

            RectangleF highlightRect;
            var hilitBrush = new SolidBrush(Color.FromArgb(128, 128, 128, 128));
            var hilitPen = new Pen(Color.FromArgb(200, 128, 128, 128));

            if (this.orientation == Orientation.Horizontal)
            {
                e.Graphics.DrawLine(SystemPens.WindowText, UI.ScaleWidth(Height - 1), ClientRectangle.Top, UI.ScaleWidth(Height - 1), ClientRectangle.Bottom);

                DrawRuler(e);
                highlightRect = new RectangleF(highlightStartPx, this.ClientRectangle.Top, highlightEndPx - highlightStartPx, this.ClientRectangle.Height - 11);
                e.Graphics.FillRectangle(hilitBrush, highlightRect);
                e.Graphics.DrawRectangle(hilitPen, Rectangle.Round(highlightRect));

            }
            else if (this.orientation == Orientation.Vertical)
            {
                highlightRect = new RectangleF(this.ClientRectangle.Left, highlightStartPx, this.ClientRectangle.Width - 11, highlightEndPx - highlightStartPx);

                DrawRuler(e);
                e.Graphics.FillRectangle(hilitBrush, highlightRect);
                e.Graphics.DrawRectangle(hilitPen, Rectangle.Round(highlightRect));

            }
        }

        private static readonly float[] majorDivisors =
            new float[]
            {
                5.0f,
                4.0f,
                5.0f,
                4.0f,
                5.0f,
            };

        private int[] GetSubdivs(MeasurementUnit unit)
        {
            switch (unit)
            {
                case MeasurementUnit.Inch:
                    {
                        return new int[] { 2 };
                    }

                case MeasurementUnit.Mil:
                    {
                        return new int[] { 2 };
                    }

                case MeasurementUnit.Centimeter:
                    {
                        return new int[] { 2 };
                    }

                case MeasurementUnit.Millimeter:
                    {
                        return new int[] { 2 };
                    }

                case MeasurementUnit.Micron:
                    {
                        return new int[] { 2 };
                    }

                case MeasurementUnit.Nano:
                    {
                        return new int[] { 2 };
                    }

                default:
                    {
                        return null;
                    }
            }
        }

        /// <summary>
        /// 分割x轴
        /// </summary>
        /// <param name="g"></param>
        /// <param name="pen"></param>
        /// <param name="x"></param>
        /// <param name="delta"></param>
        /// <param name="index"></param>
        /// <param name="y"></param>
        /// <param name="height"></param>
        /// <param name="subdivs"></param>
        private void SubdivideX(
            Graphics g,
            Pen pen,
            float x,
            float delta,
            int index,
            float y,
            float height,
            int[] subdivs)
        {
            g.DrawLine(pen, x, y, x, y + height);

            if (index > 10)
            {
                return;
            }

            float div;

            if (subdivs != null && index >= 0)
            {
                div = subdivs[index % subdivs.Length];
            }
            else if (index < 0)
            {
                div = majorDivisors[(-index - 1) % majorDivisors.Length];
            }
            else
            {
                return;
            }

            for (int i = 0; i < div; i++)
            {
                if ((delta / div) > 3.5)
                {
                    SubdivideX(g, pen, x + delta * i / div, delta / div, index + 1, y, height / div + 0.5f, subdivs);
                }
            }
        }

        /// <summary>
        /// 分割y轴
        /// </summary>
        /// <param name="g"></param>
        /// <param name="pen"></param>
        /// <param name="y"></param>
        /// <param name="delta"></param>
        /// <param name="index"></param>
        /// <param name="x"></param>
        /// <param name="width"></param>
        /// <param name="subdivs"></param>
        private void SubdivideY(
            Graphics g,
            Pen pen,
            float y,
            float delta,
            int index,
            float x,
            float width,
            int[] subdivs)
        {
            g.DrawLine(pen, x, y, x + width, y);

            if (index > 10)
            {
                return;
            }

            float div;

            if (subdivs != null && index >= 0)
            {
                div = subdivs[index % subdivs.Length];
            }
            else if (index < 0)
            {
                div = majorDivisors[(-index - 1) % majorDivisors.Length];
            }
            else
            {
                return;
            }

            for (int i = 0; i < div; i++)
            {
                if ((delta / div) > 3.5)
                {
                    SubdivideY(g, pen, y + delta * i / div, delta / div, index + 1, x, width / div + 0.5f, subdivs);
                }
            }
        }

        /// <summary>
        /// 绘制标尺
        /// </summary>
        /// <param name="e"></param>
        /// <param name="highlighted"></param>
        private void DrawRuler(PaintEventArgs e)
        {
            Pen pen;
            Brush cursorBrush;
            Brush textBrush;
            StringFormat textFormat = new StringFormat();
            int maxPixel;
            Color cursorColor;

            pen = SystemPens.WindowText;
            textBrush = SystemBrushes.WindowText;
            cursorColor = SystemColors.Highlight;

            cursorColor = Color.FromArgb(128, cursorColor);
            cursorBrush = new SolidBrush(cursorColor);

            if (orientation == Orientation.Horizontal)
            {
                maxPixel = ScaleFactor.UnscaleScalar(ClientRectangle.Width);
                textFormat.Alignment = StringAlignment.Near;
                textFormat.LineAlignment = StringAlignment.Far;
            }
            else // if (orientation == Orientation.Vertical)
            {
                maxPixel = ScaleFactor.UnscaleScalar(ClientRectangle.Height);
                textFormat.Alignment = StringAlignment.Near;
                textFormat.LineAlignment = StringAlignment.Near;
                textFormat.FormatFlags |= StringFormatFlags.DirectionVertical;
            }

            float majorSkip = 1f;

            int majorSkipPower = 0;
            float majorDivisionLength = (float)dpu;
            float majorDivisionPixels = (float)ScaleFactor.ScaleScalar(majorDivisionLength);
            int[] subdivs = GetSubdivs(measurementUnit);
            float offsetPixels = ScaleFactor.ScaleScalar((float)offset);
            int startMajor = (int)(offset / majorDivisionLength) - 1;
            int endMajor = (int)((offset + maxPixel) / majorDivisionLength) + 1;

            if (orientation == Orientation.Horizontal)
            {
                PointF pt = scaleFactor.ScalePointJustX(new PointF(ClientRectangle.Left + Value - Offset, ClientRectangle.Top));
                SizeF size = new SizeF(Math.Max(1, scaleFactor.ScaleScalar(1.0f)), ClientRectangle.Height);

                pt.X -= 0.5f;

                CompositingMode oldCM = e.Graphics.CompositingMode;
                e.Graphics.CompositingMode = CompositingMode.SourceOver;
                e.Graphics.FillRectangle(cursorBrush, new RectangleF(pt, size));
                e.Graphics.CompositingMode = oldCM;

                // draw border
                e.Graphics.DrawLine(SystemPens.WindowText, new Point(ClientRectangle.Left, ClientRectangle.Bottom - 1),
                    new Point(ClientRectangle.Right - 1, ClientRectangle.Bottom - 1));
            }
            else if (orientation == Orientation.Vertical)
            {
                PointF pt = scaleFactor.ScalePointJustY(new PointF(ClientRectangle.Left, ClientRectangle.Top + Value - Offset));
                SizeF size = new SizeF(ClientRectangle.Width, Math.Max(1, scaleFactor.ScaleScalar(1.0f)));

                pt.Y -= 0.5f;

                CompositingMode oldCM = e.Graphics.CompositingMode;
                e.Graphics.CompositingMode = CompositingMode.SourceOver;
                e.Graphics.FillRectangle(cursorBrush, new RectangleF(pt, size));
                e.Graphics.CompositingMode = oldCM;


                // draw border
                e.Graphics.DrawLine(SystemPens.WindowText, new Point(ClientRectangle.Right - 1, ClientRectangle.Top),
                    new Point(ClientRectangle.Right - 1, ClientRectangle.Bottom - 1));
            }

            while (majorDivisionPixels * majorSkip < 100)
            {
                majorSkip *= majorDivisors[majorSkipPower % majorDivisors.Length];
                ++majorSkipPower;
            }

            startMajor = (int)Math.Round((majorSkip * Math.Floor(startMajor / (double)majorSkip)));


            for (float major = startMajor; major <= endMajor; major += majorSkip)//skip
            {
                float majorMarkPos = ((float)major * majorDivisionPixels) - offsetPixels;
                string majorText = major.ToString();
                if (orientation == Orientation.Horizontal)
                {
                    SubdivideX(e.Graphics, pen, ClientRectangle.Left + majorMarkPos, majorDivisionPixels * majorSkip, -majorSkipPower, ClientRectangle.Top, ClientRectangle.Height, subdivs);
                    e.Graphics.DrawString(majorText, Font, textBrush, new PointF(ClientRectangle.Left + majorMarkPos, ClientRectangle.Bottom), textFormat);
                }
                else // if (orientation == Orientation.Vertical)
                {
                    SubdivideY(e.Graphics, pen, ClientRectangle.Top + majorMarkPos, majorDivisionPixels * majorSkip, -majorSkipPower, ClientRectangle.Left, ClientRectangle.Width, subdivs);
                    e.Graphics.DrawString(majorText, Font, textBrush, new PointF(ClientRectangle.Left, ClientRectangle.Top + majorMarkPos), textFormat);
                }
            }

            //
            // 以下是绘制文字
            //
            decimal skip = this.SkipNumberCalc(measurementUnit);
            int k = 0;
            int f = this.SkipInterval(measurementUnit);
            for (decimal major = startMajor; major <= endMajor; major += skip)//majorSkip
            {
                //float majorMarkPos = ((float)major * majorDivisionPixels) - offsetPixels;
                //string majorText = major.ToString();//(Math.Round(Convert.ToDecimal(major), 4, MidpointRounding.AwayFromZero)).ToString();

                //if (orientation == Orientation.Horizontal)
                //{
                //    if (k % f == 0)
                //    {
                //        e.Graphics.DrawString(majorText, Font, textBrush, new PointF(ClientRectangle.Left + majorMarkPos, ClientRectangle.Bottom), textFormat);
                //    }
                //}
                //else // if (orientation == Orientation.Vertical)
                //{
                //    if (k % f == 0)
                //    {
                //        e.Graphics.DrawString(majorText, Font, textBrush, new PointF(ClientRectangle.Left, ClientRectangle.Top + majorMarkPos), textFormat);
                //    }
                //}
                k++;
            }

            textFormat.Dispose();
        }

        /// <summary>
        /// 根据不同单位返回不同的间隔长度
        /// </summary>
        /// <param name="unit"></param>
        /// <returns></returns>
        private decimal SkipNumberCalc(MeasurementUnit unit)
        {
            decimal skip = 100M;
            if (unit == MeasurementUnit.Inch)
            {
                skip = 0.001M;
            }
            else if (unit == MeasurementUnit.Mil)
            {
                skip = 0.1M;//###Mil
            }
            else if (unit == MeasurementUnit.Centimeter)
            {
                skip = 0.01M;
            }
            else if (unit == MeasurementUnit.Millimeter)
            {
                skip = 0.1M;
            }
            else if (unit == MeasurementUnit.Micron)
            {
                skip = 10M;
            }
            else if (unit == MeasurementUnit.Nano)
            {
                skip = 10000M;
            }
            return skip;
        }

        /// <summary>
        /// 不同的缩放比列下，间隔多少单元格绘制文字
        /// </summary>
        /// <param name="unit"></param>
        /// <returns></returns>
        private int SkipInterval(MeasurementUnit unit)
        {
            int f = 1;
            if (scaleFactor.Ratio <= 0.05f)
            {
                switch (unit)
                {
                    case MeasurementUnit.Pixel:
                    case MeasurementUnit.Centimeter:
                    case MeasurementUnit.Millimeter:
                        f = 100;
                        break;
                    case MeasurementUnit.Inch:
                    case MeasurementUnit.Mil://###Mil
                    case MeasurementUnit.Micron:
                    case MeasurementUnit.Nano:
                        f = 1000;
                        break;
                }
            }
            else if (scaleFactor.Ratio <= 0.1f)
            {
                switch (unit)
                {
                    case MeasurementUnit.Pixel:
                    case MeasurementUnit.Centimeter:
                    case MeasurementUnit.Millimeter:
                        f = 10;
                        break;
                    case MeasurementUnit.Inch:
                    case MeasurementUnit.Mil://###Mil
                    case MeasurementUnit.Micron:
                    case MeasurementUnit.Nano:
                        f = 100;
                        break;
                }
            }
            else if (scaleFactor.Ratio <= 0.5f)
            {
                switch (unit)
                {
                    case MeasurementUnit.Pixel:
                    case MeasurementUnit.Centimeter:
                    case MeasurementUnit.Millimeter:
                        f = 5;
                        break;
                    case MeasurementUnit.Inch:
                    case MeasurementUnit.Mil://###Mil
                    case MeasurementUnit.Micron:
                    case MeasurementUnit.Nano:
                        f = 50;
                        break;
                }
            }
            else
            {
                switch (unit)
                {
                    case MeasurementUnit.Pixel:
                    case MeasurementUnit.Centimeter:
                    case MeasurementUnit.Millimeter:
                        f = 1;
                        break;
                    case MeasurementUnit.Inch:
                    case MeasurementUnit.Mil://###Mil
                    case MeasurementUnit.Micron:
                    case MeasurementUnit.Nano:
                        f = 10;
                        break;
                }
            }
            return f;
        }
    }
}