2010-04-06 Jb Evain <jbevain@novell.com>

[mcs.git] / class / System / System.ComponentModel / MaskedTextProvider.cs

// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
// Copyright (c) 2007 Novell, Inc. (http://www.novell.com)
//
// Authors:
//      Rolf Bjarne Kvinge  <RKvinge@novell.com>
//
//

/*

Mask language:

0       Digit, required. This element will accept any single digit between 0 and 9.
9       Digit or space, optional. 
#       Digit or space, optional. If this position is blank in the mask, it will be rendered as a space in the Text property. Plus (+) and minus (-) signs are allowed.
L       Letter, required. Restricts input to the ASCII letters a-z and A-Z. This mask element is equivalent to [a-zA-Z] in regular expressions. 
?       Letter, optional. Restricts input to the ASCII letters a-z and A-Z. This mask element is equivalent to [a-zA-Z]? in regular expressions. 
&       Character, required. If the AsciiOnly property is set to true, this element behaves like the "L" element. 
C       Character, optional. Any non-control character. If the AsciiOnly property is set to true, this element behaves like the "?" element.
 * LAMESPEC: A is REQUIRED, not optional.
A       Alphanumeric, optional. If the AsciiOnly property is set to true, the only characters it will accept are the ASCII letters a-z and A-Z.
a       Alphanumeric, optional. If the AsciiOnly property is set to true, the only characters it will accept are the ASCII letters a-z and A-Z.
.       Decimal placeholder. The actual display character used will be the decimal symbol appropriate to the format provider, as determined by the control's FormatProvider property.
,       Thousands placeholder. The actual display character used will be the thousands placeholder appropriate to the format provider, as determined by the control's FormatProvider property.
:       Time separator. The actual display character used will be the time symbol appropriate to the format provider, as determined by the control's FormatProvider property.
/       Date separator. The actual display character used will be the date symbol appropriate to the format provider, as determined by the control's FormatProvider property.
$       Currency symbol. The actual character displayed will be the currency symbol appropriate to the format provider, as determined by the control's FormatProvider property.
<       Shift down. Converts all characters that follow to lowercase. 
>       Shift up. Converts all characters that follow to uppercase.
|       Disable a previous shift up or shift down.
\       Escape. Escapes a mask character, turning it into a literal. "\\" is the escape sequence for a backslash.

 * */
 
#if NET_2_0
using System.Globalization;
using System.Collections;
using System.Diagnostics;
using System.Text;

namespace System.ComponentModel {
        public class MaskedTextProvider : ICloneable
        {
#region Private fields
                private bool allow_prompt_as_input;
                private bool ascii_only;
                private CultureInfo culture; 
                private bool include_literals;
                private bool include_prompt;
                private bool is_password;
                private string mask;
                private char password_char;
                private char prompt_char;
                private bool reset_on_prompt;
                private bool reset_on_space;
                private bool skip_literals;
                
                private EditPosition [] edit_positions;
                
                private static char default_prompt_char = '_';
                private static char default_password_char = char.MinValue;
                
#endregion

#region Private classes
                private enum EditState {
                        None,
                        UpperCase,
                        LowerCase
                }
                private enum EditType {
                        DigitRequired, // 0
                        DigitOrSpaceOptional, // 9
                        DigitOrSpaceOptional_Blank, // #
                        LetterRequired, // L
                        LetterOptional, // ?
                        CharacterRequired, // &
                        CharacterOptional, // C
                        AlphanumericRequired, // A
                        AlphanumericOptional, // a
                        DecimalPlaceholder, // .
                        ThousandsPlaceholder, // ,
                        TimeSeparator, // :
                        DateSeparator, // /
                        CurrencySymbol, // $ 
                        Literal
                }

                private class EditPosition {
                        public MaskedTextProvider Parent;
                        public EditType Type;
                        public EditState State;
                        public char MaskCharacter;
                        public char input;
                        
                        public void Reset ()
                        {
                                input = char.MinValue;
                        }
                        
                        internal EditPosition Clone () {
                                EditPosition result = new EditPosition ();
                                result.Parent = Parent;
                                result.Type = Type;
                                result.State = State;
                                result.MaskCharacter = MaskCharacter;
                                result.input = input;
                                return result;
                        }
                        
                        public char Input {
                                get {
                                        return input;
                                }
                                set {
                                        switch (State) {
                                        case EditState.LowerCase:
                                                input = char.ToLower (value, Parent.Culture);
                                                break;
                                        case EditState.UpperCase:
                                                input = char.ToUpper (value, Parent.Culture);
                                                break;
                                        default:// case EditState.None:
                                                input = value;
                                                break;
                                        }
                                }
                        }
                        
                        public bool IsAscii (char c)
                        {
                                return ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
                        }
                        
                        public bool Match (char c, out MaskedTextResultHint resultHint, bool only_test)
                        {
                                if (!MaskedTextProvider.IsValidInputChar (c)) {
                                        resultHint = MaskedTextResultHint.InvalidInput;
                                        return false;
                                }

                                if (Parent.ResetOnSpace && c == ' ' && Editable) {
                                        resultHint = MaskedTextResultHint.CharacterEscaped;
                                        if (FilledIn) {
                                                resultHint = MaskedTextResultHint.Success;
                                                if (!only_test && input != ' ') {
                                                        switch (Type) {
                                                        case EditType.AlphanumericOptional:
                                                        case EditType.AlphanumericRequired:
                                                        case EditType.CharacterOptional:
                                                        case EditType.CharacterRequired:
                                                                Input = c;
                                                                break;
                                                        default:
                                                                Input = char.MinValue;
                                                                break;
                                                        }
                                                }
                                        }
                                        return true;
                                }
                                
                                if (Type == EditType.Literal && MaskCharacter == c && Parent.SkipLiterals) {
                                        resultHint = MaskedTextResultHint.Success;
                                        return true;
                                }
                                
                                if (!Editable) {
                                        resultHint = MaskedTextResultHint.NonEditPosition;
                                        return false;
                                }

                                switch (Type) {
                                        case EditType.AlphanumericOptional:
                                        case EditType.AlphanumericRequired:
                                                if (char.IsLetterOrDigit (c)) {
                                                        if (Parent.AsciiOnly && !IsAscii (c)) {
                                                                resultHint = MaskedTextResultHint.AsciiCharacterExpected;
                                                                return false;
                                                        } else {
                                                                if (!only_test) {
                                                                        Input = c;
                                                                }
                                                                resultHint = MaskedTextResultHint.Success;
                                                                return true;
                                                        }
                                                } else {
                                                        resultHint = MaskedTextResultHint.AlphanumericCharacterExpected;
                                                        return false;
                                                }
                                        case EditType.CharacterOptional:
                                        case EditType.CharacterRequired:
                                                if (Parent.AsciiOnly && !IsAscii (c)) {
                                                        resultHint = MaskedTextResultHint.LetterExpected;
                                                        return false;
                                                } else if (!char.IsControl (c)) {
                                                        if (!only_test) {
                                                                Input = c;
                                                        }
                                                        resultHint = MaskedTextResultHint.Success;
                                                        return true;
                                                } else {
                                                        resultHint = MaskedTextResultHint.LetterExpected;
                                                        return false;
                                                }
                                        case EditType.DigitOrSpaceOptional:
                                        case EditType.DigitOrSpaceOptional_Blank:
                                                if (char.IsDigit (c) || c == ' ') {
                                                        if (!only_test) {
                                                                Input = c;
                                                        }
                                                        resultHint = MaskedTextResultHint.Success;
                                                        return true;
                                                } else {
                                                        resultHint = MaskedTextResultHint.DigitExpected;
                                                        return false;
                                                }
                                        case EditType.DigitRequired:
                                                if (char.IsDigit (c)) {
                                                        if (!only_test) {
                                                                Input = c;
                                                        }
                                                        resultHint = MaskedTextResultHint.Success;
                                                        return true;
                                                } else {
                                                        resultHint = MaskedTextResultHint.DigitExpected;
                                                        return false;
                                                }
                                        case EditType.LetterOptional:
                                        case EditType.LetterRequired:
                                                if (!char.IsLetter (c)) {
                                                        resultHint = MaskedTextResultHint.LetterExpected;
                                                        return false;
                                                } else if (Parent.AsciiOnly && !IsAscii (c)) {
                                                        resultHint = MaskedTextResultHint.LetterExpected;
                                                        return false;
                                                } else {
                                                        if (!only_test) {
                                                                Input = c;
                                                        }
                                                        resultHint = MaskedTextResultHint.Success;
                                                        return true;
                                                }
                                        default:
                                                resultHint = MaskedTextResultHint.Unknown;
                                                return false;
                                }
                        }
                        
