//-----------------------------------------------------------------------
// Copyright (C) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------
// MicrosoftAjaxTemplates.js
// Microsoft AJAX Templating Framework.

Type.registerNamespace("Sys.UI");

Sys.Application.get_isDisposing = function Sys$Application$get_isDisposing() {
    return this._disposing;
}

Sys.Application.disposeElement = function Sys$Application$disposeElement(element, childNodesOnly) {
    /// <param name="element"></param>
    /// <param name="childNodesOnly" type="Boolean"></param>
    var e = Function._validateParams(arguments, [
        {name: "element"},
        {name: "childNodesOnly", type: Boolean}
    ]);
    if (e) throw e;

            this._disposeElementRecursive(element);
    if (!childNodesOnly && element.nodeType === 1) {
        this._disposeElementInternal(element);
    }
}
Sys.Application._disposeElementRecursive = function Sys$Application$_disposeElementRecursive(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) {
                Sys.Application._disposeElementInternal(node);
                this._disposeElementRecursive(node);
            }
        }
    }
}
Sys.Application._disposeElementInternal = function Sys$Application$_disposeElementInternal(element) {
            var d = element.dispose;
    if (d && typeof(d) === "function") {
        element.dispose();
    }
    else {
        var c = element.control;
        if (c && typeof(c.dispose) === "function") {
            c.dispose();
        }
    }
    var behaviors = element._behaviors;
    if (behaviors) {
        for (var i = behaviors.length - 1; i >= 0; i--) {
            behaviors[i].dispose();
        }
    }
}

Sys.Application._resolveElement = function Sys$Application$_resolveElement(elementOrId) {
    if (!elementOrId) return null;
    var e = elementOrId;
    if (typeof(elementOrId) === "string") {
        e = Sys.UI.DomElement.getElementById(elementOrId);
        if (!e) {
            throw Error.invalidOperation(String.format(Sys.TemplateRes.elementNotFound, elementOrId));
        }
    }
    else if (!Sys.UI.DomElement.isDomElement(e)) {
        throw Error.argument("value", Sys.TemplateRes.expectedElementOrId);    
    }
    return e;
}
Sys.UI.DomElement._oldGetElementById = Sys.UI.DomElement.getElementById;
Sys.UI.DomElement.getElementById = function Sys$UI$DomElement$getElementById(id, element) {
    /// <param name="id" type="String"></param>
    /// <param name="element" domElement="true" optional="true" mayBeNull="true"></param>
    /// <returns domElement="true" mayBeNull="true"></returns>
    var e = Function._validateParams(arguments, [
        {name: "id", type: String},
        {name: "element", mayBeNull: true, domElement: true, optional: true}
    ]);
    if (e) throw e;

    var e = Sys.UI.DomElement._oldGetElementById(id, element);
    if (!e && !element && Sys.UI.Template._contexts.length) {
                var contexts = Sys.UI.Template._contexts;
        for (var i = 0, l = contexts.length; i < l; i++) {
            var context = contexts[i];
            for (var j = 0, m = context.length; j < m; j++) {
                var c = context[j];
                if (c.nodeType === 1) {
                    if (c.id === id) return c;
                    e = Sys.UI.DomElement._oldGetElementById(id, c);
                    if (e) return e;
                }
            }
        }
    }
    return e;
}
if ($get === Sys.UI.DomElement._oldGetElementById) {
    $get = Sys.UI.DomElement.getElementById;
}

Sys.UI.DomElement.isDomElement = function Sys$UI$DomElement$isDomElement(obj) {
                            var val = false;
    if (typeof(obj.nodeType) !== 'number') {
                                var doc = obj.ownerDocument || obj.document || obj;
        if (doc != obj) {
                                    var w = doc.defaultView || doc.parentWindow;
                        val = (w != obj) && !(w.document && obj.document && (w.document === obj.document));
        }
        else {
                                    val = (typeof(doc.body) === 'undefined');
        }
    }
    return !val;
}

Sys.UI.DomElement.raiseBubbleEvent = function Sys$UI$DomElement$raiseBubbleEvent(source, args) {
    /// <param name="source" domElement="true"></param>
    /// <param name="args" type="Sys.EventArgs"></param>
    var e = Function._validateParams(arguments, [
        {name: "source", domElement: true},
        {name: "args", type: Sys.EventArgs}
    ]);
    if (e) throw e;

    var target = source.parentNode;
    while (target) {
        var control = target.control;
        if (control && control.onBubbleEvent && control.raiseBubbleEvent) {
            if (control.onBubbleEvent(source, args)) {
                return;
            }
            control.raiseBubbleEvent(source, args);
            return;
        }
        target = target.parentNode;
    }
}
Sys.Application.registerMarkupExtension = function Sys$Application$registerMarkupExtension(extensionName, extension, isExpression) {
    /// <param name="extensionName" type="String"></param>
    /// <param name="extension" type="Function"></param>
    /// <param name="isExpression" type="Boolean" optional="true"></param>
    var e = Function._validateParams(arguments, [
        {name: "extensionName", type: String},
        {name: "extension", type: Function},
        {name: "isExpression", type: Boolean, optional: true}
    ]);
    if (e) throw e;

    if (!this._extensions) {
        this._extensions = {};
    }
    isExpression = ((typeof (isExpression) === "undefined") || (isExpression === true));
    this._extensions[extensionName] = { expression: isExpression, extension: extension };
}
Sys.Application._getMarkupExtension = function Sys$Application$_getMarkupExtension(name) {
    var extension = this._extensions ? this._extensions[name] : null;
    if (!extension) {
        throw Error.invalidOperation(String.format(Sys.TemplateRes.cannotFindMarkupExtension, name));
    }
    return extension;
}
Sys.Application._caseIndex = {};
Sys.Application._prototypeIndex = {};

Sys.Application.processNode = function Sys$Application$processNode(element, context, recursive) {
    /// <param name="element" domElement="true"></param>
    /// <param name="context" optional="true" mayBeNull="true"></param>
    /// <param name="recursive" optional="true" mayBeNull="false"></param>
    /// <returns type="Array" elementType="Sys.Component"></returns>
    var e = Function._validateParams(arguments, [
        {name: "element", domElement: true},
        {name: "context", mayBeNull: true, optional: true},
        {name: "recursive", optional: true}
    ]);
    if (e) throw e;

    context = { userContext: context, localContext: {} };
    return Sys.Application._processNodeWithMappings(
        Sys.Application._getNamespaceMappings(null, [element]),
        element, context, recursive);
}
Sys.Application.processNodes = function Sys$Application$processNodes(elements, context, recursive) {
    /// <param name="elements" type="Array" elementDomElement="true"></param>
    /// <param name="context" optional="true" mayBeNull="true"></param>
    /// <param name="recursive" optional="true" mayBeNull="false"></param>
    /// <returns type="Array" elementType="Sys.Component"></returns>
    var e = Function._validateParams(arguments, [
        {name: "elements", type: Array},
        {name: "context", mayBeNull: true, optional: true},
        {name: "recursive", optional: true}
    ]);
    if (e) throw e;

    var element, components = [];
    context = { userContext: context, localContext: {} };
    for (var i = 0, l = elements.length; i < l; i++) {
        element = elements[i];
        Array.addRange(components, Sys.Application._processNodeWithMappings(
            Sys.Application._getNamespaceMappings(null, [element]),
            element, context, recursive));
    }
    return components;
}
Sys.Application._processNodeWithMappings = function Sys$Application$_processNodeWithMappings(namespaceMappings, element, context, recursive) {
    var components = [];
    Sys.Application._processNodeInternal(element, namespaceMappings, components, context, recursive);
        for (var i = components.length - 1; i > -1; i--) {
        var component = components[i];
        if (Sys.Component.isInstanceOfType(component)) {
            component.endUpdate();
        }
    }
    return components;
}
Sys.Application._processNodeInternal = function Sys$Application$_processNodeInternal(element, namespaceMappings, components, context, recursive) {
        if (element.__msajaxactivated) return;
    var i, l, instance, types = null, key = null, command = null;
            try {
        types = element.getAttribute(namespaceMappings.types);
    }
    catch (err) {
    }
    try {
        key = element.getAttribute(namespaceMappings.sysKey);
    }
    catch (err) {
    }
    if (key) {
        context.localContext[key] = element;
    }
    if (types) {
        element.__msajaxactivated = true;
        var typeList = types.split(',');
                var index = {};
        var localComponents = [];
        for (i = 0, l = typeList.length; i < l; i++) {
            var typeName = typeList[i].trim();
            if (index[typeName]) continue;             var type = namespaceMappings.namespaces[typeName];
            if (!type) {
                throw Error.invalidOperation(String.format(Sys.TemplateRes.invalidAttach, namespaceMappings.types, typeName));
            }
            var isComponent = type.inheritsFrom(Sys.Component);
            instance = isComponent && (type.inheritsFrom(Sys.UI.Behavior) || type.inheritsFrom(Sys.UI.Control)) ?
                        new type(element) : new type();
            if (isComponent) {
                localComponents.push(instance);
                instance.beginUpdate();
            }
            index[typeName] = { instance: instance, typeName: typeName, type: type};
            components.push(instance);
        }
                                for (i = 0, l = element.attributes.length; i < l; i++) {
            var attribute = element.attributes[i];
            if (!attribute.specified) continue;
            var nodeName = attribute.nodeName;
            if ((nodeName === namespaceMappings.sysKey) || (nodeName === namespaceMappings.types)) continue;
            var attrib = Sys.Application._splitAttribute(nodeName),
                ns = attrib.ns;
            if (!ns) continue;
            var entry = index[ns];
                        if (!entry) continue;
            if (attrib.name === "sys-key") {
                context.localContext[attribute.nodeValue] = entry.instance;
            }
            else {
                Sys.Application._setProperty(entry.instance, entry.type, attrib.name, attribute.nodeValue, context);
            }
        }
        var app = Sys.Application, creatingComponents = app.get_isCreatingComponents();
        for (i = 0, l = localComponents.length; i < l; i++) {
            instance = localComponents[i];
            if (instance.get_id()) {
                app.addComponent(instance);
            }
            if (creatingComponents) {
                app._createdComponents[app._createdComponents.length] = instance;
            }
        }
    }
            try {
        command = element.getAttribute(namespaceMappings.sysCommand);
    }
    catch (err) {
    }
    if (command) {
        var commandArg = null;
        try {
            commandArg = element.getAttribute(namespaceMappings.sysCommandArgument);
        }
        catch (err) {
        }
        Sys.UI.DomEvent.addHandler(element, 'click', Sys.UI.Template._getCommandHandler(command, commandArg));
    }
    if (recursive || (typeof(recursive) === "undefined")) {
        var className = element.className;
                if (!Sys.UI.Template._isTemplate(element)) {
            for (i = 0, l = element.childNodes.length; i < l; i++) {
                var node = element.childNodes[i];
                                if (node.nodeType === 1) {
                    Sys.Application._processNodeInternal(node, namespaceMappings, components, context, true);
                }
            }
        }
    }
}
Sys.Application._splitAttribute = function Sys$Application$_splitAttribute(attributeName) {
    var nameParts = attributeName.split(':'),
            ns = nameParts.length > 1 ? nameParts[0] : null,
            name = nameParts[ns ? 1 : 0];
    return { ns: ns, name: name };
}
Sys.Application._getBodyNamespaceMapping = function Sys$Application$_getBodyNamespaceMapping() {
    if (Sys.Application._bodyNamespaceMapping) {
        return Sys.Application._bodyNamespaceMapping;
    }
    var namespaceMapping = {
        sysNamespace: "sys", types: "sys:attach", sysId: "sys:id", sysKey: "sys:key",
        sysActivate: "sys:activate", sysChecked: "sys:checked", styleNamespace: "style",
        classNamespace: "class", namespaces: {}, 
        sysCommandArgument: "sys:commandargument", sysCommand: "sys:command"
    };
    Sys.Application._getNamespaceMapping(namespaceMapping, document.body);
    Sys.Application._bodyNamespaceMapping = namespaceMapping;
    return namespaceMapping;
}
Sys.Application._getNamespaceMappings = function Sys$Application$_getNamespaceMappings(existingMapping, elements) {
    var namespaceMappings = existingMapping || Sys.Application._getBodyNamespaceMapping();
    for (var i = 0, l = elements.length; i < l; i++) {
        Sys.Application._getNamespaceMapping(namespaceMappings, elements[i]);
    }
    return namespaceMappings;
}
Sys.Application._getNamespaceMapping = function Sys$Application$_getNamespaceMapping(namespaceMapping, element) {
    var attributes = element.attributes;
    for (var i = 0, l = attributes.length; i < l; i++) {
        var attribute = attributes[i];
        if (!attribute.specified) continue;
        var attrib = Sys.Application._splitAttribute(attribute.nodeName);
        if (attrib.ns !== "xmlns") continue;
        var name = attrib.name;
        var value = attribute.nodeValue.trim();
                if (value.toLowerCase().startsWith("javascript:")) {
            value = value.substr(11).trimStart();
            if (value === "Sys") {
                with(namespaceMapping) {
                    sysNamespace = name;
                    types = name + ":attach";
                    sysId = name + ":id";
                    sysChecked = name + ":checked";
                    sysActivate = name + ":activate";
                    sysKey = name + ":key";
                    sysCommandArgument = name + ":commandargument";
                    sysCommand = name + ":command";
                }
            }
            else {
                                                try {
                    namespaceMapping.namespaces[name] = Type.parse(value);
                }
                catch(e) {
                    throw Error.invalidOperation(String.format(Sys.TemplateRes.invalidTypeNamespace, value));
                }
            }
        }
        else if (value === "http://schemas.microsoft.com/aspnet/style") {
            namespaceMapping.styleNamespace = name;
        }
        else if (value === "http://schemas.microsoft.com/aspnet/class") {
            namespaceMapping.classNamespace = name;
        }
    }
}
Sys.Application._getExtensionCode = function Sys$Application$_getExtensionCode(extension, doEval, context) {
    var name, properties, propertyBag = {}, spaceIndex = extension.indexOf(' ');
    if (spaceIndex !== -1) {
        name = extension.substr(0, spaceIndex);
        properties = extension.substr(spaceIndex + 1).trim();
        if (properties) {
            properties = properties.replace(/\\,/g, '\u0000').split(",");
            for (var i = 0, l = properties.length; i < l; i++) {
                var property = properties[i].replace(/\u0000/g, ","),
                        equalIndex = property.indexOf('='),
                        pValue, pName;
                if (equalIndex !== -1) {
                    pName = property.substr(0, equalIndex).trim();
                    pValue = property.substr(equalIndex + 1).trim();
                    if (doEval) {
                                                pValue = this._getPropertyValue(null, null, pValue, context, true);
                    }
                }
                else {
                    pName = "$default";
                    pValue = property.trim();
                }
                propertyBag[pName] = pValue;
            }
        }
    }
    else {
        name = extension;
    }
    return { instance: Sys.Application._getMarkupExtension(name), name: name, properties: propertyBag };
}

