//START AjaxControlToolkit.Compat.Timer.Timer.js
// (c) Copyright Microsoft Corporation.
// This source is subject to the Microsoft Permissive License.
// See http://www.microsoft.com/resources/sharedsource/licensingbasics/sharedsourcelicenses.mspx.
// All other rights reserved.


/// <reference name="MicrosoftAjax.debug.js" />
/// <reference name="MicrosoftAjaxTimer.debug.js" />
/// <reference name="MicrosoftAjaxWebForms.debug.js" />


///////////////////////////////////////////////////////////////////////////////
// Sys.Timer

Sys.Timer = function() {
    Sys.Timer.initializeBase(this);
    
    this._interval = 1000;
    this._enabled = false;
    this._timer = null;
}

Sys.Timer.prototype = {
    get_interval: function() {
        
        return this._interval;
    },
    set_interval: function(value) {
        
        if (this._interval !== value) {
            this._interval = value;
            this.raisePropertyChanged('interval');
            
            if (!this.get_isUpdating() && (this._timer !== null)) {
                this._stopTimer();
                this._startTimer();
            }
        }
    },
    
    get_enabled: function() {
        
        return this._enabled;
    },
    set_enabled: function(value) {
        
        if (value !== this.get_enabled()) {
            this._enabled = value;
            this.raisePropertyChanged('enabled');
            if (!this.get_isUpdating()) {
                if (value) {
                    this._startTimer();
                }
                else {
                    this._stopTimer();
                }
            }
        }
    },

    
    add_tick: function(handler) {
        
        
        this.get_events().addHandler("tick", handler);
    },

    remove_tick: function(handler) {
        
        
        this.get_events().removeHandler("tick", handler);
    },

    dispose: function() {
        this.set_enabled(false);
        this._stopTimer();
        
        Sys.Timer.callBaseMethod(this, 'dispose');
    },
    
    updated: function() {
        Sys.Timer.callBaseMethod(this, 'updated');

        if (this._enabled) {
            this._stopTimer();
            this._startTimer();
        }
    },

    _timerCallback: function() {
        var handler = this.get_events().getHandler("tick");
        if (handler) {
            handler(this, Sys.EventArgs.Empty);
        }
    },

    _startTimer: function() {
        this._timer = window.setInterval(Function.createDelegate(this, this._timerCallback), this._interval);
    },

    _stopTimer: function() {
        window.clearInterval(this._timer);
        this._timer = null;
    }
}

Sys.Timer.descriptor = {
    properties: [   {name: 'interval', type: Number},
                    {name: 'enabled', type: Boolean} ],
    events: [ {name: 'tick'} ]
}

Sys.Timer.registerClass('Sys.Timer', Sys.Component);

//END AjaxControlToolkit.Compat.Timer.Timer.js
//START AjaxControlToolkit.Common.Common.js
// (c) Copyright Microsoft Corporation.
// This source is subject to the Microsoft Permissive License.
// See http://www.microsoft.com/resources/sharedsource/licensingbasics/sharedsourcelicenses.mspx.
// All other rights reserved.


/// <reference name="MicrosoftAjax.debug.js" />
/// <reference name="MicrosoftAjaxTimer.debug.js" />
/// <reference name="MicrosoftAjaxWebForms.debug.js" />


// Add common toolkit scripts here.  To consume the scripts on a control add
// 
//      [RequiredScript(typeof(CommonToolkitScripts))] 
//      public class SomeExtender : ...
// 
// to the controls extender class declaration.


Type.registerNamespace('AjaxControlToolkit');


AjaxControlToolkit.BoxSide = function() {
    /// <summary>
    /// The BoxSide enumeration describes the sides of a DOM element
    /// </summary>
    /// <field name="Top" type="Number" integer="true" static="true" />
    /// <field name="Right" type="Number" integer="true" static="true" />
    /// <field name="Bottom" type="Number" integer="true" static="true" />
    /// <field name="Left" type="Number" integer="true" static="true" />
}
AjaxControlToolkit.BoxSide.prototype = {
    Top : 0,
    Right : 1,
    Bottom : 2,
    Left : 3
}
AjaxControlToolkit.BoxSide.registerEnum("AjaxControlToolkit.BoxSide", false);


AjaxControlToolkit._CommonToolkitScripts = function() {
    /// <summary>
    /// The _CommonToolkitScripts class contains functionality utilized across a number
    /// of controls (but not universally)
    /// </summary>
    /// <remarks>
    /// You should not create new instances of _CommonToolkitScripts.  Instead you should use the shared instance CommonToolkitScripts (or AjaxControlToolkit.CommonToolkitScripts).
    /// </remarks>
}
AjaxControlToolkit._CommonToolkitScripts.prototype = {
    // The order of these lookup tables is directly linked to the BoxSide enum defined above
    _borderStyleNames : ["borderTopStyle","borderRightStyle","borderBottomStyle","borderLeftStyle"],
    _borderWidthNames : ["borderTopWidth", "borderRightWidth", "borderBottomWidth", "borderLeftWidth"],
    _paddingWidthNames : ["paddingTop", "paddingRight", "paddingBottom", "paddingLeft"],
    _marginWidthNames : ["marginTop", "marginRight", "marginBottom", "marginLeft"],

    getCurrentStyle : function(element, attribute, defaultValue) {
        /// <summary>
        /// CommonToolkitScripts.getCurrentStyle is used to compute the value of a style attribute on an
        /// element that is currently being displayed.  This is especially useful for scenarios where
        /// several CSS classes and style attributes are merged, or when you need information about the
        /// size of an element (such as its padding or margins) that is not exposed in any other fashion.
        /// </summary>
        /// <param name="element" type="Sys.UI.DomElement" domElement="true">
        /// Live DOM element to check style of
        /// </param>
        /// <param name="attribute" type="String">
        /// The style attribute's name is expected to be in a camel-cased form that you would use when
        /// accessing a JavaScript property instead of the hyphenated form you would use in a CSS
        /// stylesheet (i.e. it should be "backgroundColor" and not "background-color").
        /// </param>
        /// <param name="defaultValue" type="Object" mayBeNull="true" optional="true">
        /// In the event of a problem (i.e. a null element or an attribute that cannot be found) we
        /// return this object (or null if none if not specified).
        /// </param>
        /// <returns type="Object">
        /// Current style of the element's attribute
        /// </returns>

        var currentValue = null;
        if (element) {
            if (element.currentStyle) {
                currentValue = element.currentStyle[attribute];
            } else if (document.defaultView && document.defaultView.getComputedStyle) {
                var style = document.defaultView.getComputedStyle(element, null);
                if (style) {
                    currentValue = style[attribute];
                }
            }
            
            if (!currentValue && element.style.getPropertyValue) {
                currentValue = element.style.getPropertyValue(attribute);
            }
            else if (!currentValue && element.style.getAttribute) {
                currentValue = element.style.getAttribute(attribute);
            }       
        }
        
        if ((!currentValue || currentValue == "" || typeof(currentValue) === 'undefined')) {
            if (typeof(defaultValue) != 'undefined') {
                currentValue = defaultValue;
            }
            else {
                currentValue = null;
            }
        }   
        return currentValue;  
    },

    getInheritedBackgroundColor : function(element) {
        /// <summary>
        /// CommonToolkitScripts.getInheritedBackgroundColor provides the ability to get the displayed
        /// background-color of an element.  In most cases calling CommonToolkitScripts.getCurrentStyle
        /// won't do the job because it will return "transparent" unless the element has been given a
        /// specific background color.  This function will walk up the element's parents until it finds
        /// a non-transparent color.  If we get all the way to the top of the document or have any other
        /// problem finding a color, we will return the default value '#FFFFFF'.  This function is
        /// especially important when we're using opacity in IE (because ClearType will make text look
        /// horrendous if you fade it with a transparent background color).
        /// </summary>
        /// <param name="element" type="Sys.UI.DomElement" domElement="true">
        /// Live DOM element to get the background color of
        /// </param>
        /// <returns type="String">
        /// Background color of the element
        /// </returns>
        
        if (!element) return '#FFFFFF';
        var background = this.getCurrentStyle(element, 'backgroundColor');
        try {
            while (!background || background == '' || background == 'transparent' || background == 'rgba(0, 0, 0, 0)') {
                element = element.parentNode;
                if (!element) {
                    background = '#FFFFFF';
                } else {
                    background = this.getCurrentStyle(element, 'backgroundColor');
                }
            }
        } catch(ex) {
            background = '#FFFFFF';
        }
        return background;
    },

    getLocation : function(element) {
    /// <summary>Gets the coordinates of a DOM element.</summary>
    /// <param name="element" domElement="true"/>
    /// <returns type="Sys.UI.Point">
    ///   A Point object with two fields, x and y, which contain the pixel coordinates of the element.
    /// </returns>

    // workaround for an issue in getLocation where it will compute the location of the document element.
    // this will return an offset if scrolled.
    //
    if (element === document.documentElement) {
        return new Sys.UI.Point(0,0);
    }

    // Workaround for IE6 bug in getLocation (also required patching getBounds - remove that fix when this is removed)
    if (Sys.Browser.agent == Sys.Browser.InternetExplorer && Sys.Browser.version < 7) {
        if (element.window === element || element.nodeType === 9 || !element.getClientRects || !element.getBoundingClientRect) return new Sys.UI.Point(0,0);

        // Get the first bounding rectangle in screen coordinates
        var screenRects = element.getClientRects();
        if (!screenRects || !screenRects.length) {
            return new Sys.UI.Point(0,0);
        }
        var first = screenRects[0];

        // Delta between client coords and screen coords
        var dLeft = 0;
        var dTop = 0;

        var inFrame = false;
        try {
            inFrame = element.ownerDocument.parentWindow.frameElement;
        } catch(ex) {
            // If accessing the frameElement fails, a frame is probably in a different
            // domain than its parent - and we still want to do the calculation below
            inFrame = true;
        }

        // If we're in a frame, get client coordinates too so we can compute the delta
        if (inFrame) {
            // Get the bounding rectangle in client coords
            var clientRect = element.getBoundingClientRect();
            if (!clientRect) {
                return new Sys.UI.Point(0,0);
            }

            // Find the minima in screen coords
            var minLeft = first.left;
            var minTop = first.top;
            for (var i = 1; i < screenRects.length; i++) {
                var r = screenRects[i];
                if (r.left < minLeft) {
                    minLeft = r.left;
                }
                if (r.top < minTop) {
                    minTop = r.top;
                }
            }

            // Compute the delta between screen and client coords
            dLeft = minLeft - clientRect.left;
            dTop = minTop - clientRect.top;
        }

        // Subtract 2px, the border of the viewport (It can be changed in IE6 by applying a border style to the HTML element,
        // but this is not supported by ASP.NET AJAX, and it cannot be changed in IE7.), and also subtract the delta between
        // screen coords and client coords
        var ownerDocument = element.document.documentElement;
        return new Sys.UI.Point(first.left - 2 - dLeft + ownerDocument.scrollLeft, first.top - 2 - dTop + ownerDocument.scrollTop);
    }

    return Sys.UI.DomElement.getLocation(element);
},

    setLocation : function(element, point) {
        /// <summary>
        /// Sets the current location for an element.
        /// </summary>
        /// <param name="element" type="Sys.UI.DomElement" domElement="true">
        /// DOM element
        /// </param>
        /// <param name="point" type="Object">
        /// Point object (of the form {x,y})
        /// </param>
        /// <remarks>
        /// This method does not attempt to set the positioning mode of an element.
        /// The position is relative from the elements nearest position:relative or
        /// position:absolute element.
        /// </remarks>
        Sys.UI.DomElement.setLocation(element, point.x, point.y);
    },
    
    getContentSize : function(element) {
        /// <summary>
        /// Gets the "content-box" size of an element.
        /// </summary>
        /// <param name="element" type="Sys.UI.DomElement" domElement="true">
        /// DOM element
        /// </param>
        /// <returns type="Object">
        /// Size of the element (in the form {width,height})
        /// </returns>
        /// <remarks>
        /// The "content-box" is the size of the content area *inside* of the borders and
        /// padding of an element. The "content-box" size does not include the margins around
        /// the element.
        /// </remarks>
        
        if (!element) {
            throw Error.argumentNull('element');
        }
        var size = this.getSize(element);
        var borderBox = this.getBorderBox(element);
        var paddingBox = this.getPaddingBox(element);
        return {
            width :  size.width - borderBox.horizontal - paddingBox.horizontal,
            height : size.height - borderBox.vertical - paddingBox.vertical
        }
    },

    getSize : function(element) {
        /// <summary>
        /// Gets the "border-box" size of an element.
        /// </summary>
        /// <param name="element" type="Sys.UI.DomElement" domElement="true">
        /// DOM element
        /// </param>
        /// <returns type="Object">
        /// Size of the element (in the form {width,height})
        /// </returns>
        /// <remarks>
        /// The "border-box" is the size of the content area *outside* of the borders and
        /// padding of an element.  The "border-box" size does not include the margins around
        /// the element.
        /// </remarks>
        
        if (!element) {
            throw Error.argumentNull('element');
        }
        return {
            width:  element.offsetWidth,
            height: element.offsetHeight
        };
    },
    
    setContentSize : function(element, size) {
        /// <summary>
        /// Sets the "content-box" size of an element.
        /// </summary>
        /// <param name="element" type="Sys.UI.DomElement" domElement="true">
        /// DOM element
        /// </param>
        /// <param name="size" type="Object">
        /// Size of the element (in the form {width,height})
        /// </param>
        /// <remarks>
        /// The "content-box" is the size of the content area *inside* of the borders and
        /// padding of an element. The "content-box" size does not include the margins around
        /// the element.
        /// </remarks>
        
        if (!element) {
            throw Error.argumentNull('element');
        }
        if (!size) {
            throw Error.argumentNull('size');
        }
        // FF respects -moz-box-sizing css extension, so adjust the box size for the border-box
        if(this.getCurrentStyle(element, 'MozBoxSizing') == 'border-box' || this.getCurrentStyle(element, 'BoxSizing') == 'border-box') {
            var borderBox = this.getBorderBox(element);
            var paddingBox = this.getPaddingBox(element);
            size = {
                width: size.width + borderBox.horizontal + paddingBox.horizontal,
                height: size.height + borderBox.vertical + paddingBox.vertical
            };
        }
        element.style.width = size.width.toString() + 'px';
        element.style.height = size.height.toString() + 'px';
    },
    
    setSize : function(element, size) {
        /// <summary>
        /// Sets the "border-box" size of an element.
        /// </summary>
        /// <remarks>
        /// The "border-box" is the size of the content area *outside* of the borders and 
        /// padding of an element.  The "border-box" size does not include the margins around
        /// the element.
        /// </remarks>
        /// <param name="element" type="Sys.UI.DomElement">DOM element</param>
        /// <param name="size" type="Object">Size of the element (in the form {width,height})</param>
        /// <returns />
        
        if (!element) {
            throw Error.argumentNull('element');
        }
        if (!size) {
            throw Error.argumentNull('size');
        }
        var borderBox = this.getBorderBox(element);
        var paddingBox = this.getPaddingBox(element);
        var contentSize = {
            width:  size.width - borderBox.horizontal - paddingBox.horizontal,
            height: size.height - borderBox.vertical - paddingBox.vertical
        };
        this.setContentSize(element, contentSize);
    },
    
    getBounds : function(element) {
        /// <summary>Gets the coordinates, width and height of an element.</summary>
        /// <param name="element" domElement="true"/>
        /// <returns type="Sys.UI.Bounds">
        ///   A Bounds object with four fields, x, y, width and height, which contain the pixel coordinates,
        ///   width and height of the element.
        /// </returns>
        /// <remarks>
        ///   Use the CommonToolkitScripts version of getLocation to handle the workaround for IE6.  We can
        ///   remove the below implementation and just call Sys.UI.DomElement.getBounds when the other bug
        ///   is fixed.
        /// </remarks>
        
        var offset = $common.getLocation(element);
        return new Sys.UI.Bounds(offset.x, offset.y, element.offsetWidth || 0, element.offsetHeight || 0);
    }, 
    
    setBounds : function(element, bounds) {
        /// <summary>
        /// Sets the "border-box" bounds of an element
        /// </summary>
        /// <param name="element" type="Sys.UI.DomElement" domElement="true">
        /// DOM element
        /// </param>
        /// <param name="bounds" type="Object">
        /// Bounds of the element (of the form {x,y,width,height})
        /// </param>
        /// <remarks>
        /// The "border-box" is the size of the content area *outside* of the borders and
        /// padding of an element.  The "border-box" size does not include the margins around
        /// the element.
        /// </remarks>
        
        if (!element) {
            throw Error.argumentNull('element');
        }
        if (!bounds) {
            throw Error.argumentNull('bounds');
        }
        this.setSize(element, bounds);
        $common.setLocation(element, bounds);
    },
    
    getClientBounds : function() {
        /// <summary>
        /// Gets the width and height of the browser client window (excluding scrollbars)
        /// </summary>
        /// <returns type="Sys.UI.Bounds">
        /// Browser's client width and height
        /// </returns>

        var clientWidth;
        var clientHeight;
        switch(Sys.Browser.agent) {
            case Sys.Browser.InternetExplorer:
                clientWidth = document.documentElement.clientWidth;
                clientHeight = document.documentElement.clientHeight;
                break;
            case Sys.Browser.Safari:
                clientWidth = window.innerWidth;
                clientHeight = window.innerHeight;
                break;
            case Sys.Browser.Opera:
                clientWidth = Math.min(window.innerWidth, document.body.clientWidth);
                clientHeight = Math.min(window.innerHeight, document.body.clientHeight);
                break;
            default:  // Sys.Browser.Firefox, etc.
                clientWidth = Math.min(window.innerWidth, document.documentElement.clientWidth);
                clientHeight = Math.min(window.innerHeight, document.documentElement.clientHeight);
                break;
        }
        return new Sys.UI.Bounds(0, 0, clientWidth, clientHeight);
    },
   
    getMarginBox : function(element) {
        /// <summary>
        /// Gets the entire margin box sizes.
        /// </summary>
        /// <param name="element" type="Sys.UI.DomElement" domElement="true">
        /// DOM element
        /// </param>
        /// <returns type="Object">
        /// Element's margin box sizes (of the form {top,left,bottom,right,horizontal,vertical})
        /// </returns>
        
        if (!element) {
            throw Error.argumentNull('element');
        }
        var box = {
            top: this.getMargin(element, AjaxControlToolkit.BoxSide.Top),
            right: this.getMargin(element, AjaxControlToolkit.BoxSide.Right),
            bottom: this.getMargin(element, AjaxControlToolkit.BoxSide.Bottom),
            left: this.getMargin(element, AjaxControlToolkit.BoxSide.Left)
        };
        box.horizontal = box.left + box.right;
        box.vertical = box.top + box.bottom;
        return box;
    },
    
    getBorderBox : function(element) {
        /// <summary>
        /// Gets the entire border box sizes.
        /// </summary>
        /// <param name="element" type="Sys.UI.DomElement" domElement="true">
        /// DOM element
        /// </param>
        /// <returns type="Object">
        /// Element's border box sizes (of the form {top,left,bottom,right,horizontal,vertical})
        /// </returns>
        
        if (!element) {
            throw Error.argumentNull('element');
        }
        var box = {
            top: this.getBorderWidth(element, AjaxControlToolkit.BoxSide.Top),
            right: this.getBorderWidth(element, AjaxControlToolkit.BoxSide.Right),
            bottom: this.getBorderWidth(element, AjaxControlToolkit.BoxSide.Bottom),
            left: this.getBorderWidth(element, AjaxControlToolkit.BoxSide.Left)
        };
        box.horizontal = box.left + box.right;
        box.vertical = box.top + box.bottom;
        return box;
    },
    
    getPaddingBox : function(element) {
        /// <summary>
        /// Gets the entire padding box sizes.
        /// </summary>
        /// <param name="element" type="Sys.UI.DomElement" domElement="true">
        /// DOM element
        /// </param>
        /// <returns type="Object">
        /// Element's padding box sizes (of the form {top,left,bottom,right,horizontal,vertical})
        /// </returns>
        
        if (!element) {
            throw Error.argumentNull('element');
        }
        var box = {
            top: this.getPadding(element, AjaxControlToolkit.BoxSide.Top),
            right: this.getPadding(element, AjaxControlToolkit.BoxSide.Right),
            bottom: this.getPadding(element, AjaxControlToolkit.BoxSide.Bottom),
            left: this.getPadding(element, AjaxControlToolkit.BoxSide.Left)
        };
        box.horizontal = box.left + box.right;
        box.vertical = box.top + box.bottom;
        return box;
    },
    
    isBorderVisible : function(element, boxSide) {
        /// <summary>
        /// Gets whether the current border style for an element on a specific boxSide is not 'none'.
        /// </summary>
        /// <param name="element" type="Sys.UI.DomElement" domElement="true">
        /// DOM element
        /// </param>
        /// <param name="boxSide" type="AjaxControlToolkit.BoxSide">
        /// Side of the element
        /// </param>
        /// <returns type="Boolean">
        /// Whether the current border style for an element on a specific boxSide is not 'none'.
        /// </returns>
        
        if (!element) {
            throw Error.argumentNull('element');
        }
        if(boxSide < AjaxControlToolkit.BoxSide.Top || boxSide > AjaxControlToolkit.BoxSide.Left) {
            throw Error.argumentOutOfRange(String.format(Sys.Res.enumInvalidValue, boxSide, 'AjaxControlToolkit.BoxSide'));
        }
        var styleName = this._borderStyleNames[boxSide];
        var styleValue = this.getCurrentStyle(element, styleName);
        return styleValue != "none";
    },
    
    getMargin : function(element, boxSide) {
        /// <summary>
        /// Gets the margin thickness of an element on a specific boxSide.
        /// </summary>
        /// <param name="element" type="Sys.UI.DomElement" domElement="true">
        /// DOM element
        /// </param>
        /// <param name="boxSide" type="AjaxControlToolkit.BoxSide">
        /// Side of the element
        /// </param>
        /// <returns type="Number" integer="true">
        /// Margin thickness on the element's specified side
        /// </returns>
        
        if (!element) {
            throw Error.argumentNull('element');
        }
        if(boxSide < AjaxControlToolkit.BoxSide.Top || boxSide > AjaxControlToolkit.BoxSide.Left) {
            throw Error.argumentOutOfRange(String.format(Sys.Res.enumInvalidValue, boxSide, 'AjaxControlToolkit.BoxSide'));
        }
        var styleName = this._marginWidthNames[boxSide];
        var styleValue = this.getCurrentStyle(element, styleName);
        try { return this.parsePadding(styleValue); } catch(ex) { return 0; }
    },

    getBorderWidth : function(element, boxSide) {
        /// <summary>
        /// Gets the border thickness of an element on a specific boxSide.
        /// </summary>
        /// <param name="element" type="Sys.UI.DomElement" domElement="true">
        /// DOM element
        /// </param>
        /// <param name="boxSide" type="AjaxControlToolkit.BoxSide">
        /// Side of the element
        /// </param>
        /// <returns type="Number" integer="true">
        /// Border thickness on the element's specified side
        /// </returns>
        
        if (!element) {
            throw Error.argumentNull('element');
        }
        if(boxSide < AjaxControlToolkit.BoxSide.Top || boxSide > AjaxControlToolkit.BoxSide.Left) {
            throw Error.argumentOutOfRange(String.format(Sys.Res.enumInvalidValue, boxSide, 'AjaxControlToolkit.BoxSide'));
        }
        if(!this.isBorderVisible(element, boxSide)) {
            return 0;
        }        
        var styleName = this._borderWidthNames[boxSide];    
        var styleValue = this.getCurrentStyle(element, styleName);
        return this.parseBorderWidth(styleValue);
    },
    
    getPadding : function(element, boxSide) {
        /// <summary>
        /// Gets the padding thickness of an element on a specific boxSide.
        /// </summary>
        /// <param name="element" type="Sys.UI.DomElement" domElement="true">
        /// DOM element
        /// </param>
        /// <param name="boxSide" type="AjaxControlToolkit.BoxSide">
        /// Side of the element
        /// </param>
        /// <returns type="Number" integer="true">
        /// Padding on the element's specified side
        /// </returns>
        
        if (!element) {
            throw Error.argumentNull('element');
        }
        if(boxSide < AjaxControlToolkit.BoxSide.Top || boxSide > AjaxControlToolkit.BoxSide.Left) {
            throw Error.argumentOutOfRange(String.format(Sys.Res.enumInvalidValue, boxSide, 'AjaxControlToolkit.BoxSide'));
        }
        var styleName = this._paddingWidthNames[boxSide];
        var styleValue = this.getCurrentStyle(element, styleName);
        return this.parsePadding(styleValue);
    },
    
    parseBorderWidth : function(borderWidth) {
        /// <summary>
        /// Parses a border-width string into a pixel size
        /// </summary>
        /// <param name="borderWidth" type="String" mayBeNull="true">
        /// Type of border ('thin','medium','thick','inherit',px unit,null,'')
        /// </param>
        /// <returns type="Number" integer="true">
        /// Number of pixels in the border-width
        /// </returns>
        if (!this._borderThicknesses) {
            
            // Populate the borderThicknesses lookup table
            var borderThicknesses = { };
            var div0 = document.createElement('div');
            div0.style.visibility = 'hidden';
            div0.style.position = 'absolute';
            div0.style.fontSize = '1px';
            document.body.appendChild(div0)
            var div1 = document.createElement('div');
            div1.style.height = '0px';
            div1.style.overflow = 'hidden';
            div0.appendChild(div1);
            var base = div0.offsetHeight;
            div1.style.borderTop = 'solid black';
            div1.style.borderTopWidth = 'thin';
            borderThicknesses['thin'] = div0.offsetHeight - base;
            div1.style.borderTopWidth = 'medium';
            borderThicknesses['medium'] = div0.offsetHeight - base;
            div1.style.borderTopWidth = 'thick';
            borderThicknesses['thick'] = div0.offsetHeight - base;
            div0.removeChild(div1);
            document.body.removeChild(div0);
            this._borderThicknesses = borderThicknesses;
        }
        
        if (borderWidth) {
            switch(borderWidth) {
                case 'thin':
                case 'medium':
                case 'thick':
                    return this._borderThicknesses[borderWidth];
                case 'inherit':
                    return 0;
            }
            var unit = this.parseUnit(borderWidth);
            Sys.Debug.assert(unit.type == 'px', String.format(AjaxControlToolkit.Resources.Common_InvalidBorderWidthUnit, unit.type));
            return unit.size;
        }
        return 0;
    },
    
    parsePadding : function(padding) {
        /// <summary>
        /// Parses a padding string into a pixel size
        /// </summary>
        /// <param name="padding" type="String" mayBeNull="true">
        /// Padding to parse ('inherit',px unit,null,'')
        /// </param>
        /// <returns type="Number" integer="true">
        /// Number of pixels in the padding
        /// </returns>
        
        if(padding) {
            if(padding == 'inherit') {
                return 0;
            }
            var unit = this.parseUnit(padding);
            Sys.Debug.assert(unit.type == 'px', String.format(AjaxControlToolkit.Resources.Common_InvalidPaddingUnit, unit.type));
            return unit.size;
        }
        return 0;
    },
    
    parseUnit : function(value) {
        /// <summary>
        /// Parses a unit string into a unit object
        /// </summary>
        /// <param name="value" type="String" mayBeNull="true">
        /// Value to parse (of the form px unit,% unit,em unit,...)
        /// </param>
        /// <returns type="Object">
        /// Parsed unit (of the form {size,type})
        /// </returns>
        
        if (!value) {
            throw Error.argumentNull('value');
        }
        
        value = value.trim().toLowerCase();
        var l = value.length;
        var s = -1;
        for(var i = 0; i < l; i++) {
            var ch = value.substr(i, 1);
            if((ch < '0' || ch > '9') && ch != '-' && ch != '.' && ch != ',') {
                break;
            }
            s = i;
        }
        if(s == -1) {
            throw Error.create(AjaxControlToolkit.Resources.Common_UnitHasNoDigits);
        }
        var type;
        var size;
        if(s < (l - 1)) {
            type = value.substring(s + 1).trim();
        } else {
            type = 'px';
        }
        size = parseFloat(value.substr(0, s + 1));
        if(type == 'px') {
            size = Math.floor(size);
        }
        return { 
            size: size,
            type: type
        };
    },
    
    getElementOpacity : function(element) {
        /// <summary>
        /// Get the element's opacity
        /// </summary>
        /// <param name="element" type="Sys.UI.DomElement" domElement="true">
        /// Element
        /// </param>
        /// <returns type="Number">
        /// Opacity of the element
        /// </returns>
        
        if (!element) {
            throw Error.argumentNull('element');
        }
        
        var hasOpacity = false;
        var opacity;
        
        if (element.filters) {
            var filters = element.filters;
            if (filters.length !== 0) {
                var alphaFilter = filters['DXImageTransform.Microsoft.Alpha'];
                if (alphaFilter) {
                    opacity = alphaFilter.opacity / 100.0;
                    hasOpacity = true;
                }
            }
        }
        else {
            opacity = this.getCurrentStyle(element, 'opacity', 1);
            hasOpacity = true;
        }
        
        if (hasOpacity === false) {
            return 1.0;
        }
        return parseFloat(opacity);
    },

    setElementOpacity : function(element, value) {
        /// <summary>
        /// Set the element's opacity
        /// </summary>
        /// <param name="element" type="Sys.UI.DomElement" domElement="true">
        /// Element
        /// </param>
        /// <param name="value" type="Number">
        /// Opacity of the element
        /// </param>
        
        if (!element) {
            throw Error.argumentNull('element');
        }
        
        if (element.filters) {
            var filters = element.filters;
            var createFilter = true;
            if (filters.length !== 0) {
                var alphaFilter = filters['DXImageTransform.Microsoft.Alpha'];
                if (alphaFilter) {
                    createFilter = false;
                    alphaFilter.opacity = value * 100;
                }
            }
            if (createFilter) {
                element.style.filter = 'progid:DXImageTransform.Microsoft.Alpha(opacity=' + (value * 100) + ')';
            }
        }
        else {
            element.style.opacity = value;
        }
    },
    
    getVisible : function(element) {
        /// <summary>
        /// Check if an element is visible
        /// </summary>
        /// <param name="element" type="Sys.UI.DomElement" domElement="true">
        /// Element
        /// </param>
        /// <returns type="Boolean" mayBeNull="false">
        /// True if the element is visible, false otherwise
        /// </returns>
        
        // Note: reference to CommonToolkitScripts must be left intact (i.e. don't
        // replace with 'this') because this function will be aliased
        
        return (element &&
                ("none" != $common.getCurrentStyle(element, "display")) &&
                ("hidden" != $common.getCurrentStyle(element, "visibility")));
    },
    
    setVisible : function(element, value) {
        /// <summary>
        /// Check if an element is visible
        /// </summary>
        /// <param name="element" type="Sys.UI.DomElement" domElement="true">
        /// Element
        /// </param>
        /// <param name="value" type="Boolean" mayBeNull="false">
        /// True to make the element visible, false to hide it
        /// </param>
        
        // Note: reference to CommonToolkitScripts must be left intact (i.e. don't
        // replace with 'this') because this function will be aliased
        
        if (element && value != $common.getVisible(element)) {
            if (value) {
                if (element.style.removeAttribute) {
                    element.style.removeAttribute("display");
                } else {
                   element.style.removeProperty("display");
                }
            } else {
                element.style.display = 'none';
            }
            element.style.visibility = value ? 'visible' : 'hidden';
        }
    },
    
    resolveFunction : function(value) {
        /// <summary>
        /// Returns a function reference that corresponds to the provided value
        /// </summary>
        /// <param name="value" type="Object">
        /// The value can either be a Function, the name of a function (that can be found using window['name']),
        /// or an expression that evaluates to a function.
        /// </param>
        /// <returns type="Function">
        /// Reference to the function, or null if not found
        /// </returns>
        
        if (value) {
            if (value instanceof Function) {
                return value;
            } else if (String.isInstanceOfType(value) && value.length > 0) {
                var func;
                if ((func = window[value]) instanceof Function) {
                    return func;
                } else if ((func = eval(value)) instanceof Function) {
                    return func;
                }
            }
        }
        return null;
    },

    addCssClasses : function(element, classNames) {
        /// <summary>
        /// Adds multiple css classes to a DomElement
        /// </summary>
        /// <param name="element" type="Sys.UI.DomElement">The element to modify</param>
        /// <param name="classNames" type="Array">The class names to add</param>
        
        for(var i = 0; i < classNames.length; i++) {
            Sys.UI.DomElement.addCssClass(element, classNames[i]);
        }
    },
    removeCssClasses : function(element, classNames) {
        /// <summary>
        /// Removes multiple css classes to a DomElement
        /// </summary>
        /// <param name="element" type="Sys.UI.DomElement">The element to modify</param>
        /// <param name="classNames" type="Array">The class names to remove</param>
        
        for(var i = 0; i < classNames.length; i++) {
            Sys.UI.DomElement.removeCssClass(element, classNames[i]);
        }
    },
    setStyle : function(element, style) {
        /// <summary>
        /// Sets the style of the element using the supplied style template object
        /// </summary>
        /// <param name="element" type="Sys.UI.DomElement">The element to modify</param>
        /// <param name="style" type="Object">The template</param>

        $common.applyProperties(element.style, style);
    },
    removeHandlers : function(element, events) {
        /// <summary>
        /// Removes a set of event handlers from an element
        /// </summary>
        /// <param name="element" type="Sys.UI.DomElement">The element to modify</param>
        /// <param name="events" type="Object">The template object that contains event names and delegates</param>
        /// <remarks>
        /// This is NOT the same as $clearHandlers which removes all delegates from a DomElement.  This rather removes select delegates 
        /// from a specified element and has a matching signature as $addHandlers
        /// </remarks>
        for (var name in events) {
            $removeHandler(element, name, events[name]);
        }
    },
    
    overlaps : function(r1, r2) {
        /// <summary>
        /// Determine if two rectangles overlap
        /// </summary>
        /// <param name="r1" type="Object">
        /// Rectangle
        /// </param>
        /// <param name="r2" type="Object">
        /// Rectangle
        /// </param>
        /// <returns type="Boolean">
        /// True if the rectangles overlap, false otherwise
        /// </returns>
        
         return r1.x < (r2.x + r2.width)
                && r2.x < (r1.x + r1.width)
                && r1.y < (r2.y + r2.height)
                && r2.y < (r1.y + r1.height);
    },
    
    containsPoint : function(rect, x, y) {
        /// <summary>
        /// Tests whether a point (x,y) is contained within a rectangle
        /// </summary>
        /// <param name="rect" type="Object">The rectangle</param>
        /// <param name="x" type="Number">The x coordinate of the point</param>
        /// <param name="y" type="Number">The y coordinate of the point</param>
        
        return x >= rect.x && x < (rect.x + rect.width) && y >= rect.y && y < (rect.y + rect.height);
    },

    isKeyDigit : function(keyCode) { 
        /// <summary>
        /// Gets whether the supplied key-code is a digit
        /// </summary>
        /// <param name="keyCode" type="Number" integer="true">The key code of the event (from Sys.UI.DomEvent)</param>
        /// <returns type="Boolean" />

        return (0x30 <= keyCode && keyCode <= 0x39); 
    },
    
    isKeyNavigation : function(keyCode) { 
        /// <summary>
        /// Gets whether the supplied key-code is a navigation key
        /// </summary>
        /// <param name="keyCode" type="Number" integer="true">The key code of the event (from Sys.UI.DomEvent)</param>
        /// <returns type="Boolean" />

        return (Sys.UI.Key.left <= keyCode && keyCode <= Sys.UI.Key.down); 
    },
    
    padLeft : function(text, size, ch, truncate) { 
        /// <summary>
        /// Pads the left hand side of the supplied text with the specified pad character up to the requested size
        /// </summary>
        /// <param name="text" type="String">The text to pad</param>
        /// <param name="size" type="Number" integer="true" optional="true">The size to pad the text (default is 2)</param>
        /// <param name="ch" type="String" optional="true">The single character to use as the pad character (default is ' ')</param>
        /// <param name="truncate" type="Boolean" optional="true">Whether to truncate the text to size (default is false)</param>
        
        return $common._pad(text, size || 2, ch || ' ', 'l', truncate || false); 
    },
    
    padRight : function(text, size, ch, truncate) { 
        /// <summary>
        /// Pads the right hand side of the supplied text with the specified pad character up to the requested size
        /// </summary>
        /// <param name="text" type="String">The text to pad</param>
        /// <param name="size" type="Number" integer="true" optional="true">The size to pad the text (default is 2)</param>
        /// <param name="ch" type="String" optional="true">The single character to use as the pad character (default is ' ')</param>
        /// <param name="truncate" type="Boolean" optional="true">Whether to truncate the text to size (default is false)</param>

        return $common._pad(text, size || 2, ch || ' ', 'r', truncate || false); 
    },
    
    _pad : function(text, size, ch, side, truncate) {
        /// <summary>
        /// Pads supplied text with the specified pad character up to the requested size
        /// </summary>
        /// <param name="text" type="String">The text to pad</param>
        /// <param name="size" type="Number" integer="true">The size to pad the text</param>
        /// <param name="ch" type="String">The single character to use as the pad character</param>
        /// <param name="side" type="String">Either 'l' or 'r' to siginfy whether to pad the Left or Right side respectively</param>
        /// <param name="truncate" type="Boolean">Whether to truncate the text to size</param>

        text = text.toString();
        var length = text.length;
        var builder = new Sys.StringBuilder();
        if (side == 'r') {
            builder.append(text);
        } 
        while (length < size) {
            builder.append(ch);
            length++;
        }
        if (side == 'l') {
            builder.append(text);
        }
        var result = builder.toString();
        if (truncate && result.length > size) {
            if (side == 'l') {
                result = result.substr(result.length - size, size);
            } else {
                result = result.substr(0, size);
            }
        }
        return result;
    },
    
    __DOMEvents : {
        focusin : { eventGroup : "UIEvents", init : function(e, p) { e.initUIEvent("focusin", true, false, window, 1); } },
        focusout : { eventGroup : "UIEvents", init : function(e, p) { e.initUIEvent("focusout", true, false, window, 1); } },
        activate : { eventGroup : "UIEvents", init : function(e, p) { e.initUIEvent("activate", true, true, window, 1); } },
        focus : { eventGroup : "UIEvents", init : function(e, p) { e.initUIEvent("focus", false, false, window, 1); } },
        blur : { eventGroup : "UIEvents", init : function(e, p) { e.initUIEvent("blur", false, false, window, 1); } },
        click : { eventGroup : "MouseEvents", init : function(e, p) { e.initMouseEvent("click", true, true, window, 1, p.screenX || 0, p.screenY || 0, p.clientX || 0, p.clientY || 0, p.ctrlKey || false, p.altKey || false, p.shiftKey || false, p.metaKey || false, p.button || 0, p.relatedTarget || null); } },
        dblclick : { eventGroup : "MouseEvents", init : function(e, p) { e.initMouseEvent("click", true, true, window, 2, p.screenX || 0, p.screenY || 0, p.clientX || 0, p.clientY || 0, p.ctrlKey || false, p.altKey || false, p.shiftKey || false, p.metaKey || false, p.button || 0, p.relatedTarget || null); } },
        mousedown : { eventGroup : "MouseEvents", init : function(e, p) { e.initMouseEvent("mousedown", true, true, window, 1, p.screenX || 0, p.screenY || 0, p.clientX || 0, p.clientY || 0, p.ctrlKey || false, p.altKey || false, p.shiftKey || false, p.metaKey || false, p.button || 0, p.relatedTarget || null); } },
        mouseup : { eventGroup : "MouseEvents", init : function(e, p) { e.initMouseEvent("mouseup", true, true, window, 1, p.screenX || 0, p.screenY || 0, p.clientX || 0, p.clientY || 0, p.ctrlKey || false, p.altKey || false, p.shiftKey || false, p.metaKey || false, p.button || 0, p.relatedTarget || null); } },
        mouseover : { eventGroup : "MouseEvents", init : function(e, p) { e.initMouseEvent("mouseover", true, true, window, 1, p.screenX || 0, p.screenY || 0, p.clientX || 0, p.clientY || 0, p.ctrlKey || false, p.altKey || false, p.shiftKey || false, p.metaKey || false, p.button || 0, p.relatedTarget || null); } },
        mousemove : { eventGroup : "MouseEvents", init : function(e, p) { e.initMouseEvent("mousemove", true, true, window, 1, p.screenX || 0, p.screenY || 0, p.clientX || 0, p.clientY || 0, p.ctrlKey || false, p.altKey || false, p.shiftKey || false, p.metaKey || false, p.button || 0, p.relatedTarget || null); } },
        mouseout : { eventGroup : "MouseEvents", init : function(e, p) { e.initMouseEvent("mousemove", true, true, window, 1, p.screenX || 0, p.screenY || 0, p.clientX || 0, p.clientY || 0, p.ctrlKey || false, p.altKey || false, p.shiftKey || false, p.metaKey || false, p.button || 0, p.relatedTarget || null); } },
        load : { eventGroup : "HTMLEvents", init : function(e, p) { e.initEvent("load", false, false); } },
        unload : { eventGroup : "HTMLEvents", init : function(e, p) { e.initEvent("unload", false, false); } },
        select : { eventGroup : "HTMLEvents", init : function(e, p) { e.initEvent("select", true, false); } },
        change : { eventGroup : "HTMLEvents", init : function(e, p) { e.initEvent("change", true, false); } },
        submit : { eventGroup : "HTMLEvents", init : function(e, p) { e.initEvent("submit", true, true); } },
        reset : { eventGroup : "HTMLEvents", init : function(e, p) { e.initEvent("reset", true, false); } },
        resize : { eventGroup : "HTMLEvents", init : function(e, p) { e.initEvent("resize", true, false); } },
        scroll : { eventGroup : "HTMLEvents", init : function(e, p) { e.initEvent("scroll", true, false); } }
    },
    
    tryFireRawEvent : function(element, rawEvent) {
        /// <summary>
        /// Attempts to fire a raw DOM event on an element
        /// </summary>
        /// <param name="element" type="Sys.UI.DomElement">The element to fire the event</param>
        /// <param name="rawEvent" type="Object">The raw DOM event object to fire. Must not be Sys.UI.DomEvent</param>
        /// <returns type="Boolean">True if the event was successfully fired, otherwise false</returns>
        
        try {
            if (element.fireEvent) {
                element.fireEvent("on" + rawEvent.type, rawEvent);
                return true;
            } else if (element.dispatchEvent) {
                element.dispatchEvent(rawEvent);
                return true;
            }
        } catch (e) {
        }
        return false;
    },    

    tryFireEvent : function(element, eventName, properties) {
        /// <summary>
        /// Attempts to fire a DOM event on an element
        /// </summary>
        /// <param name="element" type="Sys.UI.DomElement">The element to fire the event</param>
        /// <param name="eventName" type="String">The name of the event to fire (without an 'on' prefix)</param>
        /// <param name="properties" type="Object">Properties to add to the event</param>
        /// <returns type="Boolean">True if the event was successfully fired, otherwise false</returns>
        
        try {
            if (document.createEventObject) {
                var e = document.createEventObject();
                $common.applyProperties(e, properties || {});
                element.fireEvent("on" + eventName, e);
                return true;
            } else if (document.createEvent) {
                var def = $common.__DOMEvents[eventName];
                if (def) {
                    var e = document.createEvent(def.eventGroup);
                    def.init(e, properties || {});
                    element.dispatchEvent(e);
                    return true;
                }
            }
        } catch (e) {
        }
        return false;
    },

    wrapElement : function(innerElement, newOuterElement, newInnerParentElement) {
        /// <summary>
        /// Wraps an inner element with a new outer element at the same DOM location as the inner element
        /// </summary>
        /// <param name="innerElement" type="Sys.UI.DomElement">The element to be wrapped</param>
        /// <param name="newOuterElement" type="Sys.UI.DomElement">The new parent for the element</param>
        /// <returns />
        
        var parent = innerElement.parentNode;
        parent.replaceChild(newOuterElement, innerElement);        
        (newInnerParentElement || newOuterElement).appendChild(innerElement);
    },

    unwrapElement : function(innerElement, oldOuterElement) {
        /// <summary>
        /// Unwraps an inner element from an outer element at the same DOM location as the outer element
        /// </summary>
        /// <param name="innerElement" type="Sys.UI.DomElement">The element to be wrapped</param>
        /// <param name="newOuterElement" type="Sys.UI.DomElement">The new parent for the element</param>
        /// <returns />

        var parent = oldOuterElement.parentNode;
        if (parent != null) {
            $common.removeElement(innerElement);
            parent.replaceChild(innerElement, oldOuterElement);
        }
    },
    
    removeElement : function(element) {
        /// <summary>
        /// Removes an element from the DOM tree
        /// </summary>
        /// <param name="element" type="Sys.UI.DomElement">The element to be removed</param>
        /// <returns />

        var parent = element.parentNode;
        if (parent != null) {
            parent.removeChild(element);
        }
    },
 
    applyProperties : function(target, properties) {
        /// <summary>
        /// Quick utility method to copy properties from a template object to a target object
        /// </summary>
        /// <param name="target" type="Object">The object to apply to</param>
        /// <param name="properties" type="Object">The template to copy values from</param>
        
        for (var p in properties) {
            var pv = properties[p];
            if (pv != null && Object.getType(pv)===Object) {
                var tv = target[p];
                $common.applyProperties(tv, pv);
            } else {
                target[p] = pv;
            }
        }
    },
        
    createElementFromTemplate : function(template, appendToParent, nameTable) {
        /// <summary>
        /// Creates an element for the current document based on a template object
        /// </summary>
        /// <param name="template" type="Object">The template from which to create the element</param>
        /// <param name="appendToParent" type="Sys.UI.DomElement" optional="true" mayBeNull="true">A DomElement under which to append this element</param>
        /// <param name="nameTable" type="Object" optional="true" mayBeNull="true">An object to use as the storage for the element using template.name as the key</param>
        /// <returns type="Sys.UI.DomElement" />
        /// <remarks>
        /// This method is useful if you find yourself using the same or similar DomElement constructions throughout a class.  You can even set the templates
        /// as static properties for a type to cut down on overhead.  This method is often called with a JSON style template:
        /// <code>
        /// var elt = $common.createElementFromTemplate({
        ///     nodeName : "div",
        ///     properties : {
        ///         style : {
        ///             height : "100px",
        ///             width : "100px",
        ///             backgroundColor : "white"
        ///         },
        ///         expandoAttribute : "foo"
        ///     },
        ///     events : {
        ///         click : function() { alert("foo"); },
        ///         mouseover : function() { elt.backgroundColor = "silver"; },
        ///         mouseout : function() { elt.backgroundColor = "white"; }
        ///     },
        ///     cssClasses : [ "class0", "class1" ],
        ///     visible : true,
        ///     opacity : .5
        /// }, someParent);
        /// </code>
        /// </remarks>
        
        // if we wish to override the name table we do so here
        if (typeof(template.nameTable)!='undefined') {
            var newNameTable = template.nameTable;
            if (String.isInstanceOfType(newNameTable)) {
                newNameTable = nameTable[newNameTable];
            }
            if (newNameTable != null) {
                nameTable = newNameTable;
            }
        }
        
        // get a name for the element in the nameTable
        var elementName = null;
        if (typeof(template.name)!=='undefined') {
            elementName = template.name;
        }
        
        // create or acquire the element
        var elt = document.createElement(template.nodeName);
        
        // if our element is named, add it to the name table
        if (typeof(template.name)!=='undefined' && nameTable) {
            nameTable[template.name] = elt;
        }
        
        // if we wish to supply a default parent we do so here
        if (typeof(template.parent)!=='undefined' && appendToParent == null) {
            var newParent = template.parent;
            if (String.isInstanceOfType(newParent)) {
                newParent = nameTable[newParent];
            }
            if (newParent != null) {
                appendToParent = newParent;
            }
        }
        
        // properties are applied as expando values to the element
        if (typeof(template.properties)!=='undefined' && template.properties != null) {
            $common.applyProperties(elt, template.properties);
        }
        
        // css classes are added to the element's className property
        if (typeof(template.cssClasses)!=='undefined' && template.cssClasses != null) {
            $common.addCssClasses(elt, template.cssClasses);
        }
        
        // events are added to the dom element using $addHandlers
        if (typeof(template.events)!=='undefined' && template.events != null) {
            $addHandlers(elt, template.events);
        }
        
        // if the element is visible or not its visibility is set
        if (typeof(template.visible)!=='undefined' && template.visible != null) {
            this.setVisible(elt, template.visible);
        }
        
        // if we have an appendToParent we will now append to it
        if (appendToParent) {
            appendToParent.appendChild(elt);
        }

        // if we have opacity, apply it
        if (typeof(template.opacity)!=='undefined' && template.opacity != null) {
            $common.setElementOpacity(elt, template.opacity);
        }
        
        // if we have child templates, process them
        if (typeof(template.children)!=='undefined' && template.children != null) {
            for (var i = 0; i < template.children.length; i++) {
                var subtemplate = template.children[i];
                $common.createElementFromTemplate(subtemplate, elt, nameTable);
            }
        }
        
        // if we have a content presenter for the element get it (the element itself is the default presenter for content)
        var contentPresenter = elt;
        if (typeof(template.contentPresenter)!=='undefined' && template.contentPresenter != null) {
            contentPresenter = nameTable[contentPresenter];
        }
        
        // if we have content, add it
        if (typeof(template.content)!=='undefined' && template.content != null) {
            var content = template.content;
            if (String.isInstanceOfType(content)) {
                content = nameTable[content];
            }
            if (content.parentNode) {
                $common.wrapElement(content, elt, contentPresenter);
            } else {
                contentPresenter.appendChild(content);
            }
        }
        
        // return the created element
        return elt;
    },
    
    prepareHiddenElementForATDeviceUpdate : function () {
        /// <summary>
        /// JAWS, an Assistive Technology device responds to updates to form elements 
        /// and refreshes its document buffer to what is showing live
        /// in the browser. To ensure that Toolkit controls that make XmlHttpRequests to
        /// retrieve content are useful to users with visual disabilities, we update a
        /// hidden form element to ensure that JAWS conveys what is in
        /// the browser. See this article for more details: 
        /// http://juicystudio.com/article/improving-ajax-applications-for-jaws-users.php
        /// This method creates a hidden input on the screen for any page that uses a Toolkit
        /// control that will perform an XmlHttpRequest.
        /// </summary>   
        var objHidden = document.getElementById('hiddenInputToUpdateATBuffer_CommonToolkitScripts');
        if (!objHidden) {
            var objHidden = document.createElement('input');
            objHidden.setAttribute('type', 'hidden');
            objHidden.setAttribute('value', '1');
            objHidden.setAttribute('id', 'hiddenInputToUpdateATBuffer_CommonToolkitScripts');
            objHidden.setAttribute('name', 'hiddenInputToUpdateATBuffer_CommonToolkitScripts');
            if ( document.forms[0] ) {
                document.forms[0].appendChild(objHidden);
            }
        }
    },
    
    updateFormToRefreshATDeviceBuffer : function () {
        /// <summary>
        /// Updates the hidden buffer to ensure that the latest document stream is picked up
        /// by the screen reader.
        /// </summary>
        var objHidden = document.getElementById('hiddenInputToUpdateATBuffer_CommonToolkitScripts');

        if (objHidden) {
            if (objHidden.getAttribute('value') == '1') {
                objHidden.setAttribute('value', '0');
            } else {
                objHidden.setAttribute('value', '1');
            }
        }
    }
}