                        public bool FilledIn {
                                get {
                                        return Input != char.MinValue;
                                }
                        }
                        
                        public bool Required {
                                get {
                                        switch (MaskCharacter) {
                                        case '0':
                                        case 'L':
                                        case '&':
                                        case 'A':
                                                return true;
                                        default:
                                                return false;
                                        }
                                }
                        }
                        
                        public bool Editable {
                                get {
                                        switch (MaskCharacter) {
                                        case '0':
                                        case '9':
                                        case '#':
                                        case 'L':
                                        case '?':
                                        case '&':
                                        case 'C':
                                        case 'A':
                                        case 'a':
                                                return true;
                                        default:
                                                return false;
                                        }
                                }
                        }       
                        
                        public bool Visible {
                                get {
                                        switch (MaskCharacter) {
                                        case '|':
                                        case '<':
                                        case '>':
                                                return false;
                                        default:
                                                return true;
                                        }
                                }
                        }
                        public string Text {
                                get {
                                        if (Type == EditType.Literal) {
                                                return MaskCharacter.ToString ();
                                        }
                                        switch (MaskCharacter) {
                                        case '.': return Parent.Culture.NumberFormat.NumberDecimalSeparator;
                                        case ',': return Parent.Culture.NumberFormat.NumberGroupSeparator;
                                        case ':': return Parent.Culture.DateTimeFormat.TimeSeparator;
                                        case '/': return Parent.Culture.DateTimeFormat.DateSeparator;
                                        case '$': return Parent.Culture.NumberFormat.CurrencySymbol;
                                        default:
                                                return FilledIn ? Input.ToString () : Parent.PromptChar.ToString ();
                                        }
                                }
                        }

                        private EditPosition ()
                        {
                        }

                        public EditPosition (MaskedTextProvider Parent, EditType Type, EditState State, char MaskCharacter)
                        {
                                this.Type = Type;
                                this.Parent = Parent;
                                this.State = State;
                                this.MaskCharacter = MaskCharacter;
                                
                        }
                }
#endregion

#region Private methods & properties
                private void SetMask (string mask)
                {
                        if (mask == null || mask == string.Empty)
                                throw new ArgumentException ("The Mask value cannot be null or empty.\r\nParameter name: mask");

                        this.mask = mask;
                        
                        System.Collections.Generic.List <EditPosition> list = new System.Collections.Generic.List<EditPosition> (mask.Length);
                        
                        EditState State = EditState.None;
                        bool escaped = false;
                        for (int i = 0; i < mask.Length; i++) {
                                if (escaped) {
                                        list.Add (new EditPosition (this, EditType.Literal, State, mask [i]));
                                        escaped = false;
                                        continue;
                                }
                                
                                switch (mask [i]) {
                                case '\\':
                                        escaped = true; 
                                        break;
                                case '0':
                                        list.Add (new EditPosition (this, EditType.DigitRequired, State, mask [i])); 
                                        break;
                                case '9':
                                        list.Add (new EditPosition (this, EditType.DigitOrSpaceOptional, State, mask [i]));
                                        break;
                                case '#':
                                        list.Add (new EditPosition (this, EditType.DigitOrSpaceOptional_Blank, State, mask [i]));
                                        break;
                                case 'L':
                                        list.Add (new EditPosition (this, EditType.LetterRequired, State, mask [i]));
                                        break;
                                case '?':
                                        list.Add (new EditPosition (this, EditType.LetterOptional, State, mask [i]));
                                        break;
                                case '&':
                                        list.Add (new EditPosition (this, EditType.CharacterRequired, State, mask [i]));
                                        break;
                                case 'C':
                                        list.Add (new EditPosition (this, EditType.CharacterOptional, State, mask [i]));
                                        break;
                                case 'A':
                                        list.Add (new EditPosition (this, EditType.AlphanumericRequired, State, mask [i]));
                                        break;
                                case 'a':
                                        list.Add (new EditPosition (this, EditType.AlphanumericOptional, State, mask [i]));
                                        break;
                                case '.':
                                        list.Add (new EditPosition (this, EditType.DecimalPlaceholder, State, mask [i]));
                                        break;
                                case ',':
                                        list.Add (new EditPosition (this, EditType.ThousandsPlaceholder, State, mask [i]));
                                        break;
                                case ':':
                                        list.Add (new EditPosition (this, EditType.TimeSeparator, State, mask [i]));
                                        break;
                                case '/':
                                        list.Add (new EditPosition (this, EditType.DateSeparator, State, mask [i]));
                                        break;
                                case '$':
                                        list.Add (new EditPosition (this, EditType.CurrencySymbol, State, mask [i]));
                                        break;
                                case '<':
                                        State = EditState.LowerCase;
                                        break;
                                case '>':
                                        State = EditState.UpperCase;
                                        break;
                                case '|':
                                        State = EditState.None;
                                        break;
                                default:
                                        list.Add (new EditPosition (this, EditType.Literal, State, mask [i]));
                                        break;
                                }
                        }
                        edit_positions = list.ToArray ();
                }
                
                private EditPosition [] ClonePositions ()
                {
                        EditPosition [] result = new EditPosition [edit_positions.Length];
                        for (int i = 0; i < result.Length; i++) {
                                result [i] = edit_positions [i].Clone ();
                        }
                        return result;
                }

                private bool AddInternal (string str_input, out int testPosition, out MaskedTextResultHint resultHint, bool only_test)
                {
                        EditPosition [] edit_positions;
                        
                        if (only_test) {
                                edit_positions = ClonePositions ();
                        } else {
                                edit_positions = this.edit_positions;
                        }

                        if (str_input == null)
                                throw new ArgumentNullException ("input");

                        if (str_input.Length == 0) {
                                resultHint = MaskedTextResultHint.NoEffect;
                                testPosition = LastAssignedPosition + 1;
                                return true;
                        }

                        resultHint = MaskedTextResultHint.Unknown;
                        testPosition = 0;

                        int next_position = LastAssignedPosition;
                        MaskedTextResultHint tmpResult = MaskedTextResultHint.Unknown;

                        if (next_position >= edit_positions.Length) {
                                testPosition = next_position;
                                resultHint = MaskedTextResultHint.UnavailableEditPosition;
                                return false;
                        }

                        for (int i = 0; i < str_input.Length; i++) {
                                char input = str_input [i];
                                next_position++;
                                testPosition = next_position;
                                
                                if (tmpResult > resultHint) {
                                        resultHint = tmpResult;
                                }

                                if (VerifyEscapeChar (input, next_position)) {
                                        tmpResult = MaskedTextResultHint.CharacterEscaped;
                                        continue;
                                }

                                next_position = FindEditPositionFrom (next_position, true);
                                testPosition = next_position;

                                if (next_position == InvalidIndex) {
                                        testPosition = edit_positions.Length;
                                        resultHint = MaskedTextResultHint.UnavailableEditPosition;
                                        return false;
                                }

                                if (!IsValidInputChar (input)) {
                                        testPosition = next_position;
                                        resultHint = MaskedTextResultHint.InvalidInput;
                                        return false;
                                }
                                
                                if (!edit_positions [next_position].Match (input, out tmpResult, false)) {
                                        testPosition = next_position;
                                        resultHint = tmpResult;
                                        return false;
                                }               
                        }

                        if (tmpResult > resultHint) {
                                resultHint = tmpResult;
                        }

                        return true;
                }
                