Sys.Application._getPropertyValue = function Sys$Application$_getPropertyValue(target, name, value, context, isExtension) {
    var propertyValue = value;
    if (value.startsWith("{{") && value.endsWith("}}")) {
        propertyValue = this._evaluateExpression(value.slice(2, -2), context);
    }
    else if (!isExtension && value.startsWith("{") && value.endsWith("}")) {
        var extension = this._getExtensionCode(value.slice(1, -1), true, context);
        propertyValue = extension.instance.extension(target, name, extension.properties);
    }
    return propertyValue;
}
Sys.Application._setProperty = function Sys$Application$_setProperty(target, type, name, value, context) {
    value = Sys.Application._getPropertyValue(target, name, value, context);
    if (typeof(value) === "undefined") {
        return;
    }
    var map = Sys.Application._translateName(name, type),
        mapname = map.name;
    if (map.type === 1) {
        map.setter.call(target, value);
    }
    else if (map.type === 2) {
        map.setter.call(target, typeof(value) === "function" ? value : new Function("sender", "args", value));
    }
    else {
        target[mapname] = value;
    }
}
Sys.Application._tryName = function Sys$Application$_tryName(name, type) {
    var prototype = type.prototype,
        setterName = "set_" + name, setter = prototype[setterName];
    if (setter) {
        return { name: name, setterName: setterName, setter: setter, type: 1 };
    }
    if (name.startsWith('on')) {
        setterName = "add_" + name.substr(2);
        var adder = prototype[setterName];
        if (adder) {
            return { name: name, setterName: setterName, setter: adder, type: 2 };
        }
    }
    if (typeof(prototype[name]) !== "undefined") {
        return { name: name };
    }
    return null;
}
Sys.Application._translateName = function Sys$Application$_translateName(name, type) {
    if (name && (name !== name.toLowerCase())) {
        throw Error.invalidOperation(String.format(Sys.TemplateRes.invalidAttributeName, name));
    }
    var cache, index = Sys.Application._prototypeIndex[type.__typeName];
    if (index) {
        cache = index[name];
        if (cache) return cache;
    }
    else {
        index = {};
    }    
    type.resolveInheritance();
    cache = Sys.Application._tryName(name, type);
    if (!cache) {
        var casedName = Sys.Application._mapToPrototype(name, type);
        if (casedName && (casedName !== name)) {
            cache = Sys.Application._tryName(casedName, type);
        }
        if (!cache) {
            cache = { name: name };
        }
    }
    index[name] = cache;
    return cache;
}
Sys.Application._mapToPrototype = function Sys$Application$_mapToPrototype(name, type) {
        var fixedName, caseIndex = Sys.Application._caseIndex[type.__typeName];
    if (!caseIndex) {
        caseIndex = {};
        type.resolveInheritance();
        for (var memberName in type.prototype) {
            if (memberName.startsWith("get_") || memberName.startsWith("set_") || memberName.startsWith("add_")) {
                memberName = memberName.substr(4);
            }
            else if (memberName.startsWith("remove_")) {
                memberName = memberName.substr(7);
            }
            caseIndex[memberName.toLowerCase()] = memberName;
        }
        Sys.Application._caseIndex[type.__typeName] = caseIndex;
    }
    name = name.toLowerCase();
        if (name.startsWith('on')) {
        fixedName = caseIndex[name.substr(2)];
                if (fixedName) {
            fixedName = "on" + fixedName;
        }
        else {
            fixedName = caseIndex[name];
        }
    }
    else {
                fixedName = caseIndex[name];
    }
    return fixedName;
}
Sys.Application._doEval = function Sys$Application$_doEval($expression, $context) {
    with($context.localContext) {
        with($context.userContext || {}) {
            return eval("(" + $expression + ")");
        }
    }
}
Sys.Application._evaluateExpression = function Sys$Application$_evaluateExpression($expression, $context) {
    return Sys.Application._doEval.call($context.userContext, $expression, $context);
}

Sys.Application._activateOnPartial = function Sys$Application$_activateOnPartial(panel, rendering) {
    var match = Sys.Application._activateList, hasSpan = false;
    if (rendering.indexOf("<!--*") !== -1) {
                                rendering = '<span style="display:none !important">&nbsp;</span>' + rendering;
        hasSpan = true;
    }
    this._updatePanelOld(panel, rendering);
    if (hasSpan) {
                        var span = panel.childNodes[0];
        if (span && (span.nodeType === 1) && (span.tagName.toUpperCase() === "SPAN")) {
            panel.removeChild(span);
        }
    }
    var update = (match === "*" || (panel.id && Array.contains(match, panel.id)));
    if (!update) {
        var node = panel;
        do {
            node = node.parentNode;
            if (node && node.id && Array.contains(match, node.id)) {
                update = true;
                break;
            }
        }
        while (node);
    }
    if (update) {
        Sys.Application.processNode(panel);
    }
}

Sys.Application._activateDOM = function Sys$Application$_activateDOM() {
    var namespaceMapping = Sys.Application._getBodyNamespaceMapping(),
        activateList = document.body.getAttribute(namespaceMapping.sysActivate),
        activateIds;
    if (!activateList) return;
    if (activateList === "*") {
        Sys.Application.processNode(document.body);
    }
    else {
        var elements = [], activateIds = activateList.split(',');
        for (var i = 0, l = activateIds.length; i < l; i++) {
            var e = document.getElementById(activateIds[i].trim());
            if (!e) {
                throw Error.invalidOperation(String.format(Sys.TemplateRes.cannotActivate, activateIds[i]));
            }
            elements.push(e);
        }
        Sys.Application.processNodes(elements);
    }
    if (Sys.WebForms && Sys.WebForms.PageRequestManager) {
        Sys.Application._activateList = activateIds || activateList;
        var prm = Sys.WebForms.PageRequestManager.getInstance();
        prm._updatePanelOld = prm._updatePanel;
        prm._updatePanel = Sys.Application._activateOnPartial;
    }
}

Sys.Application.add_init(Sys.Application._activateDOM);
Sys.UI.Template = function Sys$UI$Template(element) {
    /// <param name="element" domElement="true"></param>
    var e = Function._validateParams(arguments, [
        {name: "element", domElement: true}
    ]);
    if (e) throw e;

    this._element = element;
    this._instantiateIn = null;
    this._instanceId = 0;
}

    function Sys$UI$Template$get_element() {
    if (arguments.length !== 0) throw Error.parameterCount();
        return this._element;
    }
    function Sys$UI$Template$dispose() {
        this._element = null;
        this._instantiateIn = null;
    }
    function Sys$UI$Template$_appendTextNode(code, storeElementCode, text) {
        code.push(storeElementCode + "document.createTextNode(" +
                    Sys.Serialization.JavaScriptSerializer.serialize(text) +
                    "));\n");
    }
    function Sys$UI$Template$_appendAttributeSetter(namespaceMappings, code, typeIndex, attrib, expression, isExpression, booleanValue) {
        var ns = attrib.ns, name = attrib.name;
        switch (attrib.type) {
            case 1:                 if (isExpression) {
                    code.push("  $component = $element;\n  $element." + name + " = " + expression + ";\n;");
                }
                else {
                                        code.push("  $component = $element;\n  " + expression + ";\n;");
                }
                return;
            case 2:                                 name = Sys.Serialization.JavaScriptSerializer.serialize(name);
                code.push("  $component = $element;\n    (" + expression +
                            ") ? Sys.UI.DomElement.addCssClass($element, " + name +
                            ") : Sys.UI.DomElement.removeCssClass($element, " + name + ");\n");
                return;
            case 3:                 code.push("  $component = __componentIndex['" + ns + "'];\n");        
                code.push("  __context[" + expression + "] = $component;\n");            
                return;
            case 4:                 code.push("  $component = __componentIndex['" + ns + "'];\n");
                if (isExpression) {
                    var map = attrib.map;
                    if (map.type === 1) {
                        code.push("  $component." + map.setterName + "(" + expression + ");\n");
                    }
                    else if (map.type === 2) {
                        code.push("  __f = " + expression + ";\n");
                        code.push("  $component." + map.setterName + '(typeof(__f) === "function" ? __f : new Function("sender", "args", __f));\n');
                    }
                    else {
                        code.push("  $component." + map.name + " = " + expression + ";\n");
                    }
                }
                else {
                    code.push("  " + expression + ";\n");
                }
                return;
            case 5:                 this["_" + name] = expression;
                return;
            default:                 if (isExpression) {
                    var lowerName = name.toLowerCase();
                    if (lowerName.startsWith('on')) {
                                                code.push("  $component = $element;\n  $element." + name + " = new Function(" + expression + ");\n");
                    }
                    else if (lowerName === "style") {
                                                                        code.push("  $component = $element;\n  $element.style.cssText = " + expression + ";\n");
                    }
                    else {
                        if (booleanValue) {
                                                                                    code.push("  $component = $element;\n  if (" + expression +
                                        ") {\n    __e = document.createAttribute('" + name +
                                        "');\n    __e.nodeValue = \"" + booleanValue + "\";\n    $element.setAttributeNode(__e);\n  }\n");
                        }
                        else {
                            code.push("  $component = $element;\n  __e = document.createAttribute('" + name + "');\n  __e.nodeValue = " +
                                    expression + ";\n  $element.setAttributeNode(__e);\n");
                        }
                    }
                }
                else {
                                                            code.push("  $component = $element;\n  " + expression + ";\n");
                }
                return;
        }
    }
    function Sys$UI$Template$_translateStyleName(name) {
                if (name.indexOf('-') === -1) return name;
        var parts = name.toLowerCase().split('-');
                var newName = parts[0];
        for (var i = 1, l = parts.length; i < l; i++) {
            var part = parts[i];
            newName += part.substr(0, 1).toUpperCase() + part.substr(1);
        }
        return newName;
    }
    function Sys$UI$Template$_processAttribute(namespaceMappings, code, typeIndex, attrib, value, booleanValue) {
        value = this._getAttributeExpression(attrib, value);
        if (value) {
            this._appendAttributeSetter(namespaceMappings, code, typeIndex, attrib,
                value.code, value.isExpression, booleanValue);
        }
    }
    function Sys$UI$Template$_getAttributeExpression(attrib, value) {
        var type = typeof(value);
        if (type === "undefined") return null;
        if (value === null) return { isExpression: true, code: "null" };      
        if (type === "string") {
            if (value.startsWith("{{") && value.endsWith("}}")) {
                return { isExpression: true, code: value.slice(2, -2).trim() };
            }
            else if (value.startsWith("{") && value.endsWith("}")) {
                var jss = Sys.Serialization.JavaScriptSerializer,
                    ext = Sys.Application._getExtensionCode(value.slice(1, -1)),
                    properties = ext.properties;
                var props = "";
                for (var name in properties) {
                    var subValue = this._getAttributeExpression(attrib, properties[name]);
                    if (subValue && subValue.isExpression) {
                        props += "," + jss.serialize(name) + ":" + subValue.code;
                    }
                }
                return { isExpression: ext.instance.expression,
                    code: "__app._getMarkupExtension(" + jss.serialize(ext.name) + ").extension($component, " +
                        jss.serialize(attrib.name) +
                        ", {$dataItem:$dataItem,$index:$index,$id:$id" + props + "})" };
            }
        }
        return { isExpression: true, code: Sys.Serialization.JavaScriptSerializer.serialize(value) };
    }
    function Sys$UI$Template$_processBooleanAttribute(element, namespaceMappings, code, typeIndex, name) {
        var value, node = element.getAttributeNode(namespaceMappings.sysNamespace + ":" + name);
        if (!node) {
            node = element.getAttributeNode(name);
            var nodeValue = node ? node.nodeValue : null;
            if (nodeValue && (typeof(nodeValue) === "string") &&
                nodeValue.startsWith("{") && nodeValue.endsWith("}")) {
                                                throw Error.invalidOperation(String.format(Sys.TemplateRes.attributeDoesNotSupportExpressions, name));
            }
            if (node && (node.specified || (node.nodeValue === true))) {
                                                value = true;
            }
            else {
                return;
            }
        }
        else {
            value = node.nodeValue;
            if (value === "true") {
                value = true;
            }
            else if (value === "false") {
                return;
            }
        }
        this._processAttribute(namespaceMappings, code, typeIndex, { name: name }, value, name);
    }
    function Sys$UI$Template$_processBooleanAttributes(element, namespaceMappings, code, typeIndex, attributes) {
        var name, node, value;
        for (var i = 0, l = attributes.length; i < l; i++) {
            this._processBooleanAttribute(element, namespaceMappings, code, typeIndex, attributes[i]);
        }
    }
    function Sys$UI$Template$_getExplicitAttribute(namespaceMappings, code, typeIndex, element, name, processName) {
        var node;
        try {
            node = element.getAttributeNode(name);
        }
        catch (e) {
            return null;
        }
        if (!node || !node.specified) {
            return null;
        }
        if (processName) {
            var value = (name === "style" ? element.style.cssText : node.nodeValue);
            this._processAttribute(namespaceMappings, code, typeIndex, { name: processName }, value);
        }
        return node.nodeValue;
    }
    function Sys$UI$Template$_buildTemplateCode(nestedTemplates, namespaceMappings, element, code, depth) {
        var i, j, l, m, typeName, isInput,
            expressionRegExp = Sys.UI.Template.expressionRegExp,
            storeElementCode = "  " + (depth ? ("__p[__d-1].appendChild(") : "__topElements.push(");
        code.push("  __d++;\n");
        for (i = 0, l = element.childNodes.length; i < l; i++) {
            var childNode = element.childNodes[i], text = childNode.nodeValue;

            if (childNode.nodeType === 8) {
                if (text.startsWith('*') && text.endsWith('*')) {
                    code.push("  " + text.slice(1, -1) + "\n");
                }
                else {
                    code.push(storeElementCode + "document.createComment(" +
                        Sys.Serialization.JavaScriptSerializer.serialize(text) + "));\n");
                }
            }
            else if (childNode.nodeType === 3) {
                                                var trimText = text.trim();
                if (trimText.startsWith("{") && trimText.endsWith("}") && (!trimText.startsWith("{{") || !trimText.endsWith("}}"))) {
                    var attribName, setComponentCode;
                                                            if (element.tagName.toLowerCase() === "textarea") {
                        attribName = "value";
                        setComponentCode = '$component=$element;\n';
                    }
                    else {
                        attribName = "nodeValue";
                        setComponentCode = storeElementCode + '$element=$component=document.createTextNode(""));\n';
                    }
                    var expr = this._getAttributeExpression({name:attribName}, trimText);
                    if (expr.isExpression) {
                        code.push(storeElementCode + "document.createTextNode(" + expr.code + "));\n");
                    }
                    else {
                                                code.push(setComponentCode + '  ' + expr.code + ';\n');
                    }
                }
                else {
                                        var match = expressionRegExp.exec(text), lastIndex = 0;
                    while (match) {
                        var catchUpText = text.substring(lastIndex, match.index);
                        if (catchUpText) {
                            this._appendTextNode(code, storeElementCode, catchUpText);
                        }
                        code.push(storeElementCode + "document.createTextNode(" + match[1] + "));\n");
                        lastIndex = match.index + match[0].length;
                        match = expressionRegExp.exec(text);
                    }
                    if (lastIndex < text.length) {
                        this._appendTextNode(code, storeElementCode, text.substr(lastIndex));
                    }
                }
            }
            else {
                var attributes = childNode.attributes,
                    typeNames = null, sysAttribute = null, typeIndex = {},
                    tagName = childNode.tagName.toLowerCase(),
                    booleanAttributes,  dp1 = depth + 1;
                if (tagName === "script") {
                                                                                                    continue;
                }
                isInput = (tagName === "input");
                if (isInput) {
                    var typeExpression = this._getAttributeExpression({ name: "type" }, childNode.getAttribute("type"));
                    var nameExpression = this._getAttributeExpression({ name: "name" }, childNode.getAttribute("name"));
                    if (!typeExpression.isExpression || !nameExpression.isExpression) {
                        throw Error.invalidOperation(Sys.TemplateRes.mustSetInputElementsExplicitly);
                    }
                    code.push("  $element=__p[__d]=Sys.UI.Template._createInput(" + typeExpression.code + ", " + nameExpression.code + ");\n");
                    booleanAttributes = Sys.UI.Template._inputBooleanAttributes;
                    this._processBooleanAttributes(childNode, namespaceMappings, code, typeIndex, booleanAttributes);
                }
                else {
                    code.push("  $element=__p[__d]=document.createElement('" + childNode.nodeName + "');\n");
                }

                                typeNames = this._getExplicitAttribute(namespaceMappings, code, typeIndex, childNode, namespaceMappings.types);
                if (typeNames) {
                    typeNames = typeNames.split(',');
                    code.push("  __componentIndex = {}\n");
                                                            for (j = 0, m = typeNames.length; j < m; j++) {
                        typeName = typeNames[j].trim();
                        if (typeIndex[typeName]) continue;                         var type = namespaceMappings.namespaces[typeName];
                        if (!type) {
                            throw Error.invalidOperation(String.format(Sys.TemplateRes.invalidAttach, namespaceMappings.types, typeName));
                        }
                                                                        var isComponent = type.inheritsFrom(Sys.Component),
                            isControlOrBehavior = (isComponent && (type.inheritsFrom(Sys.UI.Behavior) || type.inheritsFrom(Sys.UI.Control))),
                            isContext = type.implementsInterface(Sys.UI.ITemplateContext);
                        typeIndex[typeName] = { type: type, isComponent: isComponent };
                        code.push("  __components.push(__componentIndex['" + typeName + "'] = $component = new " + type.getName());
                        if (isControlOrBehavior) {
                                                        code.push("($element));\n");
                        }
                        else {
                                                        code.push("());\n");
                        }
                        if (isComponent) {
                                                                                                                code.push("  $component.beginUpdate();\n");
                        }
                        if (isContext) {
                            code.push("  $component.set_templateContext(__tc);\n");
                        }
                    }
                }
                
                                                                sysAttribute = this._getExplicitAttribute(namespaceMappings, code, typeIndex, childNode, namespaceMappings.sysKey);
                if (sysAttribute) {
                    code.push("  __context[" +
                                Sys.Serialization.JavaScriptSerializer.serialize(sysAttribute) + "] = $element;\n");
                }
                                this._getExplicitAttribute(namespaceMappings, code, typeIndex, childNode, namespaceMappings.sysId, "id");
                                                                this._getExplicitAttribute(namespaceMappings, code, typeIndex, childNode, "style", "style");
                this._getExplicitAttribute(namespaceMappings, code, typeIndex, childNode, "class", "class");
                
                                if (!isInput) {
                    booleanAttributes = Sys.UI.Template._booleanAttributes[tagName] ||
                        Sys.UI.Template._commonBooleanAttributes;
                    this._processBooleanAttributes(childNode, namespaceMappings, code, typeIndex, booleanAttributes);
                }
                
                for (j = 0, m = attributes.length; j < m; j++) {
                    var attribute = attributes[j], name = attribute.nodeName, lowerName = name.toLowerCase();
                                                            if (!attribute.specified && (!isInput || lowerName !== "value")) continue;
                                        if ((lowerName === "class") || (lowerName === "style")) continue;
                                        if (Array.indexOf(booleanAttributes, lowerName) !== -1) continue;
                                        if (isInput && (Array.indexOf(Sys.UI.Template._inputRequiredAttributes, lowerName) !== -1)) continue;
                    var attrib = Sys.Application._splitAttribute(name),
                        ns = attrib.ns,
                        value = attribute.nodeValue;
                    name = attrib.name;
                    if (ns) {
                        if (ns === namespaceMappings.sysNamespace) {
                                                                                    if (Array.indexOf(Sys.UI.Template._sysAttributes, name) !== -1) continue;
                            if ((name === "command") || (name === "commandargument")) {
                                attrib.type = 5;                             }
                                                        attrib.ns = null;
                        }
                        else if (ns === namespaceMappings.styleNamespace) {
                                                                                    attrib.name = "style." + this._translateStyleName(name);
                            attrib.ns = null;
                            attrib.type = 1;
                        }
                        else if (ns === namespaceMappings.classNamespace) {
                            attrib.type = 2;
                        }
                        else {
                            var index = typeIndex[ns];
                            if (index) {
                                if (name === "sys-key") {
                                    attrib.type = 3;
                                }
                                else {
                                    attrib.type = 4;
                                    attrib.map = Sys.Application._translateName(attrib.name, index.type);
                                    attrib.name = attrib.map.name;
                                }
                            }
                            else {
                                                                                                                                attrib.name = ns + ":" + name;
                                attrib.ns = null;
                            }
                        }
                    }
                    this._processAttribute(namespaceMappings, code, typeIndex, attrib, value);
                }
                if (this._command) {
                    if (!this._commandargument) {
                        this._commandargument = 'null';
                    }
                    code.push(" Sys.UI.DomEvent.addHandler($element, 'click', Sys.UI.Template._getCommandHandler(" 
                              +  this._command + ", " + this._commandargument + "));\n");
                    this._command = null;
                }
                this._commandargument = null;

                code.push(storeElementCode + "$element);\n");
                for (typeName in typeIndex) {
                    index = typeIndex[typeName];
                    if (index.isComponent) {
                                                code.push("  if (($component=__componentIndex['" + typeName + "']).get_id()) __app.addComponent($component);\nif (__creatingComponents) __app._createdComponents[__app._createdComponents.length] = $component;\n");
                    }
                }
                                if (Sys.UI.Template._isTemplate(childNode)) {
                                                                                                                                            var nestedTemplate = new Sys.UI.Template(childNode);
                    nestedTemplate.compile();
                    nestedTemplates.push(childNode._msajaxtemplate);
                    code.push("  $element._msajaxtemplate = this.get_element()._msajaxtemplate[1][" + (nestedTemplates.length-1) + "];\n");
                }
                else {
                    this._buildTemplateCode(nestedTemplates, namespaceMappings, childNode, code, dp1);
                                        code.push("  $element=__p[__d];\n");
                }
            }
        }
        code.push("  --__d;\n");
    }
    function Sys$UI$Template$compile() {
        if (!this._instantiateIn) {
            var element = this.get_element();
            if (element._msajaxtemplate) {
                this._instantiateIn = element._msajaxtemplate[0];
            }
            else {
                var code = [" $index = (typeof($index) === 'number' ? $index : __instanceId);\n var __context = {}, $component, __app = Sys.Application, __creatingComponents = __app.get_isCreatingComponents(), __components = [], __componentIndex, __e, __f, __topElements = [], __d = 0, __p = [__containerElement], $id = Sys.UI.Template._getIdFunction($index), $element = __containerElement;\n  var __tc = new Sys.UI.TemplateContext();\n __tc.components = __components;\n __tc.elements = __topElements;\n __tc.dataItem = $dataItem;\n __tc.index = $index;\n __tc.parentContext = $parentContext;\n __tc.keys = __context;\n __tc.id = $id;\n __tc.container = __containerElement;\n__tc.template = this;\n  Sys.UI.Template._contexts.push(__topElements);\n with(__context) { with($dataItem || {}) {\n"];
                var namespaceMappings = Sys.Application._getNamespaceMappings(null, [element]);
                var nestedTemplates = [];
                this._buildTemplateCode(nestedTemplates, namespaceMappings, element, code, 0);
                                                code.push("} }\n  for (var __i = 0, __l = __topElements.length; __i < __l; __i++) {\n  __containerElement.insertBefore(__topElements[__i], __referenceNode);\n }\n");
                code.push(" Sys.UI.Template._contexts.pop();\n");                 code.push(" return __tc;");
                code = code.join('');
                element._msajaxtemplate = [this._instantiateIn = new Function("__containerElement", "$dataItem", "$index", "__referenceNode", "$parentContext", "__instanceId", code), nestedTemplates];
            }
        }
    }
    function Sys$UI$Template$instantiateIn(container, dataItem, dataIndex, insertBeforeNode, parentContext) {
        /// <param name="container"></param>
        /// <param name="dataItem" optional="true" mayBeNull="true"></param>
        /// <param name="dataIndex" optional="true" mayBeNull="true" type="Number" integer="true"></param>
        /// <param name="insertBeforeNode" optional="true" mayBeNull="true"></param>
        /// <param name="parentContext" type="Sys.UI.TemplateContext" optional="true" mayBeNull="true"></param>
        /// <returns type="Sys.UI.TemplateContext"></returns>
        var e = Function._validateParams(arguments, [
            {name: "container"},
            {name: "dataItem", mayBeNull: true, optional: true},
            {name: "dataIndex", type: Number, mayBeNull: true, integer: true, optional: true},
            {name: "insertBeforeNode", mayBeNull: true, optional: true},
            {name: "parentContext", type: Sys.UI.TemplateContext, mayBeNull: true, optional: true}
        ]);
        if (e) throw e;

        container = Sys.Application._resolveElement(container);
        insertBeforeNode = Sys.Application._resolveElement(insertBeforeNode);
        this.compile();
        return this._instantiateIn(container, dataItem, dataIndex, insertBeforeNode, parentContext, this._instanceId++);
    }
