JD2022-TU1/main/tools/framework/JD.Sequencers/Controls/TimeRangeControl.cs

using System;
using System.Drawing;
using System.Windows.Forms;
using JD.Kernel.Structs;
using JD.Sequencers.Times;
using JD.Sequencers.Windowlesses;

namespace JD.Sequencers.Controls
{
    using RangeF = Range<float>;

    /// <summary>
    /// The cursor that displays the current range of the timeline.
    /// </summary>
    public sealed class TimeRangeControl : WindowlessControl
    {
        #region Inner Types

        private class RangeGuide : TimeGuide
        {
            #region Variables

            private readonly bool m_isStart;

            #endregion

            #region Constructor

            public RangeGuide(Timeline timeline, float time, bool isStart)
                : base(timeline)
            {
                Time = time;
                Range = RangeF.Infinite;
                m_isStart = isStart;

                Selectable = false;
                IsMoveAllowed = false;
            }

            #endregion

            #region CreateBitmap Override Method

            protected override Bitmap CreateBitmap()
            {
                Bitmap bitmap = new Bitmap(Width, Height);

                using (Graphics g = Graphics.FromImage(bitmap))
                {
                    int x = m_isStart ? 0 : 6;
                    //Line 1
                    g.DrawLine(Pens.Black, x, 0, x, 5);
                    //Line 2
                    g.DrawLine(Pens.Black, x + 1, 0, x + 1, 5);
                    g.DrawLine(Pens.Black, x + 2, 0, x + 2, 5);

                    //Line 7
                    g.DrawLine(Pens.Black, 0, 6, 8, 6);
                    g.DrawLine(Pens.Black, 0, 7, 8, 7);
                    //Line 8
                    g.DrawLine(Pens.Black, 0, 8, 8, 8);
                }

                return bitmap;
            }

            #endregion
        }

        #endregion

        #region Variables

        private readonly RangeGuide m_startGuide;
        private readonly RangeGuide m_endGuide;

        private readonly Brush m_brush;

        private int m_rangeHeight;

        #endregion

        #region Constructor

        public TimeRangeControl(Timeline timeline)
        {
            m_brush = new SolidBrush(System.Drawing.Color.LightSlateGray);

            m_startGuide = new RangeGuide(timeline, timeline.TimeRange.Min, true);
            m_endGuide = new RangeGuide(timeline, timeline.TimeRange.Max, false);

            Controls.Add(m_startGuide);
            Controls.Add(m_endGuide);
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                m_startGuide.Dispose();
                m_endGuide.Dispose();
                m_brush.Dispose();
            }
            base.Dispose(disposing);
        }

        #endregion

        #region Properties

        public int RangeHeight
        {
            get { return m_rangeHeight; }
            set
            {
                if (m_rangeHeight != value)
                {
                    m_rangeHeight = value;
                    OnRangeHeightChanged(EventArgs.Empty);
                }
            }
        }

        private Timeline Timeline
        {
            get { return m_startGuide.Timeline; }
        }

        /// <summary>
        /// The range of available time values.
        /// </summary>
        public Range<float> Range
        {
            get { return new Range<float>(m_startGuide.Time, m_endGuide.Time); }
            set
            {
                m_startGuide.Time = value.Min;
                m_endGuide.Time = value.Max;
            }
        }

        #endregion

        #region Methods

        protected override void OnPaintSelf(PaintEventArgs e)
        {
            base.OnPaintSelf(e);

            int start = Timeline.TimeToPixel(m_startGuide.Time);
            int width = Timeline.TimeToPixel(m_endGuide.Time) - start;

            e.Graphics.FillRectangle(m_brush, start, Bounds.Bottom - RangeHeight, width, RangeHeight - 1);
        }

        protected internal override void OnPaint(PaintEventArgs e)
        {
            m_startGuide.Location = new Point(Timeline.TimeToPixel(m_startGuide.Time), Bounds.Bottom - m_startGuide.Height);
            m_endGuide.Location = new Point(Timeline.TimeToPixel(m_endGuide.Time) - m_endGuide.Width, Bounds.Bottom - m_endGuide.Height);

            base.OnPaint(e);
        }

        #endregion

        #region Events

        public event EventHandler RangeHeightChanged;

        /// <summary>
        /// Triggers the <see cref="RangeHeightChanged"/> event.
        /// </summary>
        /// <param name="e">Event Args.</param>
        private void OnRangeHeightChanged(EventArgs e)
        {
            RangeHeightChanged?.Invoke(this, e);
        }

        #endregion
    }
}