                private bool AddInternal (char input, out int testPosition, out MaskedTextResultHint resultHint, bool check_available_positions_first, bool check_escape_char_first)
                {
                        /*
                         * check_available_positions_first: when adding a char, MS first seems to check if there are any available edit positions, then if there are any
                         * they will try to add the char (meaning that if you add a char matching a literal char in the mask with SkipLiterals and there are no
                         * more available edit positions, it will fail).
                         * 
                         * check_escape_char_first: When adding a char, MS doesn't check for escape char, they directly search for the first edit position.
                         * When adding a string, they check first for escape char, then if not successful they find the first edit position.
                         */
                         
                        int new_position;
                        testPosition = 0;
                        
                        new_position = LastAssignedPosition + 1;

                        if (check_available_positions_first) {
                                int tmp = new_position;
                                bool any_available = false;
                                while (tmp < edit_positions.Length) {
                                        if (edit_positions [tmp].Editable) {
                                                any_available = true;
                                                break;
                                        }
                                        tmp++;
                                }
                                if (!any_available) {
                                        testPosition = tmp;
                                        resultHint = MaskedTextResultHint.UnavailableEditPosition;
                                        return GetOperationResultFromHint (resultHint);
                                }
                        }

                        if (check_escape_char_first) {
                                if (VerifyEscapeChar (input, new_position)) {
                                        testPosition = new_position;
                                        resultHint = MaskedTextResultHint.CharacterEscaped;
                                        return true;
                                }
                        }

                        new_position = FindEditPositionFrom (new_position, true);

                        if (new_position > edit_positions.Length - 1 ||new_position == InvalidIndex) {
                                testPosition = new_position;
                                resultHint = MaskedTextResultHint.UnavailableEditPosition;
                                return GetOperationResultFromHint (resultHint);
                        }

                        if (!IsValidInputChar (input)) {
                                testPosition = new_position;
                                resultHint = MaskedTextResultHint.InvalidInput;
                                return GetOperationResultFromHint (resultHint);
                        }

                        if (!edit_positions [new_position].Match (input, out resultHint, false)) {
                                testPosition = new_position;
                                return GetOperationResultFromHint (resultHint);
                        }

                        testPosition = new_position;

                        return GetOperationResultFromHint (resultHint);
                }
                
                private bool VerifyStringInternal (string input, out int testPosition, out MaskedTextResultHint resultHint, int startIndex, bool only_test)
                {
                        int previous_position = startIndex;
                        int current_position;
                        resultHint = MaskedTextResultHint.Unknown;
                        
                        // Replace existing characters
                        for (int i = 0; i < input.Length; i++) {
                                MaskedTextResultHint tmpResult;
                                current_position = FindEditPositionFrom (previous_position, true);
                                if (current_position == InvalidIndex) {
                                        testPosition = edit_positions.Length;
                                        resultHint = MaskedTextResultHint.UnavailableEditPosition;
                                        return false;
                                }
                                
                                if (!VerifyCharInternal (input [i], current_position, out tmpResult, only_test)) {
                                        testPosition = current_position;
                                        resultHint = tmpResult;
                                        return false;
                                }
                                if (tmpResult > resultHint) {
                                        resultHint = tmpResult;
                                }
                                previous_position = current_position + 1;
                                
                        }
                        // Remove characters not in the input.
                        if (!only_test) {
                                previous_position = FindEditPositionFrom (previous_position, true);
                                while (previous_position != InvalidIndex) {
                                        if (edit_positions [previous_position].FilledIn) {
                                                edit_positions [previous_position].Reset ();
                                                if (resultHint != MaskedTextResultHint.NoEffect) {
                                                        resultHint = MaskedTextResultHint.Success;
                                                }
                                        }
                                        previous_position = FindEditPositionFrom (previous_position + 1, true);
                                }
                        }
                        if (input.Length > 0) {
                                testPosition = startIndex + input.Length - 1;
                        } else {
                                testPosition = startIndex;
                                if (resultHint < MaskedTextResultHint.NoEffect) {
                                        resultHint = MaskedTextResultHint.NoEffect;
                                }
                        }
                        
                        return true;
                }

                private bool VerifyCharInternal (char input, int position, out MaskedTextResultHint hint, bool only_test)
                {
                        hint = MaskedTextResultHint.Unknown;

                        if (position < 0 || position >= edit_positions.Length) {
                                hint = MaskedTextResultHint.PositionOutOfRange;
                                return false;
                        }

                        if (!IsValidInputChar (input)) {
                                hint = MaskedTextResultHint.InvalidInput;
                                return false;
                        }

                        if (input == ' ' && ResetOnSpace && edit_positions [position].Editable && edit_positions [position].FilledIn) {
                                if (!only_test) {
                                        edit_positions [position].Reset ();
                                }
                                hint = MaskedTextResultHint.SideEffect;
                                return true;
                        }
                        
                        if (edit_positions [position].Editable &&  edit_positions [position].FilledIn && edit_positions [position].input == input) {
                                hint = MaskedTextResultHint.NoEffect;
                                return true;
                        }

                        if (SkipLiterals && !edit_positions [position].Editable && edit_positions [position].Text == input.ToString ()) {
                                hint = MaskedTextResultHint.CharacterEscaped;
                                return true;
                        }

                        return edit_positions [position].Match (input, out hint, only_test);
                }
                
                // Test to see if the input string can be inserted at the specified position.
                // Does not try to move characters.
                private bool IsInsertableString (string str_input, int position, out int testPosition, out MaskedTextResultHint resultHint)
                {
                        int current_position = position;
                        int test_position;
                        
                        resultHint = MaskedTextResultHint.UnavailableEditPosition;
                        testPosition = InvalidIndex;
                        
                        for (int i = 0; i < str_input.Length; i++) {
                                char ch = str_input [i];

                                test_position = FindEditPositionFrom (current_position, true);
                                
                                if (test_position != InvalidIndex && VerifyEscapeChar (ch, test_position)) {
                                        current_position = test_position + 1;
                                        continue;
                                }
                                
                                if (VerifyEscapeChar (ch, current_position)) {
                                        current_position = current_position + 1;
                                        continue;
                                }
                                
                                
                                if (test_position == InvalidIndex) {
                                        resultHint = MaskedTextResultHint.UnavailableEditPosition;
                                        testPosition = edit_positions.Length;
                                        return false;
                                }

                                testPosition = test_position;
                                
                                if (!edit_positions [test_position].Match (ch, out resultHint, true)) {
                                        return false;
                                }
                                
                                current_position = test_position + 1;
                        }
                        resultHint = MaskedTextResultHint.Success;
                        
                        return true;
                }
                
