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