//-----------------------------------------------------------------------
// Copyright (C) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------
// MicrosoftAjaxWebForms.js
// Microsoft AJAX ASP.NET WebForms Framework.


Type.registerNamespace('Sys.WebForms');


Sys.WebForms.Res = {
    PRM_CannotRegisterTwice : 'The PageRequestManager cannot be initialized more than once.',
    PRM_ParserError : 'The message received from the server could not be parsed.',
    PRM_TimeoutError : 'The server request timed out.',
    PRM_ServerError : 'An unknown error occurred while processing the request on the server. The status code returned from the server was: {0}',
    PRM_MissingPanel : 'Could not find UpdatePanel with ID \'{0}\'. If it is being updated dynamically then it must be inside another UpdatePanel.'
}

Error.pageRequestManagerTimeout = function Error$pageRequestManagerTimeout() {
    /// <returns></returns>
    if (arguments.length !== 0) throw Error.parameterCount();

    var displayMessage = "Sys.WebForms.PageRequestManagerTimeoutException: " + Sys.WebForms.Res.PRM_TimeoutError;
    var e = Error.create(displayMessage, {name: 'Sys.WebForms.PageRequestManagerTimeoutException'});
    e.popStackFrame();
    return e;
}

Error.pageRequestManagerServerError = function Error$pageRequestManagerServerError(httpStatusCode, message) {
    /// <param name="httpStatusCode" type="Number"></param>
    /// <param name="message" type="String" optional="true" mayBeNull="true"></param>
    /// <returns></returns>
    var e = Function._validateParams(arguments, [
        {name: "httpStatusCode", type: Number},
        {name: "message", type: String, mayBeNull: true, optional: true}
    ]);
    if (e) throw e;


    var displayMessage = message || ("Sys.WebForms.PageRequestManagerServerErrorException: " + String.format(Sys.WebForms.Res.PRM_ServerError, httpStatusCode));
    var e = Error.create(displayMessage, {
        name: 'Sys.WebForms.PageRequestManagerServerErrorException',
        httpStatusCode: httpStatusCode
    });
    e.popStackFrame();
    return e;
}

Error.pageRequestManagerParserError = function Error$pageRequestManagerParserError() {
    /// <returns></returns>
    if (arguments.length !== 0) throw Error.parameterCount();

    var displayMessage = "Sys.WebForms.PageRequestManagerParserErrorException: " + Sys.WebForms.Res.PRM_ParserError;
    var e = Error.create(displayMessage, {name: 'Sys.WebForms.PageRequestManagerParserErrorException'});
    e.popStackFrame();
    return e;
}


Sys.WebForms.BeginRequestEventArgs = function Sys$WebForms$BeginRequestEventArgs(request, postBackElement) {
    /// <param name="request" type="Sys.Net.WebRequest"></param>
    /// <param name="postBackElement" type="Sys.UI.DomElement"></param>
    var e = Function._validateParams(arguments, [
        {name: "request", type: Sys.Net.WebRequest},
        {name: "postBackElement", type: Sys.UI.DomElement}
    ]);
    if (e) throw e;


    Sys.WebForms.BeginRequestEventArgs.initializeBase(this);
    this._request = request;
    this._postBackElement = postBackElement;
}


    function Sys$WebForms$BeginRequestEventArgs$get_postBackElement() {
        /// <value type="Sys.UI.DomElement"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._postBackElement;
    }

    function Sys$WebForms$BeginRequestEventArgs$get_request() {
        /// <value type="Sys.Net.WebRequest"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._request;
    }
Sys.WebForms.BeginRequestEventArgs.prototype = {
    get_postBackElement: Sys$WebForms$BeginRequestEventArgs$get_postBackElement,

    get_request: Sys$WebForms$BeginRequestEventArgs$get_request
}

Sys.WebForms.BeginRequestEventArgs.registerClass('Sys.WebForms.BeginRequestEventArgs', Sys.EventArgs);

Sys.WebForms.EndRequestEventArgs = function Sys$WebForms$EndRequestEventArgs(error, dataItems, response) {
    /// <param name="error" type="Error" mayBeNull="true"></param>
    /// <param name="dataItems" type="Object" mayBeNull="true"></param>
    /// <param name="response" type="Sys.Net.WebRequestExecutor"></param>
    var e = Function._validateParams(arguments, [
        {name: "error", type: Error, mayBeNull: true},
        {name: "dataItems", type: Object, mayBeNull: true},
        {name: "response", type: Sys.Net.WebRequestExecutor}
    ]);
    if (e) throw e;


    Sys.WebForms.EndRequestEventArgs.initializeBase(this);
    this._errorHandled = false;
    this._error = error;
    this._dataItems = dataItems ? dataItems : {};
    this._response = response;
}


    function Sys$WebForms$EndRequestEventArgs$get_dataItems() {
        /// <value type="Object"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._dataItems;
    }

    function Sys$WebForms$EndRequestEventArgs$get_error() {
        /// <value type="Error"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._error;
    }

    function Sys$WebForms$EndRequestEventArgs$get_errorHandled() {
        /// <value type="Boolean"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._errorHandled;
    }
    function Sys$WebForms$EndRequestEventArgs$set_errorHandled(value) {
        var e = Function._validateParams(arguments, [{name: "value", type: Boolean}]);
        if (e) throw e;

        this._errorHandled = value;
    }

    function Sys$WebForms$EndRequestEventArgs$get_response() {
        /// <value type="Sys.Net.WebRequestExecutor"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._response;
    }
Sys.WebForms.EndRequestEventArgs.prototype = {
    get_dataItems: Sys$WebForms$EndRequestEventArgs$get_dataItems,

    get_error: Sys$WebForms$EndRequestEventArgs$get_error,

    get_errorHandled: Sys$WebForms$EndRequestEventArgs$get_errorHandled,
    set_errorHandled: Sys$WebForms$EndRequestEventArgs$set_errorHandled,

    get_response: Sys$WebForms$EndRequestEventArgs$get_response
}

Sys.WebForms.EndRequestEventArgs.registerClass('Sys.WebForms.EndRequestEventArgs', Sys.EventArgs);

Sys.WebForms.InitializeRequestEventArgs = function Sys$WebForms$InitializeRequestEventArgs(request, postBackElement) {
    /// <param name="request" type="Sys.Net.WebRequest"></param>
    /// <param name="postBackElement" type="Sys.UI.DomElement"></param>
    var e = Function._validateParams(arguments, [
        {name: "request", type: Sys.Net.WebRequest},
        {name: "postBackElement", type: Sys.UI.DomElement}
    ]);
    if (e) throw e;


    Sys.WebForms.InitializeRequestEventArgs.initializeBase(this);
    this._request = request;
    this._postBackElement = postBackElement;
}


    function Sys$WebForms$InitializeRequestEventArgs$get_postBackElement() {
        /// <value type="Sys.UI.DomElement"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._postBackElement;
    }

    function Sys$WebForms$InitializeRequestEventArgs$get_request() {
        /// <value type="Sys.Net.WebRequest"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._request;
    }
