/* START Telerik.Web.UI.Common.Core.js */
// Avoids the background image flickering in IE 6 (http://www.mister-pixel.com/)
try
{
	document.execCommand("BackgroundImageCache", false, true);
}
catch(err) {}

Type.registerNamespace("Telerik.Web.UI");

window.$telerik = window.TelerikCommonScripts = Telerik.Web.CommonScripts = {
	
	_borderStyleNames : ['borderTopStyle','borderRightStyle','borderBottomStyle','borderLeftStyle'],
	_borderWidthNames : ['borderTopWidth', 'borderRightWidth', 'borderBottomWidth', 'borderLeftWidth'],
	_paddingWidthNames : ['paddingTop', 'paddingRight', 'paddingBottom', 'paddingLeft'],
	_marginWidthNames : ['marginTop', 'marginRight', 'marginBottom', 'marginLeft'],
	radControls : [],
	
	registerControl : function (control)
	{
		if (!Array.contains(this.radControls, control))
			Array.add(this.radControls, control);
	},
	
	unregisterControl : function (control)
	{
		Array.remove(this.radControls, control);
	},
	
	repaintChildren : function (parentControl)
	{
		var parentElement = parentControl.get_element();
		
		for (var i = 0, length = this.radControls.length; i < length; i ++)
		{
	        var control = this.radControls[i];
        
		    if (control.repaint && this.isDescendant(parentElement, control.get_element()))
				control.repaint();
		}
	},
	
	_borderThickness : function ()
	{
		$telerik._borderThicknesses = { };

		var div0 = document.createElement('div');
		var div1 = document.createElement('div');

		div0.style.visibility = 'hidden';
		div0.style.position = 'absolute';
		div0.style.fontSize = '1px';
	    
		div1.style.height = '0px';
		div1.style.overflow = 'hidden';
	    
		document.body.appendChild(div0).appendChild(div1);
	                    
		var base = div0.offsetHeight;
		div1.style.borderTop = 'solid black';        

		div1.style.borderTopWidth = 'thin';
		$telerik._borderThicknesses['thin'] = div0.offsetHeight - base;
	    
		div1.style.borderTopWidth = 'medium';
		$telerik._borderThicknesses['medium'] = div0.offsetHeight - base;
	    
		div1.style.borderTopWidth = 'thick';
		$telerik._borderThicknesses['thick'] = div0.offsetHeight - base;
	    
		if (typeof(div0.removeChild) !== "undefined")
			div0.removeChild(div1);
			
		document.body.removeChild(div0);
		div0 = null;
		div1 = null;
	},
	
	getCurrentStyle : function(element, attribute, defaultValue) {
     
        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) {
        if (!element) return '#FFFFFF';
        var background = $telerik.getCurrentStyle(element, 'backgroundColor');
        try {
            while (!background || background == '' || background == 'transparent' || background == 'rgba(0, 0, 0, 0)') {
                element = element.parentNode;
                if (!element) {
                    background = '#FFFFFF';
                } else {
                    background = $telerik.getCurrentStyle(element, 'backgroundColor');
                }
            }
        } catch(ex) {
            background = '#FFFFFF';
        }
        return background;
    },
    
	getLocation : function(element) {

		// 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)
		
		//TEKI: When in IE7 in a scenario when item is in a FRAMESET, the location value is wrong. However, using the IE6 code below it works fine
		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;
			
			var position = new Sys.UI.Point(first.left - 2 - dLeft + ownerDocument.scrollLeft, first.top - 2 - dTop + ownerDocument.scrollTop);

			if ($telerik.quirksMode)
			{						
				position.x += document.body.scrollLeft;
				position.y += document.body.scrollTop;
			}
			
			return position;
		}

		var position = Sys.UI.DomElement.getLocation(element);
		
		if ($telerik.isOpera)
		{
			var parent = element.offsetParent;
			
			while (parent && parent.tagName.toUpperCase() != 'BODY' 
				&& parent.tagName.toUpperCase() != 'HTML') 
			{
				position.x -= parent.scrollLeft;
				position.y -= parent.scrollTop;
				parent = parent.offsetParent;
			}
		}
		
		if ($telerik.isSafari)
		{
			var parent = element.parentNode;
			
			var parentTD = null;
			var parentTABLE = null;
			
			while (parent && parent.tagName.toUpperCase() != 'BODY' 
				&& parent.tagName.toUpperCase() != 'HTML') 
			{
				position.x -= parent.scrollLeft;
				position.y -= parent.scrollTop;
				
				// Workaround for a problem with parent TABLES - when you have a parent TABLE element with border,
				// Safari acts as if the TABLE/TD has no border and calculates X and Y incorrectly. 
				// That is why we need to add the borders manually. In case this is fixed in a future verion of the browser
				// we will need to remove this code.
				if($telerik.isSafari3 || $telerik.isSafari2)
				{
				    if(parent.tagName.toUpperCase() == "TD")
			        {
			            parentTD = parent;
			        }
                    else if(parent.tagName.toUpperCase() == "TABLE")
                    {
                        parentTABLE = parent;
                    }
                    
                    if(parentTD && parentTABLE)
                    {                
                        position.x += parseInt($telerik.getCurrentStyle(parentTABLE, 'borderTopWidth'));
                        position.y += parseInt($telerik.getCurrentStyle(parentTABLE, 'borderLeftWidth'));
                            
                        // In case the TABLE has borderCollapse:collapse, we need to take the borderWidth of either
                        // the TABLE or the TD.
                        if($telerik.getCurrentStyle(parentTABLE, 'borderCollapse') != 'collapse')
                        {
                            position.x += parseInt($telerik.getCurrentStyle(parentTD, 'borderTopWidth'));
                            position.y += parseInt($telerik.getCurrentStyle(parentTD, 'borderLeftWidth'));
                        }
                        
                        parentTD = null;
                        parentTABLE = null;
                    }
                    // In case we use getLocation for a TD element, we need to calculate the borderWidth of its TABLE
                    // only in case that TABLE has no borderCollapse:collapse.
                    else if(parentTABLE)
                    {
                        if($telerik.getCurrentStyle(parentTABLE, 'borderCollapse') != 'collapse')
                        {
                            position.x += parseInt($telerik.getCurrentStyle(parentTABLE, 'borderTopWidth'));
                            position.y += parseInt($telerik.getCurrentStyle(parentTABLE, 'borderLeftWidth'));
                        }
                        parentTABLE = null;
                    }
                }
                
                // END of Workaround for a problem with parent TABLES
				
				parent = parent.parentNode;
			}			
		}

		if ($telerik.isIE && $telerik.quirksMode)
		{
			position.x += document.body.scrollLeft;
			position.y += document.body.scrollTop;
		}

		return position;
	},

    setLocation : function(element, point) {
        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 = $telerik.getSize(element);
        var borderBox = $telerik.getBorderBox(element);
        var paddingBox = $telerik.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($telerik.getCurrentStyle(element, 'MozBoxSizing') == 'border-box' || $telerik.getCurrentStyle(element, 'BoxSizing') == 'border-box') {
            var borderBox = $telerik.getBorderBox(element);
            var paddingBox = $telerik.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 = $telerik.getBorderBox(element);
        var paddingBox = $telerik.getPaddingBox(element);
        var contentSize = {
            width:  size.width - borderBox.horizontal - paddingBox.horizontal,
            height: size.height - borderBox.vertical - paddingBox.vertical
        };
        $telerik.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>

        var offset = $telerik.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');
        }
        $telerik.setSize(element, bounds);
        $telerik.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;
                if (clientWidth == 0 && clientHeight == 0)
                {
                    //no doctype. use the body settings
                    clientWidth = document.body.clientWidth;
                    clientHeight = document.body.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: $telerik.getMargin(element, Telerik.Web.BoxSide.Top),
            right: $telerik.getMargin(element, Telerik.Web.BoxSide.Right),
            bottom: $telerik.getMargin(element, Telerik.Web.BoxSide.Bottom),
            left: $telerik.getMargin(element, Telerik.Web.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: $telerik.getPadding(element, Telerik.Web.BoxSide.Top),
            right: $telerik.getPadding(element, Telerik.Web.BoxSide.Right),
            bottom: $telerik.getPadding(element, Telerik.Web.BoxSide.Bottom),
            left: $telerik.getPadding(element, Telerik.Web.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: $telerik.getBorderWidth(element, Telerik.Web.BoxSide.Top),
            right: $telerik.getBorderWidth(element, Telerik.Web.BoxSide.Right),
            bottom: $telerik.getBorderWidth(element, Telerik.Web.BoxSide.Bottom),
            left: $telerik.getBorderWidth(element, Telerik.Web.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="Telerik.Web.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 < Telerik.Web.BoxSide.Top || boxSide > Telerik.Web.BoxSide.Left) {
            throw Error.argumentOutOfRange(String.format(Sys.Res.enumInvalidValue, boxSide, 'Telerik.Web.BoxSide'));
        }
        var styleName = $telerik._borderStyleNames[boxSide];
        var styleValue = $telerik.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="Telerik.Web.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 < Telerik.Web.BoxSide.Top || boxSide > Telerik.Web.BoxSide.Left) {
            throw Error.argumentOutOfRange(String.format(Sys.Res.enumInvalidValue, boxSide, 'Telerik.Web.BoxSide'));
        }
        var styleName = $telerik._marginWidthNames[boxSide];
        var styleValue = $telerik.getCurrentStyle(element, styleName);

        try { return $telerik.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="Telerik.Web.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 < Telerik.Web.BoxSide.Top || boxSide > Telerik.Web.BoxSide.Left) {
            throw Error.argumentOutOfRange(String.format(Sys.Res.enumInvalidValue, boxSide, 'Telerik.Web.BoxSide'));
        }
        if(!$telerik.isBorderVisible(element, boxSide)) {
            return 0;
        }        
        var styleName = $telerik._borderWidthNames[boxSide];    
        var styleValue = $telerik.getCurrentStyle(element, styleName);
        return $telerik.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="Telerik.Web.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 < Telerik.Web.BoxSide.Top || boxSide > Telerik.Web.BoxSide.Left) {
            throw Error.argumentOutOfRange(String.format(Sys.Res.enumInvalidValue, boxSide, 'Telerik.Web.BoxSide'));
        }
        var styleName = $telerik._paddingWidthNames[boxSide];
        var styleValue = $telerik.getCurrentStyle(element, styleName);
        return $telerik.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(borderWidth) {
            switch(borderWidth) {
                case 'thin':
                case 'medium':
                case 'thick':
                    return $telerik._borderThicknesses[borderWidth];
                case 'inherit':
                    return 0;
            }
            var unit = $telerik.parseUnit(borderWidth);
            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 = $telerik.parseUnit(padding);
            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('No digits');
        }
        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
        };
    },
    
    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>
        
        //ORIGINAL TOOLKIT SCRIPT CHANGE: instead of rect.height it was written rect.width (!!!) Clearly a major bug!!!!
        return x >= rect.x && x <= (rect.x + rect.width) && y >= rect.y && y <= (rect.y + rect.height);
    },

    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 $telerik.isDescendant(ancestor, descendant);
    },
    
	setOuterHeight : function (element, height)
	{
		if (height <= 0 || height == "") 
		{
			element.style.height = "";
		} 
		else
		{
			element.style.height = height + "px";
			var diff = element.offsetHeight - height;
			var newHeight = height - diff;
			if (newHeight > 0) {
				element.style.height = newHeight + "px";
			} else {
				element.style.height = "";
			}
		}
	},
	
    setOpacity : 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');
        }
        try
        {
            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;
            }
        }
        catch (ex) {}
    },
    	
    getOpacity : 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;
        
        try
        {
            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 = $telerik.getCurrentStyle(element, 'opacity', 1);
                hasOpacity = true;
            }
        }
        catch (ex) {}
        
        if (hasOpacity === false) {
            return 1.0;
        }
        return parseFloat(opacity);
    },

    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]);
        }
    },    	
	setOuterWidth : function (element, width)
	{
		if (width <= 0 || width == "") 
		{
			element.style.width = "";
		}
		else
		{
			element.style.width = width + "px";
			var diff = element.offsetWidth - width;
			var newWidth = width - diff;
			if (newWidth > 0) {
				element.style.width = newWidth + "px";
			} else {
				element.style.width = "";
			}
		}
	},
	
	getScrollOffset : function(element, recursive)
	{
		var left = 0;
		var top = 0;
		var parent = element;

		while (parent != null && parent.scrollLeft != null) {
			left += parent.scrollLeft;
			top += parent.scrollTop;
			// Don't include anything below the body. 
			if (!recursive || (parent == document.body && (parent.scrollLeft != 0 || parent.scrollTop != 0)))
				break;

			parent = parent.parentNode;
		}

		return { x: left, y: top };
	},
	
	getElementByClassName : function(element, className, tagName)
	{
		var children = null;
		if (tagName)
		{
			children = element.getElementsByTagName(tagName);
		}
		else
		{
			children = element.getElementsByTagName("*");
		}
	    
		for (var i = 0, length = children.length; i < length; i++)
		{
			var child = children[i];
	        
			if (Sys.UI.DomElement.containsCssClass(child, className))
			{
				return child;
			}
		}
	    
		return null;
	},
	
	//The $addHandler and $removeHandler only work with DOM HTML elements.
	//In products that use iframes (RadWindow, RadEditor, EditorPopup) events need to be attached to the iframes' document and/or contentWindow.
	//In addition to this to construct an event object, the MS AJAX framework attempts to use the window.event - which is null in the main page, when the event originates from a child frame
	//Thus, the need to provide an alternative to the MS AJAX framework arises
	addExternalHandler : function(element, eventName, handler)
	{        	
		if (element.addEventListener)
		{
			element.addEventListener(eventName, handler, false);
		}
		else if (element.attachEvent)
		{	
			element.attachEvent("on" + eventName, handler);
		}
	},
	removeExternalHandler : function(element, eventName, handler)
	{    	
		if (element.addEventListener)
		{
			element.removeEventListener(eventName, handler, false);
		}
		else if (element.detachEvent)
		{
			element.detachEvent("on" + eventName, handler);
		}
	},
	
	cancelRawEvent : function(e)
	{    	
		if (!e) return false;
		if (e.preventDefault) e.preventDefault();
		if (e.stopPropagation) e.stopPropagation();
		e.cancelBubble = true;
		e.returnValue = false;	
		return false;
	},
	
	getOuterHtml : function(element)
	{
		if (element.outerHTML)
		{
			return element.outerHTML;
		}
		else
		{
			var elementCopy = element.cloneNode(true);
			var tmpDiv = element.ownerDocument.createElement("DIV");
			tmpDiv.appendChild(elementCopy);
			return tmpDiv.innerHTML;		
		}
	},
	
	setVisible : function(e, value) 
	{
		if (!e) return;

		if (value != $telerik.getVisible(e)) {
	        
			if (value) {
				if (e.style.removeAttribute) {
					e.style.removeAttribute("display");
				} else {
				   e.style.removeProperty("display");
				}
			}
			else {
				e.style.display = 'none';
			}
	        
			e.style.visibility = value ? 'visible' : 'hidden';
		}
	},
	
	getVisible : function(e) 
	{
		if (!e) return false;

		return (("none" != $telerik.getCurrentStyle(e, "display")) &&
        ("hidden" != $telerik.getCurrentStyle(e, "visibility")));
	},
	
	getViewPortSize : function()
	{
		var width = 0;
		var height = 0;

		var canvas = document.body;

		if (!$telerik.quirksMode && !$telerik.isSafari)
		{
			canvas = document.documentElement;
		}

		if (window.innerWidth)
		{
			width = window.innerWidth;
			height = window.innerHeight;
		}
		else
		{
			width = canvas.clientWidth;
			height = canvas.clientHeight;
		}

		width += canvas.scrollLeft;
		height += canvas.scrollTop;

		return { width : width - 6, height : height - 6 };
	},
	
	elementOverflowsTop : function (element)
	{
		return $telerik.getLocation(element).y < 0;
	}, 

	elementOverflowsLeft : function (element)
	{
		return $telerik.getLocation(element).x < 0;
	},

	elementOverflowsBottom : function (screenSize, element)
	{
		var bottomEdge = $telerik.getLocation(element).y + element.offsetHeight;
		return bottomEdge > screenSize.height;
	},

	elementOverflowsRight : function (screenSize, element)
	{
		var rightEdge = $telerik.getLocation(element).x + element.offsetWidth;
		return rightEdge > screenSize.width;
	},

	getDocumentRelativeCursorPosition : function(e)
	{
		var scrollLeft = document.documentElement.scrollLeft || document.body.scrollLeft;
		var scrollTop = document.documentElement.scrollTop || document.body.scrollTop;
		var left = e.clientX + scrollLeft;
		var top = e.clientY + scrollTop;
		return {left:left, top:top};
	},
	
