IBookAuthor: A Skeleton Widget

--D. Thiebaut 13:38, 27 January 2013 (EST)

---

Reference

The main reference for creating Dashboard widgets is Apple's own page on the subject, titled About HTML Widget Creation. This page, in some ways, is the true definition of a skeleton widget.

Hierarchy

./skeleton.wdgt
./skeleton.wdgt/Default.png
./skeleton.wdgt/Default@2x.png
./skeleton.wdgt/Icon.png
./skeleton.wdgt/Images
./skeleton.wdgt/Info.plist
./skeleton.wdgt/main.css
./skeleton.wdgt/main.html
./skeleton.wdgt/main.js
./skeleton.wdgt/Parts
./skeleton.wdgt/Parts/parts.js
./skeleton.wdgt/version.plist

Files

Parts/parts.js

/* 
 This file was generated by Dashcode and is covered by the 
 license.txt included in the project.  You may edit this file, 
 however it is recommended to first turn off the Dashcode 
 code generator otherwise the changes will be lost.
 */
var dashcodePartSupport = {
    "imageBgParts": {}
};
if (!window.dashcode) {
    dashcode = new Object()
}
dashcode.setupParts = function () {
    if (dashcode.setupParts.called) {
        return
    }
    dashcode.setupParts.called = true;
    var H = [];
    if (window.dashcodeDataSources && !dashcode.inDesign) {
        for (var C in dashcodeDataSources) {
            var E = dashcodeDataSources[C];
            var A = dashcode.setupDataSource(C, E);
            if (A) {
                A.registerWithName(C)
            }
        }
    }
    for (
    var C in dashcodePartSpecs) {
        dashcode.preProcessBindings(dashcodePartSpecs[C])
    }
    if (!DC.Support.BorderImage) {
        var G = dashcodePartSupport.imageBgParts;
        for (var B in G) {
            var D = G[B];
            Element.set3PiecesBorderImage(document.getElementById(B), D[0], D[1], D[2])
        }
    }
    for (var C in dashcodePartSpecs) {
        var E = dashcodePartSpecs[C];
        var F = dashcode.setupPart(C, E.creationFunction, E.view, E);
        if (F && F.finishLoading) {
            H[H.length] = F
        }
    }
    for (var I = 0; I < H.length; I++) {
        H[I].finishLoading()
    }
};
dashcode.setupPart = function (elementOrId, creationFunction, viewClass, specDict, relativeController) {
    var object = null;
    var createFunc = window[creationFunction];
    var node = elementOrId;
    if (elementOrId.nodeType != 1) {
        node = document.getElementById(elementOrId)
    }
    if (!node) {
        return null
    }
    if (createFunc) {
        object = createFunc(node, specDict)
    } else {
        var viewClass = null;
        object = DC.View.fromNode(node);
        if (object) {
            return object
        }
        if (specDict.view) {
            viewClass = eval(specDict.view)
        }
        if (dashcode.inDesign) {
            dashcode.preProcessBindings(specDict)
        }
        if (!viewClass) {
            viewClass = DC.View.viewClassForNode(node, specDict.hasBindings) || DC.View
        }
        object = new(viewClass)(node, relativeController, specDict.propertyValues, specDict);
        node.object = object
    }
    return object
};
dashcode.setupDataSource = function (identifier, specDict) {
    var dsClass = null;
    var dataSource = null;
    try {
        dsClass = specDict.Class ? eval(specDict.Class) : null
    } catch (e) {}
    if (!dsClass) {
        console.error("Couldn't create data source " + identifier + ". Invalid class specified.");
        return null
    }
    var propertyValues = specDict.propertyValues;
    dataSource = new dsClass(propertyValues);
    return dataSource
};
dashcode.getDataSource = function (A) {
    return DC.dataModel.valueForKey(A)
};
dashcode.preProcessBindings = function (A) {
    if (A && A.propertyValues && !A.hasBindings) {
        for (p in A.propertyValues) {
            if (-1 !== p.search(/Binding$/)) {
                A.hasBindings = true;
                if (dashcode.inDesign) {
                    delete A.propertyValues[p]
                } else {
                    break
                }
            }
        }
    }
};
if (window.addEventListener) {
    window.addEventListener("load", dashcode.setupParts, false)
} else {
    if (window.attachEvent) {
        window.attachEvent("load", dashcode.setupParts)
    }
}
dashcode.getLocalizedString = function (A) {
    try {
        A = localizedStrings[A] || A
    } catch (B) {}
    return A
};
dashcode.createInstancePreferenceKey = function (A) {
    return widget.identifier + "-" + A
};
dashcode.getElementHeight = function (B) {
    var A = B.offsetHeight;
    if (!A || A == 0) {
        A = dashcode.getElementSize(B).height
    }
    return A
};
dashcode.getElementWidth = function (B) {
    var A = B.offsetWidth;
    if (!A || A == 0) {
        A = dashcode.getElementSize(B).width
    }
    return A
};
dashcode.getElementSize = function (B) {
    var A = dashcode.getElementSizesWithAncestor([B], B);
    return A[0]
};
dashcode.getElementSizesWithAncestor = function (A, F) {
    if (A.length < 1) {
        return []
    }
    var B = new Array();
    var C = A[0].offsetWidth;
    if (!C || C == 0) {
        var G = F;
        while (G && (G != document)) {
            var I = Element.getStyles(G, "display");
            var H = (I) ? I : G.style.display;
            if ((I && H == "none") || (!I && H != "block")) {
                B.push({
                    node: G,
                    display: G.style.display
                });
                G.style.display = "block"
            }
            G = G.parentNode
        }
    }
    var J = new Array();
    for (var E = 0; E < A.length; E++) {
        J.push({
            width: A[E].offsetWidth,
            height: A[E].offsetHeight
        })
    }
    for (var E = 0; E < B.length; E++) {
        var D = B[E].node;
        D.style.display = B[E].display;
        if (D.getAttribute("style") == "") {
            D.removeAttribute("style")
        }
    }
    return J
};
dashcode.getElementDocumentOffset = function (B) {
    var C = B.offsetParent;
    var D = {
        x: B.offsetLeft,
        y: B.offsetTop
    };
    if (C) {
        var A = dashcode.getElementDocumentOffset(C);
        D.x += A.x;
        D.y += A.y
    }
    return D
};
dashcode.pointInElement = function (A, E, D) {
    var C = dashcode.getElementSize(D);
    var B = dashcode.getElementDocumentOffset(D);
    if (A >= B.x) {
        if (A > B.x + C.width) {
            return false
        }
        if (E >= B.y) {
            if (E > B.y + C.height) {
                return false
            }
        } else {
            return false
        }
    } else {
        return false
    }
    return true
};
dashcode.cloneTemplateElement = function (B, A, C) {
    return DC.View.cloneViewsForTreeNode(B, C, null)
};
dashcode.processClonedTemplateElement = function (D, C, B, F, E, A) {
    console.error("dashcode.processClonedTemplateElement is no longer available.")
};
var setupParts = dashcode.setupParts;
var getLocalizedString = dashcode.getLocalizedString;
var createInstancePreferenceKey = dashcode.createInstancePreferenceKey;
var getElementHeight = dashcode.getElementHeight;
var getElementWidth = dashcode.getElementWidth;
var getElementSize = dashcode.getElementSize;
if (!("querySelector" in document)) {
    document.write('<script apple-no-regeneration="yes" type="text/javascript" src="../Parts/core/external/sizzle_c.js"><\/script>')
};
if ("undefined" !== typeof (DC)) {
    throw new Error("Library module (DC) already defined")
}
var DC = {
    version: "@VERSION@",
    revision: "@REVISION@",
    generateUid: (function () {
        var A = 0;
        return function () {
            return ++A
        }
    })()
};
DC.Browser = {
    IE: !! (window.attachEvent && !window.opera) && (function () {
        var B = /MSIE (\d+)/;
        var A = B.exec(navigator.userAgent);
        return A && parseInt(A[1], 10)
    })(),
    Safari: navigator.userAgent.indexOf("AppleWebKit/") > -1,
    Safari2: (function () {
        var A = /AppleWebKit\/(\d+(?:\.\d+)?)/;
        var B = A.exec(navigator.userAgent);
        return (B && parseInt(B[1], 10) < 420)
    })(),
    Mozilla: navigator.userAgent.indexOf("Gecko") > -1 && navigator.userAgent.indexOf("KHTML") == -1,
    MobileSafari: !! navigator.userAgent.match(/Apple.*Mobile.*Safari/)
};
DC.Support = {
    Properties: ("__defineGetter__" in Object.prototype),
    QuerySelector: ("querySelector" in document),
    Touches: !! document.createTouch,
    CSS3ColorModel: false,
    CSSTransitions: false,
    BorderImage: (function () {
        var A = document.createElement("div").style;
        A.cssText = "-webkit-border-image: inherit; -moz-border-image: inherit;";
        return (A.WebkitBorderImage == "inherit") || (A.MozBorderImage == "inherit")
    })()
};
if (DC.Support.Properties) {
    DC.Support.__defineGetter__("CSS3ColorModel", function () {
        delete this.CSS3ColorModel;
        var B = document.createElement("span");
        try {
            B.style.backgroundColor = "rgba(100,100,100,0.5)";
            return this.CSS3ColorModel = (B.style.length === 1)
        } catch (A) {}
        return (this.CSS3ColorModel = false)
    });
    DC.Support.__defineGetter__("CSSTransitions", function () {
        delete this.CSSTransitions;
        var B = document.createElement("span");
        try {
            B.style.setProperty("-webkit-transition-duration", "1ms", "");
            return this.CSSTransitions = (B.style.length === 1)
        } catch (A) {}
        return (this.CSSTransitions = false)
    })
}
DC.typeOf = function (B) {
    if (null === B) {
        return "null"
    }
    var A = typeof (B);
    if ("object" !== A && "function" !== A) {
        return A
    }
    return Object.prototype.toString.call(B).slice(8, -1).toLowerCase()
};
DC.compareValues = function (F, D) {
    var C = DC.typeOf(F);
    if (C !== DC.typeOf(D)) {
        var A = String(F);
        var E = String(D);
        return A.localeCompare(E)
    }
    switch (C) {
        case "null":
            return 0;
        case "boolean":
        case "number":
            var B = (F - D);
            if (0 === B) {
                return B
            }
            return (B < 0 ? -1 : 1);
        case "regexp":
        case "function":
            break;
        case "string":
        case "array":
        case "object":
            if (F.localeCompare) {
                return F.localeCompare(D)
            }
            if (F.compare) {
                return F.compare(D)
            }
            break;
        case "undefined":
            return true;
        default:
            throw new TypeError("Unknown type for comparison: " + C)
    }
    return String(F).localeCompare(String(D))
};
DC.defineError = function (B) {
    function A(C) {
        this.message = C;
        this.name = B
    }
    A.prototype = new Error;
    A.prototype.constructor = A;
    A.prototype.name = B;
    return A
};
var InvalidArgumentError = DC.defineError("InvalidArgumentError");
if ("undefined" == typeof (window.console)) {
    window.console = {}
}
if ("undefined" == typeof (window.console.log)) {
    window.console.log = function () {}
}
if ("undefined" == typeof (window.console.error)) {
    window.console.error = function () {}
};
if ("undefined" !== typeof (window.Prototype)) {
    (function () {
        var A = ["indexOf", "lastIndexOf", "forEach", "filter", "map", "some", "every", "reduce", "reduceRight"];
        for (var B = 0; B < A.length; ++B) {
            delete Array.prototype[A[B]]
        }
    })()
}
Array.prototype.distinct = function () {
    var B = this.length;
    var A = new Array(B);
    var C;
    var E;
    var D = 0;
    for (C = 0; C < B; ++C) {
        E = this[C];
        if (-1 == A.indexOf(E)) {
            A[D++] = E
        }
    }
    A.length = D;
    return A
};
Array.prototype.compare = function (B) {
    var D = this.length - B.length;
    if (0 !== D) {
        return D
    }
    var E;
    var A;
    var C;
    for (E = 0, A = this.length; E < A; ++E) {
        C = DC.compareValues(this[E], B[E]);
        if (0 !== C) {
            return C
        }
    }
    return 0
};
Array.from = function (A, B) {
    return Array.prototype.slice.call(A, B || 0)
};
if (!Array.prototype.reduce) {
    Array.prototype.reduce = function (B) {
        var A = this.length;
        if (typeof B != "function") {
            throw new TypeError()
        }
        if (0 === A && 1 === arguments.length) {
            throw new TypeError()
        }
        var C = 0;
        if (arguments.length >= 2) {
            var D = arguments[1]
        } else {
            do {
                if (C in this) {
                    D = this[C++];
                    break
                }
                if (++C >= A) {
                    throw new TypeError()
                }
            } while (true)
        }
        for (; C < A; C++) {
            if (C in this) {
                D = B.call(null, D, this[C], C, this)
            }
        }
        return D
    }
}
if (!Array.prototype.reduceRight) {
    Array.prototype.reduceRight = function (B) {
        var A = this.length;
        if (typeof B != "function") {
            throw new TypeError()
        }
        if (0 === A && 1 === arguments.length) {
            throw new TypeError()
        }
        var C = A - 1;
        if (arguments.length >= 2) {
            var D = arguments[1]
        } else {
            do {
                if (C in this) {
                    D = this[C--];
                    break
                }
                if (--C < 0) {
                    throw new TypeError()
                }
            } while (true)
        }
        for (; C >= 0; C--) {
            if (C in this) {
                D = B.call(null, D, this[C], C, this)
            }
        }
        return D
    }
}
if (!Array.indexOf) {
    Array.indexOf = function (C, B, A) {
        return Array.prototype.indexOf.call(C, B, A)
    }
}
if (!Array.lastIndexOf) {
    Array.lastIndexOf = function (C, B, A) {
        return Array.prototype.lastIndexOf.call(C, B, A)
    }
}
if (!Array.forEach) {
    Array.forEach = function (C, A, B) {
        return Array.prototype.forEach.call(C, A, B)
    }
}
if (!Array.filter) {
    Array.filter = function (C, A, B) {
        return Array.prototype.filter.call(C, A, B)
    }
}
if (!Array.map) {
    Array.map = function (C, A, B) {
        return Array.prototype.map.call(C, A, B)
    }
}
if (!Array.some) {
    Array.some = function (C, A, B) {
        return Array.prototype.some.call(C, A, B)
    }
}
if (!Array.every) {
    Array.every = function (C, A, B) {
        return Array.prototype.every.call(C, A, B)
    }
}
if (!Array.reduce) {
    Array.reduce = function (B, A) {
        if (arguments.length > 2) {
            return Array.prototype.reduce.apply(B, A, arguments[2])
        } else {
            return Array.prototype.reduce.apply(B, A)
        }
    }
}
if (!Array.reduceRight) {
    Array.reduceRight = function (B, A) {
        if (arguments.length > 2) {
            return Array.prototype.reduceRight.apply(B, A, arguments[2])
        } else {
            return Array.prototype.reduceRight.apply(B, A)
        }
    }
};