                private bool ShiftPositionsRight (EditPosition [] edit_positions, int start, out int testPosition, out MaskedTextResultHint resultHint)
                {
                        int index = start;
                        int last_assigned_index = FindAssignedEditPositionFrom (edit_positions.Length, false);
                        int endindex = FindUnassignedEditPositionFrom (last_assigned_index, true); // Find the first non-assigned edit position
                        
                        testPosition = start;
                        resultHint = MaskedTextResultHint.Unknown;

                        if (endindex == InvalidIndex) {
                                // No more free edit positions.
                                testPosition = edit_positions.Length;
                                resultHint = MaskedTextResultHint.UnavailableEditPosition;
                                return false;
                        }
                
                        while (endindex > index) {
                                char char_to_assign;
                                int index_to_move;
                                
                                index_to_move = FindEditPositionFrom (endindex - 1, false);     
                                char_to_assign = edit_positions [index_to_move].input;

                                if (char_to_assign == char.MinValue) {
                                        edit_positions [endindex].input = char_to_assign;
                                } else {
                                        if (!edit_positions [endindex].Match (char_to_assign, out resultHint, false)) {
                                                testPosition = endindex;
                                                return false;
                                        }
                                }
                                endindex = index_to_move;
                        }
                        
                        if (endindex != InvalidIndex) {
                                edit_positions [endindex].Reset ();
                        }
                        
                        return true;
                }
                
                private bool ReplaceInternal (string input, int startPosition, int endPosition, out int testPosition, out MaskedTextResultHint resultHint, bool only_test, bool dont_remove_at_end)
                {
                        EditPosition [] edit_positions;
                        resultHint = MaskedTextResultHint.Unknown;
                        
                        if (only_test) {
                                edit_positions = ClonePositions ();
                        } else {
                                edit_positions = this.edit_positions;
                        }
                        
                        if (input == null)
                                throw new ArgumentNullException ("input");

                        if (endPosition >= edit_positions.Length) {
                                testPosition = endPosition;
                                resultHint = MaskedTextResultHint.PositionOutOfRange;
                                return false;
                        }
                        
                        if (startPosition < 0) {
                                testPosition = startPosition;
                                resultHint = MaskedTextResultHint.PositionOutOfRange;
                                return false;
                        }
                        
                        if (startPosition >= edit_positions.Length) {
                                testPosition = startPosition;
                                resultHint = MaskedTextResultHint.PositionOutOfRange;
                                return false;
                        }
                        
                        if (startPosition > endPosition) {
                                testPosition = startPosition;
                                resultHint = MaskedTextResultHint.PositionOutOfRange;
                                return false;
                        }

                        
                        if (input.Length == 0) {
                                return RemoveAtInternal (startPosition, endPosition, out testPosition, out resultHint, only_test);
                        }

                        int previous_position = startPosition;
                        int current_position = previous_position;
                        MaskedTextResultHint tmpResult = MaskedTextResultHint.Unknown;
                        testPosition = InvalidIndex;
                        
                        for (int i = 0; i < input.Length; i++) {
                                char current_input = input [i];
                                
                                current_position = previous_position;

                                if (VerifyEscapeChar (current_input, current_position)) {
                                        if (edit_positions [current_position].FilledIn &&
                                                edit_positions [current_position].Editable &&
                                                (current_input == ' ' && ResetOnSpace) || (current_input == PromptChar && ResetOnPrompt)) {
                                                edit_positions [current_position].Reset ();
                                                tmpResult = MaskedTextResultHint.SideEffect;
                                        } else {
                                                tmpResult = MaskedTextResultHint.CharacterEscaped;
                                        }
                                } else if (current_position < edit_positions.Length && !edit_positions [current_position].Editable && FindAssignedEditPositionInRange (current_position, endPosition, true) == InvalidIndex) {
                                        // If replacing over a literal, the replacement character is INSERTED at the next
                                        // available edit position. Weird, huh?
                                        current_position = FindEditPositionFrom (current_position, true);
                                        if (current_position == InvalidIndex) {
                                                resultHint = MaskedTextResultHint.UnavailableEditPosition;
                                                testPosition = edit_positions.Length;
                                                return false;
                                        }
                                        if (!InsertAtInternal (current_input.ToString (), current_position, out testPosition, out tmpResult, only_test)) {
                                                resultHint = tmpResult;
                                                return false;
                                        }
                                } else { 
                                
                                        current_position = FindEditPositionFrom (current_position, true);

                                        if (current_position == InvalidIndex) {
                                                testPosition = edit_positions.Length;
                                                resultHint = MaskedTextResultHint.UnavailableEditPosition;
                                                return false;
                                        }

                                        if (!IsValidInputChar (current_input)) {
                                                testPosition = current_position;
                                                resultHint = MaskedTextResultHint.InvalidInput;
                                                return false;
                                        }

                                        if (!ReplaceInternal (edit_positions, current_input, current_position, out testPosition, out tmpResult, false)) {
                                                resultHint = tmpResult;
                                                return false;
                                        }
                                }
                                
                                if (tmpResult > resultHint) {
                                        resultHint = tmpResult;
                                }
                                
                                previous_position = current_position + 1;
                        }

                        testPosition = current_position;
                        
                        int tmpPosition;
                        if (!dont_remove_at_end && previous_position <= endPosition) {
                                if (!RemoveAtInternal (previous_position, endPosition, out tmpPosition, out tmpResult, only_test)) {
                                        testPosition = tmpPosition;
                                        resultHint = tmpResult;
                                        return false;
                                }
                        }
                        if (tmpResult == MaskedTextResultHint.Success && resultHint < MaskedTextResultHint.SideEffect) {
                                resultHint = MaskedTextResultHint.SideEffect;
                        }
                                
                        return true;
                }
                
                private bool ReplaceInternal (EditPosition [] edit_positions, char input, int position, out int testPosition, out MaskedTextResultHint resultHint, bool only_test)
                {
                        testPosition = position;

                        if (!IsValidInputChar (input)) {
                                resultHint = MaskedTextResultHint.InvalidInput;
                                return false;
                        }

                        if (VerifyEscapeChar (input, position)) {
                                if (edit_positions [position].FilledIn && edit_positions [position].Editable && (input == ' ' && ResetOnSpace) || (input == PromptChar && ResetOnPrompt)) {
                                        edit_positions [position].Reset ();
                                        resultHint = MaskedTextResultHint.SideEffect;
                                } else {
                                        resultHint = MaskedTextResultHint.CharacterEscaped;
                                }
                                testPosition = position;
                                return true;
                        }

                        if (!edit_positions [position].Editable) {
                                resultHint = MaskedTextResultHint.NonEditPosition;
                                return false;
                        }
                        
                        bool is_filled = edit_positions [position].FilledIn;
                        if (is_filled && edit_positions [position].input == input) {
                                if (VerifyEscapeChar (input, position)) {
                                        resultHint = MaskedTextResultHint.CharacterEscaped;
                                } else {
                                        resultHint = MaskedTextResultHint.NoEffect;
                                }
                        } else if (input == ' ' && this.ResetOnSpace) {
                                if (is_filled) {
                                        resultHint = MaskedTextResultHint.SideEffect;
                                        edit_positions [position].Reset ();
                                } else {
                                        resultHint = MaskedTextResultHint.CharacterEscaped;
                                }
                                return true;
                        } else if (VerifyEscapeChar (input, position)) {
                                resultHint = MaskedTextResultHint.SideEffect;
                        } else {
                                resultHint = MaskedTextResultHint.Success;
                        }
                        MaskedTextResultHint tmpResult;
                        if (!edit_positions [position].Match (input, out tmpResult, false)) {
                                resultHint = tmpResult;
                                return false;
                        }

                        return true;
                }