//	//Lini: this code is not needed anymore. It will be removed for the Q1 2008 release.
//	makeCompatible : function(type)
//	{
//		/// <exclude />
//		/// <summary>
//		///		Doubles the get_propertyName, set_propertyName, add_event, remove_event
//		///		methods with get_PropertyName, set_PropertyName, etc. ones, to save troubles for
//		///		users already having client-side code with the mistaken client-side convention.
//		///
//		///     Doubles the methodName(...) with MethodName(...) member to save troubles for
//	    ///		users already having client-side code with the mistaken client-side convention.
//		/// </summary>

//		var proto = type.prototype;
//		for (var memberName in proto)
//		{
//			if (/([gs]et|add|remove|raise)_[a-z].*/.test(memberName))
//			{
//				var propNameStart = RegExp.$1.length + 1;
//				var oldPropName = memberName.substr(0, propNameStart) + memberName.charAt(propNameStart).toUpperCase() + memberName.substr(propNameStart + 1);
//				proto[oldPropName] = proto[memberName];
//			}
//			else if (/^[a-z][a-zA-Z]+$/.test(memberName) && 
//		             proto.hasOwnProperty(memberName) &&
//		             typeof(proto[memberName]) == "function" && 
//		             memberName != "initialize" &&
//		             memberName != "dispose")
//		    {
//		        var oldMethodName = memberName.charAt(0).toUpperCase() + memberName.substr(1);
//		        proto[oldMethodName] = proto[memberName];		    
//		    }
//		}
//	},
	
	getFirstChildByTagName : function (element, tagName, index)
	{
		if (!element || !element.childNodes)
		{
			return null;
		}
		
		var currentNode = element.childNodes[index] || element.firstChild;
		
		while (currentNode)
		{
			if (currentNode.nodeType == 1 && currentNode.tagName.toLowerCase() == tagName)
				return currentNode;
			
			currentNode = currentNode.nextSibling;
		}
	
		return null;
	},

	getChildByClassName : function(element, className, index)
	{
		var currentNode = element.childNodes[index] || element.firstChild;
		while (currentNode)
		{
			if (currentNode.nodeType == 1 && currentNode.className.indexOf(className) > -1)
				return currentNode;
			currentNode = currentNode.nextSibling;
		}
		return null;
	},

	getChildrenByTagName : function (element, tagName)
	{
		var children = new Array();
		var childNodes = element.childNodes;
		for (var i = 0, length = childNodes.length; i < length; i++)
		{
			var child = childNodes[i];
			if (child.nodeType == 1 && child.tagName.toLowerCase() == tagName)
				Array.add(children, child);
		}
		return children;
	},
	
	getChildrenByClassName : function (element, className)
	{
		var children = new Array();
		var childNodes = element.childNodes;
		for (var i = 0, length = childNodes.length; i < length; i++)
		{
			var child = childNodes[i];
			if (child.nodeType == 1 && child.className.indexOf(className) > -1)
				Array.add(children, child);
		}
		return children;
	}
}