// Create the singleton instance of the CommonToolkitScripts
var CommonToolkitScripts = AjaxControlToolkit.CommonToolkitScripts = new AjaxControlToolkit._CommonToolkitScripts();
var $common = CommonToolkitScripts;

// Alias functions that were moved from BlockingScripts into Common
Sys.UI.DomElement.getVisible = $common.getVisible;
Sys.UI.DomElement.setVisible = $common.setVisible;
Sys.UI.Control.overlaps = $common.overlaps;

AjaxControlToolkit._DomUtility = function() {
    /// <summary>
    /// Utility functions for manipulating the DOM
    /// </summary>
}
AjaxControlToolkit._DomUtility.prototype = {
    isDescendant : function(ancestor, descendant) {
        /// <summary>
        /// Whether the specified element is a descendant of the ancestor
        /// </summary>
        /// <param name="ancestor" type="Sys.UI.DomElement">Ancestor node</param>
        /// <param name="descendant" type="Sys.UI.DomElement">Possible descendant node</param>
        /// <returns type="Boolean" />
        
        for (var n = descendant.parentNode; n != null; n = n.parentNode) {
            if (n == ancestor) return true;
        }
        return false;
    },
    isDescendantOrSelf : function(ancestor, descendant) {
        /// <summary>
        /// Whether the specified element is a descendant of the ancestor or the same as the ancestor
        /// </summary>
        /// <param name="ancestor" type="Sys.UI.DomElement">Ancestor node</param>
        /// <param name="descendant" type="Sys.UI.DomElement">Possible descendant node</param>
        /// <returns type="Boolean" />

        if (ancestor === descendant) 
            return true;
        return AjaxControlToolkit.DomUtility.isDescendant(ancestor, descendant);
    },
    isAncestor : function(descendant, ancestor) {
        /// <summary>
        /// Whether the specified element is an ancestor of the descendant
        /// </summary>
        /// <param name="descendant" type="Sys.UI.DomElement">Descendant node</param>
        /// <param name="ancestor" type="Sys.UI.DomElement">Possible ancestor node</param>
        /// <returns type="Boolean" />

        return AjaxControlToolkit.DomUtility.isDescendant(ancestor, descendant);
    },
    isAncestorOrSelf : function(descendant, ancestor) {
        /// <summary>
        /// Whether the specified element is an ancestor of the descendant or the same as the descendant
        /// </summary>
        /// <param name="descendant" type="Sys.UI.DomElement">Descendant node</param>
        /// <param name="ancestor" type="Sys.UI.DomElement">Possible ancestor node</param>
        /// <returns type="Boolean" />
        
        if (descendant === ancestor)
            return true;
            
        return AjaxControlToolkit.DomUtility.isDescendant(ancestor, descendant);
    },
    isSibling : function(self, sibling) {
        /// <summary>
        /// Whether the specified element is a sibling of the self element
        /// </summary>
        /// <param name="self" type="Sys.UI.DomElement">Self node</param>
        /// <param name="sibling" type="Sys.UI.DomElement">Possible sibling node</param>
        /// <returns type="Boolean" />
        
        var parent = self.parentNode;
        for (var i = 0; i < parent.childNodes.length; i++) {
            if (parent.childNodes[i] == sibling) return true;
        }
        return false;
    }
}
AjaxControlToolkit._DomUtility.registerClass("AjaxControlToolkit._DomUtility");
AjaxControlToolkit.DomUtility = new AjaxControlToolkit._DomUtility();


AjaxControlToolkit.TextBoxWrapper = function(element) {
    /// <summary>
    /// Class that wraps a TextBox (INPUT type="text") to abstract-out the
    /// presence of a watermark (which may be visible to the user but which
    /// should never be read by script.
    /// </summary>
    /// <param name="element" type="Sys.UI.DomElement" domElement="true">
    /// The DOM element the behavior is associated with
    /// </param>
    AjaxControlToolkit.TextBoxWrapper.initializeBase(this, [element]);
    this._current = element.value;
    this._watermark = null;
    this._isWatermarked = false;
}

AjaxControlToolkit.TextBoxWrapper.prototype = {

    dispose : function() {
        /// <summary>
        /// Dispose the behavior
        /// </summary>
        this.get_element().AjaxControlToolkitTextBoxWrapper = null;
        AjaxControlToolkit.TextBoxWrapper.callBaseMethod(this, 'dispose');
    },

    get_Current : function() {
        /// <value type="String">
        /// Current value actually in the TextBox (i.e., TextBox.value)
        /// </value>
        this._current = this.get_element().value;
        return this._current;
    },
    set_Current : function(value) {
        this._current = value;
        this._updateElement();
    },

    get_Value : function() {
        /// <value type="String">
        /// Conceptual "value" of the TextBox - its contents if no watermark is present
        /// or "" if one is
        /// </value>
        if (this.get_IsWatermarked()) {
            return "";
        } else {
            return this.get_Current();
        }
    },
    set_Value : function(text) {
        this.set_Current(text);
        if (!text || (0 == text.length)) {
            if (null != this._watermark) {
                this.set_IsWatermarked(true);
            }
        } else {
            this.set_IsWatermarked(false);
        }
    },

    get_Watermark : function() {
        /// <value type="String">
        /// Text of the watermark for the TextBox
        /// </value>
        return this._watermark;
    },
    set_Watermark : function(value) {
        this._watermark = value;
        this._updateElement();
    },

    get_IsWatermarked : function() {
        /// <value type="Boolean">
        /// true iff the TextBox is watermarked
        /// </value>
        return this._isWatermarked;
    },
    set_IsWatermarked : function(isWatermarked) {
        if (this._isWatermarked != isWatermarked) {
            this._isWatermarked = isWatermarked;
            this._updateElement();
            this._raiseWatermarkChanged();
        }
    },

    _updateElement : function() {
        /// <summary>
        /// Updates the actual contents of the TextBox according to what should be there
        /// </summary>
        var element = this.get_element();
        if (this._isWatermarked) {
            if (element.value != this._watermark) {
                element.value = this._watermark;
            }
        } else {
            if (element.value != this._current) {
                element.value = this._current;
            }
        }
    },

    add_WatermarkChanged : function(handler) {
        /// <summary>
        /// Adds a handler for the WatermarkChanged event
        /// </summary>
        /// <param name="handler" type="Function">
        /// Handler
        /// </param>
        this.get_events().addHandler("WatermarkChanged", handler);
    },
    remove_WatermarkChanged : function(handler) {
        /// <summary>
        /// Removes a handler for the WatermarkChanged event
        /// </summary>
        /// <param name="handler" type="Function">
        /// Handler
        /// </param>
        this.get_events().removeHandler("WatermarkChanged", handler);
    },
    _raiseWatermarkChanged : function() {
        /// <summary>
        /// Raises the WatermarkChanged event
        /// </summary>
        var onWatermarkChangedHandler = this.get_events().getHandler("WatermarkChanged");
        if (onWatermarkChangedHandler) {
            onWatermarkChangedHandler(this, Sys.EventArgs.Empty);
        }
    }
}
AjaxControlToolkit.TextBoxWrapper.get_Wrapper = function(element) {
    /// <summary>
    /// Gets (creating one if necessary) the TextBoxWrapper for the specified TextBox
    /// </summary>
    /// <param name="element" type="Sys.UI.DomElement" domElement="true">
    /// TextBox for which to get the wrapper
    /// </param>
    /// <returns type="AjaxControlToolkit.TextBoxWrapper">
    /// TextBoxWrapper instance
    /// </returns>
    if (null == element.AjaxControlToolkitTextBoxWrapper) {
        element.AjaxControlToolkitTextBoxWrapper = new AjaxControlToolkit.TextBoxWrapper(element);
    }
    return element.AjaxControlToolkitTextBoxWrapper;
}
AjaxControlToolkit.TextBoxWrapper.registerClass('AjaxControlToolkit.TextBoxWrapper', Sys.UI.Behavior);

AjaxControlToolkit.TextBoxWrapper.validatorGetValue = function(id) {
    /// <summary>
    /// Wrapper for ASP.NET's validatorGetValue to return the value from the wrapper if present
    /// </summary>
    /// <param name="id" type="String">
    /// id of the element
    /// </param>
    /// <returns type="Object">
    /// Value from the wrapper or result of original ValidatorGetValue
    /// </returns>
    var control = $get(id);
    if (control && control.AjaxControlToolkitTextBoxWrapper) {
        return control.AjaxControlToolkitTextBoxWrapper.get_Value();
    }
    return AjaxControlToolkit.TextBoxWrapper._originalValidatorGetValue(id);
}

// Wrap ASP.NET's ValidatorGetValue with AjaxControlToolkit.TextBoxWrapper.validatorGetValue
// to make validators work properly with watermarked TextBoxes
if (typeof(ValidatorGetValue) == 'function') {
    AjaxControlToolkit.TextBoxWrapper._originalValidatorGetValue = ValidatorGetValue;
    ValidatorGetValue = AjaxControlToolkit.TextBoxWrapper.validatorGetValue;
}


// Temporary fix null reference bug in Sys.CultureInfo._getAbbrMonthIndex
if (Sys.CultureInfo.prototype._getAbbrMonthIndex) {
    try {
        Sys.CultureInfo.prototype._getAbbrMonthIndex('');
    } catch(ex) {
        Sys.CultureInfo.prototype._getAbbrMonthIndex = function(value) {
            if (!this._upperAbbrMonths) {
                this._upperAbbrMonths = this._toUpperArray(this.dateTimeFormat.AbbreviatedMonthNames);
            }
            return Array.indexOf(this._upperAbbrMonths, this._toUpper(value));
        }
        Sys.CultureInfo.CurrentCulture._getAbbrMonthIndex = Sys.CultureInfo.prototype._getAbbrMonthIndex;
        Sys.CultureInfo.InvariantCulture._getAbbrMonthIndex = Sys.CultureInfo.prototype._getAbbrMonthIndex;
    }
}

//END AjaxControlToolkit.Common.Common.js
//START AjaxControlToolkit.ExtenderBase.BaseScripts.js
// (c) Copyright Microsoft Corporation.
// This source is subject to the Microsoft Permissive License.
// See http://www.microsoft.com/resources/sharedsource/licensingbasics/sharedsourcelicenses.mspx.
// All other rights reserved.


/// <reference name="MicrosoftAjax.debug.js" />
/// <reference name="MicrosoftAjaxTimer.debug.js" />
/// <reference name="MicrosoftAjaxWebForms.debug.js" />


Type.registerNamespace('AjaxControlToolkit');

// This is the base behavior for all extender behaviors
AjaxControlToolkit.BehaviorBase = function(element) {
    /// <summary>
    /// Base behavior for all extender behaviors
    /// </summary>
    /// <param name="element" type="Sys.UI.DomElement" domElement="true">
    /// Element the behavior is associated with
    /// </param>
    AjaxControlToolkit.BehaviorBase.initializeBase(this,[element]);
    
    this._clientStateFieldID = null;
    this._pageRequestManager = null;
    this._partialUpdateBeginRequestHandler = null;
    this._partialUpdateEndRequestHandler = null;
}
AjaxControlToolkit.BehaviorBase.prototype = {
    initialize : function() {
        /// <summary>
        /// Initialize the behavior
        /// </summary>

        // TODO: Evaluate necessity
        AjaxControlToolkit.BehaviorBase.callBaseMethod(this, 'initialize');
    },

    dispose : function() {
        /// <summary>
        /// Dispose the behavior
        /// </summary>
        AjaxControlToolkit.BehaviorBase.callBaseMethod(this, 'dispose');

        if (this._pageRequestManager) {
            if (this._partialUpdateBeginRequestHandler) {
                this._pageRequestManager.remove_beginRequest(this._partialUpdateBeginRequestHandler);
                this._partialUpdateBeginRequestHandler = null;
            }
            if (this._partialUpdateEndRequestHandler) {
                this._pageRequestManager.remove_endRequest(this._partialUpdateEndRequestHandler);
                this._partialUpdateEndRequestHandler = null;
            }
            this._pageRequestManager = null;
        }
    },

    get_ClientStateFieldID : function() {
        /// <value type="String">
        /// ID of the hidden field used to store client state
        /// </value>
        return this._clientStateFieldID;
    },
    set_ClientStateFieldID : function(value) {
        if (this._clientStateFieldID != value) {
            this._clientStateFieldID = value;
            this.raisePropertyChanged('ClientStateFieldID');
        }
    },

    get_ClientState : function() {
        /// <value type="String">
        /// Client state
        /// </value>
        if (this._clientStateFieldID) {
            var input = document.getElementById(this._clientStateFieldID);
            if (input) {
                return input.value;
            }
        }
        return null;
    },
    set_ClientState : function(value) {
        if (this._clientStateFieldID) {
            var input = document.getElementById(this._clientStateFieldID);
            if (input) {
                input.value = value;
            }
        }
    },

    registerPartialUpdateEvents : function() {
        /// <summary>
        /// Register for beginRequest and endRequest events on the PageRequestManager,
        /// (which cause _partialUpdateBeginRequest and _partialUpdateEndRequest to be
        /// called when an UpdatePanel refreshes)
        /// </summary>

        if (Sys && Sys.WebForms && Sys.WebForms.PageRequestManager){
            this._pageRequestManager = Sys.WebForms.PageRequestManager.getInstance();
            if (this._pageRequestManager) {
                this._partialUpdateBeginRequestHandler = Function.createDelegate(this, this._partialUpdateBeginRequest);
                this._pageRequestManager.add_beginRequest(this._partialUpdateBeginRequestHandler);
                this._partialUpdateEndRequestHandler = Function.createDelegate(this, this._partialUpdateEndRequest);
                this._pageRequestManager.add_endRequest(this._partialUpdateEndRequestHandler);
            }
        }
    },

    _partialUpdateBeginRequest : function(sender, beginRequestEventArgs) {
        /// <summary>
        /// Method that will be called when a partial update (via an UpdatePanel) begins,
        /// if registerPartialUpdateEvents() has been called.
        /// </summary>
        /// <param name="sender" type="Object">
        /// Sender
        /// </param>
        /// <param name="beginRequestEventArgs" type="Sys.WebForms.BeginRequestEventArgs">
        /// Event arguments
        /// </param>

        // Nothing done here; override this method in a child class
    },
    
    _partialUpdateEndRequest : function(sender, endRequestEventArgs) {
        /// <summary>
        /// Method that will be called when a partial update (via an UpdatePanel) finishes,
        /// if registerPartialUpdateEvents() has been called.
        /// </summary>
        /// <param name="sender" type="Object">
        /// Sender
        /// </param>
        /// <param name="endRequestEventArgs" type="Sys.WebForms.EndRequestEventArgs">
        /// Event arguments
        /// </param>

        // Nothing done here; override this method in a child class
    }
}
AjaxControlToolkit.BehaviorBase.registerClass('AjaxControlToolkit.BehaviorBase', Sys.UI.Behavior);


