private static object CoerceText(DependencyObject d, object value)
 {
     MaskedTextBox textBox = (MaskedTextBox)d;
     MaskedTextProvider maskProvider = new MaskedTextProvider(textBox.Mask);
     maskProvider.Set((string)value);
     return maskProvider.ToDisplayString();            
 }

        public static string Formatar(string valor, string mascara)
        {
            MaskedTextProvider mtpCnpj = new MaskedTextProvider(mascara);
            mtpCnpj.Set(valor);
            var formatted = mtpCnpj.ToString();
            if (formatted.IndexOf(" ") == -1) return formatted;

            mascara = mascara.Replace("0", "#").Replace(@"\", "");

            StringBuilder dado = new StringBuilder();
            foreach (char c in valor)
            {
                if (Char.IsNumber(c) || c == 'x' || c == 'X')
                    dado.Append(c);
            }

            int indMascara = mascara.Length;
            int indCampo = dado.Length;
            for (; indCampo > 0 && indMascara > 0; )
            {
                if (mascara[--indMascara] == '#')
                    indCampo -= 1;
            }

            StringBuilder saida = new StringBuilder();
            for (; indMascara < mascara.Length; indMascara++)
            {
                saida.Append((mascara[indMascara] == '#') ? dado[indCampo++] : mascara[indMascara]);
            }

            return saida.ToString();
        }

 public static bool IsValidMaskDescriptor(MaskDescriptor maskDescriptor, out string validationErrorDescription)
 {
     validationErrorDescription = string.Empty;
     if (maskDescriptor == null)
     {
         validationErrorDescription = System.Design.SR.GetString("MaskDescriptorNull");
         return false;
     }
     if ((string.IsNullOrEmpty(maskDescriptor.Mask) || string.IsNullOrEmpty(maskDescriptor.Name)) || string.IsNullOrEmpty(maskDescriptor.Sample))
     {
         validationErrorDescription = System.Design.SR.GetString("MaskDescriptorNullOrEmptyRequiredProperty");
         return false;
     }
     MaskedTextProvider maskedTextProvider = new MaskedTextProvider(maskDescriptor.Mask, maskDescriptor.Culture);
     MaskedTextBox box = new MaskedTextBox(maskedTextProvider) {
         SkipLiterals = true,
         ResetOnPrompt = true,
         ResetOnSpace = true,
         ValidatingType = maskDescriptor.ValidatingType,
         FormatProvider = maskDescriptor.Culture,
         Culture = maskDescriptor.Culture
     };
     box.TypeValidationCompleted += new TypeValidationEventHandler(MaskDescriptor.maskedTextBox1_TypeValidationCompleted);
     box.MaskInputRejected += new MaskInputRejectedEventHandler(MaskDescriptor.maskedTextBox1_MaskInputRejected);
     box.Text = maskDescriptor.Sample;
     if ((box.Tag == null) && (maskDescriptor.ValidatingType != null))
     {
         box.ValidateText();
     }
     if (box.Tag != null)
     {
         validationErrorDescription = box.Tag.ToString();
     }
     return (validationErrorDescription.Length == 0);
 }

		public void PasswordTest ()
		{

			MaskedTextProvider mtp = new MaskedTextProvider ("abcd", CultureInfo.GetCultureInfo ("es-AR"), false, '>', '^', false); 
			Assert.AreEqual (" bcd", mtp.ToString (), "#A1");
			
		}

 public void Clear()
 {
     base.CanRaiseFilterChanged = false;
     this.tsmiComparisionContains.PerformClick();
     this.MaskProvider = new MaskedTextProvider("aa", CultureInfo.InvariantCulture, true);
     this.tstbHex.Text = this.MaskProvider.ToDisplayString();
     base.CanRaiseFilterChanged = true;
 }

 public HexContentFilterControl()
 {
     this.components = null;
     this.InitializeComponent();
     this.InitializeToolStripItems();
     this.Clear();
     this.MaskProvider = new MaskedTextProvider("aa", CultureInfo.InvariantCulture, true);
 }

    public AutoCompletingMaskEventArgs( MaskedTextProvider maskedTextProvider, int startPosition, int selectionLength, string input )
    {
      m_autoCompleteStartPosition = -1;

      m_maskedTextProvider = maskedTextProvider;
      m_startPosition = startPosition;
      m_selectionLength = selectionLength;
      m_input = input;
    }

 /// <summary>
 /// formata o CNPJ
 /// </summary>
 /// <param name="cnpj">valor a ser formatado</param>
 /// <returns></returns>
 public static string FormatCNPJ(string cnpj)
 {
     string ret = "";
     MaskedTextProvider mascara;
     cnpj = Functions.OnlyNumbers(cnpj, "-.,/").ToString();
     //cnpj
     //##.###.###/####-##
     mascara = new MaskedTextProvider(@"00\.000\.000/0000-00");
     mascara.Set(cnpj);
     ret = mascara.ToString();
     return ret;
 }

 //force the text of the control to use the mask
 private static object ForceText(DependencyObject sender, object value)
 {
     MaskedTextBox textBox = (MaskedTextBox) sender;
     if (textBox.Mask != null)
     {
         MaskedTextProvider provider = new MaskedTextProvider(textBox.Mask);
         provider.Set((string) value);
         return provider.ToDisplayString();
     }
     else
     {
         return value;
     }
 }

		public void DefaultCultureTest ()
		{
			CultureInfo currentUI = Thread.CurrentThread.CurrentUICulture;
			CultureInfo current = Thread.CurrentThread.CurrentCulture;

			try {
				Thread.CurrentThread.CurrentUICulture = new CultureInfo ("en-US");
				Thread.CurrentThread.CurrentCulture = new CultureInfo ("es-ES");
				MaskedTextProvider mtp = new MaskedTextProvider ("mask");
				Assert.AreEqual ("es-ES", mtp.Culture.Name, "#01");
			} finally {
				Thread.CurrentThread.CurrentCulture = current;
				Thread.CurrentThread.CurrentUICulture = currentUI;
			}
		}

        private void MaskedTextBoxLoaded(object sender, RoutedEventArgs e)
        {
            _provider = new MaskedTextProvider(!string.IsNullOrEmpty(InputMask) ? InputMask : " ", CultureInfo.CurrentCulture);

            _provider.Set(String.IsNullOrWhiteSpace(UnmaskedText) ? String.Empty : UnmaskedText);

            _provider.PromptChar = PromptChar;
            Text = _provider.ToDisplayString();

            DependencyPropertyDescriptor textProp = DependencyPropertyDescriptor.FromProperty(TextProperty,
                                                                                              typeof(MaskedTextBox));
            if (textProp != null)
            {
                textProp.AddValueChanged(this, (s, args) => UpdateText());
            }
            DataObject.AddPastingHandler(this, Pasting);
        }

        /// <devdoc>
        ///     Override version to be able to perform the operation on a cloned provider.
        /// </devdoc>
        private bool PlaceChar(MaskedTextProvider provider, char ch, int startPosition, int length, bool overwrite, 
            out MaskedTextResultHint hint)
        {
            Debug.Assert( !this.flagState[IS_NULL_MASK], "This method must be called when a Mask is provided." );

            this.caretTestPos = startPosition;

            if (startPosition < this.maskedTextProvider.Length)
            {
                if (length > 0)  // Replacing selection with input char.
                {
                    int endPos = startPosition + length - 1;
                    return provider.Replace(ch, startPosition, endPos, out this.caretTestPos, out hint);
                }
                else
                {
                    if (overwrite)
                    {
                        // overwrite character at next edit position from startPosition (inclusive).
                        return provider.Replace(ch, startPosition, out this.caretTestPos, out hint);
                    }
                    else // insert.
                    {
                        return provider.InsertAt(ch, startPosition, out this.caretTestPos, out hint);
                    }
                }
            }

            hint = MaskedTextResultHint.UnavailableEditPosition;
            return false;
        }

        /// <devdoc>
        ///     Replaces the current selection in the text box specified by the startPosition and selectionLen parameters
        ///     with the contents of the supplied string.
        /// </devdoc>
        private void Replace(string text, int startPosition, int selectionLen)
        {
            Debug.Assert( !this.flagState[IS_NULL_MASK], "This method must be called when a Mask is provided." );
            Debug.Assert(text != null, "text is null.");

            // Clone the MaskedTextProvider so text properties are not modified until the paste operation is
            // completed.  This is needed in case one of these properties is retreived in a MaskedInputRejected
            // event handler (clipboard text is attempted to be set into the input text char by char).

            MaskedTextProvider clonedProvider = (MaskedTextProvider) this.maskedTextProvider.Clone();

            // Cache the current caret position so we restore it in case the text does not change. VSW#498875.
            int currentCaretPos = this.caretTestPos;

            // First replace characters in the selection (if any and if any edit positions) until completed, or the test position falls 
            // outside the selection range, or there's no more room in the test string for editable characters.
            // Then insert any remaining characters from the input.

            MaskedTextResultHint hint = MaskedTextResultHint.NoEffect;
            int endPos = startPosition + selectionLen - 1;

            if( this.RejectInputOnFirstFailure )
            {
                bool succeeded; 

                succeeded = (startPosition > endPos) ?
                    clonedProvider.InsertAt(text, startPosition, out this.caretTestPos, out hint ) :
                    clonedProvider.Replace(text, startPosition, endPos, out this.caretTestPos, out hint);

                if( !succeeded )
                {
                    OnMaskInputRejected(new MaskInputRejectedEventArgs(this.caretTestPos, hint));
                }
            }
            else
            {
                // temp hint used to preserve the 'primary' operation hint (no side effects).
                MaskedTextResultHint tempHint = hint;
                int testPos;
                
                foreach (char ch in text)
                {
                    if( !this.maskedTextProvider.VerifyEscapeChar( ch, startPosition ))  // char won't be escaped, find and edit position for it.
                    {
                        // Observe that we look for a position w/o respecting the selection length, because the input text could be larger than
                        // the number of edit positions in the selection.
                        testPos = clonedProvider.FindEditPositionFrom(startPosition, forward);

                        if( testPos == MaskedTextProvider.InvalidIndex )
                        {
                            // this will continue to execute (fail) until the end of the text so we fire the event for each remaining char.
                            OnMaskInputRejected(new MaskInputRejectedEventArgs(startPosition, MaskedTextResultHint.UnavailableEditPosition));
                            continue;
                        }

                        startPosition = testPos;
                    }

                    int length = endPos >= startPosition ? 1 : 0;

                    // if length > 0 we are (re)placing the input char in the current startPosition, otherwise we are inserting the input.
                    bool replace = length > 0;

                    if (PlaceChar(clonedProvider, ch, startPosition, length, replace, out tempHint))
                    {
                        // caretTestPos is updated in PlaceChar call.
                        startPosition = this.caretTestPos + 1;

                        // place char will insert or replace a single character so the hint must be success, and that will be the final operation
                        // result hint.
                        if (tempHint == MaskedTextResultHint.Success && hint != tempHint)
                        {
                            hint = tempHint;
                        }
                    }
                    else
                    {
                        OnMaskInputRejected(new MaskInputRejectedEventArgs(startPosition, tempHint));
                    }
                }

                if (selectionLen > 0)
                {
                    // At this point we have processed all characters from the input text (if any) but still need to 
                    // remove remaining characters from the selected text (if editable and valid chars).

                    if (startPosition <= endPos)
                    {
                        if (!clonedProvider.RemoveAt(startPosition, endPos, out this.caretTestPos, out tempHint))
                        {
                            OnMaskInputRejected(new MaskInputRejectedEventArgs(this.caretTestPos, tempHint));
                        }

                        // If 'replace' is not actually performed (maybe the input is empty which means 'remove', hint will be whatever
                        // the 'remove' operation result hint is.
                        if (hint == MaskedTextResultHint.NoEffect && hint != tempHint)
//.........这里部分代码省略.........

        /// <devdoc>
        ///     Initializes the object with the specified MaskedTextProvider object and default
        ///     property values.
        /// </devdoc>
        private void Initialize(MaskedTextProvider maskedTextProvider)
        {
            Debug.Assert(maskedTextProvider != null, "Initializing from a null MaskProvider ref.");

            this.maskedTextProvider = maskedTextProvider;

            // set the initial display text.
            if (!this.flagState[IS_NULL_MASK])
            {
                SetWindowText();
            }

            // set default values.
            this.passwordChar = this.maskedTextProvider.PasswordChar;
            this.insertMode   = InsertKeyMode.Default;

            this.flagState[HIDE_PROMPT_ON_LEAVE         ] = false;
            this.flagState[BEEP_ON_ERROR                ] = false;
            this.flagState[USE_SYSTEM_PASSWORD_CHAR     ] = false;
            this.flagState[REJECT_INPUT_ON_FIRST_FAILURE] = false;

            // CutCopyMaskFormat - set same defaults as TextMaskFormat (IncludePromptAndLiterals).
            // It is a lot easier to handle this flags individually since that's the way the MaskedTextProvider does it.
            this.flagState[CUTCOPYINCLUDEPROMPT         ] = this.maskedTextProvider.IncludePrompt;
            this.flagState[CUTCOPYINCLUDELITERALS       ] = this.maskedTextProvider.IncludeLiterals;

            // fields for internal use.
            this.flagState[HANDLE_KEY_PRESS] = true;
            this.caretTestPos           = 0; 
        }

        /// <devdoc>
        ///     Constructs the MaskedTextBox with the specified MaskedTextProvider object.
        /// </devdoc>
        public MaskedTextBox(MaskedTextProvider maskedTextProvider)
        {
            if (maskedTextProvider == null)
            {
                throw new ArgumentNullException();
            }

            this.flagState[IS_NULL_MASK] = false;
            Initialize(maskedTextProvider);
        }

        private void UpdateText(MaskedTextProvider provider, int position)
        {
            if (provider == null)
                throw new ArgumentNullException("MaskedTextProvider", "Mask cannot be null.");

            Text = provider.ToDisplayString();

            SelectionStart = position;
        }

 private MaskedTextProvider GetMaskProvider()
 {
     MaskedTextProvider maskProvider = new MaskedTextProvider(Mask);
     maskProvider.Set(Text);
     return maskProvider;
 }

		public MaskedTextBox (MaskedTextProvider maskedTextProvider)
		{
			if (maskedTextProvider == null) {
				throw new ArgumentNullException ();
			}
			provider = maskedTextProvider;
			is_empty_mask = false;
			Init ();
		}

 private void UpdateSortedListView(MaskDescriptorComparer.SortType sortType)
 {
     if (this.listViewCannedMasks.IsHandleCreated)
     {
         MaskDescriptor maskDex = null;
         if (this.listViewCannedMasks.SelectedItems.Count > 0)
         {
             int num = this.listViewCannedMasks.SelectedIndices[0];
             maskDex = this.maskDescriptors[num];
         }
         this.maskDescriptors.RemoveAt(this.maskDescriptors.Count - 1);
         this.maskDescriptors.Sort(new MaskDescriptorComparer(sortType, this.listViewSortOrder));
         System.Design.UnsafeNativeMethods.SendMessage(this.listViewCannedMasks.Handle, 11, false, 0);
         try
         {
             this.listViewCannedMasks.Items.Clear();
             string str = System.Design.SR.GetString("MaskDescriptorValidatingTypeNone");
             foreach (MaskDescriptor descriptor2 in this.maskDescriptors)
             {
                 string str2 = (descriptor2.ValidatingType != null) ? descriptor2.ValidatingType.Name : str;
                 MaskedTextProvider provider = new MaskedTextProvider(descriptor2.Mask, descriptor2.Culture);
                 provider.Add(descriptor2.Sample);
                 string str3 = provider.ToString(false, true);
                 this.listViewCannedMasks.Items.Add(new ListViewItem(new string[] { descriptor2.Name, str3, str2 }));
             }
             this.maskDescriptors.Add(this.customMaskDescriptor);
             this.listViewCannedMasks.Items.Add(new ListViewItem(new string[] { this.customMaskDescriptor.Name, "", str }));
             if (maskDex != null)
             {
                 this.SetSelectedMaskDescriptor(maskDex);
             }
         }
         finally
         {
             System.Design.UnsafeNativeMethods.SendMessage(this.listViewCannedMasks.Handle, 11, true, 0);
             this.listViewCannedMasks.Invalidate();
         }
     }
 }

        private void ResolveMaskProvider(string mask)
        {
            //do not create a mask provider if the Mask is empty, which can occur if the IncludePrompt and IncludeLiterals properties
            //are set prior to the Mask.
            if (String.IsNullOrEmpty(mask))
                return;

            MaskProvider = new MaskedTextProvider(mask)
            {
                IncludePrompt = this.IncludePrompt,
                IncludeLiterals = this.IncludeLiterals,
                PromptChar = this.PromptChar
            };
        }