Sys.WebForms.InitializeRequestEventArgs.prototype = {
    get_postBackElement: Sys$WebForms$InitializeRequestEventArgs$get_postBackElement,

    get_request: Sys$WebForms$InitializeRequestEventArgs$get_request
}

Sys.WebForms.InitializeRequestEventArgs.registerClass('Sys.WebForms.InitializeRequestEventArgs', Sys.CancelEventArgs);

Sys.WebForms.PageLoadedEventArgs = function Sys$WebForms$PageLoadedEventArgs(panelsUpdated, panelsCreated, dataItems) {
    /// <param name="panelsUpdated" type="Array"></param>
    /// <param name="panelsCreated" type="Array"></param>
    /// <param name="dataItems" type="Object" mayBeNull="true"></param>
    var e = Function._validateParams(arguments, [
        {name: "panelsUpdated", type: Array},
        {name: "panelsCreated", type: Array},
        {name: "dataItems", type: Object, mayBeNull: true}
    ]);
    if (e) throw e;

    Sys.WebForms.PageLoadedEventArgs.initializeBase(this);
    
    this._panelsUpdated = panelsUpdated;
    this._panelsCreated = panelsCreated;
    this._dataItems = dataItems ? dataItems : {};
}


    function Sys$WebForms$PageLoadedEventArgs$get_dataItems() {
        /// <value type="Object"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._dataItems;
    }

    function Sys$WebForms$PageLoadedEventArgs$get_panelsCreated() {
        /// <value type="Array"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._panelsCreated;
    }

    function Sys$WebForms$PageLoadedEventArgs$get_panelsUpdated() {
        /// <value type="Array"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._panelsUpdated;
    }
Sys.WebForms.PageLoadedEventArgs.prototype = {
    get_dataItems: Sys$WebForms$PageLoadedEventArgs$get_dataItems,
    
    get_panelsCreated: Sys$WebForms$PageLoadedEventArgs$get_panelsCreated,

    get_panelsUpdated: Sys$WebForms$PageLoadedEventArgs$get_panelsUpdated
}

Sys.WebForms.PageLoadedEventArgs.registerClass('Sys.WebForms.PageLoadedEventArgs', Sys.EventArgs);

Sys.WebForms.PageLoadingEventArgs = function Sys$WebForms$PageLoadingEventArgs(panelsUpdating, panelsDeleting, dataItems) {
    /// <param name="panelsUpdating" type="Array"></param>
    /// <param name="panelsDeleting" type="Array"></param>
    /// <param name="dataItems" type="Object" mayBeNull="true"></param>
    var e = Function._validateParams(arguments, [
        {name: "panelsUpdating", type: Array},
        {name: "panelsDeleting", type: Array},
        {name: "dataItems", type: Object, mayBeNull: true}
    ]);
    if (e) throw e;

    Sys.WebForms.PageLoadingEventArgs.initializeBase(this);

    this._panelsUpdating = panelsUpdating;
    this._panelsDeleting = panelsDeleting;
    this._dataItems = dataItems ? dataItems : {};
}


    function Sys$WebForms$PageLoadingEventArgs$get_dataItems() {
        /// <value type="Object"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._dataItems;
    }

    function Sys$WebForms$PageLoadingEventArgs$get_panelsDeleting() {
        /// <value type="Array"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._panelsDeleting;
    }

    function Sys$WebForms$PageLoadingEventArgs$get_panelsUpdating() {
        /// <value type="Array"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._panelsUpdating;
    }
Sys.WebForms.PageLoadingEventArgs.prototype = {
    get_dataItems: Sys$WebForms$PageLoadingEventArgs$get_dataItems,

    get_panelsDeleting: Sys$WebForms$PageLoadingEventArgs$get_panelsDeleting,

    get_panelsUpdating: Sys$WebForms$PageLoadingEventArgs$get_panelsUpdating
}