Sys.UI.Template.prototype = {
    get_element: Sys$UI$Template$get_element,
    dispose: Sys$UI$Template$dispose,
    _appendTextNode: Sys$UI$Template$_appendTextNode,
    _appendAttributeSetter: Sys$UI$Template$_appendAttributeSetter,
    _translateStyleName: Sys$UI$Template$_translateStyleName,
    _processAttribute: Sys$UI$Template$_processAttribute,
    _getAttributeExpression: Sys$UI$Template$_getAttributeExpression,
    _processBooleanAttribute: Sys$UI$Template$_processBooleanAttribute,
    _processBooleanAttributes: Sys$UI$Template$_processBooleanAttributes,
    _getExplicitAttribute: Sys$UI$Template$_getExplicitAttribute,
    _buildTemplateCode: Sys$UI$Template$_buildTemplateCode,
    compile: Sys$UI$Template$compile,
    instantiateIn: Sys$UI$Template$instantiateIn
}
Sys.UI.Template._getCommandHandler = function Sys$UI$Template$_getCommandHandler(name, argument) {
    return function() {
        Sys.UI.DomElement.raiseBubbleEvent(this, new Sys.CommandEventArgs(name, argument, this));
    }
}
Sys.UI.Template._getIdFunction = function Sys$UI$Template$_getIdFunction(instance) {
    return function(prefix) {
        return prefix + instance;
    }
}
Sys.UI.Template._createInput = function Sys$UI$Template$_createInput(type, name) {
    var element, dynamic = Sys.UI.Template._dynamicInputs;
    if (dynamic === true) {
        element = document.createElement('input');
        if (type) {
            element.type = type;
        }
        if (name) {
            element.name = name;
        }
    }
    else {
        var html = "<input ";
        if (type) {
            html += "type='" + type + "' ";
        }
        if (name) {
            html += "name='" + name + "' ";
        }
        html += "/>";
        try {
            element = document.createElement(html);
        }
        catch (err) {
            Sys.UI.Template._dynamicInputs = true;
            return Sys.UI.Template._createInput(type, name);
        }
        if (dynamic !== false) {
            if (element.tagName.toLowerCase() === "input") {
                Sys.UI.Template._dynamicInputs = false;
            }
            else {
                Sys.UI.Template._dynamicInputs = true;
                return Sys.UI.Template._createInput(type, name);
            }
        }
    }
    return element;
}
Sys.UI.Template._isTemplate = function Sys$UI$Template$_isTemplate(element) {
    var className = element.className;
    return (className && ((className === "sys-template") || Array.contains(className.split(' '), "sys-template")));
}
Sys.UI.Template._contexts = [];
Sys.UI.Template._inputRequiredAttributes = ["type", "name"];
Sys.UI.Template._commonBooleanAttributes = ["disabled"];
Sys.UI.Template._inputBooleanAttributes = ["disabled", "checked", "readonly"];
Sys.UI.Template._booleanAttributes = {
    "input": Sys.UI.Template._inputBooleanAttributes,
    "select": ["disabled", "multiple"],
    "option": ["disabled", "selected"],
    "img": ["disabled", "ismap"],
    "textarea": ["disabled", "readonly"]
};
Sys.UI.Template._sysAttributes = ["attach", "id", "key",
    "disabled", "checked", "readonly", "ismap", "multiple", "selected"];
Sys.UI.Template.expressionRegExp = /\{\{\s*([\w\W]*?)\s*\}\}/g;
Sys.UI.Template.registerClass("Sys.UI.Template", null, Sys.IDisposable);

Sys.UI.TemplateContext = function Sys$UI$TemplateContext() {
    /// <field name="dataItem"></field>
    /// <field name="index" type="Number" integer="true"></field>
    /// <field name="id" type="Function"></field>
    /// <field name="parentContext" type="Sys.UI.TemplateContext"></field>
    /// <field name="container" domElement="true"></field>
    /// <field name="components" type="Array" elementType="Object"></field>
    /// <field name="elements" type="Array" elementDomElement="true"></field>
    /// <field name="keys" type="Object"></field>
    if (arguments.length !== 0) throw Error.parameterCount();
}









    function Sys$UI$TemplateContext$dispose() {
        if (arguments.length !== 0) throw Error.parameterCount();
        var elements = this.elements;
        if (elements) {
            for (var i = 0, l = elements.length; i < l; i++) {
                var element = elements[i];
                if (element.nodeType === 1) {
                    Sys.Application.disposeElement(element, false);
                }
            }
        }
        this.elements = this.dataItem = this.components =
        this.container = this.parentContext = this.keys = null;
    }
    function Sys$UI$TemplateContext$getElementById(id) {
        /// <param name="id" type="String"></param>
        /// <returns domElement="true"></returns>
        var e = Function._validateParams(arguments, [
            {name: "id", type: String}
        ]);
        if (e) throw e;

        var instanceId = this.id(id),
            elements = this.elements,
            e, i, l;
        for (i = 0, l = elements.length; i < l; i++) {
            e = elements[i];
            if (e.id === instanceId) return e;
            e = Sys.UI.DomElement.getElementById(instanceId, e);
            if (e) return e;
        }
                for (i = 0, l = elements.length; i < l; i++) {
            e = elements[i];
            if (e.id === id) return e;
            e = Sys.UI.DomElement.getElementById(id, e);
            if (e) return e;
        }
        return null;
    }
    function Sys$UI$TemplateContext$getItemByKey(key) {
        /// <param name="key" type="String"></param>
        var e = Function._validateParams(arguments, [
            {name: "key", type: String}
        ]);
        if (e) throw e;

        if (!this.keys) return null;
        return this.keys[key];
    }
    function Sys$UI$TemplateContext$initializeComponents() {
        if (arguments.length !== 0) throw Error.parameterCount();
        var components = this.components;
        if (components) {
                        for (var i = components.length - 1; i > -1; i--) {
                var component = components[i];
                if (Sys.Component.isInstanceOfType(component)) {
                    if (component.get_isUpdating()) {
                        component.endUpdate();
                    }
                    else if (!component.get_isInitialized()) {
                        component.initialize();
                    }
                }
            }
        }
    }
Sys.UI.TemplateContext.prototype = {
    dataItem: null,
    index: 0,
    id: null,
    parentContext: null,
    container: null,
    components: null,
    elements: null,
    keys: null,
    dispose: Sys$UI$TemplateContext$dispose,
    getElementById: Sys$UI$TemplateContext$getElementById,
    getItemByKey: Sys$UI$TemplateContext$getItemByKey,
    initializeComponents: Sys$UI$TemplateContext$initializeComponents
}
Sys.UI.TemplateContext.registerClass("Sys.UI.TemplateContext", null, Sys.IDisposable);
Sys.UI.ITemplateContext = function Sys$UI$ITemplateContext() {
}

    function Sys$UI$ITemplateContext$get_templateContext() {
        /// <value type="Sys.UI.TemplateContext" mayBeNull="true"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        throw Error.notImplemented();
    }
    function Sys$UI$ITemplateContext$set_templateContext() {
        var e = Function._validateParams(arguments, [{name: "value", type: Sys.UI.TemplateContext, mayBeNull: true}]);
        if (e) throw e;

        throw Error.notImplemented();
    }
Sys.UI.ITemplateContext.prototype = {
    get_templateContext: Sys$UI$ITemplateContext$get_templateContext,
    set_templateContext: Sys$UI$ITemplateContext$set_templateContext
}
Sys.UI.ITemplateContext.registerInterface("Sys.UI.ITemplateContext");
Sys.CollectionChange = function Sys$CollectionChange(action, newItems, newStartingIndex, oldItems, oldStartingIndex) {
    /// <param name="action" type="Sys.NotifyCollectionChangedAction"></param>
    /// <param name="newItems" optional="true" mayBeNull="true"></param>
    /// <param name="newStartingIndex" type="Number" integer="true" optional="true" mayBeNull="true"></param>
    /// <param name="oldItems" optional="true" mayBeNull="true"></param>
    /// <param name="oldStartingIndex" type="Number" integer="true" optional="true" mayBeNull="true"></param>
    /// <field name="action" type="Sys.NotifyCollectionChangedAction"></field>
    /// <field name="newItems" type="Array" mayBeNull="true" elementMayBeNull="true"></field>
    /// <field name="newStartingIndex" type="Number" integer="true"></field>
    /// <field name="oldItems" type="Array" mayBeNull="true" elementMayBeNull="true"></field>
    /// <field name="oldStartingIndex" type="Number" integer="true"></field>
    var e = Function._validateParams(arguments, [
        {name: "action", type: Sys.NotifyCollectionChangedAction},
        {name: "newItems", mayBeNull: true, optional: true},
        {name: "newStartingIndex", type: Number, mayBeNull: true, integer: true, optional: true},
        {name: "oldItems", mayBeNull: true, optional: true},
        {name: "oldStartingIndex", type: Number, mayBeNull: true, integer: true, optional: true}
    ]);
    if (e) throw e;

    this.action = action;
    if (newItems) {
        if (!(newItems instanceof Array)) {
            newItems = [newItems];
        }
    }
    this.newItems = newItems || null;
    if (typeof newStartingIndex !== "number") {
        newStartingIndex = -1;
    }
    this.newStartingIndex = newStartingIndex;
    if (oldItems) {
        if (!(oldItems instanceof Array)) {
            oldItems = [oldItems];
        }
    }
    this.oldItems = oldItems || null;
    if (typeof oldStartingIndex !== "number") {
        oldStartingIndex = -1;
    }
    this.oldStartingIndex = oldStartingIndex;
}
Sys.CollectionChange.registerClass("Sys.CollectionChange");
Sys.NotifyCollectionChangedAction = function Sys$NotifyCollectionChangedAction() {
    /// <field name="add" type="Number" integer="true" static="true"></field>
    /// <field name="remove" type="Number" integer="true" static="true"></field>
    /// <field name="reset" type="Number" integer="true" static="true"></field>
    if (arguments.length !== 0) throw Error.parameterCount();
    throw Error.notImplemented();
}




