1812 lines
67 KiB
C#
1812 lines
67 KiB
C#
#if FRAMEWORK20
|
|
using System;
|
|
using System.Text;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using DevComponents.Editors;
|
|
using System.Windows.Forms;
|
|
using System.Drawing.Drawing2D;
|
|
using System.Collections;
|
|
using System.Drawing.Design;
|
|
using System.Security.Permissions;
|
|
|
|
namespace DevComponents.DotNetBar.Controls
|
|
{
|
|
/// <summary>
|
|
/// Represents single line text box control with the drop down button to display custom control on popup and additional custom buttons.
|
|
/// </summary>
|
|
[ToolboxBitmap(typeof(TextBoxDropDown), "Controls.TextBoxDropDown.ico"), ToolboxItem(true), DefaultProperty("Text"), DefaultBindingProperty("Text"), DefaultEvent("TextChanged"), Designer("DevComponents.DotNetBar.Design.TextBoxDropDownDesigner, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf")]
|
|
public class TextBoxDropDown : PopupItemControl, IInputButtonControl, ICommandSource
|
|
{
|
|
#region Private Variables
|
|
private TextBoxX _TextBox = null;
|
|
private ButtonItem _PopupItem = null;
|
|
private static string _DropDownItemContainerName = "sysPopupItemContainer";
|
|
private static string _DropDownControlContainerName = "sysPopupControlContainer";
|
|
private Color _FocusHighlightColor = ColorScheme.GetColor(0xFFFF88);
|
|
private bool _FocusHighlightEnabled = false;
|
|
#endregion
|
|
|
|
#region Events
|
|
/// <summary>
|
|
/// Occurs when Clear button is clicked and allows you to cancel the default action performed by the button.
|
|
/// </summary>
|
|
public event CancelEventHandler ButtonClearClick;
|
|
/// <summary>
|
|
/// Occurs when Drop-Down button that shows popup is clicked and allows you to cancel showing of the popup.
|
|
/// </summary>
|
|
public event CancelEventHandler ButtonDropDownClick;
|
|
/// <summary>
|
|
/// Occurs when ButtonCustom control is clicked.
|
|
/// </summary>
|
|
public event EventHandler ButtonCustomClick;
|
|
/// <summary>
|
|
/// Occurs when ButtonCustom2 control is clicked.
|
|
/// </summary>
|
|
public event EventHandler ButtonCustom2Click;
|
|
/// <summary>
|
|
/// Occurs when the text alignment is changed.
|
|
/// </summary>
|
|
[Description("Occurs when the text alignment is changed.")]
|
|
public event EventHandler TextAlignChanged;
|
|
/// <summary>
|
|
/// Occurs when the value of the Modified property has changed.
|
|
/// </summary>
|
|
public event EventHandler ModifiedChanged;
|
|
|
|
/// <summary>
|
|
/// Occurs before the popup is opened and it allows canceling of popup by setting CancelEventArgs.Cancel=true.
|
|
/// </summary>
|
|
[Description("Occurs before the popup is opened and it allows canceling of popup by setting CancelEventArgs.Cancel=true.")]
|
|
public event CancelEventHandler BeforePopupOpen;
|
|
/// <summary>
|
|
/// Raises BeforeMultiColumnPopupOpen event.
|
|
/// </summary>
|
|
/// <param name="e">Provides event arguments.</param>
|
|
protected virtual void OnBeforePopupOpen(CancelEventArgs e)
|
|
{
|
|
CancelEventHandler handler = BeforePopupOpen;
|
|
if (handler != null)
|
|
handler(this, e);
|
|
}
|
|
#endregion
|
|
|
|
#region Constructor
|
|
/// <summary>
|
|
/// Initializes a new instance of the TextBoxDropDown class.
|
|
/// </summary>
|
|
public TextBoxDropDown()
|
|
{
|
|
this.SetStyle(ControlStyles.Selectable, false);
|
|
_TextBox = new TextBoxX();
|
|
base.BackColor = SystemColors.Window;
|
|
InitControl();
|
|
}
|
|
private void InitControl()
|
|
{
|
|
_BackgroundStyle.SetColorScheme(this.ColorScheme);
|
|
_BackgroundStyle.StyleChanged += new EventHandler(this.VisualPropertyChanged);
|
|
|
|
_ButtonCustom = new InputButtonSettings(this);
|
|
_ButtonCustom2 = new InputButtonSettings(this);
|
|
_ButtonClear = new InputButtonSettings(this);
|
|
_ButtonDropDown = new InputButtonSettings(this);
|
|
CreateButtonGroup();
|
|
|
|
_TextBox.BorderStyle = BorderStyle.None;
|
|
_TextBox.TextChanged += new EventHandler(TextBoxTextChanged);
|
|
_TextBox.TextAlignChanged += new EventHandler(TextBoxTextAlignChanged);
|
|
_TextBox.SizeChanged += new EventHandler(TextBoxSizeChanged);
|
|
_TextBox.ModifiedChanged += new EventHandler(TextBoxModifiedChanged);
|
|
_TextBox.KeyPress += new KeyPressEventHandler(TextBoxKeyPress);
|
|
_TextBox.KeyDown += new KeyEventHandler(TextBoxKeyDown);
|
|
this.Controls.Add(_TextBox);
|
|
}
|
|
#endregion
|
|
|
|
#region Internal Implementation
|
|
private bool _AutoSelectAll = false;
|
|
/// <summary>
|
|
/// Indicates whether all text is auto-selected when control gets input focus. Default value is false.
|
|
/// </summary>
|
|
[DefaultValue(false), Category("Behavior"), Description("Indicates whether all text is auto-selected when control gets input focus.")]
|
|
public bool AutoSelectAll
|
|
{
|
|
get { return _AutoSelectAll; }
|
|
set { _AutoSelectAll = value; }
|
|
}
|
|
|
|
protected override void OnBindingContextChanged(EventArgs e)
|
|
{
|
|
if (_DropDownControl != null) _DropDownControl.BindingContext = this.BindingContext;
|
|
base.OnBindingContextChanged(e);
|
|
}
|
|
protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
|
|
{
|
|
if (keyData == Keys.F4)
|
|
{
|
|
if (_PopupItem.Expanded)
|
|
CloseDropDown();
|
|
else
|
|
InvokeShowDropDown();
|
|
return true;
|
|
}
|
|
else if (keyData == Keys.Escape && this.IsPopupOpen)
|
|
{
|
|
CloseDropDown();
|
|
return true;
|
|
}
|
|
else if (_ButtonGroup.ProcessCmdKey(ref msg, keyData))
|
|
return true;
|
|
return base.ProcessCmdKey(ref msg, keyData);
|
|
}
|
|
|
|
void TextBoxKeyPress(object sender, KeyPressEventArgs e)
|
|
{
|
|
if (_InternalReadOnly) e.Handled = true;
|
|
}
|
|
void TextBoxKeyDown(object sender, KeyEventArgs e)
|
|
{
|
|
if (e.KeyCode == Keys.Down && e.Modifiers == Keys.Alt)
|
|
{
|
|
if (ButtonDropDown.Visible)
|
|
{
|
|
InvokeShowDropDown();
|
|
e.Handled = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void TextBoxModifiedChanged(object sender, EventArgs e)
|
|
{
|
|
OnModifiedChanged(e);
|
|
}
|
|
protected virtual void OnModifiedChanged(EventArgs e)
|
|
{
|
|
EventHandler handler = ModifiedChanged;
|
|
if (handler != null)
|
|
{
|
|
handler(this, e);
|
|
}
|
|
}
|
|
|
|
private void TextBoxSizeChanged(object sender, EventArgs e)
|
|
{
|
|
if (!_InternalSizeUpdate)
|
|
UpdateLayout();
|
|
}
|
|
|
|
private void TextBoxTextChanged(object sender, EventArgs e)
|
|
{
|
|
base.Text = _TextBox.Text;
|
|
ExecuteCommand();
|
|
}
|
|
|
|
private void TextBoxTextAlignChanged(object sender, EventArgs e)
|
|
{
|
|
OnTextAlignChanged(e);
|
|
}
|
|
/// <summary>
|
|
/// Raises the TextAlignChanged event.
|
|
/// </summary>
|
|
protected virtual void OnTextAlignChanged(EventArgs e)
|
|
{
|
|
EventHandler eh = TextAlignChanged;
|
|
if (eh != null)
|
|
eh(this, e);
|
|
}
|
|
|
|
protected override void OnEnabledChanged(EventArgs e)
|
|
{
|
|
if (!this.Enabled)
|
|
_TextBox.ResetBackColor();
|
|
else if (_TextBox.BackColor != this.BackColor)
|
|
_TextBox.BackColor = this.BackColor;
|
|
|
|
base.OnEnabledChanged(e);
|
|
}
|
|
|
|
private Color _OldBackColor = Color.Empty;
|
|
protected override void OnEnter(EventArgs e)
|
|
{
|
|
if (_FocusHighlightEnabled)
|
|
{
|
|
_OldBackColor = this.BackColor;
|
|
this.BackColor = _FocusHighlightColor;
|
|
}
|
|
if (_AutoSelectAll)
|
|
_TextBox.SelectAll();
|
|
base.OnEnter(e);
|
|
}
|
|
|
|
protected override void OnLeave(EventArgs e)
|
|
{
|
|
if (_FocusHighlightEnabled && !_OldBackColor.IsEmpty)
|
|
{
|
|
this.BackColor = _OldBackColor;
|
|
if (_OldBackColor == SystemColors.Window)
|
|
_TextBox.ResetBackColor();
|
|
_OldBackColor = Color.Empty;
|
|
}
|
|
base.OnLeave(e);
|
|
}
|
|
|
|
protected override bool QueryPopupCloseMouseDown()
|
|
{
|
|
Point p = this.PointToClient(MousePosition);
|
|
if(this.ClientRectangle.Contains(p))
|
|
return false;
|
|
return base.QueryPopupCloseMouseDown();
|
|
}
|
|
/// <summary>
|
|
/// Gets or sets whether FocusHighlightColor is used as background color to highlight text box when it has input focus. Default value is false.
|
|
/// </summary>
|
|
[DefaultValue(false), Browsable(true), Category("Appearance"), Description("Indicates whether FocusHighlightColor is used as background color to highlight text box when it has input focus.")]
|
|
public bool FocusHighlightEnabled
|
|
{
|
|
get { return _FocusHighlightEnabled; }
|
|
set
|
|
{
|
|
if (_FocusHighlightEnabled != value)
|
|
{
|
|
_FocusHighlightEnabled = value;
|
|
//_TextBox.FocusHighlightEnabled = value;
|
|
if (this.Focused)
|
|
this.Invalidate(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the color used as background color to highlight text box when it has input focus and focus highlight is enabled.
|
|
/// </summary>
|
|
[Browsable(true), Category("Appearance"), Description("Indicates color used as background color to highlight text box when it has input focus and focus highlight is enabled.")]
|
|
public Color FocusHighlightColor
|
|
{
|
|
get { return _FocusHighlightColor; }
|
|
set
|
|
{
|
|
if (_FocusHighlightColor != value)
|
|
{
|
|
_FocusHighlightColor = value;
|
|
_TextBox.FocusHighlightColor = value;
|
|
if (this.Focused)
|
|
this.Invalidate(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
|
|
public bool ShouldSerializeFocusHighlightColor()
|
|
{
|
|
return !_FocusHighlightColor.Equals(ColorScheme.GetColor(0xFFFF88));
|
|
}
|
|
|
|
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
|
|
public void ResetFocusHighlightColor()
|
|
{
|
|
FocusHighlightColor = ColorScheme.GetColor(0xFFFF88);
|
|
}
|
|
|
|
private ElementStyle _BackgroundStyle = new ElementStyle();
|
|
/// <summary>
|
|
/// Specifies the background style of the control.
|
|
/// </summary>
|
|
[Category("Style"), Description("Gets or sets control background style."), DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public ElementStyle BackgroundStyle
|
|
{
|
|
get { return _BackgroundStyle; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resets style to default value. Used by windows forms designer.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public void ResetBackgroundStyle()
|
|
{
|
|
_BackgroundStyle.StyleChanged -= new EventHandler(this.VisualPropertyChanged);
|
|
_BackgroundStyle = new ElementStyle();
|
|
_BackgroundStyle.StyleChanged += new EventHandler(this.VisualPropertyChanged);
|
|
this.Invalidate();
|
|
}
|
|
|
|
private void VisualPropertyChanged(object sender, EventArgs e)
|
|
{
|
|
OnVisualPropertyChanged();
|
|
}
|
|
|
|
protected virtual void OnVisualPropertyChanged()
|
|
{
|
|
_ButtonGroup.InvalidateArrange();
|
|
this.Invalidate();
|
|
}
|
|
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
if (_BackgroundStyle != null) _BackgroundStyle.StyleChanged -= new EventHandler(VisualPropertyChanged);
|
|
base.Dispose(disposing);
|
|
}
|
|
|
|
private InputButtonSettings _ButtonDropDown = null;
|
|
/// <summary>
|
|
/// Gets the object that describes the settings for the button that shows drop-down when clicked.
|
|
/// </summary>
|
|
[Category("Buttons"), Description("Describes the settings for the button that shows drop-down when clicked."), DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public InputButtonSettings ButtonDropDown
|
|
{
|
|
get
|
|
{
|
|
return _ButtonDropDown;
|
|
}
|
|
}
|
|
|
|
private InputButtonSettings _ButtonClear = null;
|
|
/// <summary>
|
|
/// Gets the object that describes the settings for the button that clears the content of the control when clicked.
|
|
/// </summary>
|
|
[Category("Buttons"), Description("Describes the settings for the button that clears the content of the control when clicked."), DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public InputButtonSettings ButtonClear
|
|
{
|
|
get
|
|
{
|
|
return _ButtonClear;
|
|
}
|
|
}
|
|
|
|
|
|
private InputButtonSettings _ButtonCustom = null;
|
|
/// <summary>
|
|
/// Gets the object that describes the settings for the custom button that can execute an custom action of your choosing when clicked.
|
|
/// </summary>
|
|
[Category("Buttons"), Description("Describes the settings for the custom button that can execute an custom action of your choosing when clicked."), DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public InputButtonSettings ButtonCustom
|
|
{
|
|
get
|
|
{
|
|
return _ButtonCustom;
|
|
}
|
|
}
|
|
|
|
private InputButtonSettings _ButtonCustom2 = null;
|
|
/// <summary>
|
|
/// Gets the object that describes the settings for the custom button that can execute an custom action of your choosing when clicked.
|
|
/// </summary>
|
|
[Category("Buttons"), Description("Describes the settings for the custom button that can execute an custom action of your choosing when clicked."), DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public InputButtonSettings ButtonCustom2
|
|
{
|
|
get
|
|
{
|
|
return _ButtonCustom2;
|
|
}
|
|
}
|
|
|
|
|
|
void IInputButtonControl.InputButtonSettingsChanged(InputButtonSettings inputButtonSettings)
|
|
{
|
|
OnInputButtonSettingsChanged(inputButtonSettings);
|
|
}
|
|
|
|
protected virtual void OnInputButtonSettingsChanged(InputButtonSettings inputButtonSettings)
|
|
{
|
|
UpdateButtons();
|
|
}
|
|
|
|
private VisualGroup _ButtonGroup = null;
|
|
private void UpdateButtons()
|
|
{
|
|
RecreateButtons();
|
|
_ButtonGroup.InvalidateArrange();
|
|
this.Invalidate();
|
|
}
|
|
|
|
internal VisualGroup ButtonGroup
|
|
{
|
|
get { return (_ButtonGroup); }
|
|
}
|
|
|
|
protected virtual void RecreateButtons()
|
|
{
|
|
VisualItem[] buttons = CreateOrderedButtonList();
|
|
// Remove all system buttons that are already in the list
|
|
VisualGroup group = _ButtonGroup;
|
|
VisualItem[] items = new VisualItem[group.Items.Count];
|
|
group.Items.CopyTo(items);
|
|
foreach (VisualItem item in items)
|
|
{
|
|
if (item.ItemType == eSystemItemType.SystemButton)
|
|
{
|
|
group.Items.Remove(item);
|
|
if (item == _ButtonCustom.ItemReference)
|
|
item.MouseUp -= new MouseEventHandler(CustomButtonMouseUp);
|
|
else if (item == _ButtonCustom2.ItemReference)
|
|
item.MouseUp -= new MouseEventHandler(CustomButton2MouseUp);
|
|
}
|
|
}
|
|
|
|
// Add new buttons to the list
|
|
group.Items.AddRange(buttons);
|
|
}
|
|
|
|
private void CustomButtonMouseUp(object sender, MouseEventArgs e)
|
|
{
|
|
if (_ButtonCustom.ItemReference.RenderBounds.Contains(e.X, e.Y))
|
|
OnButtonCustomClick(e);
|
|
}
|
|
|
|
protected virtual void OnButtonCustomClick(EventArgs e)
|
|
{
|
|
if (ButtonCustomClick != null)
|
|
ButtonCustomClick(this, e);
|
|
}
|
|
|
|
private void CustomButton2MouseUp(object sender, MouseEventArgs e)
|
|
{
|
|
if (_ButtonCustom2.ItemReference.RenderBounds.Contains(e.X, e.Y))
|
|
OnButtonCustom2Click(e);
|
|
}
|
|
|
|
protected virtual void OnButtonCustom2Click(EventArgs e)
|
|
{
|
|
if (ButtonCustom2Click != null)
|
|
ButtonCustom2Click(this, e);
|
|
}
|
|
|
|
private VisualItem[] CreateOrderedButtonList()
|
|
{
|
|
SortedList list = CreateSortedButtonList();
|
|
|
|
VisualItem[] items = new VisualItem[list.Count];
|
|
list.Values.CopyTo(items, 0);
|
|
|
|
return items;
|
|
}
|
|
|
|
private void CustomButtonClick(object sender, EventArgs e)
|
|
{
|
|
OnButtonCustomClick(e);
|
|
}
|
|
private void CustomButton2Click(object sender, EventArgs e)
|
|
{
|
|
OnButtonCustom2Click(e);
|
|
}
|
|
private void ClearButtonClick(object sender, EventArgs e)
|
|
{
|
|
ClearButtonClick();
|
|
}
|
|
protected virtual SortedList CreateSortedButtonList()
|
|
{
|
|
SortedList list = new SortedList(4);
|
|
if (_ButtonCustom.Visible)
|
|
{
|
|
VisualItem button = CreateButton(_ButtonCustom);
|
|
if (_ButtonCustom.ItemReference != null)
|
|
{
|
|
_ButtonCustom.ItemReference.MouseUp -= CustomButtonMouseUp;
|
|
_ButtonCustom.ItemReference.Click -= CustomButtonClick;
|
|
}
|
|
_ButtonCustom.ItemReference = button;
|
|
button.Click += CustomButtonClick;
|
|
button.MouseUp += CustomButtonMouseUp;
|
|
button.Enabled = _ButtonCustom.Enabled;
|
|
list.Add(_ButtonCustom, button);
|
|
}
|
|
|
|
if (_ButtonCustom2.Visible)
|
|
{
|
|
VisualItem button = CreateButton(_ButtonCustom2);
|
|
if (_ButtonCustom.ItemReference != null)
|
|
{
|
|
_ButtonCustom.ItemReference.MouseUp -= CustomButton2MouseUp;
|
|
_ButtonCustom.ItemReference.Click -= CustomButton2Click;
|
|
}
|
|
_ButtonCustom2.ItemReference = button;
|
|
button.Click += CustomButton2Click;
|
|
button.MouseUp += CustomButton2MouseUp;
|
|
button.Enabled = _ButtonCustom2.Enabled;
|
|
list.Add(_ButtonCustom2, button);
|
|
}
|
|
|
|
if (_ButtonClear.Visible)
|
|
{
|
|
VisualItem button = CreateButton(_ButtonClear);
|
|
if (_ButtonClear.ItemReference != null)
|
|
{
|
|
_ButtonClear.ItemReference.MouseUp -= ClearButtonMouseUp;
|
|
_ButtonClear.ItemReference.Click -= ClearButtonClick;
|
|
}
|
|
_ButtonClear.ItemReference = button;
|
|
button.MouseUp += ClearButtonMouseUp;
|
|
button.Click += ClearButtonClick;
|
|
list.Add(_ButtonClear, button);
|
|
}
|
|
|
|
if (_ButtonDropDown.Visible)
|
|
{
|
|
VisualItem button = CreateButton(_ButtonDropDown);
|
|
if (_ButtonDropDown.ItemReference != null)
|
|
{
|
|
_ButtonDropDown.ItemReference.MouseDown -= DropDownButtonMouseDown;
|
|
_ButtonDropDown.ItemReference.Click -= DropDownButtonClick;
|
|
}
|
|
_ButtonDropDown.ItemReference = button;
|
|
button.MouseDown += DropDownButtonMouseDown;
|
|
button.Click += DropDownButtonClick;
|
|
list.Add(_ButtonDropDown, button);
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
private void DropDownButtonClick(object sender, EventArgs e)
|
|
{
|
|
if (e is KeyEventArgs) // Only if invoked through keyboard shortcut
|
|
{
|
|
if (_PopupItem.Expanded)
|
|
CloseDropDown();
|
|
else
|
|
InvokeShowDropDown();
|
|
}
|
|
}
|
|
|
|
protected virtual VisualItem CreateButton(InputButtonSettings buttonSettings)
|
|
{
|
|
VisualItem item = null;
|
|
|
|
if (buttonSettings == _ButtonDropDown)
|
|
{
|
|
item = new VisualDropDownButton();
|
|
ApplyButtonSettings(buttonSettings, item as VisualButton);
|
|
}
|
|
else
|
|
{
|
|
item = new VisualCustomButton();
|
|
ApplyButtonSettings(buttonSettings, item as VisualButton);
|
|
}
|
|
|
|
VisualButton button = item as VisualButton;
|
|
button.ClickAutoRepeat = false;
|
|
|
|
if (buttonSettings == _ButtonClear)
|
|
{
|
|
if (buttonSettings.Image == null && string.IsNullOrEmpty(buttonSettings.Text))
|
|
{
|
|
//if (Dpi.Factor.Width > 1)
|
|
button.Symbol = "\uf00d";
|
|
//else
|
|
// button.Image = DevComponents.DotNetBar.BarFunctions.LoadBitmap("SystemImages.DateReset.png");
|
|
}
|
|
}
|
|
|
|
return item;
|
|
}
|
|
|
|
protected virtual void ApplyButtonSettings(InputButtonSettings buttonSettings, VisualButton button)
|
|
{
|
|
button.Text = buttonSettings.Text;
|
|
button.Image = buttonSettings.Image;
|
|
button.ItemType = eSystemItemType.SystemButton;
|
|
button.Enabled = buttonSettings.Enabled;
|
|
button.Shortcut = buttonSettings.Shortcut;
|
|
button.Tooltip = buttonSettings.Tooltip;
|
|
button.Symbol = buttonSettings.Symbol;
|
|
button.SymbolSet = buttonSettings.SymbolSet;
|
|
button.SymbolColor = buttonSettings.SymbolColor;
|
|
}
|
|
|
|
private void CreateButtonGroup()
|
|
{
|
|
VisualGroup group = new VisualGroup();
|
|
group.HorizontalItemSpacing = 0;
|
|
group.ArrangeInvalid += new EventHandler(ButtonGroupArrangeInvalid);
|
|
group.RenderInvalid += new EventHandler(ButtonGroupRenderInvalid);
|
|
group.ResetMouseHover += ButtonGroupResetMouseHover;
|
|
_ButtonGroup = group;
|
|
}
|
|
|
|
private void ButtonGroupRenderInvalid(object sender, EventArgs e)
|
|
{
|
|
Invalidate();
|
|
}
|
|
|
|
private void ButtonGroupArrangeInvalid(object sender, EventArgs e)
|
|
{
|
|
Invalidate();
|
|
}
|
|
|
|
private void ButtonGroupResetMouseHover(object sender, EventArgs e)
|
|
{
|
|
DevComponents.AdvTree.Interop.WinApi.ResetHover(this);
|
|
}
|
|
|
|
private bool _MouseOver = false;
|
|
private PaintInfo CreatePaintInfo(Graphics g)
|
|
{
|
|
PaintInfo p = new PaintInfo();
|
|
p.Graphics = g;
|
|
p.DefaultFont = this.Font;
|
|
p.ForeColor = this.ForeColor;
|
|
p.RenderOffset = new System.Drawing.Point();
|
|
Size s = this.Size;
|
|
bool disposeStyle = false;
|
|
ElementStyle style = GetBackgroundStyle(out disposeStyle);
|
|
int styleSpace = (ElementStyleLayout.TopWhiteSpace(style, eSpacePart.Border) + ElementStyleLayout.BottomWhiteSpace(style, eSpacePart.Border));
|
|
if (styleSpace > 0) styleSpace += 2;
|
|
s.Height -= styleSpace;
|
|
styleSpace = (ElementStyleLayout.LeftWhiteSpace(style, eSpacePart.Border) + ElementStyleLayout.RightWhiteSpace(style, eSpacePart.Border));
|
|
if (styleSpace > 0) styleSpace += 2;
|
|
s.Width -= styleSpace;
|
|
p.AvailableSize = s;
|
|
p.ParentEnabled = this.Enabled;
|
|
p.MouseOver = _MouseOver || this.Focused;
|
|
if (disposeStyle) style.Dispose();
|
|
return p;
|
|
}
|
|
|
|
private ElementStyle GetBackgroundStyle(out bool disposeStyle)
|
|
{
|
|
disposeStyle = false;
|
|
_BackgroundStyle.SetColorScheme(this.GetColorScheme());
|
|
return ElementStyleDisplay.GetElementStyle(_BackgroundStyle, out disposeStyle);
|
|
}
|
|
|
|
protected override void OnPaint(PaintEventArgs e)
|
|
{
|
|
base.OnPaint(e);
|
|
Graphics g = e.Graphics;
|
|
Rectangle clientRect = this.ClientRectangle;
|
|
bool enabled = this.Enabled;
|
|
|
|
if (!this.Enabled)
|
|
e.Graphics.FillRectangle(SystemBrushes.Control, clientRect);
|
|
else
|
|
{
|
|
using (SolidBrush brush = new SolidBrush(this.BackColor))
|
|
e.Graphics.FillRectangle(brush, clientRect);
|
|
}
|
|
|
|
bool disposeStyle = false;
|
|
ElementStyle style = GetBackgroundStyle(out disposeStyle);
|
|
|
|
if (style.Custom)
|
|
{
|
|
SmoothingMode sm = g.SmoothingMode;
|
|
if (this.AntiAlias)
|
|
g.SmoothingMode = SmoothingMode.AntiAlias;
|
|
ElementStyleDisplayInfo displayInfo = new ElementStyleDisplayInfo(style, g, clientRect);
|
|
if (!enabled)
|
|
{
|
|
ElementStyleDisplay.PaintBorder(displayInfo);
|
|
}
|
|
else
|
|
ElementStyleDisplay.Paint(displayInfo);
|
|
if (this.AntiAlias)
|
|
g.SmoothingMode = sm;
|
|
}
|
|
|
|
PaintButtons(g);
|
|
|
|
if (disposeStyle) style.Dispose();
|
|
}
|
|
|
|
|
|
public override Color BackColor
|
|
{
|
|
get
|
|
{
|
|
return base.BackColor;
|
|
}
|
|
set
|
|
{
|
|
base.BackColor = value;
|
|
}
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public bool ShouldSerializeBackColor()
|
|
{
|
|
return this.BackColor != SystemColors.Window;
|
|
}
|
|
|
|
protected override void OnBackColorChanged(EventArgs e)
|
|
{
|
|
base.OnBackColorChanged(e);
|
|
if (_TextBox.Parent != null)
|
|
_TextBox.BackColor = this.BackColor;
|
|
}
|
|
|
|
private void PaintButtons(Graphics g)
|
|
{
|
|
PaintInfo p = CreatePaintInfo(g);
|
|
|
|
if (!_ButtonGroup.IsLayoutValid)
|
|
{
|
|
UpdateLayout(p);
|
|
}
|
|
|
|
bool disposeStyle = false;
|
|
ElementStyle style = GetBackgroundStyle(out disposeStyle);
|
|
_ButtonGroup.RenderBounds = GetButtonsRenderBounds(style);
|
|
_ButtonGroup.ProcessPaint(p);
|
|
if (disposeStyle) style.Dispose();
|
|
}
|
|
|
|
private Rectangle GetButtonsRenderBounds(ElementStyle style)
|
|
{
|
|
int y = ElementStyleLayout.TopWhiteSpace(style, eSpacePart.Border);
|
|
if (y > 0) y += 1;
|
|
|
|
if (this.RightToLeft == RightToLeft.Yes)
|
|
{
|
|
return new Rectangle((ElementStyleLayout.LeftWhiteSpace(style, eSpacePart.Border) + 1), y,
|
|
_ButtonGroup.Size.Width, _ButtonGroup.Size.Height);
|
|
}
|
|
|
|
return new Rectangle(this.Width - (ElementStyleLayout.RightWhiteSpace(style, eSpacePart.Border) + 1) - _ButtonGroup.Size.Width, y,
|
|
_ButtonGroup.Size.Width, _ButtonGroup.Size.Height);
|
|
}
|
|
|
|
protected override void OnResize(EventArgs e)
|
|
{
|
|
if (BarFunctions.IsHandleValid(this))
|
|
{
|
|
_ButtonGroup.InvalidateArrange();
|
|
UpdateLayout();
|
|
this.Invalidate();
|
|
}
|
|
base.OnResize(e);
|
|
}
|
|
|
|
protected override void OnGotFocus(EventArgs e)
|
|
{
|
|
_TextBox.Focus();
|
|
base.OnGotFocus(e);
|
|
}
|
|
|
|
protected override void OnRightToLeftChanged(EventArgs e)
|
|
{
|
|
_ButtonGroup.InvalidateArrange();
|
|
UpdateLayout();
|
|
this.Invalidate();
|
|
base.OnRightToLeftChanged(e);
|
|
}
|
|
|
|
protected override void OnFontChanged(EventArgs e)
|
|
{
|
|
_ButtonGroup.InvalidateArrange();
|
|
UpdateLayout();
|
|
this.Invalidate();
|
|
base.OnFontChanged(e);
|
|
}
|
|
|
|
protected override void OnForeColorChanged(EventArgs e)
|
|
{
|
|
_TextBox.ForeColor = this.ForeColor;
|
|
base.OnForeColorChanged(e);
|
|
}
|
|
|
|
private void UpdateLayout()
|
|
{
|
|
if (!BarFunctions.IsHandleValid(this))
|
|
return;
|
|
using (Graphics g = BarFunctions.CreateGraphics(this))
|
|
UpdateLayout(CreatePaintInfo(g));
|
|
}
|
|
|
|
private bool _InternalSizeUpdate = false;
|
|
private void UpdateLayout(PaintInfo p)
|
|
{
|
|
if (_InternalSizeUpdate) return;
|
|
|
|
_InternalSizeUpdate = true;
|
|
|
|
try
|
|
{
|
|
if (!_ButtonGroup.IsLayoutValid)
|
|
{
|
|
_ButtonGroup.PerformLayout(p);
|
|
}
|
|
|
|
bool disposeStyle = false;
|
|
ElementStyle style = GetBackgroundStyle(out disposeStyle);
|
|
Rectangle textBoxControlRect = ElementStyleLayout.GetInnerRect(style, this.ClientRectangle);
|
|
if (RenderButtons)
|
|
{
|
|
Rectangle buttonsRect = GetButtonsRenderBounds(style);
|
|
if (this.RightToLeft == RightToLeft.Yes)
|
|
{
|
|
textBoxControlRect.X += buttonsRect.Right;
|
|
textBoxControlRect.Width -= buttonsRect.Right;
|
|
}
|
|
else
|
|
{
|
|
textBoxControlRect.Width -= (textBoxControlRect.Right - buttonsRect.X);
|
|
}
|
|
}
|
|
if (_TextBox.Multiline == false && (_TextBox.PreferredHeight < textBoxControlRect.Height))
|
|
{
|
|
textBoxControlRect.Y += (textBoxControlRect.Height - _TextBox.PreferredHeight) / 2;
|
|
}
|
|
_TextBox.Bounds = textBoxControlRect;
|
|
|
|
if (disposeStyle) style.Dispose();
|
|
}
|
|
finally
|
|
{
|
|
_InternalSizeUpdate = false;
|
|
}
|
|
}
|
|
|
|
private Control _PreviousDropDownControlParent = null;
|
|
private void DropDownButtonMouseDown(object sender, MouseEventArgs e)
|
|
{
|
|
if (e.Button != MouseButtons.Left || _CloseTime != DateTime.MinValue && DateTime.Now.Subtract(_CloseTime).TotalMilliseconds < 250)
|
|
{
|
|
_CloseTime = DateTime.MinValue;
|
|
return;
|
|
}
|
|
|
|
InvokeShowDropDown();
|
|
|
|
if ((Control.MouseButtons & MouseButtons.Left) == 0)
|
|
_ButtonGroup.ProcessMouseUp(e);
|
|
}
|
|
|
|
private void InvokeShowDropDown()
|
|
{
|
|
CancelEventArgs cancelArgs = new CancelEventArgs();
|
|
OnButtonDropDownClick(cancelArgs);
|
|
if (cancelArgs.Cancel) return;
|
|
if (IsPopupOpen)
|
|
CloseDropDown();
|
|
else
|
|
ShowDropDown();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets a value indicating whether the drop-down is open.
|
|
/// </summary>
|
|
[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public bool IsPopupOpen
|
|
{
|
|
get
|
|
{
|
|
return _PopupItem.Expanded;
|
|
}
|
|
set
|
|
{
|
|
if (value != _PopupItem.Expanded)
|
|
{
|
|
if (value)
|
|
ShowDropDown();
|
|
else
|
|
CloseDropDown();
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _ShowingPopup = false;
|
|
/// <summary>
|
|
/// Shows drop-down popup. Note that popup will be shown only if there is a DropDownControl assigned or DropDownItems collection has at least one item.
|
|
/// </summary>
|
|
public void ShowDropDown()
|
|
{
|
|
if (_DropDownControl == null && _PopupItem.SubItems.Count == 0 || _ShowingPopup || _PopupItem.Expanded)
|
|
return;
|
|
|
|
CancelEventArgs ce = new CancelEventArgs();
|
|
OnBeforePopupOpen(ce);
|
|
if (ce.Cancel) return;
|
|
|
|
_ShowingPopup = true;
|
|
try
|
|
{
|
|
ControlContainerItem cc = null;
|
|
ItemContainer ic = null;
|
|
if (_DropDownControl != null)
|
|
{
|
|
ic = new ItemContainer();
|
|
ic.Name = _DropDownItemContainerName;
|
|
cc = new ControlContainerItem(_DropDownControlContainerName);
|
|
ic.SubItems.Add(cc);
|
|
_PopupItem.SubItems.Insert(0, ic);
|
|
}
|
|
|
|
if (_PopupItem.SubItems.Count == 0)
|
|
{
|
|
if (ic != null)
|
|
_PopupItem.SubItems.Remove(ic);
|
|
return;
|
|
}
|
|
if (_DropDownControl != null)
|
|
{
|
|
_PreviousDropDownControlParent = _DropDownControl.Parent;
|
|
cc.Control = _DropDownControl;
|
|
if (!_DropDownControl.IsHandleCreated)
|
|
{
|
|
IntPtr handle = _DropDownControl.Handle; // Forces creation of the control so its size etc. can be accessed reliably
|
|
}
|
|
}
|
|
|
|
_PopupItem.SetDisplayRectangle(this.ClientRectangle);
|
|
if (this.RightToLeft == RightToLeft.No)
|
|
{
|
|
Point pl = new Point(this.Width - _PopupItem.PopupSize.Width, this.Height);
|
|
ScreenInformation screen = BarFunctions.ScreenFromControl(this);
|
|
Point ps = PointToScreen(pl);
|
|
if (screen != null && screen.WorkingArea.X > ps.X)
|
|
{
|
|
pl.X = 0;
|
|
}
|
|
_PopupItem.PopupLocation = pl;
|
|
}
|
|
|
|
_PopupItem.Expanded = !_PopupItem.Expanded;
|
|
}
|
|
finally
|
|
{
|
|
_ShowingPopup = false;
|
|
}
|
|
|
|
if (_DropDownControl != null && _AutoFocusDropDownControl && _DropDownControl.CanFocus)
|
|
BarUtilities.InvokeDelayed(new MethodInvoker(delegate { _DropDownControl.Focus(); }));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Closes the drop-down popup if it is open.
|
|
/// </summary>
|
|
public void CloseDropDown()
|
|
{
|
|
if (_PopupItem.Expanded) _PopupItem.Expanded = false;
|
|
}
|
|
|
|
private DateTime _CloseTime = DateTime.MinValue;
|
|
private void DropDownPopupClose(object sender, EventArgs e)
|
|
{
|
|
_CloseTime = DateTime.Now;
|
|
|
|
ItemContainer ic = null;
|
|
if (_PopupItem.SubItems.Contains(_DropDownItemContainerName))
|
|
ic = _PopupItem.SubItems[_DropDownItemContainerName] as ItemContainer;
|
|
if (ic != null)
|
|
{
|
|
ControlContainerItem cc = ic.SubItems[_DropDownControlContainerName] as ControlContainerItem;
|
|
if (cc != null)
|
|
{
|
|
cc.Control = null;
|
|
ic.SubItems.Remove(cc);
|
|
if (_DropDownControl != null)
|
|
{
|
|
_DropDownControl.Parent = _PreviousDropDownControlParent;
|
|
_PreviousDropDownControlParent = null;
|
|
}
|
|
}
|
|
_PopupItem.SubItems.Remove(ic);
|
|
ic.Dispose();
|
|
}
|
|
}
|
|
|
|
private bool _AutoFocusDropDownControl = false;
|
|
/// <summary>
|
|
/// Indicates whether DropDownControl is automatically focused when popup is open.
|
|
/// </summary>
|
|
[DefaultValue(false), Category("Behavior"), Description("Indicates whether DropDownControl is automatically focused when popup is open.")]
|
|
public bool AutoFocusDropDownControl
|
|
{
|
|
get { return _AutoFocusDropDownControl; }
|
|
set
|
|
{
|
|
_AutoFocusDropDownControl = value;
|
|
}
|
|
}
|
|
|
|
|
|
private void ClearButtonClick()
|
|
{
|
|
CancelEventArgs cancelArgs = new CancelEventArgs();
|
|
OnButtonClearClick(cancelArgs);
|
|
if (cancelArgs.Cancel) return;
|
|
|
|
_TextBox.Text = "";
|
|
}
|
|
private void ClearButtonMouseUp(object sender, EventArgs e)
|
|
{
|
|
ClearButtonClick();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Raises the ButtonClearClick event.
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected virtual void OnButtonClearClick(CancelEventArgs e)
|
|
{
|
|
if (ButtonClearClick != null)
|
|
ButtonClearClick(this, e);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Raises the ButtonDropDownClick event.
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected virtual void OnButtonDropDownClick(CancelEventArgs e)
|
|
{
|
|
if (ButtonDropDownClick != null)
|
|
ButtonDropDownClick(this, e);
|
|
}
|
|
|
|
private Control _DropDownControl = null;
|
|
/// <summary>
|
|
/// Gets or sets the reference of the control that will be displayed on popup that is shown when drop-down button is clicked.
|
|
/// </summary>
|
|
[DefaultValue(null), Description("Indicates reference of the control that will be displayed on popup that is shown when drop-down button is clicked.")]
|
|
public Control DropDownControl
|
|
{
|
|
get { return _DropDownControl; }
|
|
set
|
|
{
|
|
if (value == this) return;
|
|
_DropDownControl = value;
|
|
OnDropDownControlChanged();
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Called when DropDownControl property has changed.
|
|
/// </summary>
|
|
protected virtual void OnDropDownControlChanged()
|
|
{
|
|
if (_DropDownControl != null)
|
|
{
|
|
_DropDownControl.BindingContext = this.BindingContext;
|
|
if (!this.DesignMode)
|
|
_DropDownControl.Visible = false;
|
|
}
|
|
}
|
|
|
|
protected override PopupItem CreatePopupItem()
|
|
{
|
|
ButtonItem button = new ButtonItem("sysPopupProvider");
|
|
button.PopupFinalized += new EventHandler(DropDownPopupClose);
|
|
_PopupItem = button;
|
|
return button;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the collection of BaseItem derived items displayed on popup menu.
|
|
/// </summary>
|
|
[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public SubItemsCollection DropDownItems
|
|
{
|
|
get { return _PopupItem.SubItems; }
|
|
}
|
|
|
|
protected override void RecalcSize()
|
|
{
|
|
}
|
|
|
|
public override void PerformClick()
|
|
{
|
|
}
|
|
|
|
private bool RenderButtons
|
|
{
|
|
get
|
|
{
|
|
return _ButtonCustom != null && _ButtonCustom.Visible || _ButtonCustom2 != null && _ButtonCustom2.Visible ||
|
|
_ButtonDropDown != null && _ButtonDropDown.Visible || _ButtonClear != null && _ButtonClear.Visible;
|
|
}
|
|
}
|
|
|
|
protected override void OnMouseMove(MouseEventArgs e)
|
|
{
|
|
if (RenderButtons)
|
|
{
|
|
_ButtonGroup.ProcessMouseMove(e);
|
|
}
|
|
base.OnMouseMove(e);
|
|
}
|
|
protected override void OnMouseLeave(EventArgs e)
|
|
{
|
|
if (RenderButtons)
|
|
{
|
|
_ButtonGroup.ProcessMouseLeave();
|
|
}
|
|
base.OnMouseLeave(e);
|
|
}
|
|
protected override void OnMouseHover(EventArgs e)
|
|
{
|
|
if (RenderButtons)
|
|
{
|
|
_ButtonGroup.ProcessMouseHover(e);
|
|
}
|
|
base.OnMouseHover(e);
|
|
}
|
|
protected override void OnMouseDown(MouseEventArgs e)
|
|
{
|
|
if (RenderButtons)
|
|
_ButtonGroup.ProcessMouseDown(e);
|
|
base.OnMouseDown(e);
|
|
}
|
|
protected override void OnMouseUp(MouseEventArgs e)
|
|
{
|
|
if (RenderButtons)
|
|
_ButtonGroup.ProcessMouseUp(e);
|
|
base.OnMouseUp(e);
|
|
}
|
|
|
|
internal void ProcessMouseUpOnGroup()
|
|
{
|
|
if (RenderButtons)
|
|
_ButtonGroup.ProcessMouseUp(new MouseEventArgs(MouseButtons.Left, 0, -10, -10, 0));
|
|
this.Invalidate();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the reference to internal TextBox control. Use it to get access to the text box events and properties.
|
|
/// </summary>
|
|
[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public TextBoxX TextBox
|
|
{
|
|
get
|
|
{
|
|
return _TextBox;
|
|
}
|
|
}
|
|
|
|
private bool _InternalReadOnly = false;
|
|
internal bool InternalReadOnly
|
|
{
|
|
get { return _InternalReadOnly; }
|
|
set
|
|
{
|
|
_InternalReadOnly = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether watermark text is displayed when control is empty. Default value is true.
|
|
/// </summary>
|
|
[DefaultValue(true), Description("Indicates whether watermark text is displayed when control is empty.")]
|
|
public virtual bool WatermarkEnabled
|
|
{
|
|
get { return _TextBox.WatermarkEnabled; }
|
|
set { _TextBox.WatermarkEnabled = value; this.Invalidate(true); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the watermark (tip) text displayed inside of the control when Text is not set and control does not have input focus. This property supports text-markup.
|
|
/// </summary>
|
|
[Browsable(true), DefaultValue(""), Localizable(true), Category("Appearance"), Description("Indicates watermark text displayed inside of the control when Text is not set and control does not have input focus."), Editor("DevComponents.DotNetBar.Design.TextMarkupUIEditor, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf", typeof(System.Drawing.Design.UITypeEditor))]
|
|
public string WatermarkText
|
|
{
|
|
get { return _TextBox.WatermarkText; }
|
|
set
|
|
{
|
|
if (value == null) value = "";
|
|
_TextBox.WatermarkText = value;
|
|
this.Invalidate(true);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the watermark font.
|
|
/// </summary>
|
|
[Browsable(true), Category("Appearance"), Description("Indicates watermark font."), DefaultValue(null)]
|
|
public Font WatermarkFont
|
|
{
|
|
get { return _TextBox.WatermarkFont; }
|
|
set { _TextBox.WatermarkFont = value; this.Invalidate(true); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the watermark text color.
|
|
/// </summary>
|
|
[Browsable(true), Category("Appearance"), Description("Indicates watermark text color.")]
|
|
public Color WatermarkColor
|
|
{
|
|
get { return _TextBox.WatermarkColor; }
|
|
set { _TextBox.WatermarkColor = value; this.Invalidate(); }
|
|
}
|
|
/// <summary>
|
|
/// Indicates whether property should be serialized by Windows Forms designer.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public bool ShouldSerializeWatermarkColor()
|
|
{
|
|
return _TextBox.WatermarkColor != SystemColors.GrayText;
|
|
}
|
|
/// <summary>
|
|
/// Resets the property to default value.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public void ResetWatermarkColor()
|
|
{
|
|
this.WatermarkColor = SystemColors.GrayText;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the watermark hiding behaviour. Default value indicates that watermark is hidden when control receives input focus.
|
|
/// </summary>
|
|
[DefaultValue(eWatermarkBehavior.HideOnFocus), Category("Behavior"), Description("Indicates watermark hiding behaviour.")]
|
|
public eWatermarkBehavior WatermarkBehavior
|
|
{
|
|
get { return _TextBox.WatermarkBehavior; }
|
|
set { _TextBox.WatermarkBehavior = value; this.Invalidate(true); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the watermark image displayed inside of the control when Text is not set and control does not have input focus.
|
|
/// </summary>
|
|
[DefaultValue(null), Category("Appearance"), Description("Indicates watermark image displayed inside of the control when Text is not set and control does not have input focus.")]
|
|
public Image WatermarkImage
|
|
{
|
|
get { return _TextBox.WatermarkImage; }
|
|
set { _TextBox.WatermarkImage = value; }
|
|
}
|
|
/// <summary>
|
|
/// Gets or sets the watermark image alignment.
|
|
/// </summary>
|
|
[DefaultValue(ContentAlignment.MiddleLeft), Category("Appearance"), Description("Indicates watermark image alignment.")]
|
|
public ContentAlignment WatermarkImageAlignment
|
|
{
|
|
get { return _TextBox.WatermarkImageAlignment; }
|
|
set { _TextBox.WatermarkImageAlignment = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ICommandSource Members
|
|
protected virtual void ExecuteCommand()
|
|
{
|
|
if (_Command == null) return;
|
|
CommandManager.ExecuteCommand(this);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the command assigned to the item. Default value is null.
|
|
/// <remarks>Note that if this property is set to null Enabled property will be set to false automatically to disable the item.</remarks>
|
|
/// </summary>
|
|
[DefaultValue(null), Category("Commands"), Description("Indicates the command assigned to the item.")]
|
|
public Command Command
|
|
{
|
|
get { return (Command)((ICommandSource)this).Command; }
|
|
set
|
|
{
|
|
((ICommandSource)this).Command = value;
|
|
}
|
|
}
|
|
|
|
private ICommand _Command = null;
|
|
[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
ICommand ICommandSource.Command
|
|
{
|
|
get
|
|
{
|
|
return _Command;
|
|
}
|
|
set
|
|
{
|
|
bool changed = false;
|
|
if (_Command != value)
|
|
changed = true;
|
|
|
|
if (_Command != null)
|
|
CommandManager.UnRegisterCommandSource(this, _Command);
|
|
_Command = value;
|
|
if (value != null)
|
|
CommandManager.RegisterCommand(this, value);
|
|
if (changed)
|
|
OnCommandChanged();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when Command property value changes.
|
|
/// </summary>
|
|
protected virtual void OnCommandChanged()
|
|
{
|
|
}
|
|
|
|
private object _CommandParameter = null;
|
|
/// <summary>
|
|
/// Gets or sets user defined data value that can be passed to the command when it is executed.
|
|
/// </summary>
|
|
[Browsable(true), DefaultValue(null), Category("Commands"), Description("Indicates user defined data value that can be passed to the command when it is executed."), System.ComponentModel.TypeConverter(typeof(System.ComponentModel.StringConverter)), System.ComponentModel.Localizable(true)]
|
|
public object CommandParameter
|
|
{
|
|
get
|
|
{
|
|
return _CommandParameter;
|
|
}
|
|
set
|
|
{
|
|
_CommandParameter = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TextBox Property Forwarding
|
|
/// <summary>
|
|
/// Gets or sets the text as it is currently displayed to the user.
|
|
/// </summary>
|
|
[Category("Appearance"), DefaultValue("Indicates text as it is currently displayed to the user"), Bindable(true), RefreshProperties(RefreshProperties.Repaint), Localizable(true)]
|
|
public override string Text
|
|
{
|
|
get
|
|
{
|
|
return base.Text;
|
|
}
|
|
set
|
|
{
|
|
_TextBox.Text = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Returns a string that represents the current text in text box. This method overrides ToString.
|
|
/// </summary>
|
|
/// <returns>A String that contains information about the current TextBox. The string includes the type, a simplified view of the input string, and the formatted input string.</returns>
|
|
public override string ToString()
|
|
{
|
|
return _TextBox.ToString();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the preferred height for a text box.
|
|
/// </summary>
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced)]
|
|
public int PreferredHeight
|
|
{
|
|
get
|
|
{
|
|
int height = _TextBox.PreferredHeight;
|
|
bool disposeStyle = false;
|
|
ElementStyle style = GetBackgroundStyle(out disposeStyle);
|
|
height += ElementStyleLayout.VerticalStyleWhiteSpace(style);
|
|
if (disposeStyle)
|
|
{
|
|
style.Dispose();
|
|
}
|
|
return height;
|
|
}
|
|
}
|
|
protected override void OnHandleCreated(EventArgs e)
|
|
{
|
|
UpdateLayout(); // Fixes an issue where button if visible is not showing under certain use cases
|
|
base.OnHandleCreated(e);
|
|
}
|
|
public override Size GetPreferredSize(Size proposedSize)
|
|
{
|
|
Size ps = _TextBox.GetPreferredSize(proposedSize);
|
|
ps.Height = PreferredHeight;
|
|
return ps;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets a custom StringCollection to use when the AutoCompleteSource property is set to CustomSource.
|
|
/// <value>A StringCollection to use with AutoCompleteSource.</value>
|
|
/// </summary>
|
|
[Browsable(true), EditorBrowsable(EditorBrowsableState.Always), DesignerSerializationVisibility(DesignerSerializationVisibility.Content), Localizable(true), Description("Indicates custom StringCollection to use when the AutoCompleteSource property is set to CustomSource."), Editor("System.Windows.Forms.Design.ListControlStringCollectionEditor, System.Design, Version= 2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof(UITypeEditor))]
|
|
public AutoCompleteStringCollection AutoCompleteCustomSource
|
|
{
|
|
get
|
|
{
|
|
return _TextBox.AutoCompleteCustomSource;
|
|
}
|
|
set
|
|
{
|
|
_TextBox.AutoCompleteCustomSource = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets an option that controls how automatic completion works for the TextBox.
|
|
/// <value>One of the values of AutoCompleteMode. The values are Append, None, Suggest, and SuggestAppend. The default is None.</value>
|
|
/// </summary>
|
|
[Description("Gets or sets an option that controls how automatic completion works for the TextBox."), Browsable(true), EditorBrowsable(EditorBrowsableState.Always), DefaultValue(0)]
|
|
public AutoCompleteMode AutoCompleteMode
|
|
{
|
|
get
|
|
{
|
|
return _TextBox.AutoCompleteMode;
|
|
}
|
|
set
|
|
{
|
|
_TextBox.AutoCompleteMode = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets a value specifying the source of complete strings used for automatic completion.
|
|
/// <value>One of the values of AutoCompleteSource. The options are AllSystemSources, AllUrl, FileSystem, HistoryList, RecentlyUsedList, CustomSource, and None. The default is None.</value>
|
|
/// </summary>
|
|
[DefaultValue(0x80), TypeConverter(typeof(TextBoxAutoCompleteSourceConverter)), Browsable(true), EditorBrowsable(EditorBrowsableState.Always), Description("Gets or sets a value specifying the source of complete strings used for automatic completion.")]
|
|
public AutoCompleteSource AutoCompleteSource
|
|
{
|
|
get
|
|
{
|
|
return _TextBox.AutoCompleteSource;
|
|
}
|
|
set
|
|
{
|
|
_TextBox.AutoCompleteSource = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether the TextBox control modifies the case of characters as they are typed.
|
|
/// <value>One of the CharacterCasing enumeration values that specifies whether the TextBox control modifies the case of characters. The default is CharacterCasing.Normal.</value>
|
|
/// </summary>
|
|
[Category("Behavior"), Description("Indicates whether the TextBox control modifies the case of characters as they are typed."), DefaultValue(0)]
|
|
public CharacterCasing CharacterCasing
|
|
{
|
|
get
|
|
{
|
|
return _TextBox.CharacterCasing;
|
|
}
|
|
set
|
|
{
|
|
_TextBox.CharacterCasing = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the character used to mask characters of a password in a single-line TextBox control.
|
|
/// <value>The character used to mask characters entered in a single-line TextBox control. Set the value of this property to 0 (character value) if you do not want the control to mask characters as they are typed. Equals 0 (character value) by default.</value>
|
|
/// </summary>
|
|
[RefreshProperties(RefreshProperties.Repaint), Localizable(true), Description("Gets or sets the character used to mask characters of a password in a single-line TextBox control."), Category("Behavior"), DefaultValue('\0')]
|
|
public char PasswordChar
|
|
{
|
|
get
|
|
{
|
|
return _TextBox.PasswordChar;
|
|
}
|
|
set
|
|
{
|
|
_TextBox.PasswordChar = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets how text is aligned in a TextBox control.
|
|
/// <value>One of the HorizontalAlignment enumeration values that specifies how text is aligned in the control. The default is HorizontalAlignment.Left.</value>
|
|
/// </summary>
|
|
[DefaultValue(0), Category("Appearance"), Localizable(true), Description("Indicates how text is aligned in a TextBox control.")]
|
|
public HorizontalAlignment TextAlign
|
|
{
|
|
get
|
|
{
|
|
return _TextBox.TextAlign;
|
|
}
|
|
set
|
|
{
|
|
_TextBox.TextAlign = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets a value indicating whether the text in the TextBox control should appear as the default password character.
|
|
/// <value>true if the text in the TextBox control should appear as the default password character; otherwise, false.</value>
|
|
/// </summary>
|
|
[Category("Behavior"), DefaultValue(false), Description("Gets or sets a value indicating whether the text in the TextBox control should appear as the default password character."), RefreshProperties(RefreshProperties.Repaint)]
|
|
public bool UseSystemPasswordChar
|
|
{
|
|
get
|
|
{
|
|
return _TextBox.UseSystemPasswordChar;
|
|
}
|
|
set
|
|
{
|
|
_TextBox.UseSystemPasswordChar = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets a value indicating whether the selected text in the text box control remains highlighted when the control loses focus.
|
|
/// <value>true if the selected text does not appear highlighted when the text box control loses focus; false, if the selected text remains highlighted when the text box control loses focus. The default is true.</value>
|
|
/// </summary>
|
|
[Category("Behavior"), DefaultValue(true), Description("Gets or sets a value indicating whether the selected text in the text box control remains highlighted when the control loses focus.")]
|
|
public bool HideSelection
|
|
{
|
|
get
|
|
{
|
|
return _TextBox.HideSelection;
|
|
}
|
|
set
|
|
{
|
|
_TextBox.HideSelection = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the maximum number of characters the user can type or paste into the text box control.
|
|
/// <value>The number of characters that can be entered into the control. The default is 32767.</value>
|
|
/// </summary>
|
|
[Category("Behavior"), Description("Gets or sets the maximum number of characters the user can type or paste into the text box control."), DefaultValue(0x7fff), Localizable(true)]
|
|
public virtual int MaxLength
|
|
{
|
|
get
|
|
{
|
|
return _TextBox.MaxLength;
|
|
}
|
|
set
|
|
{
|
|
_TextBox.MaxLength = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets a value that indicates that the text box control has been modified by the user since the control was created or its contents were last set.
|
|
/// <value>true if the control's contents have been modified; otherwise, false. The default is false.</value>
|
|
/// </summary>
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), Browsable(false)]
|
|
public bool Modified
|
|
{
|
|
get
|
|
{
|
|
return _TextBox.Modified;
|
|
}
|
|
set
|
|
{
|
|
_TextBox.Modified = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Gets or sets a value indicating whether text in the text box is read-only.
|
|
/// <value>true if the text box is read-only; otherwise, false. The default is false.</value>
|
|
/// </summary>
|
|
[DefaultValue(false), RefreshProperties(RefreshProperties.Repaint), Category("Behavior"), Description("Gets or sets a value indicating whether text in the text box is read-only.")]
|
|
public bool ReadOnly
|
|
{
|
|
get
|
|
{
|
|
return _TextBox.ReadOnly;
|
|
}
|
|
set
|
|
{
|
|
_TextBox.ReadOnly = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets a value indicating the currently selected text in the control.
|
|
/// <value>A string that represents the currently selected text in the text box.</value>
|
|
/// </summary>
|
|
[Description("Gets or sets a value indicating the currently selected text in the control."), Browsable(false), Category("Appearance"), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public virtual string SelectedText
|
|
{
|
|
get
|
|
{
|
|
return _TextBox.SelectedText;
|
|
}
|
|
set
|
|
{
|
|
_TextBox.SelectedText = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the number of characters selected in the text box.
|
|
/// <value>The number of characters selected in the text box.</value>
|
|
/// </summary>
|
|
[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), Description("Gets or sets the number of characters selected in the text box."), Category("Appearance")]
|
|
public virtual int SelectionLength
|
|
{
|
|
get
|
|
{
|
|
return _TextBox.SelectionLength;
|
|
}
|
|
set
|
|
{
|
|
_TextBox.SelectionLength = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the starting point of text selected in the text box.
|
|
/// <value>The starting position of text selected in the text box.</value>
|
|
/// </summary>
|
|
[Description("Gets or sets the starting point of text selected in the text box."), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), Category("Appearance"), Browsable(false)]
|
|
public int SelectionStart
|
|
{
|
|
get
|
|
{
|
|
return _TextBox.SelectionStart;
|
|
}
|
|
set
|
|
{
|
|
_TextBox.SelectionStart = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the length of text in the control.Returns number of characters contained in the text of the control.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
public virtual int TextLength
|
|
{
|
|
get
|
|
{
|
|
return _TextBox.TextLength;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Appends text to the current text of a text box.
|
|
/// </summary>
|
|
/// <param name="text">The text to append to the current contents of the text box. </param>
|
|
public void AppendText(string text)
|
|
{
|
|
_TextBox.AppendText(text);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clears all text from the text box control.
|
|
/// </summary>
|
|
public void Clear()
|
|
{
|
|
_TextBox.Clear();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clears information about the most recent operation from the undo buffer of the text box.
|
|
/// </summary>
|
|
public void ClearUndo()
|
|
{
|
|
_TextBox.ClearUndo();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copies the current selection in the text box to the Clipboard.
|
|
/// </summary>
|
|
[UIPermission(SecurityAction.Demand, Clipboard = UIPermissionClipboard.OwnClipboard)]
|
|
public void Copy()
|
|
{
|
|
_TextBox.Copy();
|
|
}
|
|
/// <summary>
|
|
/// Moves the current selection in the text box to the Clipboard.
|
|
/// </summary>
|
|
public void Cut()
|
|
{
|
|
_TextBox.Cut();
|
|
}
|
|
/// <summary>
|
|
/// Specifies that the value of the SelectionLength property is zero so that no characters are selected in the control.
|
|
/// </summary>
|
|
public void DeselectAll()
|
|
{
|
|
_TextBox.DeselectAll();
|
|
}
|
|
/// <summary>
|
|
/// Retrieves the character that is closest to the specified location within the control.
|
|
/// </summary>
|
|
/// <param name="pt">The location from which to seek the nearest character. </param>
|
|
/// <returns>The character at the specified location.</returns>
|
|
public virtual char GetCharFromPosition(Point pt)
|
|
{
|
|
return _TextBox.GetCharFromPosition(pt);
|
|
}
|
|
/// <summary>
|
|
/// Retrieves the index of the character nearest to the specified location.
|
|
/// </summary>
|
|
/// <param name="pt">The location to search.</param>
|
|
/// <returns>The zero-based character index at the specified location.</returns>
|
|
public virtual int GetCharIndexFromPosition(Point pt)
|
|
{
|
|
return _TextBox.GetCharIndexFromPosition(pt);
|
|
}
|
|
/// <summary>
|
|
/// Retrieves the index of the first character of a given line.
|
|
/// </summary>
|
|
/// <param name="lineNumber">The line for which to get the index of its first character. </param>
|
|
/// <returns>The zero-based character index in the specified line.</returns>
|
|
public int GetFirstCharIndexFromLine(int lineNumber)
|
|
{
|
|
return _TextBox.GetFirstCharIndexFromLine(lineNumber);
|
|
}
|
|
/// <summary>
|
|
/// Retrieves the index of the first character of the current line.
|
|
/// </summary>
|
|
/// <returns>The zero-based character index in the current line.</returns>
|
|
public int GetFirstCharIndexOfCurrentLine()
|
|
{
|
|
return _TextBox.GetFirstCharIndexOfCurrentLine();
|
|
}
|
|
/// <summary>
|
|
/// Retrieves the line number from the specified character position within the text of the control.
|
|
/// </summary>
|
|
/// <param name="index">The character index position to search. </param>
|
|
/// <returns>The zero-based line number in which the character index is located.</returns>
|
|
public virtual int GetLineFromCharIndex(int index)
|
|
{
|
|
return _TextBox.GetLineFromCharIndex(index);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retrieves the location within the control at the specified character index.
|
|
/// </summary>
|
|
/// <param name="index">The index of the character for which to retrieve the location. </param>
|
|
/// <returns>The location of the specified character.</returns>
|
|
public virtual Point GetPositionFromCharIndex(int index)
|
|
{
|
|
return _TextBox.GetPositionFromCharIndex(index);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Replaces the current selection in the text box with the contents of the Clipboard.
|
|
/// </summary>
|
|
[UIPermission(SecurityAction.Demand, Clipboard = UIPermissionClipboard.OwnClipboard)]
|
|
public void Paste()
|
|
{
|
|
_TextBox.Paste();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Selects a range of text in the text box.
|
|
/// </summary>
|
|
/// <param name="start">The position of the first character in the current text selection within the text box. </param>
|
|
/// <param name="length">The number of characters to select. </param>
|
|
public void Select(int start, int length)
|
|
{
|
|
_TextBox.Select(start, length);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Selects all text in the text box.
|
|
/// </summary>
|
|
public void SelectAll()
|
|
{
|
|
_TextBox.SelectAll();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Undoes the last edit operation in the text box.
|
|
/// </summary>
|
|
public void Undo()
|
|
{
|
|
_TextBox.Undo();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Replaces the specified selection in the TextBox with the contents of the Clipboard.
|
|
/// </summary>
|
|
/// <param name="text">The text to replace.</param>
|
|
public void Paste(string text)
|
|
{
|
|
_TextBox.Paste(text);
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
#region TextBoxAutoCompleteSourceConverter
|
|
internal class TextBoxAutoCompleteSourceConverter : EnumConverter
|
|
{
|
|
// Methods
|
|
public TextBoxAutoCompleteSourceConverter(Type type)
|
|
: base(type)
|
|
{
|
|
}
|
|
|
|
public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
|
|
{
|
|
TypeConverter.StandardValuesCollection standardValues = base.GetStandardValues(context);
|
|
ArrayList values = new ArrayList();
|
|
int count = standardValues.Count;
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
if (!standardValues[i].ToString().Equals("ListItems"))
|
|
{
|
|
values.Add(standardValues[i]);
|
|
}
|
|
}
|
|
return new TypeConverter.StandardValuesCollection(values);
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
#endif |