Sys.WebForms.PageLoadingEventArgs.registerClass('Sys.WebForms.PageLoadingEventArgs', Sys.EventArgs);
Sys.WebForms.PageRequestManager = function Sys$WebForms$PageRequestManager() {
    this._form = null;
    this._updatePanelIDs = null;
    this._updatePanelClientIDs = null;
    this._oldUpdatePanelIDs = null;
    this._childUpdatePanelIDs = null;
    this._panelsToRefreshIDs = null;
    this._updatePanelHasChildrenAsTriggers = null;
    this._asyncPostBackControlIDs = null;
    this._asyncPostBackControlClientIDs = null;
    this._postBackControlIDs = null;
    this._postBackControlClientIDs = null;
    this._scriptManagerID = null;
    this._pageLoadedHandler = null;

    this._additionalInput = null;
    this._onsubmit = null;
    this._onSubmitStatements = [];
    this._originalDoPostBack = null;
    this._postBackSettings = null;
    this._request = null;
    this._onFormSubmitHandler = null;
    this._onFormElementClickHandler = null;
    this._onWindowUnloadHandler = null;
    this._asyncPostBackTimeout = null;
    this._referencedScripts = [];

    this._scrollPosition = null;
    this._dataItems = null;
    this._response = null;
    this._processingRequest = false;
}



    function Sys$WebForms$PageRequestManager$_get_eventHandlerList() {
        if (!this._events) {
            this._events = new Sys.EventHandlerList();
        }
        return this._events;
    }

    function Sys$WebForms$PageRequestManager$get_isInAsyncPostBack() {
        /// <value type="Boolean"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._request !== null;
    }


    function Sys$WebForms$PageRequestManager$add_beginRequest(handler) {
        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
        if (e) throw e;

        this._get_eventHandlerList().addHandler("beginRequest", handler);
    }
    function Sys$WebForms$PageRequestManager$remove_beginRequest(handler) {
        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
        if (e) throw e;

        this._get_eventHandlerList().removeHandler("beginRequest", handler);
    }

    function Sys$WebForms$PageRequestManager$add_endRequest(handler) {
        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
        if (e) throw e;

        this._get_eventHandlerList().addHandler("endRequest", handler);
    }
    function Sys$WebForms$PageRequestManager$remove_endRequest(handler) {
        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
        if (e) throw e;

        this._get_eventHandlerList().removeHandler("endRequest", handler);
    }

    function Sys$WebForms$PageRequestManager$add_initializeRequest(handler) {
        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
        if (e) throw e;

        this._get_eventHandlerList().addHandler("initializeRequest", handler);
    }
    function Sys$WebForms$PageRequestManager$remove_initializeRequest(handler) {
        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
        if (e) throw e;

        this._get_eventHandlerList().removeHandler("initializeRequest", handler);
    }

    function Sys$WebForms$PageRequestManager$add_pageLoaded(handler) {
        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
        if (e) throw e;

        this._get_eventHandlerList().addHandler("pageLoaded", handler);
    }
    function Sys$WebForms$PageRequestManager$remove_pageLoaded(handler) {
        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
        if (e) throw e;

        this._get_eventHandlerList().removeHandler("pageLoaded", handler);
    }

    function Sys$WebForms$PageRequestManager$add_pageLoading(handler) {
        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
        if (e) throw e;

        this._get_eventHandlerList().addHandler("pageLoading", handler);
    }
    function Sys$WebForms$PageRequestManager$remove_pageLoading(handler) {
        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
        if (e) throw e;

        this._get_eventHandlerList().removeHandler("pageLoading", handler);
    }

    function Sys$WebForms$PageRequestManager$abortPostBack() {
        if (!this._processingRequest && this._request) {
            this._request.get_executor().abort();
            this._request = null;
        }
    }

    function Sys$WebForms$PageRequestManager$_createPostBackSettings(async, panelID, sourceElement) {
debug.assert(async ? ((panelID !== null) && (panelID.length > 0)) : true, 'panelID should be specified if async is true');
        return { async:async, panelID:panelID, sourceElement:sourceElement };
    }

    function Sys$WebForms$PageRequestManager$_convertToClientIDs(source, destinationIDs, destinationClientIDs) {
        if (source) {
            for (var i = 0; i < source.length; i++) {
                destinationIDs.add(source[i]);
                destinationClientIDs.add(this._uniqueIDToClientID(source[i]));
            }
        }
    }

    function Sys$WebForms$PageRequestManager$_decodeString(encodedValue) {
        return encodedValue.replace(/\\\u00FF\\/g, "\u0000").replace(/\u00FF\u00FF/g, "\u00FF");
    }

    function Sys$WebForms$PageRequestManager$_destroyTree(element) {
                if (element.nodeType === 1) {
                                    var childNodes = element.childNodes;
            for (var i = childNodes.length - 1; i >= 0; i--) {
                var node = childNodes[i];
                if (node.nodeType === 1) {
                    if (node.dispose && typeof(node.dispose) === "function") {
                        node.dispose();
                    }
                    else if (node.control && typeof(node.control.dispose) === "function") {
                        node.control.dispose();
                    }
                    var behaviors = Sys.UI.Behavior.getBehaviors(node);
                    for (var j = behaviors.length - 1; j >= 0; j--) {
                        behaviors[j].dispose();
                    }
                    this._destroyTree(node);
                }
            }
        }
    }

    function Sys$WebForms$PageRequestManager$dispose() {
        if (this._form) {
            Sys.UI.DomEvent.removeHandler(this._form, 'submit', this._onFormSubmitHandler);
            Sys.UI.DomEvent.removeHandler(this._form, 'click', this._onFormElementClickHandler);
            Sys.UI.DomEvent.removeHandler(window, 'unload', this._onWindowUnloadHandler);
            Sys.UI.DomEvent.removeHandler(window, 'load', this._pageLoadedHandler);
        }

        if (this._originalDoPostBack) {
            window.__doPostBack = this._originalDoPostBack;
            this._originalDoPostBack = null;
        }

        this._form = null;
        this._updatePanelIDs = null;
        this._oldUpdatePanelIDs = null;
        this._childUpdatePanelIDs = null;
        this._updatePanelClientIDs = null;
        this._asyncPostBackControlIDs = null;
        this._asyncPostBackControlClientIDs = null;
        this._postBackControlIDs = null;
        this._postBackControlClientIDs = null;
        this._asyncPostBackTimeout = null;
        this._scrollPosition = null;
        this._dataItems = null;
    }


    function Sys$WebForms$PageRequestManager$_doPostBack(eventTarget, eventArgument) {
        this._additionalInput = null;

                var clientID = this._uniqueIDToClientID(eventTarget);
        var postBackElement = document.getElementById(clientID);
        if (!postBackElement) {
                                                            if (this._asyncPostBackControlIDs.contains(eventTarget)) {
                                this._postBackSettings = this._createPostBackSettings(true, this._scriptManagerID + '|' + eventTarget, null);
            }
            else {
                if (this._postBackControlIDs.contains(eventTarget)) {
                                        this._postBackSettings = this._createPostBackSettings(false, null, null);
                }
                else {
                                                                                var nearestUniqueIDMatch = this._findNearestElement(eventTarget);
                    if (nearestUniqueIDMatch) {
                                                                        this._postBackSettings = this._getPostBackSettings(nearestUniqueIDMatch, eventTarget);
                    }
                    else {
                                                                        this._postBackSettings = this._createPostBackSettings(false, null, null);
                    }
                }
            }
        }
        else {
                                    this._postBackSettings = this._getPostBackSettings(postBackElement, eventTarget);
        }

        if (!this._postBackSettings.async) {
                                    this._form.onsubmit = this._onsubmit;
            this._originalDoPostBack(eventTarget, eventArgument);
            this._form.onsubmit = null;
            return;
        }

        var form = this._form;
        form.__EVENTTARGET.value = eventTarget;
        form.__EVENTARGUMENT.value = eventArgument;
        this._onFormSubmit();
    }

    function Sys$WebForms$PageRequestManager$_elementContains(container, element) {
        for (var i = 0; i < container.childNodes.length; i++) {
            var currentElement = container.childNodes[i];
            if (currentElement === element) {
                return true;
            }
            if ((currentElement.nodeType === 1) && this._elementContains(currentElement, element)) {
                return true;
            }
        }
        return false;
    }

    function Sys$WebForms$PageRequestManager$_endPostBack(error, response) {
        this._processingRequest = false;

        this._request = null;
        this._additionalInput = null;

        var handler = this._get_eventHandlerList().getHandler("endRequest");
        var errorHandled = false;
        if (handler) {
            var eventArgs = new Sys.WebForms.EndRequestEventArgs(error, this._dataItems, response);
            handler(this, eventArgs);
            errorHandled = eventArgs.get_errorHandled();
        }
        this._dataItems = null;
        if (error && !errorHandled) {
            alert(error.message);
        }
    }



    function Sys$WebForms$PageRequestManager$_findNearestElement(uniqueID) {
        while (uniqueID.length > 0) {
            var clientID = this._uniqueIDToClientID(uniqueID);
            var element = document.getElementById(clientID);
            if (element) {
                return element;
            }
            var indexOfLastDollar = uniqueID.lastIndexOf('$');
            if (indexOfLastDollar === -1) {
                return null;
            }
            uniqueID = uniqueID.substring(0, indexOfLastDollar);
        }
        return null;
    }

    function Sys$WebForms$PageRequestManager$_getPageLoadedEventArgs(initialLoad) {
                                                                                                                                        
        var updated = [];
        var created = [];

                var oldIDs = this._oldUpdatePanelIDs || [];         var newIDs = this._updatePanelIDs;         var childIDs = this._childUpdatePanelIDs || [];         var refreshedIDs = this._panelsToRefreshIDs || []; 
                for (var i = 0; i < refreshedIDs.length; i++) {
            updated.add(document.getElementById(this._uniqueIDToClientID(refreshedIDs[i])));
        }

                        for (var i = 0; i < newIDs.length; i++) {
            if (initialLoad || childIDs.indexOf(newIDs[i]) !== -1) {
                created.add(document.getElementById(this._uniqueIDToClientID(newIDs[i])));
            }
        }

        return new Sys.WebForms.PageLoadedEventArgs(updated, created, this._dataItems);
    }

    function Sys$WebForms$PageRequestManager$_getPageLoadingEventArgs() {
                                                                                                                                        
        var updated = [];
        var deleted = [];

        var oldIDs = this._oldUpdatePanelIDs;
        var newIDs = this._updatePanelIDs;
        var childIDs = this._childUpdatePanelIDs;
        var refreshedIDs = this._panelsToRefreshIDs;

                for (var i = 0; i < refreshedIDs.length; i++) {
            updated.add(document.getElementById(this._uniqueIDToClientID(refreshedIDs[i])));
        }

                for (var i = 0; i < oldIDs.length; i++) {
            if (refreshedIDs.indexOf(oldIDs[i]) === -1 &&
                (newIDs.indexOf(oldIDs[i]) === -1 || childIDs.indexOf(oldIDs[i]) > -1)) {
                deleted.add(document.getElementById(this._uniqueIDToClientID(oldIDs[i])));
            }
        }

        return new Sys.WebForms.PageLoadingEventArgs(updated, deleted, this._dataItems);
    }

    function Sys$WebForms$PageRequestManager$_getPostBackSettings(element, elementUniqueID) {
debug.assert(element ? true : false, 'panelID should be specified if async is true');

        var originalElement = element;

                        var proposedSettings = null;

                        while (element) {
            if (element.id) {
                                if (!proposedSettings && this._asyncPostBackControlClientIDs.contains(element.id)) {
                                        proposedSettings = this._createPostBackSettings(true, this._scriptManagerID + '|' + elementUniqueID, originalElement);
                }
                else {
                    if (!proposedSettings && this._postBackControlClientIDs.contains(element.id)) {
                                                return this._createPostBackSettings(false, null, null);
                    }
                    else {
                        var indexOfPanel = this._updatePanelClientIDs.indexOf(element.id);
                        if (indexOfPanel !== -1) {
                                                        if (this._updatePanelHasChildrenAsTriggers[indexOfPanel]) {
                                                                
                                                                                                                                return this._createPostBackSettings(true, this._updatePanelIDs[indexOfPanel] + '|' + elementUniqueID, originalElement);
                            }
                            else {
                                                                                                return this._createPostBackSettings(true, this._scriptManagerID + '|' + elementUniqueID, originalElement);
                            }
                        }
                    }
                }

                                if (!proposedSettings && this._matchesParentIDInList(element.id, this._asyncPostBackControlClientIDs)) {
                                        proposedSettings = this._createPostBackSettings(true, this._scriptManagerID + '|' + elementUniqueID, originalElement);
                }
                else {
                    if (!proposedSettings && this._matchesParentIDInList(element.id, this._postBackControlClientIDs)) {
                                                return this._createPostBackSettings(false, null, null);
                    }
                }
            }

            element = element.parentNode;
        }

                                                if (!proposedSettings) {
                        return this._createPostBackSettings(false, null, null);
        }
        else {
            return proposedSettings;
        }
    }

    function Sys$WebForms$PageRequestManager$_getScrollPosition() {
        var d = document.documentElement;
        if (d && (this._validPosition(d.scrollLeft) || this._validPosition(d.scrollTop))) {
            return {
                x: d.scrollLeft,
                y: d.scrollTop
            };
        }
        else {
            d = document.body;
            if (d && (this._validPosition(d.scrollLeft) || this._validPosition(d.scrollTop))) {
                return {
                    x: d.scrollLeft,
                    y: d.scrollTop
                };
            }
            else {
                if (this._validPosition(window.pageXOffset) || this._validPosition(window.pageYOffset)) {
                    return {
                        x: window.pageXOffset,
                        y: window.pageYOffset
                    };
                }
                else {
                    return {
                        x: 0,
                        y: 0
                    };
                }
            }
        }
    }

    function Sys$WebForms$PageRequestManager$_initializeInternal(scriptManagerID, formElement) {
        this._scriptManagerID = scriptManagerID;

        this._form = formElement;

        
                this._form._initialAction = this._form.action;

        this._onsubmit = this._form.onsubmit;
        this._form.onsubmit = null;
        this._onFormSubmitHandler = Function.createDelegate(this, this._onFormSubmit);
        this._onFormElementClickHandler = Function.createDelegate(this, this._onFormElementClick);
        this._onWindowUnloadHandler = Function.createDelegate(this, this._onWindowUnload);
        Sys.UI.DomEvent.addHandler(this._form, 'submit', this._onFormSubmitHandler);
        Sys.UI.DomEvent.addHandler(this._form, 'click', this._onFormElementClickHandler);
        Sys.UI.DomEvent.addHandler(window, 'unload', this._onWindowUnloadHandler);

        this._originalDoPostBack = window.__doPostBack;
                if (this._originalDoPostBack) {
            window.__doPostBack = Function.createDelegate(this, this._doPostBack);
        }

        this._pageLoadedHandler = Function.createDelegate(this, this._pageLoadedInitialLoad);
        Sys.UI.DomEvent.addHandler(window, 'load', this._pageLoadedHandler);
    }

    function Sys$WebForms$PageRequestManager$_matchesParentIDInList(clientID, parentIDList) {
        for (var i = 0; i < parentIDList.length; i++) {
            if (clientID.startsWith(parentIDList[i] + "_")) {
                return true;
            }
        }
        return false;
    }

    function Sys$WebForms$PageRequestManager$_onFormElementClick(evt) {
        var element = evt.target;
        if (element.disabled) {
            return;
        }

                this._postBackSettings = this._getPostBackSettings(element, element.name);


        if (element.name) {
            if (element.tagName === 'INPUT') {
                var type = element.type;
                if (type === 'submit') {
                    this._additionalInput = element.name + '=' + encodeURIComponent(element.value);
                }
                else if (type === 'image') {
                    var x = evt.offsetX;
                    var y = evt.offsetY;
                    this._additionalInput = element.name + '.x=' + x + '&' + element.name + '.y=' + y;
                }
            }
            else if ((element.tagName === 'BUTTON') && (element.name.length !== 0) && (element.type === 'submit')) {
                this._additionalInput = element.name + '=' + encodeURIComponent(element.value);
            }
        }
    }

    function Sys$WebForms$PageRequestManager$_onFormSubmit(evt) {
        var continueSubmit = true;

                if (this._onsubmit) {
            continueSubmit = this._onsubmit();
        }

                if (continueSubmit) {
            for (var i = 0; i < this._onSubmitStatements.length; i++) {
                if (!this._onSubmitStatements[i]()) {
                    continueSubmit = false;
                    break;
                }
            }
        }

        if (!continueSubmit) {
            if (evt) {
                evt.preventDefault();
            }
            return;
        }

        var form = this._form;
        if (form.action !== form._initialAction) {
                                    return;
        }

                        if (!this._postBackSettings.async) {
            return;
        }

                var formBody = new Sys.StringBuilder();
        formBody.append(this._scriptManagerID + '=' + this._postBackSettings.panelID + '&');

        var count = form.elements.length;
        for (var i = 0; i < count; i++) {
            var element = form.elements[i];
            var name = element.name;
            if (typeof(name) === "undefined" || (name === null) || (name.length === 0)) {
                continue;
            }

            var tagName = element.tagName;

            if (tagName === 'INPUT') {
                var type = element.type;
                if ((type === 'text') ||
                    (type === 'password') ||
                    (type === 'hidden') ||
                    (((type === 'checkbox') || (type === 'radio')) && element.checked)) {
                    formBody.append(name);
                    formBody.append('=');
                    formBody.append(encodeURIComponent(element.value));
                    formBody.append('&');
                }
            }
            else if (tagName === 'SELECT') {
                var optionCount = element.options.length;
                for (var j = 0; j < optionCount; j++) {
                    var option = element.options[j];
                    if (option.selected) {
                        formBody.append(name);
                        formBody.append('=');
                        formBody.append(encodeURIComponent(option.value));
                        formBody.append('&');
                    }
                }
            }
            else if (tagName === 'TEXTAREA') {
                formBody.append(name);
                formBody.append('=');
                formBody.append(encodeURIComponent(element.value));
                formBody.append('&');
            }
        }

        if (this._additionalInput) {
            formBody.append(this._additionalInput);
            this._additionalInput = null;
        }

        var request = new Sys.Net.WebRequest();
        request.set_url(form.action);
        request.get_headers()['Pragma'] = 'Delta=true';
        request.get_headers()['Cache-Control'] = 'no-cache';
        request.set_timeout(this._asyncPostBackTimeout);
        request.add_completed(Function.createDelegate(this, this._onFormSubmitCompleted));
        request.set_body(formBody.toString());

        var handler = this._get_eventHandlerList().getHandler("initializeRequest");
        if (handler) {
            var eventArgs = new Sys.WebForms.InitializeRequestEventArgs(request, this._postBackSettings.sourceElement);
            handler(this, eventArgs);
            continueSubmit = !eventArgs.get_cancel();
        }

        if (!continueSubmit) {
            if (evt) {
                evt.preventDefault();
            }
            return;
        }

                this._scrollPosition = this._getScrollPosition();


                                this.abortPostBack();

        handler = this._get_eventHandlerList().getHandler("beginRequest");
        if (handler) {
            var eventArgs = new Sys.WebForms.BeginRequestEventArgs(request, this._postBackSettings.sourceElement);
            handler(this, eventArgs);
        }

        this._request = request;
        request.invoke();

                if (evt) {
            evt.preventDefault();
        }
    }

    function Sys$WebForms$PageRequestManager$_onFormSubmitCompleted(sender, eventArgs) {
        this._processingRequest = true;

        var delimitByLengthDelimiter = '|';
        
        if (sender.get_timedOut()) {
            this._endPostBack(Error.pageRequestManagerTimeout(), sender);
            return;
        }

        if (sender.get_aborted()) {
            this._endPostBack(null, sender);
            return;
        }

                if (!this._request || sender.get_webRequest() !== this._request) {
            return;
        }

        var errorMessage;
        var delta = [];

                if (sender.get_statusCode() !== 200) {
            this._endPostBack(Error.pageRequestManagerServerError(sender.get_statusCode()), sender);
            return;
        }

                        var reply = sender.get_responseData();
        var delimiterIndex, len, node, type, id, content;
        var replyIndex = 0;
        var parserError = false;

        while (replyIndex < reply.length) {
                        delimiterIndex = reply.indexOf(delimitByLengthDelimiter, replyIndex);
            if (delimiterIndex === -1) {
                parserError = true;
                break;
            }
            len = parseInt(reply.substring(replyIndex, delimiterIndex), 10);
            if ((len % 1) !== 0) {
                parserError = true;
                break;
            }
            replyIndex = delimiterIndex + 1;

                        delimiterIndex = reply.indexOf(delimitByLengthDelimiter, replyIndex);
            if (delimiterIndex === -1) {
                parserError = true;
                break;
            }
            type = reply.substring(replyIndex, delimiterIndex);
            replyIndex = delimiterIndex + 1;

                        delimiterIndex = reply.indexOf(delimitByLengthDelimiter, replyIndex);
            if (delimiterIndex === -1) {
                parserError = true;
                break;
            }
            id = reply.substring(replyIndex, delimiterIndex);
            replyIndex = delimiterIndex + 1;

                        content = this._decodeString(reply.substr(replyIndex, len));
            replyIndex += len + 1;

            delta.add({type: type, id: id, content: content});
        }

                if (parserError) {
            this._endPostBack(Error.pageRequestManagerParserError(), sender);
            return;
        }


        var updatePanelNodes = [];
        var hiddenFieldNodes = [];
        var arrayDeclarationNodes = [];
        var scriptBlockNodes = [];
        var expandoNodes = [];
        var onSubmitNodes = [];
        var dataItemNodes = [];
        var dataItemJsonNodes = [];
        var asyncPostBackControlIDsNode, postBackControlIDsNode,
            updatePanelIDsNode, asyncPostBackTimeoutNode,
            childUpdatePanelIDsNode, panelsToRefreshNode, formActionNode;

                for (var i = 0; i < delta.length; i++) {
            var deltaNode = delta[i];
            switch (deltaNode.type) {
                case "updatePanel":
                    updatePanelNodes.add(deltaNode);
                    break;
                case "hiddenField":
                    hiddenFieldNodes.add(deltaNode);
                    break;
                case "arrayDeclaration":
                    arrayDeclarationNodes.add(deltaNode);
                    break;
                case "scriptBlock":
                    scriptBlockNodes.add(deltaNode);
                    break;
                case "expando":
                    expandoNodes.add(deltaNode);
                    break;
                case "onSubmit":
                    onSubmitNodes.add(deltaNode);
                    break;
                case "asyncPostBackControlIDs":
                    asyncPostBackControlIDsNode = deltaNode;
                    break;
                case "postBackControlIDs":
                    postBackControlIDsNode = deltaNode;
                    break;
                case "updatePanelIDs":
                    updatePanelIDsNode = deltaNode;
                    break;
                case "asyncPostBackTimeout":
                    asyncPostBackTimeoutNode = deltaNode;
                    break;
                case "childUpdatePanelIDs":
                    childUpdatePanelIDsNode = deltaNode;
                    break;
                case "panelsToRefreshIDs":
                    panelsToRefreshNode = deltaNode;
                    break;
                case "formAction":
                    formActionNode = deltaNode;
                    break;
                case "dataItem":
                    dataItemNodes.add(deltaNode);
                    break;
                case "dataItemJson":
                    dataItemJsonNodes.add(deltaNode);
                    break;
                case "pageRedirect":
                    window.location = deltaNode.content;
                    return;
                case "error":
                                        this._endPostBack(Error.pageRequestManagerServerError(Number.parse(deltaNode.id), deltaNode.content), sender);
                    return;
                case "pageTitle":
                    document.title = deltaNode.content;
                    break;
                default:
                                        this._endPostBack(Error.pageRequestManagerParserError(), sender);
                    return;
            }
        }

        var i;

                if (asyncPostBackControlIDsNode && postBackControlIDsNode &&
            updatePanelIDsNode && panelsToRefreshNode &&
            asyncPostBackTimeoutNode && childUpdatePanelIDsNode) {

            this._oldUpdatePanelIDs = this._updatePanelIDs;
            var childUpdatePanelIDsString = childUpdatePanelIDsNode.content;
            this._childUpdatePanelIDs = childUpdatePanelIDsString.length ? childUpdatePanelIDsString.split(',') : [];

            var asyncPostBackControlIDsArray = this._splitNodeIntoArray(asyncPostBackControlIDsNode);
            var postBackControlIDsArray = this._splitNodeIntoArray(postBackControlIDsNode);
            var updatePanelIDsArray = this._splitNodeIntoArray(updatePanelIDsNode);
            this._panelsToRefreshIDs = this._splitNodeIntoArray(panelsToRefreshNode);

                                                for (i = 0; i < this._panelsToRefreshIDs.length; i++) {
                var panelClientID = this._uniqueIDToClientID(this._panelsToRefreshIDs[i]);
                if (!document.getElementById(panelClientID)) {
                    this._endPostBack(Error.invalidOperation(String.format(Sys.WebForms.Res.PRM_MissingPanel, panelClientID)), sender);
                    return;
                }
            }

            var asyncPostBackTimeout = asyncPostBackTimeoutNode.content;
            this._updateControls(updatePanelIDsArray, asyncPostBackControlIDsArray, postBackControlIDsArray, asyncPostBackTimeout);
        }

                this._dataItems = {};
        for (i = 0; i < dataItemNodes.length; i++) {
            var dataItemNode = dataItemNodes[i];
            this._dataItems[dataItemNode.id] = dataItemNode.content;
        }
        for (i = 0; i < dataItemJsonNodes.length; i++) {
            var dataItemJsonNode = dataItemJsonNodes[i];
            this._dataItems[dataItemJsonNode.id] = eval(dataItemJsonNode.content);
        }


        var handler = this._get_eventHandlerList().getHandler("pageLoading");
        if (handler) {
            handler(this, this._getPageLoadingEventArgs());
        }


                if (formActionNode) {
            this._form.action = formActionNode.content;
                                                this._form._initialAction = this._form.action;
        }

                for (i = 0; i < updatePanelNodes.length; i++) {
            var deltaUpdatePanel = updatePanelNodes[i];

            var deltaPanelID = deltaUpdatePanel.id;
            var deltaPanelRendering = deltaUpdatePanel.content;

            var updatePanelElement = document.getElementById(deltaPanelID);

            if (!updatePanelElement) {
                this._endPostBack(Error.invalidOperation(String.format(Sys.WebForms.Res.PRM_MissingPanel, deltaPanelID)), sender);
                return;
            }

            this._updatePanel(updatePanelElement, deltaPanelRendering);
        }

                for (i = 0; i < hiddenFieldNodes.length; i++) {
            var id = hiddenFieldNodes[i].id;
            var value = hiddenFieldNodes[i].content;

            var hiddenFieldElement = document.getElementById(id);
            if (!hiddenFieldElement) {
                                hiddenFieldElement = document.createElement('input');
                hiddenFieldElement.id = id;
                hiddenFieldElement.name = id;
                hiddenFieldElement.type = 'hidden';
                this._form.appendChild(hiddenFieldElement);
            }
            hiddenFieldElement.value = value;
        }

                var arrayScript = '';
        for (i = 0; i < arrayDeclarationNodes.length; i++) {
            arrayScript += "Sys.WebForms.PageRequestManager._addArrayElement('" + arrayDeclarationNodes[i].id + "', " + arrayDeclarationNodes[i].content + ");\r\n";
        }

                var expandoScript = '';
        for (i = 0; i < expandoNodes.length; i++) {
            var propertyReference = expandoNodes[i].id;
            var propertyValue = expandoNodes[i].content;
            expandoScript += propertyReference + " = " + propertyValue + "\r\n";
        }

        
                var existingScripts = document.getElementsByTagName('SCRIPT');
        for (i = existingScripts.length - 1; i >= 0; i--) {
            var scriptNode = existingScripts[i];
            var scriptSrc = scriptNode.src;
            if (scriptSrc.length) {
                if (!this._referencedScripts.contains(scriptSrc)) {
                    this._referencedScripts.add(scriptSrc);
                }
            }
        }

                                Sys.Application.beginCreateComponents();

        var scriptLoader = new Sys.WebForms._ScriptLoader();

                                        if (arrayScript.length) {
            scriptLoader.addScriptBlock(arrayScript);
        }
        if (expandoScript.length) {
            scriptLoader.addScriptBlock(expandoScript);
        }

        for (i = 0; i < scriptBlockNodes.length; i++) {
            var scriptBlockType = scriptBlockNodes[i].id;
            switch (scriptBlockType) {
                case "ScriptContentNoTags":
                                        scriptLoader.addScriptBlock(scriptBlockNodes[i].content);
                    break;
                case "ScriptContentWithTags":
                                        var scriptTagAttributes;
                    eval("scriptTagAttributes = " + scriptBlockNodes[i].content);
                    scriptLoader.addCustomScriptTag(scriptTagAttributes);
                    break;
                case "ScriptPath":
                    
                                                                                
                    var dummyScript = document.createElement('script');
                    dummyScript.src = scriptBlockNodes[i].content;

                    if (this._referencedScripts.contains(dummyScript.src)) {
                        continue;
                    }

                                        scriptLoader.addScriptReference(scriptBlockNodes[i].content);
                    break;
            }
        }


                        var onSubmitStatementScript = '';
        for (var i = 0; i < onSubmitNodes.length; i++) {
            if (i === 0) {
                onSubmitStatementScript = 'Sys.WebForms.PageRequestManager.getInstance()._onSubmitStatements.add(function() {\r\n';
            }

            onSubmitStatementScript += onSubmitNodes[i].content + "\r\n";
        }
        if (onSubmitStatementScript.length) {
            onSubmitStatementScript += "\r\nreturn true;\r\n});\r\n";
            scriptLoader.addScriptBlock(onSubmitStatementScript);
        }

                this._response = sender;

        scriptLoader.loadScripts(Function.createDelegate(this, this._scriptsLoadComplete));

                    }

    function Sys$WebForms$PageRequestManager$_onWindowUnload(evt) {
        this.dispose();
    }

    function Sys$WebForms$PageRequestManager$_pageLoaded(initialLoad) {
        var handler = this._get_eventHandlerList().getHandler("pageLoaded");
        if (handler) {
            handler(this, this._getPageLoadedEventArgs(initialLoad));
        }
        if (!initialLoad) {
                                    Sys.Application.raiseLoad();
        }
    }

    function Sys$WebForms$PageRequestManager$_pageLoadedInitialLoad(evt) {
        this._pageLoaded(true);
    }

    function Sys$WebForms$PageRequestManager$_scriptsLoadComplete() {
                        

                                                if (window.__theFormPostData) {
            window.__theFormPostData = "";
        }
        if (window.__theFormPostCollection) {
            window.__theFormPostCollection = [];
        }
        if (window.WebForm_InitCallback) {
            window.WebForm_InitCallback();
        }

                if (this._scrollPosition) {
                        if (window.scrollTo) {
                window.scrollTo(this._scrollPosition.x, this._scrollPosition.y);
            }
            this._scrollPosition = null;
        }

        Sys.Application.endCreateComponents();
        
                this._pageLoaded(false);

        this._endPostBack(null, this._response);
        this._response = null;
    }

    function Sys$WebForms$PageRequestManager$_splitNodeIntoArray(node) {
        var str = node.content;
        var arr = str.length ? str.split(',') : [];
        return arr;
    }

    function Sys$WebForms$PageRequestManager$_uniqueIDToClientID(uniqueID) {
                return uniqueID.replace(/\$/g, '_');
    }

    function Sys$WebForms$PageRequestManager$_updateControls(updatePanelIDs, asyncPostBackControlIDs, postBackControlIDs, asyncPostBackTimeout) {
        if (updatePanelIDs) {
                                                this._updatePanelIDs = new Array(updatePanelIDs.length);
            this._updatePanelClientIDs = new Array(updatePanelIDs.length);
            this._updatePanelHasChildrenAsTriggers = new Array(updatePanelIDs.length);
            for (var i = 0; i < updatePanelIDs.length; i++) {
                var realPanelID = updatePanelIDs[i].substr(1);
                var childrenAsTriggers = (updatePanelIDs[i].charAt(0) === 't');

                                this._updatePanelHasChildrenAsTriggers[i] = childrenAsTriggers;
                this._updatePanelIDs[i] = realPanelID;
                this._updatePanelClientIDs[i] = this._uniqueIDToClientID(realPanelID);
            }
            this._asyncPostBackTimeout = asyncPostBackTimeout * 1000;
        }
        else {
            this._updatePanelIDs = [];
            this._updatePanelClientIDs = [];
            this._updatePanelHasChildrenAsTriggers = [];
            this._asyncPostBackTimeout = 0;
        }

        this._asyncPostBackControlIDs = [];
        this._asyncPostBackControlClientIDs = [];
        this._convertToClientIDs(asyncPostBackControlIDs, this._asyncPostBackControlIDs, this._asyncPostBackControlClientIDs);

        this._postBackControlIDs = [];
        this._postBackControlClientIDs = [];
        this._convertToClientIDs(postBackControlIDs, this._postBackControlIDs, this._postBackControlClientIDs);
    }

    function Sys$WebForms$PageRequestManager$_updatePanel(updatePanelElement, rendering) {
        this._destroyTree(updatePanelElement);

                updatePanelElement.innerHTML = rendering;
    }

    function Sys$WebForms$PageRequestManager$_validPosition(position) {
        return (typeof(position) !== "undefined") && (position !== null) && (position !== 0);
    }