// Dynamically populates content when the populate method is called
AjaxControlToolkit.DynamicPopulateBehaviorBase = function(element) {
    /// <summary>
    /// DynamicPopulateBehaviorBase is used to add DynamicPopulateBehavior funcitonality
    /// to other extenders.  It will dynamically populate the contents of the target element
    /// when its populate method is called.
    /// </summary>
    /// <param name="element" type="Sys.UI.DomElement" domElement="true">
    /// DOM Element the behavior is associated with
    /// </param>
    AjaxControlToolkit.DynamicPopulateBehaviorBase.initializeBase(this, [element]);
    
    this._DynamicControlID = null;
    this._DynamicContextKey = null;
    this._DynamicServicePath = null;
    this._DynamicServiceMethod = null;
    this._cacheDynamicResults = false;
    this._dynamicPopulateBehavior = null;
    this._populatingHandler = null;
    this._populatedHandler = null;
}
AjaxControlToolkit.DynamicPopulateBehaviorBase.prototype = {
    initialize : function() {
        /// <summary>
        /// Initialize the behavior
        /// </summary>

        AjaxControlToolkit.DynamicPopulateBehaviorBase.callBaseMethod(this, 'initialize');

        // Create event handlers
        this._populatingHandler = Function.createDelegate(this, this._onPopulating);
        this._populatedHandler = Function.createDelegate(this, this._onPopulated);
    },

    dispose : function() {
        /// <summary>
        /// Dispose the behavior
        /// </summary>

        // Dispose of event handlers
        if (this._populatedHandler) {
            if (this._dynamicPopulateBehavior) {
                this._dynamicPopulateBehavior.remove_populated(this._populatedHandler);
            }
            this._populatedHandler = null;
        }
        if (this._populatingHandler) {
            if (this._dynamicPopulateBehavior) {
                this._dynamicPopulateBehavior.remove_populating(this._populatingHandler);
            }
            this._populatingHandler = null;
        }

        // Dispose of the placeholder control and behavior
        if (this._dynamicPopulateBehavior) {
            this._dynamicPopulateBehavior.dispose();
            this._dynamicPopulateBehavior = null;
        }
        AjaxControlToolkit.DynamicPopulateBehaviorBase.callBaseMethod(this, 'dispose');
    },

    populate : function(contextKeyOverride) {
        /// <summary>
        /// Demand-create the DynamicPopulateBehavior and use it to populate the target element
        /// </summary>
        /// <param name="contextKeyOverride" type="String" mayBeNull="true" optional="true">
        /// An arbitrary string value to be passed to the web method. For example, if the element to be populated is within a data-bound repeater, this could be the ID of the current row.
        /// </param>

        // If the DynamicPopulateBehavior's element is out of date, dispose of it
        if (this._dynamicPopulateBehavior && (this._dynamicPopulateBehavior.get_element() != $get(this._DynamicControlID))) {
            this._dynamicPopulateBehavior.dispose();
            this._dynamicPopulateBehavior = null;
        }
        
        // If a DynamicPopulateBehavior is not available and the necessary information is, create one
        if (!this._dynamicPopulateBehavior && this._DynamicControlID && this._DynamicServiceMethod) {
            this._dynamicPopulateBehavior = $create(AjaxControlToolkit.DynamicPopulateBehavior,
                {
                    "id" : this.get_id() + "_DynamicPopulateBehavior",
                    "ContextKey" : this._DynamicContextKey,
                    "ServicePath" : this._DynamicServicePath,
                    "ServiceMethod" : this._DynamicServiceMethod,
                    "cacheDynamicResults" : this._cacheDynamicResults
                }, null, null, $get(this._DynamicControlID));

            // Attach event handlers
            this._dynamicPopulateBehavior.add_populating(this._populatingHandler);
            this._dynamicPopulateBehavior.add_populated(this._populatedHandler);
        }
        
        // If a DynamicPopulateBehavior is available, use it to populate the dynamic content
        if (this._dynamicPopulateBehavior) {
            this._dynamicPopulateBehavior.populate(contextKeyOverride ? contextKeyOverride : this._DynamicContextKey);
        }
    },

    _onPopulating : function(sender, eventArgs) {
        /// <summary>
        /// Handler for DynamicPopulate behavior's Populating event
        /// </summary>
        /// <param name="sender" type="Object">
        /// DynamicPopulate behavior
        /// </param>
        /// <param name="eventArgs" type="Sys.CancelEventArgs" mayBeNull="false">
        /// Event args
        /// </param>
        this.raisePopulating(eventArgs);
    },

    _onPopulated : function(sender, eventArgs) {
        /// <summary>
        /// Handler for DynamicPopulate behavior's Populated event
        /// </summary>
        /// <param name="sender" type="Object">
        /// DynamicPopulate behavior
        /// </param>
        /// <param name="eventArgs" type="Sys.EventArgs" mayBeNull="false">
        /// Event args
        /// </param>
        this.raisePopulated(eventArgs);
    },

    get_dynamicControlID : function() {
        /// <value type="String">
        /// ID of the element to populate with dynamic content
        /// </value>
        return this._DynamicControlID;
    },
    get_DynamicControlID : this.get_dynamicControlID,
    set_dynamicControlID : function(value) {
        if (this._DynamicControlID != value) {
            this._DynamicControlID = value;
            this.raisePropertyChanged('dynamicControlID');
            this.raisePropertyChanged('DynamicControlID');
        }
    },
    set_DynamicControlID : this.set_dynamicControlID,

    get_dynamicContextKey : function() {
        /// <value type="String">
        /// An arbitrary string value to be passed to the web method.
        /// For example, if the element to be populated is within a
        /// data-bound repeater, this could be the ID of the current row.
        /// </value>
        return this._DynamicContextKey;
    },
    get_DynamicContextKey : this.get_dynamicContextKey,
    set_dynamicContextKey : function(value) {
        if (this._DynamicContextKey != value) {
            this._DynamicContextKey = value;
            this.raisePropertyChanged('dynamicContextKey');
            this.raisePropertyChanged('DynamicContextKey');
        }
    },
    set_DynamicContextKey : this.set_dynamicContextKey,

    get_dynamicServicePath : function() {
        /// <value type="String" mayBeNull="true" optional="true">
        /// The URL of the web service to call.  If the ServicePath is not defined, then we will invoke a PageMethod instead of a web service.
        /// </value>
        return this._DynamicServicePath;
    },
    get_DynamicServicePath : this.get_dynamicServicePath,
    set_dynamicServicePath : function(value) {
        if (this._DynamicServicePath != value) {
            this._DynamicServicePath = value;
            this.raisePropertyChanged('dynamicServicePath');
            this.raisePropertyChanged('DynamicServicePath');
        }
    },
    set_DynamicServicePath : this.set_dynamicServicePath,

    get_dynamicServiceMethod : function() {
        /// <value type="String">
        /// The name of the method to call on the page or web service
        /// </value>
        /// <remarks>
        /// The signature of the method must exactly match the following:
        ///     [WebMethod]
        ///     string DynamicPopulateMethod(string contextKey)
        ///     {
        ///         ...
        ///     }
        /// </remarks>
        return this._DynamicServiceMethod;
    },
    get_DynamicServiceMethod : this.get_dynamicServiceMethod,
    set_dynamicServiceMethod : function(value) {
        if (this._DynamicServiceMethod != value) {
            this._DynamicServiceMethod = value;
            this.raisePropertyChanged('dynamicServiceMethod');
            this.raisePropertyChanged('DynamicServiceMethod');
        }
    },
    set_DynamicServiceMethod : this.set_dynamicServiceMethod,
    
    get_cacheDynamicResults : function() {
        /// <value type="Boolean" mayBeNull="false">
        /// Whether the results of the dynamic population should be cached and
        /// not fetched again after the first load
        /// </value>
        return this._cacheDynamicResults;
    },
    set_cacheDynamicResults : function(value) {
        if (this._cacheDynamicResults != value) {
            this._cacheDynamicResults = value;
            this.raisePropertyChanged('cacheDynamicResults');
        }
    },
    
    add_populated : function(handler) {
        /// <summary>
        /// Add a handler on the populated event
        /// </summary>
        /// <param name="handler" type="Function">
        /// Handler
        /// </param>
        this.get_events().addHandler("populated", handler);
    },
    remove_populated : function(handler) {
        /// <summary>
        /// Remove a handler from the populated event
        /// </summary>
        /// <param name="handler" type="Function">
        /// Handler
        /// </param>
        this.get_events().removeHandler("populated", handler);
    },
    raisePopulated : function(arg) {
        /// <summary>
        /// Raise the populated event
        /// </summary>
        /// <param name="arg" type="Sys.EventArgs">
        /// Event arguments
        /// </param>
        var handler = this.get_events().getHandler("populated");  
        if (handler) handler(this, arg);
    },
    
    add_populating : function(handler) {
        /// <summary>
        /// Add an event handler for the populating event
        /// </summary>
        /// <param name="handler" type="Function" mayBeNull="false">
        /// Event handler
        /// </param>
        /// <returns />
        this.get_events().addHandler('populating', handler);
    },
    remove_populating : function(handler) {
        /// <summary>
        /// Remove an event handler from the populating event
        /// </summary>
        /// <param name="handler" type="Function" mayBeNull="false">
        /// Event handler
        /// </param>
        /// <returns />
        this.get_events().removeHandler('populating', handler);
    },
    raisePopulating : function(eventArgs) {
        /// <summary>
        /// Raise the populating event
        /// </summary>
        /// <param name="eventArgs" type="Sys.CancelEventArgs" mayBeNull="false">
        /// Event arguments for the populating event
        /// </param>
        /// <returns />
        
        var handler = this.get_events().getHandler('populating');
        if (handler) {
            handler(this, eventArgs);
        }
    }
}
AjaxControlToolkit.DynamicPopulateBehaviorBase.registerClass('AjaxControlToolkit.DynamicPopulateBehaviorBase', AjaxControlToolkit.BehaviorBase);


AjaxControlToolkit.ControlBase = function(element) {
    AjaxControlToolkit.ControlBase.initializeBase(this, [element]);
    this._clientStateField = null;
    this._callbackTarget = null;
    this._onsubmit$delegate = Function.createDelegate(this, this._onsubmit);
    this._oncomplete$delegate = Function.createDelegate(this, this._oncomplete);
    this._onerror$delegate = Function.createDelegate(this, this._onerror);
}
AjaxControlToolkit.ControlBase.prototype = {
    initialize : function() {
        AjaxControlToolkit.ControlBase.callBaseMethod(this, "initialize");
        // load the client state if possible
        if (this._clientStateField) {
            this.loadClientState(this._clientStateField.value);
        }
        // attach an event to save the client state before a postback or updatepanel partial postback
        if (typeof(Sys.WebForms)!=="undefined" && typeof(Sys.WebForms.PageRequestManager)!=="undefined") {
            Array.add(Sys.WebForms.PageRequestManager.getInstance()._onSubmitStatements, this._onsubmit$delegate);
        } else {
            $addHandler(document.forms[0], "submit", this._onsubmit$delegate);
        }
    },
    dispose : function() {
        if (typeof(Sys.WebForms)!=="undefined" && typeof(Sys.WebForms.PageRequestManager)!=="undefined") {
            Array.remove(Sys.WebForms.PageRequestManager.getInstance()._onSubmitStatements, this._onsubmit$delegate);
        } else {
            $removeHandler(document.forms[0], "submit", this._onsubmit$delegate);
        }
        AjaxControlToolkit.ControlBase.callBaseMethod(this, "dispose");
    },
    findElement : function(id) {
        // <summary>Finds an element within this control (ScriptControl/ScriptUserControl are NamingContainers);
        return $get(this.get_id() + '_' + id.split(':').join('_'));
    },
    get_clientStateField : function() {
        return this._clientStateField;
    },
    set_clientStateField : function(value) {
        if (this.get_isInitialized()) throw Error.invalidOperation(AjaxControlToolkit.Resources.ExtenderBase_CannotSetClientStateField);
        if (this._clientStateField != value) {
            this._clientStateField = value;
            this.raisePropertyChanged('clientStateField');
        }
    },
    loadClientState : function(value) {
        /// <remarks>override this method to intercept client state loading after a callback</remarks>
    },
    saveClientState : function() {
        /// <remarks>override this method to intercept client state acquisition before a callback</remarks>
        return null;
    },
    _invoke : function(name, args, cb) {
        /// <summary>invokes a callback method on the server control</summary>        
        if (!this._callbackTarget) {
            throw Error.invalidOperation(AjaxControlToolkit.Resources.ExtenderBase_ControlNotRegisteredForCallbacks);
        }
        if (typeof(WebForm_DoCallback)==="undefined") {
            throw Error.invalidOperation(AjaxControlToolkit.Resources.ExtenderBase_PageNotRegisteredForCallbacks);
        }
        var ar = [];
        for (var i = 0; i < args.length; i++) 
            ar[i] = args[i];
        var clientState = this.saveClientState();
        if (clientState != null && !String.isInstanceOfType(clientState)) {
            throw Error.invalidOperation(AjaxControlToolkit.Resources.ExtenderBase_InvalidClientStateType);
        }
        var payload = Sys.Serialization.JavaScriptSerializer.serialize({name:name,args:ar,state:this.saveClientState()});
        WebForm_DoCallback(this._callbackTarget, payload, this._oncomplete$delegate, cb, this._onerror$delegate, true);
    },
    _oncomplete : function(result, context) {
        result = Sys.Serialization.JavaScriptSerializer.deserialize(result);
        if (result.error) {
            throw Error.create(result.error);
        }
        this.loadClientState(result.state);
        context(result.result);
    },
    _onerror : function(message, context) {
        throw Error.create(message);
    },
    _onsubmit : function() {
        if (this._clientStateField) {
            this._clientStateField.value = this.saveClientState();
        }
        return true;
    }    
   
}
AjaxControlToolkit.ControlBase.registerClass("AjaxControlToolkit.ControlBase", Sys.UI.Control);

AjaxControlToolkit.Resources={
"PasswordStrength_InvalidWeightingRatios":"Strength Weighting ratios must have 4 elements","Animation_ChildrenNotAllowed":"AjaxControlToolkit.Animation.createAnimation cannot add child animations to type \"{0}\" that does not derive from AjaxControlToolkit.Animation.ParentAnimation","PasswordStrength_RemainingSymbols":"{0} symbol characters","ExtenderBase_CannotSetClientStateField":"clientStateField can only be set before initialization","RTE_PreviewHTML":"Preview HTML","RTE_JustifyCenter":"Justify Center","PasswordStrength_RemainingUpperCase":"{0} more upper case characters","Animation_TargetNotFound":"AjaxControlToolkit.Animation.Animation.set_animationTarget requires the ID of a Sys.UI.DomElement or Sys.UI.Control.  No element or control could be found corresponding to \"{0}\"","RTE_FontColor":"Font Color","RTE_LabelColor":"Label Color","Common_InvalidBorderWidthUnit":"A unit type of \"{0}\"\u0027 is invalid for parseBorderWidth","RTE_Heading":"Heading","Tabs_PropertySetBeforeInitialization":"{0} cannot be changed before initialization","RTE_OrderedList":"Ordered List","ReorderList_DropWatcherBehavior_NoChild":"Could not find child of list with id \"{0}\"","CascadingDropDown_MethodTimeout":"[Method timeout]","RTE_Columns":"Columns","RTE_InsertImage":"Insert Image","RTE_InsertTable":"Insert Table","RTE_Values":"Values","RTE_OK":"OK","ExtenderBase_PageNotRegisteredForCallbacks":"This Page has not been registered for callbacks","Animation_NoDynamicPropertyFound":"AjaxControlToolkit.Animation.createAnimation found no property corresponding to \"{0}\" or \"{1}\"","Animation_InvalidBaseType":"AjaxControlToolkit.Animation.registerAnimation can only register types that inherit from AjaxControlToolkit.Animation.Animation","RTE_UnorderedList":"Unordered List","ResizableControlBehavior_InvalidHandler":"{0} handler not a function, function name, or function text","Animation_InvalidColor":"Color must be a 7-character hex representation (e.g. #246ACF), not \"{0}\"","RTE_CellColor":"Cell Color","PasswordStrength_RemainingMixedCase":"Mixed case characters","RTE_Italic":"Italic","CascadingDropDown_NoParentElement":"Failed to find parent element \"{0}\"","ValidatorCallout_DefaultErrorMessage":"This control is invalid","RTE_Indent":"Indent","ReorderList_DropWatcherBehavior_CallbackError":"Reorder failed, see details below.\\r\\n\\r\\n{0}","PopupControl_NoDefaultProperty":"No default property supported for control \"{0}\" of type \"{1}\"","RTE_Normal":"Normal","PopupExtender_NoParentElement":"Couldn\u0027t find parent element \"{0}\"","RTE_ViewValues":"View Values","RTE_Legend":"Legend","RTE_Labels":"Labels","RTE_CellSpacing":"Cell Spacing","PasswordStrength_RemainingNumbers":"{0} more numbers","RTE_Border":"Border","RTE_Create":"Create","RTE_BackgroundColor":"Background Color","RTE_Cancel":"Cancel","RTE_JustifyFull":"Justify Full","RTE_JustifyLeft":"Justify Left","RTE_Cut":"Cut","ResizableControlBehavior_CannotChangeProperty":"Changes to {0} not supported","RTE_ViewSource":"View Source","Common_InvalidPaddingUnit":"A unit type of \"{0}\" is invalid for parsePadding","RTE_Paste":"Paste","ExtenderBase_ControlNotRegisteredForCallbacks":"This Control has not been registered for callbacks","Calendar_Today":"Today: {0}","Common_DateTime_InvalidFormat":"Invalid format","ListSearch_DefaultPrompt":"Type to search","CollapsiblePanel_NoControlID":"Failed to find element \"{0}\"","RTE_ViewEditor":"View Editor","RTE_BarColor":"Bar Color","PasswordStrength_DefaultStrengthDescriptions":"NonExistent;Very Weak;Weak;Poor;Almost OK;Barely Acceptable;Average;Good;Strong;Excellent;Unbreakable!","RTE_Inserttexthere":"Insert text here","Animation_UknownAnimationName":"AjaxControlToolkit.Animation.createAnimation could not find an Animation corresponding to the name \"{0}\"","ExtenderBase_InvalidClientStateType":"saveClientState must return a value of type String","Rating_CallbackError":"An unhandled exception has occurred:\\r\\n{0}","Tabs_OwnerExpected":"owner must be set before initialize","DynamicPopulate_WebServiceTimeout":"Web service call timed out","PasswordStrength_RemainingLowerCase":"{0} more lower case characters","Animation_MissingAnimationName":"AjaxControlToolkit.Animation.createAnimation requires an object with an AnimationName property","RTE_JustifyRight":"Justify Right","Tabs_ActiveTabArgumentOutOfRange":"Argument is not a member of the tabs collection","RTE_CellPadding":"Cell Padding","RTE_ClearFormatting":"Clear Formatting","AlwaysVisible_ElementRequired":"AjaxControlToolkit.AlwaysVisibleControlBehavior must have an element","Slider_NoSizeProvided":"Please set valid values for the height and width attributes in the slider\u0027s CSS classes","DynamicPopulate_WebServiceError":"Web Service call failed: {0}","PasswordStrength_StrengthPrompt":"Strength: ","PasswordStrength_RemainingCharacters":"{0} more characters","PasswordStrength_Satisfied":"Nothing more required","RTE_Hyperlink":"Hyperlink","Animation_NoPropertyFound":"AjaxControlToolkit.Animation.createAnimation found no property corresponding to \"{0}\"","PasswordStrength_InvalidStrengthDescriptionStyles":"Text Strength description style classes must match the number of text descriptions.","PasswordStrength_GetHelpRequirements":"Get help on password requirements","PasswordStrength_InvalidStrengthDescriptions":"Invalid number of text strength descriptions specified","RTE_Underline":"Underline","Tabs_PropertySetAfterInitialization":"{0} cannot be changed after initialization","RTE_Rows":"Rows","RTE_Redo":"Redo","RTE_Size":"Size","RTE_Undo":"Undo","RTE_Bold":"Bold","RTE_Copy":"Copy","RTE_Font":"Font","CascadingDropDown_MethodError":"[Method error {0}]","RTE_BorderColor":"Border Color","RTE_Paragraph":"Paragraph","RTE_InsertHorizontalRule":"Insert Horizontal Rule","Common_UnitHasNoDigits":"No digits","RTE_Outdent":"Outdent","Common_DateTime_InvalidTimeSpan":"\"{0}\" is not a valid TimeSpan format","Animation_CannotNestSequence":"AjaxControlToolkit.Animation.SequenceAnimation cannot be nested inside AjaxControlToolkit.Animation.ParallelAnimation","Shared_BrowserSecurityPreventsPaste":"Your browser security settings don\u0027t permit the automatic execution of paste operations. Please use the keyboard shortcut Ctrl+V instead."};
//END AjaxControlToolkit.ExtenderBase.BaseScripts.js
//START AjaxControlToolkit.MaskedEdit.MaskedEditBehavior.js
// (c) Copyright Microsoft Corporation.
// This source is subject to the Microsoft Permissive License.
// See http://www.microsoft.com/resources/sharedsource/licensingbasics/sharedsourcelicenses.mspx.
// All other rights reserved.


/// <reference name="MicrosoftAjax.debug.js" />
/// <reference name="MicrosoftAjaxTimer.debug.js" />
/// <reference name="MicrosoftAjaxWebForms.debug.js" />
/// <reference path="../ExtenderBase/BaseScripts.js" />
/// <reference path="../Compat/Timer/Timer.js" />
/// <reference path="../Common/Common.js" />


