#region Imports
|
|
using DPumpHydr.WinFrmUI.RLT.Util;
|
using System;
|
using System.ComponentModel;
|
using System.Drawing;
|
using System.Windows.Forms;
|
using static DPumpHydr.WinFrmUI.RLT.Helper.CrownHelper;
|
|
#endregion
|
|
namespace DPumpHydr.WinFrmUI.RLT.Controls
|
{
|
#region CrownScrollBar
|
|
public class CrownScrollBar : Control
|
{
|
#region Event Region
|
|
public event EventHandler<ScrollValueEventArgs> ValueChanged;
|
|
#endregion
|
|
#region Field Region
|
|
private Enum.Crown.ScrollOrientation _scrollOrientation;
|
|
private int _value;
|
private int _minimum = 0;
|
private int _maximum = 100;
|
|
private int _viewSize;
|
|
private Rectangle _trackArea;
|
private float _viewContentRatio;
|
|
private Rectangle _thumbArea;
|
private Rectangle _upArrowArea;
|
private Rectangle _downArrowArea;
|
|
private bool _thumbHot;
|
private bool _upArrowHot;
|
private bool _downArrowHot;
|
|
private bool _thumbClicked;
|
private bool _upArrowClicked;
|
private bool _downArrowClicked;
|
|
private bool _isScrolling;
|
private int _initialValue;
|
private Point _initialContact;
|
|
private readonly Timer _scrollTimer;
|
|
#endregion
|
|
#region Property Region
|
|
[Category("Behavior")]
|
[Description("The orientation type of the scrollbar.")]
|
[DefaultValue(Enum.Crown.ScrollOrientation.Vertical)]
|
public Enum.Crown.ScrollOrientation ScrollOrientation
|
{
|
get => _scrollOrientation;
|
set
|
{
|
_scrollOrientation = value;
|
UpdateScrollBar();
|
}
|
}
|
|
[Category("Behavior")]
|
[Description("The value that the scroll thumb position represents.")]
|
[DefaultValue(0)]
|
public int Value
|
{
|
get => _value;
|
set
|
{
|
if (value < Minimum)
|
{
|
value = Minimum;
|
}
|
|
int maximumValue = Maximum - ViewSize;
|
if (value > maximumValue)
|
{
|
value = maximumValue;
|
}
|
|
if (_value == value)
|
{
|
return;
|
}
|
|
_value = value;
|
|
UpdateThumb(true);
|
|
ValueChanged?.Invoke(this, new ScrollValueEventArgs(Value));
|
}
|
}
|
|
[Category("Behavior")]
|
[Description("The lower limit value of the scrollable range.")]
|
[DefaultValue(0)]
|
public int Minimum
|
{
|
get => _minimum;
|
set
|
{
|
_minimum = value;
|
UpdateScrollBar();
|
}
|
}
|
|
[Category("Behavior")]
|
[Description("The upper limit value of the scrollable range.")]
|
[DefaultValue(100)]
|
public int Maximum
|
{
|
get => _maximum;
|
set
|
{
|
_maximum = value;
|
UpdateScrollBar();
|
}
|
}
|
|
[Category("Behavior")]
|
[Description("The view size for the scrollable area.")]
|
[DefaultValue(0)]
|
public int ViewSize
|
{
|
get => _viewSize;
|
set
|
{
|
_viewSize = value;
|
UpdateScrollBar();
|
}
|
}
|
|
public new bool Visible
|
{
|
get => base.Visible;
|
set
|
{
|
if (base.Visible == value)
|
{
|
return;
|
}
|
|
base.Visible = value;
|
}
|
}
|
|
#endregion
|
|
#region Constructor Region
|
|
public CrownScrollBar()
|
{
|
SetStyle
|
(
|
ControlStyles.OptimizedDoubleBuffer |
|
ControlStyles.ResizeRedraw |
|
ControlStyles.UserPaint,
|
true
|
);
|
|
SetStyle(ControlStyles.Selectable, false);
|
|
_scrollTimer = new Timer
|
{
|
Interval = 1
|
};
|
_scrollTimer.Tick += ScrollTimerTick;
|
}
|
|
#endregion
|
|
#region Event Handler Region
|
|
protected override void OnResize(EventArgs e)
|
{
|
base.OnResize(e);
|
|
UpdateScrollBar();
|
}
|
|
protected override void OnMouseDown(MouseEventArgs e)
|
{
|
base.OnMouseDown(e);
|
|
if (_thumbArea.Contains(e.Location) && e.Button == MouseButtons.Left)
|
{
|
_isScrolling = true;
|
_initialContact = e.Location;
|
|
if (_scrollOrientation == Enum.Crown.ScrollOrientation.Vertical)
|
{
|
_initialValue = _thumbArea.Top;
|
}
|
else
|
{
|
_initialValue = _thumbArea.Left;
|
}
|
|
Invalidate();
|
return;
|
}
|
|
if (_upArrowArea.Contains(e.Location) && e.Button == MouseButtons.Left)
|
{
|
_upArrowClicked = true;
|
_scrollTimer.Enabled = true;
|
|
Invalidate();
|
return;
|
}
|
|
if (_downArrowArea.Contains(e.Location) && e.Button == MouseButtons.Left)
|
{
|
_downArrowClicked = true;
|
_scrollTimer.Enabled = true;
|
|
Invalidate();
|
return;
|
}
|
|
if (_trackArea.Contains(e.Location) && e.Button == MouseButtons.Left)
|
{
|
// Step 1. Check if our input is at least aligned with the thumb
|
if (_scrollOrientation == Enum.Crown.ScrollOrientation.Vertical)
|
{
|
Rectangle modRect = new(_thumbArea.Left, _trackArea.Top, _thumbArea.Width, _trackArea.Height);
|
if (!modRect.Contains(e.Location))
|
{
|
return;
|
}
|
}
|
else if (_scrollOrientation == Enum.Crown.ScrollOrientation.Horizontal)
|
{
|
Rectangle modRect = new(_trackArea.Left, _thumbArea.Top, _trackArea.Width, _thumbArea.Height);
|
if (!modRect.Contains(e.Location))
|
{
|
return;
|
}
|
}
|
|
// Step 2. Scroll to the area initially clicked.
|
if (_scrollOrientation == Enum.Crown.ScrollOrientation.Vertical)
|
{
|
int loc = e.Location.Y;
|
loc -= _upArrowArea.Bottom - 1;
|
loc -= _thumbArea.Height / 2;
|
ScrollToPhysical(loc);
|
}
|
else
|
{
|
int loc = e.Location.X;
|
loc -= _upArrowArea.Right - 1;
|
loc -= _thumbArea.Width / 2;
|
ScrollToPhysical(loc);
|
}
|
|
// Step 3. Initiate a thumb drag.
|
_isScrolling = true;
|
_initialContact = e.Location;
|
_thumbHot = true;
|
|
if (_scrollOrientation == Enum.Crown.ScrollOrientation.Vertical)
|
{
|
_initialValue = _thumbArea.Top;
|
}
|
else
|
{
|
_initialValue = _thumbArea.Left;
|
}
|
|
Invalidate();
|
return;
|
}
|
}
|
|
protected override void OnMouseUp(MouseEventArgs e)
|
{
|
base.OnMouseUp(e);
|
|
_isScrolling = false;
|
|
_thumbClicked = false;
|
_upArrowClicked = false;
|
_downArrowClicked = false;
|
|
Invalidate();
|
}
|
|
protected override void OnMouseMove(MouseEventArgs e)
|
{
|
base.OnMouseMove(e);
|
|
if (!_isScrolling)
|
{
|
bool thumbHot = _thumbArea.Contains(e.Location);
|
if (_thumbHot != thumbHot)
|
{
|
_thumbHot = thumbHot;
|
Invalidate();
|
}
|
|
bool upArrowHot = _upArrowArea.Contains(e.Location);
|
if (_upArrowHot != upArrowHot)
|
{
|
_upArrowHot = upArrowHot;
|
Invalidate();
|
}
|
|
bool downArrowHot = _downArrowArea.Contains(e.Location);
|
if (_downArrowHot != downArrowHot)
|
{
|
_downArrowHot = downArrowHot;
|
Invalidate();
|
}
|
}
|
|
if (_isScrolling)
|
{
|
if (e.Button != MouseButtons.Left)
|
{
|
OnMouseUp(null);
|
return;
|
}
|
|
Point difference = new(e.Location.X - _initialContact.X, e.Location.Y - _initialContact.Y);
|
|
if (_scrollOrientation == Enum.Crown.ScrollOrientation.Vertical)
|
{
|
int thumbPos = _initialValue - _trackArea.Top;
|
int newPosition = thumbPos + difference.Y;
|
|
ScrollToPhysical(newPosition);
|
}
|
else if (_scrollOrientation == Enum.Crown.ScrollOrientation.Horizontal)
|
{
|
int thumbPos = _initialValue - _trackArea.Left;
|
int newPosition = thumbPos + difference.X;
|
|
ScrollToPhysical(newPosition);
|
}
|
|
UpdateScrollBar();
|
}
|
}
|
|
protected override void OnMouseLeave(EventArgs e)
|
{
|
base.OnMouseLeave(e);
|
|
_thumbHot = false;
|
_upArrowHot = false;
|
_downArrowHot = false;
|
|
Invalidate();
|
}
|
|
private void ScrollTimerTick(object sender, EventArgs e)
|
{
|
if (!_upArrowClicked && !_downArrowClicked)
|
{
|
_scrollTimer.Enabled = false;
|
return;
|
}
|
|
if (_upArrowClicked)
|
{
|
ScrollBy(-1);
|
}
|
else if (_downArrowClicked)
|
{
|
ScrollBy(1);
|
}
|
}
|
|
#endregion
|
|
#region Method Region
|
|
public void ScrollTo(int position)
|
{
|
Value = position;
|
}
|
|
public void ScrollToPhysical(int positionInPixels)
|
{
|
bool isVert = _scrollOrientation == Enum.Crown.ScrollOrientation.Vertical;
|
|
int trackAreaSize = isVert ? _trackArea.Height - _thumbArea.Height : _trackArea.Width - _thumbArea.Width;
|
|
float positionRatio = positionInPixels / (float)trackAreaSize;
|
int viewScrollSize = Maximum - ViewSize;
|
|
int newValue = (int)(positionRatio * viewScrollSize);
|
Value = newValue;
|
}
|
|
public void ScrollBy(int offset)
|
{
|
int newValue = Value + offset;
|
ScrollTo(newValue);
|
}
|
|
public void ScrollByPhysical(int offsetInPixels)
|
{
|
bool isVert = _scrollOrientation == Enum.Crown.ScrollOrientation.Vertical;
|
|
int thumbPos = isVert ? (_thumbArea.Top - _trackArea.Top) : (_thumbArea.Left - _trackArea.Left);
|
|
int newPosition = thumbPos - offsetInPixels;
|
|
ScrollToPhysical(newPosition);
|
}
|
|
public void UpdateScrollBar()
|
{
|
Rectangle area = ClientRectangle;
|
|
// Arrow buttons
|
if (_scrollOrientation == Enum.Crown.ScrollOrientation.Vertical)
|
{
|
_upArrowArea = new(area.Left, area.Top, ThemeProvider.Theme.Sizes.ArrowButtonSize, ThemeProvider.Theme.Sizes.ArrowButtonSize);
|
_downArrowArea = new(area.Left, area.Bottom - ThemeProvider.Theme.Sizes.ArrowButtonSize, ThemeProvider.Theme.Sizes.ArrowButtonSize, ThemeProvider.Theme.Sizes.ArrowButtonSize);
|
}
|
else if (_scrollOrientation == Enum.Crown.ScrollOrientation.Horizontal)
|
{
|
_upArrowArea = new(area.Left, area.Top, ThemeProvider.Theme.Sizes.ArrowButtonSize, ThemeProvider.Theme.Sizes.ArrowButtonSize);
|
_downArrowArea = new(area.Right - ThemeProvider.Theme.Sizes.ArrowButtonSize, area.Top, ThemeProvider.Theme.Sizes.ArrowButtonSize, ThemeProvider.Theme.Sizes.ArrowButtonSize);
|
}
|
|
// Track
|
if (_scrollOrientation == Enum.Crown.ScrollOrientation.Vertical)
|
{
|
_trackArea = new(area.Left, area.Top + ThemeProvider.Theme.Sizes.ArrowButtonSize, area.Width, area.Height - (ThemeProvider.Theme.Sizes.ArrowButtonSize * 2));
|
}
|
else if (_scrollOrientation == Enum.Crown.ScrollOrientation.Horizontal)
|
{
|
_trackArea = new(area.Left + ThemeProvider.Theme.Sizes.ArrowButtonSize, area.Top, area.Width - (ThemeProvider.Theme.Sizes.ArrowButtonSize * 2), area.Height);
|
}
|
|
// Thumb
|
UpdateThumb();
|
|
Invalidate();
|
}
|
|
private void UpdateThumb(bool forceRefresh = false)
|
{
|
if (ViewSize >= Maximum)
|
{
|
return;
|
}
|
|
// Cap to maximum value
|
int maximumValue = Maximum - ViewSize;
|
if (Value > maximumValue)
|
{
|
Value = maximumValue;
|
}
|
|
// Calculate size ratio
|
_viewContentRatio = ViewSize / (float)Maximum;
|
int viewAreaSize = Maximum - ViewSize;
|
float positionRatio = Value / (float)viewAreaSize;
|
|
// Update area
|
if (_scrollOrientation == Enum.Crown.ScrollOrientation.Vertical)
|
{
|
int thumbSize = (int)(_trackArea.Height * _viewContentRatio);
|
|
if (thumbSize < ThemeProvider.Theme.Sizes.MinimumThumbSize)
|
{
|
thumbSize = ThemeProvider.Theme.Sizes.MinimumThumbSize;
|
}
|
|
int trackAreaSize = _trackArea.Height - thumbSize;
|
int thumbPosition = (int)(trackAreaSize * positionRatio);
|
|
_thumbArea = new(_trackArea.Left + 3, _trackArea.Top + thumbPosition, ThemeProvider.Theme.Sizes.ScrollBarSize - 6, thumbSize);
|
}
|
else if (_scrollOrientation == Enum.Crown.ScrollOrientation.Horizontal)
|
{
|
int thumbSize = (int)(_trackArea.Width * _viewContentRatio);
|
|
if (thumbSize < ThemeProvider.Theme.Sizes.MinimumThumbSize)
|
{
|
thumbSize = ThemeProvider.Theme.Sizes.MinimumThumbSize;
|
}
|
|
int trackAreaSize = _trackArea.Width - thumbSize;
|
int thumbPosition = (int)(trackAreaSize * positionRatio);
|
|
_thumbArea = new(_trackArea.Left + thumbPosition, _trackArea.Top + 3, thumbSize, ThemeProvider.Theme.Sizes.ScrollBarSize - 6);
|
}
|
|
if (forceRefresh)
|
{
|
Invalidate();
|
Update();
|
}
|
}
|
|
#endregion
|
|
#region Paint Region
|
|
protected override void OnPaint(PaintEventArgs e)
|
{
|
Graphics g = e.Graphics;
|
|
// DEBUG: Scrollbar bg
|
using (SolidBrush b = new(ThemeProvider.Theme.Colors.GreyBackground))
|
{
|
g.FillRectangle(b, ClientRectangle);
|
}/**/
|
|
// DEBUG: Arrow backgrounds
|
/*using (var b = new(Color.White))
|
{
|
g.FillRectangle(b, _upArrowArea);
|
g.FillRectangle(b, _downArrowArea);
|
}*/
|
|
// Up arrow
|
Bitmap upIcon = _upArrowHot ? Properties.Resources.scrollbar_arrow_hot : Properties.Resources.scrollbar_arrow_standard;
|
|
if (_upArrowClicked)
|
{
|
upIcon = Properties.Resources.scrollbar_arrow_clicked;
|
}
|
|
if (!Enabled)
|
{
|
upIcon = Properties.Resources.scrollbar_arrow_disabled;
|
}
|
|
if (_scrollOrientation == Enum.Crown.ScrollOrientation.Vertical)
|
{
|
upIcon.RotateFlip(RotateFlipType.RotateNoneFlipY);
|
}
|
else if (_scrollOrientation == Enum.Crown.ScrollOrientation.Horizontal)
|
{
|
upIcon.RotateFlip(RotateFlipType.Rotate90FlipNone);
|
}
|
|
g.DrawImageUnscaled(upIcon, _upArrowArea.Left + (_upArrowArea.Width / 2) - (upIcon.Width / 2), _upArrowArea.Top + (_upArrowArea.Height / 2) - (upIcon.Height / 2));
|
|
// Down arrow
|
Bitmap downIcon = _downArrowHot ? Properties.Resources.scrollbar_arrow_hot : Properties.Resources.scrollbar_arrow_standard;
|
|
if (_downArrowClicked)
|
{
|
downIcon = Properties.Resources.scrollbar_arrow_clicked;
|
}
|
|
if (!Enabled)
|
{
|
downIcon = Properties.Resources.scrollbar_arrow_disabled;
|
}
|
|
if (_scrollOrientation == Enum.Crown.ScrollOrientation.Horizontal)
|
{
|
downIcon.RotateFlip(RotateFlipType.Rotate270FlipNone);
|
}
|
|
g.DrawImageUnscaled(downIcon, _downArrowArea.Left + (_downArrowArea.Width / 2) - (downIcon.Width / 2), _downArrowArea.Top + (_downArrowArea.Height / 2) - (downIcon.Height / 2));
|
|
// Draw thumb
|
if (Enabled)
|
{
|
Color scrollColor = _thumbHot ? ThemeProvider.Theme.Colors.GreyHighlight : ThemeProvider.Theme.Colors.GreySelection;
|
|
if (_isScrolling)
|
{
|
scrollColor = ThemeProvider.Theme.Colors.ActiveControl;
|
}
|
|
using SolidBrush b = new(scrollColor);
|
g.FillRectangle(b, _thumbArea);
|
}
|
}
|
|
#endregion
|
}
|
|
#endregion
|
}
|