                private bool RemoveAtInternal (int startPosition, int endPosition, out int testPosition, out MaskedTextResultHint resultHint, bool only_testing)
                {
                        EditPosition [] edit_positions;
                        testPosition = -1;
                        resultHint = MaskedTextResultHint.Unknown;

                        if (only_testing) {
                                edit_positions = ClonePositions ();
                        } else {
                                edit_positions = this.edit_positions;
                        }

                        if (endPosition < 0 || endPosition >= edit_positions.Length) {
                                testPosition = endPosition;
                                resultHint = MaskedTextResultHint.PositionOutOfRange;
                                return false;
                        }
                        
                        if (startPosition < 0 || startPosition >= edit_positions.Length) {
                                testPosition = startPosition;
                                resultHint = MaskedTextResultHint.PositionOutOfRange;
                                return false;
                        }
                        
                        
                        if (startPosition > endPosition) {
                                testPosition = startPosition;
                                resultHint = MaskedTextResultHint.PositionOutOfRange;
                                return false;
                        }
                        int edit_positions_in_range = 0;
                        for (int i = startPosition; i <= endPosition; i++) {
                                if (edit_positions [i].Editable) {
                                        edit_positions_in_range++;
                                }
                        }
                        
                        if (edit_positions_in_range == 0) {
                                testPosition = startPosition;
                                resultHint = MaskedTextResultHint.NoEffect;
                                return true;
                        }
                        
                        int current_edit_position = FindEditPositionFrom (startPosition, true);
                        while (current_edit_position != InvalidIndex) {
                                // Find the edit position that will reach the current position.
                                int next_index = FindEditPositionFrom (current_edit_position + 1, true);
                                for (int j = 1; j < edit_positions_in_range && next_index != InvalidIndex; j++) {
                                        next_index = FindEditPositionFrom (next_index + 1, true);
                                }
                                
                                if (next_index == InvalidIndex) {
                                        if (edit_positions [current_edit_position].FilledIn) {
                                                edit_positions [current_edit_position].Reset ();
                                                resultHint = MaskedTextResultHint.Success;      
                                        } else {
                                                if (resultHint < MaskedTextResultHint.NoEffect) {
                                                        resultHint = MaskedTextResultHint.NoEffect;
                                                }
                                        }
                                } else {
                                        if (!edit_positions [next_index].FilledIn) {
                                                if (edit_positions [current_edit_position].FilledIn) {
                                                        edit_positions [current_edit_position].Reset ();
                                                        resultHint = MaskedTextResultHint.Success;      
                                                } else {
                                                        if (resultHint < MaskedTextResultHint.NoEffect) {
                                                                resultHint = MaskedTextResultHint.NoEffect;
                                                        }
                                                }
                                        } else {
                                                MaskedTextResultHint tmpResult = MaskedTextResultHint.Unknown;
                                                if (edit_positions [current_edit_position].FilledIn) {
                                                        resultHint = MaskedTextResultHint.Success;
                                                } else if (resultHint < MaskedTextResultHint.SideEffect) {
                                                        resultHint = MaskedTextResultHint.SideEffect;
                                                }
                                                if (!edit_positions [current_edit_position].Match (edit_positions [next_index].input, out tmpResult, false)) {
                                                        resultHint = tmpResult;
                                                        testPosition = current_edit_position;
                                                        return false;
                                                }
                                        }       
                                        edit_positions [next_index].Reset ();
                                }
                                current_edit_position = FindEditPositionFrom (current_edit_position + 1, true);
                        }
                        
                        if (resultHint == MaskedTextResultHint.Unknown) {
                                resultHint = MaskedTextResultHint.NoEffect;
                        }
                        
                        testPosition = startPosition;
                        
                        return true;
                }
                
                private bool InsertAtInternal (string str_input, int position, out int testPosition, out MaskedTextResultHint resultHint, bool only_testing)
                {
                        EditPosition [] edit_positions;
                        testPosition = -1;
                        resultHint = MaskedTextResultHint.Unknown;

                        if (only_testing) {
                                edit_positions = ClonePositions ();
                        } else {
                                edit_positions = this.edit_positions;
                        }

                        if (position < 0 || position >= edit_positions.Length) {
                                testPosition = 0;
                                resultHint = MaskedTextResultHint.PositionOutOfRange;
                                return false;
                        }
                        
                        if (!IsInsertableString (str_input, position, out testPosition, out resultHint)) {
                                return false;
                        }
                        
                        resultHint = MaskedTextResultHint.Unknown;
                        
                        int next_position = position;
                        for (int i = 0; i < str_input.Length; i++) {
                                char input = str_input [i];
                                int index = FindEditPositionFrom (next_position, true); // Find the first edit position (here the input will go)
                                int endindex = FindUnassignedEditPositionFrom (next_position, true); // Find the first non-assigned edit position
                                bool escaped = false;

                                if (VerifyEscapeChar (input, next_position)) {
                                        escaped = true;

                                        if (input.ToString () == edit_positions [next_position].Text) {
                                                if (FindAssignedEditPositionInRange (0, next_position - 1, true) != InvalidIndex && endindex == InvalidIndex) {
                                                        resultHint = MaskedTextResultHint.UnavailableEditPosition;
                                                        testPosition = edit_positions.Length;
                                                        return false;
                                                }
                                                resultHint = MaskedTextResultHint.CharacterEscaped;
                                                testPosition = next_position;
                                                next_position++;
                                                continue;                                               
                                        }
                                }
                                
                                if (!escaped && index == InvalidIndex) {
                                        // No edit positions left at all in the string
                                        testPosition = edit_positions.Length;
                                        resultHint = MaskedTextResultHint.UnavailableEditPosition;
                                        return false;
                                }
                                
                                if (index == InvalidIndex) {
                                        index = next_position;
                                }
                                
                                bool was_filled = edit_positions [index].FilledIn;
                                bool shift = was_filled;
                                if (shift) {
                                        if (!ShiftPositionsRight (edit_positions, index, out testPosition, out resultHint)) {
                                                return false;
                                        }
                                }

                                testPosition = index;
                                if (escaped) {
                                        if (was_filled) {
                                                resultHint = MaskedTextResultHint.Success;
                                        } else if (!edit_positions [index].Editable && input.ToString () == edit_positions [index].Text) {
                                                resultHint = MaskedTextResultHint.CharacterEscaped;
                                                testPosition = next_position;
                                        } else {
                                                int first_edit_position = FindEditPositionFrom (index, true);
                                                if (first_edit_position == InvalidIndex) {
                                                        resultHint = MaskedTextResultHint.UnavailableEditPosition;
                                                        testPosition = edit_positions.Length;
                                                        return false;
                                                }
                        
                                                resultHint = MaskedTextResultHint.CharacterEscaped;
                                                if (input.ToString () == edit_positions [next_position].Text) {
                                                        testPosition = next_position;
                                                }
                                        }
                                } else {
                                        MaskedTextResultHint tmpResult;
                                        if (!edit_positions [index].Match (input, out tmpResult, false)) {
                                                resultHint = tmpResult;
                                                return false;
                                        }
                                        if (resultHint < tmpResult) {
                                                resultHint = tmpResult;
                                        }
                                }
                                next_position = index + 1;
                                
                        }
                        
                        return true;
                }
#endregion
                #region Public constructors
                static MaskedTextProvider()
                {
                }

                public MaskedTextProvider(string mask) 
                        : this (mask, null, true, default_prompt_char, default_password_char, false)
                {
                }

                public MaskedTextProvider (string mask, bool restrictToAscii) 
                        : this (mask, null, true, default_prompt_char, default_password_char, restrictToAscii)
                {
                }

                public MaskedTextProvider (string mask, CultureInfo culture) 
                        : this (mask, culture, true, default_prompt_char, default_password_char, false)
                {
                }

                public MaskedTextProvider (string mask, char passwordChar, bool allowPromptAsInput) 
                        : this (mask, null, allowPromptAsInput, default_prompt_char, passwordChar, false)
                {
                }

                public MaskedTextProvider (string mask, CultureInfo culture, bool restrictToAscii) 
                        : this (mask, culture, true, default_prompt_char, default_password_char, restrictToAscii)
                {
                }
                
                public MaskedTextProvider(string mask, CultureInfo culture, char passwordChar, bool allowPromptAsInput) 
                        : this (mask, culture, allowPromptAsInput, default_prompt_char, passwordChar, false)
                {
                }
                
