#region Imports
|
|
using DPumpHydr.WinFrmUI.RLT.Child.Material;
|
using DPumpHydr.WinFrmUI.RLT.Helper;
|
using DPumpHydr.WinFrmUI.RLT.Manager;
|
using DPumpHydr.WinFrmUI.RLT.Util;
|
using System;
|
using System.Collections.Generic;
|
using System.ComponentModel;
|
using System.Drawing;
|
using System.Drawing.Imaging;
|
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 MaterialTextBoxEdit
|
|
public class MaterialTextBoxEdit : 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;
|
|
/// <summary>
|
///
|
/// </summary>
|
/// <returns></returns>
|
public new 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 properties
|
|
private bool _UseTallSize;
|
|
[Category("Material"), DefaultValue(true), Description("Using a larger size enables the hint to always be visible")]
|
public bool UseTallSize
|
{
|
get => _UseTallSize;
|
set
|
{
|
_UseTallSize = value;
|
UpdateHeight();
|
UpdateRects();
|
Invalidate();
|
}
|
}
|
|
private bool _showAssistiveText;
|
[Category("Material"), DefaultValue(false), Description("Assistive elements provide additional detail about text entered into text fields. Could be Helper text or Error message.")]
|
public bool ShowAssistiveText
|
{
|
get => _showAssistiveText;
|
set
|
{
|
_showAssistiveText = value;
|
if (_showAssistiveText)
|
{
|
_helperTextHeight = HELPER_TEXT_HEIGHT;
|
}
|
else
|
{
|
_helperTextHeight = 0;
|
}
|
|
UpdateHeight();
|
//UpdateRects();
|
Invalidate();
|
}
|
}
|
|
private string _helperText;
|
|
[Category("Material"), DefaultValue(""), Localizable(true), Description("Helper text conveys additional guidance about the input field, such as how it will be used.")]
|
public string HelperText
|
{
|
get => _helperText;
|
set
|
{
|
_helperText = value;
|
Invalidate();
|
}
|
}
|
|
[Category("Material"), DefaultValue(""), Localizable(true), Description("Helper text conveys additional guidance about the input field, such as how it will be used.")]
|
public string NullValuePromptText
|
{
|
get => _nullValuePromptText;
|
set
|
{
|
_nullValuePromptText = value;
|
Invalidate();
|
}
|
}
|
private string _nullValuePromptText;
|
|
|
private string _errorMessage;
|
|
[Category("Material"), DefaultValue(""), Localizable(true), Description("When text input isn't accepted, an error message can display instructions on how to fix it. Error messages are displayed below the input line, replacing helper text until fixed.")]
|
public string ErrorMessage
|
{
|
get => _errorMessage;
|
set
|
{
|
_errorMessage = value;
|
Invalidate();
|
}
|
}
|
|
[Category("Material"), DefaultValue(""), Localizable(true)]
|
public string Hint
|
{
|
get => baseTextBox.Hint;
|
set
|
{
|
baseTextBox.Hint = value;
|
hasHint = !string.IsNullOrEmpty(baseTextBox.Hint);
|
UpdateRects();
|
Invalidate();
|
}
|
}
|
|
[Category("Material"), DefaultValue(true)]
|
public bool UseAccent { get; set; }
|
|
private Image _leadingIcon;
|
|
[Category("Material"), Browsable(true), Localizable(false)]
|
/// <summary>
|
/// Gets or sets the leading Icon
|
/// </summary>
|
public Image LeadingIcon
|
{
|
get => _leadingIcon;
|
set
|
{
|
_leadingIcon = value;
|
UpdateRects();
|
preProcessIcons();
|
Invalidate();
|
}
|
}
|
|
private Image _trailingIcon;
|
|
[Category("Material"), Browsable(true), Localizable(false)]
|
/// <summary>
|
/// Gets or sets the trailing Icon
|
/// </summary>
|
public Image TrailingIcon
|
{
|
get => _trailingIcon;
|
set
|
{
|
_trailingIcon = value;
|
UpdateRects();
|
preProcessIcons();
|
Invalidate();
|
}
|
}
|
|
public enum PrefixSuffixTypes
|
{
|
None,
|
Prefix,
|
Suffix,
|
}
|
|
private PrefixSuffixTypes _prefixsuffix;
|
[Category("Material"), DefaultValue(PrefixSuffixTypes.None), Description("Set Prefix/Suffix/None")]
|
public PrefixSuffixTypes PrefixSuffix
|
{
|
get => _prefixsuffix;
|
set
|
{
|
_prefixsuffix = value;
|
UpdateRects(); //Génére une nullref exception
|
if (_prefixsuffix == PrefixSuffixTypes.Suffix)
|
{
|
RightToLeft = RightToLeft.Yes;
|
}
|
else
|
{
|
RightToLeft = RightToLeft.No;
|
}
|
|
Invalidate();
|
}
|
}
|
|
private string _prefixsuffixText;
|
[Category("Material"), DefaultValue(""), Localizable(true), Description("Set Prefix or Suffix text")]
|
public string PrefixSuffixText
|
{
|
get => _prefixsuffixText;
|
set
|
{
|
//if (_prefixsuffixText != value)
|
//{
|
_prefixsuffixText = value;
|
UpdateRects();
|
Invalidate();
|
//}
|
}
|
}
|
|
//TextBox properties
|
|
public override ContextMenuStrip ContextMenuStrip
|
{
|
get => baseTextBox.ContextMenuStrip;
|
set
|
{
|
if (value != null)
|
{
|
//ContextMenuStrip = value;
|
baseTextBox.ContextMenuStrip = value;
|
base.ContextMenuStrip = value;
|
}
|
else
|
{
|
//ContextMenuStrip = cms;
|
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; UpdateRects(); } }
|
|
[Category("Appearance")]
|
public HorizontalAlignment TextAlign { get => baseTextBox.TextAlign; set => baseTextBox.TextAlign = 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.")]
|
public bool LeaveOnEnterKey
|
{
|
get => _leaveOnEnterKey;
|
set
|
{
|
_leaveOnEnterKey = value;
|
if (value)
|
{
|
baseTextBox.KeyDown += new KeyEventHandler(LeaveOnEnterKey_KeyDown);
|
}
|
else
|
{
|
baseTextBox.KeyDown -= LeaveOnEnterKey_KeyDown;
|
}
|
Invalidate();
|
}
|
}
|
|
public AutoCompleteStringCollection AutoCompleteCustomSource { get => baseTextBox.AutoCompleteCustomSource; set => baseTextBox.AutoCompleteCustomSource = value; }
|
|
public AutoCompleteSource AutoCompleteSource { get => baseTextBox.AutoCompleteSource; set => baseTextBox.AutoCompleteSource = value; }
|
|
public AutoCompleteMode AutoCompleteMode { get => baseTextBox.AutoCompleteMode; set => baseTextBox.AutoCompleteMode = value; }
|
|
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 "Events"
|
|
[Category("Action")]
|
[Description("Fires when Leading Icon is clicked")]
|
public event EventHandler LeadingIconClick;
|
|
[Category("Action")]
|
[Description("Fires when Trailing Icon is clicked")]
|
public event EventHandler TrailingIconClick;
|
|
#endregion
|
|
# 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;
|
|
public bool isFocused = false;
|
private const int PREFIX_SUFFIX_PADDING = 4;
|
private const int ICON_SIZE = 24;
|
private const int HINT_TEXT_SMALL_SIZE = 18;
|
private const int HINT_TEXT_SMALL_Y = 4;
|
private const int LEFT_PADDING = 16;
|
private const int RIGHT_PADDING = 12;
|
private const int ACTIVATION_INDICATOR_HEIGHT = 2;
|
private const int HELPER_TEXT_HEIGHT = 16;
|
private const int FONT_HEIGHT = 20;
|
|
private int HEIGHT = 48;
|
|
private int LINE_Y;
|
private bool hasHint;
|
private bool _errorState = false;
|
private int _left_padding;
|
private int _right_padding;
|
private int _prefix_padding;
|
private int _suffix_padding;
|
private int _helperTextHeight;
|
private Rectangle _leadingIconBounds;
|
private Rectangle _trailingIconBounds;
|
|
private Dictionary<string, TextureBrush> iconsBrushes;
|
private Dictionary<string, TextureBrush> iconsErrorBrushes;
|
|
protected readonly MaterialBaseTextBox baseTextBox;
|
|
public MaterialTextBoxEdit()
|
{
|
// 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();
|
|
SkinManager.ColorSchemeChanged += sender =>
|
{
|
preProcessIcons();
|
};
|
|
SkinManager.ThemeChanged += sender =>
|
{
|
preProcessIcons();
|
};
|
|
Font = SkinManager.GetFontByType(MaterialSkinManager.FontType.Subtitle1);
|
|
baseTextBox = new MaterialBaseTextBox
|
{
|
BorderStyle = BorderStyle.None,
|
Font = base.Font,
|
ForeColor = SkinManager.TextHighEmphasisColor,
|
Multiline = false,
|
Location = new Point(LEFT_PADDING, (HEIGHT / 2) - (FONT_HEIGHT / 2)),
|
Width = Width - (LEFT_PADDING + RIGHT_PADDING),
|
Height = FONT_HEIGHT
|
};
|
|
Enabled = true;
|
ReadOnly = false;
|
Size = new Size(250, HEIGHT);
|
|
UseTallSize = true;
|
PrefixSuffix = PrefixSuffixTypes.None;
|
ShowAssistiveText = false;
|
HelperText = string.Empty;
|
ErrorMessage = string.Empty;
|
|
if (!Controls.Contains(baseTextBox) && !DesignMode)
|
{
|
Controls.Add(baseTextBox);
|
}
|
|
baseTextBox.GotFocus += (sender, args) =>
|
{
|
if (Enabled)
|
{
|
isFocused = true;
|
_animationManager.StartNewAnimation(AnimationDirection.In);
|
}
|
else
|
{
|
base.Focus();
|
}
|
|
UpdateRects();
|
};
|
baseTextBox.LostFocus += (sender, args) =>
|
{
|
isFocused = false;
|
_animationManager.StartNewAnimation(AnimationDirection.Out);
|
UpdateRects();
|
};
|
|
baseTextBox.TextChanged += new EventHandler(Redraw);
|
baseTextBox.BackColorChanged += new EventHandler(Redraw);
|
|
baseTextBox.TabStop = true;
|
this.TabStop = false;
|
|
cms.Opening += ContextMenuStripOnOpening;
|
cms.OnItemClickStart += ContextMenuStripOnItemClickStart;
|
ContextMenuStrip = cms;
|
}
|
|
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
|
|
//Leading Icon
|
if (LeadingIcon != null)
|
{
|
if (_errorState)
|
{
|
g.FillRectangle(iconsErrorBrushes["_leadingIcon"], _leadingIconBounds);
|
}
|
else
|
{
|
g.FillRectangle(iconsBrushes["_leadingIcon"], _leadingIconBounds);
|
}
|
}
|
|
//Trailing Icon
|
if (TrailingIcon != null)
|
{
|
if (_errorState)
|
{
|
g.FillRectangle(iconsErrorBrushes["_trailingIcon"], _trailingIconBounds);
|
}
|
else
|
{
|
g.FillRectangle(iconsBrushes["_trailingIcon"], _trailingIconBounds);
|
}
|
}
|
|
// HintText
|
bool userTextPresent = !string.IsNullOrEmpty(Text);
|
Rectangle helperTextRect = new(LEFT_PADDING - _prefix_padding, LINE_Y + ACTIVATION_INDICATOR_HEIGHT, Width - (LEFT_PADDING - _prefix_padding) - _right_padding, HELPER_TEXT_HEIGHT);
|
Rectangle hintRect = new(_left_padding - _prefix_padding, HINT_TEXT_SMALL_Y, Width - (_left_padding - _prefix_padding) - _right_padding, HINT_TEXT_SMALL_SIZE);
|
int hintTextSize = 8;
|
|
// bottom line base
|
g.FillRectangle(SkinManager.DividersAlternativeBrush, 0, LINE_Y, Width, 1);
|
|
if (ReadOnly == false || (ReadOnly && AnimateReadOnly))
|
{
|
if (!_animationManager.IsAnimating())
|
{
|
// No animation
|
|
// bottom line
|
if (isFocused)
|
{
|
g.FillRectangle(_errorState ? SkinManager.BackgroundHoverRedBrush : 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);
|
}
|
}
|
|
// Prefix:
|
if (_prefixsuffix == PrefixSuffixTypes.Prefix && _prefixsuffixText != null && _prefixsuffixText.Length > 0 && (isFocused || userTextPresent || !hasHint))
|
{
|
using MaterialNativeTextRenderer NativeText = new(g);
|
Rectangle prefixRect = new(
|
_left_padding - _prefix_padding,
|
hasHint && UseTallSize ? hintRect.Y + hintRect.Height - 2 : ClientRectangle.Y,
|
// NativeText.MeasureLogString(_prefixsuffixText, SkinManager.getLogFontByType(MaterialSkinManager.fontType.Subtitle1)).Width,
|
_prefix_padding,
|
hasHint && UseTallSize ? LINE_Y - (hintRect.Y + hintRect.Height) : LINE_Y);
|
|
// Draw Prefix text
|
NativeText.DrawTransparentText(
|
_prefixsuffixText,
|
SkinManager.GetLogFontByType(MaterialSkinManager.FontType.Subtitle1),
|
Enabled ? SkinManager.TextMediumEmphasisColor : SkinManager.TextDisabledOrHintColor,
|
prefixRect.Location,
|
prefixRect.Size,
|
MaterialNativeTextRenderer.TextAlignFlags.Left | MaterialNativeTextRenderer.TextAlignFlags.Middle);
|
}
|
|
// Suffix:
|
if (_prefixsuffix == PrefixSuffixTypes.Suffix && _prefixsuffixText != null && _prefixsuffixText.Length > 0 && (isFocused || userTextPresent || !hasHint))
|
{
|
using MaterialNativeTextRenderer NativeText = new(g);
|
Rectangle suffixRect = new(
|
Width - _right_padding,
|
hasHint && UseTallSize ? hintRect.Y + hintRect.Height - 2 : ClientRectangle.Y,
|
//NativeText.MeasureLogString(_prefixsuffixText, SkinManager.getLogFontByType(MaterialSkinManager.fontType.Subtitle1)).Width + PREFIX_SUFFIX_PADDING,
|
_suffix_padding,
|
hasHint && UseTallSize ? LINE_Y - (hintRect.Y + hintRect.Height) : LINE_Y);
|
|
// Draw Suffix text
|
NativeText.DrawTransparentText(
|
_prefixsuffixText,
|
SkinManager.GetLogFontByType(MaterialSkinManager.FontType.Subtitle1),
|
Enabled ? SkinManager.TextMediumEmphasisColor : SkinManager.TextDisabledOrHintColor,
|
suffixRect.Location,
|
suffixRect.Size,
|
MaterialNativeTextRenderer.TextAlignFlags.Right | MaterialNativeTextRenderer.TextAlignFlags.Middle);
|
}
|
|
// Draw hint text
|
if (hasHint && UseTallSize && (isFocused || userTextPresent))
|
{
|
using MaterialNativeTextRenderer NativeText = new(g);
|
NativeText.DrawTransparentText(
|
Hint,
|
SkinManager.GetTextBoxFontBySize(hintTextSize),
|
Enabled ? !_errorState || (!userTextPresent && !isFocused) ? isFocused ? UseAccent ?
|
SkinManager.ColorScheme.AccentColor : // Focus Accent
|
SkinManager.ColorScheme.PrimaryColor : // Focus Primary
|
SkinManager.TextMediumEmphasisColor : // not focused
|
SkinManager.BackgroundHoverRedColor : // error state
|
SkinManager.TextDisabledOrHintColor, // Disabled
|
hintRect.Location,
|
hintRect.Size,
|
MaterialNativeTextRenderer.TextAlignFlags.Left | MaterialNativeTextRenderer.TextAlignFlags.Middle);
|
}
|
|
// Draw helper text
|
if (_showAssistiveText && isFocused && !_errorState)
|
{
|
using MaterialNativeTextRenderer NativeText = new(g);
|
NativeText.DrawTransparentText(
|
HelperText,
|
SkinManager.GetTextBoxFontBySize(hintTextSize),
|
Enabled ? !_errorState || (!userTextPresent && !isFocused) ? isFocused ? UseAccent ?
|
SkinManager.ColorScheme.AccentColor : // Focus Accent
|
SkinManager.ColorScheme.PrimaryColor : // Focus Primary
|
SkinManager.TextMediumEmphasisColor : // not focused
|
SkinManager.BackgroundHoverRedColor : // error state
|
SkinManager.TextDisabledOrHintColor, // Disabled
|
helperTextRect.Location,
|
helperTextRect.Size,
|
MaterialNativeTextRenderer.TextAlignFlags.Left | MaterialNativeTextRenderer.TextAlignFlags.Middle);
|
}
|
|
// Draw error message
|
if (_showAssistiveText && _errorState && ErrorMessage != null)
|
{
|
using MaterialNativeTextRenderer NativeText = new(g);
|
NativeText.DrawTransparentText(
|
ErrorMessage,
|
SkinManager.GetTextBoxFontBySize(hintTextSize),
|
Enabled ?
|
SkinManager.BackgroundHoverRedColor : // error state
|
SkinManager.TextDisabledOrHintColor, // Disabled
|
helperTextRect.Location,
|
helperTextRect.Size,
|
MaterialNativeTextRenderer.TextAlignFlags.Left | MaterialNativeTextRenderer.TextAlignFlags.Middle);
|
}
|
|
}
|
|
protected override void OnMouseMove(MouseEventArgs e)
|
{
|
base.OnMouseMove(e);
|
|
if (DesignMode)
|
{
|
return;
|
}
|
|
if (LeadingIcon != null && _leadingIconBounds.Contains(e.Location) && LeadingIconClick != null)
|
{
|
Cursor = Cursors.Hand;
|
}
|
else if (TrailingIcon != null && _trailingIconBounds.Contains(e.Location) && TrailingIconClick != null)
|
{
|
Cursor = Cursors.Hand;
|
}
|
else
|
{
|
Cursor = Cursors.IBeam;
|
}
|
|
}
|
|
protected override void OnMouseDown(MouseEventArgs e)
|
{
|
if (DesignMode)
|
{
|
return;
|
}
|
|
if (LeadingIcon != null && _leadingIconBounds.Contains(e.Location))
|
{
|
LeadingIconClick?.Invoke(this, new EventArgs());
|
}
|
else if (TrailingIcon != null && _trailingIconBounds.Contains(e.Location))
|
{
|
TrailingIconClick?.Invoke(this, new EventArgs());
|
}
|
else
|
{
|
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);
|
|
UpdateRects();
|
preProcessIcons();
|
|
Size = new Size(Width, HEIGHT);
|
LINE_Y = HEIGHT - ACTIVATION_INDICATOR_HEIGHT - _helperTextHeight;
|
|
}
|
|
protected override void OnCreateControl()
|
{
|
base.OnCreateControl();
|
|
// events
|
MouseState = MaterialMouseState.OUT;
|
|
}
|
|
#region Icon
|
|
private static Size ResizeIcon(Image Icon)
|
{
|
int newWidth, newHeight;
|
//Resize icon if greater than ICON_SIZE
|
if (Icon.Width > ICON_SIZE || Icon.Height > ICON_SIZE)
|
{
|
//calculate aspect ratio
|
float aspect = Icon.Width / (float)Icon.Height;
|
|
//calculate new dimensions based on aspect ratio
|
newWidth = (int)(ICON_SIZE * aspect);
|
newHeight = (int)(newWidth / aspect);
|
|
//if one of the two dimensions exceed the box dimensions
|
if (newWidth > ICON_SIZE || newHeight > ICON_SIZE)
|
{
|
//depending on which of the two exceeds the box dimensions set it as the box dimension and calculate the other one based on the aspect ratio
|
if (newWidth > newHeight)
|
{
|
newWidth = ICON_SIZE;
|
newHeight = (int)(newWidth / aspect);
|
}
|
else
|
{
|
newHeight = ICON_SIZE;
|
newWidth = (int)(newHeight * aspect);
|
}
|
}
|
}
|
else
|
{
|
newWidth = Icon.Width;
|
newHeight = Icon.Height;
|
}
|
|
return new Size()
|
{
|
Height = newHeight,
|
Width = newWidth
|
};
|
}
|
|
private void preProcessIcons()
|
{
|
if (_trailingIcon == null && _leadingIcon == null)
|
{
|
return;
|
}
|
|
// Calculate lightness and color
|
float l = (SkinManager.Theme == MaterialSkinManager.Themes.LIGHT) ? 0f : 1f;
|
|
// Create matrices
|
float[][] matrixGray = {
|
new float[] { 0, 0, 0, 0, 0}, // Red scale factor
|
new float[] { 0, 0, 0, 0, 0}, // Green scale factor
|
new float[] { 0, 0, 0, 0, 0}, // Blue scale factor
|
new float[] { 0, 0, 0, Enabled ? .7f : .3f, 0}, // alpha scale factor
|
new float[] { l, l, l, 0, 1}};// offset
|
|
float[][] matrixRed = {
|
new float[] { 0, 0, 0, 0, 0}, // Red scale factor
|
new float[] { 0, 0, 0, 0, 0}, // Green scale factor
|
new float[] { 0, 0, 0, 0, 0}, // Blue scale factor
|
new float[] { 0, 0, 0, 1, 0}, // alpha scale factor
|
new float[] { 1, 0, 0, 0, 1}};// offset
|
|
ColorMatrix colorMatrixGray = new(matrixGray);
|
ColorMatrix colorMatrixRed = new(matrixRed);
|
|
ImageAttributes grayImageAttributes = new();
|
ImageAttributes redImageAttributes = new();
|
|
// Set color matrices
|
grayImageAttributes.SetColorMatrix(colorMatrixGray, ColorMatrixFlag.Default, ColorAdjustType.Bitmap);
|
redImageAttributes.SetColorMatrix(colorMatrixRed, ColorMatrixFlag.Default, ColorAdjustType.Bitmap);
|
|
// Create brushes
|
iconsBrushes = new Dictionary<string, TextureBrush>(2);
|
iconsErrorBrushes = new Dictionary<string, TextureBrush>(2);
|
|
// Image Rect
|
Rectangle destRect = new(0, 0, ICON_SIZE, ICON_SIZE);
|
|
if (_leadingIcon != null)
|
{
|
// ********************
|
// *** _leadingIcon ***
|
// ********************
|
|
//Resize icon if greater than ICON_SIZE
|
Size newSize_leadingIcon = ResizeIcon(_leadingIcon);
|
Bitmap _leadingIconIconResized = new(_leadingIcon, newSize_leadingIcon.Width, newSize_leadingIcon.Height);
|
|
// Create a pre-processed copy of the image (GRAY)
|
Bitmap bgray = new(destRect.Width, destRect.Height);
|
using (Graphics gGray = Graphics.FromImage(bgray))
|
{
|
gGray.DrawImage(_leadingIconIconResized,
|
new Point[] {
|
new(0, 0),
|
new(destRect.Width, 0),
|
new(0, destRect.Height),
|
},
|
destRect, GraphicsUnit.Pixel);// 不要灰色 , grayImageAttributes);
|
}
|
|
//Create a pre - processed copy of the image(RED)
|
Bitmap bred = new(destRect.Width, destRect.Height);
|
using (Graphics gred = Graphics.FromImage(bred))
|
{
|
gred.DrawImage(_leadingIconIconResized,
|
new Point[] {
|
new(0, 0),
|
new(destRect.Width, 0),
|
new(0, destRect.Height),
|
},
|
destRect, GraphicsUnit.Pixel, redImageAttributes);
|
}
|
|
// added processed image to brush for drawing
|
TextureBrush textureBrushGray = new(bgray);
|
TextureBrush textureBrushRed = new(bred);
|
|
textureBrushGray.WrapMode = System.Drawing.Drawing2D.WrapMode.Clamp;
|
textureBrushRed.WrapMode = System.Drawing.Drawing2D.WrapMode.Clamp;
|
|
Rectangle iconRect = _leadingIconBounds;
|
|
textureBrushGray.TranslateTransform(iconRect.X + (iconRect.Width / 2) - (_leadingIconIconResized.Width / 2),
|
iconRect.Y + (iconRect.Height / 2) - (_leadingIconIconResized.Height / 2));
|
textureBrushRed.TranslateTransform(iconRect.X + (iconRect.Width / 2) - (_leadingIconIconResized.Width / 2),
|
iconRect.Y + (iconRect.Height / 2) - (_leadingIconIconResized.Height / 2));
|
|
// add to dictionary
|
iconsBrushes.Add("_leadingIcon", textureBrushGray);
|
|
iconsErrorBrushes.Add("_leadingIcon", textureBrushRed);
|
|
}
|
|
if (_trailingIcon != null)
|
{
|
// *********************
|
// *** _trailingIcon ***
|
// *********************
|
|
//Resize icon if greater than ICON_SIZE
|
Size newSize_trailingIcon = ResizeIcon(_trailingIcon);
|
Bitmap _trailingIconResized = new(_trailingIcon, newSize_trailingIcon.Width, newSize_trailingIcon.Height);
|
|
// Create a pre-processed copy of the image (GRAY)
|
Bitmap bgray = new(destRect.Width, destRect.Height);
|
using (Graphics gGray = Graphics.FromImage(bgray))
|
{
|
gGray.DrawImage(_trailingIconResized,
|
new Point[] {
|
new(0, 0),
|
new(destRect.Width, 0),
|
new(0, destRect.Height),
|
},
|
destRect, GraphicsUnit.Pixel);//, grayImageAttributes);
|
}
|
|
//Create a pre - processed copy of the image(RED)
|
Bitmap bred = new(destRect.Width, destRect.Height);
|
using (Graphics gred = Graphics.FromImage(bred))
|
{
|
gred.DrawImage(_trailingIconResized,
|
new Point[] {
|
new(0, 0),
|
new(destRect.Width, 0),
|
new(0, destRect.Height),
|
},
|
destRect, GraphicsUnit.Pixel, redImageAttributes);
|
}
|
|
|
// added processed image to brush for drawing
|
TextureBrush textureBrushGray = new(bgray);
|
TextureBrush textureBrushRed = new(bred);
|
|
textureBrushGray.WrapMode = System.Drawing.Drawing2D.WrapMode.Clamp;
|
textureBrushRed.WrapMode = System.Drawing.Drawing2D.WrapMode.Clamp;
|
|
Rectangle iconRect = _trailingIconBounds;
|
|
textureBrushGray.TranslateTransform(iconRect.X + (iconRect.Width / 2) - (_trailingIconResized.Width / 2),
|
iconRect.Y + (iconRect.Height / 2) - (_trailingIconResized.Height / 2));
|
textureBrushRed.TranslateTransform(iconRect.X + (iconRect.Width / 2) - (_trailingIconResized.Width / 2),
|
iconRect.Y + (iconRect.Height / 2) - (_trailingIconResized.Height / 2));
|
|
// add to dictionary
|
iconsBrushes.Add("_trailingIcon", textureBrushGray);
|
//iconsSelectedBrushes.Add(0, textureBrushColor);
|
iconsErrorBrushes.Add("_trailingIcon", textureBrushRed);
|
}
|
}
|
|
#endregion
|
|
private void UpdateHeight()
|
{
|
HEIGHT = _UseTallSize ? 48 : 36;
|
HEIGHT += _helperTextHeight;
|
Size = new Size(Size.Width, HEIGHT);
|
}
|
|
private void UpdateRects()
|
{
|
if (LeadingIcon != null)
|
{
|
_left_padding = LEFT_PADDING + ICON_SIZE;
|
}
|
else
|
{
|
_left_padding = LEFT_PADDING;
|
}
|
|
if (_trailingIcon != null)
|
{
|
_right_padding = RIGHT_PADDING + ICON_SIZE;
|
}
|
else
|
{
|
_right_padding = RIGHT_PADDING;
|
}
|
|
if (_prefixsuffix == PrefixSuffixTypes.Prefix && _prefixsuffixText != null && _prefixsuffixText.Length > 0)
|
{
|
using MaterialNativeTextRenderer NativeText = new(CreateGraphics());
|
_prefix_padding = NativeText.MeasureLogString(_prefixsuffixText, SkinManager.GetLogFontByType(MaterialSkinManager.FontType.Subtitle1)).Width + PREFIX_SUFFIX_PADDING;
|
_left_padding += _prefix_padding;
|
}
|
else
|
{
|
_prefix_padding = 0;
|
}
|
|
if (_prefixsuffix == PrefixSuffixTypes.Suffix && _prefixsuffixText != null && _prefixsuffixText.Length > 0)
|
{
|
using MaterialNativeTextRenderer NativeText = new(CreateGraphics());
|
_suffix_padding = NativeText.MeasureLogString(_prefixsuffixText, SkinManager.GetLogFontByType(MaterialSkinManager.FontType.Subtitle1)).Width + PREFIX_SUFFIX_PADDING;
|
_right_padding += _suffix_padding;
|
}
|
else
|
{
|
_suffix_padding = 0;
|
}
|
|
if (hasHint && UseTallSize && (isFocused || !string.IsNullOrEmpty(Text)))
|
{
|
baseTextBox.Location = new Point(_left_padding, 22);
|
baseTextBox.Width = Width - (_left_padding + _right_padding);
|
baseTextBox.Height = FONT_HEIGHT;
|
}
|
else
|
{
|
baseTextBox.Location = new Point(_left_padding, ((LINE_Y + ACTIVATION_INDICATOR_HEIGHT) / 2) - (FONT_HEIGHT / 2));
|
baseTextBox.Width = Width - (_left_padding + _right_padding);
|
baseTextBox.Height = FONT_HEIGHT;
|
}
|
|
_leadingIconBounds = new Rectangle(8, ((LINE_Y + ACTIVATION_INDICATOR_HEIGHT) / 2) - (ICON_SIZE / 2), ICON_SIZE, ICON_SIZE);
|
_trailingIconBounds = new Rectangle(Width - (ICON_SIZE + 8), ((LINE_Y + ACTIVATION_INDICATOR_HEIGHT) / 2) - (ICON_SIZE / 2), ICON_SIZE, ICON_SIZE);
|
}
|
|
public void SetErrorState(bool ErrorState)
|
{
|
_errorState = ErrorState;
|
if (_errorState)
|
{
|
baseTextBox.ForeColor = SkinManager.BackgroundHoverRedColor;
|
}
|
else
|
{
|
baseTextBox.ForeColor = SkinManager.TextHighEmphasisColor;
|
}
|
|
baseTextBox.Invalidate();
|
Invalidate();
|
}
|
|
public bool GetErrorState()
|
{
|
return _errorState;
|
}
|
|
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.KeyCode == Keys.Enter)
|
{
|
e.Handled = true;
|
e.SuppressKeyPress = true;
|
SendKeys.Send("{TAB}");
|
}
|
}
|
}
|
|
#endregion
|
}
|
