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; } }
public HexContentFilterControl(HexContentFilter filter) { this.components = null; if (filter == null) { throw new ArgumentNullException("filter"); } this.InitializeComponent(); this.InitializeToolStripItems(); base.CanRaiseFilterChanged = false; CustomFilterControl.PerformDropDownClick(this.tsddContentComparision, filter.Comparision); this.MaskProvider = new MaskedTextProvider(CreateMask(filter.Sequence.Length * 2), CultureInfo.InvariantCulture, true); this.MaskProvider.Add(filter.SequenceAsString); this.tstbHex.Text = this.MaskProvider.ToDisplayString(); base.CanRaiseFilterChanged = true; }
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) { hint = tempHint; } } } } bool updateText = TextOutput != clonedProvider.ToString(); // Always set the mtp, the formatted text could be the same but the assigned positions may be different. this.maskedTextProvider = clonedProvider; // Update text if needed. if( updateText ) { SetText(); // Update caret position. this.caretTestPos = startPosition; base.SelectInternal( this.caretTestPos, 0, this.maskedTextProvider.Length ); } else { this.caretTestPos = currentCaretPos; } return; }
/// <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 (); }
public MaskedTextBox () { provider = new MaskedTextProvider ("<>", CultureInfo.CurrentCulture); is_empty_mask = true; 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 }; }
/// <devdoc> /// Sets the underlying MaskedTextProvider object. Used when the control is initialized /// and one of its properties, backed up by the MaskedTextProvider, changes; this requires /// recreating the provider because it is immutable. /// </devdoc> private void SetMaskedTextProvider( MaskedTextProvider newProvider ) { SetMaskedTextProvider( newProvider, null); }
/// <summary> /// Check if the received string value matches with the Introduction Mask for DateTime datatype. /// </summary> /// <param name="stringValue">String to be checked.</param> /// <returns>Returns true if the string matches with Introduction Mask.</returns> private bool IsValidDateTimeAccordingMask(string stringValue) { bool result = true; if (mMask != string.Empty) { MaskedTextProvider maskTextProvider = new MaskedTextProvider(ConvertMask2DisplayMask(mMask)); result = maskTextProvider.VerifyString(stringValue); } return result; }
/// <devdoc> /// Overload to allow for passing the text when the mask is being changed from null, /// in this case the maskedTextProvider holds backend info only (not the text). /// </devdoc> private void SetMaskedTextProvider( MaskedTextProvider newProvider, string textOnInitializingMask ) { Debug.Assert( newProvider != null, "Initializing from a null MaskProvider ref." ); // Set R/W properties. newProvider.IncludePrompt = this.maskedTextProvider.IncludePrompt; newProvider.IncludeLiterals = this.maskedTextProvider.IncludeLiterals; newProvider.SkipLiterals = this.maskedTextProvider.SkipLiterals; newProvider.ResetOnPrompt = this.maskedTextProvider.ResetOnPrompt; newProvider.ResetOnSpace = this.maskedTextProvider.ResetOnSpace; // If mask not initialized and not initializing it, the new provider is just a property backend. // Change won't have any effect in text. if( this.flagState[IS_NULL_MASK] && textOnInitializingMask == null) { this.maskedTextProvider = newProvider; return; } int testPos = 0; bool raiseOnMaskInputRejected = false; // Raise if new provider rejects old text. MaskedTextResultHint hint = MaskedTextResultHint.NoEffect; MaskedTextProvider oldProvider = this.maskedTextProvider; // Attempt to add previous text. // If the mask is the same, we need to preserve the caret and character positions if the text is added successfully. bool preserveCharPos = oldProvider.Mask == newProvider.Mask; // Cache text output text before setting the new provider to determine whether we need to raise the TextChanged event. string oldText; // NOTE: Whenever changing the MTP, the text is lost if any character in the old text violates the new provider's mask. if( textOnInitializingMask != null ) // Changing Mask (from null), which is the only RO property that requires passing text. { oldText = textOnInitializingMask; raiseOnMaskInputRejected = !newProvider.Set( textOnInitializingMask, out testPos, out hint ); } else { oldText = TextOutput; // We need to attempt to set the input characters one by one in the edit positions so they are not // escaped. int assignedCount = oldProvider.AssignedEditPositionCount; int srcPos = 0; int dstPos = 0; while( assignedCount > 0 ) { srcPos = oldProvider.FindAssignedEditPositionFrom( srcPos, forward ); Debug.Assert( srcPos != MaskedTextProvider.InvalidIndex, "InvalidIndex unexpected at this time." ); if (preserveCharPos) { dstPos = srcPos; } else { dstPos = newProvider.FindEditPositionFrom(dstPos, forward); if (dstPos == MaskedTextProvider.InvalidIndex) { newProvider.Clear(); testPos = newProvider.Length; hint = MaskedTextResultHint.UnavailableEditPosition; break; } } if( !newProvider.Replace( oldProvider[srcPos], dstPos, out testPos, out hint )) { preserveCharPos = false; newProvider.Clear(); break; } srcPos++; dstPos++; assignedCount--; } raiseOnMaskInputRejected = !MaskedTextProvider.GetOperationResultFromHint(hint); } // Set provider. this.maskedTextProvider = newProvider; if( this.flagState[IS_NULL_MASK] ) { this.flagState[IS_NULL_MASK] = false; } // Raising events need to be done only after the new provider has been set so the MTB is in a state where properties // can be queried from event handlers safely. if( raiseOnMaskInputRejected ) { OnMaskInputRejected(new MaskInputRejectedEventArgs(testPos, hint)); } if( newProvider.IsPassword ) { // Reset native edit control so the MaskedTextBox will take control over the characters that // need to be replaced with the password char (the input text characters). // MTB takes over. SetEditControlPasswordChar('\0'); } EventArgs e = EventArgs.Empty; if (textOnInitializingMask != null /*changing mask from null*/ || oldProvider.Mask != newProvider.Mask) { OnMaskChanged(e); } SetWindowText(GetFormattedDisplayString(), oldText != TextOutput, preserveCharPos); }
/// <devdoc> /// Constructs the MaskedTextBox with the specified MaskedTextProvider object. /// </devdoc> public MaskedTextBox() { MaskedTextProvider maskedTextProvider = new MaskedTextProvider(nullMask, CultureInfo.CurrentCulture); this.flagState[IS_NULL_MASK] = true; Initialize(maskedTextProvider); }
private void RefreshText(MaskedTextProvider maskProvider, int pos) { // Refresh string. this.Text = maskProvider.ToDisplayString(); // Position cursor. this.SelectionStart = pos; }
/// <devdoc> /// Constructs the MaskedTextBox with the specified MaskedTextProvider object. /// </devdoc> public MaskedTextBox(string mask) { if (mask == null) { throw new ArgumentNullException(); } MaskedTextProvider maskedTextProvider = new MaskedTextProvider(mask, CultureInfo.CurrentCulture); this.flagState[IS_NULL_MASK] = false; Initialize(maskedTextProvider); }
public MaskedTextBox (string mask) { if (mask == null) { throw new ArgumentNullException (); } provider = new MaskedTextProvider (mask, CultureInfo.CurrentCulture); is_empty_mask = false; Init (); }
public object Clone() { MaskedTextProvider clonedProvider; Type providerType = this.GetType(); if (providerType == maskTextProviderType) { clonedProvider = new MaskedTextProvider( this.Mask, this.Culture, this.AllowPromptAsInput, this.PromptChar, this.PasswordChar, this.AsciiOnly); } else // A derived Type instance used. { object[] parameters = new object[] { this.Mask, this.Culture, this.AllowPromptAsInput, this.PromptChar, this.PasswordChar, this.AsciiOnly }; clonedProvider = SecurityUtils.SecureCreateInstance(providerType, parameters) as MaskedTextProvider; } clonedProvider.ResetOnPrompt = false; clonedProvider.ResetOnSpace = false; clonedProvider.SkipLiterals = false; for (int position = 0; position < this.testString.Length; position++) { CharDescriptor chDex = this.stringDescriptor[position]; if (IsEditPosition(chDex) && chDex.IsAssigned) { clonedProvider.Replace(this.testString[position], position); } } clonedProvider.ResetOnPrompt = this.ResetOnPrompt; clonedProvider.ResetOnSpace = this.ResetOnSpace; clonedProvider.SkipLiterals = this.SkipLiterals; clonedProvider.IncludeLiterals = this.IncludeLiterals; clonedProvider.IncludePrompt = this.IncludePrompt; return clonedProvider; }