//
// MaskedTextBox.cs
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
// Copyright (c) 2007 Novell, Inc.
//
// Authors:
// Rolf Bjarne Kvinge (RKvinge@novell.com)
//
#if NET_2_0
using System;
using System.Collections;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Design;
using System.Globalization;
using System.Runtime.InteropServices;
using System.Security.Permissions;
using System.Windows.Forms;
namespace System.Windows.Forms{
[ClassInterface (ClassInterfaceType.AutoDispatch)]
[ComVisible (true)]
[DefaultProperty ("Mask")]
[DefaultEvent ("MaskInputRejected")]
[Designer ("System.Windows.Forms.Design.MaskedTextBoxDesigner, " + Consts.AssemblySystem_Design)]
[DefaultBindingProperty ("Text")]
public class MaskedTextBox : TextBoxBase
{
#region Locals
private MaskedTextProvider provider;
private bool beep_on_error;
private IFormatProvider format_provider;
private bool hide_prompt_on_leave;
private InsertKeyMode insert_key_mode;
private bool insert_key_overwriting;
private bool reject_input_on_first_failure;
private HorizontalAlignment text_align;
private MaskFormat cut_copy_mask_format;
private bool use_system_password_char;
private Type validating_type;
private bool is_empty_mask;
private bool setting_text;
#endregion
#region Events
static object AcceptsTabChangedEvent = new object ();
static object IsOverwriteModeChangedEvent = new object ();
static object MaskChangedEvent = new object ();
static object MaskInputRejectedEvent = new object ();
static object MultilineChangedEvent = new object ();
static object TextAlignChangedEvent = new object ();
static object TypeValidationCompletedEvent = new object ();
// This event is never raised by MaskedTextBox.
[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
[Browsable (false)]
[EditorBrowsable (EditorBrowsableState.Never)]
public new event EventHandler AcceptsTabChanged {
add { Events.AddHandler (AcceptsTabChangedEvent, value);}
remove { Events.RemoveHandler (AcceptsTabChangedEvent, value);}
}
public event EventHandler IsOverwriteModeChanged {
add { Events.AddHandler (IsOverwriteModeChangedEvent, value); }
remove { Events.RemoveHandler (IsOverwriteModeChangedEvent, value); }
}
public event EventHandler MaskChanged {
add { Events.AddHandler (MaskChangedEvent, value); }
remove { Events.RemoveHandler (MaskChangedEvent, value); }
}
public event MaskInputRejectedEventHandler MaskInputRejected {
add { Events.AddHandler (MaskInputRejectedEvent, value); }
remove { Events.RemoveHandler (MaskInputRejectedEvent, value); }
}
// This event is never raised by MaskedTextBox.
[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
[Browsable (false)]
[EditorBrowsable (EditorBrowsableState.Never)]
public new event EventHandler MultilineChanged {
add { Events.AddHandler (MultilineChangedEvent, value); }
remove { Events.RemoveHandler (MultilineChangedEvent, value); }
}
public event EventHandler TextAlignChanged {
add { Events.AddHandler (TextAlignChangedEvent, value); }
remove { Events.RemoveHandler (TextAlignChangedEvent, value); }
}
public event TypeValidationEventHandler TypeValidationCompleted {
add { Events.AddHandler (TypeValidationCompletedEvent, value); }
remove { Events.RemoveHandler (TypeValidationCompletedEvent, value); }
}
#endregion
#region Constructors
public MaskedTextBox ()
{
provider = new MaskedTextProvider ("<>", CultureInfo.CurrentCulture);
is_empty_mask = true;
Init ();
}
public MaskedTextBox (MaskedTextProvider maskedTextProvider)
{
if (maskedTextProvider == null) {
throw new ArgumentNullException ();
}
provider = maskedTextProvider;
is_empty_mask = false;
Init ();
}
public MaskedTextBox (string mask)
{
if (mask == null) {
throw new ArgumentNullException ();
}
provider = new MaskedTextProvider (mask, CultureInfo.CurrentCulture);
is_empty_mask = false;
Init ();
}
private void Init ()
{
BackColor = SystemColors.Window;
cut_copy_mask_format = MaskFormat.IncludeLiterals;
insert_key_overwriting = false;
UpdateVisibleText ();
}
#endregion
#region Public and protected methods
[EditorBrowsable (EditorBrowsableState.Never)]
public new void ClearUndo ()
{
// Do nothing, not supported by MTB
}
[EditorBrowsable (EditorBrowsableState.Advanced)]
[UIPermission (SecurityAction.InheritanceDemand, Window = UIPermissionWindow.AllWindows)]
protected override void CreateHandle ()
{
base.CreateHandle ();
}
public override char GetCharFromPosition (Point pt)
{
return base.GetCharFromPosition (pt);
}
public override int GetCharIndexFromPosition (Point pt)
{
return base.GetCharIndexFromPosition (pt);
}
[EditorBrowsable (EditorBrowsableState.Never)]
public new int GetFirstCharIndexFromLine (int lineNumber)
{
return 0;
}
[EditorBrowsable (EditorBrowsableState.Never)]
public new int GetFirstCharIndexOfCurrentLine ()
{
return 0;
}
[EditorBrowsable (EditorBrowsableState.Never)]
public override int GetLineFromCharIndex (int index)
{
return 0;
}
public override Point GetPositionFromCharIndex (int index)
{
return base.GetPositionFromCharIndex (index);
}
protected override bool IsInputKey (Keys keyData)
{
return base.IsInputKey (keyData);
}
protected override void OnBackColorChanged (EventArgs e)
{
base.OnBackColorChanged (e);
}
protected override void OnHandleCreated (EventArgs e)
{
base.OnHandleCreated (e);
}
[EditorBrowsable (EditorBrowsableState.Advanced)]
protected virtual void OnIsOverwriteModeChanged (EventArgs e)
{
EventHandler eh = (EventHandler) Events [IsOverwriteModeChangedEvent];
if (eh != null)
eh (this, e);
}
protected override void OnKeyDown (KeyEventArgs e)
{
// Only handle Delete or Insert here
if (e.KeyCode == Keys.Insert && insert_key_mode == InsertKeyMode.Default) {
// switch the internal overwriting mode, not the public one
insert_key_overwriting = !insert_key_overwriting;
OnIsOverwriteModeChanged (EventArgs.Empty);
e.Handled = true;
return;
}
if (e.KeyCode != Keys.Delete || is_empty_mask) {
base.OnKeyDown (e);
return;
}
int testPosition, endSelection;
MaskedTextResultHint resultHint;
bool result;
// Use a slightly different approach than the one used for backspace
endSelection = SelectionLength == 0 ? SelectionStart : SelectionStart + SelectionLength - 1;
result = provider.RemoveAt (SelectionStart, endSelection, out testPosition, out resultHint);
PostprocessKeyboardInput (result, testPosition, testPosition, resultHint);
e.Handled = true;
}
protected override void OnKeyPress (KeyPressEventArgs e)
{
if (is_empty_mask) {
base.OnKeyPress (e);
return;
}
int testPosition, editPosition;
MaskedTextResultHint resultHint;
bool result;
if (e.KeyChar == '\b') {
if (SelectionLength == 0)
result = provider.RemoveAt (SelectionStart - 1, SelectionStart - 1, out testPosition, out resultHint);
else
result = provider.RemoveAt (SelectionStart, SelectionStart + SelectionLength - 1, out testPosition, out resultHint);
editPosition = testPosition;
} else if (IsOverwriteMode || SelectionLength > 0) { // Replace
int start = provider.FindEditPositionFrom (SelectionStart, true);
int end = SelectionLength > 0 ? SelectionStart + SelectionLength - 1 : start;
result = provider.Replace (e.KeyChar, start, end, out testPosition, out resultHint);
editPosition = testPosition + 1;
} else {
// Move chars to the right
result = provider.InsertAt (e.KeyChar, SelectionStart, out testPosition, out resultHint);
editPosition = testPosition + 1;
}
PostprocessKeyboardInput (result, editPosition, testPosition, resultHint);
e.Handled = true;
}
void PostprocessKeyboardInput (bool result, int newPosition, int testPosition, MaskedTextResultHint resultHint)
{
if (!result)
OnMaskInputRejected (new MaskInputRejectedEventArgs (testPosition, resultHint));
else {
if (newPosition != MaskedTextProvider.InvalidIndex)
SelectionStart = newPosition;
else
SelectionStart = provider.Length;
UpdateVisibleText ();
}
}
protected override void OnKeyUp (KeyEventArgs e)
{
base.OnKeyUp (e);
}
[EditorBrowsable (EditorBrowsableState.Advanced)]
protected virtual void OnMaskChanged (EventArgs e)
{
EventHandler eh = (EventHandler) Events [MaskChangedEvent];
if (eh != null)
eh (this, e);
}
private void OnMaskInputRejected (MaskInputRejectedEventArgs e)
{
MaskInputRejectedEventHandler eh = (MaskInputRejectedEventHandler) Events [MaskInputRejectedEvent];
if (eh != null)
eh (this, e);
}
[EditorBrowsable (EditorBrowsableState.Never)]
protected override void OnMultilineChanged (EventArgs e)
{
EventHandler eh = (EventHandler)Events [MultilineChangedEvent];
if (eh != null)
eh (this, e);
}
protected virtual void OnTextAlignChanged (EventArgs e)
{
EventHandler eh = (EventHandler)Events [TextAlignChangedEvent];
if (eh != null)
eh (this, e);
}
protected override void OnTextChanged (EventArgs e)
{
base.OnTextChanged (e);
}
[EditorBrowsable (EditorBrowsableState.Advanced)]
protected override void OnValidating (CancelEventArgs e)
{
base.OnValidating (e);
}
//[SecurityPermission (SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
protected override bool ProcessCmdKey (ref Message msg, Keys keyData)
{
return base.ProcessCmdKey (ref msg, keyData);
}
//[SecurityPermission (SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
protected internal override bool ProcessKeyMessage (ref Message m)
{
return base.ProcessKeyMessage (ref m);
}
[EditorBrowsable (EditorBrowsableState.Never)]
public new void ScrollToCaret ()
{
// MSDN: this method is overridden to perform no actions.
}
public override string ToString ()
{
return base.ToString () + ", Text: " + provider.ToString (false, false);
}
[EditorBrowsable (EditorBrowsableState.Never)]
public new void Undo ()
{
// Do nothing, not supported by MTB.
}
public object ValidateText ()
{
throw new NotImplementedException ();
}
//[SecurityPermission (SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
protected override void WndProc (ref Message m)
{
switch ((Msg) m.Msg) {
default:
base.WndProc (ref m);
return;
}
}
#endregion
#region Properties
[EditorBrowsable (EditorBrowsableState.Never)]
[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
[Browsable (false)]
public new bool AcceptsTab {
get {
return false;
}
set {
}
}
[DefaultValue (true)]
public bool AllowPromptAsInput {
get {
return provider.AllowPromptAsInput;
}
set {
provider = new MaskedTextProvider (provider.Mask, provider.Culture, value, provider.PromptChar, provider.PasswordChar, provider.AsciiOnly);
UpdateVisibleText ();
}
}
[RefreshProperties (RefreshProperties.Repaint)]
[DefaultValue (false)]
public bool AsciiOnly {
get {
return provider.AsciiOnly;
}
set {
provider = new MaskedTextProvider (provider.Mask, provider.Culture, provider.AllowPromptAsInput, provider.PromptChar, provider.PasswordChar, value);
UpdateVisibleText ();
}
}
[DefaultValue (false)]
public bool BeepOnError {
get {
return beep_on_error;
}
set {
beep_on_error = value;
}
}
[Browsable (false)]
[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
[EditorBrowsable (EditorBrowsableState.Never)]
public new bool CanUndo {
get {
return false;
}
}
protected override CreateParams CreateParams {
//[SecurityPermission (SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
get {
return base.CreateParams;
}
}
[RefreshProperties (RefreshProperties.Repaint)]
public CultureInfo Culture {
get {
return provider.Culture;
}
set {
provider = new MaskedTextProvider (provider.Mask, value, provider.AllowPromptAsInput, provider.PromptChar, provider.PasswordChar, provider.AsciiOnly);
UpdateVisibleText ();
}
}
[RefreshProperties (RefreshProperties.Repaint)]
[DefaultValue (MaskFormat.IncludeLiterals)]
public MaskFormat CutCopyMaskFormat {
get {
return cut_copy_mask_format;
}
set {
if (!Enum.IsDefined (typeof (MaskFormat), value)) {
throw new InvalidEnumArgumentException ("value", (int)value, typeof (MaskFormat));
}
cut_copy_mask_format = value;
}
}
[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
[Browsable (false)]
public IFormatProvider FormatProvider {
get {
return format_provider;
}
set {
format_provider = value;
}
}
[RefreshProperties (RefreshProperties.Repaint)]
[DefaultValue (false)]
public bool HidePromptOnLeave {
get {
return hide_prompt_on_leave;
}
set {
hide_prompt_on_leave = value;
}
}
[DefaultValue (InsertKeyMode.Default)]
public InsertKeyMode InsertKeyMode {
get {
return insert_key_mode;
}
set {
if (!Enum.IsDefined (typeof (InsertKeyMode), value)) {
throw new InvalidEnumArgumentException ("value", (int)value, typeof (InsertKeyMode));
}
insert_key_mode = value;
}
}
[Browsable (false)]
public bool IsOverwriteMode {
get {
if (insert_key_mode == InsertKeyMode.Default) {
return insert_key_overwriting;
} else {
return insert_key_mode == InsertKeyMode.Overwrite;
}
}
}
[EditorBrowsable (EditorBrowsableState.Never)]
[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
[Browsable (false)]
public new string [] Lines {
get {
string text = Text;
if (text == null || text == string.Empty)
return new string [] {};
return Text.Split (new string [] {"\r\n", "\r", "\n"}, StringSplitOptions.None);
}
set {
// Do nothing, not supported by MTB.
}
}
[Localizable (true)]
[Editor ("System.Windows.Forms.Design.MaskPropertyEditor, " + Consts.AssemblySystem_Design, typeof (UITypeEditor))]
[RefreshProperties (RefreshProperties.Repaint)]
[MergablePropertyAttribute (false)]
[DefaultValue ("")]
public string Mask {
get {
if (is_empty_mask)
return string.Empty;
return provider.Mask;
}
set {
is_empty_mask = (value == string.Empty || value == null);
if (is_empty_mask) {
value = "<>";
}
provider = new MaskedTextProvider (value, provider.Culture, provider.AllowPromptAsInput, provider.PromptChar, provider.PasswordChar, provider.AsciiOnly);
ReCalculatePasswordChar ();
UpdateVisibleText ();
}
}
[Browsable (false)]
public bool MaskCompleted {
get {
return provider.MaskCompleted;
}
}
[Browsable (false)]
[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
public MaskedTextProvider MaskedTextProvider {
get {
if (is_empty_mask)
return null;
return provider.Clone () as MaskedTextProvider;
}
}
[Browsable (false)]
public bool MaskFull {
get {
return provider.MaskFull;
}
}
[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
[Browsable (false)]
[EditorBrowsable (EditorBrowsableState.Never)]
public override int MaxLength {
get {
return base.MaxLength;
}
set {
// Do nothing, MTB doesn't support this.
}
}
[EditorBrowsable (EditorBrowsableState.Never)]
[Browsable (false)]
[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
public override bool Multiline {
get {
return false;
}
set {
// Do nothing, MTB doesn't support this.
}
}
[RefreshProperties (RefreshProperties.Repaint)]
[DefaultValue ('\0')]
public char PasswordChar {
get {
if (use_system_password_char)
return '*';
return provider.PasswordChar;
}
set {
provider.PasswordChar = value;
if (value != '\0') {
provider.IsPassword = true;
} else
provider.IsPassword = false;
ReCalculatePasswordChar (true);
CalculateDocument ();
UpdateVisibleText ();
}
}
[Localizable (true)]
[DefaultValue ('_')]
[RefreshProperties (RefreshProperties.Repaint)]
public char PromptChar {
get {
return provider.PromptChar;
}
set {
provider.PromptChar = value;
UpdateVisibleText ();
}
}
public new bool ReadOnly {
get {
return base.ReadOnly;
}
set {
base.ReadOnly = value;
}
}
[DefaultValue (false)]
public bool RejectInputOnFirstFailure {
get {
return reject_input_on_first_failure;
}
set {
reject_input_on_first_failure = value;
}
}
[DefaultValue (true)]
public bool ResetOnPrompt {
get {
return provider.ResetOnPrompt;
}
set {
provider.ResetOnPrompt = value;
}
}
[DefaultValue (true)]
public bool ResetOnSpace {
get {
return provider.ResetOnSpace;
}
set {
provider.ResetOnSpace = value;
}
}
public override string SelectedText {
get {
return base.SelectedText;
}
set {
base.SelectedText = value;
UpdateVisibleText ();
}
}
[DefaultValue (true)]
public bool SkipLiterals {
get {
return provider.SkipLiterals;
}
set {
provider.SkipLiterals = value;
}
}
[Bindable (true)]
[Editor ("System.Windows.Forms.Design.MaskedTextBoxTextEditor, " + Consts.AssemblySystem_Design, typeof (UITypeEditor))]
[Localizable (true)]
[RefreshProperties (RefreshProperties.Repaint)]
[DefaultValue ("")]
public override string Text {
get {
if (is_empty_mask || setting_text)
return base.Text;
// The base constructor may call Text before we get to create a provider,
// so it may be null even though it's not an empty mask.
if (provider == null)
return string.Empty;
return provider.ToString ();
}
set {
if (is_empty_mask) {
setting_text = true;
base.Text = value;
setting_text = false;
} else {
InputText (value);
}
UpdateVisibleText ();
}
}
[DefaultValue (HorizontalAlignment.Left)]
[Localizable (true)]
public HorizontalAlignment TextAlign {
get {
return text_align;
}
set {
if (text_align != value) {
if (!Enum.IsDefined (typeof (HorizontalAlignment), value)) {
throw new InvalidEnumArgumentException ("value", (int) value, typeof (HorizontalAlignment));
}
text_align = value;
OnTextAlignChanged (EventArgs.Empty);
}
}
}
[Browsable (false)]
public override int TextLength {
get {
return Text.Length;
}
}
[DefaultValue (MaskFormat.IncludeLiterals)]
[RefreshProperties (RefreshProperties.Repaint)]
public MaskFormat TextMaskFormat {
get {
if (provider.IncludePrompt && provider.IncludeLiterals) {
return MaskFormat.IncludePromptAndLiterals;
} else if (provider.IncludeLiterals) {
return MaskFormat.IncludeLiterals;
} else if (provider.IncludePrompt) {
return MaskFormat.IncludePrompt;
} else {
return MaskFormat.ExcludePromptAndLiterals;
}
}
set {
if (!Enum.IsDefined (typeof (MaskFormat), value)) {
throw new InvalidEnumArgumentException ("value", (int)value, typeof (MaskFormat));
}
provider.IncludeLiterals = (value & MaskFormat.IncludeLiterals) == MaskFormat.IncludeLiterals;
provider.IncludePrompt = (value & MaskFormat.IncludePrompt) == MaskFormat.IncludePrompt;
}
}
[DefaultValue (false)]
[RefreshProperties (RefreshProperties.Repaint)]
public bool UseSystemPasswordChar {
get {
return use_system_password_char;
}
set {
if (use_system_password_char != value) {
use_system_password_char = value;
if (use_system_password_char)
PasswordChar = PasswordChar;
else
PasswordChar = '\0';
}
}
}
[DefaultValue (null)]
[Browsable (false)]
public Type ValidatingType {
get {
return validating_type;
}
set {
validating_type = value;
}
}
[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
[Browsable (false)]
[EditorBrowsable (EditorBrowsableState.Never)]
public new bool WordWrap {
get {
return false;
}
set {
// Do nothing, not supported by MTB
}
}
#endregion
#region Internal and private members
private void ReCalculatePasswordChar ()
{
ReCalculatePasswordChar (PasswordChar != '\0');
}
private void ReCalculatePasswordChar (bool using_password)
{
if (using_password)
if (is_empty_mask)
document.PasswordChar = PasswordChar.ToString ();
else
document.PasswordChar = string.Empty;
}
internal override void OnPaintInternal (PaintEventArgs pevent)
{
base.OnPaintInternal (pevent);
//pevent.Graphics.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (BackColor), ClientRectangle);
//TextRenderer.DrawText (pevent.Graphics, Text, Font, ClientRectangle, ForeColor, TextFormatFlags.SingleLine);
//pevent.Handled = true;
}
internal override Color ChangeBackColor (Color backColor)
{
return backColor;
}
private void UpdateVisibleText ()
{
string text = null;
if (is_empty_mask || setting_text)
text = base.Text;
else
if (provider == null)
text = string.Empty;
else
text = provider.ToDisplayString ();
setting_text = true;
if (base.Text != text) {
int selstart = SelectionStart;
base.Text = text;
SelectionStart = selstart;
}
setting_text = false;
}
private void InputText (string text)
{
string input = text;
int testPosition;
MaskedTextResultHint resultHint;
bool result;
if (RejectInputOnFirstFailure) {
result = provider.Set (input, out testPosition, out resultHint);
if (!result)
OnMaskInputRejected (new MaskInputRejectedEventArgs (testPosition, resultHint));
} else {
provider.Clear ();
testPosition = 0;
// Unfortunately we can't break if we reach the end of the mask, since
// .net iterates over _all_ the chars in the input
for (int i = 0; i < input.Length; i++) {
char c = input [i];
result = provider.InsertAt (c, testPosition, out testPosition, out resultHint);
if (result)
testPosition++; // Move to the next free position
else
OnMaskInputRejected (new MaskInputRejectedEventArgs (testPosition, resultHint));
}
}
}
#endregion
}
}
#endif
|