mcs/class/System.Windows.Forms/System.Windows.Forms/MaskedTextBox.cs

   1 //
   2 // MaskedTextBox.cs
   3 //
   4 // Permission is hereby granted, free of charge, to any person obtaining
   5 // a copy of this software and associated documentation files (the
   6 // "Software"), to deal in the Software without restriction, including
   7 // without limitation the rights to use, copy, modify, merge, publish,
   8 // distribute, sublicense, and/or sell copies of the Software, and to
   9 // permit persons to whom the Software is furnished to do so, subject to
  10 // the following conditions:
  11 //
  12 // The above copyright notice and this permission notice shall be
  13 // included in all copies or substantial portions of the Software.
  14 //
  15 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  19 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  20 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  21 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  22 //
  23 // Copyright (c) 2007 Novell, Inc.
  24 //
  25 // Authors:
  26 //      Rolf Bjarne Kvinge (RKvinge@novell.com)
  27 //
  28
  29
  30 using System;
  31 using System.Collections;
  32 using System.ComponentModel;
  33 using System.Drawing;
  34 using System.Drawing.Design;
  35 using System.Globalization;
  36 using System.Runtime.InteropServices;
  37 using System.Security.Permissions;
  38 using System.Windows.Forms;
  39
  40 namespace System.Windows.Forms
  41 {
  42         [ClassInterface (ClassInterfaceType.AutoDispatch)]
  43         [ComVisible (true)]
  44         [DefaultProperty ("Mask")]
  45         [DefaultEvent ("MaskInputRejected")]
  46         [Designer ("System.Windows.Forms.Design.MaskedTextBoxDesigner, " + Consts.AssemblySystem_Design)]
  47         [DefaultBindingProperty ("Text")]
  48         public class MaskedTextBox : TextBoxBase
  49         {
  50 #region Locals
  51                 private MaskedTextProvider provider;
  52                 private bool beep_on_error;
  53                 private IFormatProvider format_provider;
  54                 private bool hide_prompt_on_leave;
  55                 private InsertKeyMode insert_key_mode;
  56                 private bool insert_key_overwriting;
  57                 private bool reject_input_on_first_failure;
  58                 private HorizontalAlignment text_align;
  59                 private MaskFormat cut_copy_mask_format;
  60                 private bool use_system_password_char;
  61                 private Type validating_type;
  62                 private bool is_empty_mask;
  63                 private bool setting_text;
  64 #endregion
  65
  66 #region Events
  67                 static object AcceptsTabChangedEvent = new object ();
  68                 static object IsOverwriteModeChangedEvent = new object ();
  69                 static object MaskChangedEvent = new object ();
  70                 static object MaskInputRejectedEvent = new object ();
  71                 static object MultilineChangedEvent = new object ();
  72                 static object TextAlignChangedEvent = new object ();
  73                 static object TypeValidationCompletedEvent = new object ();
  74
  75                 // This event is never raised by MaskedTextBox.
  76                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
  77                 [Browsable (false)]
  78                 [EditorBrowsable (EditorBrowsableState.Never)]
  79                 public new event EventHandler AcceptsTabChanged {
  80                         add { Events.AddHandler (AcceptsTabChangedEvent, value);}
  81                         remove { Events.RemoveHandler (AcceptsTabChangedEvent, value);}
  82                 }
  83
  84                 public event EventHandler IsOverwriteModeChanged {
  85                         add { Events.AddHandler (IsOverwriteModeChangedEvent, value); }
  86                         remove { Events.RemoveHandler (IsOverwriteModeChangedEvent, value); }
  87                 }
  88
  89                 public event EventHandler MaskChanged {
  90                         add { Events.AddHandler (MaskChangedEvent, value); }
  91                         remove { Events.RemoveHandler (MaskChangedEvent, value); }
  92                 }
  93
  94                 public event MaskInputRejectedEventHandler MaskInputRejected {
  95                         add { Events.AddHandler (MaskInputRejectedEvent, value); }
  96                         remove { Events.RemoveHandler (MaskInputRejectedEvent, value); }
  97                 }
  98
  99                 // This event is never raised by MaskedTextBox.
 100                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 101                 [Browsable (false)]
 102                 [EditorBrowsable (EditorBrowsableState.Never)]
 103                 public new event EventHandler MultilineChanged {
 104                         add { Events.AddHandler (MultilineChangedEvent, value); }
 105                         remove { Events.RemoveHandler (MultilineChangedEvent, value); }
 106                 }
 107
 108                 public event EventHandler TextAlignChanged {
 109                         add { Events.AddHandler (TextAlignChangedEvent, value); }
 110                         remove { Events.RemoveHandler (TextAlignChangedEvent, value); }
 111                 }
 112
 113                 public event TypeValidationEventHandler TypeValidationCompleted {
 114                         add { Events.AddHandler (TypeValidationCompletedEvent, value); }
 115                         remove { Events.RemoveHandler (TypeValidationCompletedEvent, value); }
 116                 }
 117 #endregion
 118
 119 #region Constructors
 120                 public MaskedTextBox ()
 121                 {
 122                         provider = new MaskedTextProvider ("<>", CultureInfo.CurrentCulture);
 123                         is_empty_mask = true;
 124                         Init ();
 125                 }
 126
 127                 public MaskedTextBox (MaskedTextProvider maskedTextProvider)
 128                 {
 129                         if (maskedTextProvider == null) {
 130                                 throw new ArgumentNullException ();
 131                         }
 132                         provider = maskedTextProvider;
 133                         is_empty_mask = false;
 134                         Init ();
 135                 }
 136
 137                 public MaskedTextBox (string mask)
 138                 {
 139                         if (mask == null) {
 140                                 throw new ArgumentNullException ();
 141                         }
 142                         provider = new MaskedTextProvider (mask, CultureInfo.CurrentCulture);
 143                         is_empty_mask = false;
 144                         Init ();
 145                 }
 146
 147                 private void Init ()
 148                 {
 149                         BackColor = SystemColors.Window;
 150                         cut_copy_mask_format = MaskFormat.IncludeLiterals;
 151                         insert_key_overwriting = false;
 152                         UpdateVisibleText ();
 153                 }
 154 #endregion
 155
 156 #region Public and protected methods
 157                 [EditorBrowsable (EditorBrowsableState.Never)]
 158                 public new void ClearUndo ()
 159                 {
 160                         // Do nothing, not supported by MTB
 161                 }
 162
 163                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 164                 [UIPermission (SecurityAction.InheritanceDemand, Window = UIPermissionWindow.AllWindows)]
 165                 protected override void CreateHandle ()
 166                 {
 167                         base.CreateHandle ();
 168                 }
 169
 170                 public override char GetCharFromPosition (Point pt)
 171                 {
 172                         return base.GetCharFromPosition (pt);
 173                 }
 174
 175                 public override int GetCharIndexFromPosition (Point pt)
 176                 {
 177                         return base.GetCharIndexFromPosition (pt);
 178                 }
 179
 180                 [EditorBrowsable (EditorBrowsableState.Never)]
 181                 public new int GetFirstCharIndexFromLine (int lineNumber)
 182                 {
 183                         return 0;
 184                 }
 185
 186                 [EditorBrowsable (EditorBrowsableState.Never)]
 187                 public new int GetFirstCharIndexOfCurrentLine ()
 188                 {
 189                         return 0;
 190                 }
 191
 192                 [EditorBrowsable (EditorBrowsableState.Never)]
 193                 public override int GetLineFromCharIndex (int index)
 194                 {
 195                         return 0;
 196                 }
 197
 198                 public override Point GetPositionFromCharIndex (int index)
 199                 {
 200                         return base.GetPositionFromCharIndex (index);
 201                 }
 202
 203                 protected override bool IsInputKey (Keys keyData)
 204                 {
 205                         return base.IsInputKey (keyData);
 206                 }
 207
 208                 protected override void OnBackColorChanged (EventArgs e)
 209                 {
 210                         base.OnBackColorChanged (e);
 211                 }
 212
 213                 protected override void OnHandleCreated (EventArgs e)
 214                 {
 215                         base.OnHandleCreated (e);
 216                 }
 217
 218                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 219                 protected virtual void OnIsOverwriteModeChanged (EventArgs e)
 220                 {
 221                         EventHandler eh = (EventHandler) Events [IsOverwriteModeChangedEvent];
 222                         if (eh != null)
 223                                 eh (this, e);
 224                 }
 225
 226                 protected override void OnKeyDown (KeyEventArgs e)
 227                 {
 228                         // Only handle Delete or Insert here
 229
 230                         if (e.KeyCode == Keys.Insert && insert_key_mode == InsertKeyMode.Default) {
 231                                 // switch the internal overwriting mode, not the public one
 232                                 insert_key_overwriting = !insert_key_overwriting;
 233                                 OnIsOverwriteModeChanged (EventArgs.Empty);
 234                                 e.Handled = true;
 235                                 return;
 236                         }
 237
 238                         if (e.KeyCode != Keys.Delete || is_empty_mask) {
 239                                 base.OnKeyDown (e);
 240                                 return;
 241                         }
 242
 243                         int testPosition, endSelection;
 244                         MaskedTextResultHint resultHint;
 245                         bool result;
 246
 247                         // Use a slightly different approach than the one used for backspace
 248                         endSelection = SelectionLength == 0 ? SelectionStart : SelectionStart + SelectionLength - 1;
 249                         result = provider.RemoveAt (SelectionStart, endSelection, out testPosition, out resultHint);
 250
 251                         PostprocessKeyboardInput (result, testPosition, testPosition, resultHint);
 252
 253                         e.Handled = true;
 254                 }
 255
 256                 protected override void OnKeyPress (KeyPressEventArgs e)
 257                 {
 258                         if (is_empty_mask) {
 259                                 base.OnKeyPress (e);
 260                                 return;
 261                         }
 262
 263                         int testPosition, editPosition;
 264                         MaskedTextResultHint resultHint;
 265                         bool result;
 266
 267                         if (e.KeyChar == '\b') {
 268                                 if (SelectionLength == 0)
 269                                         result = provider.RemoveAt (SelectionStart - 1, SelectionStart - 1, out testPosition, out resultHint);
 270                                 else
 271                                         result = provider.RemoveAt (SelectionStart, SelectionStart + SelectionLength - 1, out testPosition, out resultHint);
 272
 273                                 editPosition = testPosition;
 274                         } else if (IsOverwriteMode || SelectionLength > 0) { // Replace
 275                                 int start = provider.FindEditPositionFrom (SelectionStart, true);
 276                                 int end = SelectionLength > 0 ? SelectionStart + SelectionLength - 1 : start;
 277                                 result = provider.Replace (e.KeyChar, start, end, out testPosition, out resultHint);
 278
 279                                 editPosition = testPosition + 1;
 280                         } else {
 281                                 // Move chars to the right
 282                                 result = provider.InsertAt (e.KeyChar, SelectionStart, out testPosition, out resultHint);
 283                                 editPosition = testPosition + 1;
 284                         }
 285
 286                         PostprocessKeyboardInput (result, editPosition, testPosition, resultHint);
 287
 288                         e.Handled = true;
 289                 }
 290
 291                 void PostprocessKeyboardInput (bool result, int newPosition, int testPosition, MaskedTextResultHint resultHint)
 292                 {
 293                         if (!result)
 294                                 OnMaskInputRejected (new MaskInputRejectedEventArgs (testPosition, resultHint));
 295                         else {
 296                                 if (newPosition != MaskedTextProvider.InvalidIndex)
 297                                         SelectionStart = newPosition;
 298                                 else
 299                                         SelectionStart = provider.Length;
 300
 301                                 UpdateVisibleText ();
 302                         }
 303                 }
 304
 305                 protected override void OnKeyUp (KeyEventArgs e)
 306                 {
 307                         base.OnKeyUp (e);
 308                 }
 309
 310                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 311                 protected virtual void OnMaskChanged (EventArgs e)
 312                 {
 313                         EventHandler eh = (EventHandler) Events [MaskChangedEvent];
 314                         if (eh != null)
 315                                 eh (this, e);
 316                 }
 317
 318                 private void OnMaskInputRejected (MaskInputRejectedEventArgs e)
 319                 {
 320                         MaskInputRejectedEventHandler eh = (MaskInputRejectedEventHandler) Events [MaskInputRejectedEvent];
 321                         if (eh != null)
 322                                 eh (this, e);
 323                 }
 324
 325                 [EditorBrowsable (EditorBrowsableState.Never)]
 326                 protected override void OnMultilineChanged (EventArgs e)
 327                 {
 328                         EventHandler eh = (EventHandler)Events [MultilineChangedEvent];
 329                         if (eh != null)
 330                                 eh (this, e);
 331                 }
 332
 333                 protected virtual void OnTextAlignChanged (EventArgs e)
 334                 {
 335                         EventHandler eh = (EventHandler)Events [TextAlignChangedEvent];
 336                         if (eh != null)
 337                                 eh (this, e);
 338                 }
 339
 340                 protected override void OnTextChanged (EventArgs e)
 341                 {
 342                         base.OnTextChanged (e);
 343                 }
 344
 345                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 346                 protected override void OnValidating (CancelEventArgs e)
 347                 {
 348                         base.OnValidating (e);
 349                 }
 350
 351                 //[SecurityPermission (SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
 352                 protected override bool ProcessCmdKey (ref Message msg, Keys keyData)
 353                 {
 354                         return base.ProcessCmdKey (ref msg, keyData);
 355                 }
 356
 357                 //[SecurityPermission (SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
 358                 protected internal override bool ProcessKeyMessage (ref Message m)
 359                 {
 360                         return base.ProcessKeyMessage (ref m);
 361                 }
 362
 363                 [EditorBrowsable (EditorBrowsableState.Never)]
 364                 public new void ScrollToCaret ()
 365                 {
 366                         // MSDN: this method is overridden to perform no actions.
 367                 }
 368
 369                 public override string ToString ()
 370                 {
 371                         return base.ToString () + ", Text: " + provider.ToString (false, false);
 372                 }
 373
 374                 [EditorBrowsable (EditorBrowsableState.Never)]
 375                 public new void Undo ()
 376                 {
 377                         // Do nothing, not supported by MTB.
 378                 }
 379
 380                 public object ValidateText ()
 381                 {
 382                         throw new NotImplementedException ();
 383                 }
 384
 385                 //[SecurityPermission (SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
 386                 protected override void WndProc (ref Message m)
 387                 {
 388                         switch ((Msg) m.Msg) {
 389                         default:
 390                                 base.WndProc (ref m);
 391                                 return;
 392                         }
 393                 }
 394 #endregion
 395
 396 #region Properties
 397                 [EditorBrowsable (EditorBrowsableState.Never)]
 398                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 399                 [Browsable (false)]
 400                 public new bool AcceptsTab {
 401                         get {
 402                                 return false;
 403                         }
 404                         set {
 405                         }
 406                 }
 407
 408                 [DefaultValue (true)]
 409                 public bool AllowPromptAsInput {
 410                         get {
 411                                 return provider.AllowPromptAsInput;
 412                         }
 413                         set {
 414                                 provider = new MaskedTextProvider (provider.Mask, provider.Culture, value, provider.PromptChar, provider.PasswordChar, provider.AsciiOnly);
 415                                 UpdateVisibleText ();
 416                         }
 417                 }
 418
 419                 [RefreshProperties (RefreshProperties.Repaint)]
 420                 [DefaultValue (false)]
 421                 public bool AsciiOnly {
 422                         get {
 423                                 return provider.AsciiOnly;
 424                         }
 425                         set {
 426                                 provider = new MaskedTextProvider (provider.Mask, provider.Culture, provider.AllowPromptAsInput, provider.PromptChar, provider.PasswordChar, value);
 427                                 UpdateVisibleText ();
 428                         }
 429                 }
 430
 431                 [DefaultValue (false)]
 432                 public bool BeepOnError {
 433                         get {
 434                                 return beep_on_error;
 435                         }
 436                         set {
 437                                 beep_on_error = value;
 438                         }
 439                 }
 440
 441                 [Browsable (false)]
 442                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 443                 [EditorBrowsable (EditorBrowsableState.Never)]
 444                 public new bool CanUndo {
 445                         get {
 446                                 return false;
 447                         }
 448                 }
 449
 450                 protected override CreateParams CreateParams {
 451                         //[SecurityPermission (SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
 452                         get {
 453                                 return base.CreateParams;
 454                         }
 455                 }
 456
 457                 [RefreshProperties (RefreshProperties.Repaint)]
 458                 public CultureInfo Culture {
 459                         get {
 460                                 return provider.Culture;
 461                         }
 462                         set {
 463                                 provider = new MaskedTextProvider (provider.Mask, value, provider.AllowPromptAsInput, provider.PromptChar, provider.PasswordChar, provider.AsciiOnly);
 464                                 UpdateVisibleText ();
 465                         }
 466                 }
 467
 468                 [RefreshProperties (RefreshProperties.Repaint)]
 469                 [DefaultValue (MaskFormat.IncludeLiterals)]
 470                 public MaskFormat CutCopyMaskFormat {
 471                         get {
 472                                 return cut_copy_mask_format;
 473                         }
 474                         set {
 475                                 if (!Enum.IsDefined (typeof (MaskFormat), value)) {
 476                                         throw new InvalidEnumArgumentException ("value", (int)value, typeof (MaskFormat));
 477                                 }
 478                                 cut_copy_mask_format = value;
 479                         }
 480                 }
 481
 482                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 483                 [Browsable (false)]
 484                 public IFormatProvider FormatProvider {
 485                         get {
 486                                 return format_provider;
 487                         }
 488                         set {
 489                                 format_provider = value;
 490                         }
 491                 }
 492
 493                 [RefreshProperties (RefreshProperties.Repaint)]
 494                 [DefaultValue (false)]
 495                 public bool HidePromptOnLeave {
 496                         get {
 497                                 return hide_prompt_on_leave;
 498                         }
 499                         set {
 500                                 hide_prompt_on_leave = value;
 501                         }
 502                 }
 503
 504                 [DefaultValue (InsertKeyMode.Default)]
 505                 public InsertKeyMode InsertKeyMode {
 506                         get {
 507                                 return insert_key_mode;
 508                         }
 509                         set {
 510                                 if (!Enum.IsDefined (typeof (InsertKeyMode), value)) {
 511                                         throw new InvalidEnumArgumentException ("value", (int)value, typeof (InsertKeyMode));
 512                                 }
 513                                 insert_key_mode = value;
 514                         }
 515                 }
 516
 517                 [Browsable (false)]
 518                 public bool IsOverwriteMode {
 519                         get {
 520                                 if (insert_key_mode == InsertKeyMode.Default) {
 521                                         return insert_key_overwriting;
 522                                 } else {
 523                                         return insert_key_mode == InsertKeyMode.Overwrite;
 524                                 }
 525                         }
 526                 }
 527
 528                 [EditorBrowsable (EditorBrowsableState.Never)]
 529                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 530                 [Browsable (false)]
 531                 public new string [] Lines {
 532                         get {
 533                                 string text = Text;
 534                                 if (text == null || text == string.Empty)
 535                                         return new string [] {};
 536
 537                                 return Text.Split (new string [] {"\r\n", "\r", "\n"}, StringSplitOptions.None);
 538                         }
 539                         set {
 540                                 // Do nothing, not supported by MTB.
 541                         }
 542                 }
 543
 544                 [Localizable (true)]
 545                 [Editor ("System.Windows.Forms.Design.MaskPropertyEditor, " + Consts.AssemblySystem_Design, typeof (UITypeEditor))]
 546                 [RefreshProperties (RefreshProperties.Repaint)]
 547                 [MergablePropertyAttribute (false)]
 548                 [DefaultValue ("")]
 549                 public string Mask {
 550                         get {
 551                                 if (is_empty_mask)
 552                                         return string.Empty;
 553
 554                                 return provider.Mask;
 555                         }
 556                         set {
 557                                 is_empty_mask = (value == string.Empty || value == null);
 558                                 if (is_empty_mask) {
 559                                         value = "<>";
 560                                 }
 561
 562                                 provider = new MaskedTextProvider (value, provider.Culture, provider.AllowPromptAsInput, provider.PromptChar, provider.PasswordChar, provider.AsciiOnly);
 563                                 ReCalculatePasswordChar ();
 564                                 UpdateVisibleText ();
 565                         }
 566                 }
 567
 568                 [Browsable (false)]
 569                 public bool MaskCompleted {
 570                         get {
 571                                 return provider.MaskCompleted;
 572                         }
 573                 }
 574
 575                 [Browsable (false)]
 576                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 577                 public MaskedTextProvider MaskedTextProvider {
 578                         get {
 579                                 if (is_empty_mask)
 580                                         return null;
 581
 582                                 return provider.Clone () as MaskedTextProvider;
 583                         }
 584                 }
 585
 586                 [Browsable (false)]
 587                 public bool MaskFull {
 588                         get {
 589                                 return provider.MaskFull;
 590                         }
 591                 }
 592
 593                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 594                 [Browsable (false)]
 595                 [EditorBrowsable (EditorBrowsableState.Never)]
 596                 public override int MaxLength {
 597                         get {
 598                                 return base.MaxLength;
 599                         }
 600                         set {
 601                                 // Do nothing, MTB doesn't support this.
 602                         }
 603                 }
 604
 605                 [EditorBrowsable (EditorBrowsableState.Never)]
 606                 [Browsable (false)]
 607                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 608                 public override bool Multiline {
 609                         get {
 610                                 return false;
 611                         }
 612                         set {
 613                                 // Do nothing, MTB doesn't support this.
 614                         }
 615                 }
 616
 617                 [RefreshProperties (RefreshProperties.Repaint)]
 618                 [DefaultValue ('\0')]
 619                 public char PasswordChar {
 620                         get {
 621                                 if (use_system_password_char)
 622                                         return '*';
 623
 624                                 return provider.PasswordChar;
 625                         }
 626                         set {
 627                                 provider.PasswordChar = value;
 628
 629                                 if (value != '\0') {
 630                                         provider.IsPassword = true;
 631                                 } else
 632                                         provider.IsPassword = false;
 633
 634                                 ReCalculatePasswordChar (true);
 635                                 CalculateDocument ();
 636
 637                                 UpdateVisibleText ();
 638                         }
 639                 }
 640
 641                 [Localizable (true)]
 642                 [DefaultValue ('_')]
 643                 [RefreshProperties (RefreshProperties.Repaint)]
 644                 public char PromptChar {
 645                         get {
 646                                 return provider.PromptChar;
 647                         }
 648                         set {
 649                                 provider.PromptChar = value;
 650                                 UpdateVisibleText ();
 651                         }
 652                 }
 653
 654                 public new bool ReadOnly {
 655                         get {
 656                                 return base.ReadOnly;
 657                         }
 658                         set {
 659                                 base.ReadOnly = value;
 660                         }
 661                 }
 662
 663                 [DefaultValue (false)]
 664                 public bool RejectInputOnFirstFailure {
 665                         get {
 666                                 return reject_input_on_first_failure;
 667                         }
 668                         set {
 669                                 reject_input_on_first_failure = value;
 670                         }
 671                 }
 672
 673                 [DefaultValue (true)]
 674                 public bool ResetOnPrompt {
 675                         get {
 676                                 return provider.ResetOnPrompt;
 677                         }
 678                         set {
 679                                 provider.ResetOnPrompt = value;
 680                         }
 681                 }
 682
 683                 [DefaultValue (true)]
 684                 public bool ResetOnSpace {
 685                         get {
 686                                 return provider.ResetOnSpace;
 687                         }
 688                         set {
 689                                 provider.ResetOnSpace = value;
 690                         }
 691                 }
 692
 693                 public override string SelectedText {
 694                         get {
 695                                 return base.SelectedText;
 696                         }
 697                         set {
 698                                 base.SelectedText = value;
 699                                 UpdateVisibleText ();
 700                         }
 701                 }
 702
 703                 [DefaultValue (true)]
 704                 public bool SkipLiterals {
 705                         get {
 706                                 return provider.SkipLiterals;
 707                         }
 708                         set {
 709                                 provider.SkipLiterals = value;
 710                         }
 711                 }
 712
 713                 [Bindable (true)]
 714                 [Editor ("System.Windows.Forms.Design.MaskedTextBoxTextEditor, " + Consts.AssemblySystem_Design, typeof (UITypeEditor))]
 715                 [Localizable (true)]
 716                 [RefreshProperties (RefreshProperties.Repaint)]
 717                 [DefaultValue ("")]
 718                 public override string Text {
 719                         get {
 720                                 if (is_empty_mask || setting_text)
 721                                         return base.Text;
 722
 723                                 // The base constructor may call Text before we get to create a provider,
 724                                 // so it may be null even though it's not an empty mask.
 725                                 if (provider == null)
 726                                         return string.Empty;
 727
 728                                 return provider.ToString ();
 729                         }
 730                         set {
 731
 732                                 if (is_empty_mask) {
 733                                         setting_text = true;
 734                                         base.Text = value;
 735                                         setting_text = false;
 736                                 } else {
 737                                         InputText (value);
 738                                 }
 739                                 UpdateVisibleText ();
 740                         }
 741                 }
 742
 743                 [DefaultValue (HorizontalAlignment.Left)]
 744                 [Localizable (true)]
 745                 public HorizontalAlignment TextAlign {
 746                         get {
 747                                 return text_align;
 748                         }
 749                         set {
 750                                 if (text_align != value) {
 751                                         if (!Enum.IsDefined (typeof (HorizontalAlignment), value)) {
 752                                                 throw new InvalidEnumArgumentException ("value", (int) value, typeof (HorizontalAlignment));
 753                                         }
 754                                         text_align = value;
 755                                         OnTextAlignChanged (EventArgs.Empty);
 756                                 }
 757                         }
 758                 }
 759
 760                 [Browsable (false)]
 761                 public override int TextLength {
 762                         get {
 763                                 return Text.Length;
 764                         }
 765                 }
 766
 767                 [DefaultValue (MaskFormat.IncludeLiterals)]
 768                 [RefreshProperties (RefreshProperties.Repaint)]
 769                 public MaskFormat TextMaskFormat {
 770                         get {
 771                                 if (provider.IncludePrompt && provider.IncludeLiterals) {
 772                                         return MaskFormat.IncludePromptAndLiterals;
 773                                 } else if (provider.IncludeLiterals) {
 774                                         return MaskFormat.IncludeLiterals;
 775                                 } else if (provider.IncludePrompt) {
 776                                         return MaskFormat.IncludePrompt;
 777                                 } else {
 778                                         return MaskFormat.ExcludePromptAndLiterals;
 779                                 }
 780                         }
 781                         set {
 782                                 if (!Enum.IsDefined (typeof (MaskFormat), value)) {
 783                                         throw new InvalidEnumArgumentException ("value", (int)value, typeof (MaskFormat));
 784                                 }
 785
 786                                 provider.IncludeLiterals = (value & MaskFormat.IncludeLiterals) == MaskFormat.IncludeLiterals;
 787                                 provider.IncludePrompt = (value & MaskFormat.IncludePrompt) == MaskFormat.IncludePrompt;
 788                         }
 789                 }
 790
 791                 [DefaultValue (false)]
 792                 [RefreshProperties (RefreshProperties.Repaint)]
 793                 public bool UseSystemPasswordChar {
 794                         get {
 795                                 return use_system_password_char;
 796                         }
 797                         set {
 798                                 if (use_system_password_char != value) {
 799                                         use_system_password_char = value;
 800
 801                                         if (use_system_password_char)
 802                                                 PasswordChar = PasswordChar;
 803                                         else
 804                                                 PasswordChar = '\0';
 805                                 }
 806                         }
 807                 }
 808
 809                 [DefaultValue (null)]
 810                 [Browsable (false)]
 811                 public Type ValidatingType {
 812                         get {
 813                                 return validating_type;
 814                         }
 815                         set {
 816                                 validating_type = value;
 817                         }
 818                 }
 819                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 820                 [Browsable (false)]
 821                 [EditorBrowsable (EditorBrowsableState.Never)]
 822                 public new bool WordWrap {
 823                         get {
 824                                 return false;
 825                         }
 826                         set {
 827                                 // Do nothing, not supported by MTB
 828                         }
 829                 }
 830 #endregion
 831 #region Internal and private members
 832
 833                 private void ReCalculatePasswordChar ()
 834                 {
 835                         ReCalculatePasswordChar (PasswordChar != '\0');
 836                 }
 837
 838                 private void ReCalculatePasswordChar (bool using_password)
 839                 {
 840                         if (using_password)
 841                                 if (is_empty_mask)
 842                                         document.PasswordChar = PasswordChar.ToString ();
 843                                 else
 844                                         document.PasswordChar = string.Empty;
 845                 }
 846
 847                 internal override void OnPaintInternal (PaintEventArgs pevent)
 848                 {
 849                         base.OnPaintInternal (pevent);
 850                         //pevent.Graphics.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (BackColor), ClientRectangle);
 851                         //TextRenderer.DrawText (pevent.Graphics, Text, Font, ClientRectangle, ForeColor, TextFormatFlags.SingleLine);
 852                         //pevent.Handled = true;
 853                 }
 854
 855                 internal override Color ChangeBackColor (Color backColor)
 856                 {
 857                         return backColor;
 858                 }
 859
 860                 private void UpdateVisibleText ()
 861                 {
 862                         string text = null;
 863
 864                         if (is_empty_mask || setting_text)
 865                                 text = base.Text;
 866                         else
 867                                 if (provider == null)
 868                                         text = string.Empty;
 869                                 else
 870                                         text = provider.ToDisplayString ();
 871
 872                         setting_text = true;
 873                         if (base.Text != text) {
 874                                 int selstart = SelectionStart;
 875                                 base.Text = text;
 876                                 SelectionStart = selstart;
 877                         }
 878                         setting_text = false;
 879                 }
 880
 881                 private void InputText (string text)
 882                 {
 883                         string input = text;
 884
 885                         int testPosition;
 886                         MaskedTextResultHint resultHint;
 887                         bool result;
 888
 889                         if (RejectInputOnFirstFailure) {
 890                                 result = provider.Set (input, out testPosition, out resultHint);
 891                                 if (!result)
 892                                         OnMaskInputRejected (new MaskInputRejectedEventArgs (testPosition, resultHint));
 893                         } else {
 894                                 provider.Clear ();
 895                                 testPosition = 0;
 896
 897                                 // Unfortunately we can't break if we reach the end of the mask, since
 898                                 // .net iterates over _all_ the chars in the input
 899                                 for (int i = 0; i < input.Length; i++) {
 900                                         char c = input [i];
 901
 902                                         result = provider.InsertAt (c, testPosition, out testPosition, out resultHint);
 903                                         if (result)
 904                                                 testPosition++; // Move to the next free position
 905                                         else
 906                                                 OnMaskInputRejected (new MaskInputRejectedEventArgs (testPosition, resultHint));
 907                                 }
 908                         }
 909                 }
 910 #endregion
 911         }
 912 }