$telerik.isIE = Sys.Browser.agent == Sys.Browser.InternetExplorer;
$telerik.isIE7 = $telerik.isIE && Sys.Browser.version == 7;
$telerik.isIE6 = $telerik.isIE && Sys.Browser.version < 7;
$telerik.isOpera = Sys.Browser.agent == Sys.Browser.Opera;
$telerik.isSafari = Sys.Browser.agent == Sys.Browser.Safari;
$telerik.isSafari3 = $telerik.isSafari && Sys.Browser.version > 500;
$telerik.isSafari2 = $telerik.isSafari && Sys.Browser.version <= 500;
$telerik.isFirefox = Sys.Browser.agent == Sys.Browser.Firefox;
$telerik.quirksMode = $telerik.isIE && document.compatMode != "CSS1Compat";
$telerik.standardsMode = !$telerik.quirksMode;

//Initialize the thickness of borders based on their style
$telerik._borderThickness();

Telerik.Web.UI.Orientation = function() {
    /// <summary>
    /// The Telerik.Web.UI.Orientation enumeration is used to specify 
    /// the orientation of a given asset
    /// </summary>
    /// <field name="Horizontal" type="Number" integer="true"/>
    /// <field name="Vertical" type="Number" integer="true"/>
    throw Error.invalidOperation();
}
Telerik.Web.UI.Orientation.prototype = {
    Horizontal : 0,
    Vertical : 1
} 
Telerik.Web.UI.Orientation.registerEnum('Telerik.Web.UI.Orientation', false);

Telerik.Web.UI.RadWebControl = function(element) 
{
    Telerik.Web.UI.RadWebControl.initializeBase(this, [element]);
    
    this._clientStateFieldID = null;
}

Telerik.Web.UI.RadWebControl.prototype = 
{
    initialize: function() 
    {
        Telerik.Web.UI.RadWebControl.callBaseMethod(this, 'initialize');
        
        $telerik.registerControl(this);
        
        if(!this.get_clientStateFieldID()) return;
        
        var input = $get(this.get_clientStateFieldID());    
        
        if(!input) return;
        
        input.setAttribute('autocomplete', 'off');
    },
    
    dispose: function() 
    {
        $telerik.unregisterControl(this);
        
        Telerik.Web.UI.RadWebControl.callBaseMethod(this, 'dispose');
    },
    
    raiseEvent : function(eventName, eventArgs) {
        /// <summary>
        /// Raise the event
        /// </summary>
        /// <param name="eventName" type="String" mayBeNull="false">
        /// Name of the event to be raised
        /// </param>
        /// <param name="eventArgs" type="Sys.EventArgs" mayBeNull="true">
        /// Event arguments for the given event
        /// </param>
        /// <returns />

		var handler = this.get_events().getHandler(eventName);
		if (handler) {
			if (!eventArgs) {
				eventArgs = Sys.EventArgs.Empty;
			}
			handler(this, eventArgs);
        }
    },
    
    updateClientState: function()
    {
        /// <summary>
        /// Call this function to update the client state hidden field.
        /// Use this function with caution, because it is resource hungry.
        /// </summary>
		this.set_clientState(this.saveClientState());
    },
    
    saveClientState: function()
    {
        /// <summary>
        /// This function should return the serialized client state of the control.
        /// </summary>
        /// <example>
		/// saveClientState: function()
		/// {
		///		var state = 
		///		{
		///			Collapsed	: this.get_collapsed(),
		///			Width		: this.get_width(),
		///			Height		: this.get_height()
		///		};
		///		return Sys.Serialization.JavaScriptSerializer.serialize(state);
		/// }
        /// </example>
         return null;
    },
    
    get_clientStateFieldID : function() 
    {
        /// <value type="String">
        /// ID of the hidden field used to store the 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;
            }
        }
    },
    
    _getChildElement : function(id)
	{
		return $get(this.get_id() + "_" + id);
	},
	
	_findChildControl : function(id)
	{
		return $find(this.get_id() + "_" + id);
	}
}

Telerik.Web.UI.RadWebControl.registerClass('Telerik.Web.UI.RadWebControl', Sys.UI.Control);

Telerik.Web.Timer = function() {
    Telerik.Web.Timer.initializeBase(this);
    
    this._interval = 1000;
    this._enabled = false;
    this._timer = null;
    
    this._timerCallbackDelegate = Function.createDelegate(this, this._timerCallback);
}

Telerik.Web.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();
        
        Telerik.Web.Timer.callBaseMethod(this, 'dispose');
    },
    
    updated: function() {
        Telerik.Web.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(this._timerCallbackDelegate, this._interval);
    },

    _stopTimer: function() {
        window.clearInterval(this._timer);
        this._timer = null;
    }
}

Telerik.Web.Timer.registerClass('Telerik.Web.Timer', Sys.Component);

Telerik.Web.BoxSide = function() {
}
Telerik.Web.BoxSide.prototype = {
    Top : 0,
    Right : 1,
    Bottom : 2,
    Left : 3
}
Telerik.Web.BoxSide.registerEnum("Telerik.Web.BoxSide", false);

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;
    }
}

Type.registerNamespace("Telerik.Web.UI.Dialogs");

Telerik.Web.IParameterConsumer = function() {
}
Telerik.Web.IParameterConsumer.prototype = {
    clientInit: function(parameters) { throw Error.notImplemented(); }
}
Telerik.Web.IParameterConsumer.registerInterface('Telerik.Web.IParameterConsumer');

Telerik.Web.UI.Dialogs.CommonDialogScript = function()
{
}
Telerik.Web.UI.Dialogs.CommonDialogScript.get_windowReference = function()
{
	if (window.radWindow)
	{
		return window.radWindow;
	}
	if (window.frameElement && window.frameElement.radWindow)
	{
		return window.frameElement.radWindow;
	}
	return null;
};

Telerik.Web.UI.Dialogs.CommonDialogScript.registerClass('Telerik.Web.UI.Dialogs.CommonDialogScript', null);

Telerik.Web.UI.WebServiceLoaderEventArgs = function(context)
{
	Telerik.Web.UI.WebServiceLoaderEventArgs.initializeBase(this);
	this._context = context;
}

Telerik.Web.UI.WebServiceLoaderEventArgs.prototype =
{
	get_context : function ()
	{
		return this._context;
	}
}

Telerik.Web.UI.WebServiceLoaderEventArgs.registerClass('Telerik.Web.UI.WebServiceLoaderEventArgs', Sys.EventArgs);


// ---------- WebServiceLoaderSuccessEventArgs Class ----------
Telerik.Web.UI.WebServiceLoaderSuccessEventArgs = function(data, context)
{
	Telerik.Web.UI.WebServiceLoaderSuccessEventArgs.initializeBase(this, [context]);
	this._data = data;
}

Telerik.Web.UI.WebServiceLoaderSuccessEventArgs.prototype =
{
	get_data : function ()
	{
		return this._data;
	}	
}

Telerik.Web.UI.WebServiceLoaderSuccessEventArgs.registerClass('Telerik.Web.UI.WebServiceLoaderSuccessEventArgs', Telerik.Web.UI.WebServiceLoaderEventArgs);


// ---------- WebServiceLoaderErrorEventArgs Class ----------
Telerik.Web.UI.WebServiceLoaderErrorEventArgs = function(message, context)
{
	Telerik.Web.UI.WebServiceLoaderErrorEventArgs.initializeBase(this, [context]);
	this._message = message;
}

Telerik.Web.UI.WebServiceLoaderErrorEventArgs.prototype =
{
	get_message : function ()
	{
		return this._message;
	}
}

Telerik.Web.UI.WebServiceLoaderErrorEventArgs.registerClass('Telerik.Web.UI.WebServiceLoaderErrorEventArgs', Telerik.Web.UI.WebServiceLoaderEventArgs);


// ---------- WebServiceLoader Class ----------
Telerik.Web.UI.WebServiceLoader = function(webServiceSettings)
{
	this._webServiceSettings = webServiceSettings;
	this._events = null;
	this._currentWebRequest = null;
	this._onWebServiceSuccessDelegate = Function.createDelegate(this, this._onWebServiceSuccess);
	this._onWebServiceErrorDelegate = Function.createDelegate(this, this._onWebServiceError);
}