function Set() {
    var D = this;
    if (D.constructor !== Set) {
        D = new Set()
    }
    var B = arguments;
    if (1 == B.length && B[0] instanceof Array) {
        B = B[0]
    }
    var C;
    var A = B.length;
    for (C = 0; C < A; ++C) {
        D[B[C]] = true
    }
    return D
}
Set.union = function (C, B) {
    var A = Object.clone(C);
    if (!B) {
        return A
    }
    var D;
    for (D in B) {
        A[D] = true
    }
    return A
};
Set.intersect = function (C, B) {
    var A = new Set();
    var D;
    for (D in C) {
        if (D in B) {
            A[D] = true
        }
    }
    return A
};
Set.add = function (B, A) {
    B[A] = true;
    return B
};
Set.remove = function (B, A) {
    delete B[A];
    return B
};
Set.toArray = function (C) {
    var B;
    var A = [];
    for (B in C) {
        A.push(B)
    }
    return A
};
Set.forEach = function (E, C, B) {
    var D;
    var A = 0;
    for (D in E) {
        C.call(B, D, A++)
    }
};
Set.join = function (D, B) {
    var C;
    var A = [];
    for (C in D) {
        A.push(C)
    }
    return A.join(B || "")
};
var $S = Set;
var Class = (function () {
    function D(I, L) {
        var J;
        if (!I && !L) {
            return I
        }
        if (!I) {
            J = function () {
                return L.apply(this, arguments)
            }
        } else {
            var K = /this\.base/.test(I);
            if (!K && !L) {
                return I
            }
            if (!K) {
                J = function () {
                    L.call(this);
                    return I.apply(this, arguments)
                }
            } else {
                J = function () {
                    var N = this.base;
                    this.base = L || function () {};
                    var M = I.apply(this, arguments);
                    this.base = N;
                    return M
                }
            }
        }
        J.valueOf = function () {
            return I
        };
        J.toString = function () {
            return String(I)
        };
        return J
    }
    function G(I, J) {
        var K = I.prototype.__factory__.apply(I, J);
        if ("function" !== typeof (K)) {
            throw new Error("Factory function doesn't return a function")
        }
        K.__factoryFn__ = true;
        return K
    }
    function F(K) {
        if (K.__createFactoryObjects) {
            K.__createFactoryObjects();
            return
        }
        var J;
        var I;
        for (J in K.__factories__) {
            I = K[J];
            if (!I.__factoryFn__) {
                continue
            }
            K[J] = I.call(K)
        }
    }
    function C(I, K) {
        if (I && !(I instanceof Function)) {
            throw new Error("Invalid constructor")
        }
        if (K && !(K instanceof Function)) {
            throw new Error("Invalid superclass")
        }
        K = K ? K.valueOf() : null;
        I = D(I, K);
        var J;
        if (I) {
            J = function () {
                if (!(this instanceof J)) {
                    return G(J, arguments)
                }
                this.__uid = this.__uid || DC.generateUid();
                var L = I.apply(this, arguments);
                if (L) {
                    return L
                }
                F(this);
                if (this.__postConstruct instanceof Function) {
                    this.__postConstruct()
                }
                return this
            }
        } else {
            J = function () {
                if (!(this instanceof J)) {
                    return G(J, arguments)
                }
                this.__uid = this.__uid || DC.generateUid();
                F(this);
                if (this.__postConstruct instanceof Function) {
                    this.__postConstruct()
                }
                return this
            }
        }
        J.valueOf = function () {
            return I
        };
        J.toString = function () {
            return String(I || J)
        };
        return J
    }
    function B(J) {
        function I() {}
        I.prototype = J.prototype;
        return new I()
    }
    function E(L, J, K) {
        if (!L || !/this\.base/.test(L)) {
            return L
        }
        function I() {
            var N = this.base;
            this.base = K[J] || function () {};
            var M = L.apply(this, arguments);
            this.base = N;
            return M
        }
        I.valueOf = function () {
            return L
        };
        I.toString = function () {
            return String(L)
        };
        return I
    }
    function H(J, I, K, L) {
        if (K instanceof Function && L) {
            var M = K.valueOf();
            K = E(K, I, L);
            K.name = I;
            if (M.__factoryFn__) {
                J.__factories__[I] = K
            }
        }
        J[I] = K;
        return K
    }
    function A(J) {
        var I;
        for (I = J.superclass; I; I = I.superclass) {
            if ("__subclassCreated__" in I) {
                I.__subclassCreated__(J)
            }
        }
    }
    return {
        create: function (L, J) {
            var I;
            var K = {};
            switch (arguments.length) {
                case 0:
                    throw new TypeError("Missing superclass and declaration arguments");
                case 1:
                    J = L;
                    L = undefined;
                    break;
                default:
                    K = B(L);
                    break
            }
            if ("function" == typeof (J)) {
                J = J();
                if (!J) {
                    throw new Error("Class declaration function did not return a prototype")
                }
            }
            if (J.hasOwnProperty("constructor")) {
                I = J.constructor;
                delete J.constructor
            }
            I = C(I, L);
            I.prototype = K;
            I.prototype.constructor = I;
            I.superclass = L;
            if (L) {
                K.__factories__ = Object.clone(L.prototype.__factories__)
            } else {
                K.__factories__ = {}
            }
            I.__class_id__ = DC.generateUid();
            K.__class_id__ = DC.generateUid();
            this.extend(I, J);
            A(I);
            return I
        },
        findPropertyName: function (L, I) {
            var J;
            for (var K in L) {
                J = L[K];
                if (J === I || ("function" === typeof (J) && J.valueOf() === I)) {
                    return K
                }
            }
            return null
        },
        extend: (function () {
            if (DC.Support.Properties) {
                return function (I, J) {
                    var N = I.prototype;
                    var P = I.superclass && I.superclass.prototype;
                    var K;
                    for (var O in J) {
                        var M = J.__lookupGetter__(O);
                        var L = J.__lookupSetter__(O);
                        if (M || L) {
                            M && N.__defineGetter__(O, M);
                            L && N.__defineSetter__(O, L)
                        } else {
                            H(N, O, J[O], P)
                        }
                    }
                    return I
                }
            } else {
                return function (I, J) {
                    var K = I.prototype;
                    var M = I.superclass && I.superclass.prototype;
                    for (var L in J) {
                        H(K, L, J[L], M)
                    }
                }
            }
        })()
    }
})();
if (!Function.prototype.bind) {
    Function.prototype.bind = function (C) {
        var A = this;
        if (!arguments.length) {
            return A
        }
        if (1 == arguments.length) {
            return function () {
                return A.apply(C, arguments)
            }
        }
        var B = Array.from(arguments, 1);
        return function () {
            return A.apply(C, B.concat(Array.from(arguments)))
        }
    }
}
if (!Function.prototype.bindAsEventListener) {
    Function.prototype.bindAsEventListener = function (C) {
        var A = this;
        if (1 == arguments.length) {
            return function (D) {
                return A.call(C, D || window.event)
            }
        }
        var B = Array.from(arguments);
        B.shift();
        return function (D) {
            return A.apply(C, [D || window.event].concat(B))
        }
    }
}
if (!Function.prototype.delay) {
    Function.prototype.delay = function (D) {
        var B = this;
        D = D || 10;
        if (arguments.length < 2) {
            function A() {
                B()
            }
            return window.setTimeout(A, D)
        }
        var C = Array.from(arguments, 1);

        function E() {
            B.apply(B, C)
        }
        return window.setTimeout(E, D)
    }
}
if (!Function.prototype.bindAndDelay) {
    Function.prototype.bindAndDelay = function (F, D) {
        var B = this;
        F = F || B;
        D = D || 10;
        if (arguments.length < 3) {
            function A() {
                B.call(F)
            }
            return window.setTimeout(A, D)
        }
        var C = Array.from(arguments, 2);

        function E() {
            B.apply(F, C)
        }
        return window.setTimeout(E, D)
    }
}
Function.prototype.sync = function () {
    var B = arguments.length ? this.bind.apply(this, arguments) : this;
    var A = {};
    var C = false;
    B.stop = function () {
        C = true
    };
    B.waitFor = function (D) {
        A[D] = true;
        return function () {
            A[D] = false;
            for (var E in A) {
                if (A[E]) {
                    return
                }
            }
            if (C) {
                return
            }
            B()
        }
    };
    return B
};
Object.clone = function (B) {
    var A = (function () {});
    A.prototype = B;
    return new A()
};
Object.applyDefaults = function (C, B) {
    C = C || {};
    if (!B) {
        return C
    }
    for (var A in B) {
        if (A in C) {
            continue
        }
        C[A] = B[A]
    }
    return C
};
Object.extend = function (C, A) {
    C = C || {};
    for (var B in A) {
        C[B] = A[B]
    }
    return C
};
Object.merge = function (C, A) {
    var B = {};
    var D;
    for (D in C) {
        B[D] = C[D]
    }
    for (D in A) {
        if (D in B) {
            continue
        }
        B[D] = A[D]
    }
    return B
};
(function () {
    var B = Set("file", "submit", "image", "reset", "button");
    var D = {};

    function E(I, H, J) {
        var G = I[H];
        var F = DC.typeOf(G);
        if ("string" === F) {
            I[H] = [G, J]
        } else {
            if ("array" === F) {
                G.push(J)
            } else {
                I[H] = J
            }
        }
    }
    function C(H) {
        var F = H.name;
        var G = (H.type || "").toLowerCase();
        if (H.disabled || G in B) {
            return
        }
        if ("radio" === G || "checkbox" === G) {
            if (H.checked) {
                E(this, F, H.value)
            }
        } else {
            if (H.multiple) {
                function I(J) {
                    if (J.selected) {
                        E(this, F, J.value)
                    }
                }
                this[F] = [];
                Array.forEach(H.options, I, this)
            } else {
                E(this, F, H.value);
                if ("image" === G) {
                    E(this, F + ".x", 0);
                    E(this, F + ".y", 0)
                }
            }
        }
    }
    Object.fromForm = function (G) {
        var F = {};
        Array.forEach(G.elements, C, F);
        return F
    };

    function A(H) {
        H = H.split("=");
        if (1 === H.length) {
            return
        }
        var F = decodeURIComponent(H[0].trim());
        var G = decodeURIComponent(H[1].trim()) || null;
        E(this, F, G)
    }
    Object.fromQueryString = function (G) {
        if ("?" == G.charAt(0)) {
            G = G.slice(1)
        }
        G = G.split(/\s*&\s*/);
        var F = {};
        G.forEach(A, F);
        return F
    };
    Object.toQueryString = function (K) {
        if (!K) {
            return ""
        }
        var H;
        var J;
        var F;
        var G = [];

        function I(M) {
            if (null !== M && "undefined" !== typeof (M)) {
                M = encodeURIComponent(M)
            }
            var L = M + "";
            if (L.length) {
                G.push(H + "=" + L)
            } else {
                G.push(H)
            }
        }
        for (H in K) {
            J = K[H];
            F = DC.typeOf(J);
            if ("function" === F || J === D[H]) {
                continue
            }
            H = encodeURIComponent(H);
            if ("array" === F) {
                J.forEach(I)
            } else {
                I(J)
            }
        }
        return G.join("&")
    }
})();
RegExp.escape = function (A) {
    return A.replace(RegExp._escapeRegex, "\\$1")
};
RegExp.specialCharacters = ["/", ".", "*", "+", "?", "|", "(", ")", "[", "]", "{", "}", "\\"];
RegExp._escapeRegex = new RegExp("(\\" + RegExp.specialCharacters.join("|\\") + ")", "g");
DC.strings = {
    "marker.input.multipleValues": "Multiple Values",
    "marker.input.placeholder": "",
    "marker.input.noSelection": "No Selection",
    "marker.text.multipleValues": "Multiple Values",
    "marker.text.placeholder": "",
    "marker.text.noSelection": "No Selection",
    "error.no_description": "An unspecified error occurred.",
    "error.invalid_value": "This value is not valid.",
    "error.invalid_number": "This value is not a valid number."
};
DC.localisedString = function (A) {
    return {
        toString: function () {
            if (A in DC.strings) {
                return DC.strings[A]
            }
            console.log("Localisation missing string for key: " + A);
            return A
        }
    }
};
var _ = DC.localisedString;
DC.Error = Class.create({
    constructor: function (A) {
        Object.extend(this, A)
    },
    description: _("error.no_description"),
    recoverySuggestion: null
});
DC.KeyInfo = Class.create({
    constructor: function (D, B) {
        var A = DC.KVO.getPropertyMethodsForKeyOnObject(B, D);
        this.__uid = [B, DC.generateUid()].join("_");
        this.reader = A.getter;
        this.mutator = A.mutator;
        this.validator = A.validator;
        this.key = B;
        this.mutable = ((this.mutator || !this.reader) ? true : false);
        if (!this.reader && !this.mutator) {
            this.mutable = true
        }
        this.changeCount = 0;
        var C = A.value;
        if (!C) {
            return
        }
        var E = DC.typeOf(C);
        if (E in DC.KVO.typesOfKeyValuesToIgnore || !C._addParentLink) {
            return
        }
        C._addParentLink(D, this)
    },
    get: function (B) {
        if (this.reader) {
            return this.reader.call(B)
        }
        var A;
        if (this.key in B) {
            A = B[this.key]
        } else {
            A = null
        }
        if (A && A._addParentLink) {
            A._addParentLink(B, this)
        }
        return A
    },
    set: function (B, A) {
        if (this.mutator) {
            this.mutator.call(B, A)
        } else {
            B.willChangeValueForKey(this.key, this);
            B[this.key] = A;
            B.didChangeValueForKey(this.key, this)
        }
    },
    validate: function (B, A) {
        if (!this.validator) {
            return A
        }
        return this.validator.call(B, A)
    },
    unlinkParentLink: function () {
        if (!this.parentLink) {
            return
        }
        this.parentLink.observer = null;
        this.parentLink.callback = null;
        this.parentLink = null
    }
});
DC.ChangeType = {
    setting: 0,
    insertion: 1,
    deletion: 2,
    replacement: 3
};
DC.ChangeNotification = Class.create({
    constructor: function (D, A, E, C, B) {
        this.object = D;
        this.changeType = A;
        this.newValue = E;
        this.oldValue = C;
        this.indexes = B;
        this.objectKeyPath = []
    },
    toString: function () {
        var A = "[ChangeNotification changeType: ";
        switch (this.changeType) {
            case DC.ChangeType.setting:
                A += "setting";
                break;
            case DC.ChangeType.insertion:
                A += "insertion";
                break;
            case DC.ChangeType.deletion:
                A += "deletion";
                break;
            case DC.ChangeType.replacement:
                A += "replacement";
                break;
            default:
                A += "<<unknown>>";
                break
        }
        A += " newValue=" + this.newValue + " oldValue=" + this.oldValue + (this.indexes ? " indexes=" + this.indexes.join(", ") : "") + "]";
        return A
    }
});
DC.ObserverEntry = Class.create({
    constructor: function (A, C, B) {
        this.observer = A;
        this.callback = C;
        this.context = B
    },
    observeChangeForKeyPath: function (A, B) {
        if (!this.callback || !this.observer || -1 !== A.objectKeyPath.indexOf(this.observer)) {
            return
        }
        this.callback.call(this.observer, A, B, this.context)
    }
});
DC.KVO = Class.create({
    constructor: function () {},
    __factory__: function () {
        var B = Array.from(arguments);
        var A = this;

        function C() {}
        return function () {
            C.prototype = A.prototype;
            var D = new C();
            A.prototype.constructor.apply(D, B);
            return D
        }
    },
    setValueForKeyPath: function (C, D) {
        if (!D || 0 === D.length) {
            throw new InvalidArgumentError("keyPath may not be empty")
        }
        if ("string" == typeof (D)) {
            D = D.split(".")
        }
        var B = D[0];
        if (1 == D.length) {
            this.setValueForKey(C, B);
            return
        }
        if ("@" == B.charAt(0)) {
            return
        }
        var A = this.valueForKey(B);
        if (!A) {
            return
        }
        A.setValueForKeyPath(C, D.slice(1))
    },
    setValueForKey: function (B, A) {
        if (!A || 0 === A.length) {
            throw new InvalidArgumentError("key may not be empty")
        }
        var C = this.infoForKey(A);
        if (!C || !C.mutable) {
            return
        }
        C.set(this, B)
    },
    valueForKeyPath: function (E) {
        if (!E || 0 === E.length) {
            throw new InvalidArgumentError("keyPath may not be empty")
        }
        if ("string" == typeof (E)) {
            E = E.split(".")
        }
        var D = E[0];
        if (1 == E.length) {
            return this.valueForKey(D)
        }
        if ("@" == D.charAt(0)) {
            var B = D.substr(1);
            var A = this.valueForKeyPath(E.slice(1));
            return DC.ArrayOperator[B](A)
        }
        var C = this.valueForKey(D);
        if ("undefined" === typeof (C) || null === C) {
            return undefined
        }
        return C.valueForKeyPath(E.slice(1))
    },
    valueForKey: function (A) {
        if (!A || 0 === A.length) {
            throw new InvalidArgumentError("the key is empty")
        }
        var B = this.infoForKey(A);
        if (!B) {
            return null
        }
        return B.get(this)
    },
    validateValueForKeyPath: function (C, D) {
        if (!D || 0 === D.length) {
            throw new InvalidArgumentError("keyPath may not be empty")
        }
        if ("string" == typeof (D)) {
            D = D.split(".")
        }
        var B = D[0];
        if (1 == D.length) {
            return this.validateValueForKey(C, B)
        }
        var A = this.valueForKey(B);
        if ("undefined" === typeof (A) || null === A) {
            return C
        }
        return A.validateValueForKeyPath(C, D.slice(1))
    },
    validateValueForKey: function (B, A) {
        if (!A || !A.length) {
            throw new InvalidArgumentError("missing key")
        }
        var C = this.infoForKey(A);
        return C.validate(this, B)
    },
    observeChildObjectChangeForKeyPath: function (D, C, A) {
        if (DC.KVO.kAllPropertiesKey != C) {
            C = A + "." + C
        } else {
            C = A
        }
        var B = Object.clone(D);
        B.object = this;
        this.notifyObserversOfChangeForKeyPath(B, C)
    },
    infoForKeyPath: function (D) {
        if (!D || 0 === D.length) {
            throw new InvalidArgumentError("keyPath is empty")
        }
        if ("string" == typeof (D)) {
            D = D.split(".")
        }
        var B = D[0];
        if (1 == D.length) {
            return this.infoForKey(B)
        } else {
            if ("@" == B.charAt(0)) {
                var C = new DC.KeyInfo(null, null);
                C.mutable = false;
                return C
            } else {
                var A = this.valueForKey(B);
                if (!A) {
                    return undefined
                }
                if (!A.infoForKeyPath) {
                    return undefined
                }
                return A.infoForKeyPath(D.slice(1))
            }
        }
    },
    infoForKey: function (A) {
        var B;
        if (!this.__keys) {
            this.__keys = {}
        }
        if (DC.KVO.kAllPropertiesKey == A) {
            return null
        }
        B = this.__keys[A];
        if (B) {
            return B
        }
        B = new DC.KeyInfo(this, A);
        this.__keys[A] = B;
        return B
    },
    setKeysTriggerChangeNotificationsForDependentKey: function (D, C) {
        if (!D || !D.length) {
            throw new InvalidArgumentError("keys array is not valid")
        }
        if (!C) {
            throw new InvalidArgumentError("dependentKey can not be null")
        }
        if (-1 !== C.indexOf(".")) {
            throw new InvalidArgumentError("dependentKey may not be a key path")
        }
        var B;
        var F;
        var A;
        var E;
        if ("string" === typeof (D)) {
            D = [D]
        }
        if (!this.__dependentKeys) {
            this.__dependentKeys = {}
        }
        for (A = 0; A < D.length; ++A) {
            B = D[A];
            if (!B) {
                throw new InvalidArgumentError("key at index " + A + " was null")
            }
            if (!(B in this.__dependentKeys)) {
                this.__dependentKeys[B] = []
            }
            DC.KVO.getPropertyMethodsForKeyOnObject(B, this);
            E = this.__dependentKeys[B];
            if (-1 == E.indexOf(C)) {
                E.push(C)
            }
        }
    },
    mutableKeys: function () {
        var D = [];
        var B;
        var A;
        var C;
        if ("__mutableKeys" in this && this.__mutableKeys.concat) {
            return this.__mutableKeys
        }
        var E = Set.union(DC.KVO.keysToIgnore, this.__keysToIgnore);
        for (B in this) {
            if (B in E || "__" === B.substr(0, 2)) {
                continue
            }
            A = this[B];
            if ("function" !== typeof (A)) {
                D.push(B);
                continue
            }
            if (1 !== A.length || "set" !== B.substr(0, 3)) {
                continue
            }
            C = B.charAt(3);
            if (C !== C.toUpperCase()) {
                continue
            }
            B = C.toLowerCase() + B.substr(4);
            if (-1 === D.indexOf(B)) {
                D.push(B)
            }
        }
        return D
    },
    initialiseKeyValueObserving: function () {
        this.__uid = this.__uid || DC.generateUid();
        this.__observers = {}
    },
    _addParentLink: function (D, E, C) {
        if (!this.hasOwnProperty("__observers")) {
            this.initialiseKeyValueObserving()
        }
        var B = this.__observers[DC.KVO.kAllPropertiesKey];
        if (!B) {
            B = this.__observers[DC.KVO.kAllPropertiesKey] = {}
        }
        C = C || E.__uid;
        if (C in B) {
            return
        }
        var A = new DC.ObserverEntry(D, D.observeChildObjectChangeForKeyPath, E ? E.key : "");
        B[C] = A;
        if (!E) {
            return
        }
        E.unlinkParentLink();
        E.parentLink = A
    },
    _removeParentLink: function (C, D, B) {
        if (!this.__observers) {
            return
        }
        var A = this.__observers[DC.KVO.kAllPropertiesKey];
        if (!A) {
            A = this.__observers[DC.KVO.kAllPropertiesKey] = {}
        }
        B = B || D.__uid;
        if (D && D.parentLink === A[B]) {
            D.unlinkParentLink()
        }
        delete A[B]
    },
    addObserverForKeyPath: function (A, E, D, B) {
        if (!D || 0 === D.length) {
            throw new InvalidArgumentError("keyPath is empty")
        }
        if (!A) {
            throw new InvalidArgumentError("Observer may not be null")
        }
        if (!E) {
            E = A.observeChangeForKeyPath
        }
        if ("string" === typeof (E)) {
            E = A[E]
        }
        if (!E) {
            throw new InvalidArgumentError("Missing callback method")
        }
        if (!this.hasOwnProperty("__observers")) {
            this.initialiseKeyValueObserving()
        }
        if (!this.__observers[D]) {
            this.infoForKeyPath(D);
            this.__observers[D] = []
        }
        var C = new DC.ObserverEntry(A, E, B);
        this.__observers[D].push(C)
    },
    removeObserverForKeyPath: function (C, F) {
        if (!F || 0 === F.length) {
            throw new InvalidArgumentError("keyPath may not be empty")
        }
        if (!C) {
            throw new InvalidArgumentError("Observer may not be null")
        }
        if (!this.__observers || !this.__observers[F]) {
            return
        }
        var E = this.__observers[F];
        var B = -1;
        var D;
        var A = E.length;
        for (B = 0; B < A; ++B) {
            D = E[B];
            if (D.observer == C) {
                E.splice(B, 1);
                return
            }
        }
    },
    willChangeValueForKey: function (A, C) {
        if (!A) {
            throw new InvalidArgumentError("key may not be null")
        }
        C = (C instanceof DC.KeyInfo) ? C : this.infoForKey(A);
        if (!C) {
            return
        }
        if (1 !== ++C.changeCount) {
            return
        }
        var B = (this.__dependentKeys && this.__dependentKeys[A]);
        if (B) {
            B.forEach(this.willChangeValueForKey, this)
        }
        C.previousValue = C.get(this)
    },
    forceChangeNotificationForKey: function (A, B) {
        if (!A) {
            throw new InvalidArgumentError("key may not be null")
        }
        B = (B instanceof DC.KeyInfo) ? B : this.infoForKey(A);
        if (!B) {
            return
        }
        if (0 !== B.changeCount) {
            return
        }
        B.changeCount = 1;
        this.didChangeValueForKey(A, B)
    },
    didChangeValueForKey: function (B, F) {
        if (!B) {
            throw new InvalidArgumentError("key may not be null")
        }
        F = (F instanceof DC.KeyInfo) ? F : this.infoForKey(B);
        if (!F) {
            return
        }
        if (0 !== --F.changeCount) {
            return
        }
        var C = F.get(this);
        var A = F.previousValue;
        F.previousValue = null;
        if (C !== A) {
            var E = new DC.ChangeNotification(this, DC.ChangeType.setting, C, A);
            this.notifyObserversOfChangeForKeyPath(E, B);
            if (A && A._removeParentLink) {
                A._removeParentLink(this, F)
            }
            if (C && C._addParentLink) {
                C._addParentLink(this, F)
            }
        }
        var D = (this.__dependentKeys && this.__dependentKeys[B]);
        if (D) {
            D.forEach(this.didChangeValueForKey, this)
        }
    },
    notifyObserversOfChangeForKeyPath: function (J, L) {
        if (!L) {
            throw new InvalidArgumentError("keyPath may not be null")
        }
        if (!this.__observers) {
            return
        }
        var G;
        var F;
        var H;
        F = this.__observers[DC.KVO.kAllPropertiesKey];
        if (F) {
            var E = Object.clone(J);
            var A = J.objectKeyPath.length;
            J.objectKeyPath.push(this);
            for (G in F) {
                var B = F[G];
                B.observeChangeForKeyPath(E, L)
            }
            J.objectKeyPath.length = A
        }
        if (DC.KVO.kAllPropertiesKey == L) {
            return
        }
        F = this.__observers[L];
        if (F && F.length) {
            H = F.length;
            for (G = 0; G < H; ++G) {
                F[G].observeChangeForKeyPath(J, L)
            }
        }
        var D = L + ".";
        var I = D.length;
        var K;
        var M;
        var P;
        var O;
        var C;
        var N = !(null === J.oldValue || "undefined" === typeof (J.oldValue));
        for (M in this.__observers) {
            if (M.substr(0, I) != D) {
                continue
            }
            F = this.__observers[M];
            if (!F || !F.length) {
                continue
            }
            K = M.substr(I);
            O = J.oldValue;
            if (O && O.valueForKeyPath) {
                O = O.valueForKeyPath(K)
            } else {
                O = null
            }
            C = J.newValue;
            if (C && C.valueForKeyPath) {
                C = C.valueForKeyPath(K)
            } else {
                C = null
            }
            if (N && O === C) {
                continue
            }
            P = new DC.ChangeNotification(J.object, J.changeType, C, O, J.indexes);
            H = F.length;
            for (G = 0; G < H; ++G) {
                F[G].observeChangeForKeyPath(P, M)
            }
        }
    }
});
DC.KVO.kAllPropertiesKey = "*";
DC.KVO.keysToIgnore = $S("__keys", "__observers", "__keysToIgnore", "__dependentKeys", "__mutableKeys", "__factories__");
DC.KVO.typesOfKeyValuesToIgnore = $S("string", "number", "boolean", "date", "regexp", "function");
DC.KVO.getPropertyMethodsForKeyOnObject = (function () {
    function B(H, F) {
        F = F || "__kvo_prop_" + H;
        var G = {
            getter: function () {
                var I = null;
                if (F in this) {
                    I = this[F]
                }
                var J = this.__keys ? this.__keys[H] : null;
                if (!J) {
                    return I
                }
                if (I && I._addParentLink) {
                    I._addParentLink(this, J)
                } else {
                    J.unlinkParentLink()
                }
                return I
            },
            mutator: function (I) {
                this.willChangeValueForKey(H);
                if ("undefined" === typeof (I)) {
                    I = null
                }
                this[F] = I;
                this.didChangeValueForKey(H);
                return I
            }
        };
        G.mutator.__key = H;
        G.getter.__key = H;
        return G
    }
    function C(H, G) {
        function F(J) {
            this.willChangeValueForKey(G);
            var I = H.call(this, J);
            this.didChangeValueForKey(G);
            return I
        }
        F.__key = G;
        F.valueOf = function () {
            return H
        };
        F.toString = function () {
            return String(H)
        };
        return F
    }
    function D(F, H) {
        function G() {
            var I = F.call(this);
            var J = this.__keys ? this.__keys[H] : null;
            if (!J) {
                return I
            }
            if (I && I._addParentLink) {
                I._addParentLink(this, J)
            } else {
                J.unlinkParentLink()
            }
            return I
        }
        G.__key = H;
        G.valueOf = function () {
            return F
        };
        G.toString = function () {
            return String(F)
        };
        return G
    }
    function E(T, K) {
        var M = K.constructor.prototype;
        var J = (M == K);
        var L = (M != Object.prototype && M != DC.KVO.prototype) ? M : K;
        var U = T.titleCase();
        var P = "get" + U;
        var Q = "set" + U;
        var I = "validate" + U;
        var O;
        var H;
        var S;
        var F = K[I];
        var N = ("undefined" !== typeof (O = K.__lookupGetter__(T)) && "undefined" !== typeof (H = K.__lookupSetter__(T)));
        if (!N) {
            P = (P in K) ? P : T;
            O = K[P];
            H = K[Q]
        }
        if ("function" !== typeof (O)) {
            var R = "__kvo_prop_" + T;
            var G = B(T, R);
            if (T in K) {
                S = K[R] = ("undefined" == typeof (O) ? null : O);
                delete K[T]
            }
            O = G.getter;
            H = G.mutator;
            N = true
        } else {
            if (O && !J) {
                S = O.valueOf().call(K)
            }
            if (O && T !== O.__key) {
                O = D(O, T)
            }
            if (H && T !== H.__key) {
                H = C(H, T)
            }
        }
        if (N) {
            L.__defineGetter__(T, O);
            L.__defineSetter__(T, H)
        } else {
            if (O) {
                if (K.hasOwnProperty(P)) {
                    K[P] = O
                } else {
                    L[P] = O
                }
            }
            if (H) {
                if (K.hasOwnProperty(Q)) {
                    K[Q] = H
                } else {
                    L[Q] = H
                }
            }
        }
        return {
            getter: O,
            mutator: H,
            validator: F,
            value: S
        }
    }
    function A(Q, J) {
        var L = J.constructor.prototype;
        var I = (L == J);
        var K = (L != Object.prototype && L != DC.KVO.prototype) ? L : J;
        var R = Q.titleCase();
        var O = "set" + R;
        var N = "get" + R;
        var H = "validate" + R;
        N = (N in J) ? N : Q;
        var M = J[N];
        var G = J[O];
        var F = J[H];
        var P;
        if ("function" !== typeof (M)) {
            if (Q in J) {
                P = M
            }
            M = null;
            G = null
        } else {
            if (M && !I) {
                P = M.valueOf().call(J)
            }
            if (M && Q !== M.__key) {
                M = D(M, Q)
            }
            if (G && Q !== G.__key) {
                G = C(G, Q)
            }
        }
        if (M) {
            if (J.hasOwnProperty(N)) {
                J[N] = M
            } else {
                K[N] = M
            }
        }
        if (G) {
            if (J.hasOwnProperty(O)) {
                J[O] = G
            } else {
                K[O] = G
            }
        }
        return {
            getter: M,
            mutator: G,
            validator: F,
            value: P
        }
    }
    if (DC.Support.Properties) {
        return E
    } else {
        return A
    }
})();
DC.KVO.adapt = function (B) {
    if (!B) {
        throw new InvalidArgumentError("Can't adapt a null object")
    }
    var A;
    for (A in DC.KVO.prototype) {
        if (A in B) {
            continue
        }
        B[A] = DC.KVO.prototype[A]
    }
    if ("keyDependencies" in B && !("__dependentKeys" in B)) {
        var C = B.keyDependencies;
        for (A in C) {
            B.setKeysTriggerChangeNotificationsForDependentKey(C[A], A)
        }
    }
    return B
};
DC.KVO.adaptTree = function (C) {
    DC.KVO.adapt(C);
    var B;
    var A;
    for (B in C) {
        if (B in DC.KVO.keysToIgnore) {
            continue
        }
        A = C[B];
        if (!A) {
            continue
        }
        if (DC.typeOf(A) in DC.KVO.typesOfKeyValuesToIgnore) {
            continue
        }
        DC.KVO.adaptTree(A)
    }
    return C
};
DC.KVO.__subclassCreated__ = function (A) {
    var D = A.superclass.prototype;
    var B = A.prototype;
    if (D.keyDependencies === B.keyDependencies) {
        return
    }
    var E = B.keyDependencies || {};
    for (var C in E) {
        B.setKeysTriggerChangeNotificationsForDependentKey(E[C], C)
    }
};
DC.Bindable = Class.create(DC.KVO, {
    constructor: function (A) {
        this.bindings = {};
        this.__parameters = A;
        this.__context = DC.dataModel
    },
    __createFactoryObjects: function () {
        var A = DC.dataModel;
        var C = this.__context;
        DC.dataModel = this.__context = this;
        var D;
        var B;
        for (D in this.__factories__) {
            B = this[D];
            if (!B.__factoryFn__) {
                continue
            }
            this[D] = B.call(this)
        }
        DC.dataModel = A;
        this.__context = C
    },
    exposedBindings: [],
    defaultPlaceholders: {},
    automaticallySetupBindings: true,
    __relativeSource: null,
    defaultPlaceholderForMarkerWithBinding: function (B, C) {
        var A = this.defaultPlaceholders[C];
        if (!A) {
            return null
        }
        return A[B] || null
    },
    __createObserverMethod: function (B, C) {
        function A(E) {
            if (DC.ChangeType.setting !== E.changeType) {
                throw new InvalidArgumentError('Received invalid change type for synthesized binding observer (name="' + B + '" keyPath="' + C + '")')
            }
            var D = E.newValue;
            this.setValueForKey(E.newValue, B)
        }
        return A
    },
    bindNameToKeyPath: function (B, G, A) {
        var D;
        var F;
        var E = {};
        if (!this.bindings) {
            this.bindings = {}
        }
        D = this["observe" + B.titleCase() + "Change"] || this.__createObserverMethod(B, G);
        if (this.bindings[B]) {
            this.bindings[B].unbind()
        }
        var C = this.__context;
        if ("object" === typeof (G)) {
            Object.extend(E, G);
            G = E.keypath
        }
        Object.extend(E, DC.Binding.bindingInfoFromString(G));
        if ("transformValue" in E) {
            E.transformer = {
                transformValue: E.transformValue,
                reverseTransformedValue: E.reverseTransformedValue || null
            };
            delete E.transformValue;
            delete E.reverseTransformedValue
        }
        if ("*." === E.keypath.substr(0, 2)) {
            if (A) {
                C = A
            } else {
                C = new DC.KVO()
            }
            E.keypath = E.keypath.substr(2)
        }
        E.name = B;
        E.object = C;
        E.observer = this;
        E.observerFn = D;
        F = new DC.Binding(E);
        F.bind();
        this.bindings[B] = F
    },
    __postConstruct: function () {
        if (!this.automaticallySetupBindings) {
            return
        }
        this.__initialising = true;
        this.__copyParameters(this.__parameters || {});
        this.setupBindings();
        this.updateBindings();
        this.createObservers();
        delete this.__initialising
    },
    __copyParameters: function (C) {
        var D;
        var A;
        var B = DC.KVO.adaptTree;
        for (D in C) {
            if (-1 !== D.search(/Binding$/)) {
                continue
            }
            A = C[D];
            if ("object" === DC.typeOf(A) && !("addObserverForKeyPath" in A)) {
                B(A)
            }
            this[D] = A
        }
        this.__parameters = C
    },
    bindingInfoForName: function (A) {
        if (!this.__parameters) {
            return null
        }
        return this.__parameters[A + "Binding"]
    },
    __createAutoObserver: function (C, B) {
        var A = DC.ChangeType.setting;
        return function (D) {
            if (this.bindings[B] || A == D.changeType) {
                return
            }
            C.apply(this, arguments)
        }
    },
    createObservers: function () {
        var E = this.exposedBindings;
        var A = E.length;
        var B;
        var D;
        var C;
        for (B = 0; B < A; ++B) {
            C = E[B];
            D = this["observe" + C.titleCase() + "Change"];
            if (!D) {
                continue
            }
            D = this.__createAutoObserver(D, C);
            this.addObserverForKeyPath(this, D, C, "__auto_observer__")
        }
    },
    setupBindings: function () {
        var D = this.exposedBindings;
        var B = D.length;
        var E;
        var A;
        var C;
        for (C = 0; C < B; ++C) {
            A = D[C];
            E = this.bindingInfoForName(A);
            if (!E) {
                continue
            }
            this.bindNameToKeyPath(A, E, this.__relativeSource)
        }
    },
    updateBindings: function () {
        var E = this.bindings;
        var D = this.exposedBindings;
        var B = D.length;
        var A;
        var C;
        for (C = 0; C < B; ++C) {
            A = E[D[C]];
            if (!A) {
                continue
            }
            A.update()
        }
    },
    unbind: function () {
        for (var A in this.bindings) {
            this.bindings[A].unbind()
        }
    }
});
DC.Bindable.__subclassCreated__ = function (C) {
    var E = C.superclass.prototype;
    var D = C.prototype;
    if (D.hasOwnProperty("defaultPlaceholders")) {
        var B = Object.clone(E.defaultPlaceholders);
        D.defaultPlaceholders = Object.extend(B, D.defaultPlaceholders)
    }
    if (E.exposedBindings === D.exposedBindings && !D.maskedBindings) {
        return
    }
    var A = (E.maskedBindings === D.maskedBindings) ? {} : $S(D.maskedBindings);

    function F(H) {
        return !(H in A)
    }
    var G = E.exposedBindings.filter(F);
    if (E.exposedBindings !== D.exposedBindings) {
        G = G.concat(D.exposedBindings.filter(F))
    }
    D.exposedBindings = G
};
DC.SortDescriptor = Class.create({
    constructor: function (D, A, B) {
        this.keyPath = D;
        this.ascending = A;
        this.comparisonFn = B || this.defaultCompare;
        var C = typeof (this.comparisonFn);
        if ("string" != C && "function" != C) {
            throw new InvalidArgumentError("comparisonFn must be either the name of a method or a function reference")
        }
    },
    resolveComparisonFn: function (B) {
        var A = this.comparisonFn;
        if ("string" === typeof (A)) {
            A = B[A]
        }
        if ("function" !== typeof (A)) {
            throw new TypeError("comparisonFn does not resolve to a function")
        }
        return A
    },
    compareObjects: function (C, B) {
        if (!C.valueForKeyPath || !B.valueForKeyPath) {
            throw new InvalidArgumentError("Objects are not Key Value compliant")
        }
        var E = C.valueForKeyPath(this.keyPath);
        var D = B.valueForKeyPath(this.keyPath);
        var A = this.resolveComparisonFn(E);
        return A.call(E, D)
    },
    defaultCompare: function (A) {
        return DC.compareValues(this, A)
    },
    reversedSortDescriptor: function () {
        return new DC.SortDescriptor(this.keyPath, !this.ascending, this.comparisonFn)
    }
});
DC.ValueTransformer = Class.create({
    transformedValue: function (A) {
        return A
    },
    reverseTransformedValue: function (A) {
        return A
    },
    __factory__: function () {
        var B = Array.from(arguments);
        var A = this;

        function C() {}
        return function () {
            C.prototype = A.prototype;
            var D = new C();
            A.prototype.constructor.apply(D, B);
            return D
        }
    }
});
DC.ValueTransformer.__subclassCreated__ = function (A) {
    var C = DC.ValueTransformer.prototype;
    var B = A.prototype;
    if (C.reverseTransformedValue == B.reverseTransformedValue) {
        A.prototype.reverseTransformedValue = null
    }
};
DC.transformer = {};
DC.transformerInstances = {};
DC.findTransformerWithName = function (transformerName) {
    var valueTransformer = DC.transformerInstances[transformerName.toLowerCase()];
    if (valueTransformer) {
        return valueTransformer
    }
    if (-1 === transformerName.indexOf(".")) {
        valueTransformer = DC.transformer[transformerName]
    }
    if (!valueTransformer) {
        try {
            valueTransformer = eval(transformerName)
        } catch (e) {}
    }
    if (!valueTransformer) {
        throw new InvalidArgumentError("The transformerName argument does not specify a valid ValueTransformer: " + transformerName)
    }
    if ("function" !== typeof (valueTransformer)) {
        return valueTransformer
    }
    if (valueTransformer.__factoryFn__) {
        valueTransformer = valueTransformer()
    } else {
        valueTransformer = new valueTransformer()
    }
    return valueTransformer
};
DC.registerTransformerWithName = function (B, A) {
    if (!B.transformedValue) {
        throw new InvalidArgumentError("The valueTransformer argument does not support the ValueTransformer method transformedValue")
    }
    A = A.toLowerCase();
    DC.transformerInstances[A] = B
};
DC.transformer.Not = Class.create(DC.ValueTransformer, {
    transformedValue: function (A) {
        return (A ? false : true)
    },
    reverseTransformedValue: function (A) {
        return !!A
    }
});
DC.registerTransformerWithName(new DC.transformer.Not(), "not");
DC.transformer.Boolean = Class.create(DC.ValueTransformer, {
    constructor: function (A, B) {
        this.trueValue = A;
        this.falseValue = B
    },
    transformedValue: function (A) {
        return (A == this.trueValue)
    },
    reverseTransformedValue: function (A) {
        return (A ? this.trueValue : this.falseValue)
    }
});
DC.transformer.Matches = Class.create(DC.ValueTransformer, {
    constructor: function (A) {
        this.trueRegex = A
    },
    transformedValue: function (A) {
        return this.trueRegex.test(A)
    }
});
DC.transformer.Generic = Class.create(DC.ValueTransformer, {
    constructor: function (A, B) {
        this.modelValues = A;
        this.displayValues = B
    },
    transformedValue: function (B) {
        var A = this.modelValues.indexOf(B);
        var C;
        if (-1 == A) {
            return C
        } else {
            return this.displayValues[A]
        }
    },
    reverseTransformedValue: function (B) {
        var A = this.displayValues.indexOf(B);
        var C;
        if (-1 == A) {
            return C
        } else {
            return this.modelValues[A]
        }
    }
});
DC.transformer.Truncated = Class.create(DC.ValueTransformer, {
    constructor: function (A) {
        this.max = A || 50
    },
    ellipsis: String.fromCharCode(8230),
    transformedValue: function (C) {
        if (!C && 0 !== C) {
            return C
        }
        C = "" + C;
        var A = C.length;
        if (A <= this.max) {
            return C
        }
        var B = this.max / 2 - 2;
        return [C.substr(0, B), this.ellipsis, C.substr(A - B)].join(" ")
    }
});
DC.registerTransformerWithName(new DC.transformer.Truncated(50), "truncated");
DC.transformer.StringsToObjects = Class.create(DC.ValueTransformer, {
    constructor: function (A) {
        this.key = A || "string"
    },
    transformedValue: function (B) {
        if (!B || !B.map) {
            return B
        }
        function A(C) {
            var D = new DC.KVO();
            D[this.key] = C;
            return D
        }
        return B.map(A, this)
    },
    reverseTransformedValue: function (B) {
        if (!B || !B.map) {
            return B
        }
        function A(C) {
            return C[this.key]
        }
        return B.map(A, this)
    }
});
DC.registerTransformerWithName(new DC.transformer.StringsToObjects("string"), "StringsToObjects");
DC.transformer.FirstObject = Class.create(DC.ValueTransformer, {
    transformedValue: function (A) {
        if (DC.typeOf(A) == "array") {
            return A[0]
        }
        return A
    }
});
Object.extend(DC, {
    NoSelectionMarkerType: "noSelection",
    MultipleValuesMarkerType: "multipleValues",
    NullValueMarkerType: "nullValue"
});
DC.Binding = Class.create({
    constructor: function (A) {
        Object.extend(this, A);
        if ("string" === typeof (this.transformer)) {
            this.transformer = DC.findTransformerWithName(this.transformer)
        }
        if ("function" === typeof (this.transformer)) {
            if (this.transformer.__factoryFn__) {
                this.transformer = this.transformer()
            } else {
                this.transformer = new this.transformer()
            }
        }
        this.refresh()
    },
    bind: function () {
        this.object.addObserverForKeyPath(this, this.observeChangeForKeyPath, this.keypath)
    },
    unbind: function () {
        this.object.removeObserverForKeyPath(this, this.keypath)
    },
    refresh: function () {
        var A = this.object.valueForKeyPath(this.keypath);
        this.cachedOriginalValue = A;
        this.markerType = this.markerTypeFromValue(A);
        if (this.markerType) {
            if ((this.markerType + "Placeholder") in this) {
                A = this[this.markerType + "Placeholder"]
            } else {
                A = this.observer.defaultPlaceholderForMarkerWithBinding(this.markerType, this.name)
            }
        } else {
            A = this.transformedValue(A)
        }
        this.cachedValue = A
    },
    transformedValue: function (A) {
        if (!this.transformer) {
            return A
        }
        return this.transformer.transformedValue(A)
    },
    validateProposedValue: function (B) {
        if (this.transformer) {
            if (!this.transformer.reverseTransformedValue) {
                throw new Error("Can't validate a value when the transformer doesn't have a reverseTransformedValue method")
            }
            B = this.transformer.reverseTransformedValue(B)
        }
        var A = this.object.validateValueForKeyPath(B, this.keypath);
        if (A instanceof DC.Error) {
            return A
        }
        return this.transformedValue(A)
    },
    setValue: function (A) {
        if (this.cachedValue === A) {
            return
        }
        this.markerType = this.markerTypeFromValue(A);
        this.cachedValue = A;
        if (this.transformer) {
            if (!this.transformer.reverseTransformedValue) {
                return
            }
            A = this.transformer.reverseTransformedValue(A)
        }
        this.cachedOriginalValue = A;
        var B = this.updating;
        this.updating = true;
        this.object.setValueForKeyPath(A, this.keypath);
        this.updating = B
    },
    mutable: function () {
        if (this.transformer && !this.transformer.reverseTransformedValue) {
            return false
        }
        var A = this.object.infoForKeyPath(this.keypath);
        return A && A.mutable
    },
    value: function () {
        return this.cachedValue
    },
    update: function () {
        var B = this.value();
        var C = new DC.ChangeNotification(this.object, DC.ChangeType.setting, B);
        this.updating = true;
        try {
            this.observerFn.call(this.observer, C, this.keypath)
        } catch (A) {
            console.error('Exception while bindng "' + this.name + '" to keypath "' + this.keypath + ' ": ' + A)
        }
        this.updating = false
    },
    observerFn: function (C, A, B) {},
    markerTypeFromValue: function (A) {
        if (null === A || "undefined" === typeof (A) || "" === A) {
            return DC.NullValueMarkerType
        }
        if (DC.Markers.MultipleValues === A) {
            return DC.MultipleValuesMarkerType
        }
        if (DC.Markers.NoSelection === A) {
            return DC.NoSelectionMarkerType
        }
        return null
    },
    placeholderValue: function () {
        var A;
        if ((this.markerType + "Placeholder") in this) {
            A = this[this.markerType + "Placeholder"]
        } else {
            A = this.observer.defaultPlaceholderForMarkerWithBinding(this.markerType, this.name)
        }
        if ("function" === typeof (A)) {
            A = A.call(this.object)
        }
        return A
    },
    observeChangeForKeyPath: function (G, A, B) {
        if (this.updating && G.newValue === this.cachedOriginalValue) {
            return
        }
        this.cachedOriginalValue = G.newValue;
        var E = G.newValue;
        this.markerType = this.markerTypeFromValue(E);
        if (this.markerType) {
            E = this.placeholderValue()
        } else {
            E = this.transformedValue(E)
        }
        var C = Object.clone(G);
        C.newValue = E;
        if (DC.ChangeType.setting === G.changeType) {
            this.cachedValue = E
        }
        var F = this.updating;
        this.updating = true;
        try {
            this.observerFn.call(this.observer, C, A, B)
        } catch (D) {
            console.error('Exception while bindng "' + this.name + '" to keypath "' + this.keypath + ' ": ' + D)
        }
        this.updating = F
    }
});
DC.Binding.bindingRegex = /^(.*?)(?:\((.*)\))?$/;
DC.Binding.compoundRegex = /^\s*([^&|].*?)\s*(\&\&|\|\|)\s*(\S.+)\s*$/;
DC.Binding.bindingInfoFromString = function (B) {
    var A;
    var C;
    A = B.match(DC.Binding.bindingRegex);
    if (!A || A.length < 3) {
        throw new InvalidArgumentError("bindingString isn't in correct format")
    }
    var D = {
        keypath: A[1]
    };
    if (A[2]) {
        D.transformer = DC.findTransformerWithName(A[2])
    }
    return D
};
Class.extend(Array, {
    containsObject: function (A) {
        return -1 !== this.indexOf(A)
    },
    valueForKey: function (D) {
        if (!D || 0 === D.length) {
            throw new InvalidArgumentError("the key is empty")
        }
        if ("@count" == D) {
            return this.length
        }
        var E = new Array(this.length);
        var C;
        var A = this.length;
        var B;
        for (C = 0; C < A; ++C) {
            B = this[C];
            E[C] = B ? B.valueForKey(D) : null
        }
        return E
    },
    setValueForKey: function (D, C) {
        if (!C || 0 === C.length) {
            throw new InvalidArgumentError("key is empty")
        }
        var B;
        var A = this.length;
        for (B = 0; B < A; ++B) {
            this[B].setValueForKey(D, C)
        }
    },
    indexesOfObjects: function (E) {
        var D;
        var B = E.length;
        var A = [];
        var C;
        for (D = 0; D < B; ++D) {
            C = this.indexOf(E[D]);
            if (-1 === C) {
                continue
            }
            A.push(C)
        }
        return A
    },
    addObject: function (B) {
        var A = this.length;
        var C = new DC.ChangeNotification(this, DC.ChangeType.insertion, [B], null, [A]);
        this.push(B);
        this.observeElementAtIndex(A);
        this.notifyObserversOfChangeForKeyPath(C, DC.KVO.kAllPropertiesKey)
    },
    addObjects: function (G) {
        var B = G.length;
        var E = this.length;
        var C = [];
        var A = [];
        var F = new DC.ChangeNotification(this, DC.ChangeType.insertion, C, null, A);
        for (index = 0; index < B; ++index) {
            var D = G[index];
            this.push(D);
            this.observeElementAtIndex(E);
            C.push(D);
            A.push(E++)
        }
        this.notifyObserversOfChangeForKeyPath(F, DC.KVO.kAllPropertiesKey)
    },
    insertObjectAtIndex: function (B, A) {
        if (A < 0 || A > this.length) {
            throw new RangeError("index must be within the bounds of the array")
        }
        var C = new DC.ChangeNotification(this, DC.ChangeType.insertion, [B], null, [A]);
        this.splice(A, 0, B);
        this.observeElementAtIndex(A);
        this.notifyObserversOfChangeForKeyPath(C, DC.KVO.kAllPropertiesKey)
    },
    insertObjectsAtIndexes: function (E, C) {
        if (E.length !== C.length) {
            throw new InvalidArgumentError("length of objects and indexes parameters must be equal")
        }
        var A = E.length;
        var D;
        var B;
        for (D = 0; D < A; ++D) {
            B = C[D];
            this.splice(B, 0, E[D]);
            this.observeElementAtIndex(B)
        }
        var F = new DC.ChangeNotification(this, DC.ChangeType.insertion, E, null, C);
        this.notifyObserversOfChangeForKeyPath(F, DC.KVO.kAllPropertiesKey)
    },
    replaceObjectAtIndex: function (C, B) {
        var A = this[B];
        this[B] = C;
        var D = new DC.ChangeNotification(this, DC.ChangeType.replacement, [C], [A], [B]);
        this.notifyObserversOfChangeForKeyPath(D, DC.KVO.kAllPropertiesKey)
    },
    replaceObjectsAtIndexes: function (F, D) {
        var B = [];
        var A = F.length;
        var E;
        var C;
        for (E = 0; E < A; ++E) {
            C = D[E];
            B[E] = this[C];
            this.stopObservingElementAtIndex(C);
            this[C] = F[E];
            this.observeElementAtIndex(C)
        }
        var G = new DC.ChangeNotification(this, DC.ChangeType.replacement, F, null, D);
        this.notifyObserversOfChangeForKeyPath(G, DC.KVO.kAllPropertiesKey)
    },
    removeObject: function (B) {
        var A = this.indexOf(B);
        if (-1 === A) {
            return
        }
        this.removeObjectAtIndex(A)
    },
    removeObjects: function (D) {
        var A = D.length;
        var B;
        for (var C = 0; C < A; ++C) {
            B = this.indexOf(D[C]);
            if (-1 === B) {
                continue
            }
            this.removeObjectAtIndex(B)
        }
    },
    removeObjectsAtIndexes: function (D) {
        var C;
        var E = D.sort(function (I, H) {
            return H - I
        });
        var A = D.length;
        var B = [];
        for (C = 0; C < A; ++C) {
            var F = E[C];
            this.stopObservingElementAtIndex(F);
            B.push(this[F]);
            this.splice(F, 1)
        }
        var G = new DC.ChangeNotification(this, DC.ChangeType.deletion, null, B, E);
        this.notifyObserversOfChangeForKeyPath(G, DC.KVO.kAllPropertiesKey)
    },
    removeObjectAtIndex: function (B) {
        if (B < 0 || B >= this.length) {
            throw new RangeError("index must be within the bounds of the array")
        }
        this.stopObservingElementAtIndex(B);
        var A = this.splice(B, 1);
        var C = new DC.ChangeNotification(this, DC.ChangeType.deletion, null, A, [B]);
        this.notifyObserversOfChangeForKeyPath(C, DC.KVO.kAllPropertiesKey)
    },
    removeAllObjects: function () {
        var D;
        var C = [];
        var A = this.length;
        C.length = A;
        for (D = 0; D < A; ++D) {
            this.stopObservingElementAtIndex(D);
            C[D] = D
        }
        var B = this.splice(0, A);
        var E = new DC.ChangeNotification(this, DC.ChangeType.deletion, null, B, C);
        this.notifyObserversOfChangeForKeyPath(E, DC.KVO.kAllPropertiesKey)
    },
    objectsAtIndexes: function (C) {
        var D;
        var B = [];
        var A = C.length;
        B.length = C.length;
        for (D = 0; D < A; ++D) {
            B[D] = this[C[D]]
        }
        return B
    },
    observeChildObjectChangeForKeyPath: function (F, E, B) {
        var D = F.object;
        var C = this.indexOf(D);
        if (!this.__uid) {
            this.initialiseKeyValueObserving()
        }
        if (-1 === C) {
            D._removeParentLink(this, null, this.__uid);
            return
        }
        var A = new DC.ChangeNotification(D, DC.ChangeType.replacement, [F.newValue], [F.oldValue], [C]);
        this.notifyObserversOfChangeForKeyPath(A, E)
    },
    observeElementAtIndex: function (A) {
        var B = this[A];
        if (!B || !B._addParentLink) {
            return
        }
        if (!this.__uid) {
            this.initialiseKeyValueObserving()
        }
        B._addParentLink(this, null, this.__uid)
    },
    stopObservingElementAtIndex: function (A) {
        var B = this[A];
        if (!B || !B._removeParentLink) {
            return
        }
        if (!this.__uid) {
            this.initialiseKeyValueObserving()
        }
        B._removeParentLink(this, null, this.__uid)
    },
    initialiseKeyValueObserving: function () {
        var B;
        var A = this.length;
        this.__observers = {};
        this.__uid = this.__uid || DC.generateUid();
        for (B = 0; B < A; ++B) {
            this.observeElementAtIndex(B)
        }
    }
});
DC.KVO.adapt(Array.prototype);
DC.ArrayOperator = {
    avg: function (A) {
        return this.sum(A) / A.length
    },
    count: function (A) {
        throw new InvalidArgumentError("@count operator must end the keyPath")
    },
    distinctUnionOfArrays: function (A) {
        return this.unionOfArrays(A).distinct()
    },
    distinctUnionOfObjects: function (A) {
        return A.distinct()
    },
    max: function (D) {
        var B = null;
        var E;
        var A;
        var C;
        for (E = 0, A = D.length; E < A; ++E) {
            C = D[E];
            if (null === B || C > B) {
                B = C
            }
        }
        return B
    },
    min: function (C) {
        var E = null;
        var D;
        var A;
        var B;
        for (D = 0, A = C.length; D < A; ++D) {
            B = C[D];
            if (null === E || B < E) {
                E = B
            }
        }
        return E
    },
    sum: function (B) {
        var D = 0;
        var A = B.length;
        var C;
        for (C = 0; C < A; ++C) {
            D += B[C]
        }
        return D
    },
    unionOfArrays: function (B) {
        var D = [];
        var A;
        var C;
        for (C = 0, A = B.length; C < A; ++C) {
            D = D.concat(B[C])
        }
        return D
    },
    unionOfObjects: function (A) {
        return A
    }
};
Object.extend(DC, {
    dataModel: new DC.KVO(),
    registerModelWithName: function (B, A) {
        DC.dataModel.setValueForKey(B, A)
    },
    unregisterModelWithName: function (A) {
        delete DC.dataModel[A]
    }
});
String.prototype.titleCase = function () {
    return this.charAt(0).toUpperCase() + this.substr(1)
};
String.prototype.trim = function () {
    var B = this.replace(/^\s+/, "");
    for (var A = B.length - 1; A > 0; --A) {
        if (/\S/.test(B.charAt(A))) {
            B = B.substring(0, A + 1);
            break
        }
    }
    return B
};
String.prototype.beginsWith = function (A) {
    return A === this.substring(0, A.length)
};
if (!String.prototype.localeCompare) {
    String.prototype.localeCompare = function (A) {
        if (this < A) {
            return -1
        } else {
            if (this > A) {
                return 1
            } else {
                return 0
            }
        }
    }
}
String.prototype.expand = function (C, A) {
    function B(F, D) {
        var E = C[D];
        if (null === E || "undefined" === typeof (E)) {
            return A
        }
        return E
    }
    return this.replace(/\$\{(\w+)\}/g, B)
};
var CancelledError = DC.defineError("CancelledError");
var InvalidStateError = DC.defineError("InvalidStateError");
(function () {
    var C = -1;
    var A = 0;
    var B = 1;
    DC.Deferred = Class.create({
        constructor: function (D) {
            this.canceller = D;
            this._result = null;
            this._status = C;
            this._callbacks = []
        },
        _fire: function (D) {
            while (this._callbacks.length) {
                this._status = (D instanceof Error) ? B : A;
                this._result = D;
                var E = this._callbacks.shift()[this._status];
                if (!E) {
                    continue
                }
                D = E(D);
                if (D instanceof DC.Deferred) {
                    var F = this;

                    function G(H) {
                        F._fire(H);
                        return H
                    }
                    D.addMethods(G, G);
                    return
                }
            }
            this._status = (D instanceof Error) ? B : A;
            this._result = D
        },
        result: function () {
            return this._result
        },
        cancel: function () {
            if (C !== this._status) {
                throw new InvalidStateError("Can not cancel Deferred because it is already complete")
            }
            var D = (this.canceller && this.canceller());
            if (!(D instanceof Error)) {
                D = new CancelledError("Deferred operation cancelled")
            }
            this.failure(D)
        },
        addMethods: function (D, E) {
            this._callbacks.push([D, E]);
            if (C === this._status) {
                return this
            }
            this._fire(this._result);
            return this
        },
        addCallback: function (D) {
            return this.addMethods(D, null)
        },
        addErrorHandler: function (D) {
            return this.addMethods(null, D)
        },
        callback: function (D) {
            if (C !== this._status) {
                throw new InvalidStateError("Can not signal callback because Deferred is already complete: result=" + D)
            }
            this._fire(D)
        },
        failure: function (D) {
            if (C !== this._status) {
                throw new InvalidStateError("Can not signal failure because Deferred is already complete: error=" + D)
            }
            this._fire(D)
        }
    })
})();
window.XHR = (function () {
    var getTransport = function () {
        throw new Error("XMLHttpRequest not available.")
    };
    if (!DC.Browser.IE) {
        getTransport = function () {
            return new XMLHttpRequest()
        }
    } else {
        var progIdCandidates = ["Msxml2.XMLHTTP", "Microsoft.XMLHTTP", "Msxml2.XMLHTTP.4.0"];
        var len = progIdCandidates.length;
        var progId;
        var xhr;
        for (var i = 0; i < len; ++i) {
            try {
                progId = progIdCandidates[i];
                xhr = new ActiveXObject(progId);
                getTransport = function () {
                    return new ActiveXObject(progId)
                };
                break
            } catch (e) {}
        }
    }
    function send(url, method, options) {
        var timeout;

        function noop() {}
        function cancel() {
            xhr.onreadystatechange = noop;
            xhr.abort()
        }
        function readyStateChanged(xhrEvent) {
            if (4 !== xhr.readyState) {
                return
            }
            if (timeout) {
                clearTimeout(timeout)
            }
            if (xhrSent === false) {
                arguments.callee.delay(0);
                return
            }
            var status = xhr.status;
            var succeeded = (status >= 200 && status < 300) || 304 == status;
            if (0 === status || "undefined" === typeof (status)) {
                var protocol = window.location.protocol;
                succeeded = "file:" === protocol || "chrome:" === protocol
            }
            var result = xhr.responseText;
            var err;
            if (succeeded) {
                if ("HEAD" == method) {
                    result = {};
                    try {
                        var headers = xhr.getAllResponseHeaders();
                        if (headers) {
                            headers = headers.split("\n");
                            headers.forEach(function (header) {
                                var match = header.match(/^([^:]+):(.+)$/m);
                                var name = match[1].trim();
                                result[name] = match[2].trim()
                            })
                        }
                    } catch (e) {}
                } else {
                    var contentType = options.responseContentType || xhr.getResponseHeader("Content-Type");
                    if (contentType.match(/(?:application\/(?:x-)?json)|(?:text\/json)/)) {
                        try {
                            result = eval("(" + result + ")")
                        } catch (e) {
                            err = e;
                            succeeded = false
                        }
                    }
                    if (contentType.match(/(?:application|text)\/xml/)) {
                        result = xhr.responseXML
                    }
                }
            } else {
                err = new Error("XHR request failed");
                err.url = url;
                err.method = method;
                err.xhr = xhr;
                err.status = xhr.status;
                err.statusText = "Failed to load resource."
            }
            if (succeeded) {
                deferred.callback(result)
            } else {
                deferred.failure(err)
            }
            xhr.onreadystatechange = noop;
            xhr = null
        }
        var xhr = getTransport();
        var queryString = Object.toQueryString(options.parameters || {});
        var body = options.body || "";
        var async = !options.sync;
        var deferred = new DC.Deferred(cancel);
        var xhrSent = false;
        method = (method || "GET").toUpperCase();
        try {
            if ("GET" == method) {
                if (queryString && -1 === url.indexOf("?")) {
                    url = url + "?" + queryString
                } else {
                    if (queryString && -1 !== url.indexOf("?")) {
                        url = url + "&" + queryString
                    } else {
                        if ("&" === url.slice(-1)) {
                            url = url + queryString
                        } else {
                            url = url + queryString
                        }
                    }
                }
            }
            if (options.responseContentType && xhr.overrideMimeType) {
                xhr.overrideMimeType(options.responseContentType)
            }
            if (options.user) {
                xhr.open(method, url, async, options.user, options.password || "")
            } else {
                xhr.open(method, url, async)
            }
            var headers = options.headers || {};
            for (var h in headers) {
                xhr.setRequestHeader(h, headers[h])
            }
            if ("POST" == method) {
                xhr.setRequestHeader("Content-Type", options.contentType || "application/x-www-form-urlencoded");
                body = queryString
            }
            if (async) {
                xhr.onreadystatechange = readyStateChanged;
                timeout = setTimeout(function () {
                    xhr.abort()
                }, 30000)
            }
            xhr.send(body);
            xhrSent = true;
            if (!async) {
                readyStateChanged()
            }
        } catch (e) {
            var err = new Error("XHR request failed");
            err.url = url;
            err.method = method;
            err.xhr = xhr;
            err.status = -1;
            err.statusText = "Failed to load resource.";
            deferred.failure(err)
        }
        return deferred
    }
    return {
        get: function (url, parameters, options) {
            return XHR.request("GET", url, parameters, options)
        },
        post: function (url, parameters, options) {
            return XHR.request("POST", url, parameters, options)
        },
        request: function (method, url, parameters, options) {
            method = method.toUpperCase();
            options = options || {};
            options.parameters = parameters;
            return send(url, method, options)
        }
    }
})();
DC.Controller = Class.create(DC.Bindable, {
    constructor: function (A) {
        this.base(A)
    },
    registerWithName: function (A) {
        if (!A) {
            return
        }
        this.name = A;
        DC.registerModelWithName(this, A)
    }
});
DC.Markers = {
    MultipleValues: "ThisIsAnUniqueStringThatRepresentsMultipleValues",
    NoSelection: "ThisIsAnUniqueStringThatRepresentsNoSelection"
};
DC.SelectionProxy = Class.create(DC.KVO, {
    constructor: function (A) {
        this.controller = A;
        this.mutable = true
    },
    infoForKey: function (B) {
        var A = this.controller.selectedObjects();
        var C = A.infoForKey(B);
        C.mutable &= this.mutable;
        return C
    },
    infoForKeyPath: function (C) {
        var A = this.controller.selectedObjects();
        var B = A.infoForKeyPath(C);
        B.mutable &= this.mutable;
        return B
    },
    translateValue: function (D) {
        if ("array" !== DC.typeOf(D)) {
            return D
        }
        if (1 === D.length) {
            return D[0]
        }
        var C;
        var A;
        var B = D[0];
        for (C = 1, A = D.length; C < A; ++C) {
            if (0 !== DC.compareValues(B, D[C])) {
                return DC.Markers.MultipleValues
            }
        }
        return B
    },
    valueForKey: function (C) {
        var B = this.controller.selectedObjects();
        if (0 === B.length) {
            return DC.Markers.NoSelection
        }
        var A = B.valueForKey(C);
        return this.translateValue(A)
    },
    validateValueForKeyPath: function (E, F) {
        var B = this.controller.selectedObjects();
        var A = B.length;
        var D;
        if (0 === A) {
            return E
        }
        var C;
        for (D = 0; D < A; ++D) {
            C = B[D].validateValueForKeyPath(E, F);
            if (C instanceof DC.Error) {
                return C
            }
        }
        return C
    },
    valueForKeyPath: function (C) {
        var B = this.controller.selectedObjects();
        if (0 === B.length) {
            return DC.Markers.NoSelection
        }
        var A = B.valueForKeyPath(C);
        return this.translateValue(A)
    },
    setValueForKey: function (D, C) {
        if (!this.mutable) {
            return
        }
        var B = this.controller.selectedObjects();
        var A = this.valueForKey(C);
        B.setValueForKey(D, C);
        var E = this.valueForKey(C);
        if (A === E) {
            return
        }
        var F = new DC.ChangeNotification(this, DC.ChangeType.setting, E, A);
        this.notifyObserversOfChangeForKeyPath(F, C)
    },
    setValueForKeyPath: function (C, F) {
        if (!this.mutable) {
            return
        }
        var B = this.controller.selectedObjects();
        var A = this.valueForKeyPath(F);
        B.setValueForKeyPath(C, F);
        var D = this.valueForKeyPath(F);
        if (A === D) {
            return
        }
        var E = new DC.ChangeNotification(this, DC.ChangeType.setting, D, A);
        this.notifyObserversOfChangeForKeyPath(E, F)
    }
});
DC.ObjectController = Class.create(DC.Controller, {
    constructor: function (A) {
        this.base(A);
        this.objectClass = DC.KVO;
        this.__content = null;
        this.__editable = true;
        this.__selectedObjects = [];
        this.__selection = new DC.SelectionProxy(this)
    },
    observeChildObjectChangeForKeyPath: function (F, E, B) {
        this.base(F, E, B);
        if ("selectedObjects" !== B) {
            return
        }
        var C = "selection." + E;
        var D = this.valueForKeyPath(C);
        var A = new DC.ChangeNotification(this, DC.ChangeType.setting, D, null);
        this.notifyObserversOfChangeForKeyPath(A, C)
    },
    keyDependencies: {},
    exposedBindings: ["editable", "content"],
    editable: function () {
        var A = this.__editable;
        if (this.bindings.content) {
            A &= this.bindings.content.mutable()
        }
        return A
    },
    setEditable: function (A) {
        if (this.bindings.content) {
            A &= this.bindings.content.mutable()
        }
        if (this.bindings.editable) {
            this.bingings.editable.setValue(A)
        }
        this.__editable = A
    },
    content: function () {
        return this.__content
    },
    setContent: function (A) {
        if (this.bindings.content) {
            this.bindings.content.setValue(A)
        }
        this.__content = A;
        this.willChangeValueForKey("selectedObjects");
        if (!A) {
            this.__selectedObjects = []
        } else {
            this.__selectedObjects = [A]
        }
        this.didChangeValueForKey("selectedObjects");
        this.forceChangeNotificationForKey("selection")
    },
    selectedObjects: function () {
        return this.__selectedObjects
    },
    selection: function () {
        return this.__selection
    }
});
DC.AjaxController = Class.create(DC.ObjectController, {
    flushContentBeforeQuery: false,
    fetchesInitially: true,
    constructor: function (A) {
        this.queryDelay = 0;
        this.url = "";
        this.method = "GET";
        this.base(A);
        if (this.parameters) {
            DC.KVO.adaptTree(this.parameters)
        } else {
            this.parameters = new DC.KVO()
        }
        this.addObserverForKeyPath(this, this.queryUpdated, "url");
        this.addObserverForKeyPath(this, this.queryUpdated, "method")
    },
    __postConstruct: function () {
        this.base();
        if (this.fetchesInitially && this.url && this.url.length && this.validateParameters()) {
            this.forceChangeNotificationForKey("url")
        }
    },
    validateParameters: function () {
        return true
    },
    fullURL: function () {
        var H = {};
        var E = this.parameters.mutableKeys();
        var A = E.length;
        var B = this.url;
        var D;
        var G;
        for (var C = 0; C < A; ++C) {
            G = E[C];
            if (this.parameters.hasOwnProperty(G)) {
                H[G] = this.parameters[G]
            }
        }
        D = Object.toQueryString(H);
        if (D) {
            var F = B.indexOf("?");
            if (F != (B.length - 1)) {
                B += "?"
            }
            B += D
        }
        return B
    },
    observeChildObjectChangeForKeyPath: function (C, B, A) {
        this.base(C, B, A);
        if ("parameters" === A) {
            this.queryUpdated(C, B, A)
        }
    },
    queryUpdated: function (C, B, A) {
        if (!this.parameters || !this.validateParameters()) {
            return
        }
        this.setValueForKey(true, "queryInProgress");
        if (this.__queryTimer) {
            window.clearTimeout(this.__queryTimer)
        }
        this.__queryTimer = this.performQuery.bindAndDelay(this, this.queryDelay)
    },
    performQuery: function () {
        var F = {};
        var E = this.parameters.mutableKeys();
        var A = E.length;
        var G;
        var C;
        var B = "application/json";
        for (var D = 0; D < A; ++D) {
            G = E[D];
            if (!this.parameters.hasOwnProperty(G)) {
                continue
            }
            C = this.parameters[G];
            if (null === C || "undefined" === typeof (C)) {
                continue
            }
            F[G] = C
        }
        if (this.dataModel && ("xml" == this.dataModel.dataType)) {
            B = "text/xml"
        }
        this.__request = XHR.get(this.url, F, {
            responseContentType: B
        });
        this.__request.addMethods(this.querySucceeded.bind(this), this.queryFailed.bind(this));
        if (this.flushContentBeforeQuery) {
            this.setContent(null)
        }
    },
    extractContent: function (A) {
        return A
    },
    querySucceeded: function (A) {
        var E = null;
        var C = "json";
        if (this.dataModel) {
            if ("xml" == this.dataModel.dataType) {
                C = "xml"
            }
        }
        if (C == "json") {
            DC.KVO.adaptTree(A);
            E = A
        } else {
            if (C == "xml" && A) {
                if (this.dataModel.model) {
                    var B = this.dataModel.model;
                    var D = A;
                    for (var F = D.firstChild; F != null; F = F.nextSibling) {
                        if ((F.nodeType == 1)) {
                            D = F;
                            break
                        }
                    }
                    if (B && D) {
                        E = new DC.ModeledXMLProxy(A, D, B)
                    }
                }
            }
        }
        if (!E) {
            err = new Error("XHR request failed");
            err.url = this.url;
            err.method = this.method;
            err.status = 400;
            err.statusText = "Invalid feed.";
            this.queryFailed(err);
            return
        }
        this.setContent(this.extractContent(E));
        this.setValueForKey("", "statusCode");
        this.setValueForKey("", "errorMessage");
        this.setValueForKey(false, "queryInProgress")
    },
    queryFailed: function (A) {
        this.setValueForKey(-1, "statusCode");
        this.setValueForKey(A.statusText, "errorMessage");
        this.setContent(null);
        this.setValueForKey(false, "queryInProgress")
    }
});
DC.ModeledXMLProxy = Class.create(DC.KVO, {
    _xmlRoot: null,
    _xmlNode: null,
    constructor: function (A, C, B) {
        this._xmlRoot = A;
        this._xmlNode = C;
        this._xmlModel = B;
        this._valueCache = {};
        if (B) {
            if (DC.typeOf(B) == "array") {
                this._xmlModel = B[0]
            }
        }
    },
    _typeOfChild: function (A) {
        var B = "string";
        var C = false;
        if (!this._xmlModel) {
            return null
        }
        model = this._xmlModel[A];
        if (model == undefined) {
            if (A != "#content") {
                return {
                    type: "string",
                    toMany: false
                }
            } else {
                return null
            }
        }
        B = DC.typeOf(model);
        if (B == "array") {
            C = true;
            B = DC.typeOf(model[0])
        }
        if (B == "string" && model == "xhtml") {
            B = "xhtml"
        }
        return {
            type: B,
            toMany: C
        }
    },
    _valueOfNode: function (C, B) {
        var A = null;
        var D = null;
        if (B == "object") {
            return new DC.ModeledXMLProxy(self._xmlRoot, C, model)
        }
        for (var E = C.firstChild; E != null; E = E.nextSibling) {
            if (B == "xhtml") {
                if (E.nodeType == 1 && (E.namespaceURI == DC.ModeledXMLProxy.NS_XHTML)) {
                    return E.outerHTML || E.xml || E.innerHTML
                }
            } else {
                if ((E.nodeType == 3) || (E.nodeType == 4)) {
                    if (!(/[^\t\n\r ]/.test(E.data))) {
                        continue
                    }
                    A = E.data
                }
            }
        }
        if (A) {
            if (B == "boolean") {
                if (A == "true" || A == "YES") {
                    D = true
                } else {
                    if (A == "false" || A == "NO") {
                        D = false
                    }
                }
            } else {
                if (B == "number") {
                    D = Number(A);
                    if (D == NaN) {
                        D = A
                    }
                } else {
                    D = A
                }
            }
        }
        return D
    },
    _valueOfChild: function (H) {
        var I = this;
        var E = null;
        var F = null;
        var C = false;
        var B = function (M, L) {
            var K = new Array();
            for (var N = M.firstChild; N != null; N = N.nextSibling) {
                var J = N.nodeName;
                if (J == L) {
                    K.push(N)
                }
            }
            return K.length ? K : undefined
        };
        var D = this._typeOfChild(H);
        if (!D) {
            return null
        }
        F = D.type;
        C = D.toMany;
        if (H == "#content") {
            return this._valueOfNode(this._xmlNode, F)
        }
        var A = B(this._xmlNode, H);
        var G = null;
        if (C) {
            G = new Array();
            if (A) {
                A.forEach(function (J) {
                    G.push(I._valueOfNode(J, F))
                })
            }
        } else {
            if (A && A.length) {
                G = this._valueOfNode(A[0], F)
            }
        }
        return G
    },
    _rawValueForKey: function (A) {
        var B = null;
        if (0 == A.indexOf("$")) {
            B = this._xmlNode.getAttribute(A.substr(1))
        } else {
            if (0 == A.indexOf("#")) {
                B = this._valueOfChild(A)
            } else {
                B = this._valueOfChild(A)
            }
        }
        return B
    },
    toString: function () {
        if (this._typeOfChild("#content")) {
            return this.valueForKey("#content")
        }
        return "OBJECT"
    },
    valueForKey: function (A) {
        var B = this._valueCache[A];
        if (!A || 0 === A.length) {
            throw new InvalidArgumentError("the key is empty")
        }
        if (undefined === B) {
            var C;
            if (!this.__keys) {
                this.__keys = {}
            }
            this.__keys[A] = C = new DC.ModeledXMLKeyInfo(this, A);
            B = C.get(this)
        }
        if (!this._valueAccessedViaKeyPath && B && (B instanceof DC.ModeledXMLProxy)) {
            if (B._typeOfChild("#content")) {
                return B.valueForKey("#content")
            }
        }
        return B
    },
    valueForKeyPath: function (C) {
        if (!C || 0 === C.length) {
            throw new InvalidArgumentError("keyPath may not be empty")
        }
        if ("string" == typeof (C)) {
            C = C.split(".")
        }
        this._valueAccessedViaKeyPath = true;
        var A = C[0];
        var B = this.base(C);
        delete this._valueAccessedViaKeyPath;
        if (1 == C.length && B) {
            if (B instanceof DC.ModeledXMLProxy) {
                if (B._typeOfChild("#content")) {
                    return B.valueForKey("#content")
                }
            }
        }
        return B
    }
});
DC.ModeledXMLProxy.NS_XHTML = "http://www.w3.org/1999/xhtml";
DC.ModeledXMLKeyInfo = Class.create(DC.KeyInfo, {
    constructor: function (D, C) {
        var A = DC.KVO.getPropertyMethodsForKeyOnObject;
        var B = D._rawValueForKey(C);
        DC.KVO.getPropertyMethodsForKeyOnObject = function (E, F) {
            return {
                value: B,
                getter: function () {
                    return this._valueCache[E]
                },
                mutator: function (G) {
                    this.willChangeValueForKey(E);
                    this._valueCache[E] = G;
                    this.didChangeValueForKey(E)
                }
            }
        };
        this.base(D, C);
        D._valueCache[this.key] = B;
        DC.KVO.getPropertyMethodsForKeyOnObject = A
    }
});
(function () {
    var A = this.Element;
    this.Element = {};
    Object.extend(this.Element, A || {})
}).call(window);
Object.extend(Element, {
    uniqueId: function () {
        return "DC_id_" + Element.assignId.uniqueId++
    },
    assignId: function (A) {
        return A.id || (A.id = ("DC_id_" + Element.assignId.uniqueId++))
    },
    regexForClassName: function (B) {
        var A = arguments.callee;
        if (!A._lookup) {
            A._lookup = {}
        }
        if (B in A._lookup) {
            return A._lookup[B]
        }
        return (A._lookup[B] = new RegExp("(^|\\s)" + B + "(\\s|$)"))
    },
    hasClassName: function (A, B) {
        var C = A.className;
        if (!C) {
            return false
        }
        if (C == B) {
            return true
        }
        return Element.regexForClassName(B).test(C)
    },
    addClassName: function (A, B) {
        if (!B) {
            return
        }
        if (Element.hasClassName(A, B)) {
            return
        }
        A.className += " " + B
    },
    removeClassName: function (A, B) {
        if (!A || !B) {
            return
        }
        var C = Element.regexForClassName(B);
        A.className = A.className.replace(C, " ").trim()
    },
    replaceClassName: function (B, C, A) {
        if (!C) {
            return
        }
        if (!A) {
            Element.removeClassName(B, C);
            return
        }
        var D = Element.regexForClassName(C);
        B.className = B.className.replace(D, "$1" + A + "$2").trim()
    },
    toggleClassName: function (A, B) {
        if (!B) {
            return
        }
        var C = Element.regexForClassName(B);
        var D = A.className;
        if (C.test(D)) {
            A.className = D.replace(C, " ").trim()
        } else {
            A.className += " " + B
        }
    },
    updateClass: function (F, G, C) {
        var E = $S(F.className.split(" "));
        var H = Set.add;
        var B = Set.remove;
        var D;
        var A;
        if ("string" === typeof (G)) {
            H(E, G)
        } else {
            for (D = 0, A = G.length; D < A; ++D) {
                H(E, G[D])
            }
        }
        if ("string" === typeof (C)) {
            B(E, C)
        } else {
            for (D = 0, A = C.length; D < A; ++D) {
                B(E, C[D])
            }
        }
        F.className = Set.join(E, " ")
    },
    PROPERTIES: ["backgroundColor", "backgroundPosition", "borderTopColor", "borderRightColor", "borderBottomColor", "borderLeftColor", "borderTopWidth", "borderRightWidth", "borderBottomWidth", "borderLeftWidth", "color", "display", "fontSize", "letterSpacing", "lineHeight", "opacity", "width", "height", "top", "bottom", "left", "right", "marginTop", "marginRight", "marginBottom", "marginLeft", "paddingTop", "paddingRight", "paddingBottom", "paddingLeft"],
    getStyles: function (E, D) {
        var F = {};
        var B = window.getComputedStyle(E, null);
        if ("string" === typeof (D)) {
            return E.style[D] || B[D] || null
        }
        D = D || Element.PROPERTIES;
        var G;
        var A = D.length;
        for (var C = 0; C < A; ++C) {
            G = D[C];
            F[G] = E.style[G] || B[G] || null
        }
        return F
    },
    setStyle: function (A, B, C) {
        A.style[B] = C
    },
    setStyles: function (A, B) {
        var C = A.style;
        for (var D in B) {
            C[D] = B[D]
        }
    },
    getDimensions: function (E) {
        var G = Element.getStyle(E, "display");
        if (G && G != "none") {
            return {
                left: E.offsetLeft,
                top: E.offsetTop,
                width: E.offsetWidth,
                height: E.offsetHeight
            }
        }
        var B = E.style;
        var F = B.visibility;
        var C = B.position;
        var A = B.display;
        B.visibility = "hidden";
        B.position = "absolute";
        B.display = "block";
        var D = {
            width: E.offsetWidth,
            height: E.offsetHeight,
            left: E.offsetLeft,
            top: E.offsetTop
        };
        B.display = A;
        B.position = C;
        B.visibility = F;
        return D
    },
    set3PiecesBorderImage: function (G, B, E, J) {
        if (DC.Support.BorderImage) {
            G.style.borderWidth = B ? "0px " + J + "px 0px " + E + "px " : "0px";
            var K = B ? "url(" + B + ") 0 " + J + " 0 " + E + " repeat stretch" : "";
            G.style.webkitBorderImage = K;
            G.style.MozBorderImage = K
        } else {
            if (!B) {
                G.innerHTML = "";
                return
            }
            var A = document.createElement("div");
            var F = A.style;
            F.position = "absolute";
            F.top = "0px";
            F.bottom = "0px";
            var L = A.cloneNode(false);
            L.style.left = "0px";
            L.style.right = "0px";
            var C = A.cloneNode(false);
            var D = C.style;
            D.backgroundImage = "url(" + B + ")";
            D.backgroundRepeat = "no-repeat";
            var H = C.cloneNode(false);
            var I = H.style;
            D.left = "0px";
            D.width = E + "px";
            I.right = "0px";
            I.width = J + "px";
            I.backgroundPosition = "100% 0px";
            F.left = E + "px";
            F.right = J + "px";
            F.backgroundImage = "url(" + B.replace(/.png/, "__mid.png") + ")";
            F.backgroundRepeat = "repeat-x";
            if (G.firstChild) {
                G.insertBefore(L, G.firstChild)
            } else {
                G.appendChild(L)
            }
            L.appendChild(C);
            L.appendChild(A);
            L.appendChild(H)
        }
    },
    clone: function (A) {
        return A.cloneNode(true)
    },
    depthFirstTraversal: function (D, E, C) {
        if (!D || !E) {
            return
        }
        var A = D.nextSibling || D.parentNode;
        var B;
        C = C || E;
        while (D !== A) {
            if (1 === D.nodeType) {
                B = E.call(C, D);
                if (false !== B && D.firstChild) {
                    D = D.firstChild;
                    continue
                }
            }
            while (!D.nextSibling) {
                D = D.parentNode;
                if (D === A) {
                    return
                }
            }
            D = D.nextSibling
        }
    },
    query: function (B, A) {
        if (1 == arguments.length) {
            A = B;
            B = document
        } else {
            if (B != document) {
                A = "#" + Element.assignId(B) + " " + A
            }
        }
        return B.querySelector(A)
    },
    queryAll: function (B, A) {
        if (1 == arguments.length) {
            A = B;
            B = document
        } else {
            if (B != document) {
                A = "#" + Element.assignId(B) + " " + A
            }
        }
        return Array.from(B.querySelectorAll(A))
    },
    match: function (B, A) {
        return Sizzle.matches(A, [B]).length == 1
    },
    getViewport: function () {
        var B = document.documentElement;
        var A = document.body;
        return {
            left: window.scrollLeft || B.scrollLeft || A.scrollLeft,
            top: window.scrollTop || B.scrollTop || A.scrollTop,
            width: window.innerWidth || B.clientWidth || A.clientWidth,
            height: window.innerHeight | B.clientHeight || A.clientHeight
        }
    },
    scrollParent: function (F) {
        var E;
        var C = Element.getStyles;
        var A = document.body;
        while (F && F != A) {
            E = C(F, ["overflow", "overflowX", "overflowY"]);
            for (var B in E) {
                var D = E[B];
                if ("auto" == D || "scroll" == D) {
                    return F
                }
            }
            F = F.parentNode
        }
        return F
    },
    getRect: function (P, N) {
        if (!P) {
            return null
        }
        var R = document.documentElement;
        var M = document.body;
        var D = 0;
        var O = 0;
        if (P != document.body && P.getBoundingClientRect) {
            var L = P.getBoundingClientRect();
            L = {
                left: L.left,
                right: L.right,
                top: L.top,
                bottom: L.bottom
            };
            if ( !! N === false) {
                L.left += Math.max(R.scrollLeft, M.scrollLeft);
                L.right += Math.max(R.scrollLeft, M.scrollLeft);
                L.top += Math.max(R.scrollTop, M.scrollTop);
                L.bottom += Math.max(R.scrollTop, M.scrollTop)
            }
            L.left -= R.clientLeft;
            L.right -= R.clientLeft;
            L.top -= R.clientTop;
            L.bottom -= R.clientTop;
            L.width = L.right - L.left + 1;
            L.height = L.bottom - L.top + 1;
            return L
        }
        var J = P.parentNode;
        var F = P;
        var A = P.offsetParent;
        var K = DC.Browser.Mozilla;
        var Q = DC.Browser.Safari && !DC.Browser.Safari2;
        var B = DC.Browser.Safari2;
        var H = Element.getStyles;
        var G = Element.getDimensions(P);
        var C = ("fixed" === Element.getStyles(P, "position"));
        var I;
        D += P.offsetLeft;
        O += P.offsetTop;
        while (!C && A) {
            D += A.offsetLeft;
            O += A.offsetTop;
            if (K && !((/^t(able|d|h)$/i).test(A.tagName)) || Q) {
                I = H(A, ["borderLeftWidth", "borderTopWidth"]);
                D += parseInt(I.borderLeftWidth || 0, 10);
                O += parseInt(I.borderTopWidth || 0, 10)
            }
            if (!C) {
                C = ("fixed" === H(A, "position"))
            }
            if ("BODY" !== A.tagName) {
                F = A
            }
            A = A.offsetParent
        }
        var E = K ? ["display", "overflow", "borderLeftWidth", "borderTopWidth"] : ["display"];
        while (J && J.tagName && "BODY" !== J.tagName && "HTML" !== J.tagName) {
            I = H(J, E);
            if (!((/^inline|table.*$/i).test(I.display))) {
                D -= J.scrollLeft;
                O -= J.scrollTop
            }
            if (K && "visible" != I.overflow) {
                D += parseInt(I.borderLeftWidth || 0, 10);
                O += parseInt(I.borderTopWidth || 0, 10)
            }
            J = J.parentNode
        }
        var S = H(F, "position");
        if ((B && (C || S == "absolute")) || (K && S != "absolute")) {
            D -= M.offsetLeft;
            O -= M.offsetTop
        }
        if (N === true && !C) {
            D -= Math.max(R.scrollLeft, M.scrollLeft);
            O -= Math.max(R.scrollTop, M.scrollTop)
        }
        return {
            left: D,
            top: O,
            right: D + G.width - 1,
            bottom: O + G.height - 1,
            width: G.width,
            height: G.height
        }
    }
});
Element.getStyle = Element.getStyles;
Element.assignId.uniqueId = 1;
if (!DC.Support.QuerySelector) {
    Object.extend(Element, {
        query: function (B, A) {
            if (1 == arguments.length) {
                A = B;
                B = document
            }
            return (Sizzle(A, B)[0] || null)
        },
        queryAll: function (B, A) {
            if (1 == arguments.length) {
                A = B;
                B = document
            }
            return (Sizzle(A, B) || null)
        }
    })
}
if ("undefined" === typeof (document.documentElement.children)) {
    HTMLElement.prototype.__defineGetter__("children", function () {
        var B = [];
        var A = this.childNodes.length;
        var D;
        for (var C = 0; C < A; ++C) {
            D = this.childNodes[C];
            if (Node.ELEMENT_NODE !== D.nodeType) {
                continue
            }
            B.push(D)
        }
        return B
    })
}
if ("undefined" === typeof (document.documentElement.innerText)) {
    HTMLElement.prototype.__defineGetter__("innerText", function () {
        return this.textContent
    });
    HTMLElement.prototype.__defineSetter__("innerText", function (A) {
        this.textContent = A
    })
};
(function () {
    var A = this.Event;
    this.Event = {};
    Object.extend(this.Event, A || {})
}).call(window);
Object.extend(Event, {
    KEY_BACKSPACE: 8,
    KEY_TAB: 9,
    KEY_RETURN: 13,
    KEY_ESC: 27,
    KEY_LEFT: 37,
    KEY_UP: 38,
    KEY_RIGHT: 39,
    KEY_DOWN: 40,
    KEY_DELETE: 46,
    KEY_HOME: 36,
    KEY_END: 35,
    KEY_PAGEUP: 33,
    KEY_PAGEDOWN: 34,
    KEY_INSERT: 45,
    _domHasFinishedLoading: function () {
        if (arguments.callee.done) {
            return
        }
        arguments.callee.done = true;
        if (this._domLoadedTimer) {
            window.clearInterval(this._domLoadedTimer)
        }
        var C = Event._readyCallbacks;
        var A = C.length;
        var B;
        for (B = 0; B < A; ++B) {
            C[B]()
        }
        Event._readyCallbacks = null
    },
    observe: function (C, A, B) {
        if ("on" == A.slice(0, 2)) {
            A = A.slice(2)
        }
        C.addEventListener(A, B, false)
    },
    stopObserving: function (C, A, B) {
        if ("on" == A.slice(0, 2)) {
            A = A.slice(2)
        }
        C.removeEventListener(A, B, false)
    },
    stop: function (A) {
        A.preventDefault();
        A.stopPropagation()
    },
    preventDefault: function (A) {
        A.preventDefault()
    },
    onDomReady: function (A) {
        if (Event._domHasFinishedLoading.done) {
            window.setTimeout(A, 0);
            return
        }
        if (!Event._readyCallbacks) {
            document.addEventListener("DOMContentLoaded", Event._domHasFinishedLoading, false);

            function B() {
                if ((/loaded|complete/).test(document.readyState)) {
                    Event._domHasFinishedLoading()
                }
            }
            if (DC.Browser.Safari) {
                Event._domLoadedTimer = window.setInterval(B, 10)
            }
            Event.observe(window, "load", Event._domHasFinishedLoading);
            Event._readyCallbacks = []
        }
        Event._readyCallbacks.push(A)
    }
});
DC.PartFinder = (function () {
    function C(G, E) {
        var H = G.length;
        var D = Array.from(E);

        function I() {
            G = [];
            D = null;
            H = 0
        }
        function M(P) {
            G.splice(P, 1);
            if (D) {
                D.splice(P, 1)
            }
            H = G.length
        }
        function F(P) {
            var R = Element.assignId(P);
            var Q = G.indexOf(R);
            if (-1 == Q) {
                return
            }
            G.splice(Q, 1);
            if (D) {
                D.splice(Q, 1)
            }
            H = G.length
        }
        function O(R, Q) {
            var P = Element.assignId(R);
            G.splice(Q, 0, P);
            if (D) {
                D.splice(Q, 0, R)
            }
            H = G.length
        }
        function N(P) {
            G.push(Element.assignId(P));
            H = G.length;
            if (D) {
                D.push(P)
            }
        }
        function K() {
            D = null
        }
        function J() {
            var R = [];
            var P;
            for (var Q = 0; Q < H; ++Q) {
                P = document.getElementById(G[Q]);
                if (!P) {
                    continue
                }
                R.push(G[Q])
            }
            G = R;
            H = R.length;
            D = null
        }
        function L(R) {
            if (D) {
                if (1 == arguments.length) {
                    return D[R]
                }
                return D
            }
            if (1 == arguments.length) {
                return document.getElementById(G[R])
            }
            var P = [];
            for (var Q = 0; Q < H; ++Q) {
                P[Q] = document.getElementById(G[Q])
            }
            D = P;
            window.setTimeout(K, 250);
            return P
        }
        if (E) {
            window.setTimeout(K, 250)
        }
        L.removePartAtIndex = M;
        L.removePart = F;
        L.insertPartAtIndex = O;
        L.add = N;
        L.removeAll = I;
        L.refresh = J;
        return L
    }
    function A(G, E) {
        var D = E;

        function F() {
            D = null
        }
        function H() {
            if (D) {
                return D
            }
            D = document.getElementById(G);
            window.setTimeout(F, 250);
            return D
        }
        return H
    }
    function B(E, D) {
        var F = Element.queryAll(E, D);
        var G = Array.map(F, Element.assignId);
        return {
            nodes: F,
            ids: G
        }
    }
    return {
        singlePart: function (E, D) {
            function F() {
                var K = D;
                var G = typeof (K);
                if ("function" === G) {
                    K = K()
                } else {
                    if ("string" === G) {
                        K = document.getElementById(K)
                    } else {
                        if (!K) {
                            K = this.viewElement()
                        }
                    }
                }
                var H = B(K, E);
                var J = A(H.ids[0], H.nodes[0]);
                var I = Class.findPropertyName(this, arguments.callee);
                if (I) {
                    this[I] = J
                }
                return H.nodes[0]
            }
            return F
        },
        multipleParts: function (E, D) {
            function F(I) {
                var L = D;
                var G = typeof (L);
                if ("function" === G) {
                    L = L()
                } else {
                    if ("string" === G) {
                        L = document.getElementById(L)
                    } else {
                        if (!L) {
                            L = this.viewElement()
                        }
                    }
                }
                var H = B(L, E);
                var K = C(H.ids, H.nodes);
                var J = Class.findPropertyName(this, arguments.callee);
                if (J) {
                    this[J] = K
                }
                if (arguments.length) {
                    return H.nodes[I]
                } else {
                    return Array.from(H.nodes)
                }
            }
            return F
        }
    }
})();
var Part = DC.PartFinder.singlePart;
var PartList = DC.PartFinder.multipleParts;
DC.Style = {
    kSelectedClass: "selected",
    kDisabledClass: "disabled",
    kReadOnlyClass: "read-only",
    kMarkerClass: "nullValue",
    kFocusClass: "focused",
    kHoverClass: "hover",
    kAscendingClass: "asc",
    kDescendingClass: "desc",
    kActiveClass: "active",
    kUpdatingClass: "updating",
    kFadingClass: "invisible",
    kInvalidValueClass: "invalid",
    kInsertedClass: "inserted",
    kDeletedClass: "deleted",
    kReplacingClass: "replacing",
    kLoadingClass: "loading",
    kFirstClass: "first",
    kLastClass: "last"
};
DC.Style.__styles = (function () {
    var A = [];
    var B = DC.Style;
    for (var C in B) {
        A.push(B[C])
    }
    return A
})();
window.FIRST_RESPONDER = "__first_responder__";
DC.Responder = Class.create(DC.Bindable, {
    sendActionToView: function (B, A) {
        if (FIRST_RESPONDER === A) {
            A = DC.page.firstResponder
        }
        var C = A || DC.page.firstResponder || this;
        while (C) {
            if (B in C) {
                C[B](this);
                return true
            }
            C = C.nextResponder()
        }
        return false
    },
    acceptsFirstResponder: function () {
        return false
    },
    becomeFirstResponder: function () {
        return true
    },
    resignFirstResponder: function () {
        return true
    },
    nextResponder: function () {
        return this.__nextResponder || null
    },
    setNextResponder: function (A) {
        this.__nextResponder = A
    },
    presentError: function (B) {
        this.willPresentError(B);
        if (!("field" in B)) {
            B.field = this
        }
        var A = this.nextResponder();
        if (A) {
            return A.presentError(B)
        }
        return false
    },
    clearAllErrors: function (B) {
        var A = this.nextResponder();
        if (A) {
            A.clearAllErrors(B || this)
        }
    },
    willPresentError: function (A) {},
    onmousedown: function (A) {
        var B = this.nextResponder();
        if (B) {
            B.onmousedown(A)
        }
    },
    onmouseup: function (A) {
        var B = this.nextResponder();
        if (B) {
            B.onmouseup(A)
        }
    },
    onmousedrag: function (A) {
        var B = this.nextResponder();
        if (B) {
            B.onmousedrag(A)
        }
    },
    onmouseenter: function (A) {
        var B = this.nextResponder();
        if (B) {
            B.onmouseenter(A)
        }
    },
    onmouseleave: function (A) {
        var B = this.nextResponder();
        if (B) {
            B.onmouseleave(A)
        }
    },
    onclick: function (A) {
        var B = this.nextResponder();
        if (B) {
            B.onclick(A)
        }
    },
    ondblclick: function (A) {
        var B = this.nextResponder();
        if (B) {
            B.ondblclick(A)
        }
    },
    onkeydown: function (A) {
        var B = this.nextResponder();
        if (B) {
            B.onkeydown(A)
        }
    },
    onkeyup: function (A) {
        var B = this.nextResponder();
        if (B) {
            B.onkeyup(A)
        }
    },
    onkeypress: function (A) {
        var B = this.nextResponder();
        if (B) {
            B.onkeypress(A)
        }
    },
    ontouchstart: function (A) {
        var B = this.nextResponder();
        if (B) {
            B.ontouchstart(A)
        }
    },
    ontouchmove: function (A) {
        var B = this.nextResponder();
        if (B) {
            B.ontouchmove(A)
        }
    },
    ontouchend: function (A) {
        var B = this.nextResponder();
        if (B) {
            B.ontouchend(A)
        }
    },
    onswipe: function (A) {
        var B = this.nextResponder();
        if (B) {
            B.onswipe(A)
        }
    }
});
DC.View = Class.create(DC.Responder, {
    exposedBindings: ["visible", "class", "enabled", "editable", "html", "text"],
    defaultPlaceholders: {
        text: {
            multipleValues: _("marker.text.multipleValues"),
            nullValue: _("marker.text.placeholder"),
            noSelection: _("marker.text.noSelection")
        },
        html: {
            multipleValues: _("marker.text.multipleValues"),
            nullValue: _("marker.text.placeholder"),
            noSelection: _("marker.text.noSelection")
        }
    },
    automaticallySetupBindings: false,
    formatter: null,
    target: null,
    action: null,
    sendActionOn: ["click"],
    animated: false,
    updateAnimationDuration: 0,
    updateAnimationDelay: 0,
    postUpdateAnimationDuration: 0,
    postUpdateAnimationDelay: 0,
    preUpdateAnimationDuration: 0,
    preUpdateAnimationDelay: 0,
    constructor: function (A, B, C) {
        this.base(C);
        if ("string" === typeof (A)) {
            this.id = A;
            this.__view = document.getElementById(A)
        } else {
            this.id = Element.assignId(A);
            this.__view = A
        }
        if ("object" === DC.typeOf(B) && !("addObserverForKeyPath" in B)) {
            DC.KVO.adaptTree(B)
        }
        this.__relativeSource = B;
        if (this.id in DC.View.viewLookup) {
            throw new Error("Two views share the same ID: " + this.id)
        }
        this.viewElement().object = this;
        this.__updating = null;
        DC.View.viewLookup[this.id] = this
    },
    __postConstruct: function () {
        var B = this;

        function C() {
            if (DC.Browser.IE) {
                delete B.__view;
                delete B.__container
            }
        }
        C.delay(250);
        var A = this.viewElement();
        if (A) {
            this.__init()
        } else {
            Event.onDomReady(this.__init.bind(this))
        }
    },
    __init: function () {
        this.__initialising = true;
        var F = this.viewElement();
        if (!F) {
            throw new Error("Unable to locate node with ID: " + this.id)
        }
        this.viewElement = function () {
            return F
        };
        var G;
        var A;
        var B = F.getAttribute("__parametersId");
        var H = this.__parameters || DC.View.nodeParameters[B] || {};
        this.__copyParameters(H);
        if (this.innerHTML && "" === String(F.innerHTML).trim()) {
            F.innerHTML = this.innerHTML
        }
        var I = DC.dataModel;
        var C = this.__context;
        DC.dataModel = this.__context = this;
        var D = this.structure() || {};
        var E = {};
        for (A in D) {
            G = D[A];
            if (G && "function" == typeof (G) && (G = G.valueOf()).__factoryFn__) {
                E[A] = G;
                G.call(this, A, true)
            }
        }
        for (A in E) {
            E[A].call(this, A, false)
        }
        this.__context = C;
        DC.dataModel = I;
        this.setupBindings();
        this.init();
        this.initFromDOM();
        this.updateBindings();
        this.createObservers();
        delete this.__initialising;
        delete this.viewElement
    },
    teardown: function () {
        for (var A in this.bindings) {
            this.bindings[A].unbind()
        }
        if (this.viewElement()) {
            this.viewElement().object = null
        }
        if (!DC.Browser.IE) {
            delete this.__view;
            delete this.__container
        }
        delete DC.View.viewLookup[this.id]
    },
    __factory__: function (D, I, A) {
        var G = this;
        var F = Element.queryAll;
        var E = false;
        if ("string" !== typeof (D)) {
            A = I;
            I = D;
            D = null
        }
        I = I || {};
        var H = "parameters_" + DC.generateUid();
        DC.View.nodeParameters[H] = I;
        I.viewClass = G;

        function C(K) {
            K.setAttribute("__parametersId", H);
            var J;
            if ("sortKey" in I) {
                K.setAttribute("sortKey", I.sortKey)
            }
        }
        function B(K) {
            if (!E) {
                C(K)
            }
            var L = this.__relativeSource || this;
            var J = DC.View.fromNode(K) || new G(K, L);
            DC.View.createViewsForNodeTree(K, L, this.__context)
        }
        return function (L, K) {
            if (L && 1 === L.nodeType) {
                return new G(L, K, I)
            }
            var M = A || (this ? this.viewElement() : document);
            var J = F(M, D || L);
            if (!J.length) {
                return null
            }
            if ("action" in I) {
                if (!I.target) {
                    I.target = this
                }
                if (FIRST_RESPONDER !== I.target && "string" === typeof (I.action)) {
                    I.action = (I.target)[I.action]
                }
            }
            Array.forEach(J, K ? C : B, this);
            E = true;
            return DC.View.fromNode(J[0])
        }
    },
    init: function () {},
    initFromDOM: function () {},
    structure: function () {
        return this.__structure__
    },
    viewElement: function () {
        return this.__view || document.getElementById(this.id)
    },
    container: function () {
        return this.__container || this.__view || document.getElementById(this.__containerId || this.id)
    },
    setContainer: function (A) {
        if (this.__view) {
            this.__container = A
        }
        this.__containerId = Element.assignId(A);
        return A
    },
    superview: function () {
        var B = this.viewElement();
        if (!B) {
            return null
        }
        var A = null;
        while (B && !A) {
            B = B.parentNode;
            if (!B) {
                return null
            }
            if (document == B) {
                return DC.page
            }
            A = DC.View.fromNode(B)
        }
        return A
    },
    isDescendantOf: function (B) {
        if (!B) {
            return false
        }
        var A = B.viewElement();
        var C = this.viewElement();
        while (C && C !== document.body) {
            if (C.id == A.id) {
                return true
            }
            C = C.parentNode
        }
        return false
    },
    nextResponder: function () {
        return this.__nextResponder || this.superview()
    },
    focus: function () {
        var A = this.viewElement();
        A.focus()
    },
    blur: function () {
        var A = this.viewElement();
        A.blur()
    },
    sendAction: function () {
        var B = DC.EventLoop.currentEvent;
        if (!this.action) {
            return
        }
        if (FIRST_RESPONDER !== this.target || "string" !== typeof (this.action)) {
            this.action.call(this.target || this.action, this, B);
            return
        }
        var A = DC.page.firstResponder || this;
        var C = this.action;
        while (A) {
            if (C in A) {
                A[C](this, B);
                return
            }
            A = A.nextResponder()
        }
    },
    onclick: function (A) {
        if (this.disabled) {
            Event.stop(A);
            return
        }
        if (this.action && this.sendActionOn.containsObject("click")) {
            this.sendAction();
            Event.stop(A)
        } else {
            this.base(A)
        }
    },
    addTrackingInfo: function (A) {
        DC.page.addTrackingInfo(this.id, A)
    },
    observeVisibleChange: function (F, E, B) {
        var A = this.viewElement();
        var D = DC.Style.kFadingClass;

        function C() {
            A.style.display = "none";
            Element.removeClassName(A, D)
        }
        if (!this.animated) {
            A.style.display = (F.newValue ? "" : "none")
        } else {
            if (F.newValue) {
                if (A.style.display !== "") {
                    Element.addClassName(A, D);
                    A.style.display = ""
                }
                DC.Animator.removeClassName(A, D, {
                    duration: this.updateAnimationDuration || 300
                })
            } else {
                DC.Animator.addClassName(A, D, {
                    duration: this.updateAnimationDuration || 300,
                    callback: C
                })
            }
        }
    },
    observeEnabledChange: function (B) {
        var A = this.viewElement();
        this.disabled = A.disabled = !B.newValue;
        if (A.disabled) {
            Element.addClassName(A, DC.Style.kDisabledClass)
        } else {
            Element.removeClassName(A, DC.Style.kDisabledClass)
        }
    },
    observeEditableChange: function (B) {
        var A = this.viewElement();
        A.readOnly = !B.newValue;
        if (A.readOnly) {
            Element.addClassName(A, DC.Style.kReadOnlyClass)
        } else {
            Element.removeClassName(A, DC.Style.kReadOnlyClass)
        }
    },
    observeClassChange: function (H, G, D) {
        var A = this.viewElement();
        var C = $S(A.className.split(" "));
        var F = $S((H.newValue || "").split(" "));

        function E(I) {
            if (I in C) {
                Set.add(F, I)
            }
        }
        DC.Style.__styles.forEach(E);
        var B = Set.join(F, " ");
        if (this.animated) {
            DC.Animator.setClassName(A, B, {
                duration: 500
            })
        } else {
            A.className = B
        }
    },
    _beginUpdate: function (B, A) {
        if (B) {
            B.call(this)
        }
    },
    observeTextChange: function (G, F, C) {
        var B = this.viewElement();
        var A = this.bindings.text && this.bindings.text.markerType;
        var E = G.newValue;
        if (A) {
            if (null === E || "undefined" === typeof (E)) {
                E = ""
            }
            Element.addClassName(B, DC.Style.kMarkerClass)
        } else {
            Element.removeClassName(B, DC.Style.kMarkerClass);
            if (this.formatter) {
                E = this.formatter.stringFromValue(E)
            }
        }
        function D() {
            var H = document.createTextNode(E);
            B.innerHTML = "";
            B.appendChild(H)
        }
        this._beginUpdate(D)
    },
    observeHtmlChange: function (G, F, C) {
        var B = this.viewElement();
        var A = this.bindings.html && this.bindings.html.markerType;
        var E = G.newValue;
        if (A) {
            if (null === E || "undefined" === typeof (E)) {
                E = ""
            }
            Element.addClassName(B, DC.Style.kMarkerClass)
        } else {
            Element.removeClassName(B, DC.Style.kMarkerClass);
            if (this.formatter) {
                E = this.formatter.stringFromValue(E)
            }
        }
        function D() {
            B.innerHTML = E
        }
        this._beginUpdate(D)
    },
    removeChild: function (A) {
        if (!A) {
            return null
        }
        DC.View.teardownViewsForNodeTree(A);
        if (this.beforeRemoveElement) {
            this.beforeRemoveElement(A)
        }
        return A.parentNode.removeChild(A)
    },
    clonedFrom: function (A) {}
});
DC.View.nodeParameters = {};
DC.View.viewLookup = {};
DC.View.__subclassCreated__ = function (A) {
    var B = A.prototype;
    var C = A.superclass.prototype;
    if (B.__structure__ !== C.__structure__) {
        Object.applyDefaults(B.__structure__, C.__structure__)
    }
};
DC.View.viewClassForNode = function (B, A) {
    var C = B.getAttribute("__parametersId");
    if (!C) {
        return null
    }
    return DC.View.nodeParameters[C].viewClass
};
DC.View.createViewForNode = function (C, E, B) {
    var A = DC.View.fromNode(C);
    if (A) {
        return A
    }
    var D = DC.View.viewClassForNode(C, B);
    return new(D || DC.View)(C, E, B)
};
DC.View.fromNode = function (A) {
    var B = DC.View.viewLookup;
    var C = null;
    if (DC.typeOf(A) == "string") {
        C = A
    } else {
        if ("id" in A) {
            C = A.id
        }
    }
    if (!B || !C || !B[C]) {
        return null
    }
    return B[C]
};
DC.View.rebindNodeTreeWithRelativeSource = function (B, D, C) {
    function A(F) {
        var E = DC.View.fromNode(F);
        if (!E || (D && E.__relativeSource !== D)) {
            return
        }
        E.__relativeSource = C;
        E.setupBindings();
        E.updateBindings()
    }
    Element.depthFirstTraversal(B, A)
};
DC.View.unbindNodeTree = function (B) {
    function A(D) {
        var C = DC.View.fromNode(D);
        if (!C) {
            return
        }
        C.unbind()
    }
    Element.depthFirstTraversal(B, A)
};
DC.View.createViewsForNodeTree = function (E, C, D) {
    function B(F) {
        if (DC.View.fromNode(F)) {
            return
        }
        var G = DC.View.viewClassForNode(F);
        if (!G) {
            return
        }
        new(G)(F, C, DC.DashcodePart.PropertiesForNode(F))
    }
    var A = DC.dataModel;
    if (D) {
        DC.dataModel = D
    }
    Element.depthFirstTraversal(E || document.body, B);
    if (D) {
        DC.dataModel = A
    }
};
DC.View.teardownViewsForNodeTree = function (A) {
    function B(D) {
        var C = DC.View.fromNode(D);
        if (!C) {
            return
        }
        C.teardown()
    }
    Element.depthFirstTraversal(A || document.body, B)
};
DC.View.cloneViewsForTreeNode = function (D, A, C) {
    var F = {};
    var B = Element.clone(D);

    function E(K) {
        var G = K.id;
        if (K == D && !G) {
            G = D.id
        }
        if (G) {
            F[G] = K
        }
        K.originalID = G;
        K.id = "";
        var H = DC.View.fromNode(G);
        var I = DC.View.viewClassForNode(K);
        var J = null;
        if (!I || K.object) {
            return true
        }
        J = new(I)(K, A, DC.DashcodePart.PropertiesForNode(K));
        if (H && J) {
            J.clonedFrom(H)
        }
        return true
    }
    Element.depthFirstTraversal(B, E);
    if (!B.object) {
        B.object = {}
    }
    B.object.templateElements = F;
    return B
};
DC.DashcodePart = Class.create(DC.View, {
    maskedBindings: ["html", "text"],
    constructor: function (A, C, D, B) {
        if (!B && (A.id || A.originalID) && dashcodePartSpecs) {
            B = dashcodePartSpecs[A.originalID ? A.originalID : A.id];
            if (B && !D && !dashcode.inDesign) {
                D = B.propertyValues
            }
        }
        if (A.object) {
            return
        }
        this.base(A, C, D);
        this._registerForDocumentInsertionNotifcationIfNeeded();
        this.partSetup(B)
    },
    partSetup: function (A) {},
    _sendLegacyOnClick: function (D, C, E) {
        var B = this;
        this._savedOnClick = C.onclick;
        C.onclick = function (F) {
            E(F);
            C.onclick = B._savedOnClick;
            delete B._savedOnClick
        };
        if (document.createEvent) {
            var A = document.createEvent("MouseEvents");
            A.initMouseEvent("click", false, false, window, 1, D ? D.screenX : 0, D ? D.screenY : 0, D ? D.clientX : 0, D ? D.clientY : 0, D ? D.ctrlKey : false, D ? D.altKey : false, D ? D.shiftKey : false, D ? D.metaKey : false, D ? D.button : 0, null);
            C.dispatchEvent(A)
        } else {
            C.onclick(D)
        }
    },
    _setOnClickAsAction: function (C, B) {
        var A = this;
        if (!B) {
            B = this.viewElement()
        }
        if (C) {
            this.action = function (D, E) {
                A._sendLegacyOnClick(E, B, C)
            }
        } else {
            this.action = null
        }
    },
    insertedIntoDocument: function () {},
    _registerForDocumentInsertionNotifcationIfNeeded: function () {
        var D = this.viewElement();
        var C = D;
        var A = D.ownerDocument;
        while (D.parentNode) {
            C = D;
            D = D.parentNode
        }
        if (D == A) {
            return false
        }
        var B = this;
        Event.observe(C, "DOMNodeInsertedIntoDocument", function (E) {
            B.insertedIntoDocument()
        })
    },
    observeEnabledChange: function (A) {
        if (this.__initialising && (null === A.newValue || "undefined" === A.newValue)) {
            this.bindings.enabled.setValue(!this.valueForKey("enabled"));
            return
        }
        this.setValueForKey(A.newValue, "enabled")
    }
});
DC.DashcodePart.PropertiesForNode = function (B) {
    if (dashcode.inDesign) {
        return undefined
    }
    if ((B.id || B.originalID) && dashcodePartSpecs) {
        var A = dashcodePartSpecs[B.originalID ? B.originalID : B.id];
        if (A) {
            return A.propertyValues
        }
    }
    return undefined
};
DC.DashcodePart.updateViewId = function (C, B) {
    var A = DC.View.fromNode(C);
    A.id = B;
    delete DC.View.viewLookup[C];
    DC.View.viewLookup[B] = A
};
DC.Text = Class.create(DC.DashcodePart, {
    exposedBindings: ["text", "html"],
    partSetup: function (A) {
        if (A.text) {
            var B = A.text;
            if (window.dashcode && dashcode.getLocalizedString) {
                B = dashcode.getLocalizedString(B)
            }
            this.viewElement().innerText = B
        }
    }
});
DC.DashcodeOverrides = {
    Original: {
        View: {
            createViewForNode: DC.View.createViewForNode,
            viewClassForNode: DC.View.viewClassForNode
        },
        Binding: {
            bindingFromString: DC.Binding.bindingFromString
        }
    },
    Replacement: {
        View: {
            createViewForNode: function (B, C, A) {
                return DC.DashcodeOverrides.Original.View.createViewForNode(B, C, A)
            },
            viewClassForNode: function (node, hasBindings) {
                var viewClass = undefined;
                if (node && (node.originalID || node.id)) {
                    var spec = dashcodePartSpecs[node.originalID ? node.originalID : node.id];
                    if (spec && spec.view) {
                        try {
                            viewClass = eval(spec.view)
                        } catch (e) {}
                    }
                    if (spec && spec.hasBindings) {
                        if (!hasBindings) {
                            hasBindings = true
                        }
                    }
                }
                if (!viewClass) {
                    viewClass = DC.DashcodeOverrides.Original.View.viewClassForNode(node, hasBindings)
                }
                return viewClass
            }
        },
        Binding: {
            bindingFromString: function (B, A) {
                if (DC.DashcodeOverrides.bindToContent && (A instanceof DC.ObjectController)) {
                    if ((B.substr(0, 7) != "content")) {
                        B = "content." + B
                    }
                }
                return DC.DashcodeOverrides.Original.Binding.bindingFromString(B, A)
            }
        }
    }
};
DC.View.viewClassForNode = DC.DashcodeOverrides.Replacement.View.viewClassForNode;
DC.Binding.bindingFromString = DC.DashcodeOverrides.Replacement.Binding.bindingFromString;
DC.EventLoop = {
    currentEvent: null,
    getStart: function () {
        if (!this._start) {
            this._start = new Date().getTime()
        }
        return this._start
    },
    begin: function (A) {
        this._start = new Date().getTime();
        this.currentEvent = A
    },
    end: function () {
        this.currentEvent = null;
        this._start = null
    }
};
DC.Page = Class.create(DC.Responder, {
    focusedElement: null,
    constructor: function () {
        this.firstResponder = null;
        this.__hoverTrackingIds = {};
        this._onmousedragHandler = this._onmousedrag.bindAsEventListener(this);
        this._delegates = {
            click: []
        };
        this.onclick = this._fireDelegates
    },
    targetViewForEvent: function (C) {
        var B = C.target || C.srcElement;
        var A;
        var D = DC.View.fromNode;
        while (B && B != document && !(A = D(B))) {
            B = B.parentNode
        }
        if (!B || B == document) {
            return null
        }
        return A
    },
    makeFirstResponder: function (A) {
        if (this.firstResponder == A) {
            return true
        }
        if (this.firstResponder && !this.firstResponder.resignFirstResponder()) {
            return false
        }
        if (this.firstResponder) {
            Element.removeClassName(this.firstResponder.viewElement(), DC.Style.kFocusClass)
        }
        if (A && !A.becomeFirstResponder()) {
            return false
        }
        this.willChangeValueForKey("firstResponder");
        this.firstResponder = A;
        this.didChangeValueForKey("firstResponder");
        if (A) {
            A.focus();
            Element.addClassName(A.viewElement(), DC.Style.kFocusClass)
        }
        return true
    },
    addTrackingInfo: function (C, B) {
        if ("string" !== typeof (C)) {
            C = Element.assignId(C)
        }
        var A = this.__hoverTrackingIds[C];
        if (!A) {
            A = this.__hoverTrackingIds[C] = []
        }
        A.push(B)
    },
    superview: function () {
        return null
    },
    presentError: function (A) {
        function B() {
            var C = A.description;
            if (A.recoverySuggestion) {
                C += "\n" + A.recoverySuggestion
            }
            window.alert(C);
            DC.page.makeFirstResponder(A.field)
        }
        B.delay(0)
    },
    delegate: function (A, C, B) {
        if ("string" === typeof (C)) {
            this._delegates[C].push({
                sel: A,
                fn: B
            })
        } else {
            var D;
            for (D in C) {
                if (!(D in this._delegates)) {
                    throw new Error("Invalid delegation event type: " + D)
                }
                this._delegates[D].push({
                    sel: A,
                    fn: C[D]
                })
            }
        }
    },
    superview: function () {
        return null
    },
    _fireDelegates: function (E) {
        var C = E.target || E.srcElement;
        var B = Element.match;
        var A = this._delegates[E.type] || [];

        function D(F) {
            if (B(C, F.sel)) {
                F.fn(E)
            }
        }
        A.forEach(D)
    },
    _findFirstResponder: function (A) {
        while (A && !A.acceptsFirstResponder()) {
            A = A.superview()
        }
        if (!A) {
            return
        }
        this.makeFirstResponder(A)
    },
    _onmousedown: function (B) {
        var A = this.targetViewForEvent(B);
        if (A) {
            this._findFirstResponder(A);
            A.onmousedown(B);
            Event.observe(document, "mousemove", this._onmousedragHandler)
        }
        this._mousedownView = A
    },
    _onmouseup: function (A) {
        if (this._mousedownView) {
            this._mousedownView.onmouseup(A)
        }
        Event.stopObserving(document, "mousemove", this._onmousedragHandler)
    },
    _onmousedrag: function (A) {
        if (this._mousedownView) {
            this._mousedownView.onmousedrag(A)
        }
    },
    _onmouseover: function (A) {
        var E = this.__hoverTrackingIds || {};
        var L = this.__mouseOverIds || {};
        var C = {};
        var H = A.target || A.srcElement;
        var F = document.body;
        var I;
        var K;
        var B;
        var D;
        var G;
        var J;
        for (; H && H != F; H = H.parentNode) {
            B = H.id;
            if (!B || !(B in E)) {
                continue
            }
            C[B] = true;
            if (B in L) {
                continue
            }
            I = E[B];
            G = I.length;
            for (D = 0; D < G; ++D) {
                J = I[D];
                if (J.onmouseenter) {
                    J.onmouseenter.call(J.owner, H, J.ownerInfo)
                }
            }
        }
        for (B in L) {
            if (B in C) {
                continue
            }
            H = document.getElementById(B);
            if (!H) {
                continue
            }
            I = E[B];
            G = I.length;
            for (D = 0; D < G; ++D) {
                J = I[D];
                if (J.onmouseleave) {
                    J.onmouseleave.call(J.owner, H, J.ownerInfo)
                }
            }
        }
        this.__mouseOverIds = C
    },
    _onmouseout: function (A) {},
    _onclick: function (B) {
        if (DC.Browser.Mozilla && B.button === 2) {
            return
        }
        var A = this.targetViewForEvent(B);
        if (A) {
            A.onclick(B)
        } else {
            this._fireDelegates(B)
        }
    },
    _ondblclick: function (A) {
        if (this._mousedownView) {
            this._mousedownView.ondblclick(A)
        }
    },
    _onkeydown: function (A) {
        var B = this.firstResponder;
        if (B) {
            B.onkeydown(A)
        }
    },
    _onkeyup: function (A) {
        var B = this.firstResponder;
        if (B) {
            B.onkeyup(A)
        }
    },
    _onkeypress: function (A) {
        var B = this.firstResponder;
        if (B) {
            B.onkeypress(A)
        }
    },
    _onfocus: function (B) {
        var C = (B.target || B.srcElement) == window;
        if (DC.Browser.IE) {
            if (document.activeElement == this.focusedElement) {
                C = true
            }
        }
        if (C) {
            if (!this._documentFocused) {
                this.makeFirstResponder(this._previousFirstResponder || null);
                this._previousFirstResponder = null;
                this._documentFocused = true;
                if (!dashcode.inDesign && document.body) {
                    Element.removeClassName(document.body, "DC_windowInactive")
                }
            }
        } else {
            var A = this.targetViewForEvent(B);
            if (A && A.acceptsFirstResponder()) {
                this.makeFirstResponder(A)
            } else {
                this.makeFirstResponder(null)
            }
            this.focusedElement = B.target || B.srcElement
        }
    },
    _onblur: function (B) {
        var C = (B.target || B.srcElement) == window;
        if (DC.Browser.IE) {
            if (document.activeElement == this.focusedElement) {
                C = true
            }
        }
        if (C) {
            this._documentFocused = false;
            this._previousFirstResponder = this.firstResponder;
            this.makeFirstResponder(null);
            if (!dashcode.inDesign && document.body) {
                Element.addClassName(document.body, "DC_windowInactive")
            }
        } else {
            var A = this.targetViewForEvent(B);
            this.focusedElement = null;
            if (A && A.acceptsFirstResponder()) {
                this.makeFirstResponder(null)
            }
        }
    },
    _ontouchstart: function (C) {
        var A = this.targetViewForEvent(C);
        if (A) {
            var B = this;
            A.ontouchstart(C);
            this._touchstartMouseDownDelay = window.setTimeout(function () {
                A.onmousedown(C);
                B._touchsentMD = true;
                delete B._touchstartMouseDownDelay
            }, 100)
        }
        this._touchstartView = A;
        this._touchmovedX = false;
        this._touchmovedY = false;
        this._touchsentMD = false;
        this._touchstartX = C.targetTouches[0].clientX;
        this._touchstartY = C.targetTouches[0].clientY
    },
    _ontouchmove: function (D) {
        var A = D.targetTouches[0].clientX;
        var E = D.targetTouches[0].clientY;
        var B = false;
        var C = false;
        if (!this._touchmovedX && Math.abs(this._touchstartX - A) > 5) {
            B = this._touchmovedX = true
        }
        if (!this._touchmovedY && Math.abs(this._touchstartY - E) > 5) {
            C = this._touchmovedY = true
        }
        if (this._touchstartView) {
            this._touchstartView.ontouchmove(D);
            if (this._touchstartMouseDownDelay) {
                window.clearTimeout(this._touchstartMouseDownDelay);
                delete this._touchstartMouseDownDelay
            }
            if (B || C) {
                if (this._touchsentMD) {
                    this._touchstartView.onmouseup(D);
                    this._touchsentMD = false
                }
                if (!this._touchmovedY && B) {
                    this._touchstartView.onswipe(D)
                }
            }
        }
    },
    _ontouchend: function (A) {
        if (this._touchstartView) {
            this._touchstartView.ontouchend(A);
            if (this._touchstartMouseDownDelay) {
                var B = this._touchstartView;
                window.clearTimeout(this._touchstartMouseDownDelay);
                delete this._touchstartMouseDownDelay;
                this._touchstartView.onmousedown(A);
                this._touchsentMD = true;
                setTimeout(function () {
                    B.onmouseup(A);
                    B.onclick(A)
                }, 0)
            } else {
                if (this._touchsentMD) {
                    this._touchstartView.onmouseup(A);
                    if (!this._touchmovedX && !this._touchmovedY) {
                        this._touchstartView.onclick(A)
                    }
                }
            }
        }
    },
    _ontouchcancel: function (A) {
        if (this._touchstartView) {
            this._touchstartView.ontouchend(A);
            if (this._touchstartMouseDownDelay) {
                window.clearTimeout(this._touchstartMouseDownDelay);
                delete this._touchstartMouseDownDelay
            } else {
                if (this._touchsentMD) {
                    this._touchstartView.onmouseup(A)
                }
            }
        }
    },
    _onunload: function () {
        var B;
        var A = DC.View.viewLookup;
        for (B in A) {
            A[B].teardown();
            delete A[B]
        }
    }
});
(function () {
    DC.page = new DC.Page();
    window._setTimeout = window.setTimeout;
    window.setTimeout = function (F, E) {
        if (!F) {
            return null
        }
        if ("string" === typeof (F)) {
            F = "DC.EventLoop.begin();do {" + F + "} while (false); DC.EventLoop.end();";
            return window._setTimeout(F, E)
        }
        var D = Array.from(arguments, 2);

        function C() {
            DC.EventLoop.begin();
            var G = F.apply(this, D);
            DC.EventLoop.end();
            return G
        }
        return window._setTimeout(C, E)
    };
    window._setInterval = window.setInterval;
    window.setInterval = function (F, E) {
        if (!F) {
            return null
        }
        if ("string" === typeof (F)) {
            F = "DC.EventLoop.begin();do {" + F + "} while (false); DC.EventLoop.end();";
            return window._setInterval(F, E)
        }
        var D = Array.from(arguments, 2);

        function C() {
            DC.EventLoop.begin();
            var G = F.apply(this, D);
            DC.EventLoop.end();
            return G
        }
        return window._setInterval(C, E)
    };
    var B = DC.page;
    var A;
    if (DC.Browser.IE) {
        A = function (C) {
            return function () {
                DC.EventLoop.begin(window.event);
                B[C](window.event);
                DC.EventLoop.end()
            }
        };
        document.attachEvent("onmouseover", A("_onmouseover"));
        document.attachEvent("onmouseout", A("_onmouseout"));
        document.attachEvent("onmousedown", A("_onmousedown"));
        document.attachEvent("onmouseup", A("_onmouseup"));
        document.attachEvent("onclick", A("_onclick"));
        document.attachEvent("ondblclick", A("_ondblclick"));
        document.attachEvent("onkeydown", A("_onkeydown"));
        document.attachEvent("onkeyup", A("_onkeyup"));
        document.attachEvent("onkeypress", A("_onkeypress"));
        document.attachEvent("onfocusin", A("_onfocus"));
        document.attachEvent("onfocusout", A("_onblur"));
        window.attachEvent("focus", A("_onfocus"));
        window.attachEvent("blur", A("_onblur"));
        window.attachEvent("onunload", A("_onunload"))
    } else {
        A = function (C) {
            return function (D) {
                DC.EventLoop.begin(D);
                B[C](D);
                DC.EventLoop.end()
            }
        };
        document.addEventListener("keydown", A("_onkeydown"), false);
        document.addEventListener("keyup", A("_onkeyup"), false);
        document.addEventListener("keypress", A("_onkeypress"), false);
        document.addEventListener("focus", A("_onfocus"), true);
        document.addEventListener("blur", A("_onblur"), true);
        window.addEventListener("focus", A("_onfocus"), false);
        window.addEventListener("blur", A("_onblur"), false);
        if (!DC.Browser.MobileSafari) {
            document.addEventListener("click", A("_onclick"), false);
            document.addEventListener("dblclick", A("_ondblclick"), false)
        }
        if (DC.Support.Touches) {
            document.addEventListener("touchstart", A("_ontouchstart"), true);
            document.addEventListener("touchmove", A("_ontouchmove"), true);
            document.addEventListener("touchend", A("_ontouchend"), true);
            document.addEventListener("touchcancel", A("_ontouchcancel"), true)
        } else {
            document.addEventListener("mouseover", A("_onmouseover"), false);
            document.addEventListener("mouseout", A("_onmouseout"), false);
            document.addEventListener("mousedown", A("_onmousedown"), false);
            document.addEventListener("mouseup", A("_onmouseup"), false)
        }
    }
})();
/* 
 This file was generated by Dashcode and is covered by the 
 license.txt included in the project.  You may edit this file, 
 however it is recommended to first turn off the Dashcode 
 code generator otherwise the changes will be lost.
 */
var dashcodePartSpecs = {
    "helloText": {
        "text": "Hello, World!",
        "view": "DC.Text"
    }
};

/* 
 This file was generated by Dashcode and is covered by the 
 license.txt included in the project.  You may edit this file, 
 however it is recommended to first turn off the Dashcode 
 code generator otherwise the changes will be lost.
 */
var dashcodeDataSources = {
    "dataSource": {
        "Class": "DC.AjaxController"
    }
};