Sys.NotifyCollectionChangedAction.prototype = {
    add: 0,
    remove: 1,
    reset: 2
}
Sys.NotifyCollectionChangedAction.registerEnum('Sys.NotifyCollectionChangedAction');
Sys.NotifyCollectionChangedEventArgs = function Sys$NotifyCollectionChangedEventArgs(changes) {
    /// <param name="changes" type="Array" elementType="Sys.CollectionChange"></param>
    var e = Function._validateParams(arguments, [
        {name: "changes", type: Array, elementType: Sys.CollectionChange}
    ]);
    if (e) throw e;

    this._changes = changes;
}

    function Sys$NotifyCollectionChangedEventArgs$get_changes() {
    if (arguments.length !== 0) throw Error.parameterCount();
        return this._changes;
    }
Sys.NotifyCollectionChangedEventArgs.prototype = {
    get_changes: Sys$NotifyCollectionChangedEventArgs$get_changes
}
Sys.NotifyCollectionChangedEventArgs.registerClass("Sys.NotifyCollectionChangedEventArgs", Sys.EventArgs);

Sys.Observer = function Sys$Observer() {
    throw Error.invalidOperation();
}
Sys.Observer.registerClass("Sys.Observer");

Sys.Observer.observe = function Sys$Observer$observe(target) {
    /// <param name="target" mayBeNull="false"></param>
    var e = Function._validateParams(arguments, [
        {name: "target"}
    ]);
    if (e) throw e;

    var isArray = target instanceof Array,
        o = Sys.Observer;
    Sys.Observer._ensureObservable(target);
    if (target.setValue === o._observeMethods.setValue) return target;
    o._addMethods(target, o._observeMethods);
    if (isArray) {
        o._addMethods(target, o._arrayMethods);
    }
    return target;
}
Sys.Observer._ensureObservable = function Sys$Observer$_ensureObservable(target) {
    var type = typeof target;
    if ((type === "string") || (type === "number") || (type === "boolean") || (type === "date")) {
        throw Error.invalidOperation(String.format(Sys.TemplateRes.notObservable, type));
    }
}
Sys.Observer._addMethods = function Sys$Observer$_addMethods(target, methods) {
    for (var m in methods) {
        if (target[m] && (target[m] !== methods[m])) {
            throw Error.invalidOperation(String.format(Sys.TemplateRes.observableConflict, m));
        }
        target[m] = methods[m];
    }
}
Sys.Observer._addEventHandler = function Sys$Observer$_addEventHandler(target, eventName, handler) {
    Sys.Observer._getContext(target, true).events.addHandler(eventName, handler);
}
Sys.Observer.addEventHandler = function Sys$Observer$addEventHandler(target, eventName, handler) {
    /// <param name="target"></param>
    /// <param name="eventName" type="String"></param>
    /// <param name="handler" type="Function"></param>
    var e = Function._validateParams(arguments, [
        {name: "target"},
        {name: "eventName", type: String},
        {name: "handler", type: Function}
    ]);
    if (e) throw e;

    Sys.Observer._ensureObservable(target);
    Sys.Observer._addEventHandler(target, eventName, handler);
}
Sys.Observer._removeEventHandler = function Sys$Observer$_removeEventHandler(target, eventName, handler) {
    Sys.Observer._getContext(target, true).events.removeHandler(eventName, handler);
}
Sys.Observer.removeEventHandler = function Sys$Observer$removeEventHandler(target, eventName, handler) {
    /// <param name="target"></param>
    /// <param name="eventName" type="String"></param>
    /// <param name="handler" type="Function"></param>
    var e = Function._validateParams(arguments, [
        {name: "target"},
        {name: "eventName", type: String},
        {name: "handler", type: Function}
    ]);
    if (e) throw e;

    Sys.Observer._ensureObservable(target);
    Sys.Observer._removeEventHandler(target, eventName, handler);
}
Sys.Observer._raiseEvent = function Sys$Observer$_raiseEvent(target, eventName, eventArgs) {
    var ctx = Sys.Observer._getContext(target);
    if (!ctx) return;
    var handler = ctx.events.getHandler(eventName);
    if (handler) {
        handler(target, eventArgs);
    }
}
Sys.Observer.raiseEvent = function Sys$Observer$raiseEvent(target, eventName, eventArgs) {
    /// <param name="target"></param>
    /// <param name="eventName" type="String"></param>
    /// <param name="eventArgs" type="Sys.EventArgs"></param>
    var e = Function._validateParams(arguments, [
        {name: "target"},
        {name: "eventName", type: String},
        {name: "eventArgs", type: Sys.EventArgs}
    ]);
    if (e) throw e;

    Sys.Observer._raiseEvent(target, eventName, eventArgs);
}
Sys.Observer.addPropertyChanged = function Sys$Observer$addPropertyChanged(target, handler) {
    /// <param name="target" mayBeNull="false"></param>
    /// <param name="handler" type="Function"></param>
    var e = Function._validateParams(arguments, [
        {name: "target"},
        {name: "handler", type: Function}
    ]);
    if (e) throw e;

    Sys.Observer._ensureObservable(target);
    Sys.Observer._addEventHandler(target, "propertyChanged", handler);
}
Sys.Observer.removePropertyChanged = function Sys$Observer$removePropertyChanged(target, handler) {
    /// <param name="target" mayBeNull="false"></param>
    /// <param name="handler" type="Function"></param>
    var e = Function._validateParams(arguments, [
        {name: "target"},
        {name: "handler", type: Function}
    ]);
    if (e) throw e;

    Sys.Observer._ensureObservable(target);
    Sys.Observer._removeEventHandler(target, "propertyChanged", handler);
}
Sys.Observer._beginUpdate = function Sys$Observer$_beginUpdate(target) {
    Sys.Observer._getContext(target, true).updating = true;
}
Sys.Observer.beginUpdate = function Sys$Observer$beginUpdate(target) {
    /// <param name="target" mayBeNull="false"></param>
    var e = Function._validateParams(arguments, [
        {name: "target"}
    ]);
    if (e) throw e;

    Sys.Observer._ensureObservable(target);
    Sys.Observer._beginUpdate(target);
}
Sys.Observer._endUpdate = function Sys$Observer$_endUpdate(target) {
    var ctx = Sys.Observer._getContext(target);
    if (!ctx || !ctx.updating) return;
    ctx.updating = false;
    var dirty = ctx.dirty;
    ctx.dirty = false;
    if (dirty) {
        if (target instanceof Array) {
            var changes = ctx.changes;
            ctx.changes = null;
            Sys.Observer.raiseCollectionChanged(target, changes);
        }
        Sys.Observer.raisePropertyChanged(target, "");
    }
}
Sys.Observer.endUpdate = function Sys$Observer$endUpdate(target) {
    /// <param name="target" mayBeNull="false"></param>
    var e = Function._validateParams(arguments, [
        {name: "target"}
    ]);
    if (e) throw e;

    Sys.Observer._ensureObservable(target);
    Sys.Observer._endUpdate(target);
}
Sys.Observer._isUpdating = function Sys$Observer$_isUpdating(target) {
    var ctx = Sys.Observer._getContext(target);
    return ctx ? ctx.updating : false;
}
Sys.Observer.isUpdating = function Sys$Observer$isUpdating(target) {
    /// <param name="target" mayBeNull="false"></param>
    /// <returns type="Boolean"></returns>
    var e = Function._validateParams(arguments, [
        {name: "target"}
    ]);
    if (e) throw e;

    Sys.Observer._ensureObservable(target);
    return Sys.Observer._isUpdating(target);
}
Sys.Observer._setValue = function Sys$Observer$_setValue(target, propertyName, value) {
    var path = propertyName.split('.');
    for (var i = 0, l = (path.length - 1); i < l ; i++) {
        var name = path[i], getter = target["get_" + name]; 
        if (typeof (getter) === "function") {
            target = getter.call(target);
        }
        else {
            target = target[name];
        }
        var type = typeof (target);
        if ((target === null) || (type === "undefined")) {
            throw Error.invalidOperation(String.format(Sys.TemplateRes.nullReferenceInPath, propertyName));
        }
    }    
    var lastPath = path[l], setter = target["set_" + lastPath];
    if (typeof(setter) === 'function') {
        setter.call(target, value);
    }
    else {
        target[lastPath] = value;
    }
    var ctx = Sys.Observer._getContext(target);
    if (ctx && ctx.updating) {
        ctx.dirty = true;
        return;
    };
    Sys.Observer.raisePropertyChanged(target, path[0]);
}
Sys.Observer.setValue = function Sys$Observer$setValue(target, propertyName, value) {
    /// <param name="target" mayBeNull="false"></param>
    /// <param name="propertyName" type="String"></param>
    /// <param name="value" mayBeNull="true"></param>
    var e = Function._validateParams(arguments, [
        {name: "target"},
        {name: "propertyName", type: String},
        {name: "value", mayBeNull: true}
    ]);
    if (e) throw e;

    Sys.Observer._ensureObservable(target);
    Sys.Observer._setValue(target, propertyName, value);
}
Sys.Observer.raisePropertyChanged = function Sys$Observer$raisePropertyChanged(target, propertyName) {
    /// <param name="target" mayBeNull="false"></param>
    /// <param name="propertyName" type="String"></param>
    var e = Function._validateParams(arguments, [
        {name: "target"},
        {name: "propertyName", type: String}
    ]);
    if (e) throw e;

    Sys.Observer._ensureObservable(target);
    Sys.Observer._raiseEvent(target, "propertyChanged", new Sys.PropertyChangedEventArgs(propertyName));
}

Sys.Observer.addCollectionChanged = function Sys$Observer$addCollectionChanged(target, handler) {
    /// <param name="target" type="Array" elementMayBeNull="true"></param>
    /// <param name="handler" type="Function"></param>
    var e = Function._validateParams(arguments, [
        {name: "target", type: Array, elementMayBeNull: true},
        {name: "handler", type: Function}
    ]);
    if (e) throw e;

    Sys.Observer._addEventHandler(target, "collectionChanged", handler);
}
Sys.Observer.removeCollectionChanged = function Sys$Observer$removeCollectionChanged(target, handler) {
    /// <param name="target" type="Array" elementMayBeNull="true"></param>
    /// <param name="handler" type="Function"></param>
    var e = Function._validateParams(arguments, [
        {name: "target", type: Array, elementMayBeNull: true},
        {name: "handler", type: Function}
    ]);
    if (e) throw e;

    Sys.Observer._removeEventHandler(target, "collectionChanged", handler);
}
Sys.Observer._collectionChange = function Sys$Observer$_collectionChange(target, change) {
    var ctx = Sys.Observer._getContext(target);
    if (ctx && ctx.updating) {
        ctx.dirty = true;
        var changes = ctx.changes;
        if (!changes) {
            ctx.changes = changes = [change];
        }
        else {
            changes.push(change);
        }
    }
    else {
        Sys.Observer.raiseCollectionChanged(target, [change]);
        Sys.Observer.raisePropertyChanged(target, 'length');
    }
}
Sys.Observer._add = function Sys$Observer$_add(target, item) {
    var change = new Sys.CollectionChange(Sys.NotifyCollectionChangedAction.add, [item], target.length);
    Array.add(target, item);
    Sys.Observer._collectionChange(target, change);
}
Sys.Observer.add = function Sys$Observer$add(target, item) {
    /// <param name="target" type="Array" elementMayBeNull="true"></param>
    /// <param name="item" mayBeNull="true"></param>
    var e = Function._validateParams(arguments, [
        {name: "target", type: Array, elementMayBeNull: true},
        {name: "item", mayBeNull: true}
    ]);
    if (e) throw e;

    Sys.Observer._add(target, item);
}
Sys.Observer._addRange = function Sys$Observer$_addRange(target, items) {
    var change = new Sys.CollectionChange(Sys.NotifyCollectionChangedAction.add, items, target.length);
    Array.addRange(target, items);
    Sys.Observer._collectionChange(target, change);
}
Sys.Observer.addRange = function Sys$Observer$addRange(target, items) {
    /// <param name="target" type="Array" elementMayBeNull="true"></param>
    /// <param name="items" type="Array" elementMayBeNull="true"></param>
    var e = Function._validateParams(arguments, [
        {name: "target", type: Array, elementMayBeNull: true},
        {name: "items", type: Array, elementMayBeNull: true}
    ]);
    if (e) throw e;

    Sys.Observer._addRange(target, items);
}
Sys.Observer._clear = function Sys$Observer$_clear(target) {
    Array.clear(target);
    Sys.Observer._collectionChange(target, new Sys.CollectionChange(Sys.NotifyCollectionChangedAction.reset));
}
Sys.Observer.clear = function Sys$Observer$clear(target) {
    /// <param name="target" type="Array" elementMayBeNull="true"></param>
    var e = Function._validateParams(arguments, [
        {name: "target", type: Array, elementMayBeNull: true}
    ]);
    if (e) throw e;

    Sys.Observer._clear(target);
}
Sys.Observer._insert = function Sys$Observer$_insert(target, index, item) {
    Array.insert(target, index, item);
    Sys.Observer._collectionChange(target, new Sys.CollectionChange(Sys.NotifyCollectionChangedAction.add, [item], index));
}
Sys.Observer.insert = function Sys$Observer$insert(target, index, item) {
    /// <param name="target" type="Array" elementMayBeNull="true"></param>
    /// <param name="index" type="Number" integer="true"></param>
    /// <param name="item" mayBeNull="true"></param>
    var e = Function._validateParams(arguments, [
        {name: "target", type: Array, elementMayBeNull: true},
        {name: "index", type: Number, integer: true},
        {name: "item", mayBeNull: true}
    ]);
    if (e) throw e;

    Sys.Observer._insert(target, index, item);
}
Sys.Observer._remove = function Sys$Observer$_remove(target, item) {
    var index = Array.indexOf(target, item);
    if (index !== -1) {
        Array.remove(target, item);
        Sys.Observer._collectionChange(target, new Sys.CollectionChange(Sys.NotifyCollectionChangedAction.remove, null, -1, [item], index));
        return true;
    }
    return false;
}
Sys.Observer.remove = function Sys$Observer$remove(target, item) {
    /// <param name="target" type="Array" elementMayBeNull="true"></param>
    /// <param name="item" mayBeNull="true"></param>
    /// <returns type="Boolean"></returns>
    var e = Function._validateParams(arguments, [
        {name: "target", type: Array, elementMayBeNull: true},
        {name: "item", mayBeNull: true}
    ]);
    if (e) throw e;

    return Sys.Observer._remove(target, item);
}
Sys.Observer._removeAt = function Sys$Observer$_removeAt(target, index) {
    if ((index > -1) && (index < target.length)) {
        var item = target[index];
        Array.removeAt(target, index);
        Sys.Observer._collectionChange(target, new Sys.CollectionChange(Sys.NotifyCollectionChangedAction.remove, null, -1, [item], index));
    }
}
Sys.Observer.removeAt = function Sys$Observer$removeAt(target, index) {
    /// <param name="target" type="Array" elementMayBeNull="true"></param>
    /// <param name="index" type="Number" integer="true"></param>
    var e = Function._validateParams(arguments, [
        {name: "target", type: Array, elementMayBeNull: true},
        {name: "index", type: Number, integer: true}
    ]);
    if (e) throw e;

    Sys.Observer._removeAt(target, index);
}
Sys.Observer.raiseCollectionChanged = function Sys$Observer$raiseCollectionChanged(target, changes) {
    /// <param name="target"></param>
    /// <param name="changes" type="Array" elementType="Sys.CollectionChange"></param>
    var e = Function._validateParams(arguments, [
        {name: "target"},
        {name: "changes", type: Array, elementType: Sys.CollectionChange}
    ]);
    if (e) throw e;

    Sys.Observer._raiseEvent(target, "collectionChanged", new Sys.NotifyCollectionChangedEventArgs(changes));
}