Telerik.Web.UI.WebServiceLoader.prototype =
{
	// Public properties
	get_webServiceSettings : function ()
	{
		return this._webServiceSettings;
	},
	
	get_events: function ()
	{
		if (!this._events)
		{
			this._events = new Sys.EventHandlerList();
		}
		
		return this._events;
	},
	
	
	// Public methods
	loadData : function (params, context)
	{
		var webServiceSettings = this.get_webServiceSettings();
		
		if (webServiceSettings.get_isEmpty())
		{
			Error.invalidOperation("Please, specify valid web service and method.");
			return;
		}

		var webServicePath = webServiceSettings.get_path();
		var webMethod = webServiceSettings.get_method();
		
		this._raiseEvent("loadingStarted", new Telerik.Web.UI.WebServiceLoaderEventArgs(context));

		this._currentWebRequest =	Sys.Net.WebServiceProxy.invoke(webServicePath, webMethod, false, params,
										this._onWebServiceSuccessDelegate, this._onWebServiceErrorDelegate, context);
	},
	
	
	// Events
	add_loadingStarted : function(handler)
	{
		this.get_events().addHandler("loadingStarted", handler);
	},

	add_loadingError : function(handler)
	{
		this.get_events().addHandler("loadingError", handler);
	},

	add_loadingSuccess : function(handler)
	{
		this.get_events().addHandler("loadingSuccess", handler);
	},
	
	
	// Private methods	
	_onWebServiceSuccess : function (data, context)
	{
		var successEventArgs = new Telerik.Web.UI.WebServiceLoaderSuccessEventArgs(data, context);
		this._raiseEvent("loadingSuccess", successEventArgs);
	},
	
	_onWebServiceError : function (error, context)
	{	
		var errorEventArgs = new Telerik.Web.UI.WebServiceLoaderErrorEventArgs(error.get_message(), context);
		this._raiseEvent("loadingError", errorEventArgs);
	},

	_raiseEvent : function (eventName, eventArgs)
	{
		var handler = this.get_events().getHandler(eventName);        

		if (handler)
		{
			if (!eventArgs)
			{
				eventArgs = Sys.EventArgs.Empty;
			}

			handler(this, eventArgs);
		}
	}
}

Telerik.Web.UI.WebServiceLoader.registerClass('Telerik.Web.UI.WebServiceLoader');

Telerik.Web.UI.WebServiceSettings = function(serializedWebServiceSettings)
{
	this._path = null;
	this._method = null;
	
	//Add a check for the parameter existance
	if (!serializedWebServiceSettings) serializedWebServiceSettings = {};
	
	if (typeof(serializedWebServiceSettings.path) != "undefined")
	{
		this._path = serializedWebServiceSettings.path;
	}
	
	if (typeof(serializedWebServiceSettings.method) != "undefined")
	{
		this._method = serializedWebServiceSettings.method;
	}
}

Telerik.Web.UI.WebServiceSettings.prototype =
{
	get_path : function ()
	{
		return this._path;
	},
	
	set_path : function(value)
	{
		this._path = value;
	},

	get_method : function ()
	{
		return this._method;
	},
	
	set_method : function(value)
	{
		this._method = value;
	},
	
	get_isEmpty : function ()
	{
		/// <value type="Boolean">
		///		A value indicating wether the web service settings contain
		///		a non-null and non-empty service path and method.
		/// </value>
		var path = this.get_path();
		var method = this.get_method();
		
		return (!(path && method))
	}
}

Telerik.Web.UI.WebServiceSettings.registerClass('Telerik.Web.UI.WebServiceSettings');

/* END Telerik.Web.UI.Common.Core.js */
/* START Telerik.Web.UI.Input.RadInputEventArgs.js */

Type.registerNamespace("Telerik.Web.UI");

Telerik.Web.UI.InputValueChangedEventArgs = function(newValue, oldValue) 
{
	Telerik.Web.UI.InputValueChangedEventArgs.initializeBase(this);
	this._newValue = newValue;
	this._oldValue = oldValue;
}

Telerik.Web.UI.InputValueChangedEventArgs.prototype = 
{
	get_oldValue : function ()
	{
		return this._oldValue;
	},
	
	get_newValue : function ()
	{
		return this._newValue;
	}
}

//$telerik.makeCompatible(Telerik.Web.UI.InputValueChangedEventArgs);
Telerik.Web.UI.InputValueChangedEventArgs.registerClass('Telerik.Web.UI.InputValueChangedEventArgs', Sys.CancelEventArgs);

Telerik.Web.UI.InputValueChangingEventArgs = function(newValue, oldValue) 
{
	Telerik.Web.UI.InputValueChangingEventArgs.initializeBase(this, [newValue, oldValue]);
}

Telerik.Web.UI.InputValueChangingEventArgs.prototype = 
{
    set_newValue : function(value) 
    {
        if (this._newValue !== value) {
            this._newValue = value;
        }
    }	
}

//$telerik.makeCompatible(Telerik.Web.UI.InputValueChangingEventArgs);
Telerik.Web.UI.InputValueChangingEventArgs.registerClass('Telerik.Web.UI.InputValueChangingEventArgs', Telerik.Web.UI.InputValueChangedEventArgs);

Telerik.Web.UI.MaskedTextBoxEventArgs = function(newValue, oldValue, chunk)
{
    Telerik.Web.UI.MaskedTextBoxEventArgs.initializeBase(this);
   
    this._newValue = newValue;
	this._oldValue = oldValue;
    this._chunk = chunk;
}

Telerik.Web.UI.MaskedTextBoxEventArgs.prototype = 
{
	get_oldValue : function ()
	{
		return this._oldValue;
	},
	
	get_newValue : function ()
	{
		return this._newValue;
	},
	
    get_currentPart : function()
    {
        return this._chunk;
    }
}

//$telerik.makeCompatible(Telerik.Web.UI.MaskedTextBoxEventArgs);
Telerik.Web.UI.MaskedTextBoxEventArgs.registerClass("Telerik.Web.UI.MaskedTextBoxEventArgs", Sys.CancelEventArgs);

Telerik.Web.UI.InputKeyPressEventArgs = function(domEvent, keyCode, keyCharacter) 
{
	Telerik.Web.UI.InputKeyPressEventArgs.initializeBase(this);

	this._domEvent = domEvent;
	this._keyCode = keyCode;
	this._keyCharacter = keyCharacter;
}

Telerik.Web.UI.InputKeyPressEventArgs.prototype = 
{
	get_domEvent : function ()
	{
		return this._domEvent;
	},
	get_keyCode : function ()
	{
		return this._keyCode;
	},
    get_keyCharacter : function ()
	{
		return this._keyCharacter;
	}
}

//$telerik.makeCompatible(Telerik.Web.UI.InputKeyPressEventArgs);
Telerik.Web.UI.InputKeyPressEventArgs.registerClass('Telerik.Web.UI.InputKeyPressEventArgs', Sys.CancelEventArgs);

Telerik.Web.UI.InputButtonClickEventArgs = function(buttonType) 
{
	Telerik.Web.UI.InputButtonClickEventArgs.initializeBase(this);

	this._buttonType = buttonType;
}

Telerik.Web.UI.InputButtonClickEventArgs.prototype = 
{
	get_buttonType : function ()
	{
		return this._buttonType;
	}
}

//$telerik.makeCompatible(Telerik.Web.UI.InputButtonClickEventArgs);
Telerik.Web.UI.InputButtonClickEventArgs.registerClass('Telerik.Web.UI.InputButtonClickEventArgs', Sys.CancelEventArgs);

Telerik.Web.UI.InputErrorEventArgs = function(reason, inputText)
{
    Telerik.Web.UI.InputErrorEventArgs.initializeBase(this);
    
    this._reason = reason;
	this._inputText = inputText;
}

Telerik.Web.UI.InputErrorEventArgs.prototype = 
{
    get_reason : function ()
	{
		return this._reason;
	},
    get_inputText : function ()
	{
		return this._inputText;
	}
}

//$telerik.makeCompatible(Telerik.Web.UI.InputErrorEventArgs);
Telerik.Web.UI.InputErrorEventArgs.registerClass("Telerik.Web.UI.InputErrorEventArgs", Sys.CancelEventArgs);

Telerik.Web.UI.NumericInputErrorEventArgs = function(reason, inputText, keyCode, keyCharacter) 
{
	Telerik.Web.UI.NumericInputErrorEventArgs.initializeBase(this);
	
	this._keyCode = keyCode;
	this._keyCharacter = keyCharacter;
}

Telerik.Web.UI.NumericInputErrorEventArgs.prototype = 
{
    get_reason : function ()
	{
		return this._reason;
	},
    get_inputText : function ()
	{
		return this._inputText;
	},
    get_keyCode : function ()
	{
		return this._keyCode;
	},
    get_keyCharacter : function ()
	{
		return this._keyCharacter;
	}
}

//$telerik.makeCompatible(Telerik.Web.UI.NumericInputErrorEventArgs);
Telerik.Web.UI.NumericInputErrorEventArgs.registerClass('Telerik.Web.UI.NumericInputErrorEventArgs', Telerik.Web.UI.InputErrorEventArgs);
/* END Telerik.Web.UI.Input.RadInputEventArgs.js */
/* START Telerik.Web.UI.Input.RadInputEnumerations.js */

Type.registerNamespace("Telerik.Web.UI");

Telerik.Web.UI.InputErrorReason = function()
{
};

Telerik.Web.UI.InputErrorReason.prototype = 
{
    ParseError: 1,
    OutOfRange: 2
}

Telerik.Web.UI.InputErrorReason.registerEnum("Telerik.Web.UI.InputErrorReason", false);

Telerik.Web.UI.SelectionOnFocus = function()
{
};

Telerik.Web.UI.SelectionOnFocus.prototype = 
{
    None : 0,
    CaretToBeginning : 1,
    CaretToEnd : 2,
    SelectAll : 3
}

Telerik.Web.UI.SelectionOnFocus.registerEnum("Telerik.Web.UI.SelectionOnFocus", false);

Telerik.Web.UI.InputButtonType = function()
{
};

Telerik.Web.UI.InputButtonType.prototype = 
{
    Button:         1,
    MoveUpButton:   2,
    MoveDownButton: 3
}

