//! Script# Browser Compat Layer
//! Copyright (c) 2007, Nikhil Kothari. All Rights Reserved.
//! http://projects.nikhilk.net
//!

function __loadCompatLayer(w) {
    w.Debug = function() {
    };
    w.Debug._fail = function(message) {
        throw new Error(message);
    };
    w.Debug.writeln = function(text) {
        if (window.console) {
            if (window.console.debug) {
                window.console.debug(text);
                return;
            }
            else if (window.console.log) {
                window.console.log(text);
                return;
            }
        }
        else if (window.opera &&
            window.opera.postError) {
            window.opera.postError(text);
            return;
        }
    };

    w.__getNonTextNode = function(node) {
        try {
            while (node && (node.nodeType != 1)) {
                node = node.parentNode;
            }
        }
        catch (ex) {
            node = null;
        }
        return node;
    };
    
    w.__getLocation = function(e) {
        var loc = {x : 0, y : 0};
        while (e) {
            loc.x += e.offsetLeft;
            loc.y += e.offsetTop;
            e = e.offsetParent;
        }
        return loc;
    };

    // Allow caching regex objects for performance
    RegExp._cacheable = true;

    // Skip RegExp.test in String.quote to improve performance.
    String._quoteSkipTest = true;

    w.navigate = function(url) {
        window.setTimeout('window.location = "' + url + '";', 0);
    };

    var attachEventProxy = function(eventName, eventHandler) {
        eventHandler._mozillaEventHandler = function(e) {
            window.event = e;
            eventHandler();
            if (!e.avoidReturn) {
                return e.returnValue;
            }
        };
        this.addEventListener(eventName.slice(2), eventHandler._mozillaEventHandler, false);
    };

    var detachEventProxy = function (eventName, eventHandler) {
        if (eventHandler._mozillaEventHandler) {
            var mozillaEventHandler = eventHandler._mozillaEventHandler;
            delete eventHandler._mozillaEventHandler;
            
            this.removeEventListener(eventName.slice(2), mozillaEventHandler, false);
        }
    };

    w.attachEvent = attachEventProxy;
    w.detachEvent = detachEventProxy;
    w.HTMLDocument.prototype.attachEvent = attachEventProxy;
    w.HTMLDocument.prototype.detachEvent = detachEventProxy;
    w.HTMLElement.prototype.attachEvent = attachEventProxy;
    w.HTMLElement.prototype.detachEvent = detachEventProxy;

    w.Event.prototype.__defineGetter__('srcElement', function() {
        // __getNonTextNode(this.target) is the expected implementation.
        // However script.load has target set to the Document object... so we
        // need to throw in currentTarget as well.
        return __getNonTextNode(this.target) || this.currentTarget;
    });
    w.Event.prototype.__defineGetter__('cancelBubble', function() {
        return this._bubblingCanceled || false;
    });
    w.Event.prototype.__defineSetter__('cancelBubble', function(v) {
        if (v) {
            this._bubblingCanceled = true;
            this.stopPropagation();
        }
    });
    w.Event.prototype.__defineGetter__('returnValue', function() {
        return !this._cancelDefault;
    });
    w.Event.prototype.__defineSetter__('returnValue', function(v) {
        if (!v) {
            this._cancelDefault = true;
            this.preventDefault();
        }
    });
    w.Event.prototype.__defineGetter__('fromElement', function () {
        var n;
        if (this.type == 'mouseover') {
            n = this.relatedTarget;
        }
        else if (this.type == 'mouseout') {
            n = this.target;
        }
        return __getNonTextNode(n);
    });
    w.Event.prototype.__defineGetter__('toElement', function () {
        var n;
        if (this.type == 'mouseout') {
            n = this.relatedTarget;
        }
        else if (this.type == 'mouseover') {
            n = this.target;
        }
        return __getNonTextNode(n);
    });
    w.Event.prototype.__defineGetter__('button', function() {
        return (this.which == 1) ? 1 : (this.which == 3) ? 2 : 0
    });
    w.Event.prototype.__defineGetter__('offsetX', function() {
        return window.pageXOffset + this.clientX - __getLocation(this.srcElement).x;
    });
    w.Event.prototype.__defineGetter__('offsetY', function() {
        return window.pageYOffset + this.clientY - __getLocation(this.srcElement).y;
    });

    w.HTMLElement.prototype.__defineGetter__('parentElement', function() {
        return this.parentNode;
    });
    w.HTMLElement.prototype.__defineGetter__('children', function() {
        var children = [];
        var childCount = this.childNodes.length;
        for (var i = 0; i < childCount; i++) {
            var childNode = this.childNodes[i];
            if (childNode.nodeType == 1) {
                children.push(childNode);
            }
        }
        return children;
    });
    w.HTMLElement.prototype.__defineGetter__('innerText', function() {    
        try {
            return this.textContent
        } 
        catch (ex) {
            var text = '';
            for (var i=0; i < this.childNodes.length; i++) {
                if (this.childNodes[i].nodeType == 3) {
                    text += this.childNodes[i].textContent;
                }
            }
            return str;
        }
    });
    w.HTMLElement.prototype.__defineSetter__('innerText', function(v) {
        var textNode = document.createTextNode(v);
        this.innerHTML = '';
        this.appendChild(textNode);
    });
    w.HTMLElement.prototype.__defineGetter__('currentStyle', function() {
        return window.getComputedStyle(this, null);
    });
    w.HTMLElement.prototype.__defineGetter__('runtimeStyle', function() {
        return window.getOverrideStyle(this, null);
    });
    w.HTMLElement.prototype.removeNode = function(b) {
        return this.parentNode.removeChild(this)
    };
    w.HTMLElement.prototype.contains = function(el) {
        while (el != null && el != this) {
            el = el.parentNode;
        }
        return (el!=null)
    };

    w.HTMLStyleElement.prototype.__defineGetter__('styleSheet', function() {
        return this.sheet;
    });
    w.CSSStyleSheet.prototype.__defineGetter__('rules', function() {
        return this.cssRules;
    });
    w.CSSStyleSheet.prototype.addRule = function(selector, style, index) {
        this.insertRule(selector + '{' + style + '}', index);
    };
    w.CSSStyleSheet.prototype.removeRule = function(index) {
        this.deleteRule(index);
    };
    w.CSSStyleDeclaration.prototype.__defineGetter__('styleFloat', function() {
        return this.cssFloat;
    });
    w.CSSStyleDeclaration.prototype.__defineSetter__('styleFloat', function(v) {
        this.cssFloat = v;
    });
    DocumentFragment.prototype.getElementById = function(id) {
        var nodeQueue = [];
        var childNodes = this.childNodes;
        var node;
        var c;
        
        for (c = 0; c < childNodes.length; c++) {
            node = childNodes[c];
            if (node.nodeType == 1) {
                nodeQueue.push(node);
            }
        }

        while (nodeQueue.length) {
            node = nodeQueue.dequeue();
            if (node.id == id) {
                return node;
            }
            childNodes = node.childNodes;
            if (childNodes.length != 0) {
                for (c = 0; c < childNodes.length; c++) {
                    node = childNodes[c];
                    if (node.nodeType == 1) {
                        nodeQueue.push(node);
                    }
                }
            }
        }

        return null;
    };

    DocumentFragment.prototype.getElementsByTagName = function(tagName) {
        var elements = [];
        var nodeQueue = [];
        var childNodes = this.childNodes;
        var node;
        var c;

        for (c = 0; c < childNodes.length; c++) {
            node = childNodes[c];
            if (node.nodeType == 1) {
                nodeQueue.push(node);
            }
        }

        while (nodeQueue.length) {
            node = nodeQueue.dequeue();
            if (node.tagName == tagName) {
                elements.add(node);
            }
            childNodes = node.childNodes;
            if (childNodes.length != 0) {
                for (c = 0; c < childNodes.length; c++) {
                    node = childNodes[c];
                    if (node.nodeType == 1) {
                        nodeQueue.push(node);
                    }
                }
            }
        }

        return elements;
    };

    DocumentFragment.prototype.createElement = function(tagName) {
        return document.createElement(tagName);
    };

    var selectNodes = function(doc, path, contextNode) {
        contextNode = contextNode ? contextNode : doc;
        var xpath = new XPathEvaluator();
        var result = xpath.evaluate(path, contextNode,
                                    doc.createNSResolver(doc.documentElement),
                                    XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);

        var nodeList = new Array(result.snapshotLength);
        for(var i = 0; i < result.snapshotLength; i++) {
            nodeList[i] = result.snapshotItem(i);
        }

        return nodeList;
    };

    var selectSingleNode = function(doc, path, contextNode) {
        path += '[1]';
        var nodes = selectNodes(doc, path, contextNode);
        if (nodes.length != 0) {
            for (var i = 0; i < nodes.length; i++) {
                if (nodes[i]) {
                    return nodes[i];
                }
            }
        }
        return null;
    };

    w.XMLDocument.prototype.selectNodes = function(path, contextNode) {
        return selectNodes(this, path, contextNode);
    };

    w.XMLDocument.prototype.selectSingleNode = function(path, contextNode) {
        return selectSingleNode(this, path, contextNode);
    };

    w.XMLDocument.prototype.transformNode = function(xsl) {
        var xslProcessor = new XSLTProcessor();
        xslProcessor.importStylesheet(xsl);

        var ownerDocument = document.implementation.createDocument("", "", null);
        var transformedDoc = xslProcessor.transformToDocument(this);
        
        return transformedDoc.xml;
    };

    Node.prototype.selectNodes = function(path) {
        var doc = this.ownerDocument;
        return doc.selectNodes(path, this);
    };

    Node.prototype.selectSingleNode = function(path) {
        var doc = this.ownerDocument;
        return doc.selectSingleNode(path, this);
    };

    Node.prototype.__defineGetter__('baseName', function() {
        return this.localName;
    });

    Node.prototype.__defineGetter__('text', function() {
        return this.textContent;
    });
    Node.prototype.__defineSetter__('text', function(value) {
        this.textContent = value;
    });

    Node.prototype.__defineGetter__('xml', function() {
        return (new XMLSerializer()).serializeToString(this);
    });
}

function __supportsCompatLayer(ua) {
    // Supported browsers:
    //  - Firefox 1.5+
    //  - WebKit 500+
    //  - Opera 9.5+
    return (ua.indexOf('Gecko') >= 0) || (ua.indexOf('AppleWebKit') >= 0) || (ua.indexOf('Opera') >= 0);
}

if (__supportsCompatLayer(window.navigator.userAgent)) {
    try {
        __loadCompatLayer(window);
    }
    catch (e) {
    }
}
//! Script# Core Runtime
//! Copyright (c) 2007, Nikhil Kothari. All Rights Reserved.
//! http://projects.nikhilk.net
//!

///////////////////////////////////////////////////////////////////////////////
// Globals

function isUndefined(o) {
    return (o === undefined);
}

function isNull(o) {
    return (o === null);
}

function isNullOrUndefined(o) {
    return (o === null) || (o === undefined);
}

window.__scriptsharp = '0.5.1.0';

function $(id) {
    return document.getElementById(id);
}

document.getElementsBySelector = function getElementsBySelector(cssSelector, root) {
    var all = root ? root.getElementsByTagName('*') : document.getElementsByTagName('*');
    var matches = [];

    // Create a stylesheet we'll use to insert a CSS rule into to do the matching.
    // This is created just once.
    var styleSheet = document.getElementsBySelector.styleSheet;
    if (!styleSheet) {
        var styleSheetNode = document.createElement('style');
        styleSheetNode.type = 'text/css';

        document.getElementsByTagName('head')[0].appendChild(styleSheetNode);
        styleSheet = styleSheetNode.styleSheet || styleSheetNode.sheet;
        
        document.getElementsBySelector.styleSheet = styleSheet;
    }

    if (window.navigator.userAgent.indexOf('MSIE') >= 0) {
        // Add the rule that will be used to match elements
        styleSheet.addRule(cssSelector, 'ssCssMatch:true', 0);

        for (var i = all.length - 1; i >= 0; i--) {
            var element = all[i];

            // Find elements that contain the special css attribute, i.e.
            // the elements that match the specified selector.
            if (element.currentStyle.ssCssMatch) {
                matches[matches.length] = element;
            }
        }

        styleSheet.removeRule(0);
    }
    else {
        var matchValue = document.getElementsBySelector.matchValue;
        if (!matchValue) {
            matchValue = (window.navigator.userAgent.indexOf('Opera') >= 0) ? '"ssCssMatch"' : 'ssCssMatch 1';
            document.getElementsBySelector.matchValue = matchValue;
        }

        // Add the rule that will be used to match elements
        styleSheet.insertRule(cssSelector + ' { counter-increment: ssCssMatch }', 0);

        var docView = document.defaultView;
        for (var i = all.length - 1; i >= 0; i--) {
            var element = all[i];

            // Find elements that contain the special css attribute, i.e.
            // the elements that match the specified selector.
            if (docView.getComputedStyle(element, null).counterIncrement === matchValue) {
                matches[matches.length] = element;
            }
        }

        styleSheet.deleteRule(0);
    }

    if (matches.length > 1) {
        matches.reverse();
    }
    return matches;
}

///////////////////////////////////////////////////////////////////////////////
// Object Extensions

Object.__typeName = 'Object';
Object.__baseType = null;

Object.parse = function Object$parse(s) {
    return eval(s);
}

Object.getKeyCount = function Object$getKeyCount(d) {
    var count = 0;
    for (var n in d) {
        count++;
    }
    return count;
}

Object.clearKeys = function Object$clearKeys(d) {
    for (var n in d) {
        delete d[n];
    }
}

Object.keyExists = function Object$keyExists(d, key) {
    return d[key] !== undefined;
}

///////////////////////////////////////////////////////////////////////////////
// Function Extensions

Function.parse = function Function$parse(s) {
    if (!Function._parseCache) {
        Function._parseCache = { };
    }

    var fn = Function._parseCache[s];
    if (!fn) {
        try {
            eval('fn = ' + s);
            if (typeof(fn) != 'function') {
                fn = null;
            }
            else {
                Function._parseCache[s] = fn;
            }
        }
        catch (ex) {
        }
    }
    return fn;
}

Function.prototype.invoke = function Function$invoke() {
    this.apply(null, arguments);
}

///////////////////////////////////////////////////////////////////////////////
// Boolean Extensions

Boolean.__typeName = 'Boolean';

Boolean.parse = function Boolean$parse(s) {
    return (s.toLowerCase() == 'true');
}

///////////////////////////////////////////////////////////////////////////////
// Number Extensions

Number.__typeName = 'Number';

Number.parse = function Number$parse(s) {
    if (!s || !s.length) {
        return 0;
    }
    if ((s.indexOf('.') >= 0) || (s.indexOf('e') >= 0) ||
        s.endsWith('f') || s.endsWith('F')) {
        return parseFloat(s);
    }
    return parseInt(s, 10);
}

Number.prototype.format = function Number$format(format, useLocale) {
    if (isNullOrUndefined(format) ||
        (format.length == 0) || (format == 'i')) {
        if (useLocale) {
            return this.toLocaleString();
        }
        else {
            return this.toString();
        }
    }

    return this._netFormat(format, useLocale);
}

Number._commaFormat = function Number$_commaFormat(number, groups, decimal, comma) {
    var decimalPart = null;
    var decimalIndex = number.indexOf(decimal);
    if (decimalIndex > 0) {
        decimalPart = number.substr(decimalIndex);
        number = number.substr(0, decimalIndex);
    }

    var negative = number.startsWith('-');
    if (negative) {
        number = number.substr(1);
    }

    var groupIndex = 0;
    var groupSize = groups[groupIndex];
    if (number.length < groupSize) {
        return decimalPart ? number + decimalPart : number;
    }

    var index = number.length;
    var s = '';
    var done = false;
    while (!done) {
        var length = groupSize;
        var startIndex = index - length;
        if (startIndex < 0) {
            groupSize += startIndex;
            length += startIndex;
            startIndex = 0;
            done = true;
        }
        if (!length) {
            break;
        }
        
        var part = number.substr(startIndex, length);
        if (s.length) {
            s = part + comma + s;
        }
        else {
            s = part;
        }
        index -= length;

        if (groupIndex < groups.length - 1) {
            groupIndex++;
            groupSize = groups[groupIndex];
        }
    }

    if (negative) {
        s = '-' + s;
    }    
    return decimalPart ? s + decimalPart : s;
}

Number.prototype._netFormat = function Number$_netFormat(format, useLocale) {
    var nf = useLocale ? CultureInfo.Current.numberFormat : CultureInfo.Neutral.numberFormat;

    var s = '';    
    var precision = -1;
    
    if (format.length > 1) {
        precision = parseInt(format.substr(1));
    }

    var fs = format.charAt(0);
    switch (fs) {
        case 'd': case 'D':
            s = parseInt(Math.abs(this)).toString();
            if (precision != -1) {
                s = s.padLeft(precision, '0');
            }
            if (this < 0) {
                s = '-' + s;
            }
            break;
        case 'x': case 'X':
            s = parseInt(Math.abs(this)).toString(16);
            if (fs == 'X') {
                s = s.toUpperCase();
            }
            if (precision != -1) {
                s = s.padLeft(precision, '0');
            }
            break;
        case 'e': case 'E':
            if (precision == -1) {
                s = this.toExponential();
            }
            else {
                s = this.toExponential(precision);
            }
            if (fs == 'E') {
                s = s.toUpperCase();
            }
            break;
        case 'f': case 'F':
        case 'n': case 'N':
            if (precision == -1) {
                precision = nf.numberDecimalDigits;
            }
            s = this.toFixed(precision).toString();
            if (precision && (nf.numberDecimalSeparator != '.')) {
                var index = s.indexOf('.');
                s = s.substr(0, index) + nf.numberDecimalSeparator + s.substr(index + 1);
            }
            if ((fs == 'n') || (fs == 'N')) {
                s = Number._commaFormat(s, nf.numberGroupSizes, nf.numberDecimalSeparator, nf.numberGroupSeparator);
            }
            break;
        case 'c': case 'C':
            if (precision == -1) {
                precision = nf.currencyDecimalDigits;
            }
            s = Math.abs(this).toFixed(precision).toString();
            if (precision && (nf.currencyDecimalSeparator != '.')) {
                var index = s.indexOf('.');
                s = s.substr(0, index) + nf.currencyDecimalSeparator + s.substr(index + 1);
            }
            s = Number._commaFormat(s, nf.currencyGroupSizes, nf.currencyDecimalSeparator, nf.currencyGroupSeparator);
            if (this < 0) {
                s = String.format(nf.currencyNegativePattern, s);
            }
            else {
                s = String.format(nf.currencyPositivePattern, s);
            }
            break;
        case 'p': case 'P':
            if (precision == -1) {
                precision = nf.percentDecimalDigits;
            }
            s = (Math.abs(this) * 100.0).toFixed(precision).toString();
            if (precision && (nf.percentDecimalSeparator != '.')) {
                var index = s.indexOf('.');
                s = s.substr(0, index) + nf.percentDecimalSeparator + s.substr(index + 1);
            }
            s = Number._commaFormat(s, nf.percentGroupSizes, nf.percentDecimalSeparator, nf.percentGroupSeparator);
            if (this < 0) {
                s = String.format(nf.percentNegativePattern, s);
            }
            else {
                s = String.format(nf.percentPositivePattern, s);
            }
            break;
    }

    return s;
}

///////////////////////////////////////////////////////////////////////////////
// Math Extensions

Math.truncate = function Math$truncate(n) {
    return (n >= 0) ? Math.floor(n) : Math.ceil(n);
}

///////////////////////////////////////////////////////////////////////////////
// String Extensions

String.__typeName = 'String';
String.Empty = '';

String.compare = function String$compare(s1, s2, ignoreCase) {
    if (ignoreCase) {
        if (s1) {
            s1 = s1.toUpperCase();
        }
        if (s2) {
            s2 = s2.toUpperCase();
        }
    }
    s1 = s1 || '';
    s2 = s2 || '';

    if (s1 == s2) {
        return 0;
    }
    if (s1 < s2) {
        return -1;
    }
    return 1;
}

String.prototype.compareTo = function String$compareTo(s, ignoreCase) {
    return String.compare(this, s, ignoreCase);
}

String.prototype.endsWith = function String$endsWith(suffix) {
    if (!suffix.length) {
        return true;
    }
    if (suffix.length > this.length) {
        return false;
    }
    return (this.substr(this.length - suffix.length) == suffix);
}

String.equals = function String$equals1(s1, s2, ignoreCase) {
    return String.compare(s1, s2, ignoreCase) == 0;
}

String._format = function String$_format(format, values, useLocale) {
    if (!String._formatRE) {
        String._formatRE = /(\{[^\}^\{]+\})/g;
    }

    return format.replace(String._formatRE,
                          function(str, m) {
                              var index = parseInt(m.substr(1));
                              var value = values[index + 1];
                              if (isNullOrUndefined(value)) {
                                  return '';
                              }
                              if (value.format) {
                                  var formatSpec = null;
                                  var formatIndex = m.indexOf(':');
                                  if (formatIndex > 0) {
                                      formatSpec = m.substring(formatIndex + 1, m.length - 1);
                                  }
                                  return value.format.call(value, formatSpec, useLocale);
                              }
                              else {
                                  if (useLocale) {
                                      return value.toLocaleString();
                                  }
                                  return value.toString();
                              }
                          });
}

String.format = function String$format(format) {
    return String._format(format, arguments, /* useLocale */ false);
}

String.fromChar = function String$fromChar(ch, count) {
    var s = ch;
    for (var i = 1; i < count; i++) {
        s += ch;
    }
    return s;
}

String.prototype.htmlDecode = function String$htmlDecode() {
    if (!String._htmlDecRE) {
        String._htmlDecMap = { '&amp;': '&', '&lt;': '<', '&gt;': '>', '&quot;': '"' };
        String._htmlDecRE = /(&amp;|&lt;|&gt;|&quot;)/gi;
    }

    var s = this;
    s = s.replace(String._htmlDecRE,
                  function String$htmlDecode$replace(str, m) {
                      return String._htmlDecMap[m];
                  });
    return s;
}

String.prototype.htmlEncode = function String$htmlEncode() {
    if (!String._htmlEncRE) {
        String._htmlEncMap = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' };
        String._htmlEncRE = /([&<>"])/g;
    }

    var s = this;
    if (String._htmlEncRE.test(s)) {
        s = s.replace(String._htmlEncRE,
                      function String$htmlEncode$replace(str, m) {
                          return String._htmlEncMap[m];
                      });
    }
    return s;
}

String.prototype.indexOfAny = function String$indexOfAny(chars, startIndex, count) {
    var length = this.length;
    if (!length) {
        return -1;
    }

    startIndex = startIndex || 0;
    count = count || length;

    var endIndex = startIndex + count - 1;
    if (endIndex >= length) {
        endIndex = length - 1;
    }

    for (var i = startIndex; i <= endIndex; i++) {
        if (chars.indexOf(this.charAt(i)) >= 0) {
            return i;
        }
    }
    return -1;
}

String.prototype.insert = function String$insert(index, value) {
    if (!value) {
        return this;
    }
    if (!index) {
        return value + this;
    }
    var s1 = this.substr(0, index);
    var s2 = this.substr(index);
    return s1 + value + s2;
}

String.isNullOrEmpty = function String$isNullOrEmpty(s) {
    return !s || !s.length;
}

String.prototype.lastIndexOfAny = function String$lastIndexOfAny(chars, startIndex, count) {
    var length = this.length;
    if (!length) {
        return -1;
    }

    startIndex = startIndex || length - 1;
    count = count || length;

    var endIndex = startIndex - count + 1;
    if (endIndex < 0) {
        endIndex = 0;
    }

    for (var i = startIndex; i >= endIndex; i--) {
        if (chars.indexOf(this.charAt(i)) >= 0) {
            return i;
        }
    }
    return -1;
}

String.localeFormat = function String$localeFormat(format) {
    return String._format(format, arguments, /* useLocale */ true);
}

String.prototype.padLeft = function String$padLeft(totalWidth, ch) {
    if (this.length < totalWidth) {
        ch = ch || ' ';
        return String.fromChar(ch, totalWidth - this.length) + this;
    }
    return this;
}

String.prototype.padRight = function String$padRight(totalWidth, ch) {
    if (this.length < totalWidth) {
        ch = ch || ' ';
        return this + String.fromChar(ch, totalWidth - this.length);
    }
    return this;
}

String.prototype.quote = function String$quote() {
    if (!String._quoteMap) {
        String._quoteMap = { '\\' : '\\\\',
                             '\'' : '\\\'', '"' : '\\"',
                             '\r' : '\\r', '\n' : '\\n', '\t' : '\\t', '\f' : '\\f',
                             '\b' : '\\b' };
    }
    if (!String._quoteRE || !RegExp._cacheable) {
        String._quoteRE = new RegExp("([\'\"\\\\\x00-\x1F\x7F-\uFFFF])", "g");
    }

    var s = this;
    if (String._quoteSkipTest || String._quoteRE.test(s)) {
        s = this.replace(String._quoteRE,
                         function String$quote$replace(str, m) {
                             var c = String._quoteMap[m];
                             if (c) {
                                 return c;
                             }
                             c = m.charCodeAt(0);
                             return '\\u' + c.toString(16).toUpperCase().padLeft(4, '0');
                         });
    }
    return '"' + s + '"';
}

String.prototype.remove = function String$remove(index, count) {
    if (!count || ((index + count) > this.length)) {
        return this.substr(0, index);
    }
    return this.substr(0, index) + this.substr(index + count);
}

String.prototype._replace = String.prototype.replace;
String.prototype.replace = function String$replace(oldValue, newValue) {
    if (oldValue.constructor == String) {
        newValue = newValue || '';
        return this.split(oldValue).join(newValue);
    }
    return String.prototype._replace.call(this, oldValue, newValue);
}

String.prototype.startsWith = function String$startsWith(prefix) {
    if (!prefix.length) {
        return true;
    }
    if (prefix.length > this.length) {
        return false;
    }
    return (this.substr(0, prefix.length) == prefix);
}

String.prototype.trim = function String$trim() {
    return this.trimEnd().trimStart();
}

String.prototype.trimEnd = function String$trimEnd() {
    return this.replace(/\s*$/, '');
}

String.prototype.trimStart = function String$trimStart() {
    return this.replace(/^\s*/, '');
}

String.prototype.unquote = function String$unquote() {
    return eval('(' + this + ')');
}

///////////////////////////////////////////////////////////////////////////////
// Array Extensions

Array.__typeName = 'Array';

Array.prototype.add = function Array$add(item) {
    this[this.length] = item;
}

Array.prototype.addRange = function Array$addRange(items) {
    if (!items) {
        return;
    }
    var length = items.length;
    for (var index = 0; index < length; index++) {
        this[this.length] = items[index];
    }
}

Array.prototype.aggregate = function Array$aggregate(seed, callback) {
    var length = this.length;
    for (var index = 0; index < length; index++) {
        seed = callback(seed, this[index], index, this);
    }
    return seed;
}

Array.prototype.clear = function Array$clear() {
    if (this.length > 0) {
        this.splice(0, this.length);
    }
}

Array.prototype.clone = function Array$clone() {
    var length = this.length;
    var array = new Array(length);
    for (var index = 0; index < length; index++) {
        array[index] = this[index];
    }
    return array;
}

Array.prototype.contains = function Array$contains(item) {
    var index = this.indexOf(item);
    return (index >= 0);
}

Array.prototype.dequeue = function Array$dequeue() {
    return this.shift();
}

Array.prototype.enqueue = function Array$enqueue(item) {
    // We record that this array instance is a queue, so we
    // can implement the right behavior in the peek method.
    this._queue = true;
    this.push(item);
}

Array.prototype.peek = function Array$peek() {
    if (this.length) {
        var index = this._queue ? 0 : this.length - 1;
        return this[index];
    }
    return null;
}

if (!Array.prototype.every) {
    Array.prototype.every = function Array$every(callback) {
        for (var i = this.length - 1; i >= 0; i--) {
            if (!callback(this[i], i, this)) {
                return false;
            }
        }
        return true;
    }
}

Array.prototype.extract = function Array$extract(index, count) {
    if (!count) {
        return this.slice(index);
    }
    return this.slice(index, index + count);
}

if (!Array.prototype.filter) {
    Array.prototype.filter = function Array$filter(callback) {
        var filtered = [];
        for (var i = 0; i < this.length; i++) {
            if (callback(this[i], i, this)) {
                filtered.add(this[i]);
            }
        }
        return filtered;
    }
}

if (!Array.prototype.forEach) {
    Array.prototype.forEach = function Array$forEach(callback) {
        for (var i = 0; i < this.length; i++) {
            callback(this[i], i, this);
        }
    }
}

Array.prototype.groupBy = function Array$groupBy(callback) {
    var length = this.length;
    var groups = [];
    var keys = { };
    for (var index = 0; index < length; index++) {
        var key = callback(this[index], index);
        if (String.isNullOrEmpty(key)) {
            continue;
        }
        var items = keys[key];
        if (!items) {
            items = [];
            items.key = key;

            keys[key] = items;
            groups.add(items);
        }
        items.add(this[index]);
    }
    return groups;
}

Array.prototype.index = function Array$index(callback) {
    var length = this.length;
    var items = { };
    for (var index = 0; index < length; index++) {
        var key = callback(this[index], index);
        if (String.isNullOrEmpty(key)) {
            continue;
        }
        items[key] = this[index];
    }
    return items;
}

Array.prototype.indexOf = function Array$indexOf(item) {
    var length = this.length;
    if (length) {
        for (var index = 0; index < length; index++) {
            if (this[index] === item) {
                return index;
            }
        }
    }
    return -1;
}

Array.prototype.insert = function Array$insert(index, item) {
    this.splice(index, 0, item);
}

Array.prototype.insertRange = function Array$insertRange(index, items) {
    this.splice(index, 0, items);
}

if (!Array.prototype.map) {
    Array.prototype.map = function Array$map(callback) {
        var mapped = new Array(this.length);
        for (var i = this.length - 1; i >= 0; i--) {
            mapped[i] = callback(this[i], i, this);
        }
        return mapped;
    }
}

Array.parse = function Array$parse(s) {
    return eval('(' + s + ')');
}

Array.prototype.remove = function Array$remove(item) {
    var index = this.indexOf(item);
    if (index >= 0) {
        this.splice(index, 1);
        return true;
    }
    return false;
}

Array.prototype.removeAt = function Array$removeAt(index) {
    return this.splice(index, 1)[0];
}

Array.prototype.removeRange = function Array$removeRange(index, count) {
    return this.splice(index, count);
}

if (!Array.prototype.some) {
    Array.prototype.some = function Array$some(callback) {
        for (var i = this.length - 1; i >= 0; i--) {
            if (callback(this[i], i, this)) {
                return true;
            }
        }
        return false;
    }
}

///////////////////////////////////////////////////////////////////////////////
// RegExp Extensions

RegExp.__typeName = 'RegExp';

RegExp.parse = function RegExp$parse(s) {
    if (s.startsWith('/')) {
        var endSlashIndex = s.lastIndexOf('/');
        if (endSlashIndex > 1) {
            var expression = s.substring(1, endSlashIndex);
            var flags = s.substr(endSlashIndex + 1);
            return new RegExp(expression, flags);
        }
    }

    return null;    
}

///////////////////////////////////////////////////////////////////////////////
// Date Extensions

Date.__typeName = 'Date';

Date.get_now = function Date$get_now() {
    return new Date();
}

Date.get_today = function Date$get_today() {
    var d = new Date();
    return new Date(d.getFullYear(), d.getMonth(), d.getDate());
}

Date.prototype.format = function Date$format(format, useLocale) {
    if (isNullOrUndefined(format) ||
        (format.length == 0) || (format == 'i')) {
        if (useLocale) {
            return this.toLocaleString();
        }
        else {
            return this.toString();
        }
    }
    if (format == 'id') {
        if (useLocale) {
            return this.toLocaleDateString();
        }
        else {
            return this.toDateString();
        }
    }
    if (format == 'it') {
        if (useLocale) {
            return this.toLocaleTimeString();
        }
        else {
            return this.toTimeString();
        }
    }

    return this._netFormat(format, useLocale);
}

Date.prototype._netFormat = function Date$_netFormat(format, useLocale) {
    var dtf = useLocale ? CultureInfo.Current.dateFormat : CultureInfo.Neutral.dateFormat;
    var useUTC = false;

    if (format.length == 1) {
        switch (format) {
            case 'f': format = dtf.longDatePattern + ' ' + dtf.shortTimePattern;
            case 'F': format = dtf.dateTimePattern; break;

            case 'd': format = dtf.shortDatePattern; break;
            case 'D': format = dtf.longDatePattern; break;

            case 't': format = dtf.shortTimePattern; break;
            case 'T': format = dtf.longTimePattern; break;

            case 'g': format = dtf.shortDatePattern + ' ' + dtf.shortTimePattern; break;
            case 'G': format = dtf.shortDatePattern + ' ' + dtf.longTimePattern; break;

            case 'R': case 'r': format = dtf.gmtDateTimePattern; useUTC = true; break;
            case 'u': format = dtf.universalDateTimePattern; useUTC = true; break;
            case 'U': format = dtf.dateTimePattern; useUTC = true; break;

            case 's': format = dtf.sortableDateTimePattern; break;
        }
    }

    if (format.charAt(0) == '%') {
        format = format.substr(1);
    }

    if (!Date._formatRE) {
        Date._formatRE = /dddd|ddd|dd|d|MMMM|MMM|MM|M|yyyy|yy|y|hh|h|HH|H|mm|m|ss|s|tt|t|fff|ff|f|zzz|zz|z/g;
    }

    var re = Date._formatRE;    
    var sb = new StringBuilder();
    var dt = this;
    if (useUTC) {
        dt = new Date(Date.UTC(dt.getUTCFullYear(), dt.getUTCMonth(), dt.getUTCDate(),
                               dt.getUTCHours(), dt.getUTCMinutes(), dt.getUTCSeconds(), dt.getUTCMilliseconds()));
    }

    re.lastIndex = 0;
    while (true) {
        var index = re.lastIndex;
        var match = re.exec(format);

        sb.append(format.slice(index, match ? match.index : format.length));
        if (!match) {
            break;
        }

        var fs = match[0];
        var part = fs;
        switch (fs) {
            case 'dddd':
                part = dtf.dayNames[dt.getDay()];
                break;
            case 'ddd':
                part = dtf.shortDayNames[dt.getDay()];
                break;
            case 'dd':
                part = dt.getDate().toString().padLeft(2, '0');
                break;
            case 'd':
                part = dt.getDate();
                break;
            case 'MMMM':
                part = dtf.monthNames[dt.getMonth()];
                break;
            case 'MMM':
                part = dtf.shortMonthNames[dt.getMonth()];
                break;
            case 'MM':
                part = (dt.getMonth() + 1).toString().padLeft(2, '0');
                break;
            case 'M':
                part = (dt.getMonth() + 1);
                break;
            case 'yyyy':
                part = dt.getFullYear();
                break;
            case 'yy':
                part = (dt.getFullYear() % 100).toString().padLeft(2, '0');
                break;
            case 'y':
                part = (dt.getFullYear() % 100);
                break;
            case 'h': case 'hh':
                part = dt.getHours() % 12;
                if (!part) {
                    part = '12';
                }
                else if (fs == 'hh') {
                    part = part.toString().padLeft(2, '0');
                }
                break;
            case 'HH':
                part = dt.getHours().toString().padLeft(2, '0');
                break;
            case 'H':
                part = dt.getHours();
                break;
            case 'mm':
                part = dt.getMinutes().toString().padLeft(2, '0');
                break;
            case 'm':
                part = dt.getMinutes();
                break;
            case 'ss':
                part = dt.getSeconds().toString().padLeft(2, '0');
                break;
            case 's':
                part = dt.getSeconds();
                break;
            case 't': case 'tt':
                part = (dt.getHours() < 12) ? dtf.amDesignator : dtf.pmDesignator;
                if (fs == 't') {
                    part = part.charAt(0);
                }
                break;
            case 'fff':
                part = dt.getMilliseconds().toString().padLeft(3, '0');
                break;
            case 'ff':
                part = dt.getMilliseconds().toString().padLeft(3).substr(0, 2);
                break;
            case 'f':
                part = dt.getMilliseconds().toString().padLeft(3).charAt(0);
                break;
            case 'z':
                part = dt.getTimezoneOffset() / 60;
                part = ((part >= 0) ? '-' : '+') + Math.floor(Math.abs(part));
                break;
            case 'zz': case 'zzz':
                part = dt.getTimezoneOffset() / 60;
                part = ((part >= 0) ? '-' : '+') + Math.floor(Math.abs(part)).toString().padLeft(2, '0');
                if (fs == 'zzz') {
                    part += dtf.timeSeparator + Math.abs(dt.getTimezoneOffset() % 60).toString().padLeft(2, '0');
                }
                break;
        }
        sb.append(part);
    }

    return sb.toString();
}

Date._parse = Date.parse;
Date.parse = function Date$parse(s) {
    // Date.parse by default returns the number of milliseconds
    // and not an actual Date instance
    return new Date(Date._parse(s));
}

///////////////////////////////////////////////////////////////////////////////
// Error Extensions

Error.__typeName = 'Error';

Error.create = function Error$create(message, userData, innerException) {
    var e = new Error(message);
    if (userData) {
        e.userData = userData;
    }
    if (innerException) {
        e.innerException = innerException;
    }
    return e;
}

///////////////////////////////////////////////////////////////////////////////
// Debug Extensions

if (!Debug._fail) {
    Debug._fail = function Debug$_fail(message) {
        Debug.writeln(message);
        eval('debugger;');
    }
}

Debug.assert = function Debug$assert(condition, message) {
    if (!condition) {
        message = 'Assert failed: ' + message;
        if (confirm(message + '\r\n\r\nBreak into debugger?')) {
            Debug._fail(message);
        }
    }
}

Debug._dumpCore = function Debug$_dumpCore(sb, object, name, indentation, dumpedObjects) {
    if (object === null) {
        sb.appendLine(indentation + name + ': null');
        return;
    }
    switch (typeof(object)) {
        case 'undefined':
            sb.appendLine(indentation + name + ': undefined');
            break;
        case 'number':
        case 'string':
        case 'boolean':
            sb.appendLine(indentation + name + ': ' + object);
            break;
        default:
            if (Date.isInstance(object) || RegExp.isInstance(object)) {
                sb.appendLine(indentation + name + ': ' + object);
                break;
            }

            if (dumpedObjects.contains(object)) {
                sb.appendLine(indentation + name + ': ...');
                break;
            }
            dumpedObjects.add(object);

            var type = Type.getInstanceType(object);
            var typeName = type.get_fullName();
            var recursiveIndentation = indentation + '  ';

            if (IArray.isInstance(object)) {
                sb.appendLine(indentation + name + ': {' + typeName + '}');
                var length = object.getLength();
                for (var i = 0; i < length; i++) {
                    Debug._dumpCore(sb, object.getItem(i), '[' + i + ']', recursiveIndentation, dumpedObjects);
                }
            }
            else {
                if (object.tagName) {
                    sb.appendLine(indentation + name + ': <' + object.tagName + '>');
                    var attributes = object.attributes;
                    for (var i = 0; i < attributes.length; i++) {
                        var attrValue = attributes[i].nodeValue;
                        if (attrValue) {
                            Debug._dumpCore(sb, attrValue, attributes[i].nodeName, recursiveIndentation, dumpedObjects);
                        }
                    }
                }
                else {
                    sb.appendLine(indentation + name + ': {' + typeName + '}');
                    for (var field in object) {
                        var v = object[field];
                        if (!Function.isInstance(v)) {
                            Debug._dumpCore(sb, v, field, recursiveIndentation, dumpedObjects);
                        }
                    }
                }
            }

            dumpedObjects.remove(object);
            break;
    }
}

Debug.dump = function Debug$dump(object, name) {
    if ((!name || !name.length) && (object !== null)) {
        name = Type.getInstanceType(object).get_fullName();
    }
    if (!name || !name.length) {
        return;
    }
    var sb = new StringBuilder();
    Debug._dumpCore(sb, object, name, '', []);
    Debug.writeLine(sb.toString());
}

Debug.fail = function Debug$fail(message) {
    Debug._fail(message);
}

Debug.inspect = function Debug$inspect(object, name) {
    var dumped = false;
    if (window.debugService) {
        dumped = window.debugService.inspect(name, object);
    }
    if (!dumped) {
        Debug.dump(object, name);
    }
}

Debug.writeLine = function Debug$writeLine(message) {
    if (window.debugService) {
        window.debugService.trace(message);
        return;
    }
    Debug.writeln(message);

    var traceTextBox = $('_traceTextBox');
    if (traceTextBox) {
        traceTextBox.value = traceTextBox.value + '\r\n' + message;
    }
}

Debug.__typeName = 'Debug';

///////////////////////////////////////////////////////////////////////////////
// Type System Implementation

var Type = Function;
Type.__typeName = 'Type';

var __Namespace = function(name) {
    this.__typeName = name;
}
__Namespace.prototype = {
    __namespace: true,
    getName: function() {
        return this.__typeName;
    }
}

Type.createNamespace = function Type$createNamespace(name) {
    if (!window.__namespaces) {
        window.__namespaces = {};
    }
    if (!window.__rootNamespaces) {
        window.__rootNamespaces = [];
    }

    if (window.__namespaces[name]) {
        return;
    }

    var ns = window;
    var nameParts = name.split('.');

    for (var i = 0; i < nameParts.length; i++) {
        var part = nameParts[i];
        var nso = ns[part];
        if (!nso) {
            ns[part] = nso = new __Namespace(nameParts.slice(0, i + 1).join('.'));
            if (i == 0) {
                window.__rootNamespaces.add(nso);
            }
        }
        ns = nso;
    }

    window.__namespaces[name] = ns;
}

Type.prototype.createClass = function Type$createClass(name, baseType, interfaceType) {
    this.prototype.constructor = this;
    this.__typeName = name;
    this.__class = true;
    this.__baseType = baseType || Object;
    if (baseType) {
        this.__basePrototypePending = true;
    }

    if (interfaceType) {
        this.__interfaces = [];
        for (var i = 2; i < arguments.length; i++) {
            interfaceType = arguments[i];
            this.__interfaces.add(interfaceType);
        }
    }
}

Type.prototype.createInterface = function Type$createInterface(name) {
    this.__typeName = name;
    this.__interface = true;
}

Type.prototype.createEnum = function Type$createEnum(name, flags) {
    for (var field in this.prototype) {
         this[field] = this.prototype[field];
    }

    this.__typeName = name;
    this.__enum = true;
    if (flags) {
        this.__flags = true;
    }
}

Type.prototype.setupBase = function Type$setupBase() {
    if (this.__basePrototypePending) {
        var baseType = this.__baseType;
        if (baseType.__basePrototypePending) {
            baseType.setupBase();
        }

        for (var memberName in baseType.prototype) {
            var memberValue = baseType.prototype[memberName];
            if (!this.prototype[memberName]) {
                this.prototype[memberName] = memberValue;
            }
        }

        delete this.__basePrototypePending;
    }
}

if (!Type.prototype.resolveInheritance) {
    // This function is not used by Script#; Visual Studio relies on it
    // for JavaScript IntelliSense support of derived types.
    Type.prototype.resolveInheritance = Type.prototype.setupBase;
}

Type.prototype.constructBase = function Type$constructBase(instance, args) {
    if (this.__basePrototypePending) {
        this.setupBase();
    }

    if (!args) {
        this.__baseType.apply(instance);
    }
    else {
        this.__baseType.apply(instance, args);
    }
}

Type.prototype.callBase = function Type$callBase(instance, name, args) {
    var baseMethod = this.__baseType.prototype[name];
    if (!args) {
        return baseMethod.apply(instance);
    }
    else {
        return baseMethod.apply(instance, args);
    }
}

Type.prototype.get_baseType = function Type$get_baseType() {
    return this.__baseType || null;
}

Type.prototype.get_fullName = function Type$get_fullName() {
    return this.__typeName;
}

Type.prototype.get_name = function Type$get_name() {
    var fullName = this.__typeName;
    var nsIndex = fullName.lastIndexOf('.');
    if (nsIndex > 0) {
        return fullName.substr(nsIndex + 1);
    }
    return fullName;
}

Type.prototype.isInstance = function Type$isInstance(instance) {
    if (isNullOrUndefined(instance)) {
        return false;
    }
    if ((this == Object) || (instance instanceof this)) {
        return true;
    }

    var type = Type.getInstanceType(instance);
    return this.isAssignableFrom(type);
}

Type.prototype.isAssignableFrom = function Type$isAssignableFrom(type) {
    if ((this == Object) || (this == type)) {
        return true;
    }
    if (this.__class) {
        var baseType = type.__baseType;
        while (baseType) {
            if (this == baseType) {
                return true;
            }
            baseType = baseType.__baseType;
        }
    }
    else if (this.__interface) {
        var interfaces = type.__interfaces;
        if (interfaces && interfaces.contains(this)) {
            return true;
        }

        var baseType = type.__baseType;
        while (baseType) {
            interfaces = baseType.__interfaces;
            if (interfaces && interfaces.contains(this)) {
                return true;
            }
            baseType = baseType.__baseType;
        }
    }
    return false;
}

Type.isClass = function Type$isClass(type) {
    return (type.__class == true);
}

Type.isEnum = function Type$isEnum(type) {
    return (type.__enum == true);
}

Type.isFlagsEnum = function Type$isFlagsEnum(type) {
    return ((type.__enum == true) && (type.__flags == true));
}

Type.isInterface = function Type$isInterface(type) {
    return (type.__interface == true);
}

Type.canCast = function Type$canCast(instance, type) {
    return type.isInstance(instance);
}

Type.safeCast = function Type$safeCast(instance, type) {
    if (type.isInstance(instance)) {
        return instance;
    }
    return null;
}

Type.getInstanceType = function Type$getInstanceType(instance) {
    var ctor = null;

    // NOTE: We have to catch exceptions because the constructor
    //       cannot be looked up on native COM objects
    try {
        ctor = instance.constructor;
    }
    catch (ex) {
    }
    if (!ctor || !ctor.__typeName) {
        ctor = Object;
    }
    return ctor;
}

Type.getType = function Type$getType(typeName) {
    if (!typeName) {
        return null;
    }

    if (!Type.__typeCache) {
        Type.__typeCache = {};
    }

    var type = Type.__typeCache[typeName];
    if (!type) {
        type = eval(typeName);
        Type.__typeCache[typeName] = type;
    }
    return type;
}

Type.parse = function Type$parse(typeName) {
    return Type.getType(typeName);
}

///////////////////////////////////////////////////////////////////////////////
// Enum

var Enum = function() {
}
Enum.createClass('Enum');

Enum.parse = function Enum$parse(enumType, s) {
    var values = enumType.prototype;
    if (!enumType.__flags) {
        for (var f in values) {
            if (f === s) {
                return values[f];
            }
        }
    }
    else {
        var parts = s.split('|');
        var value = 0;
        var parsed = true;

        for (var i = parts.length - 1; i >= 0; i--) {
            var part = parts[i].trim();
            var found = false;

            for (var f in values) {
                if (f === part) {
                    value |= values[f];
                    found = true;
                    break;
                }
            }
            if (!found) {
                parsed = false;
                break;
            }
        }

        if (parsed) {
            return value;
        }
    }
    throw 'Invalid Enumeration Value';
}

Enum.toString = function Enum$toString(enumType, value) {
    var values = enumType.prototype;
    if (!enumType.__flags || (value === 0)) {
        for (var i in values) {
            if (values[i] === value) {
                return i;
            }
        }
        throw 'Invalid Enumeration Value';
    }
    else {
        var parts = [];
        for (var i in values) {
            if (values[i] & value) {
                if (parts.length) {
                    parts.add(' | ');
                }
                parts.add(i);
            }
        }
        if (!parts.length) {
            throw 'Invalid Enumeration Value';
        }
        return parts.join('');
    }
}

///////////////////////////////////////////////////////////////////////////////
// Delegate

var Delegate = function() {
}
Delegate.createClass('Delegate');

Delegate.Null = function() { }

Delegate._create = function Delegate$_create(targets) {
    var delegate = function() {
        if (targets.length == 2) {
            return targets[1].apply(targets[0], arguments);
        }
        else {
            for (var i = 0; i < targets.length; i += 2) {
                targets[i + 1].apply(targets[i], arguments);
            }
            return null;
        }
    };
    delegate.invoke = delegate;
    delegate._targets = targets;

    return delegate;
}

Delegate.create = function Delegate$create(object, method) {
    if (!object) {
        method.invoke = method;
        return method;
    }
    return Delegate._create([object, method]);
}

Delegate.combine = function Delegate$combine(delegate1, delegate2) {
    if (!delegate1) {
        if (!delegate2._targets) {
            return Delegate.create(null, delegate2);
        }
        return delegate2;
    }
    if (!delegate2) {
        if (!delegate1._targets) {
            return Delegate.create(null, delegate1);
        }
        return delegate1;
    }

    var targets1 = delegate1._targets ? delegate1._targets : [null, delegate1];
    var targets2 = delegate2._targets ? delegate2._targets : [null, delegate2];

    return Delegate._create(targets1.concat(targets2));
}

Delegate.remove = function Delegate$remove(delegate1, delegate2) {
    if (!delegate1 || (delegate1 === delegate2)) {
        return null;
    }
    if (!delegate2) {
        return delegate1;
    }

    var targets = delegate1._targets;
    var object = null;
    var method;
    if (delegate2._targets) {
        object = delegate2._targets[0];
        method = delegate2._targets[1];
    }
    else {
        method = delegate2;
    }

    for (var i = 0; i < targets.length; i += 2) {
        if ((targets[i] === object) && (targets[i + 1] === method)) {
            if (targets.length == 2) {
                return null;
            }
            targets.splice(i, 2);
            return Delegate._create(targets);
        }
    }

    return delegate1;
}


Delegate.createExport = function Delegate$createExport(delegate, multiUse) {
    var name = '__' + (new Date()).valueOf();
    Delegate[name] = function() {
        if (!multiUse) {
            Delegate.deleteExport(name);
        }
        delegate.apply(null, arguments);
    };

    return name;
}

Delegate.deleteExport = function Delegate$deleteExport(name) {
    if (Delegate[name]) {
        delete Delegate[name];
    }
}

Delegate.clearExport = function Delegate$clearExport(name) {
    if (Delegate[name]) {
        Delegate[name] = Delegate.Null;
    }
}

///////////////////////////////////////////////////////////////////////////////
// CultureInfo

var CultureInfo = function(name, numberFormat, dateFormat) {
    this.name = name;
    this.numberFormat = numberFormat;
    this.dateFormat = dateFormat;
}
CultureInfo.createClass('CultureInfo');

CultureInfo.Neutral = new CultureInfo('en-US',
    {
        naNSymbol: 'NaN',
        negativeSign: '-',
        positiveSign: '+',
        negativeInfinityText: '-Infinity',
        positiveInfinityText: 'Infinity',
        
        percentSymbol: '%',
        percentGroupSizes: [3],
        percentDecimalDigits: 2,
        percentDecimalSeparator: '.',
        percentGroupSeparator: ',',
        percentPositivePattern: '{0} %',
        percentNegativePattern: '-{0} %',

        currencySymbol:'$',
        currencyGroupSizes: [3],
        currencyDecimalDigits: 2,
        currencyDecimalSeparator: '.',
        currencyGroupSeparator: ',',
        currencyNegativePattern: '(${0})',
        currencyPositivePattern: '${0}',

        numberGroupSizes: [3],
        numberDecimalDigits: 2,
        numberDecimalSeparator: '.',
        numberGroupSeparator: ','
    },
    {
        amDesignator: 'AM',
        pmDesignator: 'PM',

        dateSeparator: '/',
        timeSeparator: ':',

        gmtDateTimePattern: 'ddd, dd MMM yyyy HH:mm:ss \'GMT\'',
        universalDateTimePattern: 'yyyy-MM-dd HH:mm:ssZ',
        sortableDateTimePattern: 'yyyy-MM-ddTHH:mm:ss',
        dateTimePattern: 'dddd, MMMM dd, yyyy h:mm:ss tt',

        longDatePattern: 'dddd, MMMM dd, yyyy',
        shortDatePattern: 'M/d/yyyy',

        longTimePattern: 'h:mm:ss tt',
        shortTimePattern: 'h:mm tt',

        firstDayOfWeek: 0,
        dayNames: ['Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday'],
        shortDayNames: ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'],
        minimizedDayNames: ['Su','Mo','Tu','We','Th','Fr','Sa'],

        monthNames: ['January','February','March','April','May','June','July','August','September','October','November','December',''],
        shortMonthNames: ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec','']
    });
CultureInfo.Current = CultureInfo.Neutral;

///////////////////////////////////////////////////////////////////////////////
// IArray

var IArray = function() { };
IArray.prototype = {
    getLength: null,
    getItem: null
}
IArray.createInterface('IArray');

///////////////////////////////////////////////////////////////////////////////
// IEnumerator

var IEnumerator = function() { };
IEnumerator.prototype = {
    get_current: null,
    moveNext: null,
    reset: null
}
IEnumerator.createInterface('IEnumerator');

///////////////////////////////////////////////////////////////////////////////
// IEnumerable

var IEnumerable = function() { };
IEnumerable.prototype = {
    getEnumerator: null
}
IEnumerable.createInterface('IEnumerable');

///////////////////////////////////////////////////////////////////////////////
// ArrayEnumerator

var ArrayEnumerator = function ArrayEnumerator$(array) {
    this._array = array;
    this._index = -1;
}
ArrayEnumerator.prototype = {
    get_current: function ArrayEnumerator$get_current() {
        return this._array[this._index];
    },
    moveNext: function ArrayEnumerator$moveNext() {
        this._index++;
        return (this._index < this._array.length);
    },
    reset: function ArrayEnumerator$reset() {
        this._index = -1;
    }
}

ArrayEnumerator.createClass('ArrayEnumerator', null, IEnumerator);

///////////////////////////////////////////////////////////////////////////////
// Array Extensions

Array.__interfaces = [ IArray, IEnumerable ];

Array.prototype.getLength = function Array$getLength() {
    return this.length;
}
Array.prototype.getItem = function Array$getItem(index) {
    return this[index];
}

Array.prototype.getEnumerator = function Array$getEnumerator() {
    return new ArrayEnumerator(this);
}

///////////////////////////////////////////////////////////////////////////////
// IDisposable

var IDisposable = function() { };
IDisposable.prototype = {
    dispose: null
}
IDisposable.createInterface('IDisposable');

///////////////////////////////////////////////////////////////////////////////
// IServiceProvider

var IServiceProvider = function() { };
IServiceProvider.prototype = {
    getService: null
}
IServiceProvider.createInterface('IServiceProvider');

///////////////////////////////////////////////////////////////////////////////
// IServiceContainer

var IServiceContainer = function() { };
IServiceContainer.prototype = {
    registerService: null,
    unregisterService: null
}
IServiceContainer.createInterface('IServiceContainer');

///////////////////////////////////////////////////////////////////////////////
// StringBuilder

var StringBuilder = function StringBuilder$(s) {

    if ((s !== undefined) && (s !== null)) {
        this._parts = [ s ];
    }
    else {
        this._parts = [];
    }
}
StringBuilder.prototype = {
    get_isEmpty: function StringBuilder$get_isEmpty() {
        return (this._parts.length == 0);
    },

    append: function StringBuilder$append(s) {
        if ((s !== undefined) && (s !== null)) {
            this._parts.add(s);
        }
    },

    appendLine: function StringBuilder$appendLine(s) {
        this.append(s);
        this.append('\r\n');
    },

    clear: function StringBuilder$clear() {
        this._parts.clear();
    },

    toString: function StringBuilder$toString() {
        return this._parts.join('');
    }
};

StringBuilder.createClass('StringBuilder');

///////////////////////////////////////////////////////////////////////////////
// EventArgs

var EventArgs = function EventArgs$() {
}
EventArgs.createClass('EventArgs');

EventArgs.Empty = new EventArgs();

///////////////////////////////////////////////////////////////////////////////
// XMLHttpRequest

if (!window.XMLHttpRequest) {
    window.XMLHttpRequest = function() {
        var progIDs = [ 'Msxml2.XMLHTTP', 'Microsoft.XMLHTTP' ];

        for (var i = 0; i < progIDs.length; i++) {
            try {
                var xmlHttp = new ActiveXObject(progIDs[i]);
                return xmlHttp;
            }
            catch (ex) {
            }
        }

        return null;
    }
}

///////////////////////////////////////////////////////////////////////////////
// XMLDocumentParser

var XMLDocumentParser = function() {
}
XMLDocumentParser.createClass('XMLDocumentParser');

XMLDocumentParser.parse = function XMLDocumentParser$parse(markup) {
    if (!window.DOMParser) {
        var progIDs = [ 'Msxml2.DOMDocument.3.0', 'Msxml2.DOMDocument' ];
        
        for (var i = 0; i < progIDs.length; i++) {
            try {
                var xmlDOM = new ActiveXObject(progIDs[i]);
                xmlDOM.async = false;
                xmlDOM.loadXML(markup);
                xmlDOM.setProperty('SelectionLanguage', 'XPath');
                
                return xmlDOM;
            }
            catch (ex) {
            }
        }
    }
    else {
        try {
            var domParser = new DOMParser();
            return domParser.parseFromString(markup, 'text/xml');
        }
        catch (ex) {
        }
    }

    return null;
}

////////////////////////////////////////////////////////////////////////////////
// ScriptLoader

var ScriptLoader = function ScriptLoader(scriptURLs) {
    Debug.assert((scriptURLs) && (scriptURLs.length));
    this._scriptURLs = scriptURLs;
    this._scriptLoadIndex = -1;
}
ScriptLoader.prototype = {
    _scriptURLs: null,
    _loadedHandler: null,
    _errorHandler: null,
    _isIE: false,
    _onLoadHandler: null,
    _onErrorHandler: null,
    _scriptLoadIndex: 0,
    _scriptElements: null,
    _loadedScripts: 0,
    _inError: false,
    _loaded: false,
    
    dispose: function ScriptLoader$dispose() {
        if (this._scriptElements) {
            for (var i = 0; i < this._scriptElements.length; i++) {
                var scriptElement = this._scriptElements[i];
                if (this._isIE) {
                    scriptElement.detachEvent('onreadystatechange', this._onLoadHandler);
                }
                else {
                    scriptElement.detachEvent('onload', this._onLoadHandler);
                    scriptElement.detachEvent('onerror', this._onErrorHandler);
                }
            }
            this._scriptElements = null;
        }
    },
    
    load: function ScriptLoader$load(loadInParallel, timeout, loadedHandler, errorHandler) {
        Debug.assert(loadedHandler);
        Debug.assert(errorHandler);
        this._loadedHandler = loadedHandler;
        this._errorHandler = errorHandler;
        this._isIE = (window.navigator.userAgent.indexOf('MSIE') >= 0);
        this._onLoadHandler = Delegate.create(this, this._onScriptLoad);
        if (!this._isIE) {
            this._onErrorHandler = Delegate.create(this, this._onScriptError);
        }
        this._scriptElements = [];
        if (loadInParallel) {
            for (var i = 0; i < this._scriptURLs.length; i++) {
                this._loadScript(this._scriptURLs[i]);
            }
        }
        else {
            this._scriptLoadIndex++;
            this._loadScript(this._scriptURLs[this._scriptLoadIndex]);
        }
        if (timeout) {
            window.setTimeout(Delegate.create(this, this._onScriptError), timeout);
        }
    },
    
    _loadScript: function ScriptLoader$_loadScript(scriptURL) {
        var scriptElement = document.createElement('SCRIPT');
        if (this._isIE) {
            scriptElement.attachEvent('onreadystatechange', this._onLoadHandler);
        }
        else {
            scriptElement.readyState = 'complete';
            scriptElement.attachEvent('onload', this._onLoadHandler);
            scriptElement.attachEvent('onerror', this._onErrorHandler);
        }
        scriptElement.type = 'text/javascript';
        scriptElement.src = scriptURL;
        this._scriptElements.add(scriptElement);
        document.getElementsByTagName('HEAD')[0].appendChild(scriptElement);
    },
    
    _onScriptError: function ScriptLoader$_onScriptError() {
        if ((!this._inError) && (!this._loaded)) {
            this._inError = true;
            this._errorHandler.invoke(this, EventArgs.Empty);
        }
    },
    
    _onScriptLoad: function ScriptLoader$_onScriptLoad() {
        if (this._inError) {
            return;
        }
        var scriptElement = window.event.srcElement;
        if (!scriptElement.readyState) {
            scriptElement = window.event.currentTarget;
        }

        if ((scriptElement.readyState != 'complete') && (scriptElement.readyState != 'loaded')) {
            return;
        }
        if (this._scriptLoadIndex != -1) {
            this._scriptLoadIndex++;
            if (this._scriptLoadIndex != this._scriptURLs.length) {
                this._loadScript(this._scriptURLs[this._scriptLoadIndex]);
                return;
            }
        }
        else {
            this._loadedScripts++;
            if (this._loadedScripts != this._scriptURLs.length) {
                return;
            }
        }
        this._loaded = true;
        this._loadedHandler.invoke(this, EventArgs.Empty);
    }
};

ScriptLoader.createClass('ScriptLoader', null, IDisposable);

////////////////////////////////////////////////////////////////////////////////
// ScriptHost

var ScriptHost = function ScriptHost() {
}
ScriptHost.get_isLoading = function ScriptHost$get_isLoading() {
    return ScriptHost._loading;
}
ScriptHost.add_load = function ScriptHost$add_load(value) {
    if (ScriptHost._loaded) {
        value.invoke(null, EventArgs.Empty);
    }
    else {
        ScriptHost._loadHandler = Delegate.combine(ScriptHost._loadHandler, value);
    }
}
ScriptHost.remove_load = function ScriptHost$remove_load(value) {
    ScriptHost._loadHandler = Delegate.remove(ScriptHost._loadHandler, value);
}
ScriptHost.add_unload = function ScriptHost$add_unload(value) {
    ScriptHost._unloadHandler = Delegate.combine(ScriptHost._unloadHandler, value);
}
ScriptHost.remove_unload = function ScriptHost$remove_unload(value) {
    ScriptHost._unloadHandler = Delegate.remove(ScriptHost._unloadHandler, value);
}
ScriptHost.close = function ScriptHost$close() {
    if (ScriptHost._fxScripts) {
        ScriptHost._fxScripts.dispose();
        ScriptHost._fxScripts = null;
    }
    if (ScriptHost._coreScripts) {
        ScriptHost._coreScripts.dispose();
        ScriptHost._coreScripts = null;
    }
    if (ScriptHost._unloadHandler) {
        ScriptHost._unloadHandler.invoke(null, EventArgs.Empty);
        ScriptHost._unloadHandler = null;
    }
    if (ScriptHost._windowLoadHandler) {
        window.detachEvent('onload', ScriptHost._windowLoadHandler);
        ScriptHost._windowLoadHandler = null;
    }
    if (ScriptHost._windowUnloadHandler) {
        window.detachEvent('onunload', ScriptHost._windowUnloadHandler);
        ScriptHost._windowUnloadHandler = null;
    }
}
ScriptHost.initialize = function ScriptHost$initialize(coreScriptURLs, fxScriptURLs) {
    if (!ScriptHost._initialized) {
        ScriptHost._initialized = true;
        if (ScriptHost._windowLoadHandler) {
            window.detachEvent('onload', ScriptHost._windowLoadHandler);
            ScriptHost._windowLoadHandler = null;
        }
        if ((coreScriptURLs) && (coreScriptURLs.length)) {
            ScriptHost._coreScripts = new ScriptLoader(coreScriptURLs);
        }
        if ((fxScriptURLs) && (fxScriptURLs.length)) {
            ScriptHost._fxScripts = new ScriptLoader(fxScriptURLs);
        }
        if ((!ScriptHost._coreScripts) && (!ScriptHost._fxScripts)) {
            ScriptHost._onLoaded();
        }
        else {
            ScriptHost._loadScripts();
        }
    }
}
ScriptHost._loadScripts = function ScriptHost$_loadScripts() {
    ScriptHost._loading = true;
    if (ScriptHost._coreScripts) {
        ScriptHost._coreScripts.load(false, 20 * 1000, Delegate.create(null, ScriptHost._onScriptsCompleted), Delegate.create(null, ScriptHost._onScriptsError));
        return;
    }
    else {
        ScriptHost._fxScripts.load(true, 20 * 1000, Delegate.create(null, ScriptHost._onScriptsCompleted), Delegate.create(null, ScriptHost._onScriptsError));
    }
}
ScriptHost._onLoaded = function ScriptHost$_onLoaded() {
    ScriptHost._loaded = true;
    if (window.main) {
        window.main();
    }
    if (ScriptHost._loadHandler) {
        ScriptHost._loadHandler.invoke(null, EventArgs.Empty);
        ScriptHost._loadHandler = null;
    }
}
ScriptHost._onScriptsCompleted = function ScriptHost$_onScriptsCompleted(sender, e) {
    if (sender == ScriptHost._coreScripts) {
        ScriptHost._coreScripts.dispose();
        ScriptHost._coreScripts = null;
        if (ScriptHost._fxScripts) {
            ScriptHost._fxScripts.load(true, 20 * 1000, Delegate.create(null, ScriptHost._onScriptsCompleted), Delegate.create(null, ScriptHost._onScriptsError));
            return;
        }
    }
    else {
        ScriptHost._fxScripts.dispose();
        ScriptHost._fxScripts = null;
    }
    ScriptHost._loading = false;
    ScriptHost._onLoaded();
}
ScriptHost._onScriptsError = function ScriptHost$_onScriptsError(sender, e) {
}
ScriptHost._onWindowLoad = function ScriptHost$_onWindowLoad() {
    ScriptHost.initialize(null, null);
}
ScriptHost._onWindowUnload = function ScriptHost$_onWindowUnload() {
    ScriptHost.close();
}

ScriptHost.createClass('ScriptHost');

ScriptHost._coreScripts = null;
ScriptHost._fxScripts = null;
ScriptHost._loadHandler = null;
ScriptHost._unloadHandler = null;
ScriptHost._initialized = false;
ScriptHost._loading = false;
ScriptHost._loaded = false;
ScriptHost._windowLoadHandler = Delegate.create(null, ScriptHost._onWindowLoad);
ScriptHost._windowUnloadHandler = Delegate.create(null, ScriptHost._onWindowUnload);
window.attachEvent('onload', ScriptHost._windowLoadHandler);
window.attachEvent('onunload', ScriptHost._windowUnloadHandler);
// Script# Framework
// Copyright (c) 2007, Nikhil Kothari. All Rights Reserved.
// http://projects.nikhilk.net
//


Type.createNamespace('ScriptFX');

////////////////////////////////////////////////////////////////////////////////
// ScriptFX.CollectionChangedAction

ScriptFX.CollectionChangedAction = function() { };
ScriptFX.CollectionChangedAction.prototype = {
    add: 0, 
    remove: 1, 
    reset: 2
}
ScriptFX.CollectionChangedAction.createEnum('ScriptFX.CollectionChangedAction', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX._registeredEvent

ScriptFX.$create__registeredEvent = function ScriptFX__registeredEvent(eventType, sender, eventArgs, eventCookie) {
    var $o = { };
    $o.eventType = eventType;
    $o.sender = sender;
    $o.eventArgs = eventArgs;
    $o.eventCookie = eventCookie;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.IEventManager

ScriptFX.IEventManager = function() { };
ScriptFX.IEventManager.prototype = {
    raiseEvent : null,
    registerEvent : null,
    registerEventHandler : null,
    unregisterEvent : null,
    unregisterEventHandler : null
}
ScriptFX.IEventManager.createInterface('ScriptFX.IEventManager');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.ISupportInitialize

ScriptFX.ISupportInitialize = function() { };
ScriptFX.ISupportInitialize.prototype = {
    beginInitialize : null,
    endInitialize : null
}
ScriptFX.ISupportInitialize.createInterface('ScriptFX.ISupportInitialize');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.INotifyDisposing

ScriptFX.INotifyDisposing = function() { };
ScriptFX.INotifyDisposing.prototype = {
    add_disposing : null,
    remove_disposing : null
}
ScriptFX.INotifyDisposing.createInterface('ScriptFX.INotifyDisposing');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.HostName

ScriptFX.HostName = function() { };
ScriptFX.HostName.prototype = {
    other: 0, 
    IE: 1, 
    mozilla: 2, 
    safari: 3, 
    opera: 4
}
ScriptFX.HostName.createEnum('ScriptFX.HostName', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.INotifyCollectionChanged

ScriptFX.INotifyCollectionChanged = function() { };
ScriptFX.INotifyCollectionChanged.prototype = {
    add_collectionChanged : null,
    remove_collectionChanged : null
}
ScriptFX.INotifyCollectionChanged.createInterface('ScriptFX.INotifyCollectionChanged');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.INotifyPropertyChanged

ScriptFX.INotifyPropertyChanged = function() { };
ScriptFX.INotifyPropertyChanged.prototype = {
    add_propertyChanged : null,
    remove_propertyChanged : null
}
ScriptFX.INotifyPropertyChanged.createInterface('ScriptFX.INotifyPropertyChanged');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.ITask

ScriptFX.ITask = function() { };
ScriptFX.ITask.prototype = {
    execute : null
}
ScriptFX.ITask.createInterface('ScriptFX.ITask');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.IObjectWithOwner

ScriptFX.IObjectWithOwner = function() { };
ScriptFX.IObjectWithOwner.prototype = {
    get_owner : null,
    setOwner : null
}
ScriptFX.IObjectWithOwner.createInterface('ScriptFX.IObjectWithOwner');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Application

ScriptFX.Application = function ScriptFX_Application() {
    this._disposableObjects = [];
    this._idleFrequency = 100;
    ScriptHost.add_load(Delegate.create(this, this._onScriptHostLoad));
    ScriptHost.add_unload(Delegate.create(this, this._onScriptHostUnload));
    this._windowUnloadingHandler = Delegate.create(this, this._onWindowUnloading);
    window.attachEvent('onbeforeunload', this._windowUnloadingHandler);
    this._windowErrorHandler = Delegate.create(this, this._onWindowError);
    window.attachEvent('onerror', this._windowErrorHandler);
    var rootElement = document.documentElement;
    var className = rootElement.className;
    if (className.startsWith('$')) {
        var hostInfo = this.get_host();
        className = className.replace('$browser', Enum.toString(ScriptFX.HostName, hostInfo.get_name()));
        className = className.replace('$majorver', hostInfo.get_majorVersion().toString());
        className = className.replace('$minorver', hostInfo.get_minorVersion().toString());
        rootElement.className = className;
    }
}
ScriptFX.Application.prototype = {
    _host: null,
    _isIE: 0,
    _scriptlets: null,
    _loaded: false,
    _disposing: false,
    _firstLoad: false,
    _sessionState: null,
    _history: null,
    _events: null,
    _disposableObjects: null,
    _idleFrequency: 0,
    _idleTimer: 0,
    _taskQueue: null,
    _taskTimer: 0,
    _registeredEventHandlers: null,
    _registeredEventTypes: null,
    _registeredEvents: null,
    _services: null,
    _windowUnloadingHandler: null,
    _windowErrorHandler: null,
    _idleTimerTickHandler: null,
    _taskTimerTickHandler: null,
    
    get_domain: function ScriptFX_Application$get_domain() {
        return window.document.domain;
    },
    set_domain: function ScriptFX_Application$set_domain(value) {
        window.document.domain = value;
        return value;
    },
    
    get__events: function ScriptFX_Application$get__events() {
        if (!this._events) {
            this._events = new ScriptFX.EventList();
        }
        return this._events;
    },
    
    get_history: function ScriptFX_Application$get_history() {
        Debug.assert(this._history, 'History has not been enabled.');
        return this._history;
    },
    
    get_host: function ScriptFX_Application$get_host() {
        if (!this._host) {
            this._host = new ScriptFX.HostInfo();
        }
        return this._host;
    },
    
    get_idleFrequency: function ScriptFX_Application$get_idleFrequency() {
        return this._idleFrequency;
    },
    set_idleFrequency: function ScriptFX_Application$set_idleFrequency(value) {
        Debug.assert(value >= 100, 'IdleFrequency must be atleast 100ms');
        this._idleFrequency = value;
        return value;
    },
    
    get_isFirstLoad: function ScriptFX_Application$get_isFirstLoad() {
        return this._firstLoad;
    },
    
    get_isIE: function ScriptFX_Application$get_isIE() {
        if (!this._isIE) {
            this._isIE = (this.get_host().get_name() === ScriptFX.HostName.IE) ? 1 : -1;
        }
        return (this._isIE === 1) ? true : false;
    },
    
    get_sessionState: function ScriptFX_Application$get_sessionState() {
        Debug.assert(this._loaded, 'You must wait until the load event before accessing session.');
        Debug.assert(this._sessionState, 'In order to use session, you must add an <input type=\"hidden\" id=\"__session\" /> within a <form>.');
        return this._sessionState;
    },
    
    add_error: function ScriptFX_Application$add_error(value) {
        this.get__events().addHandler('error', value);
    },
    remove_error: function ScriptFX_Application$remove_error(value) {
        this.get__events().removeHandler('error', value);
    },
    
    add_idle: function ScriptFX_Application$add_idle(value) {
        this.get__events().addHandler('idle', value);
        if (!this._idleTimer) {
            if (!this._idleTimerTickHandler) {
                this._idleTimerTickHandler = Delegate.create(this, this._onIdleTimerTick);
            }
            this._idleTimer = window.setTimeout(this._idleTimerTickHandler, this._idleFrequency);
        }
    },
    remove_idle: function ScriptFX_Application$remove_idle(value) {
        var isActive = this.get__events().removeHandler('idle', value);
        if ((!isActive) && (this._idleTimer)) {
            window.clearTimeout(this._idleTimer);
            this._idleTimer = 0;
        }
    },
    
    add_load: function ScriptFX_Application$add_load(value) {
        if (this._loaded) {
            value.invoke(this, EventArgs.Empty);
        }
        else {
            this.get__events().addHandler('load', value);
        }
    },
    remove_load: function ScriptFX_Application$remove_load(value) {
        this.get__events().removeHandler('load', value);
    },
    
    add_unload: function ScriptFX_Application$add_unload(value) {
        this.get__events().addHandler('unload', value);
    },
    remove_unload: function ScriptFX_Application$remove_unload(value) {
        this.get__events().removeHandler('unload', value);
    },
    
    add_unloading: function ScriptFX_Application$add_unloading(value) {
        this.get__events().addHandler('unloading', value);
    },
    remove_unloading: function ScriptFX_Application$remove_unloading(value) {
        this.get__events().removeHandler('unloading', value);
    },
    
    addTask: function ScriptFX_Application$addTask(task) {
        if (!this._taskQueue) {
            this._taskQueue = [];
        }
        this._taskQueue.enqueue(task);
        if (!this._taskTimer) {
            if (!this._taskTimerTickHandler) {
                this._taskTimerTickHandler = Delegate.create(this, this._onTaskTimerTick);
            }
            this._taskTimer = window.setTimeout(this._taskTimerTickHandler, 0);
        }
    },
    
    enableHistory: function ScriptFX_Application$enableHistory() {
        if (this._history) {
            return;
        }
        this._history = ScriptFX.HistoryManager._createHistory();
    },
    
    getService: function ScriptFX_Application$getService(serviceType) {
        Debug.assert(serviceType);
        if ((serviceType === IServiceContainer) || (serviceType === ScriptFX.IEventManager)) {
            return this;
        }
        if (this._services) {
            var name = serviceType.get_fullName().replace('.', '$');
            return this._services[name];
        }
        return null;
    },
    
    _onIdleTimerTick: function ScriptFX_Application$_onIdleTimerTick() {
        this._idleTimer = 0;
        var handler = this.get__events().getHandler('idle');
        if (handler) {
            handler.invoke(this, EventArgs.Empty);
            this._idleTimer = window.setTimeout(this._idleTimerTickHandler, this._idleFrequency);
        }
    },
    
    _onScriptHostLoad: function ScriptFX_Application$_onScriptHostLoad(sender, e) {
        var sessionElement = $('__session');
        if (sessionElement) {
            var value = sessionElement.value;
            if (String.isNullOrEmpty(value)) {
                this._firstLoad = true;
                this._sessionState = {};
            }
            else {
                this._sessionState = ScriptFX.JSON.deserialize(value);
                if (isUndefined(this._sessionState['__appLoaded'])) {
                    this._firstLoad = true;
                }
            }
            this._sessionState['__appLoaded'] = true;
        }
        else {
            this._firstLoad = true;
        }
        if (this._scriptlets) {
            for (var i = 0; i < this._scriptlets.length; i += 2) {
                this._scriptlets[i].main(this._scriptlets[i + 1]);
            }
            this._scriptlets = null;
        }
        this._loaded = true;
        var handler = this.get__events().getHandler('load');
        if (handler) {
            handler.invoke(this, EventArgs.Empty);
        }
        if (this._history) {
            this._history._initialize();
        }
    },
    
    _onScriptHostUnload: function ScriptFX_Application$_onScriptHostUnload(sender, e) {
        if (!this._disposing) {
            this._disposing = true;
            if (this._taskTimer) {
                window.clearTimeout(this._taskTimer);
            }
            if (this._idleTimer) {
                window.clearTimeout(this._idleTimer);
            }
            var handler = this.get__events().getHandler('unload');
            if (handler) {
                handler.invoke(this, EventArgs.Empty);
            }
            if (this._taskQueue) {
                while (this._taskQueue.length) {
                    var task = this._taskQueue.dequeue();
                    if (Type.canCast(task, IDisposable)) {
                        (task).dispose();
                    }
                }
            }
            if (this._disposableObjects.length) {
                var $enum1 = this._disposableObjects.getEnumerator();
                while ($enum1.moveNext()) {
                    var disposable = $enum1.get_current();
                    disposable.dispose();
                }
                this._disposableObjects.clear();
            }
            if (this._history) {
                this._history.dispose();
                this._history = null;
            }
            window.detachEvent('onbeforeunload', this._windowUnloadingHandler);
            window.detachEvent('onerror', this._windowErrorHandler);
            this._windowUnloadingHandler = null;
            this._windowErrorHandler = null;
            this._taskTimerTickHandler = null;
            this._idleTimerTickHandler = null;
        }
    },
    
    _onTaskTimerTick: function ScriptFX_Application$_onTaskTimerTick() {
        this._taskTimer = 0;
        if (this._taskQueue.length) {
            var task = this._taskQueue.dequeue();
            if (!task.execute()) {
                this._taskQueue.enqueue(task);
            }
            else {
                if (Type.canCast(task, IDisposable)) {
                    (task).dispose();
                }
            }
            if (this._taskQueue.length) {
                this._taskTimer = window.setTimeout(this._taskTimerTickHandler, 0);
            }
        }
    },
    
    _onWindowError: function ScriptFX_Application$_onWindowError() {
        var handler = this.get__events().getHandler('error');
        if (handler) {
            var ce = new ScriptFX.CancelEventArgs();
            ce.set_canceled(true);
            handler.invoke(this, ce);
            if (ce.get_canceled()) {
                window.event.returnValue = false;
            }
        }
    },
    
    _onWindowUnloading: function ScriptFX_Application$_onWindowUnloading() {
        window.event.avoidReturn = true;
        var handler = this.get__events().getHandler('unloading');
        if (handler) {
            var e = new ScriptFX.ApplicationUnloadingEventArgs();
            handler.invoke(this, e);
        }
        if (this._sessionState) {
            var sessionElement = $('__session');
            sessionElement.value = ScriptFX.JSON.serialize(this._sessionState);
        }
    },
    
    raiseEvent: function ScriptFX_Application$raiseEvent(eventType, sender, e) {
        Debug.assert(String.isNullOrEmpty(eventType));
        Debug.assert(sender);
        Debug.assert(e);
        if (this._registeredEventHandlers) {
            var handler = this._registeredEventHandlers[eventType];
            if (handler) {
                handler.invoke(sender, e);
            }
        }
    },
    
    registerDisposableObject: function ScriptFX_Application$registerDisposableObject(disposableObject) {
        if (!this._disposing) {
            this._disposableObjects.add(disposableObject);
        }
    },
    
    registerEvent: function ScriptFX_Application$registerEvent(eventType, sender, e) {
        Debug.assert(String.isNullOrEmpty(eventType));
        Debug.assert(sender);
        Debug.assert(e);
        if (this._registeredEventHandlers) {
            var handler = this._registeredEventHandlers[eventType];
            if (handler) {
                handler.invoke(sender, e);
            }
        }
        if (!this._registeredEvents) {
            this._registeredEvents = [];
        }
        if (!this._registeredEventTypes) {
            this._registeredEventTypes = {};
            this._registeredEventTypes[eventType] = 1;
        }
        else {
            var eventCount = this._registeredEventTypes[eventType];
            if (isUndefined(eventCount)) {
                this._registeredEventTypes[eventType] = 1;
            }
            else {
                this._registeredEventTypes[eventType] = 1 + eventCount;
            }
        }
        var eventInfo = ScriptFX.$create__registeredEvent(eventType, sender, e, this._registeredEvents.length);
        this._registeredEvents.add(eventInfo);
        return eventInfo.eventCookie;
    },
    
    registerEventHandler: function ScriptFX_Application$registerEventHandler(eventType, handler) {
        Debug.assert(!String.isNullOrEmpty(eventType));
        Debug.assert(handler);
        var existingHandler = null;
        if (!this._registeredEventHandlers) {
            this._registeredEventHandlers = {};
        }
        else {
            existingHandler = this._registeredEventHandlers[eventType];
        }
        this._registeredEventHandlers[eventType] = Delegate.combine(existingHandler, handler);
        if (!isNullOrUndefined(this._registeredEventTypes[eventType])) {
            var $enum1 = this._registeredEvents.getEnumerator();
            while ($enum1.moveNext()) {
                var eventInfo = $enum1.get_current();
                if (!eventInfo) {
                    continue;
                }
                if (eventInfo.eventType === eventType) {
                    handler.invoke(eventInfo.sender, eventInfo.eventArgs);
                }
            }
        }
    },
    
    registerService: function ScriptFX_Application$registerService(serviceType, service) {
        Debug.assert(serviceType);
        Debug.assert(service);
        if (!this._services) {
            this._services = {};
        }
        var name = serviceType.get_fullName().replace('.', '$');
        Debug.assert(!this._services[name]);
        this._services[name] = service;
    },
    
    run: function ScriptFX_Application$run(scriptletType, args) {
        if (this._loaded) {
            scriptletType.main(args);
        }
        else {
            if (!this._scriptlets) {
                this._scriptlets = [];
            }
            this._scriptlets.add(scriptletType);
            this._scriptlets.add(args);
        }
    },
    
    unregisterDisposableObject: function ScriptFX_Application$unregisterDisposableObject(disposableObject) {
        Debug.assert(disposableObject);
        if (!this._disposing) {
            this._disposableObjects.remove(disposableObject);
        }
    },
    
    unregisterEvent: function ScriptFX_Application$unregisterEvent(eventCookie) {
        Debug.assert(eventCookie);
        Debug.assert(Type.canCast(eventCookie, Number));
        Debug.assert(this._registeredEvents);
        Debug.assert(this._registeredEventTypes);
        var eventInfo = this._registeredEvents[eventCookie];
        Debug.assert(eventInfo);
        var eventCount = this._registeredEventTypes[eventInfo.eventType];
        Debug.assert(eventCount >= 1);
        if (eventCount === 1) {
            delete this._registeredEventTypes[eventInfo.eventType];
        }
        else {
            this._registeredEventTypes[eventInfo.eventType] = eventCount - 1;
        }
        this._registeredEvents[eventCookie] = null;
    },
    
    unregisterEventHandler: function ScriptFX_Application$unregisterEventHandler(eventType, handler) {
        Debug.assert(!String.isNullOrEmpty(eventType));
        Debug.assert(handler);
        if (this._registeredEventHandlers) {
            var existingHandler = this._registeredEventHandlers[eventType];
            if (existingHandler) {
                existingHandler = Delegate.remove(existingHandler, handler);
                if (!existingHandler) {
                    delete this._registeredEventHandlers[eventType];
                }
                else {
                    this._registeredEventHandlers[eventType] = existingHandler;
                }
            }
        }
    },
    
    unregisterService: function ScriptFX_Application$unregisterService(serviceType) {
        Debug.assert(serviceType);
        if (this._services) {
            var name = serviceType.get_fullName().replace('.', '$');
            delete this._services[name];
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.CancelEventArgs

ScriptFX.CancelEventArgs = function ScriptFX_CancelEventArgs() {
    ScriptFX.CancelEventArgs.constructBase(this);
}
ScriptFX.CancelEventArgs.prototype = {
    _canceled$1: false,
    
    get_canceled: function ScriptFX_CancelEventArgs$get_canceled() {
        return this._canceled$1;
    },
    set_canceled: function ScriptFX_CancelEventArgs$set_canceled(value) {
        this._canceled$1 = value;
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.CollectionChangedEventArgs

ScriptFX.CollectionChangedEventArgs = function ScriptFX_CollectionChangedEventArgs(action, item) {
    ScriptFX.CollectionChangedEventArgs.constructBase(this);
    this._action$1 = action;
    this._item$1 = item;
}
ScriptFX.CollectionChangedEventArgs.prototype = {
    _action$1: 0,
    _item$1: null,
    
    get_action: function ScriptFX_CollectionChangedEventArgs$get_action() {
        return this._action$1;
    },
    
    get_item: function ScriptFX_CollectionChangedEventArgs$get_item() {
        return this._item$1;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.ApplicationUnloadingEventArgs

ScriptFX.ApplicationUnloadingEventArgs = function ScriptFX_ApplicationUnloadingEventArgs() {
    ScriptFX.ApplicationUnloadingEventArgs.constructBase(this);
}
ScriptFX.ApplicationUnloadingEventArgs.prototype = {
    
    setUnloadPrompt: function ScriptFX_ApplicationUnloadingEventArgs$setUnloadPrompt(prompt) {
        window.event.returnValue = prompt;
        window.event.avoidReturn = false;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.HistoryManager

ScriptFX.HistoryManager = function ScriptFX_HistoryManager(enabled, iframe) {
    this._enabled = enabled;
    this._iframe = iframe;
}
ScriptFX.HistoryManager._createHistory = function ScriptFX_HistoryManager$_createHistory() {
    var hostName = ScriptFX.Application.current.get_host().get_name();
    if ((hostName !== ScriptFX.HostName.IE) && (hostName !== ScriptFX.HostName.mozilla)) {
        return new ScriptFX.HistoryManager(false, null);
    }
    var iframe = null;
    if (hostName === ScriptFX.HostName.IE) {
        iframe = $('_historyFrame');
        Debug.assert(iframe, 'You must have an <iframe id=\"_historyFrame\" src=\"Empty.htm\" /> tag on your page.');
    }
    return new ScriptFX.HistoryManager(true, iframe);
}
ScriptFX.HistoryManager.prototype = {
    _enabled: false,
    _iframe: null,
    _emptyPageURL: null,
    _iframeLoadHandler: null,
    _ignoreTimer: false,
    _ignoreIFrame: false,
    _currentEntry: null,
    
    get_isEnabled: function ScriptFX_HistoryManager$get_isEnabled() {
        return this._enabled;
    },
    
    add_navigated: function ScriptFX_HistoryManager$add_navigated(value) {
        this.__navigated = Delegate.combine(this.__navigated, value);
    },
    remove_navigated: function ScriptFX_HistoryManager$remove_navigated(value) {
        this.__navigated = Delegate.remove(this.__navigated, value);
    },
    
    __navigated: null,
    
    addEntry: function ScriptFX_HistoryManager$addEntry(entryName) {
        Debug.assert(!String.isNullOrEmpty(entryName));
        Debug.assert(!$(entryName), 'The entry identifier should not be the same as an element ID.');
        if (!this._enabled) {
            return;
        }
        this._ignoreTimer = true;
        if (this._iframe) {
            this._ignoreIFrame = true;
            this._iframe.src = this._emptyPageURL + entryName;
        }
        else {
            this._setCurrentEntry(entryName);
        }
    },
    
    dispose: function ScriptFX_HistoryManager$dispose() {
        if (this._iframe) {
            this._iframe.detachEvent('onload', this._iframeLoadHandler);
            this._iframe = null;
        }
    },
    
    _getCurrentEntry: function ScriptFX_HistoryManager$_getCurrentEntry() {
        var entryName = window.location.hash;
        if ((entryName.length) && (entryName.charAt(0) === '#')) {
            entryName = entryName.substr(1);
        }
        return entryName;
    },
    
    goBack: function ScriptFX_HistoryManager$goBack() {
        window.history.back();
    },
    
    goForward: function ScriptFX_HistoryManager$goForward() {
        window.history.forward();
    },
    
    _initialize: function ScriptFX_HistoryManager$_initialize() {
        if (!this._enabled) {
            return;
        }
        ScriptFX.Application.current.add_idle(Delegate.create(this, this._onAppIdle));
        if (this._iframe) {
            Debug.assert(this._iframe.src.length, 'You must set the Src attribute of the history iframe element to an empty page.');
            this._emptyPageURL = this._iframe.src + '?';
            this._iframeLoadHandler = Delegate.create(this, this._onIFrameLoad);
            this._iframe.attachEvent('onload', this._iframeLoadHandler);
        }
        this._currentEntry = this._getCurrentEntry();
        this._onNavigated(this._currentEntry);
    },
    
    _onAppIdle: function ScriptFX_HistoryManager$_onAppIdle(sender, e) {
        var entryName = this._getCurrentEntry();
        if (entryName !== this._currentEntry) {
            if (this._ignoreTimer) {
                return;
            }
            this._currentEntry = entryName;
            this._onNavigated(entryName);
        }
        else {
            this._ignoreTimer = false;
        }
    },
    
    _onIFrameLoad: function ScriptFX_HistoryManager$_onIFrameLoad() {
        var entryName = this._iframe.contentWindow.location.search;
        if ((entryName.length) && (entryName.charAt(0) === '?')) {
            entryName = entryName.substr(1);
        }
        this._setCurrentEntry(entryName);
        if (this._ignoreIFrame) {
            this._ignoreIFrame = false;
            return;
        }
        this._onNavigated(entryName);
    },
    
    _onNavigated: function ScriptFX_HistoryManager$_onNavigated(entryName) {
        if (this.__navigated) {
            this.__navigated.invoke(this, new ScriptFX.HistoryEventArgs(entryName));
        }
    },
    
    _setCurrentEntry: function ScriptFX_HistoryManager$_setCurrentEntry(entryName) {
        this._currentEntry = entryName;
        window.location.hash = entryName;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.HistoryEventArgs

ScriptFX.HistoryEventArgs = function ScriptFX_HistoryEventArgs(entryName) {
    ScriptFX.HistoryEventArgs.constructBase(this);
    this._entryName$1 = entryName;
}
ScriptFX.HistoryEventArgs.prototype = {
    _entryName$1: null,
    
    get_entryName: function ScriptFX_HistoryEventArgs$get_entryName() {
        return this._entryName$1;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.HostInfo

ScriptFX.HostInfo = function ScriptFX_HostInfo() {
    var userAgent = window.navigator.userAgent.toLowerCase();
    var version = null;
    var index;
    if ((index = userAgent.indexOf('opera')) >= 0) {
        this._name = ScriptFX.HostName.opera;
        version = userAgent.substr(index + 6);
    }
    else if ((index = userAgent.indexOf('msie')) >= 0) {
        this._name = ScriptFX.HostName.IE;
        version = userAgent.substr(index + 5);
    }
    else if ((index = userAgent.indexOf('safari')) >= 0) {
        this._name = ScriptFX.HostName.safari;
        version = userAgent.substr(index + 7);
    }
    else if ((index = userAgent.indexOf('firefox')) >= 0) {
        this._name = ScriptFX.HostName.mozilla;
        version = userAgent.substr(index + 8);
    }
    else if (userAgent.indexOf('gecko') >= 0) {
        this._name = ScriptFX.HostName.mozilla;
        version = window.navigator.appVersion;
    }
    if (version) {
        this._version = parseFloat(version);
        this._majorVersion = parseInt(this._version);
        if ((index = version.indexOf('.')) >= 0) {
            this._minorVersion = parseInt(version.substr(index + 1));
        }
    }
}
ScriptFX.HostInfo.prototype = {
    _name: 0,
    _version: 0,
    _majorVersion: 0,
    _minorVersion: 0,
    
    get_majorVersion: function ScriptFX_HostInfo$get_majorVersion() {
        return this._majorVersion;
    },
    
    get_minorVersion: function ScriptFX_HostInfo$get_minorVersion() {
        return this._minorVersion;
    },
    
    get_name: function ScriptFX_HostInfo$get_name() {
        return this._name;
    },
    
    get_version: function ScriptFX_HostInfo$get_version() {
        return this._version;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.EventList

ScriptFX.EventList = function ScriptFX_EventList() {
}
ScriptFX.EventList.prototype = {
    _events: null,
    
    addHandler: function ScriptFX_EventList$addHandler(key, handler) {
        Debug.assert(!String.isNullOrEmpty(key));
        Debug.assert(handler);
        if (!this._events) {
            this._events = {};
        }
        this._events[key] = Delegate.combine(this._events[key], handler);
    },
    
    getHandler: function ScriptFX_EventList$getHandler(key) {
        Debug.assert(!String.isNullOrEmpty(key));
        if (this._events) {
            return this._events[key];
        }
        return null;
    },
    
    removeHandler: function ScriptFX_EventList$removeHandler(key, handler) {
        Debug.assert(!String.isNullOrEmpty(key));
        Debug.assert(handler);
        if (this._events) {
            var sourceHandler = this._events[key];
            if (sourceHandler) {
                var newHandler = Delegate.remove(sourceHandler, handler);
                this._events[key] = newHandler;
                return (newHandler);
            }
        }
        return false;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.JSON

ScriptFX.JSON = function ScriptFX_JSON() {
}
ScriptFX.JSON.deserialize = function ScriptFX_JSON$deserialize(s) {
    if (String.isNullOrEmpty(s)) {
        return null;
    }
    if (!ScriptFX.JSON._dateRegex) {
        ScriptFX.JSON._dateRegex = new RegExp('(\'|\")\\\\@(-?[0-9]+)@(\'|\")', 'gm');
    }
    s = s.replace(ScriptFX.JSON._dateRegex, 'new Date($2)');
    return eval('(' + s + ')');
}
ScriptFX.JSON.serialize = function ScriptFX_JSON$serialize(o) {
    if (isNullOrUndefined(o)) {
        return String.Empty;
    }
    var sb = new StringBuilder();
    ScriptFX.JSON._serializeCore(sb, o);
    return sb.toString();
}
ScriptFX.JSON._serializeCore = function ScriptFX_JSON$_serializeCore(sb, o) {
    if (isNullOrUndefined(o)) {
        sb.append('null');
        return;
    }
    var scriptType = typeof(o);
    switch (scriptType) {
        case 'boolean':
            sb.append(o.toString());
            return;
        case 'number':
            sb.append((isFinite(o)) ? o.toString() : 'null');
            return;
        case 'string':
            sb.append((o).quote());
            return;
        case 'object':
            if (Array.isInstance(o)) {
                sb.append('[');
                var a = o;
                var length = a.length;
                var first = true;
                for (var i = 0; i < length; i++) {
                    if (first) {
                        first = false;
                    }
                    else {
                        sb.append(',');
                    }
                    ScriptFX.JSON._serializeCore(sb, a[i]);
                }
                sb.append(']');
            }
            else if (Date.isInstance(o)) {
                var d = o;
                var utcValue = Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds());
                sb.append('\"\\@');
                sb.append(utcValue.toString());
                sb.append('@\"');
            }
            else if (RegExp.isInstance(o)) {
                sb.append(o.toString());
            }
            else {
                sb.append('{');
                var first = true;
                var $dict1 = o;
                for (var $key2 in $dict1) {
                    var entry = { key: $key2, value: $dict1[$key2] };
                    if ((entry.key).startsWith('$') || Function.isInstance(entry.value)) {
                        continue;
                    }
                    if (first) {
                        first = false;
                    }
                    else {
                        sb.append(',');
                    }
                    sb.append(entry.key);
                    sb.append(':');
                    ScriptFX.JSON._serializeCore(sb, entry.value);
                }
                sb.append('}');
            }
            return;
        default:
            Debug.fail(scriptType + ' is not supported for JSON serialization.');
            sb.append('null');
            return;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.PropertyChangedEventArgs

ScriptFX.PropertyChangedEventArgs = function ScriptFX_PropertyChangedEventArgs(propertyName) {
    ScriptFX.PropertyChangedEventArgs.constructBase(this);
    this._propertyName$1 = propertyName;
}
ScriptFX.PropertyChangedEventArgs.prototype = {
    _propertyName$1: null,
    
    get_propertyName: function ScriptFX_PropertyChangedEventArgs$get_propertyName() {
        return this._propertyName$1;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.ObservableCollection

ScriptFX.ObservableCollection = function ScriptFX_ObservableCollection(owner, disposableItems) {
    this._owner = owner;
    this._items = [];
    this._disposableItems = disposableItems;
}
ScriptFX.ObservableCollection.prototype = {
    _owner: null,
    _items: null,
    _disposableItems: false,
    _handler: null,
    
    add_collectionChanged: function ScriptFX_ObservableCollection$add_collectionChanged(value) {
        this._handler = Delegate.combine(this._handler, value);
    },
    remove_collectionChanged: function ScriptFX_ObservableCollection$remove_collectionChanged(value) {
        this._handler = Delegate.remove(this._handler, value);
    },
    
    add: function ScriptFX_ObservableCollection$add(item) {
        (item).setOwner(this._owner);
        this._items.add(item);
        if (this._handler) {
            this._handler.invoke(this, new ScriptFX.CollectionChangedEventArgs(ScriptFX.CollectionChangedAction.add, item));
        }
    },
    
    clear: function ScriptFX_ObservableCollection$clear() {
        if (this._items.length) {
            var $enum1 = this._items.getEnumerator();
            while ($enum1.moveNext()) {
                var item = $enum1.get_current();
                item.setOwner(null);
            }
            this._items.clear();
            if (this._handler) {
                this._handler.invoke(this, new ScriptFX.CollectionChangedEventArgs(ScriptFX.CollectionChangedAction.reset, null));
            }
        }
    },
    
    contains: function ScriptFX_ObservableCollection$contains(item) {
        return this._items.contains(item);
    },
    
    dispose: function ScriptFX_ObservableCollection$dispose() {
        if (this._disposableItems) {
            var $enum1 = this._items.getEnumerator();
            while ($enum1.moveNext()) {
                var item = $enum1.get_current();
                item.dispose();
            }
        }
        this._items = null;
        this._owner = null;
        this._handler = null;
    },
    
    getEnumerator: function ScriptFX_ObservableCollection$getEnumerator() {
        return this._items.getEnumerator();
    },
    
    getItem: function ScriptFX_ObservableCollection$getItem(index) {
        return this._items[index];
    },
    
    getItems: function ScriptFX_ObservableCollection$getItems() {
        return this._items;
    },
    
    getLength: function ScriptFX_ObservableCollection$getLength() {
        return this._items.length;
    },
    
    remove: function ScriptFX_ObservableCollection$remove(item) {
        if (this._items.contains(item)) {
            (item).setOwner(null);
            this._items.remove(item);
            if (this._handler) {
                this._handler.invoke(this, new ScriptFX.CollectionChangedEventArgs(ScriptFX.CollectionChangedAction.remove, item));
            }
        }
    }
}


Type.createNamespace('ScriptFX.Net');

////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.HTTPStatusCode

ScriptFX.Net.HTTPStatusCode = function() { };
ScriptFX.Net.HTTPStatusCode.prototype = {
    canContinue: 100, 
    switchingProtocols: 101, 
    OK: 200, 
    created: 201, 
    partialContent: 206, 
    accepted: 202, 
    nonAuthoritativeInformation: 203, 
    noContent: 204, 
    resetContent: 205, 
    ambiguous: 300, 
    moved: 301, 
    redirect: 302, 
    redirectMethod: 303, 
    notModified: 304, 
    useProxy: 305, 
    temporaryRedirect: 307, 
    badRequest: 400, 
    methodNotAllowed: 400, 
    unauthorized: 401, 
    paymentRequired: 402, 
    forbidden: 403, 
    notFound: 404, 
    notAcceptable: 406, 
    proxyAuthenticationRequired: 407, 
    requestTimeout: 408, 
    conflict: 409, 
    gone: 410, 
    lengthRequired: 411, 
    preconditionFailed: 412, 
    requestEntityTooLarge: 413, 
    requestUriTooLong: 414, 
    unsupportedMediaType: 415, 
    requestedRangeNotSatisfiable: 416, 
    expectationFailed: 417, 
    internalServerError: 500, 
    notImplemented: 501, 
    badGateway: 502, 
    serviceUnavailable: 503, 
    gatewayTimeout: 504, 
    httpVersionNotSupported: 505
}
ScriptFX.Net.HTTPStatusCode.createEnum('ScriptFX.Net.HTTPStatusCode', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.HTTPRequestState

ScriptFX.Net.HTTPRequestState = function() { };
ScriptFX.Net.HTTPRequestState.prototype = {
    inactive: 0, 
    inProgress: 1, 
    completed: 2, 
    aborted: 3, 
    timedOut: 4
}
ScriptFX.Net.HTTPRequestState.createEnum('ScriptFX.Net.HTTPRequestState', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.HTTPVerb

ScriptFX.Net.HTTPVerb = function() { };
ScriptFX.Net.HTTPVerb.prototype = {
    GET: 0, 
    POST: 1, 
    PUT: 2, 
    DELETE: 3
}
ScriptFX.Net.HTTPVerb.createEnum('ScriptFX.Net.HTTPVerb', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.IHTTPResponse

ScriptFX.Net.IHTTPResponse = function() { };
ScriptFX.Net.IHTTPResponse.prototype = {
    get_contentLength : null,
    get_contentType : null,
    get_headers : null,
    get_request : null,
    get_statusCode : null,
    get_statusText : null,
    get_timeStamp : null,
    getHeader : null,
    getObject : null,
    getText : null,
    getXML : null
}
ScriptFX.Net.IHTTPResponse.createInterface('ScriptFX.Net.IHTTPResponse');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.HTTPRequest

ScriptFX.Net.HTTPRequest = function ScriptFX_Net_HTTPRequest() {
}
ScriptFX.Net.HTTPRequest.createRequest = function ScriptFX_Net_HTTPRequest$createRequest(uri, verb) {
    Debug.assert(!String.isNullOrEmpty(uri));
    var request = new ScriptFX.Net.HTTPRequest();
    if (!uri.startsWith('{')) {
        request._uri = uri;
    }
    else {
        var uriData = ScriptFX.JSON.deserialize(uri);
        request._uri = uriData['__uri'];
        Debug.assert(!String.isNullOrEmpty(request._uri));
        if (uriData['__nullParams']) {
            request._transportType = uriData['__transportType'];
        }
        else {
            request._transportType = Type.getType(uriData['__transportType']);
            delete uriData.__uri;
            delete uriData.__transportType;
            request._transportParameters = uriData;
        }
        Debug.assert((request._transportType) && ScriptFX.Net.HTTPTransport.isAssignableFrom(request._transportType));
    }
    request._verb = verb;
    return request;
}
ScriptFX.Net.HTTPRequest.createURI = function ScriptFX_Net_HTTPRequest$createURI(uri, parameters) {
    var sb = new StringBuilder(uri);
    if (uri.indexOf('?') < 0) {
        sb.append('?');
    }
    var parameterIndex = 0;
    var $dict1 = parameters;
    for (var $key2 in $dict1) {
        var entry = { key: $key2, value: $dict1[$key2] };
        if (parameterIndex) {
            sb.append('&');
        }
        sb.append(entry.key);
        sb.append('=');
        sb.append(encodeURIComponent(entry.value.toString()));
        parameterIndex++;
    }
    return sb.toString();
}
ScriptFX.Net.HTTPRequest.prototype = {
    _uri: null,
    _verb: 0,
    _content: null,
    _headers: null,
    _userName: null,
    _password: null,
    _transportType: null,
    _transportParameters: null,
    _timeout: 0,
    _callback: null,
    _context: null,
    _state: 0,
    _transport: null,
    _response: null,
    _timeStamp: null,
    
    get_content: function ScriptFX_Net_HTTPRequest$get_content() {
        return this._content;
    },
    set_content: function ScriptFX_Net_HTTPRequest$set_content(value) {
        Debug.assert(this.get_verb() === ScriptFX.Net.HTTPVerb.POST);
        Debug.assert(this._state === ScriptFX.Net.HTTPRequestState.inactive);
        this._content = value;
        return value;
    },
    
    get_hasCredentials: function ScriptFX_Net_HTTPRequest$get_hasCredentials() {
        return (!String.isNullOrEmpty(this._userName));
    },
    
    get_hasHeaders: function ScriptFX_Net_HTTPRequest$get_hasHeaders() {
        return (this._headers);
    },
    
    get_headers: function ScriptFX_Net_HTTPRequest$get_headers() {
        if (!this._headers) {
            this._headers = {};
        }
        return this._headers;
    },
    
    get_password: function ScriptFX_Net_HTTPRequest$get_password() {
        return this._password;
    },
    
    get_response: function ScriptFX_Net_HTTPRequest$get_response() {
        Debug.assert(this._state === ScriptFX.Net.HTTPRequestState.completed);
        return this._response;
    },
    
    get_state: function ScriptFX_Net_HTTPRequest$get_state() {
        return this._state;
    },
    
    get_timeout: function ScriptFX_Net_HTTPRequest$get_timeout() {
        return this._timeout;
    },
    set_timeout: function ScriptFX_Net_HTTPRequest$set_timeout(value) {
        this._timeout = value;
        return value;
    },
    
    get_timeStamp: function ScriptFX_Net_HTTPRequest$get_timeStamp() {
        return this._timeStamp;
    },
    
    get__transport: function ScriptFX_Net_HTTPRequest$get__transport() {
        return this._transport;
    },
    
    get__transportParameters: function ScriptFX_Net_HTTPRequest$get__transportParameters() {
        return this._transportParameters;
    },
    
    get_transportType: function ScriptFX_Net_HTTPRequest$get_transportType() {
        return this._transportType;
    },
    
    get_URI: function ScriptFX_Net_HTTPRequest$get_URI() {
        return this._uri;
    },
    
    get_userName: function ScriptFX_Net_HTTPRequest$get_userName() {
        return this._userName;
    },
    
    get_verb: function ScriptFX_Net_HTTPRequest$get_verb() {
        return this._verb;
    },
    
    abort: function ScriptFX_Net_HTTPRequest$abort() {
        if (this._state === ScriptFX.Net.HTTPRequestState.inProgress) {
            ScriptFX.Net.HTTPRequestManager._abort(this, false);
        }
    },
    
    dispose: function ScriptFX_Net_HTTPRequest$dispose() {
        if (this._transport) {
            this.abort();
        }
    },
    
    invoke: function ScriptFX_Net_HTTPRequest$invoke(callback, context) {
        Debug.assert(this._state === ScriptFX.Net.HTTPRequestState.inactive);
        this._callback = callback;
        this._context = context;
        ScriptFX.Application.current.registerDisposableObject(this);
        ScriptFX.Net.HTTPRequestManager._beginInvoke(this);
    },
    
    _invokeCallback: function ScriptFX_Net_HTTPRequest$_invokeCallback() {
        ScriptFX.Application.current.unregisterDisposableObject(this);
        if (this._transport) {
            this._transport.dispose();
            this._transport = null;
        }
        if (this._callback) {
            this._callback.invoke(this, this._context);
            this._callback = null;
            this._context = null;
        }
    },
    
    _onAbort: function ScriptFX_Net_HTTPRequest$_onAbort() {
        this._state = ScriptFX.Net.HTTPRequestState.aborted;
        this._invokeCallback();
    },
    
    _onActivate: function ScriptFX_Net_HTTPRequest$_onActivate(transport) {
        this._transport = transport;
        this._state = ScriptFX.Net.HTTPRequestState.inProgress;
        this._timeStamp = new Date();
    },
    
    _onCompleted: function ScriptFX_Net_HTTPRequest$_onCompleted(response) {
        this._response = response;
        this._state = ScriptFX.Net.HTTPRequestState.completed;
        this._invokeCallback();
    },
    
    _onTimeout: function ScriptFX_Net_HTTPRequest$_onTimeout() {
        this._state = ScriptFX.Net.HTTPRequestState.timedOut;
        this._invokeCallback();
    },
    
    setContentAsForm: function ScriptFX_Net_HTTPRequest$setContentAsForm(data) {
        Debug.assert(data);
        this.get_headers()['Content-Type'] = 'application/x-www-form-urlencoded';
        var sb = new StringBuilder();
        var firstValue = true;
        var $dict1 = data;
        for (var $key2 in $dict1) {
            var e = { key: $key2, value: $dict1[$key2] };
            if (!firstValue) {
                sb.append('&');
            }
            sb.append(e.key);
            sb.append('=');
            sb.append(encodeURIComponent(e.value.toString()));
            firstValue = false;
        }
        this.set_content(sb.toString());
    },
    
    setContentAsJSON: function ScriptFX_Net_HTTPRequest$setContentAsJSON(data) {
        Debug.assert(data);
        this.get_headers()['Content-Type'] = 'text/json';
        this.set_content(ScriptFX.JSON.serialize(data));
    },
    
    setCredentials: function ScriptFX_Net_HTTPRequest$setCredentials(userName, password) {
        Debug.assert(!String.isNullOrEmpty(userName));
        Debug.assert(!String.isNullOrEmpty(password));
        this._userName = userName;
        this._password = password;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.HTTPRequestManager

ScriptFX.Net.HTTPRequestManager = function ScriptFX_Net_HTTPRequestManager() {
}
ScriptFX.Net.HTTPRequestManager.add_requestInvoking = function ScriptFX_Net_HTTPRequestManager$add_requestInvoking(value) {
    ScriptFX.Net.HTTPRequestManager.__requestInvoking = Delegate.combine(ScriptFX.Net.HTTPRequestManager.__requestInvoking, value);
}
ScriptFX.Net.HTTPRequestManager.remove_requestInvoking = function ScriptFX_Net_HTTPRequestManager$remove_requestInvoking(value) {
    ScriptFX.Net.HTTPRequestManager.__requestInvoking = Delegate.remove(ScriptFX.Net.HTTPRequestManager.__requestInvoking, value);
}
ScriptFX.Net.HTTPRequestManager.add_requestInvoked = function ScriptFX_Net_HTTPRequestManager$add_requestInvoked(value) {
    ScriptFX.Net.HTTPRequestManager.__requestInvoked = Delegate.combine(ScriptFX.Net.HTTPRequestManager.__requestInvoked, value);
}
ScriptFX.Net.HTTPRequestManager.remove_requestInvoked = function ScriptFX_Net_HTTPRequestManager$remove_requestInvoked(value) {
    ScriptFX.Net.HTTPRequestManager.__requestInvoked = Delegate.remove(ScriptFX.Net.HTTPRequestManager.__requestInvoked, value);
}
ScriptFX.Net.HTTPRequestManager.get_online = function ScriptFX_Net_HTTPRequestManager$get_online() {
    return window.navigator.onLine;
}
ScriptFX.Net.HTTPRequestManager.get_timeoutInterval = function ScriptFX_Net_HTTPRequestManager$get_timeoutInterval() {
    return ScriptFX.Net.HTTPRequestManager._timeoutInterval;
}
ScriptFX.Net.HTTPRequestManager.set_timeoutInterval = function ScriptFX_Net_HTTPRequestManager$set_timeoutInterval(value) {
    ScriptFX.Net.HTTPRequestManager._timeoutInterval = value;
    return value;
}
ScriptFX.Net.HTTPRequestManager._abort = function ScriptFX_Net_HTTPRequestManager$_abort(request, timedOut) {
    var transport = request.get__transport();
    if (transport) {
        transport.abort();
        ScriptFX.Net.HTTPRequestManager._endInvoke(request, null, timedOut);
    }
}
ScriptFX.Net.HTTPRequestManager.abortAll = function ScriptFX_Net_HTTPRequestManager$abortAll() {
    var requests = ScriptFX.Net.HTTPRequestManager._activeRequests;
    ScriptFX.Net.HTTPRequestManager._activeRequests = [];
    var $enum1 = requests.getEnumerator();
    while ($enum1.moveNext()) {
        var request = $enum1.get_current();
        ScriptFX.Net.HTTPRequestManager._abort(request, false);
    }
}
ScriptFX.Net.HTTPRequestManager._beginInvoke = function ScriptFX_Net_HTTPRequestManager$_beginInvoke(request) {
    if (ScriptFX.Net.HTTPRequestManager.__requestInvoking) {
        var e = new ScriptFX.Net.PreHTTPRequestEventArgs(request);
        ScriptFX.Net.HTTPRequestManager.__requestInvoking.invoke(null, e);
        if (e.get_isSuppressed()) {
            request._onCompleted(e.get_response());
            return;
        }
    }
    var transportType = request.get_transportType();
    if (!transportType) {
        transportType = ScriptFX.Net._xmlhttpTransport;
    }
    var transport = new transportType(request);
    request._onActivate(transport);
    ScriptFX.Net.HTTPRequestManager._activeRequests.add(request);
    transport.invoke();
    if (((ScriptFX.Net.HTTPRequestManager._timeoutInterval) || (request.get_timeout())) && (!ScriptFX.Net.HTTPRequestManager._appIdleHandler)) {
        ScriptFX.Net.HTTPRequestManager._appIdleHandler = Delegate.create(null, ScriptFX.Net.HTTPRequestManager._onApplicationIdle);
        ScriptFX.Application.current.add_idle(ScriptFX.Net.HTTPRequestManager._appIdleHandler);
    }
}
ScriptFX.Net.HTTPRequestManager._endInvoke = function ScriptFX_Net_HTTPRequestManager$_endInvoke(request, response, timedOut) {
    ScriptFX.Net.HTTPRequestManager._activeRequests.remove(request);
    if (response) {
        request._onCompleted(response);
    }
    else if (timedOut) {
        request._onTimeout();
    }
    else {
        request._onAbort();
    }
    if (ScriptFX.Net.HTTPRequestManager.__requestInvoked) {
        var e = new ScriptFX.Net.PostHTTPRequestEventArgs(request, response);
        ScriptFX.Net.HTTPRequestManager.__requestInvoked.invoke(null, e);
    }
    if ((!ScriptFX.Net.HTTPRequestManager._activeRequests.length) && (ScriptFX.Net.HTTPRequestManager._appIdleHandler)) {
        ScriptFX.Application.current.remove_idle(ScriptFX.Net.HTTPRequestManager._appIdleHandler);
        ScriptFX.Net.HTTPRequestManager._appIdleHandler = null;
    }
}
ScriptFX.Net.HTTPRequestManager._onApplicationIdle = function ScriptFX_Net_HTTPRequestManager$_onApplicationIdle(sender, e) {
    if (!ScriptFX.Net.HTTPRequestManager._activeRequests.length) {
        return;
    }
    var timedOutRequests = null;
    var currentTimeValue = (new Date()).getTime();
    var $enum1 = ScriptFX.Net.HTTPRequestManager._activeRequests.getEnumerator();
    while ($enum1.moveNext()) {
        var request = $enum1.get_current();
        var timeStampValue = request.get_timeStamp().getTime();
        var interval = request.get_timeout();
        if (!interval) {
            interval = ScriptFX.Net.HTTPRequestManager._timeoutInterval;
            if (!interval) {
                continue;
            }
        }
        if ((currentTimeValue - timeStampValue) > interval) {
            if (!timedOutRequests) {
                timedOutRequests = [];
            }
            timedOutRequests.add(request);
        }
    }
    if (timedOutRequests) {
        var $enum2 = timedOutRequests.getEnumerator();
        while ($enum2.moveNext()) {
            var request = $enum2.get_current();
            ScriptFX.Net.HTTPRequestManager._abort(request, true);
        }
    }
}
ScriptFX.Net.HTTPRequestManager._onCompleted = function ScriptFX_Net_HTTPRequestManager$_onCompleted(request, response) {
    ScriptFX.Net.HTTPRequestManager._endInvoke(request, response, false);
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.HTTPTransport

ScriptFX.Net.HTTPTransport = function ScriptFX_Net_HTTPTransport(request) {
    this._request = request;
}
ScriptFX.Net.HTTPTransport.createURI = function ScriptFX_Net_HTTPTransport$createURI(uri, transportType, parameters) {
    Debug.assert(!String.isNullOrEmpty(uri));
    Debug.assert((transportType) && ScriptFX.Net.HTTPTransport.isAssignableFrom(transportType));
    if (!parameters) {
        return '{__nullParams: true, __uri:\'' + uri + '\', __transportType: ' + transportType.get_fullName() + '}';
    }
    else {
        parameters['__uri'] = uri;
        parameters['__transportType'] = transportType.get_fullName();
        return ScriptFX.JSON.serialize(parameters);
    }
}
ScriptFX.Net.HTTPTransport.prototype = {
    _request: null,
    
    get_parameters: function ScriptFX_Net_HTTPTransport$get_parameters() {
        return this._request.get__transportParameters();
    },
    
    get_request: function ScriptFX_Net_HTTPTransport$get_request() {
        return this._request;
    },
    
    getMethod: function ScriptFX_Net_HTTPTransport$getMethod() {
        return Enum.toString(ScriptFX.Net.HTTPVerb, this._request.get_verb());
    },
    
    onCompleted: function ScriptFX_Net_HTTPTransport$onCompleted(response) {
        ScriptFX.Net.HTTPRequestManager._onCompleted(this._request, response);
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.PostHTTPRequestEventArgs

ScriptFX.Net.PostHTTPRequestEventArgs = function ScriptFX_Net_PostHTTPRequestEventArgs(request, response) {
    ScriptFX.Net.PostHTTPRequestEventArgs.constructBase(this);
    this._request$1 = request;
    this._response$1 = response;
}
ScriptFX.Net.PostHTTPRequestEventArgs.prototype = {
    _request$1: null,
    _response$1: null,
    
    get_request: function ScriptFX_Net_PostHTTPRequestEventArgs$get_request() {
        return this._request$1;
    },
    
    get_response: function ScriptFX_Net_PostHTTPRequestEventArgs$get_response() {
        return this._response$1;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.PreHTTPRequestEventArgs

ScriptFX.Net.PreHTTPRequestEventArgs = function ScriptFX_Net_PreHTTPRequestEventArgs(request) {
    ScriptFX.Net.PreHTTPRequestEventArgs.constructBase(this);
    this._request$1 = request;
}
ScriptFX.Net.PreHTTPRequestEventArgs.prototype = {
    _request$1: null,
    _response$1: null,
    _suppressed$1: false,
    
    get_isSuppressed: function ScriptFX_Net_PreHTTPRequestEventArgs$get_isSuppressed() {
        return this._suppressed$1;
    },
    
    get_request: function ScriptFX_Net_PreHTTPRequestEventArgs$get_request() {
        return this._request$1;
    },
    
    get_response: function ScriptFX_Net_PreHTTPRequestEventArgs$get_response() {
        return this._response$1;
    },
    
    suppressRequest: function ScriptFX_Net_PreHTTPRequestEventArgs$suppressRequest(response) {
        this._suppressed$1 = true;
        this._response$1 = response;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net._xmlhttpResponse

ScriptFX.Net._xmlhttpResponse = function ScriptFX_Net__xmlhttpResponse(request, xmlHTTP) {
    this._timeStamp = new Date();
    this._request = request;
    this._xmlHTTP = xmlHTTP;
}
ScriptFX.Net._xmlhttpResponse.prototype = {
    _request: null,
    _xmlHTTP: null,
    _headers: null,
    _timeStamp: null,
    _text: null,
    _object: null,
    _xml: null,
    
    get_contentLength: function ScriptFX_Net__xmlhttpResponse$get_contentLength() {
        return this.getText().length;
    },
    
    get_contentType: function ScriptFX_Net__xmlhttpResponse$get_contentType() {
        return this._xmlHTTP.getResponseHeader('Content-Type');
    },
    
    get_headers: function ScriptFX_Net__xmlhttpResponse$get_headers() {
        if (!this._headers) {
            var headers = this._xmlHTTP.getAllResponseHeaders();
            var parts = headers.split('\n');
            this._headers = {};
            var $enum1 = parts.getEnumerator();
            while ($enum1.moveNext()) {
                var part = $enum1.get_current();
                var colonIndex = part.indexOf(':');
                this._headers[part.substr(0, colonIndex)] = part.substr(colonIndex + 1).trim();
            }
        }
        return this._headers;
    },
    
    get_request: function ScriptFX_Net__xmlhttpResponse$get_request() {
        return this._request;
    },
    
    get_statusCode: function ScriptFX_Net__xmlhttpResponse$get_statusCode() {
        return this._xmlHTTP.status;
    },
    
    get_statusText: function ScriptFX_Net__xmlhttpResponse$get_statusText() {
        return this._xmlHTTP.statusText;
    },
    
    get_timeStamp: function ScriptFX_Net__xmlhttpResponse$get_timeStamp() {
        return this._timeStamp;
    },
    
    getHeader: function ScriptFX_Net__xmlhttpResponse$getHeader(name) {
        return this._xmlHTTP.getResponseHeader(name);
    },
    
    getObject: function ScriptFX_Net__xmlhttpResponse$getObject() {
        if (!this._object) {
            this._object = ScriptFX.JSON.deserialize(this.getText());
        }
        return this._object;
    },
    
    getText: function ScriptFX_Net__xmlhttpResponse$getText() {
        if (!this._text) {
            this._text = this._xmlHTTP.responseText;
        }
        return this._text;
    },
    
    getXML: function ScriptFX_Net__xmlhttpResponse$getXML() {
        if (!this._xml) {
            var xml = this._xmlHTTP.responseXML;
            if ((!xml) || (!xml.documentElement)) {
                try {
                    xml = XMLDocumentParser.parse(this._xmlHTTP.responseText);
                    if ((xml) && (xml.documentElement)) {
                        this._xml = xml;
                    }
                }
                catch ($e1) {
                }
            }
            else {
                this._xml = xml;
                if (ScriptFX.Application.current.get_isIE()) {
                    xml.setProperty('SelectionLanguage', 'XPath');
                }
            }
        }
        return this._xml;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net._xmlhttpTransport

ScriptFX.Net._xmlhttpTransport = function ScriptFX_Net__xmlhttpTransport(request) {
    ScriptFX.Net._xmlhttpTransport.constructBase(this, [ request ]);
}
ScriptFX.Net._xmlhttpTransport.prototype = {
    _xmlHTTP$1: null,
    
    abort: function ScriptFX_Net__xmlhttpTransport$abort() {
        if (this._xmlHTTP$1) {
            this._xmlHTTP$1.onreadystatechange = Delegate.Null;
            this._xmlHTTP$1.abort();
            this._xmlHTTP$1 = null;
        }
    },
    
    dispose: function ScriptFX_Net__xmlhttpTransport$dispose() {
        this.abort();
    },
    
    invoke: function ScriptFX_Net__xmlhttpTransport$invoke() {
        var request = this.get_request();
        this._xmlHTTP$1 = new XMLHttpRequest();
        this._xmlHTTP$1.onreadystatechange = Delegate.create(this, this._onReadyStateChange$1);
        if (!this.get_request().get_hasCredentials()) {
            this._xmlHTTP$1.open(this.getMethod(), request.get_URI(), true);
        }
        else {
            this._xmlHTTP$1.open(this.getMethod(), request.get_URI(), true, request.get_userName(), request.get_password());
        }
        var headers = (request.get_hasHeaders()) ? request.get_headers() : null;
        if (headers) {
            var $dict1 = headers;
            for (var $key2 in $dict1) {
                var entry = { key: $key2, value: $dict1[$key2] };
                this._xmlHTTP$1.setRequestHeader(entry.key, entry.value);
            }
        }
        var body = request.get_content();
        if ((body) && ((!headers) || (!headers['Content-Type']))) {
            this._xmlHTTP$1.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
        }
        this._xmlHTTP$1.send(body);
    },
    
    _onReadyStateChange$1: function ScriptFX_Net__xmlhttpTransport$_onReadyStateChange$1() {
        if (this._xmlHTTP$1.readyState === 4) {
            var response = new ScriptFX.Net._xmlhttpResponse(this.get_request(), this._xmlHTTP$1);
            this._xmlHTTP$1.onreadystatechange = Delegate.Null;
            this._xmlHTTP$1 = null;
            this.onCompleted(response);
        }
    }
}


Type.createNamespace('ScriptFX.UI');

////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.AnimationStopState

ScriptFX.UI.AnimationStopState = function() { };
ScriptFX.UI.AnimationStopState.prototype = {
    complete: 0, 
    abort: 1, 
    revert: 2
}
ScriptFX.UI.AnimationStopState.createEnum('ScriptFX.UI.AnimationStopState', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Bounds

ScriptFX.UI.$create_Bounds = function ScriptFX_UI_Bounds(left, top, width, height) {
    var $o = { };
    $o.left = left;
    $o.top = top;
    $o.width = width;
    $o.height = height;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.DragDropData

ScriptFX.UI.$create_DragDropData = function ScriptFX_UI_DragDropData(mode, dataType, data) {
    var $o = { };
    $o.mode = mode;
    $o.dataType = dataType;
    $o.data = data;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.DragMode

ScriptFX.UI.DragMode = function() { };
ScriptFX.UI.DragMode.prototype = {
    move: 0, 
    copy: 1
}
ScriptFX.UI.DragMode.createEnum('ScriptFX.UI.DragMode', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.IAction

ScriptFX.UI.IAction = function() { };
ScriptFX.UI.IAction.prototype = {
    get_actionArgument : null,
    get_actionName : null,
    add_action : null,
    remove_action : null
}
ScriptFX.UI.IAction.createInterface('ScriptFX.UI.IAction');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.IDragDrop

ScriptFX.UI.IDragDrop = function() { };
ScriptFX.UI.IDragDrop.prototype = {
    get_supportsDataTransfer : null,
    dragDrop : null
}
ScriptFX.UI.IDragDrop.createInterface('ScriptFX.UI.IDragDrop');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.IDragSource

ScriptFX.UI.IDragSource = function() { };
ScriptFX.UI.IDragSource.prototype = {
    get_domElement : null,
    onDragStart : null,
    onDrag : null,
    onDragEnd : null
}
ScriptFX.UI.IDragSource.createInterface('ScriptFX.UI.IDragSource');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.IDropTarget

ScriptFX.UI.IDropTarget = function() { };
ScriptFX.UI.IDropTarget.prototype = {
    get_domElement : null,
    supportsDataObject : null,
    drop : null,
    onDragEnter : null,
    onDragLeave : null,
    onDragOver : null
}
ScriptFX.UI.IDropTarget.createInterface('ScriptFX.UI.IDropTarget');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.IEditableText

ScriptFX.UI.IEditableText = function() { };
ScriptFX.UI.IEditableText.prototype = {
    get_text : null,
    set_text : null,
    add_textChanged : null,
    remove_textChanged : null
}
ScriptFX.UI.IEditableText.createInterface('ScriptFX.UI.IEditableText');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.IStaticText

ScriptFX.UI.IStaticText = function() { };
ScriptFX.UI.IStaticText.prototype = {
    get_text : null
}
ScriptFX.UI.IStaticText.createInterface('ScriptFX.UI.IStaticText');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.IToggle

ScriptFX.UI.IToggle = function() { };
ScriptFX.UI.IToggle.prototype = {
    get_checked : null,
    add_checkedChanged : null,
    remove_checkedChanged : null
}
ScriptFX.UI.IToggle.createInterface('ScriptFX.UI.IToggle');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.IValidator

ScriptFX.UI.IValidator = function() { };
ScriptFX.UI.IValidator.prototype = {
    get_isValid : null,
    get_validationGroup : null
}
ScriptFX.UI.IValidator.createInterface('ScriptFX.UI.IValidator');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Key

ScriptFX.UI.Key = function() { };
ScriptFX.UI.Key.prototype = {
    backspace: 8, 
    tab: 9, 
    enter: 13, 
    escape: 27, 
    space: 32, 
    pageUp: 33, 
    pageDown: 34, 
    end: 35, 
    home: 36, 
    left: 37, 
    up: 38, 
    right: 39, 
    down: 40, 
    del: 127
}
ScriptFX.UI.Key.createEnum('ScriptFX.UI.Key', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Location

ScriptFX.UI.$create_Location = function ScriptFX_UI_Location(left, top) {
    var $o = { };
    $o.left = left;
    $o.top = top;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.OverlayOptions

ScriptFX.UI.$create_OverlayOptions = function ScriptFX_UI_OverlayOptions(cssClass) {
    var $o = { };
    $o.cssClass = cssClass;
    $o.fadeInOutInterval = 250;
    $o.opacity = 0.75;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.PopupMode

ScriptFX.UI.PopupMode = function() { };
ScriptFX.UI.PopupMode.prototype = {
    center: 0, 
    anchorTopLeft: 1, 
    anchorTopRight: 2, 
    anchorBottomRight: 3, 
    anchorBottomLeft: 4, 
    alignTopLeft: 5, 
    alignTopRight: 6, 
    alignBottomRight: 7, 
    alignBottomLeft: 8
}
ScriptFX.UI.PopupMode.createEnum('ScriptFX.UI.PopupMode', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.PopupOptions

ScriptFX.UI.$create_PopupOptions = function ScriptFX_UI_PopupOptions(referenceElement, mode) {
    var $o = { };
    $o.referenceElement = referenceElement;
    $o.mode = mode;
    $o.id = null;
    $o.xOffset = 0;
    $o.yOffset = 0;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Size

ScriptFX.UI.$create_Size = function ScriptFX_UI_Size(width, height) {
    var $o = { };
    $o.width = width;
    $o.height = height;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Animation

ScriptFX.UI.Animation = function ScriptFX_UI_Animation(domElement) {
    if (!domElement) {
        domElement = document.documentElement;
    }
    this._domElement = domElement;
    this._repeatCount = 1;
    ScriptFX.Application.current.registerDisposableObject(this);
}
ScriptFX.UI.Animation.prototype = {
    _domElement: null,
    _repeatCount: 0,
    _autoReverse: false,
    _repeatDelay: 0,
    _completed: false,
    _isPlaying: false,
    _isRepeating: false,
    _repetitions: 0,
    _repeatTimeStamp: 0,
    _reversed: false,
    
    add_repeating: function ScriptFX_UI_Animation$add_repeating(value) {
        this.__repeating = Delegate.combine(this.__repeating, value);
    },
    remove_repeating: function ScriptFX_UI_Animation$remove_repeating(value) {
        this.__repeating = Delegate.remove(this.__repeating, value);
    },
    
    __repeating: null,
    
    add_starting: function ScriptFX_UI_Animation$add_starting(value) {
        this.__starting = Delegate.combine(this.__starting, value);
    },
    remove_starting: function ScriptFX_UI_Animation$remove_starting(value) {
        this.__starting = Delegate.remove(this.__starting, value);
    },
    
    __starting: null,
    
    add_stopped: function ScriptFX_UI_Animation$add_stopped(value) {
        this.__stopped = Delegate.combine(this.__stopped, value);
    },
    remove_stopped: function ScriptFX_UI_Animation$remove_stopped(value) {
        this.__stopped = Delegate.remove(this.__stopped, value);
    },
    
    __stopped: null,
    
    get_autoReverse: function ScriptFX_UI_Animation$get_autoReverse() {
        return this._autoReverse;
    },
    set_autoReverse: function ScriptFX_UI_Animation$set_autoReverse(value) {
        Debug.assert(!this.get_isPlaying());
        this._autoReverse = value;
        return value;
    },
    
    get_completed: function ScriptFX_UI_Animation$get_completed() {
        return this._completed;
    },
    
    get_domElement: function ScriptFX_UI_Animation$get_domElement() {
        return this._domElement;
    },
    
    get_isPlaying: function ScriptFX_UI_Animation$get_isPlaying() {
        return this._isPlaying;
    },
    
    get_isReversed: function ScriptFX_UI_Animation$get_isReversed() {
        return this._reversed;
    },
    
    get_repeatCount: function ScriptFX_UI_Animation$get_repeatCount() {
        return this._repeatCount;
    },
    set_repeatCount: function ScriptFX_UI_Animation$set_repeatCount(value) {
        Debug.assert(!this.get_isPlaying());
        Debug.assert(value >= 0);
        this._repeatCount = value;
        return value;
    },
    
    get_repeatDelay: function ScriptFX_UI_Animation$get_repeatDelay() {
        return this._repeatDelay;
    },
    set_repeatDelay: function ScriptFX_UI_Animation$set_repeatDelay(value) {
        Debug.assert(!this.get_isPlaying());
        Debug.assert(value >= 0);
        this._repeatDelay = value;
        return value;
    },
    
    get_repetitions: function ScriptFX_UI_Animation$get_repetitions() {
        return this._repetitions;
    },
    
    dispose: function ScriptFX_UI_Animation$dispose() {
        if (this._isPlaying) {
            this.stop(ScriptFX.UI.AnimationStopState.abort);
        }
        if (this._domElement) {
            this._domElement = null;
            ScriptFX.Application.current.unregisterDisposableObject(this);
        }
    },
    
    _onPlay: function ScriptFX_UI_Animation$_onPlay(reversed) {
        if (this.__starting) {
            this.__starting.invoke(this, EventArgs.Empty);
        }
        this.performSetup();
        this._isPlaying = true;
        this._repetitions = 1;
        this._reversed = reversed;
        this.playCore();
    },
    
    _onStop: function ScriptFX_UI_Animation$_onStop(completed, stopState) {
        this.stopCore(completed, stopState);
        this._completed = completed;
        this._isPlaying = false;
        this.performCleanup();
        if (this.__stopped) {
            this.__stopped.invoke(this, EventArgs.Empty);
        }
    },
    
    _onProgress: function ScriptFX_UI_Animation$_onProgress(timeStamp) {
        if (this._isRepeating) {
            if ((this._repeatDelay) && ((this._repeatTimeStamp + this._repeatDelay) > timeStamp)) {
                return false;
            }
        }
        var completed = this.progressCore(this._isRepeating, timeStamp);
        this._isRepeating = false;
        if (completed && ((!this._repeatCount) || (this._repeatCount > this._repetitions))) {
            completed = false;
            this._repetitions++;
            if (this.__repeating) {
                var ce = new ScriptFX.CancelEventArgs();
                this.__repeating.invoke(this, ce);
                completed = ce.get_canceled();
            }
            if (!completed) {
                this._isRepeating = true;
                if (this._autoReverse) {
                    this._reversed = !this._reversed;
                }
                this._repeatTimeStamp = timeStamp;
                this.performRepetition(this._reversed);
            }
        }
        return completed;
    },
    
    performCleanup: function ScriptFX_UI_Animation$performCleanup() {
    },
    
    performRepetition: function ScriptFX_UI_Animation$performRepetition(reversed) {
    },
    
    performSetup: function ScriptFX_UI_Animation$performSetup() {
    },
    
    play: function ScriptFX_UI_Animation$play() {
        Debug.assert(!this.get_isPlaying());
        this._completed = false;
        ScriptFX.UI.AnimationManager._play(this);
    },
    
    stop: function ScriptFX_UI_Animation$stop(stopState) {
        Debug.assert(this.get_isPlaying());
        ScriptFX.UI.AnimationManager._stop(this, stopState);
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.AnimationManager

ScriptFX.UI.AnimationManager = function ScriptFX_UI_AnimationManager() {
}
ScriptFX.UI.AnimationManager.get_FPS = function ScriptFX_UI_AnimationManager$get_FPS() {
    return ScriptFX.UI.AnimationManager._fps;
}
ScriptFX.UI.AnimationManager.set_FPS = function ScriptFX_UI_AnimationManager$set_FPS(value) {
    Debug.assert((value > 0) && (value <= 100));
    ScriptFX.UI.AnimationManager._fps = value;
    return value;
}
ScriptFX.UI.AnimationManager._onTick = function ScriptFX_UI_AnimationManager$_onTick() {
    ScriptFX.UI.AnimationManager._timerCookie = 0;
    if (!ScriptFX.UI.AnimationManager._activeAnimations.length) {
        return;
    }
    var timeStamp = (new Date()).getTime();
    var currentAnimations = ScriptFX.UI.AnimationManager._activeAnimations;
    var newAnimations = [];
    ScriptFX.UI.AnimationManager._activeAnimations = null;
    var $enum1 = currentAnimations.getEnumerator();
    while ($enum1.moveNext()) {
        var animation = $enum1.get_current();
        var completed = animation._onProgress(timeStamp);
        if (completed) {
            animation._onStop(true, ScriptFX.UI.AnimationStopState.complete);
        }
        else {
            newAnimations.add(animation);
        }
    }
    if (newAnimations.length) {
        ScriptFX.UI.AnimationManager._activeAnimations = newAnimations;
        if (!ScriptFX.UI.AnimationManager._timerCookie) {
            ScriptFX.UI.AnimationManager._timerCookie = window.setTimeout(Delegate.create(null, ScriptFX.UI.AnimationManager._onTick), 1000 / ScriptFX.UI.AnimationManager._fps);
        }
    }
}
ScriptFX.UI.AnimationManager._play = function ScriptFX_UI_AnimationManager$_play(animation) {
    if (!ScriptFX.UI.AnimationManager._activeAnimations) {
        ScriptFX.UI.AnimationManager._activeAnimations = [];
    }
    ScriptFX.UI.AnimationManager._activeAnimations.add(animation);
    animation._onPlay(false);
    if (!ScriptFX.UI.AnimationManager._timerCookie) {
        ScriptFX.UI.AnimationManager._timerCookie = window.setTimeout(Delegate.create(null, ScriptFX.UI.AnimationManager._onTick), 1000 / ScriptFX.UI.AnimationManager._fps);
    }
}
ScriptFX.UI.AnimationManager._stop = function ScriptFX_UI_AnimationManager$_stop(animation, stopState) {
    Debug.assert(ScriptFX.UI.AnimationManager._activeAnimations);
    animation._onStop(false, stopState);
    ScriptFX.UI.AnimationManager._activeAnimations.remove(animation);
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.AnimationSequence

ScriptFX.UI.AnimationSequence = function ScriptFX_UI_AnimationSequence(animations) {
    ScriptFX.UI.AnimationSequence.constructBase(this, [ null ]);
    Debug.assert((animations) && (animations.length > 1));
    this._animations$1 = animations;
    this._current$1 = -1;
}
ScriptFX.UI.AnimationSequence.prototype = {
    _animations$1: null,
    _successionDelay$1: 0,
    _current$1: 0,
    _nextAnimation$1: false,
    _successionTimeStamp$1: 0,
    
    get_successionDelay: function ScriptFX_UI_AnimationSequence$get_successionDelay() {
        return this._successionDelay$1;
    },
    set_successionDelay: function ScriptFX_UI_AnimationSequence$set_successionDelay(value) {
        Debug.assert(!this.get_isPlaying());
        Debug.assert(value >= 0);
        this._successionDelay$1 = value;
        return value;
    },
    
    playCore: function ScriptFX_UI_AnimationSequence$playCore() {
        Debug.assert(this._current$1 === -1);
        if (!this.get_isReversed()) {
            this._current$1 = 0;
        }
        else {
            this._current$1 = this._animations$1.length - 1;
        }
        this._animations$1[this._current$1]._onPlay(this.get_isReversed());
    },
    
    progressCore: function ScriptFX_UI_AnimationSequence$progressCore(startRepetition, timeStamp) {
        if (startRepetition) {
            if (!this.get_isReversed()) {
                this._current$1 = 0;
            }
            else {
                this._current$1 = this._animations$1.length - 1;
            }
            this._nextAnimation$1 = true;
        }
        var animation = this._animations$1[this._current$1];
        if (this._nextAnimation$1) {
            if ((this._successionDelay$1) && ((this._successionTimeStamp$1 + this._successionDelay$1) > timeStamp)) {
                return false;
            }
            this._nextAnimation$1 = false;
            animation._onPlay(this.get_isReversed());
        }
        var completed = animation._onProgress(timeStamp);
        if (completed) {
            animation._onStop(true, ScriptFX.UI.AnimationStopState.complete);
            if (!this.get_isReversed()) {
                this._current$1++;
            }
            else {
                this._current$1--;
            }
            this._nextAnimation$1 = true;
            this._successionTimeStamp$1 = timeStamp;
        }
        return completed && ((this._current$1 === this._animations$1.length) || (this._current$1 === -1));
    },
    
    stopCore: function ScriptFX_UI_AnimationSequence$stopCore(completed, stopState) {
        if (!completed) {
            var animation = this._animations$1[this._current$1];
            animation._onStop(false, stopState);
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Behavior

ScriptFX.UI.Behavior = function ScriptFX_UI_Behavior(domElement, id) {
    Debug.assert(domElement);
    ScriptFX.Application.current.registerDisposableObject(this);
    this._domElement = domElement;
    this._id = id;
    if (!String.isNullOrEmpty(id)) {
        if (id === 'control') {
            var existingControl = domElement[id];
            if ((existingControl) && (Type.getInstanceType(existingControl) === ScriptFX.UI._genericControl)) {
                delete domElement.control;
                ScriptFX.Application.current.unregisterDisposableObject(existingControl);
                this._events = existingControl.get__eventsInternal();
            }
        }
        Debug.assert(isUndefined(domElement[id]));
        domElement[id] = this;
    }
    if (id !== 'control') {
        var existingControl = domElement.control;
        if (!existingControl) {
            existingControl = new ScriptFX.UI._genericControl(domElement);
        }
    }
    var behaviors = domElement._behaviors;
    if (!behaviors) {
        behaviors = [];
        domElement._behaviors = behaviors;
    }
    behaviors.add(this);
}
ScriptFX.UI.Behavior.getBehavior = function ScriptFX_UI_Behavior$getBehavior(domElement, type) {
    Debug.assert(domElement);
    Debug.assert(type);
    var behaviors = domElement._behaviors;
    if (behaviors) {
        var $enum1 = behaviors.getEnumerator();
        while ($enum1.moveNext()) {
            var behavior = $enum1.get_current();
            if (type.isAssignableFrom(Type.getInstanceType(behavior))) {
                return behavior;
            }
        }
    }
    return null;
}
ScriptFX.UI.Behavior.getBehaviors = function ScriptFX_UI_Behavior$getBehaviors(domElement, type) {
    Debug.assert(domElement);
    var behaviors = domElement._behaviors;
    if (isNullOrUndefined(behaviors) || (!behaviors.length)) {
        return null;
    }
    if (!type) {
        return behaviors.clone();
    }
    return behaviors.filter(Delegate.create(null, function(behavior) {
        return type.isAssignableFrom(Type.getInstanceType(behavior));
    }));
}
ScriptFX.UI.Behavior.getNamedBehavior = function ScriptFX_UI_Behavior$getNamedBehavior(domElement, id) {
    Debug.assert(domElement);
    Debug.assert(!String.isNullOrEmpty(id));
    return domElement[id];
}
ScriptFX.UI.Behavior.prototype = {
    _domElement: null,
    _id: null,
    _domEvents: null,
    _events: null,
    _initializing: false,
    
    get_domElement: function ScriptFX_UI_Behavior$get_domElement() {
        return this._domElement;
    },
    
    get_domEvents: function ScriptFX_UI_Behavior$get_domEvents() {
        if (!this._domEvents) {
            this._domEvents = new ScriptFX.UI.DOMEventList(this._domElement);
        }
        return this._domEvents;
    },
    
    get_events: function ScriptFX_UI_Behavior$get_events() {
        if (!this._events) {
            this._events = new ScriptFX.EventList();
        }
        return this._events;
    },
    
    get__eventsInternal: function ScriptFX_UI_Behavior$get__eventsInternal() {
        return this._events;
    },
    
    get_isDisposed: function ScriptFX_UI_Behavior$get_isDisposed() {
        return (!this._domElement);
    },
    
    get_isInitializing: function ScriptFX_UI_Behavior$get_isInitializing() {
        return this._initializing;
    },
    
    add_propertyChanged: function ScriptFX_UI_Behavior$add_propertyChanged(value) {
        this.get_events().addHandler('PropertyChanged', value);
    },
    remove_propertyChanged: function ScriptFX_UI_Behavior$remove_propertyChanged(value) {
        this.get_events().removeHandler('PropertyChanged', value);
    },
    
    beginInitialize: function ScriptFX_UI_Behavior$beginInitialize() {
        this._initializing = true;
    },
    
    dispose: function ScriptFX_UI_Behavior$dispose() {
        if (this._domEvents) {
            this._domEvents.dispose();
        }
        if (this._domElement) {
            if (this._id) {
                if (ScriptFX.Application.current.get_isIE()) {
                    this._domElement.removeAttribute(this._id);
                }
                else {
                    delete this._domElement[this._id];
                }
            }
            var behaviors = this._domElement._behaviors;
            Debug.assert(behaviors);
            behaviors.remove(this);
            this._domElement = null;
            ScriptFX.Application.current.unregisterDisposableObject(this);
        }
    },
    
    endInitialize: function ScriptFX_UI_Behavior$endInitialize() {
        this._initializing = false;
    },
    
    raisePropertyChanged: function ScriptFX_UI_Behavior$raisePropertyChanged(propertyName) {
        var propChangedHandler = this.get_events().getHandler('PropertyChanged');
        if (propChangedHandler) {
            propChangedHandler.invoke(this, new ScriptFX.PropertyChangedEventArgs(propertyName));
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Color

ScriptFX.UI.Color = function ScriptFX_UI_Color(red, green, blue) {
    Debug.assert(red >= 0 && red <= 255);
    Debug.assert(green >= 0 && green <= 255);
    Debug.assert(blue >= 0 && blue <= 255);
    this._red = red;
    this._green = green;
    this._blue = blue;
}
ScriptFX.UI.Color.format = function ScriptFX_UI_Color$format(red, green, blue) {
    return String.format('#{0:X2}{1:X2}{2:X2}', red, green, blue);
}
ScriptFX.UI.Color.parse = function ScriptFX_UI_Color$parse(s) {
    if (String.isNullOrEmpty(s)) {
        return null;
    }
    if ((s.length === 7) && s.startsWith('#')) {
        var red = parseInt(s.substr(1, 2), 16);
        var green = parseInt(s.substr(3, 2), 16);
        var blue = parseInt(s.substr(5, 2), 16);
        return new ScriptFX.UI.Color(red, green, blue);
    }
    else if (s.startsWith('rgb(') && s.endsWith(')')) {
        var parts = s.substring(4, s.length - 1).split(',');
        if (parts.length === 3) {
            return new ScriptFX.UI.Color(parseInt(parts[0].trim()), parseInt(parts[1].trim()), parseInt(parts[2].trim()));
        }
    }
    return null;
}
ScriptFX.UI.Color.prototype = {
    _red: 0,
    _green: 0,
    _blue: 0,
    
    get_blue: function ScriptFX_UI_Color$get_blue() {
        return this._blue;
    },
    
    get_green: function ScriptFX_UI_Color$get_green() {
        return this._green;
    },
    
    get_red: function ScriptFX_UI_Color$get_red() {
        return this._red;
    },
    
    toString: function ScriptFX_UI_Color$toString() {
        return ScriptFX.UI.Color.format(this._red, this._green, this._blue);
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Control

ScriptFX.UI.Control = function ScriptFX_UI_Control(domElement) {
    ScriptFX.UI.Control.constructBase(this, [ domElement, 'control' ]);
}
ScriptFX.UI.Control.getControl = function ScriptFX_UI_Control$getControl(domElement) {
    return ScriptFX.UI.Behavior.getNamedBehavior(domElement, 'control');
}
ScriptFX.UI.Control.prototype = {
    
    add_disposing: function ScriptFX_UI_Control$add_disposing(value) {
        this.get_events().addHandler('disposing', value);
    },
    remove_disposing: function ScriptFX_UI_Control$remove_disposing(value) {
        this.get_events().removeHandler('disposing', value);
    },
    
    dispose: function ScriptFX_UI_Control$dispose() {
        var element = this.get_domElement();
        if (element) {
            var disposingHandler = this.get_events().getHandler('disposing');
            if (disposingHandler) {
                disposingHandler.invoke(this, EventArgs.Empty);
            }
            var behaviors = ScriptFX.UI.Behavior.getBehaviors(element, null);
            Debug.assert((behaviors) && (behaviors.length > 0));
            if (behaviors.length > 1) {
                var $enum1 = behaviors.getEnumerator();
                while ($enum1.moveNext()) {
                    var behavior = $enum1.get_current();
                    if (behavior !== this) {
                        behavior.dispose();
                    }
                }
            }
        }
        ScriptFX.UI.Control.callBase(this, 'dispose');
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.DOMEventList

ScriptFX.UI.DOMEventList = function ScriptFX_UI_DOMEventList(element) {
    Debug.assert(element);
    this._element = element;
    this._handlers = {};
}
ScriptFX.UI.DOMEventList.prototype = {
    _element: null,
    _handlers: null,
    
    attach: function ScriptFX_UI_DOMEventList$attach(eventName, handler) {
        Debug.assert(this._element);
        Debug.assert(!String.isNullOrEmpty(eventName));
        Debug.assert(handler);
        Debug.assert(!this.isAttached(eventName));
        this._element.attachEvent(eventName, handler);
        this._handlers[eventName] = handler;
    },
    
    detach: function ScriptFX_UI_DOMEventList$detach(eventName) {
        Debug.assert(this._element);
        Debug.assert(!String.isNullOrEmpty(eventName));
        var handler = this._handlers[eventName];
        if (handler) {
            this._element.detachEvent(eventName, handler);
            delete this._handlers[eventName];
            return true;
        }
        return false;
    },
    
    dispose: function ScriptFX_UI_DOMEventList$dispose() {
        if (this._element) {
            var $dict1 = this._handlers;
            for (var $key2 in $dict1) {
                var e = { key: $key2, value: $dict1[$key2] };
                this._element.detachEvent(e.key, e.value);
            }
            this._element = null;
            this._handlers = null;
        }
    },
    
    isAttached: function ScriptFX_UI_DOMEventList$isAttached(eventName) {
        Debug.assert(this._element);
        Debug.assert(!String.isNullOrEmpty(eventName));
        return (this._handlers[eventName]) ? true : false;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.DragDropEventArgs

ScriptFX.UI.DragDropEventArgs = function ScriptFX_UI_DragDropEventArgs(dataObject) {
    ScriptFX.UI.DragDropEventArgs.constructBase(this);
    this._dataObject$1 = dataObject;
}
ScriptFX.UI.DragDropEventArgs.prototype = {
    _dataObject$1: null,
    
    get_dataObject: function ScriptFX_UI_DragDropEventArgs$get_dataObject() {
        return this._dataObject$1;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.DragDropManager

ScriptFX.UI.DragDropManager = function ScriptFX_UI_DragDropManager() {
}
ScriptFX.UI.DragDropManager.get_canDragDrop = function ScriptFX_UI_DragDropManager$get_canDragDrop() {
    return (ScriptFX.UI.DragDropManager._dragDropImplementation);
}
ScriptFX.UI.DragDropManager.get_supportsDataTransfer = function ScriptFX_UI_DragDropManager$get_supportsDataTransfer() {
    Debug.assert(ScriptFX.UI.DragDropManager.get_canDragDrop());
    return ScriptFX.UI.DragDropManager._dragDropImplementation.get_supportsDataTransfer();
}
ScriptFX.UI.DragDropManager.add_dragDropEnding = function ScriptFX_UI_DragDropManager$add_dragDropEnding(value) {
    ScriptFX.UI.DragDropManager._dragEndingHandler = Delegate.combine(ScriptFX.UI.DragDropManager._dragEndingHandler, value);
}
ScriptFX.UI.DragDropManager.remove_dragDropEnding = function ScriptFX_UI_DragDropManager$remove_dragDropEnding(value) {
    ScriptFX.UI.DragDropManager._dragEndingHandler = Delegate.remove(ScriptFX.UI.DragDropManager._dragEndingHandler, value);
}
ScriptFX.UI.DragDropManager.add_dragDropStarting = function ScriptFX_UI_DragDropManager$add_dragDropStarting(value) {
    ScriptFX.UI.DragDropManager._dragStartingHandler = Delegate.combine(ScriptFX.UI.DragDropManager._dragStartingHandler, value);
}
ScriptFX.UI.DragDropManager.remove_dragDropStarting = function ScriptFX_UI_DragDropManager$remove_dragDropStarting(value) {
    ScriptFX.UI.DragDropManager._dragStartingHandler = Delegate.remove(ScriptFX.UI.DragDropManager._dragStartingHandler, value);
}
ScriptFX.UI.DragDropManager._endDragDrop = function ScriptFX_UI_DragDropManager$_endDragDrop() {
    if (ScriptFX.UI.DragDropManager._dragEndingHandler) {
        ScriptFX.UI.DragDropManager._dragEndingHandler.invoke(null, new ScriptFX.UI.DragDropEventArgs(ScriptFX.UI.DragDropManager._currentDataObject));
    }
    ScriptFX.UI.DragDropManager._currentDataObject = null;
}
ScriptFX.UI.DragDropManager.registerDragDropImplementation = function ScriptFX_UI_DragDropManager$registerDragDropImplementation(dragDrop) {
    ScriptFX.UI.DragDropManager._dragDropImplementation = dragDrop;
}
ScriptFX.UI.DragDropManager.registerDropTarget = function ScriptFX_UI_DragDropManager$registerDropTarget(target) {
    ScriptFX.UI.DragDropManager._dropTargets.add(target);
}
ScriptFX.UI.DragDropManager.startDragDrop = function ScriptFX_UI_DragDropManager$startDragDrop(data, dragVisual, dragOffset, source, context) {
    Debug.assert(ScriptFX.UI.DragDropManager.get_canDragDrop());
    if (ScriptFX.UI.DragDropManager._currentDataObject) {
        return false;
    }
    var validDropTargets = [];
    var $enum1 = ScriptFX.UI.DragDropManager._dropTargets.getEnumerator();
    while ($enum1.moveNext()) {
        var dropTarget = $enum1.get_current();
        if (dropTarget.supportsDataObject(data)) {
            validDropTargets.add(dropTarget);
        }
    }
    if (!validDropTargets.length) {
        return false;
    }
    ScriptFX.UI.DragDropManager._currentDataObject = data;
    if (ScriptFX.UI.DragDropManager._dragStartingHandler) {
        ScriptFX.UI.DragDropManager._dragStartingHandler.invoke(null, new ScriptFX.UI.DragDropEventArgs(data));
    }
    ScriptFX.UI.DragDropManager._dragDropImplementation.dragDrop(new ScriptFX.UI._dragDropTracker(source), context, validDropTargets, dragVisual, dragOffset, ScriptFX.UI.DragDropManager._currentDataObject);
    return true;
}
ScriptFX.UI.DragDropManager.unregisterDropTarget = function ScriptFX_UI_DragDropManager$unregisterDropTarget(target) {
    ScriptFX.UI.DragDropManager._dropTargets.remove(target);
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI._dragDropTracker

ScriptFX.UI._dragDropTracker = function ScriptFX_UI__dragDropTracker(actualSource) {
    this._actualSource = actualSource;
}
ScriptFX.UI._dragDropTracker.prototype = {
    _actualSource: null,
    
    get_domElement: function ScriptFX_UI__dragDropTracker$get_domElement() {
        return this._actualSource.get_domElement();
    },
    
    onDragStart: function ScriptFX_UI__dragDropTracker$onDragStart(context) {
        if (this._actualSource) {
            this._actualSource.onDragStart(context);
        }
    },
    
    onDrag: function ScriptFX_UI__dragDropTracker$onDrag(context) {
        if (this._actualSource) {
            this._actualSource.onDrag(context);
        }
    },
    
    onDragEnd: function ScriptFX_UI__dragDropTracker$onDragEnd(canceled, context) {
        if (this._actualSource) {
            this._actualSource.onDragEnd(canceled, context);
        }
        ScriptFX.UI.DragDropManager._endDragDrop();
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Element

ScriptFX.UI.Element = function ScriptFX_UI_Element() {
}
ScriptFX.UI.Element.addCSSClass = function ScriptFX_UI_Element$addCSSClass(element, className) {
    var cssClass = element.className;
    if ((' ' + cssClass + ' ').indexOf(' ' + className + ' ') < 0) {
        element.className = cssClass + ' ' + className;
    }
}
ScriptFX.UI.Element.containsCSSClass = function ScriptFX_UI_Element$containsCSSClass(element, className) {
    return element.className.split(' ').contains(className);
}
ScriptFX.UI.Element.getBounds = function ScriptFX_UI_Element$getBounds(element) {
    var location = ScriptFX.UI.Element.getLocation(element);
    return ScriptFX.UI.$create_Bounds(location.left, location.top, element.offsetWidth, element.offsetHeight);
}
ScriptFX.UI.Element.getLocation = function ScriptFX_UI_Element$getLocation(element) {
    var offsetX = 0;
    var offsetY = 0;
    for (var parentElement = element; parentElement; parentElement = parentElement.offsetParent) {
        offsetX += parentElement.offsetLeft;
        offsetY += parentElement.offsetTop;
    }
    return ScriptFX.UI.$create_Location(offsetX, offsetY);
}
ScriptFX.UI.Element.getSize = function ScriptFX_UI_Element$getSize(element) {
    return ScriptFX.UI.$create_Size(element.offsetWidth, element.offsetHeight);
}
ScriptFX.UI.Element.removeCSSClass = function ScriptFX_UI_Element$removeCSSClass(element, className) {
    var cssClass = ' ' + element.className + ' ';
    var index = cssClass.indexOf(' ' + className + ' ');
    if (index >= 0) {
        var newClass = cssClass.substr(0, index) + ' ' + cssClass.substr(index + className.length + 1);
        element.className = newClass;
    }
}
ScriptFX.UI.Element.setLocation = function ScriptFX_UI_Element$setLocation(element, location) {
    element.style.left = location.left + 'px';
    element.style.top = location.top + 'px';
}
ScriptFX.UI.Element.setSize = function ScriptFX_UI_Element$setSize(element, size) {
    element.style.width = size.width + 'px';
    element.style.height = size.height + 'px';
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.FadeEffect

ScriptFX.UI.FadeEffect = function ScriptFX_UI_FadeEffect(domElement, duration, opacity) {
    ScriptFX.UI.FadeEffect.constructBase(this, [ domElement, duration ]);
    this._opacity$2 = opacity;
}
ScriptFX.UI.FadeEffect.prototype = {
    _fadingIn$2: false,
    _opacity$2: 0,
    
    get_isFadingIn: function ScriptFX_UI_FadeEffect$get_isFadingIn() {
        return this._fadingIn$2;
    },
    
    fadeIn: function ScriptFX_UI_FadeEffect$fadeIn() {
        if (this.get_isPlaying()) {
            this.stop(ScriptFX.UI.AnimationStopState.complete);
        }
        this._fadingIn$2 = true;
        this.play();
    },
    
    fadeOut: function ScriptFX_UI_FadeEffect$fadeOut() {
        if (this.get_isPlaying()) {
            this.stop(ScriptFX.UI.AnimationStopState.complete);
        }
        this._fadingIn$2 = false;
        this.play();
    },
    
    performCleanup: function ScriptFX_UI_FadeEffect$performCleanup() {
        ScriptFX.UI.FadeEffect.callBase(this, 'performCleanup');
        if (!this._fadingIn$2) {
            this._setOpacity$2(0);
            this.get_domElement().style.display = 'none';
        }
    },
    
    performSetup: function ScriptFX_UI_FadeEffect$performSetup() {
        ScriptFX.UI.FadeEffect.callBase(this, 'performSetup');
        if (this._fadingIn$2) {
            this._setOpacity$2(0);
            this.get_domElement().style.display = '';
        }
    },
    
    performTweening: function ScriptFX_UI_FadeEffect$performTweening(frame) {
        if (this._fadingIn$2) {
            this._setOpacity$2(this._opacity$2 * frame);
        }
        else {
            this._setOpacity$2(this._opacity$2 * (1 - frame));
        }
    },
    
    _setOpacity$2: function ScriptFX_UI_FadeEffect$_setOpacity$2(opacity) {
        if (ScriptFX.Application.current.get_isIE()) {
            this.get_domElement().style.filter = 'alpha(opacity=' + (opacity * 100) + ')';
        }
        else {
            this.get_domElement().style.opacity = opacity.toString();
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI._genericControl

ScriptFX.UI._genericControl = function ScriptFX_UI__genericControl(domElement) {
    ScriptFX.UI._genericControl.constructBase(this, [ domElement ]);
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.OverlayBehavior

ScriptFX.UI.OverlayBehavior = function ScriptFX_UI_OverlayBehavior(domElement, options) {
    ScriptFX.UI.OverlayBehavior.constructBase(this, [ domElement, options.id ]);
    this._overlayElement$1 = document.createElement('div');
    this._overlayElement$1.className = options.cssClass;
    var overlayStyle = this._overlayElement$1.style;
    overlayStyle.display = 'none';
    overlayStyle.top = '0px';
    overlayStyle.left = '0px';
    overlayStyle.width = '100%';
    if (ScriptFX.Application.current.get_isIE() && (ScriptFX.Application.current.get_host().get_majorVersion() < 7)) {
        overlayStyle.position = 'absolute';
    }
    else {
        this._fixedOverlayElement$1 = true;
        overlayStyle.position = 'fixed';
        overlayStyle.height = '100%';
    }
    document.body.appendChild(this._overlayElement$1);
    if (options.fadeInOutInterval) {
        this._fade$1 = new ScriptFX.UI.FadeEffect(this._overlayElement$1, options.fadeInOutInterval, options.opacity);
        this._fade$1.set_easingFunction(Delegate.create(null, ScriptFX.UI.TimedAnimation.easeInOut));
        this._fade$1.add_stopped(Delegate.create(this, this._onAnimationStopped$1));
    }
}
ScriptFX.UI.OverlayBehavior.prototype = {
    _overlayElement$1: null,
    _fixedOverlayElement$1: false,
    _fade$1: null,
    _resizeHandler$1: null,
    _visible$1: false,
    
    get_isVisible: function ScriptFX_UI_OverlayBehavior$get_isVisible() {
        return this._visible$1;
    },
    
    add_visibilityChanged: function ScriptFX_UI_OverlayBehavior$add_visibilityChanged(value) {
        this.get_events().addHandler(ScriptFX.UI.OverlayBehavior._visibilityChangedEventKey$1, value);
    },
    remove_visibilityChanged: function ScriptFX_UI_OverlayBehavior$remove_visibilityChanged(value) {
        this.get_events().removeHandler(ScriptFX.UI.OverlayBehavior._visibilityChangedEventKey$1, value);
    },
    
    dispose: function ScriptFX_UI_OverlayBehavior$dispose() {
        if (this._fade$1) {
            this._fade$1.dispose();
            this._fade$1 = null;
        }
        if (this._resizeHandler$1) {
            window.detachEvent('onresize', this._resizeHandler$1);
            this._resizeHandler$1 = null;
        }
        ScriptFX.UI.OverlayBehavior.callBase(this, 'dispose');
    },
    
    hide: function ScriptFX_UI_OverlayBehavior$hide() {
        if ((!this._visible$1) || this._fade$1.get_isPlaying()) {
            return;
        }
        if (this._resizeHandler$1) {
            window.detachEvent('onresize', this._resizeHandler$1);
            this._resizeHandler$1 = null;
        }
        if (this._fade$1) {
            this._fade$1.fadeOut();
        }
        else {
            this._overlayElement$1.style.display = 'none';
            this._visible$1 = false;
            var handler = this.get_events().getHandler(ScriptFX.UI.OverlayBehavior._visibilityChangedEventKey$1);
            if (handler) {
                handler.invoke(this, EventArgs.Empty);
            }
        }
    },
    
    _onAnimationStopped$1: function ScriptFX_UI_OverlayBehavior$_onAnimationStopped$1(sender, e) {
        this._visible$1 = this._fade$1.get_isFadingIn();
        var handler = this.get_events().getHandler(ScriptFX.UI.OverlayBehavior._visibilityChangedEventKey$1);
        if (handler) {
            handler.invoke(this, EventArgs.Empty);
        }
    },
    
    _onWindowResize$1: function ScriptFX_UI_OverlayBehavior$_onWindowResize$1() {
        this._overlayElement$1.style.height = document.documentElement.offsetHeight + 'px';
    },
    
    show: function ScriptFX_UI_OverlayBehavior$show() {
        if (this._visible$1 || this._fade$1.get_isPlaying()) {
            return;
        }
        if (!this._fixedOverlayElement$1) {
            this._overlayElement$1.style.height = document.documentElement.offsetHeight + 'px';
            this._resizeHandler$1 = Delegate.create(this, this._onWindowResize$1);
            window.attachEvent('onresize', this._resizeHandler$1);
        }
        if (this._fade$1) {
            this._fade$1.fadeIn();
        }
        else {
            this._overlayElement$1.style.display = '';
            this._visible$1 = true;
            var handler = this.get_events().getHandler(ScriptFX.UI.OverlayBehavior._visibilityChangedEventKey$1);
            if (handler) {
                handler.invoke(this, EventArgs.Empty);
            }
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.PopupBehavior

ScriptFX.UI.PopupBehavior = function ScriptFX_UI_PopupBehavior(domElement, options) {
    ScriptFX.UI.PopupBehavior.constructBase(this, [ domElement, options.id ]);
    this._options$1 = options;
    domElement.style.position = 'absolute';
    domElement.style.display = 'none';
}
ScriptFX.UI.PopupBehavior.prototype = {
    _options$1: null,
    _iframe$1: null,
    
    dispose: function ScriptFX_UI_PopupBehavior$dispose() {
        if (this.get_domElement()) {
            this.hide();
        }
        ScriptFX.UI.PopupBehavior.callBase(this, 'dispose');
    },
    
    hide: function ScriptFX_UI_PopupBehavior$hide() {
        this.get_domElement().style.display = 'none';
        if (this._iframe$1) {
            this._iframe$1.parentNode.removeChild(this._iframe$1);
            this._iframe$1 = null;
        }
    },
    
    show: function ScriptFX_UI_PopupBehavior$show() {
        var parentElement = this.get_domElement().offsetParent;
        if (!parentElement) {
            parentElement = document.documentElement;
        }
        this.get_domElement().style.display = 'block';
        var x = 0;
        var y = 0;
        var xOffsetDirection = 1;
        var yOffsetDirection = 1;
        var alignment = false;
        var parentBounds = ScriptFX.UI.Element.getBounds(parentElement);
        var elementBounds = ScriptFX.UI.Element.getBounds(this.get_domElement());
        var referenceBounds = ScriptFX.UI.Element.getBounds(this._options$1.referenceElement);
        var xDelta = referenceBounds.left - parentBounds.left;
        var yDelta = referenceBounds.top - parentBounds.top;
        switch (this._options$1.mode) {
            case ScriptFX.UI.PopupMode.center:
                x = Math.round(referenceBounds.width / 2 - elementBounds.width / 2);
                y = Math.round(referenceBounds.height / 2 - elementBounds.height / 2);
                break;
            case ScriptFX.UI.PopupMode.anchorTopLeft:
                x = 0;
                y = -elementBounds.height;
                break;
            case ScriptFX.UI.PopupMode.anchorTopRight:
                x = referenceBounds.width - elementBounds.width;
                y = -elementBounds.height;
                break;
            case ScriptFX.UI.PopupMode.anchorBottomRight:
                x = referenceBounds.width - elementBounds.width;
                y = referenceBounds.height;
                break;
            case ScriptFX.UI.PopupMode.anchorBottomLeft:
                x = 0;
                y = referenceBounds.height;
                break;
            case ScriptFX.UI.PopupMode.alignTopLeft:
                x = referenceBounds.left;
                y = referenceBounds.top;
                alignment = true;
                break;
            case ScriptFX.UI.PopupMode.alignTopRight:
                x = referenceBounds.left + referenceBounds.width - elementBounds.width;
                y = referenceBounds.top;
                xOffsetDirection = -1;
                alignment = true;
                break;
            case ScriptFX.UI.PopupMode.alignBottomRight:
                x = referenceBounds.left + referenceBounds.width - elementBounds.width;
                y = referenceBounds.top + referenceBounds.height - elementBounds.height;
                xOffsetDirection = -1;
                yOffsetDirection = -1;
                alignment = true;
                break;
            case ScriptFX.UI.PopupMode.alignBottomLeft:
                x = referenceBounds.left;
                y = referenceBounds.top + referenceBounds.height - elementBounds.height;
                yOffsetDirection = -1;
                alignment = true;
                break;
        }
        if (!alignment) {
            x += xDelta + this._options$1.xOffset;
            y += yDelta + this._options$1.yOffset;
        }
        else {
            x += xDelta + this._options$1.xOffset * xOffsetDirection;
            y += yDelta + this._options$1.yOffset * yOffsetDirection;
        }
        var docWidth = document.body.clientWidth;
        if (x + elementBounds.width > docWidth - 2) {
            x -= (x + elementBounds.width - docWidth + 2);
        }
        if (x < 0) {
            x = 2;
        }
        if (y < 0) {
            y = 2;
        }
        ScriptFX.UI.Element.setLocation(this.get_domElement(), ScriptFX.UI.$create_Location(x, y));
        var host = ScriptFX.Application.current.get_host();
        if ((host.get_name() === ScriptFX.HostName.IE) && (host.get_majorVersion() < 7)) {
            this._iframe$1 = document.createElement('IFRAME');
            this._iframe$1.src = 'javascript:false;';
            this._iframe$1.scrolling = 'no';
            this._iframe$1.style.position = 'absolute';
            this._iframe$1.style.display = 'block';
            this._iframe$1.style.border = 'none';
            this._iframe$1.style.filter = 'progid:DXImageTransform.Microsoft.Alpha(style=0,opacity=0)';
            this._iframe$1.style.left = x + 'px';
            this._iframe$1.style.top = y + 'px';
            this._iframe$1.style.width = elementBounds.width + 'px';
            this._iframe$1.style.height = elementBounds.height + 'px';
            this._iframe$1.style.zIndex = 1;
            this.get_domElement().parentNode.insertBefore(this._iframe$1, this.get_domElement());
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.TimedAnimation

ScriptFX.UI.TimedAnimation = function ScriptFX_UI_TimedAnimation(domElement, duration) {
    ScriptFX.UI.TimedAnimation.constructBase(this, [ domElement ]);
    Debug.assert(duration > 0);
    this._duration$1 = duration;
}
ScriptFX.UI.TimedAnimation.easeIn = function ScriptFX_UI_TimedAnimation$easeIn(t) {
    return t * t;
}
ScriptFX.UI.TimedAnimation.easeInOut = function ScriptFX_UI_TimedAnimation$easeInOut(t) {
    t = t * 2;
    if (t < 1) {
        return t * t / 2;
    }
    return -((--t) * (t - 2) - 1) / 2;
}
ScriptFX.UI.TimedAnimation.easeOut = function ScriptFX_UI_TimedAnimation$easeOut(t) {
    return -t * (t - 2);
}
ScriptFX.UI.TimedAnimation.prototype = {
    _duration$1: 0,
    _easingFunction$1: null,
    _startTimeStamp$1: 0,
    
    get_duration: function ScriptFX_UI_TimedAnimation$get_duration() {
        return this._duration$1;
    },
    set_duration: function ScriptFX_UI_TimedAnimation$set_duration(value) {
        Debug.assert(!this.get_isPlaying());
        Debug.assert(this._duration$1 >= 0);
        this._duration$1 = value;
        return value;
    },
    
    get_easingFunction: function ScriptFX_UI_TimedAnimation$get_easingFunction() {
        return this._easingFunction$1;
    },
    set_easingFunction: function ScriptFX_UI_TimedAnimation$set_easingFunction(value) {
        Debug.assert(!this.get_isPlaying());
        this._easingFunction$1 = value;
        return value;
    },
    
    playCore: function ScriptFX_UI_TimedAnimation$playCore() {
        this._startTimeStamp$1 = (new Date()).getTime();
        this.progressCore(false, this._startTimeStamp$1);
    },
    
    progressCore: function ScriptFX_UI_TimedAnimation$progressCore(startRepetition, timeStamp) {
        var frame = 0;
        var completed = false;
        if (!startRepetition) {
            frame = (timeStamp - this._startTimeStamp$1) / this._duration$1;
            if (!this.get_isReversed()) {
                completed = (frame >= 1);
                frame = Math.min(1, frame);
            }
            else {
                frame = 1 - frame;
                completed = (frame <= 0);
                frame = Math.max(0, frame);
            }
            if ((!completed) && (this._easingFunction$1)) {
                frame = this._easingFunction$1.invoke(frame);
            }
        }
        else {
            this._startTimeStamp$1 = timeStamp;
            if (this.get_isReversed()) {
                frame = 1;
            }
        }
        this.performTweening(frame);
        return completed;
    },
    
    stopCore: function ScriptFX_UI_TimedAnimation$stopCore(completed, stopState) {
        if (!completed) {
            if (stopState === ScriptFX.UI.AnimationStopState.complete) {
                this.performTweening(1);
            }
            else if (stopState === ScriptFX.UI.AnimationStopState.revert) {
                this.performTweening(0);
            }
        }
    }
}


ScriptFX.Application.createClass('ScriptFX.Application', null, IServiceProvider, IServiceContainer, ScriptFX.IEventManager);
ScriptFX.CancelEventArgs.createClass('ScriptFX.CancelEventArgs', EventArgs);
ScriptFX.CollectionChangedEventArgs.createClass('ScriptFX.CollectionChangedEventArgs', EventArgs);
ScriptFX.ApplicationUnloadingEventArgs.createClass('ScriptFX.ApplicationUnloadingEventArgs', EventArgs);
ScriptFX.HistoryManager.createClass('ScriptFX.HistoryManager', null, IDisposable);
ScriptFX.HistoryEventArgs.createClass('ScriptFX.HistoryEventArgs', EventArgs);
ScriptFX.HostInfo.createClass('ScriptFX.HostInfo');
ScriptFX.EventList.createClass('ScriptFX.EventList');
ScriptFX.JSON.createClass('ScriptFX.JSON');
ScriptFX.PropertyChangedEventArgs.createClass('ScriptFX.PropertyChangedEventArgs', EventArgs);
ScriptFX.ObservableCollection.createClass('ScriptFX.ObservableCollection', null, IDisposable, IArray, IEnumerable, ScriptFX.INotifyCollectionChanged);
ScriptFX.Net.HTTPRequest.createClass('ScriptFX.Net.HTTPRequest', null, IDisposable);
ScriptFX.Net.HTTPRequestManager.createClass('ScriptFX.Net.HTTPRequestManager');
ScriptFX.Net.HTTPTransport.createClass('ScriptFX.Net.HTTPTransport', null, IDisposable);
ScriptFX.Net.PostHTTPRequestEventArgs.createClass('ScriptFX.Net.PostHTTPRequestEventArgs', EventArgs);
ScriptFX.Net.PreHTTPRequestEventArgs.createClass('ScriptFX.Net.PreHTTPRequestEventArgs', EventArgs);
ScriptFX.Net._xmlhttpResponse.createClass('ScriptFX.Net._xmlhttpResponse', null, ScriptFX.Net.IHTTPResponse);
ScriptFX.Net._xmlhttpTransport.createClass('ScriptFX.Net._xmlhttpTransport', ScriptFX.Net.HTTPTransport);
ScriptFX.UI.Animation.createClass('ScriptFX.UI.Animation', null, IDisposable);
ScriptFX.UI.AnimationManager.createClass('ScriptFX.UI.AnimationManager');
ScriptFX.UI.AnimationSequence.createClass('ScriptFX.UI.AnimationSequence', ScriptFX.UI.Animation);
ScriptFX.UI.Behavior.createClass('ScriptFX.UI.Behavior', null, IDisposable, ScriptFX.ISupportInitialize, ScriptFX.INotifyPropertyChanged);
ScriptFX.UI.Color.createClass('ScriptFX.UI.Color');
ScriptFX.UI.Control.createClass('ScriptFX.UI.Control', ScriptFX.UI.Behavior, ScriptFX.INotifyDisposing);
ScriptFX.UI.DOMEventList.createClass('ScriptFX.UI.DOMEventList', null, IDisposable);
ScriptFX.UI.DragDropEventArgs.createClass('ScriptFX.UI.DragDropEventArgs', EventArgs);
ScriptFX.UI.DragDropManager.createClass('ScriptFX.UI.DragDropManager');
ScriptFX.UI._dragDropTracker.createClass('ScriptFX.UI._dragDropTracker', null, ScriptFX.UI.IDragSource);
ScriptFX.UI.Element.createClass('ScriptFX.UI.Element');
ScriptFX.UI.TimedAnimation.createClass('ScriptFX.UI.TimedAnimation', ScriptFX.UI.Animation);
ScriptFX.UI.FadeEffect.createClass('ScriptFX.UI.FadeEffect', ScriptFX.UI.TimedAnimation);
ScriptFX.UI._genericControl.createClass('ScriptFX.UI._genericControl', ScriptFX.UI.Control);
ScriptFX.UI.OverlayBehavior.createClass('ScriptFX.UI.OverlayBehavior', ScriptFX.UI.Behavior);
ScriptFX.UI.PopupBehavior.createClass('ScriptFX.UI.PopupBehavior', ScriptFX.UI.Behavior);
ScriptFX.Application.current = new ScriptFX.Application();
ScriptFX.JSON._dateRegex = null;
ScriptFX.Net.HTTPRequestManager.__requestInvoking = null;
ScriptFX.Net.HTTPRequestManager.__requestInvoked = null;
ScriptFX.Net.HTTPRequestManager._timeoutInterval = 0;
ScriptFX.Net.HTTPRequestManager._activeRequests = [];
ScriptFX.Net.HTTPRequestManager._appIdleHandler = null;
ScriptFX.UI.AnimationManager._fps = 100;
ScriptFX.UI.AnimationManager._activeAnimations = null;
ScriptFX.UI.AnimationManager._timerCookie = 0;
ScriptFX.UI.DragDropManager._dragDropImplementation = null;
ScriptFX.UI.DragDropManager._dropTargets = [];
ScriptFX.UI.DragDropManager._dragStartingHandler = null;
ScriptFX.UI.DragDropManager._dragEndingHandler = null;
ScriptFX.UI.DragDropManager._currentDataObject = null;
ScriptFX.UI.OverlayBehavior._visibilityChangedEventKey$1 = 'visibilityChanged';

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
// Script# Framework
// Copyright (c) 2006, Nikhil Kothari. All Rights Reserved.
// http://projects.nikhilk.net
//


Type.createNamespace('ScriptFX.Reflection');

////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.MemberInfoType

ScriptFX.Reflection.MemberInfoType = function() { };
ScriptFX.Reflection.MemberInfoType.prototype = {
    Field: 0, 
    Method: 1, 
    Property: 2, 
    Event: 3
}
ScriptFX.Reflection.MemberInfoType.createEnum('ScriptFX.Reflection.MemberInfoType', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.TypeInfoType

ScriptFX.Reflection.TypeInfoType = function() { };
ScriptFX.Reflection.TypeInfoType.prototype = {
    Class: 0, 
    Interface: 1, 
    Enumeration: 2, 
    FlagsEnumeration: 3
}
ScriptFX.Reflection.TypeInfoType.createEnum('ScriptFX.Reflection.TypeInfoType', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.ParameterInfo

ScriptFX.Reflection.ParameterInfo = function ScriptFX_Reflection_ParameterInfo(name) {
    this._name = name;
}
ScriptFX.Reflection.ParameterInfo.prototype = {
    _name: null,
    
    get_name: function ScriptFX_Reflection_ParameterInfo$get_name() {
        return this._name;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.FieldInfo

ScriptFX.Reflection.FieldInfo = function ScriptFX_Reflection_FieldInfo(name, fieldType, isStatic) {
    ScriptFX.Reflection.FieldInfo.constructBase(this, [ ScriptFX.Reflection.MemberInfoType.Field, name, fieldType, isStatic ]);
}
ScriptFX.Reflection.FieldInfo.prototype = {
    _value$1: null,
    
    get_value: function ScriptFX_Reflection_FieldInfo$get_value() {
        return this._value$1;
    },
    
    _initialize: function ScriptFX_Reflection_FieldInfo$_initialize(value) {
        this._value$1 = value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.Reflector

ScriptFX.Reflection.Reflector = function ScriptFX_Reflection_Reflector() {
}
ScriptFX.Reflection.Reflector.getGlobalTypes = function ScriptFX_Reflection_Reflector$getGlobalTypes() {
    if (!ScriptFX.Reflection.Reflector._globalTypes) {
        var globalTypes = [];
        var classTypes = [ Object, Boolean, Number, String, Date, Array, Function, RegExp, StringBuilder, EventArgs ];
        var interfaceTypes = [ IDisposable, IEnumerable, IEnumerator, IArray ];
        var $enum1 = classTypes.getEnumerator();
        while ($enum1.moveNext()) {
            var type = $enum1.get_current();
            var typeInfo = new ScriptFX.Reflection.TypeInfo(null, ScriptFX.Reflection.TypeInfoType.Class, type.get_name());
            typeInfo._initialize(type);
            globalTypes.add(typeInfo);
        }
        var $enum2 = interfaceTypes.getEnumerator();
        while ($enum2.moveNext()) {
            var type = $enum2.get_current();
            var typeInfo = new ScriptFX.Reflection.TypeInfo(null, ScriptFX.Reflection.TypeInfoType.Interface, type.get_name());
            typeInfo._initialize(type);
            globalTypes.add(typeInfo);
        }
        ScriptFX.Reflection.Reflector._globalTypes = globalTypes;
    }
    return ScriptFX.Reflection.Reflector._globalTypes;
}
ScriptFX.Reflection.Reflector.getNamespaces = function ScriptFX_Reflection_Reflector$getNamespaces() {
    if (!ScriptFX.Reflection.Reflector._namespaces) {
        var namespaceTable = window.__namespaces;
        ScriptFX.Reflection.Reflector._namespaces = [];
        var $dict1 = namespaceTable;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            ScriptFX.Reflection.Reflector._namespaces.add(new ScriptFX.Reflection.NamespaceInfo(entry.key, entry.value));
        }
    }
    return ScriptFX.Reflection.Reflector._namespaces;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.PropertyInfo

ScriptFX.Reflection.PropertyInfo = function ScriptFX_Reflection_PropertyInfo(name, propertyType, isStatic) {
    ScriptFX.Reflection.PropertyInfo.constructBase(this, [ ScriptFX.Reflection.MemberInfoType.Property, name, propertyType, isStatic ]);
}
ScriptFX.Reflection.PropertyInfo.prototype = {
    _getAccessor$1: null,
    _setAccessor$1: null,
    
    get_getAccessor: function ScriptFX_Reflection_PropertyInfo$get_getAccessor() {
        return this._getAccessor$1;
    },
    
    get_isReadOnly: function ScriptFX_Reflection_PropertyInfo$get_isReadOnly() {
        return (!this._setAccessor$1);
    },
    
    get_setAccessor: function ScriptFX_Reflection_PropertyInfo$get_setAccessor() {
        return this._setAccessor$1;
    },
    
    _initialize: function ScriptFX_Reflection_PropertyInfo$_initialize(getAccessor, setAccessor) {
        this._getAccessor$1 = getAccessor;
        this._setAccessor$1 = setAccessor;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.EventInfo

ScriptFX.Reflection.EventInfo = function ScriptFX_Reflection_EventInfo(name, argsType, isStatic) {
    ScriptFX.Reflection.EventInfo.constructBase(this, [ ScriptFX.Reflection.MemberInfoType.Event, name, argsType, isStatic ]);
}
ScriptFX.Reflection.EventInfo.prototype = {
    _addAccessor$1: null,
    _removeAccessor$1: null,
    
    get_addAccessor: function ScriptFX_Reflection_EventInfo$get_addAccessor() {
        return this._addAccessor$1;
    },
    
    get_removeAccessor: function ScriptFX_Reflection_EventInfo$get_removeAccessor() {
        return this._removeAccessor$1;
    },
    
    _initialialize: function ScriptFX_Reflection_EventInfo$_initialialize(addAccessor, removeAccessor) {
        this._addAccessor$1 = addAccessor;
        this._removeAccessor$1 = removeAccessor;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.MethodInfo

ScriptFX.Reflection.MethodInfo = function ScriptFX_Reflection_MethodInfo(name, returnType, isStatic) {
    ScriptFX.Reflection.MethodInfo.constructBase(this, [ ScriptFX.Reflection.MemberInfoType.Method, name, returnType, isStatic ]);
}
ScriptFX.Reflection.MethodInfo.prototype = {
    _isConstructor$1: false,
    _method$1: null,
    _parameters$1: null,
    
    get_constructor: function ScriptFX_Reflection_MethodInfo$get_constructor() {
        return this._isConstructor$1;
    },
    
    get_method: function ScriptFX_Reflection_MethodInfo$get_method() {
        return this._method$1;
    },
    
    get_parameters: function ScriptFX_Reflection_MethodInfo$get_parameters() {
        return this._parameters$1;
    },
    
    _initialize: function ScriptFX_Reflection_MethodInfo$_initialize(isConstructor, method) {
        this._isConstructor$1 = isConstructor;
        this._method$1 = method;
        var sourceCode = method.toString();
        var indexOpenParen = sourceCode.indexOf('(');
        var indexCloseParen = sourceCode.indexOf(')');
        var signature = sourceCode.substring(indexOpenParen + 1, indexCloseParen).trim();
        var parameters = [];
        if (signature.length) {
            var paramNames = signature.split(',');
            for (var i = 0; i < paramNames.length; i++) {
                parameters[i] = new ScriptFX.Reflection.ParameterInfo(paramNames[i].trim());
            }
        }
        this._parameters$1 = parameters;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.MemberInfo

ScriptFX.Reflection.MemberInfo = function ScriptFX_Reflection_MemberInfo(memberType, name, type, isStatic) {
    this._memberType = memberType;
    this._name = name;
    this._type = type;
    this._isStatic = isStatic;
}
ScriptFX.Reflection.MemberInfo.prototype = {
    _memberType: 0,
    _name: null,
    _type: null,
    _isStatic: false,
    
    get_associatedType: function ScriptFX_Reflection_MemberInfo$get_associatedType() {
        return this._type;
    },
    
    get_isPublic: function ScriptFX_Reflection_MemberInfo$get_isPublic() {
        return (!this._name.startsWith('_')) && (!this._name.startsWith('$'));
    },
    
    get_isStatic: function ScriptFX_Reflection_MemberInfo$get_isStatic() {
        return this._isStatic;
    },
    
    get_memberType: function ScriptFX_Reflection_MemberInfo$get_memberType() {
        return this._memberType;
    },
    
    get_name: function ScriptFX_Reflection_MemberInfo$get_name() {
        return this._name;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.NamespaceInfo

ScriptFX.Reflection.NamespaceInfo = function ScriptFX_Reflection_NamespaceInfo(name, typeTable) {
    this._name = name;
    this._typeTable = typeTable;
}
ScriptFX.Reflection.NamespaceInfo.prototype = {
    _name: null,
    _typeTable: null,
    _types: null,
    
    get_name: function ScriptFX_Reflection_NamespaceInfo$get_name() {
        return this._name;
    },
    
    getTypes: function ScriptFX_Reflection_NamespaceInfo$getTypes() {
        if (!this._types) {
            this._types = [];
            var $dict1 = this._typeTable;
            for (var $key2 in $dict1) {
                var entry = { key: $key2, value: $dict1[$key2] };
                var typeInfo = null;
                var type = entry.value;
                if (Type.isClass(type)) {
                    typeInfo = new ScriptFX.Reflection.TypeInfo(this, ScriptFX.Reflection.TypeInfoType.Class, entry.key);
                }
                else if (Type.isInterface(type)) {
                    typeInfo = new ScriptFX.Reflection.TypeInfo(this, ScriptFX.Reflection.TypeInfoType.Interface, entry.key);
                }
                else if (Type.isEnum(type)) {
                    if (Type.isFlagsEnum(type)) {
                        typeInfo = new ScriptFX.Reflection.TypeInfo(this, ScriptFX.Reflection.TypeInfoType.FlagsEnumeration, entry.key);
                    }
                    else {
                        typeInfo = new ScriptFX.Reflection.TypeInfo(this, ScriptFX.Reflection.TypeInfoType.Enumeration, entry.key);
                    }
                }
                if (typeInfo) {
                    typeInfo._initialize(type);
                    this._types.add(typeInfo);
                }
            }
        }
        return this._types;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.TypeInfo

ScriptFX.Reflection.TypeInfo = function ScriptFX_Reflection_TypeInfo(parent, typeType, name) {
    this._parent = parent;
    this._typeType = typeType;
    this._name = name;
}
ScriptFX.Reflection.TypeInfo.prototype = {
    _parent: null,
    _typeType: 0,
    _type: null,
    _name: null,
    
    get_baseType: function ScriptFX_Reflection_TypeInfo$get_baseType() {
        return null;
    },
    
    get_fullName: function ScriptFX_Reflection_TypeInfo$get_fullName() {
        if (this._parent) {
            return this._parent.get_name() + '.' + this.get_name();
        }
        return this.get_name();
    },
    
    get_interfaces: function ScriptFX_Reflection_TypeInfo$get_interfaces() {
        return null;
    },
    
    get_isGlobal: function ScriptFX_Reflection_TypeInfo$get_isGlobal() {
        return (!this._parent);
    },
    
    get_isPublic: function ScriptFX_Reflection_TypeInfo$get_isPublic() {
        return (!this._name.startsWith('_')) && (!this._name.startsWith('$'));
    },
    
    get_name: function ScriptFX_Reflection_TypeInfo$get_name() {
        return this._name;
    },
    
    get_typeType: function ScriptFX_Reflection_TypeInfo$get_typeType() {
        return this._typeType;
    },
    
    _initialize: function ScriptFX_Reflection_TypeInfo$_initialize(type) {
        this._type = type;
    }
}


ScriptFX.Reflection.ParameterInfo.createClass('ScriptFX.Reflection.ParameterInfo');
ScriptFX.Reflection.MemberInfo.createClass('ScriptFX.Reflection.MemberInfo');
ScriptFX.Reflection.FieldInfo.createClass('ScriptFX.Reflection.FieldInfo', ScriptFX.Reflection.MemberInfo);
ScriptFX.Reflection.Reflector.createClass('ScriptFX.Reflection.Reflector');
ScriptFX.Reflection.PropertyInfo.createClass('ScriptFX.Reflection.PropertyInfo', ScriptFX.Reflection.MemberInfo);
ScriptFX.Reflection.EventInfo.createClass('ScriptFX.Reflection.EventInfo', ScriptFX.Reflection.MemberInfo);
ScriptFX.Reflection.MethodInfo.createClass('ScriptFX.Reflection.MethodInfo', ScriptFX.Reflection.MemberInfo);
ScriptFX.Reflection.NamespaceInfo.createClass('ScriptFX.Reflection.NamespaceInfo');
ScriptFX.Reflection.TypeInfo.createClass('ScriptFX.Reflection.TypeInfo');
ScriptFX.Reflection.Reflector._globalTypes = null;
ScriptFX.Reflection.Reflector._namespaces = null;

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
// Script# Framework
// Copyright (c) 2007, Nikhil Kothari. All Rights Reserved.
// http://projects.nikhilk.net
//


Type.createNamespace('ScriptFX.UI');

////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.AutoCompleteOptions

ScriptFX.UI.$create_AutoCompleteOptions = function ScriptFX_UI_AutoCompleteOptions(service) {
    var $o = { };
    Debug.assert(!String.isNullOrEmpty(service), 'service parameter must not be empty.');
    $o.service = service;
    $o.id = null;
    $o.itemCount = 10;
    $o.itemLookupDelay = 500;
    $o.minimumPrefixLength = 3;
    $o.cssClass = 'autoComplete';
    $o.itemCSSClass = 'autoCompleteItem';
    $o.selectedItemCSSClass = 'autoCompleteSelectedItem';
    $o.xOffset = 0;
    $o.yOffset = 0;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.EnterKeyOptions

ScriptFX.UI.$create_EnterKeyOptions = function ScriptFX_UI_EnterKeyOptions(clickTarget) {
    var $o = { };
    Debug.assert(clickTarget);
    $o.clickTarget = clickTarget;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.WatermarkOptions

ScriptFX.UI.$create_WatermarkOptions = function ScriptFX_UI_WatermarkOptions(watermarkText, watermarkCssClass) {
    var $o = { };
    $o.watermarkText = watermarkText;
    $o.watermarkCssClass = watermarkCssClass;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.AutoCompleteBehavior

ScriptFX.UI.AutoCompleteBehavior = function ScriptFX_UI_AutoCompleteBehavior(domElement, options) {
    ScriptFX.UI.AutoCompleteBehavior.constructBase(this, [ domElement, options.id ]);
    this._options$1 = options;
    this._selectedItemIndex$1 = -1;
    domElement.autocomplete = 'off';
    var events = this.get_domEvents();
    events.attach('onfocus', Delegate.create(this, this._onTextBoxFocus$1));
    events.attach('onblur', Delegate.create(this, this._onTextBoxBlur$1));
    events.attach('onkeydown', Delegate.create(this, this._onTextBoxKeyDown$1));
}
ScriptFX.UI.AutoCompleteBehavior.prototype = {
    _options$1: null,
    _arguments$1: null,
    _dropDown$1: null,
    _dropDownPopup$1: null,
    _dropDownEvents$1: null,
    _dropDownVisible$1: false,
    _selectedItemIndex$1: 0,
    _itemCache$1: null,
    _timerID$1: 0,
    _currentPrefix$1: null,
    _itemRequest$1: null,
    
    get_arguments: function ScriptFX_UI_AutoCompleteBehavior$get_arguments() {
        if (!this._arguments$1) {
            this._arguments$1 = {};
        }
        return this._arguments$1;
    },
    
    add_itemDisplay: function ScriptFX_UI_AutoCompleteBehavior$add_itemDisplay(value) {
        this.get_events().addHandler('itemDisplay', value);
    },
    remove_itemDisplay: function ScriptFX_UI_AutoCompleteBehavior$remove_itemDisplay(value) {
        this.get_events().removeHandler('itemDisplay', value);
    },
    
    add_itemSelected: function ScriptFX_UI_AutoCompleteBehavior$add_itemSelected(value) {
        this.get_events().addHandler('itemSelected', value);
    },
    remove_itemSelected: function ScriptFX_UI_AutoCompleteBehavior$remove_itemSelected(value) {
        this.get_events().removeHandler('itemSelected', value);
    },
    
    add_requestingItems: function ScriptFX_UI_AutoCompleteBehavior$add_requestingItems(value) {
        this.get_events().addHandler('requestingItems', value);
    },
    remove_requestingItems: function ScriptFX_UI_AutoCompleteBehavior$remove_requestingItems(value) {
        this.get_events().removeHandler('requestingItems', value);
    },
    
    _abortRequest$1: function ScriptFX_UI_AutoCompleteBehavior$_abortRequest$1() {
        if (this._itemRequest$1) {
            this._itemRequest$1.abort();
            this._itemRequest$1 = null;
        }
    },
    
    clearCache: function ScriptFX_UI_AutoCompleteBehavior$clearCache() {
        this._itemCache$1 = null;
    },
    
    _createDropDown$1: function ScriptFX_UI_AutoCompleteBehavior$_createDropDown$1() {
        Debug.assert(!this._dropDown$1);
        this._dropDown$1 = document.createElement('DIV');
        if (this._options$1.cssClass) {
            this._dropDown$1.className = this._options$1.cssClass;
        }
        this._dropDown$1.unselectable = 'unselectable';
        document.body.appendChild(this._dropDown$1);
        this._dropDownEvents$1 = new ScriptFX.UI.DOMEventList(this._dropDown$1);
        this._dropDownEvents$1.attach('onmousedown', Delegate.create(this, this._onDropDownMouseDown$1));
        this._dropDownEvents$1.attach('onmouseup', Delegate.create(this, this._onDropDownMouseUp$1));
        this._dropDownEvents$1.attach('onmouseover', Delegate.create(this, this._onDropDownMouseOver$1));
        var options = ScriptFX.UI.$create_PopupOptions(this.get_domElement(), ScriptFX.UI.PopupMode.anchorBottomLeft);
        options.xOffset = this._options$1.xOffset;
        options.yOffset = -1 + this._options$1.yOffset;
        this._dropDownPopup$1 = new ScriptFX.UI.PopupBehavior(this._dropDown$1, options);
    },
    
    dispose: function ScriptFX_UI_AutoCompleteBehavior$dispose() {
        this._stopTimer$1();
        this._abortRequest$1();
        if (this._dropDown$1) {
            this._dropDownEvents$1.dispose();
            this._dropDownEvents$1 = null;
            this._dropDownPopup$1.dispose();
            this._dropDownPopup$1 = null;
            document.body.removeChild(this._dropDown$1);
            this._dropDown$1 = null;
            this._dropDownVisible$1 = false;
        }
        ScriptFX.UI.AutoCompleteBehavior.callBase(this, 'dispose');
    },
    
    _getDropDownItem$1: function ScriptFX_UI_AutoCompleteBehavior$_getDropDownItem$1(element) {
        while ((element) && (element !== this._dropDown$1)) {
            if (!isUndefined(element.__item)) {
                return element;
            }
            element = element.parentNode;
        }
        return null;
    },
    
    _hideDropDown$1: function ScriptFX_UI_AutoCompleteBehavior$_hideDropDown$1() {
        if (this._dropDownVisible$1) {
            this._dropDownVisible$1 = false;
            this._dropDownPopup$1.hide();
            this._selectedItemIndex$1 = -1;
        }
    },
    
    _highlightDropDownItem$1: function ScriptFX_UI_AutoCompleteBehavior$_highlightDropDownItem$1(itemElement) {
        if (this._options$1.selectedItemCSSClass) {
            ScriptFX.UI.Element.addCSSClass(itemElement, this._options$1.selectedItemCSSClass);
        }
    },
    
    _onDropDownMouseDown$1: function ScriptFX_UI_AutoCompleteBehavior$_onDropDownMouseDown$1() {
        var element = this._getDropDownItem$1(window.event.srcElement);
        if (element) {
            var item = element.__item;
            var index = element.__index;
            this._updateTextBox$1(item, index);
        }
    },
    
    _onDropDownMouseUp$1: function ScriptFX_UI_AutoCompleteBehavior$_onDropDownMouseUp$1() {
        this.get_domElement().focus();
    },
    
    _onDropDownMouseOver$1: function ScriptFX_UI_AutoCompleteBehavior$_onDropDownMouseOver$1() {
        var element = this._getDropDownItem$1(window.event.srcElement);
        if (this._selectedItemIndex$1 !== -1) {
            this._unhighlightItem$1(this._dropDown$1.childNodes[this._selectedItemIndex$1]);
            this._selectedItemIndex$1 = -1;
        }
        if (element) {
            var selectedItemIndex = element.__index;
            if (!isUndefined(this._selectedItemIndex$1)) {
                this._selectedItemIndex$1 = selectedItemIndex;
                this._highlightDropDownItem$1(element);
                return;
            }
        }
    },
    
    _onRequestComplete$1: function ScriptFX_UI_AutoCompleteBehavior$_onRequestComplete$1(request, context) {
        if ((request !== this._itemRequest$1) || (request.get_state() !== ScriptFX.Net.HTTPRequestState.completed) || (request.get_response().get_statusCode() !== ScriptFX.Net.HTTPStatusCode.OK)) {
            return;
        }
        var parameters = context;
        var prefixText = parameters['prefix'];
        var cacheKey = prefixText;
        if (this.get_events().getHandler('requestingItems')) {
            delete parameters.prefix;
            delete parameters.count;
            cacheKey += ScriptFX.JSON.serialize(parameters);
        }
        var items = request.get_response().getObject();
        this._updateDropDown$1(prefixText, items, cacheKey);
    },
    
    _onTextBoxBlur$1: function ScriptFX_UI_AutoCompleteBehavior$_onTextBoxBlur$1() {
        this._stopTimer$1();
        this._abortRequest$1();
        this._hideDropDown$1();
    },
    
    _onTextBoxFocus$1: function ScriptFX_UI_AutoCompleteBehavior$_onTextBoxFocus$1() {
        this._startTimer$1();
    },
    
    _onTextBoxKeyDown$1: function ScriptFX_UI_AutoCompleteBehavior$_onTextBoxKeyDown$1() {
        this._stopTimer$1();
        var e = window.event;
        if (this._dropDownVisible$1) {
            switch (e.keyCode) {
                case ScriptFX.UI.Key.escape:
                    this._hideDropDown$1();
                    e.returnValue = false;
                    break;
                case ScriptFX.UI.Key.up:
                    if (this._selectedItemIndex$1 > 0) {
                        this._unhighlightItem$1(this._dropDown$1.childNodes[this._selectedItemIndex$1]);
                        this._selectedItemIndex$1--;
                        this._highlightDropDownItem$1(this._dropDown$1.childNodes[this._selectedItemIndex$1]);
                    }
                    else if (this._selectedItemIndex$1 === -1) {
                        this._selectedItemIndex$1 = this._dropDown$1.childNodes.length - 1;
                        this._highlightDropDownItem$1(this._dropDown$1.childNodes[this._selectedItemIndex$1]);
                    }
                    e.returnValue = false;
                    break;
                case ScriptFX.UI.Key.down:
                    if (this._selectedItemIndex$1 < (this._dropDown$1.childNodes.length - 1)) {
                        if (this._selectedItemIndex$1 === -1) {
                            this._selectedItemIndex$1 = 0;
                        }
                        else {
                            this._unhighlightItem$1(this._dropDown$1.childNodes[this._selectedItemIndex$1]);
                            this._selectedItemIndex$1++;
                        }
                        this._highlightDropDownItem$1(this._dropDown$1.childNodes[this._selectedItemIndex$1]);
                    }
                    e.returnValue = false;
                    break;
                case ScriptFX.UI.Key.enter:
                    if (this._selectedItemIndex$1 !== -1) {
                        var item = this._dropDown$1.childNodes[this._selectedItemIndex$1].__item;
                        var index = this._dropDown$1.childNodes[this._selectedItemIndex$1].__index;
                        this._updateTextBox$1(item, index);
                    }
                    e.returnValue = false;
                    break;
            }
        }
        if (e.keyCode !== ScriptFX.UI.Key.tab) {
            this._startTimer$1();
        }
    },
    
    _onTimerTick$1: function ScriptFX_UI_AutoCompleteBehavior$_onTimerTick$1() {
        this._timerID$1 = 0;
        this._abortRequest$1();
        var text = (this.get_domElement()).value;
        if (text === this._currentPrefix$1) {
            return;
        }
        if (text.trim().length < this._options$1.minimumPrefixLength) {
            this._updateDropDown$1(null, null, null);
            return;
        }
        this._currentPrefix$1 = text;
        var requestHandler = this.get_events().getHandler('requestingItems');
        if (requestHandler) {
            var e = new ScriptFX.UI.AutoCompleteRequestEventArgs(text);
            requestHandler.invoke(this, e);
            var items = e.get__items();
            if (items) {
                this._updateDropDown$1(text, items, null);
                return;
            }
        }
        if (this._itemCache$1) {
            var cacheKey = text;
            if (this._arguments$1) {
                delete this._arguments$1.prefix;
                delete this._arguments$1.count;
                cacheKey += ScriptFX.JSON.serialize(this._arguments$1);
            }
            var items = this._itemCache$1[cacheKey];
            if (items) {
                this._updateDropDown$1(text, items, null);
                return;
            }
        }
        var parameters;
        if (this._arguments$1) {
            parameters = this._arguments$1;
        }
        else {
            parameters = {};
        }
        parameters['prefix'] = text;
        parameters['count'] = this._options$1.itemCount;
        this._itemRequest$1 = ScriptFX.Net.HTTPRequest.createRequest(ScriptFX.Net.HTTPRequest.createURI(this._options$1.service, parameters), ScriptFX.Net.HTTPVerb.GET);
        this._itemRequest$1.invoke(Delegate.create(this, this._onRequestComplete$1), parameters);
    },
    
    _showDropDown$1: function ScriptFX_UI_AutoCompleteBehavior$_showDropDown$1() {
        if (!this._dropDownVisible$1) {
            this._dropDownVisible$1 = true;
            this._dropDown$1.style.width = (this.get_domElement().offsetWidth - 2) + 'px';
            this._dropDownPopup$1.show();
        }
    },
    
    _startTimer$1: function ScriptFX_UI_AutoCompleteBehavior$_startTimer$1() {
        if (!this._timerID$1) {
            this._timerID$1 = window.setTimeout(Delegate.create(this, this._onTimerTick$1), this._options$1.itemLookupDelay);
        }
    },
    
    _stopTimer$1: function ScriptFX_UI_AutoCompleteBehavior$_stopTimer$1() {
        if (this._timerID$1) {
            window.clearTimeout(this._timerID$1);
            this._timerID$1 = 0;
        }
    },
    
    _unhighlightItem$1: function ScriptFX_UI_AutoCompleteBehavior$_unhighlightItem$1(itemElement) {
        if (this._options$1.selectedItemCSSClass) {
            ScriptFX.UI.Element.removeCSSClass(itemElement, this._options$1.selectedItemCSSClass);
        }
    },
    
    _updateDropDown$1: function ScriptFX_UI_AutoCompleteBehavior$_updateDropDown$1(prefixText, items, cacheKey) {
        var itemCount = 0;
        if (items) {
            itemCount = items.length;
        }
        if ((cacheKey) && (itemCount)) {
            if (!this._itemCache$1) {
                this._itemCache$1 = {};
            }
            this._itemCache$1[cacheKey] = items;
        }
        if (!this._dropDown$1) {
            this._createDropDown$1();
        }
        this._dropDown$1.innerHTML = '';
        this._selectedItemIndex$1 = -1;
        if (itemCount) {
            for (var i = 0; i < itemCount; i++) {
                var itemElement = document.createElement('DIV');
                if (this._options$1.itemCSSClass) {
                    itemElement.className = this._options$1.itemCSSClass;
                }
                var item = items[i];
                var text = item;
                var displayHandler = this.get_events().getHandler('itemDisplay');
                if (displayHandler) {
                    var e = new ScriptFX.UI.AutoCompleteItemEventArgs(item, i);
                    displayHandler.invoke(this, e);
                    text = e.get_text();
                    if (!text) {
                        text = item;
                    }
                }
                itemElement.innerHTML = text;
                itemElement.__index = i;
                itemElement.__item = items[i];
                this._dropDown$1.appendChild(itemElement);
            }
            this._showDropDown$1();
        }
        else {
            this._hideDropDown$1();
        }
    },
    
    _updateTextBox$1: function ScriptFX_UI_AutoCompleteBehavior$_updateTextBox$1(item, index) {
        this._stopTimer$1();
        this._hideDropDown$1();
        var text = null;
        var selectedHandler = this.get_events().getHandler('itemSelected');
        if (selectedHandler) {
            var e = new ScriptFX.UI.AutoCompleteItemEventArgs(item, index);
            selectedHandler.invoke(this, e);
            text = e.get_text();
        }
        if (!text) {
            text = item;
        }
        this._currentPrefix$1 = text;
        (this.get_domElement()).value = text;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.AutoCompleteItemEventArgs

ScriptFX.UI.AutoCompleteItemEventArgs = function ScriptFX_UI_AutoCompleteItemEventArgs(item, index) {
    ScriptFX.UI.AutoCompleteItemEventArgs.constructBase(this);
    this._item$1 = item;
    this._index$1 = index;
}
ScriptFX.UI.AutoCompleteItemEventArgs.prototype = {
    _item$1: null,
    _index$1: 0,
    _text$1: null,
    
    get_index: function ScriptFX_UI_AutoCompleteItemEventArgs$get_index() {
        return this._index$1;
    },
    
    get_item: function ScriptFX_UI_AutoCompleteItemEventArgs$get_item() {
        return this._item$1;
    },
    
    get_text: function ScriptFX_UI_AutoCompleteItemEventArgs$get_text() {
        return this._text$1;
    },
    set_text: function ScriptFX_UI_AutoCompleteItemEventArgs$set_text(value) {
        this._text$1 = value;
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.AutoCompleteRequestEventArgs

ScriptFX.UI.AutoCompleteRequestEventArgs = function ScriptFX_UI_AutoCompleteRequestEventArgs(prefixText) {
    ScriptFX.UI.AutoCompleteRequestEventArgs.constructBase(this);
    this._prefixText$1 = prefixText;
}
ScriptFX.UI.AutoCompleteRequestEventArgs.prototype = {
    _prefixText$1: null,
    _items$1: null,
    
    get__items: function ScriptFX_UI_AutoCompleteRequestEventArgs$get__items() {
        return this._items$1;
    },
    
    get_prefixText: function ScriptFX_UI_AutoCompleteRequestEventArgs$get_prefixText() {
        return this._prefixText$1;
    },
    
    setItems: function ScriptFX_UI_AutoCompleteRequestEventArgs$setItems(items) {
        this._items$1 = items;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Button

ScriptFX.UI.Button = function ScriptFX_UI_Button(domElement) {
    ScriptFX.UI.Button.constructBase(this, [ domElement ]);
    this.get_domEvents().attach('onclick', Delegate.create(this, this._onClick$2));
}
ScriptFX.UI.Button.prototype = {
    _actionArgument$2: null,
    _actionName$2: null,
    
    get_actionArgument: function ScriptFX_UI_Button$get_actionArgument() {
        return this._actionArgument$2;
    },
    set_actionArgument: function ScriptFX_UI_Button$set_actionArgument(value) {
        this._actionArgument$2 = value;
        return value;
    },
    
    get_actionName: function ScriptFX_UI_Button$get_actionName() {
        return this._actionName$2;
    },
    set_actionName: function ScriptFX_UI_Button$set_actionName(value) {
        this._actionName$2 = value;
        return value;
    },
    
    add_action: function ScriptFX_UI_Button$add_action(value) {
        this.get_events().addHandler(ScriptFX.UI.Button._clickEventKey$2, value);
    },
    remove_action: function ScriptFX_UI_Button$remove_action(value) {
        this.get_events().removeHandler(ScriptFX.UI.Button._clickEventKey$2, value);
    },
    
    add_click: function ScriptFX_UI_Button$add_click(value) {
        this.get_events().addHandler(ScriptFX.UI.Button._clickEventKey$2, value);
    },
    remove_click: function ScriptFX_UI_Button$remove_click(value) {
        this.get_events().removeHandler(ScriptFX.UI.Button._clickEventKey$2, value);
    },
    
    _onClick$2: function ScriptFX_UI_Button$_onClick$2() {
        var clickHandler = this.get_events().getHandler(ScriptFX.UI.Button._clickEventKey$2);
        if (clickHandler) {
            clickHandler.invoke(this, EventArgs.Empty);
        }
    },
    
    performClick: function ScriptFX_UI_Button$performClick() {
        this._onClick$2();
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.CheckBox

ScriptFX.UI.CheckBox = function ScriptFX_UI_CheckBox(domElement) {
    ScriptFX.UI.CheckBox.constructBase(this, [ domElement ]);
    this.get_domEvents().attach('onclick', Delegate.create(this, this._onClick$2));
}
ScriptFX.UI.CheckBox.prototype = {
    
    get_checked: function ScriptFX_UI_CheckBox$get_checked() {
        return (this.get_domElement()).checked;
    },
    set_checked: function ScriptFX_UI_CheckBox$set_checked(value) {
        (this.get_domElement()).checked = value;
        return value;
    },
    
    add_checkedChanged: function ScriptFX_UI_CheckBox$add_checkedChanged(value) {
        this.get_events().addHandler(ScriptFX.UI.CheckBox._checkChangedEventKey$2, value);
    },
    remove_checkedChanged: function ScriptFX_UI_CheckBox$remove_checkedChanged(value) {
        this.get_events().removeHandler(ScriptFX.UI.CheckBox._checkChangedEventKey$2, value);
    },
    
    _onClick$2: function ScriptFX_UI_CheckBox$_onClick$2() {
        var checkChangedHandler = this.get_events().getHandler(ScriptFX.UI.CheckBox._checkChangedEventKey$2);
        if (checkChangedHandler) {
            checkChangedHandler.invoke(this, EventArgs.Empty);
        }
        this.raisePropertyChanged('Checked');
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.EnterKeyBehavior

ScriptFX.UI.EnterKeyBehavior = function ScriptFX_UI_EnterKeyBehavior(element, options) {
    ScriptFX.UI.EnterKeyBehavior.constructBase(this, [ element, null ]);
    this._clickTarget$1 = options.clickTarget;
    this.get_domEvents().attach('onkeypress', Delegate.create(this, this._onElementKeyPress$1));
}
ScriptFX.UI.EnterKeyBehavior.prototype = {
    _clickTarget$1: null,
    
    _onElementKeyPress$1: function ScriptFX_UI_EnterKeyBehavior$_onElementKeyPress$1() {
        if ((window.event.keyCode === ScriptFX.UI.Key.enter) && (!this._clickTarget$1.disabled)) {
            window.event.cancelBubble = true;
            window.event.returnValue = false;
            this._clickTarget$1.click();
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Label

ScriptFX.UI.Label = function ScriptFX_UI_Label(domElement) {
    ScriptFX.UI.Label.constructBase(this, [ domElement ]);
}
ScriptFX.UI.Label.prototype = {
    
    get_text: function ScriptFX_UI_Label$get_text() {
        return this.get_domElement().innerText;
    },
    set_text: function ScriptFX_UI_Label$set_text(value) {
        this.get_domElement().innerText = value;
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.TextBox

ScriptFX.UI.TextBox = function ScriptFX_UI_TextBox(domElement) {
    ScriptFX.UI.TextBox.constructBase(this, [ domElement ]);
    this.get_domEvents().attach('onchange', Delegate.create(this, this._onValueChanged$2));
}
ScriptFX.UI.TextBox.prototype = {
    
    get_text: function ScriptFX_UI_TextBox$get_text() {
        var watermark = ScriptFX.UI.Behavior.getBehavior(this.get_domElement(), ScriptFX.UI.WatermarkBehavior);
        if ((watermark) && watermark.get_isWatermarked()) {
            return String.Empty;
        }
        return (this.get_domElement()).value;
    },
    set_text: function ScriptFX_UI_TextBox$set_text(value) {
        (this.get_domElement()).value = value;
        this._onValueChanged$2();
        return value;
    },
    
    add_textChanged: function ScriptFX_UI_TextBox$add_textChanged(value) {
        this.get_events().addHandler(ScriptFX.UI.TextBox._textChangedEventKey$2, value);
    },
    remove_textChanged: function ScriptFX_UI_TextBox$remove_textChanged(value) {
        this.get_events().removeHandler(ScriptFX.UI.TextBox._textChangedEventKey$2, value);
    },
    
    _onValueChanged$2: function ScriptFX_UI_TextBox$_onValueChanged$2() {
        var textChangedHandler = this.get_events().getHandler(ScriptFX.UI.TextBox._textChangedEventKey$2);
        if (textChangedHandler) {
            textChangedHandler.invoke(this, EventArgs.Empty);
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.WatermarkBehavior

ScriptFX.UI.WatermarkBehavior = function ScriptFX_UI_WatermarkBehavior(element, options) {
    ScriptFX.UI.WatermarkBehavior.constructBase(this, [ element, null ]);
    this._options$1 = options;
    this.get_domEvents().attach('onfocus', Delegate.create(this, this._onElementFocus$1));
    this.get_domEvents().attach('onblur', Delegate.create(this, this._onElementBlur$1));
    this.update();
}
ScriptFX.UI.WatermarkBehavior.prototype = {
    _options$1: null,
    _maxLength$1: 0,
    
    get_isWatermarked: function ScriptFX_UI_WatermarkBehavior$get_isWatermarked() {
        return ScriptFX.UI.Element.containsCSSClass(this.get_domElement(), this._options$1.watermarkCssClass);
    },
    
    _applyWatermark$1: function ScriptFX_UI_WatermarkBehavior$_applyWatermark$1() {
        var element = this.get_domElement();
        if (!element.value.length) {
            this._maxLength$1 = element.maxLength;
            element.maxLength = this._options$1.watermarkText.length;
            ScriptFX.UI.Element.addCSSClass(element, this._options$1.watermarkCssClass);
            element.value = this._options$1.watermarkText;
        }
    },
    
    _clearWatermark$1: function ScriptFX_UI_WatermarkBehavior$_clearWatermark$1(focusing) {
        var element = this.get_domElement();
        if (ScriptFX.UI.Element.containsCSSClass(element, this._options$1.watermarkCssClass)) {
            element.maxLength = this._maxLength$1;
            ScriptFX.UI.Element.removeCSSClass(element, this._options$1.watermarkCssClass);
            if (focusing) {
                element.value = '';
            }
        }
    },
    
    dispose: function ScriptFX_UI_WatermarkBehavior$dispose() {
        if (!this.get_isDisposed()) {
            this._clearWatermark$1(false);
        }
        ScriptFX.UI.WatermarkBehavior.callBase(this, 'dispose');
    },
    
    _onElementFocus$1: function ScriptFX_UI_WatermarkBehavior$_onElementFocus$1() {
        this._clearWatermark$1(true);
    },
    
    _onElementBlur$1: function ScriptFX_UI_WatermarkBehavior$_onElementBlur$1() {
        this._applyWatermark$1();
    },
    
    update: function ScriptFX_UI_WatermarkBehavior$update() {
        var element = this.get_domElement();
        if (!element.value.length) {
            this._applyWatermark$1();
        }
        else {
            this._clearWatermark$1(false);
        }
    }
}


ScriptFX.UI.AutoCompleteBehavior.createClass('ScriptFX.UI.AutoCompleteBehavior', ScriptFX.UI.Behavior);
ScriptFX.UI.AutoCompleteItemEventArgs.createClass('ScriptFX.UI.AutoCompleteItemEventArgs', EventArgs);
ScriptFX.UI.AutoCompleteRequestEventArgs.createClass('ScriptFX.UI.AutoCompleteRequestEventArgs', EventArgs);
ScriptFX.UI.Button.createClass('ScriptFX.UI.Button', ScriptFX.UI.Control, ScriptFX.UI.IAction);
ScriptFX.UI.CheckBox.createClass('ScriptFX.UI.CheckBox', ScriptFX.UI.Control, ScriptFX.UI.IToggle);
ScriptFX.UI.EnterKeyBehavior.createClass('ScriptFX.UI.EnterKeyBehavior', ScriptFX.UI.Behavior);
ScriptFX.UI.Label.createClass('ScriptFX.UI.Label', ScriptFX.UI.Control, ScriptFX.UI.IStaticText);
ScriptFX.UI.TextBox.createClass('ScriptFX.UI.TextBox', ScriptFX.UI.Control, ScriptFX.UI.IEditableText);
ScriptFX.UI.WatermarkBehavior.createClass('ScriptFX.UI.WatermarkBehavior', ScriptFX.UI.Behavior);
ScriptFX.UI.Button._clickEventKey$2 = 'click';
ScriptFX.UI.CheckBox._checkChangedEventKey$2 = 'checkChanged';
ScriptFX.UI.TextBox._textChangedEventKey$2 = 'textChanged';

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
// Script# Framework
// Copyright (c) 2007, Nikhil Kothari. All Rights Reserved.
// http://projects.nikhilk.net
//


Type.createNamespace('ScriptFX.Net');

////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net._scriptResponse

ScriptFX.Net._scriptResponse = function ScriptFX_Net__scriptResponse(request, data) {
    this._timeStamp = new Date();
    this._request = request;
    this._data = data;
}
ScriptFX.Net._scriptResponse.prototype = {
    _request: null,
    _timeStamp: null,
    _data: null,
    _xml: null,
    
    get_contentLength: function ScriptFX_Net__scriptResponse$get_contentLength() {
        return 0;
    },
    
    get_contentType: function ScriptFX_Net__scriptResponse$get_contentType() {
        return 'text/javascript';
    },
    
    get_headers: function ScriptFX_Net__scriptResponse$get_headers() {
        return {};
    },
    
    get_request: function ScriptFX_Net__scriptResponse$get_request() {
        return this._request;
    },
    
    get_statusCode: function ScriptFX_Net__scriptResponse$get_statusCode() {
        return ScriptFX.Net.HTTPStatusCode.OK;
    },
    
    get_statusText: function ScriptFX_Net__scriptResponse$get_statusText() {
        return String.Empty;
    },
    
    get_timeStamp: function ScriptFX_Net__scriptResponse$get_timeStamp() {
        return this._timeStamp;
    },
    
    getHeader: function ScriptFX_Net__scriptResponse$getHeader(name) {
        return null;
    },
    
    getObject: function ScriptFX_Net__scriptResponse$getObject() {
        return this._data;
    },
    
    getText: function ScriptFX_Net__scriptResponse$getText() {
        return Type.safeCast(this._data, String);
    },
    
    getXML: function ScriptFX_Net__scriptResponse$getXML() {
        if (!this._xml) {
            var text = this.getText();
            if (text) {
                try {
                    this._xml = XMLDocumentParser.parse(text);
                }
                catch ($e1) {
                }
            }
        }
        return this._xml;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.ScriptTransport

ScriptFX.Net.ScriptTransport = function ScriptFX_Net_ScriptTransport(request) {
    ScriptFX.Net.ScriptTransport.constructBase(this, [ request ]);
}
ScriptFX.Net.ScriptTransport.prototype = {
    _scriptElement$1: null,
    _callbackExport$1: null,
    
    abort: function ScriptFX_Net_ScriptTransport$abort() {
        if (this._callbackExport$1) {
            Delegate.clearExport(this._callbackExport$1);
            this._callbackExport$1 = null;
        }
        if (this._scriptElement$1) {
            document.body.removeChild(this._scriptElement$1);
            this._scriptElement$1 = null;
        }
    },
    
    dispose: function ScriptFX_Net_ScriptTransport$dispose() {
        this.abort();
    },
    
    invoke: function ScriptFX_Net_ScriptTransport$invoke() {
        Debug.assert(this.getMethod() === 'GET');
        Debug.assert(!this.get_request().get_hasHeaders());
        Debug.assert(!this.get_request().get_hasCredentials());
        var callbackParam = null;
        var parameters = this.get_parameters();
        if (parameters) {
            callbackParam = parameters['callbackParameterName'];
        }
        if (!callbackParam) {
            callbackParam = 'callback';
        }
        var callback = Delegate.create(this, this._onDataAvailable$1);
        this._callbackExport$1 = Delegate.createExport(callback);
        var callbackCode = callbackParam + '=Delegate.' + this._callbackExport$1;
        var url = this.get_request().get_URI();
        if (url.indexOf('?') >= 0) {
            url += '&' + callbackCode;
        }
        else {
            url += '?' + callbackCode;
        }
        this._scriptElement$1 = document.createElement('SCRIPT');
        this._scriptElement$1.type = 'text/javascript';
        this._scriptElement$1.src = url;
        document.body.appendChild(this._scriptElement$1);
    },
    
    _onDataAvailable$1: function ScriptFX_Net_ScriptTransport$_onDataAvailable$1(data) {
        if (this._scriptElement$1) {
            document.body.removeChild(this._scriptElement$1);
            this._scriptElement$1 = null;
            this._callbackExport$1 = null;
            this.onCompleted(new ScriptFX.Net._scriptResponse(this.get_request(), data));
        }
    }
}


ScriptFX.Net._scriptResponse.createClass('ScriptFX.Net._scriptResponse', null, ScriptFX.Net.IHTTPResponse);
ScriptFX.Net.ScriptTransport.createClass('ScriptFX.Net.ScriptTransport', ScriptFX.Net.HTTPTransport);

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
Type.createNamespace('Framework');

Framework.XMLUtils = function() {
}

Framework.XMLUtils.prototype = {
	_emptyContentDocument : null
}

Framework.XMLUtils.transformAndUpdateFirefox = function XMLUtils$transformAndUpdateFirefox(contentDocument, xsltDocument, parametersMap, domElementId, domElement, inMemoryProcessingCallback) {
	var xsltProcessor = new XSLTProcessor();
	for (var parameterName in parametersMap)
		if (parameterName != null && parametersMap[parameterName] != null)
			xsltProcessor.setParameter("", parameterName, parametersMap[parameterName]);
	xsltProcessor.importStylesheet(xsltDocument);
	var resultFragment = xsltProcessor.transformToFragment(contentDocument, document);
	var placeHolder = (domElement == null) ? $(domElementId) : domElement;
	
	if (placeHolder != null) {
	    // create garbage collector
		var GCid = 'GarbageCollector';
		if(document.getElementById(GCid) == null)
		{
			var GC = document.createElement("div");
			GC.setAttribute('id',GCid);
			GC.style.display = 'none';
			window.document.body.appendChild(GC);
		}
		var GC = document.getElementById(GCid);
		
	    // put new content into memory
		var newContent = document.createElement("div");
		GC.appendChild(newContent);
		newContent.appendChild(resultFragment);
		
		// execute in memory callback
		if(inMemoryProcessingCallback != null)
		    inMemoryProcessingCallback(newContent);
		
		// move old content away
		var oldContent = document.createElement("div");
		GC.appendChild(oldContent);
		while(placeHolder.childNodes.length)
			oldContent.appendChild(placeHolder.childNodes[0]);
		
		// add new content to screen
		while(newContent.childNodes.length)
			placeHolder.appendChild(newContent.childNodes[0]);
		
		// remove behaviors	from old content
		Framework.DocumentBehaviors.purgeBehaviors(oldContent, true, 0);
		
		GC.innerHTML = '';
		
		oldContent = null;
		newContent = null;	
	}
}

Framework.XMLUtils.transformAndUpdateInternetExplorer = function XMLUtils$transformAndUpdateInternetExplorer(contentDocument, xsltDocument, parametersMap, domElementId, domElement, inMemoryProcessingCallback) {
	var freeThreadedXsltDocument = new ActiveXObject("MSXML2.FreeThreadedDOMDocument");
	freeThreadedXsltDocument.loadXML(xsltDocument.xml);
	var cache = new ActiveXObject("MSXML2.XSLTemplate");
	cache.stylesheet = freeThreadedXsltDocument;
	var processor = cache.createProcessor();
	for (var parameterName in parametersMap)
		if (parameterName != null && parametersMap[parameterName] != null)
			processor.addParameter(parameterName, parametersMap[parameterName]);
	processor.input = contentDocument;
	processor.transform();
	
	var placeHolder = (domElement == null) ? $(domElementId) : domElement;
	if (placeHolder != null)
	{
		// create garbage collector
		var GCid = 'GarbageCollector';
		if(document.getElementById(GCid) == null)
		{
			var GC = document.createElement("div");
			GC.setAttribute('id',GCid);
			GC.style.display = 'none';
			window.document.body.appendChild(GC);
		}
		var GC = document.getElementById(GCid);
		
		// put new content into memory
		var newContent = document.createElement("div");
		GC.appendChild(newContent);
		newContent.innerHTML = processor.output;
		
		// execute in memory callback
		if(inMemoryProcessingCallback != null)
		    inMemoryProcessingCallback(newContent);
		
		// move old content to GC bin
		var oldContent = document.createElement("div");
		GC.appendChild(oldContent);
		while(placeHolder.childNodes.length)
			oldContent.appendChild(placeHolder.childNodes[0]);
		
		// add new content to screen
		while(newContent.childNodes.length)
			placeHolder.appendChild(newContent.childNodes[0]);
		
		// remove behaviors	
		Framework.DocumentBehaviors.purgeBehaviors(oldContent, true, 0);
		
		GC.innerHTML = '';
		
		oldContent = null;
		newContent = null;
	}
}

Framework.XMLUtils.transformAndUpdate = function XMLUtils$transformAndUpdate(contentDocument, xsltDocument, parametersMap, domElementId, domElement, inMemoryProcessingCallback) {
	if (document.implementation && document.implementation.createDocument)
		this.transformAndUpdateFirefox(contentDocument, xsltDocument, parametersMap, domElementId, domElement, inMemoryProcessingCallback);
	else
		this.transformAndUpdateInternetExplorer(contentDocument, xsltDocument, parametersMap, domElementId, domElement, inMemoryProcessingCallback);
}

/*
Framework.XMLUtils.transformAndUpdateWithInMemoryProcessing = function XMLUtils$transformAndUpdateWithInMemoryProcessing(contentDocument, xsltDocument, parametersMap, domElement, callback) {
	if (document.implementation && document.implementation.createDocument)
		this.transformAndUpdateFirefoxWithInMemoryProcessing(contentDocument, xsltDocument, parametersMap, domElement, callback);
	else
		this.transformAndUpdateInternetExplorerWithInMemoryProcessing(contentDocument, xsltDocument, parametersMap, domElement, callback);
}

Framework.XMLUtils.transformAndUpdateFirefoxWithInMemoryProcessing = function XMLUtils$transformAndUpdateFirefoxWithInMemoryProcessing(contentDocument, xsltDocument, parametersMap, domElement, callback) {
	var xsltProcessor = new XSLTProcessor();
	for (var parameterName in parametersMap)
		if (parameterName != null && parametersMap[parameterName] != null)
			xsltProcessor.setParameter("", parameterName, parametersMap[parameterName]);
	xsltProcessor.importStylesheet(xsltDocument);
	var resultFragment = xsltProcessor.transformToFragment(contentDocument, document);
	var placeHolder = domElement;
	if (placeHolder != null) 
	{
	    // put new content into memory
		var newContent = document.createElement("div");
		newContent.appendChild(resultFragment);
		
		// add handlers
		if(callback != null)
		    callback(newContent);
		
		// move old content away
		var oldContent = document.createElement("div");
		while(placeHolder.childNodes.length)
			oldContent.appendChild(placeHolder.childNodes[0]);
		
		// add new content to screen
		while(newContent.childNodes.length)
			placeHolder.appendChild(newContent.childNodes[0]);
		
		// remove behaviors	from old content
		Framework.DocumentBehaviors.purgeBehaviors(oldContent, true, 0);
		
		oldContent = null;
		newContent = null;	
	}
}

Framework.XMLUtils.transformAndUpdateInternetExplorerWithInMemoryProcessing = function XMLUtils$transformAndUpdateInternetExplorerWithInMemoryProcessing(contentDocument, xsltDocument, parametersMap, domElement, callback) {
	var freeThreadedXsltDocument = new ActiveXObject("MSXML2.FreeThreadedDOMDocument");
	freeThreadedXsltDocument.loadXML(xsltDocument.xml);
	var cache = new ActiveXObject("MSXML2.XSLTemplate");
	cache.stylesheet = freeThreadedXsltDocument;
	var processor = cache.createProcessor();
	for (var parameterName in parametersMap)
		if (parameterName != null && parametersMap[parameterName] != null)
			processor.addParameter(parameterName, parametersMap[parameterName]);
	processor.input = contentDocument;
	
	processor.transform();
	
	var placeHolder = domElement;
	if (placeHolder)
	{
		// put new content into memory
		var newContent = document.createElement("div");
		newContent.innerHTML = processor.output;
		
		// add handlers
		if(callback != null)
		    callback(newContent);
		
		// move old content to GC bin
		var oldContent = document.createElement("div");
		while(placeHolder.childNodes.length)
			oldContent.appendChild(placeHolder.childNodes[0]);
		
		// add new content to screen
		while(newContent.childNodes.length)
			placeHolder.appendChild(newContent.childNodes[0]);
		
		// remove behaviors	
		Framework.DocumentBehaviors.purgeBehaviors(oldContent, true, 0);
		
		oldContent = null;
		newContent = null;
    }
    placeHolder = null;
}
*/


Framework.XMLUtils.get_emptyContentDocument = function XMLUtils$get_emptyContentDocument() {
	if (!this._emptyContentDocument)
		if (document.implementation && document.implementation.createDocument)
			this._emptyContentDocument = document.implementation.createDocument("", "no-content", null); 
		else {
			this._emptyContentDocument = new ActiveXObject("MSXML2.FreeThreadedDOMDocument");
			this._emptyContentDocument.loadXML("<no-content />");
		}
	return this._emptyContentDocument;
}

//////////
/*
    The global object JSON contains two methods.

    JSON.stringify(value) takes a JavaScript value and produces a JSON text.
    The value must not be cyclical.

    JSON.parse(text) takes a JSON text and produces a JavaScript value. It will
    return false if there is an error.
*/
var JSON1 = function () {
    var m = {
            '\b': '\\b',
            '\t': '\\t',
            '\n': '\\n',
            '\f': '\\f',
            '\r': '\\r',
            '"' : '\\"',
            '\\': '\\\\'
        },
        s = {
            'boolean': function (x) {
                return String(x);
            },
            number: function (x) {
                return isFinite(x) ? String(x) : 'null';
            },
            string: function (x) {
                if (/["\\\x00-\x1f]/.test(x)) {
                    x = x.replace(/([\x00-\x1f\\"])/g, function(a, b) {
                        var c = m[b];
                        if (c) {
                            return c;
                        }
                        c = b.charCodeAt();
                        return '\\u00' +
                            Math.floor(c / 16).toString(16) +
                            (c % 16).toString(16);
                    });
                }
                return '"' + x + '"';
            },
            object: function (x) {
                if (x) {
                    var a = [], b, f, i, l, v;
                    if (x instanceof Array) {
                        a[0] = '[';
                        l = x.length;
                        for (i = 0; i < l; i += 1) {
                            v = x[i];
                            f = s[typeof v];
                            if (f) {
                                v = f(v);
                                if (typeof v == 'string') {
                                    if (b) {
                                        a[a.length] = ',';
                                    }
                                    a[a.length] = v;
                                    b = true;
                                }
                            }
                        }
                        a[a.length] = ']';
                    } else if (x instanceof Object) {
                        a[0] = '{';
                        for (i in x) {
                            v = x[i];
                            f = s[typeof v];
                            if (f) {
                                v = f(v);
                                if (typeof v == 'string') {
                                    if (b) {
                                        a[a.length] = ',';
                                    }
                                    a.push(s.string(i), ':', v);
                                    b = true;
                                }
                            }
                        }
                        a[a.length] = '}';
                    } else {
                        return;
                    }
                    return a.join('');
                }
                return 'null';
            }
        };
    return {
        copyright: '(c)2005 JSON.org',
        license: 'http://www.crockford.com/JSON/license.html',
/*
    Stringify a JavaScript value, producing a JSON text.
*/
        stringify: function (v) {
            var f = s[typeof v];
            if (f) {
                v = f(v);
                if (typeof v == 'string') {
                    return v;
                }
            }
            return null;
        },
/*
    Parse a JSON text, producing a JavaScript value.
    It returns false if there is a syntax error.
*/
        eval: function (text) {
            try {
                return !(/[^,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]/.test(
                        text.replace(/"(\\.|[^"\\])*"/g, ''))) &&
                    eval('(' + text + ')');
            } catch (e) {
                return false;
            }
        },

        parse: function (text) {
            var at = 0;
            var ch = ' ';

            function error(m) {
                throw {
                    name: 'JSONError',
                    message: m,
                    at: at - 1,
                    text: text
                };
            }

            function next() {
                ch = text.charAt(at);
                at += 1;
                return ch;
            }

            function white() {
                while (ch) {
                    if (ch <= ' ') {
                        next();
                    } else if (ch == '/') {
                        switch (next()) {
                            case '/':
                                while (next() && ch != '\n' && ch != '\r') {}
                                break;
                            case '*':
                                next();
                                for (;;) {
                                    if (ch) {
                                        if (ch == '*') {
                                            if (next() == '/') {
                                                next();
                                                break;
                                            }
                                        } else {
                                            next();
                                        }
                                    } else {
                                        error("Unterminated comment");
                                    }
                                }
                                break;
                            default:
                                error("Syntax error");
                        }
                    } else {
                        break;
                    }
                }
            }

            function string() {
                var i, s = '', t, u;

                if (ch == '"') {
    outer:          while (next()) {
                        if (ch == '"') {
                            next();
                            return s;
                        } else if (ch == '\\') {
                            switch (next()) {
                            case 'b':
                                s += '\b';
                                break;
                            case 'f':
                                s += '\f';
                                break;
                            case 'n':
                                s += '\n';
                                break;
                            case 'r':
                                s += '\r';
                                break;
                            case 't':
                                s += '\t';
                                break;
                            case 'u':
                                u = 0;
                                for (i = 0; i < 4; i += 1) {
                                    t = parseInt(next(), 16);
                                    if (!isFinite(t)) {
                                        break outer;
                                    }
                                    u = u * 16 + t;
                                }
                                s += String.fromCharCode(u);
                                break;
                            default:
                                s += ch;
                            }
                        } else {
                            s += ch;
                        }
                    }
                }
                error("Bad string");
            }

            function array() {
                var a = [];

                if (ch == '[') {
                    next();
                    white();
                    if (ch == ']') {
                        next();
                        return a;
                    }
                    while (ch) {
                        a.push(value());
                        white();
                        if (ch == ']') {
                            next();
                            return a;
                        } else if (ch != ',') {
                            break;
                        }
                        next();
                        white();
                    }
                }
                error("Bad array");
            }

            function object() {
                var k, o = {};

                if (ch == '{') {
                    next();
                    white();
                    if (ch == '}') {
                        next();
                        return o;
                    }
                    while (ch) {
                        k = string();
                        white();
                        if (ch != ':') {
                            break;
                        }
                        next();
                        o[k] = value();
                        white();
                        if (ch == '}') {
                            next();
                            return o;
                        } else if (ch != ',') {
                            break;
                        }
                        next();
                        white();
                    }
                }
                error("Bad object");
            }

            function number() {
                var n = '', v;
                if (ch == '-') {
                    n = '-';
                    next();
                }
                while (ch >= '0' && ch <= '9') {
                    n += ch;
                    next();
                }
                if (ch == '.') {
                    n += '.';
                    while (next() && ch >= '0' && ch <= '9') {
                        n += ch;
                    }
                }
                if (ch == 'e' || ch == 'E') {
                    n += 'e';
                    next();
                    if (ch == '-' || ch == '+') {
                        n += ch;
                        next();
                    }
                    while (ch >= '0' && ch <= '9') {
                        n += ch;
                        next();
                    }
                }
                v = +n;
                if (!isFinite(v)) {
                    ////error("Bad number");
                } else {
                    return v;
                }
            }

            function word() {
                switch (ch) {
                    case 't':
                        if (next() == 'r' && next() == 'u' && next() == 'e') {
                            next();
                            return true;
                        }
                        break;
                    case 'f':
                        if (next() == 'a' && next() == 'l' && next() == 's' &&
                                next() == 'e') {
                            next();
                            return false;
                        }
                        break;
                    case 'n':
                        if (next() == 'u' && next() == 'l' && next() == 'l') {
                            next();
                            return null;
                        }
                        break;
                }
                error("Syntax error");
            }

            function value() {
                white();
                switch (ch) {
                    case '{':
                        return object();
                    case '[':
                        return array();
                    case '"':
                        return string();
                    case '-':
                        return number();
                    default:
                        return ch >= '0' && ch <= '9' ? number() : word();
                }
            }

            return value();
        }
    };
}();

Framework.JsonUtil = function() {
}

Framework.JsonUtil.serialize = function serialize(value) {
	return JSON1.stringify(value);
}

Framework.JsonUtil.deserialize = function deserialize(text) {
	return JSON1.parse(text);
}

Framework.DocumentEvents = function() {
}

Framework.DocumentEvents.setOnMousemove = function(handler){
	document.onmousemove	= handler;
}

Framework.DocumentEvents.setOnMouseup = function(handler){
	document.onmouseup	= handler;
}

Framework.DocumentEvents.parse = function(handler) {
	return handler;
}

Framework.DocumentEvents.purgeEventsBeforeUpdate = function(d,ignoreRootElement, recursionCount) {
	if (recursionCount > 100)
		return;
		
	var index1;
	if(!ignoreRootElement)
	{
	    var behaviors = ScriptFX.UI.Behavior.getBehaviors(d, null);
	    if(behaviors)
	    {
	        for (index1 = 0; index1 < behaviors.length; index1++)
	        {
	            behaviors[index1].dispose();
            }
	    }
	}
		
	var i;
	if (!ignoreRootElement && d.attributes)
		for (i = 0; i < d.attributes.length; i++)
		try {
			if (typeof d[d.attributes[i].name] === 'function')
				d[d.attributes[i].name] = null;
		} catch(e){
			alert(e + 'Please contact customer support!');
		}
	var i;
	if (d.childNodes)
		for (i = 0; i < d.childNodes.length; i++)
			Framework.DocumentEvents.purgeEventsBeforeUpdate(d.childNodes[i], false, recursionCount + 1);
}

Framework.DocumentBehaviors = function() {
}

// Remove behaviors from all DOM elements recursively
Framework.DocumentBehaviors.purgeBehaviors = function(d,ignoreRootElement, recursionCount) {
	if (recursionCount > 100)
		return;
	
	var index1;
	if(!ignoreRootElement)
	{
	    var behaviors = ScriptFX.UI.Behavior.getBehaviors(d, null);
	    if(behaviors)
	    {
	        for (index1 = 0; index1 < behaviors.length; index1++)
	        {
	            behaviors[index1].dispose();
            }
	    }
	}
	
	var index2;
	if (d.childNodes)
	{
		for (index2 = 0; index2 < d.childNodes.length; index2++)
			Framework.DocumentBehaviors.purgeBehaviors(d.childNodes[index2], false, recursionCount + 1);
	}
}


Type.createNamespace('Framework.Behavior');

Framework.Behavior.ParametersObjectBuilder = function() {
}

Framework.Behavior.ParametersObjectBuilder.build = function(domElement, behaviorID) {
	if (domElement.attributes == null)
	    return null;
	
	var pattern = new RegExp("^behavior." + behaviorID + ".","i");
	var parameters = new Array();
	var i;
	for (i = 0; i < domElement.attributes.length; i++)
    {
        var attname = domElement.attributes[i].name;
        
        if(attname.search(pattern) == -1)
            continue;
        
        parameters[attname.replace(pattern,"")] = domElement.attributes[i].value;    
    }
    
    return parameters;
}


Type.createNamespace('Framework.Util');

Framework.Util.DebugInfoProvider = function() {
}

Framework.Util.DebugInfoProvider.delegateDebugInfo = function(parDelegate) {
    var result = "";
    
    if(parDelegate != null && 
        parDelegate._targets != null && 
        parDelegate._targets.length != null && 
        parDelegate._targets.length == 2)
    {
        if(parDelegate._targets[1] != null)
            result = parDelegate._targets[1].toString();
    }
    
    return result;
}


/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	WindowedControlsHider.js - Windowed Controls Hider v3.20
	aplus.co.yu/WindowedControlsHider/
	- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	(c) Copyright 2003 and on, Aleksandar Vacic, www.aplus.co.yu
		This work is licensed under the Creative Commons Attribution License.
		To view a copy of this license, visit http://creativecommons.org/licenses/by/3.0/ or
		send a letter to Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
var WCH_Constructor = function() {
	//	exit point for anything but IE5.0+/Win
	if ( !(document.all && document.getElementById && !window.opera && navigator.userAgent.toLowerCase().indexOf("mac") == -1) ) {
		this.apply = function() {};
		this.discard = function() {};
		return;
	}

	//	private properties
	var _bIE55 = false;
	var _bIE6 = false;
	var _oRule = null;
	var _bSetup = true;
	var _oSelf = this;

	//	public: hides windowed controls
	this.apply = function(vLayer, vContainer, bResize) {
		if (_bSetup) _Setup();

		if ( _bIE55 && (oIframe = _Hider(vLayer, vContainer, bResize)) ) {
			oIframe.style.visibility = "visible";
		} else if(_oRule != null) {
			_oRule.style.visibility = "hidden";
		}

	};

	//	public: shows windowed controls
	this.discard = function(vLayer, vContainer) {
		if ( _bIE55 && (oIframe = _Hider(vLayer, vContainer, false)) ) {
			oIframe.style.visibility = "hidden";
		} else if(_oRule != null) {
			_oRule.style.visibility = "visible";
		}
	};

	//	private: returns iFrame reference for IE5.5+
	function _Hider(vLayer, vContainer, bResize) {
		var oLayer = _GetObj(vLayer);
		var oContainer = ( (oTmp = _GetObj(vContainer)) ? oTmp : document.getElementsByTagName("body")[0] );
		if (!oLayer || !oContainer) return;

		//	is it there already?
		//		1. first check does the layer has an ID at all. if not, assign one, using current timestamp, so we avoid duplicates
		if (oLayer.id == "")
			oLayer.id = "WCHid" + (new Date()).getTime();
		//		2. then try to locate the hiding iFrame
		var oIframe = document.getElementById("WCHhider" + oLayer.id);

		//	if not, create it
		if ( !oIframe ) {
			//	IE 6 has this property, IE 5 not. IE 5.5(even SP2) crashes when filter is applied, hence the check
			var sFilter = (_bIE6) ? "filter:progid:DXImageTransform.Microsoft.Alpha(style=0,opacity=0);" : "";
			//	get z-index of the object
			var zIndex = oLayer.style.zIndex;
			if ( zIndex == "" ) zIndex = oLayer.currentStyle.zIndex;
			zIndex = parseInt(zIndex);
			//	if no z-index, do nothing
			if ( isNaN(zIndex) ) return null;
			//	if z-index is below 2, do nothing (no room for Hider)
			if (zIndex < 2) return null;
			//	go one step below for Hider
			zIndex--;
			var sHiderID = "WCHhider" + oLayer.id;
			oContainer.insertAdjacentHTML("afterBegin", '<iframe class="WCHiframe" src="javascript:void(0);" id="' + sHiderID + '" scroll="no" frameborder="0" style="position:absolute;visibility:hidden;' + sFilter + 'border:0;top:0;left;0;width:0;height:0;background-color:#ccc;z-index:' + zIndex + ';"></iframe>');
			oIframe = document.getElementById(sHiderID);
			//	then do calculation
			_SetPos(oIframe, oLayer);
		} else if (bResize) {
			//	resize the iFrame if asked
			_SetPos(oIframe, oLayer);
		}
		return oIframe;
	};

	//	private: set size and position of the Hider
	function _SetPos(oIframe, oLayer) {
		//	fetch and set size
		oIframe.style.width = oLayer.offsetWidth + "px";
		oIframe.style.height = oLayer.offsetHeight + "px";
		//	move to specified position
		oIframe.style.left = oLayer.offsetLeft + "px";
		oIframe.style.top = oLayer.offsetTop + "px";
	};

	//	private: returns object reference
	function _GetObj(vObj) {
		var oObj = null;
		switch( typeof(vObj) ) {
			case "object":
				oObj = vObj;
				break;
			case "string":
				oObj = document.getElementById(vObj);
				break;
		}
		return oObj;
	};

	//	private: setup properties on first call to Apply
	function _Setup() {
		_bIE55 = (typeof(document.body.contentEditable) != "undefined");
		_bIE6 = (typeof(document.compatMode) != "undefined");

		if (!_bIE55) {
			if (document.styleSheets.length == 0)
				document.createStyleSheet();
			var oSheet = document.styleSheets[0];
			oSheet.addRule(".WCHhider", "visibility:visible");
			_oRule = oSheet.rules(oSheet.rules.length-1);
		}

		_bSetup = false;
	};
};
var WindowedControlsHider = new WCH_Constructor();

function getAllChildren(e) {
  // Returns all children of element. Workaround required for IE5/Windows. Ugh.
  return e.all ? e.all : e.getElementsByTagName('*');
}

document.getElementsBySelector = function(selector) {
  // Attempt to fail gracefully in lesser browsers
  if (!document.getElementsByTagName) {
    return new Array();
  }
  // Split selector in to tokens
  var tokens = selector.split(' ');
  var currentContext = new Array(document);
  for (var i = 0; i < tokens.length; i++) {
    token = tokens[i].replace(/^\s+/,'').replace(/\s+$/,'');;
    if (token.indexOf('#') > -1) {
      // Token is an ID selector
      var bits = token.split('#');
      var tagName = bits[0];
      var id = bits[1];
      var element = document.getElementById(id);
      if (tagName && element.nodeName.toLowerCase() != tagName) {
        // tag with that ID not found, return false
        return new Array();
      }
      // Set currentContext to contain just this element
      currentContext = new Array(element);
      continue; // Skip to next token
    }
    if (token.indexOf('.') > -1) {
      // Token contains a class selector
      var bits = token.split('.');
      var tagName = bits[0];
      var className = bits[1];
      if (!tagName) {
        tagName = '*';
      }
      // Get elements matching tag, filter them for class selector
      var found = new Array;
      var foundCount = 0;
      for (var h = 0; h < currentContext.length; h++) {
        var elements;
        if (tagName == '*') {
            elements = getAllChildren(currentContext[h]);
        } else {
            elements = currentContext[h].getElementsByTagName(tagName);
        }
        for (var j = 0; j < elements.length; j++) {
          found[foundCount++] = elements[j];
        }
      }
      currentContext = new Array;
      var currentContextIndex = 0;
      for (var k = 0; k < found.length; k++) {
        if (found[k].className && found[k].className.match(new RegExp('\\b'+className+'\\b'))) {
          currentContext[currentContextIndex++] = found[k];
        }
      }
      continue; // Skip to next token
    }
    // Code to deal with attribute selectors
    if (token.match(/^(\w*)\[(\w+)([=~\|\^\$\*]?)=?"?([^\]"]*)"?\]$/)) {
      var tagName = RegExp.$1;
      var attrName = RegExp.$2;
      var attrOperator = RegExp.$3;
      var attrValue = RegExp.$4;
      if (!tagName) {
        tagName = '*';
      }
      // Grab all of the tagName elements within current context
      var found = new Array;
      var foundCount = 0;
      for (var h = 0; h < currentContext.length; h++) {
        var elements;
        if (tagName == '*') {
            elements = getAllChildren(currentContext[h]);
        } else {
            elements = currentContext[h].getElementsByTagName(tagName);
        }
        for (var j = 0; j < elements.length; j++) {
          found[foundCount++] = elements[j];
        }
      }
      currentContext = new Array;
      var currentContextIndex = 0;
      var checkFunction; // This function will be used to filter the elements
      switch (attrOperator) {
        case '=': // Equality
          checkFunction = function(e) { return (e.getAttribute(attrName) == attrValue); };
          break;
        case '~': // Match one of space seperated words 
          checkFunction = function(e) { return (e.getAttribute(attrName).match(new RegExp('\\b'+attrValue+'\\b'))); };
          break;
        case '|': // Match start with value followed by optional hyphen
          checkFunction = function(e) { return (e.getAttribute(attrName).match(new RegExp('^'+attrValue+'-?'))); };
          break;
        case '^': // Match starts with value
          checkFunction = function(e) { return (e.getAttribute(attrName).indexOf(attrValue) == 0); };
          break;
        case '$': // Match ends with value - fails with "Warning" in Opera 7
          checkFunction = function(e) { return (e.getAttribute(attrName).lastIndexOf(attrValue) == e.getAttribute(attrName).length - attrValue.length); };
          break;
        case '*': // Match ends with value
          checkFunction = function(e) { return (e.getAttribute(attrName).indexOf(attrValue) > -1); };
          break;
        default :
          // Just test for existence of attribute
          checkFunction = function(e) { return e.getAttribute(attrName); };
      }
      currentContext = new Array;
      var currentContextIndex = 0;
      for (var k = 0; k < found.length; k++) {
        if (checkFunction(found[k])) {
          currentContext[currentContextIndex++] = found[k];
        }
      }
      // alert('Attribute Selector: '+tagName+' '+attrName+' '+attrOperator+' '+attrValue);
      continue; // Skip to next token
    }
    // If we get here, token is JUST an element (not a class or ID selector)
    tagName = token;
    var found = new Array;
    var foundCount = 0;
    for (var h = 0; h < currentContext.length; h++) {
      var elements = currentContext[h].getElementsByTagName(tagName);
      for (var j = 0; j < elements.length; j++) {
        found[foundCount++] = elements[j];
      }
    }
    currentContext = found;
  }
  return currentContext;
}

Framework.DocumentFinder = function() {}

Framework.DocumentFinder.getElementsBySelector = function(css){return document.getElementsBySelector(css);}

function evSetFrameHeight (h) {
	var elements = Framework.DocumentFinder.getElementsBySelector('iframe');
	if (elements && elements.length > 0) {
		for (i = 0; i < elements.length; i++) {
			elements[i].height= h + 'px';
		}
	}
}


/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	ADxMenu.js - v4 (4.10)
	aplus.co.yu/adxmenu/
	- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	(c) Copyright 2003, Aleksandar Vacic, www.aplus.co.yu
		This work is licensed under the Creative Commons Attribution License.
		To view a copy of this license, visit http://creativecommons.org/licenses/by/2.0/ or
		send a letter to Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
Framework.ADxMenu = function() {}

Framework.ADxMenu.ieSetup = function() {
	var aTmp2, i, j, oLI, aUL, aA;
	var aTmp = this.getElementsByClassName("adxm", document, "ul");
	for (i=0;i<aTmp.length;i++) {
		aTmp2 = aTmp[i].getElementsByTagName("li");
		for (j=0;j<aTmp2.length;j++) {
			oLI = aTmp2[j];
			aUL = oLI.getElementsByTagName("ul");
			//	if item has submenu, then make the item hoverable
			if (aUL && aUL.length) {
				oLI.UL = aUL[0];	//	direct submenu
				aA = oLI.getElementsByTagName("a");
				if (aA && aA.length)
					oLI.A = aA[0];	//	direct child link
				//	li:hover
				oLI.onmouseenter = function() {
					this.className += " adxmhover";
					this.UL.className += " adxmhoverUL";
					if (this.A) this.A.className += " adxmhoverA";
					if (WindowedControlsHider) WindowedControlsHider.apply( this.UL, this, true );
				};
				//	li:blur
				oLI.onmouseleave = function() {
					this.className = this.className.replace(/adxmhover/gi,"");
					this.UL.className = this.UL.className.replace(/adxmhoverUL/gi,"");
					if (this.A) this.A.className = this.A.className.replace(/adxmhoverA/gi,"");
					if (WindowedControlsHider) WindowedControlsHider.discard( this.UL, this );
				};
			}
		}	//for-li.submenu
	}	//for-ul.adxm
}

/*	getElementsByClassName()
	Returns an array of elements which are
	descendants of parentEle and have tagName and clsName.
	If parentEle is null or not present, document will be used.
	if tagName is null or not present, "*" will be used.
	credits: Mike Foster, cross-browser.com.
*/	
Framework.ADxMenu.getElementsByClassName = function(clsName, parentEle, tagName) {
	var elements = null;
	var found = new Array();
	var re = new RegExp('\\b'+clsName+'\\b');
	if (!parentEle) parentEle = document;
	if (!tagName) tagName = '*';
	if (parentEle.getElementsByTagName) {elements = parentEle.getElementsByTagName(tagName);}
	else if (document.all) {elements = document.all.tags(tagName);}
	if (elements) {
		for (var i = 0; i < elements.length; ++i) {
			if (elements[i].className.search(re) != -1) {
				found[found.length] = elements[i];
			}
		}
	}
	return found;
}

/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	fix IE6/7 problem: on mouse over, force showing help over "?" icon (on forms)
	uses getElementsByClassName from ADxMenu (above)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
Framework.FormHelp = function() {
}

Framework.FormHelp.ieSetup = function() {
	if (!document.all || window.opera) return;
	var aTmp = Framework.ADxMenu.getElementsByClassName("formhelp", document, "a");
	if (aTmp && aTmp.length) {
		for (var i=0;i<aTmp.length;i++) {
			aTmp[i].onmouseenter = function() {
				if (!(x = this.getElementsByTagName('span')[0])) return;
				x.style.visibility = 'visible';
			};
			aTmp[i].onmouseleave = function() {
				if (!(x = this.getElementsByTagName('span')[0])) return;
				x.style.visibility = 'hidden';
			};
		}
	}
}

Framework.WindowNameManager = function() {
}

Framework.WindowNameManager.getWindowName = function WindowNameManager$getWindowName() {
	
	try{
	    return window.top.name;
	    }
	    catch(e){
	    return window.name;
	    }
}

Framework.WindowNameManager.setWindowName = function WindowNameManager$setWindowName(name) {
	window.top.name = name;
}

Framework.XMLHttpRequestDecorator = function() {
}
Framework.XMLHttpRequestDecorator.prototype = {
	_body : null,
	_request : null,
	_requestHeaders : {},
	onreadystatechange : null,
	readyState : 0,
	responseText : null,
	responseXML : null,
	status : null,
	statusText : null,
	abort : function() {
		this._request.abort();
	},
	getAllResponseHeaders : function() {
		return this._request.getAllResponseHeaders();
	},
	getResponseHeader : function(name) {
		return this._request.getResponseHeader(name);
	},
	open : function(method, url, async, username, password) {
		var that = this;
		this._request = new XMLHttpRequest();
		this._request.onreadystatechange = function() {
			that.readyState = that._request.readyState;
			if (that._request.readyState === 4) {
				that.responseText = that._request.responseText;
				that.responseXML = that._request.responseXML;
				that.status = that._request.status;
				that.statusText = that._request.statusText;
				if (!that._request.getResponseHeader('Date') && ((that._request.status >= 200  && that._request.status <= 299) || that._request.status === 304)) {
					var lastModified = that._request.getResponseHeader('Last-Modified');
					//that._request.onreadystatechange = null;
					that._request = new XMLHttpRequest();
					that._request.onreadystatechange = function() {
						that.readyState = that._request.readyState;
						if (that._request.readyState === 4) {
							if (that._request.status >= 200 && that._request.status <= 299) {
								that.responseText = that._request.responseText;
								that.responseXML = that._request.responseXML;
							}
							that.status = that._request.status;
							that.statusText = that._request.statusText;
						}
						that.onreadystatechange();
						if (that._request.readyState === 4) {
							that.onreadystatechange = null;
							that._request = null;
						}
					}
					that._request.open(method, url, async, username, password);
					that._request.setRequestHeader('If-Modified-Since', lastModified || 'Thu, 01 Jan 1970 00:00:00 GMT');
					if (that._requestHeaders)
						for (var headerName in that._requestHeaders)
							that._request.setRequestHeader(headerName, that._requestHeaders[headerName]);
					that._request.send(that._body);
				} else {
					that.onreadystatechange();
					that.onreadystatechange = null;
					that_request = null;
				}
			} else
				that.onreadystatechange();
		}
		this._request.open(method, url, async, username, password);
	},
	send : function(body) {
		this._body = body;
		this._request.send(body);
	},
	setRequestHeader : function(name, value) {
		this._request.setRequestHeader(name, value);
		this._requestHeaders[name] = value;
	}
}

Framework.ADxMenu.createClass('Framework.ADxMenu');
Framework.DocumentEvents.createClass('Framework.DocumentEvents');
Framework.DocumentBehaviors.createClass('Framework.DocumentBehaviors');
Framework.Behavior.ParametersObjectBuilder.createClass('Framework.Behavior.ParametersObjectBuilder');
Framework.Util.DebugInfoProvider.createClass('Framework.Util.DebugInfoProvider');
Framework.DocumentFinder.createClass('Framework.DocumentFinder');
Framework.FormHelp.createClass('Framework.FormHelp');
Framework.JsonUtil.createClass('Framework.JsonUtil');
//Framework.WindowedControlsHider.createClass('Framework.WindowedControlsHider');
//Framework.WindowInstanceExt.createClass('Framework.WindowInstanceExt');
Framework.WindowNameManager.createClass('Framework.WindowNameManager');
Framework.XMLUtils.createClass('Framework.XMLUtils');
Framework.XMLHttpRequestDecorator.createClass('Framework.XMLHttpRequestDecorator');

Framework.ScriptSharpQuirks = function() {
}

Framework.ScriptSharpQuirks.isNumberNull = function ScriptSharpQuirks$isNumberNull(number) {
	return number == null;
}


////////////////////////////////////////////////////////////////////////////////
// Framework.ITopicChangedListener

Framework.ITopicChangedListener = function() { };
Framework.ITopicChangedListener.prototype = {
    onTopicChanged : null
}
Framework.ITopicChangedListener.createInterface('Framework.ITopicChangedListener');


////////////////////////////////////////////////////////////////////////////////
// Framework.IRpcTask

Framework.IRpcTask = function() { };
Framework.IRpcTask.prototype = {
    getRequestPayload : null,
    processResponse : null
}
Framework.IRpcTask.createInterface('Framework.IRpcTask');


////////////////////////////////////////////////////////////////////////////////
// Framework.IEnvironment

Framework.IEnvironment = function() { };
Framework.IEnvironment.prototype = {
    init : null,
    start : null,
    registerPageWillChangeListener : null,
    get_componentUpdateScheduler : null,
    getProtocol : null,
    getLanguage : null,
    getRegion : null,
    getPageArea : null,
    getInitialPageFilter : null,
    getDomElement : null,
    updateDomElement : null,
    updateDomElementDirect : null,
    transformAndUpdate : null,
    periodicalTransformAndUpdate : null,
    clearPeriodicalTransformAndUpdate : null,
    invoke : null,
    invokeAsync : null,
    invokeAsyncUsingJsonp : null,
    storeState : null,
    getStoredState : null,
    get_debugInfo : null,
    getCookie : null,
    setCookie : null,
    setCookieWithDays : null,
    clearCookie : null,
    clearCookies : null,
    getBaselineUrl : null,
    changeLocation : null,
    changeRegion : null,
    changeLanguage : null,
    buildUrl : null,
    getHash : null,
    setHash : null,
    safelySetCssClass : null,
    safelyRemoveCssClass : null,
    safelySetAndUnsetCssClass : null,
    safelySetAndUnsetCssClassIf : null,
    containsCssClass : null,
    safelySetCssClassOnElement : null,
    safelyRemoveCssClassOnElement : null,
    safelySetAndUnsetCssClassOnElement : null,
    safelySetAndUnsetCssClassOnElementIf : null,
    containsCssClassOnElement : null
}
Framework.IEnvironment.createInterface('Framework.IEnvironment');


////////////////////////////////////////////////////////////////////////////////
// Framework.IPageWillChangeListener

Framework.IPageWillChangeListener = function() { };
Framework.IPageWillChangeListener.prototype = {
    onPageWillChange : null
}
Framework.IPageWillChangeListener.createInterface('Framework.IPageWillChangeListener');


////////////////////////////////////////////////////////////////////////////////
// Framework.AbstractComponent

Framework.AbstractComponent = function Framework_AbstractComponent() {
    this._log = Framework.Logger.getLog('AbstractComponent');
    this._children = new Array(0);
    this.componentLifeCycleManager = this.createComponentLifeCycleManager();
}
Framework.AbstractComponent.setFormEnabled = function Framework_AbstractComponent$setFormEnabled(domElementId, enabled) {
    Framework.AbstractComponent._setCollectionEnabled(document.getElementById(domElementId).getElementsByTagName('select'), enabled);
    Framework.AbstractComponent._setCollectionEnabled(document.getElementById(domElementId).getElementsByTagName('input'), enabled);
    Framework.AbstractComponent._setCollectionEnabled(document.getElementById(domElementId).getElementsByTagName('button'), enabled);
    Framework.AbstractComponent._setCollectionEnabled(document.getElementById(domElementId).getElementsByTagName('textarea'), enabled);
}
Framework.AbstractComponent._setCollectionEnabled = function Framework_AbstractComponent$_setCollectionEnabled(domElementCollection, enabled) {
    for (var i = 0; i < domElementCollection.length; i++) {
        domElementCollection[i].disabled = !enabled;
    }
}
Framework.AbstractComponent.prototype = {
    _environment: null,
    _componentInstanceName: null,
    _domElementId: null,
    _currentArea: 0,
    _area: null,
    _adminHtmlUrl: null,
    _childID: null,
    _parent: null,
    _siblingIndex: 0,
    componentLifeCycleManager: null,
    
    get__abstractEnvironment: function Framework_AbstractComponent$get__abstractEnvironment() {
        return this._environment;
    },
    
    update: function Framework_AbstractComponent$update(domElement, contentID, xsltUrl, xsltParameters, afterTransformationCallback, inMemoryTransformationCallback, xmlContent) {
        if (!afterTransformationCallback && !inMemoryTransformationCallback) {
            this.get__abstractEnvironment().transformAndUpdate(domElement.id, contentID, xsltUrl, xsltParameters, Delegate.create(this, this.repaintComplete), domElement, Delegate.create(this, this.transformationComplete), xmlContent);
        }
        else {
            this.get__abstractEnvironment().transformAndUpdate(domElement.id, contentID, xsltUrl, xsltParameters, afterTransformationCallback, domElement, inMemoryTransformationCallback, xmlContent);
        }
    },
    
    periodicalUpdate: function Framework_AbstractComponent$periodicalUpdate(domElementId, contentID, xsltUrl, xsltParameters, domain, autoRefreshPeriod, afterTransformationCallback, inMemoryTransformationCallback) {
        if (!afterTransformationCallback && !inMemoryTransformationCallback) {
            this.get__abstractEnvironment().periodicalTransformAndUpdate(domElementId, contentID, xsltUrl, xsltParameters, Delegate.create(this, this.repaintComplete), domain, autoRefreshPeriod, Delegate.create(this, this.transformationComplete));
        }
        else {
            this.get__abstractEnvironment().periodicalTransformAndUpdate(domElementId, contentID, xsltUrl, xsltParameters, afterTransformationCallback, domain, autoRefreshPeriod, inMemoryTransformationCallback);
        }
    },
    
    transformationComplete: function Framework_AbstractComponent$transformationComplete(inMemoryComponent) {
        Framework.Behavior.Binding.BehaviorBinder.autoBind(inMemoryComponent, (this));
    },
    
    repaintComplete: function Framework_AbstractComponent$repaintComplete() {
    },
    
    createComponentLifeCycleManager: function Framework_AbstractComponent$createComponentLifeCycleManager() {
        var tmpObject = this;
        return new Framework.Component.LifeCycleManagement.ComponentLifeCycleManager(tmpObject);
    },
    
    get_componentInstanceName: function Framework_AbstractComponent$get_componentInstanceName() {
        return this._componentInstanceName;
    },
    
    get_domElementId: function Framework_AbstractComponent$get_domElementId() {
        return this._domElementId;
    },
    set_domElementId: function Framework_AbstractComponent$set_domElementId(value) {
        this._domElementId = value;
        return value;
    },
    
    init: function Framework_AbstractComponent$init(environment, componentInstanceName, domElementId, parameters) {
        this._log = Framework.Logger.getLog(domElementId);
        this._log.debug('Init');
        this._environment = environment;
        this._componentInstanceName = componentInstanceName;
        this._domElementId = domElementId;
        this._adminHtmlUrl = parameters['admin-html-url'];
    },
    
    start: function Framework_AbstractComponent$start() {
        this._log.debug('Start');
        this.repaint();
    },
    
    repaintForAdmin: function Framework_AbstractComponent$repaintForAdmin() {
        var ajaxUpdater = new Framework.AjaxUpdater(this._domElementId, this._adminHtmlUrl, null, Delegate.create(this, function() {
            this._environment.updateDomElement(this._domElementId, this._domElementId);
        }));
        ajaxUpdater.update();
    },
    
    disableForAdmin: function Framework_AbstractComponent$disableForAdmin() {
        var anchors = this._environment.getDomElement(this._domElementId).getElementsByTagName('A');
        for (var i = 0; i < anchors.length; i++) {
            var anchor = anchors[i];
            anchor.setAttribute('href', '#');
            anchor.setAttribute('onclick', 'return false;');
        }
    },
    
    isVisible: function Framework_AbstractComponent$isVisible(visibleOn, notVisibleOn, action) {
        if (!visibleOn.length && !notVisibleOn.length) {
            return true;
        }
        if (visibleOn.length > 0) {
            return visibleOn.contains(action);
        }
        if (notVisibleOn.length > 0) {
            return !notVisibleOn.contains(action);
        }
        throw new Error('Parameters were not specified correctly.');
    },
    
    show: function Framework_AbstractComponent$show() {
        this._environment.getDomElement(this._domElementId).style.display = 'block';
    },
    
    hide: function Framework_AbstractComponent$hide() {
        this._environment.getDomElement(this._domElementId).style.display = 'none';
        this._environment.updateDomElement(this._domElementId, String.Empty);
    },
    
    disable: function Framework_AbstractComponent$disable() {
        this._environment.getDomElement(this._domElementId).style.cursor = 'wait';
        Framework.AbstractComponent.setFormEnabled(this._domElementId, false);
    },
    
    enable: function Framework_AbstractComponent$enable() {
        this._environment.getDomElement(this._domElementId).style.cursor = 'default';
        Framework.AbstractComponent.setFormEnabled(this._domElementId, true);
    },
    
    getPrivateDomElement: function Framework_AbstractComponent$getPrivateDomElement(domElementNameSuffix) {
        return document.getElementById(String.format('{0}-{1}', this._domElementId, domElementNameSuffix));
    },
    
    updatePrivateDomElement: function Framework_AbstractComponent$updatePrivateDomElement(domElementNameSuffix, htmlContent) {
        this.updatePrivateDomElementWithCallback(domElementNameSuffix, htmlContent, null, null);
    },
    
    updatePrivateDomElementWithCallback: function Framework_AbstractComponent$updatePrivateDomElementWithCallback(domElementNameSuffix, htmlContent, successCallback, failureCallback) {
        try {
            var element = document.getElementById(String.format('{0}-{1}', this._domElementId, domElementNameSuffix));
            if (element) {
                this._environment.updateDomElementDirect(element, htmlContent);
                if (successCallback) {
                    successCallback.invoke();
                }
            }
            else {
                throw new Error(String.format('domElementNameSuffix [{0}] cannot be found!', domElementNameSuffix));
            }
        }
        catch (ex) {
            this._log.error('UpdatePrivateDomElement', ex);
            if (failureCallback) {
                failureCallback.invoke(ex);
            }
        }
    },
    
    activateArea: function Framework_AbstractComponent$activateArea(area, messages) {
        this._log.debug(String.format('ActivateArea area=[{0}] messages=[{1}]', area, messages));
        this._environment.getDomElement(this._domElementId + '-' + this._area[this._currentArea]).style.display = 'none';
        this._currentArea = area;
        this._environment.getDomElement(this._domElementId + '-' + this._area[this._currentArea]).style.display = 'block';
        if (messages) {
            for (var i = 0; i < messages.length; i++) {
                if (!String.isNullOrEmpty(messages[i])) {
                    this._environment.getDomElement(this._domElementId + '-' + this._area[this._currentArea] + '-' + i).innerText = messages[i];
                }
            }
        }
    },
    
    getTranslation: function Framework_AbstractComponent$getTranslation(phrase) {
        return this.getPrivateDomElement(phrase).innerHTML;
    },
    
    get_parent: function Framework_AbstractComponent$get_parent() {
        return this._parent;
    },
    
    get_childID: function Framework_AbstractComponent$get_childID() {
        return this._childID;
    },
    set_childID: function Framework_AbstractComponent$set_childID(value) {
        this._childID = value;
        return value;
    },
    
    startChildren: function Framework_AbstractComponent$startChildren() {
        for (var index = 0; index < this._children.length; index++) {
            var newComponent = (this._children[index]);
            if (!isNullOrUndefined(newComponent.componentLifeCycleManager)) {
                newComponent.componentLifeCycleManager.start();
            }
            else {
                this._children[index].start();
            }
        }
    },
    
    addChild: function Framework_AbstractComponent$addChild(child) {
        var index = this._children.length;
        this._children[index] = child;
        child._parent = this;
        child._siblingIndex = index;
    },
    
    get_hasChildren: function Framework_AbstractComponent$get_hasChildren() {
        if (!this._children) {
            return false;
        }
        return this._children.length > 0;
    },
    
    get_children: function Framework_AbstractComponent$get_children() {
        return this._children;
    },
    
    getChildByID: function Framework_AbstractComponent$getChildByID(childID) {
        for (var count = 0; count < this._children.length; count++) {
            if (this._children[count].get_childID() === childID) {
                return this._children[count];
            }
        }
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AbstractEnvironment

Framework.AbstractEnvironment = function Framework_AbstractEnvironment(components, services) {
    this._multiplexedRpcTasks = [];
    this._pageWillChangeListeners = [];
    this._transformAndUpdateQueue = [];
    this.components = components;
    this.services = services;
    this._componentUpdateScheduler = new Framework.Component.Updating.ComponentUpdateScheduler();
}
Framework.AbstractEnvironment.safeUpdateDomElement = function Framework_AbstractEnvironment$safeUpdateDomElement(domElementId, htmlContent) {
    var domElement = document.getElementById(domElementId);
    if (domElement) {
        Framework.AbstractEnvironment.safeUpdateDomElementDirect(domElement, htmlContent);
    }
    else {
        Framework.AbstractEnvironment._log.debug(String.format('Environment.UpdateDomElement Error - Dom element id [{0}] does not exist', domElementId));
    }
}
Framework.AbstractEnvironment.safeUpdateDomElementDirect = function Framework_AbstractEnvironment$safeUpdateDomElementDirect(domElement, htmlContent) {
    if (!domElement) {
        return;
    }
    if (domElement.innerHTML === htmlContent) {
        Framework.AbstractEnvironment._log.debug(domElement.id + '.InnerHTML unchanged - not updated');
    }
    else {
        Framework.DocumentEvents.purgeEventsBeforeUpdate(domElement, true, 0);
        domElement.innerHTML = htmlContent;
    }
}
Framework.AbstractEnvironment.serializeToXml = function Framework_AbstractEnvironment$serializeToXml(instanceName, value, isKeyValue) {
    if ((!instanceName) || (!instanceName)) {
        return String.Empty;
    }
    var isArray = false;
    isArray = (value instanceof Array);;
    var type = '';
    type = (typeof value);;
    var isValue = (type === 'boolean') || (type === 'number') || (type === 'string');
    var isObject = (type === 'object');
    var isInstanceNameNumeric = false;
    isInstanceNameNumeric =  !isNaN(instanceName);
    var attributes = '';
    if (isKeyValue) {
        attributes = ' key=\"' + instanceName + '\"';
        instanceName = 'value';
    }
    if (isArray || isObject) {
        return String.format('<{0}{2}>{1}</{0}>', instanceName, Framework.AbstractEnvironment.serializeDictionaryToXml(value, isArray), attributes);
    }
    else if (isValue) {
        return String.format('<{0}>{1}</{0}>', instanceName, value);
    }
    return String.Empty;
}
Framework.AbstractEnvironment.serializeDictionaryToXml = function Framework_AbstractEnvironment$serializeDictionaryToXml(dictionary, isArray) {
    if (!dictionary) {
        return String.Empty;
    }
    var result = '';
    if (Object.getKeyCount(dictionary) > 0) {
        var $dict1 = dictionary;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            if (entry.key) {
                result += Framework.AbstractEnvironment.serializeToXml(entry.key, entry.value, isArray);
            }
        }
    }
    return result;
}
Framework.AbstractEnvironment.prototype = {
    _componentUpdateScheduler: null,
    components: null,
    services: null,
    _state: null,
    _language: null,
    _region: null,
    _pageArea: null,
    _initialPageFilter: null,
    
    getProtocol: function Framework_AbstractEnvironment$getProtocol() {
        return window.location.protocol.split(':')[0];
    },
    
    getLanguage: function Framework_AbstractEnvironment$getLanguage() {
        return this._language;
    },
    
    getRegion: function Framework_AbstractEnvironment$getRegion() {
        return this._region;
    },
    
    getPageArea: function Framework_AbstractEnvironment$getPageArea() {
        return this._pageArea;
    },
    
    getInitialPageFilter: function Framework_AbstractEnvironment$getInitialPageFilter() {
        return this._initialPageFilter;
    },
    
    get_componentUpdateScheduler: function Framework_AbstractEnvironment$get_componentUpdateScheduler() {
        return this._componentUpdateScheduler;
    },
    
    init: function Framework_AbstractEnvironment$init(language, region, pageArea, pageFilter) {
        Framework.AbstractEnvironment._log.debug('Init');
        this._language = language;
        this._region = region;
        this._pageArea = pageArea;
        this._initialPageFilter = pageFilter;
        var windowNameStateKey = '_window.top.name';
        var windowNameCurrentDomainKey = '_windowNameCurrentDomain';
        var debugInfoKey = '_debugInfo';
        var stateString = Framework.WindowNameManager.getWindowName();
        if (!isNullOrUndefined(stateString) && !String.isNullOrEmpty(stateString)) {
            try {
                var state = Framework.JsonUtil.deserialize(Framework.WindowNameManager.getWindowName());
                if (state && Type.getInstanceType(state) === Object) {
                    if (Object.keyExists((state), windowNameCurrentDomainKey) && (state)[windowNameCurrentDomainKey].toString() === window.location.hostname) {
                        this._state = state;
                        Framework.WindowNameManager.setWindowName(this._state[windowNameStateKey]);
                        if (!String.isNullOrEmpty(this._state[debugInfoKey])) {
                            this._debugInfo = this._state[debugInfoKey];
                        }
                    }
                    else {
                        this._state = {};
                        Framework.WindowNameManager.setWindowName('');
                    }
                }
                else {
                    this._state = {};
                }
            }
            catch ($e1) {
                this._state = {};
            }
        }
        else {
            this._state = {};
        }
        window.attachEvent('onbeforeunload', Delegate.create(this, function() {
            this.firePageWillChangeEvent();
            this._state[windowNameStateKey] = Framework.WindowNameManager.getWindowName();
            this._state[windowNameCurrentDomainKey] = window.location.hostname;
            this._state[debugInfoKey] = this._debugInfo;
            Framework.WindowNameManager.setWindowName(Framework.JsonUtil.serialize(this._state));
        }));
    },
    
    start: function Framework_AbstractEnvironment$start() {
        Framework.AbstractEnvironment._log.debug('Start');
        this._transformAndUpdateScheduler(0);
        if (String.isNullOrEmpty(this._debugInfo)) {
            this._fetchDebugInfo();
        }
    },
    
    registerPageWillChangeListener: function Framework_AbstractEnvironment$registerPageWillChangeListener(pageWillChangeListener) {
        if (!this._pageWillChangeListeners.contains(pageWillChangeListener)) {
            this._pageWillChangeListeners.add(pageWillChangeListener);
        }
    },
    
    firePageWillChangeEvent: function Framework_AbstractEnvironment$firePageWillChangeEvent() {
        var $enum1 = this._pageWillChangeListeners.getEnumerator();
        while ($enum1.moveNext()) {
            var listener = $enum1.get_current();
            listener.onPageWillChange();
        }
    },
    
    createRealUrl: function Framework_AbstractEnvironment$createRealUrl(url) {
        return ((!url) ? null : url.replace('${region}', this._region).replace('${language}', this._language));
    },
    
    getDomElement: function Framework_AbstractEnvironment$getDomElement(domElementId) {
        return document.getElementById(domElementId);
    },
    
    updateDomElement: function Framework_AbstractEnvironment$updateDomElement(domElementId, htmlContent) {
        var domElement = document.getElementById(domElementId);
        if (domElement) {
            Framework.AbstractEnvironment.safeUpdateDomElementDirect(domElement, htmlContent);
        }
        else {
            Framework.AbstractEnvironment._log.debug(String.format('Environment.UpdateDomElement Error - Dom element id [{0}] does not exist', domElementId));
        }
    },
    
    updateDomElementDirect: function Framework_AbstractEnvironment$updateDomElementDirect(domElement, htmlContent) {
        Framework.AbstractEnvironment.safeUpdateDomElementDirect(domElement, htmlContent);
    },
    
    transformAndUpdateInner: function Framework_AbstractEnvironment$transformAndUpdateInner(domElementId, contentId, xsltUrl, xsltParameters, afterTransformAndUpdateCallback, domain, autoRefreshPeriod, domElement, inMemoryProcessingCallback, xmlContent, contentUrlDelegate, useContentUrlDelegate) {
        var placeHolder = (!domElement) ? document.getElementById(domElementId) : domElement;
        if (placeHolder) {
            this.updateDomElementDirect(placeHolder, '<img src=\'/indicator.gif\' />');
            var transformAndUpdateTask = new Framework.TransformAndUpdateTask(domElementId, this.createRealUrl(contentId), xsltUrl, xsltParameters, afterTransformAndUpdateCallback, domain, autoRefreshPeriod, this, domElement, inMemoryProcessingCallback, (xmlContent) ? XMLDocumentParser.parse(xmlContent) : Framework.XMLUtils.get_emptyContentDocument(), (xmlContent) ? true : false, contentUrlDelegate, useContentUrlDelegate);
            transformAndUpdateTask.execute(true);
            return transformAndUpdateTask;
        }
        return null;
    },
    
    transformAndUpdate: function Framework_AbstractEnvironment$transformAndUpdate(domElementId, contentId, xsltUrl, xsltParameters, afterTransformAndUpdateCallback, domElement, inMemoryProcessingCallback, xmlContent) {
        Framework.AbstractEnvironment._log.debug(String.format('TransformAndUpdate domElementId=[{0}] contentId=[{1}] xsltUrl=[{2}] xsltParameters=[{3}]', domElementId, contentId, xsltUrl, Framework.DictionaryUtil.dumpToString(xsltParameters)));
        this.transformAndUpdateInner(domElementId, contentId, xsltUrl, xsltParameters, afterTransformAndUpdateCallback, null, null, domElement, inMemoryProcessingCallback, xmlContent);
    },
    
    periodicalTransformAndUpdate: function Framework_AbstractEnvironment$periodicalTransformAndUpdate(domElementId, contentId, xsltUrl, xsltParameters, afterTransformAndUpdateCallbac, domain, autoRefreshPeriod, inMemoryProcessingCallback, contentIdDelegate, useContentIdDelegate) {
        Framework.AbstractEnvironment._log.debug(String.format('ScheduledTransformAndUpdate domElementId=[{0}] contentId=[{1}] xsltUrl=[{2}] xsltParameters=[{3}] domain=[{4}] autoRefreshPeriod=[{5}]', domElementId, contentId, xsltUrl, Framework.DictionaryUtil.dumpToString(xsltParameters), domain, autoRefreshPeriod));
        var task = this.transformAndUpdateInner(domElementId, contentId, xsltUrl, xsltParameters, afterTransformAndUpdateCallbac, domain, autoRefreshPeriod, null, inMemoryProcessingCallback, null, contentIdDelegate, useContentIdDelegate);
        if (task) {
            this._transformAndUpdateQueue.add(task);
        }
    },
    
    periodicalTransformAndUpdateWithContentUrlDelegate: function Framework_AbstractEnvironment$periodicalTransformAndUpdateWithContentUrlDelegate(domElementId, contentUrlDelegate, xsltUrl, xsltParameters, afterTransformAndUpdateCallbac, domain, autoRefreshPeriod) {
        this.periodicalTransformAndUpdate(domElementId, null, xsltUrl, xsltParameters, afterTransformAndUpdateCallbac, domain, autoRefreshPeriod, null, contentUrlDelegate, true);
    },
    
    clearPeriodicalTransformAndUpdate: function Framework_AbstractEnvironment$clearPeriodicalTransformAndUpdate(domain) {
        Framework.AbstractEnvironment._log.debug(String.format('ClearScheduledTransformAndUpdate domain=[{0}]', domain));
        var newQueue = [];
        for (var i = 0; i < this._transformAndUpdateQueue.length; i++) {
            if (domain !== (this._transformAndUpdateQueue[i]).get_domain()) {
                newQueue.add(this._transformAndUpdateQueue[i]);
            }
        }
        this._transformAndUpdateQueue = newQueue;
    },
    
    _transformAndUpdateScheduler: function Framework_AbstractEnvironment$_transformAndUpdateScheduler(startIndex) {
        var queue = this._transformAndUpdateQueue;
        Framework.AbstractEnvironment._log.debug(String.format('TransformAndUpdateScheduler woke up!, StartIndex=[{0}]', startIndex));
        if (queue && queue.length > 0) {
            startIndex = Math.min(startIndex, queue.length - 1);
            var i = startIndex;
            do {
                var currentTask = queue[i];
                Framework.AbstractEnvironment._log.debug(String.format('TransformAndUpdateScheduler processing task i=[{0}] LastExecuted=[{1}] AutoRefreshPeriod=[{2}]', i, currentTask.get_lastExecuted(), currentTask.get_autoRefreshPeriod()));
                i = (i + 1) % queue.length;
                if (currentTask.get_lastExecuted().getTime() + currentTask.get_autoRefreshPeriod() < Date.get_now().getTime()) {
                    currentTask.execute(true);
                    break;
                }
            } while (i !== startIndex);
            startIndex = i;
        }
        window.setTimeout(Delegate.create(this, function() {
            this._transformAndUpdateScheduler(startIndex);
        }), Framework.Parameters.transformAndUpdateSchedulerPeriod);
    },
    
    _getCallBrokerUrl: function Framework_AbstractEnvironment$_getCallBrokerUrl() {
        return '/CallBroker.ashx';
    },
    
    invoke: function Framework_AbstractEnvironment$invoke(serviceName, methodName, arguments) {
        Framework.AbstractEnvironment._log.debug('invoke serviceName = [' + serviceName + '] methodName = [' + methodName + '] arguments = [...]');
        var request = new XMLHttpRequest();
        request.open('POST', this._getCallBrokerUrl(), false);
        request.setRequestHeader('Content-Type', 'text/json');
        var requestPayload = {};
        requestPayload['serviceName'] = serviceName;
        requestPayload['methodName'] = methodName;
        requestPayload['arguments'] = arguments;
        var JSONrequestPayload = Framework.JsonUtil.serialize(requestPayload);
        request.send(JSONrequestPayload);
        var status = request.status;
        Framework.AbstractEnvironment._log.debug(String.format('Status = [{0}]', status));
        if (status === 200) {
            var response = Framework.JsonUtil.deserialize(request.responseText);
            return response['result'];
        }
        else if (status === 500) {
            try {
                var response = Framework.JsonUtil.deserialize(request.responseText);
                throw Framework.ExceptionUtil.createException(response['exceptionType'], response['message']);
            }
            catch (e) {
                Framework.AbstractEnvironment._log.error('Invoke failed', e);
                throw Framework.ExceptionUtil.createException('RemoteException', null);
            }
        }
        else {
            throw Framework.ExceptionUtil.createException('RemoteException', null);
        }
    },
    
    invokeAsync: function Framework_AbstractEnvironment$invokeAsync(serviceName, methodName, arguments, successCallback, failureCallback) {
        var rpcTask = new Framework.JsonRpcTask(serviceName, methodName, this.getLanguage(), arguments, successCallback, failureCallback);
        if (Framework.AbstractEnvironment._enableMultiplexing) {
            if (!this._multiplexedRpcTasks.length) {
                window.setTimeout(Delegate.create(this, function() {
                    var multiplexPayload = [];
                    var $enum1 = this._multiplexedRpcTasks.getEnumerator();
                    while ($enum1.moveNext()) {
                        var task = $enum1.get_current();
                        multiplexPayload.add(task.getPayloadAsDictionary());
                    }
                    var httpRequest = ScriptFX.Net.HTTPRequest.createRequest(this._getCallBrokerUrl(), ScriptFX.Net.HTTPVerb.POST);
                    httpRequest.set_content(Framework.JsonUtil.serialize(multiplexPayload));
                    httpRequest.invoke(Delegate.create(this, function(request, context) {
                        var multiplexedRpcTasks = context;
                        if (request.get_state() === ScriptFX.Net.HTTPRequestState.completed) {
                            if (request.get_response().get_statusCode() === ScriptFX.Net.HTTPStatusCode.OK) {
                                var multiplexResponses = Framework.JsonUtil.deserialize(request.get_response().getText());
                                for (var i = 0; i < multiplexResponses.length; i++) {
                                    this._invokeSingleRpcCallback(multiplexedRpcTasks[i], multiplexResponses[i]);
                                }
                            }
                            else {
                                var remoteExceptionResponse = { exceptionType: 'RemoteException' };
                                for (var i = 0; i < multiplexedRpcTasks.length; i++) {
                                    this._invokeSingleRpcCallback(multiplexedRpcTasks[i], remoteExceptionResponse);
                                }
                            }
                        }
                        else {
                            var remoteExceptionResponse = { exceptionType: 'RemoteException' };
                            for (var i = 0; i < multiplexedRpcTasks.length; i++) {
                                this._invokeSingleRpcCallback(multiplexedRpcTasks[i], remoteExceptionResponse);
                            }
                        }
                    }), this._multiplexedRpcTasks);
                    this._multiplexedRpcTasks = [];
                }), 0);
            }
            this._multiplexedRpcTasks.add(rpcTask);
        }
        else {
            var httpRequest = ScriptFX.Net.HTTPRequest.createRequest(this._getCallBrokerUrl(), ScriptFX.Net.HTTPVerb.POST);
            httpRequest.set_content(rpcTask.getRequestPayload());
            httpRequest.invoke(Delegate.create(this, function(request, context) {
                (context).processResponse(request.get_response());
            }), rpcTask);
        }
    },
    
    _invokeSingleRpcCallback: function Framework_AbstractEnvironment$_invokeSingleRpcCallback(jsonRpcTask, singleResponse) {
        var exceptionType = singleResponse['exceptionType'];
        window.setTimeout(Delegate.create(this, function() {
            if (String.isNullOrEmpty(exceptionType)) {
                jsonRpcTask.get_jsonRpcSuccessCallback().invoke(singleResponse['result']);
            }
            else {
                jsonRpcTask.get_jsonRpcFailureCallback().invoke(Framework.ExceptionUtil.createException(exceptionType, singleResponse['message']));
            }
        }), 0);
    },
    
    invokeAsyncUsingJsonp: function Framework_AbstractEnvironment$invokeAsyncUsingJsonp(serviceName, methodName, arguments, successCallback, failureCallback, isHttpsForced) {
        var rpcTask = new Framework.JsonRpcTask(serviceName, methodName, this.getLanguage(), arguments, successCallback, failureCallback);
        var callBrokerUrl = (isHttpsForced && String.compare(window.location.protocol, 'https:')) ? 'https://' + window.location.hostname + '/CallBroker.ashx' : '/CallBroker.ashx';
        var httpRequest = ScriptFX.Net.HTTPRequest.createRequest(ScriptFX.Net.HTTPTransport.createURI(callBrokerUrl + '?payload=' + rpcTask.getRequestPayload(), ScriptFX.Net.ScriptTransport, null), ScriptFX.Net.HTTPVerb.GET);
        httpRequest.set_timeout(Framework.AbstractEnvironment._jsonpRequestTimeout);
        httpRequest.invoke(Delegate.create(this, function(request, context) {
            if (request.get_state() === ScriptFX.Net.HTTPRequestState.completed) {
                (context).processResponse(request.get_response());
            }
            else {
                failureCallback.invoke(Framework.ExceptionUtil.createException('RemoteException', null));
            }
        }), rpcTask);
    },
    
    storeState: function Framework_AbstractEnvironment$storeState(serviceName, state) {
        this._state[serviceName] = state;
    },
    
    getStoredState: function Framework_AbstractEnvironment$getStoredState(serviceName) {
        return this._state[serviceName];
    },
    
    _debugInfo: null,
    
    get_debugInfo: function Framework_AbstractEnvironment$get_debugInfo() {
        return this._debugInfo;
    },
    
    _fetchDebugInfo: function Framework_AbstractEnvironment$_fetchDebugInfo() {
        Framework.AbstractEnvironment._log.debug('FetchDebugInfo');
        this.invokeAsync('DebugService', 'GetDebugInfo', {}, Delegate.create(this, function(result) {
            this._debugInfo = result;
        }), Delegate.create(this, function(exception) {
        }));
    },
    
    getCookie: function Framework_AbstractEnvironment$getCookie(name) {
        return Framework.CookieUtil.getCookie(name);
    },
    
    setCookie: function Framework_AbstractEnvironment$setCookie(name, value) {
        Framework.CookieUtil.setCookie(name, value);
    },
    
    setCookieWithDays: function Framework_AbstractEnvironment$setCookieWithDays(name, value, numberOfDays) {
        Framework.CookieUtil.setCookieWithDays(name, value, numberOfDays);
    },
    
    clearCookie: function Framework_AbstractEnvironment$clearCookie(name) {
        Framework.CookieUtil.clearCookie(name);
    },
    
    clearCookies: function Framework_AbstractEnvironment$clearCookies() {
        Framework.CookieUtil.clearCookies();
    },
    
    getBaselineUrl: function Framework_AbstractEnvironment$getBaselineUrl(isSecure) {
        return window.location.href.substr(0, window.location.href.toUpperCase().indexOf('AREAS')).replace(new RegExp('^http[s]*:'), (isSecure) ? 'https:' : 'http:');
    },
    
    _calculateHash: function Framework_AbstractEnvironment$_calculateHash(pageFilter, putHashOnStart) {
        var result = (putHashOnStart) ? '#' : String.Empty;
        var current = 0;
        var $dict1 = pageFilter;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            if (!String.isNullOrEmpty(entry.key) && !String.isNullOrEmpty(entry.value)) {
                result += String.format('{0}{1}={2}', (!current++) ? String.Empty : '&', entry.key, entry.value);
            }
        }
        return result;
    },
    
    getHash: function Framework_AbstractEnvironment$getHash(pageFilter) {
        throw new Error('Not implemented');
    },
    
    setHash: function Framework_AbstractEnvironment$setHash(pageFilter) {
        var hash = this._calculateHash(pageFilter, false);
        if (!isNullOrUndefined(hash) && !String.isNullOrEmpty(hash)) {
            try {
                var historyManager = ScriptFX.Application.current.get_history();
                if (historyManager) {
                    historyManager.addEntry(hash);
                }
            }
            catch ($e1) {
            }
        }
        window.location.hash = hash;
    },
    
    changeLocation: function Framework_AbstractEnvironment$changeLocation(pageArea, pageFilter, storeServicesStates, protocol) {
        this.firePageWillChangeEvent();
        var url = '/Areas/' + pageArea + '/Template_' + this._region + '_' + this._language + '/index.html';
        var hash = this._calculateHash(pageFilter, false);
        if (!isNullOrUndefined(hash) && !String.isNullOrEmpty(hash)) {
            ScriptFX.Application.current.get_history().addEntry(hash);
        }
        var completeURL = '';
        if (!String.isNullOrEmpty(protocol)) {
            completeURL = String.format('{0}://{1}{2}{3}', protocol, window.location.hostname, ((window.location.port === 80) || (window.location.port === 443)) ? '' : (':' + window.location.port), url);
            window.navigate(completeURL + '#' + hash);
        }
        else {
            window.navigate(url + '#' + hash);
        }
    },
    
    buildUrl: function Framework_AbstractEnvironment$buildUrl(pageArea, pageFilter, protocol) {
        var url = '/Areas/' + pageArea + '/Template_' + this._region + '_' + this._language + '/index.html';
        var isFirst = true;
        var $dict1 = pageFilter;
        for (var $key2 in $dict1) {
            var dictionaryEntry = { key: $key2, value: $dict1[$key2] };
            if (dictionaryEntry.key && dictionaryEntry.value) {
                url += String.format('{0}{1}={2}', ((isFirst) ? '#' : '&'), dictionaryEntry.key, dictionaryEntry.value);
                isFirst = false;
            }
        }
        if (String.isNullOrEmpty(window.location.port.toString())) {
            url = String.format('{0}://{1}{2}', (String.isNullOrEmpty(protocol)) ? this.getProtocol() : protocol, window.location.hostname, url);
        }
        return url;
    },
    
    changeRegion: function Framework_AbstractEnvironment$changeRegion(region, pageArea, pageFilter) {
        this._region = region;
        this.changeLocation(pageArea, pageFilter, true, String.Empty);
    },
    
    changeLanguage: function Framework_AbstractEnvironment$changeLanguage(language, pageArea, pageFilter) {
        this._language = language;
        this.changeLocation(pageArea, pageFilter, true, String.Empty);
    },
    
    safelySetCssClass: function Framework_AbstractEnvironment$safelySetCssClass(domElementId, className) {
        var element = document.getElementById(domElementId);
        this.safelySetCssClassOnElement(element, className);
    },
    
    safelyRemoveCssClass: function Framework_AbstractEnvironment$safelyRemoveCssClass(domElementId, className) {
        var element = document.getElementById(domElementId);
        this.safelyRemoveCssClassOnElement(element, className);
    },
    
    safelySetAndUnsetCssClass: function Framework_AbstractEnvironment$safelySetAndUnsetCssClass(domElementId, classNameToSet, classNameToUnset) {
        if (String.isNullOrEmpty(domElementId) || String.isNullOrEmpty(classNameToSet) || String.isNullOrEmpty(classNameToUnset)) {
            return;
        }
        var element = document.getElementById(domElementId);
        this.safelySetAndUnsetCssClassOnElement(element, classNameToSet, classNameToUnset);
    },
    
    safelySetAndUnsetCssClassIf: function Framework_AbstractEnvironment$safelySetAndUnsetCssClassIf(value, domElementId, classNameToSet, classNameToUnset) {
        if (String.isNullOrEmpty(domElementId) || String.isNullOrEmpty(classNameToSet) || String.isNullOrEmpty(classNameToUnset)) {
            return;
        }
        var element = document.getElementById(domElementId);
        this.safelySetAndUnsetCssClassOnElementIf(value, element, classNameToSet, classNameToUnset);
    },
    
    containsCssClass: function Framework_AbstractEnvironment$containsCssClass(domElementId, className) {
        var element = document.getElementById(domElementId);
        return this.containsCssClassOnElement(element, className);
    },
    
    safelySetCssClassOnElement: function Framework_AbstractEnvironment$safelySetCssClassOnElement(domElement, className) {
        if (domElement && !String.isNullOrEmpty(className)) {
            ScriptFX.UI.Element.addCSSClass(domElement, className);
        }
    },
    
    safelyRemoveCssClassOnElement: function Framework_AbstractEnvironment$safelyRemoveCssClassOnElement(domElement, className) {
        if (domElement && !String.isNullOrEmpty(className)) {
            ScriptFX.UI.Element.removeCSSClass(domElement, className);
        }
    },
    
    safelySetAndUnsetCssClassOnElement: function Framework_AbstractEnvironment$safelySetAndUnsetCssClassOnElement(domElement, classNameToSet, classNameToUnset) {
        if (String.isNullOrEmpty(classNameToSet) || String.isNullOrEmpty(classNameToUnset)) {
            return;
        }
        if (domElement) {
            ScriptFX.UI.Element.addCSSClass(domElement, classNameToSet);
            ScriptFX.UI.Element.removeCSSClass(domElement, classNameToUnset);
        }
    },
    
    safelySetAndUnsetCssClassOnElementIf: function Framework_AbstractEnvironment$safelySetAndUnsetCssClassOnElementIf(value, domElement, classNameToSet, classNameToUnset) {
        if (String.isNullOrEmpty(classNameToSet) || String.isNullOrEmpty(classNameToUnset)) {
            return;
        }
        if (domElement) {
            if (value) {
                ScriptFX.UI.Element.addCSSClass(domElement, classNameToSet);
                ScriptFX.UI.Element.removeCSSClass(domElement, classNameToUnset);
            }
            else {
                ScriptFX.UI.Element.addCSSClass(domElement, classNameToUnset);
                ScriptFX.UI.Element.removeCSSClass(domElement, classNameToSet);
            }
        }
    },
    
    containsCssClassOnElement: function Framework_AbstractEnvironment$containsCssClassOnElement(domElement, className) {
        if (domElement && !String.isNullOrEmpty(className)) {
            return ScriptFX.UI.Element.containsCSSClass(domElement, className);
        }
        return false;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AbstractService

Framework.AbstractService = function Framework_AbstractService() {
}
Framework.AbstractService.prototype = {
    _environment: null,
    _parameters: null,
    
    init: function Framework_AbstractService$init(environment, parameters) {
        this._environment = environment;
        this._parameters = parameters;
    },
    
    hello: function Framework_AbstractService$hello(name) {
        var arguments = {};
        arguments['name'] = name;
        return this._environment.invoke(Type.getInstanceType(this).get_name(), 'Hello', arguments);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.ComponentInfo

Framework.ComponentInfo = function Framework_ComponentInfo(positionName, componentName, componentNameOri) {
    this.positionName = positionName;
    this.componentName = componentName;
    this.componentNameOri = componentNameOri;
}
Framework.ComponentInfo.prototype = {
    positionName: null,
    componentName: null,
    componentNameOri: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.PagerCall

Framework.PagerCall = function Framework_PagerCall(action, pagenumber, args) {
    this.action = action;
    this.pagenumber = pagenumber;
    this.args = args;
}
Framework.PagerCall.prototype = {
    action: null,
    pagenumber: 0,
    args: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.MessageIndicators

Framework.MessageIndicators = function Framework_MessageIndicators() {
}
Framework.MessageIndicators.getIndicator = function Framework_MessageIndicators$getIndicator(key, prefix) {
    if (isNullOrUndefined(prefix)) {
        prefix = 'messageIndicator_';
    }
    var indicatorCtl = document.getElementById(prefix + key);
    if (isNullOrUndefined(indicatorCtl)) {
        return 'false';
    }
    return indicatorCtl.value;
}
Framework.MessageIndicators.isIndicatorTrue = function Framework_MessageIndicators$isIndicatorTrue(key, prefix) {
    return Framework.MessageIndicators.getIndicator(key, prefix) === Framework.MessageIndicators.trueVal;
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Pager

Framework.Pager = function Framework_Pager() {
}
Framework.Pager.getPage = function Framework_Pager$getPage(containerId, action, pagenumber, args, onCompleteDelegate) {
    var container = document.getElementById(containerId);
    if (!container) {
        return;
    }
    Framework.AbstractEnvironment.safeUpdateDomElementDirect(container, '<span class=\'waiting\'>&nbsp;</span>Loading, please wait...');
    Framework.PagerLastCall.setLastCall(containerId + '|' + action, new Framework.PagerCall(action, pagenumber, args));
    if (!onCompleteDelegate) {
        onCompleteDelegate = Framework.Pager.defaultCallBack;
    }
    var url = String.format('{0}.rails?pagenumber={1}', action, pagenumber);
    var $dict1 = args;
    for (var $key2 in $dict1) {
        var entry = { key: $key2, value: $dict1[$key2] };
        url += String.format('&{0}={1}', entry.key, entry.value);
    }
    var ajax = new Framework.AjaxUpdater(containerId, url, onCompleteDelegate, null);
    ajax.evalScripts = true;
    ajax.update();
}
Framework.Pager.getPageAgain = function Framework_Pager$getPageAgain(containerId, action, defaultargs, onCompleteDelegate) {
    var lastCall = Framework.PagerLastCall.getLastCall(containerId + '|' + action);
    if (lastCall) {
        Framework.Pager.getPage(containerId, lastCall.action, lastCall.pagenumber, lastCall.args, onCompleteDelegate);
    }
    else {
        Framework.Pager.getPage(containerId, action, 1, defaultargs, onCompleteDelegate);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.PagerLastCall

Framework.PagerLastCall = function Framework_PagerLastCall() {
}
Framework.PagerLastCall.setLastCall = function Framework_PagerLastCall$setLastCall(key, args) {
    Framework.PagerLastCall._callsByContainerId[key] = args;
}
Framework.PagerLastCall.getLastCall = function Framework_PagerLastCall$getLastCall(key) {
    var o = Framework.PagerLastCall._callsByContainerId[key];
    return ((!o) ? null : o);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.BubblingEvent

Framework.BubblingEvent = function Framework_BubblingEvent() {
}
Framework.BubblingEvent.parse = function Framework_BubblingEvent$parse(evt) {
    return ((evt));
}
Framework.BubblingEvent.prototype = {
    
    stopPropagation: function Framework_BubblingEvent$stopPropagation() {
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AdminClassNames

Framework.AdminClassNames = function Framework_AdminClassNames() {
}
Framework.AdminClassNames.prototype = {
    placeHolder: null,
    component: null,
    placeHolderHover: null,
    placeHolderSelected: null,
    parameter: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AdminUrls

Framework.AdminUrls = function Framework_AdminUrls() {
}
Framework.AdminUrls.prototype = {
    showParams: null,
    removeComponent: null,
    storeParams: null,
    save: null,
    revert: null,
    back: null,
    findComponents: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AdminPageIds

Framework.AdminPageIds = function Framework_AdminPageIds() {
}
Framework.AdminPageIds.prototype = {
    componentToolboxId: null,
    pageAreaToolboxId: null,
    adminMessageToolboxId: null,
    propertiesToolboxId: null,
    areaname: null,
    componentPropertiesId: null,
    messageBoxId: null,
    componentListId: null,
    savebuttonId: null,
    revertButtonId: null,
    backbuttonId: null,
    componentNameFilterId: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AdminUtil

Framework.AdminUtil = function Framework_AdminUtil() {
}
Framework.AdminUtil.prototype = {
    wiring: null,
    showMessage: null,
    currentComponentConfiguration: null,
    showComponentProperties: null,
    getElementsBySelector: null,
    cancelEdit: null,
    parseIndicators: null,
    
    isElementVisible: function Framework_AdminUtil$isElementVisible(id) {
        var element = document.getElementById(id);
        if (element && element.style.display.toLowerCase() !== 'none') {
            return true;
        }
        return false;
    },
    
    setVisibilityById: function Framework_AdminUtil$setVisibilityById(elementId, visible) {
        this.setVisibility(document.getElementById(elementId), visible);
    },
    
    setVisibility: function Framework_AdminUtil$setVisibility(element, visible) {
        if (element) {
            element.style.display = ((visible) ? '' : 'none');
        }
    },
    
    isToolboxElement: function Framework_AdminUtil$isToolboxElement(element) {
        if (element && element.tagName === 'SPAN' && element.parentNode.tagName === 'LI') {
            return true;
        }
        else {
            return false;
        }
    },
    
    setToolBoxVisibility: function Framework_AdminUtil$setToolBoxVisibility(visible, ids) {
        this.setVisibilityById(ids.componentToolboxId, visible);
        this.setVisibilityById(ids.pageAreaToolboxId, visible);
        this.setVisibilityById(ids.adminMessageToolboxId, visible);
    },
    
    confirmation: function Framework_AdminUtil$confirmation(componentName, positionName, action) {
        var c = confirm(String.format('Are you sure you want to {0} {1} in {2}?', action, componentName, positionName));
        if (c) {
            return true;
        }
        else {
            return false;
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AdminDragController

Framework.AdminDragController = function Framework_AdminDragController(dragArgs, util, ids) {
    this._dragstartLocation = new Framework.Position(0, 0);
    this._args = dragArgs;
    this._ids = ids;
    this._util = util;
}
Framework.AdminDragController.prototype = {
    _ids: null,
    _args: null,
    _util: null,
    _isDragging: false,
    _currentDrop: null,
    
    isDragging: function Framework_AdminDragController$isDragging() {
        return this._isDragging;
    },
    
    getCurrentDrop: function Framework_AdminDragController$getCurrentDrop() {
        return this._currentDrop;
    },
    
    onDragComponentStart: function Framework_AdminDragController$onDragComponentStart(e) {
        this._isDragging = true;
        var pos = Framework.DragController.getAbsolutePosition(e.srcElement);
        Framework.Droppables.setOffset(pos.x, pos.y);
        return false;
    },
    
    onDragComponentEnd: function Framework_AdminDragController$onDragComponentEnd(obj, x, y) {
        this._isDragging = false;
        this._util.cancelEdit.invoke();
        if (!obj) {
            return;
        }
        this._args.dragsRefresh.invoke();
        var drop = Framework.Droppables.getDroppable(x, y);
        if (!drop) {
            return;
        }
        this._util.currentComponentConfiguration = null;
        this._util.showComponentProperties.invoke(drop.id, obj.id);
        this._util.setToolBoxVisibility(false, this._ids);
    },
    
    onDrag: function Framework_AdminDragController$onDrag(obj, x, y) {
        var drop = Framework.Droppables.getDroppable(x, y);
        if (!drop || drop !== this._currentDrop) {
            if (this._currentDrop) {
                this._currentDrop.className = this._args.dropClassName;
            }
            if (drop) {
                drop.className = this._args.dropHoverClassName;
            }
            this._currentDrop = drop;
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AdminController

Framework.AdminController = function Framework_AdminController(util, classNames, urls, ids) {
    this._ids = ids;
    this._util = util;
    if (isNullOrUndefined(util.parseIndicators)) {
        util.parseIndicators = Delegate.create(this, this.parseIndicators);
    }
    if (isNullOrUndefined(util.showComponentProperties)) {
        util.showComponentProperties = Delegate.create(this, this.showComponentProperties);
    }
    if (isNullOrUndefined(util.showMessage)) {
        util.showMessage = Delegate.create(this, this.showMessage);
    }
    if (isNullOrUndefined(util.cancelEdit)) {
        util.cancelEdit = Delegate.create(this, this.cancelComponentEditing);
    }
    var dragArgs = new Framework.DragArgs();
    dragArgs.dragsRefresh = Delegate.create(this, this.refreshComponents);
    dragArgs.dropClassName = classNames.placeHolder;
    dragArgs.dropHoverClassName = classNames.placeHolderHover;
    dragArgs.dragClassName = classNames.component;
    this._dragController = new Framework.AdminDragController(dragArgs, util, ids);
    this._classNames = classNames;
    this._urls = urls;
    this.componentOnClickHandler = Delegate.create(this, this.componentOnClickHandle);
    var ctl = document.getElementById(this._ids.backbuttonId);
    if (!isNullOrUndefined(ctl)) {
        ctl.attachEvent('onclick', Delegate.create(this, this.goBack));
    }
    ctl = document.getElementById(this._ids.savebuttonId);
    if (!isNullOrUndefined(ctl)) {
        ctl.attachEvent('onclick', Delegate.create(this, this.saveArea));
    }
    ctl = document.getElementById(this._ids.revertButtonId);
    if (!isNullOrUndefined(ctl)) {
        ctl.attachEvent('onclick', Delegate.create(this, this.revertArea));
    }
    ctl = document.getElementById(this._ids.componentNameFilterId);
    if (!isNullOrUndefined(ctl)) {
        ctl.attachEvent('onkeyup', Delegate.create(this, this.findComponentsHandler));
    }
    this.findComponents('');
    this.buildIndexMaps();
}
Framework.AdminController.prototype = {
    _ids: null,
    _urls: null,
    _util: null,
    _dragController: null,
    _classNames: null,
    _editingComponent: null,
    _currentComponentConfiguration: null,
    _storedComponentInfo: null,
    _ComponentIndexMap: null,
    _PlaceHolderNextIndexMap: null,
    
    buildIndexMaps: function Framework_AdminController$buildIndexMaps() {
        this._ComponentIndexMap = {};
        this._PlaceHolderNextIndexMap = {};
        var positions = this._util.getElementsBySelector.invoke('.' + this._classNames.placeHolder);
        if (!isNullOrUndefined(positions)) {
            for (var i = 0; i < positions.length; i++) {
                var components = positions[i].childNodes;
                var nextIndex = 0;
                if (!isNullOrUndefined(components)) {
                    for (var j = 0; j < components.length; j++) {
                        if (!isNullOrUndefined(components[j].id)) {
                            this._ComponentIndexMap[components[j].id] = nextIndex;
                            nextIndex++;
                        }
                    }
                }
                this._PlaceHolderNextIndexMap[positions[i].id] = nextIndex;
            }
        }
    },
    
    getComponentIndex: function Framework_AdminController$getComponentIndex(componentName) {
        return this._ComponentIndexMap[componentName];
    },
    
    setComponentIndex: function Framework_AdminController$setComponentIndex(componentName, index) {
        this._ComponentIndexMap[componentName] = index;
    },
    
    getNextComponentIndex: function Framework_AdminController$getNextComponentIndex(placeholderName) {
        var next = this._PlaceHolderNextIndexMap[placeholderName];
        if (isNullOrUndefined(next)) {
            next = 0;
        }
        this._PlaceHolderNextIndexMap[placeholderName] = next + 1;
        return next;
    },
    
    setUpDraggables: function Framework_AdminController$setUpDraggables() {
        var containers = this._util.getElementsBySelector.invoke('.' + this._classNames.component);
        for (var i = 0; i < containers.length; i++) {
            var d = containers[i];
            if (d && this._util.isToolboxElement(d)) {
                var dctl = new Framework.DragController(d, null, null, null, null, null, false, false, null, null);
                d.onDragEnd = Delegate.create(this._dragController, this._dragController.onDragComponentEnd);
                d.onDrag = Delegate.create(this._dragController, this._dragController.onDrag);
                d.onDragStart = Delegate.create(this._dragController, this._dragController.onDragComponentStart);
            }
        }
    },
    
    showMessage: function Framework_AdminController$showMessage(message) {
        var e = document.getElementById(this._ids.messageBoxId);
        if (!isNullOrUndefined(e)) {
            this._util.setVisibility(e.parentNode, true);
            Framework.AbstractEnvironment.safeUpdateDomElementDirect(e, '<span class=\'waiting\'>&nbsp;</span>' + message);
        }
    },
    
    setUpDroppables: function Framework_AdminController$setUpDroppables() {
        var positions = this._util.getElementsBySelector.invoke('.' + this._classNames.placeHolder);
        for (var i = 0; i < positions.length; i++) {
            positions[i].innerHTML = positions[i].innerHTML + '&nbsp;';
            Framework.Droppables.add(positions[i]);
        }
    },
    
    setUpClickables: function Framework_AdminController$setUpClickables() {
        var allComponents = this._util.getElementsBySelector.invoke('.' + this._classNames.component);
        for (var i = 0; i < allComponents.length; i++) {
            if (allComponents[i] && !this._util.isToolboxElement(allComponents[i])) {
                this.setComponentClick(allComponents[i]);
            }
        }
    },
    
    setComponentClick: function Framework_AdminController$setComponentClick(element) {
        try {
            if (isNullOrUndefined(element)) {
                return;
            }
            if (isNullOrUndefined(element.tagName)) {
                return;
            }
            if (element.tagName.toUpperCase() === 'A') {
                element.setAttribute('href', '#');
                element.setAttribute('onclick', 'return false;');
            }
            if (element.tagName.toUpperCase() === 'INPUT') {
                element.setAttribute('onclick', 'return false;');
            }
            element.attachEvent('onclick', this.componentOnClickHandler);
            var childNodes = element.childNodes;
            if (!childNodes) {
                return;
            }
            for (var i = 0; i < childNodes.length; i++) {
                this.setComponentClick(childNodes[i]);
            }
        }
        catch ($e1) {
        }
    },
    
    getElementForClassNames: function Framework_AdminController$getElementForClassNames(element, classNames) {
        var $enum1 = classNames.getEnumerator();
        while ($enum1.moveNext()) {
            var className = $enum1.get_current();
            if (element.className === className) {
                return element;
            }
        }
        var parent = element.parentNode;
        if (parent) {
            return this.getElementForClassNames(parent, classNames);
        }
        return null;
    },
    
    getPlaceHolder: function Framework_AdminController$getPlaceHolder(element) {
        return this.getElementForClassNames(element, [ this._classNames.placeHolder, this._classNames.placeHolderHover ]);
    },
    
    getComponent: function Framework_AdminController$getComponent(element) {
        return this.getElementForClassNames(element, [ this._classNames.component ]);
    },
    
    componentOnClick: function Framework_AdminController$componentOnClick(evt) {
        var placeHolder = this.getPlaceHolder(evt.srcElement);
        var component = this.getComponent(evt.srcElement);
        if (placeHolder && component) {
            window.event.cancelBubble = true;
            if (ScriptFX.Application.current.get_host().get_name() === ScriptFX.HostName.IE) {
                window.event.cancelBubble = true;
            }
            else {
                Framework.BubblingEvent.parse(evt).stopPropagation();
            }
            this.editPositionComponent(component.id, placeHolder.id);
        }
    },
    
    checkComponentProperties: function Framework_AdminController$checkComponentProperties() {
        var hasUnfilledParams = document.getElementById('hasUnfilledParams');
        if (!this._editingComponent && hasUnfilledParams && hasUnfilledParams.value === 'False') {
            this._util.setVisibilityById(this._ids.propertiesToolboxId, false);
            var positionName = document.getElementById('positionName');
            var componentName = document.getElementById('componentName');
            var componentIndex = document.getElementById('componentIndex');
            if (!isNullOrUndefined(positionName) && !isNullOrUndefined(componentName) && !isNullOrUndefined(componentIndex)) {
                this.saveParameters(positionName.value, componentName.value, Number.parse(componentIndex.value));
            }
        }
    },
    
    showComponentProperties: function Framework_AdminController$showComponentProperties(positionName, componentName) {
        var propertiesToolbox = document.getElementById(this._ids.propertiesToolboxId);
        if (isNullOrUndefined(propertiesToolbox)) {
            return;
        }
        var propertiesContainer = document.getElementById(this._ids.componentPropertiesId);
        if (isNullOrUndefined(propertiesContainer)) {
            return;
        }
        var index = this.getComponentIndex(componentName);
        if (isNullOrUndefined(index)) {
            index = this.getNextComponentIndex(positionName);
        }
        this._util.setVisibility(propertiesToolbox, true);
        Framework.AbstractEnvironment.safeUpdateDomElementDirect(propertiesContainer, '<span class=\'waiting\'>&nbsp;</span>Loading, please wait...');
        var url = String.format('{0}.rails?areaname={1}&positionName={2}&componentName={3}&componentIndex={4}', this._urls.showParams, this._ids.areaname, positionName, componentName, index);
        var ajax = new Framework.AjaxUpdater(this._ids.componentPropertiesId, url, Delegate.create(this, this.checkComponentProperties), null);
        ajax.evalScripts = true;
        ajax.update();
    },
    
    clearSelections: function Framework_AdminController$clearSelections() {
        var allComponents = this._util.getElementsBySelector.invoke('.' + this._classNames.placeHolderSelected);
        for (var i = 0; i < allComponents.length; i++) {
            allComponents[i].className = this._classNames.component;
        }
    },
    
    editPositionComponent: function Framework_AdminController$editPositionComponent(componentName, positionName) {
        if (this.isAddingComponent()) {
            return;
        }
        this.clearSelections();
        this._editingComponent = document.getElementById(componentName);
        this._currentComponentConfiguration = this._util.wiring.getComponentConfiguration(componentName);
        this.showComponentProperties(positionName, componentName);
    },
    
    cancelAddComponent: function Framework_AdminController$cancelAddComponent(positionName, componentName, index) {
        this._util.setVisibilityById(this._ids.propertiesToolboxId, false);
        this._util.setVisibilityById(this._ids.adminMessageToolboxId, false);
        this._util.setVisibilityById(this._ids.componentToolboxId, true);
        var position = document.getElementById(positionName);
        if (position) {
            position.className = this._classNames.placeHolder;
        }
        this._editingComponent = null;
    },
    
    isAddingComponent: function Framework_AdminController$isAddingComponent() {
        if (this._dragController.isDragging()) {
            return true;
        }
        document.getElementById(this._ids.componentToolboxId);
        return !this._util.isElementVisible(this._ids.componentToolboxId);
    },
    
    removeComponent: function Framework_AdminController$removeComponent(positionName, componentName, index) {
        var args = String.format('areaname={0}&positionName={1}&componentName={2}&componentIndex={3}', this._ids.areaname, positionName, componentName, index);
        this._util.showMessage.invoke('Removing component parameter values, please wait...');
        var url = String.format('{0}.rails?{1}', this._urls.removeComponent, args);
        var ajax = new Framework.AjaxUpdater(this._ids.messageBoxId, url, this._util.parseIndicators, null);
        ajax.evalScripts = true;
        ajax.update();
    },
    
    saveParameters: function Framework_AdminController$saveParameters(positionName, componentName, index) {
        var args = String.format('areaname={0}&positionName={1}&componentName={2}&componentIndex={3}', this._ids.areaname, positionName, componentName, index);
        if (!this._currentComponentConfiguration) {
            this._currentComponentConfiguration = new Framework.ComponentConfiguration(componentName + '.' + componentName, null, new Array(0), {}, null, {});
        }
        this.setComponentIndex(componentName, index);
        var nextIndex = this._PlaceHolderNextIndexMap[positionName];
        if (index >= nextIndex) {
            this._PlaceHolderNextIndexMap[positionName] = index + 1;
        }
        var allParameters = this._util.getElementsBySelector.invoke('.' + this._classNames.parameter);
        for (var i = 0; i < allParameters.length; i++) {
            var node = allParameters[i];
            args += '&' + node.id + '=';
            if (node.type.toLowerCase() === 'checkbox') {
                this._currentComponentConfiguration.parameters[node.id] = (node).checked;
                args += (node).checked;
            }
            else {
                this._currentComponentConfiguration.parameters[node.id] = node.value;
                args += node.value;
            }
        }
        this._util.showMessage.invoke('Storing component parameter values, please wait...');
        var url = String.format('{0}.rails?{1}', this._urls.storeParams, args);
        var ajax = new Framework.AjaxUpdater(this._ids.messageBoxId, url, this._util.parseIndicators, null);
        var componentNameOri = componentName;
        var componentNameOriElement = document.getElementById('componentNameOri');
        if (!isNullOrUndefined(componentNameOriElement)) {
            componentNameOri = componentNameOriElement.value;
        }
        this._storedComponentInfo = new Framework.ComponentInfo(positionName, componentNameOri, componentNameOri);
        ajax.evalScripts = true;
        ajax.update();
    },
    
    ensureComponent: function Framework_AdminController$ensureComponent(positionName, componentName) {
        if (this._editingComponent) {
            this._util.wiring.updateComponent(this._storedComponentInfo.componentNameOri, this._currentComponentConfiguration);
        }
        else {
            this._util.wiring.addComponent(this._storedComponentInfo.componentNameOri, this._currentComponentConfiguration, positionName);
        }
        this._currentComponentConfiguration = null;
    },
    
    saveArea: function Framework_AdminController$saveArea() {
        if (this._util.confirmation('all changes', this._ids.areaname, 'save')) {
            this._util.showMessage.invoke('Saving all stored values, please wait...');
            var url = String.format('{0}.rails?areaname={1}', this._urls.save, this._ids.areaname);
            var ajax = new Framework.AjaxUpdater(this._ids.messageBoxId, url, this._util.parseIndicators, null);
            ajax.evalScripts = true;
            ajax.update();
        }
    },
    
    revertArea: function Framework_AdminController$revertArea() {
        if (this._util.confirmation('all unsaved changes', this._ids.areaname, 'undo')) {
            this._util.showMessage.invoke('Undoing all stored values, please wait...');
            var url = String.format('{0}.rails?areaname={1}', this._urls.revert, this._ids.areaname);
            var ajax = new Framework.AjaxUpdater(this._ids.messageBoxId, url, this._util.parseIndicators, null);
            ajax.evalScripts = true;
            ajax.update();
        }
    },
    
    findComponentsHandler: function Framework_AdminController$findComponentsHandler() {
        var evt = this._getWindowEvent();
        var ctl = evt.srcElement;
        var findString = '';
        if (!isNullOrUndefined(ctl)) {
            findString = ctl.value;
        }
        this.findComponents(findString);
    },
    
    findComponents: function Framework_AdminController$findComponents(findString) {
        Framework.Pager.getPage(this._ids.componentListId, this._urls.findComponents, 1, { nameContains: findString }, null);
    },
    
    refreshComponents: function Framework_AdminController$refreshComponents() {
        Framework.Pager.getPageAgain(this._ids.componentListId, this._urls.findComponents, { nameContains: '' }, null);
    },
    
    goBack: function Framework_AdminController$goBack() {
        window.navigate(this._urls.back);
    },
    
    componentOnClickHandle: function Framework_AdminController$componentOnClickHandle() {
        this.componentOnClick(this._getWindowEvent());
    },
    
    componentOnClickHandler: null,
    
    _getWindowEvent: function Framework_AdminController$_getWindowEvent() {
        return window.event;
    },
    
    parseIndicators: function Framework_AdminController$parseIndicators() {
        var runForAdmin = false;
        if (Framework.MessageIndicators.isIndicatorTrue('RemoveComponent', null)) {
            if (this._editingComponent) {
                runForAdmin = true;
                this._util.wiring.removeComponent(this._editingComponent.id);
                this._currentComponentConfiguration = null;
            }
        }
        if (Framework.MessageIndicators.isIndicatorTrue('ShowComponents', null)) {
            this._util.setVisibilityById(this._ids.componentToolboxId, true);
            this._util.setVisibilityById(this._ids.pageAreaToolboxId, true);
            var currentDrop = this._dragController.getCurrentDrop();
            if (!isNullOrUndefined(currentDrop)) {
                currentDrop.className = this._classNames.placeHolder;
                currentDrop = null;
            }
            if (!isNullOrUndefined(this._storedComponentInfo)) {
                runForAdmin = true;
                this.ensureComponent(this._storedComponentInfo.positionName, this._storedComponentInfo.componentName);
            }
            this._storedComponentInfo = null;
        }
        if (Framework.MessageIndicators.isIndicatorTrue('HideParameters', null)) {
            this.cancelComponentEditing();
        }
        if (Framework.MessageIndicators.isIndicatorTrue('RevertAll', null)) {
            eval('window.location.reload();');
        }
        if (runForAdmin) {
            this._util.wiring.runForAdmin();
            window.setTimeout(Delegate.create(this, this.setUpClickables), 1000);
            window.setTimeout(Delegate.create(this, this.buildIndexMaps), 1000);
        }
    },
    
    cancelComponentEditing: function Framework_AdminController$cancelComponentEditing() {
        if (!isNullOrUndefined(this._editingComponent)) {
            this._util.setVisibilityById(this._ids.propertiesToolboxId, false);
            this.clearSelections();
            this._editingComponent = null;
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AutoWiring

Framework.AutoWiring = function Framework_AutoWiring() {
    this._services = {};
    this._components = {};
}
Framework.AutoWiring.prototype = {
    _serviceConfiguration: null,
    _componentConfiguration: null,
    _componentPlacementMap: null,
    _environment: null,
    
    getComponents: function Framework_AutoWiring$getComponents() {
        return this._components;
    },
    
    getServices: function Framework_AutoWiring$getServices() {
        return this._services;
    },
    
    init: function Framework_AutoWiring$init(servicesConfigurations, componentsConfiguration, componentsPlacementMap, encodedXsltDocumentsMap) {
        this._serviceConfiguration = servicesConfigurations;
        this._componentConfiguration = componentsConfiguration;
        this._componentPlacementMap = componentsPlacementMap;
        var $dict1 = encodedXsltDocumentsMap;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            var document = XMLDocumentParser.parse(entry.value);
            Framework.Component.Updating.UpdateXsltBasedComponentTask.storeXsltDocument(entry.key, document);
            Framework.TransformAndUpdateTask.storeXsltDocument(entry.key, document);
        }
    },
    
    _initDebuggingLayer: function Framework_AutoWiring$_initDebuggingLayer() {
        var div1 = document.createElement('div');
        div1.setAttribute('class', 'debug-layer');
        var img = document.createElement('img');
        img.setAttribute('alt', 'debug');
        img.setAttribute('src', '../../../bug.png');
        img.setAttribute('onclick', 'if ($(\'debug-area\').style.display == \'none\') $(\'debug-area\').style.display = \'block\'; else $(\'debug-area\').style.display = \'none\';');
        div1.appendChild(img);
        var div2 = document.createElement('div');
        div2.setAttribute('id', 'debug-area');
        div2.setAttribute('class', 'debug-area');
        div2.setAttribute('style', 'display : none');
        div1.appendChild(div2);
        var input1 = document.createElement('input');
        input1.setAttribute('type', 'button');
        input1.setAttribute('value', 'Clear Debug');
        input1.setAttribute('onclick', '$(\'debug\').innerHTML=\'\';');
        div2.appendChild(input1);
        var input2 = document.createElement('input');
        input2.setAttribute('type', 'button');
        input2.setAttribute('value', 'Switch');
        input2.setAttribute('onclick', 'Framework._log.switchLogging();');
        div2.appendChild(input2);
        var br = document.createElement('br');
        div2.appendChild(br);
        var div3 = document.createElement('div');
        div3.setAttribute('id', 'debug');
        div3.setAttribute('class', 'debug');
        div2.appendChild(div3);
        document.getElementsByTagName('body')[0].insertBefore(div1, document.getElementsByTagName('body')[0].childNodes[0]);
    },
    
    _initEnvironment: function Framework_AutoWiring$_initEnvironment() {
        Framework.AutoWiring._log.debug('InitEnvironment');
        var initialPageFilter = {};
        var parts = (new RegExp('/([^/]*)/[Tt][Ee][Mm][Pp][Ll][Aa][Tt][Ee]_([^_]*)_([^/]*)/')).exec(window.location.toString());
        var initialPageArea = parts[1];
        Framework.AutoWiring._log.debug('Extracted initial page area ' + initialPageArea);
        var initialRegion = parts[2];
        Framework.AutoWiring._log.debug('Extracted initial region ' + initialRegion);
        var initialLanguage = parts[3];
        Framework.AutoWiring._log.debug('Extracted initial language ' + initialLanguage);
        var searchTokens = ((window.location.search.startsWith('?')) ? window.location.search.substr(1) : window.location.search).split(new RegExp('\\&|='));
        var debug = false;
        for (var i = 0; i < searchTokens.length; i += 2) {
            var name = searchTokens[i];
            var value = (i + 1 <= searchTokens.length) ? searchTokens[i + 1] : null;
            if (String.equals('debug', name, true)) {
                this._initDebuggingLayer();
                Framework.Logger.switchLogging();
                debug = true;
            }
            else if (String.equals('maxlogsize', name, true)) {
                Framework.Logger.setMaximumLogSize(Number.parse(value));
            }
            else {
                initialPageFilter[name] = value;
            }
        }
        var hashTokens = ((window.location.hash.startsWith('#')) ? window.location.hash.substr(1) : window.location.hash).split(new RegExp('\\&|='));
        for (var i = 0; i < hashTokens.length; i += 2) {
            var name = hashTokens[i];
            var value = (i + 1 <= hashTokens.length) ? hashTokens[i + 1] : null;
            Framework.AutoWiring._log.debug(String.format('Processing hash tokens [{0}] [{1}]', name, value));
            if (value) {
                initialPageFilter[name] = value;
            }
        }
        Framework.AbstractEnvironment._debugMode = debug;
        this._environment = new Framework.AbstractEnvironment(this._components, this._services);
        this._environment.init(initialLanguage, initialRegion, initialPageArea, initialPageFilter);
    },
    
    _initServices: function Framework_AutoWiring$_initServices() {
        Framework.AutoWiring._log.debug('InitServices');
        var $dict1 = this._serviceConfiguration;
        for (var $key2 in $dict1) {
            var serviceConfigurationDictionaryEntry = { key: $key2, value: $dict1[$key2] };
            var serviceName = serviceConfigurationDictionaryEntry.key;
            Framework.AutoWiring._log.debug(String.format('Processing {0}', serviceName));
            var serviceConfiguration = serviceConfigurationDictionaryEntry.value;
            var serviceType = Type.getType(serviceConfiguration.className);
            var service = new serviceType();
            this._services[serviceName] = service;
            service.init(this._environment, serviceConfiguration.parameters);
        }
        var $dict3 = this._services;
        for (var $key4 in $dict3) {
            var serviceDictionaryEntry = { key: $key4, value: $dict3[$key4] };
            var serviceName = serviceDictionaryEntry.key;
            Framework.AutoWiring._log.debug(String.format('Connecting services to {0}', serviceName));
            var service = serviceDictionaryEntry.value;
            var serviceConfiguration = this._serviceConfiguration[serviceName];
            var $enum5 = serviceConfiguration.requiredServices.getEnumerator();
            while ($enum5.moveNext()) {
                var requiredServiceName = $enum5.get_current();
                Framework.AutoWiring._log.debug(String.format('Injecting [{0}] into [{1}]', requiredServiceName, serviceDictionaryEntry.key));
                var requiredService = this._services[requiredServiceName];
                service['set' + Type.getInstanceType(requiredService).get_name()](requiredService);
            }
            Framework.AutoWiring._log.debug(String.format('Subscribing to events {0}', serviceName));
            var $dict6 = serviceConfiguration.connectEvents;
            for (var $key7 in $dict6) {
                var connectedEventsDictionaryEntry = { key: $key7, value: $dict6[$key7] };
                var serviceToConnectTo = this._services[connectedEventsDictionaryEntry.key];
                var events = connectedEventsDictionaryEntry.value;
                if ((events.length === 1) && (!'*'.compareTo(events[0]))) {
                }
                else {
                    var $enum8 = events.getEnumerator();
                    while ($enum8.moveNext()) {
                        var eventName = $enum8.get_current();
                        serviceToConnectTo['register' + eventName + 'Listener'](service);
                    }
                }
            }
        }
    },
    
    getComponentName: function Framework_AutoWiring$getComponentName(placeHolderId, componentClassName) {
        var componentNames = this._componentPlacementMap[placeHolderId];
        var $enum1 = componentNames.getEnumerator();
        while ($enum1.moveNext()) {
            var componentName = $enum1.get_current();
            var config = this.getComponentConfiguration(componentName);
            if (config.className === componentClassName) {
                return componentName;
            }
        }
        return null;
    },
    
    _getComponentPlaceholderId: function Framework_AutoWiring$_getComponentPlaceholderId(componentPlacementMap, componentName) {
        var $dict1 = componentPlacementMap;
        for (var $key2 in $dict1) {
            var placeholderComps = { key: $key2, value: $dict1[$key2] };
            var componentNames = placeholderComps.value;
            var $enum3 = componentNames.getEnumerator();
            while ($enum3.moveNext()) {
                var componentNameItem = $enum3.get_current();
                if (componentNameItem === componentName) {
                    return placeholderComps.key;
                }
            }
        }
        return null;
    },
    
    _initComponents: function Framework_AutoWiring$_initComponents() {
        Framework.AutoWiring._log.debug('InitComponents');
        var $dict1 = this._componentConfiguration;
        for (var $key2 in $dict1) {
            var componentConfigurationDictionaryEntry = { key: $key2, value: $dict1[$key2] };
            var componentName = componentConfigurationDictionaryEntry.key;
            this._components[componentName] = Framework.Component.ComponentFactory.create(componentName, componentConfigurationDictionaryEntry.value, this._getComponentPlaceholderId(this._componentPlacementMap, componentName), this._environment);
        }
        var $dict3 = this._components;
        for (var $key4 in $dict3) {
            var componentDictionaryEntry = { key: $key4, value: $dict3[$key4] };
            var componentName = componentDictionaryEntry.key;
            var component = componentDictionaryEntry.value;
            var componentConfigurationItem = this._componentConfiguration[componentName];
            Framework.Component.ComponentFactory.initialize(componentName, component, componentConfigurationItem, this._services, this._components);
        }
    },
    
    _startEnvironment: function Framework_AutoWiring$_startEnvironment() {
        Framework.AutoWiring._log.debug('StartEnvironment');
        this._environment.start();
    },
    
    _startServices: function Framework_AutoWiring$_startServices() {
        Framework.AutoWiring._log.debug('StartServices');
        var $dict1 = this._services;
        for (var $key2 in $dict1) {
            var serviceDictionaryEntry = { key: $key2, value: $dict1[$key2] };
            var service = serviceDictionaryEntry.value;
            service.start();
        }
    },
    
    _startTopLevelComponents: function Framework_AutoWiring$_startTopLevelComponents() {
        Framework.AutoWiring._log.debug('StartComponents');
        var $dict1 = this._components;
        for (var $key2 in $dict1) {
            var componentDictionaryEntry = { key: $key2, value: $dict1[$key2] };
            var component = componentDictionaryEntry.value;
            if (!component.get_parent()) {
                component.componentLifeCycleManager.start();
            }
        }
    },
    
    _startCompleted: false,
    _eventTimeout: 0,
    _safetyTimeout: 0,
    
    run: function Framework_AutoWiring$run() {
        Framework.AutoWiring._log.debug('run');
        this._initEnvironment();
        this._initServices();
        this._initComponents();
        if (ScriptFX.Application.current && ScriptFX.Application.current.get_history().get_isEnabled()) {
            ScriptFX.Application.current.add_load(Delegate.create(this, this.timeOutToRunStart));
            this._safetyTimeout = window.setTimeout(Delegate.create(this, this.runStart), 10 * 1000);
        }
        else {
            this.runStart();
        }
    },
    
    timeOutToRunStart: function Framework_AutoWiring$timeOutToRunStart(sender, args) {
        this._eventTimeout = window.setTimeout(Delegate.create(this, this.runStart), 1);
    },
    
    runStart: function Framework_AutoWiring$runStart() {
        if (!this._startCompleted) {
            window.clearTimeout(this._eventTimeout);
            window.clearTimeout(this._safetyTimeout);
            this._startCompleted = true;
            this._startEnvironment();
            this._startServices();
            this._startTopLevelComponents();
        }
    },
    
    _counter: 0,
    
    addComponent: function Framework_AutoWiring$addComponent(componentNameBase, newComponentConfiguration, placeholderId) {
        if (isNullOrUndefined(this._counter) || !this._counter) {
            this._counter = Object.getKeyCount(this._components) + 1;
        }
        var componentName = String.format('{0}{1}', componentNameBase, this._counter++);
        this._componentConfiguration[componentName] = newComponentConfiguration;
        var componentsForPlaceHolder = this._componentPlacementMap[placeholderId];
        if (!componentsForPlaceHolder) {
            componentsForPlaceHolder = new Array(0);
        }
        var componentsForPlaceHolderAdded = new Array(componentsForPlaceHolder.length + 1);
        for (var i = 0; i < componentsForPlaceHolder.length; i++) {
            componentsForPlaceHolderAdded[i] = componentsForPlaceHolder[i];
        }
        componentsForPlaceHolderAdded[componentsForPlaceHolder.length] = componentName;
        this._componentPlacementMap[placeholderId] = componentsForPlaceHolderAdded;
    },
    
    removeComponent: function Framework_AutoWiring$removeComponent(componentName) {
        var element = this._environment.getDomElement(componentName);
        if (element && element.parentNode) {
            element.parentNode.removeChild(element);
        }
        var placeholderId = this._getComponentPlaceholderId(this._componentPlacementMap, componentName);
        var componentsForPlaceHolder = this._componentPlacementMap[placeholderId];
        var componentsForPlaceHolderArr = [];
        for (var i = 0; i < componentsForPlaceHolder.length; i++) {
            if (componentsForPlaceHolder[i] !== componentName) {
                componentsForPlaceHolderArr.add(componentsForPlaceHolder[i]);
            }
        }
        componentsForPlaceHolder = new Array(componentsForPlaceHolderArr.length);
        for (var i = 0; i < componentsForPlaceHolderArr.length; i++) {
            componentsForPlaceHolder[i] = componentsForPlaceHolderArr[i];
        }
        this._componentPlacementMap[placeholderId] = componentsForPlaceHolder;
        delete this._componentConfiguration[componentName];
        if (!componentsForPlaceHolder.length) {
            this._environment.updateDomElement(placeholderId, '&nbsp;');
        }
    },
    
    updateComponent: function Framework_AutoWiring$updateComponent(componentName, newComponentConfiguration) {
        this._componentConfiguration[componentName] = newComponentConfiguration;
    },
    
    getComponentConfiguration: function Framework_AutoWiring$getComponentConfiguration(componentName) {
        return this._componentConfiguration[componentName];
    },
    
    runForAdmin: function Framework_AutoWiring$runForAdmin() {
        Framework.AutoWiring._log.debug('RunForAdmin');
        this._initEnvironment();
        this._components = {};
        var $dict1 = this._componentConfiguration;
        for (var $key2 in $dict1) {
            var componentConfigurationDictionaryEntry = { key: $key2, value: $dict1[$key2] };
            var componentName = componentConfigurationDictionaryEntry.key;
            Framework.AutoWiring._log.debug(String.format('Processing {0}', componentName));
            var componentConfigurationItem = componentConfigurationDictionaryEntry.value;
            var component = eval('new ' + componentConfigurationItem.className + '();');
            this._components[componentName] = component;
            var placeholderId = this._getComponentPlaceholderId(this._componentPlacementMap, componentName);
            if (!this._environment.getDomElement(componentName)) {
                var componentDocumentElement = document.createElement('div');
                componentDocumentElement.className = 'component';
                componentDocumentElement.id = componentName;
                document.getElementById(placeholderId).appendChild(componentDocumentElement);
            }
            component.init(this._environment, String.format('autoWiring.getComponents()[\'{0}\']', componentName), componentName, componentConfigurationItem.parameters);
            component.repaintForAdmin();
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.ComponentConfiguration

Framework.ComponentConfiguration = function Framework_ComponentConfiguration(className, childID, requiredServices, parameters, childComponents, connectEvents) {
    this.className = className;
    this.requiredServices = requiredServices;
    this.childID = childID;
    this.parameters = parameters;
    this.connectEvents = connectEvents;
    this.childComponents = childComponents;
}
Framework.ComponentConfiguration.prototype = {
    className: null,
    requiredServices: null,
    childComponents: null,
    childID: null,
    parameters: null,
    connectEvents: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.CommonComponentParameters

Framework.CommonComponentParameters = function Framework_CommonComponentParameters(parameters) {
    this._visibleOn = [];
    this._notVisibleOn = [];
    if (!String.isNullOrEmpty(parameters['visible-on'])) {
        this._visibleOn = (parameters['visible-on']).split(',');
    }
    if (!String.isNullOrEmpty(parameters['not-visible-on'])) {
        this._notVisibleOn = (parameters['not-visible-on']).split(',');
    }
    var $enum1 = this._visibleOn.getEnumerator();
    while ($enum1.moveNext()) {
        var i = $enum1.get_current();
        var $enum2 = this._notVisibleOn.getEnumerator();
        while ($enum2.moveNext()) {
            var j = $enum2.get_current();
            if (i === j) {
                throw new Error(String.format('visible-on and not-visible-on cannot contain the same action(s) [{0}]', i));
            }
        }
    }
    this._xsltUrl = parameters['xslt-url'];
    Framework.CommonComponentParameters._log.debug('xsltUrl = [' + this._xsltUrl + ']');
    this._contentUrl = parameters['content-url'];
    Framework.CommonComponentParameters._log.debug('contentUrl = [' + this._contentUrl + ']');
}
Framework.CommonComponentParameters.prototype = {
    
    get_visibleOn: function Framework_CommonComponentParameters$get_visibleOn() {
        return this._visibleOn;
    },
    
    get_notVisibleOn: function Framework_CommonComponentParameters$get_notVisibleOn() {
        return this._notVisibleOn;
    },
    
    _contentUrl: null,
    
    get_contentUrl: function Framework_CommonComponentParameters$get_contentUrl() {
        return this._contentUrl;
    },
    
    _xsltUrl: null,
    
    get_xsltUrl: function Framework_CommonComponentParameters$get_xsltUrl() {
        return this._xsltUrl;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.CookieUtil

Framework.CookieUtil = function Framework_CookieUtil() {
}
Framework.CookieUtil.getCookie = function Framework_CookieUtil$getCookie(name) {
    var cookieName = name + '=';
    var documentCookie = document.cookie.split(';');
    for (var i = 0; i < documentCookie.length; i++) {
        var index = documentCookie[i];
        while (index.charAt(0) === ' ') {
            index = index.substring(1, index.length);
        }
        if (!index.indexOf(cookieName)) {
            return unescape(index.substring(cookieName.length, index.length));
        }
    }
    return null;
}
Framework.CookieUtil.setCookie = function Framework_CookieUtil$setCookie(name, value) {
    document.cookie = String.format('{0}={1}; expires={2}; path=/', name, escape(value), Framework.CookieUtil.getDateTime(365));
}
Framework.CookieUtil.setCookieWithDays = function Framework_CookieUtil$setCookieWithDays(name, value, numberOfDays) {
    document.cookie = String.format('{0}={1}; expires={2}; path=/', name, escape(value), Framework.CookieUtil.getDateTime(numberOfDays));
}
Framework.CookieUtil.clearCookie = function Framework_CookieUtil$clearCookie(name) {
    Framework.CookieUtil.setCookieWithDays(name, '', -1);
}
Framework.CookieUtil.clearCookies = function Framework_CookieUtil$clearCookies() {
    var allCookies = document.cookie.split(';');
    for (var i = 0; i < allCookies.length; i++) {
        var currentCookie = allCookies[i].split('=');
        if (currentCookie[0]) {
            Framework.CookieUtil.setCookieWithDays(currentCookie[0], '', -1);
        }
    }
}
Framework.CookieUtil.getDateTime = function Framework_CookieUtil$getDateTime(numberOfDays) {
    var dt = new Date();
    dt.setTime(dt.getTime() + numberOfDays * 86400000);
    return dt.toUTCString();
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AjaxUpdater

Framework.AjaxUpdater = function Framework_AjaxUpdater(domElementId, url, afterUpdateCallback, afterErrorCallback) {
    this._domElementId = domElementId;
    this._url = url;
    this._afterUpdateCallback = afterUpdateCallback;
    this._afterErrorCallback = afterErrorCallback;
}
Framework.AjaxUpdater.prototype = {
    _domElementId: null,
    _url: null,
    _request: null,
    _afterUpdateCallback: null,
    _afterErrorCallback: null,
    evalScripts: false,
    _scripts: null,
    
    _extractScripts: function Framework_AjaxUpdater$_extractScripts(responseText) {
        var regex = new RegExp(Framework.AjaxUpdater._scriptregex, 'img');
        var regexInner = new RegExp(Framework.AjaxUpdater._scriptregex, 'im');
        var scriptBlocks = responseText.match(regex);
        if (!scriptBlocks) {
            return new Array(0);
        }
        var scripts = new Array(scriptBlocks.length);
        for (var i = 0; i < scriptBlocks.length; i++) {
            var scriptBlockParts = scriptBlocks[i].match(regexInner);
            if (!scriptBlockParts || !scriptBlockParts.length) {
                scripts[i] = '';
            }
            else {
                scripts[i] = scriptBlockParts[scriptBlockParts.length - 1];
            }
        }
        return scripts;
    },
    
    executeScripts: function Framework_AjaxUpdater$executeScripts() {
        var $enum1 = this._scripts.getEnumerator();
        while ($enum1.moveNext()) {
            var script = $enum1.get_current();
            if (!String.isNullOrEmpty(script)) {
                eval(script);
            }
        }
    },
    
    update: function Framework_AjaxUpdater$update() {
        if (!this._url && this._afterErrorCallback) {
            this._afterErrorCallback.invoke();
            return;
        }
        this._request = new Framework.XMLHttpRequestDecorator();
        this._request.onreadystatechange = Delegate.create(this, function() {
            if (this._request.readyState === 4) {
                if (this._request.status === 200 || this._request.status === 304) {
                    Framework.AbstractEnvironment.safeUpdateDomElement(this._domElementId, this._request.responseText);
                    if (this.evalScripts) {
                        this._scripts = this._extractScripts(this._request.responseText);
                        window.setTimeout(Delegate.create(this, this.executeScripts), 10);
                        this.executeScripts();
                    }
                    if (this._afterUpdateCallback) {
                        this._afterUpdateCallback.invoke();
                    }
                }
                else if (this._afterErrorCallback) {
                    this._afterErrorCallback.invoke();
                }
            }
        });
        this._request.open('GET', this._url, true);
        this._request.send(null);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AbstractMessagingService

Framework.AbstractMessagingService = function Framework_AbstractMessagingService() {
    this._topics$1 = {};
    this._topicChangedListeners$1 = {};
    Framework.AbstractMessagingService.constructBase(this);
}
Framework.AbstractMessagingService.prototype = {
    
    registerTopicChangedListener: function Framework_AbstractMessagingService$registerTopicChangedListener(topicChangedListener, topic) {
        Framework.AbstractMessagingService._log$1.debug(String.format('RegisterTopicChangedListener topic=[{0}]', topic));
        if (!Object.keyExists(this._topicChangedListeners$1, topic)) {
            this._topicChangedListeners$1[topic] = [];
        }
        if (!(this._topicChangedListeners$1[topic]).contains(topicChangedListener)) {
            (this._topicChangedListeners$1[topic]).add(topicChangedListener);
        }
    },
    
    _fireTopicChangedEvent$1: function Framework_AbstractMessagingService$_fireTopicChangedEvent$1(listeners) {
        Framework.AbstractMessagingService._log$1.debug('FireTopicChangedEvent');
        var $enum1 = listeners.getEnumerator();
        while ($enum1.moveNext()) {
            var listener = $enum1.get_current();
            try {
                listener.onTopicChanged(this);
            }
            catch (e) {
                Framework.AbstractMessagingService._log$1.error('FireTopicChangedEvent OnTopicChanged', e);
            }
        }
    },
    
    getAllTopics: function Framework_AbstractMessagingService$getAllTopics() {
        var result = {};
        var $dict1 = this._topics$1;
        for (var $key2 in $dict1) {
            var de = { key: $key2, value: $dict1[$key2] };
            result[de.key] = de.value;
        }
        return result;
    },
    
    setAllTopics: function Framework_AbstractMessagingService$setAllTopics(topics) {
        var changedTopics = [];
        var $dict1 = this._topics$1;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            if (!Object.keyExists(topics, entry.key) || topics[entry.key] !== entry.value) {
                changedTopics.add(entry.key);
            }
        }
        var $dict3 = topics;
        for (var $key4 in $dict3) {
            var entry = { key: $key4, value: $dict3[$key4] };
            if (!changedTopics.contains(entry.key) && (!Object.keyExists(this._topics$1, entry.key) || this._topics$1[entry.key] !== entry.value)) {
                changedTopics.add(entry.key);
            }
        }
        var listeners = [];
        for (var i = 0; i < changedTopics.length; i++) {
            var topicListeners = [];
            if (Object.keyExists(this._topicChangedListeners$1, changedTopics[i])) {
                topicListeners = this._topicChangedListeners$1[changedTopics[i]];
            }
            for (var j = 0; j < topicListeners.length; j++) {
                if (!listeners.contains(topicListeners[j])) {
                    listeners.add(topicListeners[j]);
                }
            }
        }
        if (changedTopics.length > 0) {
            this._topics$1 = topics;
            this._fireTopicChangedEvent$1(listeners);
        }
    },
    
    getTopic: function Framework_AbstractMessagingService$getTopic(topic) {
        return this._topics$1[topic];
    },
    
    setTopic: function Framework_AbstractMessagingService$setTopic(topic, value) {
        if (String.compare(value, this._topics$1[topic])) {
            this._topics$1[topic] = value;
            var listeners = this._topicChangedListeners$1[topic];
            if (listeners) {
                this._fireTopicChangedEvent$1(listeners);
            }
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.ListenerInvoker

Framework.ListenerInvoker = function Framework_ListenerInvoker(isAsync) {
    this._listeners = [];
    this._isAsync = isAsync;
}
Framework.ListenerInvoker.prototype = {
    _isAsync: true,
    
    registerListener: function Framework_ListenerInvoker$registerListener(listener) {
        if (!this._listeners.contains(listener)) {
            this._listeners.add(listener);
        }
    },
    
    _createDelegate: function Framework_ListenerInvoker$_createDelegate(listenerCallback, i) {
        return Delegate.create(this, function() {
            listenerCallback.invoke(this._listeners[i]);
        });
    },
    
    fireUpdateEvent: function Framework_ListenerInvoker$fireUpdateEvent(listenerCallback) {
        for (var i = 0; i < this._listeners.length; i++) {
            if (this._isAsync) {
                window.setTimeout(this._createDelegate(listenerCallback, i), 0);
            }
            else {
                try {
                    listenerCallback.invoke(this._listeners[i]);
                }
                catch (ex) {
                    Framework.ListenerInvoker._log.error('FireUpdateEvent', ex);
                }
            }
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Parameters

Framework.Parameters = function Framework_Parameters() {
}


////////////////////////////////////////////////////////////////////////////////
// Framework.DragEventArgs

Framework.DragEventArgs = function Framework_DragEventArgs() {
}
Framework.DragEventArgs.prototype = {
    offsetX: null,
    offsetY: null,
    layerX: null,
    layerY: null,
    clientX: null,
    clientY: null,
    srcElement: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.DragObjectPosition

Framework.DragObjectPosition = function Framework_DragObjectPosition(position, zIndex, clientLeft, clientTop) {
    this.position = position;
    this.zIndex = zIndex;
    this.clientLeft = clientLeft;
    this.clientTop = clientTop;
}
Framework.DragObjectPosition.prototype = {
    position: null,
    zIndex: 0,
    clientLeft: null,
    clientTop: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.DragArgs

Framework.DragArgs = function Framework_DragArgs() {
}
Framework.DragArgs.prototype = {
    dragsRefresh: null,
    dropClassName: null,
    dragClassName: null,
    dropHoverClassName: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Droppables

Framework.Droppables = function Framework_Droppables() {
}
Framework.Droppables.add = function Framework_Droppables$add(element) {
    Framework.Droppables.drops.add(element);
}
Framework.Droppables.getDroppable = function Framework_Droppables$getDroppable(x, y) {
    x += Framework.Droppables.offsetLocation.left;
    y += Framework.Droppables.offsetLocation.top;
    var $enum1 = Framework.Droppables.drops.getEnumerator();
    while ($enum1.moveNext()) {
        var drop = $enum1.get_current();
        var bounds = ScriptFX.UI.Element.getBounds(drop);
        if (drop.style && drop.style.position === 'relative') {
            drop.style.position = 'absolute';
            bounds = ScriptFX.UI.Element.getBounds(drop);
            drop.style.position = 'relative';
        }
        if (y >= bounds.top && y <= (bounds.top + bounds.height)) {
            if (x >= bounds.left && x <= (bounds.left + bounds.width)) {
                return drop;
            }
        }
    }
    return null;
}
Framework.Droppables.setOffset = function Framework_Droppables$setOffset(x, y) {
    Framework.Droppables.offsetLocation.top = y;
    Framework.Droppables.offsetLocation.left = x;
}


////////////////////////////////////////////////////////////////////////////////
// Framework.DraggableStartLocations

Framework.DraggableStartLocations = function Framework_DraggableStartLocations() {
}
Framework.DraggableStartLocations.add = function Framework_DraggableStartLocations$add(element) {
    Framework.DraggableStartLocations._dictionary[element.id] = ScriptFX.UI.Element.getLocation(element);
}
Framework.DraggableStartLocations.get = function Framework_DraggableStartLocations$get(element) {
    var key = element.id;
    if (Object.keyExists(Framework.DraggableStartLocations._dictionary, key)) {
        return Framework.DraggableStartLocations._dictionary[key];
    }
    return null;
}


////////////////////////////////////////////////////////////////////////////////
// Framework.DragableControl

Framework.DragableControl = function Framework_DragableControl() {
    Framework.DragableControl.constructBase(this);
}
Framework.DragableControl.resetLocation = function Framework_DragableControl$resetLocation(element) {
    var location = Framework.DraggableStartLocations.get(element);
    if (location) {
        ScriptFX.UI.Element.setLocation(element, location);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Position

Framework.Position = function Framework_Position(x, y) {
    this.x = x;
    this.y = y;
}
Framework.Position.prototype = {
    x: 0,
    y: 0,
    scrollX: 0,
    scrollY: 0,
    
    prepare: function Framework_Position$prepare() {
        if (!isNullOrUndefined(document.documentElement.scrollLeft) && document.documentElement.scrollLeft) {
            this.scrollX = document.documentElement.scrollLeft;
        }
        else if (!isNullOrUndefined(document.body.scrollLeft) && document.body.scrollLeft) {
            this.scrollX = document.documentElement.scrollLeft;
        }
        if (!isNullOrUndefined(document.documentElement.scrollLeft) && document.documentElement.scrollTop) {
            this.scrollY = document.documentElement.scrollTop;
        }
        else if (!isNullOrUndefined(document.body.scrollLeft) && document.body.scrollTop) {
            this.scrollY = document.documentElement.scrollTop;
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.DragController

Framework.DragController = function Framework_DragController(o, oRoot, minX, maxX, minY, maxY, bSwapHorzRef, bSwapVertRef, fXMapper, fYMapper) {
    this.obj = o;
    o.onmousedown = Delegate.create(this, this.start);
    o.hmode = (bSwapHorzRef) ? false : true;
    o.vmode = (bSwapVertRef) ? false : true;
    o.minX = (isNaN(minX)) ? null : minX;
    o.minY = (isNaN(minY)) ? null : minY;
    o.maxX = (isNaN(maxX)) ? null : maxX;
    o.maxY = (isNaN(maxY)) ? null : maxY;
    o.xMapper = fXMapper;
    o.yMapper = fYMapper;
    o.root = (oRoot) ? oRoot : o;
    if (o.hmode && isNaN(parseInt(o.root.style.left))) {
        o.root.style.left = '0px';
    }
    if (o.vmode && isNaN(parseInt(o.root.style.top))) {
        o.root.style.top = '0px';
    }
    if (!o.hmode && isNaN(parseInt(o.root.style.right))) {
        o.root.style.right = '0px';
    }
    if (!o.vmode && isNaN(parseInt(o.root.style.bottom))) {
        o.root.style.bottom = '0px';
    }
    o.root.style.zIndex = 9999;
    o.root.onDragStart = Delegate.create(this, function(e) {
        return false;
    });
    o.root.onDragEnd = Delegate.create(this, function(obj, x, y) {
    });
    o.root.onDrag = Delegate.create(this, function(obj, x, y) {
    });
    this.dragHandler = Framework.DocumentEvents.parse(Delegate.create(this, this.dragHandle));
    this.endHandler = Framework.DocumentEvents.parse(Delegate.create(this, this.endHandle));
}
Framework.DragController.getAbsolutePosition = function Framework_DragController$getAbsolutePosition(element) {
    var pos = new Framework.Position(element.offsetLeft, element.offsetTop);
    if (element.offsetParent) {
        var parentPos = Framework.DragController.getAbsolutePosition(element.offsetParent);
        pos.x += parentPos.x;
        pos.y += parentPos.y;
    }
    return pos;
}
Framework.DragController.absolutize = function Framework_DragController$absolutize(element) {
    if (element.style.position === 'absolute') {
        return;
    }
    var pos = Framework.DragController.getAbsolutePosition(element);
    element.style.position = 'absolute';
    element.style.left = (pos.x - element.clientLeft) + 'px';
    element.style.top = (pos.y - element.clientTop) + 'px';
}
Framework.DragController.prototype = {
    obj: null,
    _initialPosition: null,
    
    startHandle: function Framework_DragController$startHandle() {
        this.start(this._getWindowEvent());
    },
    
    start: function Framework_DragController$start(e) {
        e = this.fixE(e);
        var o = this.obj;
        this._initialPosition = new Framework.DragObjectPosition(o.style.position, o.style.zIndex, o.clientLeft, o.clientTop);
        var y = parseInt((o.vmode) ? o.root.style.top : o.root.style.bottom);
        var x = parseInt((o.hmode) ? o.root.style.left : o.root.style.right);
        o.lastMouseX = e.clientX;
        o.lastMouseY = e.clientY;
        o.offsetX = e.clientX;
        o.offsetY = e.clientY;
        o.root.onDragStart.invoke(e);
        if (o.hmode) {
            if (o.minX) {
                o.minMouseX = e.clientX - x + o.minX;
            }
            if (o.maxX) {
                o.maxMouseX = o.minMouseX + o.maxX - o.minX;
            }
        }
        else {
            if (o.minX) {
                o.maxMouseX = -o.minX + e.clientX + x;
            }
            if (o.maxX) {
                o.minMouseX = -o.maxX + e.clientX + x;
            }
        }
        if (o.vmode) {
            if (o.minY) {
                o.minMouseY = e.clientY - y + o.minY;
            }
            if (o.maxY) {
                o.maxMouseY = o.minMouseY + o.maxY - o.minY;
            }
        }
        else {
            if (o.minY) {
                o.maxMouseY = -o.minY + e.clientY + y;
            }
            if (o.maxY) {
                o.minMouseY = -o.maxY + e.clientY + y;
            }
        }
        Framework.DocumentEvents.setOnMousemove(null);
        Framework.DocumentEvents.setOnMouseup(null);
        document.attachEvent('onmousemove', this.dragHandler);
        document.attachEvent('onmouseup', this.endHandler);
        if (ScriptFX.Application.current.get_host().get_name() === ScriptFX.HostName.IE) {
            window.event.cancelBubble = true;
        }
        else {
            Framework.BubblingEvent.parse(window.event).stopPropagation();
        }
        return false;
    },
    
    dragHandle: function Framework_DragController$dragHandle() {
        return this.drag(this._getWindowEvent());
    },
    
    drag: function Framework_DragController$drag(e) {
        e = this.fixE(e);
        var o = this.obj;
        var ey = e.clientY;
        var ex = e.clientX;
        var y = parseInt((o.vmode) ? o.root.style.top : o.root.style.bottom);
        var x = parseInt((o.hmode) ? o.root.style.left : o.root.style.right);
        var nx;
        var ny;
        if (o.minX) {
            ex = (o.hmode) ? Math.max(ex, o.minMouseX) : Math.min(ex, o.maxMouseX);
        }
        if (o.maxX) {
            ex = (o.hmode) ? Math.min(ex, o.maxMouseX) : Math.max(ex, o.minMouseX);
        }
        if (o.minY) {
            ey = (o.vmode) ? Math.max(ey, o.minMouseY) : Math.min(ey, o.maxMouseY);
        }
        if (o.maxY) {
            ey = (o.vmode) ? Math.min(ey, o.maxMouseY) : Math.max(ey, o.minMouseY);
        }
        nx = x + ((ex - o.lastMouseX) * ((o.hmode) ? 1 : -1));
        ny = y + ((ey - o.lastMouseY) * ((o.vmode) ? 1 : -1));
        if (o.xMapper) {
            nx = o.xMapper.invoke(x);
        }
        if (o.yMapper) {
            ny = o.yMapper.invoke(y);
        }
        if (o.hmode) {
            this.obj.root.style.left = nx + 'px';
        }
        else {
            this.obj.root.style.right = nx + 'px';
        }
        if (o.vmode) {
            this.obj.root.style.top = ny + 'px';
        }
        else {
            this.obj.root.style.bottom = ny + 'px';
        }
        this.obj.lastMouseX = ex;
        this.obj.lastMouseY = ey;
        this.obj.root.onDrag.invoke(this.obj, nx, ny);
        if (ScriptFX.Application.current.get_host().get_name() === ScriptFX.HostName.IE) {
            window.event.cancelBubble = true;
        }
        else {
            Framework.BubblingEvent.parse(window.event).stopPropagation();
        }
        return false;
    },
    
    endHandle: function Framework_DragController$endHandle() {
        return this.end(this._getWindowEvent());
    },
    
    end: function Framework_DragController$end(e) {
        document.detachEvent('onmousemove', this.dragHandler);
        document.detachEvent('onmouseup', this.endHandler);
        var style = this.obj.root.style;
        var x = parseInt((this.obj.hmode) ? style.left : style.right);
        var y = parseInt((this.obj.vmode) ? style.top : style.bottom);
        this.obj.root.onDragEnd.invoke(this.obj, x, y);
        return false;
    },
    
    fixE: function Framework_DragController$fixE(evt) {
        if (!evt) {
            evt = this._getWindowEvent();
        }
        return evt;
    },
    
    dragHandler: null,
    endHandler: null,
    
    _getWindowEvent: function Framework_DragController$_getWindowEvent() {
        var o = window.event;
        return o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Logger

Framework.Logger = function Framework_Logger() {
}
Framework.Logger.isLoggingEnabled = function Framework_Logger$isLoggingEnabled() {
    return Framework.Logger._isLoggingEnabled;
}
Framework.Logger.switchLogging = function Framework_Logger$switchLogging() {
    Framework.Logger._isLoggingEnabled = !Framework.Logger._isLoggingEnabled;
}
Framework.Logger.getLog = function Framework_Logger$getLog(typeName) {
    return new Framework.Log(typeName);
}
Framework.Logger.setMaximumLogSize = function Framework_Logger$setMaximumLogSize(maximumLogSize) {
    Framework.Logger._maximumLogSize = maximumLogSize;
}
Framework.Logger.getMaximumLogSize = function Framework_Logger$getMaximumLogSize() {
    return Framework.Logger._maximumLogSize;
}


////////////////////////////////////////////////////////////////////////////////
// Framework.JSONFormat

Framework.JSONFormat = function Framework_JSONFormat() {
}
Framework.JSONFormat.formatDateTime = function Framework_JSONFormat$formatDateTime(dateTime) {
    return ((!dateTime) ? null : String.format('{0}-{1}-{2} {3}-{4}-{5}', dateTime.getDate(), dateTime.getMonth() + 1, dateTime.getFullYear(), dateTime.getHours(), dateTime.getMinutes(), dateTime.getSeconds()));
}
Framework.JSONFormat.parseDateTime = function Framework_JSONFormat$parseDateTime(dateTime) {
    var dateTimeParts = dateTime.split(new RegExp('[- ]'));
    return new Date(Number.parse(dateTimeParts[2]), Number.parse(dateTimeParts[1]) - 1, Number.parse(dateTimeParts[0]), Number.parse(dateTimeParts[3]), Number.parse(dateTimeParts[4]), Number.parse(dateTimeParts[5]));
}


////////////////////////////////////////////////////////////////////////////////
// Framework.JsonRpcTask

Framework.JsonRpcTask = function Framework_JsonRpcTask(serviceName, methodName, IDMDLanguage, arguments, jsonRpcSuccessCallback, jsonRpcFailureCallback) {
    arguments['IDMDLanguage'] = IDMDLanguage;
    this._requestPayload = { serviceName: serviceName, methodName: methodName, arguments: arguments };
    this._jsonRpcSuccessCallback = jsonRpcSuccessCallback;
    this._jsonRpcFailureCallback = jsonRpcFailureCallback;
}
Framework.JsonRpcTask.prototype = {
    _requestPayload: null,
    _jsonRpcSuccessCallback: null,
    _jsonRpcFailureCallback: null,
    
    get_jsonRpcSuccessCallback: function Framework_JsonRpcTask$get_jsonRpcSuccessCallback() {
        return this._jsonRpcSuccessCallback;
    },
    
    get_jsonRpcFailureCallback: function Framework_JsonRpcTask$get_jsonRpcFailureCallback() {
        return this._jsonRpcFailureCallback;
    },
    
    getRequestPayload: function Framework_JsonRpcTask$getRequestPayload() {
        return Framework.JsonUtil.serialize(this._requestPayload);
    },
    
    getPayloadAsDictionary: function Framework_JsonRpcTask$getPayloadAsDictionary() {
        return this._requestPayload;
    },
    
    processResponse: function Framework_JsonRpcTask$processResponse(httpResponse) {
        if (httpResponse) {
            if (httpResponse.get_statusCode() === ScriptFX.Net.HTTPStatusCode.OK) {
                var response = Framework.JsonUtil.deserialize(httpResponse.getText());
                var exceptionType = null;
                var message = null;
                if (response['exceptionType']) {
                    exceptionType = response['exceptionType'];
                }
                if (response['message']) {
                    message = response['message'].toString();
                }
                if (!String.isNullOrEmpty(exceptionType)) {
                    this._jsonRpcFailureCallback.invoke(Framework.ExceptionUtil.createException(exceptionType, message));
                }
                else {
                    this._jsonRpcSuccessCallback.invoke(response['result']);
                }
            }
            else if (httpResponse.get_statusCode() === ScriptFX.Net.HTTPStatusCode.internalServerError) {
                var response = Framework.JsonUtil.deserialize(httpResponse.getText());
                var exceptionType = null;
                var message = null;
                if (response['exceptionType']) {
                    exceptionType = response['exceptionType'];
                }
                if (response['message']) {
                    message = response['message'];
                }
                this._jsonRpcFailureCallback.invoke(Framework.ExceptionUtil.createException(exceptionType, message));
            }
            else {
                this._jsonRpcFailureCallback.invoke(Framework.ExceptionUtil.createException('RemoteException', null));
            }
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.ExceptionDetails

Framework.ExceptionDetails = function Framework_ExceptionDetails(exceptionType, message) {
    this._exceptionType = exceptionType;
    if (this._exceptionType === 'System.FormatException') {
        this._message = 'A required field is not filled in.';
    }
    else {
        this._message = message;
    }
    if (!this._message) {
        this._message = 'Please contact customer support';
    }
    if (this._exceptionType === 'System.ServiceModel.EndpointNotFoundException') {
        this._message = 'Can not establish comunication to Transaction server.Please, contact support.';
    }
}
Framework.ExceptionDetails.prototype = {
    _exceptionType: null,
    
    get_exceptionType: function Framework_ExceptionDetails$get_exceptionType() {
        return this._exceptionType;
    },
    
    _message: null,
    
    get_message: function Framework_ExceptionDetails$get_message() {
        return this._message;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.ExceptionTypes

Framework.ExceptionTypes = function Framework_ExceptionTypes() {
}


////////////////////////////////////////////////////////////////////////////////
// Framework.ExceptionUtil

Framework.ExceptionUtil = function Framework_ExceptionUtil() {
}
Framework.ExceptionUtil.createException = function Framework_ExceptionUtil$createException(exceptionType, message) {
    return new Error(String.format('{0}{1}{2}', exceptionType, Framework.ExceptionUtil._separator, (String.isNullOrEmpty(message)) ? String.Empty : message));
}
Framework.ExceptionUtil.getExceptionDetails = function Framework_ExceptionUtil$getExceptionDetails(exception) {
    Framework.ExceptionUtil._log.debug(String.format('GetExceptionDetails exception=[{0}]', Framework.DictionaryUtil.dumpObjectToString(exception)));
    var messageTokens = exception.message.split(Framework.ExceptionUtil._separator);
    return new Framework.ExceptionDetails(messageTokens[0], messageTokens[1]);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Log

Framework.Log = function Framework_Log(typeName) {
    this._typeName = typeName;
}
Framework.Log.prototype = {
    _typeName: null,
    
    _write: function Framework_Log$_write(message) {
        if (!Framework.Logger.isLoggingEnabled()) {
            return;
        }
        if (!Framework.Log._domElementName) {
            return;
        }
        var _domElement = document.getElementById(Framework.Log._domElementName);
        if (!_domElement) {
            return;
        }
        var maximumLogSize = Framework.Logger.getMaximumLogSize();
        if (maximumLogSize > 0 && _domElement.innerHTML.length > maximumLogSize) {
            Framework.AbstractEnvironment.safeUpdateDomElementDirect(_domElement, '');
        }
        var newElement = document.createElement('span');
        newElement.innerText = this._prefixMessageWithTypeName(message);
        _domElement.appendChild(newElement);
    },
    
    _prefixMessageWithTypeName: function Framework_Log$_prefixMessageWithTypeName(message) {
        return String.format('{0}.{1}', this._typeName, message);
    },
    
    debug: function Framework_Log$debug(message) {
        this._write(message + '<br />\n');
    },
    
    error: function Framework_Log$error(message, exception) {
        this._write('<span style=\'color: red\'>' + this._prefixMessageWithTypeName(message) + ':' + Framework.ExceptionUtil.getExceptionDetails(exception).get_message() + '</span><br />\n');
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.RemoteException

Framework.RemoteException = function Framework_RemoteException() {
}


////////////////////////////////////////////////////////////////////////////////
// Framework.ServiceConfiguration

Framework.ServiceConfiguration = function Framework_ServiceConfiguration(className, requiredServices, parameters, connectEvents) {
    this.className = className;
    this.requiredServices = requiredServices;
    this.parameters = parameters;
    this.connectEvents = connectEvents;
}
Framework.ServiceConfiguration.prototype = {
    className: null,
    requiredServices: null,
    parameters: null,
    connectEvents: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.FormUtil

Framework.FormUtil = function Framework_FormUtil() {
}
Framework.FormUtil._purgePrefix = function Framework_FormUtil$_purgePrefix(id, idElementPrefix) {
    var oCharacters = [ 9, 10, 13, 32 ];
    var i = 0;
    var idReplaced;
    idReplaced = id;
    for (i = 0; i < oCharacters.length; i++) {
        idReplaced = idReplaced.replace(String.fromCharCode(oCharacters[i]), '');
    }
    return idReplaced.substr(idElementPrefix.length);
}
Framework.FormUtil.getFormAsDictionary = function Framework_FormUtil$getFormAsDictionary(formId, idElementPrefix) {
    var result = {};
    var formElement = document.getElementById(formId);
    var domElementCollection = formElement.getElementsByTagName('input');
    for (var i = 0; i < domElementCollection.length; i++) {
        var inputElement = domElementCollection[i];
        if (inputElement.id && inputElement.id.startsWith(idElementPrefix)) {
            if (!'radio'.compareTo(inputElement.type, true)) {
                if ((inputElement).checked && !String.isNullOrEmpty(inputElement.getAttribute('name'))) {
                    result[Framework.FormUtil._purgePrefix(inputElement.getAttribute('name'), idElementPrefix)] = inputElement.value;
                }
            }
            else if (!'checkbox'.compareTo(inputElement.type, true)) {
                result[Framework.FormUtil._purgePrefix(inputElement.id, idElementPrefix)] = (inputElement).checked;
            }
            else {
                result[Framework.FormUtil._purgePrefix(inputElement.id, idElementPrefix)] = inputElement.value;
            }
        }
    }
    domElementCollection = formElement.getElementsByTagName('select');
    for (var i = 0; i < domElementCollection.length; i++) {
        var selectElement = domElementCollection[i];
        if (selectElement.id && selectElement.id.startsWith(idElementPrefix)) {
            result[Framework.FormUtil._purgePrefix(selectElement.id, idElementPrefix)] = selectElement.value;
        }
    }
    domElementCollection = formElement.getElementsByTagName('textarea');
    for (var i = 0; i < domElementCollection.length; i++) {
        var textAreaElement = domElementCollection[i];
        if (textAreaElement.id && textAreaElement.id.startsWith(idElementPrefix)) {
            result[Framework.FormUtil._purgePrefix(textAreaElement.id, idElementPrefix)] = textAreaElement.value;
        }
    }
    return result;
}


////////////////////////////////////////////////////////////////////////////////
// Framework.DictionaryUtil

Framework.DictionaryUtil = function Framework_DictionaryUtil() {
}
Framework.DictionaryUtil.equal = function Framework_DictionaryUtil$equal(first, second) {
    if (!first && !second) {
        return true;
    }
    if (!first && second) {
        return false;
    }
    if (first && !second) {
        return false;
    }
    if (Object.getKeyCount(first) !== Object.getKeyCount(second)) {
        return false;
    }
    var $dict1 = first;
    for (var $key2 in $dict1) {
        var de = { key: $key2, value: $dict1[$key2] };
        var key = de.key;
        if (!Object.keyExists(second, key)) {
            return false;
        }
        var firstval = de.value;
        var secondval = second[key];
        if (!firstval && !secondval) {
            continue;
        }
        if (!firstval && secondval) {
            return false;
        }
        if (firstval && !secondval) {
            return false;
        }
        if (firstval !== secondval) {
            return false;
        }
    }
    return true;
}
Framework.DictionaryUtil.dumpToString = function Framework_DictionaryUtil$dumpToString(dictionary) {
    var result = '{';
    var $dict1 = dictionary;
    for (var $key2 in $dict1) {
        var entry = { key: $key2, value: $dict1[$key2] };
        if (entry.key) {
            result += String.format('{0}:{1}; ', entry.key, entry.value);
        }
    }
    return result + '}';
}
Framework.DictionaryUtil.dumpObjectToString = function Framework_DictionaryUtil$dumpObjectToString(obj) {
    return Framework.DictionaryUtil.dumpToString(obj);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.ToolTipBehavior

Framework.ToolTipBehavior = function Framework_ToolTipBehavior(domElement, id) {
    Framework.ToolTipBehavior.constructBase(this, [ domElement, id ]);
    this.get_domEvents().attach('ommousemove', Delegate.create(this, function() {
        var srcElement = window.event.srcElement;
        var toolTips = document.getElementsByTagName('span');
        for (var i = 0; i < toolTips.length; i++) {
            if (toolTips[i].className === 'tip-info') {
                var ttleftOffset = 10;
                var tttopOffset = 15;
                var leftPos = window.event.offsetX;
                var topPos = window.event.offsetY;
                var absoluteLeftPos = 0;
                var absoluteTopPos = 0;
                var offsetParent = srcElement;
                while (offsetParent) {
                    absoluteLeftPos += offsetParent.offsetLeft;
                    absoluteTopPos += offsetParent.offsetTop;
                    offsetParent = offsetParent.offsetParent;
                }
                leftPos += absoluteLeftPos;
                topPos += absoluteTopPos;
                var screenWidth = window.document.body.offsetWidth;
                var screenHeight = window.document.body.offsetHeight;
                if ((screenWidth - absoluteLeftPos) < (150 + ttleftOffset)) {
                    var newLeftPos = leftPos;
                    newLeftPos -= 150;
                    toolTips[i].style.left = newLeftPos.toString() + 'px';
                }
                else {
                    leftPos += ttleftOffset;
                    toolTips[i].style.left = leftPos.toString() + 'px';
                }
                var newTopPos = topPos;
                newTopPos += tttopOffset;
                toolTips[i].style.top = newTopPos.toString() + 'px';
            }
        }
    }));
    this.get_domEvents().attach('onmouseover', Delegate.create(this, function() {
        var srcElement = window.event.srcElement;
        var ttText = srcElement.getAttribute('toolTipText');
        if ((srcElement.className.indexOf('toolTip') >= 0) && (ttText !== '')) {
            var ttWidth = 150;
            var ttleftOffset = 10;
            var tttopOffset = 15;
            if (srcElement.getAttribute('toolTipWidth')) {
                ttWidth = srcElement.getAttribute('toolTipWidth');
                if (ttWidth > 500) {
                    ttWidth = 500;
                }
            }
            var leftPos = window.event.offsetX;
            var topPos = window.event.offsetY;
            var absoluteLeftPos = 0;
            var absoluteTopPos = 0;
            var offsetParent = srcElement;
            while (offsetParent) {
                absoluteLeftPos += offsetParent.offsetLeft;
                absoluteTopPos += offsetParent.offsetTop;
                offsetParent = offsetParent.offsetParent;
            }
            leftPos += absoluteLeftPos;
            topPos += absoluteTopPos;
            var screenWidth = window.document.body.offsetWidth;
            var screenHeight = window.document.body.offsetHeight;
            var toolTip = document.createElement('span');
            toolTip.className = 'tip-info';
            toolTip.innerHTML = ttText;
            if ((screenWidth - absoluteLeftPos) < (ttWidth + ttleftOffset)) {
                var newLeftPos = leftPos;
                newLeftPos -= ttWidth;
                toolTip.style.left = newLeftPos.toString() + 'px';
            }
            else {
                leftPos += ttleftOffset;
                toolTip.style.left = leftPos.toString() + 'px';
            }
            var newTopPos = topPos;
            newTopPos += tttopOffset;
            toolTip.style.top = newTopPos.toString() + 'px';
            srcElement.appendChild(toolTip);
        }
    }));
    this.get_domEvents().attach('onmouseout', Delegate.create(this, function() {
        var srcElement = window.event.srcElement;
        var toolTips = document.getElementsByTagName('span');
        for (var i = 0; i < toolTips.length; i++) {
            if (toolTips[i].className === 'tip-info') {
                srcElement.removeChild(toolTips[i]);
            }
        }
    }));
}


////////////////////////////////////////////////////////////////////////////////
// Framework.TransformAndUpdateTask

Framework.TransformAndUpdateTask = function Framework_TransformAndUpdateTask(domElementId, contentUrl, xsltUrl, xsltParameters, afterTransformAndUpdateCallback, domain, autoRefreshPeriod, environment, domElement, inMemoryProcessingCallback, contentXml, useSuppliedContentXml, contentUrlDelegate, useContentUrlDelegate) {
    this._domElementId = domElementId;
    this._contentUrl = contentUrl;
    this._xsltUrl = xsltUrl;
    this._xsltParameters = xsltParameters;
    this._afterTransformAndUpdateCallback = afterTransformAndUpdateCallback;
    this._domain = domain;
    this._environment = environment;
    this._autoRefreshPeriod = autoRefreshPeriod;
    this._domElement = domElement;
    this._inMemoryProcessingCallback = inMemoryProcessingCallback;
    this._useSuppliedContentXml = useSuppliedContentXml;
    if (this._useSuppliedContentXml) {
        this._contentXmlDocument = contentXml;
    }
    this._contentUrlDelegate = contentUrlDelegate;
    this._useContentUrlDelegate = useContentUrlDelegate;
}
Framework.TransformAndUpdateTask._getStamp = function Framework_TransformAndUpdateTask$_getStamp(domElementId) {
    return Framework.TransformAndUpdateTask._domElementCounterMap[domElementId];
}
Framework.TransformAndUpdateTask._setStamp = function Framework_TransformAndUpdateTask$_setStamp(domElementId, value) {
    Framework.TransformAndUpdateTask._domElementCounterMap[domElementId] = value;
}
Framework.TransformAndUpdateTask.storeXsltDocument = function Framework_TransformAndUpdateTask$storeXsltDocument(url, document) {
    Framework.TransformAndUpdateTask._cachedXsltXmlDocument[url] = document;
}
Framework.TransformAndUpdateTask._onContentRequestsComplete = function Framework_TransformAndUpdateTask$_onContentRequestsComplete(contentUrl) {
    Framework.TransformAndUpdateTask._log.debug(String.format('OnContentRequestsComplete contentUrl=[{0}]', contentUrl));
    if (Object.keyExists(Framework.TransformAndUpdateTask._xmlCallBacks, contentUrl) && Object.getKeyCount((Framework.TransformAndUpdateTask._xmlCallBacks[contentUrl])) > 0) {
        var xmlCallBacksForUrl = Framework.TransformAndUpdateTask._xmlCallBacks[contentUrl];
        var $dict1 = xmlCallBacksForUrl;
        for (var $key2 in $dict1) {
            var callback = { key: $key2, value: $dict1[$key2] };
            Framework.TransformAndUpdateTask._log.debug(String.format('OnContentRequestsComplete callback key=[{0}] contentUrl=[{1}]', callback.key, contentUrl));
            (callback.value).invoke();
        }
    }
}
Framework.TransformAndUpdateTask.prototype = {
    _startingCounterValue: 0,
    _domElementId: null,
    _contentUrl: null,
    _contentUrlDelegate: null,
    _useContentUrlDelegate: false,
    _xsltUrl: null,
    _xsltParameters: null,
    _afterTransformAndUpdateCallback: null,
    _domain: null,
    
    get_domain: function Framework_TransformAndUpdateTask$get_domain() {
        return this._domain;
    },
    
    _autoRefreshPeriod: null,
    
    get_autoRefreshPeriod: function Framework_TransformAndUpdateTask$get_autoRefreshPeriod() {
        return this._autoRefreshPeriod;
    },
    
    _lastExecuted: null,
    
    get_lastExecuted: function Framework_TransformAndUpdateTask$get_lastExecuted() {
        return this._lastExecuted;
    },
    
    _contentRequest: null,
    _xsltRequest: null,
    _contentXmlDocument: null,
    _useSuppliedContentXml: false,
    _xsltXmlDocument: null,
    _environment: null,
    _inMemoryProcessingCallback: null,
    _domElement: null,
    
    _getContentUrl: function Framework_TransformAndUpdateTask$_getContentUrl() {
        if (this._useContentUrlDelegate) {
            return this._environment.createRealUrl(this._contentUrlDelegate.invoke());
        }
        else {
            return this._contentUrl;
        }
    },
    
    execute: function Framework_TransformAndUpdateTask$execute(appendTimestampToContentUrl) {
        this._lastExecuted = Date.get_now();
        this._startingCounterValue = Framework.TransformAndUpdateTask._requestCounter++;
        Framework.TransformAndUpdateTask._setStamp(this._domElementId, this._startingCounterValue);
        var newContentUrl = this._getContentUrl();
        if (this._contentUrl !== newContentUrl) {
            this._contentUrl = newContentUrl;
            this._contentXmlDocument = null;
        }
        if (!this._useSuppliedContentXml) {
            if (this._contentUrl) {
                var doCall = false;
                if (!Object.keyExists(Framework.TransformAndUpdateTask._xmlCallBacks, this._contentUrl) || !Object.getKeyCount((Framework.TransformAndUpdateTask._xmlCallBacks[this._contentUrl]))) {
                    doCall = true;
                    Framework.TransformAndUpdateTask._xmlCallBacks[this._contentUrl] = {};
                }
                (Framework.TransformAndUpdateTask._xmlCallBacks[this._contentUrl])[this._domElementId] = Delegate.create(this, this._onContentRequestComplete);
                if (doCall) {
                    this._contentXmlDocument = null;
                    this._contentRequest = new Framework.XMLHttpRequestDecorator();
                    this._contentRequest.onreadystatechange = Delegate.create(this, function() {
                        Framework.TransformAndUpdateTask._onContentRequestsComplete(this._contentUrl);
                    });
                    this._contentRequest.open('GET', this._contentUrl, true);
                    this._contentRequest.send(null);
                    Framework.TransformAndUpdateTask._contentRequests[this._contentUrl] = this._contentRequest;
                }
            }
            else {
                this._contentXmlDocument = Framework.XMLUtils.get_emptyContentDocument();
            }
        }
        if (!Object.keyExists(Framework.TransformAndUpdateTask._cachedXsltXmlDocument, this._xsltUrl)) {
            this._xsltRequest = new Framework.XMLHttpRequestDecorator();
            this._xsltRequest.onreadystatechange = Delegate.create(this, this._onXsltRequestComplete);
            this._xsltRequest.open('GET', this._xsltUrl, true);
            this._xsltRequest.send(null);
        }
        else {
            this._xsltXmlDocument = Framework.TransformAndUpdateTask._cachedXsltXmlDocument[this._xsltUrl];
        }
        this._tryTransform();
    },
    
    _tryTransform: function Framework_TransformAndUpdateTask$_tryTransform() {
        Framework.TransformAndUpdateTask._log.debug(String.format('TryTransform domElementId=[{0}] contentUrl=[{1}]', this._domElementId, this._contentUrl));
        if (this._contentXmlDocument && this._xsltXmlDocument && this._startingCounterValue === Framework.TransformAndUpdateTask._getStamp(this._domElementId)) {
            Framework.XMLUtils.transformAndUpdate(this._contentXmlDocument, this._xsltXmlDocument, this._xsltParameters, this._domElementId, this._domElement, this._inMemoryProcessingCallback);
            if (this._afterTransformAndUpdateCallback) {
                window.setTimeout(this._afterTransformAndUpdateCallback, 0);
            }
            if (ScriptFX.Application.current.get_host().get_name() === ScriptFX.HostName.mozilla) {
                var css = '#' + this._domElementId + ' .escapedHtml';
                var elements = Framework.DocumentFinder.getElementsBySelector(css);
                if (elements) {
                    for (var i = 0; i < elements.length; i++) {
                        elements[i].innerHTML = elements[i].innerText;
                    }
                }
            }
        }
    },
    
    _onContentRequestComplete: function Framework_TransformAndUpdateTask$_onContentRequestComplete() {
        if (!this._contentRequest) {
            this._contentRequest = Framework.TransformAndUpdateTask._contentRequests[this._contentUrl];
        }
        if (this._contentRequest) {
            if (this._contentRequest.readyState === 4) {
                if (this._contentRequest.status === 200 || this._contentRequest.status === 304) {
                    this._contentXmlDocument = this._contentRequest.responseXML;
                    this._tryTransform();
                }
                else {
                    this._environment.updateDomElement(this._domElementId, '<img src=\'..\\..\\..\\error.png\' alt=\'error\' />');
                }
                if (Object.keyExists(Framework.TransformAndUpdateTask._xmlCallBacks, this._contentUrl) && Object.getKeyCount((Framework.TransformAndUpdateTask._xmlCallBacks[this._contentUrl])) > 0) {
                    var xmlCallBack = Framework.TransformAndUpdateTask._xmlCallBacks[this._contentUrl];
                    if (Object.keyExists(xmlCallBack, this._domElementId)) {
                        delete xmlCallBack[this._domElementId];
                    }
                    if (!Object.getKeyCount(xmlCallBack)) {
                        delete Framework.TransformAndUpdateTask._contentRequests[this._contentUrl];
                        this._contentRequest.onreadystatechange = null;
                    }
                }
            }
        }
    },
    
    _onXsltRequestComplete: function Framework_TransformAndUpdateTask$_onXsltRequestComplete() {
        if (this._xsltRequest.readyState === 4) {
            if (this._xsltRequest.status === 200 || this._xsltRequest.status === 304) {
                this._xsltXmlDocument = this._xsltRequest.responseXML;
                Framework.TransformAndUpdateTask._cachedXsltXmlDocument[this._xsltUrl] = this._xsltXmlDocument;
                this._tryTransform();
                if (this._xsltRequest) {
                    this._xsltRequest.onreadystatechange = null;
                }
            }
            else {
                this._environment.updateDomElement(this._domElementId, '<img src=\'..\\..\\..\\error.png\' alt=\'error\' />');
            }
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.DOMParser

Framework.DOMParser = function Framework_DOMParser(parent) {
    this._index = {};
    this._parent = parent;
    this._createIndex(this._parent);
}
Framework.DOMParser.searchForElement = function Framework_DOMParser$searchForElement(domElement, ID) {
    if (!domElement) {
        return null;
    }
    if (domElement.id === ID) {
        return domElement;
    }
    for (var i = 0; i < domElement.childNodes.length; i++) {
        var el = Framework.DOMParser.searchForElement(domElement.childNodes[i], ID);
        if (el) {
            return el;
        }
    }
    return null;
}
Framework.DOMParser.prototype = {
    _parent: null,
    
    getElementByID: function Framework_DOMParser$getElementByID(id) {
        return this._index[id];
    },
    
    _createIndex: function Framework_DOMParser$_createIndex(domElement) {
        if (domElement.id !== '') {
            this._index[domElement.id] = domElement;
        }
        for (var i = 0; i < domElement.childNodes.length; i++) {
            this._createIndex(domElement.childNodes[i]);
        }
    },
    
    dispose: function Framework_DOMParser$dispose() {
        this._index = null;
    }
}


Type.createNamespace('Framework.Behavior.Binding');

////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.BehaviorBinder

Framework.Behavior.Binding.BehaviorBinder = function Framework_Behavior_Binding_BehaviorBinder() {
    this._tasks = {};
}
Framework.Behavior.Binding.BehaviorBinder.autoBind = function Framework_Behavior_Binding_BehaviorBinder$autoBind(domElement, component) {
    if (!component) {
        throw new Error('Component parameter can not be null');
    }
    if (!domElement) {
        throw new Error('DOMElement parameter can not be null');
    }
    Framework.Behavior.Binding.BehaviorBinder._searchAndBind(domElement, null, component);
}
Framework.Behavior.Binding.BehaviorBinder._searchAndBind = function Framework_Behavior_Binding_BehaviorBinder$_searchAndBind(startingPoint, tasks, component) {
    if (!isNullOrUndefined(startingPoint.attributes) && !isNullOrUndefined(startingPoint.getAttribute(Framework.Behavior.Binding.BehaviorBinder.behavioR_ID_ATTRIBUTE))) {
        var attValue = startingPoint.getAttributeNode(Framework.Behavior.Binding.BehaviorBinder.behavioR_ID_ATTRIBUTE).value;
        if (attValue.indexOf('|') === -1) {
            Framework.Behavior.Binding.BehaviorBinder._bindBehavior(startingPoint, attValue, tasks, component);
        }
        else {
            var behaviors = attValue.split('|');
            for (var i = 0; i < behaviors.length; i++) {
                Framework.Behavior.Binding.BehaviorBinder._bindBehavior(startingPoint, behaviors[i], tasks, component);
            }
        }
    }
    for (var i = 0; i < startingPoint.childNodes.length; i++) {
        if (startingPoint.childNodes[i].nodeType === 1) {
            Framework.Behavior.Binding.BehaviorBinder._searchAndBind(startingPoint.childNodes[i], tasks, component);
        }
    }
    startingPoint = null;
}
Framework.Behavior.Binding.BehaviorBinder._bindBehavior = function Framework_Behavior_Binding_BehaviorBinder$_bindBehavior(domElement, behaviorName, tasks, component) {
    if (tasks) {
        Framework.Behavior.Binding.BehaviorBinder._manualBehaviorBind(domElement, behaviorName, tasks);
    }
    else {
        Framework.Behavior.Binding.BehaviorBinder._autoBehaviorBind(domElement, behaviorName, component);
    }
}
Framework.Behavior.Binding.BehaviorBinder._manualBehaviorBind = function Framework_Behavior_Binding_BehaviorBinder$_manualBehaviorBind(domElement, behaviorName, tasks) {
    if (Object.keyExists(tasks, behaviorName)) {
        var binding = tasks[behaviorName];
        binding.bind(domElement);
    }
}
Framework.Behavior.Binding.BehaviorBinder._autoBehaviorBind = function Framework_Behavior_Binding_BehaviorBinder$_autoBehaviorBind(domElement, behaviorName, component) {
    var eventIDAttribute = domElement.getAttributeNode(Framework.Behavior.Binding.BehaviorBinder.behavioR_EVENT_ID_ATTRIBUTE + '.' + behaviorName);
    if (!eventIDAttribute) {
        eventIDAttribute = domElement.getAttributeNode(Framework.Behavior.Binding.BehaviorBinder.behavioR_EVENT_ID_ATTRIBUTE + '.' + behaviorName.toLowerCase());
        if (!eventIDAttribute) {
            return;
        }
    }
    var behaviorEvent = Framework.Behavior.ElementBehavior.stringToBehaviorEvent(eventIDAttribute.value);
    var handler = Framework.Behavior.Binding.BehaviorBinder._findEventHandler(component, behaviorName);
    if (!handler) {
        return;
    }
    switch (behaviorEvent) {
        case Framework.Behavior.BehaviorEvent.onclick:
            (new Framework.Behavior.Binding.OnClickBinding(behaviorName, handler)).bind(domElement);
            break;
        case Framework.Behavior.BehaviorEvent.onload:
            (new Framework.Behavior.Binding.OnLoadBinding(behaviorName, handler)).bind(domElement);
            break;
        case Framework.Behavior.BehaviorEvent.onchange:
            (new Framework.Behavior.Binding.OnChangeBinding(behaviorName, handler)).bind(domElement);
            break;
        case Framework.Behavior.BehaviorEvent.onkeyup:
            (new Framework.Behavior.Binding.OnKeyUpBinding(behaviorName, handler)).bind(domElement);
            break;
        case Framework.Behavior.BehaviorEvent.onmouseover:
            (new Framework.Behavior.Binding.OnMouseOverBinding(behaviorName, handler)).bind(domElement);
            break;
        case Framework.Behavior.BehaviorEvent.onmouseout:
            (new Framework.Behavior.Binding.OnMouseOutBinding(behaviorName, handler)).bind(domElement);
            break;
        case Framework.Behavior.BehaviorEvent.onfocus:
            (new Framework.Behavior.Binding.OnFocusBinding(behaviorName, handler)).bind(domElement);
            break;
        case Framework.Behavior.BehaviorEvent.onblur:
            (new Framework.Behavior.Binding.OnBlurBinding(behaviorName, handler)).bind(domElement);
            break;
        case Framework.Behavior.BehaviorEvent.onsubmit:
            (new Framework.Behavior.Binding.OnSubmitBinding(behaviorName, handler)).bind(domElement);
            break;
    }
}
Framework.Behavior.Binding.BehaviorBinder._findEventHandler = function Framework_Behavior_Binding_BehaviorBinder$_findEventHandler(component, behaviorName) {
    var handlerName = behaviorName + Framework.Behavior.Binding.BehaviorBinder.behavioR_EVENT_HANDLER_SUFFIX;
    handlerName = handlerName.charAt(0).toString().toLowerCase() + handlerName.substr(1);
    var handler = component[handlerName];
    if (typeof(handler) !== 'function') {
        return null;
    }
    return Delegate.create(component, handler);
}
Framework.Behavior.Binding.BehaviorBinder.prototype = {
    
    addBinding: function Framework_Behavior_Binding_BehaviorBinder$addBinding(binding) {
        this._tasks[binding.get_behaviorID()] = binding;
    },
    
    bind: function Framework_Behavior_Binding_BehaviorBinder$bind(startingPoint) {
        if (isNullOrUndefined(this._tasks) || !Object.getKeyCount(this._tasks)) {
            return;
        }
        Framework.Behavior.Binding.BehaviorBinder._searchAndBind(startingPoint, this._tasks, null);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.AbstractBinding

Framework.Behavior.Binding.AbstractBinding = function Framework_Behavior_Binding_AbstractBinding(behaviorID, eventHandler) {
    this._behaviorID = behaviorID;
    this._eventHandler = eventHandler;
}
Framework.Behavior.Binding.AbstractBinding.prototype = {
    _behaviorID: null,
    
    get_behaviorID: function Framework_Behavior_Binding_AbstractBinding$get_behaviorID() {
        return this._behaviorID;
    },
    
    _eventHandler: null,
    
    get_eventHandler: function Framework_Behavior_Binding_AbstractBinding$get_eventHandler() {
        return this._eventHandler;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnSubmitBinding

Framework.Behavior.Binding.OnSubmitBinding = function Framework_Behavior_Binding_OnSubmitBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnSubmitBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnSubmitBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnSubmitBinding$bind(domElement) {
        new Framework.Behavior.OnSubmitBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnBlurBinding

Framework.Behavior.Binding.OnBlurBinding = function Framework_Behavior_Binding_OnBlurBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnBlurBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnBlurBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnBlurBinding$bind(domElement) {
        new Framework.Behavior.OnBlurBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnFocusBinding

Framework.Behavior.Binding.OnFocusBinding = function Framework_Behavior_Binding_OnFocusBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnFocusBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnFocusBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnFocusBinding$bind(domElement) {
        new Framework.Behavior.OnFocusBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnMouseOutBinding

Framework.Behavior.Binding.OnMouseOutBinding = function Framework_Behavior_Binding_OnMouseOutBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnMouseOutBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnMouseOutBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnMouseOutBinding$bind(domElement) {
        new Framework.Behavior.OnMouseOutBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnMouseOverBinding

Framework.Behavior.Binding.OnMouseOverBinding = function Framework_Behavior_Binding_OnMouseOverBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnMouseOverBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnMouseOverBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnMouseOverBinding$bind(domElement) {
        new Framework.Behavior.OnMouseOverBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnKeyUpBinding

Framework.Behavior.Binding.OnKeyUpBinding = function Framework_Behavior_Binding_OnKeyUpBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnKeyUpBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnKeyUpBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnKeyUpBinding$bind(domElement) {
        new Framework.Behavior.OnKeyUpBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnChangeBinding

Framework.Behavior.Binding.OnChangeBinding = function Framework_Behavior_Binding_OnChangeBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnChangeBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnChangeBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnChangeBinding$bind(domElement) {
        new Framework.Behavior.OnChangeBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnLoadBinding

Framework.Behavior.Binding.OnLoadBinding = function Framework_Behavior_Binding_OnLoadBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnLoadBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnLoadBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnLoadBinding$bind(domElement) {
        new Framework.Behavior.OnLoadBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnClickBinding

Framework.Behavior.Binding.OnClickBinding = function Framework_Behavior_Binding_OnClickBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnClickBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnClickBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnClickBinding$bind(domElement) {
        new Framework.Behavior.OnClickBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


Type.createNamespace('Framework.Behavior');

////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.BehaviorEvent

Framework.Behavior.BehaviorEvent = function() { };
Framework.Behavior.BehaviorEvent.prototype = {
    onclick: 0, 
    onload: 1, 
    onchange: 2, 
    onkeyup: 3, 
    onmouseover: 4, 
    onmouseout: 5, 
    onfocus: 6, 
    onblur: 7, 
    onsubmit: 8
}
Framework.Behavior.BehaviorEvent.createEnum('Framework.Behavior.BehaviorEvent', false);


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnSubmitBehavior

Framework.Behavior.OnSubmitBehavior = function Framework_Behavior_OnSubmitBehavior(domElement, behaviorID, onSubmitEventHandler) {
    Framework.Behavior.OnSubmitBehavior.constructBase(this, [ domElement ]);
    this._behaviorID$2 = behaviorID;
    this.add_onSubmit(onSubmitEventHandler);
}
Framework.Behavior.OnSubmitBehavior.prototype = {
    _behaviorID$2: null,
    
    onSubmitEventFired: function Framework_Behavior_OnSubmitBehavior$onSubmitEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnSubmitEventArgs();
        eventArgs.domElement = this.get_domElement();
        eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(this.get_domElement(), this._behaviorID$2));
        this._onSubmitEventHandler.invoke(this, eventArgs);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnBlurBehavior

Framework.Behavior.OnBlurBehavior = function Framework_Behavior_OnBlurBehavior(domElement, behaviorID, onBlurEventHandler) {
    Framework.Behavior.OnBlurBehavior.constructBase(this, [ domElement ]);
    this._behaviorID$2 = behaviorID;
    this.add_onBlur(onBlurEventHandler);
}
Framework.Behavior.OnBlurBehavior.prototype = {
    _behaviorID$2: null,
    
    onBlurEventFired: function Framework_Behavior_OnBlurBehavior$onBlurEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnBlurEventArgs();
        eventArgs.domElement = this.get_domElement();
        eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(this.get_domElement(), this._behaviorID$2));
        this._onBlurEventHandler.invoke(this, eventArgs);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnFocusBehavior

Framework.Behavior.OnFocusBehavior = function Framework_Behavior_OnFocusBehavior(domElement, behaviorID, onFocusEventHandler) {
    Framework.Behavior.OnFocusBehavior.constructBase(this, [ domElement ]);
    this._behaviorID$2 = behaviorID;
    this.add_onFocus(onFocusEventHandler);
}
Framework.Behavior.OnFocusBehavior.prototype = {
    _behaviorID$2: null,
    
    onFocusEventFired: function Framework_Behavior_OnFocusBehavior$onFocusEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnFocusEventArgs();
        eventArgs.domElement = this.get_domElement();
        eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(this.get_domElement(), this._behaviorID$2));
        this._onFocusEventHandler.invoke(this, eventArgs);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnMouseOutBehavior

Framework.Behavior.OnMouseOutBehavior = function Framework_Behavior_OnMouseOutBehavior(domElement, behaviorID, onMouseOutEventHandler) {
    Framework.Behavior.OnMouseOutBehavior.constructBase(this, [ domElement ]);
    this._behaviorID$2 = behaviorID;
    this.add_onMouseOut(onMouseOutEventHandler);
}
Framework.Behavior.OnMouseOutBehavior.prototype = {
    _behaviorID$2: null,
    
    onMouseOutEventFired: function Framework_Behavior_OnMouseOutBehavior$onMouseOutEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnMouseOutEventArgs();
        eventArgs.domElement = this.get_domElement();
        eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(this.get_domElement(), this._behaviorID$2));
        this._onMouseOutEventHandler.invoke(this, eventArgs);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnMouseOverBehavior

Framework.Behavior.OnMouseOverBehavior = function Framework_Behavior_OnMouseOverBehavior(domElement, behaviorID, onMouseOverEventHandler) {
    Framework.Behavior.OnMouseOverBehavior.constructBase(this, [ domElement ]);
    this._behaviorID$2 = behaviorID;
    this.add_onMouseOver(onMouseOverEventHandler);
}
Framework.Behavior.OnMouseOverBehavior.prototype = {
    _behaviorID$2: null,
    
    onMouseOverEventFired: function Framework_Behavior_OnMouseOverBehavior$onMouseOverEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnMouseOverEventArgs();
        eventArgs.domElement = this.get_domElement();
        eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(this.get_domElement(), this._behaviorID$2));
        this._onMouseOverEventHandler.invoke(this, eventArgs);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnKeyUpBehavior

Framework.Behavior.OnKeyUpBehavior = function Framework_Behavior_OnKeyUpBehavior(domElement, behaviorID, onKeyUpEventHandler) {
    Framework.Behavior.OnKeyUpBehavior.constructBase(this, [ domElement ]);
    this._behaviorID$2 = behaviorID;
    this.add_onKeyUp(onKeyUpEventHandler);
}
Framework.Behavior.OnKeyUpBehavior.prototype = {
    _behaviorID$2: null,
    
    onKeyUpEventFired: function Framework_Behavior_OnKeyUpBehavior$onKeyUpEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnKeyUpEventArgs();
        eventArgs.domElement = this.get_domElement();
        eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(this.get_domElement(), this._behaviorID$2));
        this._onKeyUpEventHandler.invoke(this, eventArgs);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnChangeBehavior

Framework.Behavior.OnChangeBehavior = function Framework_Behavior_OnChangeBehavior(domElement, behaviorID, onChangeEventHandler) {
    Framework.Behavior.OnChangeBehavior.constructBase(this, [ domElement ]);
    this._behaviorID$2 = behaviorID;
    this.add_onChange(onChangeEventHandler);
}
Framework.Behavior.OnChangeBehavior.prototype = {
    _behaviorID$2: null,
    
    onChangeEventFired: function Framework_Behavior_OnChangeBehavior$onChangeEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnChangeEventArgs();
        eventArgs.domElement = this.get_domElement();
        eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(this.get_domElement(), this._behaviorID$2));
        this._onChangeEventHandler.invoke(this, eventArgs);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnLoadBehavior

Framework.Behavior.OnLoadBehavior = function Framework_Behavior_OnLoadBehavior(domElement, behaviorID, onLoadEventHandler) {
    var eventArgs = new Framework.Behavior.EventArgs.OnLoadEventArgs();
    eventArgs.domElement = domElement;
    eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(domElement, behaviorID));
    onLoadEventHandler.invoke(this, eventArgs);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnClickBehavior

Framework.Behavior.OnClickBehavior = function Framework_Behavior_OnClickBehavior(domElement, behaviorID, onClickEventHandler) {
    Framework.Behavior.OnClickBehavior.constructBase(this, [ domElement ]);
    this._behaviorID$2 = behaviorID;
    this.add_onClick(onClickEventHandler);
}
Framework.Behavior.OnClickBehavior.prototype = {
    _behaviorID$2: null,
    
    onClickEventFired: function Framework_Behavior_OnClickBehavior$onClickEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnClickEventArgs();
        eventArgs.domElement = this.get_domElement();
        eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(this.get_domElement(), this._behaviorID$2));
        this._onClickEventHandler.invoke(this, eventArgs);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.ElementBehavior

Framework.Behavior.ElementBehavior = function Framework_Behavior_ElementBehavior(domElement) {
    Framework.Behavior.ElementBehavior.constructBase(this, [ domElement, null ]);
}
Framework.Behavior.ElementBehavior.detachEvent = function Framework_Behavior_ElementBehavior$detachEvent(domElement, eventName) {
    var behaviors = 'ScriptFX.UI.Behavior'.getBehaviors(domElement, null);
    if (!behaviors) {
        return;
    }
    var $enum1 = behaviors.getEnumerator();
    while ($enum1.moveNext()) {
        var behavior = $enum1.get_current();
        switch (eventName) {
            case Framework.Behavior.BehaviorEvent.onclick:
                if (behavior.detachAllOnClick) {
                    (behavior).detachAllOnClick();
                }
                break;
            case Framework.Behavior.BehaviorEvent.onchange:
                if (behavior.detachAllOnChange) {
                    (behavior).detachAllOnChange();
                }
                break;
            case Framework.Behavior.BehaviorEvent.onkeyup:
                if (behavior.detachAllOnKeyUp) {
                    (behavior).detachAllOnKeyUp();
                }
                break;
            case Framework.Behavior.BehaviorEvent.onmouseover:
                if (behavior.detachAllOnMouseOver) {
                    (behavior).detachAllOnMouseOver();
                }
                break;
            case Framework.Behavior.BehaviorEvent.onmouseout:
                if (behavior.detachAllOnMouseOut) {
                    (behavior).detachAllOnMouseOut();
                }
                break;
            case Framework.Behavior.BehaviorEvent.onfocus:
                if (behavior.detachAllOnFocus) {
                    (behavior).detachAllOnFocus();
                }
                break;
            case Framework.Behavior.BehaviorEvent.onblur:
                if (behavior.detachAllOnBlur) {
                    (behavior).detachAllOnBlur();
                }
                break;
            case Framework.Behavior.BehaviorEvent.onsubmit:
                if (behavior.detachAllOnSubmit) {
                    (behavior).detachAllOnSubmit();
                }
                break;
        }
    }
}
Framework.Behavior.ElementBehavior.behaviorEventToString = function Framework_Behavior_ElementBehavior$behaviorEventToString(eventName) {
    switch (eventName) {
        case Framework.Behavior.BehaviorEvent.onclick:
            return 'onclick';
        case Framework.Behavior.BehaviorEvent.onload:
            return 'onload';
        case Framework.Behavior.BehaviorEvent.onchange:
            return 'onchange';
        case Framework.Behavior.BehaviorEvent.onkeyup:
            return 'onkeyup';
        case Framework.Behavior.BehaviorEvent.onmouseover:
            return 'onmouseover';
        case Framework.Behavior.BehaviorEvent.onmouseout:
            return 'onmouseout';
        case Framework.Behavior.BehaviorEvent.onfocus:
            return 'onfocus';
        case Framework.Behavior.BehaviorEvent.onblur:
            return 'onblur';
        case Framework.Behavior.BehaviorEvent.onsubmit:
            return 'onsubmit';
        default:
            throw new Error('Behavior event name not recognized');
    }
}
Framework.Behavior.ElementBehavior.stringToBehaviorEvent = function Framework_Behavior_ElementBehavior$stringToBehaviorEvent(eventName) {
    switch (eventName) {
        case 'onclick':
            return Framework.Behavior.BehaviorEvent.onclick;
        case 'onload':
            return Framework.Behavior.BehaviorEvent.onload;
        case 'onchange':
            return Framework.Behavior.BehaviorEvent.onchange;
        case 'onkeyup':
            return Framework.Behavior.BehaviorEvent.onkeyup;
        case 'onmouseover':
            return Framework.Behavior.BehaviorEvent.onmouseover;
        case 'onmouseout':
            return Framework.Behavior.BehaviorEvent.onmouseout;
        case 'onfocus':
            return Framework.Behavior.BehaviorEvent.onfocus;
        case 'onblur':
            return Framework.Behavior.BehaviorEvent.onblur;
        case 'onsubmit':
            return Framework.Behavior.BehaviorEvent.onsubmit;
        default:
            throw new Error('Behavior event name not recognized');
    }
}
Framework.Behavior.ElementBehavior.prototype = {
    isBehaviorDisposed: false,
    _onClickEventHandler: null,
    
    add_onClick: function Framework_Behavior_ElementBehavior$add_onClick(value) {
        this._onClickEventHandler = Delegate.combine(this._onClickEventHandler, value);
        if (!this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onclick))) {
            this.get_domEvents().attach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onclick), Delegate.create(this, this.onClickEventFired));
            this._addDebugAttribute$1(Framework.Behavior.BehaviorEvent.onclick, value);
        }
    },
    remove_onClick: function Framework_Behavior_ElementBehavior$remove_onClick(value) {
        this._onClickEventHandler = Delegate.remove(this._onClickEventHandler, value);
        if (!this._onClickEventHandler) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onclick));
            this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onclick);
        }
    },
    
    detachAllOnClick: function Framework_Behavior_ElementBehavior$detachAllOnClick() {
        this._onClickEventHandler = null;
        if (this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onclick))) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onclick));
        }
        this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onclick);
    },
    
    onClickEventFired: function Framework_Behavior_ElementBehavior$onClickEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnClickEventArgs();
        eventArgs.domElement = this.get_domElement();
        this._onClickEventHandler.invoke(this, eventArgs);
    },
    
    _onChangeEventHandler: null,
    
    add_onChange: function Framework_Behavior_ElementBehavior$add_onChange(value) {
        this._onChangeEventHandler = Delegate.combine(this._onChangeEventHandler, value);
        if (!this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onchange))) {
            this.get_domEvents().attach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onchange), Delegate.create(this, this.onChangeEventFired));
            this._addDebugAttribute$1(Framework.Behavior.BehaviorEvent.onchange, value);
        }
    },
    remove_onChange: function Framework_Behavior_ElementBehavior$remove_onChange(value) {
        this._onChangeEventHandler = Delegate.remove(this._onChangeEventHandler, value);
        if (!this._onChangeEventHandler) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onchange));
            this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onchange);
        }
    },
    
    detachAllOnChange: function Framework_Behavior_ElementBehavior$detachAllOnChange() {
        this._onChangeEventHandler = null;
        if (this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onchange))) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onchange));
        }
        this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onchange);
    },
    
    onChangeEventFired: function Framework_Behavior_ElementBehavior$onChangeEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnChangeEventArgs();
        eventArgs.domElement = this.get_domElement();
        this._onChangeEventHandler.invoke(this, eventArgs);
    },
    
    _onKeyUpEventHandler: null,
    
    add_onKeyUp: function Framework_Behavior_ElementBehavior$add_onKeyUp(value) {
        this._onKeyUpEventHandler = Delegate.combine(this._onKeyUpEventHandler, value);
        if (!this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onkeyup))) {
            this.get_domEvents().attach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onkeyup), Delegate.create(this, this.onKeyUpEventFired));
            this._addDebugAttribute$1(Framework.Behavior.BehaviorEvent.onkeyup, value);
        }
    },
    remove_onKeyUp: function Framework_Behavior_ElementBehavior$remove_onKeyUp(value) {
        this._onKeyUpEventHandler = Delegate.remove(this._onKeyUpEventHandler, value);
        if (!this._onKeyUpEventHandler) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onkeyup));
            this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onkeyup);
        }
    },
    
    detachAllOnKeyUp: function Framework_Behavior_ElementBehavior$detachAllOnKeyUp() {
        this._onKeyUpEventHandler = null;
        if (this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onkeyup))) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onkeyup));
        }
        this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onkeyup);
    },
    
    onKeyUpEventFired: function Framework_Behavior_ElementBehavior$onKeyUpEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnKeyUpEventArgs();
        eventArgs.domElement = this.get_domElement();
        this._onKeyUpEventHandler.invoke(this, eventArgs);
    },
    
    _onMouseOverEventHandler: null,
    
    add_onMouseOver: function Framework_Behavior_ElementBehavior$add_onMouseOver(value) {
        this._onMouseOverEventHandler = Delegate.combine(this._onMouseOverEventHandler, value);
        if (!this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseover))) {
            this.get_domEvents().attach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseover), Delegate.create(this, this.onMouseOverEventFired));
            this._addDebugAttribute$1(Framework.Behavior.BehaviorEvent.onmouseover, value);
        }
    },
    remove_onMouseOver: function Framework_Behavior_ElementBehavior$remove_onMouseOver(value) {
        this._onMouseOverEventHandler = Delegate.remove(this._onMouseOverEventHandler, value);
        if (!this._onMouseOverEventHandler) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseover));
            this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onmouseover);
        }
    },
    
    detachAllOnMouseOver: function Framework_Behavior_ElementBehavior$detachAllOnMouseOver() {
        this._onMouseOverEventHandler = null;
        if (this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseover))) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseover));
        }
        this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onmouseover);
    },
    
    onMouseOverEventFired: function Framework_Behavior_ElementBehavior$onMouseOverEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnMouseOverEventArgs();
        eventArgs.domElement = this.get_domElement();
        this._onMouseOverEventHandler.invoke(this, eventArgs);
    },
    
    _onMouseOutEventHandler: null,
    
    add_onMouseOut: function Framework_Behavior_ElementBehavior$add_onMouseOut(value) {
        this._onMouseOutEventHandler = Delegate.combine(this._onMouseOutEventHandler, value);
        if (!this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseout))) {
            this.get_domEvents().attach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseout), Delegate.create(this, this.onMouseOutEventFired));
            this._addDebugAttribute$1(Framework.Behavior.BehaviorEvent.onmouseout, value);
        }
    },
    remove_onMouseOut: function Framework_Behavior_ElementBehavior$remove_onMouseOut(value) {
        this._onMouseOutEventHandler = Delegate.remove(this._onMouseOutEventHandler, value);
        if (!this._onMouseOutEventHandler) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseout));
            this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onmouseout);
        }
    },
    
    detachAllOnMouseOut: function Framework_Behavior_ElementBehavior$detachAllOnMouseOut() {
        this._onMouseOutEventHandler = null;
        if (this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseout))) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseout));
        }
        this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onmouseout);
    },
    
    onMouseOutEventFired: function Framework_Behavior_ElementBehavior$onMouseOutEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnMouseOutEventArgs();
        eventArgs.domElement = this.get_domElement();
        this._onMouseOutEventHandler.invoke(this, eventArgs);
    },
    
    _onFocusEventHandler: null,
    
    add_onFocus: function Framework_Behavior_ElementBehavior$add_onFocus(value) {
        this._onFocusEventHandler = Delegate.combine(this._onFocusEventHandler, value);
        if (!this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onfocus))) {
            this.get_domEvents().attach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onfocus), Delegate.create(this, this.onFocusEventFired));
            this._addDebugAttribute$1(Framework.Behavior.BehaviorEvent.onfocus, value);
        }
    },
    remove_onFocus: function Framework_Behavior_ElementBehavior$remove_onFocus(value) {
        this._onFocusEventHandler = Delegate.remove(this._onFocusEventHandler, value);
        if (!this._onFocusEventHandler) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onfocus));
            this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onfocus);
        }
    },
    
    detachAllOnFocus: function Framework_Behavior_ElementBehavior$detachAllOnFocus() {
        this._onFocusEventHandler = null;
        if (this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onfocus))) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onfocus));
        }
        this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onfocus);
    },
    
    onFocusEventFired: function Framework_Behavior_ElementBehavior$onFocusEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnFocusEventArgs();
        eventArgs.domElement = this.get_domElement();
        this._onFocusEventHandler.invoke(this, eventArgs);
    },
    
    _onBlurEventHandler: null,
    
    add_onBlur: function Framework_Behavior_ElementBehavior$add_onBlur(value) {
        this._onBlurEventHandler = Delegate.combine(this._onBlurEventHandler, value);
        if (!this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onblur))) {
            this.get_domEvents().attach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onblur), Delegate.create(this, this.onBlurEventFired));
            this._addDebugAttribute$1(Framework.Behavior.BehaviorEvent.onblur, value);
        }
    },
    remove_onBlur: function Framework_Behavior_ElementBehavior$remove_onBlur(value) {
        this._onBlurEventHandler = Delegate.remove(this._onBlurEventHandler, value);
        if (!this._onBlurEventHandler) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onblur));
            this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onblur);
        }
    },
    
    detachAllOnBlur: function Framework_Behavior_ElementBehavior$detachAllOnBlur() {
        this._onBlurEventHandler = null;
        if (this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onblur))) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onblur));
        }
        this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onblur);
    },
    
    onBlurEventFired: function Framework_Behavior_ElementBehavior$onBlurEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnBlurEventArgs();
        eventArgs.domElement = this.get_domElement();
        this._onBlurEventHandler.invoke(this, eventArgs);
    },
    
    _onSubmitEventHandler: null,
    
    add_onSubmit: function Framework_Behavior_ElementBehavior$add_onSubmit(value) {
        this._onSubmitEventHandler = Delegate.combine(this._onSubmitEventHandler, value);
        if (!this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onsubmit))) {
            this.get_domEvents().attach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onsubmit), Delegate.create(this, this.onSubmitEventFired));
            this._addDebugAttribute$1(Framework.Behavior.BehaviorEvent.onsubmit, value);
        }
    },
    remove_onSubmit: function Framework_Behavior_ElementBehavior$remove_onSubmit(value) {
        this._onSubmitEventHandler = Delegate.remove(this._onSubmitEventHandler, value);
        if (!this._onBlurEventHandler) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onsubmit));
            this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onsubmit);
        }
    },
    
    detachAllOnSubmit: function Framework_Behavior_ElementBehavior$detachAllOnSubmit() {
        this._onSubmitEventHandler = null;
        if (this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onsubmit))) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onsubmit));
        }
        this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onsubmit);
    },
    
    onSubmitEventFired: function Framework_Behavior_ElementBehavior$onSubmitEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnSubmitEventArgs();
        eventArgs.domElement = this.get_domElement();
        this._onSubmitEventHandler.invoke(this, eventArgs);
    },
    
    dispose: function Framework_Behavior_ElementBehavior$dispose() {
        if (this.isBehaviorDisposed) {
            return;
        }
        if (!this.get_isDisposed()) {
            this.get_domEvents().dispose();
            Framework.Behavior.ElementBehavior.callBase(this, 'dispose');
        }
        this._onClickEventHandler = null;
        this._onChangeEventHandler = null;
        this._onKeyUpEventHandler = null;
        this._onMouseOverEventHandler = null;
        this._onMouseOutEventHandler = null;
        this._onFocusEventHandler = null;
        this._onBlurEventHandler = null;
        this._onSubmitEventHandler = null;
        this.isBehaviorDisposed = true;
    },
    
    _addDebugAttribute$1: function Framework_Behavior_ElementBehavior$_addDebugAttribute$1(eventName, value) {
        if (this.get__isDevelopmentModeTurnedOn$1()) {
            this.get_domElement().setAttribute(this._getDebugAttributeName$1(eventName), this._getDelegateDebugInfo$1(value));
        }
    },
    
    _removeDebugAttribute$1: function Framework_Behavior_ElementBehavior$_removeDebugAttribute$1(eventName) {
        if (this.get__isDevelopmentModeTurnedOn$1()) {
            this.get_domElement().removeAttribute(this._getDebugAttributeName$1(eventName));
        }
    },
    
    _getDebugAttributeName$1: function Framework_Behavior_ElementBehavior$_getDebugAttributeName$1(eventName) {
        return 'debug.behavior.' + Framework.Behavior.ElementBehavior.behaviorEventToString(eventName) + '_boundto';
    },
    
    get__isDevelopmentModeTurnedOn$1: function Framework_Behavior_ElementBehavior$get__isDevelopmentModeTurnedOn$1() {
        return Framework.AbstractEnvironment._debugMode;
    },
    
    _getDelegateDebugInfo$1: function Framework_Behavior_ElementBehavior$_getDelegateDebugInfo$1(value) {
        return Framework.Util.DebugInfoProvider.delegateDebugInfo(value);
    }
}


Type.createNamespace('Framework.Behavior.EventArgs');

////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnSubmitEventArgs

Framework.Behavior.EventArgs.OnSubmitEventArgs = function Framework_Behavior_EventArgs_OnSubmitEventArgs() {
    Framework.Behavior.EventArgs.OnSubmitEventArgs.constructBase(this);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnBlurEventArgs

Framework.Behavior.EventArgs.OnBlurEventArgs = function Framework_Behavior_EventArgs_OnBlurEventArgs() {
    Framework.Behavior.EventArgs.OnBlurEventArgs.constructBase(this);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnFocusEventArgs

Framework.Behavior.EventArgs.OnFocusEventArgs = function Framework_Behavior_EventArgs_OnFocusEventArgs() {
    Framework.Behavior.EventArgs.OnFocusEventArgs.constructBase(this);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnMouseOutEventArgs

Framework.Behavior.EventArgs.OnMouseOutEventArgs = function Framework_Behavior_EventArgs_OnMouseOutEventArgs() {
    Framework.Behavior.EventArgs.OnMouseOutEventArgs.constructBase(this);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnMouseOverEventArgs

Framework.Behavior.EventArgs.OnMouseOverEventArgs = function Framework_Behavior_EventArgs_OnMouseOverEventArgs() {
    Framework.Behavior.EventArgs.OnMouseOverEventArgs.constructBase(this);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnKeyUpEventArgs

Framework.Behavior.EventArgs.OnKeyUpEventArgs = function Framework_Behavior_EventArgs_OnKeyUpEventArgs() {
    Framework.Behavior.EventArgs.OnKeyUpEventArgs.constructBase(this);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.Parameters

Framework.Behavior.EventArgs.Parameters = function Framework_Behavior_EventArgs_Parameters(parameters) {
    this._parameters = parameters;
}
Framework.Behavior.EventArgs.Parameters.prototype = {
    _parameters: null,
    
    getAsNumber: function Framework_Behavior_EventArgs_Parameters$getAsNumber(parametername) {
        return Framework.Util.StringConverter.getAsNumber(this._parameters[parametername]);
    },
    
    getAsString: function Framework_Behavior_EventArgs_Parameters$getAsString(parametername) {
        return Framework.Util.StringConverter.getAsString(this._parameters[parametername]);
    },
    
    getAsStringArray: function Framework_Behavior_EventArgs_Parameters$getAsStringArray(parametername) {
        return Framework.Util.StringConverter.getAsStringArray(this._parameters[parametername]);
    },
    
    getAsNumberArray: function Framework_Behavior_EventArgs_Parameters$getAsNumberArray(parametername) {
        return Framework.Util.StringConverter.getAsNumberArray(this._parameters[parametername]);
    },
    
    getAsBoolean: function Framework_Behavior_EventArgs_Parameters$getAsBoolean(parametername) {
        return Framework.Util.StringConverter.getAsBoolean(this._parameters[parametername]);
    },
    
    getAsEscapedString: function Framework_Behavior_EventArgs_Parameters$getAsEscapedString(parametername) {
        return Framework.Util.StringConverter.getAsEscapedString(this._parameters[parametername]);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnLoadEventArgs

Framework.Behavior.EventArgs.OnLoadEventArgs = function Framework_Behavior_EventArgs_OnLoadEventArgs() {
    Framework.Behavior.EventArgs.OnLoadEventArgs.constructBase(this);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.BehaviorEventArgs

Framework.Behavior.EventArgs.BehaviorEventArgs = function Framework_Behavior_EventArgs_BehaviorEventArgs() {
}
Framework.Behavior.EventArgs.BehaviorEventArgs.prototype = {
    domElement: null,
    parameters: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnChangeEventArgs

Framework.Behavior.EventArgs.OnChangeEventArgs = function Framework_Behavior_EventArgs_OnChangeEventArgs() {
    Framework.Behavior.EventArgs.OnChangeEventArgs.constructBase(this);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnClickEventArgs

Framework.Behavior.EventArgs.OnClickEventArgs = function Framework_Behavior_EventArgs_OnClickEventArgs() {
    Framework.Behavior.EventArgs.OnClickEventArgs.constructBase(this);
}


Type.createNamespace('Framework.Component');

////////////////////////////////////////////////////////////////////////////////
// Framework.Component.AbstractComponent

Framework.Component.AbstractComponent = function Framework_Component_AbstractComponent() {
    this._log = Framework.Logger.getLog('AbstractComponent');
    this._children = new Array(0);
    this.componentLifeCycleManager = this.createComponentLifeCycleManager();
}
Framework.Component.AbstractComponent.setFormEnabled = function Framework_Component_AbstractComponent$setFormEnabled(domElementId, enabled) {
    Framework.Component.AbstractComponent._setCollectionEnabled(document.getElementById(domElementId).getElementsByTagName('select'), enabled);
    Framework.Component.AbstractComponent._setCollectionEnabled(document.getElementById(domElementId).getElementsByTagName('input'), enabled);
    Framework.Component.AbstractComponent._setCollectionEnabled(document.getElementById(domElementId).getElementsByTagName('button'), enabled);
    Framework.Component.AbstractComponent._setCollectionEnabled(document.getElementById(domElementId).getElementsByTagName('textarea'), enabled);
}
Framework.Component.AbstractComponent._setCollectionEnabled = function Framework_Component_AbstractComponent$_setCollectionEnabled(domElementCollection, enabled) {
    for (var i = 0; i < domElementCollection.length; i++) {
        domElementCollection[i].disabled = !enabled;
    }
}
Framework.Component.AbstractComponent.prototype = {
    _environment: null,
    _componentInstanceName: null,
    _domElementId: null,
    _currentArea: 0,
    _area: null,
    _adminHtmlUrl: null,
    _childID: null,
    _parent: null,
    _siblingIndex: 0,
    componentLifeCycleManager: null,
    
    get_componentInstanceName: function Framework_Component_AbstractComponent$get_componentInstanceName() {
        return this._componentInstanceName;
    },
    
    get_domElementId: function Framework_Component_AbstractComponent$get_domElementId() {
        return this._domElementId;
    },
    set_domElementId: function Framework_Component_AbstractComponent$set_domElementId(value) {
        this._domElementId = value;
        return value;
    },
    
    init: function Framework_Component_AbstractComponent$init(environment, componentInstanceName, domElementId, parameters) {
        this._log = Framework.Logger.getLog(domElementId);
        this._log.debug('Init');
        this._environment = environment;
        this._componentInstanceName = componentInstanceName;
        this._domElementId = domElementId;
        this._adminHtmlUrl = parameters['admin-html-url'];
    },
    
    start: function Framework_Component_AbstractComponent$start() {
        this._log.debug('Start');
    },
    
    repaintForAdmin: function Framework_Component_AbstractComponent$repaintForAdmin() {
        var ajaxUpdater = new Framework.AjaxUpdater(this._domElementId, this._adminHtmlUrl, null, Delegate.create(this, function() {
            this._environment.updateDomElement(this._domElementId, this._domElementId);
        }));
        ajaxUpdater.update();
    },
    
    createComponentLifeCycleManager: function Framework_Component_AbstractComponent$createComponentLifeCycleManager() {
        return new Framework.Component.LifeCycleManagement.ComponentLifeCycleManager(this);
    },
    
    disableForAdmin: function Framework_Component_AbstractComponent$disableForAdmin() {
        var anchors = this._environment.getDomElement(this._domElementId).getElementsByTagName('A');
        for (var i = 0; i < anchors.length; i++) {
            var anchor = anchors[i];
            anchor.setAttribute('href', '#');
            anchor.setAttribute('onclick', 'return false;');
        }
    },
    
    isVisible: function Framework_Component_AbstractComponent$isVisible(visibleOn, notVisibleOn, action) {
        if (!visibleOn.length && !notVisibleOn.length) {
            return true;
        }
        if (visibleOn.length > 0) {
            return visibleOn.contains(action);
        }
        if (notVisibleOn.length > 0) {
            return !notVisibleOn.contains(action);
        }
        throw new Error('Parameters were not specified correctly.');
    },
    
    show: function Framework_Component_AbstractComponent$show() {
        this._environment.getDomElement(this._domElementId).style.display = 'block';
    },
    
    hide: function Framework_Component_AbstractComponent$hide() {
        this._environment.getDomElement(this._domElementId).style.display = 'none';
        this._environment.updateDomElement(this._domElementId, String.Empty);
    },
    
    disable: function Framework_Component_AbstractComponent$disable() {
        this._environment.getDomElement(this._domElementId).style.cursor = 'wait';
        Framework.Component.AbstractComponent.setFormEnabled(this._domElementId, false);
    },
    
    enable: function Framework_Component_AbstractComponent$enable() {
        this._environment.getDomElement(this._domElementId).style.cursor = 'default';
        Framework.Component.AbstractComponent.setFormEnabled(this._domElementId, true);
    },
    
    getPrivateDomElement: function Framework_Component_AbstractComponent$getPrivateDomElement(domElementNameSuffix) {
        return document.getElementById(String.format('{0}-{1}', this._domElementId, domElementNameSuffix));
    },
    
    updatePrivateDomElement: function Framework_Component_AbstractComponent$updatePrivateDomElement(domElementNameSuffix, htmlContent) {
        this.updatePrivateDomElementWithCallback(domElementNameSuffix, htmlContent, null, null);
    },
    
    updatePrivateDomElementWithCallback: function Framework_Component_AbstractComponent$updatePrivateDomElementWithCallback(domElementNameSuffix, htmlContent, successCallback, failureCallback) {
        try {
            var element = document.getElementById(String.format('{0}-{1}', this._domElementId, domElementNameSuffix));
            if (element) {
                this._environment.updateDomElementDirect(element, htmlContent);
                if (successCallback) {
                    successCallback.invoke();
                }
            }
            else {
                throw new Error(String.format('domElementNameSuffix [{0}] cannot be found!', domElementNameSuffix));
            }
        }
        catch (ex) {
            this._log.error('UpdatePrivateDomElement', ex);
            if (failureCallback) {
                failureCallback.invoke(ex);
            }
        }
    },
    
    activateArea: function Framework_Component_AbstractComponent$activateArea(area, messages) {
        this._log.debug(String.format('ActivateArea area=[{0}] messages=[{1}]', area, messages));
        this._environment.getDomElement(this._domElementId + '-' + this._area[this._currentArea]).style.display = 'none';
        this._currentArea = area;
        this._environment.getDomElement(this._domElementId + '-' + this._area[this._currentArea]).style.display = 'block';
        if (messages) {
            for (var i = 0; i < messages.length; i++) {
                if (!String.isNullOrEmpty(messages[i])) {
                    this._environment.getDomElement(this._domElementId + '-' + this._area[this._currentArea] + '-' + i).innerText = messages[i];
                }
            }
        }
    },
    
    getTranslation: function Framework_Component_AbstractComponent$getTranslation(phrase) {
        return this.getPrivateDomElement(phrase).innerHTML;
    },
    
    get_parent: function Framework_Component_AbstractComponent$get_parent() {
        return this._parent;
    },
    
    get_childID: function Framework_Component_AbstractComponent$get_childID() {
        return this._childID;
    },
    set_childID: function Framework_Component_AbstractComponent$set_childID(value) {
        this._childID = value;
        return value;
    },
    
    startChildren: function Framework_Component_AbstractComponent$startChildren() {
        for (var index = 0; index < this._children.length; index++) {
            var newComponent = (this._children[index]);
            if (!isNullOrUndefined(newComponent.componentLifeCycleManager)) {
                newComponent.componentLifeCycleManager.start();
            }
            else {
                this._children[index].start();
            }
        }
    },
    
    addChild: function Framework_Component_AbstractComponent$addChild(child) {
        var index = this._children.length;
        this._children[index] = child;
        child._parent = this;
        child._siblingIndex = index;
    },
    
    get_hasChildren: function Framework_Component_AbstractComponent$get_hasChildren() {
        if (!this._children) {
            return false;
        }
        return this._children.length > 0;
    },
    
    get_children: function Framework_Component_AbstractComponent$get_children() {
        return this._children;
    },
    
    getChildByID: function Framework_Component_AbstractComponent$getChildByID(childID) {
        for (var count = 0; count < this._children.length; count++) {
            if (this._children[count].get_childID() === childID) {
                return this._children[count];
            }
        }
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.ComponentFactory

Framework.Component.ComponentFactory = function Framework_Component_ComponentFactory() {
}
Framework.Component.ComponentFactory.create = function Framework_Component_ComponentFactory$create(componentName, componentConfigurationItem, placeholderId, environment) {
    Framework.Component.ComponentFactory._log.debug(String.format('Processing {0}', componentName));
    var component = eval('new ' + componentConfigurationItem.className + '();');
    component.set_childID(componentConfigurationItem.childID);
    if (placeholderId) {
        var componentDocumentElement = document.createElement('div');
        if (!componentConfigurationItem.parameters['css-class']) {
            componentDocumentElement.className = 'component';
        }
        else {
            componentDocumentElement.className = componentConfigurationItem.parameters['css-class'].toString();
        }
        componentDocumentElement.id = componentName;
        document.getElementById(placeholderId).appendChild(componentDocumentElement);
    }
    component.componentLifeCycleManager.initialize(environment, String.format('autoWiring.getComponents()[\'{0}\']', componentName), componentName, componentConfigurationItem.parameters);
    return component;
}
Framework.Component.ComponentFactory.initialize = function Framework_Component_ComponentFactory$initialize(componentName, component, componentConfigurationItem, services, components) {
    Framework.Component.ComponentFactory._bindServices(componentName, component, componentConfigurationItem, services);
    Framework.Component.ComponentFactory._addChildComponents(component, componentConfigurationItem, components);
}
Framework.Component.ComponentFactory.deleteComponent = function Framework_Component_ComponentFactory$deleteComponent(component, services, components) {
    throw new Error('NOT IMPLEMENTED');
}
Framework.Component.ComponentFactory._bindServices = function Framework_Component_ComponentFactory$_bindServices(componentName, component, componentConfigurationItem, services) {
    Framework.Component.ComponentFactory._log.debug(String.format('Connecting services to {0}', componentName));
    var $enum1 = componentConfigurationItem.requiredServices.getEnumerator();
    while ($enum1.moveNext()) {
        var requiredServiceName = $enum1.get_current();
        Framework.Component.ComponentFactory._log.debug(String.format('Injecting [{0}] into [{1}]', requiredServiceName, componentName));
        var requiredService = services[requiredServiceName];
        component['set' + Type.getInstanceType(requiredService).get_name()](requiredService);
    }
    Framework.Component.ComponentFactory._log.debug(String.format('Subscribing to events {0}', componentName));
    var $dict2 = componentConfigurationItem.connectEvents;
    for (var $key3 in $dict2) {
        var connectedEventsDictionaryEntry = { key: $key3, value: $dict2[$key3] };
        var service = services[connectedEventsDictionaryEntry.key];
        var events = connectedEventsDictionaryEntry.value;
        if ((events.length === 1) && (!'*'.compareTo(events[0]))) {
        }
        else {
            var $enum4 = events.getEnumerator();
            while ($enum4.moveNext()) {
                var eventName = $enum4.get_current();
                service['register' + eventName + 'Listener'](component);
            }
        }
    }
}
Framework.Component.ComponentFactory._addChildComponents = function Framework_Component_ComponentFactory$_addChildComponents(component, componentConfigurationItem, components) {
    var $enum1 = componentConfigurationItem.childComponents.getEnumerator();
    while ($enum1.moveNext()) {
        var childComponentName = $enum1.get_current();
        var childComponent = (components[childComponentName]);
        component.addChild(childComponent);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.AbstractXsltBasedComponent

Framework.Component.AbstractXsltBasedComponent = function Framework_Component_AbstractXsltBasedComponent() {
    Framework.Component.AbstractXsltBasedComponent.constructBase(this);
}
Framework.Component.AbstractXsltBasedComponent.prototype = {
    _parameters: null,
    
    get__componentElement$1: function Framework_Component_AbstractXsltBasedComponent$get__componentElement$1() {
        return this._environment.getDomElement(this._domElementId);
    },
    
    init: function Framework_Component_AbstractXsltBasedComponent$init(environment, componentInstanceName, domElementId, parameters) {
    },
    
    start: function Framework_Component_AbstractXsltBasedComponent$start() {
    },
    
    preTransformation: function Framework_Component_AbstractXsltBasedComponent$preTransformation(eventArgs) {
    },
    
    xmlContentReceived: function Framework_Component_AbstractXsltBasedComponent$xmlContentReceived(eventArgs) {
    },
    
    preRender: function Framework_Component_AbstractXsltBasedComponent$preRender(eventArgs) {
        Framework.Behavior.Binding.BehaviorBinder.autoBind(eventArgs.get_inMemoryContent(), this);
    },
    
    renderComplete: function Framework_Component_AbstractXsltBasedComponent$renderComplete(eventArgs) {
    },
    
    createComponentLifeCycleManager: function Framework_Component_AbstractXsltBasedComponent$createComponentLifeCycleManager() {
        return new Framework.Component.LifeCycleManagement.XsltBasedComponentLifeCycleManager(this);
    },
    
    _preTransformationAbstractXsltBasedComponent: function Framework_Component_AbstractXsltBasedComponent$_preTransformationAbstractXsltBasedComponent(eventArgs) {
        if (!this.get_isComponentVisible()) {
            eventArgs.set_cancelUpdate(true);
            this.hide();
        }
        else {
            this.show();
        }
    },
    
    _preInitializeAbstractXsltBasedComponent: function Framework_Component_AbstractXsltBasedComponent$_preInitializeAbstractXsltBasedComponent(environment, componentInstanceName, domElementId, parameters) {
        Framework.Component.AbstractXsltBasedComponent.callBase(this, 'init', [ environment, componentInstanceName, domElementId, parameters ]);
        this._parameters = new Framework.CommonComponentParameters(parameters);
    },
    
    _preStartAbstractXsltBasedComponent: function Framework_Component_AbstractXsltBasedComponent$_preStartAbstractXsltBasedComponent() {
        this._log.debug('Start');
    },
    
    removeAllScheduledUpdates: function Framework_Component_AbstractXsltBasedComponent$removeAllScheduledUpdates() {
        this._environment.get_componentUpdateScheduler().removeScheduledTasksByDomain(this._domElementId);
    },
    
    getXsltParameters: function Framework_Component_AbstractXsltBasedComponent$getXsltParameters(contextObject) {
        var result = {};
        result['component-instance-name'] = this._componentInstanceName;
        result['component-dom-element-id'] = this._domElementId;
        return result;
    },
    
    update: function Framework_Component_AbstractXsltBasedComponent$update(domElement, contentID, xsltUrl, xsltParameters, customEventArgs) {
        var xsltBasedUpdateContextObject;
        var region = this._environment.getRegion();
        var language = this._environment.getLanguage();
        if (!domElement) {
            xsltBasedUpdateContextObject = new Framework.Component.Updating.XsltBasedUpdateContextObject(this.get__componentElement$1(), null, region, language);
            xsltBasedUpdateContextObject.contentUrl = this._parameters.get_contentUrl();
            xsltBasedUpdateContextObject.xsltUrl = this._parameters.get_xsltUrl();
            xsltBasedUpdateContextObject.xsltParameters = this.getXsltParameters(null);
        }
        else {
            xsltBasedUpdateContextObject = new Framework.Component.Updating.XsltBasedUpdateContextObject(domElement, null, region, language);
            xsltBasedUpdateContextObject.contentUrl = contentID;
            xsltBasedUpdateContextObject.xsltUrl = xsltUrl;
            xsltBasedUpdateContextObject.xsltParameters = xsltParameters;
        }
        xsltBasedUpdateContextObject.customEventArgs = customEventArgs;
        var updateTask = new Framework.Component.Updating.UpdateXsltBasedComponentTask(xsltBasedUpdateContextObject, this.componentLifeCycleManager);
        updateTask.execute();
    },
    
    periodicalUpdate: function Framework_Component_AbstractXsltBasedComponent$periodicalUpdate(domElementId, contentID, xsltUrl, xsltParameters, domain, autoRefreshPeriod, customEventArgs) {
        var xsltBasedUpdateContextObject = new Framework.Component.Updating.XsltBasedUpdateContextObject(null, domElementId, this._environment.getRegion(), this._environment.getLanguage());
        xsltBasedUpdateContextObject.contentUrl = contentID;
        xsltBasedUpdateContextObject.xsltUrl = xsltUrl;
        xsltBasedUpdateContextObject.xsltParameters = xsltParameters;
        xsltBasedUpdateContextObject.customEventArgs = customEventArgs;
        var updateTask = new Framework.Component.Updating.UpdateXsltBasedComponentTask(xsltBasedUpdateContextObject, this.componentLifeCycleManager);
        this._environment.get_componentUpdateScheduler().scheduleNewTask(updateTask, domain, autoRefreshPeriod);
    }
}


Type.createNamespace('Framework.Component.LifeCycleManagement.EventArgs');

////////////////////////////////////////////////////////////////////////////////
// Framework.Component.LifeCycleManagement.EventArgs.XmlContentReceivedEventArgs

Framework.Component.LifeCycleManagement.EventArgs.XmlContentReceivedEventArgs = function Framework_Component_LifeCycleManagement_EventArgs_XmlContentReceivedEventArgs() {
}
Framework.Component.LifeCycleManagement.EventArgs.XmlContentReceivedEventArgs.prototype = {
    _contentXmlDocument: null,
    _customEventArgs: null,
    
    get_contentXmlDocument: function Framework_Component_LifeCycleManagement_EventArgs_XmlContentReceivedEventArgs$get_contentXmlDocument() {
        return this._contentXmlDocument;
    },
    set_contentXmlDocument: function Framework_Component_LifeCycleManagement_EventArgs_XmlContentReceivedEventArgs$set_contentXmlDocument(value) {
        this._contentXmlDocument = value;
        return value;
    },
    
    get_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_XmlContentReceivedEventArgs$get_customEventArgs() {
        return this._customEventArgs;
    },
    set_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_XmlContentReceivedEventArgs$set_customEventArgs(value) {
        this._customEventArgs = value;
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.LifeCycleManagement.EventArgs.CustomEventArgs

Framework.Component.LifeCycleManagement.EventArgs.CustomEventArgs = function Framework_Component_LifeCycleManagement_EventArgs_CustomEventArgs() {
    this.parametersDictionary = {};
}
Framework.Component.LifeCycleManagement.EventArgs.CustomEventArgs.prototype = {
    parametersDictionary: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.LifeCycleManagement.EventArgs.RenderCompleteEventArgs

Framework.Component.LifeCycleManagement.EventArgs.RenderCompleteEventArgs = function Framework_Component_LifeCycleManagement_EventArgs_RenderCompleteEventArgs() {
}
Framework.Component.LifeCycleManagement.EventArgs.RenderCompleteEventArgs.prototype = {
    _customEventArgs: null,
    
    get_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_RenderCompleteEventArgs$get_customEventArgs() {
        return this._customEventArgs;
    },
    set_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_RenderCompleteEventArgs$set_customEventArgs(value) {
        this._customEventArgs = value;
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.LifeCycleManagement.EventArgs.PreRenderEventArgs

Framework.Component.LifeCycleManagement.EventArgs.PreRenderEventArgs = function Framework_Component_LifeCycleManagement_EventArgs_PreRenderEventArgs(inMemoryContent) {
    this._inMemoryContent = inMemoryContent;
}
Framework.Component.LifeCycleManagement.EventArgs.PreRenderEventArgs.prototype = {
    _inMemoryContent: null,
    _customEventArgs: null,
    
    get_inMemoryContent: function Framework_Component_LifeCycleManagement_EventArgs_PreRenderEventArgs$get_inMemoryContent() {
        return this._inMemoryContent;
    },
    set_inMemoryContent: function Framework_Component_LifeCycleManagement_EventArgs_PreRenderEventArgs$set_inMemoryContent(value) {
        this._inMemoryContent = value;
        return value;
    },
    
    get_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_PreRenderEventArgs$get_customEventArgs() {
        return this._customEventArgs;
    },
    set_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_PreRenderEventArgs$set_customEventArgs(value) {
        this._customEventArgs = value;
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.LifeCycleManagement.EventArgs.PreTransformationEventArgs

Framework.Component.LifeCycleManagement.EventArgs.PreTransformationEventArgs = function Framework_Component_LifeCycleManagement_EventArgs_PreTransformationEventArgs(contextObject, isPeriodicalUpdate) {
    this._isPeriodicalUpdate = isPeriodicalUpdate;
    this._contextObject = contextObject;
}
Framework.Component.LifeCycleManagement.EventArgs.PreTransformationEventArgs.prototype = {
    _cancelUpdate: false,
    _isPeriodicalUpdate: false,
    _contextObject: null,
    
    get_contextObject: function Framework_Component_LifeCycleManagement_EventArgs_PreTransformationEventArgs$get_contextObject() {
        return this._contextObject;
    },
    
    get_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_PreTransformationEventArgs$get_customEventArgs() {
        return this._contextObject.customEventArgs;
    },
    set_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_PreTransformationEventArgs$set_customEventArgs(value) {
        this._contextObject.customEventArgs = value;
        return value;
    },
    
    get_isPeriodicalUpdate: function Framework_Component_LifeCycleManagement_EventArgs_PreTransformationEventArgs$get_isPeriodicalUpdate() {
        return this._isPeriodicalUpdate;
    },
    
    get_cancelUpdate: function Framework_Component_LifeCycleManagement_EventArgs_PreTransformationEventArgs$get_cancelUpdate() {
        return this._cancelUpdate;
    },
    set_cancelUpdate: function Framework_Component_LifeCycleManagement_EventArgs_PreTransformationEventArgs$set_cancelUpdate(value) {
        this._cancelUpdate = value;
        return value;
    }
}


Type.createNamespace('Framework.Component.LifeCycleManagement');

////////////////////////////////////////////////////////////////////////////////
// Framework.Component.LifeCycleManagement.ComponentLifeCycleManager

Framework.Component.LifeCycleManagement.ComponentLifeCycleManager = function Framework_Component_LifeCycleManagement_ComponentLifeCycleManager(component) {
    this._component = component;
}
Framework.Component.LifeCycleManagement.ComponentLifeCycleManager.prototype = {
    _component: null,
    
    initialize: function Framework_Component_LifeCycleManagement_ComponentLifeCycleManager$initialize(environment, componentInstanceName, domElementId, parameters) {
        this._component.init(environment, componentInstanceName, domElementId, parameters);
    },
    
    start: function Framework_Component_LifeCycleManagement_ComponentLifeCycleManager$start() {
        this._component.start();
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.LifeCycleManagement.XsltBasedComponentLifeCycleManager

Framework.Component.LifeCycleManagement.XsltBasedComponentLifeCycleManager = function Framework_Component_LifeCycleManagement_XsltBasedComponentLifeCycleManager(component) {
    Framework.Component.LifeCycleManagement.XsltBasedComponentLifeCycleManager.constructBase(this, [ component ]);
}
Framework.Component.LifeCycleManagement.XsltBasedComponentLifeCycleManager.prototype = {
    
    get__component$1: function Framework_Component_LifeCycleManagement_XsltBasedComponentLifeCycleManager$get__component$1() {
        return this._component;
    },
    
    initialize: function Framework_Component_LifeCycleManagement_XsltBasedComponentLifeCycleManager$initialize(environment, componentInstanceName, domElementId, parameters) {
        this.get__component$1()._preInitializeAbstractXsltBasedComponent(environment, componentInstanceName, domElementId, parameters);
        this.get__component$1().init(environment, componentInstanceName, domElementId, parameters);
    },
    
    start: function Framework_Component_LifeCycleManagement_XsltBasedComponentLifeCycleManager$start() {
        this.get__component$1()._preStartAbstractXsltBasedComponent();
        this.get__component$1().start();
        this.get__component$1().removeAllScheduledUpdates();
        this.get__component$1().update();
    },
    
    preTransformation: function Framework_Component_LifeCycleManagement_XsltBasedComponentLifeCycleManager$preTransformation(eventArgs) {
        (this._component)._preTransformationAbstractXsltBasedComponent(eventArgs);
        (this._component).preTransformation(eventArgs);
    },
    
    xmlContentReceived: function Framework_Component_LifeCycleManagement_XsltBasedComponentLifeCycleManager$xmlContentReceived(eventArgs) {
        (this._component).xmlContentReceived(eventArgs);
    },
    
    preRender: function Framework_Component_LifeCycleManagement_XsltBasedComponentLifeCycleManager$preRender(eventArgs) {
        (this._component).preRender(eventArgs);
    },
    
    renderComplete: function Framework_Component_LifeCycleManagement_XsltBasedComponentLifeCycleManager$renderComplete(eventArgs) {
        (this._component).renderComplete(eventArgs);
    }
}


Type.createNamespace('Framework.Component.Updating');

////////////////////////////////////////////////////////////////////////////////
// Framework.Component.Updating.XsltBasedUpdateContextObject

Framework.Component.Updating.XsltBasedUpdateContextObject = function Framework_Component_Updating_XsltBasedUpdateContextObject(domElement, domElementId, region, language) {
    this.domElement = domElement;
    this.domElementId = domElementId;
    this.region = region;
    this.language = language;
}
Framework.Component.Updating.XsltBasedUpdateContextObject.prototype = {
    domElement: null,
    domElementId: null,
    region: null,
    language: null,
    contentUrl: null,
    xsltUrl: null,
    xsltParameters: null,
    domain: null,
    customXmlDocument: null,
    customEventArgs: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.Updating.ComponentUpdateScheduler

Framework.Component.Updating.ComponentUpdateScheduler = function Framework_Component_Updating_ComponentUpdateScheduler() {
    this._transformAndUpdateQueue = [];
}
Framework.Component.Updating.ComponentUpdateScheduler.prototype = {
    
    scheduleNewTask: function Framework_Component_Updating_ComponentUpdateScheduler$scheduleNewTask(task, domain, autoRefreshPeriod) {
        if (!task) {
            return;
        }
        task.set_isPeriodical(true);
        task.set_autoRefreshPeriod(autoRefreshPeriod);
        task.set_domain(domain);
        Framework.Component.Updating.HtmlUpdater.updateDomElementDirect(task.get_domElement(), '<img src=\'/indicator.gif\' />');
        task.execute();
        this._transformAndUpdateQueue.add(task);
    },
    
    removeScheduledTasksByDomain: function Framework_Component_Updating_ComponentUpdateScheduler$removeScheduledTasksByDomain(domain) {
        Framework.Component.Updating.ComponentUpdateScheduler._log.debug(String.format('RemoveScheduledTasksByDomain domain=[{0}]', domain));
        var newQueue = [];
        for (var i = 0; i < this._transformAndUpdateQueue.length; i++) {
            if (domain !== (this._transformAndUpdateQueue[i]).get_domain()) {
                newQueue.add(this._transformAndUpdateQueue[i]);
            }
        }
        this._transformAndUpdateQueue = newQueue;
    },
    
    _runSchedulingRuntime: function Framework_Component_Updating_ComponentUpdateScheduler$_runSchedulingRuntime(startIndex) {
        var queue = this._transformAndUpdateQueue;
        Framework.Component.Updating.ComponentUpdateScheduler._log.debug(String.format('RunSchedulingRuntime woke up!, StartIndex=[{0}]', startIndex));
        if (queue && queue.length > 0) {
            startIndex = Math.min(startIndex, queue.length - 1);
            var i = startIndex;
            do {
                var currentTask = queue[i];
                Framework.Component.Updating.ComponentUpdateScheduler._log.debug(String.format('RunSchedulingRuntime processing task i=[{0}] LastExecuted=[{1}] AutoRefreshPeriod=[{2}]', i, currentTask.get_lastExecuted(), currentTask.get_autoRefreshPeriod()));
                i = (i + 1) % queue.length;
                if (currentTask.get_lastExecuted().getTime() + currentTask.get_autoRefreshPeriod() < Date.get_now().getTime()) {
                    currentTask.execute();
                    break;
                }
            } while (i !== startIndex);
            startIndex = i;
        }
        window.setTimeout(Delegate.create(this, function() {
            this._runSchedulingRuntime(startIndex);
        }), Framework.Parameters.transformAndUpdateSchedulerPeriod);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.Updating.UpdateXsltBasedComponentTask

Framework.Component.Updating.UpdateXsltBasedComponentTask = function Framework_Component_Updating_UpdateXsltBasedComponentTask(contextObject, lifeCycleManager) {
    this._contextObject = contextObject;
    this._contextObject.contentUrl = this._createRealUrl(this._contextObject.contentUrl);
    this._lifeCycleManager = lifeCycleManager;
}
Framework.Component.Updating.UpdateXsltBasedComponentTask._onContentRequestsComplete = function Framework_Component_Updating_UpdateXsltBasedComponentTask$_onContentRequestsComplete(contentUrl) {
    Framework.Component.Updating.UpdateXsltBasedComponentTask._log.debug(String.format('OnContentRequestsComplete contentUrl=[{0}]', contentUrl));
    if (Object.keyExists(Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks, contentUrl) && Object.getKeyCount((Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks[contentUrl])) > 0) {
        var xmlCallBacksForUrl = Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks[contentUrl];
        var $dict1 = xmlCallBacksForUrl;
        for (var $key2 in $dict1) {
            var callback = { key: $key2, value: $dict1[$key2] };
            Framework.Component.Updating.UpdateXsltBasedComponentTask._log.debug(String.format('OnContentRequestsComplete callback key=[{0}] contentUrl=[{1}]', callback.key, contentUrl));
            (callback.value).invoke();
        }
    }
}
Framework.Component.Updating.UpdateXsltBasedComponentTask._getStamp = function Framework_Component_Updating_UpdateXsltBasedComponentTask$_getStamp(domElementId) {
    return Framework.Component.Updating.UpdateXsltBasedComponentTask._domElementCounterMap[domElementId];
}
Framework.Component.Updating.UpdateXsltBasedComponentTask._setStamp = function Framework_Component_Updating_UpdateXsltBasedComponentTask$_setStamp(domElementId, value) {
    Framework.Component.Updating.UpdateXsltBasedComponentTask._domElementCounterMap[domElementId] = value;
}
Framework.Component.Updating.UpdateXsltBasedComponentTask.storeXsltDocument = function Framework_Component_Updating_UpdateXsltBasedComponentTask$storeXsltDocument(url, document) {
    Framework.Component.Updating.UpdateXsltBasedComponentTask._cachedXsltXmlDocument[url] = document;
}
Framework.Component.Updating.UpdateXsltBasedComponentTask.prototype = {
    _isPeriodical: false,
    _autoRefreshPeriod: null,
    _domain: null,
    _startingCounterValue: 0,
    _lastExecuted: null,
    _contentRequest: null,
    _xsltRequest: null,
    _contentXmlDocument: null,
    _xsltXmlDocument: null,
    _contextObject: null,
    _lifeCycleManager: null,
    _contentUrl: null,
    
    get_isPeriodical: function Framework_Component_Updating_UpdateXsltBasedComponentTask$get_isPeriodical() {
        return this._isPeriodical;
    },
    set_isPeriodical: function Framework_Component_Updating_UpdateXsltBasedComponentTask$set_isPeriodical(value) {
        this._isPeriodical = value;
        return value;
    },
    
    get_autoRefreshPeriod: function Framework_Component_Updating_UpdateXsltBasedComponentTask$get_autoRefreshPeriod() {
        return this._autoRefreshPeriod;
    },
    set_autoRefreshPeriod: function Framework_Component_Updating_UpdateXsltBasedComponentTask$set_autoRefreshPeriod(value) {
        this._autoRefreshPeriod = value;
        return value;
    },
    
    get_domain: function Framework_Component_Updating_UpdateXsltBasedComponentTask$get_domain() {
        return this._domain;
    },
    set_domain: function Framework_Component_Updating_UpdateXsltBasedComponentTask$set_domain(value) {
        this._domain = value;
        return value;
    },
    
    get_lastExecuted: function Framework_Component_Updating_UpdateXsltBasedComponentTask$get_lastExecuted() {
        return this._lastExecuted;
    },
    
    get__contentUrl: function Framework_Component_Updating_UpdateXsltBasedComponentTask$get__contentUrl() {
        if (!this._contentUrl) {
            this._contentUrl = this._createRealUrl(this._contextObject.contentUrl);
        }
        return this._contentUrl;
    },
    
    get_domElementId: function Framework_Component_Updating_UpdateXsltBasedComponentTask$get_domElementId() {
        return (this.get_isPeriodical()) ? this._contextObject.domElementId : this._contextObject.domElement.id;
    },
    
    get_domElement: function Framework_Component_Updating_UpdateXsltBasedComponentTask$get_domElement() {
        return (this.get_isPeriodical()) ? document.getElementById(this._contextObject.domElementId) : this._contextObject.domElement;
    },
    
    get__xsltUrl: function Framework_Component_Updating_UpdateXsltBasedComponentTask$get__xsltUrl() {
        return this._contextObject.xsltUrl;
    },
    
    execute: function Framework_Component_Updating_UpdateXsltBasedComponentTask$execute() {
        var preTransformationEventArgs = new Framework.Component.LifeCycleManagement.EventArgs.PreTransformationEventArgs(this._contextObject, this.get_isPeriodical());
        this._lifeCycleManager.preTransformation(preTransformationEventArgs);
        if (preTransformationEventArgs.get_cancelUpdate()) {
            return;
        }
        this._contentUrl = null;
        if (!this.get_isPeriodical()) {
            Framework.Component.Updating.HtmlUpdater.updateDomElementDirect(document.getElementById(this.get_domElementId()), '<img src=\'/indicator.gif\' />');
        }
        this._lastExecuted = Date.get_now();
        this._contentXmlDocument = this._contextObject.customXmlDocument;
        this._update(true);
    },
    
    _update: function Framework_Component_Updating_UpdateXsltBasedComponentTask$_update(appendTimestampToContentUrl) {
        this._startingCounterValue = Framework.Component.Updating.UpdateXsltBasedComponentTask._requestCounter++;
        Framework.Component.Updating.UpdateXsltBasedComponentTask._setStamp(this.get_domElementId(), this._startingCounterValue);
        if (!this._contentXmlDocument) {
            if (this.get__contentUrl()) {
                var doCall = false;
                if (!Object.keyExists(Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks, this.get__contentUrl()) || !Object.getKeyCount((Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks[this.get__contentUrl()]))) {
                    doCall = true;
                    Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks[this.get__contentUrl()] = {};
                }
                (Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks[this.get__contentUrl()])[this.get_domElementId()] = Delegate.create(this, this._onContentRequestComplete);
                if (doCall) {
                    this._contentRequest = new Framework.XMLHttpRequestDecorator();
                    this._contentRequest.onreadystatechange = Delegate.create(this, function() {
                        Framework.Component.Updating.UpdateXsltBasedComponentTask._onContentRequestsComplete(this.get__contentUrl());
                    });
                    this._contentRequest.open('GET', this.get__contentUrl(), true);
                    this._contentRequest.send(null);
                    Framework.Component.Updating.UpdateXsltBasedComponentTask._contentRequests[this.get__contentUrl()] = this._contentRequest;
                }
            }
            else {
                this._contentXmlDocument = Framework.XMLUtils.get_emptyContentDocument();
            }
        }
        if (!Object.keyExists(Framework.Component.Updating.UpdateXsltBasedComponentTask._cachedXsltXmlDocument, this.get__xsltUrl())) {
            this._xsltRequest = new Framework.XMLHttpRequestDecorator();
            this._xsltRequest.onreadystatechange = Delegate.create(this, this._onXsltRequestComplete);
            this._xsltRequest.open('GET', this.get__xsltUrl(), true);
            this._xsltRequest.send(null);
        }
        else {
            this._xsltXmlDocument = Framework.Component.Updating.UpdateXsltBasedComponentTask._cachedXsltXmlDocument[this.get__xsltUrl()];
        }
        this._tryTransform();
    },
    
    _onContentRequestComplete: function Framework_Component_Updating_UpdateXsltBasedComponentTask$_onContentRequestComplete() {
        if (!this._contentRequest) {
            this._contentRequest = Framework.Component.Updating.UpdateXsltBasedComponentTask._contentRequests[this.get__contentUrl()];
        }
        if (this._contentRequest) {
            if (this._contentRequest.readyState === 4) {
                if (this._contentRequest.status === 200 || this._contentRequest.status === 304) {
                    var xmlContentReceivedEventArgs = new Framework.Component.LifeCycleManagement.EventArgs.XmlContentReceivedEventArgs();
                    xmlContentReceivedEventArgs.set_contentXmlDocument(this._contentRequest.responseXML);
                    xmlContentReceivedEventArgs.set_customEventArgs(this._contextObject.customEventArgs);
                    this._lifeCycleManager.xmlContentReceived(xmlContentReceivedEventArgs);
                    this._contentXmlDocument = xmlContentReceivedEventArgs.get_contentXmlDocument();
                    this._tryTransform();
                }
                else {
                    Framework.Component.Updating.HtmlUpdater.updateDomElement(this.get_domElement(), '<img src=\'..\\..\\..\\error.png\' alt=\'error\' />');
                }
                if (Object.keyExists(Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks, this.get__contentUrl()) && Object.getKeyCount((Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks[this.get__contentUrl()])) > 0) {
                    var xmlCallBack = Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks[this.get__contentUrl()];
                    if (Object.keyExists(xmlCallBack, this.get_domElementId())) {
                        delete xmlCallBack[this.get_domElementId()];
                    }
                    if (!Object.getKeyCount(xmlCallBack)) {
                        delete Framework.Component.Updating.UpdateXsltBasedComponentTask._contentRequests[this.get__contentUrl()];
                        this._contentRequest.onreadystatechange = null;
                    }
                }
            }
        }
    },
    
    _onXsltRequestComplete: function Framework_Component_Updating_UpdateXsltBasedComponentTask$_onXsltRequestComplete() {
        if (this._xsltRequest.readyState === 4) {
            if (this._xsltRequest.status === 200 || this._xsltRequest.status === 304) {
                this._xsltXmlDocument = this._xsltRequest.responseXML;
                Framework.Component.Updating.UpdateXsltBasedComponentTask._cachedXsltXmlDocument[this.get__xsltUrl()] = this._xsltXmlDocument;
                this._tryTransform();
                if (this._xsltRequest) {
                    this._xsltRequest.onreadystatechange = null;
                }
            }
            else {
                Framework.Component.Updating.HtmlUpdater.updateDomElement(this.get_domElement(), '<img src=\'..\\..\\..\\error.png\' alt=\'error\' />');
            }
        }
    },
    
    _tryTransform: function Framework_Component_Updating_UpdateXsltBasedComponentTask$_tryTransform() {
        Framework.Component.Updating.UpdateXsltBasedComponentTask._log.debug(String.format('TryTransform domElementId=[{0}] contentUrl=[{1}]', this.get_domElementId(), this.get__contentUrl()));
        if (this._contentXmlDocument && this._xsltXmlDocument && this._startingCounterValue === Framework.Component.Updating.UpdateXsltBasedComponentTask._getStamp(this.get_domElementId())) {
            Framework.XMLUtils.transformAndUpdate(this._contentXmlDocument, this._xsltXmlDocument, this._contextObject.xsltParameters, this.get_domElementId(), this.get_domElement(), Delegate.create(this, this._decoratePreRenderEventCallback));
            if (ScriptFX.Application.current.get_host().get_name() === ScriptFX.HostName.mozilla) {
                var css = '#' + this.get_domElementId() + ' .escapedHtml';
                var elements = Framework.DocumentFinder.getElementsBySelector(css);
                if (elements) {
                    for (var i = 0; i < elements.length; i++) {
                        elements[i].innerHTML = elements[i].innerText;
                    }
                }
            }
            window.setTimeout(Delegate.create(this, function() {
                var eventArgs = new Framework.Component.LifeCycleManagement.EventArgs.RenderCompleteEventArgs();
                eventArgs.set_customEventArgs(this._contextObject.customEventArgs);
                this._lifeCycleManager.renderComplete(eventArgs);
            }), 0);
        }
    },