#region Imports
|
|
using DPumpHydr.WinFrmUI.RLT.Child.Material;
|
using DPumpHydr.WinFrmUI.RLT.Helper;
|
using DPumpHydr.WinFrmUI.RLT.Manager;
|
using System;
|
using System.ComponentModel;
|
using System.Drawing;
|
using System.Runtime.InteropServices;
|
using System.Windows.Forms;
|
using static DPumpHydr.WinFrmUI.RLT.Helper.MaterialDrawHelper;
|
using static DPumpHydr.WinFrmUI.RLT.Util.MaterialAnimations;
|
|
#endregion
|
|
namespace DPumpHydr.WinFrmUI.RLT.Controls
|
{
|
#region MaterialMultiLineTextBoxEdit
|
|
public class MaterialMultiLineTextBoxEdit : Control, MaterialControlI
|
{
|
MaterialContextMenuStrip cms = new MaterialBaseTextBoxContextMenuStrip();
|
ContextMenuStrip _lastContextMenuStrip = new();
|
|
//Properties for managing the material design properties
|
|
[Browsable(false)]
|
public int Depth { get; set; }
|
|
[Browsable(false)]
|
public MaterialSkinManager SkinManager => MaterialSkinManager.Instance;
|
|
public bool Focus()
|
{
|
return baseTextBox.Focus();
|
}
|
|
[Browsable(false)]
|
public MaterialMouseState MouseState { get; set; }
|
|
//Unused properties
|
|
[Browsable(false)]
|
public override Image BackgroundImage { get; set; }
|
|
[Browsable(false)]
|
public override ImageLayout BackgroundImageLayout { get; set; }
|
|
[Browsable(false)]
|
public string SelectedText { get => baseTextBox.SelectedText; set => baseTextBox.SelectedText = value; }
|
|
[Browsable(false)]
|
public int SelectionStart { get => baseTextBox.SelectionStart; set => baseTextBox.SelectionStart = value; }
|
[Browsable(false)]
|
public int SelectionLength { get => baseTextBox.SelectionLength; set => baseTextBox.SelectionLength = value; }
|
[Browsable(false)]
|
public int TextLength => baseTextBox.TextLength;
|
|
[Browsable(false)]
|
public override Color ForeColor { get; set; }
|
|
//Material Skin properties
|
|
|
[Category("Material"), DefaultValue(""), Localizable(true)]
|
public string Hint
|
{
|
get => baseTextBox.Hint;
|
set
|
{
|
baseTextBox.Hint = value;
|
hasHint = !string.IsNullOrEmpty(baseTextBox.Hint);
|
Invalidate();
|
}
|
}
|
|
[Category("Material"), DefaultValue(true)]
|
public bool UseAccent { get; set; }
|
|
|
|
[Browsable(true)]
|
[Category("Material"), DefaultValue(true), Description("Defines whether MaterialMultiLineTextBox allows scrolling of text. This property is independent of the ScrollBars property")]
|
public bool AllowScroll { get; set; }
|
|
|
|
//TextBox properties
|
|
public override ContextMenuStrip ContextMenuStrip
|
{
|
get => baseTextBox.ContextMenuStrip;
|
set
|
{
|
if (value != null)
|
{
|
baseTextBox.ContextMenuStrip = value;
|
base.ContextMenuStrip = value;
|
}
|
else
|
{
|
baseTextBox.ContextMenuStrip = cms;
|
base.ContextMenuStrip = cms;
|
}
|
_lastContextMenuStrip = base.ContextMenuStrip;
|
}
|
}
|
|
[Browsable(false)]
|
public override Color BackColor => Parent == null ? SkinManager.BackgroundColor : Parent.BackColor;
|
|
public override string Text { get => baseTextBox.Text; set => baseTextBox.Text = value; }
|
|
[Category("Appearance")]
|
public HorizontalAlignment TextAlign { get => baseTextBox.TextAlign; set => baseTextBox.TextAlign = value; }
|
|
[Category("Appearance")]
|
public ScrollBars ScrollBars { get => baseTextBox.ScrollBars; set => baseTextBox.ScrollBars = value; }
|
|
[Category("Behavior")]
|
public CharacterCasing CharacterCasing { get => baseTextBox.CharacterCasing; set => baseTextBox.CharacterCasing = value; }
|
|
[Category("Behavior")]
|
public bool HideSelection { get => baseTextBox.HideSelection; set => baseTextBox.HideSelection = value; }
|
|
[Category("Behavior")]
|
public int MaxLength { get => baseTextBox.MaxLength; set => baseTextBox.MaxLength = value; }
|
|
[Category("Behavior")]
|
public char PasswordChar { get => baseTextBox.PasswordChar; set => baseTextBox.PasswordChar = value; }
|
|
[Category("Behavior")]
|
public bool ShortcutsEnabled
|
{
|
get => baseTextBox.ShortcutsEnabled;
|
set
|
{
|
baseTextBox.ShortcutsEnabled = value;
|
if (value == false)
|
{
|
baseTextBox.ContextMenuStrip = null;
|
base.ContextMenuStrip = null;
|
}
|
else
|
{
|
baseTextBox.ContextMenuStrip = _lastContextMenuStrip;
|
base.ContextMenuStrip = _lastContextMenuStrip;
|
}
|
}
|
}
|
|
[Category("Behavior")]
|
public bool UseSystemPasswordChar { get => baseTextBox.UseSystemPasswordChar; set => baseTextBox.UseSystemPasswordChar = value; }
|
|
public new object Tag { get => baseTextBox.Tag; set => baseTextBox.Tag = value; }
|
|
private bool _readonly;
|
[Category("Behavior")]
|
public bool ReadOnly
|
{
|
get => _readonly;
|
set
|
{
|
_readonly = value;
|
if (Enabled == true)
|
{
|
baseTextBox.ReadOnly = _readonly;
|
}
|
this.Invalidate();
|
}
|
}
|
|
private bool _animateReadOnly;
|
|
[Category("Material")]
|
[Browsable(true)]
|
public bool AnimateReadOnly
|
{
|
get => _animateReadOnly;
|
set
|
{
|
_animateReadOnly = value;
|
Invalidate();
|
}
|
}
|
|
private bool _leaveOnEnterKey;
|
|
[Category("Material"), DefaultValue(false), Description("Select next control which have TabStop property set to True when enter key is pressed. To add enter in text, the user must press CTRL+Enter")]
|
public bool LeaveOnEnterKey
|
{
|
get => _leaveOnEnterKey;
|
set
|
{
|
_leaveOnEnterKey = value;
|
if (value)
|
{
|
baseTextBox.KeyDown += new KeyEventHandler(LeaveOnEnterKey_KeyDown);
|
}
|
else
|
{
|
baseTextBox.KeyDown -= LeaveOnEnterKey_KeyDown;
|
}
|
Invalidate();
|
}
|
}
|
|
public void SelectAll() { baseTextBox.SelectAll(); }
|
|
public void Clear() { baseTextBox.Clear(); }
|
|
public void Copy() { baseTextBox.Copy(); }
|
|
public void Cut() { baseTextBox.Cut(); }
|
|
public void Undo() { baseTextBox.Undo(); }
|
|
public void Paste() { baseTextBox.Paste(); }
|
|
|
#region Forwarding events to baseTextBox
|
|
public event EventHandler AcceptsTabChanged
|
{
|
add => baseTextBox.AcceptsTabChanged += value;
|
remove => baseTextBox.AcceptsTabChanged -= value;
|
}
|
|
public new event EventHandler AutoSizeChanged
|
{
|
add => baseTextBox.AutoSizeChanged += value;
|
remove => baseTextBox.AutoSizeChanged -= value;
|
}
|
|
public new event EventHandler BackgroundImageChanged
|
{
|
add => baseTextBox.BackgroundImageChanged += value;
|
remove => baseTextBox.BackgroundImageChanged -= value;
|
}
|
|
public new event EventHandler BackgroundImageLayoutChanged
|
{
|
add => baseTextBox.BackgroundImageLayoutChanged += value;
|
remove => baseTextBox.BackgroundImageLayoutChanged -= value;
|
}
|
|
public new event EventHandler BindingContextChanged
|
{
|
add => baseTextBox.BindingContextChanged += value;
|
remove => baseTextBox.BindingContextChanged -= value;
|
}
|
|
public event EventHandler BorderStyleChanged
|
{
|
add => baseTextBox.BorderStyleChanged += value;
|
remove => baseTextBox.BorderStyleChanged -= value;
|
}
|
|
public new event EventHandler CausesValidationChanged
|
{
|
add => baseTextBox.CausesValidationChanged += value;
|
remove => baseTextBox.CausesValidationChanged -= value;
|
}
|
|
public new event UICuesEventHandler ChangeUICues
|
{
|
add => baseTextBox.ChangeUICues += value;
|
remove => baseTextBox.ChangeUICues -= value;
|
}
|
|
public new event EventHandler Click
|
{
|
add => baseTextBox.Click += value;
|
remove => baseTextBox.Click -= value;
|
}
|
|
public new event EventHandler ClientSizeChanged
|
{
|
add => baseTextBox.ClientSizeChanged += value;
|
remove => baseTextBox.ClientSizeChanged -= value;
|
}
|
|
#if NETFRAMEWORK
|
public new event EventHandler ContextMenuChanged
|
{
|
add => baseTextBox.ContextMenuChanged += value;
|
remove => baseTextBox.ContextMenuChanged -= value;
|
}
|
#endif
|
|
public new event EventHandler ContextMenuStripChanged
|
{
|
add => baseTextBox.ContextMenuStripChanged += value;
|
remove => baseTextBox.ContextMenuStripChanged -= value;
|
}
|
|
public new event ControlEventHandler ControlAdded
|
{
|
add => baseTextBox.ControlAdded += value;
|
remove => baseTextBox.ControlAdded -= value;
|
}
|
|
public new event ControlEventHandler ControlRemoved
|
{
|
add => baseTextBox.ControlRemoved += value;
|
remove => baseTextBox.ControlRemoved -= value;
|
}
|
|
public new event EventHandler CursorChanged
|
{
|
add => baseTextBox.CursorChanged += value;
|
remove => baseTextBox.CursorChanged -= value;
|
}
|
|
public new event EventHandler Disposed
|
{
|
add => baseTextBox.Disposed += value;
|
remove => baseTextBox.Disposed -= value;
|
}
|
|
public new event EventHandler DockChanged
|
{
|
add => baseTextBox.DockChanged += value;
|
remove => baseTextBox.DockChanged -= value;
|
}
|
|
public new event EventHandler DoubleClick
|
{
|
add => baseTextBox.DoubleClick += value;
|
remove => baseTextBox.DoubleClick -= value;
|
}
|
|
public new event DragEventHandler DragDrop
|
{
|
add => baseTextBox.DragDrop += value;
|
remove => baseTextBox.DragDrop -= value;
|
}
|
|
public new event DragEventHandler DragEnter
|
{
|
add => baseTextBox.DragEnter += value;
|
remove => baseTextBox.DragEnter -= value;
|
}
|
|
public new event EventHandler DragLeave
|
{
|
add => baseTextBox.DragLeave += value;
|
remove => baseTextBox.DragLeave -= value;
|
}
|
|
public new event DragEventHandler DragOver
|
{
|
add => baseTextBox.DragOver += value;
|
remove => baseTextBox.DragOver -= value;
|
}
|
|
public new event EventHandler EnabledChanged
|
{
|
add => baseTextBox.EnabledChanged += value;
|
remove => baseTextBox.EnabledChanged -= value;
|
}
|
|
public new event EventHandler Enter
|
{
|
add => baseTextBox.Enter += value;
|
remove => baseTextBox.Enter -= value;
|
}
|
|
public new event EventHandler FontChanged
|
{
|
add => baseTextBox.FontChanged += value;
|
remove => baseTextBox.FontChanged -= value;
|
}
|
|
public new event EventHandler ForeColorChanged
|
{
|
add => baseTextBox.ForeColorChanged += value;
|
remove => baseTextBox.ForeColorChanged -= value;
|
}
|
|
public new event GiveFeedbackEventHandler GiveFeedback
|
{
|
add => baseTextBox.GiveFeedback += value;
|
remove => baseTextBox.GiveFeedback -= value;
|
}
|
|
public new event EventHandler GotFocus
|
{
|
add => baseTextBox.GotFocus += value;
|
remove => baseTextBox.GotFocus -= value;
|
}
|
|
public new event EventHandler HandleCreated
|
{
|
add => baseTextBox.HandleCreated += value;
|
remove => baseTextBox.HandleCreated -= value;
|
}
|
|
public new event EventHandler HandleDestroyed
|
{
|
add => baseTextBox.HandleDestroyed += value;
|
remove => baseTextBox.HandleDestroyed -= value;
|
}
|
|
public new event HelpEventHandler HelpRequested
|
{
|
add => baseTextBox.HelpRequested += value;
|
remove => baseTextBox.HelpRequested -= value;
|
}
|
|
public event EventHandler HideSelectionChanged
|
{
|
add => baseTextBox.HideSelectionChanged += value;
|
remove => baseTextBox.HideSelectionChanged -= value;
|
}
|
|
public new event EventHandler ImeModeChanged
|
{
|
add => baseTextBox.ImeModeChanged += value;
|
remove => baseTextBox.ImeModeChanged -= value;
|
}
|
|
public new event InvalidateEventHandler Invalidated
|
{
|
add => baseTextBox.Invalidated += value;
|
remove => baseTextBox.Invalidated -= value;
|
}
|
|
public new event KeyEventHandler KeyDown
|
{
|
add => baseTextBox.KeyDown += value;
|
remove => baseTextBox.KeyDown -= value;
|
}
|
|
public new event KeyPressEventHandler KeyPress
|
{
|
add => baseTextBox.KeyPress += value;
|
remove => baseTextBox.KeyPress -= value;
|
}
|
|
public new event KeyEventHandler KeyUp
|
{
|
add => baseTextBox.KeyUp += value;
|
remove => baseTextBox.KeyUp -= value;
|
}
|
|
public new event LayoutEventHandler Layout
|
{
|
add => baseTextBox.Layout += value;
|
remove => baseTextBox.Layout -= value;
|
}
|
|
public new event EventHandler Leave
|
{
|
add => baseTextBox.Leave += value;
|
remove => baseTextBox.Leave -= value;
|
}
|
|
public new event EventHandler LocationChanged
|
{
|
add => baseTextBox.LocationChanged += value;
|
remove => baseTextBox.LocationChanged -= value;
|
}
|
|
public new event EventHandler LostFocus
|
{
|
add => baseTextBox.LostFocus += value;
|
remove => baseTextBox.LostFocus -= value;
|
}
|
|
public new event EventHandler MarginChanged
|
{
|
add => baseTextBox.MarginChanged += value;
|
remove => baseTextBox.MarginChanged -= value;
|
}
|
|
public event EventHandler ModifiedChanged
|
{
|
add => baseTextBox.ModifiedChanged += value;
|
remove => baseTextBox.ModifiedChanged -= value;
|
}
|
|
public new event EventHandler MouseCaptureChanged
|
{
|
add => baseTextBox.MouseCaptureChanged += value;
|
remove => baseTextBox.MouseCaptureChanged -= value;
|
}
|
|
public new event MouseEventHandler MouseClick
|
{
|
add => baseTextBox.MouseClick += value;
|
remove => baseTextBox.MouseClick -= value;
|
}
|
|
public new event MouseEventHandler MouseDoubleClick
|
{
|
add => baseTextBox.MouseDoubleClick += value;
|
remove => baseTextBox.MouseDoubleClick -= value;
|
}
|
|
public new event MouseEventHandler MouseDown
|
{
|
add => baseTextBox.MouseDown += value;
|
remove => baseTextBox.MouseDown -= value;
|
}
|
|
public new event EventHandler MouseEnter
|
{
|
add => baseTextBox.MouseEnter += value;
|
remove => baseTextBox.MouseEnter -= value;
|
}
|
|
public new event EventHandler MouseHover
|
{
|
add => baseTextBox.MouseHover += value;
|
remove => baseTextBox.MouseHover -= value;
|
}
|
|
public new event EventHandler MouseLeave
|
{
|
add => baseTextBox.MouseLeave += value;
|
remove => baseTextBox.MouseLeave -= value;
|
}
|
|
public new event MouseEventHandler MouseMove
|
{
|
add => baseTextBox.MouseMove += value;
|
remove => baseTextBox.MouseMove -= value;
|
}
|
|
public new event MouseEventHandler MouseUp
|
{
|
add => baseTextBox.MouseUp += value;
|
remove => baseTextBox.MouseUp -= value;
|
}
|
|
public new event MouseEventHandler MouseWheel
|
{
|
add => baseTextBox.MouseWheel += value;
|
remove => baseTextBox.MouseWheel -= value;
|
}
|
|
public new event EventHandler Move
|
{
|
add => baseTextBox.Move += value;
|
remove => baseTextBox.Move -= value;
|
}
|
|
public event EventHandler MultilineChanged
|
{
|
add => baseTextBox.MultilineChanged += value;
|
remove => baseTextBox.MultilineChanged -= value;
|
}
|
|
public new event EventHandler PaddingChanged
|
{
|
add => baseTextBox.PaddingChanged += value;
|
remove => baseTextBox.PaddingChanged -= value;
|
}
|
|
public new event PaintEventHandler Paint
|
{
|
add => baseTextBox.Paint += value;
|
remove => baseTextBox.Paint -= value;
|
}
|
|
public new event EventHandler ParentChanged
|
{
|
add => baseTextBox.ParentChanged += value;
|
remove => baseTextBox.ParentChanged -= value;
|
}
|
|
public new event PreviewKeyDownEventHandler PreviewKeyDown
|
{
|
add => baseTextBox.PreviewKeyDown += value;
|
remove => baseTextBox.PreviewKeyDown -= value;
|
}
|
|
public new event QueryAccessibilityHelpEventHandler QueryAccessibilityHelp
|
{
|
add => baseTextBox.QueryAccessibilityHelp += value;
|
remove => baseTextBox.QueryAccessibilityHelp -= value;
|
}
|
|
public new event QueryContinueDragEventHandler QueryContinueDrag
|
{
|
add => baseTextBox.QueryContinueDrag += value;
|
remove => baseTextBox.QueryContinueDrag -= value;
|
}
|
|
public event EventHandler ReadOnlyChanged
|
{
|
add => baseTextBox.ReadOnlyChanged += value;
|
remove => baseTextBox.ReadOnlyChanged -= value;
|
}
|
|
public new event EventHandler RegionChanged
|
{
|
add => baseTextBox.RegionChanged += value;
|
remove => baseTextBox.RegionChanged -= value;
|
}
|
|
public new event EventHandler Resize
|
{
|
add => baseTextBox.Resize += value;
|
remove => baseTextBox.Resize -= value;
|
}
|
|
public new event EventHandler RightToLeftChanged
|
{
|
add => baseTextBox.RightToLeftChanged += value;
|
remove => baseTextBox.RightToLeftChanged -= value;
|
}
|
|
public new event EventHandler SizeChanged
|
{
|
add => baseTextBox.SizeChanged += value;
|
remove => baseTextBox.SizeChanged -= value;
|
}
|
|
public new event EventHandler StyleChanged
|
{
|
add => baseTextBox.StyleChanged += value;
|
remove => baseTextBox.StyleChanged -= value;
|
}
|
|
public new event EventHandler SystemColorsChanged
|
{
|
add => baseTextBox.SystemColorsChanged += value;
|
remove => baseTextBox.SystemColorsChanged -= value;
|
}
|
|
public new event EventHandler TabIndexChanged
|
{
|
add => baseTextBox.TabIndexChanged += value;
|
remove => baseTextBox.TabIndexChanged -= value;
|
}
|
|
public new event EventHandler TabStopChanged
|
{
|
add => baseTextBox.TabStopChanged += value;
|
remove => baseTextBox.TabStopChanged -= value;
|
}
|
|
public event EventHandler TextAlignChanged
|
{
|
add => baseTextBox.TextAlignChanged += value;
|
remove => baseTextBox.TextAlignChanged -= value;
|
}
|
|
public new event EventHandler TextChanged
|
{
|
add => baseTextBox.TextChanged += value;
|
remove => baseTextBox.TextChanged -= value;
|
}
|
|
public new event EventHandler Validated
|
{
|
add => baseTextBox.Validated += value;
|
remove => baseTextBox.Validated -= value;
|
}
|
|
public new event CancelEventHandler Validating
|
{
|
add => baseTextBox.Validating += value;
|
remove => baseTextBox.Validating -= value;
|
}
|
|
public new event EventHandler VisibleChanged
|
{
|
add => baseTextBox.VisibleChanged += value;
|
remove => baseTextBox.VisibleChanged -= value;
|
}
|
# endregion
|
|
//private readonly AnimationManager animationManager;
|
private readonly AnimationManager _animationManager;
|
|
public bool isFocused = false;
|
private const int HINT_TEXT_SMALL_SIZE = 18;
|
private const int HINT_TEXT_SMALL_Y = 4;
|
private const int LINE_BOTTOM_PADDING = 3;
|
private const int TOP_PADDING = 10;
|
private const int BOTTOM_PADDING = 10;
|
private const int LEFT_PADDING = 16;
|
private const int RIGHT_PADDING = 12;
|
private int LINE_Y;
|
private bool hasHint;
|
private readonly int SB_LINEUP = 0;
|
private readonly int SB_LINEDOWN = 1;
|
private readonly uint WM_VSCROLL = 277;
|
private readonly IntPtr ptrLparam = new(0);
|
|
protected readonly MaterialBaseTextBox baseTextBox;
|
public MaterialMultiLineTextBoxEdit()
|
{
|
AllowScroll = true;
|
// Material Properties
|
UseAccent = true;
|
MouseState = MaterialMouseState.OUT;
|
|
SetStyle(ControlStyles.OptimizedDoubleBuffer | ControlStyles.DoubleBuffer, true);
|
|
// Animations
|
_animationManager = new AnimationManager
|
{
|
Increment = 0.06,
|
AnimationType = AnimationType.EaseInOut,
|
InterruptAnimation = false
|
};
|
_animationManager.OnAnimationProgress += sender => Invalidate();
|
|
baseTextBox = new MaterialBaseTextBox
|
{
|
BorderStyle = BorderStyle.None,
|
Font = SkinManager.GetFontByType(MaterialSkinManager.FontType.Subtitle1),
|
ForeColor = SkinManager.TextHighEmphasisColor,
|
Multiline = true
|
};
|
|
Cursor = Cursors.IBeam;
|
Enabled = true;
|
ReadOnly = false;
|
ScrollBars = ScrollBars.None;
|
Size = new Size(250, 100);
|
|
if (!Controls.Contains(baseTextBox) && !DesignMode)
|
{
|
Controls.Add(baseTextBox);
|
}
|
|
baseTextBox.GotFocus += (sender, args) =>
|
{
|
if (Enabled)
|
{
|
isFocused = true;
|
_animationManager.StartNewAnimation(AnimationDirection.In);
|
}
|
else
|
{
|
base.Focus();
|
}
|
};
|
baseTextBox.LostFocus += (sender, args) =>
|
{
|
isFocused = false;
|
_animationManager.StartNewAnimation(AnimationDirection.Out);
|
};
|
|
baseTextBox.TextChanged += new EventHandler(Redraw);
|
baseTextBox.BackColorChanged += new EventHandler(Redraw);
|
|
baseTextBox.TabStop = true;
|
this.TabStop = false;
|
|
cms.Opening += ContextMenuStripOnOpening;
|
cms.OnItemClickStart += ContextMenuStripOnItemClickStart;
|
ContextMenuStrip = cms;
|
this.MouseWheel += OnMouseWheel;
|
}
|
|
private void Redraw(object sencer, EventArgs e)
|
{
|
SuspendLayout();
|
Invalidate();
|
ResumeLayout(false);
|
}
|
|
protected override void OnPaint(PaintEventArgs pevent)
|
{
|
Graphics g = pevent.Graphics;
|
g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias;
|
g.Clear(Parent.BackColor == Color.Transparent ? ((Parent.Parent == null || (Parent.Parent != null && Parent.Parent.BackColor == Color.Transparent)) ? SkinManager.BackgroundColor : Parent.Parent.BackColor) : Parent.BackColor);
|
SolidBrush backBrush = new(BlendColor(Parent.BackColor, SkinManager.BackgroundAlternativeColor, SkinManager.BackgroundAlternativeColor.A));
|
|
//backColor
|
g.FillRectangle(
|
!Enabled ? SkinManager.BackgroundDisabledBrush : // Disabled
|
isFocused ? SkinManager.BackgroundFocusBrush : // Focused
|
MouseState == MaterialMouseState.HOVER && (!ReadOnly || (ReadOnly && !AnimateReadOnly)) ? SkinManager.BackgroundHoverBrush : // Hover
|
backBrush, // Normal
|
ClientRectangle.X, ClientRectangle.Y, ClientRectangle.Width, LINE_Y);
|
|
baseTextBox.BackColor = !Enabled ? MaterialColorHelper.RemoveAlpha(SkinManager.BackgroundDisabledColor, BackColor) : //Disabled
|
isFocused ? BlendColor(BackColor, SkinManager.BackgroundFocusColor, SkinManager.BackgroundFocusColor.A) : //Focused
|
MouseState == MaterialMouseState.HOVER && (!ReadOnly || (ReadOnly && !AnimateReadOnly)) ? BlendColor(BackColor, SkinManager.BackgroundHoverColor, SkinManager.BackgroundHoverColor.A) : // Hover
|
BlendColor(BackColor, SkinManager.BackgroundAlternativeColor, SkinManager.BackgroundAlternativeColor.A); // Normal
|
|
// bottom line base
|
g.FillRectangle(SkinManager.DividersAlternativeBrush, 0, LINE_Y, Width, 1);
|
|
if (ReadOnly == false || (ReadOnly && AnimateReadOnly))
|
{
|
if (!_animationManager.IsAnimating())
|
{
|
// bottom line
|
if (isFocused)
|
{
|
//No animation
|
g.FillRectangle(isFocused ? UseAccent ? SkinManager.ColorScheme.AccentBrush : SkinManager.ColorScheme.PrimaryBrush : SkinManager.DividersBrush, 0, LINE_Y, Width, isFocused ? 2 : 1);
|
}
|
}
|
else
|
{
|
// Animate - Focus got/lost
|
double animationProgress = _animationManager.GetProgress();
|
|
// Line Animation
|
int LineAnimationWidth = (int)(Width * animationProgress);
|
int LineAnimationX = (Width / 2) - (LineAnimationWidth / 2);
|
g.FillRectangle(UseAccent ? SkinManager.ColorScheme.AccentBrush : SkinManager.ColorScheme.PrimaryBrush, LineAnimationX, LINE_Y, LineAnimationWidth, 2);
|
}
|
}
|
}
|
|
|
[DllImport("User32.dll", CharSet = CharSet.Auto, EntryPoint = "SendMessage")]
|
protected static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);
|
|
protected void OnMouseWheel(object sender, MouseEventArgs e)
|
{
|
if (AllowScroll)
|
{
|
if (DesignMode)
|
{
|
return;
|
}
|
//Calculate number of notches mouse wheel moved
|
int v = e.Delta / 120;
|
//Down Movement
|
if (v < 0)
|
{
|
IntPtr ptrWparam = new(SB_LINEDOWN);
|
SendMessage(baseTextBox.Handle, WM_VSCROLL, ptrWparam, ptrLparam);
|
}
|
//Up Movement
|
else if (v > 0)
|
{
|
IntPtr ptrWparam = new(SB_LINEUP);
|
SendMessage(baseTextBox.Handle, WM_VSCROLL, ptrWparam, ptrLparam);
|
}
|
|
baseTextBox?.Focus();
|
base.OnMouseDown(e);
|
}
|
}
|
|
protected override void OnMouseMove(MouseEventArgs e)
|
{
|
if (DesignMode)
|
{
|
return;
|
}
|
|
base.OnMouseMove(e);
|
}
|
|
protected override void OnMouseDown(MouseEventArgs e)
|
{
|
if (DesignMode)
|
{
|
return;
|
}
|
|
baseTextBox?.Focus();
|
base.OnMouseDown(e);
|
}
|
|
protected override void OnMouseEnter(EventArgs e)
|
{
|
if (DesignMode)
|
{
|
return;
|
}
|
|
base.OnMouseEnter(e);
|
MouseState = MaterialMouseState.HOVER;
|
Invalidate();
|
}
|
|
protected override void OnMouseLeave(EventArgs e)
|
{
|
if (DesignMode)
|
{
|
return;
|
}
|
|
if (this.ClientRectangle.Contains(this.PointToClient(Control.MousePosition)))
|
{
|
return;
|
}
|
else
|
{
|
base.OnMouseLeave(e);
|
MouseState = MaterialMouseState.OUT;
|
Invalidate();
|
}
|
}
|
|
protected override void OnResize(EventArgs e)
|
{
|
base.OnResize(e);
|
|
baseTextBox.Location = new Point(LEFT_PADDING, TOP_PADDING);
|
baseTextBox.Width = Width - (LEFT_PADDING + RIGHT_PADDING);
|
baseTextBox.Height = Height - (TOP_PADDING + BOTTOM_PADDING);
|
|
LINE_Y = Height - LINE_BOTTOM_PADDING;
|
|
}
|
|
protected override void OnCreateControl()
|
{
|
base.OnCreateControl();
|
|
// events
|
MouseState = MaterialMouseState.OUT;
|
}
|
|
private void ContextMenuStripOnItemClickStart(object sender, ToolStripItemClickedEventArgs toolStripItemClickedEventArgs)
|
{
|
switch (toolStripItemClickedEventArgs.ClickedItem.Text)
|
{
|
case "Undo":
|
Undo();
|
break;
|
case "Cut":
|
Cut();
|
break;
|
case "Copy":
|
Copy();
|
break;
|
case "Paste":
|
Paste();
|
break;
|
case "Delete":
|
SelectedText = string.Empty;
|
break;
|
case "Select All":
|
SelectAll();
|
break;
|
}
|
}
|
|
private void ContextMenuStripOnOpening(object sender, CancelEventArgs cancelEventArgs)
|
{
|
if (sender is MaterialBaseTextBoxContextMenuStrip strip)
|
{
|
strip.undo.Enabled = baseTextBox.CanUndo && !ReadOnly;
|
strip.cut.Enabled = !string.IsNullOrEmpty(SelectedText) && !ReadOnly;
|
strip.copy.Enabled = !string.IsNullOrEmpty(SelectedText);
|
strip.paste.Enabled = Clipboard.ContainsText() && !ReadOnly;
|
strip.delete.Enabled = !string.IsNullOrEmpty(SelectedText) && !ReadOnly;
|
strip.selectAll.Enabled = !string.IsNullOrEmpty(Text);
|
}
|
}
|
|
private void LeaveOnEnterKey_KeyDown(object sender, KeyEventArgs e)
|
{
|
if (e.KeyData == Keys.Enter && e.Control == false)
|
{
|
e.Handled = true;
|
e.SuppressKeyPress = true;
|
SendKeys.Send("{TAB}");
|
}
|
}
|
}
|
|
#endregion
|
}
|