Telerik.Web.UI.InputButtonType.registerEnum("Telerik.Web.UI.InputButtonType", false);

Telerik.Web.UI.DisplayFormatPosition = function()
{
};

Telerik.Web.UI.DisplayFormatPosition.prototype = 
{
    Left: 1,
    Right: 2
}

Telerik.Web.UI.DisplayFormatPosition.registerEnum("Telerik.Web.UI.DisplayFormatPosition", false);
/* END Telerik.Web.UI.Input.RadInputEnumerations.js */
/* START Telerik.Web.UI.Input.RadInputControl.js */
Type.registerNamespace("Telerik.Web.UI");

Telerik.Web.UI.RadInputControl = function(element) 
{
	Telerik.Web.UI.RadInputControl.initializeBase(this, [element]);
	
    this._autoPostBack = false;
    this._enabled = true;
    this._showButton = false;
    this._invalidStyleDuration = 100;
    this._emptyMessage = "";
    this._selectionOnFocus = Telerik.Web.UI.SelectionOnFocus.None;
    this._postBackEventReferenceScript = "";
    this._styles = null; 
    
    
    this._onTextBoxKeyUpDelegate = null;
    this._onTextBoxKeyPressDelegate = null;
    this._onTextBoxBlurDelegate = null;
    this._onTextBoxFocusDelegate = null;
    this._onTextBoxMouseOutDelegate = null;
    this._onTextBoxMouseOverDelegate = null;
    this._onTextBoxKeyDownDelegate = null;
    this._onTextBoxMouseWheelDelegate = null;
    this._onTextBoxDragDropDelegate = null;
}