// Product      : MaskedEdit Extend Control
// Version      : 1.0.0.0
// Date         : 10/23/2006
// Development  : Fernando Cerqueira 
// Version      : 1.0.0.1
// Development  : 02/22/2007 Fernando Cerqueira 
// 
Type.registerNamespace('AjaxControlToolkit');
AjaxControlToolkit.MaskedEditBehavior = function(element) 
{
    AjaxControlToolkit.MaskedEditBehavior.initializeBase(this, [element]);
    // **************************************************
    // Properties
    // **************************************************
    // mask
    this._Mask = "";
    this._MaskType = AjaxControlToolkit.MaskedEditType.None;
    this._Filtered = "";
    this._PromptChar = "_";
    this._InputDirection = AjaxControlToolkit.MaskedEditInputDirections.LeftToRight;
    // Message
    this._MessageValidatorTip = true;
    this._ShowMessageErrorFloat = false;
    this._CssMessageErrorFloat = "";
    // AutoComplete
    this._AutoComplete = true;
    this._AutoCompleteValue =  "";
    // behavior
    this._ClearTextOnInvalid = false;
    this._ClearMaskOnLostfocus = true;
    this._AcceptAmPm = AjaxControlToolkit.MaskedEditShowSymbol.None;
    this._AcceptNegative = AjaxControlToolkit.MaskedEditShowSymbol.None;
    this._DisplayMoney = AjaxControlToolkit.MaskedEditShowSymbol.None;
    // CSS
    this._OnFocusCssClass = "MaskedEditFocus";
    this._OnInvalidCssClass = "MaskedEditError";
    this._OnFocusCssNegative = "MaskedEditFocusNegative";
    this._OnBlurCssNegative = "MaskedEditBlurNegative";
    // globalization 
    this._CultureName = "";
    this._UserDateFormat = AjaxControlToolkit.MaskedEditUserDateFormat.None;
    this._UserTimeFormat = AjaxControlToolkit.MaskedEditUserTimeFormat.None;
    // globalization Hidden 
    this._CultureDatePlaceholder = "";
    this._CultureTimePlaceholder = "";
    this._CultureDecimalPlaceholder = "";
    this._CultureThousandsPlaceholder = "";
    this._CultureDateFormat = "";
    this._CultureCurrencySymbolPlaceholder = "";
    this._CultureAMPMPlaceholder = "";
    this._AMPMPlaceholderSeparator = ";";
    this._Century = 1900;
    // clipboard
    this._AllowCopyPaste = true;
    this._ClipboardText = AjaxControlToolkit.Resources.Shared_BrowserSecurityPreventsPaste;
    // **************************************************
    // local var mask valid
    // **************************************************
    //  9 = only numeric
    //  L = only letter
    //  $ = only letter and spaces
    //  C = only custom - read from this._Filtered
    //  A = only letter and custom
    //  N = only numeric and custom
    //  ? = any digit
    this._CharsEditMask = "9L$CAN?";
    // **************************************************
    // local var special mask
    // **************************************************
    // at runtime replace with culture property
    //  / = Date placeholder
    //  : = Time placeholder
    //  . = Decimal placeholder
    //  , = Thousands placeholder
    this._CharsSpecialMask = "/:.,";
    // **************************************************
    // local converted mask 
    // **************************************************
    // i.e.: 9{2} => 99 , 9{2}/9{2}/9{2} = 99/99/99
    this._MaskConv = "";
    // **************************************************
    // Others local Var
    // **************************************************
    this._EmptyMask = ""; // save Empty Mask
    this._maskvalid = "" // save valid Mask
    this._DirectSelText = ""; // save the Direction selected Text (only for ie)
    this._initialvalue = ""; // save the initial value for verify changed
    this._LogicSymbol = ""; // save the symbol - or AM/PM
    this._LogicTextMask = ""; // save logic mask with text input
    this._LogicMask = ""; // save logic mask without text
    this._LogicMaskConv = ""; // save logic mask without text and without escape
    this._LogicPrompt = String.fromCharCode(1); // logic prompt char
    this._LogicEscape = String.fromCharCode(2); // logic escape char
    this._LogicFirstPos = -1; // first valid position
    this._LogicLastPos = -1; // Last valid position 
    this._LogicLastInt = -1; // Last valid position RTL Integer with decimal
    this._QtdValidInput = 0; // Qtd Valid input Position 
    this._InLostfocus = false; // Flag to validate in lost focus not duplicate clearMask execute
    this._ExternalMessageError = ""; // Save local MessageError from Controls Validator
    this._CurrentMessageError = ""; // Save local Current MessageError
    this._FiringOnChange = false;  // true when OnChange is being fired
    this._ErroOnEnter = false; // Flag Erro validate with Enter
    // **************************************************
    // local chars ANSI
    // **************************************************
    this._charLetters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    this._charNumbers = "0123456789";    
    this._charEscape = "\\";
    // **************************************************
    // local placeholder delimit for info repeat mask
    // **************************************************
    this._DelimitStartDup = "{";
    this._DelimitEndDup = "}";   
    // **************************************************
    // Handler
    // **************************************************
    this._focusHandler = null;
    this._keypressdown = null;
    this._keypressHandler = null;
    this._blurHandler = null;
    this._mouseOutHandler = null;
    this._mouseOutHandler = null;
    this._mouseMoveHandler = null;
    this._mouseEnterHandler = null;
    this._changeHandler = null;
    // **************************************************
    // Only for Opera
    // **************************************************
    this._timer = null; //Timer
    this._timerHandler = null; //Timer Handler
    this._SaveSymb = ""; // Symb Saved immediate perform Action
    this._SaveText = ""; // Text Saved immediate perform Action
    this._SavePosi = -1; // Cursor pos Saved immediate perform Action
    this._SaveMask = ""; // Mask with text Saved 
    this._SaveKeyDown = 0; // save scancode at keydown
}    
AjaxControlToolkit.MaskedEditBehavior.prototype = { 
    initialize : function() 
    {
        var e = this.get_element();

        this._InLostfocus = true;
        AjaxControlToolkit.MaskedEditBehavior.callBaseMethod(this, 'initialize');
        this._createMask();
        // if this textbox is focused initially
        var hasInitialFocus = false;
        var clientState = this.get_ClientState();
        
        if (clientState != null && clientState != "") 
        {
            hasInitialFocus = (clientState == "Focused");
            this.set_ClientState(null);            
        }
        //only for ie , for firefox see keydown
        if (document.activeElement)
        {
            if (e.id == document.activeElement.id)
            {
                hasInitialFocus = true;
            }
        }
        
        // Create delegates Attach events
        if (this._ShowMessageErrorFloat)
        {
            this._mouseOutHandler = Function.createDelegate(this, this._onMouseOut);
            $addHandler(e, "mouseout", this._mouseOutHandler);
            
            this._mouseMoveHandler = Function.createDelegate(this, this._onMouseMove);
            $addHandler(e, "mousemove", this._mouseMoveHandler);

            this._mouseEnterHandler = Function.createDelegate(this, this._onMouseover);                
            $addHandler(e, "mouseover", this._mouseEnterHandler);
        }

        if (!e.readOnly)
        {
            this._keypressdown = Function.createDelegate(this, this._onKeyPressdown);
            $addHandler(e, "keydown", this._keypressdown); 

            this._keypressHandler = Function.createDelegate(this, this._onKeyPress);
            $addHandler(e, "keypress", this._keypressHandler); 
            
        }

        this._focusHandler = Function.createDelegate(this, this._onFocus);
        $addHandler(e, "focus", this._focusHandler);
        this._blurHandler = Function.createDelegate(this, this._onBlur);
        $addHandler(e, "blur", this._blurHandler);
        this._changeHandler = Function.createDelegate(this, this._onChange);
        $addHandler(e, "change", this._changeHandler);
        
        if (Sys.Browser.agent == Sys.Browser.Opera)
        {
            // Create timer
            this._timerHandler = Function.createDelegate(this, this._OnTimerTicket);
            this._timer = new Sys.Timer();
            this._timer.set_enabled(false);
            this._timer.set_interval(100);
            this._timer.add_tick(this._timerHandler);
            this._SaveText = ""; 
            this._SavePosi = -1;
            this._timer.set_enabled(true);
        }

        var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(e);
        if (this._ClearMaskOnLostfocus)
        {
            this._InitValue(wrapper.get_Value(),true);
        }
        else
        {
            this._InitValue(wrapper.get_Value().substring(this._LogicFirstPos,this._LogicLastPos+1),true);
        }
        if (hasInitialFocus) 
        {
            this._onFocus();
        }
        else 
        {
            if (this._ClearMaskOnLostfocus)
            {
                wrapper.set_Value(this._getClearMask(wrapper.get_Value()));
            }
            var IsValid = this._CaptureServerValidators();
            if (!IsValid)
            {
                if (this._OnInvalidCssClass != "")
                {
                    this.AddCssClassMaskedEdit(this._OnInvalidCssClass);
                }
            }
        }
    }
    //
    // Detach events this.dispose
    //
    , dispose : function() 
    {
        var e = this.get_element();
        if (this._mouseOutHandler) 
        {
            $removeHandler(e, "mouseout", this._mouseOutHandler);
            this._mouseOutHandler = null;
        }
        if (this._mouseMoveHandler) 
        {
            $removeHandler(e, "mousemove", this._mouseMoveHandler);
            this._mouseMoveHandler = null;
        }
        if (this._mouseEnterHandler) 
        {
            $removeHandler(e, "mouseover", this._mouseEnterHandler);
            this._mouseEnterHandler = null;
        }
        if (this._focusHandler) 
        {
            $removeHandler(e, "focus", this._focusHandler);
            this._focusHandler = null;
        }
        if (this._focusHandler) 
        {
            $removeHandler(e, "focus", this._focusHandler);
            this._focusHandler = null;
        }
        if (this._blurHandler) 
        {
            $removeHandler(e, "blur", this._blurHandler);
            this._blurHandler = null;
        }
        if (this._changeHandler) 
        {
            $removeHandler(e, "change", this._changeHandler);
            this._changeHandler = null;
        }
        if (this._keypressdown) 
        {
            $removeHandler(e, "keydown", this._keypressdown);
            this._keypressdown = null;
        }
        if (this._keypressHandler) 
        {
            $removeHandler(e, "keypress", this._keypressHandler);
            this._keypressHandler = null;
        }
        if (this._timerHandler) {
            this._timer.set_enabled(false);
            this._timerHandler = null;
            this._timer.dispose();
            this._timer = null;
        }
        AjaxControlToolkit.MaskedEditBehavior.callBaseMethod(this, 'dispose');
    }
    //
    // EVENT TARGET
    //
    , _OnTimerTicket : function() 
    {
        this._SaveSymb = "";
        if (this._InLostfocus)
        {
            return;
        }
        this._timer.set_enabled(false);
        var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element());
        if (this._SaveText != "")                
        {
            wrapper.set_Value(this._SaveText);
            this.setSelectionRange(this._SavePosi,this._SavePosi);
            this._SaveText = ""; 
            this._SavePosi = -1;
            this._SaveMask = wrapper.get_Value();
        }
        else
        {
            if (wrapper.get_Value().length != this._EmptyMask.length)
            {
                wrapper.set_Value(this._SaveMask);
            }
            if (this._timer.get_interval() != 100)
            {
                this._timer.set_interval(100);
            }
        }
        this._timer.set_enabled(true);
    }
    , _onChange : function() 
    {
        if (!this._FiringOnChange) {
            //capture and initialize external input Ex : calendar Extender
            this._onFocus();
        }
    }
    , _onFocus : function() 
    {
        this._InLostfocus = false;
        this._RemoveDivToolTip();
        if (this._OnFocusCssClass != "")
        {
            this.AddCssClassMaskedEdit(this._OnFocusCssClass);
        }
        var e = this.get_element();
        var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(e);
        this._initialvalue = wrapper.get_Value();
        if (this._ClearMaskOnLostfocus)
        {
            this._InitValue(wrapper.get_Value(),false);
        }
        else
        {
            this._InitValue(wrapper.get_Value().substring(this._LogicFirstPos,this._LogicLastPos+1),false);
        }
        var ClearText = this._getClearMask();
        var hastip = false;
        if (this._MessageValidatorTip && ClearText == "")
        {
            hastip = true;
        }
        if ( (this._MaskType == AjaxControlToolkit.MaskedEditType.Time || this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime) && this.get_CultureAMPMPlaceholder() != "" && ClearText == "")
        {
            if (this._AcceptAmPm)
            {
                this.InsertAMPM(this.get_CultureAMPMPlaceholder().substring(0,1));
            }
        }
        else if (this._MaskType == AjaxControlToolkit.MaskedEditType.Number && ClearText != "")
        {
            if (this._LogicSymbol == "-" && this._OnFocusCssNegative != "")
            {
                this.AddCssClassMaskedEdit(this._OnFocusCssNegative);
            }
        }
        if (this._InputDirection == AjaxControlToolkit.MaskedEditInputDirections.RightToLeft)
        {
            if (this._LogicLastInt != -1)
            {
                this.setSelectionRange(this._LogicLastInt,this._LogicLastInt);
            }
            else
            {
                this.setSelectionRange(this._LogicLastPos+1,this._LogicLastPos+1);
            }
        }
        else
        {
            if (this._MaskType == AjaxControlToolkit.MaskedEditType.Number && ClearText != "")
            {
                var pos = this._getLastEmptyPosition()+1;
                this.setSelectionRange(pos,pos);
            }
            else
            {
                this.setSelectionRange(this._LogicFirstPos,this._LogicFirstPos);
            }
        }
        this.ShowTooltipMessage(false);
        if (hastip)
        {
            this.ShowTooltipMessage(true);
        }
    }
    , _PeforformValidLostFocus : function(isblur) 
    {
        var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element());
        var ClearText = this._getClearMask(wrapper.get_Value());
        if (ClearText == "" && this._MaskType == AjaxControlToolkit.MaskedEditType.Number && this._LogicSymbol == "-")
        {
            this.InsertSignal("+");
        }
        // auto format 
        if (ClearText != "" && this._AutoComplete && this._MaskType == AjaxControlToolkit.MaskedEditType.Date)
        {
            this.AutoFormatDate();
        }
        else if (ClearText != "" && this._AutoComplete && this._MaskType == AjaxControlToolkit.MaskedEditType.Time)
        {
            this.AutoFormatTime();
        }
        else if (ClearText != "" && this._AutoComplete && this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime)
        {
            this.AutoFormatDateTime();
        }
        else if (ClearText != "" && this._AutoComplete && this._MaskType == AjaxControlToolkit.MaskedEditType.Number)
        {
            this.AutoFormatNumber();
        }
        // clear mask and set CSS
        if ((this._ClearMaskOnLostfocus && ClearText != "") || (isblur && this._ClearMaskOnLostfocus) )
        {
            wrapper.set_Value(this._getClearMask(wrapper.get_Value()));
        }
        this.AddCssClassMaskedEdit("");
        if (this._MaskType == AjaxControlToolkit.MaskedEditType.Number && this._LogicSymbol == "-" && this._OnBlurCssNegative != "")
        {
            this.AddCssClassMaskedEdit(this._OnBlurCssNegative);
        }
        // perform validation
        this.ShowTooltipMessage(false);
        this._RemoveDivToolTip();
        var IsValid = this._CaptureClientsValidators();
        if (!IsValid)
        {
            if (this._OnInvalidCssClass != "")
            {
                this.AddCssClassMaskedEdit(this._OnInvalidCssClass);
            }
            if (this._ClearTextOnInvalid)
            {
                this._createMask();
                wrapper.set_Value(this._EmptyMask);
            }
        }
        return IsValid;
    }
    , _onBlur : function(evt) 
    {
        this._InLostfocus = true;
        var IsValid = this._PeforformValidLostFocus(true);
        if (IsValid)
        {
            // trigger TextChanged with postback
            var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element());
            if (!this.get_element().readOnly && (this._initialvalue != wrapper.get_Value()) && evt) {
                this._fireChanged();
            }
        }
    }

    , _fireChanged : function() {
        /// <summary>
        /// Attempts to fire the change event on the attached textbox
        /// </summary>

        this._FiringOnChange = true;
        var elt = this.get_element();
        if (document.createEventObject) {
            elt.fireEvent("onchange");
        } else if (document.createEvent) {
            var e = document.createEvent("HTMLEvents");
            e.initEvent("change", true, true);
            elt.dispatchEvent(e);
        }
        this._FiringOnChange = false;
    }

    , _onKeyPress : function(evt) 
    {
        var scancode = this._KeyCode(evt);
        if (scancode == 9) //tab default action
        {
            return true;
        }
        if (scanCode == 13)
        {
            var IsValid = this._PeforformValidLostFocus(false);
            this._ErroOnEnter = false;
            if (!IsValid)
            {
                this._ErroOnEnter = true;
            }
            // Opera not perform cancel event. Re-perform at Timer
            if (Sys.Browser.agent == Sys.Browser.Opera)
            {
                var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element());
                this._SaveText = wrapper.get_Value(); 
                this._SavePosi = this._getCurrentPosition();
                this._timer.set_enabled(false);
                this._timer.set_interval(1);
                this._timer.set_enabled(true);
                
            }
            return IsValid;
        }   
        if (this._OnFocusCssClass != "" && this._ErroOnEnter)
        {
            this.AddCssClassMaskedEdit(this._OnFocusCssClass);
        }
        this._ErroOnEnter = false;
        if (!this._isNormalChar(evt,scancode)) 
        {
            this._ExecuteNav(evt,scancode);
            return false;
        }
        // process and validate normal char
        curpos = this._deleteTextSelection();
        if (curpos == -1)
        {
            curpos = this._getCurrentPosition()
        }
        var c = String.fromCharCode(scanCode);
        if (this._MaskType == AjaxControlToolkit.MaskedEditType.Date && c == this.get_CultureDatePlaceholder())
        {
            this._AdjustElementDate();
        }
        else if (this._MaskType == AjaxControlToolkit.MaskedEditType.Time && c == this.get_CultureTimePlaceholder())
        {
            this._AdjustElementTime();
        }
        else if (this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime && (c == this.get_CultureTimePlaceholder() || c == this.get_CultureDatePlaceholder()) )
        {
            this._AdjustElementDateTime(c);
        }
        else if (this._MaskType == AjaxControlToolkit.MaskedEditType.Number && this._InputDirection == AjaxControlToolkit.MaskedEditInputDirections.LeftToRight && c == this.get_CultureDecimalPlaceholder() && curpos == this._LogicLastInt)
        {
            this._AdjustElementDecimalLTR();
        }
        else if (this._MaskType == AjaxControlToolkit.MaskedEditType.Number && this._InputDirection == AjaxControlToolkit.MaskedEditInputDirections.RightToLeft && c == this.get_CultureDecimalPlaceholder() && curpos == this._LogicLastInt)
        {
            this._AdjustElementDecimalRTL();
        }
        else if (this._MaskType == AjaxControlToolkit.MaskedEditType.Number && c == this.get_CultureDecimalPlaceholder() && curpos != this._LogicLastInt)
        {
            this._MoveDecimalPos();
        }
        else if (this._MaskType == AjaxControlToolkit.MaskedEditType.Number && this._InputDirection == AjaxControlToolkit.MaskedEditInputDirections.LeftToRight && c == this.get_CultureThousandsPlaceholder() )
        {
            this._MoveThousandLTR();
        }
        else if (this._MaskType == AjaxControlToolkit.MaskedEditType.Number && this._InputDirection == AjaxControlToolkit.MaskedEditInputDirections.RightToLeft && c == this.get_CultureThousandsPlaceholder() )
        {
            this._MoveThousandRTL();
        }
        else if ( (this._MaskType == AjaxControlToolkit.MaskedEditType.Time || this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime) && this.get_CultureFirstLettersAMPM().toUpperCase().indexOf(c.toUpperCase()) != -1)
        {
            if (this._AcceptAmPm)
            {
                this.InsertAMPM(c);
                this.setSelectionRange(curpos,curpos);
            }
        }
        else if (this._MaskType == AjaxControlToolkit.MaskedEditType.Number && this._AcceptNegative != AjaxControlToolkit.MaskedEditShowSymbol.None && "+-".indexOf(c) != -1)
        {
            if (Sys.Browser.agent != Sys.Browser.Opera)
            {
                this.InsertSignal(c);
                this.setSelectionRange(curpos,curpos);
            }
            else
            {
                // Opera perform double event! when press "-" at numpad key
                if (this._SaveSymb == "")
                {
                    this.InsertSignal(c);
                    this.setSelectionRange(curpos,curpos);
                    this._SaveSymb = c;
                    this._timer.set_enabled(false);
                    this._timer.set_interval(1);
                    this._timer.set_enabled(true);
                }
                else
                {
                    this._SaveSymb = "";
                }
            }
        }
        else
        {
            var OriPos = curpos;
            curpos = this._getNextPosition(curpos);
            var logiccur = curpos;
            if (this._LogicLastInt != -1 && this._InputDirection == AjaxControlToolkit.MaskedEditInputDirections.RightToLeft)
            {
                if (OriPos == this._LogicLastInt)
                {
                    logiccur = this._getLastEmptyPosition();
                }
            }
            else
            {
                if (curpos >= this._LogicLastPos+1 && this._InputDirection == AjaxControlToolkit.MaskedEditInputDirections.RightToLeft)
                {
                    logiccur = this._getLastEmptyPosition();
                }
            }
            if (this._processKey(logiccur,c)) 
            {
                if (this._MessageValidatorTip) 
                {
                    this.ShowTooltipMessage(false);
                }
                if (this._InputDirection == AjaxControlToolkit.MaskedEditInputDirections.LeftToRight)
                {
                    this._insertContent(c,logiccur);
                    curpos = this._getNextPosition(logiccur+1);
                } 
                else if (this._InputDirection == AjaxControlToolkit.MaskedEditInputDirections.RightToLeft)
                {
                    if (this._LogicLastInt == -1)
                    {
                        if (curpos < this._LogicLastPos+1)
                        {
                            this._insertContent(c,logiccur);
                            curpos = this._getNextPosition(logiccur+1);
                        }
                        else
                        {
                            this._insertContentRight(c);
                            curpos = this._LogicLastPos+1;
                        }
                    }
                    else
                    {
                        if (OriPos != this._LogicLastInt)
                        {
                            this._insertContent(c,logiccur);
                            curpos = this._getNextPosition(logiccur+1);
                        }
                        else
                        {
                            var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element());
                            var ClearText = this._getClearMask(wrapper.get_Value());
                            if (ClearText != "")
                            {
                                var pospt = ClearText.indexOf(this.get_CultureDecimalPlaceholder());
                                if (pospt != -1)                                
                                {
                                   var intnum = ClearText.substring(0,pospt);
                                   if (intnum == "0" || intnum == "-0")
                                   {
                                        this.setSelectionRange(this._LogicLastInt-1,this._LogicLastInt);
                                        this._deleteTextSelection();
                                        curpos = this._LogicLastInt;
                                        this.setSelectionRange(curpos,curpos);
                                   }
                                }
                            }
                            if (ClearText == "" && c == "0")
                            {
                                curpos = this._LogicLastInt;
                            }
                            else
                            {
                                this._insertContentRight(c);
                                curpos = this._LogicLastInt;
                            }
                        }
                    }
                }
                this.setSelectionRange(curpos,curpos);
            }
        }
        this._SetCancelEvent(evt);
        return false;
    }
    , _onKeyPressdown : function(evt) 
    {
        // for other browsers not IE (NOT IMPLEMENT document.activeElement)
        if (this._InLostfocus)
        {
            this._onFocus(evt);
        }
        var scancode = this._KeyCode(evt);
        if (scancode == 9) //tab default action
        {
            return true;
        }
        if (scanCode == 13)  //enter 
        {
            return true;
        }
        if (!this._isNormalChar(evt,scancode)) 
        {
            this._ExecuteNav(evt,scancode);
        }
        else
        {
            // Opera not perform cancel event. Re-perform at Timer
            if (Sys.Browser.agent == Sys.Browser.Opera)
            {
                // cancel shift Ins , assume Ins = "-"
                if (evt.rawEvent.shiftKey && !evt.rawEvent.ctrlKey && !evt.rawEvent.altKey && evt.rawEvent.keyCode == 45) 
                {
                    var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element());
                    this._SaveText = wrapper.get_Value(); 
                    this._SavePosi = this._getCurrentPosition();
                    this._timer.set_enabled(false);
                    this._timer.set_interval(1);
                    this._timer.set_enabled(true);
                }
            }
        }
    }
    , _onMouseOut : function(evt) 
    {
        this._RemoveDivToolTip();
    }
    , _onMouseMove : function(evt) 
    {
        if ((this._InLostfocus || this._ErroOnEnter) && this._ExternalMessageError != "")
        {
            this._ShowDivToolTip(evt);
        }
    }
    ,_onMouseover : function(evt) 
    {
        // check if validation execute at asyc.post back
        if (!$get("DivMaskedEditTip_" + this.get_element().id))
        {
            this._CaptureServerValidators();
        }
        if ((this._InLostfocus || this._ErroOnEnter) && this._ExternalMessageError != "")
        {
            this._createDivToolTip(evt,this._ExternalMessageError);
        }
    }
    //
    // CREATE TOOLTIP
    //
    , _ShowDivToolTip : function(evt) {
        var et = $get("DivMaskedEditTip_" + this.get_element().id);
        if (!et)
        {
            this._createDivToolTip(evt,this._ExternalMessageError);
            et = $get("DivMaskedEditTip_" + this.get_element().id);
        }
        var mousepos = this._GetMousePos(evt);
        et.style.left = mousepos.x + 1/*offset To prevent flick in FF*/ + "px";
        et.style.top  = mousepos.y + 1/*offset To prevent flick in FF*/ + "px";
    }
    , _GetMousePos : function(evt) {
        var scrOfX = 0, scrOfY = 0;
        if( typeof( window.pageYOffset ) == 'number' ) {
            //Netscape compliant
            scrOfY = window.pageYOffset;
            scrOfX = window.pageXOffset;
        } 
        else if( document.body && ( document.body.scrollLeft || document.body.scrollTop ) ) {
            //DOM compliant
            scrOfY = document.body.scrollTop;
            scrOfX = document.body.scrollLeft;
        } 
        else if( document.documentElement && ( document.documentElement.scrollLeft || document.documentElement.scrollTop ) ) {
        
            //IE6 standards compliant mode
            scrOfY = document.documentElement.scrollTop;
            scrOfX = document.documentElement.scrollLeft;
        }
        var posX = 0, posY = 0;
        if( typeof( evt.pageX ) == 'number' ) 
        {
            posX = evt.pageX;
            posY = evt.pageY;
        } 
        else if( typeof( evt.clientX ) == 'number' ) 
        {
            posX = evt.clientX;
            posY = evt.clientY;
        }
        return {x:posX+scrOfX,y:posY+scrOfY}
    }
    , _RemoveDivToolTip : function() {
        var e = $get("DivMaskedEditTip_" + this.get_element().id);
        if (e)
        {
            document.body.removeChild(e);
        }
    }
    , _createDivToolTip : function(evt,Msg) {
        var e = $get("DivMaskedEditTip_" + this.get_element().id);
        if (!e)
        {
            var DivTp;
            var mousepos = this._GetMousePos(evt);
            DivTp = document.createElement("div");
            DivTp.id = "DivMaskedEditTip_" + this.get_element().id;
            DivTp.style.position = "absolute"; 
            DivTp.style.left = mousepos.x + 2/*offset*/ + "px";
            DivTp.style.top  = mousepos.y + 2/*offset*/ + "px";
            DivTp.style.zIndex = 99999;
            if (this._CssMessageErrorFloat == "")
            {
                DivTp.style.padding = "3px 3px 3px 3px";
                DivTp.style.border = "Solid 1px #000000";
                DivTp.style.backgroundColor = "#FFFFEA";
                DivTp.style.fontWeight = "normal";
                DivTp.style.fontSize = "12px";
                DivTp.style.fontFamily = "Arial";
            }
            else
            {
                DivTp.className = this._CssMessageErrorFloat;
            }
            DivTp.innerHTML = Msg;
            DivTp = document.body.insertBefore(DivTp, document.body.firstChild);
        }
    }
    //
    // Execute Navigator on Mask
    //
    , _ExecuteNav : function(evt,scanCode)
    {
        if (evt.type == "keydown")
        {
            if (Sys.Browser.agent == Sys.Browser.InternetExplorer) 
            {
                // ctrl v 
                if ( (scanCode == 86 || scanCode == 118) && !evt.shiftKey && evt.ctrlKey && !evt.altKey) {
                    this._SetCancelEvent(evt);
                    this._PasteFromClipBoard();
                    return;
                }
                //Shift Ins 
                if (evt.shiftKey && !evt.ctrlKey && !evt.altKey && evt.keyCode == 45) {
                    this._SetCancelEvent(evt);
                    this._PasteFromClipBoard();
                    return;
                }
            }
        }
        if (Sys.Browser.agent != Sys.Browser.InternetExplorer || evt.type == "keypress") 
        {
            //Shift Ins 
            if (evt.rawEvent.shiftKey && !evt.rawEvent.ctrlKey && !evt.rawEvent.altKey && evt.rawEvent.keyCode == 45) {
                //at opera assume Ins = "-" not execute Shift-Ins
                this._SetCancelEvent(evt);
                this._PasteFromClipBoard();
                return;
            }
            // ctrl v 
            if (evt.type == "keypress" && (scanCode == 86 || scanCode == 118) && !evt.shiftKey && evt.ctrlKey && !evt.altKey) {
                this._SetCancelEvent(evt);
                this._PasteFromClipBoard();
                return;
            }
        }
        if (Sys.Browser.agent == Sys.Browser.InternetExplorer || evt.type == "keypress") 
        {
            if (scanCode == 8) // BackSpace
            {
                this._SetCancelEvent(evt);
                curpos = this._deleteTextSelection();
                if (curpos != -1)
                {
                    this.setSelectionRange(curpos,curpos);
                }
                else
                {
                    curpos = this._getCurrentPosition();
                    this._backspace(curpos);
                    
                    curpos = this._getPreviousPosition(curpos-1);
                    this.setSelectionRange(curpos,curpos);
                }
                var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element());
                if (this._MessageValidatorTip && wrapper.get_Value() == this._EmptyMask)
                {
                    this.ShowTooltipMessage(true);
                }
                // Opera not perform cancel event. Re-perform at Timer
                if (Sys.Browser.agent == Sys.Browser.Opera)
                {
                    this._SaveText = wrapper.get_Value(); 
                    this._SavePosi = curpos;
                    this._timer.set_enabled(false);
                    this._timer.set_interval(1);
                    this._timer.set_enabled(true);
                }
            }
            else if (scanCode == 46 || scanCode == 127) // delete
            {
                this._SetCancelEvent(evt);
                var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element());
                curpos = this._deleteTextSelection();
                if (curpos == -1)
                {
                    curpos = this._getCurrentPosition();
                    if (!this._isValidMaskedEditPosition(curpos))
                    {
                        if (curpos != this._LogicLastInt && this._InputDirection != AjaxControlToolkit.MaskedEditInputDirections.RightToLeft)
                        {
                            curpos = this._getNextPosition(curpos);
                        }
                    }
                    this._deleteAtPosition(curpos,false);
                }
                else
                {
                    if (this._InputDirection == AjaxControlToolkit.MaskedEditInputDirections.RightToLeft)
                    {
                        ClearText = this._getClearMask(wrapper.get_Value());
                        if (ClearText != "")
                        {
                            ClearText = ClearText.replace(new RegExp("(\\" + this.get_CultureThousandsPlaceholder() + ")", "g"), "") + '';
                            if (ClearText.substring(ClearText.length-1,ClearText.length) == this.get_CultureDecimalPlaceholder())
                            {
                                ClearText = ClearText.substring(0,ClearText.length-1);
                                this.loadValue(ClearText,this._LogicLastInt);
                            }
                            else
                            {
                                this.loadValue(ClearText,this._LogicLastPos);
                            }
                        }
                    }
                }
                this.setSelectionRange(curpos,curpos);
                if (this._MessageValidatorTip && wrapper.get_Value() == this._EmptyMask)
                {
                    this.ShowTooltipMessage(true);
                }
                if (Sys.Browser.agent == Sys.Browser.Opera)
                {
                    this._SaveText = wrapper.get_Value(); 
                    this._SavePosi = curpos;
                    this._timer.set_enabled(false);
                    this._timer.set_interval(1);
                    this._timer.set_enabled(true);
                }
            }
            else if(evt.ctrlKey)
            {
                if (scanCode == 39 || scanCode == 35 || scanCode == 34) //Right or END or pgdown
                {
                    this._DirectSelText = "R";
                    if (Sys.Browser.agent == Sys.Browser.Opera)
                    {
                        return;
                    }
                    this._SetCancelEvent(evt);
                    curpos = this._getCurrentPosition();
                    this.setSelectionRange(curpos,this._LogicLastPos+1);
                }
                else if (scanCode == 37  || scanCode == 36 || scanCode == 33) //Left or Home or pgup
                {
                    this._DirectSelText = "L";
                    if (Sys.Browser.agent == Sys.Browser.Opera)
                    {
                        return;
                    }
                    this._SetCancelEvent(evt);
                    curpos = this._getCurrentPosition();
                    this.setSelectionRange(this._LogicFirstPos,curpos);
                }
            }
            else if (scanCode == 35 || scanCode == 34) //END or pgdown
            {
                this._DirectSelText = "R";
                if (Sys.Browser.agent == Sys.Browser.Opera)
                {
                    return;
                }
                this._SetCancelEvent(evt);
                if (evt.shiftKey)
                {
                    curpos = this._getCurrentPosition();
                    this.setSelectionRange(curpos,this._LogicLastPos+1);
                }
                else
                {
                    this.setSelectionRange(this._LogicLastPos+1,this._LogicLastPos+1);
                }
            }
            else if (scanCode == 36 || scanCode == 33) //Home or pgup
            {
                this._DirectSelText = "L";
                if (Sys.Browser.agent == Sys.Browser.Opera)
                {
                    return;
                }
                this._SetCancelEvent(evt);
                if (evt.shiftKey)
                {
                    curpos = this._getCurrentPosition();
                    this.setSelectionRange(this._LogicFirstPos,curpos);
                }
                else
                {
                    this.setSelectionRange(this._LogicFirstPos,this._LogicFirstPos);
                }
            }
            else if (scanCode == 37) //left
            {
                this._DirectSelText = "L";
                if (Sys.Browser.agent == Sys.Browser.Opera)
                {
                    return;
                }
                this._SetCancelEvent(evt);
                if (evt.shiftKey)
                {
                    var BoundSel = this._GetBoundSelection();
                    if (BoundSel)
                    {
                        if (BoundSel.left > this._LogicFirstPos)
                        {
                            BoundSel.left --;     
                        }
                        this.setSelectionRange(BoundSel.left,BoundSel.right);
                    }
                    else
                    {
                        var pos = this._getCurrentPosition();
                        if (pos  > this._LogicFirstPos)
                        {
                            this.setSelectionRange(pos -1,pos);
                        }
                    }
                }
                else
                {
                    curpos = this._getCurrentPosition()-1;
                    if (curpos < this._LogicFirstPos)
                    {
                        curpos = this._LogicFirstPos;
                    }
                    this.setSelectionRange(curpos,curpos);
                }
                if (Sys.Browser.agent == Sys.Browser.Opera)
                {
                    var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element());
                    this._SaveText = wrapper.get_Value(); 
                    this._SavePosi = curpos;
                    this._timer.set_enabled(false);
                    this._timer.set_interval(1);
                    this._timer.set_enabled(true);
                }
            }
            else if (scanCode == 39) // right
            {
                this._DirectSelText = "R";
                if (Sys.Browser.agent == Sys.Browser.Opera)
                {
                    return;
                }
                this._SetCancelEvent(evt);
                if (evt.shiftKey)
                {
                    var BoundSel = this._GetBoundSelection();
                    if (BoundSel)
                    {
                        if (BoundSel.right < this._LogicLastPos+1)
                        {
                            BoundSel.right ++;     
                        }
                        this.setSelectionRange(BoundSel.left,BoundSel.right);
                    }
                    else
                    {
                        pos = this._getCurrentPosition();
                        if (pos  < this._LogicLastPos+1)
                        {
                            this.setSelectionRange(pos,pos+1);
                        }
                    }
                }
                else
                {
                    curpos = this._getCurrentPosition()+1;
                    if (curpos > this._LogicLastPos+1)
                    {
                        curpos = this._LogicLastPos+1;
                    }
                    this.setSelectionRange(curpos,curpos);
                }
                if (Sys.Browser.agent == Sys.Browser.Opera)
                {
                    var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element());
                    this._SaveText = wrapper.get_Value(); 
                    this._SavePosi = curpos;
                    this._timer.set_enabled(false);
                    this._timer.set_interval(1);
                    this._timer.set_enabled(true);
                }
            }
            else if (scanCode == 27) // esc
            {
                this._SetCancelEvent(evt);
                var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element());
                if (this._EmptyMask == this._initialvalue)
                {
                    wrapper.set_Value("");
                }
                else
                {
                    wrapper.set_Value(this._initialvalue);
                }
                this._onFocus();
            }
            //else if (scanCode == 38 || scanCode == 40)  //up - down 
        }
        // any other nav key
        this._SetCancelEvent(evt);
    }
    //
    // backspace at current position
    //
    , _backspace : function(curpos) 
    {
        var exec = false;
        if (curpos > this._LogicFirstPos)
        {
            var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element());
            var masktext = wrapper.get_Value();
            curpos = this._getPreviousPosition(curpos-1);
            this._deleteAtPosition(curpos, true);
            exec = true;
        }
        return exec;
    }
    //
    // delete at current position
    //
    , _deleteAtPosition : function(curpos,isBS) 
    {
        var exec = false;
        var lastpos = this._LogicLastPos+1;
        if (this._LogicLastInt != -1 && this._InputDirection == AjaxControlToolkit.MaskedEditInputDirections.RightToLeft)
        {
            lastpos = this._LogicLastInt;
        }
        var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element());
        if (isBS == false && this._InputDirection == AjaxControlToolkit.MaskedEditInputDirections.RightToLeft && curpos == lastpos)
        {
            ClearText = this._getClearMask(wrapper.get_Value());
            if (ClearText != "")
            {
                exec = true;
                ClearText = ClearText.replace(new RegExp("(\\" + this.get_CultureThousandsPlaceholder() + ")", "g"), "") + '';
                if (ClearText.substring(ClearText.length-1,ClearText.length) == this.get_CultureDecimalPlaceholder())
                {
                    ClearText = ClearText.substring(0,ClearText.length-1);
                }
                var arr_num = ClearText.split(this.get_CultureDecimalPlaceholder());
                if (this._LogicLastInt != -1 && arr_num[0] != "")
                {
                    arr_num[0] = arr_num[0].substring(0,arr_num[0].length-1);
                    ClearText =  arr_num[0];
                    if (arr_num.length = 2)
                    {
                        ClearText += this.get_CultureDecimalPlaceholder() + arr_num[1];
                    }
                }
                else
                {
                    ClearText = ClearText.substring(0,ClearText.length-1);
                }
                ClearText += this._LogicSymbol;
                this.loadValue(ClearText,lastpos);
            }
        }
        else
        {
            var masktext = wrapper.get_Value().substring(this._LogicFirstPos,this._LogicLastPos+1);
            var logiTxt = this._LogicTextMask.substring(this._LogicFirstPos,this._LogicLastPos+1);
            var qtdDt = 0;
            var curvld = curpos - this._LogicFirstPos;
            if (this._isValidMaskedEditPosition(curpos))
            {
                exec = true;
                if (this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime)
                {
                    var arr_mask = masktext.split(" ");
                    var posmask = curpos - this._LogicFirstPos;
                    if (posmask > arr_mask[0].length)
                    {
                        // at position time
                        masktext = arr_mask[1];        
                        qtdDt = arr_mask[0].length +1;
                        logiTxt = logiTxt.substring(qtdDt);
                        curvld -= qtdDt;
                    }
                    else
                    {
                        // at position date
                        masktext = arr_mask[0];
                        logiTxt = logiTxt.substring(0,arr_mask[0].length);
                    }
                }
                var resttext = masktext.substring(curvld+1);
                var restlogi = logiTxt.substring(curvld+1);
                masktext = masktext.substring(0,curvld) + this._PromptChar;
                logiTxt = logiTxt.substring(0,curvld) + this._LogicPrompt;
                // clear rest of mask
                for (i = 0 ; i < parseInt(resttext.length,10) ; i++) 
                {
                    if (this._isValidMaskedEditPosition(curpos+1+i))
                    {
                        masktext += this._PromptChar;
                        logiTxt += this._LogicPrompt;
                    }
                    else
                    {
                        masktext += resttext.substring(i,i+1);
                        logiTxt += restlogi.substring(i,i+1);
                    }
                }
                // insert only valid text
                posaux = this._getNextPosition(curpos);
                for (i = 0 ; i < parseInt(resttext.length,10) ; i++) 
                {
                    if (this._isValidMaskedEditPosition(curpos+1+i) && restlogi.substring(i,i+1) != this._LogicPrompt)
                    {
                        masktext = masktext.substring(0,posaux- this._LogicFirstPos-qtdDt) + resttext.substring(i,i+1) + masktext.substring(posaux+1- this._LogicFirstPos-qtdDt);
                        logiTxt = logiTxt.substring(0,posaux- this._LogicFirstPos-qtdDt) + restlogi.substring(i,i+1) + logiTxt.substring(posaux+1- this._LogicFirstPos-qtdDt);
                        posaux = this._getNextPosition(posaux+1);
                    }
                }            
                if (this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime)
                {
                    var oritext = wrapper.get_Value().substring(this._LogicFirstPos,this._LogicLastPos+1);
                    var orilogi = this._LogicTextMask.substring(this._LogicFirstPos,this._LogicLastPos+1)
                    var arr_mask = oritext.split(" ");
                    var posmask = curpos - this._LogicFirstPos;
                    if (posmask > arr_mask[0].length)
                    {
                        // at position time
                        masktext = arr_mask[0] + " " +  masktext;        
                        logiTxt = orilogi.substring(0, qtdDt) + logiTxt;
                    }
                    else
                    {
                        // at position date
                        masktext = masktext + " " + arr_mask[1];
                        logiTxt = logiTxt + orilogi.substring(arr_mask[0].length);
                    }
                }
                var currValue = wrapper.get_Value();
                masktext = currValue.substring(0,this._LogicFirstPos) + masktext + currValue.substring(this._LogicLastPos+1);
                this._LogicTextMask = this._LogicTextMask.substring(0,this._LogicFirstPos) + logiTxt + this._LogicTextMask.substring(this._LogicLastPos+1);
                wrapper.set_Value(masktext);
            }
        }
        return exec;
    }
    //
    // Paste clip board
    //
    ,_ShowModalClipBoardInput : function()
    {
        var clip = prompt(this._ClipboardText,"");
        return clip;
    }
    ,_PasteFromClipBoard  : function()
    {
        var value = null;
        var curpos;
        var iniSel = -1;
        var fimSel = -1;
        if (Sys.Browser.agent == Sys.Browser.InternetExplorer) 
        {
            value = window.clipboardData.getData("Text");
        }
        else
        {
            //save current values because lost focus 
            var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element());
            var oldvalue = wrapper.get_Value();
            var BoundSel = this._GetBoundSelection();
            var curpos = this._getCurrentPosition();
            var OldAuto = this._AutoComplete;
            var OldInv = this._ClearTextOnInvalid;
            var OldCls = this._ClearMaskOnLostfocus;
            var OldDir = this._DirectSelText;
            this._AutoComplete = false;
            this._ClearTextOnInvalid = false;
            this._ClearMaskOnLostfocus = false;
            value = this._ShowModalClipBoardInput();
            this._AutoComplete = OldAuto;
            this._ClearTextOnInvalid = OldInv;
            this._ClearMaskOnLostfocus = OldCls;
            wrapper.set_Value(oldvalue);
            if (BoundSel)
            {
                this.setSelectionRange(BoundSel.left,BoundSel.right);
            }
            else
            {
                this.setSelectionRange(curpos,curpos);
            }
        }
        if (value == null || value == "")
        {
            return;
        }
        if (value.length > this._maskvalid.length)
        {
             value = value.substring(0,this._maskvalid.length);
        }
        curpos = this._deleteTextSelection();
        if (curpos == -1)
        {
            curpos = this._getCurrentPosition();
            if (BoundSel)
            {
                curpos = BoundSel.left;
            }
        }
        this.setSelectionRange(curpos,curpos);
        var ReturnPosDec = false;
        if (this._InputDirection == AjaxControlToolkit.MaskedEditInputDirections.RightToLeft && this._LogicLastInt != -1)
        {
            ReturnPosDec = true;
        }
        var i = 0;
        for (i = 0; i < value.length;i++)
        {
            var c = value.substring(i,i+1);
            var logiccur = curpos;
            if (ReturnPosDec)
            {
                logiccur = this._getLastEmptyPosition();
            }
            if ( (this._MaskType == AjaxControlToolkit.MaskedEditType.Time || this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime) && this.get_CultureFirstLettersAMPM().toUpperCase().indexOf(c.toUpperCase()) != -1)
            {
                if (this._AcceptAmPm)
                {
                    this.InsertAMPM(c);
                    this.setSelectionRange(curpos,curpos);
                }
            }
            else if (this._MaskType == AjaxControlToolkit.MaskedEditType.Number && this._AcceptNegative != AjaxControlToolkit.MaskedEditShowSymbol.None && "+-".indexOf(c) != -1)
            {
                this.InsertSignal(c);
                this.setSelectionRange(curpos,curpos);
            }
            else
            {
                var OriPos = curpos;
                curpos = this._getNextPosition(curpos);
                var logiccur = curpos;
                if (this._LogicLastInt != -1 && this._InputDirection == AjaxControlToolkit.MaskedEditInputDirections.RightToLeft)
                {
                    if (OriPos == this._LogicLastInt)
                    {
                        logiccur = this._getLastEmptyPosition();
                    }
                }
                else
                {
                    if (curpos >= this._LogicLastPos+1 && this._InputDirection == AjaxControlToolkit.MaskedEditInputDirections.RightToLeft)
                    {
                        logiccur = this._getLastEmptyPosition();
                    }
                }
                if (this._processKey(logiccur,c)) 
                {
                    if (this._MessageValidatorTip) 
                    {
                        this.ShowTooltipMessage(false);
                    }
                    if (this._InputDirection == AjaxControlToolkit.MaskedEditInputDirections.LeftToRight)
                    {
                        this._insertContent(c,logiccur);
                        curpos = this._getNextPosition(logiccur+1);
                    } 
                    else if (this._InputDirection == AjaxControlToolkit.MaskedEditInputDirections.RightToLeft)
                    {
                        if (this._LogicLastInt == -1)
                        {
                            if (curpos < this._LogicLastPos+1)
                            {
                                this._insertContent(c,logiccur);
                                curpos = this._getNextPosition(logiccur+1);
                            }
                            else
                            {
                                this._insertContentRight(c);
                                curpos = this._LogicLastPos+1;
                            }
                        }
                        else
                        {
                            if (OriPos != this._LogicLastInt)
                            {
                                this._insertContent(c,logiccur);
                                curpos = this._getNextPosition(logiccur+1);
                            }
                            else
                            {
                                this._insertContentRight(c);
                                curpos = this._LogicLastInt;
                            }
                        }
                    }
                    this.setSelectionRange(curpos,curpos);
                }
            }
        }
        if (ReturnPosDec)
        {
            this.setSelectionRange(this._LogicLastInt,this._LogicLastInt);
        }
    }
    //
    // Move cursor to decimal position (LeftToRight and RightToLeft Mode)
    //
    , _MoveDecimalPos : function()
    {
        var e = this.get_element();
        var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(e);
        var curpos = this._LogicFirstPos;
        var max = this._LogicLastPos;
        var posDc = -1;
        while (curpos < max)
        {
            if (wrapper.get_Value().substring(curpos,curpos+1) == this.get_CultureDecimalPlaceholder())
            {
                posDc = curpos;
                break;
            }
            curpos++;
        }
        if (posDc == -1)
        {
            return;
        }
        this.setSelectionRange(posDc,posDc);
    }
    //
    // Move cursor to next Thousand position (LeftToRight Mode)
    //
    , _MoveThousandLTR : function()
    {
        var e = this.get_element();
        var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(e);
        var curpos = this._getCurrentPosition();
        var max = this._LogicLastPos;
        var cur = curpos+1;
        var posTh = -1;
        while (cur < max)
        {
            if (wrapper.get_Value().substring(cur,cur+1) == this.get_CultureThousandsPlaceholder())
            {
                posTh = cur;
                break;
            }
            cur++;
        }
        if (posTh == -1)
        {
            var cur = 0;
            max = curpos;
            while (cur < max)
            {
                if (wrapper.get_Value().substring(cur,cur+1) == this.get_CultureThousandsPlaceholder())
                {
                    posTh = cur;
                    break;
                }
                cur++;
            }
            if (posTh == -1)
            {
                return;
            }
        }
        this.setSelectionRange(posTh,posTh);
    }
    //
    // Move cursor to next Thousand position (RightToLeft Mode)
    //
    , _MoveThousandRTL : function()
    {
        var e = this.get_element();
        var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(e);
        var curpos = this._getCurrentPosition();
        var min = this._LogicFirstPos;
        var cur = curpos-1;
        var posTh = -1;
        while (cur > min)
        {
            if (wrapper.get_Value().substring(cur,cur+1) == this.get_CultureThousandsPlaceholder())
            {
                posTh = cur;
                break;
            }
            cur--;
        }
        if (posTh == -1)
        {
            cur = this._LogicLastPos;
            min = curpos;
            while (cur > min)
            {
                if (wrapper.get_Value().substring(cur,cur+1) == this.get_CultureThousandsPlaceholder())
                {
                    posTh = cur;
                    break;
                }
                cur--;
            }
            if (posTh == -1)
            {
                return;
            }
        }
        this.setSelectionRange(posTh,posTh);
    }
    //
    // adjust element Number to Decimal position (LeftToRight Mode)
    //
    , _AdjustElementDecimalLTR : function()
    {
        var e = this.get_element();
        var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(e);
        var curpos = this._getCurrentPosition();
        if (wrapper.get_Value().substring(curpos).indexOf(this.get_CultureDecimalPlaceholder()) == -1)
        {
            //after decimal position
            return;
        }
        var value = wrapper.get_Value().substring(this._LogicFirstPos,this._LogicLastPos+1);
        var newcur = value.indexOf(this.get_CultureDecimalPlaceholder());
        if (newcur  == -1)
        {
            //decimal not exist
            return;
        }
        var arr_num;
        ClearText = this._getClearMask(wrapper.get_Value());
        if (ClearText != "")
        {
            ClearText = ClearText.replace(new RegExp("(\\" + this.get_CultureThousandsPlaceholder() + ")", "g"), "") + '';
            arr_num = ClearText.split(this.get_CultureDecimalPlaceholder());
        }
        else
        {
            arr_num =  this.get_CultureDecimalPlaceholder().split(this.get_CultureDecimalPlaceholder());
        }      
        if (arr_num[0] == "")
        {
            arr_num[0] = "0";
        }
        // fill decimal
        var QtdDec = value.length - newcur - 1;
        while (arr_num[1].length < QtdDec)
        {
            arr_num[1] += "0";
        }
        var OldDir = this._InputDirection;
        this._InputDirection = AjaxControlToolkit.MaskedEditInputDirections.RightToLeft;
        this.loadValue(arr_num[0] + this.get_CultureDecimalPlaceholder() + arr_num[1],this._LogicLastPos);
        this._InputDirection = OldDir;
        newcur += this._LogicFirstPos + 1;
        this.setSelectionRange(newcur,newcur);
    }
    //
    // adjust element Number to Decimal position (RightToleft Mode)
    //
    , _AdjustElementDecimalRTL : function()
    {
        var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element());
        var value = wrapper.get_Value().substring(this._LogicFirstPos,this._LogicLastPos+1);
        var posdec = value.indexOf(this.get_CultureDecimalPlaceholder());
        if (posdec == -1)
        {
            //decimal not exist
            return;
        }
        var curpos = this._getCurrentPosition();
        if (posdec + this._LogicFirstPos >= curpos)
        {
            //before decimal position , EXECUTE LTR MODE
            this._AdjustElementDecimalLTR();
            return;
        }
        var arr_num;
        ClearText = this._getClearMask(wrapper.get_Value());
        if (ClearText != "")
        {
            ClearText = ClearText.replace(new RegExp("(\\" + this.get_CultureThousandsPlaceholder() + ")", "g"), "") + '';
            arr_num = ClearText.split(this.get_CultureDecimalPlaceholder());
        }
        else
        {
            arr_num =  this.get_CultureDecimalPlaceholder().split(this.get_CultureDecimalPlaceholder());
        }      
        if (arr_num[0] == "")
        {
            arr_num[0] = "0";
        }
        // fill decimal
        var QtdDec = value.length - posdec - 1;
        while (arr_num[1].length < QtdDec)
        {
            arr_num[1] += "0";
        }
        var OldDir = this._InputDirection;
        this._InputDirection = AjaxControlToolkit.MaskedEditInputDirections.RightToLeft;
        this.loadValue(arr_num[0] + this.get_CultureDecimalPlaceholder() + arr_num[1],this._LogicLastPos);
        this._InputDirection = OldDir;
        posdec += this._LogicFirstPos + 1;
        this.setSelectionRange(posdec,posdec);
    }
    //
    // adjust Time Format 
    //
    , _AdjustTime : function(value,ValueDefault)
    {
        var emp = true;    
        var i
        for (i = 0 ; i < parseInt(value.length,10) ; i++) 
        {
            if (value.substring(i,i+1) != this._PromptChar)
            {
                emp = false;
            }
        }
        if (emp)
        {
           return ValueDefault;
        }
        var max = value.length;
        value = value.replace(new RegExp("(\\" + this._PromptChar + ")", "g"), "") + '';
        while (value.length < max)
        {
            value = "0" + value;
        }
        return value;
    }
    //
    // adjust Element Time Format 
    //
    , _AdjustElementTime : function()
    {
        var e = this.get_element();
        var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(e);
        var type = "";
        var curpos = this._getCurrentPosition() - this._LogicFirstPos;
        var m_mask = this._maskvalid;
        var newcur = curpos + this._LogicFirstPos;
        var QtdDt = 0;
        if (this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime)
        {
            QtdDt = m_mask.split(" ")[0].length+1;
            if (curpos < QtdDt)
            {
                newcur = QtdDt+this._LogicFirstPos;
                this.setSelectionRange(newcur,newcur);
                return;
            }
            // without am/pm, The AP/PM will get from this._LogicSymbol
            m_mask = m_mask.split(" ")[1];
            curpos -= QtdDt;
        }
        m_mask = m_mask.split(":");
        if (curpos <= 1)
        {
            type = "H";
            newcur = 3 + this._LogicFirstPos + QtdDt;
            
        } 
        else if (curpos >= 2 && curpos <= 4 && m_mask.length == 2)
        {
            type = "M";
            newcur = QtdDt+this._LogicFirstPos;
        }
        else if (curpos >= 2 && curpos <= 4 && m_mask.length == 3)
        {
            type = "M";
            newcur = 6 + this._LogicFirstPos + QtdDt;
        }
        else if (m_mask.length == 3)
        {
            type = "S";
            newcur = QtdDt+this._LogicFirstPos;
        } 
        if (type == "")
        {
            return;
        }
        var valueTM = wrapper.get_Value().substring(this._LogicFirstPos,this._LogicLastPos+1);
        if (this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime)
        {
            valueTM = valueTM.split(" ")[1];
        }
        var m_arrTime = valueTM.split(this.get_CultureTimePlaceholder());
        var elem = this._GetTimeElementText(type);
        var value;
        if (type == "H")
        {
            value = elem + this.get_CultureTimePlaceholder() + m_arrTime[1];
            if (m_arrTime.length == 3)
            {
                value += this.get_CultureTimePlaceholder() + m_arrTime[2];
            }
        }
        else if (type == "M")
        {
            value = m_arrTime[0] + this.get_CultureTimePlaceholder() + elem;
            if (m_arrTime.length == 3)
            {
                value += this.get_CultureTimePlaceholder() + m_arrTime[2];
            }
        }
        else if (type == "S")
        {
            value = m_arrTime[0] + this.get_CultureTimePlaceholder() + m_arrTime[1];
            value += this.get_CultureTimePlaceholder() + elem;
        }
        if (this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime)
        {
            value = wrapper.get_Value().substring(this._LogicFirstPos,QtdDt) + value;
        }
        this.loadMaskValue(value,this._LogicFirstPos,this._LogicSymbol);
        this.setSelectionRange(newcur,newcur);
    }
    //
    // Get Element Time
    //
    , _GetTimeElementText : function(Type)
    {
        var aux;
        var logiTxt = this._LogicTextMask.substring(this._LogicFirstPos,this._LogicLastPos+1);
        if (this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime)
        {
            logiTxt = logiTxt.substring(this._maskvalid.split(" ")[0].length+1);
        }
        var m_arrTime = logiTxt.split(this.get_CultureTimePlaceholder());
        m_arrTime[0] = m_arrTime[0].replace(new RegExp("(\\" + this._LogicPrompt + ")", "g"), this._PromptChar) + '';
        aux = m_arrTime[0].replace(new RegExp("(\\" + this._PromptChar + ")", "g"), "") + '';
        if (aux !="" && aux.length < 2)
        {
            aux = "0" + aux;
            m_arrTime[0] = aux;
        }
        
        m_arrTime[1] = m_arrTime[1].replace(new RegExp("(\\" + this._LogicPrompt + ")", "g"), this._PromptChar) + '';
        aux = m_arrTime[1].replace(new RegExp("(\\" + this._PromptChar + ")", "g"), "") + '';
        if (aux !="" && aux.length < 2)
        {
            aux = "0" + aux;
            m_arrTime[1] =  aux;
        }
        if (m_arrTime.length == 3)
        {
            m_arrTime[2] = m_arrTime[2].replace(new RegExp("(\\" + this._LogicPrompt + ")", "g"), this._PromptChar) + '';
            aux = m_arrTime[2].replace(new RegExp("(\\" + this._PromptChar + ")", "g"), "") + '';
            if (aux !="" && aux.length < 2)
            {
                aux = "0" + aux;
                m_arrTime[2] =  aux;
            }
        }
        if (Type == "H")
        {
            return m_arrTime[0];
        }
        else if (Type == "M")
        {
            return m_arrTime[1];
        }
        //Type == "S"
        return m_arrTime[2];
    }
    //
    // adjust Date Format 
    //
    , _AdjustElementDateTime : function(c)
    {
        if (c == this.get_CultureDatePlaceholder())
        {
            this._AdjustElementDate();
        }
        if (c == this.get_CultureTimePlaceholder())
        {
            this._AdjustElementTime();
        }
    }
    , _AdjustElementDate : function()
    {
        var e = this.get_element();
        var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(e);
        var input = wrapper.get_Value().substring(this._LogicFirstPos,this._LogicLastPos+1);
        if (this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime)
        {
            input = input.split(" ")[0];
        }
        var m_arrDate = input.split(this.get_CultureDatePlaceholder());
        var type = "";
        var curpos = this._getCurrentPosition() - this._LogicFirstPos;
        var newcur = curpos + this._LogicFirstPos;
        var QtdY = (this._maskvalid.indexOf("9999") != -1)?2:0;
        if (this.get_CultureDateFormat() == "DMY")
        {
           if (curpos <= 1)
           {
                type = "D";
                newcur = 3 + this._LogicFirstPos;
                
           } 
           else if (curpos >= 2 && curpos <= 4)
           {
                type = "M";
                newcur = 6 + this._LogicFirstPos;
           }
           else
           {
                if (curpos > 8 + QtdY &&  this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime)
                {
                    this.setSelectionRange(this._LogicFirstPos,this._LogicFirstPos);
                    return;
                }
                type = "Y";
                newcur = this._LogicFirstPos;
           } 
        }
        else if (this.get_CultureDateFormat() == "MDY")
        {
           if (curpos <= 1)
           {
                type = "M";
                newcur = 3 + this._LogicFirstPos;
                
           } 
           else if (curpos >= 2 && curpos <= 4)
           {
                type = "D";
                newcur = 6 + this._LogicFirstPos;
           }
           else
           {
                if (curpos > 8 + QtdY &&  this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime)
                {
                    this.setSelectionRange(this._LogicFirstPos,this._LogicFirstPos);
                    return;
                }
                type = "Y";
                newcur = this._LogicFirstPos;
           } 
        }
        else if (this.get_CultureDateFormat() == "DYM")
        {
           if (curpos <= 1)
           {
                type = "D";
                newcur = 3 + this._LogicFirstPos;
                
           } 
           else if (curpos >= 2 && curpos <= 4+QtdY)
           {
                type = "Y";
                newcur = 6 + QtdY + this._LogicFirstPos;
           }
           else
           {
                type = "M";
                newcur = this._LogicFirstPos;
           } 
        }
        else if (this.get_CultureDateFormat() == "MYD")
        {
           if (curpos <= 1)
           {
                type = "M";
                newcur = 3 + this._LogicFirstPos;
                
           } 
           else if (curpos >= 2 && curpos <= 4+QtdY)
           {
                type = "Y";
                newcur = 6 + QtdY + this._LogicFirstPos;
           }
           else
           {
                type = "D";
                newcur = this._LogicFirstPos;
           } 
        }
        else if (this.get_CultureDateFormat() == "YMD")
        {
           if (curpos <= 1+QtdY)
           {
                type = "Y";
                newcur = 3 + QtdY + this._LogicFirstPos;
                
           } 
           else if (curpos >= 2+ QtdY && curpos <= 4+QtdY)
           {
                type = "M";
                newcur = 6 + QtdY + this._LogicFirstPos;
           }
           else
           {
                type = "D";
                newcur = this._LogicFirstPos;
           } 
        }
        else if (this.get_CultureDateFormat() == "YDM")
        {
           if (curpos <= 1+QtdY)
           {
                type = "Y";
                newcur = 3 + QtdY + this._LogicFirstPos;
                
           } 
           else if (curpos >= 2+ QtdY && curpos <= 4+QtdY)
           {
                type = "D";
                newcur = 6 + QtdY + this._LogicFirstPos;
           }
           else
           {
                type = "M";
                newcur = this._LogicFirstPos;
           } 
        }            
        var elem = this._GetDateElementText(type);
        m_arrDate[this.get_CultureDateFormat().indexOf(type)] = elem; 
        var value = m_arrDate[0] + this.get_CultureDatePlaceholder() + m_arrDate[1] + this._CultureDatePlaceholder + m_arrDate[2];
        if (this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime)
        {
            var aux = wrapper.get_Value().substring(this._LogicFirstPos,this._LogicLastPos+1);
            if (aux.split(" ").length == 3)
            {
                value += " " + aux.split(" ")[1] + " " + aux.split(" ")[2];
            }
            else
            {
                value += " " + aux.split(" ")[1];
            }
        }
        this.loadMaskValue(value,this._LogicFirstPos,this._LogicSymbol);
        this.setSelectionRange(newcur,newcur);
    }
    //
    // Get Element Date 
    //
    , _GetDateElementText : function(Type)
    {
        var aux;
        var m_arrDate;
        if (this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime)
        {
            var auxdate = this._LogicTextMask.substring(this._LogicFirstPos,this._LogicLastPos+1).split(" ")[0];
            m_arrDate = auxdate.split(this.get_CultureDatePlaceholder());
        }
        else
        {
            m_arrDate = this._LogicTextMask.substring(this._LogicFirstPos,this._LogicLastPos+1).split(this.get_CultureDatePlaceholder());
        }
        m_arrDate[this.get_CultureDateFormat().indexOf("D")] = m_arrDate[this.get_CultureDateFormat().indexOf("D")].replace(new RegExp("(\\" + this._LogicPrompt + ")", "g"), this._PromptChar) + '';
        aux = m_arrDate[this.get_CultureDateFormat().indexOf("D")].replace(new RegExp("(\\" + this._PromptChar + ")", "g"), "") + '';
        if (aux !="" && aux.length < 2)
        {
            aux = "0" + aux;
            m_arrDate[this.get_CultureDateFormat().indexOf("D")] = aux
        }
        
        m_arrDate[this.get_CultureDateFormat().indexOf("M")] = m_arrDate[this.get_CultureDateFormat().indexOf("M")].replace(new RegExp("(\\" + this._LogicPrompt + ")", "g"), this._PromptChar) + '';
        aux = m_arrDate[this.get_CultureDateFormat().indexOf("M")].replace(new RegExp("(\\" + this._PromptChar + ")", "g"), "") + '';
        if (aux !="" && aux.length < 2)
        {
            aux = "0" + aux;
            m_arrDate[this.get_CultureDateFormat().indexOf("M")] =  aux;
        }
        
        var Y4 = (this._maskvalid.indexOf("9999") != -1)?true:false;
        m_arrDate[this.get_CultureDateFormat().indexOf("Y")] = m_arrDate[this.get_CultureDateFormat().indexOf("Y")].replace(new RegExp("(\\" + this._LogicPrompt + ")", "g"), this._PromptChar) + '';
        aux = m_arrDate[this.get_CultureDateFormat().indexOf("Y")].replace(new RegExp("(\\" + this._PromptChar + ")", "g"), "") + '';
        if (Y4)
        {
            if (aux !="" && aux.length < 4)
            {
                while (aux.length < 4)
                {
                    aux = "0" + aux;
                }
                m_arrDate[this.get_CultureDateFormat().indexOf("Y")] = aux;
            }
        }
        else
        {
            if (aux !="" && aux.length < 2)
            {
                aux = "0" + aux;
                m_arrDate[this.get_CultureDateFormat().indexOf("Y")] = aux;
            }
        }
        return m_arrDate[this.get_CultureDateFormat().indexOf(Type)];
    }
    //
    // Get Bound Selection
    //
    , _GetBoundSelection : function()
    {
        var ret = null;
        var input = this.get_element();
        if (input.setSelectionRange) 
        {
            if (input.selectionStart != input.selectionEnd)
            {
                ret = {left: parseInt(input.selectionStart,10),right: parseInt(input.selectionEnd,10)};
            }
        }    
        else if (document.selection) 
        {
            sel = document.selection.createRange();
            if (sel.text != "")
            {
                var tam = parseInt(sel.text.length,10);
                sel.text = String.fromCharCode(3) + sel.text;
                var dummy = input.createTextRange();
                dummy.findText(String.fromCharCode(3));
                dummy.select();
                var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(input);
                var pos = parseInt(wrapper.get_Value().indexOf(String.fromCharCode(3)),10);
                document.selection.clear();
                ret = {left: pos,right: pos+tam};
            }
        }
        return ret;
    }
    //
    // delete Selection
    //
    , _deleteTextSelection : function()
    {
        var input = this.get_element();
        var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(input);
        var masktext = wrapper.get_Value();
        var lenaux = -1;
        var begin = -1;
        var isDel = false;
        if (input.setSelectionRange) 
        {
            if (input.selectionStart != input.selectionEnd)
            {
                var ini = parseInt(input.selectionStart,10);
                var fim = parseInt(input.selectionEnd,10);
                isDel = true;
                lenaux = fim - ini;
                begin=input.selectionStart;
                input.selectionEnd = input.selectionStart;
            }
        }
        else if (document.selection) 
        {
            sel = document.selection.createRange();
            if (sel.text != "")
            {
                isDel = true;
                var aux = sel.text + String.fromCharCode(3);
                sel.text = aux;
                var dummy = input.createTextRange();
                dummy.findText(aux);
                dummy.select();
                begin = wrapper.get_Value().indexOf(aux);
                document.selection.clear();
                lenaux = parseInt(aux.length,10)-1;
            }
        }
        if (isDel)
        {
            for (i = 0 ; i < lenaux ; i++) 
            {
                if (this._isValidMaskedEditPosition(begin+i))
                {
                    masktext = masktext.substring(0,begin+i) + this._PromptChar + masktext.substring(begin+i+1);
                    this._LogicTextMask = this._LogicTextMask.substring(0,begin+i) + this._LogicPrompt + this._LogicTextMask.substring(begin+i+1);
                }
            }
            wrapper.set_Value(masktext);
            if (this._InputDirection == AjaxControlToolkit.MaskedEditInputDirections.RightToLeft)
            {
                begin += lenaux;
            }
        }
        this._DirectSelText = "";
        return begin;
    }
    , _isNormalChar : function(evt,scanCode) {
        /// <summary>
        /// Returns true if the specified charCode is a key rather than a normal (displayable) character or Enter Key
        /// </summary>
        /// <param>
        ///  name="scanCode" type="integer" : keycode
        /// </param>
        /// <returns type="Boolean" />
        var ret = true;
        if (Sys.Browser.agent == Sys.Browser.Opera && evt.type == "keydown")
        {
            this._SaveKeyDown = scanCode;
        }
        if (scanCode < 32) { // < space
            ret = false;
        }
        else if (Sys.Browser.agent != Sys.Browser.InternetExplorer || evt.type == "keydown") 
        {
            switch (scanCode) 
            {
                case 33: //pg up or ! 
                    if (typeof(evt.rawEvent.which) != "undefined" && evt.rawEvent.which !=null)
                    {
                        if (evt.rawEvent.which == 0)
                        {
                            //pg up
                            ret = false;
                        }
                    }
                    break;
                case 34: //pg down  or " 
                    if (typeof(evt.rawEvent.which) != "undefined" && evt.rawEvent.which !=null)
                    {
                        if (evt.rawEvent.which == 0)
                        {
                            //pg down
                            ret = false;
                        }
                    }
                    break;
                case 35: //end   
                    if (Sys.Browser.agent == Sys.Browser.Opera && evt.type == "keypress")
                    {
                        //at opera keydown = 51 keypress = 35 = #
                        if (this._SaveKeyDown == 35) 
                        {
                            //END
                            ret = false;
                        }
                    }
                    else
                    {
                        ret = false;
                    }
                    break;
                case 36: //home
                    if (Sys.Browser.agent == Sys.Browser.Opera && evt.type == "keypress")
                    {
                        //at opera keydown = 52 keypress = 36 = $
                        if (this._SaveKeyDown == 36)
                        {
                            //home
                            ret = false;
                        }
                    }
                    else
                    {
                        ret = false;
                    }
                    break;
                case 37: //left  or % 
                    if (typeof(evt.rawEvent.which) != "undefined" && evt.rawEvent.which !=null)
                    {
                        if (evt.rawEvent.which == 0)
                        {
                            //left
                            ret = false;
                        }
                    }
                    break;
                case 38: //up or &
                    if (typeof(evt.rawEvent.which) != "undefined" && evt.rawEvent.which !=null)
                    {
                        if (evt.rawEvent.which == 0)
                        {
                            //up
                            ret = false;
                        }
                    }
                    break;
                case 39: //right or  '
                    if (typeof(evt.rawEvent.which) != "undefined" && evt.rawEvent.which !=null)
                    {
                        if (evt.rawEvent.which == 0)
                        {
                            //right
                            ret = false;
                        }
                    }
                    break;
                case 40: //down or (
                    if (typeof(evt.rawEvent.which) != "undefined" && evt.rawEvent.which !=null)
                    {
                        if (evt.rawEvent.which == 0)
                        {
                            //down
                            ret = false;
                        }
                    }
                    break;
                case 45: //ins - at opera Inconsistency with -
                    if (typeof(evt.rawEvent.which) != "undefined" && evt.rawEvent.which !=null && Sys.Browser.agent != Sys.Browser.Opera)
                    {
                        if (evt.rawEvent.which == 0)
                        {
                            ret = false;
                        }
                    }
                    // re-valid Ins for opera
                    else if (Sys.Browser.agent == Sys.Browser.Opera)   
                    {
                        //assume ins = char "-"
                        //at opera Shift-ins in MaskedEdit not execute
                        ret = true;
                    }
                    else
                    {
                        ret = false;
                    }
                    break;
                case 86: // V   
                case 118: // v
                    //ctrl press
                    if (!evt.rawEvent.shiftKey && evt.rawEvent.ctrlKey && !evt.rawEvent.altKey) 
                    {
                        ret = false;
                    }
                    break;
                case 46: //del FF ~ Mozilla - at opera Inconsistency with .
                    if (typeof(evt.rawEvent.which) != "undefined" && evt.rawEvent.which !=null && Sys.Browser.agent != Sys.Browser.Opera)
                    {
                        if (evt.rawEvent.which == 0)
                        {
                            ret = false;
                        }
                    }
                    else if (Sys.Browser.agent == Sys.Browser.Opera && evt.type == "keypress")
                    {
                        //at opera keydown = 78 keypress = 46 = . at numpad
                        if (this._SaveKeyDown == 127)
                        {
                            ret = false;
                        }
                    }
                    else
                    {
                        ret = false;
                    }
                    break;
                case 127: //del IE - at opera Inconsistency with .
                    ret = false;
                    break;
            }
        }        
        return ret;
    }
    , _KeyCode : function(evt) {
        /// <summary>
        /// Get Keycode for any browser
        /// and convert keycode Safari to IE Code
        /// </summary>
        /// <param>
        /// Event info name="evt" type="Sys.UI.DomEvent" 
        /// </param>
        /// <Return>
        /// Keycode value 
        /// </Return>
        scanCode = 0;
        if (evt.keyIdentifier) {
            if (evt.charCode == 63272) { //63272: 'KEY_DELETE', 46
                scanCode = 46;
            }
            else if (evt.charCode == 63302) { //63302: 'KEY_INSERT', 45
                scanCode = 45;
            }
            else if (evt.charCode == 63233) { //63233: 'KEY_ARROW_DOWN',40
                scanCode = 40;
            }
            else if (evt.charCode == 63235) { //63235: 'KEY_ARROW_RIGHT', 39
                scanCode = 39;
            }
            else if (evt.charCode == 63232) { //63232: 'KEY_ARROW_UP', 38
                scanCode = 38;
            }
            else if (evt.charCode == 63234) { //63234: 'KEY_ARROW_LEFT', 37
                scanCode = 37;
            }
            else if (evt.charCode == 63273) { //63273: 'KEY_HOME', 36
                scanCode = 36;
            }
            else if (evt.charCode == 63275) { //63275: 'KEY_END', 35
                scanCode = 35;
            }
            else if (evt.charCode == 63277) { //63277: 'KEY_PAGE_DOWN', 34
                scanCode = 34;
            }
            else if (evt.charCode == 63276) { //63276: 'KEY_PAGE_UP', 33
                scanCode = 33;
            }
            else if (evt.charCode == 3) { //3: 'KEY_ENTER', 13
                scanCode = 13;
            }
        }    
        if (scanCode == 0) {
            if (evt.charCode) {
                scanCode = evt.charCode;
            }
        }
        if (scanCode == 0) {
            scanCode = evt.keyCode;
        }
        return scanCode;
    }
    //
    // Init value startup
    //
    , _InitValue : function(value,loadFirst)
    {
        this._LogicSymbol = "";
        var e = this.get_element();
        var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(e);
        wrapper.set_Value(this._EmptyMask);
        if (value == this._EmptyMask || value == "")
        {
            this.loadValue("",this._LogicFirstPos);
        }
        else if (this._MaskType == AjaxControlToolkit.MaskedEditType.Date && value != "")
        {
            value = this.ConvFmtDate(value,loadFirst);
        }
        else if (this._MaskType == AjaxControlToolkit.MaskedEditType.Time && value != "")
        {
            value = this.ConvFmtTime(value,loadFirst);
        }
        else if (this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime && value != "")
        {
            value = this.ConvFmtDateTime(value,loadFirst);
        }
        else if (this._MaskType == AjaxControlToolkit.MaskedEditType.Number && value != "")
        {
            value = this.ConvFmtNumber(value,loadFirst);
        }
        if (this._InputDirection == AjaxControlToolkit.MaskedEditInputDirections.LeftToRight && value != "")
        {
            if (this._MaskType == AjaxControlToolkit.MaskedEditType.Number)
            {
                this._InputDirection = AjaxControlToolkit.MaskedEditInputDirections.RightToLeft;
                this.loadValue(value,this._LogicLastPos);
                this._InputDirection = AjaxControlToolkit.MaskedEditInputDirections.LeftToRight;
            }
            else
            {
                this.loadValue(value,this._LogicFirstPos);
            }
        } 
        else if (this._InputDirection == AjaxControlToolkit.MaskedEditInputDirections.RightToLeft && value != "")
        {
            this.loadValue(value,this._LogicLastPos);
        }
        if (this._MaskType == AjaxControlToolkit.MaskedEditType.Number)
        {
            if (this._InLostfocus && this._LogicSymbol == "-" && this._OnBlurCssNegative != "")
            {
                this.AddCssClassMaskedEdit(this._OnBlurCssNegative);
            }
        }
    }
    //
    // Load initial value with mask
    //
    , loadMaskValue : function(value,logicPosition, Symb)
    {
        this._createMask();
        var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element());
        wrapper.set_Value(this._EmptyMask);
        if ( (this._MaskType == AjaxControlToolkit.MaskedEditType.Time || this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime) && this.get_CultureFirstLettersAMPM().toUpperCase().indexOf(Symb.toUpperCase().substring(0,1)) != -1)
        {
            if (this._AcceptAmPm)
            {
                this.InsertAMPM(Symb.toUpperCase().substring(0,1));
            }
        }
        else if (this._MaskType == AjaxControlToolkit.MaskedEditType.Number && this._AcceptNegative != AjaxControlToolkit.MaskedEditShowSymbol.None && "+-".indexOf(Symb) != -1)
        {
            this.InsertSignal(Symb);
        }
        var i = 0;
        for (i = 0 ; i < parseInt(value.length,10) ; i++) 
        {
            var c = value.substring(i+logicPosition,i+logicPosition+1);     
            if (this._processKey(logicPosition+i,c)) 
            {
                this._insertContent(c,logicPosition+i);
            }
        }
    }
    //
    // Load initial value in mask
    //
    , loadValue : function(value,logicPosition)
    {
        this._createMask();
        var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element());
        wrapper.set_Value(this._EmptyMask);
        if (this._InputDirection == AjaxControlToolkit.MaskedEditInputDirections.LeftToRight)
        {
            var i = 0;
            for (i = 0 ; i < parseInt(value.length,10) ; i++) 
            {
                var c = value.substring(i,i+1);     
                if ( (this._MaskType == AjaxControlToolkit.MaskedEditType.Time || this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime) && this.get_CultureFirstLettersAMPM().toUpperCase().indexOf(c.toUpperCase()) != -1)
                {
                    if (this._AcceptAmPm)
                    {
                        this.InsertAMPM(c);
                    }
                }
                else if (this._MaskType == AjaxControlToolkit.MaskedEditType.Number && this._AcceptNegative != AjaxControlToolkit.MaskedEditShowSymbol.None && "+-".indexOf(c) != -1)
                {
                    this.InsertSignal(c);
                }
                if (this._processKey(logicPosition,c)) 
                {
                    this._insertContent(c,logicPosition);
                    logicPosition  = this._getNextPosition(logicPosition+1);
                }
            }
        }
        else if (this._InputDirection == AjaxControlToolkit.MaskedEditInputDirections.RightToLeft)
        {
            if (logicPosition == this._LogicLastInt)
            {
                logicPosition = this._getPreviousPosition(logicPosition);
                var arr_num = value.split(this.get_CultureDecimalPlaceholder())
                // int element
                for (i = parseInt(arr_num[0].length,10) ; i > 0  ; i--) 
                {
                    var c = arr_num[0].substring(i-1,i);  
                    if (this._MaskType == AjaxControlToolkit.MaskedEditType.Number && this._AcceptNegative != AjaxControlToolkit.MaskedEditShowSymbol.None && "+-".indexOf(c) != -1)
                    {
                        this.InsertSignal(c);
                    }
                    if (this._processKey(logicPosition,c)) 
                    {
                        this._insertContent(c,logicPosition);
                        logicPosition  = this._getPreviousPosition(logicPosition-1);
                    }
                } 
                // decimal element
                if (arr_num.length > 1)
                {
                    logicPosition  = this._getNextPosition(this._LogicLastInt);
                    for (i = 0 ; i < parseInt(arr_num[1].length,10) ; i++) 
                    {
                        var c = arr_num[1].substring(i,i+1);     
                        if (this._MaskType == AjaxControlToolkit.MaskedEditType.Number && this._AcceptNegative != AjaxControlToolkit.MaskedEditShowSymbol.None && "+-".indexOf(c) != -1)
                        {
                            this.InsertSignal(c);
                        }
                        if (this._processKey(logicPosition,c)) 
                        {
                            this._insertContent(c,logicPosition);
                            logicPosition  = this._getNextPosition(logicPosition+1);
                        }
                    }
                }
            }
            else
            {
                for (i = parseInt(value.length,10) ; i > 0  ; i--) 
                {
                    var c = value.substring(i-1,i);  
                    if (this._MaskType == AjaxControlToolkit.MaskedEditType.Number && this._AcceptNegative != AjaxControlToolkit.MaskedEditShowSymbol.None && "+-".indexOf(c) != -1)
                    {
                        this.InsertSignal(c);
                    }
                    if (this._processKey(logicPosition,c)) 
                    {
                        this._insertContent(c,logicPosition);
                        logicPosition  = this._getPreviousPosition(logicPosition-1);
                    }
                }   
            }
        }
    }
    //
    // AutoFormat (date and Time and number)
    //
    , AutoFormatNumber : function()
    {
        var i;
        var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element());
        ValueText = wrapper.get_Value();
        var AutoComp = this._AutoCompleteValue;
        var okdgt = false;
        for (i = this._LogicFirstPos ; i <= this._LogicLastPos ; i++) 
        {
            if (this._LogicTextMask.substring(i,i+1) == this._LogicPrompt)
            {
                var CharComp = "0";
                if (AutoComp != "")
                {
                    CharComp = AutoComp.substring(i-this._LogicFirstPos,i+1-this._LogicFirstPos);
                }
                if (okdgt)
                {
                    this._LogicTextMask = this._LogicTextMask.substring(0,i) + CharComp + this._LogicTextMask.substring(i+1);
                    ValueText = ValueText.substring(0,i) + CharComp + ValueText.substring(i+1);
                }
            }
            else if (this._LogicMask.substring(i,i+1) == this._LogicPrompt && "123456789".indexOf(this._LogicTextMask.substring(i,i+1)) != -1)
            {
                okdgt = true;
            }
        }
        wrapper.set_Value(ValueText);
        return ValueText;
    }
    , AutoFormatTime : function()
    {
        var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element());   
        ValueText = wrapper.get_Value();
        var autocomp = this._AutoCompleteValue;
        if (autocomp.indexOf(this.get_CultureTimePlaceholder()) == -1)
        {
            autocomp = "";
        }
        if (this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime)
        {
            if (ValueText.split(" ").length == 3)
            {
                ValueText = ValueText.split(" ")[1] + " " + ValueText.split(" ")[2]; 
            }
            else
            {
                ValueText = ValueText.split(" ")[1]; 
            }
            if (autocomp != "")
            {
                // if not have date...
                if (autocomp.indexOf(this.get_CultureDatePlaceholder()) == -1)
                {
                    autocomp = " " + autocomp;
                }
                if (autocomp.split(" ").length == 3)
                {
                    autocomp = autocomp.split(" ")[1] + " " + autocomp.split(" ")[2];
                }
                else
                {
                    autocomp = autocomp.split(" ")[1];
                }
            }
        }
        var CurDate = new Date();
        var Hcur = CurDate.getHours().toString();
        if (Hcur.length < 2)
        {
            Hcur = "0" + Hcur;
        }
        if (autocomp != "")
        {
            Hcur = autocomp.substring(0,2);
        }
        var SetAM = false;
        var SetPM = false;
        var LcAM = "";
        var LcPM = "";
        var Symb = "";
        if (this.get_CultureAMPMPlaceholder() != "")
        {
            var m_arrtm = this.get_CultureAMPMPlaceholder().split(this._AMPMPlaceholderSeparator);
            LcAM = m_arrtm[0];
            LcPM = m_arrtm[1];
            if (autocomp == "")
            {
                var Symb = LcAM;
                if (Hcur > 12)
                {
                    Hcur = (parseInt(Hcur,10) - 12).toString();
                    if (Hcur.length < 2)
                    {
                        Hcur = "0" + Hcur;
                    }
                    Symb = LcPM;
                }
            }
            else
            {
                Symb = LcAM; // default
                if (autocomp.indexOf(LcPM) != -1)
                {
                    // set by autocomplete
                    Symb = LcPM;
                }
            }
            // set by input
            SetAM = true; // default
            if (ValueText.indexOf(LcPM) != -1 && LcPM != "")
            {
                // set by input
                SetPM = true;
            }
            if (!this._AcceptAmPm)
            {
                Symb = "";
                SetPM = false;
                SetAM = false;
            }
            else
            {
                //check empty hour to validate AM/PM
                var emp = true;
                if (ValueText.substring(0,1) != this._PromptChar || ValueText.substring(1,2) != this._PromptChar)
                {
                    emp = false;
                }
                if (emp && Symb != "") 
                {
                    SetAM = true; // default;
                    SetPM = false;
                    if (LcPM == Symb)
                    {
                        // set by current time
                        SetPM = true;
                    }
                }
            }
        }
        var Mcur = CurDate.getMinutes().toString();
        if (Mcur.length < 2)
        {
            Mcur = "0" + Mcur;
        }
        if (autocomp != "" )
        {
            Mcur = autocomp.substring(3,5);
        }
        var Scur = "00";
        var PH,PM;
        if (this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime)
        {
            PH = ValueText.substring(0,2);
            PH = this._AdjustTime(PH,Hcur);
            PM = ValueText.substring(3,5);
            PM = this._AdjustTime(PM,Mcur);
        }
        else
        {
            PH = ValueText.substring(this._LogicFirstPos,this._LogicFirstPos+2);
            PH = this._AdjustTime(PH,Hcur);
            PM = ValueText.substring(this._LogicFirstPos+3,this._LogicFirstPos+5);
            PM = this._AdjustTime(PM,Mcur);
        }
        var maskvld = this._maskvalid;
        if (this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime)
        {
            maskvld = maskvld.split(" ")[1];
        }
        if (maskvld == "99:99:99")
        {
            if (autocomp != "" )
            {
                Scur = autocomp.substring(6);
            }
            var PS;
            if (this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime)
            {
                PS = ValueText.substring(6,8);
                PS = this._AdjustTime(PS,Scur);
            }
            else
            {
                PS = ValueText.substring(this._LogicFirstPos+6,this._LogicFirstPos+8);
                PS = this._AdjustTime(PS,Scur);
            }
            ValueText = PH + this.get_CultureTimePlaceholder() + PM + this.get_CultureTimePlaceholder() + PS;
        }
        else
        {
            ValueText = PH + this.get_CultureTimePlaceholder() + PM;
        }
        if (SetPM)
        {
            ValueText += " " + LcPM;
        }
        else if (SetAM)
        {
            ValueText += " " + LcAM;
        }
        if (this._MaskType != AjaxControlToolkit.MaskedEditType.DateTime)
        {
            this.loadValue(ValueText,this._LogicFirstPos);
        }
        return ValueText;
    }
    , AutoFormatDateTime : function()
    {
        var PartDt = this.AutoFormatDate();            
        var PartTm = this.AutoFormatTime();            
        this.loadValue(PartDt + " " + PartTm,this._LogicFirstPos);
        return PartDt + " " + PartTm;
    }
    , AutoFormatDate : function()
    {
        var D = this._GetDateElementText("D").replace(new RegExp("(\\" + this._PromptChar + ")", "g"), "") + '';
        var M = this._GetDateElementText("M").replace(new RegExp("(\\" + this._PromptChar + ")", "g"), "") + '';
        var Y = this._GetDateElementText("Y").replace(new RegExp("(\\" + this._PromptChar + ")", "g"), "") + '';
        var Y4 = (this._maskvalid.indexOf("9999") != -1)?true:false;
        var autocomp = this._AutoCompleteValue;
        if (autocomp.indexOf(this.get_CultureDatePlaceholder()) == -1)
        {
            autocomp = "";
        }
        var Dcur,Mcur,Ycur;
        if (autocomp == "")
        {
            var CurDate = new Date();
            Dcur = (CurDate.getUTCDate()).toString();
            if (Dcur.length < 2)
            {
                Dcur = "0" + Dcur;
            }
            Mcur = (CurDate.getUTCMonth()+1).toString();
            if (Mcur.length < 2)
            {
                Mcur = "0" + Mcur;
            }
            if (Y4)
            {
                Ycur = CurDate.getUTCFullYear().toString();
            }
            else
            {
                Ycur = Ycur.substring(2);
            }
        }
        else
        {
            var m_arrDate;
            if (this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime)
            {
                // if not have time...
                if (autocomp.indexOf(this.get_CultureTimePlaceholder()) == -1)
                {
                    autocomp = autocomp + " ";
                }
                var partdt = autocomp.split(" ")[0]; 
                m_arrDate = partdt.split(this.get_CultureDatePlaceholder());
            }
            else
            {
                m_arrDate = autocomp.split(this.get_CultureDatePlaceholder());
            }
            if (this.get_CultureDateFormat() == "DMY")
            {
                Dcur = m_arrDate[0];
                Mcur = m_arrDate[1];
                Ycur = m_arrDate[2];
            }
            else if (this.get_CultureDateFormat() == "MDY")
            {
                Dcur = m_arrDate[1];
                Mcur = m_arrDate[0];
                Ycur = m_arrDate[2];
            }
            else if (this.get_CultureDateFormat() == "DYM")
            {
                Dcur = m_arrDate[0];
                Mcur = m_arrDate[2];
                Ycur = m_arrDate[1];
            }
            else if (this.get_CultureDateFormat() == "MYD")
            {
                Dcur = m_arrDate[2];
                Mcur = m_arrDate[0];
                Ycur = m_arrDate[1];
            }
            else if (this.get_CultureDateFormat() == "YMD")
            {
                Dcur = m_arrDate[2];
                Mcur = m_arrDate[1];
                Ycur = m_arrDate[0];
            }
            else if (this.get_CultureDateFormat() == "YDM")
            {
                Dcur = m_arrDate[1];
                Mcur = m_arrDate[2];
                Ycur = m_arrDate[0];
            }            
            if (Dcur.length < 2)
            {
                Dcur = "0" + Dcur;
            }
            if (Mcur.length < 2)
            {
                Mcur = "0" + Mcur;
            }
            if (Y4)
            {
                while (Ycur.length < 4)
                {
                    Ycur = "0" + Ycur;
                }
            }
            else
            {
                while (Ycur.length < 2)
                {
                    Ycur = "0" + Ycur;
                }
            }
        }
        if (D == "")
        {
            D = Dcur;
        }
        if (M== "")
        {
            M = Mcur;
        }
        if (Y == "")
        {
            Y = Ycur;
        }
        var value;
        if (this.get_CultureDateFormat() == "DMY")
        {
          value = D + this.get_CultureDatePlaceholder() + M + this._CultureDatePlaceholder + Y;
        }
        else if (this.get_CultureDateFormat() == "MDY")
        {
          value = M + this.get_CultureDatePlaceholder() + D + this._CultureDatePlaceholder + Y;
        }
        else if (this.get_CultureDateFormat() == "DYM")
        {
          value = D + this.get_CultureDatePlaceholder() + Y + this._CultureDatePlaceholder + M;
        }
        else if (this.get_CultureDateFormat() == "MYD")
        {
          value = M + this.get_CultureDatePlaceholder() + Y + this._CultureDatePlaceholder + D;
        }
        else if (this.get_CultureDateFormat() == "YMD")
        {
          value = Y + this.get_CultureDatePlaceholder() + M + this._CultureDatePlaceholder + D;
        }
        else if (this.get_CultureDateFormat() == "YDM")
        {
          value = Y + this.get_CultureDatePlaceholder() + D + this._CultureDatePlaceholder + M;
        }
        if (this._MaskType != AjaxControlToolkit.MaskedEditType.DateTime)
        {
            this.loadValue(value,this._LogicFirstPos);
        }
        return value;
    }
    //
    // normalize initial value (number)
    //
    , ConvFmtNumber : function(input,loadFirst)
    {
        if (this._maskvalid.split(this.get_CultureDecimalPlaceholder()).length == 2)
        {
            if (input.substring(input.length-1,input.length) == this.get_CultureDecimalPlaceholder())
            {
                input = input.substring(0,input.length-1);
            }
            if (input.indexOf(this.get_CultureDecimalPlaceholder()) == -1)
            {
                input += this.get_CultureDecimalPlaceholder();
                var i;
                var m_mask = this._maskvalid;
                for (i = 0;i < m_mask.length;i++)
                {
                    input += "0";
                }
                return input;
            }
        }
        return input;
    }
    //
    // normalize initial value (Time)
    //
    , ConvFmtTime : function(input,loadFirst)
    {
        var AddH = 0;
        var SetAM = false;
        var SetPM = false;
        var LcAM = "";
        var LcPM = "";
        if (this.get_CultureAMPMPlaceholder() != "")
        {
            LcAM = this.get_CultureAMPMPlaceholder().split(this._AMPMPlaceholderSeparator)[0];
            LcPM = this.get_CultureAMPMPlaceholder().split(this._AMPMPlaceholderSeparator)[1];
        }
        //perform convert for loading of a page 
        if (loadFirst)
        {
            var LDLcAM = "";
            var LDLcPM = "";
            if (this._CultureAMPMPlaceholder != "")
            {
                LDLcAM = this._CultureAMPMPlaceholder.split(this._AMPMPlaceholderSeparator)[0];
                LDLcPM = this._CultureAMPMPlaceholder.split(this._AMPMPlaceholderSeparator)[1];
            }
            // convert current Culture to user culture format (24H)
            if (this.get_UserTimeFormat() == AjaxControlToolkit.MaskedEditUserTimeFormat.TwentyFourHour)
            {
                input = input.replace(new RegExp("(\\" + LDLcAM + ")", "g"),"");
                if (input.indexOf(LDLcPM) != -1)
                {
                    AddH = 12;
                }
                input = input.replace(new RegExp("(\\" + LDLcPM + ")", "g"),"");
            }
        }    
        if (input.indexOf(LcAM) != -1 && LcAM != "")
        {
            SetAM = true;
        }
        else if (input.indexOf(LcPM) != -1 && LcPM != "")
        {
            SetPM = true;
        }
        if (LcAM != "")
        {
            input = input.replace(new RegExp("(\\" + LcAM + ")", "g"), "");
        }
        if (LcPM != "")
        {
            input = input.replace(new RegExp("(\\" + LcPM + ")", "g"), "");
        }
        input = input.replace(new RegExp("(\\" + " " + ")", "g"), "");
        var m_arrTime = input.split(this.get_CultureTimePlaceholder());
        var m_mask = this._maskvalid;
        if (this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime)
        {
            m_mask = m_mask.split(" ")[1];
        }
        m_mask = m_mask.split(":");
        if (parseInt(m_arrTime.length,10) < 2 || parseInt(m_arrTime.length,10) > 3)
        {
            return "";
        }
        var H = parseInt(m_arrTime[0],10) + AddH;
        H = H.toString();
        if (H.length < m_mask[0].length)
        {
            while (H.length < m_mask[0].length)
            {
                H = "0" + H;
            }
        }
        m_arrTime[0] = H;
        var M = parseInt(m_arrTime[1],10) + '';
        if (M.length < m_mask[1].length)
        {
            while (M.length < m_mask[1].length)
            {
                M = "0" + M;
            }
        }
        m_arrTime[1] = M;
        var value = "";
        if (parseInt(m_arrTime.length,10) == 3)
        {
            var S = parseInt(m_arrTime[2],10) + '';
            if (S.length < m_mask[2].length)
            {
                while (S.length < m_mask[2].length)
                {
                    S = "0" + S;
                }
            }
            m_arrTime[2] = S;
            value = m_arrTime[0] + this.get_CultureTimePlaceholder() + m_arrTime[1] + this.get_CultureTimePlaceholder() + m_arrTime[2];
        }
        else
        {
            value = m_arrTime[0] + this.get_CultureTimePlaceholder() + m_arrTime[1]; 
        }
        if (SetAM)
        {
            value += " " + LcAM;
        }
        else if (SetPM)
        {
            value += " " + LcPM;
        }
        return value;
    }
    //
    // normalize initial value (Date)
    //
    , ConvFmtDateTime : function(input,loadFirst)
    {
        var partdt = input.split(" ")[0];
        var parttm = input.split(" ")[1];
        if (input.split(" ").length == 3)
        {
            parttm += " " + input.split(" ")[2];
        }
        partdt = this.ConvFmtDate(partdt,loadFirst);
        parttm = this.ConvFmtTime(parttm,loadFirst);
        return  partdt + " " + parttm;
    }
    , ConvFmtDate : function(input,loadFirst)
    {
        var m_arrDateLD; 
        var m_arrDate;
        //perform convert for loading of a page 
        if (loadFirst)
        {
            //split values for perform convert load 
            m_arrDateLD = input.split(this.get_CultureDatePlaceholder());
            //split destination value
            m_arrDate = input.split(this.get_CultureDatePlaceholder());
            // convert current Culture to user culture format
            if (this.get_UserDateFormat() != AjaxControlToolkit.MaskedEditUserDateFormat.None)
            {
                  m_arrDate[this.get_CultureDateFormat().indexOf("D")] = m_arrDateLD[this._CultureDateFormat.indexOf("D")];   
                  m_arrDate[this.get_CultureDateFormat().indexOf("M")] = m_arrDateLD[this._CultureDateFormat.indexOf("M")];   
                  m_arrDate[this.get_CultureDateFormat().indexOf("Y")] = m_arrDateLD[this._CultureDateFormat.indexOf("Y")];   
            }
        }
        else
        {
            // split value (not load) 
            m_arrDate = input.split(this.get_CultureDatePlaceholder());
        }
        var m_mask = this._maskvalid;
        if (this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime)
        {
            m_mask = m_mask.split(" ")[0];
        }
        m_mask = m_mask.split("/");
        if (parseInt(m_arrDate.length,10) != 3)
        {
            return "";
        }
        var D = parseInt(m_arrDate[this.get_CultureDateFormat().indexOf("D")],10) + '';
        if (D.length < m_mask[this.get_CultureDateFormat().indexOf("D")].length)
        {
            while (D.length < m_mask[this.get_CultureDateFormat().indexOf("D")].length)
            {
                D = "0" + D;
            }
        }
        m_arrDate[this.get_CultureDateFormat().indexOf("D")] = D;
        var M = parseInt(m_arrDate[this.get_CultureDateFormat().indexOf("M")],10) + '' ;
        if (M.length < m_mask[this.get_CultureDateFormat().indexOf("M")].length)
        {
            while (M.length < m_mask[this.get_CultureDateFormat().indexOf("M")].length)
            {
                M = "0" + M;
            }
        }
        m_arrDate[this.get_CultureDateFormat().indexOf("M")] = M;
        var Y = parseInt(m_arrDate[this.get_CultureDateFormat().indexOf("Y")],10) + '';
        while (Y.length < m_mask[this.get_CultureDateFormat().indexOf("Y")].length)
        {
            Y = "0" + Y;
        }
        m_arrDate[this.get_CultureDateFormat().indexOf("Y")] = Y;
        return m_arrDate[0] + this.get_CultureDatePlaceholder() + m_arrDate[1] + this._CultureDatePlaceholder + m_arrDate[2];
    }
    //
    // Set/Remove CssClass
    //
    , AddCssClassMaskedEdit : function(CssClass)
    {
        var e = this.get_element();
        Sys.UI.DomElement.removeCssClass(e,this._OnBlurCssNegative);
        Sys.UI.DomElement.removeCssClass(e,this._OnFocusCssClass);
        Sys.UI.DomElement.removeCssClass(e,this._OnFocusCssNegative);
        Sys.UI.DomElement.removeCssClass(e,this._OnInvalidCssClass);
        if (CssClass != "")
        {
            Sys.UI.DomElement.addCssClass(e,CssClass);
        }
    }
    //
    // Set Cancel Event for cross browser
    //
    , _SetCancelEvent : function(evt) {
        /// <summary>
        /// Cancel Event for any browser
        /// </summary>
        /// <param name="evt" type="Sys.UI.DomEvent">
        /// Event info
        /// </param>
        if (typeof(evt.returnValue) !== "undefined") {
            evt.returnValue = false;
        }
        if (typeof(evt.cancelBubble) !== "undefined") {
            evt.cancelBubble = true;
        }
        if (typeof(evt.preventDefault) !== "undefined") {
            evt.preventDefault();
        }
        if (typeof(evt.stopPropagation) !== "undefined") {
            evt.stopPropagation();
        }
    }
    //
    // Capture result validator after Postback
    //
    ,_CaptureServerValidators : function()
    {
        var ret = true;
        var msg = this._ExternalMessageError;
        if  (typeof(Page_Validators) != "undefined")
        {
            var ctrval = null;
            var first = true;
            for (i = 0; i < Page_Validators.length; i++) 
            {
                ctrval = Page_Validators[i];
                if (typeof(ctrval.enabled) == "undefined" || ctrval.enabled != false) 
                {
                    if (ctrval.TargetValidator == this.get_element().id)
                    {
                        if (!ctrval.isvalid)
                        {
                            if (first)
                            {
                                first = false;
                                msg = "";
                            }
                            if (typeof(ctrval.errormessage) == "string")
                            {
                                if (msg != "")
                                {
                                    msg += ", ";
                                }
                                msg += ctrval.errormessage;
                            }
                            ret = false;
                        }
                    }
                }
            }
        }
        this._ExternalMessageError = msg;
        return ret;
    }
    //
    // Capture and execute client validator to control
    //
    ,_CaptureClientsValidators : function()
    {
        var ret = true;
        // clear local save External Message Error
        var msg = "";
        this._ExternalMessageError = msg;
        // Page_Validators is a Array of script asp.net
        if  (typeof(Page_Validators) != "undefined")
        {
            var ctrval = null;
            for (i = 0; i < Page_Validators.length; i++) 
            {
                ctrval = Page_Validators[i];
                if (typeof(ctrval.enabled) == "undefined" || ctrval.enabled != false) 
                {
                    if (ctrval.TargetValidator == this.get_element().id)
                    {
                        if (typeof(ctrval.evaluationfunction) == "function") 
                        {
                            var crtret = ctrval.evaluationfunction(ctrval); 
                            if (!crtret)
                            {
                                ret = false;
                                if (typeof(ctrval.errormessage) == "string")
                                {
                                    if (msg != "")
                                    {
                                        msg += ", ";
                                    }
                                    msg += ctrval.errormessage;
                                }
                            }
                        }
                        else if(typeof(ctrval.evaluationfunction) == "string") 
                        {
                            var crtret; 
                            eval("crtret = " + ctrval.evaluationfunction + "(" + ctrval.id + ")"); 
                            if (!crtret)
                            {
                                ret = false;
                                if (typeof(ctrval.errormessage) == "string")
                                {
                                    if (msg != "")
                                    {
                                        msg += ", ";
                                    }
                                    msg += ctrval.errormessage;
                                }
                            }
                        }
                    }
                }
            }
        }
        this._ExternalMessageError = msg;
        return ret;
    }
    //
    // Show/hide Message Tip
    //
    ,ShowTooltipMessage : function(Visible)
    {
        if  (typeof(Page_Validators) == "undefined")
        {
            return;
        }
        var msg = "";
        if (!Visible)
        {
            msg = this._CurrentMessageError;
            this._CurrentMessageError = "";
        }
        var i = 0
        var ctrval = null;
        for (i = 0; i < Page_Validators.length; i++) 
        {
            ctrval = Page_Validators[i];
            if (ctrval.TargetValidator == this.get_element().id && ctrval.IsMaskedEdit == "true")
            {
                if (!Visible)
                {
                    ctrval.innerHTML = msg;
                    if (typeof(ctrval.display) == "string") 
                    {    
                        if (ctrval.display == "None") {
                            return;
                        }
                        if (ctrval.display == "Dynamic") {
                            ctrval.style.display = ctrval.isvalid ? "none" : "inline";
                            return;
                        }
                    }
                    return;
                }
                this._CurrentMessageError = ctrval.innerHTML;
                ctrval.innerHTML = ctrval.TooltipMessage;
                if (typeof(ctrval.display) == "string") 
                {    
                    if (ctrval.display == "None") {
                        return;
                    }
                    if (ctrval.display == "Dynamic") {
                        ctrval.style.display = "inline";
                        return;
                    }
                }
                ctrval.style.visibility = "visible";
                return;
            }
        }    
    }
    //
    // Insert Content at position in curpos
    //
    , _insertContent : function(value,curpos) 
    {
        var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element());
        var masktext = wrapper.get_Value();
        masktext = masktext.substring(0,curpos) + value + masktext.substring(curpos+1);
        this._LogicTextMask = this._LogicTextMask.substring(0,curpos) + value + this._LogicTextMask.substring(curpos+1);
        wrapper.set_Value(masktext);
    }    
    //
    // Insert Content at last right position 
    //
    , _insertContentRight : function(value) 
    {
        var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element());
        var masktext = wrapper.get_Value();
        curpos = this._getLastEmptyPosition();
        if (curpos < 0)
        {
            return;
        }
        var resttext = masktext.substring(curpos+1);
        var restlogi = this._LogicTextMask.substring(curpos+1);
        masktext = masktext.substring(0,curpos) + this._PromptChar;
        this._LogicTextMask = this._LogicTextMask.substring(0,curpos) + this._LogicPrompt;
        // clear rest of mask
        if (this._LogicLastInt != -1 && this._InputDirection == AjaxControlToolkit.MaskedEditInputDirections.RightToLeft)
        {
            var arr_num = resttext.split(this.get_CultureDecimalPlaceholder());
            var arr_log = restlogi.split(this.get_CultureDecimalPlaceholder());
            for (i = 0 ; i < parseInt(arr_num[0].length,10) ; i++) 
            {
                if (this._isValidMaskedEditPosition(curpos+1+i))
                {
                    masktext += this._PromptChar;
                    this._LogicTextMask += this._LogicPrompt;
                }
                else
                {
                    masktext += arr_num[0].substring(i,i+1);
                    this._LogicTextMask += arr_log[0].substring(i,i+1);
                }
            }
            if (arr_num.length = 2) 
            {
                masktext += this.get_CultureDecimalPlaceholder() + arr_num[1];
                this._LogicTextMask += this.get_CultureDecimalPlaceholder() + arr_log[1];
            }
            // insert only valid text
            posaux = this._getNextPosition(curpos);
            for (i = 0 ; i < parseInt(arr_num[0].length,10); i++) 
            {
                if (this._isValidMaskedEditPosition(curpos+1+i) && arr_log[0].substring(i,i+1) != this._LogicPrompt)
                {
                    masktext = masktext.substring(0,posaux) + arr_num[0].substring(i,i+1) + masktext.substring(posaux+1);
                    this._LogicTextMask = this._LogicTextMask.substring(0,posaux) + arr_log[0].substring(i,i+1) + this._LogicTextMask.substring(posaux+1);
                    posaux = this._getNextPosition(posaux+1);
                }
            }
        }
        else
        {
            for (i = 0 ; i < parseInt(resttext.length,10) ; i++) 
            {
                if (this._isValidMaskedEditPosition(curpos+1+i))
                {
                    masktext += this._PromptChar;
                    this._LogicTextMask += this._LogicPrompt;
                }
                else
                {
                    masktext += resttext.substring(i,i+1);
                    this._LogicTextMask += restlogi.substring(i,i+1);
                }
            }
            // insert only valid text
            posaux = this._getNextPosition(curpos);
            for (i = 0 ; i < parseInt(resttext.length,10); i++) 
            {
                if (this._isValidMaskedEditPosition(curpos+1+i) && restlogi.substring(i,i+1) != this._LogicPrompt)
                {
                    masktext = masktext.substring(0,posaux) + resttext.substring(i,i+1) + masktext.substring(posaux+1);
                    this._LogicTextMask = this._LogicTextMask.substring(0,posaux) + restlogi.substring(i,i+1) + this._LogicTextMask.substring(posaux+1);
                    posaux = this._getNextPosition(posaux+1);
                }
            }            
        }
        // insert value
        var dif = 0;
        if (this._LogicLastInt != -1 && this._InputDirection == AjaxControlToolkit.MaskedEditInputDirections.RightToLeft)
        {
            dif = this._LogicLastPos - this._LogicLastInt+1;
        }
        masktext = masktext.substring(0,this._LogicLastPos-dif) + value + masktext.substring(this._LogicLastPos-dif+1);
        this._LogicTextMask = this._LogicTextMask.substring(0,this._LogicLastPos-dif) + value + this._LogicTextMask.substring(this._LogicLastPos-dif+1);
        wrapper.set_Value(masktext);
    }    
    //
    // Insert Symbol AM/PM
    //
    , InsertAMPM : function(value)
    {
        var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element());
        var masktext = wrapper.get_Value();
        var ASymMask = this.get_CultureAMPMPlaceholder().split(this._AMPMPlaceholderSeparator);
        var symb =  "";
        if (ASymMask.length == 2)
        {
            if (value.toUpperCase() == this.get_CultureFirstLetterAM().toUpperCase())
            {
              symb = ASymMask[0];
            }
            else if (value.toUpperCase() == this.get_CultureFirstLetterPM().toUpperCase())
            {
              symb = ASymMask[1];
            }
            this._LogicSymbol = symb;
        }
        masktext = masktext.substring(0,this._LogicLastPos+2) + symb + masktext.substring(this._LogicLastPos+2+symb.length);
        wrapper.set_Value(masktext);
    }
    //
    // Insert Symbol Negative
    //
    , InsertSignal : function(value)
    {
        var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element());
        var masktext = wrapper.get_Value();
        if (value == "-" && this._LogicSymbol == "-")
        {
            value = "+";
        }
        if (value == "+")
        {
            value = " ";
            this._LogicSymbol = "";
            if (!this._InLostfocus && this._OnFocusCssClass != "")
            {
                this.AddCssClassMaskedEdit(this._OnFocusCssClass);
            }
            else if (!this._InLostfocus)
            {
                this.AddCssClassMaskedEdit("");
            }
        }
        else
        {
            this._LogicSymbol = "-";
            if (!this._InLostfocus && this._OnFocusCssNegative != "")
            {
                this.AddCssClassMaskedEdit(this._OnFocusCssNegative);
            }
        }
        if (this._AcceptNegative == AjaxControlToolkit.MaskedEditShowSymbol.Left)
        {
          masktext = masktext.substring(0,this._LogicFirstPos-1) + value + masktext.substring(this._LogicFirstPos);
        }
        else if (this._AcceptNegative == AjaxControlToolkit.MaskedEditShowSymbol.Right)
        {
          masktext = masktext.substring(0,this._LogicLastPos+1) + value + masktext.substring(this._LogicLastPos+2);
        }
        wrapper.set_Value(masktext);
    }
    //
    // Set Cursor at position in TextBox
    //
    , setSelectionRange : function(selectionStart, selectionEnd) 
    {
      input = this.get_element();
      if (input.setSelectionRange) 
      {
        input.setSelectionRange(selectionStart, selectionEnd);
      }
      else if (input.createTextRange) 
      {
        var range = input.createTextRange();
        range.collapse(true);
        range.moveEnd('character', selectionEnd);
        range.moveStart('character', selectionStart);
        range.select();
      }
    }
    //
    // get last position empty in text 
    //
    , _getLastEmptyPosition : function()
    {
        var pos = this._LogicLastPos;
        if (this._InputDirection == AjaxControlToolkit.MaskedEditInputDirections.RightToLeft && this._LogicLastInt != -1)
        {
            var curpos = this._getCurrentPosition();
            if (curpos <= this._LogicLastInt)
            {
                pos = this._LogicLastInt;
            }
        }
        while (pos >= 0 && this._LogicTextMask.substring(pos, pos+1) != this._LogicPrompt)
        {
            pos--;
        }
        return pos;
    }
    //
    // position is valid edit ?
    //
    , _isValidMaskedEditPosition : function(pos) 
    {
        return (this._LogicMask.substring(pos,pos+1) == this._LogicPrompt);
    }
    //
    // Next valid Position
    //
    , _getNextPosition : function(pos)
    {
        while (!this._isValidMaskedEditPosition(pos) && pos < this._LogicLastPos+1)
        {
            pos++;
        }
        if (pos > this._LogicLastPos+1)
        {
            pos = this._LogicLastPos+1;
        }
        return pos;
    }
    //
    // Previous valid Position
    //
    , _getPreviousPosition : function(pos)
    {
        while (!this._isValidMaskedEditPosition(pos) && pos > this._LogicFirstPos)
        {
            pos--;
        }
        if (pos < this._LogicFirstPos)
        {
            pos = this._LogicFirstPos;
        }
        return pos;
    }
    //
    // Current Position
    //
    , _getCurrentPosition : function()
    {
        begin = 0;
        input = this.get_element();
        if (input.setSelectionRange) 
        {
            begin = parseInt(input.selectionStart,10);
        }
        else if (document.selection) 
        {
            sel = document.selection.createRange();
            if (sel.text != "")
            {
                var aux = ""
                if (this._DirectSelText == "R")
                {
                    aux = sel.text + String.fromCharCode(3);
                }
                else if (this._DirectSelText == "L")
                {
                    aux = String.fromCharCode(3) + sel.text ;
                }
                sel.text = aux;
                this._DirectSelText == "";
            }
            else
            {
                sel.text = String.fromCharCode(3);
                this._DirectSelText == "";
            }
            var dummy = input.createTextRange();
            dummy.findText(String.fromCharCode(3));
            dummy.select();
            var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(input);
            begin = wrapper.get_Value().indexOf(String.fromCharCode(3));
            document.selection.clear();
        }
        if (begin > this._LogicLastPos+1)
        {
            begin = this._LogicLastPos+1;
        }
        if (begin < this._LogicFirstPos)
        {
            begin = this._LogicFirstPos;
        }
        return begin;
    }
    // Validate key at position in mask and/or filter
    //
    , _processKey : function(poscur,key) {
        var posmask = this._LogicMaskConv;
        //  9 = only numeric
        //  L = only letter
        //  $ = only letter and spaces
        //  C = only Custom - read from this._Filtered
        //  A = only letter and Custom
        //  N = only numeric and Custom
        //  ? = any digit
        var filter;
        if  (posmask.substring(poscur,poscur+1) == "9")
        {
            filter = this._charNumbers;
        }
        else if  (posmask.substring(poscur,poscur+1).toUpperCase() == "L")
        {
            filter = this._charLetters + this._charLetters.toLowerCase();
        }
        else if  (posmask.substring(poscur,poscur+1) == "$")
        {
            filter = this._charLetters + this._charLetters.toLowerCase() + " ";
        }
        else if  (posmask.substring(poscur,poscur+1).toUpperCase() == "C")
        {
            filter = this._Filtered;
        }
        else if  (posmask.substring(poscur,poscur+1).toUpperCase() == "A")
        {
            filter = this._charLetters + this._charLetters.toLowerCase() + this._Filtered;
        }
        else if  (posmask.substring(poscur,poscur+1).toUpperCase() == "N")
        {
            filter = this._charNumbers + this._Filtered;
        }
        else if  (posmask.substring(poscur,poscur+1) == "?")
        {
            filter = "";
        }
        else
        {
            return false;
        }
        if (filter == "")
        {
            return true;
        }
        // return true if we should accept the character.
        return (!filter || filter.length == 0 || filter.indexOf(key) != -1);
    }    
    //
    // create mask empty , logic mask empty
    // convert escape code and Placeholder to culture
    //
    , _createMask : function()
    {
        if (this._MaskConv == "" && this._Mask != "")
        {
            this._convertMask();
        } 
        var text = this._MaskConv;
        var i = 0;
        var masktext = "";
        var maskvld = "";
        var flagescape = false;
        this._LogicTextMask = "";
        this._QtdValidInput = 0;
        while (i < parseInt(text.length,10)) 
        {
            if (text.substring(i, i+1) == this._charEscape && flagescape == false) 
            {
                flagescape = true;
            }
            else if (this._CharsEditMask.indexOf(text.substring(i, i+1)) == -1) 
            {
                if (flagescape == true)
                {
                    flagescape = false;
                    masktext += text.substring(i,i+1);
                    maskvld += text.substring(i,i+1);
                    this._LogicTextMask += this._LogicEscape;
                }
                else
                {
                    if (this._CharsSpecialMask.indexOf(text.substring(i, i+1)) != -1) 
                    {
                        this._QtdValidInput ++;
                        if (text.substring(i, i+1) == "/")
                        {
                            masktext += this.get_CultureDatePlaceholder();
                            maskvld += "/";
                            this._LogicTextMask += this.get_CultureDatePlaceholder();
                        }
                        else if (text.substring(i, i+1) == ":")
                        {
                            masktext += this.get_CultureTimePlaceholder();
                            maskvld += ":";
                            this._LogicTextMask += this.get_CultureTimePlaceholder();
                        }
                        else if (text.substring(i, i+1) == ",")
                        {
                            masktext += this.get_CultureThousandsPlaceholder();
                            maskvld += ".";
                            this._LogicTextMask += this.get_CultureThousandsPlaceholder();
                        }
                        else if (text.substring(i, i+1) == ".")
                        {
                            masktext += this.get_CultureDecimalPlaceholder();
                            maskvld += ",";
                            this._LogicTextMask += this.get_CultureDecimalPlaceholder();
                        }
                    }
                    else
                    {
                        masktext += text.substring(i,i+1);
                        maskvld += text.substring(i,i+1);
                        this._LogicTextMask += text.substring(i,i+1);
                    }
                }
            } 
            else 
            {
                if (flagescape == true)
                {
                    flagescape = false;
                    masktext += text.substring(i,i+1);
                    maskvld += text.substring(i,i+1);
                    this._LogicTextMask += this._LogicEscape;
                }
                else
                {
                    this._QtdValidInput ++;
                    masktext += this._PromptChar;
                    maskvld += text.substring(i,i+1);
                    this._LogicTextMask += this._LogicPrompt;
                }
            }
            i++;
        }
        // Set First and last logic position
        this._LogicFirstPos = -1;
        this._LogicLastPos = -1;
        this._LogicLastInt = -1;
        this._LogicMask = this._LogicTextMask;
        for (i = 0 ; i < parseInt(this._LogicMask.length,10) ; i++) 
        {
            if (this._LogicFirstPos == -1 && this._LogicMask.substring(i,i+1) == this._LogicPrompt)
            {
                this._LogicFirstPos = i;
            }
            if (this._LogicMask.substring(i,i+1) == this._LogicPrompt)
            {
                this._LogicLastPos = i;
            }
            if (this._MaskType == AjaxControlToolkit.MaskedEditType.Number && this._InputDirection == AjaxControlToolkit.MaskedEditInputDirections.RightToLeft)
            {
                if (this._LogicMask.substring(i,i+1) == this.get_CultureDecimalPlaceholder())
                {
                    this._LogicLastInt = i;
                }
            }
        }
        this._maskvalid = maskvld.substring(this._LogicFirstPos,this._LogicLastPos+1);
        this._EmptyMask = masktext;
    }
    //
    // return text without mask but with placeholders 
    //
    , _getClearMask : function(masktext)
    {
        var i = 0;
        var clearmask = "";
        var qtdok = 0;
        var includedec = false;
        while (i < parseInt(this._LogicTextMask.length,10)) 
        {
            if (qtdok < this._QtdValidInput)
            {
                if (this._isValidMaskedEditPosition(i) && this._LogicTextMask.substring(i, i+1) != this._LogicPrompt)
                {
                    if (clearmask == "" && includedec)
                    {
                        clearmask += "0" + this.get_CultureDecimalPlaceholder();
                        includedec = false;
                    }
                    clearmask += this._LogicTextMask.substring(i,i+1);
                    qtdok++;
                }
                else if (this._LogicTextMask.substring(i, i+1) != this._LogicPrompt && this._LogicTextMask.substring(i, i+1) != this._LogicEscape)
                {
                    if (this._LogicTextMask.substring(i,i+1) == this.get_CultureDatePlaceholder() && (this._MaskType == AjaxControlToolkit.MaskedEditType.Date || this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime))
                    {
                        clearmask += (clearmask == "")?"":this.get_CultureDatePlaceholder();
                    }
                    else if (this._LogicTextMask.substring(i,i+1) == this.get_CultureTimePlaceholder() && (this._MaskType == AjaxControlToolkit.MaskedEditType.Time || this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime))
                    {
                        clearmask += (clearmask == "")?"":this.get_CultureTimePlaceholder();
                    }
                    else if (this._LogicTextMask.substring(i,i+1) == " " && this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime)
                    {
                        clearmask += (clearmask == "")?"":" ";
                    }
                    else if (this._LogicTextMask.substring(i,i+1) == this.get_CultureThousandsPlaceholder() && this._MaskType == AjaxControlToolkit.MaskedEditType.Number)
                    {
                        clearmask += (clearmask == "")?"":this.get_CultureThousandsPlaceholder();
                    }
                    else if (this._LogicTextMask.substring(i,i+1) == this.get_CultureDecimalPlaceholder() && this._MaskType == AjaxControlToolkit.MaskedEditType.Number)
                    {
                        clearmask += (clearmask == "")?"":this.get_CultureDecimalPlaceholder();
                        if (clearmask == "")
                        {
                            includedec = true;
                        }
                    }
                }
            }
            i++;
        }
        if (this._LogicSymbol != "" && clearmask != "")
        {
            if (this._MaskType == AjaxControlToolkit.MaskedEditType.Time || this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime)
            {
                clearmask += " " + this._LogicSymbol;
            }
            else if (this._MaskType == AjaxControlToolkit.MaskedEditType.Number)
            {
                clearmask = this._LogicSymbol + clearmask;
            }
        }
        return clearmask;    
    }
    //
    // Convert notation {Number} in PAD's Number
    //
    , _convertMask : function() 
    {
        this._MaskConv = "";
        var qtdmask = "";
        var maskchar = "";
        for (i = 0 ; i < parseInt(this._Mask.length,10) ; i++) 
        {
          if (this._CharsEditMask.indexOf(this._Mask.substring(i, i+1)) != -1)
          {
            if (qtdmask.length == 0)
            {
                this._MaskConv += this._Mask.substring(i, i+1);
                qtdmask = "";
                maskchar = this._Mask.substring(i, i+1);
            }
            else if (this._Mask.substring(i, i+1) == "9")
            {
                qtdmask += "9";
            }
            else if (this._Mask.substring(i, i+1) == "0")
            {
                qtdmask += "0";
            }
          }
          else if (this._CharsEditMask.indexOf(this._Mask.substring(i, i+1)) == -1 && this._Mask.substring(i, i+1) != this._DelimitStartDup && this._Mask.substring(i, i+1) != this._DelimitEndDup)
          {
            if (qtdmask.length == 0)
            {
                this._MaskConv += this._Mask.substring(i, i+1);
                qtdmask = "";
                maskchar = "";
            }
            else
            {
               if (this._charNumbers.indexOf(this._Mask.substring(i, i+1)) != -1)
               {
                qtdmask += this._Mask.substring(i, i+1);
               }
            }            
          }
          else if (this._Mask.substring(i, i+1) == this._DelimitStartDup && qtdmask == "")
          {
            qtdmask = "0";
          }
          else if (this._Mask.substring(i, i+1) == this._DelimitEndDup && qtdmask != "")
          {
            qtddup = parseInt(qtdmask,10) -1;
            if (qtddup > 0)
            {
                for (q = 0 ; q < qtddup ; q++) 
                {
                    this._MaskConv += maskchar;
                }
            }
            qtdmask = "";
            maskchar = "";
          }
        }
        // set first and last position in mask for Symbols
        var FirstPos = -1;
        var LastPos = -1;
        var flagescape = false;
        for (i = 0 ; i < parseInt(this._MaskConv.length,10) ; i++) 
        {
            if (this._MaskConv.substring(i, i+1) == this._charEscape && !flagescape) 
            {
                flagescape = true;
            }
            else if (this._CharsEditMask.indexOf(this._MaskConv.substring(i, i+1)) != -1 && !flagescape) 
            {
                if (FirstPos == -1)
                {
                    FirstPos = i;
                }
                LastPos = i;
            } 
            else if(flagescape) 
            {
                flagescape = false;
            } 
        }
        // set spaces for Symbols AM/PM
        if ( (this._MaskType == AjaxControlToolkit.MaskedEditType.Time || this._MaskType == AjaxControlToolkit.MaskedEditType.DateTime) && this._AcceptAmPm)
        {
            var ASymMask = this.get_CultureAMPMPlaceholder().split(this._AMPMPlaceholderSeparator);
            var SymMask = "";
            if (ASymMask.length == 2)
            {
                SymMask = this._charEscape + " ";
                for (i = 0 ; i < parseInt(ASymMask[0].length,10) ; i++) 
                {
                    SymMask += this._charEscape + " ";
                }
            }
            this._MaskConv = this._MaskConv.substring(0,LastPos+1) + SymMask + this._MaskConv.substring(LastPos+1);
        }
        // set spaces for Symbols Currency
        else if (this._MaskType == AjaxControlToolkit.MaskedEditType.Number &&  this._DisplayMoney == AjaxControlToolkit.MaskedEditShowSymbol.Left)
        {
            var SymMask = "";
            for (i = 0 ; i < parseInt(this.get_CultureCurrencySymbolPlaceholder().length,10) ; i++) 
            {
                if (this._CharsEditMask.indexOf(this.get_CultureCurrencySymbolPlaceholder().substring(i, i+1)) == -1)
                {
                    SymMask += this.get_CultureCurrencySymbolPlaceholder().substring(i, i+1);
                }
                else
                {
                    SymMask += this._charEscape + this.get_CultureCurrencySymbolPlaceholder().substring(i, i+1);
                }
            }
            SymMask += this._charEscape + " ";
            this._MaskConv = this._MaskConv.substring(0,FirstPos) + SymMask + this._MaskConv.substring(FirstPos);
            FirstPos += SymMask.length;
            LastPos += SymMask.length;
        }
        // set spaces for Symbols negative
        else if (this._MaskType == AjaxControlToolkit.MaskedEditType.Number && this._DisplayMoney == AjaxControlToolkit.MaskedEditShowSymbol.Right)
        {
            var SymMask = this._charEscape + " ";
            for (i = 0 ; i < parseInt(this.get_CultureCurrencySymbolPlaceholder().length,10) ; i++) 
            {
                if (this._CharsEditMask.indexOf(this.get_CultureCurrencySymbolPlaceholder().substring(i, i+1)) == -1)
                {
                    SymMask += this.get_CultureCurrencySymbolPlaceholder().substring(i, i+1);
                }
                else
                {
                    SymMask += this._charEscape + this.get_CultureCurrencySymbolPlaceholder().substring(i, i+1);
                }
            }
            this._MaskConv = this._MaskConv.substring(0,LastPos+1) + SymMask  + this._MaskConv.substring(LastPos+1);
        }
        if (this._MaskType == AjaxControlToolkit.MaskedEditType.Number && this._AcceptNegative == AjaxControlToolkit.MaskedEditShowSymbol.Right)
        {
            this._MaskConv = this._MaskConv.substring(0,LastPos+1) + this._charEscape + " " + this._MaskConv.substring(LastPos+1);
        }
        else if (this._MaskType == AjaxControlToolkit.MaskedEditType.Number && this._AcceptNegative == AjaxControlToolkit.MaskedEditShowSymbol.Left)
        {
            this._MaskConv = this._MaskConv.substring(0,FirstPos) + this._charEscape + " " + this._MaskConv.substring(FirstPos);
        }
        this._convertMaskNotEscape();
    }
    //
    // Convert mask with escape to mask not escape
    // length is equal to real position 
    //
    , _convertMaskNotEscape : function()
    {
        this._LogicMaskConv = "";
        var atumask = this._MaskConv;
        var flagescape = false;
        for (i = 0 ; i < parseInt(atumask.length,10); i++) 
        {
            if (atumask.substring(i, i+1) == this._charEscape)
            {
                flagescape = true;
            }
            else if (!flagescape)
            {
                this._LogicMaskConv += atumask.substring(i, i+1);    
            }
            else
            {
                this._LogicMaskConv += this._LogicEscape;
                flagescape = false;
            }
        }
    }
    //
    // Helper properties
    //
    , get_Mask : function() {
        if (this._MaskConv == "" && this._Mask != "")
        {
            this._convertMask();
        } 
        return this._MaskConv;
    }
    , set_Mask : function(value) 
    {
        this._Mask = value;
        this.raisePropertyChanged('Mask');
    }
    , get_Filtered : function() 
    {
        return this._Filtered;
    }
    , set_Filtered : function(value) 
    {
        this._Filtered = value;
        this.raisePropertyChanged('Filtered');
    }    
    , get_InputDirection : function() 
    {
        return this._InputDirection;
    }      
    , set_InputDirection : function(value) 
    {
        this._InputDirection = value;
        this.raisePropertyChanged('InputDirection');
    }
    , get_PromptCharacter : function() 
    {
        return this._PromptChar;
    }      
    , set_PromptCharacter : function(value) 
    {
        this._PromptChar = value;
        this.raisePropertyChanged('PromptChar');
    }
    , get_OnFocusCssClass : function() 
    {
        return this._OnFocusCssClass;
    }      
    , set_OnFocusCssClass : function(value) 
    {
        this._OnFocusCssClass = value;
        this.raisePropertyChanged('OnFocusCssClass');
    }
    , get_OnInvalidCssClass : function() 
    {
        return this._OnInvalidCssClass;
    }      
    , set_OnInvalidCssClass : function(value) 
    {
        this._OnInvalidCssClass = value;
        this.raisePropertyChanged('OnInvalidCssClass');
    }
    , get_CultureName : function() 
    {
        return this._CultureName;
    }      
    , set_CultureName : function(value) 
    {
        this._CultureName = value;
        this.raisePropertyChanged('Culture');
    }
    , get_CultureDatePlaceholder : function() 
    {
        return this._CultureDatePlaceholder;
    }      
    , set_CultureDatePlaceholder : function(value) 
    {
        this._CultureDatePlaceholder = value;
        this.raisePropertyChanged('CultureDatePlaceholder');
    }      
    , get_CultureTimePlaceholder : function() 
    {
        return this._CultureTimePlaceholder;
    }      
    , set_CultureTimePlaceholder : function(value) 
    {
        this._CultureTimePlaceholder = value;
        this.raisePropertyChanged('CultureTimePlaceholder');
    }      
    , get_CultureDecimalPlaceholder : function() 
    {
        return this._CultureDecimalPlaceholder;
    }      
    , set_CultureDecimalPlaceholder : function(value) 
    {
        this._CultureDecimalPlaceholder = value;
        this.raisePropertyChanged('CultureDecimalPlaceholder');
    }      
    , get_CultureThousandsPlaceholder : function() 
    {
        return this._CultureThousandsPlaceholder;
    }      
    , set_CultureThousandsPlaceholder : function(value) 
    {
        this._CultureThousandsPlaceholder = value;
        this.raisePropertyChanged('CultureThousandsPlaceholder');
    }      
    , get_CultureDateFormat : function() 
    {
        var ret = this._CultureDateFormat;
        switch (this.get_UserDateFormat()) 
        {
            case AjaxControlToolkit.MaskedEditUserDateFormat.DayMonthYear:
            {
              ret = "DMY";
              break;
            }
            case AjaxControlToolkit.MaskedEditUserDateFormat.DayYearMonth:
            {
              ret = "DYM";
              break;
            }
            case AjaxControlToolkit.MaskedEditUserDateFormat.MonthDayYear:
            {
              ret = "MDY";
              break;
            }
            case AjaxControlToolkit.MaskedEditUserDateFormat.MonthYearDay:
            {
              ret = "MYD";
              break;
            }
            case AjaxControlToolkit.MaskedEditUserDateFormat.YearDayMonth:
            {
              ret = "YDM";
              break;
            }
            case AjaxControlToolkit.MaskedEditUserDateFormat.YearMonthDay:
            {
              ret = "YMD";
              break;
            }
        }
        return ret;
    }      
    , set_CultureDateFormat : function(value) 
    {
        this._CultureDateFormat = value;
        this.raisePropertyChanged('CultureDateFormat');
    }      
    , get_CultureCurrencySymbolPlaceholder : function() 
    {
        return this._CultureCurrencySymbolPlaceholder;
    }      
    , set_CultureCurrencySymbolPlaceholder : function(value) 
    {
        this._CultureCurrencySymbolPlaceholder= value;
        this.raisePropertyChanged('CultureCurrencySymbolPlaceholder');
    }   
    , get_CultureAMPMPlaceholder : function() 
    {
        var value = this._CultureAMPMPlaceholder;
        if (value.split(this._AMPMPlaceholderSeparator).length != 2 || value == this._AMPMPlaceholderSeparator) 
        {
            value = "";
        }
        if (this.get_UserTimeFormat() == AjaxControlToolkit.MaskedEditUserTimeFormat.TwentyFourHour)
        {
            value = "";
        }
        return value;
    }      
    , set_CultureAMPMPlaceholder : function(value) 
    {
        this._CultureAMPMPlaceholder = value;
        this.raisePropertyChanged('CultureAMPMPlaceholder');
    } 
    , get_CultureFirstLettersAMPM : function()  
    {
        if (this.get_CultureAMPMPlaceholder() != "")
        {
            var ASymMask = this.get_CultureAMPMPlaceholder().split(this._AMPMPlaceholderSeparator);
            return (ASymMask[0].substring(0,1) + ASymMask[1].substring(0,1));
        }
        return "";
    }
    , get_CultureFirstLetterAM : function() 
    {
        if (this.get_CultureAMPMPlaceholder() != "")
        {
            var ASymMask = this.get_CultureAMPMPlaceholder().split(this._AMPMPlaceholderSeparator);
            return ASymMask[0].substring(0,1);
        }
        return "";
    }   
    , get_CultureFirstLetterPM : function() 
    {
        if (this.get_CultureAMPMPlaceholder() != "")
        {
            var ASymMask = this.get_CultureAMPMPlaceholder().split(this._AMPMPlaceholderSeparator);
            return ASymMask[1].substring(0,1);
        }
        return "";
    }   
    , get_ClearMaskOnLostFocus : function() 
    {
        return this._ClearMaskOnLostfocus;
    }      
    , set_ClearMaskOnLostFocus : function(value) 
    {
        this._ClearMaskOnLostfocus = value;
        this.raisePropertyChanged('ClearMaskOnLostfocus');
    }      
    , get_MessageValidatorTip : function() 
    {
        return this._MessageValidatorTip;
    }      
    , set_MessageValidatorTip : function(value) 
    {
        this._MessageValidatorTip = value;
        this.raisePropertyChanged('MessageValidatorTip');
    }      
    , get_AcceptAMPM : function() 
    {
        return this._AcceptAmPm;
    }      
    , set_AcceptAMPM : function(value) 
    {
        this._AcceptAmPm = value;
        this.raisePropertyChanged('AcceptAmPm');
    }   
    , get_AcceptNegative : function() 
    {
        return this._AcceptNegative;
    }      
    , set_AcceptNegative : function(value) 
    {
        this._AcceptNegative= value;
        this.raisePropertyChanged('AcceptNegative');
    }   
    , get_DisplayMoney : function() 
    {
        return this._DisplayMoney;
    }      
    , set_DisplayMoney : function(value) 
    {
        this._DisplayMoney = value;
        this.raisePropertyChanged('DisplayMoney');
    }   
    , get_OnFocusCssNegative : function() 
    {
        return this._OnFocusCssNegative;
    }      
    , set_OnFocusCssNegative : function(value) 
    {
        this._OnFocusCssNegative= value;
        this.raisePropertyChanged('OnFocusCssNegative');
    }   
    , get_OnBlurCssNegative : function() 
    {
        return this._OnBlurCssNegative;
    }      
    , set_OnBlurCssNegative : function(value) 
    {
        this._OnBlurCssNegative= value;
        this.raisePropertyChanged('OnBlurCssNegative');
    }   
    , get_Century : function() 
    {
        return this._Century;
    }      
    , set_Century : function(value) 
    {
        this._Century= value;
        this.raisePropertyChanged('Century');
    }   
    , get_AutoComplete : function() 
    {
        return this._AutoComplete;
    }      
    , set_AutoComplete : function(value) 
    {
        this._AutoComplete = value;
        this.raisePropertyChanged('AutoComplete');
    }   
    , get_AutoCompleteValue : function() 
    {
        return this._AutoCompleteValue;
    }      
    , set_AutoCompleteValue : function(value) 
    {
        this._AutoCompleteValue = value;
        this.raisePropertyChanged('AutoCompleteValue');
    }   
    , get_MaskType : function() 
    {
        return this._MaskType;
    }      
    , set_MaskType : function(value) 
    {
        this._MaskType = value;
        this.raisePropertyChanged('MaskType');
    }   
    
    , get_ClearTextOnInvalid : function()
    {
        return this._ClearTextOnInvalid;
    }
    , set_ClearTextOnInvalid : function(value)
    {
        if(this._ClearTextOnInvalid !== value)
        {
            this._ClearTextOnInvalid = value;
            this.raisePropertyChanged('ClearTextOnInvalid');
        }
    }
    , get_ClipboardText : function() 
    {
        return this._ClipboardText;
    }      
    , set_ClipboardText : function(value) 
    {
        this._ClipboardText = value;
        this.raisePropertyChanged('ClipboardText');  
    }   
    , get_ClipboardEnabled : function()
    {
        return this._AllowCopyPaste;
    }
    , set_ClipboardEnabled : function(value)
    {
        this._AllowCopyPaste = value;
        this.raisePropertyChanged('ClipboardEnabled');
    }
    , get_ErrorTooltipEnabled : function()
    {
        return this._ShowMessageErrorFloat;
    }
    , set_ErrorTooltipEnabled : function(value)
    {
        this._ShowMessageErrorFloat = value;
        this.raisePropertyChanged('ErrorTooltipEnabled');
    }
    , get_ErrorTooltipCssClass : function()
    {
        return this._CssMessageErrorFloat;
    }
    , set_ErrorTooltipCssClass : function(value)
    {
        this._CssMessageErrorFloat = value;
        this.raisePropertyChanged('ErrorTooltipCssClass');
    }
    , get_UserDateFormat : function() 
    {
        return this._UserDateFormat;
    }      
    , set_UserDateFormat : function(value) 
    {
        this._UserDateFormat = value;
        this.raisePropertyChanged('UserDateFormat');
    }
    , get_UserTimeFormat : function() 
    {
        return this._UserTimeFormat;
    }      
    , set_UserTimeFormat : function(value) 
    {
        this._UserTimeFormat = value;
        this.raisePropertyChanged('UserTimeFormat');
    }
}
AjaxControlToolkit.MaskedEditBehavior.registerClass('AjaxControlToolkit.MaskedEditBehavior', AjaxControlToolkit.DynamicPopulateBehaviorBase);