Sys.WebForms.PageRequestManager.prototype = {

    _get_eventHandlerList: Sys$WebForms$PageRequestManager$_get_eventHandlerList,

    get_isInAsyncPostBack: Sys$WebForms$PageRequestManager$get_isInAsyncPostBack,

        add_beginRequest: Sys$WebForms$PageRequestManager$add_beginRequest,
    remove_beginRequest: Sys$WebForms$PageRequestManager$remove_beginRequest,

    add_endRequest: Sys$WebForms$PageRequestManager$add_endRequest,
    remove_endRequest: Sys$WebForms$PageRequestManager$remove_endRequest,

    add_initializeRequest: Sys$WebForms$PageRequestManager$add_initializeRequest,
    remove_initializeRequest: Sys$WebForms$PageRequestManager$remove_initializeRequest,

    add_pageLoaded: Sys$WebForms$PageRequestManager$add_pageLoaded,
    remove_pageLoaded: Sys$WebForms$PageRequestManager$remove_pageLoaded,

    add_pageLoading: Sys$WebForms$PageRequestManager$add_pageLoading,
    remove_pageLoading: Sys$WebForms$PageRequestManager$remove_pageLoading,

    abortPostBack: Sys$WebForms$PageRequestManager$abortPostBack,

    _createPostBackSettings: Sys$WebForms$PageRequestManager$_createPostBackSettings,

    _convertToClientIDs: Sys$WebForms$PageRequestManager$_convertToClientIDs,

    _decodeString: Sys$WebForms$PageRequestManager$_decodeString,

    _destroyTree: Sys$WebForms$PageRequestManager$_destroyTree,

    dispose: Sys$WebForms$PageRequestManager$dispose,

        _doPostBack: Sys$WebForms$PageRequestManager$_doPostBack,

    _elementContains: Sys$WebForms$PageRequestManager$_elementContains,

    _endPostBack: Sys$WebForms$PageRequestManager$_endPostBack,

            _findNearestElement: Sys$WebForms$PageRequestManager$_findNearestElement,

    _getPageLoadedEventArgs: Sys$WebForms$PageRequestManager$_getPageLoadedEventArgs,

    _getPageLoadingEventArgs: Sys$WebForms$PageRequestManager$_getPageLoadingEventArgs,

    _getPostBackSettings: Sys$WebForms$PageRequestManager$_getPostBackSettings,

    _getScrollPosition: Sys$WebForms$PageRequestManager$_getScrollPosition,

    _initializeInternal: Sys$WebForms$PageRequestManager$_initializeInternal,

    _matchesParentIDInList: Sys$WebForms$PageRequestManager$_matchesParentIDInList,

    _onFormElementClick: Sys$WebForms$PageRequestManager$_onFormElementClick,

    _onFormSubmit: Sys$WebForms$PageRequestManager$_onFormSubmit,

    _onFormSubmitCompleted: Sys$WebForms$PageRequestManager$_onFormSubmitCompleted,

    _onWindowUnload: Sys$WebForms$PageRequestManager$_onWindowUnload,

    _pageLoaded: Sys$WebForms$PageRequestManager$_pageLoaded,

    _pageLoadedInitialLoad: Sys$WebForms$PageRequestManager$_pageLoadedInitialLoad,

    _scriptsLoadComplete: Sys$WebForms$PageRequestManager$_scriptsLoadComplete,

    _splitNodeIntoArray: Sys$WebForms$PageRequestManager$_splitNodeIntoArray,

    _uniqueIDToClientID: Sys$WebForms$PageRequestManager$_uniqueIDToClientID,

    _updateControls: Sys$WebForms$PageRequestManager$_updateControls,

    _updatePanel: Sys$WebForms$PageRequestManager$_updatePanel,

    _validPosition: Sys$WebForms$PageRequestManager$_validPosition
}