                public MaskedTextProvider(string mask, CultureInfo culture, bool allowPromptAsInput, char promptChar, char passwordChar, bool restrictToAscii)
                {
                        SetMask (mask);
                        
                        if (culture == null)
                                this.culture = Threading.Thread.CurrentThread.CurrentCulture;
                        else
                                this.culture = culture;
                                
                        this.allow_prompt_as_input = allowPromptAsInput;
                        
                        this.PromptChar = promptChar;
                        this.PasswordChar = passwordChar;
                        this.ascii_only = restrictToAscii;
                        
                        include_literals = true;
                        reset_on_prompt = true;
                        reset_on_space = true;
                        skip_literals = true;
                }
#endregion

#region Public methods
                public bool Add(char input)
                {
                        int testPosition;
                        MaskedTextResultHint resultHint;
                        return Add (input, out testPosition, out resultHint);
                }

                public bool Add (string input)
                {
                        int testPosition;
                        MaskedTextResultHint resultHint;
                        return Add (input, out testPosition, out resultHint);
                }

                public bool Add (char input, out int testPosition, out MaskedTextResultHint resultHint)
                {
                        return AddInternal (input, out testPosition, out resultHint, true, false);
                }

                public bool Add (string input, out int testPosition, out MaskedTextResultHint resultHint)
                {
                        bool result;
                        
                        result = AddInternal (input, out testPosition, out resultHint, true);
                        
                        if (result) {
                                result = AddInternal (input, out testPosition, out resultHint, false);
                        }
                        
                        return result;
                }

                public void Clear ()
                {
                        MaskedTextResultHint resultHint;
                        Clear (out resultHint);
                }

                public void Clear (out MaskedTextResultHint resultHint)
                {
                        resultHint = MaskedTextResultHint.NoEffect;
                        for (int i = 0; i < edit_positions.Length; i++) {
                                if (edit_positions [i].Editable && edit_positions [i].FilledIn) {
                                        edit_positions [i].Reset ();
                                        resultHint = MaskedTextResultHint.Success;
                                }
                        }
                }

                public object Clone ()
                {
                        MaskedTextProvider result = new MaskedTextProvider (mask);
                        
                        result.allow_prompt_as_input = allow_prompt_as_input;
                        result.ascii_only = ascii_only;
                        result.culture = culture;
                        result.edit_positions = ClonePositions ();
                        result.include_literals = include_literals;
                        result.include_prompt = include_prompt;
                        result.is_password = is_password;
                        result.mask = mask;
                        result.password_char = password_char;
                        result.prompt_char = prompt_char;
                        result.reset_on_prompt = reset_on_prompt;
                        result.reset_on_space = reset_on_space;
                        result.skip_literals = skip_literals;
                                                
                        return result;
                }

                public int FindAssignedEditPositionFrom (int position, bool direction)
                {
                        if (direction) {
                                return FindAssignedEditPositionInRange (position, edit_positions.Length - 1, direction);
                        } else {
                                return FindAssignedEditPositionInRange (0, position, direction);                        
                        }
                }

                public int FindAssignedEditPositionInRange (int startPosition, int endPosition, bool direction)
                {
                        int step;
                        int start, end;
                        
                        if (startPosition < 0)
                                startPosition = 0;
                        if (endPosition >= edit_positions.Length)
                                endPosition = edit_positions.Length - 1;

                        if (startPosition > endPosition)
                                return InvalidIndex;
                                
                        step = direction ? 1 : -1;
                        start = direction ? startPosition : endPosition;
                        end = (direction ? endPosition: startPosition) + step;

                        for (int i = start; i != end; i+=step) {
                                if (edit_positions [i].Editable && edit_positions [i].FilledIn)
                                        return i;
                        }
                        return InvalidIndex;
                }

                public int FindEditPositionFrom (int position, bool direction)
                {
                        if (direction) {
                                return FindEditPositionInRange (position, edit_positions.Length - 1, direction);
                        } else {
                                return FindEditPositionInRange (0, position, direction);
                        }
                }

                public int FindEditPositionInRange (int startPosition, int endPosition, bool direction)
                {
                        int step;
                        int start, end;

                        if (startPosition < 0)
                                startPosition = 0;
                        if (endPosition >= edit_positions.Length)
                                endPosition = edit_positions.Length - 1;

                        if (startPosition > endPosition)
                                return InvalidIndex;

                        step = direction ? 1 : -1;
                        start = direction ? startPosition : endPosition;
                        end = (direction ? endPosition : startPosition) + step;

                        for (int i = start; i != end; i += step) {
                                if (edit_positions [i].Editable)
                                        return i;
                        }
                        return InvalidIndex;
                }

                public int FindNonEditPositionFrom (int position, bool direction)
                {
                        if (direction) {
                                return FindNonEditPositionInRange (position, edit_positions.Length - 1, direction);
                        } else {
                                return FindNonEditPositionInRange (0, position, direction);
                        }
                }

                public int FindNonEditPositionInRange (int startPosition, int endPosition, bool direction)
                {               
                        int step;
                        int start, end;

                        if (startPosition < 0)
                                startPosition = 0;
                        if (endPosition >= edit_positions.Length)
                                endPosition = edit_positions.Length - 1;

                        if (startPosition > endPosition)
                                return InvalidIndex;

                        step = direction ? 1 : -1;
                        start = direction ? startPosition : endPosition;
                        end = (direction ? endPosition : startPosition) + step;

                        for (int i = start; i != end; i += step) {
                                if (!edit_positions [i].Editable)
                                        return i;
                        }
                        return InvalidIndex;
                }

                public int FindUnassignedEditPositionFrom (int position, bool direction)
                {
                        if (direction) {
                                return FindUnassignedEditPositionInRange (position, edit_positions.Length - 1, direction);
                        } else {
                                return FindUnassignedEditPositionInRange (0, position, direction);
                        }
                }

                public int FindUnassignedEditPositionInRange (int startPosition, int endPosition, bool direction)
                {
                        int step;
                        int start, end;

                        if (startPosition < 0)
                                startPosition = 0;
                        if (endPosition >= edit_positions.Length)
                                endPosition = edit_positions.Length - 1;

                        if (startPosition > endPosition)
                                return InvalidIndex;

                        step = direction ? 1 : -1;
                        start = direction ? startPosition : endPosition;
                        end = (direction ? endPosition : startPosition) + step;

                        for (int i = start; i != end; i += step) {
                                if (edit_positions [i].Editable && !edit_positions [i].FilledIn)
                                        return i;
                        }
                        return InvalidIndex;
                }

                public static bool GetOperationResultFromHint (MaskedTextResultHint hint)
                {
                        return (hint == MaskedTextResultHint.CharacterEscaped || 
                                hint == MaskedTextResultHint.NoEffect || 
                                hint == MaskedTextResultHint.SideEffect || 
                                hint == MaskedTextResultHint.Success);
                }

                public bool InsertAt (char input, int position)
                {
                        int testPosition;
                        MaskedTextResultHint resultHint;
                        return InsertAt (input, position, out testPosition, out resultHint);
                }

                public bool InsertAt (string input, int position)
                {
                        int testPosition;
                        MaskedTextResultHint resultHint;
                        return InsertAt (input, position, out testPosition, out resultHint);
                }

                public bool InsertAt (char input, int position, out int testPosition, out MaskedTextResultHint resultHint)
                {
                        return InsertAt (input.ToString (), position, out testPosition, out resultHint);                
                }

                public bool InsertAt (string input, int position, out int testPosition, out MaskedTextResultHint resultHint)
                {
                        if (input == null)
                                throw new ArgumentNullException ("input");
                        
                        if (position >= edit_positions.Length) {
                                testPosition = position;
                                resultHint = MaskedTextResultHint.PositionOutOfRange;
                                return false;
                        }
                        
                        if (input == string.Empty) {
                                testPosition = position;
                                resultHint = MaskedTextResultHint.NoEffect;
                                return true;
                        }
                        
                        bool result;

                        result = InsertAtInternal (input, position, out testPosition, out resultHint, true);

                        if (result) {   
                                result = InsertAtInternal (input, position, out testPosition, out resultHint, false);
                        }

                        return result;  
                }