Telerik.Web.UI.RadInputControl.prototype = 
{
    initialize : function() {
        Telerik.Web.UI.RadInputControl.callBaseMethod(this, 'initialize');        
        this._clientID = this.get_id();        
        this._wrapperElementID = this.get_id() + "_wrapper";        
        this._textBoxElement = $get(this.get_id() + "_text");
        this._originalTextBoxCssText = this._textBoxElement.style.cssText; 
        if(this._originalTextBoxCssText.indexOf(";") != this._originalTextBoxCssText.length - 1)
        {
            this._originalTextBoxCssText += ";" ;
        }
        
        //obsolete fields
        this.ClientID = this._clientID;
        this.WrapperElementID = this._wrapperElementID;
        this.TextBoxElement = this._textBoxElement;
        this.OriginalTextBoxCssText = this._originalTextBoxCssText;
        
        this._updatePercentageHeight();
        this._originalMaxLength = this._textBoxElement.maxLength;
        if (this._originalMaxLength == -1) //not IE browser default value when not set
            this._originalMaxLength = 2147483647;
            
        this._initializeHiddenElement(this.get_id());
        this._initializeValidationField(this.get_id());
        this._selectionEnd = 0;
        this._selectionStart = 0;
        
        // state flags
        this._focused = false;
        this._hovered = false;
        this._invalid = false;
        
        this._attachEventHandlers();
        this.updateDisplayValue();
        this.updateCssClass();       
        this._initializeButtons();
        
        this._initialValue = this.get_value();
        
        //obsolete fields
        this.InitialValue = this._initialValue;
        
        this.raise_load(Sys.EventArgs.Empty);  
    },
    
    dispose : function() 
    {
        Telerik.Web.UI.RadInputControl.callBaseMethod(this, 'dispose');
        
        if (this.Button)
        {
            if (this._onButtonClickDelegate)
            {
                $removeHandler(this.Button, "click", this._onButtonClickDelegate);                                              
                this._onButtonClickDelegate = null;
            }
        }
        if (this._onTextBoxKeyDownDelegate)
        {
            $removeHandler(this._textBoxElement, "keydown", this._onTextBoxKeyDownDelegate);
            this._onTextBoxKeyDownDelegate = null;
        }
        if (this._onTextBoxKeyPressDelegate)
        {
            $removeHandler(this._textBoxElement, "keypress", this._onTextBoxKeyPressDelegate);
            this._onTextBoxKeyPressDelegate = null;
        }
        if (this._onTextBoxKeyUpDelegate)
        {
            $removeHandler(this._textBoxElement, "keyup", this._onTextBoxKeyUpDelegate);    
            this._onTextBoxKeyUpDelegate = null;
        }
        if (this._onTextBoxBlurDelegate)
        {
            $removeHandler(this._textBoxElement, "blur", this._onTextBoxBlurDelegate);
            this._onTextBoxBlurDelegate = null;
        }
        if (this._onTextBoxFocusDelegate)
        {
            $removeHandler(this._textBoxElement, "focus", this._onTextBoxFocusDelegate);
            this._onTextBoxFocusDelegate = null;
        }
        
        if (this._onTextBoxMouseOutDelegate)
        {
            $removeHandler(this._textBoxElement, "mouseout", this._onTextBoxMouseOutDelegate);   
            this._onTextBoxMouseOutDelegate = null;
        }
        if (this._onTextBoxMouseOverDelegate)
        {
            $removeHandler(this._textBoxElement, "mouseover", this._onTextBoxMouseOverDelegate);
            this._onTextBoxMouseOverDelegate = null;
        }
        
        if (Sys.Browser.agent != Sys.Browser.InternetExplorer)
		{
		    //Gecko, Opera?
		    if (this._onTextBoxMouseWheelDelegate)
		    {
		        $removeHandler(this._textBoxElement, "DOMMouseScroll", this._onTextBoxMouseWheelDelegate);
		        this._onTextBoxMouseWheelDelegate = null;
		    }
		    if (this._onTextBoxDragDropDelegate)
		    {
		        $removeHandler(this._textBoxElement, "dragdrop", this._onTextBoxDragDropDelegate);
		        this._onTextBoxDragDropDelegate = null;
		    }
		}
		else
		{
			//IE
			if (this._onTextBoxMouseWheelDelegate)
			{
		        $removeHandler(this._textBoxElement, "mousewheel", this._onTextBoxMouseWheelDelegate);
		        this._onTextBoxMouseWheelDelegate = null;
		    }
		    if (this._onTextBoxDragDropDelegate)
		    {
		        $removeHandler(this._textBoxElement, "drop", this._onTextBoxDragDropDelegate);
		        this._onTextBoxDragDropDelegate = null;
		    }
		}       
    },
    
    // PUBLIC API START
    
    clear : function ()
    {
        this.set_value("");
    },
    
    disable : function()
    {
        this.set_enabled(false);
        this._textBoxElement.disabled = "disabled";
        this.updateCssClass();
        this.raise_disable(Sys.EventArgs.Empty);
    },
        
    enable : function ()
    {
        this.set_enabled(true);
        this._textBoxElement.disabled = "";
        this.updateCssClass();
        this.raise_enable(Sys.EventArgs.Empty);
    },
    
    focus : function ()
    {
        this._textBoxElement.focus();
    },

    blur : function ()
    {
        this._textBoxElement.blur();
    },
    
    isEmpty : function ()
    {
        return this._hiddenElement.value == "";
    }, 

    isNegative : function ()
	{
		return false;
	},
	
	isReadOnly : function ()
	{	    
	    return this._textBoxElement.readOnly || !this._enabled;
	},
	
	isMultiLine: function()
    {
        return this._textBoxElement.tagName.toUpperCase() == "TEXTAREA";
    },    
    
    updateDisplayValue : function()
    {
        if (this._focused)
        {
            this.set_textBoxValue(this.get_editValue());
        }
        else
        {
            if (this.isEmpty() && this.get_emptyMessage())
            {
                this._textBoxElement.maxLength = 2147483647; //the default value (when not set)               
                this._isEmptyMessage = true;
                this.set_textBoxValue(this.get_emptyMessage());
                this._textBoxElement.maxLength = this._originalMaxLength;         
            }
            else
            {
                this._isEmptyMessage = false;
                this.set_textBoxValue(this.get_displayValue());
            }
        }
    },
    
    updateCssClass  : function ()
    {      
        if (this._enabled && (!this._isEmptyMessage) && (!this.isNegative()))
        {
             this._textBoxElement.style.cssText = this._originalTextBoxCssText + this.updateCssText(this.get_styles()["EnabledStyle"][0]);
             this._textBoxElement.className = this.get_styles()["EnabledStyle"][1];            
        }     
        if (this._enabled && (!this._isEmptyMessage) && this.isNegative())
        {
             this._textBoxElement.style.cssText = this._originalTextBoxCssText + this.updateCssText(this.get_styles()["NegativeStyle"][0]);
             this._textBoxElement.className = this.get_styles()["NegativeStyle"][1];
        }          
        if (this._enabled && this._isEmptyMessage)
        {
             this._textBoxElement.style.cssText = this._originalTextBoxCssText + this.updateCssText(this.get_styles()["EmptyMessageStyle"][0]);
             this._textBoxElement.className = this.get_styles()["EmptyMessageStyle"][1];
        }   
        if (this._hovered)
        {
            this._textBoxElement.style.cssText = this._originalTextBoxCssText + this.updateCssText(this.get_styles()["HoveredStyle"][0]);
            this._textBoxElement.className = this.get_styles()["HoveredStyle"][1];
        }
        if (this._focused)
        {
            this._textBoxElement.style.cssText = this._originalTextBoxCssText + this.updateCssText(this.get_styles()["FocusedStyle"][0]);
            this._textBoxElement.className = this.get_styles()["FocusedStyle"][1];   
        }
        if (this._invalid)
        {
            this._textBoxElement.style.cssText = this._originalTextBoxCssText + this.updateCssText(this.get_styles()["InvalidStyle"][0]);
            this._textBoxElement.className = this.get_styles()["InvalidStyle"][1];
        }   
        if (this._textBoxElement.readOnly)
        {
            this._textBoxElement.style.cssText = this._originalTextBoxCssText + this.updateCssText(this.get_styles()["ReadOnlyStyle"][0]);
            this._textBoxElement.className = this.get_styles()["ReadOnlyStyle"][1];        
        }
        if (!this._enabled)
        {   
            this._textBoxElement.style.cssText = this._originalTextBoxCssText + this.updateCssText(this.get_styles()["DisabledStyle"][0]);
            this._textBoxElement.className = this.get_styles()["DisabledStyle"][1];        
        }
    },
    
    updateCssText : function(styleCssText)
    {
        var settings = styleCssText.split(';');
        var i;
        var result = ""; 
        for (i=0; i < settings.length; i++)
        {
            var setting = settings[i].split(':');
            if(setting.length == 2)
            {   
                var name = "" + setting[0].toLowerCase();
                if(name != "width" && name != "height")
                {
                    result += settings[i] + ";";
                }  
            }
        }
        return result;
    },
    
    selectText : function (start, end)
    {
        this._selectionStart = start;
        this._selectionEnd = end;
        this._applySelection();
    },

    selectAllText : function ()
    {
        if (this._textBoxElement.value.length > 0)
        {
             this.selectText(0, this._textBoxElement.value.length);
             return true;
        }
        return false;
    },    
    
    // obsolete: use the value property
	GetValue : function()
	{
	    return this.get_value();
	},
	
    // obsolete: use the value property
    SetValue : function (newValue)
    {
        this.set_value(newValue);
    },
	
	// obsolete: use the displayValue property
	GetDisplayValue : function ()
    {
        return this.get_displayValue();
    },
    
    // obsolete: use the editValue property
    GetEditValue : function ()
    {
        return this.get_editValue();
    },
    
    // obsolete: use the caretPosition property
    SetCaretPosition : function(position)
    {
        this.set_caretPosition(position);
    },
    
    // obsolete: use the wrapperElement property
    GetWrapperElement : function()
    {
        return this.get_wrapperElement();
    },
    
    // obsolete: use the textBoxValue property    
    GetTextBoxValue : function ()
    {
        return this.get_textBoxValue();
    },
    
    // obsolete: use the textBoxValue property
    SetTextBoxValue : function (value)
    {
        this.set_textBoxValue(value);
    },
    
    get_value : function ()
    {
        return this._hiddenElement.value;
    },
    
    set_value : function(newValue)
    {
        var eventArgs = new Telerik.Web.UI.InputValueChangingEventArgs(newValue, this._initialValue);
        this.raise_valueChanging(eventArgs);
        
        if (eventArgs.get_cancel() == true)
        {
            this._SetValue(this._initialValue);
            return false;
        }
            
        if (eventArgs.get_newValue())
            newValue = eventArgs.get_newValue();
            
        var validValue = this._setHiddenValue(newValue);
        
        if (validValue == false)
            newValue = "";
            
        this._triggerDOMChangeEvent(this._getValidationField());
        this.raise_valueChanged(newValue, this._initialValue);
        
        if (typeof(validValue) == "undefined" || validValue == true)
        {
            this.set_textBoxValue(this.get_editValue());
            this.updateDisplayValue();
            this.updateCssClass();
        }
    },    

    get_displayValue : function()
    {
        return this._hiddenElement.value;
    },

    get_editValue: function()
    {
        return this._hiddenElement.value;
    },

    set_caretPosition : function (position)
    {   
        this._selectionStart = position;
        this._selectionEnd = position;
        this._applySelection();
    },
    
    raisePostBackEvent : function()
    {
        eval(this._postBackEventReferenceScript);
    },
    
    get_wrapperElement : function()
    {
        return $get(this._wrapperElementID);
    },
    
    get_textBoxValue : function()
    {
        return this._textBoxElement.value; 
    },
    
    set_textBoxValue : function(value)
    {
        if (this._textBoxElement.value != value)
        {
            this._textBoxElement.value = value;
        }
    },
    
    get_autoPostBack : function() 
    {
        return this._autoPostBack;
    },
    set_autoPostBack : function(value) 
    {
        if (this._autoPostBack !== value) 
        {
            this._autoPostBack = value;
            this.raisePropertyChanged('autoPostBack');
        }
    },
    
    get_emptyMessage : function() 
    {
        return this._emptyMessage;
    },
    set_emptyMessage : function(value) 
    {
        if (this._emptyMessage !== value) 
        {
            this._emptyMessage = value;
            this._isEmptyMessage = (value != "");
            this.raisePropertyChanged('emptyMessage');
        }
    },
    
    get_selectionOnFocus : function() 
    {
        return this._selectionOnFocus;
    },
    set_selectionOnFocus : function(value) 
    {
        if (this._selectionOnFocus !== value) 
        {
            this._selectionOnFocus = value;
            this.raisePropertyChanged('selectionOnFocus');
        }
    },
    
    get_showButton : function() 
    {
        return this._showButton;
    },
    set_showButton : function(value) 
    {
        if (this._showButton !== value) 
        {
            this._showButton = value;
            this.raisePropertyChanged('showButton');
        }
    },
    
    get_invalidStyleDuration : function() 
    {
        return this._invalidStyleDuration;
    },
    set_invalidStyleDuration : function(value) 
    {
        if (this._invalidStyleDuration !== value) 
        {
            this._invalidStyleDuration = value;
            this.raisePropertyChanged('invalidStyleDuration');
        }
    },    
    
    get_enabled : function() 
    {
        return this._enabled;
    },
    set_enabled : function(value) 
    {
        if (this._enabled !== value) 
        {
            this._enabled = value;
            this.raisePropertyChanged('enabled');
        }
    },
    
    get_styles : function() 
    {
        return this._styles;
    },
    set_styles : function(value) 
    {
        if (this._styles !== value) 
        {
            this._styles = value;
            this.raisePropertyChanged('styles');
        }
    },
    
    // PUBLIC API END
    
    _updatePercentageHeight : function ()
    {        
        var wrapper = $get(this._wrapperElementID);
        if(wrapper.style.height.indexOf("%")> -1) 
        {       
            if(wrapper.offsetHeight != 0)
            {
                this._textBoxElement.style.height = wrapper.offsetHeight + "px";
                this._originalTextBoxCssText += "height:" + this._textBoxElement.style.height + ";";
            }
            else
            {
                var obj = this;
                window.setTimeout(
	            function()
	            {
	                obj.TextBoxElement.style.height = wrapper.offsetHeight + "px";
                    obj.OriginalTextBoxCssText += "height:" + obj.TextBoxElement.style.height + ";";                        
	            }, 
	            0);
            }
        }
    },
    
    _initializeHiddenElement : function(id)
    {
        this._hiddenElement = $get(id);
    },
    
    _initializeValidationField : function(id)
    {
    },
    
    _initializeButtons : function()
    {
        this._onButtonClickDelegate = Function.createDelegate(this, this._onButtonClickHandler);
        this.Button = null;
		var domElement = $get(this._wrapperElementID);
        var anchors = domElement.getElementsByTagName("a");
        
        for (i = 0; i < anchors.length; i++)
        {
			if (anchors[i].className.indexOf("gobutton") != (-1))
            {
                this.Button = anchors[i];
                $addHandler(this.Button, "click", this._onButtonClickDelegate);        
            }            
        }   
    },

    _attachEventHandlers : function ()
    {   
        this._onTextBoxKeyUpDelegate = Function.createDelegate(this, this._onTextBoxKeyUpHandler);    
        this._onTextBoxKeyPressDelegate = Function.createDelegate(this, this._onTextBoxKeyPressHandler);
        this._onTextBoxBlurDelegate = Function.createDelegate(this, this._onTextBoxBlurHandler);
        this._onTextBoxFocusDelegate = Function.createDelegate(this, this._onTextBoxFocusHandler);
        this._onTextBoxKeyDownDelegate = Function.createDelegate(this, this._onTextBoxKeyDownHandler);
    
        $addHandler(this._textBoxElement, "keydown", this._onTextBoxKeyDownDelegate);
        $addHandler(this._textBoxElement, "keypress", this._onTextBoxKeyPressDelegate);
        $addHandler(this._textBoxElement, "keyup", this._onTextBoxKeyUpDelegate);    
        $addHandler(this._textBoxElement, "blur", this._onTextBoxBlurDelegate);
        $addHandler(this._textBoxElement, "focus", this._onTextBoxFocusDelegate);

        this._attachMouseEventHandlers();
    },
    
    _attachMouseEventHandlers : function()
    {
        this._onTextBoxMouseOutDelegate = Function.createDelegate(this, this._onTextBoxMouseOutHandler);
        this._onTextBoxMouseOverDelegate = Function.createDelegate(this, this._onTextBoxMouseOverHandler);
        this._onTextBoxMouseWheelDelegate = Function.createDelegate(this, this._onTextBoxMouseWheelHandler);
        this._onTextBoxDragDropDelegate = Function.createDelegate(this, this._onTextBoxDragDropHandler);        
        
        $addHandler(this._textBoxElement, "mouseout", this._onTextBoxMouseOutDelegate);   
        $addHandler(this._textBoxElement, "mouseover", this._onTextBoxMouseOverDelegate);
        
        if (Sys.Browser.agent != Sys.Browser.InternetExplorer)
		{
		    //Gecko, Opera?
		    $addHandler(this._textBoxElement, "DOMMouseScroll", this._onTextBoxMouseWheelDelegate);
		    $addHandler(this._textBoxElement, "dragdrop", this._onTextBoxDragDropDelegate);
		}
		else
		{
			//IE
		    $addHandler(this._textBoxElement, "mousewheel", this._onTextBoxMouseWheelDelegate);
		    $addHandler(this._textBoxElement, "drop", this._onTextBoxDragDropDelegate);
		}        
    },
    
    //
    //Event Handlers
    //
    _onTextBoxKeyPressHandler : function (e)
    {        
        var eventArgs = new Telerik.Web.UI.InputKeyPressEventArgs(e, e.charCode, String.fromCharCode(e.charCode));
        this.raise_keyPress(eventArgs);
        
        if (eventArgs.get_cancel())
        {
            e.stopPropagation();
		    e.preventDefault();        
			return false;        
        }           
       
        if ((e.charCode == 13) 
			&& !this.isMultiLine())
        {           
           this._updateHiddenValueOnKeyPress(e); 
           if (this.get_autoPostBack())
           {
               this.raisePostBackEvent();
               
               if (Sys.Browser.agent == Sys.Browser.InternetExplorer)
               {
                    e.stopPropagation();
		            e.preventDefault();     
               }         
           }
           return true;
        }        
    },
    
    _onTextBoxKeyUpHandler : function (e)
    {
        this._updateHiddenValueOnKeyPress(e);  
    },     
    
    _onTextBoxBlurHandler : function (e)
    {
        this._focused = false;
        
        var textBoxValue = this.get_textBoxValue(); 
        if (this._initialValue != textBoxValue)
        {
            this.set_value(textBoxValue);
        }
        else
        {
            this.updateDisplayValue();
            this.updateCssClass();
        }
        
        this.raise_blur(Sys.EventArgs.Empty); 
    },
    
    _onTextBoxFocusHandler : function (e)
    {
        this._focused = true;
        this.updateDisplayValue();
        this.updateCssClass();
        this._updateSelectionOnFocus();
        this.raise_focus(Sys.EventArgs.Empty); 
    },
    
    _onTextBoxMouseOutHandler : function (e)
    {
        this._hovered = false;
        this.updateCssClass();
        this.raise_mouseOut(Sys.EventArgs.Empty); 
    },    
    
    _onTextBoxMouseOverHandler : function (e)
    {
        this._hovered = true;
        this.updateCssClass(); 
        this.raise_mouseOver(Sys.EventArgs.Empty); 
    },    
    
	_onTextBoxKeyDownHandler : function(e)
	{
	},    
	
    _onTextBoxMouseWheelHandler : function(e)
	{
	    var delta;
	    if (this._focused)
	    {            
            if (e.rawEvent.wheelDelta) 
            { 
                /* IE/Opera. */
                delta = e.rawEvent.wheelDelta/120;
                /** In Opera 9, delta differs in sign as compared to IE.*/
                if (window.opera)
                    delta = -delta;
            } 
            else if (e.detail) 
            {
                    /** Mozilla case. In Mozilla, sign of delta is different than in IE. Also, delta is multiple of 3.*/
                    delta = - e.rawEvent.detail/3;
            }
            
            if (delta > 0)
            {
                this._handleWheel(false);
            }
            else
            {
                this._handleWheel(true);
            }
            
            return true;
        }
        return false;
	},
    
    _onButtonClickHandler : function (e)
    {
        var eventArgs = new Telerik.Web.UI.InputButtonClickEventArgs(Telerik.Web.UI.InputButtonType.Button);
        this.raise_buttonClick(eventArgs); 
    },    
    
    _onTextBoxDragDropHandler : function (e)
    {        
        if (Sys.Browser.agent == Sys.Browser.InternetExplorer)
        {
            this.set_value(e.rawEvent.dataTransfer.getData("text"));
        }
        else
        {   
            this.set_value(this.get_textBoxValue());
        }
    },
       
    _getValidationField : function()
    {
        return this._hiddenElement;
    },
	
    _calculateSelection : function ()
    {
        if ((Sys.Browser.agent == Sys.Browser.Opera) || !document.selection)
        {
            this._selectionEnd = this._textBoxElement.selectionEnd;
            this._selectionStart = this._textBoxElement.selectionStart;
            return;
        }
        
        var s1 = document.selection.createRange();
        if (s1.parentElement() != this._textBoxElement) return;
        var s = s1.duplicate();

        s.move('character', -this._textBoxElement.value.length);
        
        s.setEndPoint('EndToStart', s1);
        
        var sel1 = s.text.length;
        var sel2 = s.text.length +  s1.text.length;
        this._selectionEnd = Math.max(sel1, sel2);
        this._selectionStart = Math.min(sel1, sel2);
    },
    
    _SetValue : function (newValue)
    {
        var validValue = this._setHiddenValue(newValue);
			
        if (typeof(validValue) == "undefined" || validValue == true)
        {
            this.set_textBoxValue(this.get_editValue());
        }
    },    
        
    _triggerDOMChangeEvent : function(element) 
    {
            
        if (element.fireEvent && document.createEventObject) 
        {
            var eventObject = document.createEventObject();
            
                element.fireEvent("onchange", eventObject);
            
        } 
        else if (element.dispatchEvent)
        {
            var canBubble = true;
            var eventObject = document.createEvent("HTMLEvents");
            eventObject.initEvent("change", canBubble, true);
            element.dispatchEvent(eventObject);
        }
    },   
    
    _updateSelectionOnFocus : function()
    {
        switch (this.get_selectionOnFocus())
        {
            case Telerik.Web.UI.SelectionOnFocus.None:
                break;
            case Telerik.Web.UI.SelectionOnFocus.CaretToBeginning:

                this.set_caretPosition(0);
                break;
            case Telerik.Web.UI.SelectionOnFocus.CaretToEnd:
                if (this._textBoxElement.value.length > 0)
                {
                    this.set_caretPosition(this._textBoxElement.value.length);
                }
                break;
            case Telerik.Web.UI.SelectionOnFocus.SelectAll:
                this.selectAllText();
                break;            
            default : 
				this.set_caretPosition(0); //CaretToBeginning
				break;
        }
    },	   
    
    _applySelection : function ()
    {
            if ((Sys.Browser.agent == Sys.Browser.Opera) || !document.selection)
            {
                this._textBoxElement.selectionStart = this._selectionStart;
                this._textBoxElement.selectionEnd = this._selectionEnd;
                return;
            }

            this._textBoxElement.select();
            sel = document.selection.createRange();
            sel.collapse();
            sel.moveStart('character', this._selectionStart);
            sel.collapse();
            sel.moveEnd('character', this._selectionEnd - this._selectionStart);
            sel.select();        
    },     
    
    _clearHiddenValue : function()
    {
        this._hiddenElement.value = "";
    },   
    
    _handleWheel : function(isNegativeWheel)
	{
	},

    _setHiddenValue : function(value)
    {
        if (this._hiddenElement.value != value.toString())
        {
            this._hiddenElement.value = value;
        }
        
        this._setValidationField(value);
        
        return true;
    },
    
    _setValidationField : function(value)
    {
    },     
    
    _updateHiddenValueOnKeyPress : function()
    {
		this._updateHiddenValue();
    },
    
    _updateHiddenValue : function()
    {
        return this._setHiddenValue(this._textBoxElement.value);
    }, 
    
    _escapeNewLineChars : function(text, replaceWith)
    { 
        text = escape(text);
        var i;
        for(i = 0; i < text.length; i++)
        { 
            if(text.indexOf("%0D%0A") > -1)
            { 
                text = text.replace("%0D%0A", replaceWith);
            }
            else if (text.indexOf("%0A") > -1)
            { 
                text = text.replace("%0A", replaceWith);
            }
            else if (text.indexOf("%0D") > -1)
            { 
                text = text.replace("%0D", replaceWith);
            }       
        }
        return unescape(text);
    },
    
    _isNormalChar : function(e)
	{
        if (($telerik.isFirefox&& e.rawEvent.keyCode) 
            || 
            ($telerik.isOpera && e.rawEvent.which == 0)
            ||
            ($telerik.isSafari && (e.charCode < Sys.UI.Key.space || e.charCode > 60000)))
        {
            return false;
        }	
        return true;
	},
    
    //register events    
    add_blur: function(handler) 
    {
        this.get_events().addHandler('blur', handler);
    },
    remove_blur: function(handler) 
    {
        this.get_events().removeHandler('blur', handler);
    },
	raise_blur : function(args)
	{
		this.raiseEvent("blur", args);
	}, 
	
    add_mouseOut : function(handler) 
    {
        this.get_events().addHandler('mouseOut', handler);
    },
    remove_mouseOut : function(handler) 
    {
        this.get_events().removeHandler('mouseOut', handler);
    },
	raise_mouseOut : function(args)
	{
		this.raiseEvent("mouseOut", args);
	},   
	
    add_valueChanged : function(handler) 
    {
        this.get_events().addHandler('valueChanged', handler);
    },
    remove_valueChanged : function(handler) 
    {
        this.get_events().removeHandler('valueChanged', handler);
    },
	raise_valueChanged : function(newValue, oldValue)
	{
        if (newValue.toString() == oldValue.toString())
            return false;
        this._initialValue = this.get_value();
        var eventArgs = new Telerik.Web.UI.InputValueChangedEventArgs(newValue, oldValue);
        this.raiseEvent("valueChanged", eventArgs);
        
		var shouldPostBack = !eventArgs.get_cancel();		    
        if (this.get_autoPostBack() && shouldPostBack)
            this.raisePostBackEvent();
	},
	
    add_error : function(handler) 
    {
        this.get_events().addHandler('error', handler);
    },
    remove_error : function(handler) 
    {
        this.get_events().removeHandler('error', handler);
    },
    
    raise_error : function(args)
    {
        if (this.InEventRaise)
        {
            return;
        }

        this.InEventRaise = true;
        this.raiseEvent("error", args);
        if (!args.get_cancel())
        {
            this._invalid = true;
            this._errorHandlingCanceled = false;
            
            this.updateCssClass();
        	
            var instance = this;
            var restore = function()
            {
	            instance._invalid = false;
	            instance.updateCssClass();
            }
            setTimeout(restore, this.get_invalidStyleDuration());	        
        }
        else
        {
            this._errorHandlingCanceled = true;
        }
        
        this.InEventRaise = false;	
    },
	
    add_load : function(handler) 
    {
        this.get_events().addHandler('load', handler);
    },
    remove_load : function(handler) 
    {
        this.get_events().removeHandler('load', handler);
    },
	raise_load : function(args)
	{
		this.raiseEvent("load", args);
	},
	
    add_mouseOver : function(handler) 
    {
        this.get_events().addHandler('mouseOver', handler);
    },
    remove_mouseOver : function(handler) 
    {
        this.get_events().removeHandler('mouseOver', handler);
    },
	raise_mouseOver : function(args)
	{
		this.raiseEvent("mouseOver", args);
	},
	
    add_focus : function(handler) 
    {
        this.get_events().addHandler('focus', handler);
    },
    remove_focus : function(handler) 
    {
        this.get_events().removeHandler('focus', handler);
    },
	raise_focus : function(args)
	{
		this.raiseEvent("focus", args);
	},
	
    add_disable : function(handler) 
    {
        this.get_events().addHandler('disable', handler);
    },
    remove_disable : function(handler) 
    {
        this.get_events().removeHandler('disable', handler);
    },
	raise_disable : function(args)
	{
		this.raiseEvent("disable", args);
	},
	
    add_enable : function(handler) 
    {
        this.get_events().addHandler('enable', handler);
    },
    remove_enable : function(handler) 
    {
        this.get_events().removeHandler('enable', handler);
    },
	raise_enable : function(args)
	{
		this.raiseEvent("enable", args);
	},	
	
    add_keyPress : function(handler) 
    {
        this.get_events().addHandler('keyPress', handler);
    },
    remove_keyPress : function(handler) 
    {
        this.get_events().removeHandler('keyPress', handler);
    },
	raise_keyPress : function(args)
	{
		this.raiseEvent("keyPress", args);
	},
	
    add_enumerationChanged : function(handler) 
    {
        this.get_events().addHandler('enumerationChanged', handler);
    },
    remove_enumerationChanged : function(handler) 
    {
        this.get_events().removeHandler('enumerationChanged', handler);
    },
	raise_enumerationChanged : function(args)
	{
		this.raiseEvent("enumerationChanged", args);
	},
	
    add_moveUp : function(handler) 
    {
        this.get_events().addHandler('moveUp', handler);
    },
    remove_moveUp : function(handler) 
    {
        this.get_events().removeHandler('moveUp', handler);
    },
	raise_moveUp : function(args)
	{
		this.raiseEvent("moveUp", args);
	},
	
    add_moveDown : function(handler) 
    {
        this.get_events().addHandler('moveDown', handler);
    },
    remove_moveDown : function(handler) 
    {
        this.get_events().removeHandler('moveDown', handler);
    },
	raise_moveDown : function(args)
	{
		this.raiseEvent("moveDown", args);
	},
	
    add_buttonClick : function(handler) 
    {
        this.get_events().addHandler('buttonClick', handler);
    },
    remove_buttonClick : function(handler) 
    {
        this.get_events().removeHandler('buttonClick', handler);
    },
	raise_buttonClick : function(args)
	{
		this.raiseEvent("buttonClick", args);
	},
	
    add_valueChanging : function(handler) 
    {
        this.get_events().addHandler('valueChanging', handler);
    },
    remove_valueChanging : function(handler) 
    {
        this.get_events().removeHandler('valueChanging', handler);
    },
	raise_valueChanging : function(args)
	{
		this.raiseEvent("valueChanging", args);
	}								
}