// **************************************************
// Register enumerations  
// **************************************************
AjaxControlToolkit.MaskedEditType = function() {
    throw Error.invalidOperation();
}

AjaxControlToolkit.MaskedEditInputDirections = function() {
    throw Error.invalidOperation();
}

AjaxControlToolkit.MaskedEditShowSymbol = function() {
    throw Error.invalidOperation();
}

AjaxControlToolkit.MaskedEditUserDateFormat = function() {
    throw Error.invalidOperation();
}

AjaxControlToolkit.MaskedEditUserTimeFormat = function() {
    throw Error.invalidOperation();
}

AjaxControlToolkit.MaskedEditType.prototype = {
    None: 0,
    Date: 1,
    Number: 2,
    Time: 3,
    DateTime: 4
}

AjaxControlToolkit.MaskedEditInputDirections.prototype = {
    LeftToRight: 0,
    RightToLeft: 1
}

AjaxControlToolkit.MaskedEditShowSymbol.prototype = {
    None: 0,
    Left: 1,
    Right: 2
}

AjaxControlToolkit.MaskedEditUserDateFormat.prototype = {
    None: 0,
    DayMonthYear: 1,
    DayYearMonth: 2,
    MonthDayYear: 3,
    MonthYearDay: 4,
    YearDayMonth: 5,
    YearMonthDay: 6
}