Sys.Observer._observeMethods = {
    add_propertyChanged: function(handler) {
        Sys.Observer._addEventHandler(this, "propertyChanged", handler);
    },
    remove_propertyChanged: function(handler) {
        Sys.Observer._removeEventHandler(this, "propertyChanged", handler);
    },
    addEventHandler: function(eventName, handler) {
        /// <param name="eventName" type="String"></param>
        /// <param name="handler" type="Function"></param>
        var e = Function._validateParams(arguments, [
            {name: "eventName", type: String},
            {name: "handler", type: Function}
        ]);
        if (e) throw e;

        Sys.Observer._addEventHandler(this, eventName, handler);
    },
    removeEventHandler: function(eventName, handler) {
        /// <param name="eventName" type="String"></param>
        /// <param name="handler" type="Function"></param>
        var e = Function._validateParams(arguments, [
            {name: "eventName", type: String},
            {name: "handler", type: Function}
        ]);
        if (e) throw e;

        Sys.Observer._removeEventHandler(this, eventName, handler);
    },
    get_isUpdating: function() {
        /// <returns type="Boolean"></returns>
        if (arguments.length !== 0) throw Error.parameterCount();
        return Sys.Observer._isUpdating(this);
    },
    beginUpdate: function() {
        if (arguments.length !== 0) throw Error.parameterCount();
        Sys.Observer._beginUpdate(this);
    },
    endUpdate: function() {
        if (arguments.length !== 0) throw Error.parameterCount();
        Sys.Observer._endUpdate(this);
    },
    setValue: function(name, value) {
        /// <param name="name" type="String"></param>
        /// <param name="value" mayBeNull="true"></param>
        var e = Function._validateParams(arguments, [
            {name: "name", type: String},
            {name: "value", mayBeNull: true}
        ]);
        if (e) throw e;

        Sys.Observer._setValue(this, name, value);
    },
    raiseEvent: function(eventName, eventArgs) {
        /// <param name="eventName" type="String"></param>
        /// <param name="eventArgs" type="Sys.EventArgs"></param>
        var e = Function._validateParams(arguments, [
            {name: "eventName", type: String},
            {name: "eventArgs", type: Sys.EventArgs}
        ]);
        if (e) throw e;

        Sys.Observer._raiseEvent(this, eventName, eventArgs);
    },
    raisePropertyChanged: function(name) {
        /// <param name="name" type="String"></param>
        var e = Function._validateParams(arguments, [
            {name: "name", type: String}
        ]);
        if (e) throw e;

        Sys.Observer._raiseEvent(this, "propertyChanged", new Sys.PropertyChangedEventArgs(name));
    }
}
Sys.Observer._arrayMethods = {
    add_collectionChanged: function(handler) {
        Sys.Observer._addEventHandler(this, "collectionChanged", handler);
    },
    remove_collectionChanged: function(handler) {
        Sys.Observer._removeEventHandler(this, "collectionChanged", handler);
    },
    add: function(item) {
        /// <param name="item" mayBeNull="true"></param>
        var e = Function._validateParams(arguments, [
            {name: "item", mayBeNull: true}
        ]);
        if (e) throw e;

        Sys.Observer._add(this, item);
    },
    addRange: function(items) {
        /// <param name="items" type="Array" elementMayBeNull="true"></param>
        var e = Function._validateParams(arguments, [
            {name: "items", type: Array, elementMayBeNull: true}
        ]);
        if (e) throw e;

        Sys.Observer._addRange(this, items);
    },
    clear: function() {
        if (arguments.length !== 0) throw Error.parameterCount();
        Sys.Observer._clear(this);
    },
    insert: function(index, item) { 
        /// <param name="index" type="Number" integer="true"></param>
        /// <param name="item" mayBeNull="true"></param>
        var e = Function._validateParams(arguments, [
            {name: "index", type: Number, integer: true},
            {name: "item", mayBeNull: true}
        ]);
        if (e) throw e;

        Sys.Observer._insert(this, index, item);
    },
    remove: function(item) {
        /// <param name="item" mayBeNull="true"></param>
        /// <returns type="Boolean"></returns>
        var e = Function._validateParams(arguments, [
            {name: "item", mayBeNull: true}
        ]);
        if (e) throw e;

        return Sys.Observer._remove(this, item);
    },
    removeAt: function(index) {
        /// <param name="index" type="Number" integer="true"></param>
        var e = Function._validateParams(arguments, [
            {name: "index", type: Number, integer: true}
        ]);
        if (e) throw e;

        Sys.Observer._removeAt(this, index);
    },
    raiseCollectionChanged: function(changes) {
        /// <param name="changes" type="Array" elementType="Sys.CollectionChange"></param>
        var e = Function._validateParams(arguments, [
            {name: "changes", type: Array, elementType: Sys.CollectionChange}
        ]);
        if (e) throw e;

        Sys.Observer._raiseEvent(this, "collectionChanged", new Sys.NotifyCollectionChangedEventArgs(changes));
    }
}
Sys.Observer._getContext = function Sys$Observer$_getContext(obj, create) {
    var ctx = obj._observerContext;
    if (ctx) return ctx();
    if (create) {
        return (obj._observerContext = Sys.Observer._createContext())();
    }
    return null;
}
Sys.Observer._createContext = function Sys$Observer$_createContext() {
                            var ctx = {
        events: new Sys.EventHandlerList()
    };
    return function() {
        return ctx;
    }
}


Sys.BindingMode = function Sys$BindingMode() {
}






Sys.BindingMode.prototype = {
    auto: 0,
    oneTime: 1,
    oneWay: 2,
    twoWay: 3,
    oneWayToSource: 4
}
Sys.BindingMode.registerEnum("Sys.BindingMode");
Sys.Binding = function Sys$Binding() {
    Sys.Binding.initializeBase(this);
}















    function Sys$Binding$get_convert() {
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._convert || null;
    }
    function Sys$Binding$set_convert(value) {
       this._convert = value;
       this._convertFn = this._resolveFunction(value);
    }
    function Sys$Binding$get_convertBack() {
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._convertBack || null;
    }
    function Sys$Binding$set_convertBack(value) {
       this._convertBack = value;
       this._convertBackFn = this._resolveFunction(value);
    }
    function Sys$Binding$get_ignoreErrors() {
        /// <value type="Boolean" mayBeNull="false"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._ignoreErrors;
    }
    function Sys$Binding$set_ignoreErrors(value) {
        var e = Function._validateParams(arguments, [{name: "value", type: Boolean}]);
        if (e) throw e;

       this._ignoreErrors = value;
    }
    function Sys$Binding$get_mode() {
        /// <value type="Sys.BindingMode" mayBeNull="false"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._mode;
    }
    function Sys$Binding$set_mode(value) {
        var e = Function._validateParams(arguments, [{name: "value", type: Sys.BindingMode}]);
        if (e) throw e;

        if (this.get_isInitialized()) {
            throw Error.invalidOperation(String.format(Sys.TemplateRes.bindingUpdateAfterInit, "mode"));
        }
        this._mode = value;
    }
    function Sys$Binding$get_source() {
        /// <value mayBeNull="true"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._source || null;
    }
    function Sys$Binding$set_source(value) {
        var e = Function._validateParams(arguments, [{name: "value", mayBeNull: true}]);
        if (e) throw e;

        if (this.get_isInitialized()) {
            throw Error.invalidOperation(String.format(Sys.TemplateRes.bindingUpdateAfterInit, "source"));
        }
        this._source = value;
    }
    function Sys$Binding$get_path() {
        /// <value type="String" mayBeNull="true"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._path || "";
    }
    function Sys$Binding$set_path(value) {
        var e = Function._validateParams(arguments, [{name: "value", type: String, mayBeNull: true}]);
        if (e) throw e;

        if (this.get_isInitialized()) {
            throw Error.invalidOperation(String.format(Sys.TemplateRes.bindingUpdateAfterInit, "path"));
        }
        this._path = value;
        this._pathArray = value ? value.split('.') : null;
    }
    function Sys$Binding$get_target() {
        /// <value mayBeNull="true"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._target || null;
    }
    function Sys$Binding$set_target(value) {
        var e = Function._validateParams(arguments, [{name: "value", mayBeNull: true}]);
        if (e) throw e;

        if (this.get_isInitialized()) {
            throw Error.invalidOperation(String.format(Sys.TemplateRes.bindingUpdateAfterInit, "target"));
        }
        this._target = value;
    }
    function Sys$Binding$get_targetProperty() {
        /// <value type="String" mayBeNull="true"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._targetProperty || "";
    }
    function Sys$Binding$set_targetProperty(value) {
        var e = Function._validateParams(arguments, [{name: "value", type: String, mayBeNull: true}]);
        if (e) throw e;

        if (this.get_isInitialized()) {
            throw Error.invalidOperation(String.format(Sys.TemplateRes.bindingUpdateAfterInit, 
                                                       "targetProperty"));
        }
        this._targetProperty = value;
        this._targetPropertyArray = value ? value.split('.') : null;
    }


    function Sys$Binding$_addBinding(element) {
                        if (element.nodeType === 3) {
                        element = element.parentNode;
                        if (!element) return;
        }
        var bindings = element._msajaxBindings;
        if (!bindings) {
           element._msajaxBindings = [this];
        }
        else {
           bindings.push(this);
        }
                if (typeof(element.dispose) !== "function") {
            element.dispose = Sys.Binding._disposeBindings;
        }
    }
    function Sys$Binding$_disposeHandlers() {
        for (var i = 0, l = this._handlers.length; i < l; i++) {
            var entry = this._handlers[i], object = entry[2];
            switch (entry[0]) {
                case "click":                 case "keyup":                 case "change":                     Sys.UI.DomEvent.removeHandler(object, entry[0], entry[1]);
                    break;
                case "propertyChanged":                                                             if (object.remove_propertyChanged) { 
                        object.remove_propertyChanged(entry[1]);
                    }
                    else {
                        Sys.Observer.removePropertyChanged(object, entry[1]);
                    }
                    break;
                case "disposing":                     object.remove_disposing(entry[1]);
                    break;
            }
        }
    }
    function Sys$Binding$dispose() {
                if (this._handlers) {
            this._disposeHandlers();
            delete this._handlers;
        }
        this._convert = null;
        this._convertBack = null;
        this._convertFn = null;
        this._convertBackFn = null;
        this._source = null;
        this._target = null;
        this._pathArray = null;
        this._targetPropertyArray = null;
        Sys.Binding.callBaseMethod(this, 'dispose');
    }
    function Sys$Binding$_getDefaultMode(target) {
        if (Sys.UI.DomElement.isDomElement(target)) {
            if (target.nodeType === 1) { 
                var tag = target.tagName ? target.tagName.toLowerCase() : null;
                if ((tag === "input") || (tag === "select") || (tag === "textarea")) {
                    return Sys.BindingMode.twoWay;
                }
            }
        }
        else {
            if (Sys.INotifyPropertyChange.isImplementedBy(target)) { 
                return Sys.BindingMode.twoWay;
            }
        }
        return Sys.BindingMode.oneWay;
    }
    function Sys$Binding$_getPropertyFromIndex(obj, path, index) {
                        for (var i = 0; i <= index; i++) {
            obj = this._getPropertyData(obj, path[i]);
                                                            var type = typeof (obj);
            if ((i < (path.length - 1)) && ((obj === null) || (type === "undefined"))) {
                throw Error.invalidOperation(String.format(Sys.TemplateRes.nullReferenceInPath, path.join('.')));
            }
        }
        return obj;
    }
    function Sys$Binding$_getPropertyData(obj, name) {
        if (typeof (obj["get_" + name]) === "function") {
            return obj["get_" + name]();
        }
        else {
            return obj[name];
        }
    }
    function Sys$Binding$_hookEvent(object, handlerMethod, componentHandlerMethod) {
                var thisHander;
        if (Sys.UI.DomElement.isDomElement(object)) {
            thisHandler = Function.createDelegate(this, handlerMethod);
            Array.add(this._handlers, ["propertyChanged", thisHandler, object]);                                                                                if (object.add_propertyChanged) { 
                object.add_propertyChanged(thisHandler);
            }
            else {
                Sys.Observer.addPropertyChanged(object, thisHandler);
            }

            var tag = object.tagName ? object.tagName.toLowerCase() : null;
                        if ((tag === "input") || (tag === "select") || (tag === "textarea")) {
                var type = object.type;
                                if ((tag === "input") && type && 
                    ((type.toLowerCase() === "checkbox") || (type.toLowerCase() === "radio"))) {
                        thisHandler = Function.createDelegate(this, handlerMethod);
                        Array.add(this._handlers, ["click", thisHandler, object]);                         Sys.UI.DomEvent.addHandler(object, "click", thisHandler);
                }
                                if (tag === "select") {
                    thisHandler = Function.createDelegate(this, handlerMethod);
                    Array.add(this._handlers, ["click", thisHandler, object]);                     Sys.UI.DomEvent.addHandler(object, "click", thisHandler);
                }
                                if (tag === "select") {
                    thisHandler = Function.createDelegate(this, handlerMethod);
                    Array.add(this._handlers, ["keyup", thisHandler, object]);                     Sys.UI.DomEvent.addHandler(object, "keyup", thisHandler);
                }
                thisHandler = Function.createDelegate(this, handlerMethod);
                Array.add(this._handlers, ["change", thisHandler, object]);                 Sys.UI.DomEvent.addHandler(object, "change", thisHandler);
                this._addBinding(object);
            }
        }
        else {
                                                thisHandler = Function.createDelegate(this, componentHandlerMethod);
            Array.add(this._handlers, ["propertyChanged", thisHandler, object]);             if (object.add_propertyChanged) { 
                object.add_propertyChanged(thisHandler);
            }
            else {
                Sys.Observer.addPropertyChanged(object, thisHandler);
            }
            
            if (Sys.INotifyDisposing.isImplementedBy(object)) {
                thisHandler = Function.createDelegate(this, this._onDisposing);
                Array.add(this._handlers, ["disposing", thisHandler, object]);                 object.add_disposing(thisHandler);
            }
        }
    }
    function Sys$Binding$_onDisposing() {
                this.dispose();
    }
    function Sys$Binding$_resolveFunction(value) {
        var ret;
        if (typeof(value) === 'function') {             ret = value;
        }
        else {
            if (typeof(value) !== "string") {
                throw Error.invalidOperation(String.format(Sys.TemplateRes.invalidFunctionName, value));
            }
            try {
                ret = Type.parse(value);
            }
            catch (e) {
                throw Error.invalidOperation(String.format(Sys.TemplateRes.functionNotFound, value));
            }
        }
        return ret;
    }
    function Sys$Binding$update(mode) {
        /// <param name="mode" optional="true" mayBeNull="false"></param>
        var e = Function._validateParams(arguments, [
            {name: "mode", optional: true}
        ]);
        if (e) throw e;

                        if (!this.get_isInitialized()) {
            throw Error.invalidOperation(Sys.TemplateRes.updateBeforeInit);
        }
        mode = mode || this.get_mode();
        if (mode === Sys.BindingMode.oneWayToSource) {
            delete this._lastTarget; 
            this._onTargetPropertyChanged();
        }
        else{
            delete this._lastSource;
            this._onSourcePropertyChanged();
        }
    }

    function Sys$Binding$initialize() {
                                var source = this.get_source(), target = this.get_target(), mode = this.get_mode();
        if (this.get_isInitialized()) {
            throw Error.invalidOperation(Sys.TemplateRes.initializeAfterInit);
        }
                var msg = Sys.TemplateRes.bindingPropertyNotSet;
        if (!source) {
            throw Error.invalidOperation(String.format(msg,"source"));
        }
        if (!target) {
            throw Error.invalidOperation(String.format(msg,"target"));
        }
        if (!this.get_path()) {
            throw Error.invalidOperation(String.format(msg,"path"));
        }
        if (!this.get_targetProperty()) {
            throw Error.invalidOperation(String.format(msg,"targetProperty"));
        }
        Sys.Binding.callBaseMethod(this, 'initialize');
        if (mode === Sys.BindingMode.auto) {
            mode = this._getDefaultMode(target);
        }
                this.update(mode);

        if (mode != Sys.BindingMode.oneTime) {
            this._handlers = [];
                        if (mode !== Sys.BindingMode.oneWayToSource) {
                this._hookEvent(source, this._onSourcePropertyChanged, this._onComponentSourceChanged);
            }
            else {
                if (Sys.UI.DomElement.isDomElement(source)) {
                    this._addBinding(source);
                }
            }
                        if (mode !== Sys.BindingMode.oneWay) {
                this._hookEvent(target, this._onTargetPropertyChanged, this._onComponentTargetChanged);
            }
            else {
                if (Sys.UI.DomElement.isDomElement(target)) {
                    this._addBinding(target);
                }
            }
        }
    }
    function Sys$Binding$_onComponentSourceChanged(sender, args) {
        var name = args.get_propertyName();
        if ((name === "") || (name === this._pathArray[0])) {
            this._onSourcePropertyChanged();
        }
    }
    function Sys$Binding$_onComponentTargetChanged(sender, args) {
        var name = args.get_propertyName();
        if ((name === "") || (name ===  this._targetPropertyArray[0])) {
            this._onTargetPropertyChanged();
        }
    }
    function Sys$Binding$_onSourcePropertyChanged() {
                var source = this._getPropertyFromIndex(this.get_source(), this._pathArray, 
                                                this._pathArray.length - 1);
        if (!this._updateSource && (source !== this._lastSource)) {
            try {
                this._updateTarget = true;
                this._lastSource = this._lastTarget = source;
                if (this._convertFn) {
                    if (this._ignoreErrors) {
                        try {
                            source = this._convertFn(source, this);
                        }
                        catch (e) {}
                    }
                    else {
                        source = this._convertFn(source, this);
                    }
                }
                var targetArrayLength = this._targetPropertyArray.length, 
                    target = this._getPropertyFromIndex(this.get_target(), this._targetPropertyArray, 
                                                        targetArrayLength - 2);
                    Sys.Observer.setValue(target, this._targetPropertyArray[targetArrayLength - 1], source);
            }
            finally {
                this._updateTarget = false;
            }
        }
    }
    function Sys$Binding$_onTargetPropertyChanged() {
                var target = this._getPropertyFromIndex(this.get_target(), this._targetPropertyArray, 
                                                this._targetPropertyArray.length - 1);
        if (!this._updateTarget && (target !== this._lastTarget)) {
            try {
                this._updateSource = true;
                this._lastTarget = this._lastSource = target;
                if (this._convertBackFn) {
                    if (this._ignoreErrors) {
                        try {
                            target = this._convertBackFn(target, this);
                        }
                        catch (e) {}
                    }
                    else {
                        target = this._convertBackFn(target, this);
                    }
                }
                var sourceArrayLength = this._pathArray.length,
                    source = this._getPropertyFromIndex(this.get_source(), this._pathArray, 
                                                        sourceArrayLength - 2);
                    Sys.Observer.setValue(source, this._pathArray[sourceArrayLength - 1], target);
            }
            finally {
                this._updateSource = false;
            }
        }
    }