//$telerik.makeCompatible(Telerik.Web.UI.RadInputControl);
Telerik.Web.UI.RadInputControl.registerClass('Telerik.Web.UI.RadInputControl', Telerik.Web.UI.RadWebControl);


// fix ValidatorSetFocus: Work Item #6120
if (typeof(ValidatorSetFocus) == "function")
{
    ValidatorSetFocus = function (val, event) 
    {
        var ctrl;
        if (typeof(val.controlhookup) == "string") 
        {
            var eventCtrl;
            if ((typeof(event) != "undefined") && (event != null)) 
            {
                if ((typeof(event.srcElement) != "undefined") && (event.srcElement != null)) 
                {
                    eventCtrl = event.srcElement;
                }
                else 
                {
                    eventCtrl = event.target;
                }
            }
            if ((typeof(eventCtrl) != "undefined") && (eventCtrl != null) &&
                (typeof(eventCtrl.id) == "string") &&
                (eventCtrl.id == val.controlhookup)) 
            {
                ctrl = eventCtrl;
            }
        }
        if ((typeof(ctrl) == "undefined") || (ctrl == null)) 
        {
            ctrl = document.getElementById(val.controltovalidate);
        }
        var isRadInputControl = false;
        if ((ctrl.style)
            && (typeof(ctrl.style.visibility) != "undefined") 
            && (ctrl.style.visibility == "hidden")
            && (typeof(ctrl.style.width) != "undefined")
            && (document.getElementById(ctrl.id + "_text"))
            && (ctrl.tagName.toLowerCase() == "input"))
        {
            isRadInputControl = true;     
        }       
        if ((typeof(ctrl) != "undefined") && (ctrl != null) &&  
            (ctrl.tagName.toLowerCase() != "table" || (typeof(event) == "undefined") || (event == null)) &&
            ((ctrl.tagName.toLowerCase() != "input") || (ctrl.type.toLowerCase() != "hidden")) &&
            (typeof(ctrl.disabled) == "undefined" || ctrl.disabled == null || ctrl.disabled == false) &&
            (typeof(ctrl.visible) == "undefined" || ctrl.visible == null || ctrl.visible != false) &&
            (IsInVisibleContainer(ctrl) || isRadInputControl)) 
        {
            if (ctrl.tagName.toLowerCase() == "table" &&
                (typeof(__nonMSDOMBrowser) == "undefined" || __nonMSDOMBrowser)) 
            {
                var inputElements = ctrl.getElementsByTagName("input");
                var lastInputElement = inputElements[inputElements.length -1];
                if (lastInputElement != null) 
                {
                    ctrl = lastInputElement;
                }
            }

            if (typeof(ctrl.focus) != "undefined" && ctrl.focus != null) 
            {
                if (isRadInputControl)
                    document.getElementById(ctrl.id + "_text").focus();
                else
                    ctrl.focus();
                    
                Page_InvalidControlToBeFocused = ctrl;
            }
        }
    } 
}
/* END Telerik.Web.UI.Input.RadInputControl.js */
/* START Telerik.Web.UI.Input.TextBox.RadTextBox.js */
Telerik.Web.UI.RadTextBox = function(element) 
{
    Telerik.Web.UI.RadTextBox.initializeBase(this, [element]);
    
    this._maxLength = 0;
}