AjaxControlToolkit.MaskedEditUserTimeFormat.prototype = {
    None: 0,
    TwentyFourHour: 1
}

AjaxControlToolkit.MaskedEditType.registerEnum('AjaxControlToolkit.MaskedEditType');
AjaxControlToolkit.MaskedEditInputDirections.registerEnum('AjaxControlToolkit.MaskedEditInputDirections');
AjaxControlToolkit.MaskedEditShowSymbol.registerEnum('AjaxControlToolkit.MaskedEditShowSymbol');
AjaxControlToolkit.MaskedEditUserDateFormat.registerEnum('AjaxControlToolkit.MaskedEditUserDateFormat');
AjaxControlToolkit.MaskedEditUserTimeFormat.registerEnum('AjaxControlToolkit.MaskedEditUserTimeFormat');

//END AjaxControlToolkit.MaskedEdit.MaskedEditBehavior.js
//START AjaxControlToolkit.MaskedEdit.MaskedEditValidator.js
// (c) Copyright Microsoft Corporation.
// This source is subject to the Microsoft Permissive License.
// See http://www.microsoft.com/resources/sharedsource/licensingbasics/sharedsourcelicenses.mspx.
// All other rights reserved.


/// <reference name="MicrosoftAjax.debug.js" />
/// <reference name="MicrosoftAjaxTimer.debug.js" />
/// <reference name="MicrosoftAjaxWebForms.debug.js" />
/// <reference path="../Common/Common.js" />