Sys.WebForms.PageRequestManager.getInstance = function Sys$WebForms$PageRequestManager$getInstance() {
    /// <returns type="Sys.WebForms.PageRequestManager"></returns>
    if (arguments.length !== 0) throw Error.parameterCount();
    return Sys.WebForms.PageRequestManager._instance || null;
}

Sys.WebForms.PageRequestManager._addArrayElement = function Sys$WebForms$PageRequestManager$_addArrayElement(arrayName, arrayValue) {
    if (typeof(window[arrayName]) === "undefined") {
                window[arrayName] = [ arrayValue ];
    }
    else {
                window[arrayName].add(arrayValue);
    }
}

Sys.WebForms.PageRequestManager._initialize = function Sys$WebForms$PageRequestManager$_initialize(scriptManagerID, formElement) {
    if (Sys.WebForms.PageRequestManager.getInstance()) {
        throw Error.invalidOperation(Sys.WebForms.Res.PRM_CannotRegisterTwice);
    }
    Sys.WebForms.PageRequestManager._instance = new Sys.WebForms.PageRequestManager();
    Sys.WebForms.PageRequestManager.getInstance()._initializeInternal(scriptManagerID, formElement);
}

Sys.WebForms.PageRequestManager.registerClass('Sys.WebForms.PageRequestManager');




