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