Sys.Binding.prototype = {
    _convert: null,
    _convertBack: null,
    _convertFn: null,
    _convertBackFn: null,
    _handlers: null,
    _ignoreErrors: false,
    _mode: Sys.BindingMode.auto,
    _path: null,
    _targetProperty: null,
    _source: null,
    _target: null,
    _updateSource: false,
    _updateTarget: false,
        get_convert: Sys$Binding$get_convert,
    set_convert: Sys$Binding$set_convert,
    get_convertBack: Sys$Binding$get_convertBack,
    set_convertBack: Sys$Binding$set_convertBack,
    get_ignoreErrors: Sys$Binding$get_ignoreErrors,
    set_ignoreErrors: Sys$Binding$set_ignoreErrors,
    get_mode: Sys$Binding$get_mode,
    set_mode: Sys$Binding$set_mode,
    get_source: Sys$Binding$get_source,
    set_source: Sys$Binding$set_source,
    get_path: Sys$Binding$get_path,
    set_path: Sys$Binding$set_path,
    get_target: Sys$Binding$get_target,
    set_target: Sys$Binding$set_target,
    get_targetProperty: Sys$Binding$get_targetProperty,
    set_targetProperty: Sys$Binding$set_targetProperty,

        _addBinding: Sys$Binding$_addBinding,
    _disposeHandlers: Sys$Binding$_disposeHandlers,
    dispose: Sys$Binding$dispose,
    _getDefaultMode: Sys$Binding$_getDefaultMode,
    _getPropertyFromIndex: Sys$Binding$_getPropertyFromIndex,
    _getPropertyData: Sys$Binding$_getPropertyData,
    _hookEvent: Sys$Binding$_hookEvent,
    _onDisposing: Sys$Binding$_onDisposing,
    _resolveFunction: Sys$Binding$_resolveFunction,
    update: Sys$Binding$update,
        initialize: Sys$Binding$initialize,
    _onComponentSourceChanged: Sys$Binding$_onComponentSourceChanged,
    _onComponentTargetChanged: Sys$Binding$_onComponentTargetChanged,
    _onSourcePropertyChanged: Sys$Binding$_onSourcePropertyChanged,
    _onTargetPropertyChanged: Sys$Binding$_onTargetPropertyChanged
}
Sys.Binding._disposeBindings = function Sys$Binding$_disposeBindings() {
        var bindings = this._msajaxBindings;    
    if (bindings) {
        for(var i = 0, l = bindings.length; i < l; i++) {
            bindings[i].dispose();
        }
    }
    this._msajaxBindings = null;
    
        if (this.control && typeof(this.control.dispose) === "function") {
        this.control.dispose();
    }

    if (this.dispose === Sys.Binding._disposeBindings) {
        this.dispose = null;
    }
}
Sys.Binding.registerClass("Sys.Binding", Sys.Component);

Sys.Application.registerMarkupExtension(
"binding", 
function(component, targetProperty, properties) {
    var mode = properties.mode, convert = properties.convert, 
        convertBack = properties.convertBack, ignoreErrors = properties.ignoreErrors,
        binding = new Sys.Binding();

    if (mode) {
        if (typeof(mode) === "string") {
            mode = Sys.BindingMode.parse(mode);
        }
    }
    else {
        mode = Sys.BindingMode.auto;
    }
    
    binding.set_source(properties.source || properties.$dataItem);
    binding.set_path(properties.path || properties.$default);
    binding.set_target(component);
    binding.set_targetProperty(targetProperty);
    binding.set_mode(mode);

    if (properties.convert) {
        binding.set_convert(properties.convert);
    }
    if (properties.convertBack) {
        binding.set_convertBack(properties.convertBack);
    }
    if (ignoreErrors) {
        if (typeof(ignoreErrors) === "string") {
            ignoreErrors = Boolean.parse(ignoreErrors);
        }
        else {
            ignoreErrors = !!ignoreErrors;
        }
        binding.set_ignoreErrors(ignoreErrors);
    }   
    binding.initialize();
}, 
false);
Sys.UI.DataView = function Sys$UI$DataView(element) {
    /// <param name="element"></param>
    var e = Function._validateParams(arguments, [
        {name: "element"}
    ]);
    if (e) throw e;

    Sys.UI.DataView.initializeBase(this, [element]);
}





























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

        this.get_events().addHandler("command", handler);
    }
    function Sys$UI$DataView$remove_command(handler) {
    var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
    if (e) throw e;

        this.get_events().removeHandler("command", handler);
    }
    function Sys$UI$DataView$add_itemCreated(handler) {
    var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
    if (e) throw e;

        this.get_events().addHandler("itemCreated", handler);
    }
    function Sys$UI$DataView$remove_itemCreated(handler) {
    var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
    if (e) throw e;

        this.get_events().removeHandler("itemCreated", handler);
    }
    function Sys$UI$DataView$get_data() {
        /// <value mayBeNull="true"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        var ds = this._dataSource;
        return (ds ? ds.get_data() : this._data);
    }
    function Sys$UI$DataView$set_data(value) {
        var e = Function._validateParams(arguments, [{name: "value", mayBeNull: true}]);
        if (e) throw e;

        if (!this._setData || (this._data !== value)) {
            this._swapData(this._data, value);
            this._data = value;
            if (this._dataSource && (this._dataSource.get_data() !== value)) {
                this._dataSource.set_data(value);
            }
            this._dirty = this._setData = true;
            if (this.get_isInitialized()) {
                                                var isReset = this._resetSelectedIndex();
                if (!this.get_isUpdating()) {
                    this._render();
                    this.raisePropertyChanged("data");
                                                            if (!isReset) {
                        this.raisePropertyChanged("selectedData");
                        return;
                    }
                }
            }
            this._changed = true;
        }
    }
    function Sys$UI$DataView$get_dataSource() {
        /// <value type="Sys.Data.DataSource" mayBeNull="true"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        if (!this._dataSource) {
            this._dataSource = new Sys.Data.DataSource();
            this._defaultDs = true;
            this._captureDs();
        }
        return this._dataSource;
    }
    function Sys$UI$DataView$set_dataSource(value) {
        var e = Function._validateParams(arguments, [{name: "value", type: Sys.Data.DataSource, mayBeNull: true}]);
        if (e) throw e;

        if (this._dataSource !== value) {
            if (this._dataSource) {
                this._releaseDs();
            }
            if (value) {
                                                                                this._dataSource = null;
                value.beginUpdate();
                var v = this.get_autoFetch();
                if (!v) {
                    value.set_autoFetch(v);
                }
                v = this.get_httpMethod();
                if (v !== "POST") {
                    value.set_httpMethod(v);
                }
                v = this.get_timeout();
                if (v !== 0) {
                    value.set_timeout(v);
                }
                v = this.get_serviceUri();
                if (v) {
                    value.set_serviceUri(v);
                }
                v = this.get_query();
                if (v) {
                    value.set_query(v);
                }
                v = this.get_parameters();
                if (v) {
                    value.set_parameters(v);
                }
                v = this.get_data();
                if (v) {
                    value.set_data(v);
                }
                this._dataSource = value;
                this._captureDs();
                value.endUpdate();
            }
            this._defaultDs = false;
        }
    }

    function Sys$UI$DataView$get_autoFetch() {
        /// <value type="Boolean"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        var ds = this._dataSource;
        return ds ? ds.get_autoFetch() : this._autoFetch;
    }
    function Sys$UI$DataView$set_autoFetch(value) {
        var e = Function._validateParams(arguments, [{name: "value", type: Boolean}]);
        if (e) throw e;

        this._autoFetch = value;
        this.get_dataSource().set_autoFetch(value);
    }
    function Sys$UI$DataView$get_httpMethod() {
        /// <value type="String"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        var ds = this._dataSource;
        return (ds ? ds.get_httpMethod() : this._httpMethod) || "POST";
    }
    function Sys$UI$DataView$set_httpMethod(value) {
        var e = Function._validateParams(arguments, [{name: "value", type: String}]);
        if (e) throw e;

        this._httpMethod = value;
        this.get_dataSource().set_httpMethod(value);
    }
    function Sys$UI$DataView$get_items() {
        /// <value type="Array" elementType="Sys.UI.TemplateContext"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._results;
    }
    function Sys$UI$DataView$get_parameters() {
        if (arguments.length !== 0) throw Error.parameterCount();
        var ds = this._dataSource;
        return (ds ? ds.get_parameters() : this._parameters);
    }
    function Sys$UI$DataView$set_parameters(value) {
        this._parameters = value;
        this.get_dataSource().set_parameters(value);
    }
    function Sys$UI$DataView$get_selectedData() {
        if (arguments.length !== 0) throw Error.parameterCount();
        var selectedIndex = this.get_selectedIndex();
        if (selectedIndex > -1) {
            var data = this.get_data();
            if ((data instanceof Array) && (selectedIndex < data.length)) {
                return data[selectedIndex];
            }
        }
        return null;
    }
    function Sys$UI$DataView$get_selectedIndex() {
        /// <value></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._selectedIndex;
    }
    function Sys$UI$DataView$set_selectedIndex(value) {
        var e = Function._validateParams(arguments, [{name: "value"}]);
        if (e) throw e;

        value = this._validateIndexInput(value);
        var currentIndex = this.get_selectedIndex();
        if (value !== currentIndex) {
            var data = this.get_data(), 
                outOfRange = (value < -1) || (value > (data instanceof Array ? data.length-1 : -1));
            if (outOfRange) {
                throw Error.argumentOutOfRange("value", value);
            }
            this._selectedIndex = value;
            var previousData = this._currentSelectedData;
            this._currentSelectedData = ((value === -1) || outOfRange) ? null : data[value];
            if (this.get_isInitialized()) {
                var className = this.get_selectedItemClass();
                this._addRemoveCssClass(currentIndex, className, Sys.UI.DomElement.removeCssClass);
                this._addRemoveCssClass(value, className, Sys.UI.DomElement.addCssClass);
                if (!this.get_isUpdating()) {
                    this.raisePropertyChanged('selectedIndex');
                    if (previousData !== this._currentSelectedData) {
                        this.raisePropertyChanged('selectedData');
                        return;
                    }
                }
            }
            this._changed = true;
        }
    }
    function Sys$UI$DataView$get_initialSelectedIndex() {
        /// <value></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._initialSelectedIndex;
    }
    function Sys$UI$DataView$set_initialSelectedIndex(value) {
        var e = Function._validateParams(arguments, [{name: "value"}]);
        if (e) throw e;

        value = this._validateIndexInput(value);
        if (value !== this.get_initialSelectedIndex()) {
            this._initialSelectedIndex = value;
            if (this._isActive()) {
                this.raisePropertyChanged('initialSelectedIndex');
            }
            else {
                this._changed = true;
            }
        }
    }
    function Sys$UI$DataView$get_selectedItemClass() {
        /// <value type="String"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._selectedItemClass || "";
    }
    function Sys$UI$DataView$set_selectedItemClass(value) {
        var e = Function._validateParams(arguments, [{name: "value", type: String}]);
        if (e) throw e;

        var name = this.get_selectedItemClass();
        if (value !== name) {
            var index = this.get_selectedIndex();
            this._addRemoveCssClass(index, name, Sys.UI.DomElement.removeCssClass);
            this._addRemoveCssClass(index, value, Sys.UI.DomElement.addCssClass);
            this._selectedItemClass = value;
        }
    }
    function Sys$UI$DataView$get_serviceUri() {
        /// <value type="String"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        var ds = this._dataSource;
        return (ds ? ds.get_serviceUri() : this._serviceUri) || "";
    }
    function Sys$UI$DataView$set_serviceUri(value) {
        var e = Function._validateParams(arguments, [{name: "value", type: String}]);
        if (e) throw e;

        this._serviceUri = value;
        this.get_dataSource().set_serviceUri(value);
    }
    function Sys$UI$DataView$get_timeout() {
        /// <value type="Number" integer="true"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        var ds = this._dataSource;
        return ds ? ds.get_timeout() : this._timeout;
    }
    function Sys$UI$DataView$set_timeout(value) {
        var e = Function._validateParams(arguments, [{name: "value", type: Number, integer: true}]);
        if (e) throw e;

        this._timeout = value;
        this.get_dataSource().set_timeout(value);
    }
    function Sys$UI$DataView$get_query() {
        /// <value mayBeNull="true"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        var ds = this._dataSource;
        return (ds ? ds.get_query() : this._query) || "";
    }
    function Sys$UI$DataView$set_query(value) {
        var e = Function._validateParams(arguments, [{name: "value", mayBeNull: true}]);
        if (e) throw e;

        this._query = value;
        this.get_dataSource().set_query(value);
    }
    function Sys$UI$DataView$get_itemPlaceholder() {
        /// <value mayBeNull="true"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._placeholder || null;
    }
    function Sys$UI$DataView$set_itemPlaceholder(value) {
        var e = Function._validateParams(arguments, [{name: "value", mayBeNull: true}]);
        if (e) throw e;

        if (this._placeholder !== value) {
            this._placeholder = value;
            this._container = null;
            this._dirty = true;
            this.raisePropertyChanged("itemPlaceholder");
        }
    }
    function Sys$UI$DataView$get_templateContext() {
        /// <value mayBeNull="true" type="Sys.UI.TemplateContext"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._parentContext || null;
    }
    function Sys$UI$DataView$set_templateContext(value) {
        var e = Function._validateParams(arguments, [{name: "value", type: Sys.UI.TemplateContext, mayBeNull: true}]);
        if (e) throw e;

        if (this._parentContext !== value) {
            this._parentContext = value;
            this._dirty = true;
            this.raisePropertyChanged("templateContext");
        }
    }
    function Sys$UI$DataView$get_itemTemplate() {
        /// <value mayBeNull="true"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._template || null;
    }
    function Sys$UI$DataView$set_itemTemplate(value) {
        var e = Function._validateParams(arguments, [{name: "value", mayBeNull: true}]);
        if (e) throw e;

        if (this._template !== value) {
            this._template = value;
            this._dirty = true;
            if (this._dvTemplate) {
                this._dvTemplate.dispose();
                this._dvTemplate = null;
            }
            if (this._isActive()) {
                this.raisePropertyChanged("itemTemplate");
                if (this._setData) {
                    this._render();
                }
            }
            else {
                this._changed = true;
            }
        }
    }
    function Sys$UI$DataView$_addRemoveCssClass(index, className, addRemove) {
        if (className && (index > -1)) {
            var items = this.get_items(), l = items ? items.length : -1;
            if (l && (index < l)) {
                var elementsSet = items[index].elements;
                if (elementsSet) {
                    for (var i = 0, len = elementsSet.length; i < len; i++) {
                        var element = elementsSet[i];
                        if (element.nodeType === 1) {
                            addRemove(element, className);
                        }
                    }
                }
            }
        }
    }
    function Sys$UI$DataView$_captureDs() {
        if (!this._dsChanged) {
            this._dsChanged = Function.createDelegate(this, this._onDsChanged);
        }
        this._dataSource.add_propertyChanged(this._dsChanged);
    }
    function Sys$UI$DataView$_releaseDs() {
        this._dataSource.remove_propertyChanged(this._dsChanged);
    }
    function Sys$UI$DataView$_clearContainer(c, ref, count) {
        if (ref === 0) {
            this._clearElement(c);
        }
        else {
            this._removeChildren(c, ref, count, true);
        }
    }
    function Sys$UI$DataView$_clearElement(e) {
        Sys.Application.disposeElement(e, true);
        if (this._useRemove) {
            this._removeChildren(e);
        }
        else {
            try {
                e.innerHTML = "";
            }
            catch (err) {
                                this._removeChildren(e);
                this._useRemove = true;
            }
        }
    }
    function Sys$UI$DataView$_collectionChanged(sender, args) {
        if (this._isActive()) {
            this._render();
            var selectedIndex = this.get_selectedIndex();
            if (selectedIndex !== -1) {
                var changes = args ? args.get_changes() : null, oldIndex = selectedIndex;
                for (var i = 0, l = changes.length; i < l; i++) {
                    var thisChange = changes[i];
                    if (thisChange.action === Sys.NotifyCollectionChangedAction.add) {
                        if (selectedIndex >= thisChange.newStartingIndex) {
                            selectedIndex++;
                        }
                    }
                    else if (thisChange.action === Sys.NotifyCollectionChangedAction.remove) {
                        var index = thisChange.oldStartingIndex;
                        if (selectedIndex > index) {
                            selectedIndex--;
                        }
                        else if (selectedIndex === index) {
                            selectedIndex = -1;
                            break;
                        }
                    }
                    else if (thisChange.action === Sys.NotifyCollectionChangedAction.reset) {
                        selectedIndex = -1;
                        break;
                    }
                }
                if (selectedIndex !== oldIndex) {
                    this.set_selectedIndex(selectedIndex);
                }
            }
        }
        else {
            this._dirty = true;
        }
    }
    function Sys$UI$DataView$_elementContains(container, element, excludeSelf) {
        if (container === element) {
            return !excludeSelf;
        }
        do {
            element = element.parentNode;
            if (element === container) return true;
        }
        while (element);
        return false;
    }
    function Sys$UI$DataView$_onDsChanged(ds, args) {
        this.set_data(ds.get_data());
    }
    function Sys$UI$DataView$_removeChildren(e, ref, count, dispose) {
                                if ((ref === 0) || typeof(count) === "undefined") {
            while (e.firstChild) {
                if (dispose) {
                    Sys.Application.disposeElement(e.firstChild, false);
                }
                e.removeChild(e.firstChild);
            }
        }
        else {
            while (count--) {
                var c = ref ? ref.previousSibling : e.lastChild;
                if (dispose) {
                    Sys.Application.disposeElement(c, false);
                }
                e.removeChild(c);
            }
        }
    }
    function Sys$UI$DataView$_getTemplate() {
                                                if (this._dvTemplate) return this._dvTemplate;
        var template = this.get_itemTemplate();
        if (!template) {
                        this._dvTemplate = template = new Sys.UI.Template(this.get_element());
        }
        else if (!Sys.UI.Template.isInstanceOfType(template)) {
                        template = Sys.Application._resolveElement(template);
            var e = this.get_element();
            if ((e !== template) && this._elementContains(e, template, true)) {
                throw Error.invalidOperation(Sys.TemplateRes.misplacedTemplate);
            }
            this._dvTemplate = template = new Sys.UI.Template(template);
        }
        else {
                        if (this._elementContains(this.get_element(), template.get_element(), true)) {
                throw Error.invalidOperation(Sys.TemplateRes.misplacedTemplate);
            }
        }
        return template;
    }
    function Sys$UI$DataView$_resetSelectedIndex() {
        var data = this.get_data(), initialSelectedIndex = this.get_initialSelectedIndex(),
            selectedIndex = this.get_selectedIndex();
        if (!(data instanceof Array) || (initialSelectedIndex >= data.length)) {
            if (selectedIndex !== -1) {
                this.set_selectedIndex(-1);
                return true;
            }
        } 
        else if (selectedIndex !== initialSelectedIndex) {
            this.set_selectedIndex(initialSelectedIndex);
            return true;
        }
        return false;
    }
    function Sys$UI$DataView$_resolveContainer() {
        if (!this._container) {
            var e, ref, container, ph = Sys.Application._resolveElement(this.get_itemPlaceholder());
            if (ph) {
                if (!this._elementContains(this.get_element(), ph)) {
                    throw Error.invalidOperation(Sys.TemplateRes.misplacedPlaceholder);
                }
                                                                container = ph.parentNode;
                ref = ph.nextSibling;
            }
            else {
                container = this.get_element();
                                                                                ref = 0; 
            }
            this._container = container;
            this._refNode = ref;
        }
    }
    function Sys$UI$DataView$_initializeResults() {
        for (var i = 0, l = this._results.length; i < l; i++) {
            this._results[i].initializeComponents();
        }
    }
    function Sys$UI$DataView$_isActive() {
        return (this.get_isInitialized() && !this.get_isUpdating());
    }
    function Sys$UI$DataView$_raiseCommand(args) {
        this.onCommand(args);
        var handler = this.get_events().getHandler("command");
        if (handler) {
            handler(this, args);
        }
    }
    function Sys$UI$DataView$_raiseItemCreated(args) {
        this.onItemCreated(args);
        var handler = this.get_events().getHandler("itemCreated");
        if (handler) {
            handler(this, args);
        }
    }
    function Sys$UI$DataView$onBubbleEvent(source, args) {
        /// <param name="source"></param>
        /// <param name="args" type="Sys.EventArgs"></param>
        /// <returns type="Boolean"></returns>
        var e = Function._validateParams(arguments, [
            {name: "source"},
            {name: "args", type: Sys.EventArgs}
        ]);
        if (e) throw e;

        if (Sys.CommandEventArgs.isInstanceOfType(args)) {
            this._raiseCommand(args);
            if (args.get_cancel()) {
                return true;
            }
            else {
                var name = args.get_commandName();
                if (name && (name.toLowerCase() === "select")) {
                    var index = this._getItemIndex(source);
                    if (index !== -1) {
                        this.set_selectedIndex(index);
                        return true;
                    }
                }
            }
        }
        return false;
    }
    function Sys$UI$DataView$_getItemIndex(source) {
        if (source && this._currentContainer) {
            var results = this.get_items();
            if (results) {
                var element;
                if (typeof(source) === "string") {
                    element = Sys.UI.DomElement.getElementById(source);
                } 
                else if (Sys.UI.Control.isInstanceOfType(source) || Sys.UI.Behavior.isInstanceOfType(source)) {
                    element = source.get_element();
                } 
                else if (Sys.UI.DomElement.isDomElement(source)) {
                    element = source;
                }
                if (element) {
                    var parent = element.parentNode, dvElement = this.get_element();
                    while (parent && (parent !== this._currentContainer) && (parent !== dvElement)) {
                        element = parent;
                        parent = parent.parentNode;
                    }
                    if (parent === this._currentContainer) { 
                        for (var i = 0, l = results.length; i < l; i++) {
                            if (Array.contains(results[i].elements, element)) {
                                return i;
                            }
                        }
                    }
                }
            }
        }
        return -1;
    }
    function Sys$UI$DataView$getItem(source) {
        if (!source || ((typeof(source) !== "string") && !Sys.UI.Control.isInstanceOfType(source) 
            && !Sys.UI.Behavior.isInstanceOfType(source) && !Sys.UI.DomElement.isDomElement(source))) {
            throw Error.argument(Sys.TemplateRes.invalidSource);
        }
        var index = this._getItemIndex(source);
        return (index !== -1) ? this.get_items()[index] : null;
    }
    function Sys$UI$DataView$_render() {
        this._dirty = false;
        this._resolveContainer();
        var template = this._getTemplate(),
            data = this.get_data(),
            pctx = this.get_templateContext(),
            element = this.get_element(),
            container = this._container,
            currentContainer = this._currentContainer,
            result;
        if (currentContainer) {
                        this._clearContainer(currentContainer, this._currentRef, this._currentCount);
        }
                template.compile();
        if (currentContainer !== this._container) {
                                                            this._useRemove = false;
            this._clearContainer(container, this._refNode, 1);
        }
        this._currentContainer = container;
        this._currentRef = this._refNode;
        this._currentCount = 0;
        if (template.get_element() === element) {
                        Sys.UI.DomElement.removeCssClass(element, "sys-template");
        }
        if ((data === null) || (typeof(data) === "undefined")) {
            this._results = [];
        }
        else if (data instanceof Array) {
            var len = data.length;
            this._results = new Array(len);
            for (var i = 0; i < len; i++) {
                var item = data[i];
                result = template.instantiateIn(container, item, i, this._currentRef, pctx);
                if (this._currentRef !== 0) {
                                                                                this._currentCount += result.elements.length;
                }
                this._raiseItemCreated(new Sys.UI.DataViewItemEventArgs(item, result));
                this._results[i] = result;
            }
        }
        else {
            result = template.instantiateIn(container, data, 0, this._currentRef, pctx);
            if (this._currentRef !== 0) {
                this._currentCount = result.elements.length;
            }
            this.onItemCreated(new Sys.UI.DataViewItemEventArgs(data, result));
            this._results = [result];
        }
        var selectedClass = this.get_selectedItemClass();
        if (selectedClass) {
            var selectedIndex = this.get_selectedIndex();
            if (selectedIndex !== -1) {
                this._addRemoveCssClass(selectedIndex, selectedClass, Sys.UI.DomElement.addCssClass);
            }
        }
        this._initializeResults();
    }
    function Sys$UI$DataView$_swapData(oldData, newData) {
                if (oldData) {
            switch (this._eventType) {
                case 1:
                    oldData.remove_collectionChanged(this._changedHandler);
                    break;
                case 2:
                    Sys.Observer.removeCollectionChanged(oldData, this._changedHandler);
                    break;
            }
        }
                        this._eventType = 0;
        if (newData) {
            if (!this._changedHandler) {
                this._changedHandler = Function.createDelegate(this, this._collectionChanged);
            }
            if (typeof(newData.add_collectionChanged) === "function") {
                newData.add_collectionChanged(this._changedHandler);
                this._eventType = 1;
            }
            else if (newData instanceof Array) {
                Sys.Observer.addCollectionChanged(newData, this._changedHandler);
                this._eventType = 2;
            }
        }
    }
    function Sys$UI$DataView$_validateIndexInput(value) {
        var type = typeof(value);
        if (type === "string") {
            value = parseInt(value);
            if (isNaN(value)) {
                throw Error.argument(Sys.TemplateRes.invalidSelectedIndexValue);
            }
        }
        else if (type !== "number") {
            throw Error.argument(Sys.TemplateRes.invalidSelectedIndexValue);
        }
        return value;
    }
    function Sys$UI$DataView$dispose() {
                if (this._currentContainer && !Sys.Application.get_isDisposing()) {
            this._clearContainer(this._currentContainer, this._currentRef, this._currentCount);        
        }
        if (this._dvTemplate) {
            this._dvTemplate.dispose();
        }
        if (this._dataSource) {
            if (this._dsDefault) {
                this._dataSource.dispose();
            }
            this._releaseDs();
            this._dataSource = null;
        }
        this._swapData(this._data, null);
        this._currentSelectedData = this._currentContainer = this._currentRef = this._container = this._placeholder =
        this._results = this._parentContext = this._dvTemplate =
        this._data = this._parameters = this._query = null;
        Sys.UI.DataView.callBaseMethod(this, "dispose")
    }
    function Sys$UI$DataView$initialize() {
        if (arguments.length !== 0) throw Error.parameterCount();
        this._resetSelectedIndex();
        Sys.UI.DataView.callBaseMethod(this, "initialize");
        if (this._dataSource && this._defaultDs) {
            this._dataSource.initialize();
        }
        if (this._setData) {
            this._render();
        }
    }
    function Sys$UI$DataView$fetchData() {
        var ds = this.get_dataSource();
        if (!ds) {
            throw Error.invalidOperation(Sys.TemplateRes.noDataSource);
        }
        else {
            ds.fetchData();
        }
    }
    function Sys$UI$DataView$onCommand(args) {
        /// <param name="args" type="Sys.CommandEventArgs"></param>
        var e = Function._validateParams(arguments, [
            {name: "args", type: Sys.CommandEventArgs}
        ]);
        if (e) throw e;

    }
    function Sys$UI$DataView$onItemCreated(args) {
        /// <param name="args" type="Sys.UI.DataViewItemEventArgs"></param>
        var e = Function._validateParams(arguments, [
            {name: "args", type: Sys.UI.DataViewItemEventArgs}
        ]);
        if (e) throw e;

    }
    function Sys$UI$DataView$updated() {
        if (arguments.length !== 0) throw Error.parameterCount();
        if (this._dirty && this._setData) {
            this._render();
        }
        if (this._changed) {
            this.raisePropertyChanged("");
            this._changed = false;
        }
    }
