478 lines
15 KiB
C#
478 lines
15 KiB
C#
using System;
|
|
using System.Drawing;
|
|
using System.Windows.Forms;
|
|
using JD.Kernel.Structs;
|
|
using JD.Maths.Utils;
|
|
using JD.ScreenWrappers;
|
|
using JD.Sequencers.Controls;
|
|
using JD.Sequencers.Windowlesses;
|
|
|
|
namespace JD.Sequencers.Times
|
|
{
|
|
using RangeF = Range<float>;
|
|
|
|
/// <summary>
|
|
/// Provides base behaviors for any sequencer control (TrackView, Timeline, Zoom, Optional scroll bars, etc)
|
|
/// </summary>
|
|
public abstract class SequencerControlBase : WindowlessRootControl
|
|
{
|
|
#region Variables
|
|
|
|
private Timeline m_timeline;
|
|
private HScrollBar m_horizontalScrollbar;
|
|
private VScrollBar m_verticalScrollbar;
|
|
private TrackView m_trackView;
|
|
private Cursor m_previousCursor;
|
|
|
|
private Point m_lastMouseMoveLocation;
|
|
private bool m_suspendScrollbarEvents;
|
|
private bool m_isTrackViewVisible = true;
|
|
|
|
#endregion
|
|
|
|
#region Constructor
|
|
|
|
protected SequencerControlBase()
|
|
{
|
|
SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint | ControlStyles.DoubleBuffer, true);
|
|
m_previousCursor = DefaultCursor;
|
|
}
|
|
|
|
protected void Init()
|
|
{
|
|
RootContainer.BoundsChanged += RootContainer_BoundsChanged;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Properties
|
|
|
|
public bool IsTrackViewVisible
|
|
{
|
|
get { return m_isTrackViewVisible; }
|
|
set { m_isTrackViewVisible = value; }
|
|
}
|
|
|
|
public TrackView TrackView
|
|
{
|
|
get
|
|
{
|
|
if (m_trackView == null)
|
|
{
|
|
m_trackView = new TrackView(this, Timeline);
|
|
m_trackView.ScrollMaximumChanged += m_trackView_ScrollMaximumChanged;
|
|
m_trackView.ScrollValueChanged += m_trackView_ScrollValueChanged;
|
|
|
|
RootContainer.Controls.Add(m_trackView);
|
|
}
|
|
|
|
m_trackView.IsVisible = m_isTrackViewVisible;
|
|
return m_trackView;
|
|
}
|
|
}
|
|
|
|
private Timeline Timeline
|
|
{
|
|
get
|
|
{
|
|
if (m_timeline == null)
|
|
{
|
|
m_timeline = CreateTimeline();
|
|
|
|
m_timeline.CurrentTimeChanged += m_timeline_CurrentTimeChanged;
|
|
m_timeline.TimeRangeChanged += m_timeline_TimeRangeChanged;
|
|
m_timeline.PixelsPerTimeChanged += m_timeline_PixelsPerTimeChanged;
|
|
m_timeline.TimeOffsetChanged += m_timeline_TimeOffsetChanged;
|
|
m_timeline.MouseWheel += m_timeline_MouseWheel;
|
|
}
|
|
|
|
return m_timeline;
|
|
}
|
|
}
|
|
|
|
private HScrollBar HorizontalScrollbar
|
|
{
|
|
get
|
|
{
|
|
if (m_horizontalScrollbar == null)
|
|
{
|
|
m_horizontalScrollbar = CreateHorizontalScrollbar();
|
|
|
|
if (m_horizontalScrollbar != null)
|
|
{
|
|
m_horizontalScrollbar.ValueChanged += m_horizontalScrollbar_ValueChanged;
|
|
}
|
|
}
|
|
|
|
return m_horizontalScrollbar;
|
|
}
|
|
}
|
|
|
|
private VScrollBar VerticalScrollbar
|
|
{
|
|
get
|
|
{
|
|
if (m_verticalScrollbar == null)
|
|
{
|
|
m_verticalScrollbar = CreateVerticalScrollbar();
|
|
|
|
if (m_verticalScrollbar != null)
|
|
{
|
|
m_verticalScrollbar.ValueChanged += m_verticalScrollbar_ValueChanged;
|
|
}
|
|
}
|
|
|
|
return m_verticalScrollbar;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Methods
|
|
|
|
protected abstract Timeline CreateTimeline();
|
|
protected abstract HScrollBar CreateHorizontalScrollbar();
|
|
protected abstract VScrollBar CreateVerticalScrollbar();
|
|
|
|
public void Zoom(float factor)
|
|
{
|
|
float zoomFactor = factor > 0.0f ? -0.1f : 0.1f;
|
|
|
|
RangeF currentRange = Timeline.VisibleTimeRange;
|
|
currentRange = currentRange.Inflate(currentRange.Width() * zoomFactor);
|
|
|
|
if (currentRange.Width() > 0.1f)
|
|
{
|
|
Timeline.VisibleTimeRange = currentRange;
|
|
}
|
|
}
|
|
|
|
public void SelectTrack(Track track)
|
|
{
|
|
int index = TrackView.GetTrackIndex(track);
|
|
if (index >= 0)
|
|
{
|
|
TrackView.ScrollValue = index <= TrackView.ScrollMaximum ? index : TrackView.ScrollMaximum;
|
|
TrackView.ActiveTrack = track;
|
|
UpdateScrollbars();
|
|
}
|
|
}
|
|
|
|
protected virtual void UpdateBoundsRootContainer()
|
|
{
|
|
Rectangle bounds = RootContainer.Bounds;
|
|
Timeline.Bounds = new Rectangle(bounds.Left, bounds.Top, bounds.Width, Timeline.Height);
|
|
|
|
if (TrackView.IsVisible)
|
|
{
|
|
TrackView.Bounds = new Rectangle(bounds.Left, Timeline.Bounds.Bottom, bounds.Width, bounds.Height - Timeline.Height);
|
|
}
|
|
|
|
UpdateScrollbars();
|
|
}
|
|
|
|
protected virtual void UpdateHorizontalScrollbar()
|
|
{
|
|
double rangeWidth = Timeline.TimeRange.Width() * Timeline.PixelsPerTime;
|
|
double displayWidth = Timeline.Width - 2 * Timeline.Margin;
|
|
|
|
if (System.Math.Abs(displayWidth - rangeWidth) > 1e-3)
|
|
{
|
|
m_suspendScrollbarEvents = true;
|
|
HorizontalScrollbar.Minimum = (int)System.Math.Round(Timeline.TimeRange.Min * Timeline.PixelsPerTime) - Timeline.Margin;
|
|
HorizontalScrollbar.Maximum = (int)System.Math.Round((Timeline.TimeRange.Max + Timeline.MajorInterval) * Timeline.PixelsPerTime - Timeline.Width + Timeline.Margin);
|
|
m_suspendScrollbarEvents = false;
|
|
|
|
HorizontalScrollbar.LargeChange = (int)System.Math.Round(Timeline.MajorInterval * Timeline.PixelsPerTime);
|
|
HorizontalScrollbar.SmallChange = (int)System.Math.Round(Timeline.MinorInterval * Timeline.PixelsPerTime);
|
|
|
|
if (Timeline.TimeOffset > HorizontalScrollbar.Maximum / Timeline.PixelsPerTime)
|
|
{
|
|
HorizontalScrollbar.Value = HorizontalScrollbar.Maximum;
|
|
}
|
|
else if (Timeline.TimeOffset < HorizontalScrollbar.Minimum / Timeline.PixelsPerTime)
|
|
{
|
|
HorizontalScrollbar.Value = HorizontalScrollbar.Minimum;
|
|
}
|
|
else
|
|
{
|
|
HorizontalScrollbar.Value = (int)System.Math.Round(Timeline.TimeOffset * Timeline.PixelsPerTime);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_suspendScrollbarEvents = true;
|
|
HorizontalScrollbar.Maximum = HorizontalScrollbar.Minimum = 0;
|
|
m_suspendScrollbarEvents = false;
|
|
}
|
|
}
|
|
|
|
protected virtual void UpdateVerticalScrollbar()
|
|
{
|
|
if (TrackView.ScrollMaximum <= 0)
|
|
{
|
|
VerticalScrollbar.Value = 0;
|
|
VerticalScrollbar.Visible = false;
|
|
}
|
|
else
|
|
{
|
|
VerticalScrollbar.Visible = true;
|
|
|
|
m_suspendScrollbarEvents = true;
|
|
VerticalScrollbar.Minimum = 0;
|
|
VerticalScrollbar.Maximum = System.Math.Max(TrackView.ScrollMaximum + VerticalScrollbar.LargeChange - 1, TrackView.ScrollValue);
|
|
m_suspendScrollbarEvents = false;
|
|
VerticalScrollbar.Value = TrackView.ScrollValue;
|
|
}
|
|
}
|
|
|
|
private void UpdateScrollbars()
|
|
{
|
|
if (m_suspendScrollbarEvents)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (HorizontalScrollbar != null)
|
|
{
|
|
int valueBefore = HorizontalScrollbar.Value;
|
|
UpdateHorizontalScrollbar();
|
|
HorizontalScrollbar.Invalidate();
|
|
if (HorizontalScrollbar.Value != valueBefore)
|
|
{
|
|
Timeline.Invalidate();
|
|
TrackView.Invalidate();
|
|
}
|
|
}
|
|
|
|
if (VerticalScrollbar != null)
|
|
{
|
|
int valueBefore = VerticalScrollbar.Value;
|
|
UpdateVerticalScrollbar();
|
|
VerticalScrollbar.Invalidate();
|
|
if (VerticalScrollbar.Value != valueBefore)
|
|
{
|
|
Timeline.Invalidate();
|
|
TrackView.Invalidate();
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Event Handlers
|
|
|
|
protected override void OnMouseClick(MouseEventArgs e)
|
|
{
|
|
base.OnMouseClick(e);
|
|
|
|
Focus();
|
|
}
|
|
|
|
protected override void OnMouseDown(MouseEventArgs e)
|
|
{
|
|
base.OnMouseDown(e);
|
|
|
|
if (e.Button == MouseButtons.Middle)
|
|
{
|
|
m_previousCursor = Cursor;
|
|
}
|
|
}
|
|
|
|
protected override void OnMouseUp(MouseEventArgs e)
|
|
{
|
|
base.OnMouseUp(e);
|
|
|
|
if (e.Button == MouseButtons.Middle)
|
|
{
|
|
Cursor = m_previousCursor;
|
|
}
|
|
}
|
|
|
|
protected override void OnMouseWheel(MouseEventArgs e)
|
|
{
|
|
base.OnMouseWheel(e);
|
|
|
|
if (Bounds.Contains(e.Location))
|
|
HandleZoomOnMouseWheel(e);
|
|
}
|
|
|
|
private void m_timeline_MouseWheel(object sender, MouseEventArgs e)
|
|
{
|
|
if (Bounds.Contains(e.Location))
|
|
HandleZoomOnMouseWheel(e);
|
|
}
|
|
|
|
protected virtual void HandleZoomOnMouseWheel(MouseEventArgs e)
|
|
{
|
|
if ((ModifierKeys & Keys.Control) == Keys.Control)
|
|
{
|
|
Zoom(e.Delta);
|
|
}
|
|
else
|
|
{
|
|
if (m_suspendScrollbarEvents || e.Delta == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (e.Delta > 0 && TrackView.ScrollValue > 0)
|
|
{
|
|
TrackView.ScrollValue--;
|
|
}
|
|
|
|
if (e.Delta < 1 && TrackView.ScrollValue < TrackView.ScrollMaximum)
|
|
{
|
|
TrackView.ScrollValue++;
|
|
}
|
|
|
|
UpdateScrollbars();
|
|
}
|
|
}
|
|
|
|
protected override void OnMouseMove(MouseEventArgs e)
|
|
{
|
|
base.OnMouseMove(e);
|
|
|
|
Point delta = new Point(
|
|
e.Location.X - m_lastMouseMoveLocation.X,
|
|
e.Location.Y - m_lastMouseMoveLocation.Y
|
|
);
|
|
|
|
m_lastMouseMoveLocation = e.Location;
|
|
|
|
if (e.Button == MouseButtons.Middle)
|
|
{
|
|
Cursor = PanCursor(true);
|
|
|
|
PanHorizontal(delta);
|
|
PanVertical(delta);
|
|
|
|
int lastLocationX = m_lastMouseMoveLocation.X;
|
|
int lastLocationY = m_lastMouseMoveLocation.Y;
|
|
|
|
GuiUtil.WrapAround(this, ref lastLocationX, ref lastLocationY);
|
|
m_lastMouseMoveLocation = new Point(lastLocationX, lastLocationY);
|
|
}
|
|
}
|
|
|
|
private void PanVertical(Point delta)
|
|
{
|
|
// Scroll according to an average track size, ...
|
|
//int trackSize = TrackView.Tracks.Where(track => !track.Fixed).Select(track => track.Height).FirstOrDefault();
|
|
int trackSize = 16;
|
|
|
|
if (trackSize > 0 && VerticalScrollbar != null && VerticalScrollbar.Visible)
|
|
{
|
|
double scroll = delta.Y/(double) trackSize;
|
|
double appliedScroll = System.Math.Round(delta.Y/(double) trackSize);
|
|
|
|
int initialValue = VerticalScrollbar.Value;
|
|
int newValue = (initialValue - (int) appliedScroll).Clamp(VerticalScrollbar.Minimum, VerticalScrollbar.Maximum - VerticalScrollbar.LargeChange + 1);
|
|
VerticalScrollbar.Value = newValue;
|
|
|
|
// Set last point according to what was already consumed by the event.
|
|
int unconsumedDelta = (int) ((scroll - appliedScroll)*trackSize);
|
|
|
|
m_lastMouseMoveLocation.Y -= unconsumedDelta;
|
|
}
|
|
}
|
|
|
|
private void PanHorizontal(Point delta)
|
|
{
|
|
float deltaInTime = delta.X / Timeline.PixelsPerTime;
|
|
float oldOffset = Timeline.TimeOffset;
|
|
float newOffset = oldOffset - deltaInTime;
|
|
|
|
if (oldOffset != newOffset)
|
|
{
|
|
Cursor = PanCursor(oldOffset < newOffset);
|
|
Timeline.TimeOffset = newOffset;
|
|
}
|
|
}
|
|
|
|
protected virtual Cursor PanCursor(bool west)
|
|
{
|
|
return west ? Cursors.PanWest : Cursors.PanEast;
|
|
}
|
|
|
|
private void m_timeline_CurrentTimeChanged(object sender, EventArgs e)
|
|
{
|
|
UpdateScrollbars();
|
|
}
|
|
|
|
private void m_timeline_TimeRangeChanged(object sender, EventArgs e)
|
|
{
|
|
UpdateScrollbars();
|
|
}
|
|
|
|
private void m_timeline_PixelsPerTimeChanged(object sender, EventArgs e)
|
|
{
|
|
UpdateScrollbars();
|
|
}
|
|
|
|
private void m_timeline_TimeOffsetChanged(object sender, EventArgs e)
|
|
{
|
|
UpdateScrollbars();
|
|
}
|
|
|
|
private void m_trackView_ScrollMaximumChanged(object sender, EventArgs e)
|
|
{
|
|
UpdateScrollbars();
|
|
}
|
|
|
|
void m_trackView_ScrollValueChanged(object sender, EventArgs e)
|
|
{
|
|
UpdateScrollbars();
|
|
}
|
|
|
|
private void m_horizontalScrollbar_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
if (m_suspendScrollbarEvents)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var currentOffset = Timeline.TimeOffset;
|
|
var offset = HorizontalScrollbar.Value / Timeline.PixelsPerTime;
|
|
|
|
if (currentOffset != offset)
|
|
{
|
|
Timeline.TimeOffset = offset;
|
|
Invalidate();
|
|
}
|
|
|
|
OnScrolled(EventArgs.Empty);
|
|
}
|
|
|
|
private void m_verticalScrollbar_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
if (m_suspendScrollbarEvents)
|
|
{
|
|
return;
|
|
}
|
|
|
|
TrackView.ScrollValue = VerticalScrollbar.Value;
|
|
|
|
OnScrolled(EventArgs.Empty);
|
|
}
|
|
|
|
private void RootContainer_BoundsChanged(object sender, EventArgs e)
|
|
{
|
|
UpdateBoundsRootContainer();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Events
|
|
|
|
public event EventHandler<EventArgs> Scrolled;
|
|
|
|
protected virtual void OnScrolled(EventArgs e)
|
|
{
|
|
Scrolled?.Invoke(this, e);
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|