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