// Product      : MaskedEdit Validator Control
// Version      : 1.0.0.0
// Date         : 11/08/2006
// Development  : Fernando Cerqueira 
// Version      : 1.0.0.1
// Development  : 02/22/2007 Fernando Cerqueira 
//
function MaskedEditSetMessage(value,msg,txt)
{
    value.errormessage = msg;
    if (txt == "")
    {
        value.text = msg;
    }
    else
    {
        value.text = txt;
    }
    value.innerHTML = value.text;
}
function MaskedEditMessageShow(value,IsValid)
{
    if (typeof(value.display) == "string") 
    {    
        if (value.display == "None") {
            return;
        }
        if (value.display == "Dynamic") {
            value.style.display = IsValid ? "none" : "inline";
            return;
        }
    }
    value.style.visibility = IsValid ? "hidden" : "visible";
}
function MaskedEditSetCssClass(value,Css)
{
    var target = $get(value.TargetValidator); 
    Sys.UI.DomElement.removeCssClass(target,value.InvalidValueCssClass);
    Sys.UI.DomElement.removeCssClass(target,value.CssBlurNegative);
    Sys.UI.DomElement.removeCssClass(target,value.CssFocus);
    Sys.UI.DomElement.removeCssClass(target,value.CssFocusNegative);
    if (Css != "")
    {
        Sys.UI.DomElement.addCssClass(target,Css);
    }
}
function MaskedEditValidatorDateTime(value)
{
    MaskedEditSetMessage(value,"","");
    MaskedEditSetCssClass(value,"");
    MaskedEditMessageShow(value,true);
    if (value.IsMaskedEdit == "false")
    {
        return true;
    }
    var target = $get(value.TargetValidator); 
    if (value.ValidEmpty  == "false")
    {
        if (AjaxControlToolkit.TextBoxWrapper.get_Wrapper(target).get_Value() == value.InitialValue)
        {
            MaskedEditSetMessage(value,value.EmptyValueMessage,value.EmptyValueText);
            MaskedEditSetCssClass(value,value.InvalidValueCssClass);
            MaskedEditMessageShow(value,false);
            return false;
        }
    }
    if (AjaxControlToolkit.TextBoxWrapper.get_Wrapper(target).get_Value() == "")
    {
        return true;
    }
    var ret = true;
    var mask = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(target).get_Value();
    //regular Exp
    if (value.ValidationExpression != "" )
    {
        var rx = new RegExp(value.ValidationExpression);
        var matches = rx.exec(mask);
        ret = (matches != null && mask == matches[0]);
        if (!ret)
        {
            MaskedEditSetMessage(value,value.InvalidValueMessage,value.InvalidValueText);
            MaskedEditSetCssClass(value,value.InvalidValueCssClass);
            MaskedEditMessageShow(value,false);
            return false;
        }
    }
    var PartDate = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(target).get_Value().split(" ")[0];
    var PartTime = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(target).get_Value().split(" ")[1];
    if (AjaxControlToolkit.TextBoxWrapper.get_Wrapper(target).get_Value().split(" ").length == 3)
    {
        PartTime += " " + AjaxControlToolkit.TextBoxWrapper.get_Wrapper(target).get_Value().split(" ")[2];
    }
    var MinVlDt = "";
    var MinVlTm = "";
    if (value.MinimumValue != "")
    {
        MinVlDt = value.MinimumValue.split(" ")[0];
        MinVlTm = value.MinimumValue.split(" ")[1];
    }
    var MaxVlDt = "";
    var MaxVlTm = "";
    if (value.MaximumValue != "")
    {
        MaxVlDt = value.MaximumValue.split(" ")[0];
        MaxVlTm = value.MaximumValue.split(" ")[1];
    }
    ret = MaskedEditValidatorPartDate(value,PartDate,MinVlDt,MaxVlDt);
    if (ret)
    {
        ret = MaskedEditValidatorPartTime(value,PartTime,MinVlTm,MaxVlTm);
    }
    //custom valid
    if (ret && value.ClientValidationFunction != "")
    {
        var args = { Value:mask, IsValid:true };
        eval(value.ClientValidationFunction + "(value, args);");
        ret = args.IsValid;
        if (!ret)
        {
            MaskedEditSetMessage(value,value.InvalidValueMessage,value.InvalidValueText);
            MaskedEditSetCssClass(value,value.InvalidValueCssClass);
        }
    }
    if (!ret)
    {
        MaskedEditMessageShow(value,ret);
    }
    return ret;
}
function MaskedEditValidatorPartTime(value,mask,MinVl,MaxVl)
{
    var ret = true;
    var AttibTmSep = value.TimeSeparator;
    var AttibTmSyb = value.AmPmSymbol;
    // hh:mm or hh:mm:ss  
    var SybTm = AttibTmSyb.split(";");
    var tm = AttibTmSyb.replace(";","|");
    var reg1 = "^(^([0][0-9]|[1][0-2])"+ AttibTmSep + "([0-5][0-9])" + AttibTmSep + "([0-5][0-9])\\s("+tm+")$)|(^([0][0-9]|[1][0-2])" + AttibTmSep + "([0-5][0-9])\\s("+tm+")$)$";
    var reg2 = "^(^([0-1][0-9]|[2][0-3])" + AttibTmSep + "([0-5][0-9])" + AttibTmSep + "([0-5][0-9])$)|(^([0-1][0-9]|[2][0-3])" + AttibTmSep + "([0-5][0-9])$)$";
    var H=-1;
    var M=-1;
    var S=-1;
    var aux = "";
    var m_arrValue = mask.split(AttibTmSep);
    var regex1 = new RegExp(reg1);
    var matches1 = regex1.exec(mask);
    var regex2 = new RegExp(reg2);
    var matches2 = regex2.exec(mask);
    if  (matches1 && (matches1[0] == mask))
    {
        aux = mask.substring(mask.length-2).substring(0,1);
        H = parseInt(m_arrValue[0],10);
        if (aux.toUpperCase() == SybTm[1].substring(0,1).toUpperCase())
        {
            H += 12;
            if (H == 24)
            {
                H = 0;
            }
        }
        M = parseInt(m_arrValue[1],10);
        S = (value.length > 9?parseInt(m_arrValue[2].substring(0,2),10):0);
    }
    else if (matches2 && (matches2[0] == mask))
    {
        H = parseInt(m_arrValue[0],10);
        M = parseInt(m_arrValue[1],10);
        S = (mask.length > 5?parseInt(m_arrValue[2],10):0);
    }
    if (H==-1 || M==-1 || S==-1)
    {
        ret = false;
    }
    if (!ret)
    {
        MaskedEditSetMessage(value,value.InvalidValueMessage,value.InvalidValueText);
        MaskedEditSetCssClass(value,value.InvalidValueCssClass);
    }
    if(ret && (MaxVl != "" || MinVl != ""))
    {
        var Hr;
        var Mr;
        var Sr;
        var m_arr;
        if (MinVl != "" )
        {
            Hr=-1;
            Mr=-1;
            Sr=-1;
            m_arr = MinVl.split(AttibTmSep);
            matches1 = regex1.exec(MinVl);
            matches2 = regex2.exec(MinVl);
            if (matches1 && (matches1[0] == MinVl))
            {
                aux = MinVl.substring(MinVl.length-2).substring(0,1);
                Hr = parseInt(m_arr[0],10);
                if (aux.toUpperCase() == SybTm[1].substring(0,1).toUpperCase())
                {
                    Hr += 12;
                    if (Hr == 24)
                    {
                        Hr = 0;
                    }
                }
                Mr = parseInt(m_arr[1],10);
                Sr = (MinVl.length > 9?parseInt(m_arr[2].substring(0,2),10):0);
            }
            else if (matches2 && (matches2[0] == MinVl))
            {
                Hr = parseInt(m_arr[0],10);
                Mr = parseInt(m_arr[1],10);
                Sr = (MinVl.length > 5?parseInt(m_arr[2],10):0);
            }
            ret = (H > Hr || (H == Hr && M > Mr) || (H == Hr && M == Mr && S >= Sr));
            if (!ret)
            {
                MaskedEditSetMessage(value,value.MinimumValueMessage,value.MinimumValueText);
                MaskedEditSetCssClass(value,value.InvalidValueCssClass);
            }
        }
        if (MaxVl != "" && ret)
        {
            Hr=-1;
            Mr=-1;
            Sr=-1;
            m_arr = MaxVl.split(AttibTmSep);
            matches1 = regex1.exec(MaxVl);
            matches2 = regex2.exec(MaxVl);
            if  (matches1 && (matches1[0] == MaxVl))
            {
                aux = MaxVl.substring(MaxVl.length-2).substring(0,1);
                Hr = parseInt(m_arr[0],10);
                if (aux.toUpperCase() == SybTm[1].substring(0,1).toUpperCase())
                {
                    Hr += 12;
                    if (Hr == 24)
                    {
                        Hr = 0;
                    }
                }
                Mr = parseInt(m_arr[1],10);
                Sr = (MaxVl.length > 9?parseInt(m_arr[2].substring(0,2),10):0);
            }
            else if (matches2 && (matches2[0] == MaxVl))
            {
                Hr = parseInt(m_arr[0],10);
                Mr = parseInt(m_arr[1],10);
                Sr = (MaxVl.length > 5?parseInt(m_arr[2],10):0);
            }
            ret = (H < Hr || (H == Hr && M < Mr) || (H == Hr && M == Mr && S <= Sr));
            if (!ret)
            {
                MaskedEditSetMessage(value,value.MaximumValueMessage,value.MaximumValueText);
                MaskedEditSetCssClass(value,value.InvalidValueCssClass);
            }
        }
    }
    return ret;
}
function MaskedEditValidatorPartDate(value,mask,MinVl,MaxVl)
{
    var ret = true;
    var AttibDtFmt = value.DateFormat;
    var AttibDtSep = value.DateSeparator;
    var m_arrDate = mask.split(AttibDtSep);
    if (parseInt(m_arrDate.length,10) != 3)
    {
        MaskedEditSetMessage(value,value.InvalidValueMessage,value.InvalidValueText);
        MaskedEditSetCssClass(value,value.InvalidValueCssClass);
        ret = false;
    }
    if (AttibDtFmt.indexOf("D") == -1 || AttibDtFmt.indexOf("M") == -1 || AttibDtFmt.indexOf("Y") == -1)
    {
        MaskedEditSetMessage(value,value.InvalidValueMessage,value.InvalidValueText);
        MaskedEditSetCssClass(value,value.InvalidValueCssClass);
        ret = false;
    }
    var D = -1;
    var M = -1;
    var Y = -1;
    if (ret)
    {
        D = parseInt(m_arrDate[AttibDtFmt.indexOf("D")],10);
        M = parseInt(m_arrDate[AttibDtFmt.indexOf("M")],10);
        Y = parseInt(m_arrDate[AttibDtFmt.indexOf("Y")],10)
        if (Y < 100)
        {
            Y = parseInt(Y + value.Century,10);
        }
        else if (Y < 999)
        {
            Y += parseInt(value.Century.substring(0,1) + Y,10)
        }
        ret = (D>0 && M>0 && Y>0 && (D<=[,31,28,31,30,31,30,31,31,30,31,30,31][M] || D==29 && M==2 && Y%4==0 && (Y%100>0 || Y%400==0)));
    }
    if (!ret)
    {
        MaskedEditSetMessage(value,value.InvalidValueMessage,value.InvalidValueText);
        MaskedEditSetCssClass(value,value.InvalidValueCssClass);
    }
    if(ret && (MaxVl != "" || MinVl != ""))
    {
       var m_arr;
       var Dr=-1;
       var Mr=-1;
       var Yr=-1;
       if (MinVl != "")
       {
            m_arr = MinVl.split(AttibDtSep);
            Dr = parseInt(m_arr[AttibDtFmt.indexOf("D")],10);
            Mr = parseInt(m_arr[AttibDtFmt.indexOf("M")],10);
            Yr = parseInt(m_arr[AttibDtFmt.indexOf("Y")],10);
            if (Yr < 100)
            {
                Yr = parseInt(Yr + value.Century,10);
            }
            else if (Yr < 999)
            {
                Yr += parseInt(value.Century.substring(0,1) + Yr,10)
            }
            ret = (Dr>0 && Mr>0 && Yr>0 && Y > Yr || (Y == Yr && M > Mr) || (Y == Yr && M == Mr && D >= Dr));
            if (!ret)
            {
                MaskedEditSetMessage(value,value.MinimumValueMessage,value.MinimumValueText);
                MaskedEditSetCssClass(value,value.InvalidValueCssClass);
            }
       }
       if (ret && MaxVl != "")
       {
            m_arr = MaxVl.split(AttibDtSep);
            Dr = parseInt(m_arr[AttibDtFmt.indexOf("D")],10);
            Mr = parseInt(m_arr[AttibDtFmt.indexOf("M")],10);
            Yr = parseInt(m_arr[AttibDtFmt.indexOf("Y")],10);
            if (Yr < 100)
            {
                Yr = parseInt(Yr + value.Century,10);
            }
            else if (Yr < 999)
            {
                Yr += parseInt(value.Century.substring(0,1) + Yr,10)
            }
            ret = (Dr>0 && Mr>0 && Yr>0 && Y < Yr || (Y == Yr && M < Mr) || (Y == Yr && M == Mr && D <= Dr));
            if (!ret)
            {
                MaskedEditSetMessage(value,value.MaximumValueMessage,value.MaximumValueText);
                MaskedEditSetCssClass(value,value.InvalidValueCssClass);
            }
       }
    }
    return ret;
}
function MaskedEditValidatorDate(value)
{

    MaskedEditSetMessage(value,"","");
    MaskedEditSetCssClass(value,"");
    MaskedEditMessageShow(value,true);
    if (value.IsMaskedEdit == "false")
    {
        return true;
    }
    var target = $get(value.TargetValidator); 
    if (value.ValidEmpty  == "false")
    {
        if (AjaxControlToolkit.TextBoxWrapper.get_Wrapper(target).get_Value() == value.InitialValue)
        {
            MaskedEditSetMessage(value,value.EmptyValueMessage,value.EmptyValueText);
            MaskedEditSetCssClass(value,value.InvalidValueCssClass);
            MaskedEditMessageShow(value,false);
            return false;
        }
    }
    if (AjaxControlToolkit.TextBoxWrapper.get_Wrapper(target).get_Value() == "")
    {
        return true;
    }
    var ret = true;
    var mask = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(target).get_Value();
    //regular Exp
    if (value.ValidationExpression != "" )
    {
        var rx = new RegExp(value.ValidationExpression);
        var matches = rx.exec(mask);
        ret = (matches != null && mask == matches[0]);
        if (!ret)
        {
            MaskedEditSetMessage(value,value.InvalidValueMessage,value.InvalidValueText);
            MaskedEditSetCssClass(value,value.InvalidValueCssClass);
            MaskedEditMessageShow(value,false);
            return false;
        }
    }
    ret = MaskedEditValidatorPartDate(value,mask,value.MinimumValue,value.MaximumValue);
    if (ret && value.ClientValidationFunction != "")
    {
        var args = { Value:mask, IsValid:true };
        eval(value.ClientValidationFunction + "(value, args);");
        ret = args.IsValid;
        if (!ret)
        {
            MaskedEditSetMessage(value,value.InvalidValueMessage,value.InvalidValueText);
            MaskedEditSetCssClass(value,value.InvalidValueCssClass);
        }
    }
    if (!ret)
    {
        MaskedEditMessageShow(value,ret);
    }
    return ret;
}
//  Validator time
function MaskedEditValidatorTime(value)
{
    MaskedEditSetMessage(value,"","");
    MaskedEditSetCssClass(value,"");
    MaskedEditMessageShow(value,true);
    if (value.IsMaskedEdit == "false")
    {
        return true;
    }
    var target = $get(value.TargetValidator); 
    if (value.ValidEmpty  == "false")
    {
        if (AjaxControlToolkit.TextBoxWrapper.get_Wrapper(target).get_Value() == value.InitialValue)
        {
            MaskedEditSetMessage(value,value.EmptyValueMessage,value.EmptyValueText);
            MaskedEditSetCssClass(value,value.InvalidValueCssClass);
            MaskedEditMessageShow(value,false);
            return false;
        }
    }
    if (AjaxControlToolkit.TextBoxWrapper.get_Wrapper(target).get_Value() == "")
    {
        return true;
    }
    var ret = true;
    var mask = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(target).get_Value();
    //regular Exp
    if (value.ValidationExpression != "" )
    {
        var rx = new RegExp(value.ValidationExpression);
        var matches = rx.exec(mask);
        ret = (matches != null && mask == matches[0]);
        if (!ret)
        {
            MaskedEditSetMessage(value,value.InvalidValueMessage,value.InvalidValueText);
            MaskedEditSetCssClass(value,value.InvalidValueCssClass);
            MaskedEditMessageShow(value,false);
            return false;
        }
    }
    ret = MaskedEditValidatorPartTime(value,mask,value.MinimumValue,value.MaximumValue);
    if (ret && value.ClientValidationFunction != "")
    {
        var args = { Value:mask, IsValid:true };
        eval(value.ClientValidationFunction + "(value, args);");
        ret = args.IsValid;
        if (!ret)
        {
            MaskedEditSetMessage(value,value.InvalidValueMessage,value.InvalidValueText);
            MaskedEditSetCssClass(value,value.InvalidValueCssClass);
        }
    }
    if (!ret)
    {
        MaskedEditMessageShow(value,ret);
    }
    return ret;        
}
//  Validator Number
function MaskedEditValidatorNumber(value)
{
    MaskedEditSetMessage(value,"","");
    MaskedEditSetCssClass(value,"");
    MaskedEditMessageShow(value,true);
    if (value.IsMaskedEdit == "false")
    {
        return true;
    }
    var target = $get(value.TargetValidator); 
    if (value.ValidEmpty  == "false")
    {
        if (AjaxControlToolkit.TextBoxWrapper.get_Wrapper(target).get_Value() == value.InitialValue)
        {
            MaskedEditSetMessage(value,value.EmptyValueMessage,value.EmptyValueText);
            MaskedEditSetCssClass(value,value.InvalidValueCssClass);
            MaskedEditMessageShow(value,false);
            return false;
        }
    }
    if (AjaxControlToolkit.TextBoxWrapper.get_Wrapper(target).get_Value() == "")
    {
        return true;
    }
    var ret = true;
    var AttibThSep = value.Thousands;
    var AttibDcSep = value.Decimal;
    var AttibCuSyb = value.Money;
    var AttibLastPos = value.LastMaskPosition + AttibCuSyb.length + 1;
    
    var mask = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(target).get_Value();

    if (value.ValidationExpression != "" )
    {
        var rx = new RegExp(value.ValidationExpression);
        var matches = rx.exec(mask);
        ret = (matches != null && mask == matches[0]);
        if (!ret)
        {
            MaskedEditSetMessage(value,value.InvalidValueMessage,value.InvalidValueText);
            MaskedEditSetCssClass(value,value.InvalidValueCssClass);
            MaskedEditMessageShow(value,false);
            return false;
        }
    }
    ret = false;
    var cleanInput = null;
    var exp  = null;
    var m = null;
    var num = null;
    var Compnum = null;
    mask = mask.replace(new RegExp("(\\" + AttibThSep + ")", "g"), "");
    mask = mask.replace(new RegExp("(\\" + AttibCuSyb + ")", "g"), "");
    //trim
    m = mask.match(/^\s*(\S+(\s+\S+)*)\s*$/);
    if (m != null)
    {
        mask = m[1];
    }
    //integer
    exp = /^\s*[-\+]?\d+\s*$/;
    if (mask.match(exp) != null) 
    {
        num = parseInt(mask, 10);
        ret = (num == (isNaN(num) ? null : num));
    }
    if (ret)
    {
        if (value.MaximumValue != "")
        {
            Compnum = parseInt(value.MaximumValue, 10);
            if (Compnum == (isNaN(Compnum) ? null : Compnum))
            {
                if (num > Compnum)
                {
                    ret = false;
                    MaskedEditSetMessage(value,value.MaximumValueMessage,value.MaximumValueText);
                    MaskedEditSetCssClass(value,value.InvalidValueCssClass);
                }
            }
        }
        if (ret && value.MinimumValue != "")
        {
            Compnum = parseInt(value.MinimumValue, 10);
            if (Compnum == (isNaN(Compnum) ? null : Compnum))
            {
                if (num < Compnum)
                {
                    ret = false;
                    MaskedEditSetMessage(value,value.MinimumValueMessage,value.MinimumValueText);
                    MaskedEditSetCssClass(value,value.InvalidValueCssClass);
                }
            }
        }
    }
    else
    {
        //float
        exp = new RegExp("^\\s*([-\\+])?(\\d+)?(\\" + AttibDcSep + "(\\d+))?\\s*$");
        m = mask.match(exp);
        if (m != null)
        {
            cleanInput = null;
            if  (typeof(m[1]) != "undefined")
            {
                cleanInput = m[1] + (m[2].length>0 ? m[2] : "0") + "." + m[4];
            }
            else
            {
                cleanInput = (m[2].length>0 ? m[2] : "0") + "." + m[4];
            }
            num = parseFloat(cleanInput);
            ret = (num == (isNaN(num) ? null : num));            
        }
        if (!ret)
        {
            MaskedEditSetMessage(value,value.InvalidValueMessage,value.InvalidValueText);
            MaskedEditSetCssClass(value,value.InvalidValueCssClass);
        }
        if (ret)
        {
            if (value.MaximumValue != "")
            {
                Compnum = parseFloat(value.MaximumValue);
                if (Compnum == (isNaN(Compnum) ? null : Compnum))
                {
                    if (num > Compnum)
                    {
                        ret = false;
                        MaskedEditSetMessage(value,value.MaximumValueMessage,value.MaximumValueText);
                        MaskedEditSetCssClass(value,value.InvalidValueCssClass);
                    }
                }
            }
            if (ret && value.MinimumValue != "")
            {
                Compnum = parseFloat(value.MinimumValue);
                if (Compnum == (isNaN(Compnum) ? null : Compnum))
                {
                    if (num < Compnum)
                    {
                        ret = false;
                        MaskedEditSetMessage(value,value.MinimumValueMessage,value.MinimumValueText);
                        MaskedEditSetCssClass(value,value.InvalidValueCssClass);
                    }
                }
            }
        }
    }
    if (ret && value.ClientValidationFunction != "")
    {
        var args = { Value:mask, IsValid:true };
        eval(value.ClientValidationFunction + "(value, args);");
        ret = args.IsValid;
        if (!ret)
        {
            MaskedEditSetMessage(value,value.InvalidValueMessage,value.InvalidValueText);
            MaskedEditSetCssClass(value,value.InvalidValueCssClass);
        }
    }
    if (!ret)
    {
        MaskedEditMessageShow(value,ret);
    }
    return ret;        
}
//  Validator None
function MaskedEditValidatorNone(value)
{
    MaskedEditSetMessage(value,"","");
    MaskedEditSetCssClass(value,"");
    MaskedEditMessageShow(value,true);
    if (value.IsMaskedEdit == "false")
    {
        return true;
    }
    var target = $get(value.TargetValidator); 
    if (value.ValidEmpty  == "false")
    {
        if (AjaxControlToolkit.TextBoxWrapper.get_Wrapper(target).get_Value() == value.InitialValue)
        {
            MaskedEditSetMessage(value,value.EmptyValueMessage,value.EmptyValueText);
            MaskedEditSetCssClass(value,value.InvalidValueCssClass);
            MaskedEditMessageShow(value,false);
            return false;
        }
    }
    if (AjaxControlToolkit.TextBoxWrapper.get_Wrapper(target).get_Value() == "")
    {
        return true;
    }
    var ret = true;
    var mask = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(target).get_Value();
    if (value.ValidationExpression != "" )
    {
        var rx = new RegExp(value.ValidationExpression);
        var matches = rx.exec(mask);
        ret = (matches != null && mask == matches[0]);
        if (!ret)
        {
            MaskedEditSetMessage(value,value.InvalidValueMessage,value.InvalidValueText);
            MaskedEditSetCssClass(value,value.InvalidValueCssClass);
            MaskedEditMessageShow(value,false);
            return false;
        }
    }
    var exp = /^\d+\s*$/;
    var num = null;
    if (value.MaximumValue != "")
    {
        if (value.MaximumValue.match(exp) != null) 
        {
            num = parseInt(value.MaximumValue, 10);
            if (num == (isNaN(num) ? null : num))
            {
                if (mask.length > num)
                {
                    ret = false;
                    MaskedEditSetMessage(value,value.MaximumValueMessage,value.MaximumValueText);
                    MaskedEditSetCssClass(value,value.InvalidValueCssClass);
                }
            }
        }
    }
    if (ret && value.MinimumValue != "")
    {
        if (value.MinimumValue.match(exp) != null) 
        {
            num = parseInt(value.MinimumValue, 10);
            if (num == (isNaN(num) ? null : num))
            {
                if (mask.length < num)
                {
                    ret = false;
                    MaskedEditSetMessage(value,value.MinimumValueMessage,value.MinimumValueText);
                    MaskedEditSetCssClass(value,value.InvalidValueCssClass);
                }
            }
        }
    }
    if (ret && value.ClientValidationFunction != "")
    {
        var args = { Value:mask, IsValid:true };
        eval(value.ClientValidationFunction + "(value, args);");
        ret = args.IsValid;
        if (!ret)
        {
            MaskedEditSetMessage(value,value.InvalidValueMessage,value.InvalidValueText);
            MaskedEditSetCssClass(value,value.InvalidValueCssClass);
        }
    }
    if (!ret)
    {
        MaskedEditMessageShow(value,ret);
    }
    return ret;        
}