                public bool IsAvailablePosition (int position)
                {
                        if (position < 0 || position >= edit_positions.Length)
                                return false;
                                
                        return edit_positions [position].Editable && !edit_positions [position].FilledIn;
                }

                public bool IsEditPosition (int position)
                {
                        if (position < 0 || position >= edit_positions.Length)
                                return false;
                                
                        return edit_positions [position].Editable;
                }

                public static bool IsValidInputChar (char c)
                {
                        return char.IsLetterOrDigit (c) || char.IsPunctuation (c) || char.IsSymbol (c) || c == ' ';
                }

                public static bool IsValidMaskChar (char c)
                {
                        return char.IsLetterOrDigit (c) || char.IsPunctuation (c) || char.IsSymbol (c) || c == ' ';
                }

                public static bool IsValidPasswordChar (char c)
                {
                        return char.IsLetterOrDigit (c) || char.IsPunctuation (c) || char.IsSymbol (c) || c == ' ' || c == char.MinValue;
                }

                public bool Remove ()
                {
                        int testPosition;
                        MaskedTextResultHint resultHint;
                        return Remove (out testPosition, out resultHint);
                }

                public bool Remove (out int testPosition, out MaskedTextResultHint resultHint)
                {
                        if (LastAssignedPosition == InvalidIndex) {
                                resultHint = MaskedTextResultHint.NoEffect;
                                testPosition = 0;
                                return true;
                        }
                        
                        testPosition = LastAssignedPosition;
                        resultHint = MaskedTextResultHint.Success;
                        edit_positions [LastAssignedPosition].input = char.MinValue;
                        
                        return true;
                }

                public bool RemoveAt (int position)
                {
                        return RemoveAt (position, position);
                }

                public bool RemoveAt (int startPosition, int endPosition)
                {
                        int testPosition;
                        MaskedTextResultHint resultHint;
                        return RemoveAt (startPosition, endPosition, out testPosition, out resultHint);
                }

                public bool RemoveAt (int startPosition, int endPosition, out int testPosition, out MaskedTextResultHint resultHint)
                {       
                        bool result;
                        
                        result = RemoveAtInternal (startPosition, endPosition, out testPosition, out resultHint, true);
                        
                        if (result) {
                                result = RemoveAtInternal (startPosition, endPosition, out testPosition, out resultHint, false);
                        }
                
                        return result;
                }

                public bool Replace (char input, int position)
                {
                        int testPosition;
                        MaskedTextResultHint resultHint;
                        return Replace (input, position, out testPosition, out resultHint);
                }

                public bool Replace (string input, int position)
                {
                        int testPosition;
                        MaskedTextResultHint resultHint;
                        return Replace (input, position, out testPosition, out resultHint);
                }

                public bool Replace (char input, int position, out int testPosition, out MaskedTextResultHint resultHint)
                {
                        if (position < 0 || position >= edit_positions.Length) {
                                testPosition = position;
                                resultHint = MaskedTextResultHint.PositionOutOfRange;
                                return false;
                        }

                        if (VerifyEscapeChar (input, position)) {
                                if (edit_positions [position].FilledIn && edit_positions [position].Editable && (input == ' ' && ResetOnSpace) || (input == PromptChar && ResetOnPrompt)) {
                                        edit_positions [position].Reset ();
                                        resultHint = MaskedTextResultHint.SideEffect;
                                } else {
                                        resultHint = MaskedTextResultHint.CharacterEscaped;
                                }
                                testPosition = position;
                                return true;
                        }
                        
                        int current_edit_position;
                        current_edit_position = FindEditPositionFrom (position, true);

                        if (current_edit_position == InvalidIndex) {
                                testPosition = position;
                                resultHint = MaskedTextResultHint.UnavailableEditPosition;
                                return false;
                        }

                        if (!IsValidInputChar (input)) {
                                testPosition = current_edit_position;
                                resultHint = MaskedTextResultHint.InvalidInput;
                                return false;
                        }
                        
                        return ReplaceInternal (edit_positions, input, current_edit_position, out testPosition, out resultHint, false);
                }

                public bool Replace (string input, int position, out int testPosition, out MaskedTextResultHint resultHint)
                {
                        if (input == null)
                                throw new ArgumentNullException ("input");

                        if (position < 0 || position >= edit_positions.Length) {
                                testPosition = position;
                                resultHint = MaskedTextResultHint.PositionOutOfRange;
                                return false;
                        }
                        
                        if (input.Length == 0) {
                                return RemoveAt (position, position, out testPosition, out resultHint);
                        }
                        
                        bool result;
                        
                        result = ReplaceInternal (input, position, edit_positions.Length - 1, out testPosition, out resultHint, true, true);
                        
                        if (result) {
                                result = ReplaceInternal (input, position, edit_positions.Length - 1, out testPosition, out resultHint, false, true);   
                        }

                        return result;
                }

                public bool Replace (char input, int startPosition, int endPosition, out int testPosition, out MaskedTextResultHint resultHint)
                {

                        if (endPosition >= edit_positions.Length) {
                                testPosition = endPosition;
                                resultHint = MaskedTextResultHint.PositionOutOfRange;
                                return false;
                        }

                        if (startPosition < 0) {
                                testPosition = startPosition;
                                resultHint = MaskedTextResultHint.PositionOutOfRange;
                                return false;
                        }
                        
                        if (startPosition > endPosition) {
                                testPosition = startPosition;
                                resultHint = MaskedTextResultHint.PositionOutOfRange;
                                return false;
                        }
                        
                        if (startPosition == endPosition) {
                                return ReplaceInternal (edit_positions, input, startPosition, out testPosition, out resultHint, false);
                        }

                        return Replace (input.ToString (), startPosition, endPosition, out testPosition, out resultHint);
                }

                public bool Replace (string input, int startPosition, int endPosition, out int testPosition, out MaskedTextResultHint resultHint)
                {
                        bool result;
                        
                        result = ReplaceInternal (input, startPosition, endPosition, out testPosition, out resultHint, true, false);
                        
                        if (result) {
                                result = ReplaceInternal (input, startPosition, endPosition, out testPosition, out resultHint, false, false);
                        }
                        return result;
                }

                public bool Set (string input)
                {
                        int testPosition;
                        MaskedTextResultHint resultHint;
                        return Set (input, out testPosition, out resultHint);
                }

                public bool Set (string input, out int testPosition, out MaskedTextResultHint resultHint)
                {
                        bool result;

                        if (input == null) {
                                throw new ArgumentNullException ("input");
                        }

                        result = VerifyStringInternal (input, out testPosition, out resultHint, 0, true);
                        
                        if (result) {
                                result = VerifyStringInternal (input, out testPosition, out resultHint, 0, false);
                        }
                        
                        return result;
                }

                public string ToDisplayString ()
                {
                        return ToString (false, true, true, 0, Length);
                }

                public override string ToString ()
                {
                        return ToString (true, IncludePrompt, IncludeLiterals, 0, Length);
                }

                public string ToString (bool ignorePasswordChar)
                {
                        return ToString (ignorePasswordChar, IncludePrompt, IncludeLiterals, 0, Length);
                }

                public string ToString (bool includePrompt, bool includeLiterals)
                {
                        return ToString (true, includePrompt, includeLiterals, 0, Length);
                }

                public string ToString (int startPosition, int length)
                {
                        return ToString (true, IncludePrompt, IncludeLiterals, startPosition, length);
                }