Telerik.Web.UI.RadTextBox.prototype = 
{
    initialize : function() 
    {        
        Telerik.Web.UI.RadTextBox.callBaseMethod(this, 'initialize');
        
        //fix security issue using the RadTextBox with Password 
        if ((!$telerik.isFirefox)
            && (this._textBoxElement)
            && (this._textBoxElement.type == "password"))
        {
            var obj = this;
            setTimeout(function () {obj._SetValue(""); obj.updateDisplayValue();}, 0);
        }
        //end fix        
    },
    
    dispose : function() 
    {
        Telerik.Web.UI.RadTextBox.callBaseMethod(this, 'dispose');        
    },
    
    _onTextBoxKeyPressHandler : function (e)
	{ 
        Telerik.Web.UI.RadTextBox.callBaseMethod(this, '_onTextBoxKeyPressHandler', [e]);        
        
        var value = this._escapeNewLineChars(this._textBoxElement.value, "");       
        
	    if ((this.get_maxLength() > 0) 
	        && (value.length >= this.get_maxLength())
	        && (this._isNormalChar(e)))
	    {
            e.stopPropagation();
            e.preventDefault();	            
            return false;
	    }           
	},
	
    get_maxLength : function() 
    {
        return this._maxLength;
    },
    set_maxLength : function(value) 
    {
        if (this._maxLength !== value) 
        {
            this._maxLength = value;
            this.raisePropertyChanged('maxLength');
        }
    }
}

Telerik.Web.UI.RadTextBox.registerClass('Telerik.Web.UI.RadTextBox', Telerik.Web.UI.RadInputControl);

/* END Telerik.Web.UI.Input.TextBox.RadTextBox.js */
if(typeof(Sys)!=='undefined')Sys.Application.notifyScriptLoaded();
(function() {var fn = function() {$get('ctl00_ContentPlaceHolder1_radScriptManager_HiddenField').value += ';;Telerik.Web.UI, Version=2008.1.619.0, Culture=neutral, PublicKeyToken=29ac1a93ec063d92:en-US:7d8ee94c-6ddd-4dea-a7a2-18ab28c45add:393f5085:e3129d75:99dbf74d:d56f3952:d76c3a56';Sys.Application.remove_load(fn);};Sys.Application.add_load(fn);})();