//END AjaxControlToolkit.MaskedEdit.MaskedEditValidator.js
//START AjaxControlToolkit.TextboxWatermark.TextboxWatermark.js
// (c) Copyright Microsoft Corporation.
// This source is subject to the Microsoft Permissive License.
// See http://www.microsoft.com/resources/sharedsource/licensingbasics/sharedsourcelicenses.mspx.
// All other rights reserved.


/// <reference name="MicrosoftAjax.debug.js" />
/// <reference name="MicrosoftAjaxTimer.debug.js" />
/// <reference name="MicrosoftAjaxWebForms.debug.js" />
/// <reference path="../ExtenderBase/BaseScripts.js" />
/// <reference path="../Common/Common.js" />


Type.registerNamespace('AjaxControlToolkit');

AjaxControlToolkit.TextBoxWatermarkBehavior = function(element) {
    /// <summary>
    /// The TextBoxWatermarkBehavior applies a watermark to a textbox
    /// </summary>
    /// <param name="element" type="Sys.UI.DomElement" domElement="true">
    /// Textbox associated with the behavior
    /// </param>
    AjaxControlToolkit.TextBoxWatermarkBehavior.initializeBase(this, [element]);
    
    // Properties
    this._watermarkText = null;
    this._watermarkCssClass = null;

    // Member variables
    this._focusHandler = null;
    this._blurHandler = null;
    this._keyPressHandler = null;
    this._propertyChangedHandler = null;
    this._watermarkChangedHandler = null;
    this._oldClassName = null;
    this._clearedForSubmit = null;
    this._maxLength = null;

    // Hook into the ASP.NET WebForm_OnSubmit function to clear watermarks prior to submission
    if ((typeof(WebForm_OnSubmit) == 'function') && !AjaxControlToolkit.TextBoxWatermarkBehavior._originalWebForm_OnSubmit) {
        AjaxControlToolkit.TextBoxWatermarkBehavior._originalWebForm_OnSubmit = WebForm_OnSubmit;
        WebForm_OnSubmit = AjaxControlToolkit.TextBoxWatermarkBehavior.WebForm_OnSubmit;
    }
}
AjaxControlToolkit.TextBoxWatermarkBehavior.prototype = {
    initialize : function() {
        /// <summary>
        /// Initialize the behavior
        /// </summary>
        AjaxControlToolkit.TextBoxWatermarkBehavior.callBaseMethod(this, 'initialize');

        var e = this.get_element();

        // Determine if this textbox is focused initially
        var hasInitialFocus = false;
        
        var clientState = AjaxControlToolkit.TextBoxWatermarkBehavior.callBaseMethod(this, 'get_ClientState');
        if (clientState != null && clientState != "") {
            hasInitialFocus = (clientState == "Focused");
            AjaxControlToolkit.TextBoxWatermarkBehavior.callBaseMethod(this, 'set_ClientState', null);
        }

        // Capture the initial style so we can toggle back and forth
        // between this and the watermarked style
        this._oldClassName = e.className;

        // Create delegates
        this._focusHandler = Function.createDelegate(this, this._onFocus);
        this._blurHandler = Function.createDelegate(this, this._onBlur);
        this._keyPressHandler = Function.createDelegate(this, this._onKeyPress);

        // Attach events
        $addHandler(e, 'focus', this._focusHandler);
        $addHandler(e, 'blur', this._blurHandler);
        $addHandler(e, 'keypress', this._keyPressHandler);

        this.registerPropertyChanged();

        // Initialize state and simulate a blur to apply the watermark if appropriate
        // Note: The comparison against _watermarkText is undesirable, but seemingly
        // necessary to support the load->Home->Back scenario in IE
        var currentValue = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element()).get_Current();
        var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element());
        if (("" == currentValue) || (this._watermarkText == currentValue)) {
            wrapper.set_Watermark(this._watermarkText)
            wrapper.set_IsWatermarked(true);
        }
        if (hasInitialFocus) {
            this._onFocus();
        } else {
            e.blur();
            this._onBlur();
        }

        this._clearedForSubmit = false;

        this.registerPartialUpdateEvents();

        this._watermarkChangedHandler = Function.createDelegate(this, this._onWatermarkChanged);
        wrapper.add_WatermarkChanged(this._watermarkChangedHandler);
    },

    dispose : function() {
        /// <summary>
        /// Dispose the behavior
        /// </summary>
        var e = this.get_element();

        if (this._watermarkChangedHandler) {
            AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element()).remove_WatermarkChanged(this._watermarkChangedHandler);
            this._watermarkChangedHandler = null;
        }

        // Unhook from Sys.Preview.UI.TextBox if present
        if(e.control && this._propertyChangedHandler) {
            e.control.remove_propertyChanged(this._propertyChangedHandler);
            this._propertyChangedHandler = null;
        }

        // Detach events
        if (this._focusHandler) {
            $removeHandler(e, 'focus', this._focusHandler);
            this._focusHandler = null;
        }
        if (this._blurHandler) {
            $removeHandler(e, 'blur', this._blurHandler);
            this._blurHandler = null;
        }
        if (this._keyPressHandler) {
            $removeHandler(e, 'keypress', this._keyPressHandler);
            this._keyPressHandler = null;
        }

        // Clear watermark text to avoid confusion during Refresh/Back/Forward
        if(AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element()).get_IsWatermarked()) {
            this.clearText(false);
        }

        AjaxControlToolkit.TextBoxWatermarkBehavior.callBaseMethod(this, 'dispose');
    },

    _onWatermarkChanged : function(sender, eventArgs) {
        /// <summary>
        /// Handler invoked when the watermark changes
        /// </summary>
        /// <param name="sender" type="Object" mayBeNull="true"/>
        /// <param name="eventArgs" type="Sys.EventArgs" mayBeNull="true" />
        if (AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element()).get_IsWatermarked()) {
            this._onBlur();
        } else {
            this._onFocus();
        }
    },

    clearText : function(focusing) {
        /// <summary>
        /// Clear the text from the target
        /// </summary>
        /// <param name="focusing" type="Boolean">
        /// Whether or not we are focusing on the textbox
        /// </param>
        var element = this.get_element();
        var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(element);
        wrapper.set_Value("");
        wrapper.set_IsWatermarked(false);
        if(focusing) {
            element.setAttribute("autocomplete","off");  // Avoid NS_ERROR_XPC_JS_THREW_STRING error in Firefox
            element.select();  // This fix displays the blinking cursor in a focused, empty text box in IE
        }
    },

    _onFocus : function(evt) {
        /// <summary>
        /// Handler for the textbox's focus event
        /// </summary>
        /// <param name="evt" type="Sys.UI.DomEvent">
        /// Event info
        /// </param>
        
        var e = this.get_element();
        if(AjaxControlToolkit.TextBoxWrapper.get_Wrapper(e).get_IsWatermarked()) {
            // Clear watermark
            this.clearText(evt ? true : false);
        }
        e.className = this._oldClassName;
        
        // Restore the MaxLength on the TextBox when we edit
        // the non-watermarked text
        if (this._maxLength > 0) {
            this.get_element().maxLength = this._maxLength;
            this._maxLength = null;
        }
    },

    _onBlur : function() {
        /// <summary>
        /// Handle the textbox's blur event
        /// </summary>
        var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element());
        if(("" == wrapper.get_Current()) || wrapper.get_IsWatermarked()) {
            // Enlarge the TextBox's MaxLength if it's not big enough
            // to accomodate the watermark
            if (this.get_element().maxLength > 0 && this._watermarkText.length > this.get_element().maxLength) {
                this._maxLength = this.get_element().maxLength;
                this.get_element().maxLength = this._watermarkText.length;
            }
            
            this._applyWatermark();
        }
    },

    _applyWatermark : function() {
        /// <summary>
        /// Apply the watermark to the textbox
        /// </summary>
        var wrapper = AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element());
        wrapper.set_Watermark(this._watermarkText);
        wrapper.set_IsWatermarked(true);
        if(this._watermarkCssClass) {
            this.get_element().className = this._watermarkCssClass;
        }
    },

    _onKeyPress : function() {
        /// <summary>
        /// Handle the textbox's keypress event
        /// </summary>
        AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element()).set_IsWatermarked(false);
    },

    registerPropertyChanged : function() {
        /// <summary>
        /// Method called to hook up to Sys.Preview.UI.TextBox if present
        /// Note: This method must be called manually if the Sys.Preview.UI.TextBox
        ///       is added after the TextBoxWatermarkBehavior is initialized.
        /// </summary>

        var e = this.get_element();
        if(e.control && !this._propertyChangedHandler) {
            this._propertyChangedHandler = Function.createDelegate(this, this._onPropertyChanged);
            e.control.add_propertyChanged(this._propertyChangedHandler);
        }
    },

    _onPropertyChanged : function(sender, propertyChangedEventArgs) {
        /// <summary>
        /// Handler called automatically when a property change event is fired
        /// </summary>
        /// <param name="sender" type="Object">
        /// Sender
        /// </param>
        /// <param name="propertyChangedEventArgs" type="Sys.PropertyChangedEventArgs">
        /// Event arguments
        /// </param>
        if("text" == propertyChangedEventArgs.get_propertyName()) {
            this.set_Value(AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element()).get_Current());
        }
    },

    _onSubmit : function() {
        /// <summary>
        /// Handler Called automatically when a submit happens to clear the watermark before posting back
        /// </summary>
        if(AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element()).get_IsWatermarked()) {
            // Clear watermark text before page is submitted
            this.clearText(false);
            this._clearedForSubmit = true;
        }
    },

    _partialUpdateEndRequest : function(sender, endRequestEventArgs) {
        /// <summary>
        /// Handler Called automatically when a partial postback ends
        /// </summary>
        /// <param name="sender" type="Object">
        /// Sender
        /// </param>
        /// <param name="endRequestEventArgs" type="Sys.WebForms.EndRequestEventArgs">
        /// Event arguments
        /// </param>
        AjaxControlToolkit.TextBoxWatermarkBehavior.callBaseMethod(this, '_partialUpdateEndRequest', [sender, endRequestEventArgs]);

        if (this.get_element() && this._clearedForSubmit) {
            // Restore the cleared watermark (useful when the submit was wrapped in an UpdatePanel)
            this.get_element().blur();
            this._onBlur();
            this._clearedForSubmit = false;
        }
    },

    get_WatermarkText : function() {
        /// <value type="String">
        /// The text to show when the control has no value
        /// </value>
        return this._watermarkText;
    },
    set_WatermarkText : function(value) {
        if (this._watermarkText != value) {
            this._watermarkText = value;
            if (AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element()).get_IsWatermarked()) {
                this._applyWatermark();
            }
            this.raisePropertyChanged('WatermarkText');
        }
    },

    get_WatermarkCssClass : function() {
        /// <value type="String">
        /// The CSS class to apply to the TextBox when it has no value (e.g. the watermark text is shown).
        /// </value>
        return this._watermarkCssClass;
    },
    set_WatermarkCssClass : function(value) {
        if (this._watermarkCssClass != value) {
            this._watermarkCssClass = value;
            if (AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element()).get_IsWatermarked()) {
                this._applyWatermark();
            }
            this.raisePropertyChanged('WatermarkCssClass');
        }
    },

    get_Text : function() {
        /// <value type="String">
        /// Wrapper for the textbox's text that will ignore or create the watermark as appropriate
        /// </value>
        return AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element()).get_Value();
    },
    set_Text : function(value) {
        if ("" == value) {
            AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element()).set_Current("");
            this.get_element().blur();
            this._onBlur();  // onBlur needs to see ""
        } else {
            this._onFocus();  // onFocus sets ""
            AjaxControlToolkit.TextBoxWrapper.get_Wrapper(this.get_element()).set_Current(value);
        }
    }
}
AjaxControlToolkit.TextBoxWatermarkBehavior.registerClass('AjaxControlToolkit.TextBoxWatermarkBehavior', AjaxControlToolkit.BehaviorBase);

AjaxControlToolkit.TextBoxWatermarkBehavior.WebForm_OnSubmit = function() {
    /// <summary>
    /// Wraps ASP.NET's WebForm_OnSubmit in order to strip all watermarks prior to submission
    /// </summary>
    /// <returns type="Boolean">
    /// Result of original WebForm_OnSubmit
    /// </returns>
    var result = AjaxControlToolkit.TextBoxWatermarkBehavior._originalWebForm_OnSubmit();
    if (result) {
        var components = Sys.Application.getComponents();
        for(var i = 0 ; i < components.length ; i++) {
            var component = components[i];
            if (AjaxControlToolkit.TextBoxWatermarkBehavior.isInstanceOfType(component)) {
                component._onSubmit();
            }
        }
    }
    return result;
}

//END AjaxControlToolkit.TextboxWatermark.TextboxWatermark.js
if(typeof(Sys)!=='undefined')Sys.Application.notifyScriptLoaded();
(function() {var fn = function() {$get('ctl00_topContent_ToolkitScriptManager1_HiddenField').value += ';;AjaxControlToolkit, Version=1.0.11119.21733, Culture=neutral, PublicKeyToken=28f01b0e84b6d53e:en-US:f3309251-69d6-4c95-9c43-77de984453b0:9ea3f0e2:e2e86ef9:1df13a87:bae32fb7:182913ba:8ccd9c1b';Sys.Application.remove_load(fn);};Sys.Application.add_load(fn);})();