                public string ToString (bool ignorePasswordChar, int startPosition, int length)
                {
                        return ToString (ignorePasswordChar, IncludePrompt, IncludeLiterals, startPosition, length);
                }

                public string ToString (bool includePrompt, bool includeLiterals, int startPosition, int length)
                {
                        return ToString (true, includePrompt, includeLiterals, startPosition, length);
                }

                public string ToString (bool ignorePasswordChar, bool includePrompt, bool includeLiterals, int startPosition, int length)
                {
                        if (startPosition < 0)
                                startPosition = 0;
                        
                        if (length <= 0)
                                return string.Empty;
                        
                        StringBuilder result = new StringBuilder ();
                        int start = startPosition;
                        int end = startPosition + length - 1;
                        
                        if (end >= edit_positions.Length) {
                                end = edit_positions.Length - 1;
                        }
                        int last_assigned_position = FindAssignedEditPositionInRange (start, end, false);
                        
                        // Find the last position in the mask to check for
                        if (!includePrompt) {
                                int last_non_edit_position;
                                
                                last_non_edit_position = FindNonEditPositionInRange (start, end, false);
                                
                                if (includeLiterals) {
                                        end = last_assigned_position > last_non_edit_position ? last_assigned_position : last_non_edit_position;
                                } else {
                                        end = last_assigned_position;
                                }
                        }
                        
                        for (int i = start; i <= end; i++) {
                                EditPosition ed = edit_positions [i];
                                
                                if (ed.Type == EditType.Literal) {
                                        if (includeLiterals) {
                                                result.Append (ed.Text);
                                        }                               
                                } else if (ed.Editable) {
                                        if (IsPassword) {
                                                if (!ed.FilledIn) { // Nothing to hide or show.
                                                        if (includePrompt)
                                                                result.Append (PromptChar);
                                                        else
                                                                result.Append (" ");
                                                } else if (ignorePasswordChar)
                                                        result.Append (ed.Input);
                                                else
                                                        result.Append (PasswordChar);
                                        } else if (!ed.FilledIn) {
                                                if (includePrompt) {
                                                        result.Append (PromptChar);
                                                } else if (includeLiterals) {
                                                        result.Append (" ");
                                                } else if (last_assigned_position != InvalidIndex && last_assigned_position > i) {
                                                        result.Append (" ");
                                                }
                                        } else {
                                                result.Append (ed.Text);
                                        }
                                } else {
                                        if (includeLiterals)
                                                result.Append (ed.Text);
                                }
                        }
                        
                        return result.ToString ();
                }

                public bool VerifyChar (char input, int position, out MaskedTextResultHint hint)
                {
                        return VerifyCharInternal (input, position, out hint, true);
                }

                public bool VerifyEscapeChar (char input, int position)
                {
                        if (position >= edit_positions.Length || position < 0) {
                                return false;
                        }
                        
                        if (!edit_positions [position].Editable) {
                                if (SkipLiterals) {
                                        return input.ToString () == edit_positions [position].Text;
                                } else {
                                        return false;
                                }
                        }
                        
                        if (ResetOnSpace && input == ' ') {
                                return true;
                        } else if (ResetOnPrompt && input == PromptChar) {
                                return true;
                        } else {
                                return false;
                        }
                }

                public bool VerifyString (string input)
                {
                        int testPosition;
                        MaskedTextResultHint resultHint;
                        return VerifyString (input, out testPosition, out resultHint);
                }

                public bool VerifyString (string input, out int testPosition, out MaskedTextResultHint resultHint)
                {
                        if (input == null || input.Length == 0) {                       
                                testPosition = 0;
                                resultHint = MaskedTextResultHint.NoEffect;
                                return true;
                        }
                        
                        return VerifyStringInternal (input, out testPosition, out resultHint, 0, true);
                }
#endregion

#region Public properties
                public bool AllowPromptAsInput {
                        get {
                                return allow_prompt_as_input;
                        }
                }
                
                public bool AsciiOnly {
                        get {
                                return ascii_only;
                        }
                }
                
                public int AssignedEditPositionCount {
                        get {
                                int result = 0;
                                for (int i = 0; i < edit_positions.Length; i++) {
                                        if (edit_positions [i].FilledIn) {
                                                result++;
                                        }
                                }
                                return result;
                        }
                }
                
                public int AvailableEditPositionCount {
                        get {
                                int result = 0;
                                foreach (EditPosition edit in edit_positions) {
                                        if (!edit.FilledIn && edit.Editable) {
                                                result++;
                                        }
                                }
                                return result;
                        }
                }
                
                public CultureInfo Culture {
                        get {
                                return culture;
                        }
                }
                
                public static char DefaultPasswordChar {
                        get {
                                return '*';
                        }
                }
                
                public int EditPositionCount {
                        get {
                                int result = 0;
                                foreach (EditPosition edit in edit_positions) {
                                        if (edit.Editable) {
                                                result++;
                                        }
                                }
                                                
                                return result;
                        }
                }
                
                public IEnumerator EditPositions {
                        get {
                                System.Collections.Generic.List <int> result = new System.Collections.Generic.List<int> ();
                                for (int i = 0; i < edit_positions.Length; i++) {
                                        if (edit_positions [i].Editable) {
                                                result.Add (i);
                                        }
                                }
                                return result.GetEnumerator ();
                        }
                }
                
                public bool IncludeLiterals {
                        get {
                                return include_literals;
                        }
                        set {
                                include_literals = value;
                        }
                }
                
                public bool IncludePrompt {
                        get {
                                return include_prompt;
                        }
                        set {
                                include_prompt = value;
                        }
                }
                
                public static int InvalidIndex {
                        get {
                                return -1;
                        }
                }
                
                public bool IsPassword {
                        get {
                                return password_char != char.MinValue;
                        }
                        set {
                                password_char = value ? DefaultPasswordChar : char.MinValue;
                        }
                }
                
                public char this [int index] {
                        get {
                                if (index < 0 || index >= Length) {
                                        throw new IndexOutOfRangeException (index.ToString ());
                                }
                                
                                return ToString (true, true, true, 0, edit_positions.Length) [index];
                        }
                }
                
                public int LastAssignedPosition {
                        get {
                                return FindAssignedEditPositionFrom (edit_positions.Length - 1, false);
                        }
                }
                
                public int Length {
                        get {
                                int result = 0;
                                for (int i = 0; i < edit_positions.Length; i++) {
                                        if (edit_positions [i].Visible)
                                                result++;
                                }
                                return result;
                        }
                }
                
                public string Mask {
                        get {
                                return mask;
                        }
                }
                
                public bool MaskCompleted {
                        get {
                                for (int i = 0; i < edit_positions.Length; i++)
                                        if (edit_positions [i].Required && !edit_positions [i].FilledIn)
                                                return false;
                                return true;
                        }
                }
                
                public bool MaskFull {
                        get {
                                for (int i = 0; i < edit_positions.Length; i++)
                                        if (edit_positions [i].Editable && !edit_positions [i].FilledIn)
                                                return false;
                                return true;
                        }
                }
                
                public char PasswordChar {
                        get {
                                return password_char;
                        }
                        set {
                                password_char = value;
                        }
                }
                
                public char PromptChar {
                        get {
                                return prompt_char;
                        }
                        set {
                                prompt_char = value;
                        }
                }
                
                public bool ResetOnPrompt {
                        get {
                                return reset_on_prompt;
                        }
                        set {
                                reset_on_prompt = value;
                        }
                }
                
                public bool ResetOnSpace {
                        get {
                                return reset_on_space;
                        }
                        set {
                                reset_on_space = value;
                        }
                }
                
                public bool SkipLiterals {
                        get {
                                return skip_literals;
                        }
                        set {
                                skip_literals = value;
                        }
                }
#endregion

        }
}
#endif