Sys.UI.DataView.prototype = {
    _autoFetch: true,
    _changed: false,
    _container: null,
    _currentContainer: null,
    _currentRef: null,
    _currentSelectedData: null,
    _data: null,
    _dataSource: null,
    _dirty: false,
    _dsDefault: false,
    _dvTemplate: null,
    _eventType: 0,
    _httpMethod: null,
    _initialSelectedIndex: 0,
    _parameters: null,
    _parentContext: null,
    _placeholder: null,
    _query: null,
    _results: null,
    _selectedIndex: -1,
    _selectedItemClass: null,
    _serviceUri: null,
    _setData: false,
    _template: null,
    _timeout: 0,
            _useRemove: false,
    add_command: Sys$UI$DataView$add_command,
    remove_command: Sys$UI$DataView$remove_command,
    add_itemCreated: Sys$UI$DataView$add_itemCreated,
    remove_itemCreated: Sys$UI$DataView$remove_itemCreated,
    get_data: Sys$UI$DataView$get_data,
    set_data: Sys$UI$DataView$set_data,
    get_dataSource: Sys$UI$DataView$get_dataSource,
    set_dataSource: Sys$UI$DataView$set_dataSource,
        get_autoFetch: Sys$UI$DataView$get_autoFetch,
    set_autoFetch: Sys$UI$DataView$set_autoFetch,
    get_httpMethod: Sys$UI$DataView$get_httpMethod,
    set_httpMethod: Sys$UI$DataView$set_httpMethod,
    get_items: Sys$UI$DataView$get_items,
    get_parameters: Sys$UI$DataView$get_parameters,
    set_parameters: Sys$UI$DataView$set_parameters,
    get_selectedData: Sys$UI$DataView$get_selectedData,
    get_selectedIndex: Sys$UI$DataView$get_selectedIndex,
    set_selectedIndex: Sys$UI$DataView$set_selectedIndex,
    get_initialSelectedIndex: Sys$UI$DataView$get_initialSelectedIndex,
    set_initialSelectedIndex: Sys$UI$DataView$set_initialSelectedIndex,
    get_selectedItemClass: Sys$UI$DataView$get_selectedItemClass,
    set_selectedItemClass: Sys$UI$DataView$set_selectedItemClass,
    get_serviceUri: Sys$UI$DataView$get_serviceUri,
    set_serviceUri: Sys$UI$DataView$set_serviceUri,
    get_timeout: Sys$UI$DataView$get_timeout,
    set_timeout: Sys$UI$DataView$set_timeout,
    get_query: Sys$UI$DataView$get_query,
    set_query: Sys$UI$DataView$set_query,    
    get_itemPlaceholder: Sys$UI$DataView$get_itemPlaceholder,
    set_itemPlaceholder: Sys$UI$DataView$set_itemPlaceholder,
    get_templateContext: Sys$UI$DataView$get_templateContext,
    set_templateContext: Sys$UI$DataView$set_templateContext,    
    get_itemTemplate: Sys$UI$DataView$get_itemTemplate,
    set_itemTemplate: Sys$UI$DataView$set_itemTemplate,
    _addRemoveCssClass: Sys$UI$DataView$_addRemoveCssClass,
    _captureDs: Sys$UI$DataView$_captureDs,
    _releaseDs: Sys$UI$DataView$_releaseDs,
    _clearContainer: Sys$UI$DataView$_clearContainer,
    _clearElement: Sys$UI$DataView$_clearElement,
    _collectionChanged: Sys$UI$DataView$_collectionChanged,
    _elementContains: Sys$UI$DataView$_elementContains,
    _onDsChanged: Sys$UI$DataView$_onDsChanged,
    _removeChildren: Sys$UI$DataView$_removeChildren,
    _getTemplate: Sys$UI$DataView$_getTemplate,
    _resetSelectedIndex: Sys$UI$DataView$_resetSelectedIndex,
    _resolveContainer: Sys$UI$DataView$_resolveContainer,
    _initializeResults: Sys$UI$DataView$_initializeResults,    
    _isActive: Sys$UI$DataView$_isActive,
    _raiseCommand: Sys$UI$DataView$_raiseCommand,
    _raiseItemCreated: Sys$UI$DataView$_raiseItemCreated,
    onBubbleEvent: Sys$UI$DataView$onBubbleEvent,
    _getItemIndex: Sys$UI$DataView$_getItemIndex,
    getItem: Sys$UI$DataView$getItem,
    _render: Sys$UI$DataView$_render,
    _swapData: Sys$UI$DataView$_swapData,
    _validateIndexInput: Sys$UI$DataView$_validateIndexInput,
    dispose: Sys$UI$DataView$dispose, 
    initialize: Sys$UI$DataView$initialize,
    fetchData: Sys$UI$DataView$fetchData,
    onCommand: Sys$UI$DataView$onCommand,
    onItemCreated: Sys$UI$DataView$onItemCreated,
    updated: Sys$UI$DataView$updated    
}
Sys.UI.DataView.registerClass("Sys.UI.DataView", Sys.UI.Control, Sys.UI.ITemplateContext);
Sys.UI.DataViewItemEventArgs = function Sys$UI$DataViewItemEventArgs(dataItem, templateContext) {
    /// <param name="dataItem"></param>
    /// <param name="templateContext" type="Sys.UI.TemplateContext"></param>
    var e = Function._validateParams(arguments, [
        {name: "dataItem"},
        {name: "templateContext", type: Sys.UI.TemplateContext}
    ]);
    if (e) throw e;

    Sys.UI.DataViewItemEventArgs.initializeBase(this);
    this._ctx = templateContext || null;
    this._data = dataItem || null;
}

    function Sys$UI$DataViewItemEventArgs$get_dataItem() {
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._data;
    }
    function Sys$UI$DataViewItemEventArgs$get_templateContext() {
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._ctx;
    }