Sys.WebForms._ScriptLoader = function Sys$WebForms$_ScriptLoader() {
    this._scriptsToLoad = [];
    this._loadComplete = null;
    this._currentLoadingScript = null;
}


    function Sys$WebForms$_ScriptLoader$addCustomScriptTag(scriptAttributes) {
        this._scriptsToLoad.add(scriptAttributes);
    }

    function Sys$WebForms$_ScriptLoader$addScriptBlock(scriptContent) {
        this._scriptsToLoad.add({text: scriptContent});
    }

    function Sys$WebForms$_ScriptLoader$addScriptReference(scriptUrl) {
        this._scriptsToLoad.add({src: scriptUrl});
    }

    function Sys$WebForms$_ScriptLoader$_clearScript(scriptElement) {
        if (!window.debug.isDebug) {
                                    var headElement = document.getElementsByTagName('HEAD')[0];
            headElement.removeChild(scriptElement);
        }
    }

    function Sys$WebForms$_ScriptLoader$loadScripts(loadCompleteHandler) {
        
                                                
        this._loadComplete = loadCompleteHandler;
        this._loadScriptsInternal();
    }

    function Sys$WebForms$_ScriptLoader$_loadScriptsInternal() {
                
                var currentScript = this._currentLoadingScript;
        if (currentScript) {
            if ((currentScript.readyState !== 'loaded') &&
                (currentScript.readyState !== 'complete')) {
                return;
            }
            else {
                if (Sys.Browser.agent !== Sys.Browser.InternetExplorer) {
                    Sys.UI.DomEvent.removeHandler(this._currentLoadingScript, 'load', this._scriptElementLoadCompleteHandler);
                }
                else {
                    Sys.UI.DomEvent.removeHandler(this._currentLoadingScript, 'readystatechange', this._scriptElementLoadCompleteHandler);
                }

                this._scriptElementLoadCompleteHandler = null;
                this._clearScript(this._currentLoadingScript);
                this._currentLoadingScript = null;
            }
        }

                if (this._scriptsToLoad && this._scriptsToLoad.length > 0) {
            var nextScript = this._scriptsToLoad.dequeue();

                        var scriptElement = document.createElement('SCRIPT');

                                    scriptElement.type = 'text/javascript';

                        for (var attr in nextScript) {
                scriptElement[attr] = nextScript[attr];
            }

            var isInline = false;
            if (scriptElement.text) {
                if (Sys.Browser.agent === Sys.Browser.Safari) {
                                        scriptElement.innerHTML = scriptElement.text;
                    delete scriptElement.text;
                }
                isInline = true;
            }

            if (!isInline) {
                                                                this._currentLoadingScript = scriptElement;

                this._scriptElementLoadCompleteHandler = Function.createDelegate(this, this._loadScriptsInternal);
                if (Sys.Browser.agent !== Sys.Browser.InternetExplorer) {
                    scriptElement.readyState = 'loaded';
                    Sys.UI.DomEvent.addHandler(this._currentLoadingScript, 'load', this._scriptElementLoadCompleteHandler);
                }
                else {
                    Sys.UI.DomEvent.addHandler(this._currentLoadingScript, 'readystatechange', this._scriptElementLoadCompleteHandler);
                }
            }

                        var headElement = document.getElementsByTagName('HEAD')[0];
            headElement.appendChild(scriptElement);

            if (isInline) {
                                                                this._clearScript(scriptElement);
                this._loadScriptsInternal();
            }
        }
        else {
                        if (this._loadComplete) {
                                this._loadComplete();
            }
        }
    }
Sys.WebForms._ScriptLoader.prototype = {
    addCustomScriptTag: Sys$WebForms$_ScriptLoader$addCustomScriptTag,

    addScriptBlock: Sys$WebForms$_ScriptLoader$addScriptBlock,

    addScriptReference: Sys$WebForms$_ScriptLoader$addScriptReference,

    _clearScript: Sys$WebForms$_ScriptLoader$_clearScript,

    loadScripts: Sys$WebForms$_ScriptLoader$loadScripts,

    _loadScriptsInternal: Sys$WebForms$_ScriptLoader$_loadScriptsInternal
}

Sys.WebForms._ScriptLoader.registerClass('Sys.WebForms._ScriptLoader');