Sys.UI.DataViewItemEventArgs.prototype = {
    get_dataItem: Sys$UI$DataViewItemEventArgs$get_dataItem,
    get_templateContext: Sys$UI$DataViewItemEventArgs$get_templateContext
}
Sys.UI.DataViewItemEventArgs.registerClass("Sys.UI.DataViewItemEventArgs", Sys.EventArgs);
Sys.TemplateRes = {
    "bindingUpdateAfterInit":"Binding '{0}' cannot be set after initialize.",
    "bindingPropertyNotSet":"Binding '{0}' must be set prior to initialize.",
    "elementNotFound":"An element with id '{0}' could not be found.",
    "expectedElementOrId":"Value must be a DOM element or DOM element Id.",
    "functionNotFound":"A function with the name '{0}' could not be found.",
    "initializeAfterInit":"Initialize cannot be called more than once.",
    "invalidFunctionName":"'{0}' must be of type Function or the name of a function as a String.",
    "invalidSysAttribute":"Invalid attribute '{0}'.",
    "invalidTypeNamespace":"Invalid type namespace declaration, '{0}' is not a valid type.",
    "invalidAttach":"Invalid attribute '{0}', the type '{1}' is not a registered namespace.",
    "misplacedPlaceholder":"DataView item placeholder must be a child element of the DataView.",
    "misplacedTemplate":"DataView item template must not be a child element of the DataView.",
    "updateBeforeInit":"Update cannot be called before initialize.",
    "notObservable":"Instances of type '{0}' cannot be observed.",
    "observableConflict":"Object already contains a member with the name '{0}'.",
    "cannotActivate":"Could not activate element with id '{0}', the element could not be found.",
    "requiresAdoNetServiceProxy":"AdoNetDataSource requires a reference to the MicrosoftAjaxAdoNet.js library.",
    "invalidSelectedIndexValue":"Value must be a Number or a String that can be converted to a Number.",
    "invalidAttributeName":"Invalid attribute name '{0}'. Declared attribute names must be in lowercase.",
    "attributeDoesNotSupportExpressions":"Attribute '{0}' does not support expressions, use 'sys:{0}' instead.",
    "mustSetInputElementsExplicitly":"Input elements 'type' and 'name' attributes must be explicitly set.",
    "invalidSource":"Value must be a DOM element, DOM element id, control, or behavior.",
    "cannotFindMarkupExtension":"A markup extension with the name '{0}' could not be found.",
    "nullReferenceInPath":"Null reference while evaluating data path: '{0}'.",
    "invalidHandler":"Trying to dispose an invalid handler: '{0}'.",
    "noDataSource":"DataView cannot fetch data because there is no connected data source."
};
Boolean._oldParse = Boolean.parse;
Boolean.parse = function Boolean$parse(value) {
    return Boolean._oldParse(value);
}
Date._oldParse = Date.parse;
Date.parse = function Date$parse(value) {
    return Date._oldParse(value);
}
Number._oldParseLocale = Number.parseLocale;
Number.parseLocale = function Number$parseLocale(value) {
    return Number._oldParseLocale(value);
}
Number._oldParseInvariant = Number.parseInvariant;
Number.parseInvariant = function Number$parseInvariant(value) {
    return Number._oldParseInvariant(value);
}
Sys.CommandEventArgs = function Sys$CommandEventArgs(commandName, commandArgument, commandSource) {
    /// <param name="commandName" type="String"></param>
    /// <param name="commandArgument" mayBeNull="true"></param>
    /// <param name="commandSource" mayBeNull="true"></param>
    var e = Function._validateParams(arguments, [
        {name: "commandName", type: String},
        {name: "commandArgument", mayBeNull: true},
        {name: "commandSource", mayBeNull: true}
    ]);
    if (e) throw e;

    Sys.CommandEventArgs.initializeBase(this);
    this._commandName = commandName;
    this._commandArgument = commandArgument;
    this._commandSource = commandSource;
}




    function Sys$CommandEventArgs$get_commandName() {
        /// <value type="String"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._commandName;
    }
    function Sys$CommandEventArgs$get_commandArgument() {
        /// <value mayBeNull="true"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._commandArgument;
    }
    function Sys$CommandEventArgs$get_commandSource() {
        /// <value mayBeNull="true"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._commandSource;
    }
Sys.CommandEventArgs.prototype = {
    _commandName: null,
    _commandArgument: null,
    _commandSource: null,
    get_commandName: Sys$CommandEventArgs$get_commandName,
    get_commandArgument: Sys$CommandEventArgs$get_commandArgument,
    get_commandSource: Sys$CommandEventArgs$get_commandSource
}
Sys.CommandEventArgs.registerClass("Sys.CommandEventArgs", Sys.CancelEventArgs);

Type.registerNamespace("Sys.Data");

Sys.Data.DataSource = function Sys$Data$DataSource() {
    Sys.Data.DataSource.initializeBase(this);
}














    function Sys$Data$DataSource$get_autoFetch() {
        /// <value type="Boolean"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._autoFetch;
    }
    function Sys$Data$DataSource$set_autoFetch(value) {
        var e = Function._validateParams(arguments, [{name: "value", type: Boolean}]);
        if (e) throw e;

        var was = this._autoFetch;
        this._autoFetch = value;
        if (this._isActive() && this._stale && !was && value) {
                                    this.fetchData();
        }
    }
    function Sys$Data$DataSource$get_data() {
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._data || null;
    }
    function Sys$Data$DataSource$set_data(value) {
        if (this._data !== value) {
            this._data = value;
            if (this._data) {
                this._stale = false;
            }
            if (this._isActive()) {
                this.raisePropertyChanged("data");
            }
            else {
                this._dirty = true;
            }            
        }
    }
    function Sys$Data$DataSource$get_httpMethod() {
        /// <value type="String"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._httpMethod || "POST";
    }
    function Sys$Data$DataSource$set_httpMethod(value) {
        var e = Function._validateParams(arguments, [{name: "value", type: String}]);
        if (e) throw e;

        this._httpMethod = value;
    }
    function Sys$Data$DataSource$get_fetching() {
        /// <value type="Boolean"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._fetching;
    }
    function Sys$Data$DataSource$get_fetchDataMethod() {
        /// <value type="Function" mayBeNull="true"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._fetchDataMethod;
    }
    function Sys$Data$DataSource$set_fetchDataMethod(value) {
        var e = Function._validateParams(arguments, [{name: "value", type: Function, mayBeNull: true}]);
        if (e) throw e;

        this._fetchDataMethod = value;
    }
    function Sys$Data$DataSource$get_parameters() {
        /// <value type="Object" mayBeNull="true"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._parameters;
    }
    function Sys$Data$DataSource$set_parameters(value) {
        var e = Function._validateParams(arguments, [{name: "value", type: Object, mayBeNull: true}]);
        if (e) throw e;

        if (this._parameters !== value) {
            this._parameters = value;
            if (this.get_autoFetch() && this._isActive()) {
                this.fetchData();
            }
            else {
                this._stale = true;
            }
        }
    }
    function Sys$Data$DataSource$get_serviceUri() {
        /// <value type="String" mayBeNull="true"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._serviceUri || "";
    }
    function Sys$Data$DataSource$set_serviceUri(value) {
        var e = Function._validateParams(arguments, [{name: "value", type: String, mayBeNull: true}]);
        if (e) throw e;

        if (this._serviceUri !== value) {
            this._serviceUri = value;
            if (this.get_autoFetch() && this._isActive()) {
                if (value) {
                    this.fetchData();
                }
            }
            else {
                this._stale = true;
            }
        }
    }
    function Sys$Data$DataSource$get_timeout() {
        /// <value type="Number" integer="true"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._timeout;
    }
    function Sys$Data$DataSource$set_timeout(value) {
        var e = Function._validateParams(arguments, [{name: "value", type: Number, integer: true}]);
        if (e) throw e;

        if (value < 0) {
            throw Error.argumentOutOfRange("value", value);
        }
        this._timeout = value;
    }
    function Sys$Data$DataSource$get_query() {
        /// <value mayBeNull="true"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._query || "";
    }
    function Sys$Data$DataSource$set_query(value) {
        var e = Function._validateParams(arguments, [{name: "value", mayBeNull: true}]);
        if (e) throw e;

        if (this._query !== value) {
            this._query = value;
            if (this.get_autoFetch() && this._isActive()) {
                if (value) {
                    this.fetchData();
                }
            }
            else {
                this._stale = true;
            }
        }
    }
    function Sys$Data$DataSource$abort() {
        if (arguments.length !== 0) throw Error.parameterCount();
        if (this._request) {
            this._request.get_executor().abort();
            this._request = null;
        }
        this._fetching = false;
        this._counter++;
    }
    function Sys$Data$DataSource$dispose() {
        if (arguments.length !== 0) throw Error.parameterCount();
        if (this._fetching) {
            this.abort();
            this._fetching = false;
        }
        this._data = this._query = this._request = this._parameters = this._fetchDataMethod = null;
        Sys.Data.DataSource.callBaseMethod(this, "dispose");
    }
    function Sys$Data$DataSource$initialize() {
        if (arguments.length !== 0) throw Error.parameterCount();
        this.updated();
        Sys.Data.DataSource.callBaseMethod(this, "initialize");
    }
    function Sys$Data$DataSource$fetchData() {
        if (arguments.length !== 0) throw Error.parameterCount();
        var uri = this.get_serviceUri(),
            query = this.get_query(),
            canFetch = (uri && query),
            httpMethod = this.get_httpMethod();            
        if (!canFetch) return;
        if (this._fetching) {
            this.abort();
        }
        this._fetching = true;
        this._stale = false;
        if (!this._completed) {
            this._completed = Function.createDelegate(this, this._onCompleted);
            this._errored = Function.createDelegate(this, this._onError);
        }
        this._request = (this.get_fetchDataMethod() || this._fetchInternal)
            (this, this._completed, this._errored, this._counter);
    }
    function Sys$Data$DataSource$_fetchInternal(dataSource, succeededCallback, failedCallback, context) {
        return Sys.Net.WebServiceProxy.invoke(
            dataSource.get_serviceUri(), dataSource.get_query(),
            dataSource.get_httpMethod() === "GET", dataSource.get_parameters(), succeededCallback,
            failedCallback, context, dataSource.get_timeout());
    }
    function Sys$Data$DataSource$updated() {
        if (arguments.length !== 0) throw Error.parameterCount();
        if (this._stale && this.get_autoFetch()) {
            this._stale = false;
            this.fetchData();
        }
        if (this._dirty) {
            this._dirty = false;
            this.raisePropertyChanged("");
        }
    }
    function Sys$Data$DataSource$_isActive() {
        return this.get_isInitialized() && !this.get_isUpdating();
    }
    function Sys$Data$DataSource$_onCompleted(data, ctx) {
        if (ctx === this._counter) {
            this._counter++;
            this._fetching = false;
            this._request = null;
            this.set_data(data);
        }
    }
    function Sys$Data$DataSource$_onError(r, ctx) {
        if (ctx === this._counter) {
            this._counter++;
            this._fetching = false;
            this._request = null;
        }
            }
Sys.Data.DataSource.prototype = {
    _data: null,
    _request: null,
    _dirty: false,
    _stale: true,
    _serviceUri: null,
    _query: null,
    _fetching: false,
    _httpMethod: null,
    _timeout: 0,
    _autoFetch: true,
    _parameters: null,
    _fetchDataMethod: null,
    _counter: 0,
    get_autoFetch: Sys$Data$DataSource$get_autoFetch,
    set_autoFetch: Sys$Data$DataSource$set_autoFetch,
    get_data: Sys$Data$DataSource$get_data,
    set_data: Sys$Data$DataSource$set_data,
    get_httpMethod: Sys$Data$DataSource$get_httpMethod,
    set_httpMethod: Sys$Data$DataSource$set_httpMethod,
    get_fetching: Sys$Data$DataSource$get_fetching,
    get_fetchDataMethod: Sys$Data$DataSource$get_fetchDataMethod,
    set_fetchDataMethod: Sys$Data$DataSource$set_fetchDataMethod,
    get_parameters: Sys$Data$DataSource$get_parameters,
    set_parameters: Sys$Data$DataSource$set_parameters,
    get_serviceUri: Sys$Data$DataSource$get_serviceUri,
    set_serviceUri: Sys$Data$DataSource$set_serviceUri,
    get_timeout: Sys$Data$DataSource$get_timeout,
    set_timeout: Sys$Data$DataSource$set_timeout,
    get_query: Sys$Data$DataSource$get_query,
    set_query: Sys$Data$DataSource$set_query,
    abort: Sys$Data$DataSource$abort,
    dispose: Sys$Data$DataSource$dispose,
    initialize: Sys$Data$DataSource$initialize,
    fetchData: Sys$Data$DataSource$fetchData,
    _fetchInternal: Sys$Data$DataSource$_fetchInternal,
    updated: Sys$Data$DataSource$updated,
    _isActive: Sys$Data$DataSource$_isActive,    
    _onCompleted: Sys$Data$DataSource$_onCompleted,
    _onError: Sys$Data$DataSource$_onError
}
Sys.Data.DataSource.registerClass("Sys.Data.DataSource", Sys.Component);
Sys.Data.AdoNetDataSource = function Sys$Data$AdoNetDataSource() {
    Sys.Data.AdoNetDataSource.initializeBase(this);
}



    function Sys$Data$AdoNetDataSource$get_fetchDataMethod() {
        /// <value type="Function" mayBeNull="true"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return Sys.Data.AdoNetDataSource.callBaseMethod(this, "get_fetchDataMethod") || this._fetchAdoNet;
    }
    function Sys$Data$AdoNetDataSource$set_timeout(value) {
        Sys.Data.AdoNetDataSource.callBaseMethod(this, "set_timeout", [value]);
        if (this._proxy) {
            this._proxy.set_timeout(value);
        }
    }
    function Sys$Data$AdoNetDataSource$_fetchAdoNet(dataSource, succeededCallback, failedCallback, context) {
        var proxy = dataSource._getProxy(dataSource.get_serviceUri());
        return proxy.query(dataSource.get_query(), succeededCallback, failedCallback, context);
    }
    function Sys$Data$AdoNetDataSource$_getProxy(uri) {
        if (this._puri !== uri) {
            if (!Sys.Data.AdoNetServiceProxy) {
                throw Error.invalidOperation(Sys.TemplateRes.requiresAdoNetProxy);
            }
            this._proxy = new Sys.Data.AdoNetServiceProxy(uri);
            this._proxy.set_timeout(this.get_timeout());
            this._puri = uri;
        }
        return this._proxy;
    }
Sys.Data.AdoNetDataSource.prototype = {
    _proxy: null,
    _puri: null,
    get_fetchDataMethod: Sys$Data$AdoNetDataSource$get_fetchDataMethod,
    set_timeout: Sys$Data$AdoNetDataSource$set_timeout,
    _fetchAdoNet: Sys$Data$AdoNetDataSource$_fetchAdoNet,    
    _getProxy: Sys$Data$AdoNetDataSource$_getProxy
}
Sys.Data.AdoNetDataSource.registerClass("Sys.Data.AdoNetDataSource", Sys.Data.DataSource);