atoms-gen.js


/*

The MIT License (MIT)

Copyright (c) 2014 Akash Kava

Permission is hereby granted, free of charge, to any person obtaining a copy of this 
software and associated documentation files (the "Software"), to deal in the Software 
without restriction, including without limitation the rights to use, copy, modify, merge, 
publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons 
to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies 
or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING 
BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

*/
function mapLibrary(n, p, v) {
    var index = n.indexOf('.');
    if (index == -1) {
        var r = p[n];
        if (!r) {
            r = v;
            p[n] = r;
        }
        return r;
    }
    var r = mapLibrary(n.substr(0, index), p, {});
    return mapLibrary(n.substr(index + 1), r, v);
};

function createProperty(name, g) {
    if (g) {
        return function () {
            return this[name];
        };
    }
    return function (v) {
        this[name] = v;
    };
}

function classCreator(name, basePrototype, classConstructor, classPrototype, classProperties, thisPrototype, thisProperties) {
    var baseClass = basePrototype ? basePrototype.constructor : null;
    var old = classConstructor || (function () { });
    var cp = classProperties;
    var f = null;
    if (baseClass) {
        if (classProperties) {
            f = function () {
                for (var k in cp) {
                    this["_" + k] = cp[k];
                }
                baseClass.apply(this, arguments);
                this.__typeName = name;
                //var cp = Atom.clone(classProperties);
                old.apply(this, arguments);
            };
        } else {
            f = function () {
                baseClass.apply(this, arguments);
                this.__typeName = name;
                old.apply(this, arguments);
            };
        }

        var bpt = baseClass.prototype;

        // extend
        for (var k in bpt) {
            if (classPrototype[k])
                continue;
            if (bpt.hasOwnProperty(k)) {
                classPrototype[k] = bpt[k];
            }
        }

    } else {
        if (classProperties) {
            f = function () {
                this.__typeName = name;
                //var cp = Atom.clone(classProperties);
                for (var k in cp) {
                    this["_" + k] = cp[k];
                }
                old.apply(this, arguments);
            };
        } else {
            f = function () {
                this.__typeName = name;
                old.apply(this, arguments);
            };
        }
    }

    if (classProperties) {
        for (var k in classProperties) {
            if (!classPrototype["get_" + k]) {
                classPrototype["get_" + k] = createProperty("_"+ k,true);
            }
            if (!classPrototype["set_" + k]) {
                classPrototype["set_" + k] = createProperty("_" + k);
            }
        }
    }

    f.__typeName = name;

    if (baseClass) {
        f.__baseType = baseClass;
    }

    f.prototype = classPrototype;
    f.prototype.constructor = f;
    if (!classPrototype.hasOwnProperty("toString")) {
        f.prototype.toString = function () {
            return name;
        };
    }

    mapLibrary( /\./.test(name) ? name : 'WebAtoms.' + name, window, f);

    return f;
};

function classCreatorEx(objDef) {
    return classCreator(objDef.name, objDef.base, objDef.start, objDef.methods, objDef.properties);
}

window.createClass = classCreatorEx;
window.classCreatorEx = classCreatorEx;
(function (factory) {
	if (typeof define === 'function' && define.amd) {
		// AMD. Register as an anonymous module.
		define(['jquery'], factory);
	} else if (typeof exports === 'object') {
		// Node/CommonJS
		factory(require('jquery'));
	} else {
		// Browser globals
		factory(jQuery);
	}
}(function ($) {

	var ua = navigator.userAgent,
		iPhone = /iphone/i.test(ua),
		chrome = /chrome/i.test(ua),
		android = /android/i.test(ua),
		caretTimeoutId;

	$.mask = {
		//Predefined character definitions
		definitions: {
			'9': "[0-9]",
			'a': "[A-Za-z]",
			'*': "[A-Za-z0-9]"
		},
		autoclear: true,
		dataName: "rawMaskFn",
		placeholder: '_'
	};

	$.fn.extend({
		//Helper Function for Caret positioning
		caret: function (begin, end) {
			var range;

			if (this.length === 0 || this.is(":hidden")) {
				return;
			}

			if (typeof begin == 'number') {
				end = (typeof end === 'number') ? end : begin;
				return this.each(function () {
					if (this.setSelectionRange) {
						this.setSelectionRange(begin, end);
					} else if (this.createTextRange) {
						range = this.createTextRange();
						range.collapse(true);
						range.moveEnd('character', end);
						range.moveStart('character', begin);
						range.select();
					}
				});
			} else {
				if (this[0].setSelectionRange) {
					begin = this[0].selectionStart;
					end = this[0].selectionEnd;
				} else if (document.selection && document.selection.createRange) {
					range = document.selection.createRange();
					begin = 0 - range.duplicate().moveStart('character', -100000);
					end = begin + range.text.length;
				}
				return { begin: begin, end: end };
			}
		},
		unmask: function () {
			return this.trigger("unmask");
		},
		mask: function (mask, settings) {
			var input,
				defs,
				tests,
				partialPosition,
				firstNonMaskPos,
				lastRequiredNonMaskPos,
				len,
				oldVal;

			if (!mask && this.length > 0) {
				input = $(this[0]);
				var fn = input.data($.mask.dataName)
				return fn ? fn() : undefined;
			}

			settings = $.extend({
				autoclear: $.mask.autoclear,
				placeholder: $.mask.placeholder, // Load default placeholder
				completed: null
			}, settings);


			defs = $.mask.definitions;
			tests = [];
			partialPosition = len = mask.length;
			firstNonMaskPos = null;

			$.each(mask.split(""), function (i, c) {
				if (c == '?') {
					len--;
					partialPosition = i;
				} else if (defs[c]) {
					tests.push(new RegExp(defs[c]));
					if (firstNonMaskPos === null) {
						firstNonMaskPos = tests.length - 1;
					}
					if (i < partialPosition) {
						lastRequiredNonMaskPos = tests.length - 1;
					}
				} else {
					tests.push(null);
				}
			});

			return this.trigger("unmask").each(function () {
				var input = $(this),
					buffer = $.map(
						mask.split(""),
						function (c, i) {
							if (c != '?') {
								return defs[c] ? getPlaceholder(i) : c;
							}
						}),
					defaultBuffer = buffer.join(''),
					focusText = input.val();

				function tryFireCompleted() {
					if (!settings.completed) {
						return;
					}

					for (var i = firstNonMaskPos; i <= lastRequiredNonMaskPos; i++) {
						if (tests[i] && buffer[i] === getPlaceholder(i)) {
							return;
						}
					}
					settings.completed.call(input);
				}

				function getPlaceholder(i) {
					if (i < settings.placeholder.length)
						return settings.placeholder.charAt(i);
					return settings.placeholder.charAt(0);
				}

				function seekNext(pos) {
					while (++pos < len && !tests[pos]);
					return pos;
				}

				function seekPrev(pos) {
					while (--pos >= 0 && !tests[pos]);
					return pos;
				}

				function shiftL(begin, end) {
					var i,
						j;

					if (begin < 0) {
						return;
					}

					for (i = begin, j = seekNext(end) ; i < len; i++) {
						if (tests[i]) {
							if (j < len && tests[i].test(buffer[j])) {
								buffer[i] = buffer[j];
								buffer[j] = getPlaceholder(j);
							} else {
								break;
							}

							j = seekNext(j);
						}
					}
					writeBuffer();
					input.caret(Math.max(firstNonMaskPos, begin));
				}

				function shiftR(pos) {
					var i,
						c,
						j,
						t;

					for (i = pos, c = getPlaceholder(pos) ; i < len; i++) {
						if (tests[i]) {
							j = seekNext(i);
							t = buffer[i];
							buffer[i] = c;
							if (j < len && tests[j].test(t)) {
								c = t;
							} else {
								break;
							}
						}
					}
				}

				function androidInputEvent(e) {
					var curVal = input.val();
					var pos = input.caret();
					if (curVal.length < oldVal.length) {
						// a deletion or backspace happened
						checkVal(true);
						while (pos.begin > 0 && !tests[pos.begin - 1])
							pos.begin--;
						if (pos.begin === 0) {
							while (pos.begin < firstNonMaskPos && !tests[pos.begin])
								pos.begin++;
						}
						input.caret(pos.begin, pos.begin);
					} else {
						var pos2 = checkVal(true);
						while (pos.begin < len && !tests[pos.begin])
							pos.begin++;

						input.caret(pos.begin, pos.begin);
					}

					tryFireCompleted();
				}

				function blurEvent(e) {
					checkVal();

					if (input.val() != focusText)
						input.change();
				}

				function keydownEvent(e) {
					if (input.prop("readonly")) {
						return;
					}

					var k = e.which || e.keyCode,
						pos,
						begin,
						end;
					oldVal = input.val();
					//backspace, delete, and escape get special treatment
					if (k === 8 || k === 46 || (iPhone && k === 127)) {
						pos = input.caret();
						begin = pos.begin;
						end = pos.end;

						if (end - begin === 0) {
							begin = k !== 46 ? seekPrev(begin) : (end = seekNext(begin - 1));
							end = k === 46 ? seekNext(end) : end;
						}
						clearBuffer(begin, end);
						shiftL(begin, end - 1);

						e.preventDefault();
					} else if (k === 13) { // enter
						blurEvent.call(this, e);
					} else if (k === 27) { // escape
						input.val(focusText);
						input.caret(0, checkVal());
						e.preventDefault();
					}
				}

				function keypressEvent(e) {
					if (input.prop("readonly")) {
						return;
					}

					var k = e.which || e.keyCode,
						pos = input.caret(),
						p,
						c,
						next;

					if (e.ctrlKey || e.altKey || e.metaKey || k < 32) {//Ignore
						return;
					} else if (k && k !== 13) {
						if (pos.end - pos.begin !== 0) {
							clearBuffer(pos.begin, pos.end);
							shiftL(pos.begin, pos.end - 1);
						}

						p = seekNext(pos.begin - 1);
						if (p < len) {
							c = String.fromCharCode(k);
							if (tests[p].test(c)) {
								shiftR(p);

								buffer[p] = c;
								writeBuffer();
								next = seekNext(p);

								if (android) {
									//Path for CSP Violation on FireFox OS 1.1
									var proxy = function () {
										$.proxy($.fn.caret, input, next)();
									};

									setTimeout(proxy, 0);
								} else {
									input.caret(next);
								}
								if (pos.begin <= lastRequiredNonMaskPos) {
									tryFireCompleted();
								}
							}
						}
						e.preventDefault();
					}
				}

				function clearBuffer(start, end) {
					var i;
					for (i = start; i < end && i < len; i++) {
						if (tests[i]) {
							buffer[i] = getPlaceholder(i);
						}
					}
				}

				function writeBuffer() { input.val(buffer.join('')); }

				function checkVal(allow) {
					//try to place characters where they belong
					var test = input.val(),
						lastMatch = -1,
						i,
						c,
						pos;

					for (i = 0, pos = 0; i < len; i++) {
						if (tests[i]) {
							buffer[i] = getPlaceholder(i);
							while (pos++ < test.length) {
								c = test.charAt(pos - 1);
								if (tests[i].test(c)) {
									buffer[i] = c;
									lastMatch = i;
									break;
								}
							}
							if (pos > test.length) {
								clearBuffer(i + 1, len);
								break;
							}
						} else {
							if (buffer[i] === test.charAt(pos)) {
								pos++;
							}
							if (i < partialPosition) {
								lastMatch = i;
							}
						}
					}
					if (allow) {
						writeBuffer();
					} else if (lastMatch + 1 < partialPosition) {
						if (settings.autoclear || buffer.join('') === defaultBuffer) {
							// Invalid value. Remove it and replace it with the
							// mask, which is the default behavior.
							if (input.val()) input.val("");
							clearBuffer(0, len);
						} else {
							// Invalid value, but we opt to show the value to the
							// user and allow them to correct their mistake.
							writeBuffer();
						}
					} else {
						writeBuffer();
						input.val(input.val().substring(0, lastMatch + 1));
					}
					return (partialPosition ? i : firstNonMaskPos);
				}

				input.data($.mask.dataName, function () {
					return $.map(buffer, function (c, i) {
						return tests[i] && c != getPlaceholder(i) ? c : null;
					}).join('');
				});


				input
					.one("unmask", function () {
						input
							.off(".mask")
							.removeData($.mask.dataName);
					})
					.on("focus.mask", function () {
						if (input.prop("readonly")) {
							return;
						}

						clearTimeout(caretTimeoutId);
						var pos;

						focusText = input.val();

						pos = checkVal();

						caretTimeoutId = setTimeout(function () {
							if (input.get(0) !== document.activeElement) {
								return;
							}
							writeBuffer();
							if (pos == mask.replace("?", "").length) {
								input.caret(0, pos);
							} else {
								input.caret(pos);
							}
						}, 10);
					})
					.on("blur.mask", blurEvent)
					.on("keydown.mask", keydownEvent)
					.on("keypress.mask", keypressEvent)
					.on("input.mask paste.mask", function () {
						if (input.prop("readonly")) {
							return;
						}

						setTimeout(function () {
							var pos = checkVal(true);
							input.caret(pos);
							tryFireCompleted();
						}, 0);
					});
				if (chrome && android) {
					input
						.off('input.mask')
						.on('input.mask', androidInputEvent);
				}
				checkVal(); //Perform initial check for existing values
			});
		}
	});
}));


(function(window){

	//var $old = window.$;
//
    //var $ = function(o){
        //if(typeof HTMLElement === "object" ? o instanceof HTMLElement : o 
            //&& typeof o === "object" 
            //&& o !== null 
            //&& o.nodeType === 1 
            //&& typeof o.nodeName==="string"){
            //o.__$ = o.__$ || $old(o);
            //return o.__$;
        //}
        //return $old(o);
    //};
//
    //$.prototype = $old;

    var $ = window.$;

	var document = window.document;
	var Templates = { jsonML: {} };

    var WebAtoms = {};
    window.WebAtoms = WebAtoms;

	window.Templates = Templates;

    var jsonML = Templates.jsonML;

jsonML["WebAtoms.AtomAutoCompleteBox.template"] = 
[["input",
{ "data-atom-presenter": "selectionBox", "disabled": "disabled", "type": "text", "data-atom-init": "t1" }
], ["input",
{ "data-atom-presenter": "inputBox", "type": "text", "autocomplete": "off", "autocorrect": "off", "data-atom-init": "t2" }
], ["div",
{ "data-atom-presenter": "itemsPresenter", "class": "atom-list-box", "style": "position: absolute; z-index: 100;", "data-atom-init": "t3" }
,["div",
{ "data-atom-template": "itemTemplate", "style": "min-width:100px;", "data-atom-init": "t4" }
]]]
;
jsonML["WebAtoms.AtomCalendar.itemTemplate"] = 
[["div",
{ "data-atom-template": "itemTemplate", "data-atom-init": "t5" }
,["span",
{ "data-atom-init": "t6" }
]]]
;
jsonML["WebAtoms.AtomCalendar.template"] = 
[["section",
{ "class": "calendar" }
,["header",
{  }
,["button",
{ "class": "prev", "data-atom-init": "t7" }
], ["select",
{ "data-atom-type": "AtomComboBox", "class": "month", "data-atom-init": "t8" }
], ["select",
{ "data-atom-type": "AtomComboBox", "class": "year", "data-atom-init": "t9" }
], ["button",
{ "class": "next", "data-atom-init": "t10" }
]], ["ul",
{ "class": "days" }
,["li",
{ "class": "weekend" }
,"S"], ["li",
{  }
,"M"], ["li",
{  }
,"T"], ["li",
{  }
,"W"], ["li",
{  }
,"T"], ["li",
{  }
,"F"], ["li",
{ "class": "weekend" }
,"S"]], ["section",
{ "class": "day-list", "data-atom-presenter": "itemsPresenter" }
,]]]
;
jsonML["WebAtoms.AtomCheckBoxList.itemTemplate"] = 
[["div",
{ "data-atom-template": "itemTemplate" }
,["input",
{ "type": "checkbox", "data-atom-init": "t13" }
], ["span",
{ "data-atom-init": "t14" }
]]]
;
jsonML["WebAtoms.AtomDataPager.template"] = 
[["button",
{ "class": "atom-pager-first-button", "style": "float:left", "data-atom-init": "t15" }
,"First"], ["span",
{ "style": "text-align:left" }
,["button",
{ "class": "atom-pager-prev-button", "data-atom-init": "t16" }
,"Prev"], ["span",
{  }
,"Goto: Page"], ["select",
{ "data-atom-type": "AtomComboBox", "data-atom-init": "t17" }
,], ["button",
{ "class": "atom-pager-next-button", "data-atom-init": "t18" }
,"Next"]], ["button",
{ "class": "atom-pager-last-button", "style": "float:right", "data-atom-init": "t19" }
,"Last"]]
;
jsonML["WebAtoms.AtomDateField.popupTemplate"] = 
[["div",
{ "class": "atom-date-popup", "data-atom-init": "t20" }
,["div",
{ "class": "atom-date-list-box" }
,["div",
{ "class": "calendar", "data-atom-presenter": "calendarPresenter" }
,["select",
{ "data-atom-type": "AtomComboBox", "class": "month", "data-atom-init": "t22" }
], ["select",
{ "data-atom-type": "AtomNumberComboBox", "class": "year", "data-atom-init": "t23" }
], ["div",
{ "class": "days" }
,["span",
{ "class": "weekend-header" }
,"S"], ["span",
{  }
,"M"], ["span",
{  }
,"T"], ["span",
{  }
,"W"], ["span",
{  }
,"T"], ["span",
{  }
,"F"], ["span",
{ "class": "weekend-header" }
,"S"]], ["div",
{ "class": "day-list", "data-atom-type": "AtomItemsControl", "data-atom-presenter": "itemsPresenter", "data-atom-init": "t24" }
,["div",
{ "data-atom-template": "itemTemplate", "data-atom-init": "t25" }
,["span",
{ "data-atom-init": "t26" }
]]]]]]]
;
jsonML["WebAtoms.AtomDateField.template"] = 
[["div",
{ "class": "date-label", "data-atom-init": "t27" }
]]
;
jsonML["WebAtoms.AtomDateListBox.template"] = 
[["div",
{ "class": "atom-date-list-box" }
,["div",
{ "class": "calendar" }
,["select",
{ "data-atom-type": "AtomComboBox", "class": "month", "data-atom-init": "t28" }
], ["select",
{ "data-atom-type": "AtomComboBox", "class": "year", "data-atom-init": "t29" }
], ["div",
{ "class": "days" }
,["span",
{ "class": "weekend-header" }
,"S"], ["span",
{  }
,"M"], ["span",
{  }
,"T"], ["span",
{  }
,"W"], ["span",
{  }
,"T"], ["span",
{  }
,"F"], ["span",
{ "class": "weekend-header" }
,"S"]], ["div",
{ "class": "day-list", "data-atom-presenter": "itemsPresenter" }
,["div",
{ "data-atom-template": "itemTemplate", "data-atom-init": "t31" }
,["span",
{ "data-atom-init": "t32" }
]]]], ["div",
{ "class": "list", "data-atom-type": "AtomListBox", "data-atom-init": "t33" }
,["div",
{ "data-atom-template": "itemTemplate", "data-atom-init": "t34" }
,]]]]
;
jsonML["WebAtoms.AtomItemsControl.itemTemplate"] = 
[["span",
{ "data-atom-init": "t35" }
,"Item"]]
;
jsonML["WebAtoms.AtomLinkBar.itemTemplate"] = 
[["li",
{ "data-atom-init": "t36" }
,["a",
{ "data-atom-init": "t37" }
,]]]
;
jsonML["WebAtoms.AtomLinkBar.menuTemplate"] = 
[["ul",
{ "class": "menu", "data-atom-type": "AtomLinkBar", "data-atom-init": "t38" }
,["li",
{ "data-atom-template": "itemTemplate" }
,["a",
{ "data-atom-init": "t40" }
]]]]
;
jsonML["WebAtoms.AtomNavigatorList.detailTemplate"] = 
[["iframe",
{ "class": "atom-navigator-list-iframe", "data-atom-template": "detailTemplate", "data-atom-init": "t41" }
]]
;
jsonML["WebAtoms.AtomNavigatorList.template"] = 
[["div",
{ "data-atom-type": "AtomViewStack", "data-atom-init": "t42" }
,["div",
{ "data-atom-type": "AtomDockPanel", "data-atom-presenter": "gridPanel" }
,["div",
{ "data-atom-dock": "Fill", "data-atom-presenter": "gridPresenter", "class": "atom-navigator-list-grid" }
,]], ["div",
{ "data-atom-presenter": "detailView", "data-atom-type": "AtomDockPanel", "data-atom-init": "t45" }
,["div",
{ "data-atom-dock": "Top", "data-atom-presenter": "detailHeaderToolbar" }
,["input",
{ "type": "button", "value": "Back", "style": "float: left", "data-atom-init": "t47" }
]]], ["div",
{ "data-atom-presenter": "newView", "data-atom-type": "AtomDockPanel", "data-atom-init": "t48" }
,["div",
{ "data-atom-dock": "Top", "data-atom-presenter": "newHeaderToolbar" }
,["input",
{ "type": "button", "value": "Back", "style": "float: left", "data-atom-init": "t50" }
]]]]]
;
jsonML["WebAtoms.AtomRadioButtonList.itemTemplate"] = 
[["span",
{  }
,["input",
{ "type": "radio", "data-atom-name": "{$owner.groupName}", "data-atom-init": "t51" }
], ["span",
{ "data-atom-init": "t52" }
]]]
;
jsonML["WebAtoms.AtomSortableColumn.template"] = 
[["span",
{ "data-atom-init": "t53" }
]]
;
jsonML["WebAtoms.AtomTabControl.template"] = 
[["div",
{ "data-atom-type": "AtomDockPanel" }
,["ul",
{ "data-atom-dock": "Top", "data-atom-type": "AtomToggleButtonBar", "data-atom-init": "t55" }
,["li",
{ "data-atom-template": "itemTemplate", "data-atom-init": "t56" }
]], ["div",
{ "data-atom-dock": "Fill", "data-atom-type": "AtomViewStack", "data-atom-presenter": "itemsPresenter", "data-atom-init": "t57" }
,]]]
;
jsonML["WebAtoms.AtomTimeEditor.template"] = 
[["span",
{  }
,"Hour:"], ["input",
{ "type": "number", "min": "0", "max": "12", "data-atom-init": "t58" }
], ["span",
{  }
,"Minute:"], ["input",
{ "type": "number", "min": "0", "max": "59", "data-atom-init": "t59" }
], ["ul",
{ "data-atom-type": "AtomToggleButtonBar", "data-atom-init": "t60" }
,["li",
{ "data-atom-template": "itemTemplate", "data-atom-init": "t61" }
]]]
;
jsonML["WebAtoms.AtomToggleButtonBar.itemTemplate"] = 
[["li",
{ "data-atom-init": "t62" }
,]]
;
jsonML["WebAtoms.AtomWizard.template"] = 
[["div",
{ "data-atom-dock": "Fill", "data-atom-type": "AtomViewStack", "data-atom-presenter": "viewPresenter", "data-atom-init": "t63" }
,], ["div",
{ "data-atom-dock": "Bottom", "class": "atom-wizard-command-bar" }
,["button",
{ "class": "atom-wizard-back-button", "data-atom-init": "t65" }
,["span",
{ "data-atom-init": "t66" }
]], ["button",
{ "class": "atom-wizard-next-button", "data-atom-init": "t67" }
,["span",
{ "data-atom-init": "t68" }
]]]]
;
jsonML["WebAtoms.AtomYesNoCustom.template"] = 
[["ul",
{ "data-atom-type": "AtomYesNoControl", "data-atom-presenter": "yesNo", "data-atom-init": "t69" }
], ["input",
{ "style": "vertical-align:top", "type": "text", "data-atom-presenter": "input", "data-atom-init": "t70" }
]]
;
jsonML["WebAtoms.AtomApplication.busyTemplate"] = 
[["div",
{ "style": "position:absolute;left:0px;top:0px;z-index:10000; display:none", "data-atom-init": "t71" }
,["div",
{ "class": "atom-busy-window", "style": "position:absolute", "data-atom-init": "t72" }
,["div",
{ "class": "atom-busy-image", "data-atom-init": "t73" }
], ["div",
{ "data-atom-init": "t74" }
], ["div",
{ "style": "height:3px; background-color:green", "data-atom-init": "t75" }
]]]]
;
jsonML["WebAtoms.AtomFormGridLayout.fieldTemplate"] = 
[["table",
{ "class": "atom-form-grid-row", "data-atom-type": "AtomFormField", "data-atom-init": "t76" }
,["tbody",
{  }
,["tr",
{  }
,["td",
{ "class": "atom-form-grid-label", "data-atom-init": "t77" }
], ["td",
{ "class": "atom-form-grid-required", "data-atom-init": "t78" }
,"*"], ["td",
{ "class": "atom-form-grid-content", "data-atom-presenter": "contentPresenter", "data-atom-init": "t79" }
,], ["td",
{ "data-atom-init": "t80" }
,]]]]]
;
jsonML["WebAtoms.AtomFormLayout.fieldTemplate"] = 
[["tr",
{ "data-atom-type": "AtomFormField" }
,["td",
{ "class": "atom-form-label", "data-atom-init": "t82" }
], ["td",
{ "class": "atom-form-required", "data-atom-init": "t83" }
,], ["td",
{ "class": "atom-form-content", "data-atom-presenter": "contentPresenter", "data-atom-init": "t84" }
,["span",
{ "class": "atom-form-error", "data-atom-init": "t85" }
]]]]
;
jsonML["WebAtoms.AtomFormVerticalLayout.fieldTemplate"] = 
[["tr",
{ "data-atom-type": "AtomFormField" }
,["td",
{  }
,["div",
{  }
,["span",
{ "class": "atom-form-label", "data-atom-init": "t87" }
], ["span",
{ "class": "atom-form-required", "data-atom-init": "t88" }
]], ["div",
{ "class": "atom-form-content", "data-atom-presenter": "contentPresenter", "data-atom-init": "t89" }
], ["div",
{ "class": "atom-form-error", "data-atom-init": "t90" }
]]]]
;
jsonML["WebAtoms.AtomWindow.alertTemplate"] = 
[["div",
{ "class": "atom-alert", "data-atom-dock": "Fill" }
,["pre",
{ "data-atom-init": "t92" }
,], ["div",
{ "class": "buttons", "data-atom-init": "t93" }
,["button",
{ "class": "ok", "data-atom-init": "t94" }
,"Ok"], ["button",
{ "class": "yes", "data-atom-init": "t95" }
,"Yes"], ["button",
{ "class": "no", "data-atom-init": "t96" }
,"No"]]]]
;
jsonML["WebAtoms.AtomWindow.frameTemplate"] = 
[["div",
{ "class": "atom-window-background", "data-atom-init": "t97" }
,["div",
{ "class": "atom-window", "data-atom-presenter": "windowDiv", "style": "position:absolute", "data-atom-type": "AtomDockPanel", "data-atom-init": "t98" }
,["div",
{ "class": "atom-window-title", "data-atom-dock": "Top", "data-atom-presenter": "windowTitleDiv", "data-atom-init": "t99" }
], ["div",
{ "class": "atom-window-close-button", "data-atom-presenter": "windowCloseButton", "data-atom-init": "t100" }
]]]]
;
jsonML["WebAtoms.AtomWindow.windowTemplate"] = 
[["iframe",
{ "class": "atom-window-frame", "data-atom-presenter": "iframe", "data-atom-init": "t101" }
,]]
;

        WebAtoms.PageSetup = WebAtoms.PageSetup || {};

    (function(window,WebAtoms){

        /* WebAtoms.AtomAutoCompleteBox.template */
this.t1= function(e){
this.bind(e,'styleDisplay',[
	['isPopupOpen']],
			0, function(v1){
				 return v1 ? '' : 'none'; 
			});
	this.bind(e,'value',
	['selectedText']);
};

this.t2= function(e){
this.bind(e,'placeholder',
	['placeholder']);
	this.bind(e,'value',['displayLabel'],true,null,'keyup')
};

this.t3= function(e){
this.bind(e,'styleLeft',[
	['offsetLeft']],
			0, function(v1){
				 return (v1 + 2) + 'px'; 
			});
	this.bind(e,'styleTop',[
	['offsetTop']],
			0, function(v1){
				 return (v1 + 24) + 'px'; 
			});
	this.bind(e,'styleDisplay',[
	['isPopupOpen']],
			0, function(v1){
				 return v1 ? 'block' : 'none'; 
			});
};

this.t4= function(e){
this.setLocalValue('text',  Atom.get(this,'data')[Atom.get(this,'templateParent.labelPath')] , e);
};

/* WebAtoms.AtomCalendar.itemTemplate */
this.t5= function(e){
this.bind(e,'class',[
	['data', 'isWeekEnd'],
	['data', 'isOtherMonth'],
	['data', 'isToday'],
	['scope', 'itemSelected']],
			0, function(v1,v2,v3,v4){
				 return  {
'weekend': v1,
other: v2,
today: v3,
'selected': v4 } ; 
			});
};

this.t6= function(e){
this.bind(e,'text',
	['data', 'label']);
};

/* WebAtoms.AtomCalendar.template */
this.t7= function(e){
this.setLocalValue('eventClick', Atom.get(this,'prevMonthCommand'), e);
	AtomProperties.text(e,"\u003c");
};

this.t8= function(e){
this.setLocalValue('items', AtomDate.monthList, e);
	this.bind(e,'value',['templateParent', 'month'],true)
};

this.t9= function(e){
this.bind(e,'items',[
	['value'],
	['templateParent', 'startYear'],
	['value'],
	['templateParent', 'endYear']],
			0, function(v1,v2,v3,v4){
				 return  Atom.range( v1 + v2, v3 + v4) ; 
			});
	this.bind(e,'value',['templateParent', 'year'],true)
};

this.t10= function(e){
this.setLocalValue('eventClick', Atom.get(this,'nextMonthCommand'), e);
	AtomProperties.text(e,"\u003e");
};

/* WebAtoms.AtomCheckBoxList.itemTemplate */
this.t13= function(e){
this.bind(e,'checked',['scope', 'itemSelected'],true)
};

this.t14= function(e){
this.setLocalValue('text', Atom.get(this,'data')[Atom.get(this,'templateParent.labelPath')], e);
};

/* WebAtoms.AtomDataPager.template */
this.t15= function(e){
this.bind(e,'isEnabled',[
	['pages', 'length'],
	['currentPage']],
			0, function(v1,v2){
				 return v1 > 1 && v2; 
			});
	this.setLocalValue('eventClick', Atom.get(this,'goFirstCommand'), e);
};

this.t16= function(e){
this.setLocalValue('eventClick', Atom.get(this,'goPrevCommand'), e);
	this.bind(e,'isEnabled',
	['currentPage']);
};

this.t17= function(e){
this.bind(e,'items',
	['atomParent', 'pages']);
	this.bind(e,'value',['atomParent', 'currentPage'],true)
};

this.t18= function(e){
this.setLocalValue('eventClick', Atom.get(this,'goNextCommand'), e);
	this.bind(e,'isEnabled',[
	['currentPage'],
	['pages', 'length']],
			0, function(v1,v2){
				 return v1 < v2 -1 ; 
			});
};

this.t19= function(e){
this.setLocalValue('eventClick', Atom.get(this,'goLastCommand'), e);
	this.bind(e,'isEnabled',[
	['pages', 'length'],
	['currentPage'],
	['pages', 'length']],
			0, function(v1,v2,v3){
				 return v1 > 1 && v2 < v3 -1 ; 
			});
};

/* WebAtoms.AtomDateField.popupTemplate */
this.t20= function(e){
this.bind(e,'styleLeft',[
	['offsetLeft']],
			0, function(v1){
				 return (v1 ) + 'px'; 
			});
	this.bind(e,'styleTop',[
	['offsetTop']],
			0, function(v1){
				 return (v1 + 25) + 'px'; 
			});
	this.bind(e,'class',[
	['isOpen']],
			0, function(v1){
				 return v1 ? 'popup-open' : 'popup-closed' ; 
			});
};

this.t22= function(e){
this.setLocalValue('items', AtomDate.monthList, e);
	this.bind(e,'value',['templateParent', 'month'],true)
};

this.t23= function(e){
this.bind(e,'startNumber',[
	['templateParent', 'currentYear'],
	['templateParent', 'startYear']],
			0, function(v1,v2){
				 return  v1 + v2; 
			});
	this.bind(e,'endNumber',[
	['templateParent', 'currentYear'],
	['templateParent', 'endYear']],
			0, function(v1,v2){
				 return  v1 + v2; 
			});
	this.bind(e,'value',['templateParent', 'year'],true)
};

this.t24= function(e){
this.bind(e,'items',
	['templateParent', 'items']);
};

this.t25= function(e){
this.setLocalValue('eventClick',  Atom.get(this,'templateParent.templateParent.toggleDateCommand') , e);
	this.bind(e,'class',[
	['data', 'isWeekEnd'],
	['data', 'isOtherMonth'],
	['data', 'isToday'],
	['templateParent', 'templateParent', 'selectedItems'],
	['data', 'value']],
			0, function(v1,v2,v3,v4,v5){
				 return  {
'list-item':true,
'weekend': v1,
other: v2,
today: v3,
'selected': Atom.query(v4).any({ value: v5}) } ; 
			});
};

this.t26= function(e){
this.bind(e,'text',
	['data', 'label']);
};

/* WebAtoms.AtomDateField.template */
this.t27= function(e){
this.bind(e,'class',[
	['isOpen']],
			0, function(v1){
				 return v1 ? 'date-label-open' : 'date-label-closed'; 
			});
	this.bind(e,'eventClick',[
	['isOpen']],
			0, function(v1){
				 return  { owner: { isOpen: ! v1 } } ; 
			});
	this.bind(e,'text',[
	['selectedItem'],
	['selectedItem', 'dateLabel']],
			0, function(v1,v2){
				 return  v1 ? v2 : 'SELECT' ; 
			});
};

/* WebAtoms.AtomDateListBox.template */
this.t28= function(e){
this.setLocalValue('items', AtomDate.monthList, e);
	this.bind(e,'value',['templateParent', 'month'],true)
};

this.t29= function(e){
this.bind(e,'items',[
	['value'],
	['templateParent', 'startYear'],
	['value'],
	['templateParent', 'endYear']],
			0, function(v1,v2,v3,v4){
				 return  Atom.range( v1 + v2, v3 + v4) ; 
			});
	this.bind(e,'value',['templateParent', 'year'],true)
};

this.t31= function(e){
this.setLocalValue('eventClick',  Atom.get(this,'templateParent.toggleDateCommand') , e);
	this.bind(e,'data',[
	['templateParent', 'items'],
	['scope', 'itemIndex']],
			0, function(v1,v2){
				 return v1[v2]; 
			});
	this.bind(e,'class',[
	['data', 'isWeekEnd'],
	['data', 'isOtherMonth'],
	['data', 'isToday'],
	['templateParent', 'selectedItems'],
	['data', 'value']],
			0, function(v1,v2,v3,v4,v5){
				 return  {
'list-item':true,
'weekend': v1,
other: v2,
today: v3,
'selected': Atom.query(v4).any({ value: v5}) } ; 
			});
};

this.t32= function(e){
this.bind(e,'text',
	['data', 'label']);
};

this.t33= function(e){
this.bind(e,'items',
	['templateParent', 'selectedItems']);
	this.setLocalValue('labelPath', "dateLabel", e);
	this.setLocalValue('valuePath', "date", e);
	this.bind(e,'value',['templateParent', 'visibleDate'],true)
};

this.t34= function(e){
this.setLocalValue('text', Atom.get(this,'data.dateLabel'), e);
};

/* WebAtoms.AtomItemsControl.itemTemplate */
this.t35= function(e){
this.bind(e,'text',[
	['data'],
	['atomParent', 'labelPath']],
			0, function(v1,v2){
				 return v1[v2]; 
			});
};

/* WebAtoms.AtomLinkBar.itemTemplate */
this.t36= function(e){
this.setLocalValue('class', Atom.get(this,'data')[Atom.get(this,'templateParent.itemsPath')] ? ((Atom.get(this,'data')[Atom.get(this,'templateParent.itemsPath')]).length ? 'sub-menu' : '' ) : '' , e);
};

this.t37= function(e){
this.setLocalValue('href', Atom.get(this,'data')[Atom.get(this,'atomParent.valuePath')], e);
	this.setLocalValue('target', Atom.get(this,'data')[Atom.get(this,'atomParent.targetPath')], e);
	this.setLocalValue('text', Atom.get(this,'data')[Atom.get(this,'atomParent.labelPath')], e);
};

/* WebAtoms.AtomLinkBar.menuTemplate */
this.t38= function(e){
this.bind(e,'items',[
	['data'],
	['templateParent', 'itemsPath']],
			0, function(v1,v2){
				 return v1[v2]; 
			});
	this.setLocalValue('menuTemplate', Atom.get(this,'templateParent.menuTemplate'), e);
	this.setLocalValue('menuDirection', "vertical", e);
};

this.t40= function(e){
this.setLocalValue('href', Atom.get(this,'data')[Atom.get(this,'templateParent.valuePath')], e);
	this.setLocalValue('text', Atom.get(this,'data')[Atom.get(this,'templateParent.labelPath')], e);
	this.setLocalValue('target', Atom.get(this,'data.target'), e);
	this.setLocalValue('eventClick', Atom.get(this,'data.action'), e);
};

/* WebAtoms.AtomNavigatorList.detailTemplate */
this.t41= function(e){
this.bind(e,'src',[
	['templateParent', 'displayMode'],
	['templateParent', 'displayMode'],
	['templateParent', 'newUrl'],
	['templateParent', 'detailUrl']],
			0, function(v1,v2,v3,v4){
				 return v1 == 1 ?( v2 == 2 ? v3 : v4 ): 'about:none'; 
			});
};

/* WebAtoms.AtomNavigatorList.template */
this.t42= function(e){
this.bind(e,'selectedIndex',
	['atomParent', 'displayMode']);
};

this.t45= function(e){
this.bind(e,'data',
	['templateParent', 'selectedItem']);
};

this.t47= function(e){
this.bind(e,'eventClick',
	['templateParent', 'backCommand']);
};

this.t48= function(e){
this.bind(e,'data',
	['templateParent', 'newItemCopy']);
};

this.t50= function(e){
this.bind(e,'eventClick',
	['templateParent', 'cancelAddCommand']);
};

/* WebAtoms.AtomRadioButtonList.itemTemplate */
this.t51= function(e){
this.bind(e,'checked',['scope', 'itemSelected'],true)
};

this.t52= function(e){
this.setLocalValue('text', Atom.get(this,'data.label'), e);
};

/* WebAtoms.AtomSortableColumn.template */
this.t53= function(e){
this.bind(e,'text',
	['label']);
};

/* WebAtoms.AtomTabControl.template */
this.t55= function(e){
this.setLocalValue('showTabs', "true", e);
	this.bind(e,'labelPath',
	['templateParent', 'labelPath']);
	this.bind(e,'items',
	['templateParent', 'items']);
	this.bind(e,'selectedIndex',['templateParent', 'selectedIndex'],true)
};

this.t56= function(e){
this.bind(e,'text',
	['data']);
};

this.t57= function(e){
this.bind(e,'selectedIndex',
	['templateParent', 'selectedIndex']);
};

/* WebAtoms.AtomTimeEditor.template */
this.t58= function(e){
this.bind(e,'value',['hours'],true)
};

this.t59= function(e){
this.bind(e,'value',['minutes'],true)
};

this.t60= function(e){
this.setLocalValue('items',  [ { label:'AM', value:'AM'},{ label:'PM', value:'PM'}] , e);
	this.bind(e,'value',['templateParent', 'ap'],true)
};

this.t61= function(e){
this.setLocalValue('text', Atom.get(this,'data.label'), e);
};

/* WebAtoms.AtomToggleButtonBar.itemTemplate */
this.t62= function(e){
this.setLocalValue('text', Atom.get(this,'data')[Atom.get(this,'atomParent.labelPath')], e);
};

/* WebAtoms.AtomWizard.template */
this.t63= function(e){
this.bind(e,'selectedIndex',['templateParent', 'currentStep'],true)
};

this.t65= function(e){
this.bind(e,'isEnabled',
	['canMoveBack']);
	this.setLocalValue('eventClick', Atom.get(this,'goPrevCommand'), e);
	this.bind(e,'styleVisibility',[
	['currentStep']],
			0, function(v1){
				 return v1 ? 'visible' : 'hidden'; 
			});
};

this.t66= function(e){
this.bind(e,'text',
	['prevLabel']);
};

this.t67= function(e){
this.bind(e,'class',[
	['nextClass'],
	['isLastStep']],
			0, function(v1,v2){
				 return v1 || (v2 ? 'finish-button' : ''); 
			});
	this.setLocalValue('eventClick', Atom.get(this,'nextCommand'), e);
	this.bind(e,'isEnabled',
	['nextCommand']);
};

this.t68= function(e){
this.bind(e,'text',[
	['isLastStep'],
	['finishLabel'],
	['nextLabel']],
			0, function(v1,v2,v3){
				 return v1 ? v2 : v3; 
			});
};

/* WebAtoms.AtomYesNoCustom.template */
this.t69= function(e){
this.bind(e,'value',['templateParent', 'hasValue'],true)
};

this.t70= function(e){
this.bind(e,'isEnabled',
	['hasValue']);
	this.bind(e,'placeholder',
	['placeholder']);
};

/* WebAtoms.AtomApplication.busyTemplate */
this.t71= function(e){
this.bind(e,'styleWidth',[
	['appWidth']],
			0, function(v1){
				 return v1 + 'px'; 
			});
	this.bind(e,'styleHeight',[
	['appHeight']],
			0, function(v1){
				 return v1 + 'px'; 
			});
	this.bind(e,'styleDisplay',[
	['isBusy']],
			0, function(v1){
				 return v1 ? 'block' : 'none'; 
			});
};

this.t72= function(e){
this.bind(e,'styleLeft',[
	['appWidth']],
			0, function(v1){
				 return ((v1/2)-100) + 'px'; 
			});
	this.bind(e,'styleTop',[
	['appHeight']],
			0, function(v1){
				 return ((v1/2)-25) + 'px'; 
			});
};

this.t73= function(e){
AtomProperties.absPos(e,"12,12,36,36");
};

this.t74= function(e){
AtomProperties.absPos(e,"56,24,145,null");
	this.bind(e,'text',[
	['busyMessage']],
			0, function(v1){
				 return v1 || 'Loading...'; 
			});
};

this.t75= function(e){
AtomProperties.absPos(e,"0,48");
	this.bind(e,'styleDisplay',[
	['isBusy'],
	['progress']],
			0, function(v1,v2){
				 return v1 && v2 ? 'block' : 'none'; 
			});
	this.bind(e,'styleWidth',[
	['progress']],
			0, function(v1){
				 return v1 + '%'; 
			});
};

/* WebAtoms.AtomFormGridLayout.fieldTemplate */
this.t76= function(e){
this.bind(e,'class',
	['fieldClass']);
	this.bind(e,'styleDisplay',[
	['fieldVisible']],
			0, function(v1){
				 return v1 ? '' : 'none'; 
			});
};

this.t77= function(e){
this.bind(e,'text',
	['label']);
	this.bind(e,'styleMinWidth',[
	['atomParent', 'minLabelWidth'],
	['atomParent', 'minLabelWidth']],
			0, function(v1,v2){
				 return v1 ? (v2 + 'px') : undefined; 
			});
};

this.t78= function(e){
this.bind(e,'class',[
	['required']],
			0, function(v1){
				 return v1 ? 'atom-form-grid-required' : 'atom-form-grid-not-required'; 
			});
};

this.t79= function(e){
this.bind(e,'class',[
	['error']],
			0, function(v1){
				 return v1 ? 'atom-data-error' : ''; 
			});
};

this.t80= function(e){
this.bind(e,'class',[
	['error']],
			0, function(v1){
				 return v1 ? 'atom-data-error' : ''; 
			});
	this.bind(e,'text',[
	['error']],
			0, function(v1){
				 return v1 || ''; 
			});
	this.bind(e,'styleDisplay',[
	['error']],
			0, function(v1){
				 return v1 ? '' : 'none'; 
			});
};

/* WebAtoms.AtomFormLayout.fieldTemplate */
this.t82= function(e){
this.bind(e,'text',
	['label']);
	this.bind(e,'styleMinWidth',[
	['atomParent', 'minLabelWidth']],
			0, function(v1){
				 return v1 || undefined; 
			});
};

this.t83= function(e){
this.bind(e,'text',[
	['required']],
			0, function(v1){
				 return v1 ? '*' : ''; 
			});
};

this.t84= function(e){
this.bind(e,'class',[
	['error']],
			0, function(v1){
				 return v1 ? 'atom-data-error' : ''; 
			});
};

this.t85= function(e){
this.bind(e,'text',[
	['error']],
			0, function(v1){
				 return v1 || ''; 
			});
};

/* WebAtoms.AtomFormVerticalLayout.fieldTemplate */
this.t87= function(e){
this.bind(e,'text',
	['label']);
};

this.t88= function(e){
this.bind(e,'text',[
	['required']],
			0, function(v1){
				 return v1 ? '*' : ''; 
			});
};

this.t89= function(e){
this.bind(e,'class',[
	['error']],
			0, function(v1){
				 return v1 ? 'atom-data-error' : ''; 
			});
};

this.t90= function(e){
this.bind(e,'text',[
	['error']],
			0, function(v1){
				 return v1 || ''; 
			});
};

/* WebAtoms.AtomWindow.alertTemplate */
this.t92= function(e){
this.setLocalValue('text', Atom.get(this,'data.Message'), e);
};

this.t93= function(e){
this.setLocalValue('class',  Atom.get(this,'data.Confirm') ? 'confirm-buttons' : 'alert-buttons' , e);
};

this.t94= function(e){
this.setLocalValue('eventClick', Atom.get(this,'templateParent.closeCommand'), e);
};

this.t95= function(e){
this.setLocalValue('eventClick',  [ { data: { ConfirmValue: true } } , Atom.get(this,'templateParent.closeCommand') ] , e);
};

this.t96= function(e){
this.setLocalValue('eventClick', Atom.get(this,'templateParent.closeCommand'), e);
};

/* WebAtoms.AtomWindow.frameTemplate */
this.t97= function(e){
this.bind(e,'styleWidth',[
	['appScope', 'owner', 'bodyWidth']],
			0, function(v1){
				 return v1 + 'px'; 
			});
	this.bind(e,'styleHeight',[
	['appScope', 'owner', 'appHeight']],
			0, function(v1){
				 return v1 + 'px'; 
			});
	this.bind(e,'styleDisplay',[
	['isOpen']],
			0, function(v1){
				 return v1 ? 'block' : 'none'; 
			});
};

this.t98= function(e){
this.bind(e,'styleWidth',[
	['atomParent', 'windowWidth']],
			0, function(v1){
				 return v1 + 'px'; 
			});
	this.bind(e,'styleHeight',[
	['atomParent', 'windowHeight']],
			0, function(v1){
				 return v1 + 'px'; 
			});
	this.bind(e,'styleLeft',[
	['appScope', 'owner', 'bodyWidth'],
	['atomParent', 'windowWidth']],
			0, function(v1,v2){
				 return ((v1-v2)/2) + 'px'; 
			});
	this.bind(e,'styleTop',[
	['appScope', 'owner', 'bodyHeight'],
	['atomParent', 'windowHeight']],
			0, function(v1,v2){
				 return ((v1-v2)/2) + 'px'; 
			});
};

this.t99= function(e){
this.bind(e,'text',
	['atomParent', 'title']);
};

this.t100= function(e){
this.setLocalValue('eventClick', Atom.get(this,'atomParent.cancelCommand'), e);
};

/* WebAtoms.AtomWindow.windowTemplate */
this.t101= function(e){
this.setLocalValue('src', Atom.get(this,'templateParent.url'), e);
};

              


    }).call(WebAtoms.PageSetup,window,WebAtoms);

		/*Line 0 - 'Stop.js' */var $x = {};

/*Line 2 - 'Stop.js' */window.$x = $x;

/*Line 4 - 'Stop.js' */$x.stop = function stop(test, msg) {
/*Line 5 - 'Stop.js' */    return function () {
/*Line 6 - 'Stop.js' */        if (test)
/*Line 7 - 'Stop.js' */            throw new Error(msg);
/*Line 8 - 'Stop.js' */    }
/*Line 9 - 'Stop.js' */}

/*Line 11 - 'Stop.js' */$x.stopIf = window.stop;

/*Line 13 - 'Stop.js' */$x.timeout = function (i, actions) {
/*Line 14 - 'Stop.js' */    return function () {
/*Line 15 - 'Stop.js' */        var self = this;
/*Line 16 - 'Stop.js' */        setTimeout(function () {
/*Line 17 - 'Stop.js' */            self.invokeAction(actions);
/*Line 18 - 'Stop.js' */        }, i);
/*Line 19 - 'Stop.js' */    }
/*Line 20 - 'Stop.js' */}

/*Line 22 - 'Stop.js' */$x.invoke = function(i,d,v){
/*Line 23 - 'Stop.js' */    return function(){
/*Line 24 - 'Stop.js' */        var a = {};
/*Line 25 - 'Stop.js' */        if(v !== undefined){
/*Line 26 - 'Stop.js' */            var x = {};
/*Line 27 - 'Stop.js' */            x[d] = v;
/*Line 28 - 'Stop.js' */            a[i] = x;        
/*Line 29 - 'Stop.js' */        }else{
/*Line 30 - 'Stop.js' */            a[i] = d;
/*Line 31 - 'Stop.js' */        }
/*Line 32 - 'Stop.js' */        this.invokeAction(a);
/*Line 33 - 'Stop.js' */    }
/*Line 34 - 'Stop.js' */}

/*Line 36 - 'Stop.js' */$x.data = function (d, v) {
/*Line 37 - 'Stop.js' */    return $x.invoke("data", d, v);
/*Line 38 - 'Stop.js' */}

/*Line 40 - 'Stop.js' */$x.scope = function (d, v) {
/*Line 41 - 'Stop.js' */    return $x.invoke("scope", d, v);
/*Line 42 - 'Stop.js' */}

/*Line 44 - 'Stop.js' */$x.localScope = function (d, v) {
/*Line 45 - 'Stop.js' */    return $x.invoke("localScope", d, v);
/*Line 46 - 'Stop.js' */}

/*Line 48 - 'Stop.js' */$x.appScope = function (d, v) {
/*Line 49 - 'Stop.js' */    return $x.invoke("appScope", d, v);
/*Line 50 - 'Stop.js' */}

/*Line 52 - 'Stop.js' */$x.owner = function (d, v) {
/*Line 53 - 'Stop.js' */    return $x.invoke("owner", d, v);
/*Line 54 - 'Stop.js' */}

/*Line 56 - 'Stop.js' */$x.if = function (c, r) {
/*Line 57 - 'Stop.js' */    if (c) return r;
/*Line 58 - 'Stop.js' */    return null;
/*Line 59 - 'Stop.js' */}

/*Line 61 - 'Stop.js' */$x.isValid = function (target, action) {
/*Line 62 - 'Stop.js' */    return function () {
/*Line 63 - 'Stop.js' */        if (action === undefined) {
/*Line 64 - 'Stop.js' */            target = o;
/*Line 65 - 'Stop.js' */            target = this;
/*Line 66 - 'Stop.js' */        }
/*Line 67 - 'Stop.js' */        target.validate();

/*Line 69 - 'Stop.js' */        var e = this.get_errors();
/*Line 70 - 'Stop.js' */        if (e && e.length) {
/*Line 71 - 'Stop.js' */            Atom.alert(Atom.mapJoin(e, "label", "\n"));
/*Line 72 - 'Stop.js' */            return;
/*Line 73 - 'Stop.js' */        }
/*Line 74 - 'Stop.js' */        this.invokeAction(action);
/*Line 75 - 'Stop.js' */    };
/*Line 76 - 'Stop.js' */}

/*Line 78 - 'Stop.js' */$x.alert = function (msg) {
/*Line 79 - 'Stop.js' */    return function () {
/*Line 80 - 'Stop.js' */        Atom.alert(msg);
/*Line 81 - 'Stop.js' */    };
/*Line 82 - 'Stop.js' */};

/*Line 84 - 'Stop.js' */$x.focus = function (e) {
/*Line 85 - 'Stop.js' */    return function () {
/*Line 86 - 'Stop.js' */        var el = e._element || e;
/*Line 87 - 'Stop.js' */        el.focus();
/*Line 88 - 'Stop.js' */    }
/*Line 89 - 'Stop.js' */};

/*Line 91 - 'Stop.js' */$x.clearErrors = function (e) {
/*Line 92 - 'Stop.js' */    return function () {
/*Line 93 - 'Stop.js' */        window.errors.clear(e._element || e, true);
/*Line 94 - 'Stop.js' */    }
/*Line 95 - 'Stop.js' */};

/*Line 97 - 'Stop.js' */$x.confirm = function (msg, actions) {
/*Line 98 - 'Stop.js' */    return function () {
/*Line 99 - 'Stop.js' */        var self = this;
/*Line 100 - 'Stop.js' */        return Atom.confirm(msg, function () {
/*Line 101 - 'Stop.js' */            self.invokeAction(actions);
/*Line 102 - 'Stop.js' */        });
/*Line 103 - 'Stop.js' */    }
/*Line 104 - 'Stop.js' */}

/*Line 106 - 'Stop.js' */$x.window = function (path, props, data, next) {
/*Line 107 - 'Stop.js' */    var a = path;
/*Line 108 - 'Stop.js' */    var self = this;
/*Line 109 - 'Stop.js' */    if (arguments.length > 1) {
/*Line 110 - 'Stop.js' */        a = {
/*Line 111 - 'Stop.js' */            path: path,
/*Line 112 - 'Stop.js' */            prop: props,
/*Line 113 - 'Stop.js' */            next: next
/*Line 114 - 'Stop.js' */        };
/*Line 115 - 'Stop.js' */        if (data) {
/*Line 116 - 'Stop.js' */            var p = a.prop || {};
/*Line 117 - 'Stop.js' */            p.data = data;
/*Line 118 - 'Stop.js' */            a.prop = p;
/*Line 119 - 'Stop.js' */        }
/*Line 120 - 'Stop.js' */    } else {
/*Line 121 - 'Stop.js' */        a = {
/*Line 122 - 'Stop.js' */            prop: a,
/*Line 123 - 'Stop.js' */            path: a.path,
/*Line 124 - 'Stop.js' */            next: a.next,
/*Line 125 - 'Stop.js' */            scope: a.scope
/*Line 126 - 'Stop.js' */        };

/*Line 128 - 'Stop.js' */    }


/*Line 131 - 'Stop.js' */    a.prop = a.prop || {};
/*Line 132 - 'Stop.js' */    for (var k in a) {
/*Line 133 - 'Stop.js' */        if (!a.hasOwnProperty(k))
/*Line 134 - 'Stop.js' */            continue;
/*Line 135 - 'Stop.js' */        if (/path|prop|next|scope/.test(k))
/*Line 136 - 'Stop.js' */            continue;
/*Line 137 - 'Stop.js' */        a.prop[k] = a[k];
/*Line 138 - 'Stop.js' */    }

/*Line 140 - 'Stop.js' */    return function () {
/*Line 141 - 'Stop.js' */        WebAtoms.AtomWindow.openNewWindow({
/*Line 142 - 'Stop.js' */            url: a,
/*Line 143 - 'Stop.js' */            scope: this.get_scope(),
/*Line 144 - 'Stop.js' */            opener: this
/*Line 145 - 'Stop.js' */        });
/*Line 146 - 'Stop.js' */    }
/*Line 147 - 'Stop.js' */};


/*Line 150 - 'Stop.js' */$x.localWindow = function (path, props, scope, next) {
/*Line 151 - 'Stop.js' */    var a = path;
/*Line 152 - 'Stop.js' */    if (arguments.length > 1) {
/*Line 153 - 'Stop.js' */        a = {
/*Line 154 - 'Stop.js' */            path: path,
/*Line 155 - 'Stop.js' */            prop: props,
/*Line 156 - 'Stop.js' */            next: next,
/*Line 157 - 'Stop.js' */            scope: scope
/*Line 158 - 'Stop.js' */        };

/*Line 160 - 'Stop.js' */    }

/*Line 162 - 'Stop.js' */    a.prop = a.prop || {};
/*Line 163 - 'Stop.js' */    for (var k in a) {
/*Line 164 - 'Stop.js' */        if (!a.hasOwnProperty(k))
/*Line 165 - 'Stop.js' */            continue;
/*Line 166 - 'Stop.js' */        if (/path|prop|next|scope/.test(k))
/*Line 167 - 'Stop.js' */            continue;
/*Line 168 - 'Stop.js' */        a.prop[k] = a[k];
/*Line 169 - 'Stop.js' */    }


/*Line 172 - 'Stop.js' */    return function () {
/*Line 173 - 'Stop.js' */        WebAtoms.AtomWindow.openNewWindow({
/*Line 174 - 'Stop.js' */            url: a,
/*Line 175 - 'Stop.js' */            scope: this.get_scope(),
/*Line 176 - 'Stop.js' */            localScope: true,
/*Line 177 - 'Stop.js' */            opener: this
/*Line 178 - 'Stop.js' */        });
/*Line 179 - 'Stop.js' */    }
/*Line 180 - 'Stop.js' */};
/*Line 0 - 'ActionSet.js' */



/*Line 4 - 'ActionSet.js' */function runAction(action,evt) {

/*Line 6 - 'ActionSet.js' */    if (!action)
/*Line 7 - 'ActionSet.js' */        return;
/*Line 8 - 'ActionSet.js' */    if (action.constructor == String) {
/*Line 9 - 'ActionSet.js' */        location.href = action;
/*Line 10 - 'ActionSet.js' */    }
/*Line 11 - 'ActionSet.js' */    else {

/*Line 13 - 'ActionSet.js' */        var f = action;

/*Line 15 - 'ActionSet.js' */        if (f.isMVVMAtomCommand) {
/*Line 16 - 'ActionSet.js' */            f.execute(this);
/*Line 17 - 'ActionSet.js' */        }

/*Line 19 - 'ActionSet.js' */        // is it atomControl?
/*Line 20 - 'ActionSet.js' */        if (f.atomControl) {
/*Line 21 - 'ActionSet.js' */            f = f.atomControl;
/*Line 22 - 'ActionSet.js' */            if (f.refresh) {
/*Line 23 - 'ActionSet.js' */                f.refresh(this.get_scope(), this);
/*Line 24 - 'ActionSet.js' */            } else {
/*Line 25 - 'ActionSet.js' */                Atom.alert("no default action defined");
/*Line 26 - 'ActionSet.js' */            }
/*Line 27 - 'ActionSet.js' */        } else {
/*Line 28 - 'ActionSet.js' */            if (f._element) {
/*Line 29 - 'ActionSet.js' */                f.refresh(this.get_scope(), this);
/*Line 30 - 'ActionSet.js' */            } else {

/*Line 32 - 'ActionSet.js' */                //is it function

/*Line 34 - 'ActionSet.js' */                if ((typeof f) == 'function') {

/*Line 36 - 'ActionSet.js' */                    // invoke method...
/*Line 37 - 'ActionSet.js' */                    f.call(this, this.get_scope(), this, evt);
/*Line 38 - 'ActionSet.js' */                } else {

/*Line 40 - 'ActionSet.js' */                    // it is an array...
/*Line 41 - 'ActionSet.js' */                    if (f.length) {

/*Line 43 - 'ActionSet.js' */                        ae = new AtomEnumerator(f);
/*Line 44 - 'ActionSet.js' */                        while (ae.next()) {
/*Line 45 - 'ActionSet.js' */                            this.invokeAction(ae.current(), evt);
/*Line 46 - 'ActionSet.js' */                        }
/*Line 47 - 'ActionSet.js' */                        return;
/*Line 48 - 'ActionSet.js' */                    }

/*Line 50 - 'ActionSet.js' */                    // identify scope and actions...
/*Line 51 - 'ActionSet.js' */                    var action = (f.timeOut || f.timeout);
/*Line 52 - 'ActionSet.js' */                    if (action) {
/*Line 53 - 'ActionSet.js' */                        var _this = this;
/*Line 54 - 'ActionSet.js' */                        var tm = 100;
/*Line 55 - 'ActionSet.js' */                        if (action.hasOwnProperty("length")) {
/*Line 56 - 'ActionSet.js' */                            if (action.length > 1) {
/*Line 57 - 'ActionSet.js' */                                tm = action[0];
/*Line 58 - 'ActionSet.js' */                                action = action[1];
/*Line 59 - 'ActionSet.js' */                            }
/*Line 60 - 'ActionSet.js' */                        }
/*Line 61 - 'ActionSet.js' */                        setTimeout(function () {
/*Line 62 - 'ActionSet.js' */                            _this.invokeAction(action);
/*Line 63 - 'ActionSet.js' */                        }, tm);
/*Line 64 - 'ActionSet.js' */                        return;
/*Line 65 - 'ActionSet.js' */                    }
/*Line 66 - 'ActionSet.js' */                    this.set_merge(f);
/*Line 67 - 'ActionSet.js' */                    action = f.confirm;
/*Line 68 - 'ActionSet.js' */                    if (action) {
/*Line 69 - 'ActionSet.js' */                        var msg = "Are you sure?";
/*Line 70 - 'ActionSet.js' */                        if (action.hasOwnProperty("length")) {
/*Line 71 - 'ActionSet.js' */                            if (action.length > 1) {
/*Line 72 - 'ActionSet.js' */                                msg = action[0];
/*Line 73 - 'ActionSet.js' */                                action = action[1];
/*Line 74 - 'ActionSet.js' */                            } else {
/*Line 75 - 'ActionSet.js' */                                action = action[0];
/*Line 76 - 'ActionSet.js' */                            }
/*Line 77 - 'ActionSet.js' */                        }
/*Line 78 - 'ActionSet.js' */                        var _this = this;
/*Line 79 - 'ActionSet.js' */                        var _action = action;
/*Line 80 - 'ActionSet.js' */                        var _evt = evt;
/*Line 81 - 'ActionSet.js' */                        Atom.confirm(msg, function () {
/*Line 82 - 'ActionSet.js' */                            _this.invokeAction(_action, _evt);
/*Line 83 - 'ActionSet.js' */                        });
/*Line 84 - 'ActionSet.js' */                    }
/*Line 85 - 'ActionSet.js' */                    action = f.alert;
/*Line 86 - 'ActionSet.js' */                    if (action) {
/*Line 87 - 'ActionSet.js' */                        Atom.alert(action);
/*Line 88 - 'ActionSet.js' */                    }
/*Line 89 - 'ActionSet.js' */                    action = f.next;
/*Line 90 - 'ActionSet.js' */                    if (action) {
/*Line 91 - 'ActionSet.js' */                        this.invokeAction(action, evt);
/*Line 92 - 'ActionSet.js' */                        return;
/*Line 93 - 'ActionSet.js' */                    }
/*Line 94 - 'ActionSet.js' */                    action = f.control;
/*Line 95 - 'ActionSet.js' */                    if (action) {
/*Line 96 - 'ActionSet.js' */                        allControls[action].refresh();
/*Line 97 - 'ActionSet.js' */                    }
/*Line 98 - 'ActionSet.js' */                    action = f.window;
/*Line 99 - 'ActionSet.js' */                    if (action) {
/*Line 100 - 'ActionSet.js' */                        WebAtoms.AtomWindow.openNewWindow({
/*Line 101 - 'ActionSet.js' */                            url: action,
/*Line 102 - 'ActionSet.js' */                            localScope: false,
/*Line 103 - 'ActionSet.js' */                            opener: this,
/*Line 104 - 'ActionSet.js' */                            scope: this.get_scope()
/*Line 105 - 'ActionSet.js' */                        });
/*Line 106 - 'ActionSet.js' */                    }
/*Line 107 - 'ActionSet.js' */                    action = f.localWindow;
/*Line 108 - 'ActionSet.js' */                    if (action) {
/*Line 109 - 'ActionSet.js' */                        WebAtoms.AtomWindow.openNewWindow({
/*Line 110 - 'ActionSet.js' */                            url: action,
/*Line 111 - 'ActionSet.js' */                            localScope: true,
/*Line 112 - 'ActionSet.js' */                            opener: this,
/*Line 113 - 'ActionSet.js' */                            scope: this.get_scope()
/*Line 114 - 'ActionSet.js' */                        });
/*Line 115 - 'ActionSet.js' */                    }

/*Line 117 - 'ActionSet.js' */                }
/*Line 118 - 'ActionSet.js' */            }
/*Line 119 - 'ActionSet.js' */        }
/*Line 120 - 'ActionSet.js' */    }
/*Line 121 - 'ActionSet.js' */}
/*Line 0 - 'atom-filter.js' */(function (window) {

/*Line 2 - 'atom-filter.js' */    var AtomEnumerator = function (a) {
/*Line 3 - 'atom-filter.js' */        this.a = a;
/*Line 4 - 'atom-filter.js' */        this.i = -1;
/*Line 5 - 'atom-filter.js' */    };
/*Line 6 - 'atom-filter.js' */    AtomEnumerator.prototype = {
/*Line 7 - 'atom-filter.js' */        next: function () {
/*Line 8 - 'atom-filter.js' */            this.i++;
/*Line 9 - 'atom-filter.js' */            return this.i < this.a.length;
/*Line 10 - 'atom-filter.js' */        },
/*Line 11 - 'atom-filter.js' */        current: function () {
/*Line 12 - 'atom-filter.js' */            return this.a[this.i];
/*Line 13 - 'atom-filter.js' */        }
/*Line 14 - 'atom-filter.js' */    };


/*Line 17 - 'atom-filter.js' */    var AtomFilter = {
/*Line 18 - 'atom-filter.js' */        truef: function () {
/*Line 19 - 'atom-filter.js' */            return true;
/*Line 20 - 'atom-filter.js' */        },
/*Line 21 - 'atom-filter.js' */        falsef: function () {
/*Line 22 - 'atom-filter.js' */            return false;
/*Line 23 - 'atom-filter.js' */        },

/*Line 25 - 'atom-filter.js' */        get: function (item, n) {
/*Line 26 - 'atom-filter.js' */            if (!item)
/*Line 27 - 'atom-filter.js' */                return;
/*Line 28 - 'atom-filter.js' */            var i = n.indexOf('.');
/*Line 29 - 'atom-filter.js' */            if (i === -1) {
/*Line 30 - 'atom-filter.js' */                return item[n];
/*Line 31 - 'atom-filter.js' */            }
/*Line 32 - 'atom-filter.js' */            var l = n.substr(0, i);
/*Line 33 - 'atom-filter.js' */            n = n.substr(i + 1);
/*Line 34 - 'atom-filter.js' */            return AtomFilter.get(item[l], n);
/*Line 35 - 'atom-filter.js' */        },

/*Line 37 - 'atom-filter.js' */        escapeRegex: function (b, value, a, f) {
/*Line 38 - 'atom-filter.js' */            if (!value)
/*Line 39 - 'atom-filter.js' */                return {
/*Line 40 - 'atom-filter.js' */                    test: AtomFilter.falsef
/*Line 41 - 'atom-filter.js' */                };
/*Line 42 - 'atom-filter.js' */            var r = value.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
/*Line 43 - 'atom-filter.js' */            if (b) r = b + r;
/*Line 44 - 'atom-filter.js' */            if (a) r = r + a;
/*Line 45 - 'atom-filter.js' */            return new RegExp(r, f);
/*Line 46 - 'atom-filter.js' */        },

/*Line 48 - 'atom-filter.js' */        compare: function (cmp, r) {
/*Line 49 - 'atom-filter.js' */            switch (cmp) {
/*Line 50 - 'atom-filter.js' */                case "==":
/*Line 51 - 'atom-filter.js' */                case "=":
/*Line 52 - 'atom-filter.js' */                    return function (l) {
/*Line 53 - 'atom-filter.js' */                        return l == r;
/*Line 54 - 'atom-filter.js' */                    };
/*Line 55 - 'atom-filter.js' */                case "<=":
/*Line 56 - 'atom-filter.js' */                    return function (l) {
/*Line 57 - 'atom-filter.js' */                        return l <= r;
/*Line 58 - 'atom-filter.js' */                    };
/*Line 59 - 'atom-filter.js' */                case ">=":
/*Line 60 - 'atom-filter.js' */                    return function (l) {
/*Line 61 - 'atom-filter.js' */                        return l >= r;
/*Line 62 - 'atom-filter.js' */                    };
/*Line 63 - 'atom-filter.js' */                case "<":
/*Line 64 - 'atom-filter.js' */                    return function (l) {
/*Line 65 - 'atom-filter.js' */                        return l < r;
/*Line 66 - 'atom-filter.js' */                    };
/*Line 67 - 'atom-filter.js' */                case ">":
/*Line 68 - 'atom-filter.js' */                    return function (l) {
/*Line 69 - 'atom-filter.js' */                        return l > r;
/*Line 70 - 'atom-filter.js' */                    };
/*Line 71 - 'atom-filter.js' */                case "between":
/*Line 72 - 'atom-filter.js' */                    return function (l) {
/*Line 73 - 'atom-filter.js' */                        return l >= r[0] && l <= r[1];
/*Line 74 - 'atom-filter.js' */                    };
/*Line 75 - 'atom-filter.js' */                case "equals":
/*Line 76 - 'atom-filter.js' */                    r = AtomFilter.escapeRegex("^", r, "$", "i");
/*Line 77 - 'atom-filter.js' */                    return function (l) {
/*Line 78 - 'atom-filter.js' */                        if (!l)
/*Line 79 - 'atom-filter.js' */                            return !r;
/*Line 80 - 'atom-filter.js' */                        return r.test(l);
/*Line 81 - 'atom-filter.js' */                    };

/*Line 83 - 'atom-filter.js' */                case "contains":
/*Line 84 - 'atom-filter.js' */                    r = AtomFilter.escapeRegex("", r, "", "i");
/*Line 85 - 'atom-filter.js' */                    return function (l) {
/*Line 86 - 'atom-filter.js' */                        if (!l) return false;
/*Line 87 - 'atom-filter.js' */                        return r.test(l);
/*Line 88 - 'atom-filter.js' */                    };
/*Line 89 - 'atom-filter.js' */                case "startswith":
/*Line 90 - 'atom-filter.js' */                    r = AtomFilter.escapeRegex("^", r, "", "i");
/*Line 91 - 'atom-filter.js' */                    return function (l) {
/*Line 92 - 'atom-filter.js' */                        if (!l)
/*Line 93 - 'atom-filter.js' */                            return !r;
/*Line 94 - 'atom-filter.js' */                        return r.test(l);
/*Line 95 - 'atom-filter.js' */                    };
/*Line 96 - 'atom-filter.js' */                case "endswith":
/*Line 97 - 'atom-filter.js' */                    r = AtomFilter.escapeRegex("", r, "$", "i");
/*Line 98 - 'atom-filter.js' */                    return function (l) {
/*Line 99 - 'atom-filter.js' */                        if (!l)
/*Line 100 - 'atom-filter.js' */                            return !r;
/*Line 101 - 'atom-filter.js' */                        return r.test(l);
/*Line 102 - 'atom-filter.js' */                    };

/*Line 104 - 'atom-filter.js' */                case "equals":
/*Line 105 - 'atom-filter.js' */                    r = AtomFilter.escapeRegex("^", r, "$");
/*Line 106 - 'atom-filter.js' */                    return function (l) {
/*Line 107 - 'atom-filter.js' */                        if (!l)
/*Line 108 - 'atom-filter.js' */                            return !r;
/*Line 109 - 'atom-filter.js' */                        return r.test(l);
/*Line 110 - 'atom-filter.js' */                    };

/*Line 112 - 'atom-filter.js' */                case "containscs":
/*Line 113 - 'atom-filter.js' */                    r = AtomFilter.escapeRegex("", r, "");
/*Line 114 - 'atom-filter.js' */                    return function (l) {
/*Line 115 - 'atom-filter.js' */                        if (!l) return false;
/*Line 116 - 'atom-filter.js' */                        return r.test(l);
/*Line 117 - 'atom-filter.js' */                    };
/*Line 118 - 'atom-filter.js' */                case "startswithcs":
/*Line 119 - 'atom-filter.js' */                    r = AtomFilter.escapeRegex("^", r, "");
/*Line 120 - 'atom-filter.js' */                    return function (l) {
/*Line 121 - 'atom-filter.js' */                        if (!l)
/*Line 122 - 'atom-filter.js' */                            return !r;
/*Line 123 - 'atom-filter.js' */                        return r.test(l);
/*Line 124 - 'atom-filter.js' */                    };
/*Line 125 - 'atom-filter.js' */                case "endswithcs":
/*Line 126 - 'atom-filter.js' */                    r = AtomFilter.escapeRegex("", r, "$");
/*Line 127 - 'atom-filter.js' */                    return function (l) {
/*Line 128 - 'atom-filter.js' */                        if (!l)
/*Line 129 - 'atom-filter.js' */                            return !r;
/*Line 130 - 'atom-filter.js' */                        return r.test(l);
/*Line 131 - 'atom-filter.js' */                    };
/*Line 132 - 'atom-filter.js' */                case "~":
/*Line 133 - 'atom-filter.js' */                    return function (l) {
/*Line 134 - 'atom-filter.js' */                        return r.test(l);
/*Line 135 - 'atom-filter.js' */                    };

/*Line 137 - 'atom-filter.js' */                case "in":
/*Line 138 - 'atom-filter.js' */                    return function (l) {
/*Line 139 - 'atom-filter.js' */                        if (!l) return false;
/*Line 140 - 'atom-filter.js' */                        var ae = new AtomEnumerator(r);
/*Line 141 - 'atom-filter.js' */                        while (ae.next()) {
/*Line 142 - 'atom-filter.js' */                            var item = ae.current();
/*Line 143 - 'atom-filter.js' */                            if (item == l)
/*Line 144 - 'atom-filter.js' */                                return true;
/*Line 145 - 'atom-filter.js' */                        }
/*Line 146 - 'atom-filter.js' */                        return false;
/*Line 147 - 'atom-filter.js' */                    };
/*Line 148 - 'atom-filter.js' */                    // has a value in an array
/*Line 149 - 'atom-filter.js' */                case "has":
/*Line 150 - 'atom-filter.js' */                    return function (l) {
/*Line 151 - 'atom-filter.js' */                        if (!l) return false;
/*Line 152 - 'atom-filter.js' */                        var ae = new AtomEnumerator(l);
/*Line 153 - 'atom-filter.js' */                        while (ae.next()) {
/*Line 154 - 'atom-filter.js' */                            var item = ae.current();
/*Line 155 - 'atom-filter.js' */                            if (item == r)
/*Line 156 - 'atom-filter.js' */                                return true;
/*Line 157 - 'atom-filter.js' */                        }
/*Line 158 - 'atom-filter.js' */                        return false;
/*Line 159 - 'atom-filter.js' */                    }
/*Line 160 - 'atom-filter.js' */                case "any":
/*Line 161 - 'atom-filter.js' */                    var rf = AtomFilter.filter(r);
/*Line 162 - 'atom-filter.js' */                    return function (l) {
/*Line 163 - 'atom-filter.js' */                        if (!l) return false;
/*Line 164 - 'atom-filter.js' */                        var ae = new AtomEnumerator(l);
/*Line 165 - 'atom-filter.js' */                        while (ae.next()) {
/*Line 166 - 'atom-filter.js' */                            var item = ae.current();
/*Line 167 - 'atom-filter.js' */                            if (rf(item))
/*Line 168 - 'atom-filter.js' */                                return true;
/*Line 169 - 'atom-filter.js' */                        }
/*Line 170 - 'atom-filter.js' */                        return false;
/*Line 171 - 'atom-filter.js' */                    }
/*Line 172 - 'atom-filter.js' */                case "all":
/*Line 173 - 'atom-filter.js' */                    var rf = AtomFilter.filter(r);
/*Line 174 - 'atom-filter.js' */                    return function (l) {
/*Line 175 - 'atom-filter.js' */                        if (!l) return false;
/*Line 176 - 'atom-filter.js' */                        var ae = new AtomEnumerator(l);
/*Line 177 - 'atom-filter.js' */                        while (ae.next()) {
/*Line 178 - 'atom-filter.js' */                            if (!rf(item))
/*Line 179 - 'atom-filter.js' */                                return false;
/*Line 180 - 'atom-filter.js' */                        }
/*Line 181 - 'atom-filter.js' */                        return true;
/*Line 182 - 'atom-filter.js' */                    }
/*Line 183 - 'atom-filter.js' */                default:
/*Line 184 - 'atom-filter.js' */                    return function (l) {
/*Line 185 - 'atom-filter.js' */                        return false;
/*Line 186 - 'atom-filter.js' */                    };
/*Line 187 - 'atom-filter.js' */            }
/*Line 188 - 'atom-filter.js' */        },

/*Line 190 - 'atom-filter.js' */        isString: function (a) {
/*Line 191 - 'atom-filter.js' */            return typeof a == 'string' || a instanceof String;
/*Line 192 - 'atom-filter.js' */        },

/*Line 194 - 'atom-filter.js' */        sort: function (orderBy) {

/*Line 196 - 'atom-filter.js' */            if (!AtomFilter.isString(orderBy)) {
/*Line 197 - 'atom-filter.js' */                return orderBy;
/*Line 198 - 'atom-filter.js' */            }

/*Line 200 - 'atom-filter.js' */            var fields = orderBy.split(',');
/*Line 201 - 'atom-filter.js' */            fields = fields.map(function (item) {
/*Line 202 - 'atom-filter.js' */                var tokens = item.split(' ');
/*Line 203 - 'atom-filter.js' */                var desc = tokens[1] || 'asc';
/*Line 204 - 'atom-filter.js' */                return {
/*Line 205 - 'atom-filter.js' */                    field: tokens[0],
/*Line 206 - 'atom-filter.js' */                    desc: /desc/i.test(desc),
/*Line 207 - 'atom-filter.js' */                    cs: /^cs/i.test(desc)
/*Line 208 - 'atom-filter.js' */                }
/*Line 209 - 'atom-filter.js' */            });

/*Line 211 - 'atom-filter.js' */            return function (a, b) {

/*Line 213 - 'atom-filter.js' */                if (a == null || a == undefined) {
/*Line 214 - 'atom-filter.js' */                    return b == null || b == undefined ? 0 : 1;
/*Line 215 - 'atom-filter.js' */                }
/*Line 216 - 'atom-filter.js' */                if (b == null || b == undefined) {
/*Line 217 - 'atom-filter.js' */                    return 1;
/*Line 218 - 'atom-filter.js' */                }

/*Line 220 - 'atom-filter.js' */                for (var i = 0; i < fields.length; i++) {
/*Line 221 - 'atom-filter.js' */                    var f = fields[i];
/*Line 222 - 'atom-filter.js' */                    var field = f.field;
/*Line 223 - 'atom-filter.js' */                    var af = a[field];
/*Line 224 - 'atom-filter.js' */                    var bf = b[field];
/*Line 225 - 'atom-filter.js' */                    if (f.desc) {
/*Line 226 - 'atom-filter.js' */                        var t = af;
/*Line 227 - 'atom-filter.js' */                        af = bf;
/*Line 228 - 'atom-filter.js' */                        bf = t;
/*Line 229 - 'atom-filter.js' */                    }
/*Line 230 - 'atom-filter.js' */                    if (af == bf)
/*Line 231 - 'atom-filter.js' */                        continue;
/*Line 232 - 'atom-filter.js' */                    if (!af) {
/*Line 233 - 'atom-filter.js' */                        return !bf ? 0 : -1;
/*Line 234 - 'atom-filter.js' */                    }
/*Line 235 - 'atom-filter.js' */                    if (!bf) {
/*Line 236 - 'atom-filter.js' */                        return !af ? 0 : 1;
/*Line 237 - 'atom-filter.js' */                    }
/*Line 238 - 'atom-filter.js' */                    if (AtomFilter.isString(af)) {
/*Line 239 - 'atom-filter.js' */                        if (f.cs) {
/*Line 240 - 'atom-filter.js' */                            return af.localeCompare(bf);
/*Line 241 - 'atom-filter.js' */                        } else {
/*Line 242 - 'atom-filter.js' */                            af = af.toLowerCase();
/*Line 243 - 'atom-filter.js' */                            bf = bf.toLowerCase();
/*Line 244 - 'atom-filter.js' */                            if (af == bf)
/*Line 245 - 'atom-filter.js' */                                continue;
/*Line 246 - 'atom-filter.js' */                            return af.localeCompare(bf);
/*Line 247 - 'atom-filter.js' */                        }
/*Line 248 - 'atom-filter.js' */                    }

/*Line 250 - 'atom-filter.js' */                }
/*Line 251 - 'atom-filter.js' */                return 0;
/*Line 252 - 'atom-filter.js' */            }
/*Line 253 - 'atom-filter.js' */        },

/*Line 255 - 'atom-filter.js' */        build: function (ae, i, v, q, cor) {
/*Line 256 - 'atom-filter.js' */            if (i === '$or') {
/*Line 257 - 'atom-filter.js' */                var orf = AtomFilter.filter(v, true);
/*Line 258 - 'atom-filter.js' */                ae.push(function (item) {
/*Line 259 - 'atom-filter.js' */                    return orf(item);
/*Line 260 - 'atom-filter.js' */                });
/*Line 261 - 'atom-filter.js' */                return;
/*Line 262 - 'atom-filter.js' */            }
/*Line 263 - 'atom-filter.js' */            if (i === '$and') {
/*Line 264 - 'atom-filter.js' */                var orf = AtomFilter.filter(v, false);
/*Line 265 - 'atom-filter.js' */                ae.push(function (item) {
/*Line 266 - 'atom-filter.js' */                    return orf(item);
/*Line 267 - 'atom-filter.js' */                });
/*Line 268 - 'atom-filter.js' */                return;
/*Line 269 - 'atom-filter.js' */            }
/*Line 270 - 'atom-filter.js' */            if (i === '$not') {
/*Line 271 - 'atom-filter.js' */                var fn = AtomFilter.filter(v, cor);
/*Line 272 - 'atom-filter.js' */                ae.push(function (item) {
/*Line 273 - 'atom-filter.js' */                    return !fn(item);
/*Line 274 - 'atom-filter.js' */                });
/*Line 275 - 'atom-filter.js' */                return;
/*Line 276 - 'atom-filter.js' */            }
/*Line 277 - 'atom-filter.js' */            var args = i.split(' ');
/*Line 278 - 'atom-filter.js' */            if (args.length === 1) {
/*Line 279 - 'atom-filter.js' */                args = i.split(':');
/*Line 280 - 'atom-filter.js' */            }

/*Line 282 - 'atom-filter.js' */            var n = args[0];
/*Line 283 - 'atom-filter.js' */            var cond = "==";
/*Line 284 - 'atom-filter.js' */            if (args.length === 2) {
/*Line 285 - 'atom-filter.js' */                cond = args[1];
/*Line 286 - 'atom-filter.js' */            }

/*Line 288 - 'atom-filter.js' */            var left = function (item) {
/*Line 289 - 'atom-filter.js' */                return AtomFilter.get(item, n);
/*Line 290 - 'atom-filter.js' */            };
/*Line 291 - 'atom-filter.js' */            if (cond.indexOf('!') !== 0) {
/*Line 292 - 'atom-filter.js' */                var compF = AtomFilter.compare(cond, v);
/*Line 293 - 'atom-filter.js' */                var fx = function (item) {
/*Line 294 - 'atom-filter.js' */                    var l = left(item);
/*Line 295 - 'atom-filter.js' */                    return compF(l);
/*Line 296 - 'atom-filter.js' */                };
/*Line 297 - 'atom-filter.js' */                ae.push(fx);

/*Line 299 - 'atom-filter.js' */            } else {
/*Line 300 - 'atom-filter.js' */                cond = cond.substr(1);
/*Line 301 - 'atom-filter.js' */                var compF = AtomFilter.compare(cond, v);
/*Line 302 - 'atom-filter.js' */                var fx = function (item) {
/*Line 303 - 'atom-filter.js' */                    var l = left(item);
/*Line 304 - 'atom-filter.js' */                    return !compF(l);
/*Line 305 - 'atom-filter.js' */                };
/*Line 306 - 'atom-filter.js' */                ae.push(fx);
/*Line 307 - 'atom-filter.js' */            }
/*Line 308 - 'atom-filter.js' */        },

/*Line 310 - 'atom-filter.js' */        filter: function (q, cor) {
/*Line 311 - 'atom-filter.js' */            // compiles json object into function
/*Line 312 - 'atom-filter.js' */            // that accepts object and returns true/false

/*Line 314 - 'atom-filter.js' */            if (q === false)
/*Line 315 - 'atom-filter.js' */                return AtomFilter.falsef;
/*Line 316 - 'atom-filter.js' */            if (!q)
/*Line 317 - 'atom-filter.js' */                return AtomFilter.truef;

/*Line 319 - 'atom-filter.js' */            var ae = [];

/*Line 321 - 'atom-filter.js' */            for (var i in q) {
/*Line 322 - 'atom-filter.js' */                if (!q.hasOwnProperty(i))
/*Line 323 - 'atom-filter.js' */                    continue;
/*Line 324 - 'atom-filter.js' */                var v = q[i];
/*Line 325 - 'atom-filter.js' */                AtomFilter.build(ae, i, v, q, cor);
/*Line 326 - 'atom-filter.js' */            }

/*Line 328 - 'atom-filter.js' */            return function (item) {

/*Line 330 - 'atom-filter.js' */                var e = new AtomEnumerator(ae);
/*Line 331 - 'atom-filter.js' */                var a = [];
/*Line 332 - 'atom-filter.js' */                while (e.next()) {
/*Line 333 - 'atom-filter.js' */                    var ec = e.current();
/*Line 334 - 'atom-filter.js' */                    var r = ec(item);
/*Line 335 - 'atom-filter.js' */                    a.push(r);
/*Line 336 - 'atom-filter.js' */                    if (r) {
/*Line 337 - 'atom-filter.js' */                        if (cor) {
/*Line 338 - 'atom-filter.js' */                            return true;
/*Line 339 - 'atom-filter.js' */                        }
/*Line 340 - 'atom-filter.js' */                    } else {
/*Line 341 - 'atom-filter.js' */                        if (!cor)
/*Line 342 - 'atom-filter.js' */                            return false;
/*Line 343 - 'atom-filter.js' */                    }
/*Line 344 - 'atom-filter.js' */                }

/*Line 346 - 'atom-filter.js' */                e = new AtomEnumerator(a);
/*Line 347 - 'atom-filter.js' */                while (e.next()) {
/*Line 348 - 'atom-filter.js' */                    if (!e.current())
/*Line 349 - 'atom-filter.js' */                        return false;
/*Line 350 - 'atom-filter.js' */                }

/*Line 352 - 'atom-filter.js' */                return true;
/*Line 353 - 'atom-filter.js' */            };

/*Line 355 - 'atom-filter.js' */        }

/*Line 357 - 'atom-filter.js' */    };

/*Line 359 - 'atom-filter.js' */    window.$f = AtomFilter.filter;

/*Line 361 - 'atom-filter.js' */    if (!Array.prototype.filter) {
/*Line 362 - 'atom-filter.js' */        Array.prototype.filter = function (f) {
/*Line 363 - 'atom-filter.js' */            var r = [];
/*Line 364 - 'atom-filter.js' */            for (var i = 0; i < this.length; i++) {
/*Line 365 - 'atom-filter.js' */                var v = this[i];
/*Line 366 - 'atom-filter.js' */                if (f(v, i)) r.push(v);
/*Line 367 - 'atom-filter.js' */            }
/*Line 368 - 'atom-filter.js' */            return r;
/*Line 369 - 'atom-filter.js' */        };
/*Line 370 - 'atom-filter.js' */    }

/*Line 372 - 'atom-filter.js' */    var af = Array.prototype.filter;

/*Line 374 - 'atom-filter.js' */    Array.prototype.filter = function (i) {
/*Line 375 - 'atom-filter.js' */        if (i instanceof Function || typeof i == 'function') {
/*Line 376 - 'atom-filter.js' */            return af.call(this, i);
/*Line 377 - 'atom-filter.js' */        }
/*Line 378 - 'atom-filter.js' */        return af.call(this, $f(i));
/*Line 379 - 'atom-filter.js' */    };

/*Line 381 - 'atom-filter.js' */    var aps = Array.prototype.sort;

/*Line 383 - 'atom-filter.js' */    Array.prototype.sort = function (s) {
/*Line 384 - 'atom-filter.js' */        var f = AtomFilter.sort(s);
/*Line 385 - 'atom-filter.js' */        return aps.call(this, f);
/*Line 386 - 'atom-filter.js' */    };

/*Line 388 - 'atom-filter.js' */    window.AtomFilter = AtomFilter;

/*Line 390 - 'atom-filter.js' */})(window);
/*Line 0 - 'AtomBrowser.js' */var AtomConfig = {
/*Line 1 - 'AtomBrowser.js' */    debug: false,
/*Line 2 - 'AtomBrowser.js' */    baseUrl: "",
/*Line 3 - 'AtomBrowser.js' */    log: "",    
/*Line 4 - 'AtomBrowser.js' */    ajax: {
/*Line 5 - 'AtomBrowser.js' */        versionUrl: true,
/*Line 6 - 'AtomBrowser.js' */        versionKey: "__wav",
/*Line 7 - 'AtomBrowser.js' */        version: ((new Date()).toDateString()),
/*Line 8 - 'AtomBrowser.js' */        headers: {
/*Line 9 - 'AtomBrowser.js' */        }
/*Line 10 - 'AtomBrowser.js' */    }
/*Line 11 - 'AtomBrowser.js' */};

/*Line 13 - 'AtomBrowser.js' */window.AtomConfig = AtomConfig;


/*Line 16 - 'AtomBrowser.js' */var log = function log(s) {

/*Line 18 - 'AtomBrowser.js' */    if (window.console) {
/*Line 19 - 'AtomBrowser.js' */        console.log(s);
/*Line 20 - 'AtomBrowser.js' */    }

/*Line 22 - 'AtomBrowser.js' */    AtomConfig.log += s + "\r\n";

/*Line 24 - 'AtomBrowser.js' */};

/*Line 26 - 'AtomBrowser.js' */window.log = log;

/*Line 28 - 'AtomBrowser.js' */var AtomBrowser = {
/*Line 29 - 'AtomBrowser.js' */    browserName: "",
/*Line 30 - 'AtomBrowser.js' */    version: "1.0",
/*Line 31 - 'AtomBrowser.js' */    majorVersion: 1,
/*Line 32 - 'AtomBrowser.js' */    isMobile: false,
/*Line 33 - 'AtomBrowser.js' */    userAgent:'',
/*Line 34 - 'AtomBrowser.js' */    detect: function () {
/*Line 35 - 'AtomBrowser.js' */        var nVer = navigator.appVersion;
/*Line 36 - 'AtomBrowser.js' */        var nAgt = navigator.userAgent;
/*Line 37 - 'AtomBrowser.js' */        this.userAgent = nAgt;
/*Line 38 - 'AtomBrowser.js' */        var browserName = navigator.appName;
/*Line 39 - 'AtomBrowser.js' */        var fullVersion = "" + parseFloat(navigator.appVersion);
/*Line 40 - 'AtomBrowser.js' */        var majorVersion = parseInt(navigator.appVersion, 10);
/*Line 41 - 'AtomBrowser.js' */        var nameOffset, verOffset, ix;

/*Line 43 - 'AtomBrowser.js' */        // In Opera, the true version is after "Opera" or after "Version"
/*Line 44 - 'AtomBrowser.js' */        if ((verOffset = nAgt.indexOf("Opera")) != -1) {
/*Line 45 - 'AtomBrowser.js' */            browserName = "Opera";
/*Line 46 - 'AtomBrowser.js' */            fullVersion = nAgt.substring(verOffset + 6);
/*Line 47 - 'AtomBrowser.js' */            if ((verOffset = nAgt.indexOf("Version")) != -1) {
/*Line 48 - 'AtomBrowser.js' */                fullVersion = nAgt.substring(verOffset + 8);
/*Line 49 - 'AtomBrowser.js' */            }
/*Line 50 - 'AtomBrowser.js' */        }
/*Line 51 - 'AtomBrowser.js' */            // In MSIE, the true version is after "MSIE" in userAgent
/*Line 52 - 'AtomBrowser.js' */        else if ((verOffset = nAgt.indexOf("MSIE")) != -1) {
/*Line 53 - 'AtomBrowser.js' */            browserName = "Microsoft Internet Explorer";
/*Line 54 - 'AtomBrowser.js' */            fullVersion = nAgt.substring(verOffset + 5);
/*Line 55 - 'AtomBrowser.js' */        }
/*Line 56 - 'AtomBrowser.js' */                // In Chrome, the true version is after "Chrome"
/*Line 57 - 'AtomBrowser.js' */        else if ((verOffset = nAgt.indexOf("Chrome")) != -1) {
/*Line 58 - 'AtomBrowser.js' */            browserName = "Chrome";
/*Line 59 - 'AtomBrowser.js' */            fullVersion = nAgt.substring(verOffset + 7);
/*Line 60 - 'AtomBrowser.js' */        }
/*Line 61 - 'AtomBrowser.js' */                // In Safari, the true version is after "Safari" or after "Version"
/*Line 62 - 'AtomBrowser.js' */        else if ((verOffset = nAgt.indexOf("Safari")) != -1) {
/*Line 63 - 'AtomBrowser.js' */            browserName = "Safari";
/*Line 64 - 'AtomBrowser.js' */            this.isMobile = nAgt.indexOf("iPhone") != -1;
/*Line 65 - 'AtomBrowser.js' */            fullVersion = nAgt.substring(verOffset + 7);
/*Line 66 - 'AtomBrowser.js' */            if ((verOffset = nAgt.indexOf("Version")) != -1) {
/*Line 67 - 'AtomBrowser.js' */                fullVersion = nAgt.substring(verOffset + 8);
/*Line 68 - 'AtomBrowser.js' */            }
/*Line 69 - 'AtomBrowser.js' */        }
/*Line 70 - 'AtomBrowser.js' */                // In Firefox, the true version is after "Firefox"
/*Line 71 - 'AtomBrowser.js' */        else if ((verOffset = nAgt.indexOf("Firefox")) != -1) {
/*Line 72 - 'AtomBrowser.js' */            browserName = "Firefox";
/*Line 73 - 'AtomBrowser.js' */            fullVersion = nAgt.substring(verOffset + 8);
/*Line 74 - 'AtomBrowser.js' */        }
/*Line 75 - 'AtomBrowser.js' */                // In most other browsers, "name/version" is at the end of userAgent
/*Line 76 - 'AtomBrowser.js' */        else if ((nameOffset = nAgt.lastIndexOf(' ') + 1) <
/*Line 77 - 'AtomBrowser.js' */              (verOffset = nAgt.lastIndexOf('/'))) {
/*Line 78 - 'AtomBrowser.js' */                  browserName = nAgt.substring(nameOffset, verOffset);
/*Line 79 - 'AtomBrowser.js' */                  fullVersion = nAgt.substring(verOffset + 1);
/*Line 80 - 'AtomBrowser.js' */                  if (browserName.toLowerCase() == browserName.toUpperCase()) {
/*Line 81 - 'AtomBrowser.js' */                      browserName = navigator.appName;
/*Line 82 - 'AtomBrowser.js' */                  }
/*Line 83 - 'AtomBrowser.js' */              }
/*Line 84 - 'AtomBrowser.js' */        // trim the fullVersion string at semicolon/space if present
/*Line 85 - 'AtomBrowser.js' */        if ((ix = fullVersion.indexOf(";")) != -1) {
/*Line 86 - 'AtomBrowser.js' */            fullVersion = fullVersion.substring(0, ix);
/*Line 87 - 'AtomBrowser.js' */        }
/*Line 88 - 'AtomBrowser.js' */        if ((ix = fullVersion.indexOf(" ")) != -1) {
/*Line 89 - 'AtomBrowser.js' */            fullVersion = fullVersion.substring(0, ix);
/*Line 90 - 'AtomBrowser.js' */        }

/*Line 92 - 'AtomBrowser.js' */        majorVersion = parseInt('' + fullVersion, 10);
/*Line 93 - 'AtomBrowser.js' */        if (isNaN(majorVersion)) {
/*Line 94 - 'AtomBrowser.js' */            fullVersion = '' + parseFloat(navigator.appVersion);
/*Line 95 - 'AtomBrowser.js' */            majorVersion = parseInt(navigator.appVersion, 10);
/*Line 96 - 'AtomBrowser.js' */        }

/*Line 98 - 'AtomBrowser.js' */        this.browserName = browserName;
/*Line 99 - 'AtomBrowser.js' */        this.majorVersion = majorVersion;
/*Line 100 - 'AtomBrowser.js' */        this.isMobile = /android|mobile|ios|iphone/gi.test(nAgt);
/*Line 101 - 'AtomBrowser.js' */    },

/*Line 103 - 'AtomBrowser.js' */    isFF: false,
/*Line 104 - 'AtomBrowser.js' */    isChrome: false,
/*Line 105 - 'AtomBrowser.js' */    isIE: false,
/*Line 106 - 'AtomBrowser.js' */    isSafari: false,
/*Line 107 - 'AtomBrowser.js' */    isMac : false,

/*Line 109 - 'AtomBrowser.js' */    init: function () {

/*Line 111 - 'AtomBrowser.js' */        this.isMac = /mac os x/gi.test(this.userAgent) && !(/iphone|ipad/gi.test(this.userAgent));

/*Line 113 - 'AtomBrowser.js' */        switch (this.browserName) {
/*Line 114 - 'AtomBrowser.js' */            case "Firefox":
/*Line 115 - 'AtomBrowser.js' */                this.supportsUpload = this.majorVersion >= 4;
/*Line 116 - 'AtomBrowser.js' */                this.isFF = true;
/*Line 117 - 'AtomBrowser.js' */                break;
/*Line 118 - 'AtomBrowser.js' */            case "Chrome":
/*Line 119 - 'AtomBrowser.js' */                this.supportsUpload = this.majorVersion >= 6;
/*Line 120 - 'AtomBrowser.js' */                this.isChrome = true;
/*Line 121 - 'AtomBrowser.js' */                break;
/*Line 122 - 'AtomBrowser.js' */            case "Microsoft Internet Explorer":
/*Line 123 - 'AtomBrowser.js' */                this.supportsUpload = this.majorVersion >= 10;
/*Line 124 - 'AtomBrowser.js' */                this.isIE = true;
/*Line 125 - 'AtomBrowser.js' */                break;
/*Line 126 - 'AtomBrowser.js' */            case "Safari":
/*Line 127 - 'AtomBrowser.js' */                this.isSafari = true;
/*Line 128 - 'AtomBrowser.js' */                if (!this.isMobile) {
/*Line 129 - 'AtomBrowser.js' */                    this.supportsUpload = this.majorVersion >= 5;
/*Line 130 - 'AtomBrowser.js' */                }
/*Line 131 - 'AtomBrowser.js' */                break;
/*Line 132 - 'AtomBrowser.js' */        }

/*Line 134 - 'AtomBrowser.js' */        // is it ios??
/*Line 135 - 'AtomBrowser.js' */        this.supportsFlash = !this.isMobile;
/*Line 136 - 'AtomBrowser.js' */    }

/*Line 138 - 'AtomBrowser.js' */};

/*Line 140 - 'AtomBrowser.js' */window.AtomBrowser = AtomBrowser;

/*Line 142 - 'AtomBrowser.js' */AtomBrowser.detect();
/*Line 143 - 'AtomBrowser.js' */AtomBrowser.init();
/*Line 0 - 'Atom.js' */
/*Line 1 - 'Atom.js' */
/*Line 2 - 'Atom.js' */
/*Line 3 - 'Atom.js' */

/*Line 5 - 'Atom.js' */var AtomEnumerator = (function () {
/*Line 6 - 'Atom.js' */    return classCreator("AtomEnumerator",null,
/*Line 7 - 'Atom.js' */    function (array) {
/*Line 8 - 'Atom.js' */        this._array = array;
/*Line 9 - 'Atom.js' */        this.i = -1;
/*Line 10 - 'Atom.js' */    },
/*Line 11 - 'Atom.js' */    {
/*Line 12 - 'Atom.js' */        next: function () {
/*Line 13 - 'Atom.js' */            this.i = this.i + 1;
/*Line 14 - 'Atom.js' */            return this.i < this._array.length;
/*Line 15 - 'Atom.js' */        },
/*Line 16 - 'Atom.js' */        current: function () {
/*Line 17 - 'Atom.js' */            return this._array[this.i];
/*Line 18 - 'Atom.js' */        },
/*Line 19 - 'Atom.js' */        currentIndex: function () {
/*Line 20 - 'Atom.js' */            return this.i;
/*Line 21 - 'Atom.js' */        },
/*Line 22 - 'Atom.js' */        isFirst: function () {
/*Line 23 - 'Atom.js' */            return this.i == 0;
/*Line 24 - 'Atom.js' */        },
/*Line 25 - 'Atom.js' */        isLast: function () {
/*Line 26 - 'Atom.js' */            return this.i == this._array.length - 1;
/*Line 27 - 'Atom.js' */        },
/*Line 28 - 'Atom.js' */        reset: function () {
/*Line 29 - 'Atom.js' */            this.i = -1;
/*Line 30 - 'Atom.js' */        }
/*Line 31 - 'Atom.js' */    });
/*Line 32 - 'Atom.js' */})();

/*Line 34 - 'Atom.js' */window.AtomEnumerator = AtomEnumerator;
    

/*Line 37 - 'Atom.js' */var Atom = {

/*Line 39 - 'Atom.js' */    version: {
/*Line 40 - 'Atom.js' */        text: "1.8.254",
/*Line 41 - 'Atom.js' */        major: 1,
/*Line 42 - 'Atom.js' */        minor: 8,
/*Line 43 - 'Atom.js' */        build: 254
/*Line 44 - 'Atom.js' */    },

/*Line 46 - 'Atom.js' */    refreshWindowCommand: function () {
/*Line 47 - 'Atom.js' */        location.reload(true);
/*Line 48 - 'Atom.js' */        //var q = location.search || "?";
/*Line 49 - 'Atom.js' */        //var tq = q.split('&').filter(function (p) {
/*Line 50 - 'Atom.js' */        //    return !(/^\_v\=/i.test(p));
/*Line 51 - 'Atom.js' */        //}).join("&");
/*Line 52 - 'Atom.js' */        //var url = location.pathname + tq + "_v=" + (new Date()).getTime() + location.hash;
/*Line 53 - 'Atom.js' */        //if (window.console) window.console.log("Refreshing: " + url);
/*Line 54 - 'Atom.js' */        //location.href = url;
/*Line 55 - 'Atom.js' */    },

/*Line 57 - 'Atom.js' */    time: function () {
/*Line 58 - 'Atom.js' */        return (new Date()).getTime();
/*Line 59 - 'Atom.js' */    },

/*Line 61 - 'Atom.js' */    get: function (obj, path) {
/*Line 62 - 'Atom.js' */        var index = path.indexOf('.');
/*Line 63 - 'Atom.js' */        if (index != -1) {
/*Line 64 - 'Atom.js' */            var f = path.substr(0, index);
/*Line 65 - 'Atom.js' */            obj = AtomBinder.getValue(obj, f);
/*Line 66 - 'Atom.js' */            path = path.substr(index + 1);
/*Line 67 - 'Atom.js' */            return Atom.get(obj, path);
/*Line 68 - 'Atom.js' */        }
/*Line 69 - 'Atom.js' */        return AtomBinder.getValue(obj, path);
/*Line 70 - 'Atom.js' */    },

/*Line 72 - 'Atom.js' */    set: function (obj, path, val) {
/*Line 73 - 'Atom.js' */        if (!obj) return;
/*Line 74 - 'Atom.js' */        var index = path.indexOf('.');
/*Line 75 - 'Atom.js' */        if (index != -1) {
/*Line 76 - 'Atom.js' */            var f = path.substr(0, index);
/*Line 77 - 'Atom.js' */            obj = AtomBinder.getValue(obj, f);
/*Line 78 - 'Atom.js' */            path = path.substr(index + 1);
/*Line 79 - 'Atom.js' */            return Atom.set(obj, path,val);
/*Line 80 - 'Atom.js' */        }
/*Line 81 - 'Atom.js' */        AtomBinder.setValue(obj, path, val);
/*Line 82 - 'Atom.js' */    },

/*Line 84 - 'Atom.js' */    csv: function (a, path, s) {
/*Line 85 - 'Atom.js' */        if (!s) {
/*Line 86 - 'Atom.js' */            s = ", ";
/*Line 87 - 'Atom.js' */        }
/*Line 88 - 'Atom.js' */        var l = [];
/*Line 89 - 'Atom.js' */        var ae = new AtomEnumerator(a);
/*Line 90 - 'Atom.js' */        while (ae.next()) {
/*Line 91 - 'Atom.js' */            var item = ae.current();
/*Line 92 - 'Atom.js' */            l.push(Atom.get(item,path));
/*Line 93 - 'Atom.js' */        }
/*Line 94 - 'Atom.js' */        return l.join(s);
/*Line 95 - 'Atom.js' */    },

/*Line 97 - 'Atom.js' */    range: function (start, end, step) {
/*Line 98 - 'Atom.js' */        var a = [];
/*Line 99 - 'Atom.js' */        step = step || 1;
/*Line 100 - 'Atom.js' */        for (var i = start; i <= end; i+=step) {
/*Line 101 - 'Atom.js' */            a.push({ label: i, value: i });
/*Line 102 - 'Atom.js' */        }
/*Line 103 - 'Atom.js' */        return a;
/*Line 104 - 'Atom.js' */    },

/*Line 106 - 'Atom.js' */    merge: function (x, y, update, clone) {
/*Line 107 - 'Atom.js' */        //var c = AtomBinder.getClone(y);
/*Line 108 - 'Atom.js' */        if (!x)
/*Line 109 - 'Atom.js' */            return;
/*Line 110 - 'Atom.js' */        var c = clone ? AtomBinder.getClone(y) : y;
/*Line 111 - 'Atom.js' */        if (update) {
/*Line 112 - 'Atom.js' */            for (var k in c) {
/*Line 113 - 'Atom.js' */                //x[k] = c[k];
/*Line 114 - 'Atom.js' */                Atom.set(x, k, AtomBinder.getValue(c, k));
/*Line 115 - 'Atom.js' */            }
/*Line 116 - 'Atom.js' */        } else {
/*Line 117 - 'Atom.js' */            for (var k in c) {
/*Line 118 - 'Atom.js' */                x[k] = c[k];
/*Line 119 - 'Atom.js' */            }
/*Line 120 - 'Atom.js' */        }
/*Line 121 - 'Atom.js' */        return x;
/*Line 122 - 'Atom.js' */    },

/*Line 124 - 'Atom.js' */    url: function (url, q, lq) {
/*Line 125 - 'Atom.js' */        var finalUrl = url;
/*Line 126 - 'Atom.js' */        var plist = [];
/*Line 127 - 'Atom.js' */        if (q) {
/*Line 128 - 'Atom.js' */            for (var i in q) {
/*Line 129 - 'Atom.js' */                if (q.hasOwnProperty(i)) {
/*Line 130 - 'Atom.js' */                    var val = q[i];
/*Line 131 - 'Atom.js' */                    if (val === undefined)
/*Line 132 - 'Atom.js' */                        continue;
/*Line 133 - 'Atom.js' */                    if (val === null)
/*Line 134 - 'Atom.js' */                        continue;
/*Line 135 - 'Atom.js' */                    if (val && (val.constructor != String) && (typeof val) == 'object') {
/*Line 136 - 'Atom.js' */                        val = JSON.stringify(val);
/*Line 137 - 'Atom.js' */                    }
/*Line 138 - 'Atom.js' */                    plist.push(i + '=' + encodeURIComponent(val));
/*Line 139 - 'Atom.js' */                }
/*Line 140 - 'Atom.js' */            }

/*Line 142 - 'Atom.js' */            if (plist.length) {
/*Line 143 - 'Atom.js' */                var index = finalUrl.indexOf('?');
/*Line 144 - 'Atom.js' */                if (index == -1) {
/*Line 145 - 'Atom.js' */                    finalUrl += "?";
/*Line 146 - 'Atom.js' */                } else {
/*Line 147 - 'Atom.js' */                    finalUrl += '&';
/*Line 148 - 'Atom.js' */                }
/*Line 149 - 'Atom.js' */            }

/*Line 151 - 'Atom.js' */            finalUrl += plist.join('&');
/*Line 152 - 'Atom.js' */        }

/*Line 154 - 'Atom.js' */        if (lq) {
/*Line 155 - 'Atom.js' */            plist = [];
/*Line 156 - 'Atom.js' */            for (var i in lq) {
/*Line 157 - 'Atom.js' */                if (lq.hasOwnProperty(i)) {
/*Line 158 - 'Atom.js' */                    var val = lq[i];
/*Line 159 - 'Atom.js' */                    if (val === undefined || val === null)
/*Line 160 - 'Atom.js' */                        continue;
/*Line 161 - 'Atom.js' */                    plist.push(i + '=' + encodeURIComponent(val));
/*Line 162 - 'Atom.js' */                }
/*Line 163 - 'Atom.js' */            }
/*Line 164 - 'Atom.js' */            if (plist.length) {
/*Line 165 - 'Atom.js' */                finalUrl += '#' + plist.join("&");
/*Line 166 - 'Atom.js' */            }
/*Line 167 - 'Atom.js' */        }

/*Line 169 - 'Atom.js' */        return finalUrl;
/*Line 170 - 'Atom.js' */    },

/*Line 172 - 'Atom.js' */    encodeParameters: function (q) {
/*Line 173 - 'Atom.js' */        var plist = [];
/*Line 174 - 'Atom.js' */        for (var i in q) {
/*Line 175 - 'Atom.js' */            if (i.indexOf('_') == 0)
/*Line 176 - 'Atom.js' */                continue;
/*Line 177 - 'Atom.js' */            var val = q[i];
/*Line 178 - 'Atom.js' */            if (val === undefined)
/*Line 179 - 'Atom.js' */                continue;
/*Line 180 - 'Atom.js' */            if (val === null)
/*Line 181 - 'Atom.js' */                continue;
/*Line 182 - 'Atom.js' */            var t = typeof(val);
/*Line 183 - 'Atom.js' */            if (t != 'string' && t != 'number' && t != 'boolean') {
/*Line 184 - 'Atom.js' */                continue;
/*Line 185 - 'Atom.js' */            }
/*Line 186 - 'Atom.js' */            plist.push(i + '=' + encodeURIComponent(val));
/*Line 187 - 'Atom.js' */        }
/*Line 188 - 'Atom.js' */        return plist.join('&');
/*Line 189 - 'Atom.js' */    },

/*Line 191 - 'Atom.js' */    tableLayout: function (columns, cellWidth, cellHeight) {
/*Line 192 - 'Atom.js' */        return new WebAtoms.AtomTableLayout(columns, cellWidth, cellHeight);
/*Line 193 - 'Atom.js' */    },

/*Line 195 - 'Atom.js' */    toDash: function(text){
/*Line 196 - 'Atom.js' */        return text.replace(/([A-Z])/g, function($1){return "-"+$1.toLowerCase();});
/*Line 197 - 'Atom.js' */    },

/*Line 199 - 'Atom.js' */    secureUrl: function () {
/*Line 200 - 'Atom.js' */        var u = "";
/*Line 201 - 'Atom.js' */        for (var i = 0; i < arguments.length; i++) {
/*Line 202 - 'Atom.js' */            var ui = arguments[i];
/*Line 203 - 'Atom.js' */            if (ui === null || ui === undefined) {
/*Line 204 - 'Atom.js' */                return undefined;
/*Line 205 - 'Atom.js' */            }
/*Line 206 - 'Atom.js' */            u += ui;
/*Line 207 - 'Atom.js' */        }
/*Line 208 - 'Atom.js' */        if (/^\/\//.test(u)) {
/*Line 209 - 'Atom.js' */            return document.location.protocol + u;
/*Line 210 - 'Atom.js' */        }
/*Line 211 - 'Atom.js' */        if ('https:' == document.location.protocol) {
/*Line 212 - 'Atom.js' */            u = u.replace(/http\:\/\//, "https://");
/*Line 213 - 'Atom.js' */        }
/*Line 214 - 'Atom.js' */        return u;
/*Line 215 - 'Atom.js' */    },

/*Line 217 - 'Atom.js' */    showError: function (e) {
/*Line 218 - 'Atom.js' */        // show slight warning.. make warning go away...
/*Line 219 - 'Atom.js' */        Atom.alert(e);
/*Line 220 - 'Atom.js' */    }
/*Line 221 - 'Atom.js' */};

/*Line 223 - 'Atom.js' */Atom.resolve = function (obj, ap) {

/*Line 225 - 'Atom.js' */    var start = !ap;

/*Line 227 - 'Atom.js' */    if (!obj)
/*Line 228 - 'Atom.js' */        return obj;

/*Line 230 - 'Atom.js' */    if (start) {

/*Line 232 - 'Atom.js' */        ap = new AtomPromise();
/*Line 233 - 'Atom.js' */        ap.list = [];
/*Line 234 - 'Atom.js' */        ap.done = function (v) {
/*Line 235 - 'Atom.js' */            Atom.remove(ap.list, v);
/*Line 236 - 'Atom.js' */            if (ap.list.length == 0) {
/*Line 237 - 'Atom.js' */                ap.pushValue(obj);
/*Line 238 - 'Atom.js' */            }
/*Line 239 - 'Atom.js' */        };
/*Line 240 - 'Atom.js' */    }


/*Line 243 - 'Atom.js' */    var type = typeof (obj);

/*Line 245 - 'Atom.js' */    if (type == 'object') {
/*Line 246 - 'Atom.js' */        if (typeof (obj.length) != 'undefined') {
/*Line 247 - 'Atom.js' */            //this is an array
/*Line 248 - 'Atom.js' */            for (var i = 0; i < obj.length; i++) {
/*Line 249 - 'Atom.js' */                var v = obj[i];
/*Line 250 - 'Atom.js' */                if (!v)
/*Line 251 - 'Atom.js' */                    continue;
/*Line 252 - 'Atom.js' */                var item = obj;
/*Line 253 - 'Atom.js' */                var key = i;
/*Line 254 - 'Atom.js' */                if (v instanceof AtomPromise || v.constructor == AtomPromise) {
/*Line 255 - 'Atom.js' */                    ap.list.push(v);
/*Line 256 - 'Atom.js' */                    v.failed(function (a) {
/*Line 257 - 'Atom.js' */                        ap.done(a);
/*Line 258 - 'Atom.js' */                    });
/*Line 259 - 'Atom.js' */                    v.then(function (a) {
/*Line 260 - 'Atom.js' */                        item[key] = a.value();
/*Line 261 - 'Atom.js' */                        ap.done(a);
/*Line 262 - 'Atom.js' */                    });
/*Line 263 - 'Atom.js' */                    continue;
/*Line 264 - 'Atom.js' */                }
/*Line 265 - 'Atom.js' */                Atom.resolve(v, ap);
/*Line 266 - 'Atom.js' */            }
/*Line 267 - 'Atom.js' */        } else {
/*Line 268 - 'Atom.js' */            for (var i in obj) {
/*Line 269 - 'Atom.js' */                var v = obj[i];
/*Line 270 - 'Atom.js' */                if (!v)
/*Line 271 - 'Atom.js' */                    continue;
/*Line 272 - 'Atom.js' */                if (v instanceof AtomPromise || v.constructor == AtomPromise) {
/*Line 273 - 'Atom.js' */                    ap.list.push(v);
/*Line 274 - 'Atom.js' */                    v.failed(function (a) {
/*Line 275 - 'Atom.js' */                        ap.done(a);
/*Line 276 - 'Atom.js' */                    });
/*Line 277 - 'Atom.js' */                    var item = obj;
/*Line 278 - 'Atom.js' */                    var key = i;
/*Line 279 - 'Atom.js' */                    v.then(function (a) {
/*Line 280 - 'Atom.js' */                        item[key] = a.value();
/*Line 281 - 'Atom.js' */                        ap.done(a);
/*Line 282 - 'Atom.js' */                    });
/*Line 283 - 'Atom.js' */                    continue;
/*Line 284 - 'Atom.js' */                }
/*Line 285 - 'Atom.js' */                Atom.resolve(v, ap);
/*Line 286 - 'Atom.js' */            }
/*Line 287 - 'Atom.js' */        }
/*Line 288 - 'Atom.js' */    }

/*Line 290 - 'Atom.js' */    if (ap.list.length) {
/*Line 291 - 'Atom.js' */        if (start) {
/*Line 292 - 'Atom.js' */            ap.onInvoke(function () {
/*Line 293 - 'Atom.js' */                var ae = new AtomEnumerator(ap.list);
/*Line 294 - 'Atom.js' */                while (ae.next()) {
/*Line 295 - 'Atom.js' */                    ae.current().invoke(ap._invoker);
/*Line 296 - 'Atom.js' */                }
/*Line 297 - 'Atom.js' */            });
/*Line 298 - 'Atom.js' */        }
/*Line 299 - 'Atom.js' */        return ap;
/*Line 300 - 'Atom.js' */    }
/*Line 301 - 'Atom.js' */    return obj;

/*Line 303 - 'Atom.js' */};

/*Line 305 - 'Atom.js' */window.Atom = Atom;

/*Line 307 - 'Atom.js' */(function () {
/*Line 308 - 'Atom.js' */    var e,
/*Line 309 - 'Atom.js' */        a = /\+/g,  
/*Line 310 - 'Atom.js' */        r = /([^&=]+)=?([^&]*)/g,
/*Line 311 - 'Atom.js' */        d = function (s) { return decodeURIComponent(s.replace(a, " ")); },
/*Line 312 - 'Atom.js' */        q = window.location.search.substring(1);

/*Line 314 - 'Atom.js' */    var urlParams = {};
/*Line 315 - 'Atom.js' */    while (e = r.exec(q))
/*Line 316 - 'Atom.js' */        urlParams[d(e[1])] = d(e[2]);
/*Line 317 - 'Atom.js' */    Atom.pageQuery = urlParams;
/*Line 318 - 'Atom.js' */})();

/*Line 320 - 'Atom.js' */var AtomDate = {
/*Line 321 - 'Atom.js' */    zoneOffsetMinutes: (new Date()).getTimezoneOffset(),
/*Line 322 - 'Atom.js' */    zoneOffset: (new Date()).getTimezoneOffset() * 60 * 1000,

/*Line 324 - 'Atom.js' */    toLocalTime: function (d) {
/*Line 325 - 'Atom.js' */        return d.toJSON();
/*Line 326 - 'Atom.js' */    },

/*Line 328 - 'Atom.js' */    m_names: ["Jan", "Feb", "Mar", 
/*Line 329 - 'Atom.js' */"Apr", "May", "Jun", "Jul", "Aug", "Sep", 
/*Line 330 - 'Atom.js' */"Oct", "Nov", "Dec"],

/*Line 332 - 'Atom.js' */    setTime: function (dt, time) {
/*Line 333 - 'Atom.js' */        if (!dt || !time)
/*Line 334 - 'Atom.js' */            return dt;
/*Line 335 - 'Atom.js' */        var tokens = time.split(':');
/*Line 336 - 'Atom.js' */        var h = parseInt(tokens[0]);
/*Line 337 - 'Atom.js' */        tokens = tokens[1].split(' ');
/*Line 338 - 'Atom.js' */        var m = parseInt(tokens[0]);
/*Line 339 - 'Atom.js' */        if (tokens[1] == "PM") {
/*Line 340 - 'Atom.js' */            if (h != 12) {
/*Line 341 - 'Atom.js' */                h += 12;
/*Line 342 - 'Atom.js' */            }
/*Line 343 - 'Atom.js' */        }
/*Line 344 - 'Atom.js' */        var d = new Date(dt.getFullYear(),dt.getMonth(),dt.getDate());
/*Line 345 - 'Atom.js' */        d.setHours(h);
/*Line 346 - 'Atom.js' */        d.setMinutes(m);
/*Line 347 - 'Atom.js' */        return d;
/*Line 348 - 'Atom.js' */    },

/*Line 350 - 'Atom.js' */    toMMDDYY: function (dt) {
/*Line 351 - 'Atom.js' */        var m = dt.getMonth() + 1;
/*Line 352 - 'Atom.js' */        var y = dt.getFullYear();
/*Line 353 - 'Atom.js' */        var d = dt.getDate();

/*Line 355 - 'Atom.js' */        var str = "";
/*Line 356 - 'Atom.js' */        str +=  ((m > 9) ? m : ("0" + m));
/*Line 357 - 'Atom.js' */        str += "/" + ((d > 9) ? d : ("0" + d));
/*Line 358 - 'Atom.js' */        str += "/" + y;
/*Line 359 - 'Atom.js' */        return str;
/*Line 360 - 'Atom.js' */    },

/*Line 362 - 'Atom.js' */    toShortDateString: function (val) {
/*Line 363 - 'Atom.js' */        if (!val)
/*Line 364 - 'Atom.js' */            return "";
/*Line 365 - 'Atom.js' */        if (val.constructor == String) {
/*Line 366 - 'Atom.js' */            if (/^\/date\(/gi.test(val)) {
/*Line 367 - 'Atom.js' */                val = val.substr(6);
/*Line 368 - 'Atom.js' */                val = new Date(parseInt(val,10));
/*Line 369 - 'Atom.js' */            } else {
/*Line 370 - 'Atom.js' */                throw new Error("Invalid date format " + val);
/*Line 371 - 'Atom.js' */            }
/*Line 372 - 'Atom.js' */        }
/*Line 373 - 'Atom.js' */        //var dt = new Date();
        
/*Line 375 - 'Atom.js' */        return this.m_names[val.getMonth()] + " " + val.getDate() + ", " + val.getFullYear();
/*Line 376 - 'Atom.js' */    },
/*Line 377 - 'Atom.js' */    toDateTimeString: function (val) {
/*Line 378 - 'Atom.js' */        if (!val)
/*Line 379 - 'Atom.js' */            return "";
/*Line 380 - 'Atom.js' */        if (val.constructor == String) {
/*Line 381 - 'Atom.js' */            val = val.substr(6);
/*Line 382 - 'Atom.js' */            val = new Date(parseInt(val,10));
/*Line 383 - 'Atom.js' */        }
/*Line 384 - 'Atom.js' */        var dt = AtomDate.toShortDateString(val);
/*Line 385 - 'Atom.js' */        return dt + " - " + AtomDate.toTimeString(val);
/*Line 386 - 'Atom.js' */    },

/*Line 388 - 'Atom.js' */    toTimeString: function (d) {
/*Line 389 - 'Atom.js' */        d = AtomDate.parse(d);
/*Line 390 - 'Atom.js' */        if (!d)
/*Line 391 - 'Atom.js' */            return "";
/*Line 392 - 'Atom.js' */        var h = d.getHours();
/*Line 393 - 'Atom.js' */        var s = "AM";
/*Line 394 - 'Atom.js' */        if (h == 12) {
/*Line 395 - 'Atom.js' */            s = "PM";
/*Line 396 - 'Atom.js' */        } else {
/*Line 397 - 'Atom.js' */            if (h > 12) {
/*Line 398 - 'Atom.js' */                h = h - 12;
/*Line 399 - 'Atom.js' */                s = "PM";
/*Line 400 - 'Atom.js' */            }
/*Line 401 - 'Atom.js' */        }
/*Line 402 - 'Atom.js' */        var m = d.getMinutes();
/*Line 403 - 'Atom.js' */        if (m < 10) {
/*Line 404 - 'Atom.js' */            m = "0" + m;
/*Line 405 - 'Atom.js' */        } else {
/*Line 406 - 'Atom.js' */            m = m + "";
/*Line 407 - 'Atom.js' */            if (m.length == 1) {
/*Line 408 - 'Atom.js' */                m = m + "0";
/*Line 409 - 'Atom.js' */            }
/*Line 410 - 'Atom.js' */        }
/*Line 411 - 'Atom.js' */        return h + ":" + m + " " + s;
/*Line 412 - 'Atom.js' */    },

/*Line 414 - 'Atom.js' */    smartDate: function (v) {
/*Line 415 - 'Atom.js' */        if (!v)
/*Line 416 - 'Atom.js' */            return null;
/*Line 417 - 'Atom.js' */        var d = AtomDate.parse(v);
/*Line 418 - 'Atom.js' */        var now = new Date();

/*Line 420 - 'Atom.js' */        if (now.getFullYear() === d.getFullYear()
/*Line 421 - 'Atom.js' */            && now.getMonth() === d.getMonth()) {
/*Line 422 - 'Atom.js' */            var diff = now.getDate() - d.getDate();
/*Line 423 - 'Atom.js' */            switch(diff){
/*Line 424 - 'Atom.js' */                case -1:
/*Line 425 - 'Atom.js' */                    return "Tomorrow (" + AtomDate.toTimeString(d) + ")";
/*Line 426 - 'Atom.js' */                case 0:
/*Line 427 - 'Atom.js' */                    return "Today (" + AtomDate.toTimeString(d) + ")";
/*Line 428 - 'Atom.js' */                case 1:
/*Line 429 - 'Atom.js' */                    return "Yesterday (" + AtomDate.toTimeString(d) + ")";
/*Line 430 - 'Atom.js' */            }
/*Line 431 - 'Atom.js' */        }
/*Line 432 - 'Atom.js' */        return AtomDate.toDateTimeString(d);
/*Line 433 - 'Atom.js' */    },

/*Line 435 - 'Atom.js' */    smartDateUTC: function (v) {
/*Line 436 - 'Atom.js' */        return AtomDate.smartDate(v);
/*Line 437 - 'Atom.js' */    },

/*Line 439 - 'Atom.js' */    jsonDate: function (v) {
/*Line 440 - 'Atom.js' */        var d = AtomDate.parse(v);
/*Line 441 - 'Atom.js' */        return {
/*Line 442 - 'Atom.js' */            Year: d.getFullYear(),
/*Line 443 - 'Atom.js' */            Month: d.getMonth() + 1,
/*Line 444 - 'Atom.js' */            Date: d.getDate(),
/*Line 445 - 'Atom.js' */            Hours: d.getHours(),
/*Line 446 - 'Atom.js' */            Minutes: d.getMinutes(),
/*Line 447 - 'Atom.js' */            Seconds: d.getSeconds(),
/*Line 448 - 'Atom.js' */            Offset: AtomDate.zoneOffsetMinutes
/*Line 449 - 'Atom.js' */        };
/*Line 450 - 'Atom.js' */    },

/*Line 452 - 'Atom.js' */    toUTC: function (v) {
/*Line 453 - 'Atom.js' */        if (!v)
/*Line 454 - 'Atom.js' */            return "";
/*Line 455 - 'Atom.js' */        v = AtomDate.parse(v);
/*Line 456 - 'Atom.js' */        var d = new Date(v.getTime() + AtomDate.zoneOffset);
/*Line 457 - 'Atom.js' */        return d;
/*Line 458 - 'Atom.js' */    },

/*Line 460 - 'Atom.js' */    parse: function (v) {
/*Line 461 - 'Atom.js' */        if (!v)
/*Line 462 - 'Atom.js' */            return null;
/*Line 463 - 'Atom.js' */        if (v.constructor !== String)
/*Line 464 - 'Atom.js' */            return v;
/*Line 465 - 'Atom.js' */        if (/^\/date\([\-0-9]+\)\//gi.test(v)) {
/*Line 466 - 'Atom.js' */            v = new Date(parseInt(v.substr(6),10));
/*Line 467 - 'Atom.js' */        } else {
/*Line 468 - 'Atom.js' */            if (/^\/dateiso/gi.test(v)) {
/*Line 469 - 'Atom.js' */                v = v.substr(9);
/*Line 470 - 'Atom.js' */                v = v.substr(0, v.length - 1);
/*Line 471 - 'Atom.js' */                var tokens = v.split('T');
/*Line 472 - 'Atom.js' */                var date = tokens[0];
/*Line 473 - 'Atom.js' */                var time = tokens[1];
/*Line 474 - 'Atom.js' */                date = date.split('-');
/*Line 475 - 'Atom.js' */                time = time.split(':');
/*Line 476 - 'Atom.js' */                var d = new Date(date[0], parseInt(date[1]) - 1, date[2], time[0], time[1], parseFloat(time[2]));
/*Line 477 - 'Atom.js' */                d = new Date(d.getTime() + AtomDate.zoneOffset);
/*Line 478 - 'Atom.js' */                return d;
/*Line 479 - 'Atom.js' */            } else {
/*Line 480 - 'Atom.js' */                v = Date.parse(v);
/*Line 481 - 'Atom.js' */            }
/*Line 482 - 'Atom.js' */        }
/*Line 483 - 'Atom.js' */        return v;
/*Line 484 - 'Atom.js' */        //var i = v.getTime();
/*Line 485 - 'Atom.js' */        //var z = v.getTimezoneOffset() * 60 * 1000;
/*Line 486 - 'Atom.js' */        //i = i - z;
/*Line 487 - 'Atom.js' */        //return new Date(i);
/*Line 488 - 'Atom.js' */    }
/*Line 489 - 'Atom.js' */};

/*Line 491 - 'Atom.js' */window.AtomDate = AtomDate;

/*Line 493 - 'Atom.js' */AtomDate.monthList = [
/*Line 494 - 'Atom.js' */    { label: "January", value: 1 },
/*Line 495 - 'Atom.js' */    { label: "February", value: 2 },
/*Line 496 - 'Atom.js' */    { label: "March", value: 3 },
/*Line 497 - 'Atom.js' */    { label: "April", value: 4 },
/*Line 498 - 'Atom.js' */    { label: "May", value: 5 },
/*Line 499 - 'Atom.js' */    { label: "June", value: 6 },
/*Line 500 - 'Atom.js' */    { label: "July", value: 7 },
/*Line 501 - 'Atom.js' */    { label: "August", value: 8 },
/*Line 502 - 'Atom.js' */    { label: "September", value: 9 },
/*Line 503 - 'Atom.js' */    { label: "October", value: 10 },
/*Line 504 - 'Atom.js' */    { label: "November", value: 11 },
/*Line 505 - 'Atom.js' */    { label: "December", value: 12 }
/*Line 506 - 'Atom.js' */];


/*Line 509 - 'Atom.js' */var AtomFileSize = {
/*Line 510 - 'Atom.js' */    toFileSize: function (val) {
/*Line 511 - 'Atom.js' */        if (!val)
/*Line 512 - 'Atom.js' */            return "";
/*Line 513 - 'Atom.js' */        if (val.constructor == String)
/*Line 514 - 'Atom.js' */            val = parseInt(val, 10);
/*Line 515 - 'Atom.js' */        if (val > 1073741824) {
/*Line 516 - 'Atom.js' */            return Math.round(val / 1073741824) + " GB";
/*Line 517 - 'Atom.js' */        }
/*Line 518 - 'Atom.js' */        if (val > 1048576) {
/*Line 519 - 'Atom.js' */            return Math.round(val / 1048576) + " MB";
/*Line 520 - 'Atom.js' */        }
/*Line 521 - 'Atom.js' */        if (val > 1024) {
/*Line 522 - 'Atom.js' */            return Math.round(val / 1024) + " KB";
/*Line 523 - 'Atom.js' */        }
/*Line 524 - 'Atom.js' */        return val + " B";
/*Line 525 - 'Atom.js' */    }
/*Line 526 - 'Atom.js' */};

/*Line 528 - 'Atom.js' */window.AtomFileSize = AtomFileSize;

/*Line 530 - 'Atom.js' */var AtomPhone = {
/*Line 531 - 'Atom.js' */    toSmallPhoneString: function (val) {
/*Line 532 - 'Atom.js' */        if (!val)
/*Line 533 - 'Atom.js' */            return "";
/*Line 534 - 'Atom.js' */        var tokens = val.split(":", 6);
/*Line 535 - 'Atom.js' */        var cc = tokens[2];
/*Line 536 - 'Atom.js' */        cc = "(" + (/^\+/.test(cc) ? '' : '+') + tokens[2] + ") ";
/*Line 537 - 'Atom.js' */        var phone = tokens[3];
/*Line 538 - 'Atom.js' */        var ext = tokens[4];
/*Line 539 - 'Atom.js' */        var msg = tokens[5];
/*Line 540 - 'Atom.js' */        if (!phone)
/*Line 541 - 'Atom.js' */            return "";
/*Line 542 - 'Atom.js' */        return cc + phone;
/*Line 543 - 'Atom.js' */    },
/*Line 544 - 'Atom.js' */    toPhoneString: function (val) {
/*Line 545 - 'Atom.js' */        if (!val)
/*Line 546 - 'Atom.js' */            return "";
/*Line 547 - 'Atom.js' */        var tokens = val.split(":", 6);
/*Line 548 - 'Atom.js' */        var cc = "(+" + tokens[2] + ") ";
/*Line 549 - 'Atom.js' */        var phone = tokens[3];
/*Line 550 - 'Atom.js' */        var ext = tokens[4];
/*Line 551 - 'Atom.js' */        var msg = tokens[5];
/*Line 552 - 'Atom.js' */        if (!phone)
/*Line 553 - 'Atom.js' */            return "";
/*Line 554 - 'Atom.js' */        var txt = cc + phone;
/*Line 555 - 'Atom.js' */        if (ext)
/*Line 556 - 'Atom.js' */            txt += " (ext: " + ext + ")";
/*Line 557 - 'Atom.js' */        if (msg)
/*Line 558 - 'Atom.js' */            txt += " (" + msg + ")";
/*Line 559 - 'Atom.js' */        return txt;
/*Line 560 - 'Atom.js' */    }
/*Line 561 - 'Atom.js' */};

/*Line 563 - 'Atom.js' */window.AtomPhone = AtomPhone;


/*Line 2 - 'AtomEvaluator.js' */var AtomEvaluator = {

/*Line 4 - 'AtomEvaluator.js' */    ecache: {},

/*Line 6 - 'AtomEvaluator.js' */    becache: {},

/*Line 8 - 'AtomEvaluator.js' */    parse: function (txt) {

/*Line 10 - 'AtomEvaluator.js' */        // http://jsfiddle.net/A3vg6/44/ (recommended)
/*Line 11 - 'AtomEvaluator.js' */        // http://jsfiddle.net/A3vg6/45/ (working)
/*Line 12 - 'AtomEvaluator.js' */        // http://jsfiddle.net/A3vg6/51/ (including $ sign)

/*Line 14 - 'AtomEvaluator.js' */        var be = this.becache[txt];
/*Line 15 - 'AtomEvaluator.js' */        if (be)
/*Line 16 - 'AtomEvaluator.js' */            return be;

/*Line 18 - 'AtomEvaluator.js' */        var regex = /(?:(\$)(window|viewModel|appScope|scope|data|owner|localScope))(?:\.[a-zA-Z_][a-zA-Z_0-9]*)*/gi;

/*Line 20 - 'AtomEvaluator.js' */        var keywords = /(window|viewModel|appScope|scope|data|owner|localScope)/gi;

/*Line 22 - 'AtomEvaluator.js' */        var path = [];
/*Line 23 - 'AtomEvaluator.js' */        var vars = [];

/*Line 25 - 'AtomEvaluator.js' */        var found = {};

/*Line 27 - 'AtomEvaluator.js' */        var ms = txt.replace(regex,
/*Line 28 - 'AtomEvaluator.js' */            function (match) {
/*Line 29 - 'AtomEvaluator.js' */                var nv = "v" + (path.length + 1);
/*Line 30 - 'AtomEvaluator.js' */                if (match.indexOf("$owner.") == 0) {
/*Line 31 - 'AtomEvaluator.js' */                    match = match.substr(7);
/*Line 32 - 'AtomEvaluator.js' */                } else
/*Line 33 - 'AtomEvaluator.js' */                {
/*Line 34 - 'AtomEvaluator.js' */                    if (match.indexOf("owner.") == 0) {
/*Line 35 - 'AtomEvaluator.js' */                        match = match.substr(6);
/*Line 36 - 'AtomEvaluator.js' */                    } else {
/*Line 37 - 'AtomEvaluator.js' */                        match = match.substr(1);
/*Line 38 - 'AtomEvaluator.js' */                    }
/*Line 39 - 'AtomEvaluator.js' */                }
/*Line 40 - 'AtomEvaluator.js' */                path.push(match.split('.'));
/*Line 41 - 'AtomEvaluator.js' */                vars.push(nv);
/*Line 42 - 'AtomEvaluator.js' */                return nv;
/*Line 43 - 'AtomEvaluator.js' */            }
/*Line 44 - 'AtomEvaluator.js' */            );


/*Line 47 - 'AtomEvaluator.js' */        var method = "return " + ms + ";";
/*Line 48 - 'AtomEvaluator.js' */        var methodString = method;
/*Line 49 - 'AtomEvaluator.js' */        try {
/*Line 50 - 'AtomEvaluator.js' */            method = AtomEvaluator.compile(vars, method);
/*Line 51 - 'AtomEvaluator.js' */        } catch (e) {
/*Line 52 - 'AtomEvaluator.js' */            Atom.alert("Error executing \n" + methodString + "\nOriginal: " + txt);
/*Line 53 - 'AtomEvaluator.js' */            throw e;
/*Line 54 - 'AtomEvaluator.js' */        }

/*Line 56 - 'AtomEvaluator.js' */        be = { length: vars.length, method: method, path: path, original: ms };
/*Line 57 - 'AtomEvaluator.js' */        this.becache[txt] = be;
/*Line 58 - 'AtomEvaluator.js' */        return be;
/*Line 59 - 'AtomEvaluator.js' */    },
/*Line 60 - 'AtomEvaluator.js' */    compile: function (vars, method) {
/*Line 61 - 'AtomEvaluator.js' */        var k = vars.join("-") + ":" + method;
/*Line 62 - 'AtomEvaluator.js' */        var e = this.ecache[k];
/*Line 63 - 'AtomEvaluator.js' */        if (e)
/*Line 64 - 'AtomEvaluator.js' */            return e;

/*Line 66 - 'AtomEvaluator.js' */        vars.push("Atom");
/*Line 67 - 'AtomEvaluator.js' */        vars.push("AtomPromise");

/*Line 69 - 'AtomEvaluator.js' */        e = new Function(vars,method);
/*Line 70 - 'AtomEvaluator.js' */        this.ecache[k] = e;
/*Line 71 - 'AtomEvaluator.js' */        return e;
/*Line 72 - 'AtomEvaluator.js' */    }
/*Line 73 - 'AtomEvaluator.js' */};

/*Line 75 - 'AtomEvaluator.js' */window.AtomEvaluator = AtomEvaluator;
/*Line 0 - 'ChildEnumerator.js' */

/*Line 2 - 'ChildEnumerator.js' */var ChildEnumerator = null;

/*Line 4 - 'ChildEnumerator.js' */if (AtomBrowser.isIE && AtomBrowser.majorVersion < 9) {
/*Line 5 - 'ChildEnumerator.js' */    ChildEnumerator = function (e) {
/*Line 6 - 'ChildEnumerator.js' */        this.index = -1;
/*Line 7 - 'ChildEnumerator.js' */        this.nextItem = e.firstChild;
/*Line 8 - 'ChildEnumerator.js' */        this.findNext();
/*Line 9 - 'ChildEnumerator.js' */        this.item = null;
/*Line 10 - 'ChildEnumerator.js' */    };

/*Line 12 - 'ChildEnumerator.js' */    ChildEnumerator.prototype ={

/*Line 14 - 'ChildEnumerator.js' */        findNext: function () {
/*Line 15 - 'ChildEnumerator.js' */            var ne = this.nextItem;
/*Line 16 - 'ChildEnumerator.js' */            while (ne && ne.nodeType !== 1) {
/*Line 17 - 'ChildEnumerator.js' */                ne = ne.nextSibling;
/*Line 18 - 'ChildEnumerator.js' */            }
/*Line 19 - 'ChildEnumerator.js' */            this.nextItem = ne;
/*Line 20 - 'ChildEnumerator.js' */            this.index++;
/*Line 21 - 'ChildEnumerator.js' */        },

/*Line 23 - 'ChildEnumerator.js' */        isFirst: function () {
/*Line 24 - 'ChildEnumerator.js' */            return this.index === 1;
/*Line 25 - 'ChildEnumerator.js' */        },

/*Line 27 - 'ChildEnumerator.js' */        isLast: function () {
/*Line 28 - 'ChildEnumerator.js' */            return this.item && !this.nextItem;
/*Line 29 - 'ChildEnumerator.js' */        },

/*Line 31 - 'ChildEnumerator.js' */        next: function () {
/*Line 32 - 'ChildEnumerator.js' */            this.item = this.nextItem;
/*Line 33 - 'ChildEnumerator.js' */            if (!this.item)
/*Line 34 - 'ChildEnumerator.js' */                return false;
/*Line 35 - 'ChildEnumerator.js' */            this.nextItem = this.item.nextSibling;
/*Line 36 - 'ChildEnumerator.js' */            this.findNext();
/*Line 37 - 'ChildEnumerator.js' */            return this.item ? true : false;
/*Line 38 - 'ChildEnumerator.js' */        },

/*Line 40 - 'ChildEnumerator.js' */        current: function () {
/*Line 41 - 'ChildEnumerator.js' */            return this.item;
/*Line 42 - 'ChildEnumerator.js' */        }

/*Line 44 - 'ChildEnumerator.js' */    };

/*Line 46 - 'ChildEnumerator.js' */    window.ChildEnumerator = ChildEnumerator;
/*Line 47 - 'ChildEnumerator.js' */}
/*Line 48 - 'ChildEnumerator.js' */else {
/*Line 49 - 'ChildEnumerator.js' */    ChildEnumerator = function (e) {
/*Line 50 - 'ChildEnumerator.js' */        this.nextItem = e.firstElementChild;
/*Line 51 - 'ChildEnumerator.js' */        this.item = null;
/*Line 52 - 'ChildEnumerator.js' */        this.first = true;
/*Line 53 - 'ChildEnumerator.js' */    };

/*Line 55 - 'ChildEnumerator.js' */    ChildEnumerator.prototype = {
/*Line 56 - 'ChildEnumerator.js' */        isFirst: function () {
/*Line 57 - 'ChildEnumerator.js' */            return !this.item.previousElementSibling;
/*Line 58 - 'ChildEnumerator.js' */        },
/*Line 59 - 'ChildEnumerator.js' */        isLast: function () {
/*Line 60 - 'ChildEnumerator.js' */            return this.item && !this.nextItem;
/*Line 61 - 'ChildEnumerator.js' */        },
/*Line 62 - 'ChildEnumerator.js' */        next: function () {
/*Line 63 - 'ChildEnumerator.js' */            this.item = this.nextItem;
/*Line 64 - 'ChildEnumerator.js' */            if (!this.item)
/*Line 65 - 'ChildEnumerator.js' */                return false;
/*Line 66 - 'ChildEnumerator.js' */            this.nextItem = this.item.nextElementSibling;
/*Line 67 - 'ChildEnumerator.js' */            return this.item ? true : false;
/*Line 68 - 'ChildEnumerator.js' */        },
/*Line 69 - 'ChildEnumerator.js' */        current: function () {
/*Line 70 - 'ChildEnumerator.js' */            return this.item;
/*Line 71 - 'ChildEnumerator.js' */        }

/*Line 73 - 'ChildEnumerator.js' */    };

/*Line 75 - 'ChildEnumerator.js' */    window.ChildEnumerator = ChildEnumerator;
/*Line 76 - 'ChildEnumerator.js' */}



/*Line 0 - 'AtomPopup.js' */

/*Line 2 - 'AtomPopup.js' */var AtomPopup = {

/*Line 4 - 'AtomPopup.js' */    stack: [],

/*Line 6 - 'AtomPopup.js' */    startOrder: 2000,


    
/*Line 10 - 'AtomPopup.js' */    show: function (parent, element, pos, removeHandler) {

/*Line 12 - 'AtomPopup.js' */        // post =  { 0: bottom left, 1: bottom right, 2: top left, 3: top right }

/*Line 14 - 'AtomPopup.js' */        // set logical parent
/*Line 15 - 'AtomPopup.js' */        element.style.zOrder = this.startOrder++;

/*Line 17 - 'AtomPopup.js' */        if (pos == 0) {

/*Line 19 - 'AtomPopup.js' */            var p = $(parent).offset();
/*Line 20 - 'AtomPopup.js' */            element.style.position = "absolute";
/*Line 21 - 'AtomPopup.js' */            element.style.left =   p.left + "px";
/*Line 22 - 'AtomPopup.js' */            element.style.top = (p.top + $(parent).outerHeight(true)) + "px";
/*Line 23 - 'AtomPopup.js' */        }

/*Line 25 - 'AtomPopup.js' */        element.style.visibility = "visible";

/*Line 27 - 'AtomPopup.js' */        this.stack.push({ parent: parent, element: element, removeHandler: removeHandler });

/*Line 29 - 'AtomPopup.js' */    },

/*Line 31 - 'AtomPopup.js' */    peek: function () {
/*Line 32 - 'AtomPopup.js' */        var l = null;
/*Line 33 - 'AtomPopup.js' */        if (this.stack.length > 0)
/*Line 34 - 'AtomPopup.js' */            l = this.stack[this.stack.length - 1];
/*Line 35 - 'AtomPopup.js' */        return l;
/*Line 36 - 'AtomPopup.js' */    },

/*Line 38 - 'AtomPopup.js' */    hide: function (element) {

/*Line 40 - 'AtomPopup.js' */        // only hide top most element
/*Line 41 - 'AtomPopup.js' */        // otherwise it may have been removed
/*Line 42 - 'AtomPopup.js' */        // by clicked function
/*Line 43 - 'AtomPopup.js' */        var pk = this.peek();
/*Line 44 - 'AtomPopup.js' */        if (!pk)
/*Line 45 - 'AtomPopup.js' */            return;
/*Line 46 - 'AtomPopup.js' */        if (pk.element !== element)
/*Line 47 - 'AtomPopup.js' */            return;

/*Line 49 - 'AtomPopup.js' */        element.style.visibility = "hidden";
/*Line 50 - 'AtomPopup.js' */        var item = this.stack.pop();
/*Line 51 - 'AtomPopup.js' */        if (item.removeHandler) {
/*Line 52 - 'AtomPopup.js' */            item.removeHandler(item.element);
/*Line 53 - 'AtomPopup.js' */        }
/*Line 54 - 'AtomPopup.js' */    },

/*Line 56 - 'AtomPopup.js' */    clicked: function (e) {

/*Line 58 - 'AtomPopup.js' */        var target = e.target;

/*Line 60 - 'AtomPopup.js' */        // lets see if target is outside the topmost popup...
/*Line 61 - 'AtomPopup.js' */        var pk = AtomPopup.peek();
/*Line 62 - 'AtomPopup.js' */        if (!pk)
/*Line 63 - 'AtomPopup.js' */            return;
/*Line 64 - 'AtomPopup.js' */        while (target && target != pk.element && target != pk.parent) {
/*Line 65 - 'AtomPopup.js' */            target = target.parentNode;
/*Line 66 - 'AtomPopup.js' */        }
/*Line 67 - 'AtomPopup.js' */        if (target == pk.element || target == pk.parent) {
/*Line 68 - 'AtomPopup.js' */            return;
/*Line 69 - 'AtomPopup.js' */        }

/*Line 71 - 'AtomPopup.js' */        //AtomPopup.hide(pk);
/*Line 72 - 'AtomPopup.js' */        pk.element.style.visibility = "hidden";
/*Line 73 - 'AtomPopup.js' */        this.stack.pop();
/*Line 74 - 'AtomPopup.js' */        if (pk.removeHandler) {
/*Line 75 - 'AtomPopup.js' */            pk.removeHandler(pk.element);
/*Line 76 - 'AtomPopup.js' */        }


/*Line 79 - 'AtomPopup.js' */    }


/*Line 82 - 'AtomPopup.js' */};

/*Line 84 - 'AtomPopup.js' */window.AtomPopup = AtomPopup;

/*Line 86 - 'AtomPopup.js' */window.simulateParentClick = function () {

/*Line 88 - 'AtomPopup.js' */    var p = null;
/*Line 89 - 'AtomPopup.js' */    try {
/*Line 90 - 'AtomPopup.js' */        p = frameElement;
/*Line 91 - 'AtomPopup.js' */    } catch (e) {
/*Line 92 - 'AtomPopup.js' */        //log(e);
/*Line 93 - 'AtomPopup.js' */        return;
/*Line 94 - 'AtomPopup.js' */    }
/*Line 95 - 'AtomPopup.js' */    if (!p)
/*Line 96 - 'AtomPopup.js' */        return;
/*Line 97 - 'AtomPopup.js' */    if (!parent)
/*Line 98 - 'AtomPopup.js' */        return;

/*Line 100 - 'AtomPopup.js' */    var $ = parent.$;

/*Line 102 - 'AtomPopup.js' */    $(frameElement).click();

/*Line 104 - 'AtomPopup.js' */    if (p.simulateParentClick) {
/*Line 105 - 'AtomPopup.js' */        p.simulateParentClick();
/*Line 106 - 'AtomPopup.js' */    }
/*Line 107 - 'AtomPopup.js' */}


/*Line 110 - 'AtomPopup.js' */$(window).click(function (e) {
/*Line 111 - 'AtomPopup.js' */    AtomPopup.clicked(e);

/*Line 113 - 'AtomPopup.js' */    window.simulateParentClick();

/*Line 115 - 'AtomPopup.js' */});
/*Line 0 - 'AtomQuery.js' */
/*Line 1 - 'AtomQuery.js' */

/*Line 3 - 'AtomQuery.js' */// rewire get...
/*Line 4 - 'AtomQuery.js' */$f.get = Atom.get;

/*Line 6 - 'AtomQuery.js' */$f.compileSelect = function (s) {
/*Line 7 - 'AtomQuery.js' */    if (!s) {
/*Line 8 - 'AtomQuery.js' */        return function (item) {
/*Line 9 - 'AtomQuery.js' */            return item;
/*Line 10 - 'AtomQuery.js' */        };
/*Line 11 - 'AtomQuery.js' */    }

/*Line 13 - 'AtomQuery.js' */    if (s.constructor == String) {
/*Line 14 - 'AtomQuery.js' */        return function (item) {
/*Line 15 - 'AtomQuery.js' */            return Atom.get(item, s);
/*Line 16 - 'AtomQuery.js' */        };
/*Line 17 - 'AtomQuery.js' */    }

/*Line 19 - 'AtomQuery.js' */    return function (item) {

/*Line 21 - 'AtomQuery.js' */        var r = {};
/*Line 22 - 'AtomQuery.js' */        for (var i in s) {
/*Line 23 - 'AtomQuery.js' */            var v = s[i];
/*Line 24 - 'AtomQuery.js' */            i = JSON.stringify(i);
/*Line 25 - 'AtomQuery.js' */            if (!v) {
/*Line 26 - 'AtomQuery.js' */                r[i] = Atom.get(item, i);
/*Line 27 - 'AtomQuery.js' */            } else {
/*Line 28 - 'AtomQuery.js' */                r[i] = Atom.get(item, v);
/*Line 29 - 'AtomQuery.js' */            }
/*Line 30 - 'AtomQuery.js' */        }
/*Line 31 - 'AtomQuery.js' */        return r;
/*Line 32 - 'AtomQuery.js' */    };
/*Line 33 - 'AtomQuery.js' */};


/*Line 36 - 'AtomQuery.js' */var AtomQuery = {

/*Line 38 - 'AtomQuery.js' */    firstOrDefault:function (q) {
/*Line 39 - 'AtomQuery.js' */        var f = $f(q);
/*Line 40 - 'AtomQuery.js' */        while (this.next()) {
/*Line 41 - 'AtomQuery.js' */            var item = this.current();
/*Line 42 - 'AtomQuery.js' */            if (f(item)) {
/*Line 43 - 'AtomQuery.js' */                return item;
/*Line 44 - 'AtomQuery.js' */            }
/*Line 45 - 'AtomQuery.js' */        }
/*Line 46 - 'AtomQuery.js' */        return null;
/*Line 47 - 'AtomQuery.js' */    },

/*Line 49 - 'AtomQuery.js' */    first: function (q) {
/*Line 50 - 'AtomQuery.js' */        var f = $f(q);
/*Line 51 - 'AtomQuery.js' */        while (this.next()) {
/*Line 52 - 'AtomQuery.js' */            var item = this.current();
/*Line 53 - 'AtomQuery.js' */            if (f(item)) {
/*Line 54 - 'AtomQuery.js' */                return item;
/*Line 55 - 'AtomQuery.js' */            }
/*Line 56 - 'AtomQuery.js' */        }
/*Line 57 - 'AtomQuery.js' */        throw new Error("Item not found in collection");
/*Line 58 - 'AtomQuery.js' */    },

/*Line 60 - 'AtomQuery.js' */    where: function (q) {
/*Line 61 - 'AtomQuery.js' */        var f = $f(q);
/*Line 62 - 'AtomQuery.js' */        var r = [];
/*Line 63 - 'AtomQuery.js' */        while (this.next()) {
/*Line 64 - 'AtomQuery.js' */            var item = this.current();
/*Line 65 - 'AtomQuery.js' */            if (f(item)) {
/*Line 66 - 'AtomQuery.js' */                r.push(item);
/*Line 67 - 'AtomQuery.js' */            }
/*Line 68 - 'AtomQuery.js' */        }
/*Line 69 - 'AtomQuery.js' */        return new AtomEnumerator(r);
/*Line 70 - 'AtomQuery.js' */    },

/*Line 72 - 'AtomQuery.js' */    toArray: function(){
/*Line 73 - 'AtomQuery.js' */        var r = [];
/*Line 74 - 'AtomQuery.js' */        while (this.next()) {
/*Line 75 - 'AtomQuery.js' */            r.push(this.current());
/*Line 76 - 'AtomQuery.js' */        }
/*Line 77 - 'AtomQuery.js' */        return r;
/*Line 78 - 'AtomQuery.js' */    },

/*Line 80 - 'AtomQuery.js' */    any: function(q){
/*Line 81 - 'AtomQuery.js' */        if (this.firstOrDefault(q))
/*Line 82 - 'AtomQuery.js' */            return true;
/*Line 83 - 'AtomQuery.js' */        return false;
/*Line 84 - 'AtomQuery.js' */    },

/*Line 86 - 'AtomQuery.js' */    select: function (q) {

/*Line 88 - 'AtomQuery.js' */        var f = $f.compileSelect(q);
/*Line 89 - 'AtomQuery.js' */        var r = [];
/*Line 90 - 'AtomQuery.js' */        while (this.next()) {
/*Line 91 - 'AtomQuery.js' */            var item = this.current();
/*Line 92 - 'AtomQuery.js' */            r.push(f(item));
/*Line 93 - 'AtomQuery.js' */        }
/*Line 94 - 'AtomQuery.js' */        return new AtomEnumerator(r);
/*Line 95 - 'AtomQuery.js' */    },

/*Line 97 - 'AtomQuery.js' */    join: function (s) {
/*Line 98 - 'AtomQuery.js' */        var r = [];
/*Line 99 - 'AtomQuery.js' */        while (this.next()) {
/*Line 100 - 'AtomQuery.js' */            r.push(this.current());
/*Line 101 - 'AtomQuery.js' */        }
/*Line 102 - 'AtomQuery.js' */        return r.join(s);
/*Line 103 - 'AtomQuery.js' */    },

/*Line 105 - 'AtomQuery.js' */    count: function(s){
/*Line 106 - 'AtomQuery.js' */        if (s) {
/*Line 107 - 'AtomQuery.js' */            return this.where(s).count();
/*Line 108 - 'AtomQuery.js' */        }
/*Line 109 - 'AtomQuery.js' */        var n = 0;
/*Line 110 - 'AtomQuery.js' */        while (this.next()) n++;
/*Line 111 - 'AtomQuery.js' */        return n;
/*Line 112 - 'AtomQuery.js' */    },

/*Line 114 - 'AtomQuery.js' */    sum: function (s) {
/*Line 115 - 'AtomQuery.js' */        var n = 0;
/*Line 116 - 'AtomQuery.js' */        var ae = this;
/*Line 117 - 'AtomQuery.js' */        while (ae.next()) {
/*Line 118 - 'AtomQuery.js' */            var item = ae.current();
/*Line 119 - 'AtomQuery.js' */            if (s) {
/*Line 120 - 'AtomQuery.js' */                item = Atom.get(item,s);
/*Line 121 - 'AtomQuery.js' */            }
/*Line 122 - 'AtomQuery.js' */            n += +(item || 0);
/*Line 123 - 'AtomQuery.js' */        }
/*Line 124 - 'AtomQuery.js' */        return n;
/*Line 125 - 'AtomQuery.js' */    },

/*Line 127 - 'AtomQuery.js' */    groupBy: function (s) {
/*Line 128 - 'AtomQuery.js' */        var fs = $f.compileSelect(s);
/*Line 129 - 'AtomQuery.js' */        var ae = this;
/*Line 130 - 'AtomQuery.js' */        var g = {};
/*Line 131 - 'AtomQuery.js' */        var r = [];
/*Line 132 - 'AtomQuery.js' */        while (ae.next()) {
/*Line 133 - 'AtomQuery.js' */            var item = ae.current();
/*Line 134 - 'AtomQuery.js' */            var si = fs(item);
/*Line 135 - 'AtomQuery.js' */            var rl = g[si];
/*Line 136 - 'AtomQuery.js' */            if (!rl) {
/*Line 137 - 'AtomQuery.js' */                rl = [];
/*Line 138 - 'AtomQuery.js' */                g[si] = rl;
/*Line 139 - 'AtomQuery.js' */                r.push({ key: si, items: rl });
/*Line 140 - 'AtomQuery.js' */            }
/*Line 141 - 'AtomQuery.js' */            rl.push(item);
/*Line 142 - 'AtomQuery.js' */        }
/*Line 143 - 'AtomQuery.js' */        return Atom.query(r);
/*Line 144 - 'AtomQuery.js' */    }

/*Line 146 - 'AtomQuery.js' */};

/*Line 148 - 'AtomQuery.js' */window.AtomQuery = AtomQuery;


/*Line 151 - 'AtomQuery.js' */for (var i in AtomQuery) {
/*Line 152 - 'AtomQuery.js' */    AtomEnumerator.prototype[i] = AtomQuery[i];
/*Line 153 - 'AtomQuery.js' */}


/*Line 156 - 'AtomQuery.js' */Atom.query = function (a) {
/*Line 157 - 'AtomQuery.js' */    if (a.length !== undefined) {
/*Line 158 - 'AtomQuery.js' */        return new AtomEnumerator(a);
/*Line 159 - 'AtomQuery.js' */    }
/*Line 160 - 'AtomQuery.js' */    return a;
/*Line 161 - 'AtomQuery.js' */};

/*Line 0 - 'AtomUI.js' */
/*Line 1 - 'AtomUI.js' */
/*Line 2 - 'AtomUI.js' */
/*Line 3 - 'AtomUI.js' */


/*Line 6 - 'AtomUI.js' */var AtomUI =
/*Line 7 - 'AtomUI.js' */{
/*Line 8 - 'AtomUI.js' */    nodeValue: (AtomBrowser.isIE && AtomBrowser.majorVersion < 9) ? "nodeValue" : "value",

/*Line 10 - 'AtomUI.js' */    attributeMap: function (e, r) {
/*Line 11 - 'AtomUI.js' */        var item;
/*Line 12 - 'AtomUI.js' */        var name;
/*Line 13 - 'AtomUI.js' */        var map = {};
/*Line 14 - 'AtomUI.js' */        var ae = new AtomEnumerator(e.attributes);
/*Line 15 - 'AtomUI.js' */        if (r) {
/*Line 16 - 'AtomUI.js' */            while (ae.next()) {
/*Line 17 - 'AtomUI.js' */                item = ae.current();
/*Line 18 - 'AtomUI.js' */                name = item.nodeName;
/*Line 19 - 'AtomUI.js' */                if (/^data\-/i.test(name)) {
/*Line 20 - 'AtomUI.js' */                    name = name.substr(5);
/*Line 21 - 'AtomUI.js' */                }
/*Line 22 - 'AtomUI.js' */                if (r.test(name)) {
/*Line 23 - 'AtomUI.js' */                    r.lastIndex = 0;
/*Line 24 - 'AtomUI.js' */                    map[name] = { value: item[AtomUI.nodeValue], node: item };
/*Line 25 - 'AtomUI.js' */                }
/*Line 26 - 'AtomUI.js' */            }
/*Line 27 - 'AtomUI.js' */            return map;
/*Line 28 - 'AtomUI.js' */        }

/*Line 30 - 'AtomUI.js' */        while (ae.next()) {
/*Line 31 - 'AtomUI.js' */            item = ae.current();
/*Line 32 - 'AtomUI.js' */            name = item.nodeName;
/*Line 33 - 'AtomUI.js' */            if (/^data\-/i.test(name)) {
/*Line 34 - 'AtomUI.js' */                name = name.substr(5);
/*Line 35 - 'AtomUI.js' */            }
/*Line 36 - 'AtomUI.js' */            map[name] = { value: item[AtomUI.nodeValue], node: item };
/*Line 37 - 'AtomUI.js' */        }
/*Line 38 - 'AtomUI.js' */        return map;
/*Line 39 - 'AtomUI.js' */    },

/*Line 41 - 'AtomUI.js' */    attr: function (e, n, sv) {
/*Line 42 - 'AtomUI.js' */        if (sv !== undefined) {
/*Line 43 - 'AtomUI.js' */            if (/^(atom|style)\-/.test(n)) {
/*Line 44 - 'AtomUI.js' */                n = "data-" + n;
/*Line 45 - 'AtomUI.js' */            }
/*Line 46 - 'AtomUI.js' */            //e[n] = sv;
/*Line 47 - 'AtomUI.js' */            e.setAttribute(n, sv);
/*Line 48 - 'AtomUI.js' */            return sv;
/*Line 49 - 'AtomUI.js' */        }
/*Line 50 - 'AtomUI.js' */        var v = e.getAttribute("data-" + n) || e.getAttribute(n);
/*Line 51 - 'AtomUI.js' */        return v;
/*Line 52 - 'AtomUI.js' */    },
/*Line 53 - 'AtomUI.js' */    removeAttr: function (e, n) {
/*Line 54 - 'AtomUI.js' */        e.removeAttribute(n);
/*Line 55 - 'AtomUI.js' */        e.removeAttribute("data-" + n);
/*Line 56 - 'AtomUI.js' */    },

/*Line 58 - 'AtomUI.js' */    getAtomType: function (e) {
/*Line 59 - 'AtomUI.js' */        return AtomUI.attr(e,"atom-type");
/*Line 60 - 'AtomUI.js' */    },

/*Line 62 - 'AtomUI.js' */    cloneNode: ((AtomBrowser.isIE && AtomBrowser.majorVersion < 8) ? (function (e) {

/*Line 64 - 'AtomUI.js' */        var document = window.document;

/*Line 66 - 'AtomUI.js' */        var r = document.createElement(e.nodeName);
/*Line 67 - 'AtomUI.js' */        var ae = new AtomEnumerator(e.attributes);
/*Line 68 - 'AtomUI.js' */        while (ae.next()) {
/*Line 69 - 'AtomUI.js' */            var a = ae.current();
/*Line 70 - 'AtomUI.js' */            try{
/*Line 71 - 'AtomUI.js' */                var name = a.nodeName;
/*Line 72 - 'AtomUI.js' */                var v = a[AtomUI.nodeValue];
/*Line 73 - 'AtomUI.js' */                if (!v)
/*Line 74 - 'AtomUI.js' */                    continue;
/*Line 75 - 'AtomUI.js' */                r.setAttribute(name, v);
/*Line 76 - 'AtomUI.js' */            }catch(ex){}
/*Line 77 - 'AtomUI.js' */        }

/*Line 79 - 'AtomUI.js' */        var firstChild = e.firstChild;
/*Line 80 - 'AtomUI.js' */        while (firstChild) {

/*Line 82 - 'AtomUI.js' */            if (firstChild.nodeType == 3) {
/*Line 83 - 'AtomUI.js' */                var n = document.createTextNode(firstChild.nodeValue);
/*Line 84 - 'AtomUI.js' */                r.appendChild(n);
/*Line 85 - 'AtomUI.js' */            } else if (firstChild.nodeType == 1) {
/*Line 86 - 'AtomUI.js' */                r.appendChild(AtomUI.cloneNode(firstChild));
/*Line 87 - 'AtomUI.js' */            }
/*Line 88 - 'AtomUI.js' */            firstChild = firstChild.nextSibling;
/*Line 89 - 'AtomUI.js' */        }

/*Line 91 - 'AtomUI.js' */        return r;
/*Line 92 - 'AtomUI.js' */    }) : function (e) {
/*Line 93 - 'AtomUI.js' */        return e.cloneNode(true);
/*Line 94 - 'AtomUI.js' */    }),

/*Line 96 - 'AtomUI.js' */    findPresenter: function (e) {
/*Line 97 - 'AtomUI.js' */        //if (!(AtomBrowser.isIE && AtomBrowser.majorVersion < 8)) {
/*Line 98 - 'AtomUI.js' */        //    return $(e).find("[atom-presenter]").get(0);
/*Line 99 - 'AtomUI.js' */        //}
/*Line 100 - 'AtomUI.js' */        var ae = new ChildEnumerator(e);
/*Line 101 - 'AtomUI.js' */        while (ae.next()) {
/*Line 102 - 'AtomUI.js' */            var item = ae.current();
/*Line 103 - 'AtomUI.js' */            var ap = AtomUI.attr(item,"atom-presenter");
/*Line 104 - 'AtomUI.js' */            if (ap)
/*Line 105 - 'AtomUI.js' */                return item;
/*Line 106 - 'AtomUI.js' */            var c = AtomUI.findPresenter(item);
/*Line 107 - 'AtomUI.js' */            if (c)
/*Line 108 - 'AtomUI.js' */                return c;
/*Line 109 - 'AtomUI.js' */        }
/*Line 110 - 'AtomUI.js' */        return null;
/*Line 111 - 'AtomUI.js' */    },

/*Line 113 - 'AtomUI.js' */    parseUrl: function (url) {
/*Line 114 - 'AtomUI.js' */        var r = {};

/*Line 116 - 'AtomUI.js' */        var plist = url.split('&');

/*Line 118 - 'AtomUI.js' */        var ae = new AtomEnumerator(plist);
/*Line 119 - 'AtomUI.js' */        while (ae.next()) {
/*Line 120 - 'AtomUI.js' */            var p = ae.current().split('=');
/*Line 121 - 'AtomUI.js' */            var key = p[0];
/*Line 122 - 'AtomUI.js' */            var val = p[1];
/*Line 123 - 'AtomUI.js' */            if (val) {
/*Line 124 - 'AtomUI.js' */                val = decodeURIComponent(val);
/*Line 125 - 'AtomUI.js' */            }
/*Line 126 - 'AtomUI.js' */            val = AtomUI.parseValue(val);
/*Line 127 - 'AtomUI.js' */            r[key] = val;
/*Line 128 - 'AtomUI.js' */        }
/*Line 129 - 'AtomUI.js' */        return r;
/*Line 130 - 'AtomUI.js' */    },

/*Line 132 - 'AtomUI.js' */    parseValue: function (val) {
/*Line 133 - 'AtomUI.js' */        var n;
/*Line 134 - 'AtomUI.js' */        if (/^[0-9]+$/.test(val)) {
/*Line 135 - 'AtomUI.js' */            n = parseInt(val, 10);
/*Line 136 - 'AtomUI.js' */            if (!isNaN(n)) {
/*Line 137 - 'AtomUI.js' */                val = n;
/*Line 138 - 'AtomUI.js' */            }
/*Line 139 - 'AtomUI.js' */            return val;
/*Line 140 - 'AtomUI.js' */        }
/*Line 141 - 'AtomUI.js' */        if (/^[0-9]+\.[0-9]+/gi.test(val)) {
/*Line 142 - 'AtomUI.js' */            n = parseFloat(val);
/*Line 143 - 'AtomUI.js' */            if (!isNaN(n)) {
/*Line 144 - 'AtomUI.js' */                val = n;
/*Line 145 - 'AtomUI.js' */            }
/*Line 146 - 'AtomUI.js' */            return val;
/*Line 147 - 'AtomUI.js' */        }

/*Line 149 - 'AtomUI.js' */        if (/true/.test(val)) {
/*Line 150 - 'AtomUI.js' */            val = true;
/*Line 151 - 'AtomUI.js' */            return val;
/*Line 152 - 'AtomUI.js' */        }
/*Line 153 - 'AtomUI.js' */        if (/false/.test(val)) {
/*Line 154 - 'AtomUI.js' */            val = false;
/*Line 155 - 'AtomUI.js' */            return val;
/*Line 156 - 'AtomUI.js' */        }
/*Line 157 - 'AtomUI.js' */        return val;
/*Line 158 - 'AtomUI.js' */    },

/*Line 160 - 'AtomUI.js' */    cancelEvent: function (e) {

/*Line 162 - 'AtomUI.js' */        var t = e.target;
/*Line 163 - 'AtomUI.js' */        if (t && /input/gi.test(t.nodeName) && /checkbox/gi.test(t.type))
/*Line 164 - 'AtomUI.js' */            return;

/*Line 166 - 'AtomUI.js' */        if (e.preventDefault) { e.preventDefault(); }
/*Line 167 - 'AtomUI.js' */        else { e.stop(); }

/*Line 169 - 'AtomUI.js' */        e.returnValue = false;
/*Line 170 - 'AtomUI.js' */        e.stopPropagation();
/*Line 171 - 'AtomUI.js' */        return false;
/*Line 172 - 'AtomUI.js' */    },

/*Line 174 - 'AtomUI.js' */    assignID: function (element) {
/*Line 175 - 'AtomUI.js' */        if (!element.id) {
/*Line 176 - 'AtomUI.js' */            element.id = "__waID" + AtomUI.getNewIndex();
/*Line 177 - 'AtomUI.js' */        }
/*Line 178 - 'AtomUI.js' */        return element.id;
/*Line 179 - 'AtomUI.js' */    },

/*Line 181 - 'AtomUI.js' */    atomParent: function (element) {
/*Line 182 - 'AtomUI.js' */        if (element.atomControl) {
/*Line 183 - 'AtomUI.js' */            return element.atomControl;
/*Line 184 - 'AtomUI.js' */        }
/*Line 185 - 'AtomUI.js' */        if (element === document || element === window || !element.parentNode)
/*Line 186 - 'AtomUI.js' */            return null;
/*Line 187 - 'AtomUI.js' */        return AtomUI.atomParent(element._logicalParent || element.parentNode);
/*Line 188 - 'AtomUI.js' */    },
/*Line 189 - 'AtomUI.js' */    //startsWith: function (text, part) {
/*Line 190 - 'AtomUI.js' */    //    if (!text || text.constructor != String)
/*Line 191 - 'AtomUI.js' */    //        return false;
/*Line 192 - 'AtomUI.js' */    //    return text.indexOf(part) == 0;
/*Line 193 - 'AtomUI.js' */    //},
/*Line 194 - 'AtomUI.js' */    //endsWith: function (text, part) {
/*Line 195 - 'AtomUI.js' */    //    if (!text || text.constructor != String)
/*Line 196 - 'AtomUI.js' */    //        return false;
/*Line 197 - 'AtomUI.js' */    //    return text.lastIndexOf(part) == (text.length - part.length);
/*Line 198 - 'AtomUI.js' */    //},

/*Line 200 - 'AtomUI.js' */    toNumber: function (text) {
/*Line 201 - 'AtomUI.js' */        if (!text)
/*Line 202 - 'AtomUI.js' */            return 0;
/*Line 203 - 'AtomUI.js' */        if (text.constructor == String)
/*Line 204 - 'AtomUI.js' */            return parseFloat(text);
/*Line 205 - 'AtomUI.js' */        return text;
/*Line 206 - 'AtomUI.js' */    },

/*Line 208 - 'AtomUI.js' */    isNode: function (o) {
/*Line 209 - 'AtomUI.js' */        try {
/*Line 210 - 'AtomUI.js' */            if (window.XMLHttpRequest && o instanceof XMLHttpRequest)
/*Line 211 - 'AtomUI.js' */                return true;
/*Line 212 - 'AtomUI.js' */        } catch (ex) {
/*Line 213 - 'AtomUI.js' */        }
/*Line 214 - 'AtomUI.js' */        //if (o.addEventListener)
/*Line 215 - 'AtomUI.js' */        //    return true;

/*Line 217 - 'AtomUI.js' */        if (o === window || o === document)
/*Line 218 - 'AtomUI.js' */            return true;
/*Line 219 - 'AtomUI.js' */        return (
/*Line 220 - 'AtomUI.js' */        typeof Node === "object" ? o instanceof Node :
/*Line 221 - 'AtomUI.js' */        typeof o === "object" && typeof o.nodeType === "number" && typeof o.nodeName === "string"
/*Line 222 - 'AtomUI.js' */      );
/*Line 223 - 'AtomUI.js' */    },

/*Line 225 - 'AtomUI.js' */    createDelegate: function (instance, methodName) {
/*Line 226 - 'AtomUI.js' */        return this.getDelegate(instance, methodName, true);
/*Line 227 - 'AtomUI.js' */    },
/*Line 228 - 'AtomUI.js' */    getDelegate: function (instance, methodName, create) {
/*Line 229 - 'AtomUI.js' */        if (methodName && methodName.constructor != String)
/*Line 230 - 'AtomUI.js' */            throw new Error("methodName has to be string");
/*Line 231 - 'AtomUI.js' */        var d = instance.__delegates;
/*Line 232 - 'AtomUI.js' */        if (!d) {
/*Line 233 - 'AtomUI.js' */            if (!create)
/*Line 234 - 'AtomUI.js' */                return null;
/*Line 235 - 'AtomUI.js' */            d = {};
/*Line 236 - 'AtomUI.js' */            instance.__delegates = d;
/*Line 237 - 'AtomUI.js' */        }
/*Line 238 - 'AtomUI.js' */        var m = d[methodName];
/*Line 239 - 'AtomUI.js' */        if (!m) {
/*Line 240 - 'AtomUI.js' */            if (!create)
/*Line 241 - 'AtomUI.js' */                return null;
/*Line 242 - 'AtomUI.js' */            var f = instance[methodName];
/*Line 243 - 'AtomUI.js' */            if (!f) {
/*Line 244 - 'AtomUI.js' */                throw new Error("method " + methodName + " not found");
/*Line 245 - 'AtomUI.js' */            }
/*Line 246 - 'AtomUI.js' */            m = function () {
/*Line 247 - 'AtomUI.js' */                return f.apply(instance, arguments);
/*Line 248 - 'AtomUI.js' */            };
/*Line 249 - 'AtomUI.js' */            d[methodName] = m;
/*Line 250 - 'AtomUI.js' */        }
/*Line 251 - 'AtomUI.js' */        return m;
/*Line 252 - 'AtomUI.js' */    },

/*Line 254 - 'AtomUI.js' */    __index: 1000,
/*Line 255 - 'AtomUI.js' */    getNewIndex: function () {
/*Line 256 - 'AtomUI.js' */        this.__index = this.__index + 1;
/*Line 257 - 'AtomUI.js' */        return this.__index;
/*Line 258 - 'AtomUI.js' */    },

/*Line 260 - 'AtomUI.js' */    contains: function (array, item) {
/*Line 261 - 'AtomUI.js' */        var n = array.length;
/*Line 262 - 'AtomUI.js' */        var i = 0;
/*Line 263 - 'AtomUI.js' */        for (i = 0; i < n; i++) {
/*Line 264 - 'AtomUI.js' */            if (array[i] == item)
/*Line 265 - 'AtomUI.js' */                return true;
/*Line 266 - 'AtomUI.js' */        }
/*Line 267 - 'AtomUI.js' */        return false;
/*Line 268 - 'AtomUI.js' */    },

/*Line 270 - 'AtomUI.js' */    removeAllChildren: function (element) {
/*Line 271 - 'AtomUI.js' */        while (element.hasChildNodes()) {
/*Line 272 - 'AtomUI.js' */            var lc = element.lastChild;
/*Line 273 - 'AtomUI.js' */            if (!lc)
/*Line 274 - 'AtomUI.js' */                break;
/*Line 275 - 'AtomUI.js' */            //element.removeChild(lc);
/*Line 276 - 'AtomUI.js' */            if (lc.atomControl) {
/*Line 277 - 'AtomUI.js' */                lc.atomControl.dispose();
/*Line 278 - 'AtomUI.js' */                delete lc.atomControl;
/*Line 279 - 'AtomUI.js' */            }
/*Line 280 - 'AtomUI.js' */            $(lc).remove();
/*Line 281 - 'AtomUI.js' */            //delete lc;
/*Line 282 - 'AtomUI.js' */        }
/*Line 283 - 'AtomUI.js' */    },

/*Line 285 - 'AtomUI.js' */    isWebkit: function () {
/*Line 286 - 'AtomUI.js' */        if (window.navigator.userAgent.toLowerCase().indexOf("webkit") == -1)
/*Line 287 - 'AtomUI.js' */            return false;
/*Line 288 - 'AtomUI.js' */        return true;
/*Line 289 - 'AtomUI.js' */    },

/*Line 291 - 'AtomUI.js' */    isWeirdControl: function (e) {
/*Line 292 - 'AtomUI.js' */        return e.nodeName == "BUTTON" || e.nodeName == "SELECT" || (e.nodeName == "INPUT" && e.getAttribute('type') == "submit");
/*Line 293 - 'AtomUI.js' */    },

/*Line 295 - 'AtomUI.js' */    parseCSS: function (e, a) {
/*Line 296 - 'AtomUI.js' */        var p = parseInt($(e).css(a), 10);
/*Line 297 - 'AtomUI.js' */        if (isNaN(p))
/*Line 298 - 'AtomUI.js' */            return 0;
/*Line 299 - 'AtomUI.js' */        return p;
/*Line 300 - 'AtomUI.js' */    },

/*Line 302 - 'AtomUI.js' */    setItemRect: function (e, r) {

/*Line 304 - 'AtomUI.js' */        var isButton = this.isWeirdControl(e);

/*Line 306 - 'AtomUI.js' */        if (r.width) {
/*Line 307 - 'AtomUI.js' */            r.width -= this.parseCSS(e, "marginLeft") + this.parseCSS(e, "marginRight");
/*Line 308 - 'AtomUI.js' */            if (!isButton) {
/*Line 309 - 'AtomUI.js' */                r.width -= this.parseCSS(e, "borderLeftWidth") + this.parseCSS(e, "borderRightWidth");
/*Line 310 - 'AtomUI.js' */                r.width -= this.parseCSS(e, "paddingLeft") + this.parseCSS(e, "paddingRight");
/*Line 311 - 'AtomUI.js' */            }
/*Line 312 - 'AtomUI.js' */            if (r.width < 0)
/*Line 313 - 'AtomUI.js' */                r.width = 0;
/*Line 314 - 'AtomUI.js' */            e.style.width = r.width + "px";
/*Line 315 - 'AtomUI.js' */        }
/*Line 316 - 'AtomUI.js' */        if (r.height) {
/*Line 317 - 'AtomUI.js' */            //r.height -= $(e).outerWidth(true) - $(e).width();
/*Line 318 - 'AtomUI.js' */            r.height -= this.parseCSS(e, "marginTop") + this.parseCSS(e, "marginBottom");
/*Line 319 - 'AtomUI.js' */            if (!isButton) {
/*Line 320 - 'AtomUI.js' */                r.height -= this.parseCSS(e, "borderTopWidth") + this.parseCSS(e, "borderBottomWidth");
/*Line 321 - 'AtomUI.js' */                r.height -= this.parseCSS(e, "paddingTop") + this.parseCSS(e, "paddingBottom");
/*Line 322 - 'AtomUI.js' */            }
/*Line 323 - 'AtomUI.js' */            if (r.height < 0)
/*Line 324 - 'AtomUI.js' */                r.height = 0;
/*Line 325 - 'AtomUI.js' */            e.style.height = r.height + "px";
/*Line 326 - 'AtomUI.js' */        }
/*Line 327 - 'AtomUI.js' */        if (r.left) {
/*Line 328 - 'AtomUI.js' */            e.style.left = r.left + "px";
/*Line 329 - 'AtomUI.js' */        }
/*Line 330 - 'AtomUI.js' */        if (r.top) {
/*Line 331 - 'AtomUI.js' */            e.style.top = r.top + "px";
/*Line 332 - 'AtomUI.js' */        }
/*Line 333 - 'AtomUI.js' */    },

/*Line 335 - 'AtomUI.js' */    getPresenterOwner: function (ctrl, p) {
/*Line 336 - 'AtomUI.js' */        if (ctrl._presenters) {
/*Line 337 - 'AtomUI.js' */            var ae = new AtomEnumerator(ctrl._presenters);
/*Line 338 - 'AtomUI.js' */            while (ae.next()) {
/*Line 339 - 'AtomUI.js' */                var c = ae.current();
/*Line 340 - 'AtomUI.js' */                if (c == p)
/*Line 341 - 'AtomUI.js' */                    return ctrl;
/*Line 342 - 'AtomUI.js' */            }
/*Line 343 - 'AtomUI.js' */        }
/*Line 344 - 'AtomUI.js' */        return this.getPresenterOwner(ctrl.get_atomParent(), p);
/*Line 345 - 'AtomUI.js' */    },

/*Line 347 - 'AtomUI.js' */    createCss: function (o) {
/*Line 348 - 'AtomUI.js' */        if (!o)
/*Line 349 - 'AtomUI.js' */            return "";
/*Line 350 - 'AtomUI.js' */        if (o.constructor == String)
/*Line 351 - 'AtomUI.js' */            return o;
/*Line 352 - 'AtomUI.js' */        var list = [];
/*Line 353 - 'AtomUI.js' */        for (var k in o) {
/*Line 354 - 'AtomUI.js' */            var v = o[k];
/*Line 355 - 'AtomUI.js' */            if (!v)
/*Line 356 - 'AtomUI.js' */                continue;
/*Line 357 - 'AtomUI.js' */            list.push(k);
/*Line 358 - 'AtomUI.js' */        }
/*Line 359 - 'AtomUI.js' */        return list.join(" ");
/*Line 360 - 'AtomUI.js' */    },

/*Line 362 - 'AtomUI.js' */    createControl: function (element, type, data, newScope) {
/*Line 363 - 'AtomUI.js' */        if (element.atomControl)
/*Line 364 - 'AtomUI.js' */            return;
/*Line 365 - 'AtomUI.js' */        if (!type) {
/*Line 366 - 'AtomUI.js' */            type = AtomUI.getAtomType(element);
/*Line 367 - 'AtomUI.js' */            type = WebAtoms[type];
/*Line 368 - 'AtomUI.js' */        } else {
/*Line 369 - 'AtomUI.js' */            if (type.constructor == String) {
/*Line 370 - 'AtomUI.js' */                type = WebAtoms[type];
/*Line 371 - 'AtomUI.js' */            }
/*Line 372 - 'AtomUI.js' */        }
/*Line 373 - 'AtomUI.js' */        if (type) {
/*Line 374 - 'AtomUI.js' */            var ctrl = new type(element);
/*Line 375 - 'AtomUI.js' */            if (data) {
/*Line 376 - 'AtomUI.js' */                ctrl._data = data;
/*Line 377 - 'AtomUI.js' */            }
/*Line 378 - 'AtomUI.js' */            if (newScope) {
/*Line 379 - 'AtomUI.js' */                ctrl._scope = newScope;
/*Line 380 - 'AtomUI.js' */            }

/*Line 382 - 'AtomUI.js' */            //inits templates..
/*Line 383 - 'AtomUI.js' */            //ctrl.prepareControl();

/*Line 385 - 'AtomUI.js' */            //init templates and creates controls...
/*Line 386 - 'AtomUI.js' */            ctrl.createChildren();

/*Line 388 - 'AtomUI.js' */            if (data) {
/*Line 389 - 'AtomUI.js' */                ctrl.init();
/*Line 390 - 'AtomUI.js' */            }
/*Line 391 - 'AtomUI.js' */            //$(element).removeAttr("atom-type");
/*Line 392 - 'AtomUI.js' */            return ctrl;
/*Line 393 - 'AtomUI.js' */        }
/*Line 394 - 'AtomUI.js' */        return null;
/*Line 395 - 'AtomUI.js' */    }

/*Line 397 - 'AtomUI.js' */};

/*Line 399 - 'AtomUI.js' */window.AtomUI = AtomUI;

/*Line 401 - 'AtomUI.js' */AtomUI.isIE7 = window.navigator.userAgent.indexOf("MSIE 7.0") != -1;
/*Line 402 - 'AtomUI.js' */AtomUI.isIE8 = window.navigator.userAgent.indexOf("MSIE 8.0") != -1;

/*Line 404 - 'AtomUI.js' */window.AtomUri = function (url) {
/*Line 405 - 'AtomUI.js' */    var path;
/*Line 406 - 'AtomUI.js' */    var query = "";
/*Line 407 - 'AtomUI.js' */    var hash = "";
/*Line 408 - 'AtomUI.js' */    var t = url.split('?');
/*Line 409 - 'AtomUI.js' */    path = t[0];
/*Line 410 - 'AtomUI.js' */    if (t.length == 2) {
/*Line 411 - 'AtomUI.js' */        query = t[1] || "";

/*Line 413 - 'AtomUI.js' */        t = query.split('#');
/*Line 414 - 'AtomUI.js' */        query = t[0];
/*Line 415 - 'AtomUI.js' */        hash = t[1] || "";
/*Line 416 - 'AtomUI.js' */    } else {
/*Line 417 - 'AtomUI.js' */        t = path.split('#');
/*Line 418 - 'AtomUI.js' */        path = t[0];
/*Line 419 - 'AtomUI.js' */        hash = t[1] || "";
/*Line 420 - 'AtomUI.js' */    }

/*Line 422 - 'AtomUI.js' */    // extract protocol and domain...

/*Line 424 - 'AtomUI.js' */    var scheme = location.protocol;
/*Line 425 - 'AtomUI.js' */    var host = location.host;
/*Line 426 - 'AtomUI.js' */    var port = location.port;

/*Line 428 - 'AtomUI.js' */    var i = path.indexOf('//');
/*Line 429 - 'AtomUI.js' */    if (i !== -1) {
/*Line 430 - 'AtomUI.js' */        scheme = path.substr(0, i);
/*Line 431 - 'AtomUI.js' */        path = path.substr(i + 2);


/*Line 434 - 'AtomUI.js' */        i = path.indexOf('/');
/*Line 435 - 'AtomUI.js' */        if (i !== -1) {
/*Line 436 - 'AtomUI.js' */            host = path.substr(0, i);
/*Line 437 - 'AtomUI.js' */            path = path.substr(i + 1);
/*Line 438 - 'AtomUI.js' */            t = host.split(':');
/*Line 439 - 'AtomUI.js' */            if (t.length > 1) {
/*Line 440 - 'AtomUI.js' */                host = t[0];
/*Line 441 - 'AtomUI.js' */                port = t[1];
/*Line 442 - 'AtomUI.js' */            }
/*Line 443 - 'AtomUI.js' */        }
/*Line 444 - 'AtomUI.js' */    }
/*Line 445 - 'AtomUI.js' */    this.host = host;
/*Line 446 - 'AtomUI.js' */    this.protocol = scheme;
/*Line 447 - 'AtomUI.js' */    this.port = port;
/*Line 448 - 'AtomUI.js' */    this.path = path;



/*Line 452 - 'AtomUI.js' */    this.query = AtomUI.parseUrl(query);
/*Line 453 - 'AtomUI.js' */    this.hash = AtomUI.parseUrl(hash);
/*Line 454 - 'AtomUI.js' */}
/*Line 0 - 'AtomBindingHelper.js' */


/*Line 3 - 'AtomBindingHelper.js' */var AtomBinder = {
/*Line 4 - 'AtomBindingHelper.js' */    getClone: function (dupeObj) {
/*Line 5 - 'AtomBindingHelper.js' */        var retObj = {};
/*Line 6 - 'AtomBindingHelper.js' */        if (typeof (dupeObj) == 'object') {
/*Line 7 - 'AtomBindingHelper.js' */            if (typeof (dupeObj.length) != 'undefined')
/*Line 8 - 'AtomBindingHelper.js' */                var retObj = new Array();
/*Line 9 - 'AtomBindingHelper.js' */            for (var objInd in dupeObj) {
/*Line 10 - 'AtomBindingHelper.js' */                var val = dupeObj[objInd];
/*Line 11 - 'AtomBindingHelper.js' */                if (val === undefined)
/*Line 12 - 'AtomBindingHelper.js' */                    continue;
/*Line 13 - 'AtomBindingHelper.js' */                if (val === null) {
/*Line 14 - 'AtomBindingHelper.js' */                    retObj[objInd] = null;
/*Line 15 - 'AtomBindingHelper.js' */                    continue;
/*Line 16 - 'AtomBindingHelper.js' */                }
/*Line 17 - 'AtomBindingHelper.js' */                if (/^\_\$\_/gi.test(objInd))
/*Line 18 - 'AtomBindingHelper.js' */                    continue;
/*Line 19 - 'AtomBindingHelper.js' */                var type = typeof (val);
/*Line 20 - 'AtomBindingHelper.js' */                if (type == 'object') {
/*Line 21 - 'AtomBindingHelper.js' */                    if (val.constructor == Date) {
/*Line 22 - 'AtomBindingHelper.js' */                        retObj[objInd] = "/DateISO(" + AtomDate.toLocalTime(val) + ")/";
/*Line 23 - 'AtomBindingHelper.js' */                    } else {
/*Line 24 - 'AtomBindingHelper.js' */                        retObj[objInd] = AtomBinder.getClone(val);
/*Line 25 - 'AtomBindingHelper.js' */                    }
/*Line 26 - 'AtomBindingHelper.js' */                } else if (type == 'string') {
/*Line 27 - 'AtomBindingHelper.js' */                    retObj[objInd] = val;
/*Line 28 - 'AtomBindingHelper.js' */                } else if (type == 'number') {
/*Line 29 - 'AtomBindingHelper.js' */                    retObj[objInd] = val;
/*Line 30 - 'AtomBindingHelper.js' */                } else if (type == 'boolean') {
/*Line 31 - 'AtomBindingHelper.js' */                    ((val == true) ? retObj[objInd] = true : retObj[objInd] = false);
/*Line 32 - 'AtomBindingHelper.js' */                } else if (type == 'date') {
/*Line 33 - 'AtomBindingHelper.js' */                    retObj[objInd] = val.getTime();
/*Line 34 - 'AtomBindingHelper.js' */                }
/*Line 35 - 'AtomBindingHelper.js' */            }
/*Line 36 - 'AtomBindingHelper.js' */        }
/*Line 37 - 'AtomBindingHelper.js' */        return retObj;
/*Line 38 - 'AtomBindingHelper.js' */    },
/*Line 39 - 'AtomBindingHelper.js' */    setValue: function (target, key, value) {
/*Line 40 - 'AtomBindingHelper.js' */        if (!target && value === undefined)
/*Line 41 - 'AtomBindingHelper.js' */            return;
/*Line 42 - 'AtomBindingHelper.js' */        var oldValue = AtomBinder.getValue(target, key);
/*Line 43 - 'AtomBindingHelper.js' */        if (oldValue === value)
/*Line 44 - 'AtomBindingHelper.js' */            return;
/*Line 45 - 'AtomBindingHelper.js' */        var f = target["set_" + key];
/*Line 46 - 'AtomBindingHelper.js' */        if (f) {
/*Line 47 - 'AtomBindingHelper.js' */            f.apply(target, [value]);
/*Line 48 - 'AtomBindingHelper.js' */        }
/*Line 49 - 'AtomBindingHelper.js' */        else {
/*Line 50 - 'AtomBindingHelper.js' */            target[key] = value;
/*Line 51 - 'AtomBindingHelper.js' */        }
/*Line 52 - 'AtomBindingHelper.js' */        AtomBinder.refreshValue(target, key, oldValue, value);
/*Line 53 - 'AtomBindingHelper.js' */    },
/*Line 54 - 'AtomBindingHelper.js' */    refreshValue: function (target, key) {
/*Line 55 - 'AtomBindingHelper.js' */        var handlers = AtomBinder.get_WatchHandler(target, key);
/*Line 56 - 'AtomBindingHelper.js' */        if (handlers == undefined || handlers == null)
/*Line 57 - 'AtomBindingHelper.js' */            return;
/*Line 58 - 'AtomBindingHelper.js' */        var ae = new AtomEnumerator(handlers);
/*Line 59 - 'AtomBindingHelper.js' */        while (ae.next()) {
/*Line 60 - 'AtomBindingHelper.js' */            var item = ae.current();
/*Line 61 - 'AtomBindingHelper.js' */            item(target, key);
/*Line 62 - 'AtomBindingHelper.js' */        }

/*Line 64 - 'AtomBindingHelper.js' */        if (target._$_watcher) {
/*Line 65 - 'AtomBindingHelper.js' */            target._$_watcher._onRefreshValue(target, key);
/*Line 66 - 'AtomBindingHelper.js' */        }
/*Line 67 - 'AtomBindingHelper.js' */    },
/*Line 68 - 'AtomBindingHelper.js' */    getValue: function (target, key) {
/*Line 69 - 'AtomBindingHelper.js' */        if (target == null)
/*Line 70 - 'AtomBindingHelper.js' */            return null;
/*Line 71 - 'AtomBindingHelper.js' */        var f = target["get_" + key];
/*Line 72 - 'AtomBindingHelper.js' */        if (f) {
/*Line 73 - 'AtomBindingHelper.js' */            return f.apply(target);
/*Line 74 - 'AtomBindingHelper.js' */        }
/*Line 75 - 'AtomBindingHelper.js' */        return target[key];
/*Line 76 - 'AtomBindingHelper.js' */    },
/*Line 77 - 'AtomBindingHelper.js' */    add_WatchHandler: function (target, key, handler) {
/*Line 78 - 'AtomBindingHelper.js' */        if (target == null)
/*Line 79 - 'AtomBindingHelper.js' */            return;
/*Line 80 - 'AtomBindingHelper.js' */        var handlers = AtomBinder.get_WatchHandler(target, key);
/*Line 81 - 'AtomBindingHelper.js' */        handlers.push(handler);
/*Line 82 - 'AtomBindingHelper.js' */    },
/*Line 83 - 'AtomBindingHelper.js' */    get_WatchHandler: function (target, key) {
/*Line 84 - 'AtomBindingHelper.js' */        if (target == null)
/*Line 85 - 'AtomBindingHelper.js' */            return null;
/*Line 86 - 'AtomBindingHelper.js' */        var handlers = target._$_handlers;
/*Line 87 - 'AtomBindingHelper.js' */        if (!handlers) {
/*Line 88 - 'AtomBindingHelper.js' */            handlers = {};
/*Line 89 - 'AtomBindingHelper.js' */            target._$_handlers = handlers;
/*Line 90 - 'AtomBindingHelper.js' */        }
/*Line 91 - 'AtomBindingHelper.js' */        var handlersForKey = handlers[key];
/*Line 92 - 'AtomBindingHelper.js' */        if (handlersForKey == undefined || handlersForKey == null) {
/*Line 93 - 'AtomBindingHelper.js' */            handlersForKey = [];
/*Line 94 - 'AtomBindingHelper.js' */            handlers[key] = handlersForKey;
/*Line 95 - 'AtomBindingHelper.js' */        }
/*Line 96 - 'AtomBindingHelper.js' */        return handlersForKey;
/*Line 97 - 'AtomBindingHelper.js' */    },
/*Line 98 - 'AtomBindingHelper.js' */    remove_WatchHandler: function (target, key, handler) {
/*Line 99 - 'AtomBindingHelper.js' */        if (target == null)
/*Line 100 - 'AtomBindingHelper.js' */            return;
/*Line 101 - 'AtomBindingHelper.js' */        if (target._$_handlers === undefined || target._$_handlers === null)
/*Line 102 - 'AtomBindingHelper.js' */            return;
/*Line 103 - 'AtomBindingHelper.js' */        var handlersForKey = target._$_handlers[key];
/*Line 104 - 'AtomBindingHelper.js' */        if (handlersForKey == undefined || handlersForKey == null)
/*Line 105 - 'AtomBindingHelper.js' */            return;
/*Line 106 - 'AtomBindingHelper.js' */        var ae = new AtomEnumerator(handlersForKey);
/*Line 107 - 'AtomBindingHelper.js' */        while (ae.next()) {
/*Line 108 - 'AtomBindingHelper.js' */            if (ae.current() == handler) {
/*Line 109 - 'AtomBindingHelper.js' */                handlersForKey.splice(ae.currentIndex(), 1);
/*Line 110 - 'AtomBindingHelper.js' */                return;
/*Line 111 - 'AtomBindingHelper.js' */            }
/*Line 112 - 'AtomBindingHelper.js' */        }
/*Line 113 - 'AtomBindingHelper.js' */    },

/*Line 115 - 'AtomBindingHelper.js' */    invokeItemsEvent: function (target, mode, index, item) {
/*Line 116 - 'AtomBindingHelper.js' */        var key = "_items";
/*Line 117 - 'AtomBindingHelper.js' */        var handlers = AtomBinder.get_WatchHandler(target, key);
/*Line 118 - 'AtomBindingHelper.js' */        if (!handlers)
/*Line 119 - 'AtomBindingHelper.js' */            return;
/*Line 120 - 'AtomBindingHelper.js' */        var ae = new AtomEnumerator(handlers);
/*Line 121 - 'AtomBindingHelper.js' */        while (ae.next()) {
/*Line 122 - 'AtomBindingHelper.js' */            var obj = ae.current();
/*Line 123 - 'AtomBindingHelper.js' */            obj(mode, index, item);
/*Line 124 - 'AtomBindingHelper.js' */        }
/*Line 125 - 'AtomBindingHelper.js' */        if (target._$_watcher) {
/*Line 126 - 'AtomBindingHelper.js' */            target._$_watcher._onRefreshItems(target, mode, index, item);
/*Line 127 - 'AtomBindingHelper.js' */        }
/*Line 128 - 'AtomBindingHelper.js' */        AtomBinder.refreshValue(target, "length");
/*Line 129 - 'AtomBindingHelper.js' */    },
/*Line 130 - 'AtomBindingHelper.js' */    clear: function (ary) {
/*Line 131 - 'AtomBindingHelper.js' */        ary.length = 0;
/*Line 132 - 'AtomBindingHelper.js' */        AtomBinder.invokeItemsEvent(ary, "refresh", 0, null);
/*Line 133 - 'AtomBindingHelper.js' */    },
/*Line 134 - 'AtomBindingHelper.js' */    addItem: function (ary, item) {
/*Line 135 - 'AtomBindingHelper.js' */        var l = ary.length;
/*Line 136 - 'AtomBindingHelper.js' */        ary.push(item);
/*Line 137 - 'AtomBindingHelper.js' */        AtomBinder.invokeItemsEvent(ary, "add", l, item);
/*Line 138 - 'AtomBindingHelper.js' */    },
/*Line 139 - 'AtomBindingHelper.js' */    insertItem: function (ary, index, item) {
/*Line 140 - 'AtomBindingHelper.js' */        ary.splice(index, 0, item);
/*Line 141 - 'AtomBindingHelper.js' */        AtomBinder.invokeItemsEvent(ary, "add", index, item);
/*Line 142 - 'AtomBindingHelper.js' */    },
/*Line 143 - 'AtomBindingHelper.js' */    addItems: function (ary, items) {
/*Line 144 - 'AtomBindingHelper.js' */        var ae = new AtomEnumerator(items);
/*Line 145 - 'AtomBindingHelper.js' */        while (ae.next()) {
/*Line 146 - 'AtomBindingHelper.js' */            AtomBinder.addItem(ary, ae.current());
/*Line 147 - 'AtomBindingHelper.js' */        }
/*Line 148 - 'AtomBindingHelper.js' */    },
/*Line 149 - 'AtomBindingHelper.js' */    removeItem: function (ary, item) {
/*Line 150 - 'AtomBindingHelper.js' */        var i = ary.indexOf(item);
/*Line 151 - 'AtomBindingHelper.js' */        if (i == -1)
/*Line 152 - 'AtomBindingHelper.js' */            return;
/*Line 153 - 'AtomBindingHelper.js' */        ary.splice(i, 1);
/*Line 154 - 'AtomBindingHelper.js' */        AtomBinder.invokeItemsEvent(ary, "remove", i, item);
/*Line 155 - 'AtomBindingHelper.js' */    },
/*Line 156 - 'AtomBindingHelper.js' */    removeAtIndex: function (ary, i) {
/*Line 157 - 'AtomBindingHelper.js' */        if (i == -1)
/*Line 158 - 'AtomBindingHelper.js' */            return;
/*Line 159 - 'AtomBindingHelper.js' */        var item = ary[i];
/*Line 160 - 'AtomBindingHelper.js' */        ary.splice(i, 1);
/*Line 161 - 'AtomBindingHelper.js' */        AtomBinder.invokeItemsEvent(ary, "remove", i, item);
/*Line 162 - 'AtomBindingHelper.js' */    },
/*Line 163 - 'AtomBindingHelper.js' */    refreshItems: function (ary) {
/*Line 164 - 'AtomBindingHelper.js' */        AtomBinder.invokeItemsEvent(ary, "refresh", -1, null);
/*Line 165 - 'AtomBindingHelper.js' */    },
/*Line 166 - 'AtomBindingHelper.js' */    add_CollectionChanged: function (target, handler) {
/*Line 167 - 'AtomBindingHelper.js' */        if (target == null)
/*Line 168 - 'AtomBindingHelper.js' */            return;
/*Line 169 - 'AtomBindingHelper.js' */        var key = "_items";
/*Line 170 - 'AtomBindingHelper.js' */        var handlers = AtomBinder.get_WatchHandler(target, key);
/*Line 171 - 'AtomBindingHelper.js' */        handlers.push(handler);
/*Line 172 - 'AtomBindingHelper.js' */    },
/*Line 173 - 'AtomBindingHelper.js' */    remove_CollectionChanged: function (target, handler) {
/*Line 174 - 'AtomBindingHelper.js' */        if (target == null)
/*Line 175 - 'AtomBindingHelper.js' */            return;
/*Line 176 - 'AtomBindingHelper.js' */        if (!target._$_handlers)
/*Line 177 - 'AtomBindingHelper.js' */            return;
/*Line 178 - 'AtomBindingHelper.js' */        var key = "_items";
/*Line 179 - 'AtomBindingHelper.js' */        var handlersForKey = target._$_handlers[key];
/*Line 180 - 'AtomBindingHelper.js' */        if (handlersForKey == undefined || handlersForKey == null)
/*Line 181 - 'AtomBindingHelper.js' */            return;
/*Line 182 - 'AtomBindingHelper.js' */        var ae = new AtomEnumerator(handlersForKey);
/*Line 183 - 'AtomBindingHelper.js' */        while (ae.next()) {
/*Line 184 - 'AtomBindingHelper.js' */            if (ae.current() == handler) {
/*Line 185 - 'AtomBindingHelper.js' */                handlersForKey.splice(ae.currentIndex(), 1);
/*Line 186 - 'AtomBindingHelper.js' */                return;
/*Line 187 - 'AtomBindingHelper.js' */            }
/*Line 188 - 'AtomBindingHelper.js' */        }
/*Line 189 - 'AtomBindingHelper.js' */    },
/*Line 190 - 'AtomBindingHelper.js' */    setError: function (target, key, message) {
/*Line 191 - 'AtomBindingHelper.js' */        var errors = AtomBinder.getValue(target, "__errors");
/*Line 192 - 'AtomBindingHelper.js' */        if (!errors) {
/*Line 193 - 'AtomBindingHelper.js' */            AtomBinder.setValue(target, "__errors", {});
/*Line 194 - 'AtomBindingHelper.js' */        }
/*Line 195 - 'AtomBindingHelper.js' */        AtomBinder.setValue(errors, key, message);
/*Line 196 - 'AtomBindingHelper.js' */    }

/*Line 198 - 'AtomBindingHelper.js' */};

/*Line 200 - 'AtomBindingHelper.js' */window.AtomBinder = AtomBinder;

/*Line 202 - 'AtomBindingHelper.js' */Atom.clone = AtomBinder.getClone;
/*Line 203 - 'AtomBindingHelper.js' */Atom.add = AtomBinder.addItem;
/*Line 204 - 'AtomBindingHelper.js' */Atom.insert = AtomBinder.insertItem;
/*Line 205 - 'AtomBindingHelper.js' */Atom.remove = AtomBinder.removeItem;
/*Line 206 - 'AtomBindingHelper.js' */Atom.refresh = AtomBinder.refreshValue;
/*Line 207 - 'AtomBindingHelper.js' */Atom.refreshArray = AtomBinder.refreshItems;
/*Line 208 - 'AtomBindingHelper.js' */Atom.clearArray = AtomBinder.clear;
/*Line 0 - 'WebAtoms.Core.js' */
/*Line 1 - 'WebAtoms.Core.js' */
/*Line 2 - 'WebAtoms.Core.js' */
/*Line 3 - 'WebAtoms.Core.js' */
/*Line 4 - 'WebAtoms.Core.js' */
/*Line 5 - 'WebAtoms.Core.js' */
/*Line 6 - 'WebAtoms.Core.js' */
/*Line 7 - 'WebAtoms.Core.js' */

/*Line 9 - 'WebAtoms.Core.js' */Array.prototype.enumerator = function () {
/*Line 10 - 'WebAtoms.Core.js' */    return new AtomEnumerator(this);
/*Line 11 - 'WebAtoms.Core.js' */};

/*Line 13 - 'WebAtoms.Core.js' */if (!Array.prototype.indexOf) {
/*Line 14 - 'WebAtoms.Core.js' */    Array.prototype.indexOf = function (item) {
/*Line 15 - 'WebAtoms.Core.js' */        var i = 0;
/*Line 16 - 'WebAtoms.Core.js' */        for (i = 0; i < this.length; i++) {
/*Line 17 - 'WebAtoms.Core.js' */            if (item == this[i])
/*Line 18 - 'WebAtoms.Core.js' */                return i;
/*Line 19 - 'WebAtoms.Core.js' */        }
/*Line 20 - 'WebAtoms.Core.js' */        return -1;
/*Line 21 - 'WebAtoms.Core.js' */    };
/*Line 22 - 'WebAtoms.Core.js' */}

/*Line 24 - 'WebAtoms.Core.js' */var AtomArray = {

/*Line 26 - 'WebAtoms.Core.js' */    split: function (text, sep) {
/*Line 27 - 'WebAtoms.Core.js' */        if (sep && sep.constructor == String) {
/*Line 28 - 'WebAtoms.Core.js' */            sep = $.trim(sep);
/*Line 29 - 'WebAtoms.Core.js' */        }
/*Line 30 - 'WebAtoms.Core.js' */        var ar = text.split(sep);
/*Line 31 - 'WebAtoms.Core.js' */        var r = [];
/*Line 32 - 'WebAtoms.Core.js' */        var ae = new AtomEnumerator(ar);
/*Line 33 - 'WebAtoms.Core.js' */        var item;
/*Line 34 - 'WebAtoms.Core.js' */        while (ae.next()) {
/*Line 35 - 'WebAtoms.Core.js' */            item = ae.current();
/*Line 36 - 'WebAtoms.Core.js' */            if (item && item.constructor == String) {
/*Line 37 - 'WebAtoms.Core.js' */                item = $.trim(item);
/*Line 38 - 'WebAtoms.Core.js' */            }
/*Line 39 - 'WebAtoms.Core.js' */            r.push(item);
/*Line 40 - 'WebAtoms.Core.js' */        }
/*Line 41 - 'WebAtoms.Core.js' */        return r;
/*Line 42 - 'WebAtoms.Core.js' */    },

/*Line 44 - 'WebAtoms.Core.js' */    getValues: function (array, path) {
/*Line 45 - 'WebAtoms.Core.js' */        var item;
/*Line 46 - 'WebAtoms.Core.js' */        var result = array;
/*Line 47 - 'WebAtoms.Core.js' */        if (path) {
/*Line 48 - 'WebAtoms.Core.js' */            result = [];
/*Line 49 - 'WebAtoms.Core.js' */            var ae = new AtomEnumerator(array);
/*Line 50 - 'WebAtoms.Core.js' */            while (ae.next()) {
/*Line 51 - 'WebAtoms.Core.js' */                item = ae.current();
/*Line 52 - 'WebAtoms.Core.js' */                result.push(item[path]);
/*Line 53 - 'WebAtoms.Core.js' */            }
/*Line 54 - 'WebAtoms.Core.js' */        }
/*Line 55 - 'WebAtoms.Core.js' */        return result;
/*Line 56 - 'WebAtoms.Core.js' */    },

/*Line 58 - 'WebAtoms.Core.js' */    intersect: function (array, path, value) {
/*Line 59 - 'WebAtoms.Core.js' */        var result = [];
/*Line 60 - 'WebAtoms.Core.js' */        var ae = new AtomEnumerator(value);
/*Line 61 - 'WebAtoms.Core.js' */        var item;
/*Line 62 - 'WebAtoms.Core.js' */        var match;
/*Line 63 - 'WebAtoms.Core.js' */        while (ae.next()) {
/*Line 64 - 'WebAtoms.Core.js' */            item = ae.current();
/*Line 65 - 'WebAtoms.Core.js' */            match = this.getMatch(array, path, item);
/*Line 66 - 'WebAtoms.Core.js' */            if (match != undefined)
/*Line 67 - 'WebAtoms.Core.js' */                result.push(match);
/*Line 68 - 'WebAtoms.Core.js' */        }
/*Line 69 - 'WebAtoms.Core.js' */        return result;
/*Line 70 - 'WebAtoms.Core.js' */    },

/*Line 72 - 'WebAtoms.Core.js' */    getMatch: function (array, path, value) {
/*Line 73 - 'WebAtoms.Core.js' */        var ae = new AtomEnumerator(array);
/*Line 74 - 'WebAtoms.Core.js' */        var dataItem;
/*Line 75 - 'WebAtoms.Core.js' */        var item;
/*Line 76 - 'WebAtoms.Core.js' */        while (ae.next()) {
/*Line 77 - 'WebAtoms.Core.js' */            dataItem = ae.current();
/*Line 78 - 'WebAtoms.Core.js' */            item = dataItem;
/*Line 79 - 'WebAtoms.Core.js' */            if (path)
/*Line 80 - 'WebAtoms.Core.js' */                item = dataItem[path];
/*Line 81 - 'WebAtoms.Core.js' */            if (item == value)
/*Line 82 - 'WebAtoms.Core.js' */                return dataItem;
/*Line 83 - 'WebAtoms.Core.js' */        }
/*Line 84 - 'WebAtoms.Core.js' */    },

/*Line 86 - 'WebAtoms.Core.js' */    remove: function (array, item) {
/*Line 87 - 'WebAtoms.Core.js' */        var ae = new AtomEnumerator(array);
/*Line 88 - 'WebAtoms.Core.js' */        while (ae.next()) {
/*Line 89 - 'WebAtoms.Core.js' */            var arrayItem = ae.current();
/*Line 90 - 'WebAtoms.Core.js' */            if (arrayItem == item) {
/*Line 91 - 'WebAtoms.Core.js' */                array.splice(ae.currentIndex(), 1);
/*Line 92 - 'WebAtoms.Core.js' */                return;
/*Line 93 - 'WebAtoms.Core.js' */            }
/*Line 94 - 'WebAtoms.Core.js' */        }
/*Line 95 - 'WebAtoms.Core.js' */    }
/*Line 96 - 'WebAtoms.Core.js' */};

/*Line 98 - 'WebAtoms.Core.js' */window.AtomArray = AtomArray;

/*Line 100 - 'WebAtoms.Core.js' *///Creating AtomScope Class
/*Line 101 - 'WebAtoms.Core.js' */var AtomScope = (function () {
/*Line 102 - 'WebAtoms.Core.js' */    return classCreator("WebAtoms.AtomScope", null,
/*Line 103 - 'WebAtoms.Core.js' */        function (owner,parent,app) {
/*Line 104 - 'WebAtoms.Core.js' */            this.owner = owner;
/*Line 105 - 'WebAtoms.Core.js' */            this.parent = parent;
/*Line 106 - 'WebAtoms.Core.js' */            if (app) {
/*Line 107 - 'WebAtoms.Core.js' */                this.__application = app;
/*Line 108 - 'WebAtoms.Core.js' */            }
/*Line 109 - 'WebAtoms.Core.js' */            if (this.__application == this.owner) {
/*Line 110 - 'WebAtoms.Core.js' */                //this._$_watcher = this.__application;
/*Line 111 - 'WebAtoms.Core.js' */                this._v = 0;
/*Line 112 - 'WebAtoms.Core.js' */                this.refreshCommand = function () {
/*Line 113 - 'WebAtoms.Core.js' */                    appScope._v = appScope._v + 1;
/*Line 114 - 'WebAtoms.Core.js' */                    AtomBinder.refreshValue(appScope, "_v");
/*Line 115 - 'WebAtoms.Core.js' */                };
/*Line 116 - 'WebAtoms.Core.js' */            }
/*Line 117 - 'WebAtoms.Core.js' */            this._refreshValue = function (name) {
/*Line 118 - 'WebAtoms.Core.js' */                AtomBinder.refreshValue(this, name);
/*Line 119 - 'WebAtoms.Core.js' */                if (this.__application === this.owner) {
/*Line 120 - 'WebAtoms.Core.js' */                    this.__application._onRefreshValue(this, name);
/*Line 121 - 'WebAtoms.Core.js' */                }
/*Line 122 - 'WebAtoms.Core.js' */            };

/*Line 124 - 'WebAtoms.Core.js' */        },
/*Line 125 - 'WebAtoms.Core.js' */        {
/*Line 126 - 'WebAtoms.Core.js' */            setValue: function (name, value, forceRefresh) {
/*Line 127 - 'WebAtoms.Core.js' */                if (AtomBinder.getValue(this, name) == value) {
/*Line 128 - 'WebAtoms.Core.js' */                    if (forceRefresh) {
/*Line 129 - 'WebAtoms.Core.js' */                        this._refreshValue(name);
/*Line 130 - 'WebAtoms.Core.js' */                    }
/*Line 131 - 'WebAtoms.Core.js' */                    return;
/*Line 132 - 'WebAtoms.Core.js' */                }
/*Line 133 - 'WebAtoms.Core.js' */                var f = this["set_" + name];
/*Line 134 - 'WebAtoms.Core.js' */                if (f) {
/*Line 135 - 'WebAtoms.Core.js' */                    f.apply(this, [value]);
/*Line 136 - 'WebAtoms.Core.js' */                } else {
/*Line 137 - 'WebAtoms.Core.js' */                    this[name] = value;
/*Line 138 - 'WebAtoms.Core.js' */                }
/*Line 139 - 'WebAtoms.Core.js' */                this._refreshValue(name);
/*Line 140 - 'WebAtoms.Core.js' */            }
/*Line 141 - 'WebAtoms.Core.js' */        });
/*Line 142 - 'WebAtoms.Core.js' */})();
/*Line 0 - 'AtomComponent.js' */
/*Line 1 - 'AtomComponent.js' */
/*Line 2 - 'AtomComponent.js' */

/*Line 4 - 'AtomComponent.js' */(function(){
/*Line 5 - 'AtomComponent.js' */    return classCreator("WebAtoms.AtomComponent", null,
/*Line 6 - 'AtomComponent.js' */        function () {
/*Line 7 - 'AtomComponent.js' */            this._eventHandlers = [];
/*Line 8 - 'AtomComponent.js' */        },
/*Line 9 - 'AtomComponent.js' */        {
/*Line 10 - 'AtomComponent.js' */            bindEvent: function (element, name, methodName, key, method) {
/*Line 11 - 'AtomComponent.js' */                if (element == null)
/*Line 12 - 'AtomComponent.js' */                    return;
/*Line 13 - 'AtomComponent.js' */                if (typeof methodName == 'function') {
/*Line 14 - 'AtomComponent.js' */                    method = methodName;
/*Line 15 - 'AtomComponent.js' */                }
/*Line 16 - 'AtomComponent.js' */                method = method || AtomUI.createDelegate(this, methodName);
/*Line 17 - 'AtomComponent.js' */                var be = {
/*Line 18 - 'AtomComponent.js' */                    element: element,
/*Line 19 - 'AtomComponent.js' */                    name: name,
/*Line 20 - 'AtomComponent.js' */                    methodName: methodName,
/*Line 21 - 'AtomComponent.js' */                    handler: method
/*Line 22 - 'AtomComponent.js' */                };
/*Line 23 - 'AtomComponent.js' */                if (key) {
/*Line 24 - 'AtomComponent.js' */                    be.key = key;
/*Line 25 - 'AtomComponent.js' */                }
/*Line 26 - 'AtomComponent.js' */                if (AtomUI.isNode(element)) {
/*Line 27 - 'AtomComponent.js' */                    $(element).bind(name, null, method);
/*Line 28 - 'AtomComponent.js' */                } else {
/*Line 29 - 'AtomComponent.js' */                    if (element.addEventListener) {
/*Line 30 - 'AtomComponent.js' */                        element.addEventListener(name, method, false);
/*Line 31 - 'AtomComponent.js' */                    } else {
/*Line 32 - 'AtomComponent.js' */                        var f = element["add_" + name];
/*Line 33 - 'AtomComponent.js' */                        if (f == null) {
/*Line 34 - 'AtomComponent.js' */                            // try atom binder...
/*Line 35 - 'AtomComponent.js' */                            f = AtomBinder["add_" + name];
/*Line 36 - 'AtomComponent.js' */                            if (key) {
/*Line 37 - 'AtomComponent.js' */                                f.apply(AtomBinder, [element, key, method]);
/*Line 38 - 'AtomComponent.js' */                            }
/*Line 39 - 'AtomComponent.js' */                            else {
/*Line 40 - 'AtomComponent.js' */                                f.apply(AtomBinder, [element, method]);
/*Line 41 - 'AtomComponent.js' */                            }
/*Line 42 - 'AtomComponent.js' */                        } else {
/*Line 43 - 'AtomComponent.js' */                            f.apply(element, [method]);
/*Line 44 - 'AtomComponent.js' */                        }
/*Line 45 - 'AtomComponent.js' */                    }
/*Line 46 - 'AtomComponent.js' */                }
/*Line 47 - 'AtomComponent.js' */                this._eventHandlers.push(be);
/*Line 48 - 'AtomComponent.js' */            },

/*Line 50 - 'AtomComponent.js' */            unbindEvent: function (element, name, methodName, key) {
/*Line 51 - 'AtomComponent.js' */                var ae = new AtomEnumerator(this._eventHandlers);
/*Line 52 - 'AtomComponent.js' */                var removed = [];
/*Line 53 - 'AtomComponent.js' */                while (ae.next()) {
/*Line 54 - 'AtomComponent.js' */                    var be = ae.current();
/*Line 55 - 'AtomComponent.js' */                    if (element && element !== be.element)
/*Line 56 - 'AtomComponent.js' */                        continue;
/*Line 57 - 'AtomComponent.js' */                    if (name && name !== be.name)
/*Line 58 - 'AtomComponent.js' */                        continue;
/*Line 59 - 'AtomComponent.js' */                    if (methodName && methodName !== be.methodName)
/*Line 60 - 'AtomComponent.js' */                        continue;
/*Line 61 - 'AtomComponent.js' */                    if (key && key !== be.key)
/*Line 62 - 'AtomComponent.js' */                        continue;
/*Line 63 - 'AtomComponent.js' */                    if (AtomUI.isNode(be.element)) {
/*Line 64 - 'AtomComponent.js' */                        $(be.element).unbind(be.name, be.handler);
/*Line 65 - 'AtomComponent.js' */                    } else {
/*Line 66 - 'AtomComponent.js' */                        if (be.element.removeEventListener) {
/*Line 67 - 'AtomComponent.js' */                            // dont do any thing..
/*Line 68 - 'AtomComponent.js' */                            be.element.removeEventListener(name, be.handler, false);
/*Line 69 - 'AtomComponent.js' */                        } else {
/*Line 70 - 'AtomComponent.js' */                            var f = be.element["remove_" + be.name];
/*Line 71 - 'AtomComponent.js' */                            if (f == null) {
/*Line 72 - 'AtomComponent.js' */                                f = AtomBinder["remove_" + be.name];
/*Line 73 - 'AtomComponent.js' */                                if (be.key) {
/*Line 74 - 'AtomComponent.js' */                                    f.apply(AtomBinder, [be.element, be.key, be.handler]);
/*Line 75 - 'AtomComponent.js' */                                }
/*Line 76 - 'AtomComponent.js' */                                else {
/*Line 77 - 'AtomComponent.js' */                                    f.apply(AtomBinder, [be.element, be.handler]);
/*Line 78 - 'AtomComponent.js' */                                }
/*Line 79 - 'AtomComponent.js' */                            } else {
/*Line 80 - 'AtomComponent.js' */                                f.apply(be.element, [be.handler]);
/*Line 81 - 'AtomComponent.js' */                            }
/*Line 82 - 'AtomComponent.js' */                        }
/*Line 83 - 'AtomComponent.js' */                    }
/*Line 84 - 'AtomComponent.js' */                    removed.push(be);
/*Line 85 - 'AtomComponent.js' */                }

/*Line 87 - 'AtomComponent.js' */                if (removed.length == this._eventHandlers.length) {
/*Line 88 - 'AtomComponent.js' */                    this._eventHandlers.length = 0;
/*Line 89 - 'AtomComponent.js' */                } else {
/*Line 90 - 'AtomComponent.js' */                    ae = new AtomEnumerator(removed);
/*Line 91 - 'AtomComponent.js' */                    while (ae.next()) {
/*Line 92 - 'AtomComponent.js' */                        var be = ae.current();
/*Line 93 - 'AtomComponent.js' */                        AtomArray.remove(this._eventHandlers, be);
/*Line 94 - 'AtomComponent.js' */                    }
/*Line 95 - 'AtomComponent.js' */                }
/*Line 96 - 'AtomComponent.js' */            },


/*Line 99 - 'AtomComponent.js' */            init: function () {
/*Line 100 - 'AtomComponent.js' */            },
/*Line 101 - 'AtomComponent.js' */            dispose: function () {
/*Line 102 - 'AtomComponent.js' */                // remove all event handlers...
/*Line 103 - 'AtomComponent.js' */                this.unbindEvent(null, null, null);

/*Line 105 - 'AtomComponent.js' */                // also remove __delegates..
/*Line 106 - 'AtomComponent.js' */                if (this.__delegates)
/*Line 107 - 'AtomComponent.js' */                    this.__delegates = null;
/*Line 108 - 'AtomComponent.js' */            }
/*Line 109 - 'AtomComponent.js' */        });
/*Line 110 - 'AtomComponent.js' */})();
/*Line 0 - 'AtomPromise.js' */


/*Line 3 - 'AtomPromise.js' */var AtomPromise = function () {

/*Line 5 - 'AtomPromise.js' */    this._success = [];
/*Line 6 - 'AtomPromise.js' */    this._failed = [];
/*Line 7 - 'AtomPromise.js' */    this._cached = false;

/*Line 9 - 'AtomPromise.js' */    this._process = null;

/*Line 11 - 'AtomPromise.js' */    this._calls = 0;

/*Line 13 - 'AtomPromise.js' */    this._showProgress = true;
/*Line 14 - 'AtomPromise.js' */    this._showError = true;
/*Line 15 - 'AtomPromise.js' */    var _this = this;
/*Line 16 - 'AtomPromise.js' */    this.success = function () {
/*Line 17 - 'AtomPromise.js' */        _this.onSuccess.apply(_this, arguments);
/*Line 18 - 'AtomPromise.js' */    };

/*Line 20 - 'AtomPromise.js' */    this.error = function () {
/*Line 21 - 'AtomPromise.js' */        _this.onError.apply(_this, arguments);
/*Line 22 - 'AtomPromise.js' */    };
/*Line 23 - 'AtomPromise.js' */};

/*Line 25 - 'AtomPromise.js' */window.AtomPromise = AtomPromise;

/*Line 27 - 'AtomPromise.js' */AtomPromise.prototype = {

/*Line 29 - 'AtomPromise.js' */    onSuccess: function (c) {
/*Line 30 - 'AtomPromise.js' */        this._value = c;
/*Line 31 - 'AtomPromise.js' */        if (this._process) {
/*Line 32 - 'AtomPromise.js' */            this._value = this._process(this._value);
/*Line 33 - 'AtomPromise.js' */        }
/*Line 34 - 'AtomPromise.js' */        var r = this._success;
/*Line 35 - 'AtomPromise.js' */        for (var i = 0; i < r.length ; i++) {
/*Line 36 - 'AtomPromise.js' */            r[i](this);
/*Line 37 - 'AtomPromise.js' */        }
/*Line 38 - 'AtomPromise.js' */    },

/*Line 40 - 'AtomPromise.js' */    onError: function () {
/*Line 41 - 'AtomPromise.js' */        this.errors = arguments;
/*Line 42 - 'AtomPromise.js' */        var r = this._failed;
/*Line 43 - 'AtomPromise.js' */        for (var i = 0; i < r.length; i++) {
/*Line 44 - 'AtomPromise.js' */            r[i](this);
/*Line 45 - 'AtomPromise.js' */        }
/*Line 46 - 'AtomPromise.js' */    },

/*Line 48 - 'AtomPromise.js' */    then: function (t) {
/*Line 49 - 'AtomPromise.js' */        this._success.push(t);
/*Line 50 - 'AtomPromise.js' */        return this;
/*Line 51 - 'AtomPromise.js' */    },

/*Line 53 - 'AtomPromise.js' */    process: function (f) {
/*Line 54 - 'AtomPromise.js' */        this._process = f;
/*Line 55 - 'AtomPromise.js' */        return this;
/*Line 56 - 'AtomPromise.js' */    },

/*Line 58 - 'AtomPromise.js' */    failed: function (f) {
/*Line 59 - 'AtomPromise.js' */        this._failed.push(f);
/*Line 60 - 'AtomPromise.js' */        return this;
/*Line 61 - 'AtomPromise.js' */    },

/*Line 63 - 'AtomPromise.js' */    value: function (v) {

/*Line 65 - 'AtomPromise.js' */        if (v !== undefined) {
/*Line 66 - 'AtomPromise.js' */            this._value = v;
/*Line 67 - 'AtomPromise.js' */            return;
/*Line 68 - 'AtomPromise.js' */        }
/*Line 69 - 'AtomPromise.js' */        return this._value;
/*Line 70 - 'AtomPromise.js' */    },

/*Line 72 - 'AtomPromise.js' */    onInvoke: function (r) {
/*Line 73 - 'AtomPromise.js' */        this._invoke = r;
/*Line 74 - 'AtomPromise.js' */        return this;
/*Line 75 - 'AtomPromise.js' */    },

/*Line 77 - 'AtomPromise.js' */    invoke: function () {
/*Line 78 - 'AtomPromise.js' */        if (!this._persist) {
/*Line 79 - 'AtomPromise.js' */            this.invokePromise();
/*Line 80 - 'AtomPromise.js' */            return this;
/*Line 81 - 'AtomPromise.js' */        }
/*Line 82 - 'AtomPromise.js' */        var _this = this;
/*Line 83 - 'AtomPromise.js' */        this.promiseTimeout = setTimeout(function () {
/*Line 84 - 'AtomPromise.js' */            _this.invokePromise();
/*Line 85 - 'AtomPromise.js' */        }, 100);
/*Line 86 - 'AtomPromise.js' */        return this;
/*Line 87 - 'AtomPromise.js' */    },

/*Line 89 - 'AtomPromise.js' */    invokePromise: function () {
/*Line 90 - 'AtomPromise.js' */        this.promiseTimeout = null;
/*Line 91 - 'AtomPromise.js' */        if (this._showProgress) {
/*Line 92 - 'AtomPromise.js' */            atomApplication.setBusy(true);
/*Line 93 - 'AtomPromise.js' */            if (this._calls === 0) {
/*Line 94 - 'AtomPromise.js' */                var f = function () {
/*Line 95 - 'AtomPromise.js' */                    atomApplication.setBusy(false);
/*Line 96 - 'AtomPromise.js' */                };
/*Line 97 - 'AtomPromise.js' */                this.then(f);
/*Line 98 - 'AtomPromise.js' */                this.failed(f);
/*Line 99 - 'AtomPromise.js' */            }
/*Line 100 - 'AtomPromise.js' */        }
/*Line 101 - 'AtomPromise.js' */        this._calls++;
/*Line 102 - 'AtomPromise.js' */        this._invoke(this);
/*Line 103 - 'AtomPromise.js' */        return this;
/*Line 104 - 'AtomPromise.js' */    },

/*Line 106 - 'AtomPromise.js' */    pushValue: function (v) {
/*Line 107 - 'AtomPromise.js' */        var _this = this;
/*Line 108 - 'AtomPromise.js' */        this._cached = true;
/*Line 109 - 'AtomPromise.js' */        setTimeout(function () {
/*Line 110 - 'AtomPromise.js' */            _this.onSuccess.apply(_this, [v]);
/*Line 111 - 'AtomPromise.js' */        }, 1);
/*Line 112 - 'AtomPromise.js' */    },


/*Line 115 - 'AtomPromise.js' */    showProgress: function (b) {
/*Line 116 - 'AtomPromise.js' */        this._showProgress = b;
/*Line 117 - 'AtomPromise.js' */        return this;
/*Line 118 - 'AtomPromise.js' */    },

/*Line 120 - 'AtomPromise.js' */    showError: function (b) {
/*Line 121 - 'AtomPromise.js' */        this._showError = b;
/*Line 122 - 'AtomPromise.js' */        return this;
/*Line 123 - 'AtomPromise.js' */    },

/*Line 125 - 'AtomPromise.js' */    persist: function (v) {
/*Line 126 - 'AtomPromise.js' */        if (v === undefined)
/*Line 127 - 'AtomPromise.js' */            this._persist = true;
/*Line 128 - 'AtomPromise.js' */        else
/*Line 129 - 'AtomPromise.js' */            this._persist = v;
/*Line 130 - 'AtomPromise.js' */        return this;
/*Line 131 - 'AtomPromise.js' */    },

/*Line 133 - 'AtomPromise.js' */    abort: function () {
/*Line 134 - 'AtomPromise.js' */        if (this.promiseTimeout) {
/*Line 135 - 'AtomPromise.js' */            clearTimeout(this.promiseTimeout);
/*Line 136 - 'AtomPromise.js' */            this.promiseTimeout = null;
/*Line 137 - 'AtomPromise.js' */            return;
/*Line 138 - 'AtomPromise.js' */        }
/*Line 139 - 'AtomPromise.js' */        this._failed.length = 0;
/*Line 140 - 'AtomPromise.js' */        this._success.length = 0;
/*Line 141 - 'AtomPromise.js' */        if (this._showProgress) {
/*Line 142 - 'AtomPromise.js' */            atomApplication.setBusy(false);
/*Line 143 - 'AtomPromise.js' */        }
/*Line 144 - 'AtomPromise.js' */        if (this.handle) {
/*Line 145 - 'AtomPromise.js' */            this.handle.abort();
/*Line 146 - 'AtomPromise.js' */        }
/*Line 147 - 'AtomPromise.js' */    }

/*Line 149 - 'AtomPromise.js' */};

/*Line 151 - 'AtomPromise.js' */AtomPromise.getUrl = function (url) {
/*Line 152 - 'AtomPromise.js' */    var pageUrl = location.href;
/*Line 153 - 'AtomPromise.js' */    var index = pageUrl.indexOf('#');
/*Line 154 - 'AtomPromise.js' */    if (index !== -1)
/*Line 155 - 'AtomPromise.js' */        pageUrl = pageUrl.substr(0, index);
/*Line 156 - 'AtomPromise.js' */    if (url) {
/*Line 157 - 'AtomPromise.js' */        index = pageUrl.lastIndexOf('/');
/*Line 158 - 'AtomPromise.js' */        if (index !== -1) {
/*Line 159 - 'AtomPromise.js' */            pageUrl = pageUrl.substr(0, index + 1);
/*Line 160 - 'AtomPromise.js' */        }


/*Line 163 - 'AtomPromise.js' */        //if (AtomUI.startsWith(url, "http://") || AtomUI.startsWith(url, "https://")) {
/*Line 164 - 'AtomPromise.js' */        //    return url;
/*Line 165 - 'AtomPromise.js' */        //}
/*Line 166 - 'AtomPromise.js' */        if (/^(http|https)\:\/\//gi.test(url)) {
/*Line 167 - 'AtomPromise.js' */            return url;
/*Line 168 - 'AtomPromise.js' */        }
/*Line 169 - 'AtomPromise.js' */        if (/^\//gi.test(url)) {
/*Line 170 - 'AtomPromise.js' */            return url;
/*Line 171 - 'AtomPromise.js' */        }
/*Line 172 - 'AtomPromise.js' */        if (/^\./gi.test(url)) {
/*Line 173 - 'AtomPromise.js' */            url = url.substr(1);
/*Line 174 - 'AtomPromise.js' */            //if (AtomUI.endsWith(pageUrl, "/") && AtomUI.startsWith(url, "/")) {
/*Line 175 - 'AtomPromise.js' */            //    url = url.substr(1);
/*Line 176 - 'AtomPromise.js' */            //}
/*Line 177 - 'AtomPromise.js' */            if (/\/$/gi.test(pageUrl) && /^\//gi.test(url)) {
/*Line 178 - 'AtomPromise.js' */                url = url.substr(1);
/*Line 179 - 'AtomPromise.js' */            }
/*Line 180 - 'AtomPromise.js' */            return pageUrl + url;
/*Line 181 - 'AtomPromise.js' */        }
/*Line 182 - 'AtomPromise.js' */        return pageUrl + url;
/*Line 183 - 'AtomPromise.js' */    } else {
/*Line 184 - 'AtomPromise.js' */        return pageUrl;
/*Line 185 - 'AtomPromise.js' */    }
/*Line 186 - 'AtomPromise.js' */};

/*Line 188 - 'AtomPromise.js' */AtomPromise.parseDates = function (obj) {
/*Line 189 - 'AtomPromise.js' */    if (!obj)
/*Line 190 - 'AtomPromise.js' */        return obj;
/*Line 191 - 'AtomPromise.js' */    var type = typeof (obj);
/*Line 192 - 'AtomPromise.js' */    if (type === 'object') {
/*Line 193 - 'AtomPromise.js' */        if (typeof (obj.length) !== 'undefined') {
/*Line 194 - 'AtomPromise.js' */            for (var i = 0; i < obj.length; i++) {
/*Line 195 - 'AtomPromise.js' */                obj[i] = AtomPromise.parseDates(obj[i]);
/*Line 196 - 'AtomPromise.js' */            }
/*Line 197 - 'AtomPromise.js' */            return obj;
/*Line 198 - 'AtomPromise.js' */        }

/*Line 200 - 'AtomPromise.js' */        for (var k in obj) {
/*Line 201 - 'AtomPromise.js' */            var v = obj[k];
/*Line 202 - 'AtomPromise.js' */            if (!v)
/*Line 203 - 'AtomPromise.js' */                continue;
/*Line 204 - 'AtomPromise.js' */            obj[k] = AtomPromise.parseDates(v);
/*Line 205 - 'AtomPromise.js' */        }

/*Line 207 - 'AtomPromise.js' */    }
/*Line 208 - 'AtomPromise.js' */    if (typeof (obj) === 'string' || obj.constructor === String) {
/*Line 209 - 'AtomPromise.js' */        if (/^\/date\(/gi.test(obj) && /\)\/$/gi.test(obj)) {
/*Line 210 - 'AtomPromise.js' */            return AtomDate.parse(obj);
/*Line 211 - 'AtomPromise.js' */        }
/*Line 212 - 'AtomPromise.js' */    }
/*Line 213 - 'AtomPromise.js' */    return obj;
/*Line 214 - 'AtomPromise.js' */};

/*Line 216 - 'AtomPromise.js' */AtomPromise.ajax = function (url, query, options, type) {
/*Line 217 - 'AtomPromise.js' */    var p = new AtomPromise();

/*Line 219 - 'AtomPromise.js' */    if (!options) {
/*Line 220 - 'AtomPromise.js' */        options = {
/*Line 221 - 'AtomPromise.js' */            type: "GET",
/*Line 222 - 'AtomPromise.js' */            dataType: "text",
/*Line 223 - 'AtomPromise.js' */            data: null
/*Line 224 - 'AtomPromise.js' */        };
/*Line 225 - 'AtomPromise.js' */    }

/*Line 227 - 'AtomPromise.js' */    if (AtomConfig.ajax.versionUrl) {
/*Line 228 - 'AtomPromise.js' */        if (options.versionUrl !== undefined && options.versionUrl) {
/*Line 229 - 'AtomPromise.js' */            query = query || {};
/*Line 230 - 'AtomPromise.js' */            query[AtomConfig.ajax.versionKey] = AtomConfig.ajax.version;
/*Line 231 - 'AtomPromise.js' */        }
/*Line 232 - 'AtomPromise.js' */    }


/*Line 235 - 'AtomPromise.js' */    options.success = p.success;
/*Line 236 - 'AtomPromise.js' */    options.error = p.error;

/*Line 238 - 'AtomPromise.js' */    // caching is disabled by default...
/*Line 239 - 'AtomPromise.js' */    if (options.cache === undefined) {
/*Line 240 - 'AtomPromise.js' */        options.cache = false;

/*Line 242 - 'AtomPromise.js' */    }


/*Line 245 - 'AtomPromise.js' */    var u = url;

/*Line 247 - 'AtomPromise.js' */    var dh = AtomConfig.ajax.headers;
/*Line 248 - 'AtomPromise.js' */    if (dh) {
/*Line 249 - 'AtomPromise.js' */        if (!options.headers) {
/*Line 250 - 'AtomPromise.js' */            options.headers = {};
/*Line 251 - 'AtomPromise.js' */        }
/*Line 252 - 'AtomPromise.js' */        for (var k in dh) {
/*Line 253 - 'AtomPromise.js' */            var v = dh[k];
/*Line 254 - 'AtomPromise.js' */            options.headers[k] = v;
/*Line 255 - 'AtomPromise.js' */            if (AtomConfig.debug) {
/*Line 256 - 'AtomPromise.js' */                log("Header set: " + k + "=" + v);
/*Line 257 - 'AtomPromise.js' */            }
/*Line 258 - 'AtomPromise.js' */        }
/*Line 259 - 'AtomPromise.js' */    }


/*Line 262 - 'AtomPromise.js' */    var sc = AtomConfig.ajax.statusCode;
/*Line 263 - 'AtomPromise.js' */    if (sc) {
/*Line 264 - 'AtomPromise.js' */        var osc = options.statusCode || {};
/*Line 265 - 'AtomPromise.js' */        for (var k in sc) {
/*Line 266 - 'AtomPromise.js' */            var v = sc[k];
/*Line 267 - 'AtomPromise.js' */            if (!osc[k]) {
/*Line 268 - 'AtomPromise.js' */                osc[k] = v;
/*Line 269 - 'AtomPromise.js' */            }
/*Line 270 - 'AtomPromise.js' */        }
/*Line 271 - 'AtomPromise.js' */        options.statusCode = osc;
/*Line 272 - 'AtomPromise.js' */    }

/*Line 274 - 'AtomPromise.js' */    var o = options;

/*Line 276 - 'AtomPromise.js' */    var data = o.data;

/*Line 278 - 'AtomPromise.js' */    if (data) {
/*Line 279 - 'AtomPromise.js' */        o.data = AtomBinder.getClone(data);
/*Line 280 - 'AtomPromise.js' */    }
/*Line 281 - 'AtomPromise.js' */    var e = AtomConfig.ajax.jsonPostEncode;
/*Line 282 - 'AtomPromise.js' */    if (e) {
/*Line 283 - 'AtomPromise.js' */        o = e(o);
/*Line 284 - 'AtomPromise.js' */    } else {
/*Line 285 - 'AtomPromise.js' */        o.data = { formModel: JSON.stringify(o.data) };
/*Line 286 - 'AtomPromise.js' */    }

/*Line 288 - 'AtomPromise.js' */    var attachments = o.attachments;
/*Line 289 - 'AtomPromise.js' */    if (attachments && attachments.length) {
/*Line 290 - 'AtomPromise.js' */        var fd = new FormData();
/*Line 291 - 'AtomPromise.js' */        var ae = new AtomEnumerator(attachments);
/*Line 292 - 'AtomPromise.js' */        while (ae.next()) {
/*Line 293 - 'AtomPromise.js' */            fd.append("file" + ae.currentIndex(), ae.current());
/*Line 294 - 'AtomPromise.js' */        }
/*Line 295 - 'AtomPromise.js' */        if (data) {
/*Line 296 - 'AtomPromise.js' */            for (var k in data) {
/*Line 297 - 'AtomPromise.js' */                fd.append(k, data[k]);
/*Line 298 - 'AtomPromise.js' */            }
/*Line 299 - 'AtomPromise.js' */        }
/*Line 300 - 'AtomPromise.js' */        o.type = "POST";
/*Line 301 - 'AtomPromise.js' */        o.xhr = function () {
/*Line 302 - 'AtomPromise.js' */            var myXhr = $.ajaxSettings.xhr();
/*Line 303 - 'AtomPromise.js' */            if (myXhr.upload) {
/*Line 304 - 'AtomPromise.js' */                myXhr.upload.addEventListener('progress', function (e) {
/*Line 305 - 'AtomPromise.js' */                    if (e.lengthComputable) {
/*Line 306 - 'AtomPromise.js' */                        var percentComplete = Math.round(e.loaded * 100 / e.total);
/*Line 307 - 'AtomPromise.js' */                        AtomBinder.setValue(atomApplication, 'progress', percentComplete);
/*Line 308 - 'AtomPromise.js' */                    }
/*Line 309 - 'AtomPromise.js' */                }, false);
/*Line 310 - 'AtomPromise.js' */            }
/*Line 311 - 'AtomPromise.js' */            return myXhr;
/*Line 312 - 'AtomPromise.js' */        };
/*Line 313 - 'AtomPromise.js' */        o.cache = false;
/*Line 314 - 'AtomPromise.js' */        o.contentType = false;
/*Line 315 - 'AtomPromise.js' */        o.processData = false;
/*Line 316 - 'AtomPromise.js' */    }

/*Line 318 - 'AtomPromise.js' */    if (query) {
/*Line 319 - 'AtomPromise.js' */        var q = {};
/*Line 320 - 'AtomPromise.js' */        if (!o.sendRawQueryString) {
/*Line 321 - 'AtomPromise.js' */            for (var k in query) {
/*Line 322 - 'AtomPromise.js' */                var v = query[k];
/*Line 323 - 'AtomPromise.js' */                if (v && ((typeof v) === "object")) {
/*Line 324 - 'AtomPromise.js' */                    v = JSON.stringify(AtomBinder.getClone(v));
/*Line 325 - 'AtomPromise.js' */                    if (v === undefined)
/*Line 326 - 'AtomPromise.js' */                        continue;
/*Line 327 - 'AtomPromise.js' */                    if (v === null)
/*Line 328 - 'AtomPromise.js' */                        continue;
/*Line 329 - 'AtomPromise.js' */                }
/*Line 330 - 'AtomPromise.js' */                q[k] = v;
/*Line 331 - 'AtomPromise.js' */            }
/*Line 332 - 'AtomPromise.js' */        }
/*Line 333 - 'AtomPromise.js' */        u = Atom.url(url, q);
/*Line 334 - 'AtomPromise.js' */    }

/*Line 336 - 'AtomPromise.js' */    if (url) {
/*Line 337 - 'AtomPromise.js' */        p.onInvoke(function () {
/*Line 338 - 'AtomPromise.js' */            p.handle = $.ajax(u, o);
/*Line 339 - 'AtomPromise.js' */        });
/*Line 340 - 'AtomPromise.js' */    }

/*Line 342 - 'AtomPromise.js' */    p.failed(function () {

/*Line 344 - 'AtomPromise.js' */        var res = p.errors[0].responseText;
/*Line 345 - 'AtomPromise.js' */        if (!res) {
/*Line 346 - 'AtomPromise.js' */            if (p.errors[2] !== 'Internal Server Error') {
/*Line 347 - 'AtomPromise.js' */                var m = p.errors[2];
/*Line 348 - 'AtomPromise.js' */                if (m)
/*Line 349 - 'AtomPromise.js' */                    res = m;
/*Line 350 - 'AtomPromise.js' */            }
/*Line 351 - 'AtomPromise.js' */        }

/*Line 353 - 'AtomPromise.js' */        p.error = {
/*Line 354 - 'AtomPromise.js' */            msg: res
/*Line 355 - 'AtomPromise.js' */        };

/*Line 357 - 'AtomPromise.js' */        if (p._showError) {
/*Line 358 - 'AtomPromise.js' */            if (p.error.msg) Atom.alert(p.error.msg);
/*Line 359 - 'AtomPromise.js' */        }
/*Line 360 - 'AtomPromise.js' */    });

/*Line 362 - 'AtomPromise.js' */    p.then(function (p) {
/*Line 363 - 'AtomPromise.js' */        var v = p.value();
/*Line 364 - 'AtomPromise.js' */        v = AtomPromise.parseDates(v);
/*Line 365 - 'AtomPromise.js' */        if (v && v.items && v.merge) {
/*Line 366 - 'AtomPromise.js' */            v.items.total = v.total;
/*Line 367 - 'AtomPromise.js' */            v = v.items;
/*Line 368 - 'AtomPromise.js' */            p.value(v);
/*Line 369 - 'AtomPromise.js' */        }
/*Line 370 - 'AtomPromise.js' */    });

/*Line 372 - 'AtomPromise.js' */    p.showError(true);
/*Line 373 - 'AtomPromise.js' */    p.showProgress(true);

/*Line 375 - 'AtomPromise.js' */    return p;
/*Line 376 - 'AtomPromise.js' */};
/*Line 377 - 'AtomPromise.js' */AtomPromise.get = function (url, query, options) {
/*Line 378 - 'AtomPromise.js' */    options = options || {};
/*Line 379 - 'AtomPromise.js' */    options.type = options.type || "get";
/*Line 380 - 'AtomPromise.js' */    options.dataType = options.dataType || "text";
/*Line 381 - 'AtomPromise.js' */    return AtomPromise.ajax(url, query, options, "get");
/*Line 382 - 'AtomPromise.js' */};

/*Line 384 - 'AtomPromise.js' */AtomPromise.plugins = {
/*Line 385 - 'AtomPromise.js' */};

/*Line 387 - 'AtomPromise.js' */AtomPromise.json = function (url, query, options) {
/*Line 388 - 'AtomPromise.js' */    options = options || {};
/*Line 389 - 'AtomPromise.js' */    options.type = options.type || "get";
/*Line 390 - 'AtomPromise.js' */    options.dataType = options.dataType || "json";

/*Line 392 - 'AtomPromise.js' */    var method = null;

/*Line 394 - 'AtomPromise.js' */    var i = url.indexOf('://');
/*Line 395 - 'AtomPromise.js' */    if (i !== -1) {
/*Line 396 - 'AtomPromise.js' */        var plugin = url.substr(0, i);
/*Line 397 - 'AtomPromise.js' */        if (!/http|https/i.test(plugin)) {
/*Line 398 - 'AtomPromise.js' */            url = url.substr(i + 3);
/*Line 399 - 'AtomPromise.js' */            method = AtomPromise.plugins[plugin];
/*Line 400 - 'AtomPromise.js' */        }
/*Line 401 - 'AtomPromise.js' */    }

/*Line 403 - 'AtomPromise.js' */    method = method || AtomPromise.ajax;

/*Line 405 - 'AtomPromise.js' */    return method(url, query, options, "json");
/*Line 406 - 'AtomPromise.js' */};

/*Line 408 - 'AtomPromise.js' */AtomPromise.cache = {
/*Line 409 - 'AtomPromise.js' */};

/*Line 411 - 'AtomPromise.js' */AtomPromise.cacheInProgress = {
/*Line 412 - 'AtomPromise.js' */};

/*Line 414 - 'AtomPromise.js' */AtomPromise.cachedPromise = function (key, p) {
/*Line 415 - 'AtomPromise.js' */    var c = AtomPromise.cache[key];

/*Line 417 - 'AtomPromise.js' */    if (!c && window.sessionStorage) {
/*Line 418 - 'AtomPromise.js' */        c = window.sessionStorage["__AP" + key];
/*Line 419 - 'AtomPromise.js' */        if (c) {
/*Line 420 - 'AtomPromise.js' */            c = JSON.parse(c);
/*Line 421 - 'AtomPromise.js' */            AtomPromise.cache[key] = c;
/*Line 422 - 'AtomPromise.js' */        }
/*Line 423 - 'AtomPromise.js' */    }

/*Line 425 - 'AtomPromise.js' */    if (c) {
/*Line 426 - 'AtomPromise.js' */        p.onInvoke(function () {
/*Line 427 - 'AtomPromise.js' */            p.pushValue(c);
/*Line 428 - 'AtomPromise.js' */        });
/*Line 429 - 'AtomPromise.js' */        return p;
/*Line 430 - 'AtomPromise.js' */    }

/*Line 432 - 'AtomPromise.js' */    p.then(function (p1) {
/*Line 433 - 'AtomPromise.js' */        AtomPromise.cache[key] = p1.value();
/*Line 434 - 'AtomPromise.js' */        if (window.sessionStorage) {
/*Line 435 - 'AtomPromise.js' */            window.sessionStorage["__AP" + key] = JSON.stringify( p1.value() );
/*Line 436 - 'AtomPromise.js' */        }
/*Line 437 - 'AtomPromise.js' */    });

/*Line 439 - 'AtomPromise.js' */    return p;
/*Line 440 - 'AtomPromise.js' */};

/*Line 442 - 'AtomPromise.js' */AtomPromise.cachedJson = function (url, query, options) {

/*Line 444 - 'AtomPromise.js' */    var vd = new Date();

/*Line 446 - 'AtomPromise.js' */    var v = AtomConfig.ajax.version;
/*Line 447 - 'AtomPromise.js' */    var vk = AtomConfig.ajax.versionKey + '=' + v;

/*Line 449 - 'AtomPromise.js' */    if (url.indexOf('?') === -1) {
/*Line 450 - 'AtomPromise.js' */        vk = '?' + vk;
/*Line 451 - 'AtomPromise.js' */    } else {
/*Line 452 - 'AtomPromise.js' */        if (!/\&$/.test(url)) {
/*Line 453 - 'AtomPromise.js' */            vk = '&' + vk;
/*Line 454 - 'AtomPromise.js' */        }
/*Line 455 - 'AtomPromise.js' */    }
/*Line 456 - 'AtomPromise.js' */    url += vk;

/*Line 458 - 'AtomPromise.js' */    options = options || {};
/*Line 459 - 'AtomPromise.js' */    // caching must be true everywhere
/*Line 460 - 'AtomPromise.js' */    options.cache = true;
/*Line 461 - 'AtomPromise.js' */    options.ifModified = true;
/*Line 462 - 'AtomPromise.js' */    options.versionUrl = false;

/*Line 464 - 'AtomPromise.js' */    var ap = AtomPromise.ajax(url, query, options, "json");
/*Line 465 - 'AtomPromise.js' */    return AtomPromise.cachedPromise(url, ap);
/*Line 466 - 'AtomPromise.js' */};

/*Line 468 - 'AtomPromise.js' */AtomPromise.configCache = {};

/*Line 470 - 'AtomPromise.js' */AtomPromise.configLabel = function (url, value, options) {

/*Line 472 - 'AtomPromise.js' */    if (value === null || value === undefined)
/*Line 473 - 'AtomPromise.js' */        return "";

/*Line 475 - 'AtomPromise.js' */    options = options || {};

/*Line 477 - 'AtomPromise.js' */    var valuePath = options.valuePath || "value";
/*Line 478 - 'AtomPromise.js' */    var labelPath = options.labelPath || "label";
/*Line 479 - 'AtomPromise.js' */    var isNumber = options.isNumber || false;

/*Line 481 - 'AtomPromise.js' */    if (isNumber) {
/*Line 482 - 'AtomPromise.js' */        if (typeof value !== "number") {
/*Line 483 - 'AtomPromise.js' */            value = parseFloat(value);
/*Line 484 - 'AtomPromise.js' */        }
/*Line 485 - 'AtomPromise.js' */    }

/*Line 487 - 'AtomPromise.js' */    var p = new AtomPromise();
/*Line 488 - 'AtomPromise.js' */    p.onInvoke(function () {

/*Line 490 - 'AtomPromise.js' */        var cf = AtomPromise.configCache[url];
/*Line 491 - 'AtomPromise.js' */        if (cf) {
/*Line 492 - 'AtomPromise.js' */            cf = cf[value];
/*Line 493 - 'AtomPromise.js' */            cf = cf ? cf[labelPath] : "";
/*Line 494 - 'AtomPromise.js' */            p.pushValue(cf);
/*Line 495 - 'AtomPromise.js' */            return;
/*Line 496 - 'AtomPromise.js' */        }

/*Line 498 - 'AtomPromise.js' */        var ap = AtomPromise.cachedJson(url);


/*Line 501 - 'AtomPromise.js' */        ap.then(function (a) {
/*Line 502 - 'AtomPromise.js' */            var v = "";

/*Line 504 - 'AtomPromise.js' */            var nv = {};

/*Line 506 - 'AtomPromise.js' */            var ae = new AtomEnumerator(a.value());
/*Line 507 - 'AtomPromise.js' */            while (ae.next()) {
/*Line 508 - 'AtomPromise.js' */                var item = ae.current();
/*Line 509 - 'AtomPromise.js' */                v = item[valuePath];
/*Line 510 - 'AtomPromise.js' */                if (isNumber) {
/*Line 511 - 'AtomPromise.js' */                    if (typeof v !== "number") {
/*Line 512 - 'AtomPromise.js' */                        v = parseFloat(v);
/*Line 513 - 'AtomPromise.js' */                    }
/*Line 514 - 'AtomPromise.js' */                }
/*Line 515 - 'AtomPromise.js' */                nv[v] = item;
/*Line 516 - 'AtomPromise.js' */            }
/*Line 517 - 'AtomPromise.js' */            AtomPromise.configCache[url] = nv;
/*Line 518 - 'AtomPromise.js' */            nv = nv[value];
/*Line 519 - 'AtomPromise.js' */            nv = nv ? nv[labelPath] : "";
/*Line 520 - 'AtomPromise.js' */            p.pushValue(nv);
/*Line 521 - 'AtomPromise.js' */        });

/*Line 523 - 'AtomPromise.js' */        ap.invoke();
/*Line 524 - 'AtomPromise.js' */    });

/*Line 526 - 'AtomPromise.js' */    return p;
/*Line 527 - 'AtomPromise.js' */};

/*Line 529 - 'AtomPromise.js' */AtomPromise.prototype.insertItem = function (index, item, arrayPath) {
/*Line 530 - 'AtomPromise.js' */    return this.then(function (p) {
/*Line 531 - 'AtomPromise.js' */        var v = p.value();
/*Line 532 - 'AtomPromise.js' */        if (v._$_itemInserted)
/*Line 533 - 'AtomPromise.js' */            return;
/*Line 534 - 'AtomPromise.js' */        if (arrayPath) {
/*Line 535 - 'AtomPromise.js' */            v = v[arrayPath];
/*Line 536 - 'AtomPromise.js' */        }
/*Line 537 - 'AtomPromise.js' */        if (index === -1) {
/*Line 538 - 'AtomPromise.js' */            v.push(item);
/*Line 539 - 'AtomPromise.js' */        } else {
/*Line 540 - 'AtomPromise.js' */            v.splice(index || 0, 0, item);
/*Line 541 - 'AtomPromise.js' */        }
/*Line 542 - 'AtomPromise.js' */        v._$_itemInserted = true;        
/*Line 543 - 'AtomPromise.js' */    });
/*Line 544 - 'AtomPromise.js' */};

/*Line 546 - 'AtomPromise.js' */AtomPromise.prototype.toNativePromise = function () {
/*Line 547 - 'AtomPromise.js' */    var self = this;
/*Line 548 - 'AtomPromise.js' */    return new Promise(function (resolve, reject) {
/*Line 549 - 'AtomPromise.js' */        var ap = self;
/*Line 550 - 'AtomPromise.js' */        ap.showProgress(false);
/*Line 551 - 'AtomPromise.js' */        ap.invoke();
/*Line 552 - 'AtomPromise.js' */        ap.then(function (r) {
/*Line 553 - 'AtomPromise.js' */            resolve(r.value());
/*Line 554 - 'AtomPromise.js' */            //console.log(r);
/*Line 555 - 'AtomPromise.js' */        }).failed(function (r) {
/*Line 556 - 'AtomPromise.js' */            reject(r);
/*Line 557 - 'AtomPromise.js' */            //console.log(r);
/*Line 558 - 'AtomPromise.js' */        });
/*Line 559 - 'AtomPromise.js' */    });
/*Line 560 - 'AtomPromise.js' */};

/*Line 562 - 'AtomPromise.js' *///$setValue = AtomBinder.setValue;
/*Line 563 - 'AtomPromise.js' *///$getValue = AtomBinder.getValue;


/*Line 566 - 'AtomPromise.js' *///Object.prototype.setValue = function (key, value) {
/*Line 567 - 'AtomPromise.js' *///    
/*Line 568 - 'AtomPromise.js' *///    AtomBinder.setValue(this, key, value);
/*Line 569 - 'AtomPromise.js' *///};

/*Line 571 - 'AtomPromise.js' *///Object.prototype.getValue = function (key) {
/*Line 572 - 'AtomPromise.js' *///    return AtomBinder.getValue(this, key);
/*Line 573 - 'AtomPromise.js' *///};

/*Line 575 - 'AtomPromise.js' *///Object.prototype.add_WatchHandler = function(key,handler){
/*Line 576 - 'AtomPromise.js' *///    AtomBinder.add_WatchHandler(this,key,handler);
/*Line 577 - 'AtomPromise.js' *///};

/*Line 579 - 'AtomPromise.js' *///Object.prototype.remove_WatchHandler = function(key,handler){
/*Line 580 - 'AtomPromise.js' *///    AtomBinder.remove_WatchHandler(this,key,handler);
/*Line 581 - 'AtomPromise.js' *///};

/*Line 583 - 'AtomPromise.js' *///Array.prototype.add = function (item) {
/*Line 584 - 'AtomPromise.js' *///    AtomBinder.addItem(this, item);
/*Line 585 - 'AtomPromise.js' *///};

/*Line 587 - 'AtomPromise.js' *///Array.prototype.remove = function (item) {
/*Line 588 - 'AtomPromise.js' *///    AtomBinder.removeItem(this, item);
/*Line 589 - 'AtomPromise.js' *///};

/*Line 591 - 'AtomPromise.js' *///Array.prototype.add_CollectionHandler= function(handler){
/*Line 592 - 'AtomPromise.js' *///    AtomBinder.add_CollectionHandler(this,handler);
/*Line 593 - 'AtomPromise.js' *///};

/*Line 595 - 'AtomPromise.js' *///Array.prototype.remove_CollectionHandler= function(handler){
/*Line 596 - 'AtomPromise.js' *///    AtomBinder.remove_CollectionHandler(this,handler);
/*Line 597 - 'AtomPromise.js' *///};


/*Line 600 - 'AtomPromise.js' */var AtomLocalStorage = {

/*Line 602 - 'AtomPromise.js' */    list: function (storage, query)
/*Line 603 - 'AtomPromise.js' */    {
/*Line 604 - 'AtomPromise.js' */    },
/*Line 605 - 'AtomPromise.js' */    add: function (storage, query) {
/*Line 606 - 'AtomPromise.js' */    },
/*Line 607 - 'AtomPromise.js' */    remove: function (storage, query) {
/*Line 608 - 'AtomPromise.js' */    },
/*Line 609 - 'AtomPromise.js' */    clear: function (storage) {
/*Line 610 - 'AtomPromise.js' */    },
/*Line 611 - 'AtomPromise.js' */    set: function (storage, query, data) {
/*Line 612 - 'AtomPromise.js' */    },
/*Line 613 - 'AtomPromise.js' */    get: function (storage, query) {
/*Line 614 - 'AtomPromise.js' */    }

/*Line 616 - 'AtomPromise.js' */};


/*Line 619 - 'AtomPromise.js' */AtomPromise.plugins["local-storage"] = function (url, query, options) {
/*Line 620 - 'AtomPromise.js' */    var tokens = url.split('/');
/*Line 621 - 'AtomPromise.js' */    var storage = tokens[0];
/*Line 622 - 'AtomPromise.js' */    var method = tokens[1];
/*Line 623 - 'AtomPromise.js' */    var ap = new AtomPromise();
/*Line 624 - 'AtomPromise.js' */    ap.onInvoke(function (a) {
/*Line 625 - 'AtomPromise.js' */        var als = AtomLocalStorage;
/*Line 626 - 'AtomPromise.js' */        var r = als[method](storage, query, options.data);
/*Line 627 - 'AtomPromise.js' */        a.pushValue(r);
/*Line 628 - 'AtomPromise.js' */    });
/*Line 629 - 'AtomPromise.js' */    return ap;
/*Line 630 - 'AtomPromise.js' */};

/*Line 0 - 'AtomBinding.js' */
/*Line 1 - 'AtomBinding.js' */

/*Line 3 - 'AtomBinding.js' */(function (baseType) {
/*Line 4 - 'AtomBinding.js' */    return classCreatorEx({
/*Line 5 - 'AtomBinding.js' */        name: "WebAtoms.AtomBinding",
/*Line 6 - 'AtomBinding.js' */        base: baseType,
/*Line 7 - 'AtomBinding.js' */        start: function (control, element, key, path, twoWays, jq, vf, events) {
/*Line 8 - 'AtomBinding.js' */            this.element = element;
/*Line 9 - 'AtomBinding.js' */            this.control = control;
/*Line 10 - 'AtomBinding.js' */            this.vf = vf;
/*Line 11 - 'AtomBinding.js' */            this.key = key;
/*Line 12 - 'AtomBinding.js' */            this.events = events;

/*Line 14 - 'AtomBinding.js' */            if ($.isArray(path)) {
/*Line 15 - 'AtomBinding.js' */                this.pathList = [];
/*Line 16 - 'AtomBinding.js' */                this.path = [];
/*Line 17 - 'AtomBinding.js' */                var ae = new AtomEnumerator(path);
/*Line 18 - 'AtomBinding.js' */                while (ae.next()) {
/*Line 19 - 'AtomBinding.js' */                    var item = ae.current();
/*Line 20 - 'AtomBinding.js' */                    if (!$.isArray(item)) {
/*Line 21 - 'AtomBinding.js' */                        this.path.push({ path: item, value: null });
/*Line 22 - 'AtomBinding.js' */                        continue;
/*Line 23 - 'AtomBinding.js' */                    }
/*Line 24 - 'AtomBinding.js' */                    var pe = new AtomEnumerator(item);
/*Line 25 - 'AtomBinding.js' */                    var p = [];
/*Line 26 - 'AtomBinding.js' */                    while (pe.next()) {
/*Line 27 - 'AtomBinding.js' */                        p.push({ path: pe.current(), value: null });
/*Line 28 - 'AtomBinding.js' */                    }
/*Line 29 - 'AtomBinding.js' */                    this.pathList.push(p);
/*Line 30 - 'AtomBinding.js' */                }
/*Line 31 - 'AtomBinding.js' */                if (this.path.length) {
/*Line 32 - 'AtomBinding.js' */                    this.pathList = null;
/*Line 33 - 'AtomBinding.js' */                } else {
/*Line 34 - 'AtomBinding.js' */                    this.path = null;
/*Line 35 - 'AtomBinding.js' */                }

/*Line 37 - 'AtomBinding.js' */            } else {
/*Line 38 - 'AtomBinding.js' */                var ae = new AtomEnumerator(path.split("."));
/*Line 39 - 'AtomBinding.js' */                this.path = [];
/*Line 40 - 'AtomBinding.js' */                while (ae.next()) {
/*Line 41 - 'AtomBinding.js' */                    this.path.push({ path: ae.current(), value: null });
/*Line 42 - 'AtomBinding.js' */                }
/*Line 43 - 'AtomBinding.js' */            }
/*Line 44 - 'AtomBinding.js' */            this.twoWays = twoWays;
/*Line 45 - 'AtomBinding.js' */            this.jq = jq;
/*Line 46 - 'AtomBinding.js' */            this._isUpdating = false;
/*Line 47 - 'AtomBinding.js' */        },
/*Line 48 - 'AtomBinding.js' */        methods: {
/*Line 49 - 'AtomBinding.js' */            onPropChanged: function (sender, key) {
/*Line 50 - 'AtomBinding.js' */                // update target....
/*Line 51 - 'AtomBinding.js' */                // most like end of path...
/*Line 52 - 'AtomBinding.js' */                if (this.path == null || this.path.length == 0)
/*Line 53 - 'AtomBinding.js' */                    return;
/*Line 54 - 'AtomBinding.js' */                var ae = new AtomEnumerator(this.path);
/*Line 55 - 'AtomBinding.js' */                var obj = this.control;
/*Line 56 - 'AtomBinding.js' */                var objKey = null;
/*Line 57 - 'AtomBinding.js' */                while (ae.next()) {
/*Line 58 - 'AtomBinding.js' */                    objKey = ae.current();
/*Line 59 - 'AtomBinding.js' */                    objKey.value = obj;
/*Line 60 - 'AtomBinding.js' */                    if (!obj)
/*Line 61 - 'AtomBinding.js' */                        return;
/*Line 62 - 'AtomBinding.js' */                    if (!ae.isLast())
/*Line 63 - 'AtomBinding.js' */                        obj = AtomBinder.getValue(obj, objKey.path);
/*Line 64 - 'AtomBinding.js' */                }
/*Line 65 - 'AtomBinding.js' */                var value = null;
/*Line 66 - 'AtomBinding.js' */                if (this.jq) {
/*Line 67 - 'AtomBinding.js' */                    switch (this.key) {
/*Line 68 - 'AtomBinding.js' */                        case "valueAsDate":
/*Line 69 - 'AtomBinding.js' */                            value = this.element.valueAsDate;
/*Line 70 - 'AtomBinding.js' */                            break;
/*Line 71 - 'AtomBinding.js' */                        case "checked":
/*Line 72 - 'AtomBinding.js' */                            value = this.element.checked ? true : false;
/*Line 73 - 'AtomBinding.js' */                            break;
/*Line 74 - 'AtomBinding.js' */                        default:
/*Line 75 - 'AtomBinding.js' */                            value = $(this.element).val();
/*Line 76 - 'AtomBinding.js' */                    }
/*Line 77 - 'AtomBinding.js' */                } else {
/*Line 78 - 'AtomBinding.js' */                    value = AtomBinder.getValue(this.control, this.key);
/*Line 79 - 'AtomBinding.js' */                }
/*Line 80 - 'AtomBinding.js' */                AtomBinder.setValue(obj, objKey.path, value);
/*Line 81 - 'AtomBinding.js' */            },
/*Line 82 - 'AtomBinding.js' */            onDataChanged: function (sender, key) {
/*Line 83 - 'AtomBinding.js' */                if (this._isUpdating)
/*Line 84 - 'AtomBinding.js' */                    return;

/*Line 86 - 'AtomBinding.js' */                // called by jquery while posting an ajax request...
/*Line 87 - 'AtomBinding.js' */                if (arguments === undefined || arguments.length == 0)
/*Line 88 - 'AtomBinding.js' */                    return;

/*Line 90 - 'AtomBinding.js' */                var ae;
/*Line 91 - 'AtomBinding.js' */                var target = this.control;
/*Line 92 - 'AtomBinding.js' */                if (this.pathList) {
/*Line 93 - 'AtomBinding.js' */                    var newTarget = [];
/*Line 94 - 'AtomBinding.js' */                    ae = new AtomEnumerator(this.pathList);
/*Line 95 - 'AtomBinding.js' */                    while (ae.next()) {
/*Line 96 - 'AtomBinding.js' */                        newTarget.push(this.evaluate(target, ae.current()));
/*Line 97 - 'AtomBinding.js' */                    }
/*Line 98 - 'AtomBinding.js' */                    ae = new AtomEnumerator(newTarget);
/*Line 99 - 'AtomBinding.js' */                    while (ae.next()) {
/*Line 100 - 'AtomBinding.js' */                        if (ae.current() === undefined)
/*Line 101 - 'AtomBinding.js' */                            return;
/*Line 102 - 'AtomBinding.js' */                    }
/*Line 103 - 'AtomBinding.js' */                    this.setValue(newTarget);
/*Line 104 - 'AtomBinding.js' */                } else {
/*Line 105 - 'AtomBinding.js' */                    var path = this.path;
/*Line 106 - 'AtomBinding.js' */                    var newTarget = this.evaluate(target, path);
/*Line 107 - 'AtomBinding.js' */                    if (newTarget !== undefined)
/*Line 108 - 'AtomBinding.js' */                        this.setValue(newTarget);
/*Line 109 - 'AtomBinding.js' */                }
/*Line 110 - 'AtomBinding.js' */            },

/*Line 112 - 'AtomBinding.js' */            evaluate: function (target, path) {
/*Line 113 - 'AtomBinding.js' */                var newTarget = null;
/*Line 114 - 'AtomBinding.js' */                var property = null;
/*Line 115 - 'AtomBinding.js' */                var ae = new AtomEnumerator(path);

/*Line 117 - 'AtomBinding.js' */                // first remove old handlers...
/*Line 118 - 'AtomBinding.js' */                var remove = false;
/*Line 119 - 'AtomBinding.js' */                while (target && ae.next()) {
/*Line 120 - 'AtomBinding.js' */                    property = ae.current();
/*Line 121 - 'AtomBinding.js' */                    newTarget = AtomBinder.getValue(target, property.path);

/*Line 123 - 'AtomBinding.js' */                    if (!(/scope|appScope|atomParent|templateParent|localScope/gi.test(property.path))) {
/*Line 124 - 'AtomBinding.js' */                        var _this = this;
/*Line 125 - 'AtomBinding.js' */                        if (!property.value) {
/*Line 126 - 'AtomBinding.js' */                            this.bindEvent(target, "WatchHandler", "onDataChanged", property.path);
/*Line 127 - 'AtomBinding.js' */                            //this.bindEvent(target, "WatchHandler", function () {
/*Line 128 - 'AtomBinding.js' */                            //    _this.onDataChanged.apply(_this, arguments);
/*Line 129 - 'AtomBinding.js' */                            //}, property.path);
/*Line 130 - 'AtomBinding.js' */                        } else if (property.value != target) {
/*Line 131 - 'AtomBinding.js' */                            this.unbindEvent(property.value, "WatchHandler", null, property.path);
/*Line 132 - 'AtomBinding.js' */                            this.bindEvent(target, "WatchHandler", "onDataChanged", property.path);
/*Line 133 - 'AtomBinding.js' */                            //this.bindEvent(target, "WatchHandler", function () {
/*Line 134 - 'AtomBinding.js' */                            //    _this.onDataChanged.apply(_this, arguments);
/*Line 135 - 'AtomBinding.js' */                            //}, property.path);
/*Line 136 - 'AtomBinding.js' */                        }
/*Line 137 - 'AtomBinding.js' */                    }

/*Line 139 - 'AtomBinding.js' */                    property.value = target;
/*Line 140 - 'AtomBinding.js' */                    target = newTarget;
/*Line 141 - 'AtomBinding.js' */                }
/*Line 142 - 'AtomBinding.js' */                if (newTarget === undefined && AtomConfig.debug) {
/*Line 143 - 'AtomBinding.js' */                    log('Undefined:' + this.control._element.id + ' -> ' + ($.map(path, function (a) { return a.path; })).join('.'));
/*Line 144 - 'AtomBinding.js' */                }
/*Line 145 - 'AtomBinding.js' */                return newTarget;
/*Line 146 - 'AtomBinding.js' */            },

/*Line 148 - 'AtomBinding.js' */            onValChanged: function () {
/*Line 149 - 'AtomBinding.js' */                var self = this;
/*Line 150 - 'AtomBinding.js' */                WebAtoms.dispatcher.callLater(function () { self.onPropChanged(null, null); });
/*Line 151 - 'AtomBinding.js' */            },
/*Line 152 - 'AtomBinding.js' */            setup: function () {
/*Line 153 - 'AtomBinding.js' */                if (this.twoWays) {
/*Line 154 - 'AtomBinding.js' */                    if (this.jq) {
/*Line 155 - 'AtomBinding.js' */                        this.bindEvent(this.element, "change", "onValChanged");
/*Line 156 - 'AtomBinding.js' */                        this.bindEvent(this.element, "blur", "onValChanged");
/*Line 157 - 'AtomBinding.js' */                        if (this.events) {
/*Line 158 - 'AtomBinding.js' */                            var list = new AtomEnumerator(this.events.split(","));
/*Line 159 - 'AtomBinding.js' */                            while (list.next()) {
/*Line 160 - 'AtomBinding.js' */                                this.bindEvent(this.element, list.current(), "onValChanged");
/*Line 161 - 'AtomBinding.js' */                            }
/*Line 162 - 'AtomBinding.js' */                        }
/*Line 163 - 'AtomBinding.js' */                    } else {
/*Line 164 - 'AtomBinding.js' */                        this.bindEvent(this.control, "WatchHandler", "onPropChanged", this.key);
/*Line 165 - 'AtomBinding.js' */                    }
/*Line 166 - 'AtomBinding.js' */                }

/*Line 168 - 'AtomBinding.js' */                this.onDataChanged(this, null);

/*Line 170 - 'AtomBinding.js' */            },

/*Line 172 - 'AtomBinding.js' */            setValue: function (value) {

/*Line 174 - 'AtomBinding.js' */                if (!this.pathList && this.vf) {
/*Line 175 - 'AtomBinding.js' */                    value = [value];
/*Line 176 - 'AtomBinding.js' */                }

/*Line 178 - 'AtomBinding.js' */                if (this.vf) {
/*Line 179 - 'AtomBinding.js' */                    value.push(Atom);
/*Line 180 - 'AtomBinding.js' */                    value.push(AtomPromise);
/*Line 181 - 'AtomBinding.js' */                    value = this.vf.apply(this, value);
/*Line 182 - 'AtomBinding.js' */                }

/*Line 184 - 'AtomBinding.js' */                if (value instanceof AtomPromise) {
/*Line 185 - 'AtomBinding.js' */                    value._persist = true;
/*Line 186 - 'AtomBinding.js' */                }

/*Line 188 - 'AtomBinding.js' */                this._lastValue = value;
/*Line 189 - 'AtomBinding.js' */                this._isUpdating = true;
/*Line 190 - 'AtomBinding.js' */                this.control.setLocalValue(this.key, value, this.element, true);
/*Line 191 - 'AtomBinding.js' */                this._isUpdating = false;
/*Line 192 - 'AtomBinding.js' */            }


/*Line 195 - 'AtomBinding.js' */        }
/*Line 196 - 'AtomBinding.js' */    });
/*Line 197 - 'AtomBinding.js' */})(WebAtoms.AtomComponent.prototype);
/*Line 0 - 'AtomDispatcher.js' */

/*Line 2 - 'AtomDispatcher.js' */var allControls = {
/*Line 3 - 'AtomDispatcher.js' */};

/*Line 5 - 'AtomDispatcher.js' */window.allControls = allControls;

/*Line 7 - 'AtomDispatcher.js' */(function (base) {
/*Line 8 - 'AtomDispatcher.js' */    return classCreator("WebAtoms.AtomDispatcher", base,
/*Line 9 - 'AtomDispatcher.js' */        function () {
/*Line 10 - 'AtomDispatcher.js' */            this._paused = false;
/*Line 11 - 'AtomDispatcher.js' */            this.queue = [];
/*Line 12 - 'AtomDispatcher.js' */            this.onTimeout = function () {
/*Line 13 - 'AtomDispatcher.js' */                if (this._paused)
/*Line 14 - 'AtomDispatcher.js' */                    return;
/*Line 15 - 'AtomDispatcher.js' */                if (this.queue.length == 0) {
/*Line 16 - 'AtomDispatcher.js' */                    var app = atomApplication._element;
/*Line 17 - 'AtomDispatcher.js' */                    if (app.style.visibility == "hidden" || $(app).css("visibility") == "hidden") {
/*Line 18 - 'AtomDispatcher.js' */                        app.style.visibility = "visible";

/*Line 20 - 'AtomDispatcher.js' */                        app.atomControl.updateUI();
/*Line 21 - 'AtomDispatcher.js' */                    }
/*Line 22 - 'AtomDispatcher.js' */                    return;
/*Line 23 - 'AtomDispatcher.js' */                }
/*Line 24 - 'AtomDispatcher.js' */                var item = this.queue.shift();
/*Line 25 - 'AtomDispatcher.js' */                //try{
/*Line 26 - 'AtomDispatcher.js' */                item();
/*Line 27 - 'AtomDispatcher.js' */                //} catch (ex) {

/*Line 29 - 'AtomDispatcher.js' */                //    if (window.console) {
/*Line 30 - 'AtomDispatcher.js' */                //        window.console.log(item.toString());
/*Line 31 - 'AtomDispatcher.js' */                //        window.console.log(JSON.stringify(ex));
/*Line 32 - 'AtomDispatcher.js' */                //    }
/*Line 33 - 'AtomDispatcher.js' */                //}
/*Line 34 - 'AtomDispatcher.js' */                window.setTimeout(this._onTimeout, 1);
/*Line 35 - 'AtomDispatcher.js' */            };
/*Line 36 - 'AtomDispatcher.js' */            //this._onTimeout = Function.createDelegate(this, this.onTimeout);
/*Line 37 - 'AtomDispatcher.js' */            var _this = this;
/*Line 38 - 'AtomDispatcher.js' */            this._onTimeout = function () {
/*Line 39 - 'AtomDispatcher.js' */                _this.onTimeout();
/*Line 40 - 'AtomDispatcher.js' */            };
/*Line 41 - 'AtomDispatcher.js' */        },
/*Line 42 - 'AtomDispatcher.js' */        {
/*Line 43 - 'AtomDispatcher.js' */            pause: function () {
/*Line 44 - 'AtomDispatcher.js' */                this._paused = true;
/*Line 45 - 'AtomDispatcher.js' */            },
/*Line 46 - 'AtomDispatcher.js' */            start: function () {
/*Line 47 - 'AtomDispatcher.js' */                this._paused = false;
/*Line 48 - 'AtomDispatcher.js' */                window.setTimeout(this._onTimeout, 1);
/*Line 49 - 'AtomDispatcher.js' */            },
/*Line 50 - 'AtomDispatcher.js' */            callLater: function (fn) {
/*Line 51 - 'AtomDispatcher.js' */                this.queue.push(fn);
/*Line 52 - 'AtomDispatcher.js' */                if (!this._paused)
/*Line 53 - 'AtomDispatcher.js' */                    this.start();
/*Line 54 - 'AtomDispatcher.js' */            },
/*Line 55 - 'AtomDispatcher.js' */            setupControls: function () {

/*Line 57 - 'AtomDispatcher.js' */                //if (window.console) {
/*Line 58 - 'AtomDispatcher.js' */                //    window.console.log("Starting Web Atoms");
/*Line 59 - 'AtomDispatcher.js' */                //}

/*Line 61 - 'AtomDispatcher.js' */                var a = $('[data-atom-type],[atom-type]').first()[0];
/*Line 62 - 'AtomDispatcher.js' */                if (a.atomControl != undefined && a.atomControl != null)
/*Line 63 - 'AtomDispatcher.js' */                    return;
/*Line 64 - 'AtomDispatcher.js' */                var ct = AtomUI.getAtomType(a);
/*Line 65 - 'AtomDispatcher.js' */                $(a).removeAttr("atom-type");
/*Line 66 - 'AtomDispatcher.js' */                $(a).removeAttr("data-atom-type");
/*Line 67 - 'AtomDispatcher.js' */                var ctrl = new (WebAtoms[ct])(a);
/*Line 68 - 'AtomDispatcher.js' */                ctrl.setup();

/*Line 70 - 'AtomDispatcher.js' */            }
/*Line 71 - 'AtomDispatcher.js' */        }
/*Line 72 - 'AtomDispatcher.js' */        );
/*Line 73 - 'AtomDispatcher.js' */})();

/*Line 75 - 'AtomDispatcher.js' */WebAtoms.dispatcher = new WebAtoms.AtomDispatcher();

/*Line 77 - 'AtomDispatcher.js' */function aggregateHandler(f,i) {

/*Line 79 - 'AtomDispatcher.js' */    function ah(fx) {
/*Line 80 - 'AtomDispatcher.js' */        this._handler = fx;

/*Line 82 - 'AtomDispatcher.js' */        var self = this;

/*Line 84 - 'AtomDispatcher.js' */        this.invoke = function () {
/*Line 85 - 'AtomDispatcher.js' */            try {
/*Line 86 - 'AtomDispatcher.js' */                self._handler.apply(self, self.args);
/*Line 87 - 'AtomDispatcher.js' */            }
/*Line 88 - 'AtomDispatcher.js' */            catch (e) {
/*Line 89 - 'AtomDispatcher.js' */                if (console) {
/*Line 90 - 'AtomDispatcher.js' */                    console.log(e);
/*Line 91 - 'AtomDispatcher.js' */                }
/*Line 92 - 'AtomDispatcher.js' */            }
/*Line 93 - 'AtomDispatcher.js' */            finally {
/*Line 94 - 'AtomDispatcher.js' */                self.timeout = 0;
/*Line 95 - 'AtomDispatcher.js' */                self.pending = false;
/*Line 96 - 'AtomDispatcher.js' */            }
/*Line 97 - 'AtomDispatcher.js' */        }

/*Line 99 - 'AtomDispatcher.js' */        this.handler = function () {
/*Line 100 - 'AtomDispatcher.js' */            if (self.pending)
/*Line 101 - 'AtomDispatcher.js' */                return;
/*Line 102 - 'AtomDispatcher.js' */            self.pending = true;
/*Line 103 - 'AtomDispatcher.js' */            self.args = arguments;
/*Line 104 - 'AtomDispatcher.js' */            if (self.timeout) {
/*Line 105 - 'AtomDispatcher.js' */                clearTimeout(self.timeout);
/*Line 106 - 'AtomDispatcher.js' */            }
/*Line 107 - 'AtomDispatcher.js' */            self.timeout = setTimeout(self.invoke, i || 500);
/*Line 108 - 'AtomDispatcher.js' */        }
/*Line 109 - 'AtomDispatcher.js' */    }

/*Line 111 - 'AtomDispatcher.js' */    var n = new ah(f);
/*Line 112 - 'AtomDispatcher.js' */    return n.handler;
/*Line 113 - 'AtomDispatcher.js' */}

/*Line 0 - 'AtomUIComponent.js' */

/*Line 2 - 'AtomUIComponent.js' */(function (base) {
/*Line 3 - 'AtomUIComponent.js' */    return classCreator("WebAtoms.AtomUIComponent", base,
/*Line 4 - 'AtomUIComponent.js' */        function () {
/*Line 5 - 'AtomUIComponent.js' */        },
/*Line 6 - 'AtomUIComponent.js' */        {
/*Line 7 - 'AtomUIComponent.js' */            get_owner: function () {
/*Line 8 - 'AtomUIComponent.js' */                return this;
/*Line 9 - 'AtomUIComponent.js' */            },

/*Line 11 - 'AtomUIComponent.js' */            get_appScope: function () {
/*Line 12 - 'AtomUIComponent.js' */                return appScope;
/*Line 13 - 'AtomUIComponent.js' */            },

/*Line 15 - 'AtomUIComponent.js' */            get_scope: function () {
/*Line 16 - 'AtomUIComponent.js' */                if (this._scope === undefined) {
/*Line 17 - 'AtomUIComponent.js' */                    var ap = this.get_atomParent(this._element._logicalParent || this._element.parentNode);
/*Line 18 - 'AtomUIComponent.js' */                    if (ap) {
/*Line 19 - 'AtomUIComponent.js' */                        return ap._localScope || ap.get_scope();
/*Line 20 - 'AtomUIComponent.js' */                    }
/*Line 21 - 'AtomUIComponent.js' */                    else {
/*Line 22 - 'AtomUIComponent.js' */                        return appScope;
/*Line 23 - 'AtomUIComponent.js' */                    }
/*Line 24 - 'AtomUIComponent.js' */                }
/*Line 25 - 'AtomUIComponent.js' */                return this._scope;
/*Line 26 - 'AtomUIComponent.js' */            },

/*Line 28 - 'AtomUIComponent.js' */            get_localScope: function () {
/*Line 29 - 'AtomUIComponent.js' */                if (this._localScope === undefined) {
/*Line 30 - 'AtomUIComponent.js' */                    var ap = this.get_atomParent(this._element._logicalParent || this._element.parentNode);
/*Line 31 - 'AtomUIComponent.js' */                    if (ap) {
/*Line 32 - 'AtomUIComponent.js' */                        return ap.get_localScope();
/*Line 33 - 'AtomUIComponent.js' */                    } else {
/*Line 34 - 'AtomUIComponent.js' */                        throw new Error("Local Scope does not exist");
/*Line 35 - 'AtomUIComponent.js' */                    }
/*Line 36 - 'AtomUIComponent.js' */                }
/*Line 37 - 'AtomUIComponent.js' */                return this._localScope;
/*Line 38 - 'AtomUIComponent.js' */            },
/*Line 39 - 'AtomUIComponent.js' */            set_scope: function (s) {
/*Line 40 - 'AtomUIComponent.js' */                var scope = this._localScope || this.get_scope();
/*Line 41 - 'AtomUIComponent.js' */                for (var k in s) {
/*Line 42 - 'AtomUIComponent.js' */                    if (/^(application|owner|app|parent)$/gi.test(k))
/*Line 43 - 'AtomUIComponent.js' */                        throw new Error("Invalid name for the scope property");
/*Line 44 - 'AtomUIComponent.js' */                    // if value is already set...
/*Line 45 - 'AtomUIComponent.js' */                    var v = s[k];
/*Line 46 - 'AtomUIComponent.js' */                    if (scope == window.appScope && !window.atomApplication._ready) {
/*Line 47 - 'AtomUIComponent.js' */                        if ((k.indexOf('_') != 0)
/*Line 48 - 'AtomUIComponent.js' */                            && (v !== undefined && v !== null)
/*Line 49 - 'AtomUIComponent.js' */                            && (/string|number|boolean/i.test(typeof (v)))){
/*Line 50 - 'AtomUIComponent.js' */                                atomApplication._defaultScope[k] = v;
/*Line 51 - 'AtomUIComponent.js' */                            }
/*Line 52 - 'AtomUIComponent.js' */                    }
/*Line 53 - 'AtomUIComponent.js' */                    if (scope[k] !== undefined)
/*Line 54 - 'AtomUIComponent.js' */                        continue;
/*Line 55 - 'AtomUIComponent.js' */                    scope[k] = v;
/*Line 56 - 'AtomUIComponent.js' */                }
/*Line 57 - 'AtomUIComponent.js' */            },

/*Line 59 - 'AtomUIComponent.js' */            get_name: function () {
/*Line 60 - 'AtomUIComponent.js' */                return this._name;
/*Line 61 - 'AtomUIComponent.js' */            },
/*Line 62 - 'AtomUIComponent.js' */            getTemplate: function (k) {

/*Line 64 - 'AtomUIComponent.js' */                var t = this["_" + k];
/*Line 65 - 'AtomUIComponent.js' */                if (t !== undefined && t !== null)
/*Line 66 - 'AtomUIComponent.js' */                    return t;

/*Line 68 - 'AtomUIComponent.js' */                // resolve...
/*Line 69 - 'AtomUIComponent.js' */                t = Templates.get(this.constructor, k);
/*Line 70 - 'AtomUIComponent.js' */                if (!t) {
/*Line 71 - 'AtomUIComponent.js' */                    return null;
/*Line 72 - 'AtomUIComponent.js' */                }
/*Line 73 - 'AtomUIComponent.js' */                this["_" + k] = t;
/*Line 74 - 'AtomUIComponent.js' */                return t;
/*Line 75 - 'AtomUIComponent.js' */            }
/*Line 76 - 'AtomUIComponent.js' */        },
/*Line 77 - 'AtomUIComponent.js' */        {
/*Line 78 - 'AtomUIComponent.js' */            next: null,
/*Line 79 - 'AtomUIComponent.js' */            value: undefined
/*Line 80 - 'AtomUIComponent.js' */        });
/*Line 81 - 'AtomUIComponent.js' */})(WebAtoms.AtomComponent.prototype);


/*Line 84 - 'AtomUIComponent.js' */Templates.compiled = {
/*Line 85 - 'AtomUIComponent.js' */};

/*Line 87 - 'AtomUIComponent.js' */Templates.compileElement = function (e) {
/*Line 88 - 'AtomUIComponent.js' */    var ae = new AtomEnumerator(e);
/*Line 89 - 'AtomUIComponent.js' */    ae.next();
/*Line 90 - 'AtomUIComponent.js' */    var a = ae.current();
/*Line 91 - 'AtomUIComponent.js' */    var e1 = document.createElement(a);
/*Line 92 - 'AtomUIComponent.js' */    if (!ae.next())
/*Line 93 - 'AtomUIComponent.js' */        return e1;
/*Line 94 - 'AtomUIComponent.js' */    a = ae.current();
/*Line 95 - 'AtomUIComponent.js' */    if (a) {
/*Line 96 - 'AtomUIComponent.js' */        for (var k in a) {
/*Line 97 - 'AtomUIComponent.js' */            e1.setAttribute(k, a[k]);
/*Line 98 - 'AtomUIComponent.js' */        }
/*Line 99 - 'AtomUIComponent.js' */    }
    
/*Line 101 - 'AtomUIComponent.js' */    while (ae.next()) {
/*Line 102 - 'AtomUIComponent.js' */        a = ae.current();
/*Line 103 - 'AtomUIComponent.js' */        if (!a)
/*Line 104 - 'AtomUIComponent.js' */            break;
/*Line 105 - 'AtomUIComponent.js' */        if (a.constructor == String) {
/*Line 106 - 'AtomUIComponent.js' */            e1.appendChild(document.createTextNode(a));
/*Line 107 - 'AtomUIComponent.js' */        } else {
/*Line 108 - 'AtomUIComponent.js' */            e1.appendChild(Templates.compileElement(a));
/*Line 109 - 'AtomUIComponent.js' */        }
/*Line 110 - 'AtomUIComponent.js' */    }
/*Line 111 - 'AtomUIComponent.js' */    return e1;
/*Line 112 - 'AtomUIComponent.js' */};

/*Line 114 - 'AtomUIComponent.js' */Templates.compileJsonML = function (j) {

/*Line 116 - 'AtomUIComponent.js' */    if (j.length == 1)
/*Line 117 - 'AtomUIComponent.js' */        return Templates.compileElement(j[0]);

/*Line 119 - 'AtomUIComponent.js' */    var r = [];
/*Line 120 - 'AtomUIComponent.js' */    var ae = new AtomEnumerator(j);
/*Line 121 - 'AtomUIComponent.js' */    while (ae.next()) {
/*Line 122 - 'AtomUIComponent.js' */        r.push(Templates.compileElement(ae.current()));
/*Line 123 - 'AtomUIComponent.js' */    }
/*Line 124 - 'AtomUIComponent.js' */    return r;
/*Line 125 - 'AtomUIComponent.js' */};

/*Line 127 - 'AtomUIComponent.js' */Templates.compile = function (type, name, t) {

/*Line 129 - 'AtomUIComponent.js' */    var div = document.createElement("div");
/*Line 130 - 'AtomUIComponent.js' */    div.innerHTML = t;

/*Line 132 - 'AtomUIComponent.js' */    if ($(div).children().length == 1) {
/*Line 133 - 'AtomUIComponent.js' */        t = AtomUI.cloneNode((div.firstElementChild || div.children[0]));
/*Line 134 - 'AtomUIComponent.js' */    }

/*Line 136 - 'AtomUIComponent.js' */    return t;
/*Line 137 - 'AtomUIComponent.js' */};

/*Line 139 - 'AtomUIComponent.js' */Templates.get = function (type, k) {
/*Line 140 - 'AtomUIComponent.js' */    //var x = this.compileType(type);
/*Line 141 - 'AtomUIComponent.js' */    //return x[k];

/*Line 143 - 'AtomUIComponent.js' */    var name = type.__typeName + "." + k;
/*Line 144 - 'AtomUIComponent.js' */    var x = this.compiled[name];
/*Line 145 - 'AtomUIComponent.js' */    if (x)
/*Line 146 - 'AtomUIComponent.js' */        return x;
/*Line 147 - 'AtomUIComponent.js' */    x = Templates.jsonML[name];
/*Line 148 - 'AtomUIComponent.js' */    if (!x) {
/*Line 149 - 'AtomUIComponent.js' */        if (type.__baseType) {
/*Line 150 - 'AtomUIComponent.js' */            x = Templates.get(type.__baseType, k);
/*Line 151 - 'AtomUIComponent.js' */        }
/*Line 152 - 'AtomUIComponent.js' */    } else {
/*Line 153 - 'AtomUIComponent.js' */        x = Templates.compileJsonML(x);
/*Line 154 - 'AtomUIComponent.js' */    }
/*Line 155 - 'AtomUIComponent.js' */    if (!x)
/*Line 156 - 'AtomUIComponent.js' */        return null;
/*Line 157 - 'AtomUIComponent.js' */    this.compiled[name] = x;
/*Line 158 - 'AtomUIComponent.js' */    return x;

/*Line 160 - 'AtomUIComponent.js' */};

/*Line 162 - 'AtomUIComponent.js' */Templates.compileType = function (type) {

/*Line 164 - 'AtomUIComponent.js' */    var name = type.__typeName;
/*Line 165 - 'AtomUIComponent.js' */    var shortName = name.split(".");
/*Line 166 - 'AtomUIComponent.js' */    shortName = shortName[shortName.length - 1];

/*Line 168 - 'AtomUIComponent.js' */    var x = this.compiled[name];
/*Line 169 - 'AtomUIComponent.js' */    if (x)
/*Line 170 - 'AtomUIComponent.js' */        return x;

/*Line 172 - 'AtomUIComponent.js' */    x = {
/*Line 173 - 'AtomUIComponent.js' */    };

/*Line 175 - 'AtomUIComponent.js' */    var tl = this[name] || this[shortName];
/*Line 176 - 'AtomUIComponent.js' */    if (tl) {
/*Line 177 - 'AtomUIComponent.js' */        for (var t in tl) {
/*Line 178 - 'AtomUIComponent.js' */            x[t] = this.compile(type, t, tl[t]);
/*Line 179 - 'AtomUIComponent.js' */        }
/*Line 180 - 'AtomUIComponent.js' */    }

/*Line 182 - 'AtomUIComponent.js' */    if (type.__baseType) {
/*Line 183 - 'AtomUIComponent.js' */        var y = this.compileType(type.__baseType);
/*Line 184 - 'AtomUIComponent.js' */        for (var yt in y) {
/*Line 185 - 'AtomUIComponent.js' */            if (!x[yt]) {
/*Line 186 - 'AtomUIComponent.js' */                x[yt] = y[yt];
/*Line 187 - 'AtomUIComponent.js' */            }
/*Line 188 - 'AtomUIComponent.js' */        }
/*Line 189 - 'AtomUIComponent.js' */    }

/*Line 191 - 'AtomUIComponent.js' */    this.compiled[name] = x;

/*Line 193 - 'AtomUIComponent.js' */    var t = this;
/*Line 194 - 'AtomUIComponent.js' */    delete t[name];
/*Line 195 - 'AtomUIComponent.js' */    delete t[shortName];

/*Line 197 - 'AtomUIComponent.js' */    return x;
/*Line 198 - 'AtomUIComponent.js' */};
/*Line 0 - 'AtomControl.js' */
/*Line 1 - 'AtomControl.js' */
/*Line 2 - 'AtomControl.js' */
/*Line 3 - 'AtomControl.js' */


/*Line 6 - 'AtomControl.js' */// Binding Handlers
/*Line 7 - 'AtomControl.js' */var AtomBinders = {
/*Line 8 - 'AtomControl.js' */    "{": function (ctrl, key, value, element) {
/*Line 9 - 'AtomControl.js' */        value = value.substr(1, value.length - 2);
/*Line 10 - 'AtomControl.js' */        var be = AtomEvaluator.parse(value);
/*Line 11 - 'AtomControl.js' */        if (be.path) {
/*Line 12 - 'AtomControl.js' */            var ae = new AtomEnumerator(be.path);
/*Line 13 - 'AtomControl.js' */            value = [];
/*Line 14 - 'AtomControl.js' */            while (ae.next()) {
/*Line 15 - 'AtomControl.js' */                var pe = new AtomEnumerator(ae.current());
/*Line 16 - 'AtomControl.js' */                var v = ctrl;
/*Line 17 - 'AtomControl.js' */                while (pe.next()) {
/*Line 18 - 'AtomControl.js' */                    v = AtomBinder.getValue(v, pe.current());
/*Line 19 - 'AtomControl.js' */                }
/*Line 20 - 'AtomControl.js' */                value.push(v);
/*Line 21 - 'AtomControl.js' */            }
/*Line 22 - 'AtomControl.js' */        } else {
/*Line 23 - 'AtomControl.js' */            value = [value];
/*Line 24 - 'AtomControl.js' */        }
/*Line 25 - 'AtomControl.js' */        value.push(Atom);
/*Line 26 - 'AtomControl.js' */        value.push(AtomPromise);
/*Line 27 - 'AtomControl.js' */        value = be.method.apply(null, value);

/*Line 29 - 'AtomControl.js' */        ctrl.setLocalValue(key, value, element);
/*Line 30 - 'AtomControl.js' */    },
/*Line 31 - 'AtomControl.js' */    "[": function (ctrl, key, value, element) {
/*Line 32 - 'AtomControl.js' */        value = value.substr(1, value.length - 2);
/*Line 33 - 'AtomControl.js' */        var be = AtomEvaluator.parse(value);
/*Line 34 - 'AtomControl.js' */        if (be.length == 0) {
/*Line 35 - 'AtomControl.js' */            value = eval(value);
/*Line 36 - 'AtomControl.js' */            AtomBinder.setValue(ctrl, key, value);
/*Line 37 - 'AtomControl.js' */        } else {
/*Line 38 - 'AtomControl.js' */            if (be.length == 1 && be.path[0] == be.original) {
/*Line 39 - 'AtomControl.js' */                ctrl.bind(element, key, value, false);
/*Line 40 - 'AtomControl.js' */            }
/*Line 41 - 'AtomControl.js' */            else {
/*Line 42 - 'AtomControl.js' */                ctrl.bind(element, key, be.path, false, be.method);
/*Line 43 - 'AtomControl.js' */            }
/*Line 44 - 'AtomControl.js' */        }
/*Line 45 - 'AtomControl.js' */    },
/*Line 46 - 'AtomControl.js' */    "$[": function (ctrl, key, value, element) {
/*Line 47 - 'AtomControl.js' */        var l = value.lastIndexOf("]");
/*Line 48 - 'AtomControl.js' */        var events = null;
/*Line 49 - 'AtomControl.js' */        if (l < value.length - 1) {
/*Line 50 - 'AtomControl.js' */            events = value.substr(l + 2);
/*Line 51 - 'AtomControl.js' */            events = events.substr(0, events.length - 1);
/*Line 52 - 'AtomControl.js' */        }
/*Line 53 - 'AtomControl.js' */        value = value.substr(0, l);
/*Line 54 - 'AtomControl.js' */        value = value.substr(2);
/*Line 55 - 'AtomControl.js' */        if (/^(@|\$)/g.test(value)) {
/*Line 56 - 'AtomControl.js' */            value = value.substr(1);
/*Line 57 - 'AtomControl.js' */        }
/*Line 58 - 'AtomControl.js' */        ctrl.bind(element, key, value, true, null, events);
/*Line 59 - 'AtomControl.js' */    },
/*Line 60 - 'AtomControl.js' */    "^[": function (ctrl, key, value, element) {
/*Line 61 - 'AtomControl.js' */        value = value.substr(2, value.length - 3);
/*Line 62 - 'AtomControl.js' */        if (/^(@|\$)/g.test(value)) {
/*Line 63 - 'AtomControl.js' */            value = value.substr(1);
/*Line 64 - 'AtomControl.js' */        }
/*Line 65 - 'AtomControl.js' */        ctrl.bind(element, key, value, true, null, "keyup,keydown,keypress,blur,click");
/*Line 66 - 'AtomControl.js' */    }
/*Line 67 - 'AtomControl.js' */};

/*Line 69 - 'AtomControl.js' */// Property Handlers
/*Line 70 - 'AtomControl.js' */var AtomProperties = {
/*Line 71 - 'AtomControl.js' */    any: function (e, v, k) {
/*Line 72 - 'AtomControl.js' */        AtomUI.attr(e, k, v);
/*Line 73 - 'AtomControl.js' */    },
/*Line 74 - 'AtomControl.js' */    isEnabled: function(element,value){
/*Line 75 - 'AtomControl.js' */        if (value) {
/*Line 76 - 'AtomControl.js' */            AtomUI.removeAttr(element,"disabled");
/*Line 77 - 'AtomControl.js' */        } else {
/*Line 78 - 'AtomControl.js' */            AtomUI.attr(element,"disabled", "disabled");
/*Line 79 - 'AtomControl.js' */        }
/*Line 80 - 'AtomControl.js' */    },
/*Line 81 - 'AtomControl.js' */    checked: function (element, value) {
/*Line 82 - 'AtomControl.js' */        if (element.checked != value) {
/*Line 83 - 'AtomControl.js' */            element.checked = value ? true : false;
/*Line 84 - 'AtomControl.js' */        }
/*Line 85 - 'AtomControl.js' */    },
/*Line 86 - 'AtomControl.js' */    value: function (element, value) {
/*Line 87 - 'AtomControl.js' */        if (/date|datetime/gi.test(element.type)) {
/*Line 88 - 'AtomControl.js' */            element.valueAsDate = AtomDate.parse(value);
/*Line 89 - 'AtomControl.js' */        } else {
/*Line 90 - 'AtomControl.js' */            $(element).val(value);
/*Line 91 - 'AtomControl.js' */        }
/*Line 92 - 'AtomControl.js' */    },
/*Line 93 - 'AtomControl.js' */    src: function (e, v) {
/*Line 94 - 'AtomControl.js' */        if (v) {
/*Line 95 - 'AtomControl.js' */            if (/http\:\/\//i.test(v)) {
/*Line 96 - 'AtomControl.js' */                v = v.substr(5);
/*Line 97 - 'AtomControl.js' */            }
/*Line 98 - 'AtomControl.js' */        }
/*Line 99 - 'AtomControl.js' */        AtomUI.attr(e, 'src', v);
/*Line 100 - 'AtomControl.js' */    },
/*Line 101 - 'AtomControl.js' */    valueAsDate: function (element, value) {
/*Line 102 - 'AtomControl.js' */        element.valueAsDate = AtomDate.parse(value);
/*Line 103 - 'AtomControl.js' */    },
/*Line 104 - 'AtomControl.js' */    text: function (element, value) {
/*Line 105 - 'AtomControl.js' */        //clears everything..
/*Line 106 - 'AtomControl.js' */        element.innerHTML = "";
/*Line 107 - 'AtomControl.js' */        var a = document.createTextNode(value);
/*Line 108 - 'AtomControl.js' */        element.appendChild(a);
/*Line 109 - 'AtomControl.js' */    },
/*Line 110 - 'AtomControl.js' */    mask: function (element, value) {
/*Line 111 - 'AtomControl.js' */        if (value) {
/*Line 112 - 'AtomControl.js' */            if (value.constructor === String) {
/*Line 113 - 'AtomControl.js' */                $(element).mask(value);
/*Line 114 - 'AtomControl.js' */            } else {
/*Line 115 - 'AtomControl.js' */                $(element).mask(value.mask, value.settings);
/*Line 116 - 'AtomControl.js' */            }
/*Line 117 - 'AtomControl.js' */        } else {
/*Line 118 - 'AtomControl.js' */            $(element).unmask();
/*Line 119 - 'AtomControl.js' */        }
/*Line 120 - 'AtomControl.js' */    },
/*Line 121 - 'AtomControl.js' */    html: function (element, value) {
/*Line 122 - 'AtomControl.js' */        element.innerHTML = value;
/*Line 123 - 'AtomControl.js' */    },
/*Line 124 - 'AtomControl.js' */    absPos: function (element, value) {
/*Line 125 - 'AtomControl.js' */        AtomProperties.setPosition(true, element, value);
/*Line 126 - 'AtomControl.js' */    },
/*Line 127 - 'AtomControl.js' */    relPos: function (element, value) {
/*Line 128 - 'AtomControl.js' */        AtomProperties.setPosition(false, element, value);
/*Line 129 - 'AtomControl.js' */    },
/*Line 130 - 'AtomControl.js' */    "class": function (element,value) {
/*Line 131 - 'AtomControl.js' */        if (element.atomClass) {
/*Line 132 - 'AtomControl.js' */            $(element).removeClass(element.atomClass);
/*Line 133 - 'AtomControl.js' */        }
/*Line 134 - 'AtomControl.js' */        if (value) {
/*Line 135 - 'AtomControl.js' */            value = AtomUI.createCss(value);
/*Line 136 - 'AtomControl.js' */            if (value) {
/*Line 137 - 'AtomControl.js' */                $(element).addClass(value);
/*Line 138 - 'AtomControl.js' */            }
/*Line 139 - 'AtomControl.js' */            element.atomClass = value;
/*Line 140 - 'AtomControl.js' */        }
/*Line 141 - 'AtomControl.js' */    },
/*Line 142 - 'AtomControl.js' */    setPosition: function (a, e, val) {
/*Line 143 - 'AtomControl.js' */        var l = val;

/*Line 145 - 'AtomControl.js' */        if (l.constructor == String) {
/*Line 146 - 'AtomControl.js' */            l = eval("[" + l + "]");
/*Line 147 - 'AtomControl.js' */        }

/*Line 149 - 'AtomControl.js' */        e.style.position = a ? 'absolute' : 'relative';

/*Line 151 - 'AtomControl.js' */        var left = l[0];
/*Line 152 - 'AtomControl.js' */        var top = l[1];

/*Line 154 - 'AtomControl.js' */        if (left !== null) {
/*Line 155 - 'AtomControl.js' */            e.style.left = left + "px";
/*Line 156 - 'AtomControl.js' */        }
/*Line 157 - 'AtomControl.js' */        if (top !== null) {
/*Line 158 - 'AtomControl.js' */            e.style.top = top + "px";
/*Line 159 - 'AtomControl.js' */        }
/*Line 160 - 'AtomControl.js' */        if (l.length > 2) {
/*Line 161 - 'AtomControl.js' */            var width = l[2];
/*Line 162 - 'AtomControl.js' */            var height = l[3];
/*Line 163 - 'AtomControl.js' */            if (width !== undefined && width !== null) {
/*Line 164 - 'AtomControl.js' */                e.style.width = width + "px";
/*Line 165 - 'AtomControl.js' */            }
/*Line 166 - 'AtomControl.js' */            if (height !== undefined && height !== null) {
/*Line 167 - 'AtomControl.js' */                e.style.height = height + "px";
/*Line 168 - 'AtomControl.js' */            }
/*Line 169 - 'AtomControl.js' */        }
/*Line 170 - 'AtomControl.js' */    }
/*Line 171 - 'AtomControl.js' */};

/*Line 173 - 'AtomControl.js' */window.AtomProperties = AtomProperties;

/*Line 175 - 'AtomControl.js' */(function (base) {

/*Line 177 - 'AtomControl.js' */    return classCreatorEx({
/*Line 178 - 'AtomControl.js' */        name: "WebAtoms.AtomControl",
/*Line 179 - 'AtomControl.js' */        base: base,
/*Line 180 - 'AtomControl.js' */        start: function (element) {
/*Line 181 - 'AtomControl.js' */            element.atomControl = this;
/*Line 182 - 'AtomControl.js' */            this._element = element;

/*Line 184 - 'AtomControl.js' */            this.dispatcher = WebAtoms.dispatcher;
/*Line 185 - 'AtomControl.js' */            this.bindings = [];
/*Line 186 - 'AtomControl.js' */            this._isVisible = true;

/*Line 188 - 'AtomControl.js' */            var eid = element.id;
/*Line 189 - 'AtomControl.js' */            if (eid && appScope) {
/*Line 190 - 'AtomControl.js' */                if (!/^\_\_waID/.test(eid)) {
/*Line 191 - 'AtomControl.js' */                    appScope[eid] = this;
/*Line 192 - 'AtomControl.js' */                }
/*Line 193 - 'AtomControl.js' */            }
/*Line 194 - 'AtomControl.js' */            AtomUI.assignID(element);

/*Line 196 - 'AtomControl.js' */            allControls[eid] = this;
/*Line 197 - 'AtomControl.js' */        },
/*Line 198 - 'AtomControl.js' */        properties: {
/*Line 199 - 'AtomControl.js' */            layout: null,
/*Line 200 - 'AtomControl.js' */            loadNext: null,
/*Line 201 - 'AtomControl.js' */            next: null,
/*Line 202 - 'AtomControl.js' */            merge: undefined,
/*Line 203 - 'AtomControl.js' */            value: undefined
/*Line 204 - 'AtomControl.js' */        },
/*Line 205 - 'AtomControl.js' */        methods: {
/*Line 206 - 'AtomControl.js' */            set_merge: function (v) {
/*Line 207 - 'AtomControl.js' */                this._mergeData2 = null;
/*Line 208 - 'AtomControl.js' */                if (!v)
/*Line 209 - 'AtomControl.js' */                    return;
/*Line 210 - 'AtomControl.js' */                var d = v.data;
/*Line 211 - 'AtomControl.js' */                if (d) {
/*Line 212 - 'AtomControl.js' */                    Atom.merge(this.get_data(), d, true);
/*Line 213 - 'AtomControl.js' */                    this._mergeData2 = d;
/*Line 214 - 'AtomControl.js' */                }
/*Line 215 - 'AtomControl.js' */                d = v.scope;
/*Line 216 - 'AtomControl.js' */                if (d) {
/*Line 217 - 'AtomControl.js' */                    Atom.merge(this.get_scope(), d, true);
/*Line 218 - 'AtomControl.js' */                }
/*Line 219 - 'AtomControl.js' */                d = v.appScope;
/*Line 220 - 'AtomControl.js' */                if (d) {
/*Line 221 - 'AtomControl.js' */                    Atom.merge(this.get_appScope(), d, true);
/*Line 222 - 'AtomControl.js' */                }
/*Line 223 - 'AtomControl.js' */                d = v.localScope;
/*Line 224 - 'AtomControl.js' */                if (d) {
/*Line 225 - 'AtomControl.js' */                    Atom.merge(this.get_localScope(), d, true);
/*Line 226 - 'AtomControl.js' */                }
/*Line 227 - 'AtomControl.js' */                d = v.owner;
/*Line 228 - 'AtomControl.js' */                if (d) {
/*Line 229 - 'AtomControl.js' */                    Atom.merge(this,d,true);
/*Line 230 - 'AtomControl.js' */                }
/*Line 231 - 'AtomControl.js' */                var action = (v.timeOut || v.timeout);
/*Line 232 - 'AtomControl.js' */                if (action) {
/*Line 233 - 'AtomControl.js' */                    var _this = this;
/*Line 234 - 'AtomControl.js' */                    var tm = 100;
/*Line 235 - 'AtomControl.js' */                    if (action.hasOwnProperty("length")) {
/*Line 236 - 'AtomControl.js' */                        if (action.length > 1) {
/*Line 237 - 'AtomControl.js' */                            tm = action[0];
/*Line 238 - 'AtomControl.js' */                            action = action[1];
/*Line 239 - 'AtomControl.js' */                        }
/*Line 240 - 'AtomControl.js' */                    }
/*Line 241 - 'AtomControl.js' */                    setTimeout(function () {
/*Line 242 - 'AtomControl.js' */                        _this.set_merge(action);
/*Line 243 - 'AtomControl.js' */                    }, tm);
/*Line 244 - 'AtomControl.js' */                    return;
/*Line 245 - 'AtomControl.js' */                }

/*Line 247 - 'AtomControl.js' */            },
/*Line 248 - 'AtomControl.js' */            invokeAction: function (action, evt) {
/*Line 249 - 'AtomControl.js' */                try {
/*Line 250 - 'AtomControl.js' */                    runAction.call(this,action, evt);
/*Line 251 - 'AtomControl.js' */                } catch (e) {
/*Line 252 - 'AtomControl.js' */                    alert(e);
/*Line 253 - 'AtomControl.js' */                    if (console.error) {
/*Line 254 - 'AtomControl.js' */                        console.error(e);
/*Line 255 - 'AtomControl.js' */                    }
/*Line 256 - 'AtomControl.js' */                }
/*Line 257 - 'AtomControl.js' */            },

/*Line 259 - 'AtomControl.js' */            refresh: function () {
/*Line 260 - 'AtomControl.js' */                // invoke some default action...!!!
/*Line 261 - 'AtomControl.js' */            },

/*Line 263 - 'AtomControl.js' */            get_element: function () {
/*Line 264 - 'AtomControl.js' */                return this._element;
/*Line 265 - 'AtomControl.js' */            },

/*Line 267 - 'AtomControl.js' */            clearBinding: function (element, key) {
/*Line 268 - 'AtomControl.js' */                var ae = new AtomEnumerator(this.bindings);
/*Line 269 - 'AtomControl.js' */                var item;
/*Line 270 - 'AtomControl.js' */                var removed = [];
/*Line 271 - 'AtomControl.js' */                while (ae.next()) {
/*Line 272 - 'AtomControl.js' */                    item = ae.current();
/*Line 273 - 'AtomControl.js' */                    if (element && item.element != element)
/*Line 274 - 'AtomControl.js' */                        continue;
/*Line 275 - 'AtomControl.js' */                    if (key && item.key != key)
/*Line 276 - 'AtomControl.js' */                        continue;
/*Line 277 - 'AtomControl.js' */                    //this.bindings.splice(ae.currentIndex(), 1);
/*Line 278 - 'AtomControl.js' */                    item.dispose();
/*Line 279 - 'AtomControl.js' */                    removed.push(item);
/*Line 280 - 'AtomControl.js' */                }
/*Line 281 - 'AtomControl.js' */                ae = new AtomEnumerator(removed);
/*Line 282 - 'AtomControl.js' */                while (ae.next()) {
/*Line 283 - 'AtomControl.js' */                    AtomArray.remove(this.bindings, ae.current());
/*Line 284 - 'AtomControl.js' */                }
/*Line 285 - 'AtomControl.js' */            },
/*Line 286 - 'AtomControl.js' */            addBinding: function (target, element, key, path, twoWays, jq, valueFunction, events) {
/*Line 287 - 'AtomControl.js' */                this.clearBinding(element, key);
/*Line 288 - 'AtomControl.js' */                var ab = new WebAtoms.AtomBinding(target, element, key, path, twoWays, jq, valueFunction, events);
/*Line 289 - 'AtomControl.js' */                this.bindings.push(ab);
/*Line 290 - 'AtomControl.js' */                ab.setup();
/*Line 291 - 'AtomControl.js' */            },

/*Line 293 - 'AtomControl.js' */            get_atomParent: function (element) {
/*Line 294 - 'AtomControl.js' */                if (element == null) {
/*Line 295 - 'AtomControl.js' */                    if (this._element._logicalParent || this._element.parentNode)
/*Line 296 - 'AtomControl.js' */                        element = this._element._logicalParent || this._element.parentNode;
/*Line 297 - 'AtomControl.js' */                    else
/*Line 298 - 'AtomControl.js' */                        return null;
/*Line 299 - 'AtomControl.js' */                }
/*Line 300 - 'AtomControl.js' */                if (element.atomControl) {
/*Line 301 - 'AtomControl.js' */                    return element.atomControl;
/*Line 302 - 'AtomControl.js' */                }
/*Line 303 - 'AtomControl.js' */                if (element === document || element === window || !element.parentNode)
/*Line 304 - 'AtomControl.js' */                    return null;
/*Line 305 - 'AtomControl.js' */                return this.get_atomParent(element._logicalParent || element.parentNode);
/*Line 306 - 'AtomControl.js' */            },

/*Line 308 - 'AtomControl.js' */            get_templateParent: function (element) {
/*Line 309 - 'AtomControl.js' */                if (!element) {
/*Line 310 - 'AtomControl.js' */                    element = this._element;
/*Line 311 - 'AtomControl.js' */                }
/*Line 312 - 'AtomControl.js' */                if (element._templateParent) {
/*Line 313 - 'AtomControl.js' */                    return element._templateParent;
/*Line 314 - 'AtomControl.js' */                }
/*Line 315 - 'AtomControl.js' */                var p = element._logicalParent || element.parentNode;
/*Line 316 - 'AtomControl.js' */                if (!p)
/*Line 317 - 'AtomControl.js' */                    throw new Error("Could not find templateParent");
/*Line 318 - 'AtomControl.js' */                return this.get_templateParent(element._logicalParent || element.parentNode);
/*Line 319 - 'AtomControl.js' */            },

/*Line 321 - 'AtomControl.js' */            get_viewModel: function () {
/*Line 322 - 'AtomControl.js' */                if (this._viewModel === undefined) {
/*Line 323 - 'AtomControl.js' */                    // get parent..
/*Line 324 - 'AtomControl.js' */                    var ap = this.get_atomParent(this._element._logicalParent || this._element.parentNode);
/*Line 325 - 'AtomControl.js' */                    if (ap)
/*Line 326 - 'AtomControl.js' */                        return ap.get_viewModel();
/*Line 327 - 'AtomControl.js' */                }
/*Line 328 - 'AtomControl.js' */                return this._viewModel;
/*Line 329 - 'AtomControl.js' */            },
/*Line 330 - 'AtomControl.js' */            set_viewModel: function(v){
/*Line 331 - 'AtomControl.js' */                this._viewModel = v;
                
/*Line 333 - 'AtomControl.js' */               function propogate(e){
/*Line 334 - 'AtomControl.js' */                    var ae = new ChildEnumerator(e);
/*Line 335 - 'AtomControl.js' */                    while(ae.next()){
/*Line 336 - 'AtomControl.js' */                        var child = ae.current();
/*Line 337 - 'AtomControl.js' */                        if(child.atomControl && child.atomControl._created){
/*Line 338 - 'AtomControl.js' */                            var ctrl = child.atomControl;
/*Line 339 - 'AtomControl.js' */                            if(ctrl._viewModel !== undefined)
/*Line 340 - 'AtomControl.js' */                                continue;
/*Line 341 - 'AtomControl.js' */                            Atom.refresh(ctrl,"viewModel");
/*Line 342 - 'AtomControl.js' */                        }
/*Line 343 - 'AtomControl.js' */                        propogate(child);
/*Line 344 - 'AtomControl.js' */                    }
/*Line 345 - 'AtomControl.js' */               };
/*Line 346 - 'AtomControl.js' */               propogate(this._element);
/*Line 347 - 'AtomControl.js' */            },

/*Line 349 - 'AtomControl.js' */            get_data: function () {
/*Line 350 - 'AtomControl.js' */                if (this._data === undefined) {
/*Line 351 - 'AtomControl.js' */                    // get parent...
/*Line 352 - 'AtomControl.js' */                    var ap = this.get_atomParent(this._element._logicalParent || this._element.parentNode);
/*Line 353 - 'AtomControl.js' */                    if (ap)
/*Line 354 - 'AtomControl.js' */                        return ap.get_data();
/*Line 355 - 'AtomControl.js' */                }
/*Line 356 - 'AtomControl.js' */                return this._data;
/*Line 357 - 'AtomControl.js' */            },            
/*Line 358 - 'AtomControl.js' */            set_data: function (d) {
/*Line 359 - 'AtomControl.js' */                this._data = d;
/*Line 360 - 'AtomControl.js' */                this.mergeData();
/*Line 361 - 'AtomControl.js' */                // update child references...
/*Line 362 - 'AtomControl.js' */                this.updateChildBindings(this._element);
/*Line 363 - 'AtomControl.js' */            },

/*Line 365 - 'AtomControl.js' */            mergeData: function () {
/*Line 366 - 'AtomControl.js' */                if (!this._mergeData2)
/*Line 367 - 'AtomControl.js' */                    return;
/*Line 368 - 'AtomControl.js' */                Atom.merge(this.get_data(), this._mergeData2, true);
/*Line 369 - 'AtomControl.js' */            },

/*Line 371 - 'AtomControl.js' */            updateChildBindings: function (element) {
/*Line 372 - 'AtomControl.js' */                var ae = new ChildEnumerator(element);
/*Line 373 - 'AtomControl.js' */                while (ae.next()) {
/*Line 374 - 'AtomControl.js' */                    var child = ae.current();
/*Line 375 - 'AtomControl.js' */                    if (child.atomControl && child.atomControl._created) {
/*Line 376 - 'AtomControl.js' */                        var ctrl = child.atomControl;
/*Line 377 - 'AtomControl.js' */                        if (ctrl._data !== undefined)
/*Line 378 - 'AtomControl.js' */                            continue;
/*Line 379 - 'AtomControl.js' */                        AtomBinder.refreshValue(ctrl, "data");
/*Line 380 - 'AtomControl.js' */                        ctrl.mergeData();
/*Line 381 - 'AtomControl.js' */                    }
/*Line 382 - 'AtomControl.js' */                    this.updateChildBindings(child);
/*Line 383 - 'AtomControl.js' */                }
/*Line 384 - 'AtomControl.js' */            },

/*Line 386 - 'AtomControl.js' */            initProperties: function () {

/*Line 388 - 'AtomControl.js' */                if (this._disposed)
/*Line 389 - 'AtomControl.js' */                    return;

/*Line 391 - 'AtomControl.js' */                //// init properties...
/*Line 392 - 'AtomControl.js' */                var element = this.get_element();

/*Line 394 - 'AtomControl.js' */                this.setProperties(element);
/*Line 395 - 'AtomControl.js' */                this._created = true;
/*Line 396 - 'AtomControl.js' */                this.onCreated();
/*Line 397 - 'AtomControl.js' */                this.onLoaded();
/*Line 398 - 'AtomControl.js' */            },


/*Line 401 - 'AtomControl.js' */            createChildren: function () {

/*Line 403 - 'AtomControl.js' */                this.onCreateChildren(this._element);

/*Line 405 - 'AtomControl.js' */                var t = this.getTemplate("template");

/*Line 407 - 'AtomControl.js' */                if (t) {
/*Line 408 - 'AtomControl.js' */                    var ce = new ChildEnumerator(this._element);
/*Line 409 - 'AtomControl.js' */                    // check if there is any children or not..
/*Line 410 - 'AtomControl.js' */                    if (!ce.next()) {
/*Line 411 - 'AtomControl.js' */                        if (t.constructor == String) {
/*Line 412 - 'AtomControl.js' */                            this._element.innerHTML = t;
/*Line 413 - 'AtomControl.js' */                            var caller = this;
/*Line 414 - 'AtomControl.js' */                            $(this._element).children().each(function () {
/*Line 415 - 'AtomControl.js' */                                this._templateParent = caller;
/*Line 416 - 'AtomControl.js' */                            });
/*Line 417 - 'AtomControl.js' */                        } else {
/*Line 418 - 'AtomControl.js' */                            //this._element.innerHTML = this._template;
/*Line 419 - 'AtomControl.js' */                            if (AtomUI.isNode(t)) {
/*Line 420 - 'AtomControl.js' */                                t = AtomUI.cloneNode(t);
/*Line 421 - 'AtomControl.js' */                                t._templateParent = this;
/*Line 422 - 'AtomControl.js' */                                this._element.appendChild(t);
/*Line 423 - 'AtomControl.js' */                            } else {
/*Line 424 - 'AtomControl.js' */                                // should be an array...
/*Line 425 - 'AtomControl.js' */                                var ae = new AtomEnumerator(t);
/*Line 426 - 'AtomControl.js' */                                while (ae.next()) {
/*Line 427 - 'AtomControl.js' */                                    var tc = ae.current();
/*Line 428 - 'AtomControl.js' */                                    tc = AtomUI.cloneNode(tc);
/*Line 429 - 'AtomControl.js' */                                    tc._templateParent = this;
/*Line 430 - 'AtomControl.js' */                                    this._element.appendChild(tc);
/*Line 431 - 'AtomControl.js' */                                }
/*Line 432 - 'AtomControl.js' */                            }
/*Line 433 - 'AtomControl.js' */                        }
/*Line 434 - 'AtomControl.js' */                        this.onCreateChildren(this._element);
/*Line 435 - 'AtomControl.js' */                    }
/*Line 436 - 'AtomControl.js' */                }
/*Line 437 - 'AtomControl.js' */            },


/*Line 440 - 'AtomControl.js' */            onCreateChildren: function (element) {

/*Line 442 - 'AtomControl.js' */                var ae = new ChildEnumerator(element);
/*Line 443 - 'AtomControl.js' */                var child;
/*Line 444 - 'AtomControl.js' */                while (ae.next()) {
/*Line 445 - 'AtomControl.js' */                    child = ae.current();

/*Line 447 - 'AtomControl.js' */                    var amap = AtomUI.attributeMap(child, /^atom\-(template|presenter|type|template\-name)$/gi);

/*Line 449 - 'AtomControl.js' */                    var t = amap["atom-template"];
/*Line 450 - 'AtomControl.js' */                    if (t) {
/*Line 451 - 'AtomControl.js' */                        child.removeAttributeNode(t.node);
/*Line 452 - 'AtomControl.js' */                        element.templateOwner = true;
/*Line 453 - 'AtomControl.js' */                        this["_" + t.value] = child;
/*Line 454 - 'AtomControl.js' */                        element.removeChild(child);
/*Line 455 - 'AtomControl.js' */                        continue;
/*Line 456 - 'AtomControl.js' */                    }

/*Line 458 - 'AtomControl.js' */                    var tn = amap["atom-template-name"];
/*Line 459 - 'AtomControl.js' */                    if (tn) {
/*Line 460 - 'AtomControl.js' */                        child.removeAttributeNode(tn.node);
/*Line 461 - 'AtomControl.js' */                        this._scopeTemplates = this._scopeTemplates || {};
/*Line 462 - 'AtomControl.js' */                        this._scopeTemplates[tn.value] = child;
/*Line 463 - 'AtomControl.js' */                        element.removeChild(child);
/*Line 464 - 'AtomControl.js' */                        continue;
/*Line 465 - 'AtomControl.js' */                    }

/*Line 467 - 'AtomControl.js' */                    var p = amap["atom-presenter"];
/*Line 468 - 'AtomControl.js' */                    if (p) {
/*Line 469 - 'AtomControl.js' */                        // search upwords for expected presenter...
/*Line 470 - 'AtomControl.js' */                        var owner = AtomUI.getPresenterOwner(this, p.value);
/*Line 471 - 'AtomControl.js' */                        owner["_" + p.value] = child;
/*Line 472 - 'AtomControl.js' */                    }

/*Line 474 - 'AtomControl.js' */                    var childType = amap["atom-type"];

/*Line 476 - 'AtomControl.js' */                    if (childType) {
/*Line 477 - 'AtomControl.js' */                        AtomUI.createControl(child, childType.value);
/*Line 478 - 'AtomControl.js' */                        //element.removeAttributeNode(childType.node);
/*Line 479 - 'AtomControl.js' */                    } else {
/*Line 480 - 'AtomControl.js' */                        this.onCreateChildren(child);
/*Line 481 - 'AtomControl.js' */                    }
/*Line 482 - 'AtomControl.js' */                }
/*Line 483 - 'AtomControl.js' */            },

/*Line 485 - 'AtomControl.js' */            onLoaded: function () {
/*Line 486 - 'AtomControl.js' */            },

/*Line 488 - 'AtomControl.js' */            onUpdateUI: function () {
/*Line 489 - 'AtomControl.js' */                if (this._layout) {
/*Line 490 - 'AtomControl.js' */                    this._layout.doLayout(this._element);
/*Line 491 - 'AtomControl.js' */                } else {
/*Line 492 - 'AtomControl.js' */                    this.updateChildUI(this.get_element());
/*Line 493 - 'AtomControl.js' */                }
/*Line 494 - 'AtomControl.js' */            },

/*Line 496 - 'AtomControl.js' */            updateUI: function () {
/*Line 497 - 'AtomControl.js' */                var ctrl = this;
/*Line 498 - 'AtomControl.js' */                this.dispatcher.callLater(function () {
/*Line 499 - 'AtomControl.js' */                    ctrl.onUpdateUI();
/*Line 500 - 'AtomControl.js' */                });
/*Line 501 - 'AtomControl.js' */            },

/*Line 503 - 'AtomControl.js' */            updateChildUI: function (parent) {
/*Line 504 - 'AtomControl.js' */                if (!parent)
/*Line 505 - 'AtomControl.js' */                    parent = this._element;
/*Line 506 - 'AtomControl.js' */                var ae = new ChildEnumerator(parent);
/*Line 507 - 'AtomControl.js' */                while (ae.next()) {
/*Line 508 - 'AtomControl.js' */                    var child = ae.current();
/*Line 509 - 'AtomControl.js' */                    if (child.atomControl) {
/*Line 510 - 'AtomControl.js' */                        child.atomControl.updateUI();
/*Line 511 - 'AtomControl.js' */                        continue;
/*Line 512 - 'AtomControl.js' */                    }
/*Line 513 - 'AtomControl.js' */                    this.updateChildUI(child);
/*Line 514 - 'AtomControl.js' */                }
/*Line 515 - 'AtomControl.js' */            },

/*Line 517 - 'AtomControl.js' */            onCreated: function () {
/*Line 518 - 'AtomControl.js' */                this.updateUI();
/*Line 519 - 'AtomControl.js' */            },

/*Line 521 - 'AtomControl.js' */            setProperties: function (element) {


/*Line 524 - 'AtomControl.js' */                var obj;
/*Line 525 - 'AtomControl.js' */                var key;
/*Line 526 - 'AtomControl.js' */                var value;
/*Line 527 - 'AtomControl.js' */                var fn;
/*Line 528 - 'AtomControl.js' */                var at;

/*Line 530 - 'AtomControl.js' */                var attr = element.attributes;
/*Line 531 - 'AtomControl.js' */                var ae = new AtomEnumerator(attr);

/*Line 533 - 'AtomControl.js' */                var remove = [];

/*Line 535 - 'AtomControl.js' */                var nodeValue = "value";
/*Line 536 - 'AtomControl.js' */                if (AtomBrowser.isIE && AtomBrowser.majorVersion < 9) {
/*Line 537 - 'AtomControl.js' */                    nodeValue = "nodeValue";
/*Line 538 - 'AtomControl.js' */                }

/*Line 540 - 'AtomControl.js' */                var bindList = {};

/*Line 542 - 'AtomControl.js' */                var compiledFunc = null;

/*Line 544 - 'AtomControl.js' */                while (ae.next()) {
/*Line 545 - 'AtomControl.js' */                    at = ae.current();
/*Line 546 - 'AtomControl.js' */                    key = at.nodeName;
/*Line 547 - 'AtomControl.js' */                    value = at[nodeValue];

/*Line 549 - 'AtomControl.js' */                    if (key === "data-atom-init") {
/*Line 550 - 'AtomControl.js' */                        compiledFunc = value;
/*Line 551 - 'AtomControl.js' */                        remove.push(at);
/*Line 552 - 'AtomControl.js' */                        continue;
/*Line 553 - 'AtomControl.js' */                    }
/*Line 554 - 'AtomControl.js' */                    if (/^data\-atom/.test(key)) {
/*Line 555 - 'AtomControl.js' */                        key = key.substr(5);
/*Line 556 - 'AtomControl.js' */                    }

/*Line 558 - 'AtomControl.js' */                    if (/^atomControl$/g.test(key)) {
/*Line 559 - 'AtomControl.js' */                        continue;
/*Line 560 - 'AtomControl.js' */                    }
/*Line 561 - 'AtomControl.js' */                    if (/^atom\-type$/.test(key)) {
/*Line 562 - 'AtomControl.js' */                        remove.push(at);
/*Line 563 - 'AtomControl.js' */                        continue;
/*Line 564 - 'AtomControl.js' */                    }
/*Line 565 - 'AtomControl.js' */                    if (!(/^(atom|bind|style|event)\-/g.test(key)))
/*Line 566 - 'AtomControl.js' */                        continue;
/*Line 567 - 'AtomControl.js' */                    if (!(/^(style|event)\-/g.test(key)))
/*Line 568 - 'AtomControl.js' */                        key = key.substr(5);

/*Line 570 - 'AtomControl.js' */                    if (!value)
/*Line 571 - 'AtomControl.js' */                        continue;

/*Line 573 - 'AtomControl.js' */                    if (!/(^style$|dock)/.test(key)) {
/*Line 574 - 'AtomControl.js' */                        remove.push(at);
/*Line 575 - 'AtomControl.js' */                    }

/*Line 577 - 'AtomControl.js' */                    // rename key...
/*Line 578 - 'AtomControl.js' */                    key = $.camelCase(key);

/*Line 580 - 'AtomControl.js' */                    bindList[key] = value;

/*Line 582 - 'AtomControl.js' */                }

/*Line 584 - 'AtomControl.js' */                if (compiledFunc) {
/*Line 585 - 'AtomControl.js' */                    var f = WebAtoms.PageSetup[compiledFunc];
/*Line 586 - 'AtomControl.js' */                    f.call(this, element);
/*Line 587 - 'AtomControl.js' */                }

/*Line 589 - 'AtomControl.js' */                // Since setValue may add up new attributes
/*Line 590 - 'AtomControl.js' */                // We set value after we have collected attribute list
/*Line 591 - 'AtomControl.js' */                for (key in bindList) {
/*Line 592 - 'AtomControl.js' */                    this.setValue(key, bindList[key], true, element);
/*Line 593 - 'AtomControl.js' */                }

/*Line 595 - 'AtomControl.js' */                ae = new AtomEnumerator(remove);
/*Line 596 - 'AtomControl.js' */                while (ae.next()) {
/*Line 597 - 'AtomControl.js' */                    //$(element).removeAttr(ae.current().nodeName);
/*Line 598 - 'AtomControl.js' */                    element.removeAttributeNode(ae.current());
/*Line 599 - 'AtomControl.js' */                }

/*Line 601 - 'AtomControl.js' */                var child = new ChildEnumerator(element);
/*Line 602 - 'AtomControl.js' */                while (child.next()) {
/*Line 603 - 'AtomControl.js' */                    var childItem = child.current();
/*Line 604 - 'AtomControl.js' */                    if (childItem.atomControl)
/*Line 605 - 'AtomControl.js' */                        continue;
/*Line 606 - 'AtomControl.js' */                    this.setProperties(childItem);
/*Line 607 - 'AtomControl.js' */                }

/*Line 609 - 'AtomControl.js' */            },

/*Line 611 - 'AtomControl.js' */            setValue: function (key, value, bind, element) {
/*Line 612 - 'AtomControl.js' */                if (value && value.constructor == String) {

/*Line 614 - 'AtomControl.js' */                    var s = value[0];

/*Line 616 - 'AtomControl.js' */                    var f = AtomBinders[s];
/*Line 617 - 'AtomControl.js' */                    if (f) {
/*Line 618 - 'AtomControl.js' */                        f(this, key, value, element);
/*Line 619 - 'AtomControl.js' */                        return;
/*Line 620 - 'AtomControl.js' */                    }

/*Line 622 - 'AtomControl.js' */                    s += value[1];
/*Line 623 - 'AtomControl.js' */                    f = AtomBinders[s];
/*Line 624 - 'AtomControl.js' */                    if (f) {
/*Line 625 - 'AtomControl.js' */                        f(this, key, value, element);
/*Line 626 - 'AtomControl.js' */                        return;
/*Line 627 - 'AtomControl.js' */                    }

/*Line 629 - 'AtomControl.js' */                }

/*Line 631 - 'AtomControl.js' */                this.setLocalValue(key, value, element);
/*Line 632 - 'AtomControl.js' */            },

/*Line 634 - 'AtomControl.js' */            setLocalValue: function (key, value, element, refresh) {

/*Line 636 - 'AtomControl.js' */                // undefined can never be set
/*Line 637 - 'AtomControl.js' */                if (value === undefined)
/*Line 638 - 'AtomControl.js' */                    return;

/*Line 640 - 'AtomControl.js' */                if (value && value instanceof AtomPromise) {

/*Line 642 - 'AtomControl.js' */                    element._promisesQueue = element._promisesQueue || {};

/*Line 644 - 'AtomControl.js' */                    var op = element._promisesQueue[key];
/*Line 645 - 'AtomControl.js' */                    if (op) {
/*Line 646 - 'AtomControl.js' */                        op.abort();
/*Line 647 - 'AtomControl.js' */                    }
/*Line 648 - 'AtomControl.js' */                    element._promisesQueue[key] = value;

/*Line 650 - 'AtomControl.js' */                    if (value._persist) {

/*Line 652 - 'AtomControl.js' */                        // is it a promise?
/*Line 653 - 'AtomControl.js' */                        this._promises = this._promises || {};

/*Line 655 - 'AtomControl.js' */                        // cache promise...
/*Line 656 - 'AtomControl.js' */                        this._promises[key] = value;


/*Line 659 - 'AtomControl.js' */                    }

/*Line 661 - 'AtomControl.js' */                    var caller = this;

/*Line 663 - 'AtomControl.js' */                    value.then(function (p) {

/*Line 665 - 'AtomControl.js' */                        if (element._promisesQueue[key] == p) {
/*Line 666 - 'AtomControl.js' */                            element._promisesQueue[key] = null;
/*Line 667 - 'AtomControl.js' */                        }

/*Line 669 - 'AtomControl.js' */                        element._promisesQueue[key] = null;

/*Line 671 - 'AtomControl.js' */                        caller.setLocalValue(key, p.value(), element, true);

/*Line 673 - 'AtomControl.js' */                        if (caller._loadNext) {
/*Line 674 - 'AtomControl.js' */                            caller.invokeAction(caller._loadNext);
/*Line 675 - 'AtomControl.js' */                        }
/*Line 676 - 'AtomControl.js' */                    });

/*Line 678 - 'AtomControl.js' */                    value.failed(function (p) {
/*Line 679 - 'AtomControl.js' */                        if (element._promisesQueue[key] == p) {
/*Line 680 - 'AtomControl.js' */                            element._promisesQueue[key] = null;
/*Line 681 - 'AtomControl.js' */                        }
/*Line 682 - 'AtomControl.js' */                    });

/*Line 684 - 'AtomControl.js' */                    value.invoke();
/*Line 685 - 'AtomControl.js' */                    return;

/*Line 687 - 'AtomControl.js' */                }

/*Line 689 - 'AtomControl.js' */                if (this._element == element) {
/*Line 690 - 'AtomControl.js' */                    var fn = this["set_" + key];
/*Line 691 - 'AtomControl.js' */                    if (fn != null) {
/*Line 692 - 'AtomControl.js' */                        if (refresh) {
/*Line 693 - 'AtomControl.js' */                            // checking old value is necessary
/*Line 694 - 'AtomControl.js' */                            // as two way binding may cause recursive
/*Line 695 - 'AtomControl.js' */                            // updates
/*Line 696 - 'AtomControl.js' */                            var oldValue = AtomBinder.getValue(this, key);
/*Line 697 - 'AtomControl.js' */                            if (oldValue == value)
/*Line 698 - 'AtomControl.js' */                                return;
/*Line 699 - 'AtomControl.js' */                        }
/*Line 700 - 'AtomControl.js' */                        fn.apply(this, [value]);
/*Line 701 - 'AtomControl.js' */                        if (refresh) {
/*Line 702 - 'AtomControl.js' */                            AtomBinder.refreshValue(this, key);
/*Line 703 - 'AtomControl.js' */                        }
/*Line 704 - 'AtomControl.js' */                        return;
/*Line 705 - 'AtomControl.js' */                    }
/*Line 706 - 'AtomControl.js' */                }

/*Line 708 - 'AtomControl.js' */                if (/^style/g.test(key) && key.length > 5) {
/*Line 709 - 'AtomControl.js' */                    var k = key.substr(5);
/*Line 710 - 'AtomControl.js' */                    k = String.fromCharCode(k.charCodeAt(0)).toLowerCase() + k.substr(1);
/*Line 711 - 'AtomControl.js' */                    element.style[k] = value;
/*Line 712 - 'AtomControl.js' */                    return;
/*Line 713 - 'AtomControl.js' */                }

/*Line 715 - 'AtomControl.js' */                if (/^event/g.test(key) && key.length > 5) {
/*Line 716 - 'AtomControl.js' */                    var k = key.substr(5);
/*Line 717 - 'AtomControl.js' */                    k = String.fromCharCode(k.charCodeAt(0)).toLowerCase() + k.substr(1);
/*Line 718 - 'AtomControl.js' */                    var _this = this;
/*Line 719 - 'AtomControl.js' */                    // unbind previous event...
/*Line 720 - 'AtomControl.js' */                    this.unbindEvent(element, k);
/*Line 721 - 'AtomControl.js' */                    this.bindEvent(element, k, null, null, function (evt) {
/*Line 722 - 'AtomControl.js' */                        _this.invokeAction(value, evt);
/*Line 723 - 'AtomControl.js' */                    });
/*Line 724 - 'AtomControl.js' */                    return;
/*Line 725 - 'AtomControl.js' */                }

/*Line 727 - 'AtomControl.js' */                var f = AtomProperties[key] || AtomProperties.any;
/*Line 728 - 'AtomControl.js' */                if (f) {
/*Line 729 - 'AtomControl.js' */                    f(element || this._element, value, key);
/*Line 730 - 'AtomControl.js' */                }

/*Line 732 - 'AtomControl.js' */            },

/*Line 734 - 'AtomControl.js' */            bind: function (element, key, value, twoWays, vf, events) {

/*Line 736 - 'AtomControl.js' */                if (value == null) {
/*Line 737 - 'AtomControl.js' */                    // remove existing binding...
/*Line 738 - 'AtomControl.js' */                    this.clearBinding(element, key);
/*Line 739 - 'AtomControl.js' */                    return;
/*Line 740 - 'AtomControl.js' */                }

/*Line 742 - 'AtomControl.js' */                var target = this;
/*Line 743 - 'AtomControl.js' */                if (value && value.constructor == String && /^window\./g.test(value)) {
/*Line 744 - 'AtomControl.js' */                    target = window;
/*Line 745 - 'AtomControl.js' */                }

/*Line 747 - 'AtomControl.js' */                var thisElement = this.get_element();

/*Line 749 - 'AtomControl.js' */                var jq = thisElement != element;

/*Line 751 - 'AtomControl.js' */                if (!jq) {
/*Line 752 - 'AtomControl.js' */                    var f = this["get_" + key];
/*Line 753 - 'AtomControl.js' */                    if (f == undefined || f == null) {
/*Line 754 - 'AtomControl.js' */                        jq = true;
/*Line 755 - 'AtomControl.js' */                    }
/*Line 756 - 'AtomControl.js' */                }

/*Line 758 - 'AtomControl.js' */                switch (key) {
/*Line 759 - 'AtomControl.js' */                    case "value":
/*Line 760 - 'AtomControl.js' */                        if (/input/gi.test(element.nodeName)) { jq = true; }
/*Line 761 - 'AtomControl.js' */                        this.addBinding(target, element, "value", value, twoWays, jq, vf, events);
/*Line 762 - 'AtomControl.js' */                        break;
/*Line 763 - 'AtomControl.js' */                    case "text":
/*Line 764 - 'AtomControl.js' */                        this.addBinding(target, element, "text", value, false, true, vf, events);
/*Line 765 - 'AtomControl.js' */                        break;
/*Line 766 - 'AtomControl.js' */                    default:
/*Line 767 - 'AtomControl.js' */                        this.addBinding(target, element, key, value, twoWays, jq, vf, events);
/*Line 768 - 'AtomControl.js' */                        break;
/*Line 769 - 'AtomControl.js' */                }

/*Line 771 - 'AtomControl.js' */            },

/*Line 773 - 'AtomControl.js' */            onInitialized: function () {
/*Line 774 - 'AtomControl.js' */            },

/*Line 776 - 'AtomControl.js' */            init: function () {

/*Line 778 - 'AtomControl.js' */                // first remove all templates ...
/*Line 779 - 'AtomControl.js' */                base.init.apply(this, arguments);

/*Line 781 - 'AtomControl.js' */                // init properties...
/*Line 782 - 'AtomControl.js' */                var element = this.get_element();

/*Line 784 - 'AtomControl.js' */                var amap = AtomUI.attributeMap(element, /^atom\-(name|local\-scope)$/gi);

/*Line 786 - 'AtomControl.js' */                var aname = amap["atom-name"];
/*Line 787 - 'AtomControl.js' */                if (!aname) {
/*Line 788 - 'AtomControl.js' */                    var eid = element.id;
/*Line 789 - 'AtomControl.js' */                    if (!/^\_\_waID/.test(eid)) {
/*Line 790 - 'AtomControl.js' */                        aname = element.id;
/*Line 791 - 'AtomControl.js' */                    }
/*Line 792 - 'AtomControl.js' */                } else {
/*Line 793 - 'AtomControl.js' */                    element.removeAttributeNode(aname.node);
/*Line 794 - 'AtomControl.js' */                    aname = aname.value;
/*Line 795 - 'AtomControl.js' */                }
/*Line 796 - 'AtomControl.js' */                if (aname) {
/*Line 797 - 'AtomControl.js' */                    if (/^(app|window|owner|scope|localScope|parent)$/gi.test(aname))
/*Line 798 - 'AtomControl.js' */                        throw new Error("Invalid Control Name '" + aname + "'");
/*Line 799 - 'AtomControl.js' */                    var s = this.get_scope();
/*Line 800 - 'AtomControl.js' */                    AtomBinder.setValue(s, aname, this);
/*Line 801 - 'AtomControl.js' */                    this._name = aname;
/*Line 802 - 'AtomControl.js' */                }


/*Line 805 - 'AtomControl.js' */                ls = amap["atom-local-scope"];
/*Line 806 - 'AtomControl.js' */                if (ls) {
/*Line 807 - 'AtomControl.js' */                    this._localScope = new AtomScope(this, this.get_scope(), atomApplication);
/*Line 808 - 'AtomControl.js' */                    this._scope = this._localScope;
/*Line 809 - 'AtomControl.js' */                    if (this._name) {
/*Line 810 - 'AtomControl.js' */                        this._localScope[this._name] = this;
/*Line 811 - 'AtomControl.js' */                    }
/*Line 812 - 'AtomControl.js' */                    element.removeAttributeNode(ls.node);
/*Line 813 - 'AtomControl.js' */                }

/*Line 815 - 'AtomControl.js' */                // scope is now ready, set scopeTemplates...
/*Line 816 - 'AtomControl.js' */                var st = this._scopeTemplates;
/*Line 817 - 'AtomControl.js' */                if (st) {
/*Line 818 - 'AtomControl.js' */                    var s = this.get_scope();
/*Line 819 - 'AtomControl.js' */                    for (var i in st) {
/*Line 820 - 'AtomControl.js' */                        var t = st[i];
/*Line 821 - 'AtomControl.js' */                        AtomBinder.setValue(s, i, t);
/*Line 822 - 'AtomControl.js' */                    }
/*Line 823 - 'AtomControl.js' */                    //try {
/*Line 824 - 'AtomControl.js' */                    //    delete this._scopeTemplates;
/*Line 825 - 'AtomControl.js' */                    //} catch (exx) {

/*Line 827 - 'AtomControl.js' */                    //}
/*Line 828 - 'AtomControl.js' */                }

/*Line 830 - 'AtomControl.js' */                //var fn = Function.createDelegate(this, this.initProperties);
/*Line 831 - 'AtomControl.js' */                var _this = this;
/*Line 832 - 'AtomControl.js' */                WebAtoms.dispatcher.callLater(function () {
/*Line 833 - 'AtomControl.js' */                    _this.initProperties();
/*Line 834 - 'AtomControl.js' */                });

/*Line 836 - 'AtomControl.js' */                // init every children..
/*Line 837 - 'AtomControl.js' */                this.initChildren(this._element);

/*Line 839 - 'AtomControl.js' */                //fn = Function.createDelegate(this, this.onInitialized);
/*Line 840 - 'AtomControl.js' */                WebAtoms.dispatcher.callLater(function () {
/*Line 841 - 'AtomControl.js' */                    _this.onInitialized();
/*Line 842 - 'AtomControl.js' */                });
/*Line 843 - 'AtomControl.js' */            },


/*Line 846 - 'AtomControl.js' */            dispose: function (e) {

/*Line 848 - 'AtomControl.js' */                var vm = this._viewModel;
/*Line 849 - 'AtomControl.js' */                if (vm && vm.dispose) {
/*Line 850 - 'AtomControl.js' */                    vm.dispose();
/*Line 851 - 'AtomControl.js' */                    this._viewModel = null;
/*Line 852 - 'AtomControl.js' */                }

/*Line 854 - 'AtomControl.js' */                // disposing only one element
/*Line 855 - 'AtomControl.js' */                if (e) {
/*Line 856 - 'AtomControl.js' */                    var eac = e.atomControl;
/*Line 857 - 'AtomControl.js' */                    if (eac) {
/*Line 858 - 'AtomControl.js' */                        eac.dispose();
/*Line 859 - 'AtomControl.js' */                    } else {
/*Line 860 - 'AtomControl.js' */                        this.clearBinding(e);
/*Line 861 - 'AtomControl.js' */                        this.disposeChildren(e);
/*Line 862 - 'AtomControl.js' */                    }
/*Line 863 - 'AtomControl.js' */                    $(e).remove();
/*Line 864 - 'AtomControl.js' */                    return;
/*Line 865 - 'AtomControl.js' */                }

/*Line 867 - 'AtomControl.js' */                this._disposed = true;
/*Line 868 - 'AtomControl.js' */                this.disposeChildren(this._element);
/*Line 869 - 'AtomControl.js' */                this.clearBinding();
/*Line 870 - 'AtomControl.js' */                this.bindings.length = 0;
/*Line 871 - 'AtomControl.js' */                base.dispose.apply(this, arguments);
/*Line 872 - 'AtomControl.js' */            },


/*Line 875 - 'AtomControl.js' */            disposeChildren: function (e) {
/*Line 876 - 'AtomControl.js' */                var oldIE = AtomBrowser.isIE && AtomBrowser.majorVersion < 9;
/*Line 877 - 'AtomControl.js' */                var ae = new ChildEnumerator(e);
/*Line 878 - 'AtomControl.js' */                while (ae.next()) {
/*Line 879 - 'AtomControl.js' */                    var ce = ae.current();
/*Line 880 - 'AtomControl.js' */                    if (ce.atomControl) {
/*Line 881 - 'AtomControl.js' */                        ce.atomControl.dispose();
/*Line 882 - 'AtomControl.js' */                        if (oldIE) {
/*Line 883 - 'AtomControl.js' */                            ce.atomControl = undefined;
/*Line 884 - 'AtomControl.js' */                        } else {
/*Line 885 - 'AtomControl.js' */                            delete ce.atomControl;
/*Line 886 - 'AtomControl.js' */                        }
/*Line 887 - 'AtomControl.js' */                    } else {
/*Line 888 - 'AtomControl.js' */                        this.clearBinding(ce);
/*Line 889 - 'AtomControl.js' */                        this.unbindEvent(ce);
/*Line 890 - 'AtomControl.js' */                        this.disposeChildren(ce);
/*Line 891 - 'AtomControl.js' */                    }
/*Line 892 - 'AtomControl.js' */                    //$(ce).remove();
/*Line 893 - 'AtomControl.js' */                }
/*Line 894 - 'AtomControl.js' */                // this will and should remove every children..
/*Line 895 - 'AtomControl.js' */                try {
/*Line 896 - 'AtomControl.js' */                    e.innerHTML = "";
/*Line 897 - 'AtomControl.js' */                } catch (ex) {
/*Line 898 - 'AtomControl.js' */                    $(e).html('');
/*Line 899 - 'AtomControl.js' */                }
/*Line 900 - 'AtomControl.js' */            },

/*Line 902 - 'AtomControl.js' */            get_innerTemplate: function () {
/*Line 903 - 'AtomControl.js' */                return this._template;
/*Line 904 - 'AtomControl.js' */            },

/*Line 906 - 'AtomControl.js' */            set_innerTemplate: function (v) {
/*Line 907 - 'AtomControl.js' */                if (this._template === v) {
/*Line 908 - 'AtomControl.js' */                    if (this._created)
/*Line 909 - 'AtomControl.js' */                        return;
/*Line 910 - 'AtomControl.js' */                }
/*Line 911 - 'AtomControl.js' */                if (!this._created) {
/*Line 912 - 'AtomControl.js' */                    var _this = this;
/*Line 913 - 'AtomControl.js' */                    // this is because, sometimes template change occurs while creation
/*Line 914 - 'AtomControl.js' */                    // which creates endless loop
/*Line 915 - 'AtomControl.js' */                    WebAtoms.dispatcher.callLater(function () {
/*Line 916 - 'AtomControl.js' */                        _this.set_innerTemplate(v);
/*Line 917 - 'AtomControl.js' */                    });
/*Line 918 - 'AtomControl.js' */                    return;
/*Line 919 - 'AtomControl.js' */                }
/*Line 920 - 'AtomControl.js' */                this._template = v;
/*Line 921 - 'AtomControl.js' */                // disposing all children...
/*Line 922 - 'AtomControl.js' */                this.disposeChildren(this._element);

/*Line 924 - 'AtomControl.js' */                this.createChildren();
/*Line 925 - 'AtomControl.js' */                this.setProperties(this._element);
/*Line 926 - 'AtomControl.js' */                this.initChildren(this._element);
/*Line 927 - 'AtomControl.js' */                this.updateUI();
/*Line 928 - 'AtomControl.js' */            },

/*Line 930 - 'AtomControl.js' */            initChildren: function (e) {
/*Line 931 - 'AtomControl.js' */                var ae = new ChildEnumerator(e);
/*Line 932 - 'AtomControl.js' */                var item;
/*Line 933 - 'AtomControl.js' */                var ctrl;

/*Line 935 - 'AtomControl.js' */                var remove = [];

/*Line 937 - 'AtomControl.js' */                while (ae.next()) {
/*Line 938 - 'AtomControl.js' */                    item = ae.current();

/*Line 940 - 'AtomControl.js' */                    if (item.nodeName == "SCRIPT") {

/*Line 942 - 'AtomControl.js' */                        var s = $.trim(item.innerHTML);
/*Line 943 - 'AtomControl.js' */                        if (/^\(\{/.test(s) && /\}\)$/.test(s)) {
/*Line 944 - 'AtomControl.js' */                            try {
/*Line 945 - 'AtomControl.js' */                                s = (new Function("return " + s + ";"))()
/*Line 946 - 'AtomControl.js' */                                this.set_scope(s);
/*Line 947 - 'AtomControl.js' */                            } catch (ex) {
/*Line 948 - 'AtomControl.js' */                                log(JSON.stringify(ex));
/*Line 949 - 'AtomControl.js' */                                alert(JSON.stringify(ex));
/*Line 950 - 'AtomControl.js' */                            }

/*Line 952 - 'AtomControl.js' */                        }
/*Line 953 - 'AtomControl.js' */                        remove.push(item);
/*Line 954 - 'AtomControl.js' */                        continue;

/*Line 956 - 'AtomControl.js' */                    }

/*Line 958 - 'AtomControl.js' */                    ctrl = item.atomControl;
/*Line 959 - 'AtomControl.js' */                    if (ctrl) {
/*Line 960 - 'AtomControl.js' */                        ctrl.init();
/*Line 961 - 'AtomControl.js' */                    } else {
/*Line 962 - 'AtomControl.js' */                        this.initChildren(item);
/*Line 963 - 'AtomControl.js' */                    }
/*Line 964 - 'AtomControl.js' */                }

/*Line 966 - 'AtomControl.js' */                ae = new AtomEnumerator(remove);
/*Line 967 - 'AtomControl.js' */                while (ae.next()) {
/*Line 968 - 'AtomControl.js' */                    e.removeChild(ae.current());
/*Line 969 - 'AtomControl.js' */                }
/*Line 970 - 'AtomControl.js' */            }
/*Line 971 - 'AtomControl.js' */        }
/*Line 972 - 'AtomControl.js' */    });
/*Line 973 - 'AtomControl.js' */})(WebAtoms.AtomUIComponent.prototype);
/*Line 0 - 'AtomItemsControl.js' */

/*Line 2 - 'AtomItemsControl.js' */(function (base) {
/*Line 3 - 'AtomItemsControl.js' */    return classCreatorEx({
/*Line 4 - 'AtomItemsControl.js' */        name: "WebAtoms.AtomItemsControl",
/*Line 5 - 'AtomItemsControl.js' */        base: base,
/*Line 6 - 'AtomItemsControl.js' */        start: function () {
/*Line 7 - 'AtomItemsControl.js' */            this._selectedItems = [];
/*Line 8 - 'AtomItemsControl.js' */            this._selectedElements = [];
/*Line 9 - 'AtomItemsControl.js' */            this._selectedIndexSet = false;
/*Line 10 - 'AtomItemsControl.js' */            this._onUIChanged = false;
/*Line 11 - 'AtomItemsControl.js' */            this._itemsPresenter = null;
/*Line 12 - 'AtomItemsControl.js' */            this._itemsPanel = null;
/*Line 13 - 'AtomItemsControl.js' */            this._presenters = ["itemsPresenter","virtualContainer"];
/*Line 14 - 'AtomItemsControl.js' */            this._childItemType = WebAtoms.AtomControl;
/*Line 15 - 'AtomItemsControl.js' */        },
/*Line 16 - 'AtomItemsControl.js' */        properties: {
/*Line 17 - 'AtomItemsControl.js' */            allowSelectFirst: false,
/*Line 18 - 'AtomItemsControl.js' */            allowMultipleSelection: false,
/*Line 19 - 'AtomItemsControl.js' */            uiVirtualize: false,
/*Line 20 - 'AtomItemsControl.js' */            defaultValue: null,
/*Line 21 - 'AtomItemsControl.js' */            autoScrollToSelection: false,
/*Line 22 - 'AtomItemsControl.js' */            /* this forces SelectAll Checkbox to ignore value of get_selectAll and forces its own value on click */
/*Line 23 - 'AtomItemsControl.js' */            selectAll: undefined,
/*Line 24 - 'AtomItemsControl.js' */            labelPath: "label",
/*Line 25 - 'AtomItemsControl.js' */            valuePath: "value",
/*Line 26 - 'AtomItemsControl.js' */            sortPath: null,
/*Line 27 - 'AtomItemsControl.js' */            valueSeparator: null,
/*Line 28 - 'AtomItemsControl.js' */            postData: null,
/*Line 29 - 'AtomItemsControl.js' */            errorNext: null,
/*Line 30 - 'AtomItemsControl.js' */            postUrl: null,
/*Line 31 - 'AtomItemsControl.js' */            confirm: false,
/*Line 32 - 'AtomItemsControl.js' */            confirmMessage: null,
/*Line 33 - 'AtomItemsControl.js' */            filter: null,
/*Line 34 - 'AtomItemsControl.js' */            items: null,
/*Line 35 - 'AtomItemsControl.js' */            itemTemplate: null
/*Line 36 - 'AtomItemsControl.js' */        },
/*Line 37 - 'AtomItemsControl.js' */        methods: {
/*Line 38 - 'AtomItemsControl.js' */            get_postData: function () {
/*Line 39 - 'AtomItemsControl.js' */                return this._postData || this.get_selectedItem();
/*Line 40 - 'AtomItemsControl.js' */            },
/*Line 41 - 'AtomItemsControl.js' */            get_allValues: function () {
/*Line 42 - 'AtomItemsControl.js' */                if (!this._valueSeparator)
/*Line 43 - 'AtomItemsControl.js' */                    return;
/*Line 44 - 'AtomItemsControl.js' */                if (!this._valuePath)
/*Line 45 - 'AtomItemsControl.js' */                    return;
/*Line 46 - 'AtomItemsControl.js' */                var list = [];
/*Line 47 - 'AtomItemsControl.js' */                var vp = this._valuePath;
/*Line 48 - 'AtomItemsControl.js' */                var vfp = function (item) {
/*Line 49 - 'AtomItemsControl.js' */                    return item[vp];
/*Line 50 - 'AtomItemsControl.js' */                };
/*Line 51 - 'AtomItemsControl.js' */                var ae = Atom.query(this.get_dataItems());
/*Line 52 - 'AtomItemsControl.js' */                while (ae.next()) {
/*Line 53 - 'AtomItemsControl.js' */                    list.push(vfp(ae.current()));
/*Line 54 - 'AtomItemsControl.js' */                }
/*Line 55 - 'AtomItemsControl.js' */                return list.join(this._valueSeparator);
/*Line 56 - 'AtomItemsControl.js' */            },
/*Line 57 - 'AtomItemsControl.js' */            get_value: function () {

/*Line 59 - 'AtomItemsControl.js' */                if (this._allowMultipleSelection) {
/*Line 60 - 'AtomItemsControl.js' */                    var items = this._selectedItems;
/*Line 61 - 'AtomItemsControl.js' */                    if (items.length == 0) {
/*Line 62 - 'AtomItemsControl.js' */                        if (this._value !== undefined)
/*Line 63 - 'AtomItemsControl.js' */                            return this._value;
/*Line 64 - 'AtomItemsControl.js' */                        return null;
/*Line 65 - 'AtomItemsControl.js' */                    }
/*Line 66 - 'AtomItemsControl.js' */                    items = AtomArray.getValues(items, this._valuePath);
/*Line 67 - 'AtomItemsControl.js' */                    if (this._valueSeparator)
/*Line 68 - 'AtomItemsControl.js' */                        items = items.join(this._valueSeparator);
/*Line 69 - 'AtomItemsControl.js' */                    return items;
/*Line 70 - 'AtomItemsControl.js' */                }

/*Line 72 - 'AtomItemsControl.js' */                var s = this.get_selectedItem();
/*Line 73 - 'AtomItemsControl.js' */                if (!s) {
/*Line 74 - 'AtomItemsControl.js' */                    if (this._value !== undefined)
/*Line 75 - 'AtomItemsControl.js' */                        return this._value;
/*Line 76 - 'AtomItemsControl.js' */                    return null;
/*Line 77 - 'AtomItemsControl.js' */                }
/*Line 78 - 'AtomItemsControl.js' */                if (this._valuePath) {
/*Line 79 - 'AtomItemsControl.js' */                    s = s[this._valuePath];
/*Line 80 - 'AtomItemsControl.js' */                }
/*Line 81 - 'AtomItemsControl.js' */                return s;
/*Line 82 - 'AtomItemsControl.js' */            },
/*Line 83 - 'AtomItemsControl.js' */            set_value: function (v) {
/*Line 84 - 'AtomItemsControl.js' */                this._value = v;
/*Line 85 - 'AtomItemsControl.js' */                if (v === undefined || v === null) {
/*Line 86 - 'AtomItemsControl.js' */                    // reset...
/*Line 87 - 'AtomItemsControl.js' */                    AtomBinder.clear(this._selectedItems);
/*Line 88 - 'AtomItemsControl.js' */                    return;
/*Line 89 - 'AtomItemsControl.js' */                }
/*Line 90 - 'AtomItemsControl.js' */                var dataItems = this.get_dataItems();
/*Line 91 - 'AtomItemsControl.js' */                if (this._allowMultipleSelection && this._valueSeparator) {
/*Line 92 - 'AtomItemsControl.js' */                    if (v.constructor != String) {
/*Line 93 - 'AtomItemsControl.js' */                        v = "" + v;
/*Line 94 - 'AtomItemsControl.js' */                    }
/*Line 95 - 'AtomItemsControl.js' */                    v = AtomArray.split(v, this._valueSeparator);
/*Line 96 - 'AtomItemsControl.js' */                } else {
/*Line 97 - 'AtomItemsControl.js' */                    v = [v];
/*Line 98 - 'AtomItemsControl.js' */                }
/*Line 99 - 'AtomItemsControl.js' */                var items = AtomArray.intersect(dataItems, this._valuePath, v);
/*Line 100 - 'AtomItemsControl.js' */                this._selectedItems.length = 0;
/*Line 101 - 'AtomItemsControl.js' */                var ae = new AtomEnumerator(items);
/*Line 102 - 'AtomItemsControl.js' */                while (ae.next()) {
/*Line 103 - 'AtomItemsControl.js' */                    this._selectedItems.push(ae.current());
/*Line 104 - 'AtomItemsControl.js' */                }
/*Line 105 - 'AtomItemsControl.js' */                AtomBinder.refreshItems(this._selectedItems);
/*Line 106 - 'AtomItemsControl.js' */            },
/*Line 107 - 'AtomItemsControl.js' */            set_sortPath: function (v) {
/*Line 108 - 'AtomItemsControl.js' */                this._sortPath = v;
/*Line 109 - 'AtomItemsControl.js' */                if (v) {
/*Line 110 - 'AtomItemsControl.js' */                    this.onCollectionChangedInternal("refresh", -1, null);
/*Line 111 - 'AtomItemsControl.js' */                }
/*Line 112 - 'AtomItemsControl.js' */            },
/*Line 113 - 'AtomItemsControl.js' */            set_selectAll: function (v) {
/*Line 114 - 'AtomItemsControl.js' */                if (v === undefined || v === null)
/*Line 115 - 'AtomItemsControl.js' */                    return;
/*Line 116 - 'AtomItemsControl.js' */                this._selectedItems.length = 0;
/*Line 117 - 'AtomItemsControl.js' */                var items = this.get_dataItems();
/*Line 118 - 'AtomItemsControl.js' */                if (v && items) {
/*Line 119 - 'AtomItemsControl.js' */                    var ae = new AtomEnumerator(items);
/*Line 120 - 'AtomItemsControl.js' */                    while (ae.next()) {
/*Line 121 - 'AtomItemsControl.js' */                        this._selectedItems.push(ae.current());
/*Line 122 - 'AtomItemsControl.js' */                    }
/*Line 123 - 'AtomItemsControl.js' */                }
/*Line 124 - 'AtomItemsControl.js' */                this._selectAll = true;
/*Line 125 - 'AtomItemsControl.js' */                AtomBinder.refreshItems(this._selectedItems);
/*Line 126 - 'AtomItemsControl.js' */            },
/*Line 127 - 'AtomItemsControl.js' */            refresh: function () {
/*Line 128 - 'AtomItemsControl.js' */                if (this._promises && this._promises.items) {
/*Line 129 - 'AtomItemsControl.js' */                    this._promises.items.invoke();
/*Line 130 - 'AtomItemsControl.js' */                }

/*Line 132 - 'AtomItemsControl.js' */            },

/*Line 134 - 'AtomItemsControl.js' */            set_defaultValue: function (v) {
/*Line 135 - 'AtomItemsControl.js' */                if (this.get_value())
/*Line 136 - 'AtomItemsControl.js' */                    return;
/*Line 137 - 'AtomItemsControl.js' */                AtomBinder.setValue(this, "value", v);
/*Line 138 - 'AtomItemsControl.js' */            },
/*Line 139 - 'AtomItemsControl.js' */            invokePost: function () {
/*Line 140 - 'AtomItemsControl.js' */                if (!this._onUIChanged)
/*Line 141 - 'AtomItemsControl.js' */                    return;



/*Line 145 - 'AtomItemsControl.js' */                //var errors = this.get_errors();
/*Line 146 - 'AtomItemsControl.js' */                //if (errors.length) {

/*Line 148 - 'AtomItemsControl.js' */                //    alert(errors.join("\n"));

/*Line 150 - 'AtomItemsControl.js' */                //    return false;
/*Line 151 - 'AtomItemsControl.js' */                //}

/*Line 153 - 'AtomItemsControl.js' */                if (this._confirm) {
/*Line 154 - 'AtomItemsControl.js' */                    if (!confirm(this._confirmMessage))
/*Line 155 - 'AtomItemsControl.js' */                        return;
/*Line 156 - 'AtomItemsControl.js' */                }

/*Line 158 - 'AtomItemsControl.js' */                if (!this._postUrl) {
/*Line 159 - 'AtomItemsControl.js' */                    this.invokeAction(this._next);
/*Line 160 - 'AtomItemsControl.js' */                    return;
/*Line 161 - 'AtomItemsControl.js' */                }

/*Line 163 - 'AtomItemsControl.js' */                var data = this.get_postData();

/*Line 165 - 'AtomItemsControl.js' */                if (data === null || data === undefined)
/*Line 166 - 'AtomItemsControl.js' */                    return;

/*Line 168 - 'AtomItemsControl.js' */                data = AtomBinder.getClone(data);

/*Line 170 - 'AtomItemsControl.js' */                var caller = this;
/*Line 171 - 'AtomItemsControl.js' */                var p = AtomPromise.json(this._postUrl, null, { type: "POST", data: data });
/*Line 172 - 'AtomItemsControl.js' */                p.then(function () {
/*Line 173 - 'AtomItemsControl.js' */                    caller.invokeNext();
/*Line 174 - 'AtomItemsControl.js' */                });
/*Line 175 - 'AtomItemsControl.js' */                var errorNext = this._errorNext;
/*Line 176 - 'AtomItemsControl.js' */                if (errorNext) {
/*Line 177 - 'AtomItemsControl.js' */                    p.failed(function (pr) {
/*Line 178 - 'AtomItemsControl.js' */                        caller.invokeAction(errorNext);
/*Line 179 - 'AtomItemsControl.js' */                    });
/*Line 180 - 'AtomItemsControl.js' */                }
/*Line 181 - 'AtomItemsControl.js' */                p.invoke();
/*Line 182 - 'AtomItemsControl.js' */            },

/*Line 184 - 'AtomItemsControl.js' */            invokeNext: function () {
/*Line 185 - 'AtomItemsControl.js' */                this.invokeAction(this._next);
/*Line 186 - 'AtomItemsControl.js' */            },

/*Line 188 - 'AtomItemsControl.js' */            set_filter: function (f) {
/*Line 189 - 'AtomItemsControl.js' */                if (f == this._filter)
/*Line 190 - 'AtomItemsControl.js' */                    return;
/*Line 191 - 'AtomItemsControl.js' */                this._filter = f;
/*Line 192 - 'AtomItemsControl.js' */                this._filteredItems = null;
/*Line 193 - 'AtomItemsControl.js' */                if (this.hasItems()) {
/*Line 194 - 'AtomItemsControl.js' */                    this.onCollectionChangedInternal("refresh", -1, null);
/*Line 195 - 'AtomItemsControl.js' */                }
/*Line 196 - 'AtomItemsControl.js' */            },

/*Line 198 - 'AtomItemsControl.js' */            isSelected: function (item) {
/*Line 199 - 'AtomItemsControl.js' */                var se = new AtomEnumerator(this._selectedItems);
/*Line 200 - 'AtomItemsControl.js' */                var sitem = null;
/*Line 201 - 'AtomItemsControl.js' */                while (se.next()) {
/*Line 202 - 'AtomItemsControl.js' */                    sitem = se.current();
/*Line 203 - 'AtomItemsControl.js' */                    if (sitem == item) {
/*Line 204 - 'AtomItemsControl.js' */                        return true;
/*Line 205 - 'AtomItemsControl.js' */                    }
/*Line 206 - 'AtomItemsControl.js' */                }
/*Line 207 - 'AtomItemsControl.js' */                return false;
/*Line 208 - 'AtomItemsControl.js' */            },

/*Line 210 - 'AtomItemsControl.js' */            get_dataItems: function () {
/*Line 211 - 'AtomItemsControl.js' */                var r = this._items;
/*Line 212 - 'AtomItemsControl.js' */                if (this.hasItems()) {
/*Line 213 - 'AtomItemsControl.js' */                    var f = this._filter;
/*Line 214 - 'AtomItemsControl.js' */                    if (f) {
/*Line 215 - 'AtomItemsControl.js' */                        //if (this._filteredItems)
/*Line 216 - 'AtomItemsControl.js' */                        //    return this._filteredItems;
/*Line 217 - 'AtomItemsControl.js' */                        var a = [];
/*Line 218 - 'AtomItemsControl.js' */                        if (typeof f == 'object') {
/*Line 219 - 'AtomItemsControl.js' */                            a = Atom.query(r).where(f).toArray();
/*Line 220 - 'AtomItemsControl.js' */                        } else {
/*Line 221 - 'AtomItemsControl.js' */                            var ae = new AtomEnumerator(r);
/*Line 222 - 'AtomItemsControl.js' */                            while (ae.next()) {
/*Line 223 - 'AtomItemsControl.js' */                                var item = ae.current();
/*Line 224 - 'AtomItemsControl.js' */                                if (f(item, ae.currentIndex())) {
/*Line 225 - 'AtomItemsControl.js' */                                    a.push(item);
/*Line 226 - 'AtomItemsControl.js' */                                }
/*Line 227 - 'AtomItemsControl.js' */                            }
/*Line 228 - 'AtomItemsControl.js' */                        }
/*Line 229 - 'AtomItemsControl.js' */                        this._filteredItems = a;
/*Line 230 - 'AtomItemsControl.js' */                        r = a;
/*Line 231 - 'AtomItemsControl.js' */                    }

/*Line 233 - 'AtomItemsControl.js' */                    var sp = this._sortPath;
/*Line 234 - 'AtomItemsControl.js' */                    if (sp) {
/*Line 235 - 'AtomItemsControl.js' */                        var spf = window.AtomFilter.sort(sp);
/*Line 236 - 'AtomItemsControl.js' */                        r = r.sort(spf);
/*Line 237 - 'AtomItemsControl.js' */                    }
/*Line 238 - 'AtomItemsControl.js' */                    return r;
/*Line 239 - 'AtomItemsControl.js' */                }
/*Line 240 - 'AtomItemsControl.js' */                return $(this._itemsPresenter).children();
/*Line 241 - 'AtomItemsControl.js' */            },

/*Line 243 - 'AtomItemsControl.js' */            getIndexOfDataItem: function (item) {
/*Line 244 - 'AtomItemsControl.js' */                if (item == null)
/*Line 245 - 'AtomItemsControl.js' */                    return -1;
/*Line 246 - 'AtomItemsControl.js' */                var array = this.get_dataItems();
/*Line 247 - 'AtomItemsControl.js' */                var ae = new AtomEnumerator(array);
/*Line 248 - 'AtomItemsControl.js' */                while (ae.next()) {
/*Line 249 - 'AtomItemsControl.js' */                    if (ae.current() == item)
/*Line 250 - 'AtomItemsControl.js' */                        return ae.currentIndex();
/*Line 251 - 'AtomItemsControl.js' */                }
/*Line 252 - 'AtomItemsControl.js' */                return -1;
/*Line 253 - 'AtomItemsControl.js' */            },
/*Line 254 - 'AtomItemsControl.js' */            getDataItemAtIndex: function (index) {
/*Line 255 - 'AtomItemsControl.js' */                if (index == -1)
/*Line 256 - 'AtomItemsControl.js' */                    return null;
/*Line 257 - 'AtomItemsControl.js' */                return this.get_dataItems()[index];
/*Line 258 - 'AtomItemsControl.js' */            },

/*Line 260 - 'AtomItemsControl.js' */            get_childAtomControls: function () {
/*Line 261 - 'AtomItemsControl.js' */                var p = this._itemsPresenter || this._element;
/*Line 262 - 'AtomItemsControl.js' */                var r = [];
/*Line 263 - 'AtomItemsControl.js' */                var ce = new ChildEnumerator(p);
/*Line 264 - 'AtomItemsControl.js' */                while (ce.next()) {
/*Line 265 - 'AtomItemsControl.js' */                    var a = ce.current();
/*Line 266 - 'AtomItemsControl.js' */                    a = !a || a.atomControl;
/*Line 267 - 'AtomItemsControl.js' */                    if (!a)
/*Line 268 - 'AtomItemsControl.js' */                        continue;
/*Line 269 - 'AtomItemsControl.js' */                    r.push(a);
/*Line 270 - 'AtomItemsControl.js' */                }
/*Line 271 - 'AtomItemsControl.js' */                return r;
/*Line 272 - 'AtomItemsControl.js' */            },

/*Line 274 - 'AtomItemsControl.js' */            get_selectedChild: function () {
/*Line 275 - 'AtomItemsControl.js' */                var item = this.get_selectedItem();
/*Line 276 - 'AtomItemsControl.js' */                if (!this.hasItems())
/*Line 277 - 'AtomItemsControl.js' */                    return item;
/*Line 278 - 'AtomItemsControl.js' */                var ce = new ChildEnumerator(this._itemsPresenter);
/*Line 279 - 'AtomItemsControl.js' */                while (ce.next()) {
/*Line 280 - 'AtomItemsControl.js' */                    var child = ce.current();
/*Line 281 - 'AtomItemsControl.js' */                    if (child.atomControl.get_data() == item)
/*Line 282 - 'AtomItemsControl.js' */                        return child;
/*Line 283 - 'AtomItemsControl.js' */                }
/*Line 284 - 'AtomItemsControl.js' */                return null;
/*Line 285 - 'AtomItemsControl.js' */            },

/*Line 287 - 'AtomItemsControl.js' */            set_allowSelectFirst: function (b) {
/*Line 288 - 'AtomItemsControl.js' */                b = b ? b != "false" : b;
/*Line 289 - 'AtomItemsControl.js' */                this._allowSelectFirst = b;
/*Line 290 - 'AtomItemsControl.js' */            },

/*Line 292 - 'AtomItemsControl.js' */            get_selectedItem: function () {
/*Line 293 - 'AtomItemsControl.js' */                if (this._selectedItems.length > 0)
/*Line 294 - 'AtomItemsControl.js' */                    return this._selectedItems[0];
/*Line 295 - 'AtomItemsControl.js' */                return null;
/*Line 296 - 'AtomItemsControl.js' */            },
/*Line 297 - 'AtomItemsControl.js' */            set_selectedItem: function (value) {
/*Line 298 - 'AtomItemsControl.js' */                if (value) {
/*Line 299 - 'AtomItemsControl.js' */                    this._selectedItems.length = 1;
/*Line 300 - 'AtomItemsControl.js' */                    this._selectedItems[0] = value;
/*Line 301 - 'AtomItemsControl.js' */                } else {
/*Line 302 - 'AtomItemsControl.js' */                    this._selectedItems.length = 0;
/*Line 303 - 'AtomItemsControl.js' */                }
/*Line 304 - 'AtomItemsControl.js' */                AtomBinder.refreshItems(this._selectedItems);
/*Line 305 - 'AtomItemsControl.js' */            },

/*Line 307 - 'AtomItemsControl.js' */            get_selectedItems: function () {
/*Line 308 - 'AtomItemsControl.js' */                return this._selectedItems;
/*Line 309 - 'AtomItemsControl.js' */            },
/*Line 310 - 'AtomItemsControl.js' */            set_selectedItems: function () {
/*Line 311 - 'AtomItemsControl.js' */                // watching !!!
/*Line 312 - 'AtomItemsControl.js' */                // updating !!!
/*Line 313 - 'AtomItemsControl.js' */                throw new Error("Not yet implemented");
/*Line 314 - 'AtomItemsControl.js' */            },

/*Line 316 - 'AtomItemsControl.js' */            get_selectedIndex: function () {
/*Line 317 - 'AtomItemsControl.js' */                var item = this.get_selectedItem();
/*Line 318 - 'AtomItemsControl.js' */                return this.getIndexOfDataItem(item);
/*Line 319 - 'AtomItemsControl.js' */            },
/*Line 320 - 'AtomItemsControl.js' */            set_selectedIndex: function (value) {
/*Line 321 - 'AtomItemsControl.js' */                AtomBinder.setValue(this, "selectedItem", this.getDataItemAtIndex(value));
/*Line 322 - 'AtomItemsControl.js' */            },

/*Line 324 - 'AtomItemsControl.js' */            updateChildSelections: function (type, index, item) {

/*Line 326 - 'AtomItemsControl.js' */            },

/*Line 328 - 'AtomItemsControl.js' */            bringSelectionIntoView: function () {

/*Line 330 - 'AtomItemsControl.js' */                // do not scroll for first auto select 
/*Line 331 - 'AtomItemsControl.js' */                if (this._allowSelectFirst && this.get_selectedIndex() == 0)
/*Line 332 - 'AtomItemsControl.js' */                    return;

/*Line 334 - 'AtomItemsControl.js' */                if (this._uiVirtualize) {
/*Line 335 - 'AtomItemsControl.js' */                    var index = this.get_selectedIndex();
/*Line 336 - 'AtomItemsControl.js' */                    if (!this._ready) {
/*Line 337 - 'AtomItemsControl.js' */                        var self = this;
/*Line 338 - 'AtomItemsControl.js' */                        setTimeout(function () {
/*Line 339 - 'AtomItemsControl.js' */                            self.bringSelectionIntoView();
/*Line 340 - 'AtomItemsControl.js' */                        }, 1000);
/*Line 341 - 'AtomItemsControl.js' */                        return;
/*Line 342 - 'AtomItemsControl.js' */                    }
/*Line 343 - 'AtomItemsControl.js' */                    var avgHeight = this._avgHeight;
/*Line 344 - 'AtomItemsControl.js' */                    var vc = $(this._virtualContainer);

/*Line 346 - 'AtomItemsControl.js' */                    var vcHeight = vc.innerHeight();

/*Line 348 - 'AtomItemsControl.js' */                    var block = Math.ceil(vcHeight / avgHeight);
/*Line 349 - 'AtomItemsControl.js' */                    var itemsInBlock = block * this._columns;

/*Line 351 - 'AtomItemsControl.js' */                    var scrollTop = Math.floor(index / itemsInBlock);
/*Line 352 - 'AtomItemsControl.js' */                    vc.scrollTop(scrollTop * vcHeight);
                    


/*Line 356 - 'AtomItemsControl.js' */                    return;
/*Line 357 - 'AtomItemsControl.js' */                }

/*Line 359 - 'AtomItemsControl.js' */                //var children = $(this._itemsPresenter).children();
/*Line 360 - 'AtomItemsControl.js' */                var ae = new ChildEnumerator(this._itemsPresenter);
/*Line 361 - 'AtomItemsControl.js' */                while (ae.next()) {
/*Line 362 - 'AtomItemsControl.js' */                    var item = ae.current();
/*Line 363 - 'AtomItemsControl.js' */                    var dataItem = item.atomControl ? item.atomControl.get_data() : item;
/*Line 364 - 'AtomItemsControl.js' */                    if (this.isSelected(dataItem)) {
/*Line 365 - 'AtomItemsControl.js' */                        item.scrollIntoView();
/*Line 366 - 'AtomItemsControl.js' */                        return;
/*Line 367 - 'AtomItemsControl.js' */                    }
/*Line 368 - 'AtomItemsControl.js' */                }
/*Line 369 - 'AtomItemsControl.js' */            },

/*Line 371 - 'AtomItemsControl.js' */            updateSelectionBindings: function () {
/*Line 372 - 'AtomItemsControl.js' */                AtomBinder.refreshValue(this, "value");
/*Line 373 - 'AtomItemsControl.js' */                AtomBinder.refreshValue(this, "selectedItem");
/*Line 374 - 'AtomItemsControl.js' */                AtomBinder.refreshValue(this, "selectedItems");
/*Line 375 - 'AtomItemsControl.js' */                AtomBinder.refreshValue(this, "selectedIndex");
/*Line 376 - 'AtomItemsControl.js' */                if (!this._selectedItems.length) {
/*Line 377 - 'AtomItemsControl.js' */                    if (this._selectAll === true) {
/*Line 378 - 'AtomItemsControl.js' */                        this._selectAll = false;
/*Line 379 - 'AtomItemsControl.js' */                        AtomBinder.refreshValue(this, "selectAll");
/*Line 380 - 'AtomItemsControl.js' */                    }
/*Line 381 - 'AtomItemsControl.js' */                }
/*Line 382 - 'AtomItemsControl.js' */            },

/*Line 384 - 'AtomItemsControl.js' */            onSelectedItemsChanged: function (type, index, item) {
/*Line 385 - 'AtomItemsControl.js' */                if (!this._onUIChanged) {
/*Line 386 - 'AtomItemsControl.js' */                    this.updateChildSelections(type, index, item);
/*Line 387 - 'AtomItemsControl.js' */                    if (this._autoScrollToSelection) {
/*Line 388 - 'AtomItemsControl.js' */                        this.bringSelectionIntoView();
/*Line 389 - 'AtomItemsControl.js' */                    }
/*Line 390 - 'AtomItemsControl.js' */                }
/*Line 391 - 'AtomItemsControl.js' */                this.updateSelectionBindings();
/*Line 392 - 'AtomItemsControl.js' */                this.updateUI();

/*Line 394 - 'AtomItemsControl.js' */                this.invokePost();
/*Line 395 - 'AtomItemsControl.js' */            },


/*Line 398 - 'AtomItemsControl.js' */            hasItems: function () {
/*Line 399 - 'AtomItemsControl.js' */                return this._items != undefined && this._items != null;
/*Line 400 - 'AtomItemsControl.js' */            },

/*Line 402 - 'AtomItemsControl.js' */            get_items: function () {
/*Line 403 - 'AtomItemsControl.js' */                return this._items;
/*Line 404 - 'AtomItemsControl.js' */            },
/*Line 405 - 'AtomItemsControl.js' */            set_items: function (v) {
/*Line 406 - 'AtomItemsControl.js' */                var _this = this;
/*Line 407 - 'AtomItemsControl.js' */                if (this._items) {
/*Line 408 - 'AtomItemsControl.js' */                    this.unbindEvent(this._items, "CollectionChanged", null);
/*Line 409 - 'AtomItemsControl.js' */                }
/*Line 410 - 'AtomItemsControl.js' */                this._items = v;
/*Line 411 - 'AtomItemsControl.js' */                this._filteredItems = null;
/*Line 412 - 'AtomItemsControl.js' */                // try starting observing....
/*Line 413 - 'AtomItemsControl.js' */                if (v != null) {
/*Line 414 - 'AtomItemsControl.js' */                    this.bindEvent(this._items, "CollectionChanged", function () {
/*Line 415 - 'AtomItemsControl.js' */                        _this.onCollectionChangedInternal.apply(_this, arguments);
/*Line 416 - 'AtomItemsControl.js' */                    });
/*Line 417 - 'AtomItemsControl.js' */                    this.onCollectionChangedInternal("refresh", -1, null);
/*Line 418 - 'AtomItemsControl.js' */                }
/*Line 419 - 'AtomItemsControl.js' */            },
/*Line 420 - 'AtomItemsControl.js' */            set_itemTemplate: function (v) {
/*Line 421 - 'AtomItemsControl.js' */                this._itemTemplate = v;
/*Line 422 - 'AtomItemsControl.js' */                this.onCollectionChangedInternal("refresh", -1, null);
/*Line 423 - 'AtomItemsControl.js' */            },

/*Line 425 - 'AtomItemsControl.js' */            onCollectionChangedInternal: function (mode, index, item) {
/*Line 426 - 'AtomItemsControl.js' */                if (!this._created)
/*Line 427 - 'AtomItemsControl.js' */                    return;

/*Line 429 - 'AtomItemsControl.js' */                Atom.refresh(this, "allValues");

/*Line 431 - 'AtomItemsControl.js' */                var value = this.get_value();

/*Line 433 - 'AtomItemsControl.js' */                if (this.hasItems()) {
/*Line 434 - 'AtomItemsControl.js' */                    this.onCollectionChanged(mode, index, item);
/*Line 435 - 'AtomItemsControl.js' */                    //this._selectedItems.length = 0;
/*Line 436 - 'AtomItemsControl.js' */                    if (!(value || this._allowSelectFirst)) {
/*Line 437 - 'AtomItemsControl.js' */                        AtomBinder.clear(this._selectedItems);
/*Line 438 - 'AtomItemsControl.js' */                    }
/*Line 439 - 'AtomItemsControl.js' */                }


/*Line 442 - 'AtomItemsControl.js' */                if (value != null) {
/*Line 443 - 'AtomItemsControl.js' */                    this.set_value(value);
/*Line 444 - 'AtomItemsControl.js' */                    if (this.get_selectedIndex() != -1) {
/*Line 445 - 'AtomItemsControl.js' */                        return;
/*Line 446 - 'AtomItemsControl.js' */                    } else {
/*Line 447 - 'AtomItemsControl.js' */                        this._value = undefined;
/*Line 448 - 'AtomItemsControl.js' */                    }
/*Line 449 - 'AtomItemsControl.js' */                }

/*Line 451 - 'AtomItemsControl.js' */                this.selectDefault();

/*Line 453 - 'AtomItemsControl.js' */            },

/*Line 455 - 'AtomItemsControl.js' */            selectDefault: function () {


/*Line 458 - 'AtomItemsControl.js' */                if (this._allowSelectFirst) {
/*Line 459 - 'AtomItemsControl.js' */                    if (this.get_dataItems().length > 0) {
/*Line 460 - 'AtomItemsControl.js' */                        this.set_selectedIndex(0);
/*Line 461 - 'AtomItemsControl.js' */                        return;
/*Line 462 - 'AtomItemsControl.js' */                    }
/*Line 463 - 'AtomItemsControl.js' */                }

/*Line 465 - 'AtomItemsControl.js' */                this.updateSelectionBindings();
/*Line 466 - 'AtomItemsControl.js' */            },

/*Line 468 - 'AtomItemsControl.js' */            onScroll: function () {
/*Line 469 - 'AtomItemsControl.js' */                if (this.scrollTimeout) {
/*Line 470 - 'AtomItemsControl.js' */                    clearTimeout(this.scrollTimeout);
/*Line 471 - 'AtomItemsControl.js' */                }
/*Line 472 - 'AtomItemsControl.js' */                var _this = this;
/*Line 473 - 'AtomItemsControl.js' */                this.scrollTimeout = setTimeout(function () {
/*Line 474 - 'AtomItemsControl.js' */                    _this.scrollTimeout = 0;
/*Line 475 - 'AtomItemsControl.js' */                    _this.onVirtualCollectionChanged();
/*Line 476 - 'AtomItemsControl.js' */                }, 10);
/*Line 477 - 'AtomItemsControl.js' */            },

/*Line 479 - 'AtomItemsControl.js' */            validateScroller: function () {

/*Line 481 - 'AtomItemsControl.js' */                if (this._scrollerSetup)
/*Line 482 - 'AtomItemsControl.js' */                    return;

/*Line 484 - 'AtomItemsControl.js' */                var ip = this._itemsPresenter;
/*Line 485 - 'AtomItemsControl.js' */                var e = this._element;


/*Line 488 - 'AtomItemsControl.js' */                var vc = this._virtualContainer;
/*Line 489 - 'AtomItemsControl.js' */                if (!vc) {
/*Line 490 - 'AtomItemsControl.js' */                    if (ip == e || /table/i.test(e.nodeName)) {
/*Line 491 - 'AtomItemsControl.js' */                        throw new Error("virtualContainer presenter not found, you must put itemsPresenter inside a virtualContainer in order for Virtualization to work");
/*Line 492 - 'AtomItemsControl.js' */                    } else {
/*Line 493 - 'AtomItemsControl.js' */                        vc = this._virtualContainer = this._element;
/*Line 494 - 'AtomItemsControl.js' */                    }
/*Line 495 - 'AtomItemsControl.js' */                }

/*Line 497 - 'AtomItemsControl.js' */                var $vc = $(vc);
/*Line 498 - 'AtomItemsControl.js' */                $vc.css({
/*Line 499 - 'AtomItemsControl.js' */                    overflow: "auto"
/*Line 500 - 'AtomItemsControl.js' */                });

/*Line 502 - 'AtomItemsControl.js' */                this.bindEvent(vc, "scroll","onScroll");

/*Line 504 - 'AtomItemsControl.js' */                var $ip = $(ip);
/*Line 505 - 'AtomItemsControl.js' */                $ip.css({
/*Line 506 - 'AtomItemsControl.js' */                    overflow: "hidden"
/*Line 507 - 'AtomItemsControl.js' */                });

/*Line 509 - 'AtomItemsControl.js' */                //this.validateScroller = null;

/*Line 511 - 'AtomItemsControl.js' */                var isTable = /tbody/i.test(ip.nodeName);

/*Line 513 - 'AtomItemsControl.js' */                var fc, lc;

/*Line 515 - 'AtomItemsControl.js' */                if (isTable) {
/*Line 516 - 'AtomItemsControl.js' */                    fc = document.createElement("TR");
/*Line 517 - 'AtomItemsControl.js' */                    lc = document.createElement("TR");
/*Line 518 - 'AtomItemsControl.js' */                } else {
/*Line 519 - 'AtomItemsControl.js' */                    fc = document.createElement("DIV");
/*Line 520 - 'AtomItemsControl.js' */                    lc = document.createElement("DIV");
/*Line 521 - 'AtomItemsControl.js' */                }

/*Line 523 - 'AtomItemsControl.js' */                $(fc).addClass("sticky first-child").css({ posiiton:"relative", height: 0, width: "100%", clear: "both" });
/*Line 524 - 'AtomItemsControl.js' */                $(lc).addClass("sticky last-child").css({ posiiton:"relative", height: 0, width: "100%", clear: "both" });

/*Line 526 - 'AtomItemsControl.js' */                this._firstChild = fc;
/*Line 527 - 'AtomItemsControl.js' */                this._lastChild = lc;

/*Line 529 - 'AtomItemsControl.js' */                ip.appendChild(fc);
/*Line 530 - 'AtomItemsControl.js' */                ip.appendChild(lc);

/*Line 532 - 'AtomItemsControl.js' */                // let us train ourselves to find average height/width
/*Line 533 - 'AtomItemsControl.js' */                this._training = true;
/*Line 534 - 'AtomItemsControl.js' */                this._scrollerSetup = true;

/*Line 536 - 'AtomItemsControl.js' */            },

/*Line 538 - 'AtomItemsControl.js' */            postVirtualCollectionChanged: function () {
/*Line 539 - 'AtomItemsControl.js' */                var self = this;
/*Line 540 - 'AtomItemsControl.js' */                WebAtoms.dispatcher.callLater(function () {
/*Line 541 - 'AtomItemsControl.js' */                    self.onVirtualCollectionChanged();
/*Line 542 - 'AtomItemsControl.js' */                });
/*Line 543 - 'AtomItemsControl.js' */            },

/*Line 545 - 'AtomItemsControl.js' */            resetVirtulContainer: function () {
/*Line 546 - 'AtomItemsControl.js' */                if (this._itemsPresenter) {
/*Line 547 - 'AtomItemsControl.js' */                    this.disposeChildren(this._itemsPresenter);
/*Line 548 - 'AtomItemsControl.js' */                }
/*Line 549 - 'AtomItemsControl.js' */                this._firstChild = null;
/*Line 550 - 'AtomItemsControl.js' */                this._lastChild = null;
/*Line 551 - 'AtomItemsControl.js' */                this._scrollerSetup = false;
/*Line 552 - 'AtomItemsControl.js' */                this._scopes = null;
/*Line 553 - 'AtomItemsControl.js' */                this.unbindEvent(this._virtualContainer, "scroll");
/*Line 554 - 'AtomItemsControl.js' */            },

/*Line 556 - 'AtomItemsControl.js' */            onVirtualCollectionChanged: function () {



/*Line 560 - 'AtomItemsControl.js' */                var ip = this._itemsPresenter;

/*Line 562 - 'AtomItemsControl.js' */                var items = this.get_dataItems();
/*Line 563 - 'AtomItemsControl.js' */                if (!items.length) {
/*Line 564 - 'AtomItemsControl.js' */                    this.resetVirtulContainer();
/*Line 565 - 'AtomItemsControl.js' */                    return;
/*Line 566 - 'AtomItemsControl.js' */                }



/*Line 570 - 'AtomItemsControl.js' */                this.validateScroller();

/*Line 572 - 'AtomItemsControl.js' */                var $ip = $(ip);

/*Line 574 - 'AtomItemsControl.js' */                var fc = this._firstChild;
/*Line 575 - 'AtomItemsControl.js' */                var lc = this._lastChild;

/*Line 577 - 'AtomItemsControl.js' */                var $fc = $(fc);
/*Line 578 - 'AtomItemsControl.js' */                var $lc = $(lc);

/*Line 580 - 'AtomItemsControl.js' */                var vc = this._virtualContainer;
/*Line 581 - 'AtomItemsControl.js' */                var $vc = $(vc);

/*Line 583 - 'AtomItemsControl.js' */                var vcHeight = $vc.innerHeight();
/*Line 584 - 'AtomItemsControl.js' */                var vcScrollHeight = vc.scrollHeight;

/*Line 586 - 'AtomItemsControl.js' */                if ( isNaN(vcHeight) || vcHeight <= 0 || vcScrollHeight <= 0) {
/*Line 587 - 'AtomItemsControl.js' */                    // leave it..
/*Line 588 - 'AtomItemsControl.js' */                    var self = this;
/*Line 589 - 'AtomItemsControl.js' */                    setTimeout(function () {
/*Line 590 - 'AtomItemsControl.js' */                        self.onVirtualCollectionChanged();
/*Line 591 - 'AtomItemsControl.js' */                    }, 1000);
/*Line 592 - 'AtomItemsControl.js' */                    return;
/*Line 593 - 'AtomItemsControl.js' */                }

/*Line 595 - 'AtomItemsControl.js' */                var vcWidth = $vc.innerWidth();

/*Line 597 - 'AtomItemsControl.js' */                var avgHeight = this._avgHeight;
/*Line 598 - 'AtomItemsControl.js' */                var avgWidth = this._avgWidth;

/*Line 600 - 'AtomItemsControl.js' */                var itemsHeight = vc.scrollHeight - $fc.outerHeight() - $lc.outerHeight();
/*Line 601 - 'AtomItemsControl.js' */                var itemsWidth = $ip.innerWidth();

/*Line 603 - 'AtomItemsControl.js' */                var parentScope = this.get_scope();

/*Line 605 - 'AtomItemsControl.js' */                var element = this._element;

/*Line 607 - 'AtomItemsControl.js' */                var ae = new AtomEnumerator(items);


/*Line 610 - 'AtomItemsControl.js' */                if (this._training) {
/*Line 611 - 'AtomItemsControl.js' */                    if (vcHeight >= itemsHeight) {
/*Line 612 - 'AtomItemsControl.js' */                        // lets add item...
/*Line 613 - 'AtomItemsControl.js' */                        var ce = lc.previousElementSibling;
/*Line 614 - 'AtomItemsControl.js' */                        var index = 0;
/*Line 615 - 'AtomItemsControl.js' */                        if (ce != fc) {
/*Line 616 - 'AtomItemsControl.js' */                            var data = ce.atomControl.get_data();
/*Line 617 - 'AtomItemsControl.js' */                            while (ae.next()) {
/*Line 618 - 'AtomItemsControl.js' */                                if (ae.current() == data) break;
/*Line 619 - 'AtomItemsControl.js' */                            };
/*Line 620 - 'AtomItemsControl.js' */                        }

/*Line 622 - 'AtomItemsControl.js' */                        if (ae.next()) {
/*Line 623 - 'AtomItemsControl.js' */                            var data = ae.current();
/*Line 624 - 'AtomItemsControl.js' */                            var elementChild = this.createChildElement(parentScope, null, data, ae);
/*Line 625 - 'AtomItemsControl.js' */                            //WebAtoms.dispatcher.callLater(function () { 
/*Line 626 - 'AtomItemsControl.js' */                            ip.insertBefore(elementChild,lc);
/*Line 627 - 'AtomItemsControl.js' */                            //});
/*Line 628 - 'AtomItemsControl.js' */                            this.applyItemStyle(elementChild, data, ae.isFirst(), ae.isLast());
/*Line 629 - 'AtomItemsControl.js' */                            this.postVirtualCollectionChanged();
/*Line 630 - 'AtomItemsControl.js' */                        }
/*Line 631 - 'AtomItemsControl.js' */                    } else {

/*Line 633 - 'AtomItemsControl.js' */                        // calculate avg height
/*Line 634 - 'AtomItemsControl.js' */                        var totalVisibleItems = 0;
/*Line 635 - 'AtomItemsControl.js' */                        var ce = fc.nextElementSibling;
/*Line 636 - 'AtomItemsControl.js' */                        var allHeight = 0;
/*Line 637 - 'AtomItemsControl.js' */                        var allWidth = 0;
/*Line 638 - 'AtomItemsControl.js' */                        while (ce != lc) {
/*Line 639 - 'AtomItemsControl.js' */                            totalVisibleItems++;
/*Line 640 - 'AtomItemsControl.js' */                            allHeight += $(ce).outerHeight(true);
/*Line 641 - 'AtomItemsControl.js' */                            allWidth += $(ce).outerWidth(true);
/*Line 642 - 'AtomItemsControl.js' */                            ce = ce.nextElementSibling;
/*Line 643 - 'AtomItemsControl.js' */                        }
/*Line 644 - 'AtomItemsControl.js' */                        avgHeight = allHeight / totalVisibleItems;
/*Line 645 - 'AtomItemsControl.js' */                        avgWidth = allWidth / totalVisibleItems;
/*Line 646 - 'AtomItemsControl.js' */                        totalVisibleItems--;
/*Line 647 - 'AtomItemsControl.js' */                        this._avgHeight = avgHeight;
/*Line 648 - 'AtomItemsControl.js' */                        this._avgWidth = avgWidth;

/*Line 650 - 'AtomItemsControl.js' */                        var columns = Math.floor(vcWidth / avgWidth);
/*Line 651 - 'AtomItemsControl.js' */                        var allRows = Math.ceil(items.length / columns);
/*Line 652 - 'AtomItemsControl.js' */                        var visibleRows = Math.ceil(totalVisibleItems / columns);

/*Line 654 - 'AtomItemsControl.js' */                        console.log({
/*Line 655 - 'AtomItemsControl.js' */                            avgWidth:avgWidth,
/*Line 656 - 'AtomItemsControl.js' */                            avgHeight: avgHeight,
/*Line 657 - 'AtomItemsControl.js' */                            totalVisibleItems: totalVisibleItems,
/*Line 658 - 'AtomItemsControl.js' */                            allRows: allRows,
/*Line 659 - 'AtomItemsControl.js' */                            columns: columns
/*Line 660 - 'AtomItemsControl.js' */                        });

/*Line 662 - 'AtomItemsControl.js' */                        //this._visibleBlock = visibleRows * avgHeight;
/*Line 663 - 'AtomItemsControl.js' */                        //this._itemsInBlock = totalVisibleItems;
/*Line 664 - 'AtomItemsControl.js' */                        this._allRows = allRows;
/*Line 665 - 'AtomItemsControl.js' */                        this._columns = columns;


/*Line 668 - 'AtomItemsControl.js' */                        //this._allRows = allRows;
/*Line 669 - 'AtomItemsControl.js' */                        this._visibleRows = visibleRows;
/*Line 670 - 'AtomItemsControl.js' */                        this._visibleHeight = visibleRows * avgHeight;

/*Line 672 - 'AtomItemsControl.js' */                        // set height of last child... to increase padding
/*Line 673 - 'AtomItemsControl.js' */                        $lc.css({
/*Line 674 - 'AtomItemsControl.js' */                            height: ((allRows-visibleRows+1) * avgHeight) + "px"
/*Line 675 - 'AtomItemsControl.js' */                        });
/*Line 676 - 'AtomItemsControl.js' */                        this._training = false;
/*Line 677 - 'AtomItemsControl.js' */                        this._ready = true;
/*Line 678 - 'AtomItemsControl.js' */                        this.postVirtualCollectionChanged();
/*Line 679 - 'AtomItemsControl.js' */                    }
/*Line 680 - 'AtomItemsControl.js' */                    return;

/*Line 682 - 'AtomItemsControl.js' */                }

/*Line 684 - 'AtomItemsControl.js' */                var self = this;

/*Line 686 - 'AtomItemsControl.js' */                this.lastScrollTop = vc.scrollTop;

/*Line 688 - 'AtomItemsControl.js' */                if (this._isChanging) {
/*Line 689 - 'AtomItemsControl.js' */                    //setTimeout(function () {
/*Line 690 - 'AtomItemsControl.js' */                    //    self.onVirtualCollectionChanged();
/*Line 691 - 'AtomItemsControl.js' */                    //}, 100);
/*Line 692 - 'AtomItemsControl.js' */                    return;
/*Line 693 - 'AtomItemsControl.js' */                }
/*Line 694 - 'AtomItemsControl.js' */                this._isChanging = true;

/*Line 696 - 'AtomItemsControl.js' */                var block = Math.floor(this._visibleHeight / avgHeight);
/*Line 697 - 'AtomItemsControl.js' */                var itemsInBlock = this._visibleRows * this._columns;

/*Line 699 - 'AtomItemsControl.js' */                // lets simply recreate the view... if we are out of the scroll bounds... 
/*Line 700 - 'AtomItemsControl.js' */                var index = Math.floor(vc.scrollTop / this._visibleHeight);
/*Line 701 - 'AtomItemsControl.js' */                var itemIndex = index * itemsInBlock;
/*Line 702 - 'AtomItemsControl.js' */                //console.log("First block index is " + index + " item index is " + index * itemsInBlock);

/*Line 704 - 'AtomItemsControl.js' */                if (itemIndex >= items.length) {
/*Line 705 - 'AtomItemsControl.js' */                    this._isChanging = false;
/*Line 706 - 'AtomItemsControl.js' */                    return;
/*Line 707 - 'AtomItemsControl.js' */                }

/*Line 709 - 'AtomItemsControl.js' */                var lastIndex = (Math.max(index,0) + 3 ) * itemsInBlock - 1;
/*Line 710 - 'AtomItemsControl.js' */                var firstIndex =  Math.max(0, (index) * itemsInBlock);

/*Line 712 - 'AtomItemsControl.js' */                var ce = fc.nextElementSibling;

/*Line 714 - 'AtomItemsControl.js' */                var firstItem = fc.nextElementSibling;
/*Line 715 - 'AtomItemsControl.js' */                var lastItem = lc.previousElementSibling;

/*Line 717 - 'AtomItemsControl.js' */                if (firstItem != lastItem) {
/*Line 718 - 'AtomItemsControl.js' */                    var firstVisibleIndex = firstItem.atomControl.get_scope().itemIndex;
/*Line 719 - 'AtomItemsControl.js' */                    var lastVisibleIndex = lastItem.atomControl.get_scope().itemIndex;
/*Line 720 - 'AtomItemsControl.js' */                    console.log({
/*Line 721 - 'AtomItemsControl.js' */                        firstVisibleIndex: firstVisibleIndex,
/*Line 722 - 'AtomItemsControl.js' */                        firstIndex: firstIndex,
/*Line 723 - 'AtomItemsControl.js' */                        lastVisibleIndex: lastVisibleIndex,
/*Line 724 - 'AtomItemsControl.js' */                        lastIndex: lastIndex
/*Line 725 - 'AtomItemsControl.js' */                    });
/*Line 726 - 'AtomItemsControl.js' */                    if (firstIndex >= firstVisibleIndex && lastIndex <= lastVisibleIndex) {
/*Line 727 - 'AtomItemsControl.js' */                        console.log("All items are visible...");
/*Line 728 - 'AtomItemsControl.js' */                        this._isChanging = false;
/*Line 729 - 'AtomItemsControl.js' */                        return;
/*Line 730 - 'AtomItemsControl.js' */                    }
/*Line 731 - 'AtomItemsControl.js' */                }

/*Line 733 - 'AtomItemsControl.js' */                var remove = [];
/*Line 734 - 'AtomItemsControl.js' */                var cache = {};

/*Line 736 - 'AtomItemsControl.js' */                while (ce != lc) {
/*Line 737 - 'AtomItemsControl.js' */                    var c = ce;
/*Line 738 - 'AtomItemsControl.js' */                    ce = ce.nextElementSibling;
/*Line 739 - 'AtomItemsControl.js' */                    var s = c.atomControl.get_scope().itemIndex;
/*Line 740 - 'AtomItemsControl.js' */                    cache[s] = c;
/*Line 741 - 'AtomItemsControl.js' */                    //c.atomControl.dispose();
/*Line 742 - 'AtomItemsControl.js' */                    //c.remove();
/*Line 743 - 'AtomItemsControl.js' */                    remove.push(c);
/*Line 744 - 'AtomItemsControl.js' */                }

/*Line 746 - 'AtomItemsControl.js' */                WebAtoms.dispatcher.pause();


/*Line 749 - 'AtomItemsControl.js' */                var ae = new AtomEnumerator(items);
/*Line 750 - 'AtomItemsControl.js' */                for (var i = 0; i < firstIndex; i++) {
/*Line 751 - 'AtomItemsControl.js' */                    ae.next();
/*Line 752 - 'AtomItemsControl.js' */                }


/*Line 755 - 'AtomItemsControl.js' */                var after = fc;

/*Line 757 - 'AtomItemsControl.js' */                var last = null;

/*Line 759 - 'AtomItemsControl.js' */                var add = [];

/*Line 761 - 'AtomItemsControl.js' */                for (var i = firstIndex; i <= lastIndex; i++) {
/*Line 762 - 'AtomItemsControl.js' */                    if (!ae.next())
/*Line 763 - 'AtomItemsControl.js' */                        break;
/*Line 764 - 'AtomItemsControl.js' */                    var index2 = ae.currentIndex();
/*Line 765 - 'AtomItemsControl.js' */                    var data = ae.current();
/*Line 766 - 'AtomItemsControl.js' */                    var elementChild = cache[index2];
/*Line 767 - 'AtomItemsControl.js' */                    if (elementChild && element.atomControl.get_data() == data) {
/*Line 768 - 'AtomItemsControl.js' */                        cache[index2] = null;
/*Line 769 - 'AtomItemsControl.js' */                    } else {
/*Line 770 - 'AtomItemsControl.js' */                        elementChild = this.createChildElement(parentScope, null, data, ae);
/*Line 771 - 'AtomItemsControl.js' */                    }
/*Line 772 - 'AtomItemsControl.js' */                    elementChild.before = after;
/*Line 773 - 'AtomItemsControl.js' */                    add.push(elementChild);
/*Line 774 - 'AtomItemsControl.js' */                    after = elementChild;
/*Line 775 - 'AtomItemsControl.js' */                    this.applyItemStyle(elementChild, data, ae.isFirst(), ae.isLast());
/*Line 776 - 'AtomItemsControl.js' */                    last = index2;
/*Line 777 - 'AtomItemsControl.js' */                }


/*Line 780 - 'AtomItemsControl.js' */                var h = (this._allRows - block * 3) * avgHeight -  index * this._visibleHeight;
/*Line 781 - 'AtomItemsControl.js' */                console.log("last child height = " + h);

/*Line 783 - 'AtomItemsControl.js' */                WebAtoms.dispatcher.callLater(function () {

/*Line 785 - 'AtomItemsControl.js' */                    var oldHeight = $fc.height();
/*Line 786 - 'AtomItemsControl.js' */                    var newHeight = index * self._visibleHeight;

/*Line 788 - 'AtomItemsControl.js' */                    var diff = newHeight - oldHeight;
/*Line 789 - 'AtomItemsControl.js' */                    var oldScrollTop = vc.scrollTop;



/*Line 793 - 'AtomItemsControl.js' */                    var a = new AtomEnumerator(add);
/*Line 794 - 'AtomItemsControl.js' */                    while (a.next()) {
/*Line 795 - 'AtomItemsControl.js' */                        var ec = a.current();
/*Line 796 - 'AtomItemsControl.js' */                        ip.insertBefore(ec, ec.before.nextElementSibling);
/*Line 797 - 'AtomItemsControl.js' */                        ec.before = null;
/*Line 798 - 'AtomItemsControl.js' */                    }

/*Line 800 - 'AtomItemsControl.js' */                    $fc.css({
/*Line 801 - 'AtomItemsControl.js' */                        height: newHeight
/*Line 802 - 'AtomItemsControl.js' */                    });

/*Line 804 - 'AtomItemsControl.js' */                    a = new AtomEnumerator(remove);
/*Line 805 - 'AtomItemsControl.js' */                    while (a.next()) {
/*Line 806 - 'AtomItemsControl.js' */                        var ec = a.current();
/*Line 807 - 'AtomItemsControl.js' */                        if (!ec.before) {
/*Line 808 - 'AtomItemsControl.js' */                            ec.atomControl.dispose();
/*Line 809 - 'AtomItemsControl.js' */                        }
/*Line 810 - 'AtomItemsControl.js' */                        ec.remove();
/*Line 811 - 'AtomItemsControl.js' */                    }


/*Line 814 - 'AtomItemsControl.js' */                    //vc.scrollTop = oldScrollTop - diff;


/*Line 817 - 'AtomItemsControl.js' */                    $lc.css({
/*Line 818 - 'AtomItemsControl.js' */                        height:  h
/*Line 819 - 'AtomItemsControl.js' */                    });


/*Line 822 - 'AtomItemsControl.js' */                    console.log("Old: " + oldScrollTop + " Diff: " + diff + " Old Height: " + oldHeight + " Height: " + newHeight);

/*Line 824 - 'AtomItemsControl.js' */                    self._isChanging = false;

/*Line 826 - 'AtomItemsControl.js' */                });
/*Line 827 - 'AtomItemsControl.js' */                WebAtoms.dispatcher.start();

/*Line 829 - 'AtomItemsControl.js' */                AtomBinder.refreshValue(this, "childAtomControls");
/*Line 830 - 'AtomItemsControl.js' */            },

/*Line 832 - 'AtomItemsControl.js' */            onCollectionChanged: function (mode, index, item) {

/*Line 834 - 'AtomItemsControl.js' */                if (/reset|refresh/i.test(mode)) {
/*Line 835 - 'AtomItemsControl.js' */                    this.resetVirtulContainer();
/*Line 836 - 'AtomItemsControl.js' */                }


/*Line 839 - 'AtomItemsControl.js' */                // just reset for now...
/*Line 840 - 'AtomItemsControl.js' */                if (/remove/gi.test(mode)) {
/*Line 841 - 'AtomItemsControl.js' */                    // simply delete and remove...
/*Line 842 - 'AtomItemsControl.js' */                    var ce = new ChildEnumerator(this._itemsPresenter);
/*Line 843 - 'AtomItemsControl.js' */                    while (ce.next()) {
/*Line 844 - 'AtomItemsControl.js' */                        var c = ce.current();
/*Line 845 - 'AtomItemsControl.js' */                        if (c.atomControl && c.atomControl.get_data() == item) {
/*Line 846 - 'AtomItemsControl.js' */                            c.atomControl.dispose();
/*Line 847 - 'AtomItemsControl.js' */                            $(c).remove();
/*Line 848 - 'AtomItemsControl.js' */                            break;
/*Line 849 - 'AtomItemsControl.js' */                        }
/*Line 850 - 'AtomItemsControl.js' */                    }
/*Line 851 - 'AtomItemsControl.js' */                    this.updateUI();
/*Line 852 - 'AtomItemsControl.js' */                    return;
/*Line 853 - 'AtomItemsControl.js' */                }

/*Line 855 - 'AtomItemsControl.js' */                if (this._uiVirtualize) {
/*Line 856 - 'AtomItemsControl.js' */                    this.onVirtualCollectionChanged();
/*Line 857 - 'AtomItemsControl.js' */                    return;
/*Line 858 - 'AtomItemsControl.js' */                }

/*Line 860 - 'AtomItemsControl.js' */                var parentScope = this.get_scope();

/*Line 862 - 'AtomItemsControl.js' */                var et = this.getTemplate("itemTemplate");
/*Line 863 - 'AtomItemsControl.js' */                if (et) {
/*Line 864 - 'AtomItemsControl.js' */                    et = AtomUI.getAtomType(et);
/*Line 865 - 'AtomItemsControl.js' */                    if (et) {
/*Line 866 - 'AtomItemsControl.js' */                        this._childItemType = et;
/*Line 867 - 'AtomItemsControl.js' */                    }
/*Line 868 - 'AtomItemsControl.js' */                }

/*Line 870 - 'AtomItemsControl.js' */                if (/add/gi.test(mode)) {
/*Line 871 - 'AtomItemsControl.js' */                    WebAtoms.dispatcher.pause();

/*Line 873 - 'AtomItemsControl.js' */                    var ae = new AtomEnumerator(this._items);
/*Line 874 - 'AtomItemsControl.js' */                    var ce = new ChildEnumerator(this._itemsPresenter);
/*Line 875 - 'AtomItemsControl.js' */                    while (ae.next()) {
/*Line 876 - 'AtomItemsControl.js' */                        ce.next();
/*Line 877 - 'AtomItemsControl.js' */                        var c = ce.current();
/*Line 878 - 'AtomItemsControl.js' */                        if (ae.currentIndex() == index) {
/*Line 879 - 'AtomItemsControl.js' */                            var ctrl = this.createChildElement(parentScope, this._itemsPresenter, item, ae, c);
/*Line 880 - 'AtomItemsControl.js' */                            this.applyItemStyle(ctrl, item, ae.isFirst(), ae.isLast());
/*Line 881 - 'AtomItemsControl.js' */                            break;
/*Line 882 - 'AtomItemsControl.js' */                        }
/*Line 883 - 'AtomItemsControl.js' */                        if (ae.isLast()) {
/*Line 884 - 'AtomItemsControl.js' */                            var ctrl = this.createChildElement(parentScope, this._itemsPresenter, item, ae);
/*Line 885 - 'AtomItemsControl.js' */                            this.applyItemStyle(ctrl, item, ae.isFirst(), ae.isLast());
/*Line 886 - 'AtomItemsControl.js' */                            break;
/*Line 887 - 'AtomItemsControl.js' */                        }
/*Line 888 - 'AtomItemsControl.js' */                    }

/*Line 890 - 'AtomItemsControl.js' */                    WebAtoms.dispatcher.start();
/*Line 891 - 'AtomItemsControl.js' */                    this.updateUI();
/*Line 892 - 'AtomItemsControl.js' */                    return;
/*Line 893 - 'AtomItemsControl.js' */                }

/*Line 895 - 'AtomItemsControl.js' */                var element = this._itemsPresenter;

/*Line 897 - 'AtomItemsControl.js' */                var dataItems = this.get_dataItems();


/*Line 900 - 'AtomItemsControl.js' */                //AtomUI.removeAllChildren(element);
/*Line 901 - 'AtomItemsControl.js' */                this.disposeChildren(element);
/*Line 902 - 'AtomItemsControl.js' */                //this._dataElements.length = 0;
/*Line 903 - 'AtomItemsControl.js' */                // rebuild from template...

/*Line 905 - 'AtomItemsControl.js' */                WebAtoms.dispatcher.pause();

/*Line 907 - 'AtomItemsControl.js' */                // implement stock...


/*Line 910 - 'AtomItemsControl.js' */                var items = this.get_dataItems(true);

/*Line 912 - 'AtomItemsControl.js' */                var added = [];

/*Line 914 - 'AtomItemsControl.js' */                var ae = new AtomEnumerator(items);


/*Line 917 - 'AtomItemsControl.js' */                    this.getTemplate("itemTemplate");

/*Line 919 - 'AtomItemsControl.js' */                    while (ae.next()) {
/*Line 920 - 'AtomItemsControl.js' */                        var data = ae.current();
/*Line 921 - 'AtomItemsControl.js' */                        var elementChild = this.createChildElement(parentScope, element, data, ae);
/*Line 922 - 'AtomItemsControl.js' */                        added.push(elementChild);
/*Line 923 - 'AtomItemsControl.js' */                        this.applyItemStyle(elementChild, data, ae.isFirst(), ae.isLast());
/*Line 924 - 'AtomItemsControl.js' */                    }


/*Line 927 - 'AtomItemsControl.js' */                    //var ae = new AtomEnumerator(items);
/*Line 928 - 'AtomItemsControl.js' */                    //while (ae.next()) {
/*Line 929 - 'AtomItemsControl.js' */                    //    var data = ae.current();
/*Line 930 - 'AtomItemsControl.js' */                    //    var elementChild = this.createChildElement(parentScope, element, data, ae);
/*Line 931 - 'AtomItemsControl.js' */                    //    this.applyItemStyle(elementChild, data, ae.isFirst(), ae.isLast());
/*Line 932 - 'AtomItemsControl.js' */                    //}
/*Line 933 - 'AtomItemsControl.js' */                    var self = this;
/*Line 934 - 'AtomItemsControl.js' */                    WebAtoms.dispatcher.callLater(function () {
/*Line 935 - 'AtomItemsControl.js' */                        var dirty = [];
/*Line 936 - 'AtomItemsControl.js' */                        var ce = new ChildEnumerator(element);
/*Line 937 - 'AtomItemsControl.js' */                        while (ce.next()) {
/*Line 938 - 'AtomItemsControl.js' */                            var item = ce.current();
/*Line 939 - 'AtomItemsControl.js' */                            var f = added.filter(function (fx) { return item == fx; });
/*Line 940 - 'AtomItemsControl.js' */                            if (f.pop() != item) {
/*Line 941 - 'AtomItemsControl.js' */                                dirty.push(item);
/*Line 942 - 'AtomItemsControl.js' */                            }
/*Line 943 - 'AtomItemsControl.js' */                        }
/*Line 944 - 'AtomItemsControl.js' */                        ce = new AtomEnumerator(dirty);
/*Line 945 - 'AtomItemsControl.js' */                        while (ce.next()) {
/*Line 946 - 'AtomItemsControl.js' */                            var item = ce.current();
/*Line 947 - 'AtomItemsControl.js' */                            //self.dispose(item);
/*Line 948 - 'AtomItemsControl.js' */                            if (item.atomControl) {
/*Line 949 - 'AtomItemsControl.js' */                                item.atomControl.dispose();
/*Line 950 - 'AtomItemsControl.js' */                            }
/*Line 951 - 'AtomItemsControl.js' */                            $(item).remove();
/*Line 952 - 'AtomItemsControl.js' */                        }

/*Line 954 - 'AtomItemsControl.js' */                    });

                

/*Line 958 - 'AtomItemsControl.js' */                WebAtoms.dispatcher.start();

/*Line 960 - 'AtomItemsControl.js' */                AtomBinder.refreshValue(this, "childAtomControls");


/*Line 963 - 'AtomItemsControl.js' */            },

/*Line 965 - 'AtomItemsControl.js' */            set_innerTemplate: function (v) {
/*Line 966 - 'AtomItemsControl.js' */                this._itemsPresenter = this._element;
/*Line 967 - 'AtomItemsControl.js' */                base.set_innerTemplate.apply(this, arguments);
/*Line 968 - 'AtomItemsControl.js' */                this.onCollectionChangedInternal("mode", -1, null);
/*Line 969 - 'AtomItemsControl.js' */            },

/*Line 971 - 'AtomItemsControl.js' */            applyItemStyle: function (item, dataItem, first, last) {
/*Line 972 - 'AtomItemsControl.js' */            },

/*Line 974 - 'AtomItemsControl.js' */            createChildElement: function (parentScope, parentElement, data, ae, before) {

/*Line 976 - 'AtomItemsControl.js' */                var elementChild = AtomUI.cloneNode(this._itemTemplate);
/*Line 977 - 'AtomItemsControl.js' */                elementChild._logicalParent = parentElement || this._itemsPresenter;
/*Line 978 - 'AtomItemsControl.js' */                elementChild._templateParent = this;
/*Line 979 - 'AtomItemsControl.js' */                elementChild._isDirty = true;

/*Line 981 - 'AtomItemsControl.js' */                if (parentElement) {
/*Line 982 - 'AtomItemsControl.js' */                    WebAtoms.dispatcher.callLater(function () {
/*Line 983 - 'AtomItemsControl.js' */                        if (before) {
/*Line 984 - 'AtomItemsControl.js' */                            parentElement.insertBefore(elementChild, before);
/*Line 985 - 'AtomItemsControl.js' */                        } else {
/*Line 986 - 'AtomItemsControl.js' */                            parentElement.appendChild(elementChild);
/*Line 987 - 'AtomItemsControl.js' */                        }
/*Line 988 - 'AtomItemsControl.js' */                    });
/*Line 989 - 'AtomItemsControl.js' */                }

/*Line 991 - 'AtomItemsControl.js' */                var index = ae ? ae.currentIndex() : -1;
/*Line 992 - 'AtomItemsControl.js' */                var scope = null;

/*Line 994 - 'AtomItemsControl.js' */                if (this._uiVirtualize) {
/*Line 995 - 'AtomItemsControl.js' */                    var scopes = this._scopes || {
/*Line 996 - 'AtomItemsControl.js' */                    };
/*Line 997 - 'AtomItemsControl.js' */                    this._scopes = scopes;

/*Line 999 - 'AtomItemsControl.js' */                    scope = scopes[index] || new AtomScope(this, parentScope, parentScope.__application);
/*Line 1000 - 'AtomItemsControl.js' */                    scopes[index] = scope;
/*Line 1001 - 'AtomItemsControl.js' */                } else {
/*Line 1002 - 'AtomItemsControl.js' */                    scope = new AtomScope(this, parentScope, parentScope.__application);
/*Line 1003 - 'AtomItemsControl.js' */                }

/*Line 1005 - 'AtomItemsControl.js' */                if (ae) {
/*Line 1006 - 'AtomItemsControl.js' */                    scope.itemIsFirst = ae.isFirst();
/*Line 1007 - 'AtomItemsControl.js' */                    scope.itemIsLast = ae.isLast();
/*Line 1008 - 'AtomItemsControl.js' */                    scope.itemIndex = index;
/*Line 1009 - 'AtomItemsControl.js' */                    scope.itemExpanded = false;
/*Line 1010 - 'AtomItemsControl.js' */                    scope.data = data;
/*Line 1011 - 'AtomItemsControl.js' */                    scope.get_itemSelected = function () {
/*Line 1012 - 'AtomItemsControl.js' */                        return scope.owner.isSelected(data);
/*Line 1013 - 'AtomItemsControl.js' */                };
/*Line 1014 - 'AtomItemsControl.js' */                    scope.set_itemSelected = function (v) {
/*Line 1015 - 'AtomItemsControl.js' */                        scope.owner.toggleSelection(data, true);
/*Line 1016 - 'AtomItemsControl.js' */                    };
/*Line 1017 - 'AtomItemsControl.js' */                }

/*Line 1019 - 'AtomItemsControl.js' */                var ac = AtomUI.createControl(elementChild, this._childItemType, data, scope);
/*Line 1020 - 'AtomItemsControl.js' */                return elementChild;
/*Line 1021 - 'AtomItemsControl.js' */            },

/*Line 1023 - 'AtomItemsControl.js' */            toggleSelection: function (data) {
/*Line 1024 - 'AtomItemsControl.js' */                this._onUIChanged = true;
/*Line 1025 - 'AtomItemsControl.js' */                this._value = undefined;
/*Line 1026 - 'AtomItemsControl.js' */                if (this._allowMultipleSelection) {
/*Line 1027 - 'AtomItemsControl.js' */                    if (AtomUI.contains(this._selectedItems, data)) {
/*Line 1028 - 'AtomItemsControl.js' */                        AtomBinder.removeItem(this._selectedItems, data);
/*Line 1029 - 'AtomItemsControl.js' */                    } else {
/*Line 1030 - 'AtomItemsControl.js' */                        AtomBinder.addItem(this._selectedItems, data);
/*Line 1031 - 'AtomItemsControl.js' */                    }
/*Line 1032 - 'AtomItemsControl.js' */                } else {
/*Line 1033 - 'AtomItemsControl.js' */                    this._selectedItems.length = 1;
/*Line 1034 - 'AtomItemsControl.js' */                    this._selectedItems[0] = data;
/*Line 1035 - 'AtomItemsControl.js' */                    AtomBinder.refreshItems(this._selectedItems);
/*Line 1036 - 'AtomItemsControl.js' */                }
/*Line 1037 - 'AtomItemsControl.js' */                this._onUIChanged = false;
/*Line 1038 - 'AtomItemsControl.js' */            },

/*Line 1040 - 'AtomItemsControl.js' */            onUpdateUI: function () {
/*Line 1041 - 'AtomItemsControl.js' */                base.onUpdateUI.call(this);

/*Line 1043 - 'AtomItemsControl.js' */                if (this._uiVirtualize) {
/*Line 1044 - 'AtomItemsControl.js' */                    this.onVirtualCollectionChanged();
/*Line 1045 - 'AtomItemsControl.js' */                }

/*Line 1047 - 'AtomItemsControl.js' */                var ae = new ChildEnumerator(this._itemsPresenter);
/*Line 1048 - 'AtomItemsControl.js' */                while (ae.next()) {
/*Line 1049 - 'AtomItemsControl.js' */                    var item = ae.current();
/*Line 1050 - 'AtomItemsControl.js' */                    if (!item.atomControl)
/*Line 1051 - 'AtomItemsControl.js' */                        continue;
/*Line 1052 - 'AtomItemsControl.js' */                    var dataItem = item.atomControl.get_data();
/*Line 1053 - 'AtomItemsControl.js' */                    AtomBinder.refreshValue(item.atomControl.get_scope(), "itemSelected");
/*Line 1054 - 'AtomItemsControl.js' */                    this.applyItemStyle(item, dataItem, ae.isFirst(), ae.isLast());
/*Line 1055 - 'AtomItemsControl.js' */                }
/*Line 1056 - 'AtomItemsControl.js' */            },

/*Line 1058 - 'AtomItemsControl.js' */            onCreated: function () {


/*Line 1061 - 'AtomItemsControl.js' */                if (this._items) {
/*Line 1062 - 'AtomItemsControl.js' */                    this.onCollectionChangedInternal("refresh", -1, null);
/*Line 1063 - 'AtomItemsControl.js' */                }

/*Line 1065 - 'AtomItemsControl.js' */                var caller = this;

/*Line 1067 - 'AtomItemsControl.js' */                this.dispatcher.callLater(function () {
/*Line 1068 - 'AtomItemsControl.js' */                    if (caller._autoScrollToSelection) {
/*Line 1069 - 'AtomItemsControl.js' */                        caller.bringSelectionIntoView();
/*Line 1070 - 'AtomItemsControl.js' */                    }
/*Line 1071 - 'AtomItemsControl.js' */                });

/*Line 1073 - 'AtomItemsControl.js' */            },

/*Line 1075 - 'AtomItemsControl.js' */            dispose: function () {
/*Line 1076 - 'AtomItemsControl.js' */                this.resetVirtulContainer();
/*Line 1077 - 'AtomItemsControl.js' */                base.dispose.call(this);
/*Line 1078 - 'AtomItemsControl.js' */                //this._selectedItems = null;
/*Line 1079 - 'AtomItemsControl.js' */            },


/*Line 1082 - 'AtomItemsControl.js' */            init: function () {

/*Line 1084 - 'AtomItemsControl.js' */                var element = this.get_element();


/*Line 1087 - 'AtomItemsControl.js' */                // set self as Items Presenter..
/*Line 1088 - 'AtomItemsControl.js' */                if (!this._itemsPresenter) {
/*Line 1089 - 'AtomItemsControl.js' */                    this._itemsPresenter = this._element;
/*Line 1090 - 'AtomItemsControl.js' */                }
/*Line 1091 - 'AtomItemsControl.js' */                else {
/*Line 1092 - 'AtomItemsControl.js' */                    //this._layout = WebAtoms.AtomViewBoxLayout.defaultInstnace;
/*Line 1093 - 'AtomItemsControl.js' */                }

/*Line 1095 - 'AtomItemsControl.js' */                var _this = this;
/*Line 1096 - 'AtomItemsControl.js' */                this.bindEvent(this._selectedItems, "CollectionChanged", function () {
/*Line 1097 - 'AtomItemsControl.js' */                    _this.onSelectedItemsChanged.apply(_this, arguments);
/*Line 1098 - 'AtomItemsControl.js' */                });
/*Line 1099 - 'AtomItemsControl.js' */                base.init.apply(this, arguments);


/*Line 1102 - 'AtomItemsControl.js' */                var caller = this;

/*Line 1104 - 'AtomItemsControl.js' */                this.removeItemCommand = function (scope, sender) {
/*Line 1105 - 'AtomItemsControl.js' */                    if (!sender)
/*Line 1106 - 'AtomItemsControl.js' */                        return;
/*Line 1107 - 'AtomItemsControl.js' */                    var d = sender.get_data();
/*Line 1108 - 'AtomItemsControl.js' */                    AtomBinder.removeItem(caller._items, d);
/*Line 1109 - 'AtomItemsControl.js' */                };

/*Line 1111 - 'AtomItemsControl.js' */                this.removeSelectedCommand = function (scope, sender) {
/*Line 1112 - 'AtomItemsControl.js' */                    var s = caller.get_selectedItems().slice(0);
/*Line 1113 - 'AtomItemsControl.js' */                    var ae = new AtomEnumerator(s);
/*Line 1114 - 'AtomItemsControl.js' */                    while (ae.next()) {
/*Line 1115 - 'AtomItemsControl.js' */                        AtomBinder.removeItem(caller.get_items(), ae.current());
/*Line 1116 - 'AtomItemsControl.js' */                    }
/*Line 1117 - 'AtomItemsControl.js' */                };

/*Line 1119 - 'AtomItemsControl.js' */                this.removeAllCommand = function (scope, sender) {
/*Line 1120 - 'AtomItemsControl.js' */                    AtomBinder.clear(caller.get_items());
/*Line 1121 - 'AtomItemsControl.js' */                };
/*Line 1122 - 'AtomItemsControl.js' */            }
/*Line 1123 - 'AtomItemsControl.js' */        }
/*Line 1124 - 'AtomItemsControl.js' */    });
/*Line 1125 - 'AtomItemsControl.js' */})(WebAtoms.AtomControl.prototype);
/*Line 0 - 'AtomButton.js' */

/*Line 2 - 'AtomButton.js' */(function (base) {
/*Line 3 - 'AtomButton.js' */    return classCreatorEx(
/*Line 4 - 'AtomButton.js' */    {
/*Line 5 - 'AtomButton.js' */        name: "WebAtoms.AtomButton",
/*Line 6 - 'AtomButton.js' */        base: base,
/*Line 7 - 'AtomButton.js' */        start: function (e) {
/*Line 8 - 'AtomButton.js' */            this._sendData = false;
/*Line 9 - 'AtomButton.js' */            $(e).addClass("atom-button");
/*Line 10 - 'AtomButton.js' */        },
/*Line 11 - 'AtomButton.js' */        properties: {
/*Line 12 - 'AtomButton.js' */            sendData: false,
/*Line 13 - 'AtomButton.js' */            command: null,
/*Line 14 - 'AtomButton.js' */            commandParameter: null,
/*Line 15 - 'AtomButton.js' */            invalid: null
/*Line 16 - 'AtomButton.js' */        },
/*Line 17 - 'AtomButton.js' */        methods: {

/*Line 19 - 'AtomButton.js' */            onClickHandler: function (e) {

/*Line 21 - 'AtomButton.js' */                AtomUI.cancelEvent(e);

/*Line 23 - 'AtomButton.js' */                if(this._command){
/*Line 24 - 'AtomButton.js' */                    var self = this;
/*Line 25 - 'AtomButton.js' */                    setTimeout(function () {
/*Line 26 - 'AtomButton.js' */                        self._command.execute(self._commandParameter);
/*Line 27 - 'AtomButton.js' */                    });
/*Line 28 - 'AtomButton.js' */                    return false;
/*Line 29 - 'AtomButton.js' */                }


/*Line 32 - 'AtomButton.js' */                if (this._next) {

/*Line 34 - 'AtomButton.js' */                    var inv = this._invalid;
/*Line 35 - 'AtomButton.js' */                    if (inv) {
/*Line 36 - 'AtomButton.js' */                        if ($.isArray(inv)) {
/*Line 37 - 'AtomButton.js' */                            inv = inv.join();
/*Line 38 - 'AtomButton.js' */                        }
/*Line 39 - 'AtomButton.js' */                        if (inv) {
/*Line 40 - 'AtomButton.js' */                            alert(inv);
/*Line 41 - 'AtomButton.js' */                            return;
/*Line 42 - 'AtomButton.js' */                        }
/*Line 43 - 'AtomButton.js' */                    }

/*Line 45 - 'AtomButton.js' */                    if (this._sendData && this._next) {
/*Line 46 - 'AtomButton.js' */                        AtomBinder.setValue(this._next, "data", this.get_data());
/*Line 47 - 'AtomButton.js' */                    }
/*Line 48 - 'AtomButton.js' */                    this.invokeAction(this._next);
/*Line 49 - 'AtomButton.js' */                }
/*Line 50 - 'AtomButton.js' */                return false;
/*Line 51 - 'AtomButton.js' */            },

/*Line 53 - 'AtomButton.js' */            init: function () {

/*Line 55 - 'AtomButton.js' */                var element = this._element;
/*Line 56 - 'AtomButton.js' */                this.bindEvent(element, "click", "onClickHandler");
/*Line 57 - 'AtomButton.js' */                this.bind(element, "isEnabled", [["command"],["command", "enabled"]], 0, function (v1,v2) {
/*Line 58 - 'AtomButton.js' */                    return v1 ? v2 : true; 
/*Line 59 - 'AtomButton.js' */                });
/*Line 60 - 'AtomButton.js' */                base.init.apply(this);
/*Line 61 - 'AtomButton.js' */            }
/*Line 62 - 'AtomButton.js' */        }

/*Line 64 - 'AtomButton.js' */    });
/*Line 65 - 'AtomButton.js' */})(WebAtoms.AtomControl.prototype);
/*Line 0 - 'AtomListBox.js' */

/*Line 2 - 'AtomListBox.js' */(function (baseType) {
/*Line 3 - 'AtomListBox.js' */    return classCreatorEx({
/*Line 4 - 'AtomListBox.js' */        name: "WebAtoms.AtomListBox",
/*Line 5 - 'AtomListBox.js' */        base: baseType,
/*Line 6 - 'AtomListBox.js' */        start: function (e) {
/*Line 7 - 'AtomListBox.js' */            this._labelPath = "label";
/*Line 8 - 'AtomListBox.js' */            this._valuePath = "value";

/*Line 10 - 'AtomListBox.js' */            this._autoScrollToSelection = false;

/*Line 12 - 'AtomListBox.js' */        },
/*Line 13 - 'AtomListBox.js' */        properties: {
/*Line 14 - 'AtomListBox.js' */            autoSelectOnClick: true
/*Line 15 - 'AtomListBox.js' */        },
/*Line 16 - 'AtomListBox.js' */        methods: {

/*Line 18 - 'AtomListBox.js' */            setClass: function () {
/*Line 19 - 'AtomListBox.js' */                var $e = $(this._element);
/*Line 20 - 'AtomListBox.js' */                $e.addClass("atom-list-box");
/*Line 21 - 'AtomListBox.js' */            },

/*Line 23 - 'AtomListBox.js' */            onClick: function (event) {

/*Line 25 - 'AtomListBox.js' */                if (!this._autoSelectOnClick)
/*Line 26 - 'AtomListBox.js' */                    return;

/*Line 28 - 'AtomListBox.js' */                this.onSelectItem(null, null, event);
/*Line 29 - 'AtomListBox.js' */                //return AtomUI.cancelEvent(event);
/*Line 30 - 'AtomListBox.js' */            },

/*Line 32 - 'AtomListBox.js' */            get_itemWidth: function () {
/*Line 33 - 'AtomListBox.js' */                if (!this._items || !this._items.length)
/*Line 34 - 'AtomListBox.js' */                    return 0;
/*Line 35 - 'AtomListBox.js' */                var w = $(this._element).innerWidth();
/*Line 36 - 'AtomListBox.js' */                return w / this._items.length;
/*Line 37 - 'AtomListBox.js' */            },

/*Line 39 - 'AtomListBox.js' */            applyItemStyle: function (item, dataItem, first, last) {
/*Line 40 - 'AtomListBox.js' */                var $item = $(item);
/*Line 41 - 'AtomListBox.js' */                $item.removeClass("selected-item list-item first-item last-item");
/*Line 42 - 'AtomListBox.js' */                //$(item).removeClass("list-item");
/*Line 43 - 'AtomListBox.js' */                //$(item).removeClass("first-item");
/*Line 44 - 'AtomListBox.js' */                //$(item).removeClass("last-item");
/*Line 45 - 'AtomListBox.js' */                if (!dataItem)
/*Line 46 - 'AtomListBox.js' */                    return;
/*Line 47 - 'AtomListBox.js' */                $item.addClass("list-item");
/*Line 48 - 'AtomListBox.js' */                if (first) {
/*Line 49 - 'AtomListBox.js' */                    $item.addClass("first-item");
/*Line 50 - 'AtomListBox.js' */                }
/*Line 51 - 'AtomListBox.js' */                if (last) {
/*Line 52 - 'AtomListBox.js' */                    $item.addClass("last-item");
/*Line 53 - 'AtomListBox.js' */                }
/*Line 54 - 'AtomListBox.js' */                if (this.isSelected(dataItem)) {
/*Line 55 - 'AtomListBox.js' */                    $item.addClass("selected-item");
/*Line 56 - 'AtomListBox.js' */                }
/*Line 57 - 'AtomListBox.js' */            },

/*Line 59 - 'AtomListBox.js' */            onCreated: function () {
/*Line 60 - 'AtomListBox.js' */                this.bindEvent(this._itemsPresenter, "click", "onClick");
/*Line 61 - 'AtomListBox.js' */                baseType.onCreated.call(this);
/*Line 62 - 'AtomListBox.js' */            },

/*Line 64 - 'AtomListBox.js' */            invokePost: function () {
/*Line 65 - 'AtomListBox.js' */                if (this.get_selectedIndex() != -1) {
/*Line 66 - 'AtomListBox.js' */                    baseType.invokePost.apply(this, arguments);
/*Line 67 - 'AtomListBox.js' */                }
/*Line 68 - 'AtomListBox.js' */            },

/*Line 70 - 'AtomListBox.js' */            onSelectItem: function (scope, sender, event) {
/*Line 71 - 'AtomListBox.js' */                var target = event ? event.target : null;
/*Line 72 - 'AtomListBox.js' */                var element = this._itemsPresenter;
/*Line 73 - 'AtomListBox.js' */                var childElement = target || sender._element;
/*Line 74 - 'AtomListBox.js' */                while (childElement.parentNode != null && childElement.parentNode != element)
/*Line 75 - 'AtomListBox.js' */                    childElement = childElement.parentNode;
/*Line 76 - 'AtomListBox.js' */                if (childElement == document) {
/*Line 77 - 'AtomListBox.js' */                    //console.log("listbox clicked outside");
/*Line 78 - 'AtomListBox.js' */                    return;
/*Line 79 - 'AtomListBox.js' */                }
/*Line 80 - 'AtomListBox.js' */                var dataItem = childElement;
/*Line 81 - 'AtomListBox.js' */                if (this.hasItems()) {
/*Line 82 - 'AtomListBox.js' */                    dataItem = childElement.atomControl.get_data();
/*Line 83 - 'AtomListBox.js' */                }

/*Line 85 - 'AtomListBox.js' */                this.toggleSelection(dataItem);

/*Line 87 - 'AtomListBox.js' */            },


/*Line 90 - 'AtomListBox.js' */            updateChildSelections: function () {
/*Line 91 - 'AtomListBox.js' */                var e = this._element;
/*Line 92 - 'AtomListBox.js' */                if (/select/i.test(e.tagName)) {
/*Line 93 - 'AtomListBox.js' */                    var i = this.get_selectedIndex();
/*Line 94 - 'AtomListBox.js' */                    if (e.selectedIndex != i) {
/*Line 95 - 'AtomListBox.js' */                        WebAtoms.dispatcher.callLater(function () {
/*Line 96 - 'AtomListBox.js' */                            e.selectedIndex = i;
/*Line 97 - 'AtomListBox.js' */                        });
/*Line 98 - 'AtomListBox.js' */                    }
/*Line 99 - 'AtomListBox.js' */                } else {
/*Line 100 - 'AtomListBox.js' */                    baseType.updateChildSelections.apply(this, arguments);
/*Line 101 - 'AtomListBox.js' */                }
/*Line 102 - 'AtomListBox.js' */            },

/*Line 104 - 'AtomListBox.js' */            init: function () {

/*Line 106 - 'AtomListBox.js' */                this.setClass();

/*Line 108 - 'AtomListBox.js' */                baseType.init.call(this);
/*Line 109 - 'AtomListBox.js' */                var self = this;

/*Line 111 - 'AtomListBox.js' */                var e = this._element;
/*Line 112 - 'AtomListBox.js' */                if (/select/i.test(e.tagName)) {
/*Line 113 - 'AtomListBox.js' */                    this.set_allowSelectFirst(true);
/*Line 114 - 'AtomListBox.js' */                    this.bindEvent(e, 'change', function () {
/*Line 115 - 'AtomListBox.js' */                        AtomBinder.setValue(self, 'selectedIndex', e.selectedIndex);
/*Line 116 - 'AtomListBox.js' */                    });
/*Line 117 - 'AtomListBox.js' */                }



/*Line 121 - 'AtomListBox.js' */                this.selectCommand = function () {
/*Line 122 - 'AtomListBox.js' */                    self.onSelectItem.apply(self, arguments);
/*Line 123 - 'AtomListBox.js' */                };
/*Line 124 - 'AtomListBox.js' */                this.selectAllCommand = function () {
/*Line 125 - 'AtomListBox.js' */                    self.set_selectAll(true);
/*Line 126 - 'AtomListBox.js' */                };
/*Line 127 - 'AtomListBox.js' */                this.clearSelectionCommand = function () {
/*Line 128 - 'AtomListBox.js' */                    self.set_selectedIndex(-1);
/*Line 129 - 'AtomListBox.js' */                };
/*Line 130 - 'AtomListBox.js' */            }
/*Line 131 - 'AtomListBox.js' */        }
/*Line 132 - 'AtomListBox.js' */    });
/*Line 133 - 'AtomListBox.js' */})(WebAtoms.AtomItemsControl.prototype);

/*Line 0 - 'AtomAutoCompleteBox.js' */
/*Line 1 - 'AtomAutoCompleteBox.js' */

/*Line 3 - 'AtomAutoCompleteBox.js' */(function (base) {
/*Line 4 - 'AtomAutoCompleteBox.js' */    return classCreatorEx(
/*Line 5 - 'AtomAutoCompleteBox.js' */    {
/*Line 6 - 'AtomAutoCompleteBox.js' */        name: "WebAtoms.AtomAutoCompleteBox",
/*Line 7 - 'AtomAutoCompleteBox.js' */        base: base,
/*Line 8 - 'AtomAutoCompleteBox.js' */        start:
/*Line 9 - 'AtomAutoCompleteBox.js' */            function (e) {
/*Line 10 - 'AtomAutoCompleteBox.js' */                $(e).addClass("atom-auto-complete-box");
/*Line 11 - 'AtomAutoCompleteBox.js' */                this._presenters = ["itemsPresenter", "inputBox", "selectionBox"];
/*Line 12 - 'AtomAutoCompleteBox.js' */                this._mouseCapture = 0;
/*Line 13 - 'AtomAutoCompleteBox.js' */            },
/*Line 14 - 'AtomAutoCompleteBox.js' */        properties: {
/*Line 15 - 'AtomAutoCompleteBox.js' */            isPopupOpen: false,
/*Line 16 - 'AtomAutoCompleteBox.js' */            autoOpen: false,
/*Line 17 - 'AtomAutoCompleteBox.js' */            selectedText:'',
/*Line 18 - 'AtomAutoCompleteBox.js' */            placeholder: undefined,
/*Line 19 - 'AtomAutoCompleteBox.js' */            keyPressed: undefined,
/*Line 20 - 'AtomAutoCompleteBox.js' */            displayLabel: undefined
/*Line 21 - 'AtomAutoCompleteBox.js' */        },
/*Line 22 - 'AtomAutoCompleteBox.js' */        methods: {
/*Line 23 - 'AtomAutoCompleteBox.js' */            get_offsetLeft: function () {
/*Line 24 - 'AtomAutoCompleteBox.js' */                //return $(this._element).offset().left - parseInt( $(atomApplication._element).css("left") , 10);
/*Line 25 - 'AtomAutoCompleteBox.js' */                return $(this._element).offset().left;
/*Line 26 - 'AtomAutoCompleteBox.js' */            },
/*Line 27 - 'AtomAutoCompleteBox.js' */            get_offsetTop: function () {
/*Line 28 - 'AtomAutoCompleteBox.js' */                return $(this._element).offset().top;
/*Line 29 - 'AtomAutoCompleteBox.js' */            },

/*Line 31 - 'AtomAutoCompleteBox.js' */            get_offsetWidth: function () {
/*Line 32 - 'AtomAutoCompleteBox.js' */                return $(this._inputBox).offset().width;
/*Line 33 - 'AtomAutoCompleteBox.js' */            },

/*Line 35 - 'AtomAutoCompleteBox.js' */            set_itemsUrl: function (v) {
/*Line 36 - 'AtomAutoCompleteBox.js' */                var url = "[ !$owner.keyPressed ? undefined : AtomPromise.json('" + v + "').showProgress(false) ]";
/*Line 37 - 'AtomAutoCompleteBox.js' */                this.setValue("items", url, true, this._element);
/*Line 38 - 'AtomAutoCompleteBox.js' */            },

/*Line 40 - 'AtomAutoCompleteBox.js' */            set_isPopupOpen: function (v) {
/*Line 41 - 'AtomAutoCompleteBox.js' */                this._isPopupOpen = v;
/*Line 42 - 'AtomAutoCompleteBox.js' */                if (v) {
/*Line 43 - 'AtomAutoCompleteBox.js' */                    AtomBinder.refreshValue(this, "offsetTop");
/*Line 44 - 'AtomAutoCompleteBox.js' */                    AtomBinder.refreshValue(this, "offsetLeft");
/*Line 45 - 'AtomAutoCompleteBox.js' */                    AtomBinder.refreshValue(this, "offsetWidth");
/*Line 46 - 'AtomAutoCompleteBox.js' */                    //this.bindEvent(window, "click", "onWindowClick");
/*Line 47 - 'AtomAutoCompleteBox.js' */                    var _this = this;
/*Line 48 - 'AtomAutoCompleteBox.js' */                    this.trySelect();
/*Line 49 - 'AtomAutoCompleteBox.js' */                    this.bindEvent(window, "click", function () {
/*Line 50 - 'AtomAutoCompleteBox.js' */                        _this.onWindowClick.apply(_this, arguments);
/*Line 51 - 'AtomAutoCompleteBox.js' */                    });
/*Line 52 - 'AtomAutoCompleteBox.js' */                } else {
/*Line 53 - 'AtomAutoCompleteBox.js' */                    //this.unbindEvent(window, "click", "onWindowClick");
/*Line 54 - 'AtomAutoCompleteBox.js' */                    this.unbindEvent(window, "click");
/*Line 55 - 'AtomAutoCompleteBox.js' */                }
/*Line 56 - 'AtomAutoCompleteBox.js' */            },

/*Line 58 - 'AtomAutoCompleteBox.js' */            onSelectedItemsChanged: function () {
/*Line 59 - 'AtomAutoCompleteBox.js' */                if (this._onUIChanged) {
/*Line 60 - 'AtomAutoCompleteBox.js' */                    if (this._selectedItems.length > 0) {
/*Line 61 - 'AtomAutoCompleteBox.js' */                        this.refreshLabel();
/*Line 62 - 'AtomAutoCompleteBox.js' */                    }
/*Line 63 - 'AtomAutoCompleteBox.js' */                }
/*Line 64 - 'AtomAutoCompleteBox.js' */                base.onSelectedItemsChanged.apply(this, arguments);
/*Line 65 - 'AtomAutoCompleteBox.js' */            },

/*Line 67 - 'AtomAutoCompleteBox.js' */            onClick: function (e) {
/*Line 68 - 'AtomAutoCompleteBox.js' */                base.onClick.apply(this, arguments);
/*Line 69 - 'AtomAutoCompleteBox.js' */                this._backupValue = this.get_value();
/*Line 70 - 'AtomAutoCompleteBox.js' */                this.refreshLabel();
/*Line 71 - 'AtomAutoCompleteBox.js' */                this._backupLabel = this.get_displayLabel();
/*Line 72 - 'AtomAutoCompleteBox.js' */                AtomBinder.setValue(this, "keyPressed", false);
/*Line 73 - 'AtomAutoCompleteBox.js' */                AtomBinder.setValue(this, "isPopupOpen", false);
/*Line 74 - 'AtomAutoCompleteBox.js' */            },

/*Line 76 - 'AtomAutoCompleteBox.js' */            restoreSelection: function () {
/*Line 77 - 'AtomAutoCompleteBox.js' */                AtomBinder.setValue(this, "isPopupOpen", false);
/*Line 78 - 'AtomAutoCompleteBox.js' */                if (this._backupValue) {
/*Line 79 - 'AtomAutoCompleteBox.js' */                    AtomBinder.setValue(this, "value", this._backupValue);
/*Line 80 - 'AtomAutoCompleteBox.js' */                    AtomBinder.setValue(this, "displayLabel", this._backupLabel);
/*Line 81 - 'AtomAutoCompleteBox.js' */                    this._backupValue = null;
/*Line 82 - 'AtomAutoCompleteBox.js' */                } else {
/*Line 83 - 'AtomAutoCompleteBox.js' */                    AtomBinder.setValue(this, "selectedIndex", -1);
/*Line 84 - 'AtomAutoCompleteBox.js' */                }
/*Line 85 - 'AtomAutoCompleteBox.js' */            },

/*Line 87 - 'AtomAutoCompleteBox.js' */            onKeyUp: function (e) {

/*Line 89 - 'AtomAutoCompleteBox.js' */                AtomBinder.setValue(this, "isPopupOpen", true);

/*Line 91 - 'AtomAutoCompleteBox.js' */                switch (e.keyCode) {
/*Line 92 - 'AtomAutoCompleteBox.js' */                    case 27:
/*Line 93 - 'AtomAutoCompleteBox.js' */                        AtomBinder.setValue(this, "keyPressed", false);
/*Line 94 - 'AtomAutoCompleteBox.js' */                        this.restoreSelection();
/*Line 95 - 'AtomAutoCompleteBox.js' */                        return;
/*Line 96 - 'AtomAutoCompleteBox.js' */                    case 13:
/*Line 97 - 'AtomAutoCompleteBox.js' */                        AtomBinder.setValue(this, "keyPressed", false);
/*Line 98 - 'AtomAutoCompleteBox.js' */                        AtomBinder.setValue(this, "isPopupOpen", false);
/*Line 99 - 'AtomAutoCompleteBox.js' */                        this._backupValue = this.get_value();
/*Line 100 - 'AtomAutoCompleteBox.js' */                        this.refreshLabel();
/*Line 101 - 'AtomAutoCompleteBox.js' */                        this._backupLabel = this.get_displayLabel();
/*Line 102 - 'AtomAutoCompleteBox.js' */                        return AtomUI.cancelEvent(e);
/*Line 103 - 'AtomAutoCompleteBox.js' */                    case 37:
/*Line 104 - 'AtomAutoCompleteBox.js' */                        // Left
/*Line 105 - 'AtomAutoCompleteBox.js' */                        break;
/*Line 106 - 'AtomAutoCompleteBox.js' */                    case 38:
/*Line 107 - 'AtomAutoCompleteBox.js' */                        // up
/*Line 108 - 'AtomAutoCompleteBox.js' */                        AtomBinder.setValue(this, "keyPressed", false);
/*Line 109 - 'AtomAutoCompleteBox.js' */                        this.moveSelection(true);
/*Line 110 - 'AtomAutoCompleteBox.js' */                        return;
/*Line 111 - 'AtomAutoCompleteBox.js' */                    case 39:
/*Line 112 - 'AtomAutoCompleteBox.js' */                        // right
/*Line 113 - 'AtomAutoCompleteBox.js' */                        break;
/*Line 114 - 'AtomAutoCompleteBox.js' */                    case 40:
/*Line 115 - 'AtomAutoCompleteBox.js' */                        AtomBinder.setValue(this, "keyPressed", false);
/*Line 116 - 'AtomAutoCompleteBox.js' */                        this.moveSelection(false);
/*Line 117 - 'AtomAutoCompleteBox.js' */                        return;
/*Line 118 - 'AtomAutoCompleteBox.js' */                    default:
/*Line 119 - 'AtomAutoCompleteBox.js' */                        // try selecting complete word...
/*Line 120 - 'AtomAutoCompleteBox.js' */                        var caller = this;
/*Line 121 - 'AtomAutoCompleteBox.js' */                        this.dispatcher.callLater(function () {
/*Line 122 - 'AtomAutoCompleteBox.js' */                            caller.trySelect();
/*Line 123 - 'AtomAutoCompleteBox.js' */                        });
/*Line 124 - 'AtomAutoCompleteBox.js' */                        break;
/*Line 125 - 'AtomAutoCompleteBox.js' */                }

/*Line 127 - 'AtomAutoCompleteBox.js' */                if (this.oldTimeout) {
/*Line 128 - 'AtomAutoCompleteBox.js' */                    clearTimeout(this.oldTimeout);
/*Line 129 - 'AtomAutoCompleteBox.js' */                }
/*Line 130 - 'AtomAutoCompleteBox.js' */                var _this = this;
/*Line 131 - 'AtomAutoCompleteBox.js' */                this.oldTimeout = setTimeout(function () {
/*Line 132 - 'AtomAutoCompleteBox.js' */                    AtomBinder.setValue(_this, "keyPressed", true);
/*Line 133 - 'AtomAutoCompleteBox.js' */                }, 500);

/*Line 135 - 'AtomAutoCompleteBox.js' */            },

/*Line 137 - 'AtomAutoCompleteBox.js' */            trySelect: function () {

/*Line 139 - 'AtomAutoCompleteBox.js' */                if (!this._items || this._items.length == 0)
/*Line 140 - 'AtomAutoCompleteBox.js' */                    return;

/*Line 142 - 'AtomAutoCompleteBox.js' */                //if (this.get_selectedIndex() != -1)
/*Line 143 - 'AtomAutoCompleteBox.js' */                //    return;

/*Line 145 - 'AtomAutoCompleteBox.js' */                var ae = new AtomEnumerator(this._items);
/*Line 146 - 'AtomAutoCompleteBox.js' */                var lp = this._labelPath;

/*Line 148 - 'AtomAutoCompleteBox.js' */                var cl = this._displayLabel;

/*Line 150 - 'AtomAutoCompleteBox.js' */                if (cl)
/*Line 151 - 'AtomAutoCompleteBox.js' */                    cl = cl.toLowerCase();

/*Line 153 - 'AtomAutoCompleteBox.js' */                while (ae.next()) {
/*Line 154 - 'AtomAutoCompleteBox.js' */                    var item = ae.current();
/*Line 155 - 'AtomAutoCompleteBox.js' */                    var l = item;
/*Line 156 - 'AtomAutoCompleteBox.js' */                    if (lp)
/*Line 157 - 'AtomAutoCompleteBox.js' */                        l = l[lp];
/*Line 158 - 'AtomAutoCompleteBox.js' */                    if (l.toLowerCase().indexOf(cl)==0) {
/*Line 159 - 'AtomAutoCompleteBox.js' */                        AtomBinder.setValue(this, "selectedItem", item);
/*Line 160 - 'AtomAutoCompleteBox.js' */                        AtomBinder.setValue(this, "selectedText", l);
/*Line 161 - 'AtomAutoCompleteBox.js' */                        this.bringSelectionIntoView();
/*Line 162 - 'AtomAutoCompleteBox.js' */                        return;
/*Line 163 - 'AtomAutoCompleteBox.js' */                    }
/*Line 164 - 'AtomAutoCompleteBox.js' */                }
/*Line 165 - 'AtomAutoCompleteBox.js' */            },

/*Line 167 - 'AtomAutoCompleteBox.js' */            moveSelection: function (up) {
/*Line 168 - 'AtomAutoCompleteBox.js' */                if (!this._items || !this._items.length)
/*Line 169 - 'AtomAutoCompleteBox.js' */                    return;
/*Line 170 - 'AtomAutoCompleteBox.js' */                var i = this.get_selectedIndex();

/*Line 172 - 'AtomAutoCompleteBox.js' */                if (i == -1) {
/*Line 173 - 'AtomAutoCompleteBox.js' */                    this.backupLabel = this.get_displayLabel();
/*Line 174 - 'AtomAutoCompleteBox.js' */                }

/*Line 176 - 'AtomAutoCompleteBox.js' */                i = up ? (i - 1) : (i + 1);
/*Line 177 - 'AtomAutoCompleteBox.js' */                if (up && i == -2) {
/*Line 178 - 'AtomAutoCompleteBox.js' */                    i = this._items.length - 1;
/*Line 179 - 'AtomAutoCompleteBox.js' */                }
/*Line 180 - 'AtomAutoCompleteBox.js' */                if (!up && i == this._items.length) {
/*Line 181 - 'AtomAutoCompleteBox.js' */                    i = -1;
/*Line 182 - 'AtomAutoCompleteBox.js' */                }

/*Line 184 - 'AtomAutoCompleteBox.js' */                AtomBinder.setValue(this, "selectedIndex", i);
/*Line 185 - 'AtomAutoCompleteBox.js' */                if (i == -1) {
/*Line 186 - 'AtomAutoCompleteBox.js' */                    AtomBinder.setValue(this, "displayLabel", this.backupLabel || "");
/*Line 187 - 'AtomAutoCompleteBox.js' */                } else {
/*Line 188 - 'AtomAutoCompleteBox.js' */                    this.refreshLabel();
/*Line 189 - 'AtomAutoCompleteBox.js' */                }
/*Line 190 - 'AtomAutoCompleteBox.js' */            },

/*Line 192 - 'AtomAutoCompleteBox.js' */            refreshLabel: function () {
/*Line 193 - 'AtomAutoCompleteBox.js' */                var item = this.get_selectedItem();
/*Line 194 - 'AtomAutoCompleteBox.js' */                var l = item;
/*Line 195 - 'AtomAutoCompleteBox.js' */                if (l && this._labelPath) {
/*Line 196 - 'AtomAutoCompleteBox.js' */                    l = l[this._labelPath];
/*Line 197 - 'AtomAutoCompleteBox.js' */                }
/*Line 198 - 'AtomAutoCompleteBox.js' */                AtomBinder.setValue(this, "displayLabel", l || "");
/*Line 199 - 'AtomAutoCompleteBox.js' */            },

/*Line 201 - 'AtomAutoCompleteBox.js' */            onWindowClick: function (e) {
/*Line 202 - 'AtomAutoCompleteBox.js' */                var se = this._element;
/*Line 203 - 'AtomAutoCompleteBox.js' */                var p = this._itemsPresenter;
/*Line 204 - 'AtomAutoCompleteBox.js' */                var childElement = e.target;
/*Line 205 - 'AtomAutoCompleteBox.js' */                while (childElement.parentNode != null && childElement != se && childElement != p)
/*Line 206 - 'AtomAutoCompleteBox.js' */                    childElement = childElement.parentNode;
/*Line 207 - 'AtomAutoCompleteBox.js' */                if (childElement == se || childElement == p)
/*Line 208 - 'AtomAutoCompleteBox.js' */                    return;
/*Line 209 - 'AtomAutoCompleteBox.js' */                // close popup....
/*Line 210 - 'AtomAutoCompleteBox.js' */                this.restoreSelection();

/*Line 212 - 'AtomAutoCompleteBox.js' */            },

/*Line 214 - 'AtomAutoCompleteBox.js' */            onInputFocus: function () {
/*Line 215 - 'AtomAutoCompleteBox.js' */                if (!this._autoOpen)
/*Line 216 - 'AtomAutoCompleteBox.js' */                    return;
/*Line 217 - 'AtomAutoCompleteBox.js' */                this._backupValue = this.get_value();
/*Line 218 - 'AtomAutoCompleteBox.js' */                this._backupLabel = this.get_displayLabel();
/*Line 219 - 'AtomAutoCompleteBox.js' */                AtomBinder.setValue(this, "isPopupOpen", true);
/*Line 220 - 'AtomAutoCompleteBox.js' */                $(this._inputBox).select();
/*Line 221 - 'AtomAutoCompleteBox.js' */            },

/*Line 223 - 'AtomAutoCompleteBox.js' */            onInputBlur: function () {
/*Line 224 - 'AtomAutoCompleteBox.js' */                if (this._mouseCapture)
/*Line 225 - 'AtomAutoCompleteBox.js' */                    return;
/*Line 226 - 'AtomAutoCompleteBox.js' */                var caller = this;

/*Line 228 - 'AtomAutoCompleteBox.js' */                setTimeout(function () {
/*Line 229 - 'AtomAutoCompleteBox.js' */                    if (caller._isPopupOpen) {
/*Line 230 - 'AtomAutoCompleteBox.js' */                        AtomBinder.setValue(caller, "isPopupOpen", false);
/*Line 231 - 'AtomAutoCompleteBox.js' */                        caller.restoreSelection();
/*Line 232 - 'AtomAutoCompleteBox.js' */                    }
/*Line 233 - 'AtomAutoCompleteBox.js' */                }, 10);
/*Line 234 - 'AtomAutoCompleteBox.js' */            },

/*Line 236 - 'AtomAutoCompleteBox.js' */            onCreated: function () {

/*Line 238 - 'AtomAutoCompleteBox.js' */                this._itemsPresenter._logicalParent = this._element;

/*Line 240 - 'AtomAutoCompleteBox.js' */                $(this._itemsPresenter).remove();

/*Line 242 - 'AtomAutoCompleteBox.js' */                document.body.appendChild(this._itemsPresenter);

/*Line 244 - 'AtomAutoCompleteBox.js' */                $(this._itemsPresenter).addClass("auto-complete-popup");

/*Line 246 - 'AtomAutoCompleteBox.js' */                base.onCreated.apply(this, arguments);
/*Line 247 - 'AtomAutoCompleteBox.js' */                this.bindEvent(this._itemsPresenter, "mouseover", "onMouseOver");
/*Line 248 - 'AtomAutoCompleteBox.js' */                this.bindEvent(this._itemsPresenter, "mouseout", "onMouseOut");
/*Line 249 - 'AtomAutoCompleteBox.js' */            },

/*Line 251 - 'AtomAutoCompleteBox.js' */            onMouseOver: function () {
/*Line 252 - 'AtomAutoCompleteBox.js' */                this._mouseCapture++;

/*Line 254 - 'AtomAutoCompleteBox.js' */            },

/*Line 256 - 'AtomAutoCompleteBox.js' */            onMouseOut: function () {
/*Line 257 - 'AtomAutoCompleteBox.js' */                var _this = this;
/*Line 258 - 'AtomAutoCompleteBox.js' */                setTimeout(function () {
/*Line 259 - 'AtomAutoCompleteBox.js' */                    _this._mouseCapture--;

/*Line 261 - 'AtomAutoCompleteBox.js' */                }, 1000);
/*Line 262 - 'AtomAutoCompleteBox.js' */            },

/*Line 264 - 'AtomAutoCompleteBox.js' */            init: function () {

/*Line 266 - 'AtomAutoCompleteBox.js' */                base.init.apply(this, arguments);
/*Line 267 - 'AtomAutoCompleteBox.js' */                this.bindEvent(this._inputBox, "focus", "onInputFocus");
/*Line 268 - 'AtomAutoCompleteBox.js' */                this.bindEvent(this._inputBox, "blur", "onInputBlur");
/*Line 269 - 'AtomAutoCompleteBox.js' */                this.bindEvent(this._inputBox, "keyup", "onKeyUp");
/*Line 270 - 'AtomAutoCompleteBox.js' */            },
/*Line 271 - 'AtomAutoCompleteBox.js' */            dispose: function () {
/*Line 272 - 'AtomAutoCompleteBox.js' */                if(this._itemsPresenter){
/*Line 273 - 'AtomAutoCompleteBox.js' */                    this.disposeChildren(this._itemsPresenter);
/*Line 274 - 'AtomAutoCompleteBox.js' */                    $(this._itemsPresenter).remove();
/*Line 275 - 'AtomAutoCompleteBox.js' */                    this._itemsPresenter = null;
/*Line 276 - 'AtomAutoCompleteBox.js' */                }
/*Line 277 - 'AtomAutoCompleteBox.js' */                base.dispose.call(this);
/*Line 278 - 'AtomAutoCompleteBox.js' */            }
/*Line 279 - 'AtomAutoCompleteBox.js' */        }
/*Line 280 - 'AtomAutoCompleteBox.js' */    });
/*Line 281 - 'AtomAutoCompleteBox.js' */})(WebAtoms.AtomListBox.prototype);

/*Line 0 - 'AtomComboBox.js' */
/*Line 1 - 'AtomComboBox.js' */


/*Line 4 - 'AtomComboBox.js' */(function (base) {
/*Line 5 - 'AtomComboBox.js' */    return classCreatorEx(
/*Line 6 - 'AtomComboBox.js' */    {
/*Line 7 - 'AtomComboBox.js' */        name: "WebAtoms.AtomComboBox",
/*Line 8 - 'AtomComboBox.js' */        base: base,
/*Line 9 - 'AtomComboBox.js' */        start: function () {
/*Line 10 - 'AtomComboBox.js' */            this._labelPath = "label";
/*Line 11 - 'AtomComboBox.js' */            this._valuePath = "value";
/*Line 12 - 'AtomComboBox.js' */            this._allowSelectFirst = true;
/*Line 13 - 'AtomComboBox.js' */        },
/*Line 14 - 'AtomComboBox.js' */        methods: {
/*Line 15 - 'AtomComboBox.js' */            invokePost: function () {
/*Line 16 - 'AtomComboBox.js' */                if (this.get_selectedIndex() > 0) {
/*Line 17 - 'AtomComboBox.js' */                    base.invokePost.apply(this, arguments);
/*Line 18 - 'AtomComboBox.js' */                }
/*Line 19 - 'AtomComboBox.js' */            },

/*Line 21 - 'AtomComboBox.js' */            invokeNext: function () {
/*Line 22 - 'AtomComboBox.js' */                base.invokeNext.apply(this, arguments);
/*Line 23 - 'AtomComboBox.js' */                if (this._postUrl) {
/*Line 24 - 'AtomComboBox.js' */                    AtomBinder.setValue(this, "selectedIndex", 0);
/*Line 25 - 'AtomComboBox.js' */                    this.updateChildSelections();
/*Line 26 - 'AtomComboBox.js' */                }
/*Line 27 - 'AtomComboBox.js' */            },

/*Line 29 - 'AtomComboBox.js' */            onSelectionChanged: function () {
/*Line 30 - 'AtomComboBox.js' */                this._onUIChanged = true;
/*Line 31 - 'AtomComboBox.js' */                var element = this.get_element();
/*Line 32 - 'AtomComboBox.js' */                this.set_selectedIndex(element.selectedIndex);
/*Line 33 - 'AtomComboBox.js' */                this._onUIChanged = false;

/*Line 35 - 'AtomComboBox.js' */                //this.invokeAction(this._next);
/*Line 36 - 'AtomComboBox.js' */            },

/*Line 38 - 'AtomComboBox.js' */            updateChildSelections: function () {
/*Line 39 - 'AtomComboBox.js' */                var element = this._element;
/*Line 40 - 'AtomComboBox.js' */                element.selectedIndex = this.get_selectedIndex();
/*Line 41 - 'AtomComboBox.js' */            },

/*Line 43 - 'AtomComboBox.js' */            onCollectionChanged: function (mode, index, item) {
/*Line 44 - 'AtomComboBox.js' */                var element = this.get_element();
/*Line 45 - 'AtomComboBox.js' */                var dataItems = this.get_dataItems();
/*Line 46 - 'AtomComboBox.js' */                element.options.length = dataItems.length;
/*Line 47 - 'AtomComboBox.js' */                var ae = new AtomEnumerator(dataItems);

/*Line 49 - 'AtomComboBox.js' */                var lp = this._labelPath;
/*Line 50 - 'AtomComboBox.js' */                var vp = this._valuePath;
/*Line 51 - 'AtomComboBox.js' */                var label = null;
/*Line 52 - 'AtomComboBox.js' */                var value = null;
/*Line 53 - 'AtomComboBox.js' */                var selectedValue = this.get_value();
/*Line 54 - 'AtomComboBox.js' */                while (ae.next()) {
/*Line 55 - 'AtomComboBox.js' */                    var data = ae.current();
/*Line 56 - 'AtomComboBox.js' */                    label = data;
/*Line 57 - 'AtomComboBox.js' */                    value = data;
/*Line 58 - 'AtomComboBox.js' */                    if (lp)
/*Line 59 - 'AtomComboBox.js' */                        label = label[lp];
/*Line 60 - 'AtomComboBox.js' */                    if (vp)
/*Line 61 - 'AtomComboBox.js' */                        value = value[vp];

/*Line 63 - 'AtomComboBox.js' */                    element.options[ae.currentIndex()] = new Option(label, value, false, value == selectedValue);
/*Line 64 - 'AtomComboBox.js' */                }
/*Line 65 - 'AtomComboBox.js' */            },

/*Line 67 - 'AtomComboBox.js' */            verifyTemplates: function () {
/*Line 68 - 'AtomComboBox.js' */            },

/*Line 70 - 'AtomComboBox.js' */            init: function () {

/*Line 72 - 'AtomComboBox.js' */                var element = this.get_element();
/*Line 73 - 'AtomComboBox.js' */                this.bindEvent(element, "change", "onSelectionChanged");
/*Line 74 - 'AtomComboBox.js' */                base.init.apply(this, arguments);
/*Line 75 - 'AtomComboBox.js' */            }
/*Line 76 - 'AtomComboBox.js' */        }
/*Line 77 - 'AtomComboBox.js' */    });
/*Line 78 - 'AtomComboBox.js' */})(WebAtoms.AtomItemsControl.prototype);



/*Line 0 - 'AtomDateListBox.js' */

/*Line 2 - 'AtomDateListBox.js' */(function (base) {
/*Line 3 - 'AtomDateListBox.js' */    return classCreatorEx({
/*Line 4 - 'AtomDateListBox.js' */        name: "WebAtoms.AtomDateListBox",
/*Line 5 - 'AtomDateListBox.js' */        base: base,
/*Line 6 - 'AtomDateListBox.js' */        start: function (element) {
/*Line 7 - 'AtomDateListBox.js' */            this._monthList = AtomDate.monthList;

/*Line 9 - 'AtomDateListBox.js' */            var today = new Date();
/*Line 10 - 'AtomDateListBox.js' */            this._month = today.getMonth() + 1;
/*Line 11 - 'AtomDateListBox.js' */            this._year = today.getFullYear();
/*Line 12 - 'AtomDateListBox.js' */            this._selectedItems = [];

/*Line 14 - 'AtomDateListBox.js' */            this._presenters = ['itemsPresenter'];

/*Line 16 - 'AtomDateListBox.js' */            this._startYear = -5;
/*Line 17 - 'AtomDateListBox.js' */            this._endYear = 10;

/*Line 19 - 'AtomDateListBox.js' */            this._currentYear = (new Date()).getFullYear();
/*Line 20 - 'AtomDateListBox.js' */            this._value = null;
/*Line 21 - 'AtomDateListBox.js' */        },
/*Line 22 - 'AtomDateListBox.js' */        properties: {
/*Line 23 - 'AtomDateListBox.js' */            month: 0,
/*Line 24 - 'AtomDateListBox.js' */            year: 0,
/*Line 25 - 'AtomDateListBox.js' */            selectedItems: [],
/*Line 26 - 'AtomDateListBox.js' */            startYear: -5,
/*Line 27 - 'AtomDateListBox.js' */            endYear: 0,
/*Line 28 - 'AtomDateListBox.js' */            currentYear: 0,
/*Line 29 - 'AtomDateListBox.js' */            monthList: null,
/*Line 30 - 'AtomDateListBox.js' */            items: undefined,
/*Line 31 - 'AtomDateListBox.js' */            month: null,
/*Line 32 - 'AtomDateListBox.js' */            visibleDate: undefined
/*Line 33 - 'AtomDateListBox.js' */        },
/*Line 34 - 'AtomDateListBox.js' */        methods: {
/*Line 35 - 'AtomDateListBox.js' */            set_month: function (v) {
/*Line 36 - 'AtomDateListBox.js' */                this._month = v;
/*Line 37 - 'AtomDateListBox.js' */                this.updateList();
/*Line 38 - 'AtomDateListBox.js' */            },

/*Line 40 - 'AtomDateListBox.js' */            set_year: function (v) {
/*Line 41 - 'AtomDateListBox.js' */                this._year = v;
/*Line 42 - 'AtomDateListBox.js' */                this.updateList();
/*Line 43 - 'AtomDateListBox.js' */            },

/*Line 45 - 'AtomDateListBox.js' */            set_visibleDate: function (v) {
/*Line 46 - 'AtomDateListBox.js' */                if (!v)
/*Line 47 - 'AtomDateListBox.js' */                    return;
/*Line 48 - 'AtomDateListBox.js' */                this._visibleDate = v;
/*Line 49 - 'AtomDateListBox.js' */                this._year = v.getFullYear();
/*Line 50 - 'AtomDateListBox.js' */                this._month = v.getMonth() + 1;
/*Line 51 - 'AtomDateListBox.js' */                this.updateList();
/*Line 52 - 'AtomDateListBox.js' */                AtomBinder.refreshValue(this, "year");
/*Line 53 - 'AtomDateListBox.js' */                AtomBinder.refreshValue(this, "month");
/*Line 54 - 'AtomDateListBox.js' */            },

/*Line 56 - 'AtomDateListBox.js' */            init: function () {
/*Line 57 - 'AtomDateListBox.js' */                base.init.apply(this);
/*Line 58 - 'AtomDateListBox.js' */                var _this = this;
/*Line 59 - 'AtomDateListBox.js' */                this.toggleDateCommand = function (scope, sender) {
/*Line 60 - 'AtomDateListBox.js' */                    _this.toggleDate.apply(_this, arguments);
/*Line 61 - 'AtomDateListBox.js' */                };
/*Line 62 - 'AtomDateListBox.js' */            },

/*Line 64 - 'AtomDateListBox.js' */            onLoaded: function () {
/*Line 65 - 'AtomDateListBox.js' */                var t = this.getTemplate("itemTemplate");

/*Line 67 - 'AtomDateListBox.js' */                var s = this.get_scope();

/*Line 69 - 'AtomDateListBox.js' */                var its = this._itemsPresenter;

/*Line 71 - 'AtomDateListBox.js' */                var et = this.getTemplate("itemTemplate");
/*Line 72 - 'AtomDateListBox.js' */                if (et) {
/*Line 73 - 'AtomDateListBox.js' */                    et = AtomUI.getAtomType(et);
/*Line 74 - 'AtomDateListBox.js' */                    if (!et) {
/*Line 75 - 'AtomDateListBox.js' */                        et = WebAtoms.AtomControl;
/*Line 76 - 'AtomDateListBox.js' */                    }
/*Line 77 - 'AtomDateListBox.js' */                }


/*Line 80 - 'AtomDateListBox.js' */                this.updateList();
/*Line 81 - 'AtomDateListBox.js' */                if (!t)
/*Line 82 - 'AtomDateListBox.js' */                    return;
/*Line 83 - 'AtomDateListBox.js' */                var list = this._items;
/*Line 84 - 'AtomDateListBox.js' */                for (var i = 0; i < 42; i++) {
/*Line 85 - 'AtomDateListBox.js' */                    var e = AtomUI.cloneNode(t);
/*Line 86 - 'AtomDateListBox.js' */                    e._templateParent = this;
/*Line 87 - 'AtomDateListBox.js' */                    var sc = new AtomScope(this, s, atomApplication);
/*Line 88 - 'AtomDateListBox.js' */                    sc.itemIndex = i;
/*Line 89 - 'AtomDateListBox.js' */                    $(its).append(e);
/*Line 90 - 'AtomDateListBox.js' */                    var ac = AtomUI.createControl(e, et, list[i], sc);
/*Line 91 - 'AtomDateListBox.js' */                }
/*Line 92 - 'AtomDateListBox.js' */            },

/*Line 94 - 'AtomDateListBox.js' */            toggleDate: function (scope, sender) {
/*Line 95 - 'AtomDateListBox.js' */                var item = sender.get_data();
/*Line 96 - 'AtomDateListBox.js' */                var s = $.inArray(item.value, $.map(this._selectedItems, function (a) { return a.value; }));
/*Line 97 - 'AtomDateListBox.js' */                if (s > -1) {

/*Line 99 - 'AtomDateListBox.js' */                    AtomBinder.removeAtIndex(this._selectedItems, s);
/*Line 100 - 'AtomDateListBox.js' */                } else {
/*Line 101 - 'AtomDateListBox.js' */                    AtomBinder.addItem(this._selectedItems, item);
/*Line 102 - 'AtomDateListBox.js' */                }
/*Line 103 - 'AtomDateListBox.js' */                AtomBinder.refreshValue(this, "value");
/*Line 104 - 'AtomDateListBox.js' */                AtomBinder.refreshValue(this, "selectedItems");
/*Line 105 - 'AtomDateListBox.js' */                this.invokeAction(this._next);
/*Line 106 - 'AtomDateListBox.js' */            },

/*Line 108 - 'AtomDateListBox.js' */            getItemClass: function (item, sv) {
/*Line 109 - 'AtomDateListBox.js' */                var s = $.inArray(item.value, $.map(this._selectedItems, function (a) { return a.value; })) > -1;
/*Line 110 - 'AtomDateListBox.js' */                var d = item.date.getDay();
/*Line 111 - 'AtomDateListBox.js' */                // weekend..
/*Line 112 - 'AtomDateListBox.js' */                var w = d == 0 || d == 6;

/*Line 114 - 'AtomDateListBox.js' */                var cls = "atom-date-list-box-day-list-item ";
/*Line 115 - 'AtomDateListBox.js' */                cls += w ? "atom-date-list-box-weekend " : "";
/*Line 116 - 'AtomDateListBox.js' */                cls += s ? "atom-date-list-box-selected " : "atom-date-list-box-item ";
/*Line 117 - 'AtomDateListBox.js' */                cls += (this._month == item.date.getMonth() + 1) ? "" : "atom-date-list-box-day-list-item-other";

/*Line 119 - 'AtomDateListBox.js' */                return cls;
/*Line 120 - 'AtomDateListBox.js' */            },

/*Line 122 - 'AtomDateListBox.js' */            set_value: function (v) {
/*Line 123 - 'AtomDateListBox.js' */                if (v === undefined) {
/*Line 124 - 'AtomDateListBox.js' */                    return;
/*Line 125 - 'AtomDateListBox.js' */                }
/*Line 126 - 'AtomDateListBox.js' */                this._selectedItems.length = 0;
/*Line 127 - 'AtomDateListBox.js' */                if (v !== null) {
/*Line 128 - 'AtomDateListBox.js' */                    var items = v.split(',');
/*Line 129 - 'AtomDateListBox.js' */                    for (var i = 0; i < items.length; i++) {
/*Line 130 - 'AtomDateListBox.js' */                        var item = items[i];
/*Line 131 - 'AtomDateListBox.js' */                        if (!item) {
/*Line 132 - 'AtomDateListBox.js' */                            continue;
/*Line 133 - 'AtomDateListBox.js' */                        }
/*Line 134 - 'AtomDateListBox.js' */                        var dts = item.split('/');
/*Line 135 - 'AtomDateListBox.js' */                        var d = new Date(parseInt(dts[2], 10), parseInt(dts[0], 10) - 1, parseInt(dts[1], 10));
/*Line 136 - 'AtomDateListBox.js' */                        this._selectedItems.push({ date: d, dateLabel: AtomDate.toShortDateString(d), value: item, label: d.getDate() });
/*Line 137 - 'AtomDateListBox.js' */                    }
/*Line 138 - 'AtomDateListBox.js' */                }
/*Line 139 - 'AtomDateListBox.js' */                if (this._created) {
/*Line 140 - 'AtomDateListBox.js' */                    AtomBinder.refreshItems(this._selectedItems);
/*Line 141 - 'AtomDateListBox.js' */                    AtomBinder.refreshValue(this, "value");
/*Line 142 - 'AtomDateListBox.js' */                    AtomBinder.refreshValue(this, "selectedItems");
/*Line 143 - 'AtomDateListBox.js' */                }
/*Line 144 - 'AtomDateListBox.js' */            },
/*Line 145 - 'AtomDateListBox.js' */            get_value: function (v) {
/*Line 146 - 'AtomDateListBox.js' */                return $.map(this._selectedItems, function (a) { return a.value; }).join(",");
/*Line 147 - 'AtomDateListBox.js' */            },

/*Line 149 - 'AtomDateListBox.js' */            updateList: function () {
/*Line 150 - 'AtomDateListBox.js' */                if (!this._month || !this._year)
/*Line 151 - 'AtomDateListBox.js' */                    return;

/*Line 153 - 'AtomDateListBox.js' */                var now = new Date();

/*Line 155 - 'AtomDateListBox.js' */                var d = new Date(this._year, this._month - 1, 1);
/*Line 156 - 'AtomDateListBox.js' */                var first = new Date(this._year, this._month - 1, 1);

/*Line 158 - 'AtomDateListBox.js' */                if (first.getDay()) {
/*Line 159 - 'AtomDateListBox.js' */                    // go to first day of the month...
/*Line 160 - 'AtomDateListBox.js' */                    var start = first.getDay() - 1;
/*Line 161 - 'AtomDateListBox.js' */                    start = -start;

/*Line 163 - 'AtomDateListBox.js' */                    first.setDate(start);
/*Line 164 - 'AtomDateListBox.js' */                }

/*Line 166 - 'AtomDateListBox.js' */                var m = first.getMonth();
/*Line 167 - 'AtomDateListBox.js' */                var y = first.getFullYear();

/*Line 169 - 'AtomDateListBox.js' */                var items = [];

/*Line 171 - 'AtomDateListBox.js' */                var i = 0;

/*Line 173 - 'AtomDateListBox.js' */                var cm = this._month - 1;

/*Line 175 - 'AtomDateListBox.js' */                for (i = 0; i < 42; i++) {
/*Line 176 - 'AtomDateListBox.js' */                    var cd = i + first.getDate();
/*Line 177 - 'AtomDateListBox.js' */                    var id = new Date(y, m, cd);
/*Line 178 - 'AtomDateListBox.js' */                    var w = id.getDay();
/*Line 179 - 'AtomDateListBox.js' */                    w = w == 0 || w == 6;
/*Line 180 - 'AtomDateListBox.js' */                    items.push({
/*Line 181 - 'AtomDateListBox.js' */                        label: id.getDate(),
/*Line 182 - 'AtomDateListBox.js' */                        isWeekEnd: w,
/*Line 183 - 'AtomDateListBox.js' */                        isToday:
/*Line 184 - 'AtomDateListBox.js' */                            now.getDate() == id.getDate()
/*Line 185 - 'AtomDateListBox.js' */                            && now.getMonth() == id.getMonth()
/*Line 186 - 'AtomDateListBox.js' */                            && now.getFullYear() == id.getFullYear(),
/*Line 187 - 'AtomDateListBox.js' */                        isOtherMonth: id.getMonth() != cm,
/*Line 188 - 'AtomDateListBox.js' */                        dateLabel: AtomDate.toShortDateString(id),
/*Line 189 - 'AtomDateListBox.js' */                        value: AtomDate.toMMDDYY(id),
/*Line 190 - 'AtomDateListBox.js' */                        date: id
/*Line 191 - 'AtomDateListBox.js' */                    });
/*Line 192 - 'AtomDateListBox.js' */                }

/*Line 194 - 'AtomDateListBox.js' */                this._items = items;
/*Line 195 - 'AtomDateListBox.js' */                AtomBinder.refreshValue(this, "items");
/*Line 196 - 'AtomDateListBox.js' */                AtomBinder.refreshValue(this, "selectedItems");
/*Line 197 - 'AtomDateListBox.js' */                if (this._created) {
/*Line 198 - 'AtomDateListBox.js' */                    AtomBinder.refreshValue(this, "value");
/*Line 199 - 'AtomDateListBox.js' */                }
/*Line 200 - 'AtomDateListBox.js' */            }
/*Line 201 - 'AtomDateListBox.js' */        }
/*Line 202 - 'AtomDateListBox.js' */    });
/*Line 203 - 'AtomDateListBox.js' */})(WebAtoms.AtomControl.prototype);
/*Line 0 - 'AtomDockPanel.js' */

/*Line 2 - 'AtomDockPanel.js' */(function (base) {

/*Line 4 - 'AtomDockPanel.js' */    var AtomUI = window.AtomUI;

/*Line 6 - 'AtomDockPanel.js' */    return classCreatorEx({
/*Line 7 - 'AtomDockPanel.js' */        name: "WebAtoms.AtomDockPanel",
/*Line 8 - 'AtomDockPanel.js' */        base: base,
/*Line 9 - 'AtomDockPanel.js' */        start: function (e) {
/*Line 10 - 'AtomDockPanel.js' */            $(e).addClass("atom-dock-panel");
/*Line 11 - 'AtomDockPanel.js' */        },
/*Line 12 - 'AtomDockPanel.js' */        properties: {
/*Line 13 - 'AtomDockPanel.js' */            resizeOnChildResized: false,
/*Line 14 - 'AtomDockPanel.js' */            contentWidth: 0
/*Line 15 - 'AtomDockPanel.js' */        },
/*Line 16 - 'AtomDockPanel.js' */        methods: {
/*Line 17 - 'AtomDockPanel.js' */            resizeChild: function (item) {
/*Line 18 - 'AtomDockPanel.js' */                if (item.atomControl) {
/*Line 19 - 'AtomDockPanel.js' */                    item.atomControl.updateUI();
/*Line 20 - 'AtomDockPanel.js' */                } else {
/*Line 21 - 'AtomDockPanel.js' */                    this.updateChildUI(item);
/*Line 22 - 'AtomDockPanel.js' */                }
/*Line 23 - 'AtomDockPanel.js' */            },

/*Line 25 - 'AtomDockPanel.js' */            calculateSize: function () {
/*Line 26 - 'AtomDockPanel.js' */                var element = this.get_element();
/*Line 27 - 'AtomDockPanel.js' */                var $element = $(element);
/*Line 28 - 'AtomDockPanel.js' */                var size = { width: $element.width(), height: $element.height() };

/*Line 30 - 'AtomDockPanel.js' */                //if (AtomBrowser.isIE && AtomBrowser.majorVersion < 10) {
/*Line 31 - 'AtomDockPanel.js' */                //    size = { width: element.offsetWidth, height: element.offsetHeight };
/*Line 32 - 'AtomDockPanel.js' */                //}else {

/*Line 34 - 'AtomDockPanel.js' */                //var s = AtomUI.getComputedStyle(element);

/*Line 36 - 'AtomDockPanel.js' */                //size = { width: AtomUI.parseStyleNumber(s.width), height: AtomUI.parseStyleNumber(s.height) };
/*Line 37 - 'AtomDockPanel.js' */                //}

/*Line 39 - 'AtomDockPanel.js' */                if (!this._resizeOnChildResized)
/*Line 40 - 'AtomDockPanel.js' */                    return size;

/*Line 42 - 'AtomDockPanel.js' */                var desiredHeight = 0;

/*Line 44 - 'AtomDockPanel.js' */                var ae = new ChildEnumerator(element);
/*Line 45 - 'AtomDockPanel.js' */                while (ae.next()) {
/*Line 46 - 'AtomDockPanel.js' */                    var child = ae.current();
/*Line 47 - 'AtomDockPanel.js' */                    var dock = AtomUI.attr(child, "atom-dock");
/*Line 48 - 'AtomDockPanel.js' */                    switch (dock) {
/*Line 49 - 'AtomDockPanel.js' */                        case "Bottom":
/*Line 50 - 'AtomDockPanel.js' */                        case "Fill":
/*Line 51 - 'AtomDockPanel.js' */                        case "Top":
/*Line 52 - 'AtomDockPanel.js' */                            var h;
/*Line 53 - 'AtomDockPanel.js' */                            if (AtomBrowser.isIE && AtomBrowser.majorVersion < 10) {
/*Line 54 - 'AtomDockPanel.js' */                                h = child.offsetHeight;
/*Line 55 - 'AtomDockPanel.js' */                            } else {
/*Line 56 - 'AtomDockPanel.js' */                                //h = AtomUI.getItemRect(child).height;
/*Line 57 - 'AtomDockPanel.js' */                                h = $(child).outerHeight(true);
/*Line 58 - 'AtomDockPanel.js' */                            }
/*Line 59 - 'AtomDockPanel.js' */                            desiredHeight += h;
/*Line 60 - 'AtomDockPanel.js' */                            break;
/*Line 61 - 'AtomDockPanel.js' */                    }
/*Line 62 - 'AtomDockPanel.js' */                }

/*Line 64 - 'AtomDockPanel.js' */                if (size.height < desiredHeight) {
/*Line 65 - 'AtomDockPanel.js' */                    size.height = desiredHeight;
/*Line 66 - 'AtomDockPanel.js' */                    $element.height(size.height);
/*Line 67 - 'AtomDockPanel.js' */                }

/*Line 69 - 'AtomDockPanel.js' */                return size;
/*Line 70 - 'AtomDockPanel.js' */            },

/*Line 72 - 'AtomDockPanel.js' */            onUpdateUI: function () {


/*Line 75 - 'AtomDockPanel.js' */                var element = this.get_element();
/*Line 76 - 'AtomDockPanel.js' */                var $element = $(element);

/*Line 78 - 'AtomDockPanel.js' */                var i;
/*Line 79 - 'AtomDockPanel.js' */                var left = 0;
/*Line 80 - 'AtomDockPanel.js' */                var top = parseInt($(element).css("paddingTop"), 10);

/*Line 82 - 'AtomDockPanel.js' */                var s = this.calculateSize();

/*Line 84 - 'AtomDockPanel.js' */                // is parent of this is body??
/*Line 85 - 'AtomDockPanel.js' */                var height = s.height;
/*Line 86 - 'AtomDockPanel.js' */                var width = s.width;

/*Line 88 - 'AtomDockPanel.js' */                if (this._contentWidth) {
/*Line 89 - 'AtomDockPanel.js' */                    left = (width - this._contentWidth) / 2;
/*Line 90 - 'AtomDockPanel.js' */                    width = this._contentWidth;
/*Line 91 - 'AtomDockPanel.js' */                }

/*Line 93 - 'AtomDockPanel.js' */                var children = [];
/*Line 94 - 'AtomDockPanel.js' */                var en;
/*Line 95 - 'AtomDockPanel.js' */                var item;

/*Line 97 - 'AtomDockPanel.js' */                var itemRect;
/*Line 98 - 'AtomDockPanel.js' */                var clientRect;

/*Line 100 - 'AtomDockPanel.js' */                var itemHeight;
/*Line 101 - 'AtomDockPanel.js' */                var itemWidth;

/*Line 103 - 'AtomDockPanel.js' */                var childList = {
/*Line 104 - 'AtomDockPanel.js' */                    top: [],
/*Line 105 - 'AtomDockPanel.js' */                    bottom: [],
/*Line 106 - 'AtomDockPanel.js' */                    left: [],
/*Line 107 - 'AtomDockPanel.js' */                    right: [],
/*Line 108 - 'AtomDockPanel.js' */                    fill:[]
/*Line 109 - 'AtomDockPanel.js' */                };

/*Line 111 - 'AtomDockPanel.js' */                isScriptOrStyle = /script|style/i;

/*Line 113 - 'AtomDockPanel.js' */                var ce = new ChildEnumerator(element);
/*Line 114 - 'AtomDockPanel.js' */                while (ce.next()) {
/*Line 115 - 'AtomDockPanel.js' */                    var e = ce.current();
/*Line 116 - 'AtomDockPanel.js' */                    if (isScriptOrStyle.test(e.tagName))
/*Line 117 - 'AtomDockPanel.js' */                        continue;
/*Line 118 - 'AtomDockPanel.js' */                    var $e = $(e);
/*Line 119 - 'AtomDockPanel.js' */                    if ($e.is(".dock-left,[dock$='Left']")) {
/*Line 120 - 'AtomDockPanel.js' */                        childList.left.push(e);
/*Line 121 - 'AtomDockPanel.js' */                        continue;
/*Line 122 - 'AtomDockPanel.js' */                    }
/*Line 123 - 'AtomDockPanel.js' */                    if ($e.is(".dock-right,[dock$='Right']")) {
/*Line 124 - 'AtomDockPanel.js' */                        childList.right.push(e);
/*Line 125 - 'AtomDockPanel.js' */                        continue;
/*Line 126 - 'AtomDockPanel.js' */                    }
/*Line 127 - 'AtomDockPanel.js' */                    if ($e.is("header,.dock-top,[dock$='Top']")) {
/*Line 128 - 'AtomDockPanel.js' */                        childList.top.push(e);
/*Line 129 - 'AtomDockPanel.js' */                        continue;
/*Line 130 - 'AtomDockPanel.js' */                    }
/*Line 131 - 'AtomDockPanel.js' */                    if ($e.is("footer,.dock-bottom,[dock$='Bottom']")) {
/*Line 132 - 'AtomDockPanel.js' */                        childList.bottom.push(e);
/*Line 133 - 'AtomDockPanel.js' */                        continue;
/*Line 134 - 'AtomDockPanel.js' */                    }
/*Line 135 - 'AtomDockPanel.js' */                    if ($e.is("section,.dock-fill,[dock$='Fill']")) {
/*Line 136 - 'AtomDockPanel.js' */                        childList.fill.push(e);
/*Line 137 - 'AtomDockPanel.js' */                        continue;
/*Line 138 - 'AtomDockPanel.js' */                    }
/*Line 139 - 'AtomDockPanel.js' */                    //childList.fill.push(e);
/*Line 140 - 'AtomDockPanel.js' */                }

/*Line 142 - 'AtomDockPanel.js' */                en = new AtomEnumerator(childList.top);
/*Line 143 - 'AtomDockPanel.js' */                while (en.next()) {
/*Line 144 - 'AtomDockPanel.js' */                    item = en.current();

/*Line 146 - 'AtomDockPanel.js' */                    itemHeight = $(item).outerHeight(true);

/*Line 148 - 'AtomDockPanel.js' */                    AtomUI.setItemRect(item, { top: top, left: left, width: width });

/*Line 150 - 'AtomDockPanel.js' */                    top += itemHeight;
/*Line 151 - 'AtomDockPanel.js' */                    height -= itemHeight;

/*Line 153 - 'AtomDockPanel.js' */                    this.resizeChild(item);
/*Line 154 - 'AtomDockPanel.js' */                }

/*Line 156 - 'AtomDockPanel.js' */                en = new AtomEnumerator(childList.bottom.reverse());
/*Line 157 - 'AtomDockPanel.js' */                while (en.next()) {
/*Line 158 - 'AtomDockPanel.js' */                    item = en.current();
/*Line 159 - 'AtomDockPanel.js' */                    itemHeight = $(item).outerHeight(true);

/*Line 161 - 'AtomDockPanel.js' */                    height -= itemHeight;

/*Line 163 - 'AtomDockPanel.js' */                    AtomUI.setItemRect(item, { left: left, top: (top + height), width: width });

/*Line 165 - 'AtomDockPanel.js' */                    this.resizeChild(item);
/*Line 166 - 'AtomDockPanel.js' */                }

/*Line 168 - 'AtomDockPanel.js' */                en = new AtomEnumerator(childList.left);
/*Line 169 - 'AtomDockPanel.js' */                while (en.next()) {
/*Line 170 - 'AtomDockPanel.js' */                    item = en.current();

/*Line 172 - 'AtomDockPanel.js' */                    var itemWidth = $(item).outerWidth(true);
/*Line 173 - 'AtomDockPanel.js' */                    width -= itemWidth;

/*Line 175 - 'AtomDockPanel.js' */                    AtomUI.setItemRect(item, { top: top, left: left, height: height });
/*Line 176 - 'AtomDockPanel.js' */                    left += itemWidth;

/*Line 178 - 'AtomDockPanel.js' */                    this.resizeChild(item);
/*Line 179 - 'AtomDockPanel.js' */                }

/*Line 181 - 'AtomDockPanel.js' */                en = new AtomEnumerator(childList.right.reverse());
/*Line 182 - 'AtomDockPanel.js' */                while (en.next()) {
/*Line 183 - 'AtomDockPanel.js' */                    item = en.current();
/*Line 184 - 'AtomDockPanel.js' */                    var itemWidth = $(item).outerWidth(true);
/*Line 185 - 'AtomDockPanel.js' */                    width -= itemWidth;

/*Line 187 - 'AtomDockPanel.js' */                    AtomUI.setItemRect(item, { left: (width + left), top: top, height: height });

/*Line 189 - 'AtomDockPanel.js' */                    this.resizeChild(item);
/*Line 190 - 'AtomDockPanel.js' */                }

/*Line 192 - 'AtomDockPanel.js' */                en = new AtomEnumerator(childList.fill);
/*Line 193 - 'AtomDockPanel.js' */                while (en.next()) {
/*Line 194 - 'AtomDockPanel.js' */                    item = en.current();
/*Line 195 - 'AtomDockPanel.js' */                    itemWidth = $(item).css("max-width");
/*Line 196 - 'AtomDockPanel.js' */                    if (itemWidth) {
/*Line 197 - 'AtomDockPanel.js' */                        itemWidth = parseFloat(itemWidth);
/*Line 198 - 'AtomDockPanel.js' */                        if (itemWidth > 0) {
/*Line 199 - 'AtomDockPanel.js' */                            width = itemWidth;
/*Line 200 - 'AtomDockPanel.js' */                        }
/*Line 201 - 'AtomDockPanel.js' */                    }

/*Line 203 - 'AtomDockPanel.js' */                    AtomUI.setItemRect(item, { left: left, top: top, width: width, height: height });

/*Line 205 - 'AtomDockPanel.js' */                    this.resizeChild(item);
/*Line 206 - 'AtomDockPanel.js' */                }

/*Line 208 - 'AtomDockPanel.js' */            }
/*Line 209 - 'AtomDockPanel.js' */        }
/*Line 210 - 'AtomDockPanel.js' */    });
/*Line 211 - 'AtomDockPanel.js' */})(WebAtoms.AtomControl.prototype);

/*Line 0 - 'AtomPostButton.js' */

/*Line 2 - 'AtomPostButton.js' */(function (base) {
/*Line 3 - 'AtomPostButton.js' */    return classCreatorEx({
/*Line 4 - 'AtomPostButton.js' */        name: "WebAtoms.AtomPostButton",
/*Line 5 - 'AtomPostButton.js' */        base: base,
/*Line 6 - 'AtomPostButton.js' */        start:function(){
/*Line 7 - 'AtomPostButton.js' */        },
/*Line 8 - 'AtomPostButton.js' */        properties: {
/*Line 9 - 'AtomPostButton.js' */            postData: null,
/*Line 10 - 'AtomPostButton.js' */            postResult: null,
/*Line 11 - 'AtomPostButton.js' */            postUrl: null,
/*Line 12 - 'AtomPostButton.js' */            next: null,
/*Line 13 - 'AtomPostButton.js' */            confirm: false,
/*Line 14 - 'AtomPostButton.js' */            confirmMessage: null,
/*Line 15 - 'AtomPostButton.js' */            mergeData: null,
/*Line 16 - 'AtomPostButton.js' */            errorNext: null
/*Line 17 - 'AtomPostButton.js' */        },
/*Line 18 - 'AtomPostButton.js' */        methods: {
/*Line 19 - 'AtomPostButton.js' */            get_postData: function () {
/*Line 20 - 'AtomPostButton.js' */                return this._postData || this.get_data();
/*Line 21 - 'AtomPostButton.js' */            },

/*Line 23 - 'AtomPostButton.js' */            onClickHandler: function (e) {

/*Line 25 - 'AtomPostButton.js' */                var inv = this._invalid;
/*Line 26 - 'AtomPostButton.js' */                if (inv) {
/*Line 27 - 'AtomPostButton.js' */                    if ($.isArray(inv)) {
/*Line 28 - 'AtomPostButton.js' */                        inv = inv.join();
/*Line 29 - 'AtomPostButton.js' */                    }
/*Line 30 - 'AtomPostButton.js' */                    if (inv) {
/*Line 31 - 'AtomPostButton.js' */                        alert(inv);
/*Line 32 - 'AtomPostButton.js' */                        return;
/*Line 33 - 'AtomPostButton.js' */                    }
/*Line 34 - 'AtomPostButton.js' */                }


/*Line 37 - 'AtomPostButton.js' */                if (this._confirm) {
/*Line 38 - 'AtomPostButton.js' */                    var _this = this;
/*Line 39 - 'AtomPostButton.js' */                    Atom.confirm(this._confirmMessage, function () {
/*Line 40 - 'AtomPostButton.js' */                        _this.onConfirmed(e);
/*Line 41 - 'AtomPostButton.js' */                    });
/*Line 42 - 'AtomPostButton.js' */                    return;
/*Line 43 - 'AtomPostButton.js' */                }
/*Line 44 - 'AtomPostButton.js' */                this.onConfirmed(e);
/*Line 45 - 'AtomPostButton.js' */            },

/*Line 47 - 'AtomPostButton.js' */            onConfirmed: function (e) {


/*Line 50 - 'AtomPostButton.js' */                if (!this._postUrl) {
/*Line 51 - 'AtomPostButton.js' */                    base.onClickHandler.apply(this, arguments);
/*Line 52 - 'AtomPostButton.js' */                    return;
/*Line 53 - 'AtomPostButton.js' */                }


/*Line 56 - 'AtomPostButton.js' */                var data = this.get_postData();

/*Line 58 - 'AtomPostButton.js' */                if (data === null || data === undefined)
/*Line 59 - 'AtomPostButton.js' */                    return;

/*Line 61 - 'AtomPostButton.js' */                var m = this._mergeData;
/*Line 62 - 'AtomPostButton.js' */                if (m) {
/*Line 63 - 'AtomPostButton.js' */                    for (var i in m) {
/*Line 64 - 'AtomPostButton.js' */                        data[i] = m[i];
/*Line 65 - 'AtomPostButton.js' */                    }
/*Line 66 - 'AtomPostButton.js' */                }

/*Line 68 - 'AtomPostButton.js' */                //data = AtomBinder.getClone(data);

/*Line 70 - 'AtomPostButton.js' */                var caller = this;
/*Line 71 - 'AtomPostButton.js' */                var invokeNext = function (p) {
/*Line 72 - 'AtomPostButton.js' */                    AtomBinder.setValue(caller, "postResult", p.value());
/*Line 73 - 'AtomPostButton.js' */                    caller.invokeAction(caller._next);
/*Line 74 - 'AtomPostButton.js' */                };

/*Line 76 - 'AtomPostButton.js' */                //this.invokeAjax(this._postUrl, { type: "POST", data: data, success: invokeNext });
/*Line 77 - 'AtomPostButton.js' */                AtomPromise.json(this._postUrl, null, { type: "POST", data: data }).then(invokeNext).failed(function () {
/*Line 78 - 'AtomPostButton.js' */                    var en = caller.get_errorNext();
/*Line 79 - 'AtomPostButton.js' */                    if (en) {
/*Line 80 - 'AtomPostButton.js' */                        caller.invokeAction(en);
/*Line 81 - 'AtomPostButton.js' */                    }
/*Line 82 - 'AtomPostButton.js' */                }).invoke();

/*Line 84 - 'AtomPostButton.js' */            }
/*Line 85 - 'AtomPostButton.js' */        }
/*Line 86 - 'AtomPostButton.js' */    });
/*Line 87 - 'AtomPostButton.js' */})(WebAtoms.AtomButton.prototype);
/*Line 0 - 'AtomToggleButtonBar.js' */

/*Line 2 - 'AtomToggleButtonBar.js' */(function (baseType) {
/*Line 3 - 'AtomToggleButtonBar.js' */    return classCreatorEx({
/*Line 4 - 'AtomToggleButtonBar.js' */        name: "WebAtoms.AtomToggleButtonBar",
/*Line 5 - 'AtomToggleButtonBar.js' */        base: baseType,
/*Line 6 - 'AtomToggleButtonBar.js' */        start: function (e) {
/*Line 7 - 'AtomToggleButtonBar.js' */            this._allowSelectFirst = true;
/*Line 8 - 'AtomToggleButtonBar.js' */            this._allowMultipleSelection = false;
/*Line 9 - 'AtomToggleButtonBar.js' */            this._showTabs = false;
/*Line 10 - 'AtomToggleButtonBar.js' */            this._autoScrollToSelection = false;

/*Line 12 - 'AtomToggleButtonBar.js' */            //$(e).removeClass("atom-list-box");

/*Line 14 - 'AtomToggleButtonBar.js' */            //if (! /ul/i.test(e.tagName)) {
/*Line 15 - 'AtomToggleButtonBar.js' */            //    //throw new Error("Button bar can only support UL style");
/*Line 16 - 'AtomToggleButtonBar.js' */            //    log("Button bar can only support UL style");
/*Line 17 - 'AtomToggleButtonBar.js' */            //}

/*Line 19 - 'AtomToggleButtonBar.js' */        },
/*Line 20 - 'AtomToggleButtonBar.js' */        properties: {
/*Line 21 - 'AtomToggleButtonBar.js' */            showTabs: false
/*Line 22 - 'AtomToggleButtonBar.js' */        },
/*Line 23 - 'AtomToggleButtonBar.js' */        methods: {

/*Line 25 - 'AtomToggleButtonBar.js' */            setClass: function () {
/*Line 26 - 'AtomToggleButtonBar.js' */                var $e = $(this._element);
/*Line 27 - 'AtomToggleButtonBar.js' */                $e.removeClass("atom-tab-bar atom-toggle-button-bar");
/*Line 28 - 'AtomToggleButtonBar.js' */                $e.addClass(this._showTabs ? 'atom-tab-bar' : 'atom-toggle-button-bar');
/*Line 29 - 'AtomToggleButtonBar.js' */            },

/*Line 31 - 'AtomToggleButtonBar.js' */            set_showTabs: function (v) {
/*Line 32 - 'AtomToggleButtonBar.js' */                this._showTabs = v;
/*Line 33 - 'AtomToggleButtonBar.js' */                this.setClass();
/*Line 34 - 'AtomToggleButtonBar.js' */            }
/*Line 35 - 'AtomToggleButtonBar.js' */        }
/*Line 36 - 'AtomToggleButtonBar.js' */    });
/*Line 37 - 'AtomToggleButtonBar.js' */})(WebAtoms.AtomListBox.prototype);
/*Line 0 - 'AtomViewStack.js' */

/*Line 2 - 'AtomViewStack.js' */(function (baseType) {

/*Line 4 - 'AtomViewStack.js' */    return classCreatorEx({
/*Line 5 - 'AtomViewStack.js' */        name: "WebAtoms.AtomViewStack",
/*Line 6 - 'AtomViewStack.js' */        base: baseType,
/*Line 7 - 'AtomViewStack.js' */        start: function (e) {
/*Line 8 - 'AtomViewStack.js' */            this._swipeDirection = 'left-right';
/*Line 9 - 'AtomViewStack.js' */        },
/*Line 10 - 'AtomViewStack.js' */        properties: {
/*Line 11 - 'AtomViewStack.js' */            selectedIndex: -1,
/*Line 12 - 'AtomViewStack.js' */            previousIndex: -1,
/*Line 13 - 'AtomViewStack.js' */            swipeDirection: 'left-right'
/*Line 14 - 'AtomViewStack.js' */        },
/*Line 15 - 'AtomViewStack.js' */        methods: {
/*Line 16 - 'AtomViewStack.js' */            bringSelectionIntoView: function () {
/*Line 17 - 'AtomViewStack.js' */            },
/*Line 18 - 'AtomViewStack.js' */            set_swipeDirection: function (v) {
/*Line 19 - 'AtomViewStack.js' */                var ov = this._swipeDirection;
/*Line 20 - 'AtomViewStack.js' */                if (ov) {
/*Line 21 - 'AtomViewStack.js' */                    $(this._element).removeClass(ov);
/*Line 22 - 'AtomViewStack.js' */                }
/*Line 23 - 'AtomViewStack.js' */                this._swipeDirection = v;
/*Line 24 - 'AtomViewStack.js' */                if (v) {
/*Line 25 - 'AtomViewStack.js' */                    $(this._element).addClass(v);
/*Line 26 - 'AtomViewStack.js' */                }
/*Line 27 - 'AtomViewStack.js' */            },
/*Line 28 - 'AtomViewStack.js' */            set_selectedIndex: function (v) {

/*Line 30 - 'AtomViewStack.js' */                if (this._isAnimating) {
/*Line 31 - 'AtomViewStack.js' */                    var self = this;
/*Line 32 - 'AtomViewStack.js' */                    setTimeout(function () {
/*Line 33 - 'AtomViewStack.js' */                        self.set_selectedIndex(v);
/*Line 34 - 'AtomViewStack.js' */                    }, 50);
/*Line 35 - 'AtomViewStack.js' */                    return;
/*Line 36 - 'AtomViewStack.js' */                }
/*Line 37 - 'AtomViewStack.js' */                if (v == this._selectedIndex)
/*Line 38 - 'AtomViewStack.js' */                    return;
/*Line 39 - 'AtomViewStack.js' */                this._previousIndex = this._selectedIndex;
/*Line 40 - 'AtomViewStack.js' */                this._selectedIndex = v;
/*Line 41 - 'AtomViewStack.js' */                this.updateUI();
/*Line 42 - 'AtomViewStack.js' */            },
/*Line 43 - 'AtomViewStack.js' */            get_selectedChild: function () {
/*Line 44 - 'AtomViewStack.js' */                return this._selectedChild;
/*Line 45 - 'AtomViewStack.js' */            },
/*Line 46 - 'AtomViewStack.js' */            onUpdateUI: function () {

/*Line 48 - 'AtomViewStack.js' */                var element = this._element;
/*Line 49 - 'AtomViewStack.js' */                var childEn = new ChildEnumerator(element);

/*Line 51 - 'AtomViewStack.js' */                var selectedIndex = this.get_selectedIndex();
/*Line 52 - 'AtomViewStack.js' */                var previousIndex = this._previousIndex;

/*Line 54 - 'AtomViewStack.js' */                var queue = WebAtoms.dispatcher;
/*Line 55 - 'AtomViewStack.js' */                queue.pause();

/*Line 57 - 'AtomViewStack.js' */                var i = -1;

/*Line 59 - 'AtomViewStack.js' */                var self = this;

/*Line 61 - 'AtomViewStack.js' */                var selectedElement, previousElement;

/*Line 63 - 'AtomViewStack.js' */                while (childEn.next()) {
/*Line 64 - 'AtomViewStack.js' */                    i = i + 1;
/*Line 65 - 'AtomViewStack.js' */                    var item = childEn.current();
/*Line 66 - 'AtomViewStack.js' */                    var $item = $(item);
/*Line 67 - 'AtomViewStack.js' */                    $item.addClass("view-stack-child");
/*Line 68 - 'AtomViewStack.js' */                    if (previousIndex == -1) {
/*Line 69 - 'AtomViewStack.js' */                        $item.addClass("hidden");
/*Line 70 - 'AtomViewStack.js' */                    }
/*Line 71 - 'AtomViewStack.js' */                    if (i == selectedIndex) {
/*Line 72 - 'AtomViewStack.js' */                        selectedElement = item;
/*Line 73 - 'AtomViewStack.js' */                    } else if (i == previousIndex) {
/*Line 74 - 'AtomViewStack.js' */                        previousElement = item;
/*Line 75 - 'AtomViewStack.js' */                    } else {
/*Line 76 - 'AtomViewStack.js' */                        $item.addClass("hidden");
/*Line 77 - 'AtomViewStack.js' */                    }
/*Line 78 - 'AtomViewStack.js' */                }

/*Line 80 - 'AtomViewStack.js' */                if (selectedElement) {
/*Line 81 - 'AtomViewStack.js' */                    var width = $(element).innerWidth();
/*Line 82 - 'AtomViewStack.js' */                    var height = $(element).innerHeight();

/*Line 84 - 'AtomViewStack.js' */                    this._selectedChild = selectedElement;

/*Line 86 - 'AtomViewStack.js' */                    AtomUI.setItemRect(selectedElement, { width: width, height: height });
/*Line 87 - 'AtomViewStack.js' */                    var sac = selectedElement.atomControl;
/*Line 88 - 'AtomViewStack.js' */                    if (sac) {
/*Line 89 - 'AtomViewStack.js' */                        sac.updateUI();
/*Line 90 - 'AtomViewStack.js' */                    }

/*Line 92 - 'AtomViewStack.js' */                    if (previousElement && previousElement != selectedElement) {
/*Line 93 - 'AtomViewStack.js' */                        var self = this;


/*Line 96 - 'AtomViewStack.js' */                        var sd = this._swipeDirection;
/*Line 97 - 'AtomViewStack.js' */                        if (sd != null && /none/i.test(sd)) {
/*Line 98 - 'AtomViewStack.js' */                            $(previousElement).addClass("hidden");
/*Line 99 - 'AtomViewStack.js' */                            $(selectedElement).removeClass("hidden");
/*Line 100 - 'AtomViewStack.js' */                        } else {
/*Line 101 - 'AtomViewStack.js' */                            // animate...
/*Line 102 - 'AtomViewStack.js' */                            var ael = [selectedElement, previousElement];
/*Line 103 - 'AtomViewStack.js' */                            $(ael).removeClass("hidden");
/*Line 104 - 'AtomViewStack.js' */                            this._isAnimating = true;
/*Line 105 - 'AtomViewStack.js' */                            if (selectedIndex < previousIndex) {
/*Line 106 - 'AtomViewStack.js' */                                $(selectedElement).css("left", -width);
/*Line 107 - 'AtomViewStack.js' */                                //log("left: -" + width);
/*Line 108 - 'AtomViewStack.js' */                            } else {
/*Line 109 - 'AtomViewStack.js' */                                $(selectedElement).css("left", width);
/*Line 110 - 'AtomViewStack.js' */                                //log("left: " + width);
/*Line 111 - 'AtomViewStack.js' */                            }
/*Line 112 - 'AtomViewStack.js' */                            $(ael).addClass("animate-left-property");
/*Line 113 - 'AtomViewStack.js' */                            setTimeout(function () {
/*Line 114 - 'AtomViewStack.js' */                                $(selectedElement).css("left", 0);
/*Line 115 - 'AtomViewStack.js' */                                //log("left: 0");
/*Line 116 - 'AtomViewStack.js' */                                if (selectedIndex < previousIndex) {
/*Line 117 - 'AtomViewStack.js' */                                    $(previousElement).css("left", width);
/*Line 118 - 'AtomViewStack.js' */                                } else {
/*Line 119 - 'AtomViewStack.js' */                                    $(previousElement).css("left", -width);
/*Line 120 - 'AtomViewStack.js' */                                }
/*Line 121 - 'AtomViewStack.js' */                                setTimeout(function () {
/*Line 122 - 'AtomViewStack.js' */                                    self._isAnimating = false;
/*Line 123 - 'AtomViewStack.js' */                                    $(ael).removeClass("animate-left-property");
/*Line 124 - 'AtomViewStack.js' */                                    $(previousElement).addClass("hidden");
/*Line 125 - 'AtomViewStack.js' */                                }, 800);
/*Line 126 - 'AtomViewStack.js' */                            }, 50);
/*Line 127 - 'AtomViewStack.js' */                        }
/*Line 128 - 'AtomViewStack.js' */                    } else {
/*Line 129 - 'AtomViewStack.js' */                        $(selectedElement).removeClass("hidden");
/*Line 130 - 'AtomViewStack.js' */                    }
/*Line 131 - 'AtomViewStack.js' */                }

/*Line 133 - 'AtomViewStack.js' */                queue.start();

/*Line 135 - 'AtomViewStack.js' */            },
/*Line 136 - 'AtomViewStack.js' */            init: function () {
/*Line 137 - 'AtomViewStack.js' */                var element = this.get_element();
/*Line 138 - 'AtomViewStack.js' */                $(element).addClass("atom-view-stack");
/*Line 139 - 'AtomViewStack.js' */                baseType.init.call(this);

/*Line 141 - 'AtomViewStack.js' */                var element = this.get_element();

/*Line 143 - 'AtomViewStack.js' */                if (!element.parentNode.atomControl) {
/*Line 144 - 'AtomViewStack.js' */                    $(element).addClass("atom-view-stack-fill");
/*Line 145 - 'AtomViewStack.js' */                }
/*Line 146 - 'AtomViewStack.js' */                $(element).addClass(this._swipeDirection);

/*Line 148 - 'AtomViewStack.js' */                //this.updateUI();
/*Line 149 - 'AtomViewStack.js' */            }
/*Line 150 - 'AtomViewStack.js' */        }
/*Line 151 - 'AtomViewStack.js' */    });
/*Line 152 - 'AtomViewStack.js' */})(WebAtoms.AtomControl.prototype);

/*Line 0 - 'AtomForm.js' */

/*Line 2 - 'AtomForm.js' */(function (baseType) {
/*Line 3 - 'AtomForm.js' */    return classCreatorEx({
/*Line 4 - 'AtomForm.js' */        name: "WebAtoms.AtomForm",
/*Line 5 - 'AtomForm.js' */        base: baseType,
/*Line 6 - 'AtomForm.js' */        start: function () {
/*Line 7 - 'AtomForm.js' */            this._success = null;
/*Line 8 - 'AtomForm.js' */            this._submit = null;
/*Line 9 - 'AtomForm.js' */            this._error = null;
/*Line 10 - 'AtomForm.js' */            this._attachments = null;
/*Line 11 - 'AtomForm.js' */        },
/*Line 12 - 'AtomForm.js' */        properties: {
/*Line 13 - 'AtomForm.js' */            result: null,
/*Line 14 - 'AtomForm.js' */            mergeData: null,
/*Line 15 - 'AtomForm.js' */            mergeResult: true,
/*Line 16 - 'AtomForm.js' */            postUrl: null,
/*Line 17 - 'AtomForm.js' */            postData: null,
/*Line 18 - 'AtomForm.js' */            successMessage: null,
/*Line 19 - 'AtomForm.js' */            clearData:false
/*Line 20 - 'AtomForm.js' */        },
/*Line 21 - 'AtomForm.js' */        methods: {
/*Line 22 - 'AtomForm.js' */            createFormLayout: function () {
/*Line 23 - 'AtomForm.js' */            },


/*Line 26 - 'AtomForm.js' */            preparePostData: function () {


/*Line 29 - 'AtomForm.js' */                var element = this.get_element();
/*Line 30 - 'AtomForm.js' */                var data = this._postData || this.get_data();

/*Line 32 - 'AtomForm.js' */                var m = this._mergeData;
/*Line 33 - 'AtomForm.js' */                if (m) {
/*Line 34 - 'AtomForm.js' */                    for (var i in m) {
/*Line 35 - 'AtomForm.js' */                        data[i] = m[i];
/*Line 36 - 'AtomForm.js' */                    }
/*Line 37 - 'AtomForm.js' */                }

/*Line 39 - 'AtomForm.js' */                return data;
/*Line 40 - 'AtomForm.js' */            },

/*Line 42 - 'AtomForm.js' */            onSubmit: function () {

/*Line 44 - 'AtomForm.js' */                if (!this.isValid()) {
/*Line 45 - 'AtomForm.js' */                    Atom.alert("Please complete all required fields");
/*Line 46 - 'AtomForm.js' */                    return;
/*Line 47 - 'AtomForm.js' */                }

/*Line 49 - 'AtomForm.js' */                var data = this.preparePostData();
/*Line 50 - 'AtomForm.js' */                var url = AtomPromise.getUrl(this._postUrl);
/*Line 51 - 'AtomForm.js' */                AtomPromise.json(url, { _tv: Atom.time() }, { type: "POST", data: data }).then(this._success).invoke();
/*Line 52 - 'AtomForm.js' */            },

/*Line 54 - 'AtomForm.js' */            onSuccess: function (p) {

/*Line 56 - 'AtomForm.js' */                var result = p.value();

/*Line 58 - 'AtomForm.js' */                AtomBinder.setValue(this, "result", result);

/*Line 60 - 'AtomForm.js' */                if (this._mergeResult) {
/*Line 61 - 'AtomForm.js' */                    // merge...
/*Line 62 - 'AtomForm.js' */                    // AtomBinder.setValue(this, "data", result);
/*Line 63 - 'AtomForm.js' */                    var data = this.get_data();
/*Line 64 - 'AtomForm.js' */                    for (var index in result) {
/*Line 65 - 'AtomForm.js' */                        AtomBinder.setValue(data, index, result[index]);
/*Line 66 - 'AtomForm.js' */                    }
/*Line 67 - 'AtomForm.js' */                }

/*Line 69 - 'AtomForm.js' */                if (this._clearData) {
/*Line 70 - 'AtomForm.js' */                    var data = this.get_data();
/*Line 71 - 'AtomForm.js' */                    for (var index in this._clearData) {
/*Line 72 - 'AtomForm.js' */                        AtomBinder.setValue(data, index, result[index]);
/*Line 73 - 'AtomForm.js' */                    }
/*Line 74 - 'AtomForm.js' */                }

/*Line 76 - 'AtomForm.js' */                if (this._successMessage) {
/*Line 77 - 'AtomForm.js' */                    Atom.alert(this._successMessage);
/*Line 78 - 'AtomForm.js' */                }

/*Line 80 - 'AtomForm.js' */                this.invokeAction(this._next);

/*Line 82 - 'AtomForm.js' */            },

/*Line 84 - 'AtomForm.js' */            onKeyUp: function (e) {
/*Line 85 - 'AtomForm.js' */                if (e.target && e.target.nodeName && /textarea/gi.test(e.target.nodeName))
/*Line 86 - 'AtomForm.js' */                    return;
/*Line 87 - 'AtomForm.js' */                if (e.keyCode == 13) {
/*Line 88 - 'AtomForm.js' */                    var _this = this;
/*Line 89 - 'AtomForm.js' */                    // fix for IE 11, IE 11 does not fire Change event on enter
/*Line 90 - 'AtomForm.js' */                    if (/input/gi.test(e.target.nodeName)) {
/*Line 91 - 'AtomForm.js' */                        $(e.target).change();
/*Line 92 - 'AtomForm.js' */                    }
/*Line 93 - 'AtomForm.js' */                    WebAtoms.dispatcher.callLater(function () {
/*Line 94 - 'AtomForm.js' */                        _this.onSubmit();
/*Line 95 - 'AtomForm.js' */                    });
/*Line 96 - 'AtomForm.js' */                }
/*Line 97 - 'AtomForm.js' */            },

/*Line 99 - 'AtomForm.js' */            isValid: function () {
/*Line 100 - 'AtomForm.js' */                var element = this.get_element();
/*Line 101 - 'AtomForm.js' */                var ae = new ChildEnumerator(element);
/*Line 102 - 'AtomForm.js' */                var formValid = true;
/*Line 103 - 'AtomForm.js' */                while (ae.next()) {
/*Line 104 - 'AtomForm.js' */                    var field = ae.current();
/*Line 105 - 'AtomForm.js' */                    if (!this.validate(field))
/*Line 106 - 'AtomForm.js' */                        formValid = false;
/*Line 107 - 'AtomForm.js' */                }
/*Line 108 - 'AtomForm.js' */                return formValid;
/*Line 109 - 'AtomForm.js' */            },


/*Line 112 - 'AtomForm.js' */            validateField: function (e) {
/*Line 113 - 'AtomForm.js' */                var target = e.target;
/*Line 114 - 'AtomForm.js' */                this.validate(target);
/*Line 115 - 'AtomForm.js' */            },

/*Line 117 - 'AtomForm.js' */            validate: function (e, ef) {

/*Line 119 - 'AtomForm.js' */                if (!ef)
/*Line 120 - 'AtomForm.js' */                    ef = $(e).data("field-error");

/*Line 122 - 'AtomForm.js' */                var ctrl = e.atomControl;
/*Line 123 - 'AtomForm.js' */                var val = null;
/*Line 124 - 'AtomForm.js' */                var skip = false;
/*Line 125 - 'AtomForm.js' */                if (!ctrl) {
/*Line 126 - 'AtomForm.js' */                    if ((/input|select|textarea/i).test(e.nodeName)) {
/*Line 127 - 'AtomForm.js' */                        val = $(e).val();
/*Line 128 - 'AtomForm.js' */                    } else {
/*Line 129 - 'AtomForm.js' */                        skip = true;
/*Line 130 - 'AtomForm.js' */                    }
/*Line 131 - 'AtomForm.js' */                } else {
/*Line 132 - 'AtomForm.js' */                    if (ctrl.constructor == WebAtoms.AtomFormField) {
/*Line 133 - 'AtomForm.js' */                        return ctrl.validate();
/*Line 134 - 'AtomForm.js' */                    }
/*Line 135 - 'AtomForm.js' */                    val = AtomBinder.getValue(ctrl, "value");
/*Line 136 - 'AtomForm.js' */                }

/*Line 138 - 'AtomForm.js' */                if (!skip) {

/*Line 140 - 'AtomForm.js' */                    var req = AtomUI.attr(e,"atom-required");
/*Line 141 - 'AtomForm.js' */                    if (req && !val) {
/*Line 142 - 'AtomForm.js' */                        // error...
/*Line 143 - 'AtomForm.js' */                        AtomProperties.text(ef, "Required");
/*Line 144 - 'AtomForm.js' */                        $(e).addClass("atom-data-error");
/*Line 145 - 'AtomForm.js' */                        return false;
/*Line 146 - 'AtomForm.js' */                    }


/*Line 149 - 'AtomForm.js' */                    var re = AtomUI.attr(e, "atom-regex");
/*Line 150 - 'AtomForm.js' */                    if (!re) {
/*Line 151 - 'AtomForm.js' */                        var dt = AtomUI.attr(e, "atom-data-type");
/*Line 152 - 'AtomForm.js' */                        if (dt) {
/*Line 153 - 'AtomForm.js' */                            switch (dt) {
/*Line 154 - 'AtomForm.js' */                                case "email":
/*Line 155 - 'AtomForm.js' */                                    re = /^(([^<>()\[\]\\.,;:\s@\"]+(\.[^<>()\[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
/*Line 156 - 'AtomForm.js' */                                    break;
/*Line 157 - 'AtomForm.js' */                            }
/*Line 158 - 'AtomForm.js' */                        }
/*Line 159 - 'AtomForm.js' */                    } else {
/*Line 160 - 'AtomForm.js' */                        re = eval("(" + re + ")");
/*Line 161 - 'AtomForm.js' */                    }

/*Line 163 - 'AtomForm.js' */                    if (re) {
/*Line 164 - 'AtomForm.js' */                        if (!re.test(val)) {
/*Line 165 - 'AtomForm.js' */                            $(ef).text("Invalid");
/*Line 166 - 'AtomForm.js' */                            $(e).addClass("atom-data-error");
/*Line 167 - 'AtomForm.js' */                            return false;
/*Line 168 - 'AtomForm.js' */                        }
/*Line 169 - 'AtomForm.js' */                    }

/*Line 171 - 'AtomForm.js' */                    $(ef).text("");
/*Line 172 - 'AtomForm.js' */                    $(e).removeClass("atom-data-error");
/*Line 173 - 'AtomForm.js' */                }

/*Line 175 - 'AtomForm.js' */                // return for every children??
/*Line 176 - 'AtomForm.js' */                var ae = new ChildEnumerator(e);
/*Line 177 - 'AtomForm.js' */                var isValid = true;
/*Line 178 - 'AtomForm.js' */                while (ae.next()) {
/*Line 179 - 'AtomForm.js' */                    if (!this.validate(ae.current(), ef)) {
/*Line 180 - 'AtomForm.js' */                        isValid = false;
/*Line 181 - 'AtomForm.js' */                    }
/*Line 182 - 'AtomForm.js' */                }

/*Line 184 - 'AtomForm.js' */                return isValid;
/*Line 185 - 'AtomForm.js' */            },

/*Line 187 - 'AtomForm.js' */            init: function () {
/*Line 188 - 'AtomForm.js' */                baseType.init.call(this);

/*Line 190 - 'AtomForm.js' */                var _this = this;
/*Line 191 - 'AtomForm.js' */                this._success = function () {
/*Line 192 - 'AtomForm.js' */                    _this.onSuccess.apply(_this, arguments);
/*Line 193 - 'AtomForm.js' */                };

/*Line 195 - 'AtomForm.js' */                this._submit = function () {
/*Line 196 - 'AtomForm.js' */                    WebAtoms.dispatcher.callLater(function () {
/*Line 197 - 'AtomForm.js' */                        _this.onSubmit.apply(_this, arguments);
/*Line 198 - 'AtomForm.js' */                    });
/*Line 199 - 'AtomForm.js' */                };

/*Line 201 - 'AtomForm.js' */                var element = this.get_element();

/*Line 203 - 'AtomForm.js' */                this.submitCommand = this._submit;

/*Line 205 - 'AtomForm.js' */                this.bindEvent(element, "keyup", "onKeyUp");

/*Line 207 - 'AtomForm.js' */                $(element).find("input[type=submit]").bind("click", null, this._submit);
/*Line 208 - 'AtomForm.js' */                $(element).find("button[type=submit]").bind("click", null, this._submit);


/*Line 211 - 'AtomForm.js' */                var _this = this;
/*Line 212 - 'AtomForm.js' */                this._vh = function () {
/*Line 213 - 'AtomForm.js' */                    _this.validateField.apply(_this, arguments);
/*Line 214 - 'AtomForm.js' */                };

/*Line 216 - 'AtomForm.js' */                $(element).find("input,select,textarea").bind("blur", null, this._vh);



/*Line 220 - 'AtomForm.js' */            }

/*Line 222 - 'AtomForm.js' */        }
/*Line 223 - 'AtomForm.js' */    });
/*Line 224 - 'AtomForm.js' */})(WebAtoms.AtomControl.prototype);

/*Line 0 - 'AtomFormLayout.js' */

/*Line 2 - 'AtomFormLayout.js' */(function (baseType) {
/*Line 3 - 'AtomFormLayout.js' */    return classCreatorEx({
/*Line 4 - 'AtomFormLayout.js' */        name: "WebAtoms.AtomFormLayout",
/*Line 5 - 'AtomFormLayout.js' */        base: baseType,
/*Line 6 - 'AtomFormLayout.js' */        start: function () {
/*Line 7 - 'AtomFormLayout.js' */            this._useTable = true;
/*Line 8 - 'AtomFormLayout.js' */            this._errorItems = [];
/*Line 9 - 'AtomFormLayout.js' */            this._minLabelWidth = 0;
/*Line 10 - 'AtomFormLayout.js' */        },
/*Line 11 - 'AtomFormLayout.js' */        properties: {
/*Line 12 - 'AtomFormLayout.js' */            minLabelWidth: 0
/*Line 13 - 'AtomFormLayout.js' */        },
/*Line 14 - 'AtomFormLayout.js' */        methods: {
/*Line 15 - 'AtomFormLayout.js' */            createField: function (parent, child) {

/*Line 17 - 'AtomFormLayout.js' */                var isChildField = false;

/*Line 19 - 'AtomFormLayout.js' */                var amap = AtomUI.attributeMap(child, /^(atom\-(init|type|label|required|regex|data\-type|is\-valid|field\-(value|visible|class)|error))$/i);

/*Line 21 - 'AtomFormLayout.js' */                var at = amap["atom-type"];
/*Line 22 - 'AtomFormLayout.js' */                if (at) {
/*Line 23 - 'AtomFormLayout.js' */                    amap["atom-type"] = null;
/*Line 24 - 'AtomFormLayout.js' */                    switch (at.value) {
/*Line 25 - 'AtomFormLayout.js' */                        case "AtomFormField":
/*Line 26 - 'AtomFormLayout.js' */                            isChildField = true;
/*Line 27 - 'AtomFormLayout.js' */                            break;
/*Line 28 - 'AtomFormLayout.js' */                        case "AtomFormGridLayout":
/*Line 29 - 'AtomFormLayout.js' */                        case "AtomFormTab":
/*Line 30 - 'AtomFormLayout.js' */                            parent.appendChild(child);
/*Line 31 - 'AtomFormLayout.js' */                            var a = AtomUI.createControl(child, at.value);
/*Line 32 - 'AtomFormLayout.js' */                            return a;
/*Line 33 - 'AtomFormLayout.js' */                            break;
/*Line 34 - 'AtomFormLayout.js' */                    }
/*Line 35 - 'AtomFormLayout.js' */                }


/*Line 38 - 'AtomFormLayout.js' */                var field = AtomUI.cloneNode(this._fieldTemplate);

/*Line 40 - 'AtomFormLayout.js' */                var cp = AtomUI.findPresenter(field);
/*Line 41 - 'AtomFormLayout.js' */                if (cp) {
/*Line 42 - 'AtomFormLayout.js' */                    if (isChildField) {
/*Line 43 - 'AtomFormLayout.js' */                        var ce = new ChildEnumerator(child);
/*Line 44 - 'AtomFormLayout.js' */                        while (ce.next()) {
/*Line 45 - 'AtomFormLayout.js' */                            cp.appendChild(ce.current());
/*Line 46 - 'AtomFormLayout.js' */                        }
/*Line 47 - 'AtomFormLayout.js' */                    } else {
/*Line 48 - 'AtomFormLayout.js' */                        cp.appendChild(child);
/*Line 49 - 'AtomFormLayout.js' */                    }
/*Line 50 - 'AtomFormLayout.js' */                    AtomUI.removeAttr(cp, "atom-presenter");
/*Line 51 - 'AtomFormLayout.js' */                } else {
/*Line 52 - 'AtomFormLayout.js' */                    field.contentElement = child;
/*Line 53 - 'AtomFormLayout.js' */                }

/*Line 55 - 'AtomFormLayout.js' */                parent.appendChild(field);

/*Line 57 - 'AtomFormLayout.js' */                for (var k in amap) {
/*Line 58 - 'AtomFormLayout.js' */                    var v = amap[k];
/*Line 59 - 'AtomFormLayout.js' */                    if (!v)
/*Line 60 - 'AtomFormLayout.js' */                        continue;
/*Line 61 - 'AtomFormLayout.js' */                    child.removeAttributeNode(v.node);
/*Line 62 - 'AtomFormLayout.js' */                    field.setAttributeNode(v.node);
/*Line 63 - 'AtomFormLayout.js' */                }

/*Line 65 - 'AtomFormLayout.js' */                amap = AtomUI.attributeMap(field, /^atom\-(field\-value|is\-valid)$/i);

/*Line 67 - 'AtomFormLayout.js' */                if (!(amap["atom-field-value"] || amap["atom-is-valid"])) {
/*Line 68 - 'AtomFormLayout.js' */                    var v = AtomUI.attr(child, "atom-value");
/*Line 69 - 'AtomFormLayout.js' */                    if (v && /^\$\[/gi.test(v)) {
/*Line 70 - 'AtomFormLayout.js' */                        // must be a two way binding..
/*Line 71 - 'AtomFormLayout.js' */                        v = v.substr(2);
/*Line 72 - 'AtomFormLayout.js' */                        if (!/^\$/gi.test(v)) {
/*Line 73 - 'AtomFormLayout.js' */                            v = "$" + v;
/*Line 74 - 'AtomFormLayout.js' */                        }
/*Line 75 - 'AtomFormLayout.js' */                        v = "[" + v;
/*Line 76 - 'AtomFormLayout.js' */                        var ind = v.indexOf(']');
/*Line 77 - 'AtomFormLayout.js' */                        v = v.substr(0, ind + 1);
/*Line 78 - 'AtomFormLayout.js' */                        AtomUI.attr(field, "atom-field-value", v);
/*Line 79 - 'AtomFormLayout.js' */                    }
/*Line 80 - 'AtomFormLayout.js' */                }

/*Line 82 - 'AtomFormLayout.js' */                return AtomUI.createControl(field, WebAtoms.AtomFieldType);
/*Line 83 - 'AtomFormLayout.js' */            },

/*Line 85 - 'AtomFormLayout.js' */            createChildren: function () {
/*Line 86 - 'AtomFormLayout.js' */                var element = this._element;
/*Line 87 - 'AtomFormLayout.js' */                $(element).addClass("atom-form");
/*Line 88 - 'AtomFormLayout.js' */                var ae = new AtomEnumerator($(element).children());

/*Line 90 - 'AtomFormLayout.js' */                // add table...
/*Line 91 - 'AtomFormLayout.js' */                var table = document.createElement("TABLE");

/*Line 93 - 'AtomFormLayout.js' */                $(table).addClass("atom-form-table");

/*Line 95 - 'AtomFormLayout.js' */                var tbody = document.createElement("TBODY");

/*Line 97 - 'AtomFormLayout.js' */                AtomUI.removeAllChildren(element);
/*Line 98 - 'AtomFormLayout.js' */                //element.innerHTML = "";

/*Line 100 - 'AtomFormLayout.js' */                element.appendChild(table);
/*Line 101 - 'AtomFormLayout.js' */                table.appendChild(tbody);

/*Line 103 - 'AtomFormLayout.js' */                var child;
/*Line 104 - 'AtomFormLayout.js' */                this.getTemplate("fieldTemplate");

/*Line 106 - 'AtomFormLayout.js' */                while (ae.next()) {
/*Line 107 - 'AtomFormLayout.js' */                    child = ae.current();
/*Line 108 - 'AtomFormLayout.js' */                    if (!child)
/*Line 109 - 'AtomFormLayout.js' */                        continue;

/*Line 111 - 'AtomFormLayout.js' */                    this.createField(tbody, child);

/*Line 113 - 'AtomFormLayout.js' */                }

/*Line 115 - 'AtomFormLayout.js' */            }
/*Line 116 - 'AtomFormLayout.js' */        }
/*Line 117 - 'AtomFormLayout.js' */    });
/*Line 118 - 'AtomFormLayout.js' */})(WebAtoms.AtomControl.prototype);
/*Line 0 - 'AtomLayout.js' */

/*Line 2 - 'AtomLayout.js' */(function () {
/*Line 3 - 'AtomLayout.js' */    return classCreatorEx({
/*Line 4 - 'AtomLayout.js' */        name: "WebAtoms.AtomLayout",
/*Line 5 - 'AtomLayout.js' */        start: function () {
/*Line 6 - 'AtomLayout.js' */        },
/*Line 7 - 'AtomLayout.js' */        methods: {
/*Line 8 - 'AtomLayout.js' */            doLayout: function () {
/*Line 9 - 'AtomLayout.js' */            }
/*Line 10 - 'AtomLayout.js' */        }
/*Line 11 - 'AtomLayout.js' */    });
/*Line 12 - 'AtomLayout.js' */})();
/*Line 0 - 'AtomWindow.js' */

/*Line 2 - 'AtomWindow.js' */(function (baseType) {
/*Line 3 - 'AtomWindow.js' */    return classCreatorEx({
/*Line 4 - 'AtomWindow.js' */        name: "WebAtoms.AtomWindow",
/*Line 5 - 'AtomWindow.js' */        base: baseType,
/*Line 6 - 'AtomWindow.js' */        start: function () {
/*Line 7 - 'AtomWindow.js' */            this._presenters = ["windowDiv", "windowTitleDiv", "windowCloseButton", "iframe", "windowPlaceholder"];
/*Line 8 - 'AtomWindow.js' */        },
/*Line 9 - 'AtomWindow.js' */        properties: {
/*Line 10 - 'AtomWindow.js' */            opener: null,
/*Line 11 - 'AtomWindow.js' */            openerData: null,
/*Line 12 - 'AtomWindow.js' */            windowTemplate: null,
/*Line 13 - 'AtomWindow.js' */            isOpen: false,
/*Line 14 - 'AtomWindow.js' */            windowHeight: 300,
/*Line 15 - 'AtomWindow.js' */            windowWidth: 500,
/*Line 16 - 'AtomWindow.js' */            url: undefined,
/*Line 17 - 'AtomWindow.js' */            title: undefined,
/*Line 18 - 'AtomWindow.js' */            windowUrl: undefined,
/*Line 19 - 'AtomWindow.js' */            cancelNext: undefined
/*Line 20 - 'AtomWindow.js' */        },
/*Line 21 - 'AtomWindow.js' */        methods: {


/*Line 24 - 'AtomWindow.js' */            get_openerData: function () {
/*Line 25 - 'AtomWindow.js' */                var v = this.get_opener();
/*Line 26 - 'AtomWindow.js' */                if (!v)
/*Line 27 - 'AtomWindow.js' */                    return;
/*Line 28 - 'AtomWindow.js' */                return v.get_data();
/*Line 29 - 'AtomWindow.js' */            },

/*Line 31 - 'AtomWindow.js' */            onCloseCommand: function (scope, sender) {
/*Line 32 - 'AtomWindow.js' */                AtomBinder.setValue(this, "isOpen", false);
/*Line 33 - 'AtomWindow.js' */                var val = this._value;
/*Line 34 - 'AtomWindow.js' */                var self = this;
/*Line 35 - 'AtomWindow.js' */                this._value = null;

/*Line 37 - 'AtomWindow.js' */                WebAtoms.dispatcher.callLater(function () {
/*Line 38 - 'AtomWindow.js' */                    AtomBinder.setValue(self, "value", val);
/*Line 39 - 'AtomWindow.js' */                    self.invokeAction(self._next);
/*Line 40 - 'AtomWindow.js' */                    self.disposeChildren(self._element);
/*Line 41 - 'AtomWindow.js' */                });
/*Line 42 - 'AtomWindow.js' */            },

/*Line 44 - 'AtomWindow.js' */            onCancelCommand: function(scope,sender){
/*Line 45 - 'AtomWindow.js' */                AtomBinder.setValue(this, "isOpen", false);
/*Line 46 - 'AtomWindow.js' */                var self = this;

/*Line 48 - 'AtomWindow.js' */                WebAtoms.dispatcher.callLater(function () {
/*Line 49 - 'AtomWindow.js' */                    self.invokeAction(self._cancelNext);
/*Line 50 - 'AtomWindow.js' */                    self.disposeChildren(self._element);
/*Line 51 - 'AtomWindow.js' */                });
/*Line 52 - 'AtomWindow.js' */            },

/*Line 54 - 'AtomWindow.js' */            refresh: function (scope, sender) {
/*Line 55 - 'AtomWindow.js' */                this.openWindow(scope, sender);
/*Line 56 - 'AtomWindow.js' */            },

/*Line 58 - 'AtomWindow.js' */            openWindow: function (scope, sender) {

/*Line 60 - 'AtomWindow.js' */                var tt = this.getTemplate("frameTemplate");

/*Line 62 - 'AtomWindow.js' */                tt = AtomUI.cloneNode(tt);

/*Line 64 - 'AtomWindow.js' */                var tt$ = $(tt);

/*Line 66 - 'AtomWindow.js' */                var wdiv = tt$.find("[data-atom-presenter=windowDiv],[atom-presenter=windowDiv]").get(0);
/*Line 67 - 'AtomWindow.js' */                var wtitle = tt$.find("[data-atom-presenter=windowTitleDiv],[atom-presenter=windowTitleDiv]").get(0);

/*Line 69 - 'AtomWindow.js' */                var wt = this.getTemplate("windowTemplate");

/*Line 71 - 'AtomWindow.js' */                $(wt).addClass("atom-window-template");

/*Line 73 - 'AtomWindow.js' */                if (!(AtomUI.attr(wt, "atom-dock"))) {
/*Line 74 - 'AtomWindow.js' */                    AtomUI.attr(wt, "atom-dock", "Fill");
/*Line 75 - 'AtomWindow.js' */                }

/*Line 77 - 'AtomWindow.js' */                if (wt.length) {
/*Line 78 - 'AtomWindow.js' */                    for (var i = 0; i < wt.length; i++) {
/*Line 79 - 'AtomWindow.js' */                        wdiv.appendChild(wt[i]);
/*Line 80 - 'AtomWindow.js' */                    }
/*Line 81 - 'AtomWindow.js' */                } else {
/*Line 82 - 'AtomWindow.js' */                    wdiv.appendChild(wt);
/*Line 83 - 'AtomWindow.js' */                }

/*Line 85 - 'AtomWindow.js' */                var wct = this.getTemplate("commandTemplate");
/*Line 86 - 'AtomWindow.js' */                if (wct) {
/*Line 87 - 'AtomWindow.js' */                    AtomUI.attr(wct, "atom-dock", "Bottom");
/*Line 88 - 'AtomWindow.js' */                    wct.setAttribute("class", "atom-wizard-command-bar");
/*Line 89 - 'AtomWindow.js' */                    wdiv.appendChild(wct);
/*Line 90 - 'AtomWindow.js' */                }

/*Line 92 - 'AtomWindow.js' */                this.set_innerTemplate(tt);

/*Line 94 - 'AtomWindow.js' */                if (this._iframe) {
/*Line 95 - 'AtomWindow.js' */                    this._iframe.atomWindow = this;
/*Line 96 - 'AtomWindow.js' */                }

/*Line 98 - 'AtomWindow.js' */                if (sender) {
/*Line 99 - 'AtomWindow.js' */                    this._opener = sender;
/*Line 100 - 'AtomWindow.js' */                    AtomBinder.refreshValue(this, "opener");
/*Line 101 - 'AtomWindow.js' */                    AtomBinder.refreshValue(this, "openerData");
/*Line 102 - 'AtomWindow.js' */                }

/*Line 104 - 'AtomWindow.js' */                var _this = this;
/*Line 105 - 'AtomWindow.js' */                WebAtoms.dispatcher.callLater(function () {
/*Line 106 - 'AtomWindow.js' */                    AtomBinder.setValue(_this, "isOpen", true);
/*Line 107 - 'AtomWindow.js' */                    if (!_this._url) {
/*Line 108 - 'AtomWindow.js' */                        var children = $(_this._windowPlaceholder).find("input");
/*Line 109 - 'AtomWindow.js' */                        if (children.length > 0) {
/*Line 110 - 'AtomWindow.js' */                            var item = children.get(0);
/*Line 111 - 'AtomWindow.js' */                            try {
/*Line 112 - 'AtomWindow.js' */                                item.focus();
/*Line 113 - 'AtomWindow.js' */                            } catch (er) {
/*Line 114 - 'AtomWindow.js' */                            }
/*Line 115 - 'AtomWindow.js' */                        }
/*Line 116 - 'AtomWindow.js' */                    }
/*Line 117 - 'AtomWindow.js' */                });
/*Line 118 - 'AtomWindow.js' */            },

/*Line 120 - 'AtomWindow.js' */            init: function () {



/*Line 124 - 'AtomWindow.js' */                $(this._element).addClass("atom-window-placeholder");
/*Line 125 - 'AtomWindow.js' */                baseType.init.call(this);

/*Line 127 - 'AtomWindow.js' */                var self = this;
/*Line 128 - 'AtomWindow.js' */                this.closeCommand = function () {
/*Line 129 - 'AtomWindow.js' */                    self.onCloseCommand.apply(self, arguments);
/*Line 130 - 'AtomWindow.js' */                };

/*Line 132 - 'AtomWindow.js' */                this.cancelCommand = function () {
/*Line 133 - 'AtomWindow.js' */                    self.onCancelCommand.apply(self, arguments);
/*Line 134 - 'AtomWindow.js' */                };

/*Line 136 - 'AtomWindow.js' */                this.openCommand = function () {
/*Line 137 - 'AtomWindow.js' */                    self.openWindow.apply(self, arguments);
/*Line 138 - 'AtomWindow.js' */                };

/*Line 140 - 'AtomWindow.js' */                WebAtoms.dispatcher.callLater(function () {
/*Line 141 - 'AtomWindow.js' */                    var e = self._element;
/*Line 142 - 'AtomWindow.js' */                    if (!e._logicalParent) {
/*Line 143 - 'AtomWindow.js' */                        e._logicalParent = e.parentNode;
/*Line 144 - 'AtomWindow.js' */                        $(e).remove();
/*Line 145 - 'AtomWindow.js' */                        document.body.appendChild(e);
/*Line 146 - 'AtomWindow.js' */                    }
/*Line 147 - 'AtomWindow.js' */                });
/*Line 148 - 'AtomWindow.js' */            }
/*Line 149 - 'AtomWindow.js' */        }
/*Line 150 - 'AtomWindow.js' */    });
/*Line 151 - 'AtomWindow.js' */})(WebAtoms.AtomControl.prototype);


/*Line 154 - 'AtomWindow.js' */WebAtoms.AtomWindow.openNewWindow = function (c) {
/*Line 155 - 'AtomWindow.js' */    var e1 = document.createElement("DIV");
/*Line 156 - 'AtomWindow.js' */    var id = AtomUI.assignID(e1);
/*Line 157 - 'AtomWindow.js' */    if (c.localScope) {
/*Line 158 - 'AtomWindow.js' */        e1.setAttribute("data-atom-local-scope", "true");
/*Line 159 - 'AtomWindow.js' */    }
/*Line 160 - 'AtomWindow.js' */    e1._logicalParent = c.opener;
/*Line 161 - 'AtomWindow.js' */    document.body.appendChild(e1);

/*Line 163 - 'AtomWindow.js' */    var w = AtomUI.createControl(e1, WebAtoms.AtomWindow);


/*Line 166 - 'AtomWindow.js' */    var url = c.url;

/*Line 168 - 'AtomWindow.js' */    if (url.length !== undefined) {
/*Line 169 - 'AtomWindow.js' */        c.next = url[1];
/*Line 170 - 'AtomWindow.js' */        c.url = url[0];
/*Line 171 - 'AtomWindow.js' */        url = new AtomUri(c.url);
/*Line 172 - 'AtomWindow.js' */    } else {
/*Line 173 - 'AtomWindow.js' */        url = {
/*Line 174 - 'AtomWindow.js' */            path: url.path,
/*Line 175 - 'AtomWindow.js' */            query: url.prop,
/*Line 176 - 'AtomWindow.js' */            hash: url.scope
/*Line 177 - 'AtomWindow.js' */        };
/*Line 178 - 'AtomWindow.js' */        if (c.url.next) {
/*Line 179 - 'AtomWindow.js' */            c.next = c.url.next;
/*Line 180 - 'AtomWindow.js' */        }
/*Line 181 - 'AtomWindow.js' */    }

/*Line 183 - 'AtomWindow.js' */    w._next = [c.next || {}, function () {
/*Line 184 - 'AtomWindow.js' */        WebAtoms.dispatcher.callLater(function () {
/*Line 185 - 'AtomWindow.js' */            w.dispose();
/*Line 186 - 'AtomWindow.js' */            $(e1).remove();
/*Line 187 - 'AtomWindow.js' */        });
/*Line 188 - 'AtomWindow.js' */    }];

/*Line 190 - 'AtomWindow.js' */    var wt = url.path;
/*Line 191 - 'AtomWindow.js' */    if (!AtomUI.isNode(wt)) {
/*Line 192 - 'AtomWindow.js' */        wt = Atom.get(c.scope, url.path);
/*Line 193 - 'AtomWindow.js' */        if (!wt) {
/*Line 194 - 'AtomWindow.js' */            wt = Atom.get(appScope, url.path);
/*Line 195 - 'AtomWindow.js' */        }
/*Line 196 - 'AtomWindow.js' */    }

/*Line 198 - 'AtomWindow.js' */    var $wt = $( AtomUI.cloneNode(wt));
/*Line 199 - 'AtomWindow.js' */    var ct = $wt.children("[atom-template=commandTemplate],[data-atom-template=commandTemplate]").get(0);
/*Line 200 - 'AtomWindow.js' */    if (ct) {
/*Line 201 - 'AtomWindow.js' */        AtomUI.removeAttr(ct, "atom-template");
/*Line 202 - 'AtomWindow.js' */        w._commandTemplate = ct;
/*Line 203 - 'AtomWindow.js' */        $(ct).remove();
/*Line 204 - 'AtomWindow.js' */    }

/*Line 206 - 'AtomWindow.js' */    ct = $wt.children("[atom-template=windowTemplate],[data-atom-template=windowTemplate]").get(0);
/*Line 207 - 'AtomWindow.js' */    if (ct) {
/*Line 208 - 'AtomWindow.js' */        AtomUI.removeAttr(ct, "atom-template");
/*Line 209 - 'AtomWindow.js' */        w._windowTemplate = ct;
/*Line 210 - 'AtomWindow.js' */    } else {
/*Line 211 - 'AtomWindow.js' */        AtomUI.removeAttr(wt, "atom-template");
/*Line 212 - 'AtomWindow.js' */        w._windowTemplate = wt;
/*Line 213 - 'AtomWindow.js' */    }


/*Line 216 - 'AtomWindow.js' */    w.init();

/*Line 218 - 'AtomWindow.js' */    WebAtoms.dispatcher.callLater(function () { 
/*Line 219 - 'AtomWindow.js' */        var scope = w.get_scope();

/*Line 221 - 'AtomWindow.js' */        var hash = url.hash;
/*Line 222 - 'AtomWindow.js' */        for (var i in hash) {
/*Line 223 - 'AtomWindow.js' */            if (hash.hasOwnProperty(i))
/*Line 224 - 'AtomWindow.js' */                Atom.set(scope, i, hash[i]);
/*Line 225 - 'AtomWindow.js' */        }

/*Line 227 - 'AtomWindow.js' */        var query = url.query;
/*Line 228 - 'AtomWindow.js' */        for (var i in query) {
/*Line 229 - 'AtomWindow.js' */            if (query.hasOwnProperty(i))
/*Line 230 - 'AtomWindow.js' */                Atom.set(w, i, query[i]);
/*Line 231 - 'AtomWindow.js' */        }

/*Line 233 - 'AtomWindow.js' */        w.openWindow(c.scope, c.opener);
/*Line 234 - 'AtomWindow.js' */    });
/*Line 235 - 'AtomWindow.js' */};
/*Line 0 - 'AtomCalendar.js' */

/*Line 2 - 'AtomCalendar.js' */(function (baseType) {
/*Line 3 - 'AtomCalendar.js' */    return classCreatorEx({
/*Line 4 - 'AtomCalendar.js' */        name: "WebAtoms.AtomCalendar",
/*Line 5 - 'AtomCalendar.js' */        base: baseType,
/*Line 6 - 'AtomCalendar.js' */        start: function (e) {
/*Line 7 - 'AtomCalendar.js' */            $(e).addClass("atom-calendar");

/*Line 9 - 'AtomCalendar.js' */            var today = new Date();
/*Line 10 - 'AtomCalendar.js' */            this._month = today.getMonth() + 1;
/*Line 11 - 'AtomCalendar.js' */            this._year = today.getFullYear();

/*Line 13 - 'AtomCalendar.js' */            this._startYear = -5;
/*Line 14 - 'AtomCalendar.js' */            this._endYear = 10;

/*Line 16 - 'AtomCalendar.js' */            this._currentYear = (new Date()).getFullYear();
/*Line 17 - 'AtomCalendar.js' */            this._value = null;


/*Line 20 - 'AtomCalendar.js' */        },
/*Line 21 - 'AtomCalendar.js' */        properties: {
/*Line 22 - 'AtomCalendar.js' */            month: 0,
/*Line 23 - 'AtomCalendar.js' */            year:0,
/*Line 24 - 'AtomCalendar.js' */            startYear: -5,
/*Line 25 - 'AtomCalendar.js' */            endYear: 0,
/*Line 26 - 'AtomCalendar.js' */            currentYear: 0,
/*Line 27 - 'AtomCalendar.js' */            visibleDate: undefined
/*Line 28 - 'AtomCalendar.js' */        },
/*Line 29 - 'AtomCalendar.js' */        methods: {
/*Line 30 - 'AtomCalendar.js' */            set_month: function (v) {
/*Line 31 - 'AtomCalendar.js' */                this._month = v;
/*Line 32 - 'AtomCalendar.js' */                this.updateCalendar();
/*Line 33 - 'AtomCalendar.js' */            },

/*Line 35 - 'AtomCalendar.js' */            set_year: function (v) {
/*Line 36 - 'AtomCalendar.js' */                this._year = v;
/*Line 37 - 'AtomCalendar.js' */                this.updateCalendar();
/*Line 38 - 'AtomCalendar.js' */            },

/*Line 40 - 'AtomCalendar.js' */            set_visibleDate: function (v) {
/*Line 41 - 'AtomCalendar.js' */                if (!v)
/*Line 42 - 'AtomCalendar.js' */                    return;
/*Line 43 - 'AtomCalendar.js' */                if (v == this._visibleDate)
/*Line 44 - 'AtomCalendar.js' */                    return;
/*Line 45 - 'AtomCalendar.js' */                this._visibleDate = v;
/*Line 46 - 'AtomCalendar.js' */                this._year = v.getFullYear();
/*Line 47 - 'AtomCalendar.js' */                this._month = v.getMonth() + 1;
/*Line 48 - 'AtomCalendar.js' */                this.updateCalendar();
/*Line 49 - 'AtomCalendar.js' */                AtomBinder.refreshValue(this, "year");
/*Line 50 - 'AtomCalendar.js' */                AtomBinder.refreshValue(this, "month");
/*Line 51 - 'AtomCalendar.js' */            },

/*Line 53 - 'AtomCalendar.js' */            onCreated: function () {
/*Line 54 - 'AtomCalendar.js' */                baseType.onCreated.call(this);
/*Line 55 - 'AtomCalendar.js' */                var self = this;
/*Line 56 - 'AtomCalendar.js' */                WebAtoms.dispatcher.callLater(function () {
/*Line 57 - 'AtomCalendar.js' */                    self.updateCalendar();
/*Line 58 - 'AtomCalendar.js' */                });
/*Line 59 - 'AtomCalendar.js' */            },

/*Line 61 - 'AtomCalendar.js' */            applyItemStyle: function (item, data, first, last) {
/*Line 62 - 'AtomCalendar.js' */            },

/*Line 64 - 'AtomCalendar.js' */            updateCalendar: function(){
/*Line 65 - 'AtomCalendar.js' */                if (!this._created)
/*Line 66 - 'AtomCalendar.js' */                    return;
/*Line 67 - 'AtomCalendar.js' */                var now = new Date();

/*Line 69 - 'AtomCalendar.js' */                var d = new Date(this._year, this._month - 1, 1);
/*Line 70 - 'AtomCalendar.js' */                var first = new Date(this._year, this._month - 1, 1);

/*Line 72 - 'AtomCalendar.js' */                if (first.getDay()) {
/*Line 73 - 'AtomCalendar.js' */                    // go to first day of the month...
/*Line 74 - 'AtomCalendar.js' */                    var start = first.getDay() - 1;
/*Line 75 - 'AtomCalendar.js' */                    start = -start;

/*Line 77 - 'AtomCalendar.js' */                    first.setDate(start);
/*Line 78 - 'AtomCalendar.js' */                }

/*Line 80 - 'AtomCalendar.js' */                var m = first.getMonth();
/*Line 81 - 'AtomCalendar.js' */                var y = first.getFullYear();

/*Line 83 - 'AtomCalendar.js' */                var items = [];

/*Line 85 - 'AtomCalendar.js' */                var i = 0;

/*Line 87 - 'AtomCalendar.js' */                var cm = this._month - 1;

/*Line 89 - 'AtomCalendar.js' */                for (i = 0; i < 42; i++) {
/*Line 90 - 'AtomCalendar.js' */                    var cd = i + first.getDate();
/*Line 91 - 'AtomCalendar.js' */                    var id = new Date(y, m, cd);
/*Line 92 - 'AtomCalendar.js' */                    var w = id.getDay();
/*Line 93 - 'AtomCalendar.js' */                    w = w == 0 || w == 6;
/*Line 94 - 'AtomCalendar.js' */                    items.push({
/*Line 95 - 'AtomCalendar.js' */                        label: id.getDate(),
/*Line 96 - 'AtomCalendar.js' */                        isWeekEnd: w,
/*Line 97 - 'AtomCalendar.js' */                        isToday:
/*Line 98 - 'AtomCalendar.js' */                            now.getDate() == id.getDate()
/*Line 99 - 'AtomCalendar.js' */                            && now.getMonth() == id.getMonth()
/*Line 100 - 'AtomCalendar.js' */                            && now.getFullYear() == id.getFullYear(),
/*Line 101 - 'AtomCalendar.js' */                        isOtherMonth: id.getMonth() != cm,
/*Line 102 - 'AtomCalendar.js' */                        dateLabel: AtomDate.toShortDateString(id),
/*Line 103 - 'AtomCalendar.js' */                        value: AtomDate.toMMDDYY(id),
/*Line 104 - 'AtomCalendar.js' */                        date: id
/*Line 105 - 'AtomCalendar.js' */                    });
/*Line 106 - 'AtomCalendar.js' */                }


/*Line 109 - 'AtomCalendar.js' */                AtomBinder.setValue(this, "items", items);
/*Line 110 - 'AtomCalendar.js' */            },
/*Line 111 - 'AtomCalendar.js' */            changeMonth: function (n) {
/*Line 112 - 'AtomCalendar.js' */                var m = this._month;
/*Line 113 - 'AtomCalendar.js' */                m += n;
/*Line 114 - 'AtomCalendar.js' */                if (m > 12) {
/*Line 115 - 'AtomCalendar.js' */                    m = 1;
/*Line 116 - 'AtomCalendar.js' */                    Atom.set(this, "year", this._year + 1);
/*Line 117 - 'AtomCalendar.js' */                }
/*Line 118 - 'AtomCalendar.js' */                if (m == 0) {
/*Line 119 - 'AtomCalendar.js' */                    Atom.set(this, "year", this._year - 1);
/*Line 120 - 'AtomCalendar.js' */                    m = 12;
/*Line 121 - 'AtomCalendar.js' */                }
/*Line 122 - 'AtomCalendar.js' */                AtomBinder.setValue(this, "month",m);
/*Line 123 - 'AtomCalendar.js' */            },
/*Line 124 - 'AtomCalendar.js' */            init: function () {
/*Line 125 - 'AtomCalendar.js' */                baseType.init.call(this);
/*Line 126 - 'AtomCalendar.js' */                var _this = this;
/*Line 127 - 'AtomCalendar.js' */                this.nextMonthCommand = function () {
/*Line 128 - 'AtomCalendar.js' */                    _this.changeMonth(1);
/*Line 129 - 'AtomCalendar.js' */                };
/*Line 130 - 'AtomCalendar.js' */                this.prevMonthCommand = function () {
/*Line 131 - 'AtomCalendar.js' */                    _this.changeMonth(-1);
/*Line 132 - 'AtomCalendar.js' */                }
/*Line 133 - 'AtomCalendar.js' */            }
/*Line 134 - 'AtomCalendar.js' */        }
/*Line 135 - 'AtomCalendar.js' */    });
/*Line 136 - 'AtomCalendar.js' */})(WebAtoms.AtomListBox.prototype);
/*Line 0 - 'AtomCheckBoxList.js' */

/*Line 2 - 'AtomCheckBoxList.js' */(function (base) {
/*Line 3 - 'AtomCheckBoxList.js' */    return classCreatorEx(
/*Line 4 - 'AtomCheckBoxList.js' */    {
/*Line 5 - 'AtomCheckBoxList.js' */        name: "WebAtoms.AtomCheckBoxList",
/*Line 6 - 'AtomCheckBoxList.js' */        base: base,
/*Line 7 - 'AtomCheckBoxList.js' */        start: function () {
/*Line 8 - 'AtomCheckBoxList.js' */            this._allowMultipleSelection = true;
/*Line 9 - 'AtomCheckBoxList.js' */            this._valueSeparator = ", ";
/*Line 10 - 'AtomCheckBoxList.js' */            this._dataElements = [];
/*Line 11 - 'AtomCheckBoxList.js' */        },
/*Line 12 - 'AtomCheckBoxList.js' */        methods: {
/*Line 13 - 'AtomCheckBoxList.js' */            init: function () {
/*Line 14 - 'AtomCheckBoxList.js' */                base.init.call(this);
/*Line 15 - 'AtomCheckBoxList.js' */                $(this._element).addClass("atom-check-box-list");
/*Line 16 - 'AtomCheckBoxList.js' */            }
/*Line 17 - 'AtomCheckBoxList.js' */        }
/*Line 18 - 'AtomCheckBoxList.js' */    });
/*Line 19 - 'AtomCheckBoxList.js' */})(WebAtoms.AtomItemsControl.prototype);

/*Line 0 - 'AtomDataPager.js' */

/*Line 2 - 'AtomDataPager.js' */(function (base) {

/*Line 4 - 'AtomDataPager.js' */    return classCreatorEx(
/*Line 5 - 'AtomDataPager.js' */        {
/*Line 6 - 'AtomDataPager.js' */            name: "WebAtoms.AtomDataPager",
/*Line 7 - 'AtomDataPager.js' */            base: base,
/*Line 8 - 'AtomDataPager.js' */            properties:{
/*Line 9 - 'AtomDataPager.js' */                itemsPath: "items",
/*Line 10 - 'AtomDataPager.js' */                totalPath: "total",
/*Line 11 - 'AtomDataPager.js' */                pageSize: 25,
/*Line 12 - 'AtomDataPager.js' */                currentPage: 0,
/*Line 13 - 'AtomDataPager.js' */                items: null,
/*Line 14 - 'AtomDataPager.js' */                total: 0,
/*Line 15 - 'AtomDataPager.js' */                pages: []
/*Line 16 - 'AtomDataPager.js' */            },

/*Line 18 - 'AtomDataPager.js' */            start: function () {
/*Line 19 - 'AtomDataPager.js' */                this._presenters = ["pageList"];

/*Line 21 - 'AtomDataPager.js' */                var caller = this;

/*Line 23 - 'AtomDataPager.js' */                var binder = AtomBinder;

/*Line 25 - 'AtomDataPager.js' */                this.goFirstCommand = function () {
/*Line 26 - 'AtomDataPager.js' */                    binder.setValue(caller, "currentPage", 0);
/*Line 27 - 'AtomDataPager.js' */                };

/*Line 29 - 'AtomDataPager.js' */                this.goLastCommand = function () {
/*Line 30 - 'AtomDataPager.js' */                    binder.setValue(caller, "currentPage", caller._pages.length - 1);
/*Line 31 - 'AtomDataPager.js' */                };

/*Line 33 - 'AtomDataPager.js' */                this.goNextCommand = function () {
/*Line 34 - 'AtomDataPager.js' */                    binder.setValue(caller, "currentPage", caller.get_currentPage() + 1);
/*Line 35 - 'AtomDataPager.js' */                };

/*Line 37 - 'AtomDataPager.js' */                this.goPrevCommand = function () {
/*Line 38 - 'AtomDataPager.js' */                    binder.setValue(caller, "currentPage", caller.get_currentPage() - 1);
/*Line 39 - 'AtomDataPager.js' */                };
/*Line 40 - 'AtomDataPager.js' */            },

/*Line 42 - 'AtomDataPager.js' */            methods:{
/*Line 43 - 'AtomDataPager.js' */                preparePages: function () {
/*Line 44 - 'AtomDataPager.js' */                    if (!this._items)
/*Line 45 - 'AtomDataPager.js' */                        return;
/*Line 46 - 'AtomDataPager.js' */                    if (!this._total)
/*Line 47 - 'AtomDataPager.js' */                        return;
/*Line 48 - 'AtomDataPager.js' */                    if (!this._pageSize)
/*Line 49 - 'AtomDataPager.js' */                        return;
/*Line 50 - 'AtomDataPager.js' */                    var l = this._items.length;
/*Line 51 - 'AtomDataPager.js' */                    var t = this._total;
/*Line 52 - 'AtomDataPager.js' */                    var count = Math.ceil(t / this._pageSize);

/*Line 54 - 'AtomDataPager.js' */                    if (count == this._pages.length)
/*Line 55 - 'AtomDataPager.js' */                        return;

/*Line 57 - 'AtomDataPager.js' */                    var ps = this._pageSize;
/*Line 58 - 'AtomDataPager.js' */                    var pages = [];
/*Line 59 - 'AtomDataPager.js' */                    var i;
/*Line 60 - 'AtomDataPager.js' */                    for (i = 0; i < count; i++) {
/*Line 61 - 'AtomDataPager.js' */                        pages.push({
/*Line 62 - 'AtomDataPager.js' */                            value: i,
/*Line 63 - 'AtomDataPager.js' */                            label: i + 1
/*Line 64 - 'AtomDataPager.js' */                        });
/*Line 65 - 'AtomDataPager.js' */                    }
/*Line 66 - 'AtomDataPager.js' */                    AtomBinder.setValue(this, "pages", pages);
/*Line 67 - 'AtomDataPager.js' */                },

/*Line 69 - 'AtomDataPager.js' */                set_items: function (v) {

/*Line 71 - 'AtomDataPager.js' */                    if (v != this._items) {
/*Line 72 - 'AtomDataPager.js' */                        if (this._items) {
/*Line 73 - 'AtomDataPager.js' */                            this.unbindEvent(this._items, "CollectionChanged", "onCollectionChangedInternal");
/*Line 74 - 'AtomDataPager.js' */                        }
/*Line 75 - 'AtomDataPager.js' */                    }

/*Line 77 - 'AtomDataPager.js' */                    if (!v)
/*Line 78 - 'AtomDataPager.js' */                        return;
/*Line 79 - 'AtomDataPager.js' */                    this._items = v;

/*Line 81 - 'AtomDataPager.js' */                    if (v != null && this._created) {
/*Line 82 - 'AtomDataPager.js' */                        this.bindEvent(this._items, "CollectionChanged", "onCollectionChangedInternal");
/*Line 83 - 'AtomDataPager.js' */                        this.onCollectionChangedInternal("refresh", -1, null);
/*Line 84 - 'AtomDataPager.js' */                    }

/*Line 86 - 'AtomDataPager.js' */                },

/*Line 88 - 'AtomDataPager.js' */                onCollectionChangedInternal: function () {
/*Line 89 - 'AtomDataPager.js' */                    var v = this._items;
/*Line 90 - 'AtomDataPager.js' */                    if (v.length === undefined) {
/*Line 91 - 'AtomDataPager.js' */                        var val = v[this._itemsPath];

/*Line 93 - 'AtomDataPager.js' */                        AtomBinder.setValue(this, "total", v[this._totalPath]);
/*Line 94 - 'AtomDataPager.js' */                        AtomBinder.setValue(this, "value", val);
/*Line 95 - 'AtomDataPager.js' */                    } else {
/*Line 96 - 'AtomDataPager.js' */                        if (v.total) {
/*Line 97 - 'AtomDataPager.js' */                            AtomBinder.setValue(this, "total", v.total);
/*Line 98 - 'AtomDataPager.js' */                        } else {
/*Line 99 - 'AtomDataPager.js' */                            //AtomBinder.setValue(this, "pages", []);
/*Line 100 - 'AtomDataPager.js' */                        }
/*Line 101 - 'AtomDataPager.js' */                        AtomBinder.setValue(this, "value", v);
/*Line 102 - 'AtomDataPager.js' */                    }

/*Line 104 - 'AtomDataPager.js' */                    this.preparePages();
/*Line 105 - 'AtomDataPager.js' */                },

/*Line 107 - 'AtomDataPager.js' */                onCreated: function () {
/*Line 108 - 'AtomDataPager.js' */                    if (this._items) {
/*Line 109 - 'AtomDataPager.js' */                        this.bindEvent(this._items, "CollectionChanged", "onCollectionChangedInternal");
/*Line 110 - 'AtomDataPager.js' */                        this.onCollectionChangedInternal("refresh", -1, null);
/*Line 111 - 'AtomDataPager.js' */                    }
/*Line 112 - 'AtomDataPager.js' */                },


/*Line 115 - 'AtomDataPager.js' */                set_currentPage: function (v) {
/*Line 116 - 'AtomDataPager.js' */                    this._currentPage = v;
/*Line 117 - 'AtomDataPager.js' */                    AtomBinder.refreshValue(this, "pageStart");
/*Line 118 - 'AtomDataPager.js' */                },

/*Line 120 - 'AtomDataPager.js' */                get_pageStart: function () {
/*Line 121 - 'AtomDataPager.js' */                    return this._currentPage * this._pageSize;
/*Line 122 - 'AtomDataPager.js' */                },

/*Line 124 - 'AtomDataPager.js' */                set_pageSize: function (v) {
/*Line 125 - 'AtomDataPager.js' */                    this._pageSize = v;
/*Line 126 - 'AtomDataPager.js' */                    this.preparePages();
/*Line 127 - 'AtomDataPager.js' */                },
/*Line 128 - 'AtomDataPager.js' */                set_total: function (v) {
/*Line 129 - 'AtomDataPager.js' */                    if (this._total == v)
/*Line 130 - 'AtomDataPager.js' */                        return;
/*Line 131 - 'AtomDataPager.js' */                    this._total = v;
/*Line 132 - 'AtomDataPager.js' */                },
/*Line 133 - 'AtomDataPager.js' */                init: function () {

/*Line 135 - 'AtomDataPager.js' */                    $(this._element).addClass("atom-data-pager");

/*Line 137 - 'AtomDataPager.js' */                    base.init.apply(this, arguments);
/*Line 138 - 'AtomDataPager.js' */                }
/*Line 139 - 'AtomDataPager.js' */            }

/*Line 141 - 'AtomDataPager.js' */    }
/*Line 142 - 'AtomDataPager.js' */);

/*Line 144 - 'AtomDataPager.js' */})(WebAtoms.AtomControl.prototype);
/*Line 0 - 'AtomDateControl.js' */

/*Line 2 - 'AtomDateControl.js' */// Date Month Year

/*Line 4 - 'AtomDateControl.js' */(function (base) {
/*Line 5 - 'AtomDateControl.js' */    return classCreatorEx({
/*Line 6 - 'AtomDateControl.js' */        name: "WebAtoms.AtomDateControl",
/*Line 7 - 'AtomDateControl.js' */        base: base,
/*Line 8 - 'AtomDateControl.js' */        start: function () {
/*Line 9 - 'AtomDateControl.js' */        },
/*Line 10 - 'AtomDateControl.js' */        properties: {
/*Line 11 - 'AtomDateControl.js' */            startYear: -1,
/*Line 12 - 'AtomDateControl.js' */            endYear: +10
/*Line 13 - 'AtomDateControl.js' */        },
/*Line 14 - 'AtomDateControl.js' */        methods: {
/*Line 15 - 'AtomDateControl.js' */            resetYears: function () {
/*Line 16 - 'AtomDateControl.js' */                var years = this._year;
/*Line 17 - 'AtomDateControl.js' */                var dt = new Date();
/*Line 18 - 'AtomDateControl.js' */                var start = dt.getFullYear();
/*Line 19 - 'AtomDateControl.js' */                start += this._startYear;
/*Line 20 - 'AtomDateControl.js' */                var end = dt.getFullYear() + this._endYear;
/*Line 21 - 'AtomDateControl.js' */                var val = this._value;
/*Line 22 - 'AtomDateControl.js' */                if (!val)
/*Line 23 - 'AtomDateControl.js' */                    val = dt;
/*Line 24 - 'AtomDateControl.js' */                years.options.length = 0;
/*Line 25 - 'AtomDateControl.js' */                var j = 1;
/*Line 26 - 'AtomDateControl.js' */                years.options[0] = new Option("Select", "", false, false);
/*Line 27 - 'AtomDateControl.js' */                var dt = (this._value || new Date()).getFullYear();
/*Line 28 - 'AtomDateControl.js' */                for (var i = start; i <= end; i++) {
/*Line 29 - 'AtomDateControl.js' */                    years.options[j] = new Option(i, i, false, dt == i);
/*Line 30 - 'AtomDateControl.js' */                    j++;
/*Line 31 - 'AtomDateControl.js' */                }
/*Line 32 - 'AtomDateControl.js' */            },
/*Line 33 - 'AtomDateControl.js' */            set_value: function (v) {
/*Line 34 - 'AtomDateControl.js' */                if (v && v.constructor == String) {
/*Line 35 - 'AtomDateControl.js' */                    // date format??
/*Line 36 - 'AtomDateControl.js' */                    v = new Date(parseInt(v.substr(6)));
/*Line 37 - 'AtomDateControl.js' */                }
/*Line 38 - 'AtomDateControl.js' */                this._value = v;
/*Line 39 - 'AtomDateControl.js' */                this.setDate();
/*Line 40 - 'AtomDateControl.js' */            },
/*Line 41 - 'AtomDateControl.js' */            setDate: function () {
/*Line 42 - 'AtomDateControl.js' */                if (!this._value)
/*Line 43 - 'AtomDateControl.js' */                    return;
/*Line 44 - 'AtomDateControl.js' */                var dt = this._value;
/*Line 45 - 'AtomDateControl.js' */                var m = dt.getMonth() + 1;
/*Line 46 - 'AtomDateControl.js' */                var d = dt.getDate();
/*Line 47 - 'AtomDateControl.js' */                var y = dt.getFullYear();

/*Line 49 - 'AtomDateControl.js' */                this.setComboValue(this._month, m);
/*Line 50 - 'AtomDateControl.js' */                this.setComboValue(this._year, y);
/*Line 51 - 'AtomDateControl.js' */                this.setComboValue(this._date, d);

/*Line 53 - 'AtomDateControl.js' */            },

/*Line 55 - 'AtomDateControl.js' */            setComboValue: function (cb, v) {
/*Line 56 - 'AtomDateControl.js' */                var ae = new AtomEnumerator(cb.options);
/*Line 57 - 'AtomDateControl.js' */                while (ae.next()) {
/*Line 58 - 'AtomDateControl.js' */                    if (ae.current().value == v) {
/*Line 59 - 'AtomDateControl.js' */                        cb.selectedIndex = ae.currentIndex();
/*Line 60 - 'AtomDateControl.js' */                        break;
/*Line 61 - 'AtomDateControl.js' */                    }
/*Line 62 - 'AtomDateControl.js' */                }
/*Line 63 - 'AtomDateControl.js' */            },

/*Line 65 - 'AtomDateControl.js' */            set_startYear: function (v) {
/*Line 66 - 'AtomDateControl.js' */                this._startYear = v;
/*Line 67 - 'AtomDateControl.js' */                this.resetYears();
/*Line 68 - 'AtomDateControl.js' */            },
/*Line 69 - 'AtomDateControl.js' */            set_endYear: function (v) {
/*Line 70 - 'AtomDateControl.js' */                this._endYear = v;
/*Line 71 - 'AtomDateControl.js' */                this.resetYears();
/*Line 72 - 'AtomDateControl.js' */            },
/*Line 73 - 'AtomDateControl.js' */            onDataChange: function () {
/*Line 74 - 'AtomDateControl.js' */                var year = $(this._year).val();
/*Line 75 - 'AtomDateControl.js' */                var month = $(this._month).val();
/*Line 76 - 'AtomDateControl.js' */                var date = $(this._date).val();
/*Line 77 - 'AtomDateControl.js' */                try {
/*Line 78 - 'AtomDateControl.js' */                    if (year && month && date) {
/*Line 79 - 'AtomDateControl.js' */                        var dt = new Date(year, month - 1, date, 9, 0, 0);
/*Line 80 - 'AtomDateControl.js' */                        this._value = dt;
/*Line 81 - 'AtomDateControl.js' */                    } else {
/*Line 82 - 'AtomDateControl.js' */                        this._value = null;
/*Line 83 - 'AtomDateControl.js' */                    }
/*Line 84 - 'AtomDateControl.js' */                } catch (error) {
/*Line 85 - 'AtomDateControl.js' */                    Atom.alert(error);
/*Line 86 - 'AtomDateControl.js' */                }
/*Line 87 - 'AtomDateControl.js' */                AtomBinder.refreshValue(this, "value");
/*Line 88 - 'AtomDateControl.js' */            },

/*Line 90 - 'AtomDateControl.js' */            setMonths: function () {

/*Line 92 - 'AtomDateControl.js' */                var r = AtomDate.monthList;

/*Line 94 - 'AtomDateControl.js' */                var options = this._month.options;
/*Line 95 - 'AtomDateControl.js' */                options.length = 0;
/*Line 96 - 'AtomDateControl.js' */                var ae = new AtomEnumerator(r);
/*Line 97 - 'AtomDateControl.js' */                options[0] = new Option("Select", "", false, false);
/*Line 98 - 'AtomDateControl.js' */                while (ae.next()) {
/*Line 99 - 'AtomDateControl.js' */                    var item = ae.current();
/*Line 100 - 'AtomDateControl.js' */                    options[ae.currentIndex() + 1] = new Option(item.label, item.value, false, false);
/*Line 101 - 'AtomDateControl.js' */                }
/*Line 102 - 'AtomDateControl.js' */                this.setDate();
/*Line 103 - 'AtomDateControl.js' */                AtomBinder.refreshValue(this, "value");
/*Line 104 - 'AtomDateControl.js' */            },
/*Line 105 - 'AtomDateControl.js' */            init: function () {

/*Line 107 - 'AtomDateControl.js' */                var element = this._element;

/*Line 109 - 'AtomDateControl.js' */                this._date = document.createElement("SELECT");
/*Line 110 - 'AtomDateControl.js' */                this._month = document.createElement("SELECT");
/*Line 111 - 'AtomDateControl.js' */                this._year = document.createElement("SELECT");

/*Line 113 - 'AtomDateControl.js' */                element.style.height = "25px";

/*Line 115 - 'AtomDateControl.js' */                element.appendChild(this._date);
/*Line 116 - 'AtomDateControl.js' */                element.appendChild(this._month);
/*Line 117 - 'AtomDateControl.js' */                element.appendChild(this._year);

/*Line 119 - 'AtomDateControl.js' */                // add days...
/*Line 120 - 'AtomDateControl.js' */                var options = this._date.options;
/*Line 121 - 'AtomDateControl.js' */                var i;
/*Line 122 - 'AtomDateControl.js' */                options[0] = new Option("Select", "", false, false);
/*Line 123 - 'AtomDateControl.js' */                for (i = 1; i < 32; i++) {
/*Line 124 - 'AtomDateControl.js' */                    options[i] = new Option(i, i, false, false);
/*Line 125 - 'AtomDateControl.js' */                }



/*Line 129 - 'AtomDateControl.js' */                this.resetYears();

/*Line 131 - 'AtomDateControl.js' */                this.bindEvent(this._date, "change", "onDataChange");
/*Line 132 - 'AtomDateControl.js' */                this.bindEvent(this._month, "change", "onDataChange");
/*Line 133 - 'AtomDateControl.js' */                this.bindEvent(this._year, "change", "onDataChange");

/*Line 135 - 'AtomDateControl.js' */                this.setMonths();


/*Line 138 - 'AtomDateControl.js' */                base.init.apply(this, arguments);


/*Line 141 - 'AtomDateControl.js' */            }
/*Line 142 - 'AtomDateControl.js' */        }
/*Line 143 - 'AtomDateControl.js' */    });
/*Line 144 - 'AtomDateControl.js' */})(WebAtoms.AtomControl.prototype);

/*Line 0 - 'AtomDateField.js' */
/*Line 1 - 'AtomDateField.js' */

/*Line 3 - 'AtomDateField.js' */(function (base) {
/*Line 4 - 'AtomDateField.js' */    return classCreatorEx({
/*Line 5 - 'AtomDateField.js' */        name: "WebAtoms.AtomDateField",
/*Line 6 - 'AtomDateField.js' */        base: base,
/*Line 7 - 'AtomDateField.js' */        start: function (e) {
/*Line 8 - 'AtomDateField.js' */            this._presenters = ["calendarPresenter", "itemsPresenter"];
/*Line 9 - 'AtomDateField.js' */            $(e).addClass("atom-date-field");
/*Line 10 - 'AtomDateField.js' */        },
/*Line 11 - 'AtomDateField.js' */        properties: {
/*Line 12 - 'AtomDateField.js' */            isOpen: false,
/*Line 13 - 'AtomDateField.js' */            time: "9:00 AM"
/*Line 14 - 'AtomDateField.js' */        },
/*Line 15 - 'AtomDateField.js' */        methods: {
/*Line 16 - 'AtomDateField.js' */            get_offsetLeft: function () {
/*Line 17 - 'AtomDateField.js' */                //return $(this._element).offset().left - parseInt( $(atomApplication._element).css("left") , 10);
/*Line 18 - 'AtomDateField.js' */                return $(this._element).offset().left;
/*Line 19 - 'AtomDateField.js' */            },
/*Line 20 - 'AtomDateField.js' */            get_offsetTop: function () {
/*Line 21 - 'AtomDateField.js' */                return $(this._element).offset().top;
/*Line 22 - 'AtomDateField.js' */            },

/*Line 24 - 'AtomDateField.js' */            onPopupRemoved: function (e) {
/*Line 25 - 'AtomDateField.js' */                AtomBinder.setValue(this, "isOpen", false);
/*Line 26 - 'AtomDateField.js' */            },

/*Line 28 - 'AtomDateField.js' */            set_isOpen: function (v) {
/*Line 29 - 'AtomDateField.js' */                this._isOpen = v;
/*Line 30 - 'AtomDateField.js' */                if (v) {
/*Line 31 - 'AtomDateField.js' */                    this.getTemplate("popupTemplate");

/*Line 33 - 'AtomDateField.js' */                    this.popup = AtomUI.cloneNode(this._popupTemplate);
/*Line 34 - 'AtomDateField.js' */                    this.popup._logicalParent = this._element;
/*Line 35 - 'AtomDateField.js' */                    this.popup._templateParent = this;
/*Line 36 - 'AtomDateField.js' */                    //this.popup.style.visibility = "hidden";
/*Line 37 - 'AtomDateField.js' */                    document.body.appendChild(this.popup);
/*Line 38 - 'AtomDateField.js' */                    this.onCreateChildren(this.popup);
/*Line 39 - 'AtomDateField.js' */                    this.setProperties(this.popup);
/*Line 40 - 'AtomDateField.js' */                    this.initChildren(this.popup);

/*Line 42 - 'AtomDateField.js' */                    var _this = this;
/*Line 43 - 'AtomDateField.js' */                    this._refreshInterval = setInterval(function () {
/*Line 44 - 'AtomDateField.js' */                        AtomBinder.refreshValue(_this, "offsetLeft");
/*Line 45 - 'AtomDateField.js' */                        AtomBinder.refreshValue(_this, "offsetTop");
/*Line 46 - 'AtomDateField.js' */                    });

/*Line 48 - 'AtomDateField.js' */                    AtomPopup.show(this._element, this.popup, -1, function () {
/*Line 49 - 'AtomDateField.js' */                        Atom.set(_this, "isOpen", false);
/*Line 50 - 'AtomDateField.js' */                    });

/*Line 52 - 'AtomDateField.js' */                    //var _this = this;
/*Line 53 - 'AtomDateField.js' */                    //WebAtoms.dispatcher.callLater(function () {
/*Line 54 - 'AtomDateField.js' */                    //    AtomPopup.show(_this._element, _this.popup, 0, function () {
/*Line 55 - 'AtomDateField.js' */                    //        _this.onPopupRemoved(_this.popup);
/*Line 56 - 'AtomDateField.js' */                    //    });
/*Line 57 - 'AtomDateField.js' */                    //});
/*Line 58 - 'AtomDateField.js' */                } else {
/*Line 59 - 'AtomDateField.js' */                    //AtomPopup.hide(this.popup);
/*Line 60 - 'AtomDateField.js' */                    if (this._refreshInterval) {
/*Line 61 - 'AtomDateField.js' */                        clearInterval(this._refreshInterval);
/*Line 62 - 'AtomDateField.js' */                    }
/*Line 63 - 'AtomDateField.js' */                    if (this.popup) {
/*Line 64 - 'AtomDateField.js' */                        this.disposeChildren(this.popup);
/*Line 65 - 'AtomDateField.js' */                        $(this.popup).remove();
/*Line 66 - 'AtomDateField.js' */                        this.popup = null;
/*Line 67 - 'AtomDateField.js' */                    }
/*Line 68 - 'AtomDateField.js' */                }
/*Line 69 - 'AtomDateField.js' */            },

/*Line 71 - 'AtomDateField.js' */            dispose: function () {
/*Line 72 - 'AtomDateField.js' */                this.set_isOpen(false);
/*Line 73 - 'AtomDateField.js' */                base.dispose.call(this);
/*Line 74 - 'AtomDateField.js' */            },
/*Line 75 - 'AtomDateField.js' */            get_isOpen: function () {
/*Line 76 - 'AtomDateField.js' */                return this._isOpen;
/*Line 77 - 'AtomDateField.js' */            },

/*Line 79 - 'AtomDateField.js' */            get_selectedItem: function () {
/*Line 80 - 'AtomDateField.js' */                if (this._selectedItems.length)
/*Line 81 - 'AtomDateField.js' */                    return this._selectedItems[0];
/*Line 82 - 'AtomDateField.js' */                return null;
/*Line 83 - 'AtomDateField.js' */            },

/*Line 85 - 'AtomDateField.js' */            set_time: function (v) {
/*Line 86 - 'AtomDateField.js' */                if (this._set_timeCalled)
/*Line 87 - 'AtomDateField.js' */                    return;
/*Line 88 - 'AtomDateField.js' */                this._set_timeCalled = true;
/*Line 89 - 'AtomDateField.js' */                if (v) {
/*Line 90 - 'AtomDateField.js' */                    this._time = v;
/*Line 91 - 'AtomDateField.js' */                    var d = AtomDate.setTime(this.get_value(), v);
/*Line 92 - 'AtomDateField.js' */                    AtomBinder.setValue(this, "value", d);
/*Line 93 - 'AtomDateField.js' */                }
/*Line 94 - 'AtomDateField.js' */                this._set_timeCalled = false;
/*Line 95 - 'AtomDateField.js' */            },

/*Line 97 - 'AtomDateField.js' */            set_value: function (v) {
/*Line 98 - 'AtomDateField.js' */                v = AtomDate.parse(v);
/*Line 99 - 'AtomDateField.js' */                this._value = v;

/*Line 101 - 'AtomDateField.js' */                AtomBinder.setValue(this, "time", AtomDate.toTimeString(v));

/*Line 103 - 'AtomDateField.js' */                this._selectedItems.length = 0;
/*Line 104 - 'AtomDateField.js' */                if (v) {

/*Line 106 - 'AtomDateField.js' */                    this._selectedItems.push({ date: v, dateLabel: AtomDate.toShortDateString(v), value: AtomDate.toMMDDYY(v), label: v.getDate() });
/*Line 107 - 'AtomDateField.js' */                    this.set_visibleDate(v);
/*Line 108 - 'AtomDateField.js' */                }
/*Line 109 - 'AtomDateField.js' */                if (this._created) {
/*Line 110 - 'AtomDateField.js' */                    AtomBinder.refreshItems(this._selectedItems);
/*Line 111 - 'AtomDateField.js' */                    AtomBinder.refreshValue(this, "value");
/*Line 112 - 'AtomDateField.js' */                    AtomBinder.refreshValue(this, "selectedItem");
/*Line 113 - 'AtomDateField.js' */                    AtomBinder.refreshValue(this, "selectedItems");
/*Line 114 - 'AtomDateField.js' */                }
/*Line 115 - 'AtomDateField.js' */            },
/*Line 116 - 'AtomDateField.js' */            get_value: function (v) {
/*Line 117 - 'AtomDateField.js' */                if (this._selectedItems.length)
/*Line 118 - 'AtomDateField.js' */                    return this._selectedItems[0].date;
/*Line 119 - 'AtomDateField.js' */                return this._value;
/*Line 120 - 'AtomDateField.js' */            },

/*Line 122 - 'AtomDateField.js' */            toggleDate: function (scope, sender) {
/*Line 123 - 'AtomDateField.js' */                var item = sender.get_data();
/*Line 124 - 'AtomDateField.js' */                this._selectedItems.length = 0;
/*Line 125 - 'AtomDateField.js' */                AtomBinder.addItem(this._selectedItems, item);
/*Line 126 - 'AtomDateField.js' */                AtomBinder.refreshValue(this, "value");
/*Line 127 - 'AtomDateField.js' */                AtomBinder.refreshValue(this, "selectedItem");
/*Line 128 - 'AtomDateField.js' */                AtomBinder.refreshValue(this, "selectedItems");
/*Line 129 - 'AtomDateField.js' */                AtomBinder.setValue(this, "isOpen", false);
/*Line 130 - 'AtomDateField.js' */            }


/*Line 133 - 'AtomDateField.js' */        }
/*Line 134 - 'AtomDateField.js' */    });
/*Line 135 - 'AtomDateField.js' */})(WebAtoms.AtomDateListBox.prototype);
/*Line 0 - 'AtomDeleteButton.js' */

/*Line 2 - 'AtomDeleteButton.js' */(function (base) {
/*Line 3 - 'AtomDeleteButton.js' */    return classCreatorEx({
/*Line 4 - 'AtomDeleteButton.js' */        name: "WebAtoms.AtomDeleteButton",
/*Line 5 - 'AtomDeleteButton.js' */        base: base,
/*Line 6 - 'AtomDeleteButton.js' */        start: function () {
/*Line 7 - 'AtomDeleteButton.js' */            this._confirm = true;
/*Line 8 - 'AtomDeleteButton.js' */            this._confirmMessage = "Are you sure you want to delete this item?";
/*Line 9 - 'AtomDeleteButton.js' */        },
/*Line 10 - 'AtomDeleteButton.js' */        methods: {
/*Line 11 - 'AtomDeleteButton.js' */        },
/*Line 12 - 'AtomDeleteButton.js' */        properties: {
/*Line 13 - 'AtomDeleteButton.js' */        }
/*Line 14 - 'AtomDeleteButton.js' */    });
/*Line 15 - 'AtomDeleteButton.js' */})(WebAtoms.AtomPostButton.prototype);

/*Line 0 - 'AtomFrameView.js' */
/*Line 1 - 'AtomFrameView.js' */

/*Line 3 - 'AtomFrameView.js' */(function (baseType) {
/*Line 4 - 'AtomFrameView.js' */    return createClass({
/*Line 5 - 'AtomFrameView.js' */        name: "WebAtoms.AtomFrameView",
/*Line 6 - 'AtomFrameView.js' */        base: baseType,
/*Line 7 - 'AtomFrameView.js' */        start: function (e) {
/*Line 8 - 'AtomFrameView.js' */            var self = this;
/*Line 9 - 'AtomFrameView.js' */            $(e).addClass("atom-frame-view");
/*Line 10 - 'AtomFrameView.js' */            this._items = [];
/*Line 11 - 'AtomFrameView.js' */            this._layout = WebAtoms.AtomViewBoxLayout.defaultInstance;
/*Line 12 - 'AtomFrameView.js' */            this.backCommand = function () {
/*Line 13 - 'AtomFrameView.js' */                self.onBackCommand.apply(self, arguments);
/*Line 14 - 'AtomFrameView.js' */            };
/*Line 15 - 'AtomFrameView.js' */        },
/*Line 16 - 'AtomFrameView.js' */        properties: {
/*Line 17 - 'AtomFrameView.js' */            url: '',
/*Line 18 - 'AtomFrameView.js' */            replaceUrl: '',
/*Line 19 - 'AtomFrameView.js' */            layout: null,
/*Line 20 - 'AtomFrameView.js' */            items: [],
/*Line 21 - 'AtomFrameView.js' */            removeOnBack: true
/*Line 22 - 'AtomFrameView.js' */        },
/*Line 23 - 'AtomFrameView.js' */        methods: {
/*Line 24 - 'AtomFrameView.js' */            set_replaceUrl: function (v) {
/*Line 25 - 'AtomFrameView.js' */                //var item = Atom.query(this._items).firstOrDefault({ index: this._selectedIndex });
/*Line 26 - 'AtomFrameView.js' */                //this.replaceItemWithUrl(item, v);
/*Line 27 - 'AtomFrameView.js' */                var ae = new AtomEnumerator(this._items);

/*Line 29 - 'AtomFrameView.js' */                var remove = [];

/*Line 31 - 'AtomFrameView.js' */                this.set_url(v);

/*Line 33 - 'AtomFrameView.js' */                while (ae.next()) {
/*Line 34 - 'AtomFrameView.js' */                    var item = ae.current();
/*Line 35 - 'AtomFrameView.js' */                    if (item.url != v) {
/*Line 36 - 'AtomFrameView.js' */                        this.replaceItemWithUrl(item);
/*Line 37 - 'AtomFrameView.js' */                    }
/*Line 38 - 'AtomFrameView.js' */                }


/*Line 41 - 'AtomFrameView.js' */            },

/*Line 43 - 'AtomFrameView.js' */            set_url: function (v) {
/*Line 44 - 'AtomFrameView.js' */                if (!v) {
/*Line 45 - 'AtomFrameView.js' */                    return;
/*Line 46 - 'AtomFrameView.js' */                }

/*Line 48 - 'AtomFrameView.js' */                if (/replace\:/.test(v)) {
/*Line 49 - 'AtomFrameView.js' */                    this.set_replaceUrl(v.substr(8));
/*Line 50 - 'AtomFrameView.js' */                    this._url = v;
/*Line 51 - 'AtomFrameView.js' */                    return;
/*Line 52 - 'AtomFrameView.js' */                }

/*Line 54 - 'AtomFrameView.js' */                var i = v.indexOf('?');
/*Line 55 - 'AtomFrameView.js' */                var u = v;
/*Line 56 - 'AtomFrameView.js' */                var q = "";
/*Line 57 - 'AtomFrameView.js' */                var self = this;
/*Line 58 - 'AtomFrameView.js' */                if (i !== -1) {
/*Line 59 - 'AtomFrameView.js' */                    u = v.substr(0,i);
/*Line 60 - 'AtomFrameView.js' */                    q = v.substr(i + 1);
/*Line 61 - 'AtomFrameView.js' */                }

/*Line 63 - 'AtomFrameView.js' */                var items = this._items;

/*Line 65 - 'AtomFrameView.js' */                var item = Atom.query(items).firstOrDefault({ url: u });
/*Line 66 - 'AtomFrameView.js' */                if (!item) {

/*Line 68 - 'AtomFrameView.js' */                    // get item from scope...
/*Line 69 - 'AtomFrameView.js' */                    var scope = Atom.get(this, "scope");
/*Line 70 - 'AtomFrameView.js' */                    var t = scope[u];
/*Line 71 - 'AtomFrameView.js' */                    if (!t) {
/*Line 72 - 'AtomFrameView.js' */                        if (console && console.error) {
/*Line 73 - 'AtomFrameView.js' */                            console.error("Page Template " + t + " not found");
/*Line 74 - 'AtomFrameView.js' */                        }
/*Line 75 - 'AtomFrameView.js' */                        return;
/*Line 76 - 'AtomFrameView.js' */                    }

/*Line 78 - 'AtomFrameView.js' */                    t = AtomUI.cloneNode(t);
/*Line 79 - 'AtomFrameView.js' */                    t._logicalParent = this._element;
/*Line 80 - 'AtomFrameView.js' */                    item = {
/*Line 81 - 'AtomFrameView.js' */                        url: u,
/*Line 82 - 'AtomFrameView.js' */                        index: items.length,
/*Line 83 - 'AtomFrameView.js' */                        opener: this._url,
/*Line 84 - 'AtomFrameView.js' */                        element: t
/*Line 85 - 'AtomFrameView.js' */                    };
/*Line 86 - 'AtomFrameView.js' */                    Atom.add(items, item);
/*Line 87 - 'AtomFrameView.js' */                    var c = AtomUI.createControl(t, AtomUI.getAtomType(t) || WebAtoms.AtomControl);
/*Line 88 - 'AtomFrameView.js' */                    item.control = c;
/*Line 89 - 'AtomFrameView.js' */                    WebAtoms.dispatcher.callLater(function () {
/*Line 90 - 'AtomFrameView.js' */                        c.init();
/*Line 91 - 'AtomFrameView.js' */                        self._element.appendChild(t);
/*Line 92 - 'AtomFrameView.js' */                        Atom.set(self, "selectedIndex", item.index);
/*Line 93 - 'AtomFrameView.js' */                        self.updateUI();
/*Line 94 - 'AtomFrameView.js' */                    });
/*Line 95 - 'AtomFrameView.js' */                } else {
/*Line 96 - 'AtomFrameView.js' */                    Atom.set(this, "selectedIndex", item.index);
/*Line 97 - 'AtomFrameView.js' */                    this.updateUI();
/*Line 98 - 'AtomFrameView.js' */                }

/*Line 100 - 'AtomFrameView.js' */                if (q) {
/*Line 101 - 'AtomFrameView.js' */                    //WebAtoms.dispatcher.callLater(function () {
/*Line 102 - 'AtomFrameView.js' */                    //    location.hash = q;
/*Line 103 - 'AtomFrameView.js' */                    //});
/*Line 104 - 'AtomFrameView.js' */                    this.invokeAction({ appScope: AtomUI.parseUrl(q) });
/*Line 105 - 'AtomFrameView.js' */                }
/*Line 106 - 'AtomFrameView.js' */                this._url = v;
/*Line 107 - 'AtomFrameView.js' */            },

/*Line 109 - 'AtomFrameView.js' */            replaceItemWithUrl: function (item, url) {
/*Line 110 - 'AtomFrameView.js' */                if (url) {
/*Line 111 - 'AtomFrameView.js' */                    this.set_url(url);
/*Line 112 - 'AtomFrameView.js' */                }
/*Line 113 - 'AtomFrameView.js' */                if (item) {
/*Line 114 - 'AtomFrameView.js' */                    var self = this;
/*Line 115 - 'AtomFrameView.js' */                    setTimeout(function () {
/*Line 116 - 'AtomFrameView.js' */                        self.removeItem(item);
/*Line 117 - 'AtomFrameView.js' */                    }, 1000);
/*Line 118 - 'AtomFrameView.js' */                }

/*Line 120 - 'AtomFrameView.js' */            },

/*Line 122 - 'AtomFrameView.js' */            removeItem: function (item) {
/*Line 123 - 'AtomFrameView.js' */                Atom.remove(this._items, item);
/*Line 124 - 'AtomFrameView.js' */                item.control.dispose();
/*Line 125 - 'AtomFrameView.js' */                $(item.element).remove();

/*Line 127 - 'AtomFrameView.js' */                var ae = new AtomEnumerator(this._items);
/*Line 128 - 'AtomFrameView.js' */                while (ae.next()) {
/*Line 129 - 'AtomFrameView.js' */                    item = ae.current();
/*Line 130 - 'AtomFrameView.js' */                    item.index = ae.currentIndex();
/*Line 131 - 'AtomFrameView.js' */                }
/*Line 132 - 'AtomFrameView.js' */            },

/*Line 134 - 'AtomFrameView.js' */            onBackCommand: function () {
/*Line 135 - 'AtomFrameView.js' */                var index = this._selectedIndex;
/*Line 136 - 'AtomFrameView.js' */                if (index) {
/*Line 137 - 'AtomFrameView.js' */                    var item = Atom.query(this._items).firstOrDefault({ index: index });
/*Line 138 - 'AtomFrameView.js' */                    if (item) {
/*Line 139 - 'AtomFrameView.js' */                        var self = this;
/*Line 140 - 'AtomFrameView.js' */                        index = index - 1;
/*Line 141 - 'AtomFrameView.js' */                        Atom.set(this, "selectedIndex", index);
/*Line 142 - 'AtomFrameView.js' */                        if (self._removeOnBack) {
/*Line 143 - 'AtomFrameView.js' */                            this.replaceItemWithUrl(item, item.opener);
/*Line 144 - 'AtomFrameView.js' */                        }

/*Line 146 - 'AtomFrameView.js' */                    }
/*Line 147 - 'AtomFrameView.js' */                }
/*Line 148 - 'AtomFrameView.js' */            },
/*Line 149 - 'AtomFrameView.js' */            init: function () {
/*Line 150 - 'AtomFrameView.js' */                baseType.init.call(this);
/*Line 151 - 'AtomFrameView.js' */                var self = this;
/*Line 152 - 'AtomFrameView.js' */                var u = this._url;
/*Line 153 - 'AtomFrameView.js' */                if (u) {
/*Line 154 - 'AtomFrameView.js' */                    WebAtoms.dispatcher.callLater(function () {
/*Line 155 - 'AtomFrameView.js' */                        self.set_url(u);
/*Line 156 - 'AtomFrameView.js' */                    });
/*Line 157 - 'AtomFrameView.js' */                }
/*Line 158 - 'AtomFrameView.js' */            }
/*Line 159 - 'AtomFrameView.js' */        }
/*Line 160 - 'AtomFrameView.js' */    });
/*Line 161 - 'AtomFrameView.js' */})(WebAtoms.AtomViewStack.prototype);
/*Line 0 - 'AtomLinkBar.js' */

/*Line 2 - 'AtomLinkBar.js' */(function (base) {
/*Line 3 - 'AtomLinkBar.js' */    return classCreatorEx({
/*Line 4 - 'AtomLinkBar.js' */        name: "WebAtoms.AtomLinkBar",
/*Line 5 - 'AtomLinkBar.js' */        base: base,
/*Line 6 - 'AtomLinkBar.js' */        start: function () {
/*Line 7 - 'AtomLinkBar.js' */            this._allowSelectFirst = false;

/*Line 9 - 'AtomLinkBar.js' */            var _this = this;
/*Line 10 - 'AtomLinkBar.js' */            this.openMenuCommand = function () {
/*Line 11 - 'AtomLinkBar.js' */                _this.openMenu.apply(_this, arguments);
/*Line 12 - 'AtomLinkBar.js' */            };

/*Line 14 - 'AtomLinkBar.js' */        },
/*Line 15 - 'AtomLinkBar.js' */        properties: {
/*Line 16 - 'AtomLinkBar.js' */            itemsPath: "items",
/*Line 17 - 'AtomLinkBar.js' */            selectCurrent: true,
/*Line 18 - 'AtomLinkBar.js' */            targetPath: "",
/*Line 19 - 'AtomLinkBar.js' */            menuTemplate: null,
/*Line 20 - 'AtomLinkBar.js' */            menuDirection: "horizontal"
/*Line 21 - 'AtomLinkBar.js' */        },
/*Line 22 - 'AtomLinkBar.js' */        methods: {

/*Line 24 - 'AtomLinkBar.js' */            setClass: function () {
/*Line 25 - 'AtomLinkBar.js' */                var $e = $(this._element);
/*Line 26 - 'AtomLinkBar.js' */                $e.removeClass("atom-tab-bar atom-link-bar");
/*Line 27 - 'AtomLinkBar.js' */                $e.addClass(this._showTabs ? 'atom-tab-bar' : 'atom-link-bar');
/*Line 28 - 'AtomLinkBar.js' */            },

/*Line 30 - 'AtomLinkBar.js' */            set_menuDirection: function (v) {
/*Line 31 - 'AtomLinkBar.js' */                var $e = $(this._element);
/*Line 32 - 'AtomLinkBar.js' */                $e.removeClass("vertical horizontal");
/*Line 33 - 'AtomLinkBar.js' */                $e.addClass(v);
/*Line 34 - 'AtomLinkBar.js' */                this._menuDirection = v;
/*Line 35 - 'AtomLinkBar.js' */            },

/*Line 37 - 'AtomLinkBar.js' */            onClick: function () {
/*Line 38 - 'AtomLinkBar.js' */            },



/*Line 42 - 'AtomLinkBar.js' */            openMenu: function (e) {

/*Line 44 - 'AtomLinkBar.js' */                var target = e.target;

/*Line 46 - 'AtomLinkBar.js' */                var ap = this.get_atomParent(target);

/*Line 48 - 'AtomLinkBar.js' */                if (ap == null)
/*Line 49 - 'AtomLinkBar.js' */                    return;

/*Line 51 - 'AtomLinkBar.js' */                var data = ap.get_data();

/*Line 53 - 'AtomLinkBar.js' */                if (!data[this._itemsPath])
/*Line 54 - 'AtomLinkBar.js' */                    return;

/*Line 56 - 'AtomLinkBar.js' */                var menu = this._subMenu;

/*Line 58 - 'AtomLinkBar.js' */                if (menu) {
/*Line 59 - 'AtomLinkBar.js' */                    AtomPopup.hide(menu._element);
/*Line 60 - 'AtomLinkBar.js' */                }
/*Line 61 - 'AtomLinkBar.js' */                else {

/*Line 63 - 'AtomLinkBar.js' */                    var mt = this.getTemplate("menuTemplate");

/*Line 65 - 'AtomLinkBar.js' */                    menu = AtomUI.cloneNode(mt);
/*Line 66 - 'AtomLinkBar.js' */                    menu._templateParent = this;
/*Line 67 - 'AtomLinkBar.js' */                    menu.style.position = "absolute";
/*Line 68 - 'AtomLinkBar.js' */                    //menu.style.zOrder = 
/*Line 69 - 'AtomLinkBar.js' */                    document.body.appendChild(menu);
/*Line 70 - 'AtomLinkBar.js' */                    var mt = AtomUI.getAtomType(mt) || WebAtoms.AtomControl;

/*Line 72 - 'AtomLinkBar.js' */                    menu = AtomUI.createControl(menu, mt, data);

/*Line 74 - 'AtomLinkBar.js' */                    this._subMenu = menu;
/*Line 75 - 'AtomLinkBar.js' */                }

/*Line 77 - 'AtomLinkBar.js' */                AtomBinder.setValue(menu, "data", data);

/*Line 79 - 'AtomLinkBar.js' */                AtomPopup.show(ap._element, menu._element, 0);

/*Line 81 - 'AtomLinkBar.js' */                AtomUI.cancelEvent(e);
/*Line 82 - 'AtomLinkBar.js' */            },


/*Line 85 - 'AtomLinkBar.js' */            selectDefault: function () {
/*Line 86 - 'AtomLinkBar.js' */                if (!this._items)
/*Line 87 - 'AtomLinkBar.js' */                    return;

/*Line 89 - 'AtomLinkBar.js' */                if (!this._selectCurrent)
/*Line 90 - 'AtomLinkBar.js' */                    return;

/*Line 92 - 'AtomLinkBar.js' */                if (this._value) {
/*Line 93 - 'AtomLinkBar.js' */                    return;
/*Line 94 - 'AtomLinkBar.js' */                }
/*Line 95 - 'AtomLinkBar.js' */                AtomBinder.setValue(this, "value", location.pathname);

/*Line 97 - 'AtomLinkBar.js' */                if (this.get_selectedIndex() == -1) {
/*Line 98 - 'AtomLinkBar.js' */                    this.selectItem(this._items);
/*Line 99 - 'AtomLinkBar.js' */                }

/*Line 101 - 'AtomLinkBar.js' */                this.updateSelectionBindings();
/*Line 102 - 'AtomLinkBar.js' */            },

/*Line 104 - 'AtomLinkBar.js' */            selectItem: function (a, t) {
/*Line 105 - 'AtomLinkBar.js' */                var ae = new AtomEnumerator(a);
/*Line 106 - 'AtomLinkBar.js' */                var vp = this._valuePath;
/*Line 107 - 'AtomLinkBar.js' */                var lp = location.pathname.toLowerCase();
/*Line 108 - 'AtomLinkBar.js' */                while (ae.next()) {
/*Line 109 - 'AtomLinkBar.js' */                    var item = ae.current();
/*Line 110 - 'AtomLinkBar.js' */                    var l = item;
/*Line 111 - 'AtomLinkBar.js' */                    if (vp)
/*Line 112 - 'AtomLinkBar.js' */                        l = l[vp];
/*Line 113 - 'AtomLinkBar.js' */                    if (!l)
/*Line 114 - 'AtomLinkBar.js' */                        continue;
/*Line 115 - 'AtomLinkBar.js' */                    if (lp == l.toLowerCase()) {
/*Line 116 - 'AtomLinkBar.js' */                        if (!t) {
/*Line 117 - 'AtomLinkBar.js' */                            AtomBinder.setValue(this, "selectedItem", item);
/*Line 118 - 'AtomLinkBar.js' */                        }
/*Line 119 - 'AtomLinkBar.js' */                        return true;
/*Line 120 - 'AtomLinkBar.js' */                    }

/*Line 122 - 'AtomLinkBar.js' */                    if (item.links) {
/*Line 123 - 'AtomLinkBar.js' */                        if (this.selectItem(item.links, true)) {
/*Line 124 - 'AtomLinkBar.js' */                            AtomBinder.setValue(this, "selectedItem", item);
/*Line 125 - 'AtomLinkBar.js' */                            return true;
/*Line 126 - 'AtomLinkBar.js' */                        }
/*Line 127 - 'AtomLinkBar.js' */                    }
/*Line 128 - 'AtomLinkBar.js' */                }
/*Line 129 - 'AtomLinkBar.js' */                return false;
/*Line 130 - 'AtomLinkBar.js' */            },

/*Line 132 - 'AtomLinkBar.js' */            dispose: function () {

/*Line 134 - 'AtomLinkBar.js' */                if (this._subMenu) {
/*Line 135 - 'AtomLinkBar.js' */                    this._subMenu.dispose();
/*Line 136 - 'AtomLinkBar.js' */                    this._subMenu = null;
/*Line 137 - 'AtomLinkBar.js' */                }
/*Line 138 - 'AtomLinkBar.js' */                base.dispose.apply(this, arguments);
/*Line 139 - 'AtomLinkBar.js' */            },

/*Line 141 - 'AtomLinkBar.js' */            init: function () {
/*Line 142 - 'AtomLinkBar.js' */                base.init.apply(this, arguments);

/*Line 144 - 'AtomLinkBar.js' */                //this.bindEvent(this._element, "mouseover", "openMenuCommand");
/*Line 145 - 'AtomLinkBar.js' */                this.bindEvent(this._element, "click", "openMenuCommand");
/*Line 146 - 'AtomLinkBar.js' */                //this.setValue("class", "[$owner.showTabs ? 'atom-tab-button-bar' : 'menu atom-link-bar']", true, this._element);
/*Line 147 - 'AtomLinkBar.js' */                //this.bind(this._element,
/*Line 148 - 'AtomLinkBar.js' */                //    'class',
/*Line 149 - 'AtomLinkBar.js' */                //    ['showTabs'], 0,
/*Line 150 - 'AtomLinkBar.js' */                //    function (v) {
/*Line 151 - 'AtomLinkBar.js' */                //        return v ? 'atom-tab-bar' : 'atom-link-bar'
/*Line 152 - 'AtomLinkBar.js' */                //    });

/*Line 154 - 'AtomLinkBar.js' */                this.set_menuDirection('horizontal');
/*Line 155 - 'AtomLinkBar.js' */            }

/*Line 157 - 'AtomLinkBar.js' */        }
/*Line 158 - 'AtomLinkBar.js' */    });
/*Line 159 - 'AtomLinkBar.js' */})(WebAtoms.AtomToggleButtonBar.prototype);

/*Line 0 - 'AtomMultiButtonList.js' */

/*Line 2 - 'AtomMultiButtonList.js' */(function (base) {
/*Line 3 - 'AtomMultiButtonList.js' */    return classCreatorEx({
/*Line 4 - 'AtomMultiButtonList.js' */        name: "WebAtoms.AtomMultiButtonList",
/*Line 5 - 'AtomMultiButtonList.js' */        base: base,
/*Line 6 - 'AtomMultiButtonList.js' */        start: function () {
/*Line 7 - 'AtomMultiButtonList.js' */            this._dataElements = [];
/*Line 8 - 'AtomMultiButtonList.js' */        },
/*Line 9 - 'AtomMultiButtonList.js' */        properties: {
/*Line 10 - 'AtomMultiButtonList.js' */            labelPath: "label",
/*Line 11 - 'AtomMultiButtonList.js' */            valuePath: "value",
/*Line 12 - 'AtomMultiButtonList.js' */            options: null,
/*Line 13 - 'AtomMultiButtonList.js' */            isRadio: false,
/*Line 14 - 'AtomMultiButtonList.js' */            items:null
/*Line 15 - 'AtomMultiButtonList.js' */        },
/*Line 16 - 'AtomMultiButtonList.js' */        methods: {
/*Line 17 - 'AtomMultiButtonList.js' */            set_options: function (v) {
/*Line 18 - 'AtomMultiButtonList.js' */                this._options = v;
/*Line 19 - 'AtomMultiButtonList.js' */                if (v) {
/*Line 20 - 'AtomMultiButtonList.js' */                    this.onCollectionChangedInternal("refresh", -1, null);
/*Line 21 - 'AtomMultiButtonList.js' */                }
/*Line 22 - 'AtomMultiButtonList.js' */            },
/*Line 23 - 'AtomMultiButtonList.js' */            set_value: function (v) {
/*Line 24 - 'AtomMultiButtonList.js' */                this._value = v;
/*Line 25 - 'AtomMultiButtonList.js' */                this.updateSelections();
/*Line 26 - 'AtomMultiButtonList.js' */            },
/*Line 27 - 'AtomMultiButtonList.js' */            set_items: function (v) {
/*Line 28 - 'AtomMultiButtonList.js' */                if (this._items) {
/*Line 29 - 'AtomMultiButtonList.js' */                    this.unbindEvent(this._items, "CollectionChanged", "onCollectionChangedInternal");
/*Line 30 - 'AtomMultiButtonList.js' */                }
/*Line 31 - 'AtomMultiButtonList.js' */                this._items = v;

/*Line 33 - 'AtomMultiButtonList.js' */                // try starting observing....
/*Line 34 - 'AtomMultiButtonList.js' */                if (v != null) {
/*Line 35 - 'AtomMultiButtonList.js' */                    this.bindEvent(this._items, "CollectionChanged", "onCollectionChangedInternal");
/*Line 36 - 'AtomMultiButtonList.js' */                    this.onCollectionChangedInternal("refresh", -1, null);
/*Line 37 - 'AtomMultiButtonList.js' */                }
/*Line 38 - 'AtomMultiButtonList.js' */            },

/*Line 40 - 'AtomMultiButtonList.js' */            onCollectionChangedInternal: function (mode, index, item) {
/*Line 41 - 'AtomMultiButtonList.js' */                var value = this.get_value();

/*Line 43 - 'AtomMultiButtonList.js' */                this.onCollectionChanged(mode, index, item);

/*Line 45 - 'AtomMultiButtonList.js' */                // update selections !!!
/*Line 46 - 'AtomMultiButtonList.js' */                this.set_value(value);
/*Line 47 - 'AtomMultiButtonList.js' */            },
/*Line 48 - 'AtomMultiButtonList.js' */            onCollectionChanged: function (mode, index, item) {
/*Line 49 - 'AtomMultiButtonList.js' */                if (!this._items || !this._options)
/*Line 50 - 'AtomMultiButtonList.js' */                    return;
/*Line 51 - 'AtomMultiButtonList.js' */                this._dataElements = [];
/*Line 52 - 'AtomMultiButtonList.js' */                this.unbindEvent(null, "change", "onDataChange");
/*Line 53 - 'AtomMultiButtonList.js' */                var ae = new AtomEnumerator(this._items);
/*Line 54 - 'AtomMultiButtonList.js' */                var parentScope = this.get_scope();
/*Line 55 - 'AtomMultiButtonList.js' */                while (ae.next()) {
/*Line 56 - 'AtomMultiButtonList.js' */                    var data = ae.current();
/*Line 57 - 'AtomMultiButtonList.js' */                    this.createChildElement(parentScope, this._element, data);
/*Line 58 - 'AtomMultiButtonList.js' */                }

/*Line 60 - 'AtomMultiButtonList.js' */                this.updateUI();
/*Line 61 - 'AtomMultiButtonList.js' */            },

/*Line 63 - 'AtomMultiButtonList.js' */            updateSelections: function () {

/*Line 65 - 'AtomMultiButtonList.js' */                if (!this._dataElements || this._dataElements.length == 0)
/*Line 66 - 'AtomMultiButtonList.js' */                    return;

/*Line 68 - 'AtomMultiButtonList.js' */                ace = new AtomEnumerator(this._dataElements);
/*Line 69 - 'AtomMultiButtonList.js' */                while (ace.next()) {
/*Line 70 - 'AtomMultiButtonList.js' */                    var ce = ace.current();
/*Line 71 - 'AtomMultiButtonList.js' */                    ce.checked = false;
/*Line 72 - 'AtomMultiButtonList.js' */                }

/*Line 74 - 'AtomMultiButtonList.js' */                if (!this._value)
/*Line 75 - 'AtomMultiButtonList.js' */                    return;

/*Line 77 - 'AtomMultiButtonList.js' */                var ae;
/*Line 78 - 'AtomMultiButtonList.js' */                var ace;
/*Line 79 - 'AtomMultiButtonList.js' */                var item;
/*Line 80 - 'AtomMultiButtonList.js' */                var selections = this._value.split(",");

/*Line 82 - 'AtomMultiButtonList.js' */                ace.reset();

/*Line 84 - 'AtomMultiButtonList.js' */                var cb;
/*Line 85 - 'AtomMultiButtonList.js' */                while (ace.next()) {
/*Line 86 - 'AtomMultiButtonList.js' */                    cb = ace.current();
/*Line 87 - 'AtomMultiButtonList.js' */                    ae = new AtomEnumerator(selections);
/*Line 88 - 'AtomMultiButtonList.js' */                    while (ae.next()) {
/*Line 89 - 'AtomMultiButtonList.js' */                        item = ae.current();
/*Line 90 - 'AtomMultiButtonList.js' */                        item = $.trim(item);
/*Line 91 - 'AtomMultiButtonList.js' */                        if (cb.value == item) {
/*Line 92 - 'AtomMultiButtonList.js' */                            cb.checked = true;
/*Line 93 - 'AtomMultiButtonList.js' */                        }
/*Line 94 - 'AtomMultiButtonList.js' */                    }
/*Line 95 - 'AtomMultiButtonList.js' */                }
/*Line 96 - 'AtomMultiButtonList.js' */            },

/*Line 98 - 'AtomMultiButtonList.js' */            onDataChange: function () {
/*Line 99 - 'AtomMultiButtonList.js' */                var ae = new AtomEnumerator(this._dataElements);
/*Line 100 - 'AtomMultiButtonList.js' */                var add = [];
/*Line 101 - 'AtomMultiButtonList.js' */                while (ae.next()) {
/*Line 102 - 'AtomMultiButtonList.js' */                    var item = ae.current();
/*Line 103 - 'AtomMultiButtonList.js' */                    var dataItem = $(item).val();
/*Line 104 - 'AtomMultiButtonList.js' */                    //var checked = $(item).attr("checked");
/*Line 105 - 'AtomMultiButtonList.js' */                    if (item.checked) {
/*Line 106 - 'AtomMultiButtonList.js' */                        add.push(dataItem);
/*Line 107 - 'AtomMultiButtonList.js' */                    }
/*Line 108 - 'AtomMultiButtonList.js' */                }
/*Line 109 - 'AtomMultiButtonList.js' */                this._value = add.join(", ");
/*Line 110 - 'AtomMultiButtonList.js' */                AtomBinder.refreshValue(this, "value");
/*Line 111 - 'AtomMultiButtonList.js' */            },

/*Line 113 - 'AtomMultiButtonList.js' */            createChildElement: function (parentScope, parentElement, data) {
/*Line 114 - 'AtomMultiButtonList.js' */                var span = document.createElement("SPAN");
/*Line 115 - 'AtomMultiButtonList.js' */                parentElement.appendChild(span);

/*Line 117 - 'AtomMultiButtonList.js' */                parentElement = span;
/*Line 118 - 'AtomMultiButtonList.js' */                span = document.createElement("SPAN");
/*Line 119 - 'AtomMultiButtonList.js' */                var lp = this.get_labelPath();
/*Line 120 - 'AtomMultiButtonList.js' */                var vp = this.get_valuePath();
/*Line 121 - 'AtomMultiButtonList.js' */                l = data;
/*Line 122 - 'AtomMultiButtonList.js' */                v = data;
/*Line 123 - 'AtomMultiButtonList.js' */                if (lp)
/*Line 124 - 'AtomMultiButtonList.js' */                    l = data[lp];
/*Line 125 - 'AtomMultiButtonList.js' */                if (vp)
/*Line 126 - 'AtomMultiButtonList.js' */                    v = data[vp];


/*Line 129 - 'AtomMultiButtonList.js' */                var gpName = null;
/*Line 130 - 'AtomMultiButtonList.js' */                if (this._isRadio) {
/*Line 131 - 'AtomMultiButtonList.js' */                    gpName = "_g" + AtomUI.getNewIndex();
/*Line 132 - 'AtomMultiButtonList.js' */                }

/*Line 134 - 'AtomMultiButtonList.js' */                parentElement.appendChild(span);

/*Line 136 - 'AtomMultiButtonList.js' */                var options = new AtomEnumerator(this._options);
/*Line 137 - 'AtomMultiButtonList.js' */                while (options.next()) {
/*Line 138 - 'AtomMultiButtonList.js' */                    var op = options.current();
/*Line 139 - 'AtomMultiButtonList.js' */                    if (vp) {
/*Line 140 - 'AtomMultiButtonList.js' */                        op = op[vp];
/*Line 141 - 'AtomMultiButtonList.js' */                    }

/*Line 143 - 'AtomMultiButtonList.js' */                    var val = v + "." + op;

/*Line 145 - 'AtomMultiButtonList.js' */                    var cb = document.createElement("INPUT");
/*Line 146 - 'AtomMultiButtonList.js' */                    if (this._isRadio) {
/*Line 147 - 'AtomMultiButtonList.js' */                        AtomUI.attr(cb, "type", "radio");
/*Line 148 - 'AtomMultiButtonList.js' */                        AtomUI.attr(cb, "name", gpName);
/*Line 149 - 'AtomMultiButtonList.js' */                    } else {
/*Line 150 - 'AtomMultiButtonList.js' */                        AtomUI.attr(cb, "type", "checkbox");
/*Line 151 - 'AtomMultiButtonList.js' */                    }
/*Line 152 - 'AtomMultiButtonList.js' */                    $(cb).val(val);
/*Line 153 - 'AtomMultiButtonList.js' */                    span.appendChild(cb);
/*Line 154 - 'AtomMultiButtonList.js' */                    this.bindEvent(cb, "change", "onDataChange");
/*Line 155 - 'AtomMultiButtonList.js' */                    this._dataElements.push(cb);
/*Line 156 - 'AtomMultiButtonList.js' */                }

/*Line 158 - 'AtomMultiButtonList.js' */                span = document.createElement("SPAN");
/*Line 159 - 'AtomMultiButtonList.js' */                parentElement.appendChild(span);
/*Line 160 - 'AtomMultiButtonList.js' */                // Create Label First..
/*Line 161 - 'AtomMultiButtonList.js' */                var txt = document.createTextNode(l);
/*Line 162 - 'AtomMultiButtonList.js' */                span.appendChild(txt);
/*Line 163 - 'AtomMultiButtonList.js' */                //span.style.float = "left";

/*Line 165 - 'AtomMultiButtonList.js' */            }
/*Line 166 - 'AtomMultiButtonList.js' */        }
/*Line 167 - 'AtomMultiButtonList.js' */    });
/*Line 168 - 'AtomMultiButtonList.js' */})(WebAtoms.AtomControl.prototype);
/*Line 0 - 'AtomNavigatorList.js' */

/*Line 2 - 'AtomNavigatorList.js' */(function (base) {
/*Line 3 - 'AtomNavigatorList.js' */    return classCreatorEx({
/*Line 4 - 'AtomNavigatorList.js' */        name: "WebAtoms.AtomNavigatorList",
/*Line 5 - 'AtomNavigatorList.js' */        base: base,
/*Line 6 - 'AtomNavigatorList.js' */        start: function () {
/*Line 7 - 'AtomNavigatorList.js' */            // 0 = items, 1 = selection, 2 = new item..
/*Line 8 - 'AtomNavigatorList.js' */            this._displayMode = 0;

/*Line 10 - 'AtomNavigatorList.js' */            this._presenters =
/*Line 11 - 'AtomNavigatorList.js' */                [
/*Line 12 - 'AtomNavigatorList.js' */                    "gridPanel",
/*Line 13 - 'AtomNavigatorList.js' */                    "gridPresenter",
/*Line 14 - 'AtomNavigatorList.js' */                    "itemsPresenter",
/*Line 15 - 'AtomNavigatorList.js' */                    "detailHeaderPresenter",
/*Line 16 - 'AtomNavigatorList.js' */                    "newHeaderPresenter",
/*Line 17 - 'AtomNavigatorList.js' */                    "detailPresenter",
/*Line 18 - 'AtomNavigatorList.js' */                    "newPresenter",
/*Line 19 - 'AtomNavigatorList.js' */                    "newView",
/*Line 20 - 'AtomNavigatorList.js' */                    "detailView",
/*Line 21 - 'AtomNavigatorList.js' */                    "newHeaderToolbar",
/*Line 22 - 'AtomNavigatorList.js' */                    "detailHeaderToolbar"];

/*Line 24 - 'AtomNavigatorList.js' */            this._layout = new WebAtoms.AtomViewBoxLayout();

/*Line 26 - 'AtomNavigatorList.js' */            this._newItem = {};

/*Line 28 - 'AtomNavigatorList.js' */        },
/*Line 29 - 'AtomNavigatorList.js' */        properties: {
/*Line 30 - 'AtomNavigatorList.js' */            autoShowDetail: true,
/*Line 31 - 'AtomNavigatorList.js' */            currentPage: null,
/*Line 32 - 'AtomNavigatorList.js' */            pageSize: undefined,
/*Line 33 - 'AtomNavigatorList.js' */            newItem: null,
/*Line 34 - 'AtomNavigatorList.js' */            newUrl: null,
/*Line 35 - 'AtomNavigatorList.js' */            detailUrl: null,
/*Line 36 - 'AtomNavigatorList.js' */            displayMode: null
/*Line 37 - 'AtomNavigatorList.js' */        },
/*Line 38 - 'AtomNavigatorList.js' */        methods: {
/*Line 39 - 'AtomNavigatorList.js' */            get_newItemCopy: function () {
/*Line 40 - 'AtomNavigatorList.js' */                return this._newItemCopy;
/*Line 41 - 'AtomNavigatorList.js' */            },


/*Line 44 - 'AtomNavigatorList.js' */            onBackCommand: function () {
/*Line 45 - 'AtomNavigatorList.js' */                AtomBinder.setValue(this, "displayMode", 0);
/*Line 46 - 'AtomNavigatorList.js' */                this.updateDisplayMode();
/*Line 47 - 'AtomNavigatorList.js' */                AtomBinder.setValue(this, "selectedIndex", -1);
/*Line 48 - 'AtomNavigatorList.js' */            },

/*Line 50 - 'AtomNavigatorList.js' */            onCancelAddNewCommand: function () {
/*Line 51 - 'AtomNavigatorList.js' */                this.onBackCommand();
/*Line 52 - 'AtomNavigatorList.js' */                AtomBinder.refreshValue(this, "newItemCopy");
/*Line 53 - 'AtomNavigatorList.js' */                this.refresh();
/*Line 54 - 'AtomNavigatorList.js' */            },

/*Line 56 - 'AtomNavigatorList.js' */            onAddCommand: function () {
/*Line 57 - 'AtomNavigatorList.js' */                AtomBinder.setValue(this, "selectedIndex", -1);
/*Line 58 - 'AtomNavigatorList.js' */                AtomBinder.setValue(this, "displayMode", 2);
/*Line 59 - 'AtomNavigatorList.js' */                var item = this._newItem || {};
/*Line 60 - 'AtomNavigatorList.js' */                this._newItemCopy = AtomBinder.getClone(item);
/*Line 61 - 'AtomNavigatorList.js' */                AtomBinder.refreshValue(this, "newItemCopy");
/*Line 62 - 'AtomNavigatorList.js' */                this.updateDisplayMode();
/*Line 63 - 'AtomNavigatorList.js' */            },

/*Line 65 - 'AtomNavigatorList.js' */            onSelectedItemsChanged: function () {
/*Line 66 - 'AtomNavigatorList.js' */                base.onSelectedItemsChanged.apply(this, arguments);

/*Line 68 - 'AtomNavigatorList.js' */                if (this._autoShowDetail) {
/*Line 69 - 'AtomNavigatorList.js' */                    this.showDetailCommand();
/*Line 70 - 'AtomNavigatorList.js' */                }
/*Line 71 - 'AtomNavigatorList.js' */            },

/*Line 73 - 'AtomNavigatorList.js' */            addTemplate: function (p, e, inite) {
/*Line 74 - 'AtomNavigatorList.js' */                if (inite) {
/*Line 75 - 'AtomNavigatorList.js' */                    p.appendChild(e);
/*Line 76 - 'AtomNavigatorList.js' */                    e._templateParent = this;
/*Line 77 - 'AtomNavigatorList.js' */                    this.onCreateChildren(p);
/*Line 78 - 'AtomNavigatorList.js' */                    //this.setProperties(e);
/*Line 79 - 'AtomNavigatorList.js' */                    this.initChildren(p);
/*Line 80 - 'AtomNavigatorList.js' */                } else {
/*Line 81 - 'AtomNavigatorList.js' */                    p.appendChild(e);
/*Line 82 - 'AtomNavigatorList.js' */                    e._templateParent = this;
/*Line 83 - 'AtomNavigatorList.js' */                    this.onCreateChildren(p);
/*Line 84 - 'AtomNavigatorList.js' */                }
/*Line 85 - 'AtomNavigatorList.js' */            },

/*Line 87 - 'AtomNavigatorList.js' */            updateDisplayMode: function () {
/*Line 88 - 'AtomNavigatorList.js' */                var v = this._displayMode;
/*Line 89 - 'AtomNavigatorList.js' */                if (v == 0) {

/*Line 91 - 'AtomNavigatorList.js' */                    if (this._detailPresenter) {
/*Line 92 - 'AtomNavigatorList.js' */                        this._detailView.atomControl.dispose(this._detailPresenter);
/*Line 93 - 'AtomNavigatorList.js' */                        this._detailPresenter = null;
/*Line 94 - 'AtomNavigatorList.js' */                    }
/*Line 95 - 'AtomNavigatorList.js' */                    if (this._newPresenter) {
/*Line 96 - 'AtomNavigatorList.js' */                        this._newView.atomControl.dispose(this._newPresenter);
/*Line 97 - 'AtomNavigatorList.js' */                        this._newPresenter = null;
/*Line 98 - 'AtomNavigatorList.js' */                    }
/*Line 99 - 'AtomNavigatorList.js' */                    if (this._detailHeaderPresenter) {
/*Line 100 - 'AtomNavigatorList.js' */                        this._detailView.atomControl.dispose(this._detailHeaderPresenter);
/*Line 101 - 'AtomNavigatorList.js' */                        this._detailHeaderPresenter = null;
/*Line 102 - 'AtomNavigatorList.js' */                    }
/*Line 103 - 'AtomNavigatorList.js' */                    if (this._newHeaderPresenter) {
/*Line 104 - 'AtomNavigatorList.js' */                        this._newView.atomControl.dispose(this._newHeaderPresenter);
/*Line 105 - 'AtomNavigatorList.js' */                        this._newHeaderPresenter = null;
/*Line 106 - 'AtomNavigatorList.js' */                    }

/*Line 108 - 'AtomNavigatorList.js' */                    return;
/*Line 109 - 'AtomNavigatorList.js' */                }

/*Line 111 - 'AtomNavigatorList.js' */                var c = null;
/*Line 112 - 'AtomNavigatorList.js' */                var ct = this.getTemplate("detailTemplate");;
/*Line 113 - 'AtomNavigatorList.js' */                var ch = null;
/*Line 114 - 'AtomNavigatorList.js' */                var cht;
/*Line 115 - 'AtomNavigatorList.js' */                var key = "";

/*Line 117 - 'AtomNavigatorList.js' */                if (v == 1) {
/*Line 118 - 'AtomNavigatorList.js' */                    c = this._detailView;
/*Line 119 - 'AtomNavigatorList.js' */                    ch = this._detailHeaderToolbar;
/*Line 120 - 'AtomNavigatorList.js' */                    cht = this.getTemplate("detailHeaderTemplate");
/*Line 121 - 'AtomNavigatorList.js' */                    key = "_detail";
/*Line 122 - 'AtomNavigatorList.js' */                } else {
/*Line 123 - 'AtomNavigatorList.js' */                    c = this._newView;
/*Line 124 - 'AtomNavigatorList.js' */                    ch = this._newHeaderToolbar;
/*Line 125 - 'AtomNavigatorList.js' */                    cht = this.getTemplate("newHeaderTemplate");
/*Line 126 - 'AtomNavigatorList.js' */                    key = "_new";
/*Line 127 - 'AtomNavigatorList.js' */                }

/*Line 129 - 'AtomNavigatorList.js' */                if (ch && cht) {
/*Line 130 - 'AtomNavigatorList.js' */                    cht = AtomUI.cloneNode(cht);
/*Line 131 - 'AtomNavigatorList.js' */                    this.addTemplate(ch, cht, true);
/*Line 132 - 'AtomNavigatorList.js' */                    this[key + "HeaderPresenter"] = cht;
/*Line 133 - 'AtomNavigatorList.js' */                }

/*Line 135 - 'AtomNavigatorList.js' */                if (c && ct) {
/*Line 136 - 'AtomNavigatorList.js' */                    ct = AtomUI.cloneNode(ct);
/*Line 137 - 'AtomNavigatorList.js' */                    this.addTemplate(c, ct, true);
/*Line 138 - 'AtomNavigatorList.js' */                    this[key + "Presenter"] = ct;
/*Line 139 - 'AtomNavigatorList.js' */                }
/*Line 140 - 'AtomNavigatorList.js' */            },

/*Line 142 - 'AtomNavigatorList.js' */            createChildren: function () {
/*Line 143 - 'AtomNavigatorList.js' */                base.createChildren.call(this);

/*Line 145 - 'AtomNavigatorList.js' */                this.getTemplate("gridTemplate");
/*Line 146 - 'AtomNavigatorList.js' */                this.getTemplate("detailTemplate");
/*Line 147 - 'AtomNavigatorList.js' */                this.getTemplate("searchTemplate");
/*Line 148 - 'AtomNavigatorList.js' */                this.getTemplate("detailHeaderTemplate");
/*Line 149 - 'AtomNavigatorList.js' */                this.getTemplate("newHeaderTemplate");
/*Line 150 - 'AtomNavigatorList.js' */                this.getTemplate("headerTemplate");
/*Line 151 - 'AtomNavigatorList.js' */                this.getTemplate("footerTemplate");

/*Line 153 - 'AtomNavigatorList.js' */                var p = this.get_scope();

/*Line 155 - 'AtomNavigatorList.js' */                this._newView.atomControl._scope = new AtomScope(this, p);
/*Line 156 - 'AtomNavigatorList.js' */                this._detailView.atomControl._scope = new AtomScope(this, p);

/*Line 158 - 'AtomNavigatorList.js' */                var g = AtomUI.cloneNode(this._gridTemplate);
/*Line 159 - 'AtomNavigatorList.js' */                this.addTemplate(this._gridPresenter, g);

/*Line 161 - 'AtomNavigatorList.js' */                var dt = this._detailTemplate;
/*Line 162 - 'AtomNavigatorList.js' */                if (!(AtomUI.attr(dt,"atom-dock"))) {
/*Line 163 - 'AtomNavigatorList.js' */                    AtomUI.attr(dt, "atom-dock", "Fill");
/*Line 164 - 'AtomNavigatorList.js' */                }

/*Line 166 - 'AtomNavigatorList.js' */                if (this._headerTemplate) {
/*Line 167 - 'AtomNavigatorList.js' */                    var hd = AtomUI.cloneNode(this._headerTemplate);
/*Line 168 - 'AtomNavigatorList.js' */                    hd.setAttribute("atom-dock", "Top");
/*Line 169 - 'AtomNavigatorList.js' */                    $(hd).addClass("atom-navigator-list-header");
/*Line 170 - 'AtomNavigatorList.js' */                    hd._templateParent = this;
/*Line 171 - 'AtomNavigatorList.js' */                    this.addTemplate(this._gridPanel, hd);
/*Line 172 - 'AtomNavigatorList.js' */                }

/*Line 174 - 'AtomNavigatorList.js' */                if (this._footerTemplate) {
/*Line 175 - 'AtomNavigatorList.js' */                    var fd = AtomUI.cloneNode(this._footerTemplate);
/*Line 176 - 'AtomNavigatorList.js' */                    fd.setAttribute("atom-dock", "Bottom");
/*Line 177 - 'AtomNavigatorList.js' */                    $(fd).addClass("atom-navigator-list-footer");
/*Line 178 - 'AtomNavigatorList.js' */                    this.addTemplate(this._gridPanel, fd);
/*Line 179 - 'AtomNavigatorList.js' */                }
/*Line 180 - 'AtomNavigatorList.js' */            },

/*Line 182 - 'AtomNavigatorList.js' */            init: function () {
/*Line 183 - 'AtomNavigatorList.js' */                base.init.call(this);

/*Line 185 - 'AtomNavigatorList.js' */                var _this = this;

/*Line 187 - 'AtomNavigatorList.js' */                this.backCommand = function () {
/*Line 188 - 'AtomNavigatorList.js' */                    _this.onBackCommand.apply(_this, arguments);
/*Line 189 - 'AtomNavigatorList.js' */                };

/*Line 191 - 'AtomNavigatorList.js' */                this.addCommand = function () {
/*Line 192 - 'AtomNavigatorList.js' */                    _this.onAddCommand.apply(_this, arguments);
/*Line 193 - 'AtomNavigatorList.js' */                };

/*Line 195 - 'AtomNavigatorList.js' */                this.cancelAddCommand = function () {
/*Line 196 - 'AtomNavigatorList.js' */                    _this.onCancelAddNewCommand.apply(_this, arguments);
/*Line 197 - 'AtomNavigatorList.js' */                };

/*Line 199 - 'AtomNavigatorList.js' */                this.showDetailCommand = function () {
/*Line 200 - 'AtomNavigatorList.js' */                    var s = _this.get_selectedItem();
/*Line 201 - 'AtomNavigatorList.js' */                    if (s) {
/*Line 202 - 'AtomNavigatorList.js' */                        AtomBinder.setValue(_this, "displayMode", 1);
/*Line 203 - 'AtomNavigatorList.js' */                        _this.updateDisplayMode();
/*Line 204 - 'AtomNavigatorList.js' */                    }
/*Line 205 - 'AtomNavigatorList.js' */                };
/*Line 206 - 'AtomNavigatorList.js' */            }
/*Line 207 - 'AtomNavigatorList.js' */        }
/*Line 208 - 'AtomNavigatorList.js' */    });
/*Line 209 - 'AtomNavigatorList.js' */})(WebAtoms.AtomListBox.prototype);

/*Line 0 - 'AtomNumberComboBox.js' */

/*Line 2 - 'AtomNumberComboBox.js' */(function (base) {

/*Line 4 - 'AtomNumberComboBox.js' */    var AtomUI = window.AtomUI;

/*Line 6 - 'AtomNumberComboBox.js' */    return classCreatorEx({
/*Line 7 - 'AtomNumberComboBox.js' */        name: "WebAtoms.AtomNumberComboBox",
/*Line 8 - 'AtomNumberComboBox.js' */        base: base,
/*Line 9 - 'AtomNumberComboBox.js' */        start: function () { },
/*Line 10 - 'AtomNumberComboBox.js' */        properties: {
/*Line 11 - 'AtomNumberComboBox.js' */            showPrompt: false,
/*Line 12 - 'AtomNumberComboBox.js' */            startNumber: undefined,
/*Line 13 - 'AtomNumberComboBox.js' */            endNumber: undefined,
/*Line 14 - 'AtomNumberComboBox.js' */            step:1
/*Line 15 - 'AtomNumberComboBox.js' */        },
/*Line 16 - 'AtomNumberComboBox.js' */        methods: {
/*Line 17 - 'AtomNumberComboBox.js' */            set_startNumber: function (v) {
/*Line 18 - 'AtomNumberComboBox.js' */                this._startNumber = v;
/*Line 19 - 'AtomNumberComboBox.js' */                this.resetNumbers();
/*Line 20 - 'AtomNumberComboBox.js' */            },

/*Line 22 - 'AtomNumberComboBox.js' */            set_endNumber: function (v) {
/*Line 23 - 'AtomNumberComboBox.js' */                this._endNumber = v;
/*Line 24 - 'AtomNumberComboBox.js' */                this.resetNumbers();
/*Line 25 - 'AtomNumberComboBox.js' */            },

/*Line 27 - 'AtomNumberComboBox.js' */            set_step: function (v) {
/*Line 28 - 'AtomNumberComboBox.js' */                if (!v)
/*Line 29 - 'AtomNumberComboBox.js' */                    return;
/*Line 30 - 'AtomNumberComboBox.js' */                this._step = v;
/*Line 31 - 'AtomNumberComboBox.js' */                this.resetNumbers();
/*Line 32 - 'AtomNumberComboBox.js' */            },

/*Line 34 - 'AtomNumberComboBox.js' */            onLoaded: function () {
/*Line 35 - 'AtomNumberComboBox.js' */                this.resetNumbers();
/*Line 36 - 'AtomNumberComboBox.js' */            },

/*Line 38 - 'AtomNumberComboBox.js' */            resetNumbers: function () {
/*Line 39 - 'AtomNumberComboBox.js' */                if (!this._created)
/*Line 40 - 'AtomNumberComboBox.js' */                    return;
/*Line 41 - 'AtomNumberComboBox.js' */                if ((this._startNumber === undefined) || (this._endNumber === undefined))
/*Line 42 - 'AtomNumberComboBox.js' */                    return;
/*Line 43 - 'AtomNumberComboBox.js' */                var sn = AtomUI.toNumber(this._startNumber);
/*Line 44 - 'AtomNumberComboBox.js' */                var en = AtomUI.toNumber(this._endNumber);
/*Line 45 - 'AtomNumberComboBox.js' */                var step = AtomUI.toNumber(this._step);
/*Line 46 - 'AtomNumberComboBox.js' */                var numbers = [];
/*Line 47 - 'AtomNumberComboBox.js' */                if (this._showPrompt) {
/*Line 48 - 'AtomNumberComboBox.js' */                    numbers.push({ label: "Select", value: 0 });
/*Line 49 - 'AtomNumberComboBox.js' */                }
/*Line 50 - 'AtomNumberComboBox.js' */                for (; sn <= en; sn += step) {
/*Line 51 - 'AtomNumberComboBox.js' */                    numbers.push({ label: sn, value: sn });
/*Line 52 - 'AtomNumberComboBox.js' */                }

/*Line 54 - 'AtomNumberComboBox.js' */                this.set_items(numbers);
/*Line 55 - 'AtomNumberComboBox.js' */            }
/*Line 56 - 'AtomNumberComboBox.js' */        }
/*Line 57 - 'AtomNumberComboBox.js' */    });
/*Line 58 - 'AtomNumberComboBox.js' */})(WebAtoms.AtomComboBox.prototype);

/*Line 0 - 'AtomPhoneControl.js' */
/*Line 1 - 'AtomPhoneControl.js' */
/*Line 2 - 'AtomPhoneControl.js' */



/*Line 6 - 'AtomPhoneControl.js' */(function (base) {

/*Line 8 - 'AtomPhoneControl.js' */    var document = window.document;
/*Line 9 - 'AtomPhoneControl.js' */    var $ = window.$;

/*Line 11 - 'AtomPhoneControl.js' */    var phoneConfig = [
/*Line 12 - 'AtomPhoneControl.js' */        {
/*Line 13 - 'AtomPhoneControl.js' */            label: "(US +1)",
/*Line 14 - 'AtomPhoneControl.js' */            code: 1,
/*Line 15 - 'AtomPhoneControl.js' */            country: "US",
/*Line 16 - 'AtomPhoneControl.js' */            format: "999-999-9999"
/*Line 17 - 'AtomPhoneControl.js' */        },
/*Line 18 - 'AtomPhoneControl.js' */        {
/*Line 19 - 'AtomPhoneControl.js' */            label: "(CA +1)",
/*Line 20 - 'AtomPhoneControl.js' */            code: 1,
/*Line 21 - 'AtomPhoneControl.js' */            country: "CA",
/*Line 22 - 'AtomPhoneControl.js' */            format: "999-999-9999"
/*Line 23 - 'AtomPhoneControl.js' */        },
/*Line 24 - 'AtomPhoneControl.js' */        {
/*Line 25 - 'AtomPhoneControl.js' */            label: "(IN +91)",
/*Line 26 - 'AtomPhoneControl.js' */            code: 91,
/*Line 27 - 'AtomPhoneControl.js' */            country: "IN",
/*Line 28 - 'AtomPhoneControl.js' */            format: "99-99-999999"
/*Line 29 - 'AtomPhoneControl.js' */        },
/*Line 30 - 'AtomPhoneControl.js' */        {
/*Line 31 - 'AtomPhoneControl.js' */            label: "(UK +44)",
/*Line 32 - 'AtomPhoneControl.js' */            code: 44,
/*Line 33 - 'AtomPhoneControl.js' */            country: "UK",
/*Line 34 - 'AtomPhoneControl.js' */            format: "999-999-9999"
/*Line 35 - 'AtomPhoneControl.js' */        },
/*Line 36 - 'AtomPhoneControl.js' */    ];

/*Line 38 - 'AtomPhoneControl.js' */    return classCreatorEx({
/*Line 39 - 'AtomPhoneControl.js' */        name: "WebAtoms.AtomPhoneControl",
/*Line 40 - 'AtomPhoneControl.js' */        base: base,
/*Line 41 - 'AtomPhoneControl.js' */        start: function () {
/*Line 42 - 'AtomPhoneControl.js' */            this._value = "";
/*Line 43 - 'AtomPhoneControl.js' */        },
/*Line 44 - 'AtomPhoneControl.js' */        properties: {
/*Line 45 - 'AtomPhoneControl.js' */            countries: phoneConfig
/*Line 46 - 'AtomPhoneControl.js' */        },
/*Line 47 - 'AtomPhoneControl.js' */        methods: {
/*Line 48 - 'AtomPhoneControl.js' */            set_value: function (v) {
/*Line 49 - 'AtomPhoneControl.js' */                this._value = v;
/*Line 50 - 'AtomPhoneControl.js' */                if (this._countries) {
/*Line 51 - 'AtomPhoneControl.js' */                    this.setupValues();
/*Line 52 - 'AtomPhoneControl.js' */                }
/*Line 53 - 'AtomPhoneControl.js' */            },

/*Line 55 - 'AtomPhoneControl.js' */            setupValues: function () {
/*Line 56 - 'AtomPhoneControl.js' */                if (!this._value) {
/*Line 57 - 'AtomPhoneControl.js' */                    $(this.num).val("");
/*Line 58 - 'AtomPhoneControl.js' */                    $(this.ext).val("");
/*Line 59 - 'AtomPhoneControl.js' */                    $(this.msg).val("");
/*Line 60 - 'AtomPhoneControl.js' */                    return;
/*Line 61 - 'AtomPhoneControl.js' */                }
/*Line 62 - 'AtomPhoneControl.js' */                var tokens = this._value.split(":", 6);

/*Line 64 - 'AtomPhoneControl.js' */                var cc = tokens[1];

/*Line 66 - 'AtomPhoneControl.js' */                var ae = new AtomEnumerator(this._countries);
/*Line 67 - 'AtomPhoneControl.js' */                while (ae.next()) {
/*Line 68 - 'AtomPhoneControl.js' */                    var ci = ae.current();
/*Line 69 - 'AtomPhoneControl.js' */                    if (ci.country == cc) {
/*Line 70 - 'AtomPhoneControl.js' */                        this.cs.selectedIndex = ae.currentIndex();
/*Line 71 - 'AtomPhoneControl.js' */                        break;
/*Line 72 - 'AtomPhoneControl.js' */                    }
/*Line 73 - 'AtomPhoneControl.js' */                }

/*Line 75 - 'AtomPhoneControl.js' */                var num = (tokens[3] || "").split(".").join("-");
/*Line 76 - 'AtomPhoneControl.js' */                if (num == "--")
/*Line 77 - 'AtomPhoneControl.js' */                    num = "";
/*Line 78 - 'AtomPhoneControl.js' */                $(this.num).val(num);
/*Line 79 - 'AtomPhoneControl.js' */                $(this.ext).val(tokens[4]);
/*Line 80 - 'AtomPhoneControl.js' */                $(this.msg).val(tokens[5]);
/*Line 81 - 'AtomPhoneControl.js' */                this.onFormat();
/*Line 82 - 'AtomPhoneControl.js' */            },

/*Line 84 - 'AtomPhoneControl.js' */            onDataChange: function () {
/*Line 85 - 'AtomPhoneControl.js' */                var value = "v2:";
/*Line 86 - 'AtomPhoneControl.js' */                var si = this.cs.selectedIndex;
/*Line 87 - 'AtomPhoneControl.js' */                var ci = this._countries[si];
/*Line 88 - 'AtomPhoneControl.js' */                value += ci.country + ":" + ci.code;
/*Line 89 - 'AtomPhoneControl.js' */                var num = (($(this.num).val()).split("-").join("."));
/*Line 90 - 'AtomPhoneControl.js' */                value += ":" + num;
/*Line 91 - 'AtomPhoneControl.js' */                value += ":" + $(this.ext).val();
/*Line 92 - 'AtomPhoneControl.js' */                value += ":" + $(this.msg).val();

/*Line 94 - 'AtomPhoneControl.js' */                if (num) {
/*Line 95 - 'AtomPhoneControl.js' */                    this._value = value;
/*Line 96 - 'AtomPhoneControl.js' */                } else {
/*Line 97 - 'AtomPhoneControl.js' */                    this._value = "";
/*Line 98 - 'AtomPhoneControl.js' */                }

/*Line 100 - 'AtomPhoneControl.js' */                AtomBinder.refreshValue(this, "value");
/*Line 101 - 'AtomPhoneControl.js' */            },

/*Line 103 - 'AtomPhoneControl.js' */            set_countries: function (r) {
/*Line 104 - 'AtomPhoneControl.js' */                this._countries = r;
/*Line 105 - 'AtomPhoneControl.js' */                this.onFormat();
/*Line 106 - 'AtomPhoneControl.js' */            },


/*Line 109 - 'AtomPhoneControl.js' */            onCountryChange: function () {
/*Line 110 - 'AtomPhoneControl.js' */                this.onDataChange();
/*Line 111 - 'AtomPhoneControl.js' */                this.onFormat();
/*Line 112 - 'AtomPhoneControl.js' */            },

/*Line 114 - 'AtomPhoneControl.js' */            onFormat: function () {
/*Line 115 - 'AtomPhoneControl.js' */                if (this._isFormatting) return;
/*Line 116 - 'AtomPhoneControl.js' */                this._isFormatting = true;

/*Line 118 - 'AtomPhoneControl.js' */                var r = this._countries;
/*Line 119 - 'AtomPhoneControl.js' */                var options = this.cs.options;
/*Line 120 - 'AtomPhoneControl.js' */                options.length = r.length;
/*Line 121 - 'AtomPhoneControl.js' */                var last = this.cs.selectedIndex;
/*Line 122 - 'AtomPhoneControl.js' */                var ae = new AtomEnumerator(r);
/*Line 123 - 'AtomPhoneControl.js' */                while (ae.next()) {
/*Line 124 - 'AtomPhoneControl.js' */                    var ci = ae.current();
/*Line 125 - 'AtomPhoneControl.js' */                    if (!ci.valueIndex) {
/*Line 126 - 'AtomPhoneControl.js' */                        ci.label = ci.label;
/*Line 127 - 'AtomPhoneControl.js' */                        ci.valueIndex = ae.currentIndex();
/*Line 128 - 'AtomPhoneControl.js' */                    }
/*Line 129 - 'AtomPhoneControl.js' */                    options[ae.currentIndex()] = new Option(ci.label, ci.valueIndex, false, false);
/*Line 130 - 'AtomPhoneControl.js' */                }

/*Line 132 - 'AtomPhoneControl.js' */                this.setupValues();
/*Line 133 - 'AtomPhoneControl.js' */                this.cs.selectedIndex = last;

/*Line 135 - 'AtomPhoneControl.js' */                var cs = this.cs;
/*Line 136 - 'AtomPhoneControl.js' */                if (cs.selectedIndex == -1)
/*Line 137 - 'AtomPhoneControl.js' */                    return;
/*Line 138 - 'AtomPhoneControl.js' */                var ci = this._countries[cs.selectedIndex];

/*Line 140 - 'AtomPhoneControl.js' */                if (ci.format) {
/*Line 141 - 'AtomPhoneControl.js' */                    $(this.num).mask(ci.format);
/*Line 142 - 'AtomPhoneControl.js' */                } else {
/*Line 143 - 'AtomPhoneControl.js' */                    $(this.num).unmask();
/*Line 144 - 'AtomPhoneControl.js' */                }
/*Line 145 - 'AtomPhoneControl.js' */                this._isFormatting = false;
/*Line 146 - 'AtomPhoneControl.js' */            },


/*Line 149 - 'AtomPhoneControl.js' */            init: function () {
/*Line 150 - 'AtomPhoneControl.js' */                this.cs = document.createElement("SELECT");
/*Line 151 - 'AtomPhoneControl.js' */                //this.cs.style['float'] = "left";
/*Line 152 - 'AtomPhoneControl.js' */                this.num = document.createElement("INPUT");
/*Line 153 - 'AtomPhoneControl.js' */                this.num.type = "text";
/*Line 154 - 'AtomPhoneControl.js' */                //this.num.style.width = "150px";
/*Line 155 - 'AtomPhoneControl.js' */                //this.num.style['float'] = "left";
/*Line 156 - 'AtomPhoneControl.js' */                //this.num.style.marginLeft = "2px";
/*Line 157 - 'AtomPhoneControl.js' */                this.ext = document.createElement("INPUT");
/*Line 158 - 'AtomPhoneControl.js' */                //this.num = [this.num1, this.num2, this.num3, this.ext];
/*Line 159 - 'AtomPhoneControl.js' */                this.ext.type = "text";
/*Line 160 - 'AtomPhoneControl.js' */                //this.ext.style.width = "30px";
/*Line 161 - 'AtomPhoneControl.js' */                //this.ext.style['float'] = "left";
/*Line 162 - 'AtomPhoneControl.js' */                //this.ext.style.marginLeft = "2px";
/*Line 163 - 'AtomPhoneControl.js' */                $(this.ext).attr("placeholder", "Ext.");
/*Line 164 - 'AtomPhoneControl.js' */                this.msg = document.createElement("INPUT");
/*Line 165 - 'AtomPhoneControl.js' */                this.msg.type = "text";
/*Line 166 - 'AtomPhoneControl.js' */                //this.msg.style.width = "100px";
/*Line 167 - 'AtomPhoneControl.js' */                //this.msg.style['float'] = "left";
/*Line 168 - 'AtomPhoneControl.js' */                //this.msg.style.marginLeft = "2px";
/*Line 169 - 'AtomPhoneControl.js' */                $(this.msg).attr("placeholder", "Message");

/*Line 171 - 'AtomPhoneControl.js' */                var element = this.get_element();
/*Line 172 - 'AtomPhoneControl.js' */                //element.style.width = "450px";
/*Line 173 - 'AtomPhoneControl.js' */                element.appendChild(this.cs);
/*Line 174 - 'AtomPhoneControl.js' */                element.appendChild(this.num);
/*Line 175 - 'AtomPhoneControl.js' */                element.appendChild(this.ext);
/*Line 176 - 'AtomPhoneControl.js' */                element.appendChild(this.msg);

/*Line 178 - 'AtomPhoneControl.js' */                var caller = this;

/*Line 180 - 'AtomPhoneControl.js' */                this.onKeyUpLater = function (e) {
/*Line 181 - 'AtomPhoneControl.js' */                    var evt = e;
/*Line 182 - 'AtomPhoneControl.js' */                    caller.onDataChange(evt);
/*Line 183 - 'AtomPhoneControl.js' */                };

/*Line 185 - 'AtomPhoneControl.js' */                this.bindEvent(this.cs, "change", "onCountryChange");
/*Line 186 - 'AtomPhoneControl.js' */                this.bindEvent(this.num, "change", "onDataChange");
/*Line 187 - 'AtomPhoneControl.js' */                this.bindEvent(this.num, "keyup", "onKeyUpLater");
/*Line 188 - 'AtomPhoneControl.js' */                this.bindEvent(this.num, "keypress", "onKeyUpLater");
/*Line 189 - 'AtomPhoneControl.js' */                this.bindEvent(this.ext, "change", "onDataChange");
/*Line 190 - 'AtomPhoneControl.js' */                this.bindEvent(this.msg, "change", "onDataChange");

/*Line 192 - 'AtomPhoneControl.js' */                $(this._element).addClass("atom-phone-control");
/*Line 193 - 'AtomPhoneControl.js' */                $(this.num).addClass("atom-pc-num");
/*Line 194 - 'AtomPhoneControl.js' */                $(this.msg).addClass("atom-pc-msg");
/*Line 195 - 'AtomPhoneControl.js' */                $(this.cs).addClass("atom-pc-cs");
/*Line 196 - 'AtomPhoneControl.js' */                $(this.ext).addClass("atom-pc-ext");


/*Line 199 - 'AtomPhoneControl.js' */                base.init.call(this);
/*Line 200 - 'AtomPhoneControl.js' */                var phone = this;

/*Line 202 - 'AtomPhoneControl.js' */                WebAtoms.dispatcher.callLater(function () {
/*Line 203 - 'AtomPhoneControl.js' */                    phone.onFormat();
/*Line 204 - 'AtomPhoneControl.js' */                });

/*Line 206 - 'AtomPhoneControl.js' */            }
/*Line 207 - 'AtomPhoneControl.js' */        }
/*Line 208 - 'AtomPhoneControl.js' */    });
/*Line 209 - 'AtomPhoneControl.js' */})(WebAtoms.AtomControl.prototype);
/*Line 0 - 'AtomRadioButtonList.js' */

/*Line 2 - 'AtomRadioButtonList.js' */(function (baseType) {
/*Line 3 - 'AtomRadioButtonList.js' */    return classCreatorEx({
/*Line 4 - 'AtomRadioButtonList.js' */        name: "WebAtoms.AtomRadioButtonList",
/*Line 5 - 'AtomRadioButtonList.js' */        base: baseType,
/*Line 6 - 'AtomRadioButtonList.js' */        start: function () {
/*Line 7 - 'AtomRadioButtonList.js' */            this._allowMultipleSelection = false;
/*Line 8 - 'AtomRadioButtonList.js' */        },
/*Line 9 - 'AtomRadioButtonList.js' */        properties: {
/*Line 10 - 'AtomRadioButtonList.js' */            groupName:""
/*Line 11 - 'AtomRadioButtonList.js' */        },
/*Line 12 - 'AtomRadioButtonList.js' */        methods: {
/*Line 13 - 'AtomRadioButtonList.js' */            init: function () {
/*Line 14 - 'AtomRadioButtonList.js' */                this._groupName = "__g" + AtomUI.getNewIndex();
/*Line 15 - 'AtomRadioButtonList.js' */                baseType.init.call(this);
/*Line 16 - 'AtomRadioButtonList.js' */            }
/*Line 17 - 'AtomRadioButtonList.js' */        }
/*Line 18 - 'AtomRadioButtonList.js' */    });
/*Line 19 - 'AtomRadioButtonList.js' */})(WebAtoms.AtomItemsControl.prototype);

/*Line 0 - 'AtomSortableColumn.js' */

/*Line 2 - 'AtomSortableColumn.js' */(function (baseType) {
/*Line 3 - 'AtomSortableColumn.js' */    return classCreatorEx({
/*Line 4 - 'AtomSortableColumn.js' */        name: "WebAtoms.AtomSortableColumn",
/*Line 5 - 'AtomSortableColumn.js' */        base: baseType,
/*Line 6 - 'AtomSortableColumn.js' */        start: function () {
/*Line 7 - 'AtomSortableColumn.js' */        },
/*Line 8 - 'AtomSortableColumn.js' */        properties: {
/*Line 9 - 'AtomSortableColumn.js' */            direction: "",
/*Line 10 - 'AtomSortableColumn.js' */            defaultDirection: "",
/*Line 11 - 'AtomSortableColumn.js' */            label: "",
/*Line 12 - 'AtomSortableColumn.js' */            sortField: null
/*Line 13 - 'AtomSortableColumn.js' */        },
/*Line 14 - 'AtomSortableColumn.js' */        methods: {
/*Line 15 - 'AtomSortableColumn.js' */            set_direction: function (v) {
/*Line 16 - 'AtomSortableColumn.js' */                this._direction = v;
/*Line 17 - 'AtomSortableColumn.js' */                var $e = $(this._element);
/*Line 18 - 'AtomSortableColumn.js' */                $e.removeClass("atom-sort-asc atom-sort-desc");
/*Line 19 - 'AtomSortableColumn.js' */                if (v) {
/*Line 20 - 'AtomSortableColumn.js' */                    $e.addClass("atom-sort-" + v.toLowerCase());
/*Line 21 - 'AtomSortableColumn.js' */                }
/*Line 22 - 'AtomSortableColumn.js' */            },

/*Line 24 - 'AtomSortableColumn.js' */            set_value: function (v) {
/*Line 25 - 'AtomSortableColumn.js' */                this._value = v;
/*Line 26 - 'AtomSortableColumn.js' */                this.refreshUI();
/*Line 27 - 'AtomSortableColumn.js' */            },

/*Line 29 - 'AtomSortableColumn.js' */            refreshUI: function () {
/*Line 30 - 'AtomSortableColumn.js' */                if (!this._value)
/*Line 31 - 'AtomSortableColumn.js' */                    return;
/*Line 32 - 'AtomSortableColumn.js' */                if (this._value.indexOf(this._sortField) == -1) {
/*Line 33 - 'AtomSortableColumn.js' */                    AtomBinder.setValue(this, "direction", "");
/*Line 34 - 'AtomSortableColumn.js' */                    return;
/*Line 35 - 'AtomSortableColumn.js' */                }

/*Line 37 - 'AtomSortableColumn.js' */                if (this._value.lastIndexOf("desc") != this._value.length - 4) {
/*Line 38 - 'AtomSortableColumn.js' */                    AtomBinder.setValue(this, "direction", "asc");
/*Line 39 - 'AtomSortableColumn.js' */                } else {
/*Line 40 - 'AtomSortableColumn.js' */                    AtomBinder.setValue(this, "direction", "desc");
/*Line 41 - 'AtomSortableColumn.js' */                }
/*Line 42 - 'AtomSortableColumn.js' */            },

/*Line 44 - 'AtomSortableColumn.js' */            onClick: function (e) {
/*Line 45 - 'AtomSortableColumn.js' */                if (!this._direction) {
/*Line 46 - 'AtomSortableColumn.js' */                    AtomBinder.setValue(this, "direction", this._defaultDirection);
/*Line 47 - 'AtomSortableColumn.js' */                } else {
/*Line 48 - 'AtomSortableColumn.js' */                    if (this._direction == "asc") {
/*Line 49 - 'AtomSortableColumn.js' */                        AtomBinder.setValue(this, "direction", "desc");
/*Line 50 - 'AtomSortableColumn.js' */                    } else {
/*Line 51 - 'AtomSortableColumn.js' */                        AtomBinder.setValue(this, "direction", "asc");
/*Line 52 - 'AtomSortableColumn.js' */                    }
/*Line 53 - 'AtomSortableColumn.js' */                }
/*Line 54 - 'AtomSortableColumn.js' */                AtomBinder.setValue(this, "value", this._sortField + " " + this._direction);
/*Line 55 - 'AtomSortableColumn.js' */            },

/*Line 57 - 'AtomSortableColumn.js' */            init: function () {
/*Line 58 - 'AtomSortableColumn.js' */                baseType.init.call(this);

/*Line 60 - 'AtomSortableColumn.js' */                this.bindEvent(this._element, "click", "onClick");
/*Line 61 - 'AtomSortableColumn.js' */                $(this._element).addClass("atom-column");

/*Line 63 - 'AtomSortableColumn.js' */            },

/*Line 65 - 'AtomSortableColumn.js' */            onUpdateUI: function () {
/*Line 66 - 'AtomSortableColumn.js' */                this.refreshUI();
/*Line 67 - 'AtomSortableColumn.js' */            }
/*Line 68 - 'AtomSortableColumn.js' */        }
/*Line 69 - 'AtomSortableColumn.js' */    });
/*Line 70 - 'AtomSortableColumn.js' */})(WebAtoms.AtomControl.prototype);
/*Line 0 - 'AtomTabButtonBar.js' */

/*Line 2 - 'AtomTabButtonBar.js' */(function (baseType) {
/*Line 3 - 'AtomTabButtonBar.js' */    return classCreatorEx({
/*Line 4 - 'AtomTabButtonBar.js' */        name: "WebAtoms.AtomTabButtonBar",
/*Line 5 - 'AtomTabButtonBar.js' */        base: baseType,
/*Line 6 - 'AtomTabButtonBar.js' */        start: function () {
/*Line 7 - 'AtomTabButtonBar.js' */            this._allowMultipleSelection = false;
/*Line 8 - 'AtomTabButtonBar.js' */            this._showTabs = true;
/*Line 9 - 'AtomTabButtonBar.js' */        },
/*Line 10 - 'AtomTabButtonBar.js' */        methods: {

/*Line 12 - 'AtomTabButtonBar.js' */        }
/*Line 13 - 'AtomTabButtonBar.js' */    });
/*Line 14 - 'AtomTabButtonBar.js' */})(WebAtoms.AtomLinkBar.prototype);
/*Line 0 - 'AtomTabControl.js' */

/*Line 2 - 'AtomTabControl.js' */(function (baseType) {
/*Line 3 - 'AtomTabControl.js' */    return classCreatorEx({
/*Line 4 - 'AtomTabControl.js' */        name: "WebAtoms.AtomTabControl",
/*Line 5 - 'AtomTabControl.js' */        base: baseType,
/*Line 6 - 'AtomTabControl.js' */        start: function () {
/*Line 7 - 'AtomTabControl.js' */            this._presenters = ["itemsPresenter"];

/*Line 9 - 'AtomTabControl.js' */            this._layout = WebAtoms.AtomViewBoxLayout.defaultInstance;

/*Line 11 - 'AtomTabControl.js' */            this.selectedIndex = 0;
/*Line 12 - 'AtomTabControl.js' */            this.labelPath = "label";

/*Line 14 - 'AtomTabControl.js' */        },
/*Line 15 - 'AtomTabControl.js' */        properties: {
/*Line 16 - 'AtomTabControl.js' */            items: null
/*Line 17 - 'AtomTabControl.js' */        },
/*Line 18 - 'AtomTabControl.js' */        methods: {
/*Line 19 - 'AtomTabControl.js' */            createChildren: function () {
/*Line 20 - 'AtomTabControl.js' */               baseType.createChildren.call(this);

/*Line 22 - 'AtomTabControl.js' */                if (this._itemsPresenter != this._element) {


/*Line 25 - 'AtomTabControl.js' */                    var children = [];

/*Line 27 - 'AtomTabControl.js' */                    var ae = new ChildEnumerator(this._element);
/*Line 28 - 'AtomTabControl.js' */                    while (ae.next()) {
/*Line 29 - 'AtomTabControl.js' */                        var c = ae.current();
/*Line 30 - 'AtomTabControl.js' */                        this._element.removeChild(c);
/*Line 31 - 'AtomTabControl.js' */                        children.push(c);
/*Line 32 - 'AtomTabControl.js' */                    }

/*Line 34 - 'AtomTabControl.js' */                    if (this._template) {
/*Line 35 - 'AtomTabControl.js' */                        var t = AtomUI.cloneNode(this._template);
/*Line 36 - 'AtomTabControl.js' */                        t._templateParent = this;
/*Line 37 - 'AtomTabControl.js' */                        this._element.appendChild(t);
/*Line 38 - 'AtomTabControl.js' */                        this.onCreateChildren(this._element);
/*Line 39 - 'AtomTabControl.js' */                    }

/*Line 41 - 'AtomTabControl.js' */                    ae = new AtomEnumerator(children);
/*Line 42 - 'AtomTabControl.js' */                    while (ae.next()) {
/*Line 43 - 'AtomTabControl.js' */                        this._itemsPresenter.appendChild(ae.current());
/*Line 44 - 'AtomTabControl.js' */                    }
/*Line 45 - 'AtomTabControl.js' */                    if (this._template) {
/*Line 46 - 'AtomTabControl.js' */                        this.onCreateChildren(this._itemsPresenter);
/*Line 47 - 'AtomTabControl.js' */                    }

/*Line 49 - 'AtomTabControl.js' */                }

/*Line 51 - 'AtomTabControl.js' */            }
/*Line 52 - 'AtomTabControl.js' */        }
/*Line 53 - 'AtomTabControl.js' */    });
/*Line 54 - 'AtomTabControl.js' */})(WebAtoms.AtomControl.prototype);

/*Line 0 - 'AtomTimePicker.js' */

/*Line 2 - 'AtomTimePicker.js' */(function (baseType) {
/*Line 3 - 'AtomTimePicker.js' */    return classCreatorEx({
/*Line 4 - 'AtomTimePicker.js' */        name: "WebAtoms.AtomTimePicker",
/*Line 5 - 'AtomTimePicker.js' */        base: baseType,
/*Line 6 - 'AtomTimePicker.js' */        start: function (e) {
/*Line 7 - 'AtomTimePicker.js' */            log("AtomTimePicker is Depricated !!!, use AtomTimeEditor");
/*Line 8 - 'AtomTimePicker.js' */        },
/*Line 9 - 'AtomTimePicker.js' */        properties: {
/*Line 10 - 'AtomTimePicker.js' */            displayLabel: "9:00 AM"
/*Line 11 - 'AtomTimePicker.js' */        },
/*Line 12 - 'AtomTimePicker.js' */        methods: {
/*Line 13 - 'AtomTimePicker.js' */            init: function () {
/*Line 14 - 'AtomTimePicker.js' */                this._autoOpen = true;
/*Line 15 - 'AtomTimePicker.js' */                var items = [];
/*Line 16 - 'AtomTimePicker.js' */                for (var i = 0; i <= 23; i++) {
/*Line 17 - 'AtomTimePicker.js' */                    var a = "AM";
/*Line 18 - 'AtomTimePicker.js' */                    var n = i;
/*Line 19 - 'AtomTimePicker.js' */                    if (i > 11) {
/*Line 20 - 'AtomTimePicker.js' */                        a = "PM";
/*Line 21 - 'AtomTimePicker.js' */                        if (i > 12) {
/*Line 22 - 'AtomTimePicker.js' */                            n = i - 12;
/*Line 23 - 'AtomTimePicker.js' */                        }
/*Line 24 - 'AtomTimePicker.js' */                    }
/*Line 25 - 'AtomTimePicker.js' */                    var item = n + ":00 " + a;
/*Line 26 - 'AtomTimePicker.js' */                    items.push({ label: item, value: item });
/*Line 27 - 'AtomTimePicker.js' */                    item = n + ":30 " + a;
/*Line 28 - 'AtomTimePicker.js' */                    items.push({ label: item, value: item });
/*Line 29 - 'AtomTimePicker.js' */                }
/*Line 30 - 'AtomTimePicker.js' */                this._items = items;
/*Line 31 - 'AtomTimePicker.js' */                baseType.init.call(this);
/*Line 32 - 'AtomTimePicker.js' */            }
/*Line 33 - 'AtomTimePicker.js' */        }
/*Line 34 - 'AtomTimePicker.js' */    });
/*Line 35 - 'AtomTimePicker.js' */})(WebAtoms.AtomAutoCompleteBox.prototype);

/*Line 37 - 'AtomTimePicker.js' */var AtomicUpdator = function (self) {
/*Line 38 - 'AtomTimePicker.js' */    this._self = self;
/*Line 39 - 'AtomTimePicker.js' */    this._updating = false;
/*Line 40 - 'AtomTimePicker.js' */    this.update = function (f) {
/*Line 41 - 'AtomTimePicker.js' */        if (this._updating)
/*Line 42 - 'AtomTimePicker.js' */            return;
/*Line 43 - 'AtomTimePicker.js' */        try{
/*Line 44 - 'AtomTimePicker.js' */            this._updating = true;
/*Line 45 - 'AtomTimePicker.js' */            f.apply(this._self);
/*Line 46 - 'AtomTimePicker.js' */        } finally {
/*Line 47 - 'AtomTimePicker.js' */            this._updating = false;
/*Line 48 - 'AtomTimePicker.js' */        }
/*Line 49 - 'AtomTimePicker.js' */    };
/*Line 50 - 'AtomTimePicker.js' */};

/*Line 52 - 'AtomTimePicker.js' */(function (baseType) {

/*Line 54 - 'AtomTimePicker.js' */    var timeRegex = /^([0-1]?[0-9]|2[0-3]):[0-5][0-9] [ap][m]$/i;

/*Line 56 - 'AtomTimePicker.js' */    return classCreatorEx({
/*Line 57 - 'AtomTimePicker.js' */        name: "WebAtoms.AtomTimeEditor",
/*Line 58 - 'AtomTimePicker.js' */        base: baseType,
/*Line 59 - 'AtomTimePicker.js' */        start: function (e) {
/*Line 60 - 'AtomTimePicker.js' */            $(e).addClass("atom-time-editor");
/*Line 61 - 'AtomTimePicker.js' */            this._updater = new AtomicUpdator(this);
/*Line 62 - 'AtomTimePicker.js' */        },
/*Line 63 - 'AtomTimePicker.js' */        properties: {
/*Line 64 - 'AtomTimePicker.js' */            time: "10:00",
/*Line 65 - 'AtomTimePicker.js' */            ap: "AM",
/*Line 66 - 'AtomTimePicker.js' */            value: "10:00 AM"
/*Line 67 - 'AtomTimePicker.js' */        },
/*Line 68 - 'AtomTimePicker.js' */        methods: {
/*Line 69 - 'AtomTimePicker.js' */            get_hours24: function () {
/*Line 70 - 'AtomTimePicker.js' */                var t = this._time.split(':');
/*Line 71 - 'AtomTimePicker.js' */                var h = parseInt(t[0] || '0');
/*Line 72 - 'AtomTimePicker.js' */                if (this._ap == 'PM') {
/*Line 73 - 'AtomTimePicker.js' */                    if (h != 12) {
/*Line 74 - 'AtomTimePicker.js' */                        h += 12;
/*Line 75 - 'AtomTimePicker.js' */                    }
/*Line 76 - 'AtomTimePicker.js' */                }
/*Line 77 - 'AtomTimePicker.js' */                return h;
/*Line 78 - 'AtomTimePicker.js' */            },
/*Line 79 - 'AtomTimePicker.js' */            set_hours24: function (v) {
/*Line 80 - 'AtomTimePicker.js' */                this.setTime(v, this.get_minutes(), true);
/*Line 81 - 'AtomTimePicker.js' */            },
/*Line 82 - 'AtomTimePicker.js' */            get_hours: function () {
/*Line 83 - 'AtomTimePicker.js' */                var t = this._time.split(':');
/*Line 84 - 'AtomTimePicker.js' */                var h = parseInt(t[0] || '0');
/*Line 85 - 'AtomTimePicker.js' */                return h;
/*Line 86 - 'AtomTimePicker.js' */            },
/*Line 87 - 'AtomTimePicker.js' */            get_minutes: function () {
/*Line 88 - 'AtomTimePicker.js' */                var t = this._time.split(':');
/*Line 89 - 'AtomTimePicker.js' */                return parseInt(t[1] || '0');
/*Line 90 - 'AtomTimePicker.js' */            },
/*Line 91 - 'AtomTimePicker.js' */            setTime: function (h, m, is24) {
/*Line 92 - 'AtomTimePicker.js' */                var ap = this.get_ap();
/*Line 93 - 'AtomTimePicker.js' */                if (is24) {
/*Line 94 - 'AtomTimePicker.js' */                    if (h > 12) {
/*Line 95 - 'AtomTimePicker.js' */                        h -= 12;
/*Line 96 - 'AtomTimePicker.js' */                        ap = "PM";
/*Line 97 - 'AtomTimePicker.js' */                    } else {
/*Line 98 - 'AtomTimePicker.js' */                        ap = "AM";
/*Line 99 - 'AtomTimePicker.js' */                    }
/*Line 100 - 'AtomTimePicker.js' */                }
/*Line 101 - 'AtomTimePicker.js' */                h = "" + h;
/*Line 102 - 'AtomTimePicker.js' */                if (h.length == 1) {
/*Line 103 - 'AtomTimePicker.js' */                    h = "0" + h;
/*Line 104 - 'AtomTimePicker.js' */                }
/*Line 105 - 'AtomTimePicker.js' */                m = m + "";
/*Line 106 - 'AtomTimePicker.js' */                if (m.length == 1) {
/*Line 107 - 'AtomTimePicker.js' */                    m = "0" + m;
/*Line 108 - 'AtomTimePicker.js' */                }
/*Line 109 - 'AtomTimePicker.js' */                AtomBinder.setValue(this, "value", h + ":" + m + " " + ap);
/*Line 110 - 'AtomTimePicker.js' */            },
/*Line 111 - 'AtomTimePicker.js' */            set_hours: function (v) {
/*Line 112 - 'AtomTimePicker.js' */                this.setTime(v, this.get_minutes());
/*Line 113 - 'AtomTimePicker.js' */            },
/*Line 114 - 'AtomTimePicker.js' */            set_minutes: function (v) {
/*Line 115 - 'AtomTimePicker.js' */                this.setTime(this.get_hours(), v);
/*Line 116 - 'AtomTimePicker.js' */            },
/*Line 117 - 'AtomTimePicker.js' */            set_value: function (v) {
/*Line 118 - 'AtomTimePicker.js' */                this._updater.update(function () {
/*Line 119 - 'AtomTimePicker.js' */                    if (this._value == v)
/*Line 120 - 'AtomTimePicker.js' */                        return;
/*Line 121 - 'AtomTimePicker.js' */                    if (!timeRegex.test(v)) {
/*Line 122 - 'AtomTimePicker.js' */                        throw new Error("Unknown time format, expecting ##:## AM");
/*Line 123 - 'AtomTimePicker.js' */                    }
/*Line 124 - 'AtomTimePicker.js' */                    this._value = v;
/*Line 125 - 'AtomTimePicker.js' */                    v = v.split(' ');
/*Line 126 - 'AtomTimePicker.js' */                    this._time = v[0];
/*Line 127 - 'AtomTimePicker.js' */                    this._ap = (v[1]).toUpperCase();
/*Line 128 - 'AtomTimePicker.js' */                    this.refreshProperties();
/*Line 129 - 'AtomTimePicker.js' */                });
/*Line 130 - 'AtomTimePicker.js' */            },
/*Line 131 - 'AtomTimePicker.js' */            refreshProperties: function () {
/*Line 132 - 'AtomTimePicker.js' */                Atom.refresh(this, "value");
/*Line 133 - 'AtomTimePicker.js' */                Atom.refresh(this, "time");
/*Line 134 - 'AtomTimePicker.js' */                Atom.refresh(this, "ap");
/*Line 135 - 'AtomTimePicker.js' */                Atom.refresh(this, "hours");
/*Line 136 - 'AtomTimePicker.js' */                Atom.refresh(this, "hours24");
/*Line 137 - 'AtomTimePicker.js' */                Atom.refresh(this, "minutes");
/*Line 138 - 'AtomTimePicker.js' */            },
/*Line 139 - 'AtomTimePicker.js' */            set_time: function (v) {
/*Line 140 - 'AtomTimePicker.js' */                this.set_value(v + " " + this._ap);
/*Line 141 - 'AtomTimePicker.js' */            },
/*Line 142 - 'AtomTimePicker.js' */            set_ap: function (v) {
/*Line 143 - 'AtomTimePicker.js' */                this.set_value(this._time + " " + v);
/*Line 144 - 'AtomTimePicker.js' */            },
/*Line 145 - 'AtomTimePicker.js' */            get_value: function () {
/*Line 146 - 'AtomTimePicker.js' */                return this._time + " " + this._ap;
/*Line 147 - 'AtomTimePicker.js' */            }
/*Line 148 - 'AtomTimePicker.js' */        }
/*Line 149 - 'AtomTimePicker.js' */    });
/*Line 150 - 'AtomTimePicker.js' */})(WebAtoms.AtomControl.prototype);
/*Line 0 - 'AtomUploadButton.js' */

/*Line 2 - 'AtomUploadButton.js' */(function (baseType) {
/*Line 3 - 'AtomUploadButton.js' */    return classCreatorEx({
/*Line 4 - 'AtomUploadButton.js' */        name: "WebAtoms.AtomUploadButton",
/*Line 5 - 'AtomUploadButton.js' */        base: baseType,
/*Line 6 - 'AtomUploadButton.js' */        start: function (e) {
/*Line 7 - 'AtomUploadButton.js' */            if (/input/gi.test(e.nodeName) && /file/gi.test(AtomUI.attr(e,"type"))) {
/*Line 8 - 'AtomUploadButton.js' */                this._filePresenter = e;
/*Line 9 - 'AtomUploadButton.js' */                return;
/*Line 10 - 'AtomUploadButton.js' */            }

/*Line 12 - 'AtomUploadButton.js' */            var fp = this._filePresenter = document.createElement("input");
/*Line 13 - 'AtomUploadButton.js' */            AtomUI.attr(fp, "type", "file");
/*Line 14 - 'AtomUploadButton.js' */            $(fp).css({
/*Line 15 - 'AtomUploadButton.js' */                left: "-500px",
/*Line 16 - 'AtomUploadButton.js' */                position: "absolute",
/*Line 17 - 'AtomUploadButton.js' */                top: "0"
/*Line 18 - 'AtomUploadButton.js' */            });
/*Line 19 - 'AtomUploadButton.js' */            document.body.appendChild(this._filePresenter);
/*Line 20 - 'AtomUploadButton.js' */        },
/*Line 21 - 'AtomUploadButton.js' */        properties: {
/*Line 22 - 'AtomUploadButton.js' */            fileTypes: undefined,
/*Line 23 - 'AtomUploadButton.js' */            accept: "*/*",
/*Line 24 - 'AtomUploadButton.js' */            capture: "",
/*Line 25 - 'AtomUploadButton.js' */            progress: 0
/*Line 26 - 'AtomUploadButton.js' */        },
/*Line 27 - 'AtomUploadButton.js' */        methods: {
/*Line 28 - 'AtomUploadButton.js' */            set_accept: function (v) {
/*Line 29 - 'AtomUploadButton.js' */                this._accept = v;
/*Line 30 - 'AtomUploadButton.js' */                if (v) {
/*Line 31 - 'AtomUploadButton.js' */                    var fp = this._filePresenter;
/*Line 32 - 'AtomUploadButton.js' */                    if (fp) {
/*Line 33 - 'AtomUploadButton.js' */                        AtomUI.attr(fp, "accept", v);
/*Line 34 - 'AtomUploadButton.js' */                    }
/*Line 35 - 'AtomUploadButton.js' */                }
/*Line 36 - 'AtomUploadButton.js' */            },

/*Line 38 - 'AtomUploadButton.js' */            set_capture: function (v) {
/*Line 39 - 'AtomUploadButton.js' */                this._capture = v;
/*Line 40 - 'AtomUploadButton.js' */                if (v) {
/*Line 41 - 'AtomUploadButton.js' */                    var fp = this._filePresenter;
/*Line 42 - 'AtomUploadButton.js' */                    if (fp) {
/*Line 43 - 'AtomUploadButton.js' */                        AtomUI.attr(fp, "capture", v);
/*Line 44 - 'AtomUploadButton.js' */                    }
/*Line 45 - 'AtomUploadButton.js' */                }
/*Line 46 - 'AtomUploadButton.js' */            },
/*Line 47 - 'AtomUploadButton.js' */            onClickHandler: function (e) {

/*Line 49 - 'AtomUploadButton.js' */                if (this._confirm) {
/*Line 50 - 'AtomUploadButton.js' */                    if (!confirm(this._confirmMessage))
/*Line 51 - 'AtomUploadButton.js' */                        return;
/*Line 52 - 'AtomUploadButton.js' */                }

/*Line 54 - 'AtomUploadButton.js' */                if (!this._postUrl) {
/*Line 55 - 'AtomUploadButton.js' */                    //WebAtoms.AtomUploadButton.callBaseMethod(this, "onClickHandler", [e]);
/*Line 56 - 'AtomUploadButton.js' */                    return;
/*Line 57 - 'AtomUploadButton.js' */                }

/*Line 59 - 'AtomUploadButton.js' */                if (this._filePresenter == this._element) {
/*Line 60 - 'AtomUploadButton.js' */                    return;
/*Line 61 - 'AtomUploadButton.js' */                }

/*Line 63 - 'AtomUploadButton.js' */                $(this._filePresenter).trigger("click");
/*Line 64 - 'AtomUploadButton.js' */                AtomUI.cancelEvent(e);
/*Line 65 - 'AtomUploadButton.js' */            },

/*Line 67 - 'AtomUploadButton.js' */            onFileSelected: function () {
/*Line 68 - 'AtomUploadButton.js' */                var data = this.get_postData();

/*Line 70 - 'AtomUploadButton.js' */                if (data === null || data === undefined)
/*Line 71 - 'AtomUploadButton.js' */                    return;

/*Line 73 - 'AtomUploadButton.js' */                var m = this._mergeData;
/*Line 74 - 'AtomUploadButton.js' */                if (m) {
/*Line 75 - 'AtomUploadButton.js' */                    for (var i in m) {
/*Line 76 - 'AtomUploadButton.js' */                        data[i] = m[i];
/*Line 77 - 'AtomUploadButton.js' */                    }
/*Line 78 - 'AtomUploadButton.js' */                }
/*Line 79 - 'AtomUploadButton.js' */                var xhr = this._xhr;
/*Line 80 - 'AtomUploadButton.js' */                if (!xhr) {
/*Line 81 - 'AtomUploadButton.js' */                    xhr = new XMLHttpRequest();
/*Line 82 - 'AtomUploadButton.js' */                    var upload = xhr.upload;
/*Line 83 - 'AtomUploadButton.js' */                    try {
/*Line 84 - 'AtomUploadButton.js' */                        xhr.timeout = 3600000;
/*Line 85 - 'AtomUploadButton.js' */                    } catch (e) {
/*Line 86 - 'AtomUploadButton.js' */                        // IE 10 has some issue with this code..
/*Line 87 - 'AtomUploadButton.js' */                    }

/*Line 89 - 'AtomUploadButton.js' */                    this.bindEvent(upload, "progress", "onProgress");
/*Line 90 - 'AtomUploadButton.js' */                    this.bindEvent(upload, "timeout", "onError");
/*Line 91 - 'AtomUploadButton.js' */                    this.bindEvent(upload, "error", "onError");
/*Line 92 - 'AtomUploadButton.js' */                    this.bindEvent(xhr, "load", "onComplete");
/*Line 93 - 'AtomUploadButton.js' */                    this.bindEvent(xhr, "error", "onError");
/*Line 94 - 'AtomUploadButton.js' */                    this.bindEvent(xhr, "timeout", "onError");
/*Line 95 - 'AtomUploadButton.js' */                    this._xhr = xhr;
/*Line 96 - 'AtomUploadButton.js' */                }

/*Line 98 - 'AtomUploadButton.js' */                var fd = new FormData();

/*Line 100 - 'AtomUploadButton.js' */                var ae = new AtomEnumerator(this._filePresenter.files);
/*Line 101 - 'AtomUploadButton.js' */                while (ae.next()) {
/*Line 102 - 'AtomUploadButton.js' */                    fd.append("file" + ae.currentIndex(), ae.current());
/*Line 103 - 'AtomUploadButton.js' */                }

/*Line 105 - 'AtomUploadButton.js' */                fd.append("formModel", JSON.stringify(AtomBinder.getClone(data)));

/*Line 107 - 'AtomUploadButton.js' */                xhr.open("POST", this._postUrl);
/*Line 108 - 'AtomUploadButton.js' */                xhr.send(fd);

/*Line 110 - 'AtomUploadButton.js' */                atomApplication.setBusy(true, "Uploading...");
/*Line 111 - 'AtomUploadButton.js' */            },

/*Line 113 - 'AtomUploadButton.js' */            set_progress: function (v) {
/*Line 114 - 'AtomUploadButton.js' */                this._progress = v;
/*Line 115 - 'AtomUploadButton.js' */                if (v) {
/*Line 116 - 'AtomUploadButton.js' */                    AtomBinder.setValue(atomApplication, "progress", v);
/*Line 117 - 'AtomUploadButton.js' */                }
/*Line 118 - 'AtomUploadButton.js' */            },

/*Line 120 - 'AtomUploadButton.js' */            onError: function (evt) {
/*Line 121 - 'AtomUploadButton.js' */                atomApplication.setBusy(false, "Uploading...");
/*Line 122 - 'AtomUploadButton.js' */                this.unbindEvent(this._xhr);
/*Line 123 - 'AtomUploadButton.js' */                this._xhr = null;
/*Line 124 - 'AtomUploadButton.js' */                this._lastError = evt;
/*Line 125 - 'AtomUploadButton.js' */                Atom.alert('Upload failed');
/*Line 126 - 'AtomUploadButton.js' */            },
/*Line 127 - 'AtomUploadButton.js' */            onProgress: function (evt) {
/*Line 128 - 'AtomUploadButton.js' */                //evt = evt.originalEvent;
/*Line 129 - 'AtomUploadButton.js' */                if (evt.lengthComputable) {
/*Line 130 - 'AtomUploadButton.js' */                    var percentComplete = Math.round(evt.loaded * 100 / evt.total);
/*Line 131 - 'AtomUploadButton.js' */                    AtomBinder.setValue(this, "progress", percentComplete);
/*Line 132 - 'AtomUploadButton.js' */                }
/*Line 133 - 'AtomUploadButton.js' */            },
/*Line 134 - 'AtomUploadButton.js' */            onComplete: function (evt) {
/*Line 135 - 'AtomUploadButton.js' */                atomApplication.setBusy(false, "Uploading...");
/*Line 136 - 'AtomUploadButton.js' */                var result = null;
/*Line 137 - 'AtomUploadButton.js' */                if (evt.target) {
/*Line 138 - 'AtomUploadButton.js' */                    if (evt.target.status == 200) {
/*Line 139 - 'AtomUploadButton.js' */                        this._value = evt.target.responseText;
/*Line 140 - 'AtomUploadButton.js' */                    } else {
/*Line 141 - 'AtomUploadButton.js' */                        Atom.alert(evt.target.statusText);
/*Line 142 - 'AtomUploadButton.js' */                        return;
/*Line 143 - 'AtomUploadButton.js' */                    }
/*Line 144 - 'AtomUploadButton.js' */                } else {
/*Line 145 - 'AtomUploadButton.js' */                    this._value = evt.result;
/*Line 146 - 'AtomUploadButton.js' */                }

/*Line 148 - 'AtomUploadButton.js' */                this.unbindEvent(this._xhr);
/*Line 149 - 'AtomUploadButton.js' */                this._xhr = null;

/*Line 151 - 'AtomUploadButton.js' */                AtomBinder.refreshValue(this, "value");

/*Line 153 - 'AtomUploadButton.js' */                this.invokeAction(this._next, evt);
/*Line 154 - 'AtomUploadButton.js' */            },

/*Line 156 - 'AtomUploadButton.js' */            init: function () {
/*Line 157 - 'AtomUploadButton.js' */                baseType.init.call(this);

/*Line 159 - 'AtomUploadButton.js' */                var f = this._filePresenter;

/*Line 161 - 'AtomUploadButton.js' */                this.bindEvent(f, "change", "onFileSelected");

/*Line 163 - 'AtomUploadButton.js' */            }
/*Line 164 - 'AtomUploadButton.js' */        }
/*Line 165 - 'AtomUploadButton.js' */    });
/*Line 166 - 'AtomUploadButton.js' */})(WebAtoms.AtomPostButton.prototype);
/*Line 0 - 'AtomViewBox.js' */

/*Line 2 - 'AtomViewBox.js' */(function (WebAtoms, baseType) {
/*Line 3 - 'AtomViewBox.js' */    return classCreatorEx({
/*Line 4 - 'AtomViewBox.js' */        name: "WebAtoms.AtomViewBox",
/*Line 5 - 'AtomViewBox.js' */        base: baseType,
/*Line 6 - 'AtomViewBox.js' */        start: function () {
/*Line 7 - 'AtomViewBox.js' */            this._layout = WebAtoms.AtomViewBoxLayout.defaultInstance;
/*Line 8 - 'AtomViewBox.js' */        },
/*Line 9 - 'AtomViewBox.js' */        methods: {

/*Line 11 - 'AtomViewBox.js' */        }
/*Line 12 - 'AtomViewBox.js' */    });
/*Line 13 - 'AtomViewBox.js' */})(WebAtoms, WebAtoms.AtomControl.prototype);

/*Line 0 - 'AtomWizard.js' */

/*Line 2 - 'AtomWizard.js' */(function (baseType) {
/*Line 3 - 'AtomWizard.js' */    return classCreatorEx({
/*Line 4 - 'AtomWizard.js' */        name: "WebAtoms.AtomWizard",
/*Line 5 - 'AtomWizard.js' */        base: baseType,
/*Line 6 - 'AtomWizard.js' */        start: function () {
/*Line 7 - 'AtomWizard.js' */            this._presenters = ["viewPresenter"];
/*Line 8 - 'AtomWizard.js' */        },
/*Line 9 - 'AtomWizard.js' */        properties: {
/*Line 10 - 'AtomWizard.js' */            currentStep: null,
/*Line 11 - 'AtomWizard.js' */            nextLabel: "Next",
/*Line 12 - 'AtomWizard.js' */            nextClass: "",
/*Line 13 - 'AtomWizard.js' */            buttons: null,
/*Line 14 - 'AtomWizard.js' */            prevLabel: "Back",
/*Line 15 - 'AtomWizard.js' */            finishLabel: "Finish",
/*Line 16 - 'AtomWizard.js' */            canMoveBack: true,
/*Line 17 - 'AtomWizard.js' */            canMoveNext: true,
/*Line 18 - 'AtomWizard.js' */            steps: 0,
/*Line 19 - 'AtomWizard.js' */            isLastStep: false
/*Line 20 - 'AtomWizard.js' */        },
/*Line 21 - 'AtomWizard.js' */        methods: {
/*Line 22 - 'AtomWizard.js' */            set_currentStep: function (v) {
/*Line 23 - 'AtomWizard.js' */                this._currentStep = v;
/*Line 24 - 'AtomWizard.js' */                var a = this._buttons;
/*Line 25 - 'AtomWizard.js' */                if (a && a.length) {
/*Line 26 - 'AtomWizard.js' */                    var item = a[v];
/*Line 27 - 'AtomWizard.js' */                    AtomBinder.setValue(this, "nextLabel", item.label);
/*Line 28 - 'AtomWizard.js' */                    AtomBinder.setValue(this, "nextClass", item.styleClass);
/*Line 29 - 'AtomWizard.js' */                }
/*Line 30 - 'AtomWizard.js' */                AtomBinder.refreshValue(this, "isLastStep");
/*Line 31 - 'AtomWizard.js' */            },

/*Line 33 - 'AtomWizard.js' */            get_isLastStep: function () {
/*Line 34 - 'AtomWizard.js' */                return this._currentStep == (this._steps - 1);
/*Line 35 - 'AtomWizard.js' */            },

/*Line 37 - 'AtomWizard.js' */            createWizard: function () {


/*Line 40 - 'AtomWizard.js' */                var vs = this._viewPresenter;

/*Line 42 - 'AtomWizard.js' */                this.disposeChildren(vs);

/*Line 44 - 'AtomWizard.js' */                var vt = this._viewTemplate;

/*Line 46 - 'AtomWizard.js' */                var i = 0;

/*Line 48 - 'AtomWizard.js' */                var ae = new ChildEnumerator(vt);
/*Line 49 - 'AtomWizard.js' */                while (ae.next()) {
/*Line 50 - 'AtomWizard.js' */                    i++;
/*Line 51 - 'AtomWizard.js' */                    var item = AtomUI.cloneNode(ae.current());
/*Line 52 - 'AtomWizard.js' */                    //$(vs).append(item);
/*Line 53 - 'AtomWizard.js' */                    vs.appendChild(item);
/*Line 54 - 'AtomWizard.js' */                    var type = AtomUI.getAtomType(item);
/*Line 55 - 'AtomWizard.js' */                    if (!type) {
/*Line 56 - 'AtomWizard.js' */                        type = "AtomViewBox";
/*Line 57 - 'AtomWizard.js' */                        AtomUI.attr(item, "data-atom-type", type);
/*Line 58 - 'AtomWizard.js' */                    }

/*Line 60 - 'AtomWizard.js' */                    //var s = new AtomScope(this, this.get_scope(), atomApplication);

/*Line 62 - 'AtomWizard.js' */                    var ct = AtomUI.getAtomType(item) || WebAtoms.AtomControl;
/*Line 63 - 'AtomWizard.js' */                    var cc = AtomUI.createControl(item, ct);
/*Line 64 - 'AtomWizard.js' */                    cc.init();
/*Line 65 - 'AtomWizard.js' */                }
/*Line 66 - 'AtomWizard.js' */                AtomBinder.setValue(this, "steps", i);

/*Line 68 - 'AtomWizard.js' */                if (i) {
/*Line 69 - 'AtomWizard.js' */                    AtomBinder.setValue(this, "currentStep", 0);
/*Line 70 - 'AtomWizard.js' */                }
/*Line 71 - 'AtomWizard.js' */            },

/*Line 73 - 'AtomWizard.js' */            init: function () {
/*Line 74 - 'AtomWizard.js' */                $(this._element).addClass('atom-wizard');

/*Line 76 - 'AtomWizard.js' */                baseType.init.call(this);

/*Line 78 - 'AtomWizard.js' */                var _this = this;

/*Line 80 - 'AtomWizard.js' */                var vs = this._viewPresenter;

/*Line 82 - 'AtomWizard.js' */                this.goNextCommand = function (scope, sender, evt) {
/*Line 83 - 'AtomWizard.js' */                    if (_this.get_isLastStep()) {
/*Line 84 - 'AtomWizard.js' */                        _this.invokeAction(_this._next, evt);
/*Line 85 - 'AtomWizard.js' */                        AtomBinder.setValue(_this, "canMoveBack", false);
/*Line 86 - 'AtomWizard.js' */                    } else {
/*Line 87 - 'AtomWizard.js' */                        AtomBinder.setValue(_this, "currentStep", _this._currentStep + 1);
/*Line 88 - 'AtomWizard.js' */                    }
/*Line 89 - 'AtomWizard.js' */                };

/*Line 91 - 'AtomWizard.js' */                this.goPrevCommand = function () {
/*Line 92 - 'AtomWizard.js' */                    AtomBinder.setValue(_this, "currentStep", _this._currentStep - 1);
/*Line 93 - 'AtomWizard.js' */                };

/*Line 95 - 'AtomWizard.js' */                this.resetCommand = function () {
/*Line 96 - 'AtomWizard.js' */                    _this.createWizard();
/*Line 97 - 'AtomWizard.js' */                    AtomBinder.setValue(_this, "currentStep", 0);
/*Line 98 - 'AtomWizard.js' */                    AtomBinder.setValue(_this, "canMoveBack", true);
/*Line 99 - 'AtomWizard.js' */                };

/*Line 101 - 'AtomWizard.js' */                // create children...
/*Line 102 - 'AtomWizard.js' */                this.createWizard();

/*Line 104 - 'AtomWizard.js' */                this.nextCommand = function (scope, sender, evt) {
/*Line 105 - 'AtomWizard.js' */                    var child = vs.atomControl.get_selectedChild().atomControl;
/*Line 106 - 'AtomWizard.js' */                    if (child._next) {
/*Line 107 - 'AtomWizard.js' */                        child.invokeAction(child._next);
/*Line 108 - 'AtomWizard.js' */                        return;
/*Line 109 - 'AtomWizard.js' */                    } else {
/*Line 110 - 'AtomWizard.js' */                        _this.goNextCommand(scope, sender, evt);
/*Line 111 - 'AtomWizard.js' */                    }
/*Line 112 - 'AtomWizard.js' */                };

/*Line 114 - 'AtomWizard.js' */            }
/*Line 115 - 'AtomWizard.js' */        }
/*Line 116 - 'AtomWizard.js' */    });
/*Line 117 - 'AtomWizard.js' */})(WebAtoms.AtomDockPanel.prototype);

/*Line 0 - 'AtomYesNoControl.js' */

/*Line 2 - 'AtomYesNoControl.js' */(function (baseType) {
/*Line 3 - 'AtomYesNoControl.js' */    return classCreatorEx({
/*Line 4 - 'AtomYesNoControl.js' */        name: "WebAtoms.AtomYesNoControl",
/*Line 5 - 'AtomYesNoControl.js' */        base: baseType,
/*Line 6 - 'AtomYesNoControl.js' */        start: function () {
/*Line 7 - 'AtomYesNoControl.js' */            this._allowSelectFirst = false;
/*Line 8 - 'AtomYesNoControl.js' */            this._items = [
/*Line 9 - 'AtomYesNoControl.js' */                { label: "Yes", value: true },
/*Line 10 - 'AtomYesNoControl.js' */                { label: "No", value: false }
/*Line 11 - 'AtomYesNoControl.js' */            ];
/*Line 12 - 'AtomYesNoControl.js' */        },
/*Line 13 - 'AtomYesNoControl.js' */        methods: {
/*Line 14 - 'AtomYesNoControl.js' */        }
/*Line 15 - 'AtomYesNoControl.js' */    });
/*Line 16 - 'AtomYesNoControl.js' */})(WebAtoms.AtomToggleButtonBar.prototype);
/*Line 0 - 'AtomYesNoCustom.js' */

/*Line 2 - 'AtomYesNoCustom.js' */(function (baseType) {
/*Line 3 - 'AtomYesNoCustom.js' */    return classCreatorEx({
/*Line 4 - 'AtomYesNoCustom.js' */        name: "WebAtoms.AtomYesNoCustom",
/*Line 5 - 'AtomYesNoCustom.js' */        base: baseType,
/*Line 6 - 'AtomYesNoCustom.js' */        start: function () {
/*Line 7 - 'AtomYesNoCustom.js' */            this._presenters = ["yesNo", "input"];
/*Line 8 - 'AtomYesNoCustom.js' */            this._hasValue = false;
/*Line 9 - 'AtomYesNoCustom.js' */        },
/*Line 10 - 'AtomYesNoCustom.js' */        properties:{
/*Line 11 - 'AtomYesNoCustom.js' */            hasValue: false,
/*Line 12 - 'AtomYesNoCustom.js' */            placeholder: null
/*Line 13 - 'AtomYesNoCustom.js' */        },
/*Line 14 - 'AtomYesNoCustom.js' */        methods: {
/*Line 15 - 'AtomYesNoCustom.js' */            set_hasValue: function (v) {
/*Line 16 - 'AtomYesNoCustom.js' */                this._hasValue = v;
/*Line 17 - 'AtomYesNoCustom.js' */                if (!v) {
/*Line 18 - 'AtomYesNoCustom.js' */                    AtomBinder.setValue(this, "value", "");
/*Line 19 - 'AtomYesNoCustom.js' */                }
/*Line 20 - 'AtomYesNoCustom.js' */            },

/*Line 22 - 'AtomYesNoCustom.js' */            set_value: function (v) {
/*Line 23 - 'AtomYesNoCustom.js' */                this._value = v;
/*Line 24 - 'AtomYesNoCustom.js' */                AtomBinder.setValue(this, "hasValue", v ? true : false);
/*Line 25 - 'AtomYesNoCustom.js' */                if (!this._onUIChanged) {
/*Line 26 - 'AtomYesNoCustom.js' */                    $(this._input).val(v);
/*Line 27 - 'AtomYesNoCustom.js' */                }
/*Line 28 - 'AtomYesNoCustom.js' */            },
/*Line 29 - 'AtomYesNoCustom.js' */            onValueChange: function () {
/*Line 30 - 'AtomYesNoCustom.js' */                this._onUIChanged = true;
/*Line 31 - 'AtomYesNoCustom.js' */                var val = $(this._input).val();
/*Line 32 - 'AtomYesNoCustom.js' */                AtomBinder.setValue(this, "value", val);
/*Line 33 - 'AtomYesNoCustom.js' */                this._onUIChanged = false;
/*Line 34 - 'AtomYesNoCustom.js' */            },

/*Line 36 - 'AtomYesNoCustom.js' */            onUpdateUI: function () {
/*Line 37 - 'AtomYesNoCustom.js' */                $(this._input).addClass("atom-yes-no-custom-input");
/*Line 38 - 'AtomYesNoCustom.js' */                if (this._placeholder) {
/*Line 39 - 'AtomYesNoCustom.js' */                    AtomUI.attr(this._input, "placeholder", this._placeholder);
/*Line 40 - 'AtomYesNoCustom.js' */                    var pf = window.placeHolderFixer;
/*Line 41 - 'AtomYesNoCustom.js' */                    if(pf) pf.refresh();
/*Line 42 - 'AtomYesNoCustom.js' */                }
/*Line 43 - 'AtomYesNoCustom.js' */            },

/*Line 45 - 'AtomYesNoCustom.js' */            init: function () {

/*Line 47 - 'AtomYesNoCustom.js' */                baseType.init.call(this);

/*Line 49 - 'AtomYesNoCustom.js' */                this._yesNo = this._yesNo.atomControl;

/*Line 51 - 'AtomYesNoCustom.js' */                var input = this._input;
/*Line 52 - 'AtomYesNoCustom.js' */                this.bindEvent(input, "change", "onValueChange");
/*Line 53 - 'AtomYesNoCustom.js' */                //this.bindEvent(this._yesNo, "selectionChanged", "onSelectionChanged");
/*Line 54 - 'AtomYesNoCustom.js' */            }
/*Line 55 - 'AtomYesNoCustom.js' */        }
/*Line 56 - 'AtomYesNoCustom.js' */    });
/*Line 57 - 'AtomYesNoCustom.js' */})(WebAtoms.AtomControl.prototype);
/*Line 0 - 'AtomApplication.js' */

/*Line 2 - 'AtomApplication.js' */window.appScope = window.appScope || {};

/*Line 4 - 'AtomApplication.js' */this.atomApplication = null;

/*Line 6 - 'AtomApplication.js' */(function (base) {

/*Line 8 - 'AtomApplication.js' */    return classCreator("WebAtoms.AtomApplication", base,
/*Line 9 - 'AtomApplication.js' */        function (element) {
/*Line 10 - 'AtomApplication.js' */            $(element).removeClass("atom-dock-panel");
/*Line 11 - 'AtomApplication.js' */            $(element).addClass("atom-application");

/*Line 13 - 'AtomApplication.js' */            this._scope = new AtomScope(this, null, this);
/*Line 14 - 'AtomApplication.js' */            //window.appScope = this._scope;

/*Line 16 - 'AtomApplication.js' */            if (window.model) {
/*Line 17 - 'AtomApplication.js' */                window.appScope.model = window.model;
/*Line 18 - 'AtomApplication.js' */                this._data = window.model;
/*Line 19 - 'AtomApplication.js' */            }

/*Line 21 - 'AtomApplication.js' */            if (window.appScope) {
/*Line 22 - 'AtomApplication.js' */                var d = this._scope;
/*Line 23 - 'AtomApplication.js' */                var s = window.appScope;
/*Line 24 - 'AtomApplication.js' */                for (var i in s) {
/*Line 25 - 'AtomApplication.js' */                    d[i] = s[i];
/*Line 26 - 'AtomApplication.js' */                }
/*Line 27 - 'AtomApplication.js' */            }
/*Line 28 - 'AtomApplication.js' */            window.appScope = this._scope;

/*Line 30 - 'AtomApplication.js' */            window.atomApplication = this;
/*Line 31 - 'AtomApplication.js' */            this.busyCount = 0;

/*Line 33 - 'AtomApplication.js' */            var url = location.hash;
/*Line 34 - 'AtomApplication.js' */            url = url ? url.substr(1) : url;
/*Line 35 - 'AtomApplication.js' */            if (url) {
/*Line 36 - 'AtomApplication.js' */                var s = AtomUI.parseUrl(url);
/*Line 37 - 'AtomApplication.js' */                this._hash = location.hash;
/*Line 38 - 'AtomApplication.js' */                var ts = this._scope;
/*Line 39 - 'AtomApplication.js' */                this._defaultHash = s;
/*Line 40 - 'AtomApplication.js' */                for (var i in s) {
/*Line 41 - 'AtomApplication.js' */                    var v = s[i];
/*Line 42 - 'AtomApplication.js' */                    ts[i] = v;
/*Line 43 - 'AtomApplication.js' */                }
                
/*Line 45 - 'AtomApplication.js' */            } else {
/*Line 46 - 'AtomApplication.js' */                this._hash = location.hash;
/*Line 47 - 'AtomApplication.js' */            }

/*Line 49 - 'AtomApplication.js' */            this._defaultScope = {};

/*Line 51 - 'AtomApplication.js' */        },
/*Line 52 - 'AtomApplication.js' */        {
/*Line 53 - 'AtomApplication.js' */            get_title: function () {
/*Line 54 - 'AtomApplication.js' */                return document.title;
/*Line 55 - 'AtomApplication.js' */            },
/*Line 56 - 'AtomApplication.js' */            set_title: function (v) {
/*Line 57 - 'AtomApplication.js' */                document.title = v;
/*Line 58 - 'AtomApplication.js' */            },

/*Line 60 - 'AtomApplication.js' */            get_isBusy: function () {
/*Line 61 - 'AtomApplication.js' */                return this.busyCount;
/*Line 62 - 'AtomApplication.js' */            },

/*Line 64 - 'AtomApplication.js' */            setBusy: function (b, msg) {
/*Line 65 - 'AtomApplication.js' */                if (b) {
/*Line 66 - 'AtomApplication.js' */                    this.busyCount++;
/*Line 67 - 'AtomApplication.js' */                } else {
/*Line 68 - 'AtomApplication.js' */                    this.busyCount--;
/*Line 69 - 'AtomApplication.js' */                }
/*Line 70 - 'AtomApplication.js' */                if (msg !== undefined) {
/*Line 71 - 'AtomApplication.js' */                    if (!msg)
/*Line 72 - 'AtomApplication.js' */                        msg = "";
/*Line 73 - 'AtomApplication.js' */                    AtomBinder.setValue(this, "busyMessage", msg);
/*Line 74 - 'AtomApplication.js' */                } else {
/*Line 75 - 'AtomApplication.js' */                    AtomBinder.setValue(this, "busyMessage", "Loading...");
/*Line 76 - 'AtomApplication.js' */                }
/*Line 77 - 'AtomApplication.js' */                AtomBinder.refreshValue(this, "isBusy");
/*Line 78 - 'AtomApplication.js' */            },

/*Line 80 - 'AtomApplication.js' */            updateUI: function () {
/*Line 81 - 'AtomApplication.js' */                //if (!this._renderAsPage) {
/*Line 82 - 'AtomApplication.js' */                //    var element = this.get_element();
/*Line 83 - 'AtomApplication.js' */                //    var ep = element.parentNode;
/*Line 84 - 'AtomApplication.js' */                //    var pw = $(ep).outerWidth();
/*Line 85 - 'AtomApplication.js' */                //    var left = (pw - $(element).width()) / 2;
/*Line 86 - 'AtomApplication.js' */                //    element.style.left = left + "px";
/*Line 87 - 'AtomApplication.js' */                //    element.style.position = "absolute";
/*Line 88 - 'AtomApplication.js' */                //}
/*Line 89 - 'AtomApplication.js' */                base.updateUI.call(this);

/*Line 91 - 'AtomApplication.js' */                AtomBinder.refreshValue(this, "appWidth");
/*Line 92 - 'AtomApplication.js' */                AtomBinder.refreshValue(this, "appHeight");
/*Line 93 - 'AtomApplication.js' */                AtomBinder.refreshValue(this, "bodyWidth");
/*Line 94 - 'AtomApplication.js' */                AtomBinder.refreshValue(this, "bodyHeight");
/*Line 95 - 'AtomApplication.js' */            },

/*Line 97 - 'AtomApplication.js' */            onUpdateUI: function () {
/*Line 98 - 'AtomApplication.js' */                if (!this._renderAsPage) {
/*Line 99 - 'AtomApplication.js' */                    base.onUpdateUI.call(this);
/*Line 100 - 'AtomApplication.js' */                }
/*Line 101 - 'AtomApplication.js' */            },

/*Line 103 - 'AtomApplication.js' */            get_appWidth: function () {
/*Line 104 - 'AtomApplication.js' */                return $(this._element).width();
/*Line 105 - 'AtomApplication.js' */            },
/*Line 106 - 'AtomApplication.js' */            get_appHeight: function () {
/*Line 107 - 'AtomApplication.js' */                return $(this._element).height();
/*Line 108 - 'AtomApplication.js' */            },

/*Line 110 - 'AtomApplication.js' */            get_bodyWidth: function () {
/*Line 111 - 'AtomApplication.js' */                return $(document.body).width();
/*Line 112 - 'AtomApplication.js' */            },
/*Line 113 - 'AtomApplication.js' */            get_bodyHeight: function () {
/*Line 114 - 'AtomApplication.js' */                return $(document.body).height();
/*Line 115 - 'AtomApplication.js' */            },


/*Line 118 - 'AtomApplication.js' */            onHashChanged: function () {

/*Line 120 - 'AtomApplication.js' */                if (this._noHashRefresh)
/*Line 121 - 'AtomApplication.js' */                    return;
/*Line 122 - 'AtomApplication.js' */                var scope = this._scope;

/*Line 124 - 'AtomApplication.js' */                var url = location.hash;
/*Line 125 - 'AtomApplication.js' */                if (!url) {
/*Line 126 - 'AtomApplication.js' */                    //return;
/*Line 127 - 'AtomApplication.js' */                    url = "#";
/*Line 128 - 'AtomApplication.js' */                }

/*Line 130 - 'AtomApplication.js' */                //log("#changed:" + url);

/*Line 132 - 'AtomApplication.js' */                this._noHashRefresh = true;
/*Line 133 - 'AtomApplication.js' */                url = url.substr(1);

/*Line 135 - 'AtomApplication.js' */                var s = AtomUI.parseUrl(url);

/*Line 137 - 'AtomApplication.js' */                if (this._created) {
/*Line 138 - 'AtomApplication.js' */                    var ds = this._defaultScope;
/*Line 139 - 'AtomApplication.js' */                    for (var key in ds) {
/*Line 140 - 'AtomApplication.js' */                        var v = ds[key];
/*Line 141 - 'AtomApplication.js' */                        if (s[key] === undefined) {
/*Line 142 - 'AtomApplication.js' */                            s[key] = v;
/*Line 143 - 'AtomApplication.js' */                        }
/*Line 144 - 'AtomApplication.js' */                    }

/*Line 146 - 'AtomApplication.js' */                    for (var key in s) {
/*Line 147 - 'AtomApplication.js' */                        var val = s[key];
/*Line 148 - 'AtomApplication.js' */                        if (scope[key] != val) {
/*Line 149 - 'AtomApplication.js' */                            AtomBinder.setValue(scope, key, val);
/*Line 150 - 'AtomApplication.js' */                        }
/*Line 151 - 'AtomApplication.js' */                    }
/*Line 152 - 'AtomApplication.js' */                } else {
/*Line 153 - 'AtomApplication.js' */                    Atom.merge(scope, s);
/*Line 154 - 'AtomApplication.js' */                }

/*Line 156 - 'AtomApplication.js' */                this._noHashRefresh = false;

/*Line 158 - 'AtomApplication.js' */            },

/*Line 160 - 'AtomApplication.js' */            invokeUpdateUI: function () {
/*Line 161 - 'AtomApplication.js' */                var container = this;
/*Line 162 - 'AtomApplication.js' */                var _this = this;
/*Line 163 - 'AtomApplication.js' */                window.setTimeout(function () {
/*Line 164 - 'AtomApplication.js' */                    return _this.updateUI();
/*Line 165 - 'AtomApplication.js' */                }, 5);
/*Line 166 - 'AtomApplication.js' */            },

/*Line 168 - 'AtomApplication.js' */            onRefreshValue: function () {
/*Line 169 - 'AtomApplication.js' */                if (this._noHashRefresh)
/*Line 170 - 'AtomApplication.js' */                    return;

/*Line 172 - 'AtomApplication.js' */                if (!this._ready)
/*Line 173 - 'AtomApplication.js' */                    return;

/*Line 175 - 'AtomApplication.js' */                var dest = this._defaultScope;

/*Line 177 - 'AtomApplication.js' */                //var i = key;
/*Line 178 - 'AtomApplication.js' */                //if (i.indexOf('_') == 0)
/*Line 179 - 'AtomApplication.js' */                //    return;
/*Line 180 - 'AtomApplication.js' */                //var val = this._scope[i];
/*Line 181 - 'AtomApplication.js' */                //if (val === undefined)
/*Line 182 - 'AtomApplication.js' */                //    return;
/*Line 183 - 'AtomApplication.js' */                //if (val === null)
/*Line 184 - 'AtomApplication.js' */                //    return;
/*Line 185 - 'AtomApplication.js' */                //var t = typeof (val);
/*Line 186 - 'AtomApplication.js' */                //if (t != 'string' && t != 'number' && t != 'boolean') {
/*Line 187 - 'AtomApplication.js' */                //    return;
/*Line 188 - 'AtomApplication.js' */                //}


/*Line 191 - 'AtomApplication.js' */                var diff =  AtomBinder.getClone(this._defaultHash || {});
                
/*Line 193 - 'AtomApplication.js' */                var src = this._scope;

/*Line 195 - 'AtomApplication.js' */                for (var k in src) {
/*Line 196 - 'AtomApplication.js' */                    var v = src[k];
/*Line 197 - 'AtomApplication.js' */                    if (dest.hasOwnProperty(k)) {
/*Line 198 - 'AtomApplication.js' */                        if (v == dest[k])
/*Line 199 - 'AtomApplication.js' */                            continue;
/*Line 200 - 'AtomApplication.js' */                        //diff.push({ key: k, value: v });
/*Line 201 - 'AtomApplication.js' */                        diff[k]=v;
/*Line 202 - 'AtomApplication.js' */                    } else {
/*Line 203 - 'AtomApplication.js' */                        if (k.indexOf('_') == 0) continue;
/*Line 204 - 'AtomApplication.js' */                        if (v === undefined || v === null) continue;
/*Line 205 - 'AtomApplication.js' */                        if (!/string|number|boolean/i.test(typeof (v))) continue;
/*Line 206 - 'AtomApplication.js' */                        //diff.push({ key:k, value: v });
/*Line 207 - 'AtomApplication.js' */                        diff[k]=v;
/*Line 208 - 'AtomApplication.js' */                    }
/*Line 209 - 'AtomApplication.js' */                }

/*Line 211 - 'AtomApplication.js' */                var da = [];
/*Line 212 - 'AtomApplication.js' */                for(var k in diff){
/*Line 213 - 'AtomApplication.js' */                    var v = diff[k];
/*Line 214 - 'AtomApplication.js' */                    da.push({ key:k, value:v });
/*Line 215 - 'AtomApplication.js' */                }
/*Line 216 - 'AtomApplication.js' */                var p = "#" + da.map(function (a) { return a.key + "=" + encodeURIComponent(a.value); }).join("&");

/*Line 218 - 'AtomApplication.js' */                if (p == location.hash)
/*Line 219 - 'AtomApplication.js' */                    return;
/*Line 220 - 'AtomApplication.js' */                if (p == "#" && !location.hash)
/*Line 221 - 'AtomApplication.js' */                    return;

/*Line 223 - 'AtomApplication.js' */                this._noHashRefresh = true;
/*Line 224 - 'AtomApplication.js' */                if (history && history.pushState) {
/*Line 225 - 'AtomApplication.js' */                    history.pushState({}, document.title, (location.href.split('#')[0]) + p);
/*Line 226 - 'AtomApplication.js' */                } else {
/*Line 227 - 'AtomApplication.js' */                    location.href = p;
/*Line 228 - 'AtomApplication.js' */                }
/*Line 229 - 'AtomApplication.js' */                this._noHashRefresh = false;
/*Line 230 - 'AtomApplication.js' */            },

/*Line 232 - 'AtomApplication.js' */            onInitialized: function () {

/*Line 234 - 'AtomApplication.js' */                this._ready = true;

/*Line 236 - 'AtomApplication.js' */                // reset url values... enforce again...
/*Line 237 - 'AtomApplication.js' */                base.onInitialized.call(this);
/*Line 238 - 'AtomApplication.js' */                if (!this._renderAsPage) {
/*Line 239 - 'AtomApplication.js' */                    $(this._element).addClass("atom-dock-application");
/*Line 240 - 'AtomApplication.js' */                }


/*Line 243 - 'AtomApplication.js' */                if (AtomBrowser.isIE && AtomBrowser.majorVersion < 8) {
/*Line 244 - 'AtomApplication.js' */                    // setup timer...
/*Line 245 - 'AtomApplication.js' */                    var _this = this;
/*Line 246 - 'AtomApplication.js' */                    setInterval(function () {
/*Line 247 - 'AtomApplication.js' */                        _this.onCheckHash();
/*Line 248 - 'AtomApplication.js' */                    }, 1000);
/*Line 249 - 'AtomApplication.js' */                    this._lastHash = location.hash;
/*Line 250 - 'AtomApplication.js' */                } else {
/*Line 251 - 'AtomApplication.js' */                    var eventName = window.onhashchange ? "onhashchange" : "hashchange";
/*Line 252 - 'AtomApplication.js' */                    this.bindEvent(window, eventName, "onHashChanged");
/*Line 253 - 'AtomApplication.js' */                }

/*Line 255 - 'AtomApplication.js' */            },

/*Line 257 - 'AtomApplication.js' */            createChildren: function () {
/*Line 258 - 'AtomApplication.js' */                base.createChildren.call(this);

/*Line 260 - 'AtomApplication.js' */                this.getTemplate("busyTemplate");
/*Line 261 - 'AtomApplication.js' */                if (this._busyTemplate) {
/*Line 262 - 'AtomApplication.js' */                    this._element.appendChild(this._busyTemplate);

/*Line 264 - 'AtomApplication.js' */                    this.onCreateChildren(this._busyTemplate);
/*Line 265 - 'AtomApplication.js' */                }
/*Line 266 - 'AtomApplication.js' */            },

/*Line 268 - 'AtomApplication.js' */            onCreated: function () {
/*Line 269 - 'AtomApplication.js' */                base.onCreated.call(this);

/*Line 271 - 'AtomApplication.js' */                if (this._next) {
/*Line 272 - 'AtomApplication.js' */                    WebAtoms.dispatcher.callLater(function () {
/*Line 273 - 'AtomApplication.js' */                        window.atomApplication.invokeAction(window.atomApplication._next);
/*Line 274 - 'AtomApplication.js' */                    });
/*Line 275 - 'AtomApplication.js' */                }
/*Line 276 - 'AtomApplication.js' */            },

/*Line 278 - 'AtomApplication.js' */            onCheckHash: function () {
/*Line 279 - 'AtomApplication.js' */                if (this._lastHash != location.hash) {
/*Line 280 - 'AtomApplication.js' */                    this.onHashChanged();
/*Line 281 - 'AtomApplication.js' */                    this._lastHash = location.hash;
/*Line 282 - 'AtomApplication.js' */                }
/*Line 283 - 'AtomApplication.js' */            },

/*Line 285 - 'AtomApplication.js' */            onCloseCommand: function () {
/*Line 286 - 'AtomApplication.js' */                if (!parent)
/*Line 287 - 'AtomApplication.js' */                    return;
/*Line 288 - 'AtomApplication.js' */                //var iframe = parent.document.getElementById(frameElement.id);
/*Line 289 - 'AtomApplication.js' */                var win = frameElement.atomWindow;
/*Line 290 - 'AtomApplication.js' */                win._value = this._value;
/*Line 291 - 'AtomApplication.js' */                win.onCloseCommand();
/*Line 292 - 'AtomApplication.js' */            },

/*Line 294 - 'AtomApplication.js' */            setup: function () {
/*Line 295 - 'AtomApplication.js' */                this.createChildren();
/*Line 296 - 'AtomApplication.js' */                this.init();
/*Line 297 - 'AtomApplication.js' */            },

/*Line 299 - 'AtomApplication.js' */            init: function () {

/*Line 301 - 'AtomApplication.js' */                this.bindEvent(window, "resize", "invokeUpdateUI");

/*Line 303 - 'AtomApplication.js' */                var self = this;
/*Line 304 - 'AtomApplication.js' */                //this._onRefreshValue = function () {
/*Line 305 - 'AtomApplication.js' */                //    self.onRefreshValue.apply(self, arguments);
/*Line 306 - 'AtomApplication.js' */                //};
/*Line 307 - 'AtomApplication.js' */                this._onRefreshValue = aggregateHandler(function () {
/*Line 308 - 'AtomApplication.js' */                    self.onRefreshValue.apply(self, arguments);
/*Line 309 - 'AtomApplication.js' */                });

/*Line 311 - 'AtomApplication.js' */                this._scope._$_watcher = this;

/*Line 313 - 'AtomApplication.js' */                base.init.call(this);


/*Line 316 - 'AtomApplication.js' */                this.closeCommand = function () {
/*Line 317 - 'AtomApplication.js' */                    self.onCloseCommand.apply(self, arguments);
/*Line 318 - 'AtomApplication.js' */                };

/*Line 320 - 'AtomApplication.js' */            }
/*Line 321 - 'AtomApplication.js' */        },
/*Line 322 - 'AtomApplication.js' */        {
/*Line 323 - 'AtomApplication.js' */            renderAsPage: false,
/*Line 324 - 'AtomApplication.js' */            busyMessage: "",
/*Line 325 - 'AtomApplication.js' */            progress: 0

/*Line 327 - 'AtomApplication.js' */        });
/*Line 328 - 'AtomApplication.js' */})(WebAtoms.AtomDockPanel.prototype);
/*Line 0 - 'AtomAutoPostForm.js' */

/*Line 2 - 'AtomAutoPostForm.js' */(function (baseType) {
/*Line 3 - 'AtomAutoPostForm.js' */    return classCreatorEx({
/*Line 4 - 'AtomAutoPostForm.js' */        name: "WebAtoms.AtomAutoPostForm",
/*Line 5 - 'AtomAutoPostForm.js' */        base: baseType,
/*Line 6 - 'AtomAutoPostForm.js' */        start: function () {
/*Line 7 - 'AtomAutoPostForm.js' */        },
/*Line 8 - 'AtomAutoPostForm.js' */        properties: {
/*Line 9 - 'AtomAutoPostForm.js' */            isBusy: false,
/*Line 10 - 'AtomAutoPostForm.js' */            postError: null
/*Line 11 - 'AtomAutoPostForm.js' */        },
/*Line 12 - 'AtomAutoPostForm.js' */        methods: {
/*Line 13 - 'AtomAutoPostForm.js' */            pushPost: function (n) {
/*Line 14 - 'AtomAutoPostForm.js' */                if (this._isBusy)
/*Line 15 - 'AtomAutoPostForm.js' */                    return;
/*Line 16 - 'AtomAutoPostForm.js' */                if (this._pushPostTimeout) {
/*Line 17 - 'AtomAutoPostForm.js' */                    clearTimeout(this._pushPostTimeout);
/*Line 18 - 'AtomAutoPostForm.js' */                }
/*Line 19 - 'AtomAutoPostForm.js' */                if (!n)
/*Line 20 - 'AtomAutoPostForm.js' */                    n = 1000;
/*Line 21 - 'AtomAutoPostForm.js' */                var _this = this;
/*Line 22 - 'AtomAutoPostForm.js' */                this._pushPostTimeout = setTimeout(function () {
/*Line 23 - 'AtomAutoPostForm.js' */                    WebAtoms.dispatcher.callLater(function () {
/*Line 24 - 'AtomAutoPostForm.js' */                        _this.onSubmit();
/*Line 25 - 'AtomAutoPostForm.js' */                    });
/*Line 26 - 'AtomAutoPostForm.js' */                }, n);
/*Line 27 - 'AtomAutoPostForm.js' */            },

/*Line 29 - 'AtomAutoPostForm.js' */            onSubmit: function () {

/*Line 31 - 'AtomAutoPostForm.js' */                this._pushPostTimeout = 0;

/*Line 33 - 'AtomAutoPostForm.js' */                // already submitted?
/*Line 34 - 'AtomAutoPostForm.js' */                if (this._isBusy)
/*Line 35 - 'AtomAutoPostForm.js' */                    return;

/*Line 37 - 'AtomAutoPostForm.js' */                // for all nested children...
/*Line 38 - 'AtomAutoPostForm.js' */                if (!this.isValid()) {
/*Line 39 - 'AtomAutoPostForm.js' */                    //alert("Invalid Form");
/*Line 40 - 'AtomAutoPostForm.js' */                    return;
/*Line 41 - 'AtomAutoPostForm.js' */                }

/*Line 43 - 'AtomAutoPostForm.js' */                var data = this.preparePostData();
/*Line 44 - 'AtomAutoPostForm.js' */                if (!data)
/*Line 45 - 'AtomAutoPostForm.js' */                    return;

/*Line 47 - 'AtomAutoPostForm.js' */                var str = JSON.stringify(AtomBinder.getClone(data));
/*Line 48 - 'AtomAutoPostForm.js' */                if (this._cachedData) {
/*Line 49 - 'AtomAutoPostForm.js' */                    if (str == this._cachedData)
/*Line 50 - 'AtomAutoPostForm.js' */                        return;
/*Line 51 - 'AtomAutoPostForm.js' */                }
/*Line 52 - 'AtomAutoPostForm.js' */                this._cachedData = str;

/*Line 54 - 'AtomAutoPostForm.js' */                var self = this;

/*Line 56 - 'AtomAutoPostForm.js' */                var url = AtomPromise.getUrl(this._postUrl);

/*Line 58 - 'AtomAutoPostForm.js' */                //data = AtomBinder.getClone(data);

/*Line 60 - 'AtomAutoPostForm.js' */                //this.invokeAjax(url, { type: "POST", data: data, success: self._success });
/*Line 61 - 'AtomAutoPostForm.js' */                var ap = AtomPromise.json(url, null, { type: "POST", data: data }).then(self._success);
/*Line 62 - 'AtomAutoPostForm.js' */                ap.failed(function () {
/*Line 63 - 'AtomAutoPostForm.js' */                    self._isBusy = false;
/*Line 64 - 'AtomAutoPostForm.js' */                    self._postError = ap.error.msg;
/*Line 65 - 'AtomAutoPostForm.js' */                    AtomBinder.refreshValue(self, "isBusy");
/*Line 66 - 'AtomAutoPostForm.js' */                    AtomBinder.refreshValue(self, "postError");
/*Line 67 - 'AtomAutoPostForm.js' */                });
/*Line 68 - 'AtomAutoPostForm.js' */                ap.showProgress(false);
/*Line 69 - 'AtomAutoPostForm.js' */                ap.showError(false);
/*Line 70 - 'AtomAutoPostForm.js' */                ap.invoke();
/*Line 71 - 'AtomAutoPostForm.js' */            },

/*Line 73 - 'AtomAutoPostForm.js' */            onCreated: function () {
/*Line 74 - 'AtomAutoPostForm.js' */                baseType.onCreated.apply(this, arguments);
/*Line 75 - 'AtomAutoPostForm.js' */                var data = this.preparePostData();
/*Line 76 - 'AtomAutoPostForm.js' */                if (!data)
/*Line 77 - 'AtomAutoPostForm.js' */                    return;
/*Line 78 - 'AtomAutoPostForm.js' */                this._cachedData = JSON.stringify(AtomBinder.getClone(data));
/*Line 79 - 'AtomAutoPostForm.js' */            },

/*Line 81 - 'AtomAutoPostForm.js' */            onSuccess: function (p) {

/*Line 83 - 'AtomAutoPostForm.js' */                baseType.onSuccess.apply(this, arguments);

/*Line 85 - 'AtomAutoPostForm.js' */                this._isBusy = false;
/*Line 86 - 'AtomAutoPostForm.js' */                AtomBinder.refreshValue(this, "isBusy");
/*Line 87 - 'AtomAutoPostForm.js' */            },

/*Line 89 - 'AtomAutoPostForm.js' */            onKeyUp: function (e) {

/*Line 91 - 'AtomAutoPostForm.js' */                this.pushPost();

/*Line 93 - 'AtomAutoPostForm.js' */                if (e.target && e.target.nodeName && /textarea/gi.test(e.target.nodeName))
/*Line 94 - 'AtomAutoPostForm.js' */                    return;
/*Line 95 - 'AtomAutoPostForm.js' */                if (e.keyCode == 13) {
/*Line 96 - 'AtomAutoPostForm.js' */                    this.onSubmit();
/*Line 97 - 'AtomAutoPostForm.js' */                }
/*Line 98 - 'AtomAutoPostForm.js' */            },

/*Line 100 - 'AtomAutoPostForm.js' */            init: function () {
/*Line 101 - 'AtomAutoPostForm.js' */                baseType.init.call(this);

/*Line 103 - 'AtomAutoPostForm.js' */                var _this = this;
/*Line 104 - 'AtomAutoPostForm.js' */                this.pushPostHandler = function () {
/*Line 105 - 'AtomAutoPostForm.js' */                    _this.pushPost(1000);
/*Line 106 - 'AtomAutoPostForm.js' */                };
/*Line 107 - 'AtomAutoPostForm.js' */                this.bindEvent(this._element, 'click', this.pushPostHandler);

/*Line 109 - 'AtomAutoPostForm.js' */                $(this._element).find('input,select,textarea').bind('change', null, this.pushPostHandler)
/*Line 110 - 'AtomAutoPostForm.js' */            }
/*Line 111 - 'AtomAutoPostForm.js' */        }
/*Line 112 - 'AtomAutoPostForm.js' */    });
/*Line 113 - 'AtomAutoPostForm.js' */})(WebAtoms.AtomForm.prototype);


/*Line 0 - 'AtomDataGrid.js' *////// <reference path="../controls/AtomListBox.js" />

/*Line 2 - 'AtomDataGrid.js' *///WebAtoms.AtomDataGridColumn = function (e) {
/*Line 3 - 'AtomDataGrid.js' *///    WebAtoms.AtomDataGridColumn.initBase(this, arguments);
/*Line 4 - 'AtomDataGrid.js' *///};

/*Line 6 - 'AtomDataGrid.js' *///WebAtoms.AtomDataGridColumn.prototype = {

/*Line 8 - 'AtomDataGrid.js' *///};

/*Line 10 - 'AtomDataGrid.js' *///WebAtoms.AtomDataGridColumn.registerClass("WebAtoms.AtomDataGridColumn", WebAtoms.AtomControl);

/*Line 12 - 'AtomDataGrid.js' *///WebAtoms.AtomDataGrid = function (e) {
/*Line 13 - 'AtomDataGrid.js' *///    WebAtoms.AtomDataGrid.initBase(this, arguments);

/*Line 15 - 'AtomDataGrid.js' *///};

/*Line 17 - 'AtomDataGrid.js' *///WebAtoms.AtomDataGrid.prototype = {



/*Line 21 - 'AtomDataGrid.js' *///};

/*Line 23 - 'AtomDataGrid.js' *///WebAtoms.AtomDataGrid.registerClass("WebAtoms.DataGrid", WebAtoms.AtomListBox);
/*Line 0 - 'AtomFormField.js' */

/*Line 2 - 'AtomFormField.js' */(function (baseType) {
/*Line 3 - 'AtomFormField.js' */    return classCreatorEx({
/*Line 4 - 'AtomFormField.js' */        name: "WebAtoms.AtomFormField",
/*Line 5 - 'AtomFormField.js' */        base: baseType,
/*Line 6 - 'AtomFormField.js' */        start: function () {
/*Line 7 - 'AtomFormField.js' */            this._presenters = ["contentPresenter"];
/*Line 8 - 'AtomFormField.js' */        },
/*Line 9 - 'AtomFormField.js' */        properties: {
/*Line 10 - 'AtomFormField.js' */            error: undefined,
/*Line 11 - 'AtomFormField.js' */            dataType: null,
/*Line 12 - 'AtomFormField.js' */            label: undefined,
/*Line 13 - 'AtomFormField.js' */            fieldClass: undefined,
/*Line 14 - 'AtomFormField.js' */            required: false,
/*Line 15 - 'AtomFormField.js' */            isValid: undefined,
/*Line 16 - 'AtomFormField.js' */            regex: null,
/*Line 17 - 'AtomFormField.js' */            fieldValue: undefined,
/*Line 18 - 'AtomFormField.js' */            field: null,
/*Line 19 - 'AtomFormField.js' */            requiredMessage: "Required",
/*Line 20 - 'AtomFormField.js' */            invalidMessage: "Invalid",
/*Line 21 - 'AtomFormField.js' */            fieldVisible: true,
/*Line 22 - 'AtomFormField.js' */            validate: false,
/*Line 23 - 'AtomFormField.js' */            isValidSet: false
/*Line 24 - 'AtomFormField.js' */        },
/*Line 25 - 'AtomFormField.js' */        methods: {
/*Line 26 - 'AtomFormField.js' */            set_fieldVisible: function (v) {
/*Line 27 - 'AtomFormField.js' */                this._fieldVisible = v;
/*Line 28 - 'AtomFormField.js' */                $(this._element).css("display", v ? '' : 'none');
/*Line 29 - 'AtomFormField.js' */            },
/*Line 30 - 'AtomFormField.js' */            set_fieldClass: function (v) {
/*Line 31 - 'AtomFormField.js' */                this._fieldClass = v;
/*Line 32 - 'AtomFormField.js' */                this.setLocalValue('class', v, this._element);
/*Line 33 - 'AtomFormField.js' */            },
/*Line 34 - 'AtomFormField.js' */            set_dataType: function (v) {
/*Line 35 - 'AtomFormField.js' */                this._dataType = v;
/*Line 36 - 'AtomFormField.js' */                this.setup();
/*Line 37 - 'AtomFormField.js' */            },

/*Line 39 - 'AtomFormField.js' */            set_fieldValue: function (v) {
/*Line 40 - 'AtomFormField.js' */                this._fieldValue = v;
/*Line 41 - 'AtomFormField.js' */                if (!this._validate)
/*Line 42 - 'AtomFormField.js' */                    return;
/*Line 43 - 'AtomFormField.js' */                this.validate();
/*Line 44 - 'AtomFormField.js' */            },
/*Line 45 - 'AtomFormField.js' */            set_isValid: function (v) {
/*Line 46 - 'AtomFormField.js' */                this._isValid = v;
/*Line 47 - 'AtomFormField.js' */                this._isValidSet = true;
/*Line 48 - 'AtomFormField.js' */                if (!this._validate)
/*Line 49 - 'AtomFormField.js' */                    return;
/*Line 50 - 'AtomFormField.js' */                this.validate();
/*Line 51 - 'AtomFormField.js' */            },
/*Line 52 - 'AtomFormField.js' */            set_regex: function (v) {
/*Line 53 - 'AtomFormField.js' */                this._regex = v;
/*Line 54 - 'AtomFormField.js' */                this.setup();
/*Line 55 - 'AtomFormField.js' */            },
/*Line 56 - 'AtomFormField.js' */            set_required: function (v) {
/*Line 57 - 'AtomFormField.js' */                this._required = v;
/*Line 58 - 'AtomFormField.js' */                this.setup();
/*Line 59 - 'AtomFormField.js' */            },
/*Line 60 - 'AtomFormField.js' */            validateChildren: function (e) {
/*Line 61 - 'AtomFormField.js' */                var ae = new ChildEnumerator(e);
/*Line 62 - 'AtomFormField.js' */                while (ae.next()) {
/*Line 63 - 'AtomFormField.js' */                    var child = ae.current();

/*Line 65 - 'AtomFormField.js' */                    if (child.atomControl) {
/*Line 66 - 'AtomFormField.js' */                        this.validateValue(AtomBinder.getValue(child.atomControl, "value"));
/*Line 67 - 'AtomFormField.js' */                    } else {
/*Line 68 - 'AtomFormField.js' */                        if (/input|select|textarea/gi.test(child.nodeName)) {
/*Line 69 - 'AtomFormField.js' */                            this.validateValue($(child).val());
/*Line 70 - 'AtomFormField.js' */                        } else {
/*Line 71 - 'AtomFormField.js' */                            this.validateChildren(child);
/*Line 72 - 'AtomFormField.js' */                        }
/*Line 73 - 'AtomFormField.js' */                    }
/*Line 74 - 'AtomFormField.js' */                }
/*Line 75 - 'AtomFormField.js' */            },
/*Line 76 - 'AtomFormField.js' */            validateValue: function (v) {
/*Line 77 - 'AtomFormField.js' */                if (this._required) {
/*Line 78 - 'AtomFormField.js' */                    if (!v) {
/*Line 79 - 'AtomFormField.js' */                        AtomBinder.setValue(this, "error", this._requiredMessage);
/*Line 80 - 'AtomFormField.js' */                        this._isValid = false;
/*Line 81 - 'AtomFormField.js' */                        return;
/*Line 82 - 'AtomFormField.js' */                    }
/*Line 83 - 'AtomFormField.js' */                } else {
/*Line 84 - 'AtomFormField.js' */                    // if value is not required
/*Line 85 - 'AtomFormField.js' */                    // and if value is empty
/*Line 86 - 'AtomFormField.js' */                    // it is a valid value
/*Line 87 - 'AtomFormField.js' */                    if (!v) {
/*Line 88 - 'AtomFormField.js' */                        this._isValid = true;
/*Line 89 - 'AtomFormField.js' */                        return;
/*Line 90 - 'AtomFormField.js' */                    }
/*Line 91 - 'AtomFormField.js' */                }

/*Line 93 - 'AtomFormField.js' */                var re = null;

/*Line 95 - 'AtomFormField.js' */                if (/email/gi.test(this._dataType)) {
/*Line 96 - 'AtomFormField.js' */                    re = /^(([^<>()\[\]\\.,;:\s@\"]+(\.[^<>()\[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
/*Line 97 - 'AtomFormField.js' */                } else {
/*Line 98 - 'AtomFormField.js' */                    if (this._regex) {
/*Line 99 - 'AtomFormField.js' */                        re = eval("(" + this._regex + ")");
/*Line 100 - 'AtomFormField.js' */                    }
/*Line 101 - 'AtomFormField.js' */                }

/*Line 103 - 'AtomFormField.js' */                if (re) {
/*Line 104 - 'AtomFormField.js' */                    if (!re.test(v)) {
/*Line 105 - 'AtomFormField.js' */                        AtomBinder.setValue(this, "error", this._invalidMessage);
/*Line 106 - 'AtomFormField.js' */                        this._isValid = false;
/*Line 107 - 'AtomFormField.js' */                        return;
/*Line 108 - 'AtomFormField.js' */                    }
/*Line 109 - 'AtomFormField.js' */                }
/*Line 110 - 'AtomFormField.js' */            },
/*Line 111 - 'AtomFormField.js' */            validate: function () {
/*Line 112 - 'AtomFormField.js' */                this._validate = true;
/*Line 113 - 'AtomFormField.js' */                if (!(this._required || this._regex || this._dataType))
/*Line 114 - 'AtomFormField.js' */                    return this._isValid === undefined ? true : this._isValid;



/*Line 118 - 'AtomFormField.js' */                if (this._isValid) {
/*Line 119 - 'AtomFormField.js' */                    AtomBinder.setValue(this, "error", "");
/*Line 120 - 'AtomFormField.js' */                    if (this._isValidSet) {
/*Line 121 - 'AtomFormField.js' */                        return true;
/*Line 122 - 'AtomFormField.js' */                    }
/*Line 123 - 'AtomFormField.js' */                }

/*Line 125 - 'AtomFormField.js' */                this._isValid = true;

/*Line 127 - 'AtomFormField.js' */                if (this._fieldValue !== undefined) {
/*Line 128 - 'AtomFormField.js' */                    this.validateValue(this._fieldValue);
/*Line 129 - 'AtomFormField.js' */                } else {
/*Line 130 - 'AtomFormField.js' */                    // check validity..
/*Line 131 - 'AtomFormField.js' */                    this.validateChildren(this._element);
/*Line 132 - 'AtomFormField.js' */                }
/*Line 133 - 'AtomFormField.js' */                if (this._isValid) {
/*Line 134 - 'AtomFormField.js' */                    AtomBinder.setValue(this, "error", "");
/*Line 135 - 'AtomFormField.js' */                }
/*Line 136 - 'AtomFormField.js' */                return this._isValid;
/*Line 137 - 'AtomFormField.js' */            },
/*Line 138 - 'AtomFormField.js' */            onCreated: function () {
/*Line 139 - 'AtomFormField.js' */                this.setup();
/*Line 140 - 'AtomFormField.js' */            },
/*Line 141 - 'AtomFormField.js' */            onFocusOut: function () {
/*Line 142 - 'AtomFormField.js' */                this._validate = true;
/*Line 143 - 'AtomFormField.js' */                this.validate();
/*Line 144 - 'AtomFormField.js' */            },
/*Line 145 - 'AtomFormField.js' */            setup: function () {
/*Line 146 - 'AtomFormField.js' */                if (!this._created)
/*Line 147 - 'AtomFormField.js' */                    return;

/*Line 149 - 'AtomFormField.js' */                // find two way bindings...
/*Line 150 - 'AtomFormField.js' */                var e = this._element;

/*Line 152 - 'AtomFormField.js' */                if (this._contentPresenter) {
/*Line 153 - 'AtomFormField.js' */                    this._contentPresenter.appendChild(this._element.contentElement);
/*Line 154 - 'AtomFormField.js' */                }

/*Line 156 - 'AtomFormField.js' */                var ae = new AtomEnumerator($(e).find("input,select,textarea"));
/*Line 157 - 'AtomFormField.js' */                while (ae.next()) {
/*Line 158 - 'AtomFormField.js' */                    var item = ae.current();
/*Line 159 - 'AtomFormField.js' */                    this.bindEvent(item, "blur", "onFocusOut");
/*Line 160 - 'AtomFormField.js' */                    this.bindEvent(item, "change", "onFocusOut");
/*Line 161 - 'AtomFormField.js' */                }

/*Line 163 - 'AtomFormField.js' */                AtomBinder.refreshValue(this, "fieldClass");
/*Line 164 - 'AtomFormField.js' */            }
/*Line 165 - 'AtomFormField.js' */        }
/*Line 166 - 'AtomFormField.js' */    });
/*Line 167 - 'AtomFormField.js' */})(WebAtoms.AtomControl.prototype);
/*Line 0 - 'AtomFormGrid.js' */

/*Line 2 - 'AtomFormGrid.js' */// http://jsfiddle.net/2yqQF/

/*Line 4 - 'AtomFormGrid.js' */(function (baseType) {
/*Line 5 - 'AtomFormGrid.js' */    return classCreatorEx({
/*Line 6 - 'AtomFormGrid.js' */        name: "WebAtoms.AtomFormGridLayout",
/*Line 7 - 'AtomFormGrid.js' */        base: baseType,
/*Line 8 - 'AtomFormGrid.js' */        start: function () { },
/*Line 9 - 'AtomFormGrid.js' */        properties: {
/*Line 10 - 'AtomFormGrid.js' */            minLabelWidth: 100,
/*Line 11 - 'AtomFormGrid.js' */            cellSpacing: 5,
/*Line 12 - 'AtomFormGrid.js' */            label: ""
/*Line 13 - 'AtomFormGrid.js' */        },
/*Line 14 - 'AtomFormGrid.js' */        methods: {
/*Line 15 - 'AtomFormGrid.js' */            onUpdateUI: function () {
/*Line 16 - 'AtomFormGrid.js' */                AtomBinder.refreshValue(this, "controlWidth");
/*Line 17 - 'AtomFormGrid.js' */                AtomBinder.refreshValue(this, "controlHeight");
/*Line 18 - 'AtomFormGrid.js' */                baseType.onUpdateUI.apply(this, arguments);
/*Line 19 - 'AtomFormGrid.js' */            },

/*Line 21 - 'AtomFormGrid.js' */            get_controlWidth: function () {
/*Line 22 - 'AtomFormGrid.js' */                return $(this._element.parentNode).innerWidth();
/*Line 23 - 'AtomFormGrid.js' */            },

/*Line 25 - 'AtomFormGrid.js' */            get_controlHeight: function () {
/*Line 26 - 'AtomFormGrid.js' */                return $(this._element.parentNode).innerHeight();
/*Line 27 - 'AtomFormGrid.js' */            },

/*Line 29 - 'AtomFormGrid.js' */            createChildren: function () {
/*Line 30 - 'AtomFormGrid.js' */                var element = this._element;
/*Line 31 - 'AtomFormGrid.js' */                $(element).addClass("atom-form-grid");

/*Line 33 - 'AtomFormGrid.js' */                var children = $(element).children();

/*Line 35 - 'AtomFormGrid.js' */                var ae = new AtomEnumerator(children);

/*Line 37 - 'AtomFormGrid.js' */                AtomUI.removeAllChildren(element);

/*Line 39 - 'AtomFormGrid.js' */                var container = document.createElement("DIV");
/*Line 40 - 'AtomFormGrid.js' */                //container.setAttribute("style-width", "[$owner.controlWidth]");
/*Line 41 - 'AtomFormGrid.js' */                $(container).addClass("atom-form-grid-container");

/*Line 43 - 'AtomFormGrid.js' */                element.appendChild(container);

/*Line 45 - 'AtomFormGrid.js' */                var minLabelWidth = AtomUI.attr(this._element, "atom-min-label-width");

/*Line 47 - 'AtomFormGrid.js' */                this.getTemplate("fieldTemplate");

/*Line 49 - 'AtomFormGrid.js' */                while (ae.next()) {
/*Line 50 - 'AtomFormGrid.js' */                    var item = ae.current();

/*Line 52 - 'AtomFormGrid.js' */                    var at = AtomUI.attr(item,"atom-type");
/*Line 53 - 'AtomFormGrid.js' */                    if (at == "AtomFormRow") {
/*Line 54 - 'AtomFormGrid.js' */                        var table = document.createElement("TABLE");
/*Line 55 - 'AtomFormGrid.js' */                        container.appendChild(table);
/*Line 56 - 'AtomFormGrid.js' */                        $(table).addClass("atom-form-grid-row");
/*Line 57 - 'AtomFormGrid.js' */                        var tbody = document.createElement("TBODY");
/*Line 58 - 'AtomFormGrid.js' */                        table.appendChild(tbody);

/*Line 60 - 'AtomFormGrid.js' */                        var tr = document.createElement("TR");
/*Line 61 - 'AtomFormGrid.js' */                        tbody.appendChild(tr);

/*Line 63 - 'AtomFormGrid.js' */                        var children = $(item).children();
/*Line 64 - 'AtomFormGrid.js' */                        var ce = new AtomEnumerator(children);
/*Line 65 - 'AtomFormGrid.js' */                        while (ce.next()) {
/*Line 66 - 'AtomFormGrid.js' */                            var td = document.createElement("TD");
/*Line 67 - 'AtomFormGrid.js' */                            tr.appendChild(td);
/*Line 68 - 'AtomFormGrid.js' */                            this.createField(td, ce.current());
/*Line 69 - 'AtomFormGrid.js' */                        }

/*Line 71 - 'AtomFormGrid.js' */                        continue;
/*Line 72 - 'AtomFormGrid.js' */                    }
/*Line 73 - 'AtomFormGrid.js' */                    if (at == "AtomFormTabControl" || at == "AtomTabControl") {


/*Line 76 - 'AtomFormGrid.js' */                        var tabBar = document.createElement("ul");
/*Line 77 - 'AtomFormGrid.js' */                        tabBar.setAttribute("atom-type", "AtomToggleButtonBar");
/*Line 78 - 'AtomFormGrid.js' */                        var tabBarID = AtomUI.assignID(tabBar);
/*Line 79 - 'AtomFormGrid.js' */                        tabBar.setAttribute("atom-name", tabBarID);
/*Line 80 - 'AtomFormGrid.js' */                        tabBar.setAttribute("atom-show-tabs", "true");
/*Line 81 - 'AtomFormGrid.js' */                        var te = document.createElement("li");
/*Line 82 - 'AtomFormGrid.js' */                        tabBar.appendChild(te);
/*Line 83 - 'AtomFormGrid.js' */                        te.setAttribute("atom-text", "{$data.label}");
/*Line 84 - 'AtomFormGrid.js' */                        te.setAttribute("atom-template", "itemTemplate");
/*Line 85 - 'AtomFormGrid.js' */                        //td.appendChild(tabBar);
/*Line 86 - 'AtomFormGrid.js' */                        this.createField(container, tabBar);

/*Line 88 - 'AtomFormGrid.js' */                        var tbc = allControls[tabBarID];

/*Line 90 - 'AtomFormGrid.js' */                        var ce = new ChildEnumerator(item);
/*Line 91 - 'AtomFormGrid.js' */                        var list = [];
/*Line 92 - 'AtomFormGrid.js' */                        var index = 0;
/*Line 93 - 'AtomFormGrid.js' */                        while (ce.next()) {
/*Line 94 - 'AtomFormGrid.js' */                            var child = ce.current();
/*Line 95 - 'AtomFormGrid.js' */                            $(child).remove();
/*Line 96 - 'AtomFormGrid.js' */                            child.setAttribute("style-display", "[$scope." + tabBarID + ".selectedIndex == " + index + " ? '' : 'none']");
/*Line 97 - 'AtomFormGrid.js' */                            var cf = this.createField(container, child);
/*Line 98 - 'AtomFormGrid.js' */                            list.push(cf);
/*Line 99 - 'AtomFormGrid.js' */                            //if (cf.constructor == WebAtoms.AtomFormGridLayout) {

/*Line 101 - 'AtomFormGrid.js' */                            //}
/*Line 102 - 'AtomFormGrid.js' */                            index++;
/*Line 103 - 'AtomFormGrid.js' */                        }

/*Line 105 - 'AtomFormGrid.js' */                        tbc.set_items(list);
/*Line 106 - 'AtomFormGrid.js' */                        continue;
/*Line 107 - 'AtomFormGrid.js' */                    }
/*Line 108 - 'AtomFormGrid.js' */                    this.createField(container, item);

/*Line 110 - 'AtomFormGrid.js' */                }

/*Line 112 - 'AtomFormGrid.js' */            }
/*Line 113 - 'AtomFormGrid.js' */        }
/*Line 114 - 'AtomFormGrid.js' */    });
/*Line 115 - 'AtomFormGrid.js' */})(WebAtoms.AtomFormLayout.prototype);


/*Line 118 - 'AtomFormGrid.js' */(function (baseType) {
/*Line 119 - 'AtomFormGrid.js' */    return classCreatorEx({
/*Line 120 - 'AtomFormGrid.js' */        name: "WebAtoms.AtomFormTab",
/*Line 121 - 'AtomFormGrid.js' */        base: baseType,
/*Line 122 - 'AtomFormGrid.js' */        start: function () {
/*Line 123 - 'AtomFormGrid.js' */        },
/*Line 124 - 'AtomFormGrid.js' */        methods: {

/*Line 126 - 'AtomFormGrid.js' */        }
/*Line 127 - 'AtomFormGrid.js' */    });
/*Line 128 - 'AtomFormGrid.js' */})(WebAtoms.AtomFormGridLayout.prototype);
/*Line 0 - 'AtomFormNoLayout.js' */

/*Line 2 - 'AtomFormNoLayout.js' */(function (baseType) {
/*Line 3 - 'AtomFormNoLayout.js' */    return classCreatorEx({
/*Line 4 - 'AtomFormNoLayout.js' */        name: "WebAtoms.AtomFormNoLayout",
/*Line 5 - 'AtomFormNoLayout.js' */        base: baseType,
/*Line 6 - 'AtomFormNoLayout.js' */        start: function () { },
/*Line 7 - 'AtomFormNoLayout.js' */        methods: {

/*Line 9 - 'AtomFormNoLayout.js' */        }
/*Line 10 - 'AtomFormNoLayout.js' */    });
/*Line 11 - 'AtomFormNoLayout.js' */})(WebAtoms.AtomForm.prototype);

/*Line 0 - 'AtomFormVerticalLayout.js' */

/*Line 2 - 'AtomFormVerticalLayout.js' */(function (baseType) {
/*Line 3 - 'AtomFormVerticalLayout.js' */    return classCreatorEx({
/*Line 4 - 'AtomFormVerticalLayout.js' */        name: "WebAtoms.AtomFormVerticalLayout",
/*Line 5 - 'AtomFormVerticalLayout.js' */        base: baseType,
/*Line 6 - 'AtomFormVerticalLayout.js' */        start: function () { },
/*Line 7 - 'AtomFormVerticalLayout.js' */        methods: {}
/*Line 8 - 'AtomFormVerticalLayout.js' */    });
/*Line 9 - 'AtomFormVerticalLayout.js' */})(WebAtoms.AtomFormLayout.prototype);

/*Line 0 - 'AtomTableLayout.js' */

/*Line 2 - 'AtomTableLayout.js' */(function (baseType) {
/*Line 3 - 'AtomTableLayout.js' */    return classCreatorEx({
/*Line 4 - 'AtomTableLayout.js' */        name: "WebAtoms.AtomTableLayout",
/*Line 5 - 'AtomTableLayout.js' */        base: baseType,
/*Line 6 - 'AtomTableLayout.js' */        start: function (columns, cellWidth, cellHeight) {
/*Line 7 - 'AtomTableLayout.js' */            this._cellWidth = cellWidth;
/*Line 8 - 'AtomTableLayout.js' */            this._cellHeight = cellHeight;
/*Line 9 - 'AtomTableLayout.js' */            this._columns = columns;
/*Line 10 - 'AtomTableLayout.js' */        },
/*Line 11 - 'AtomTableLayout.js' */        methods: {
/*Line 12 - 'AtomTableLayout.js' */            doLayout: function (element) {
/*Line 13 - 'AtomTableLayout.js' */                var ae = new AtomEnumerator($(element).children());
/*Line 14 - 'AtomTableLayout.js' */                var item;

/*Line 16 - 'AtomTableLayout.js' */                var left = 0;
/*Line 17 - 'AtomTableLayout.js' */                var top = 0;

/*Line 19 - 'AtomTableLayout.js' */                var maxRows = Math.ceil(ae._array.length / this._columns) - 1;
/*Line 20 - 'AtomTableLayout.js' */                var rows = maxRows;

/*Line 22 - 'AtomTableLayout.js' */                var width = this._columns * this._cellWidth;
/*Line 23 - 'AtomTableLayout.js' */                var height = this._cellHeight * (maxRows + 1);

/*Line 25 - 'AtomTableLayout.js' */                element.style.position = "relative";
/*Line 26 - 'AtomTableLayout.js' */                element.style.width = width + "px";
/*Line 27 - 'AtomTableLayout.js' */                element.style.height = height + "px";

/*Line 29 - 'AtomTableLayout.js' */                element.maxRows = maxRows;

/*Line 31 - 'AtomTableLayout.js' */                while (ae.next()) {
/*Line 32 - 'AtomTableLayout.js' */                    item = ae.current();

/*Line 34 - 'AtomTableLayout.js' */                    item.style.position = "absolute";
/*Line 35 - 'AtomTableLayout.js' */                    item.style.left = left + "px";
/*Line 36 - 'AtomTableLayout.js' */                    item.style.top = top + "px";

/*Line 38 - 'AtomTableLayout.js' */                    item.style.width = this._cellWidth + "px";

/*Line 40 - 'AtomTableLayout.js' */                    if (rows <= 0) {
/*Line 41 - 'AtomTableLayout.js' */                        rows = maxRows;
/*Line 42 - 'AtomTableLayout.js' */                        left += this._cellWidth + 10;
/*Line 43 - 'AtomTableLayout.js' */                        top = 0;
/*Line 44 - 'AtomTableLayout.js' */                    } else {
/*Line 45 - 'AtomTableLayout.js' */                        rows--;
/*Line 46 - 'AtomTableLayout.js' */                        top += this._cellHeight;
/*Line 47 - 'AtomTableLayout.js' */                    }
/*Line 48 - 'AtomTableLayout.js' */                }
/*Line 49 - 'AtomTableLayout.js' */            }
/*Line 50 - 'AtomTableLayout.js' */        }
/*Line 51 - 'AtomTableLayout.js' */    });
/*Line 52 - 'AtomTableLayout.js' */})(WebAtoms.AtomLayout.prototype);
/*Line 0 - 'AtomViewBoxLayout.js' */

/*Line 2 - 'AtomViewBoxLayout.js' */var AtomViewBoxLayout = (function (baseType) {
/*Line 3 - 'AtomViewBoxLayout.js' */    return classCreatorEx({
/*Line 4 - 'AtomViewBoxLayout.js' */        name: "WebAtoms.AtomViewBoxLayout",
/*Line 5 - 'AtomViewBoxLayout.js' */        base: baseType,
/*Line 6 - 'AtomViewBoxLayout.js' */        start: function () { },
/*Line 7 - 'AtomViewBoxLayout.js' */        methods: {
/*Line 8 - 'AtomViewBoxLayout.js' */            doLayout: function (element) {
/*Line 9 - 'AtomViewBoxLayout.js' */                var style = { width: $(element).innerWidth() + 'px', height: $(element).innerHeight() + 'px' };
/*Line 10 - 'AtomViewBoxLayout.js' */                var ae = new ChildEnumerator(element);
/*Line 11 - 'AtomViewBoxLayout.js' */                var item;
/*Line 12 - 'AtomViewBoxLayout.js' */                while (ae.next()) {
/*Line 13 - 'AtomViewBoxLayout.js' */                    item = ae.current();
/*Line 14 - 'AtomViewBoxLayout.js' */                    item.style.width = style.width;
/*Line 15 - 'AtomViewBoxLayout.js' */                    item.style.height = style.height;
/*Line 16 - 'AtomViewBoxLayout.js' */                    if (item.atomControl) {
/*Line 17 - 'AtomViewBoxLayout.js' */                        item.atomControl.updateUI();
/*Line 18 - 'AtomViewBoxLayout.js' */                    }
/*Line 19 - 'AtomViewBoxLayout.js' */                }
/*Line 20 - 'AtomViewBoxLayout.js' */            }
/*Line 21 - 'AtomViewBoxLayout.js' */        }
/*Line 22 - 'AtomViewBoxLayout.js' */    });
/*Line 23 - 'AtomViewBoxLayout.js' */})(WebAtoms.AtomLayout.prototype);

/*Line 25 - 'AtomViewBoxLayout.js' */AtomViewBoxLayout.defaultInstance = new AtomViewBoxLayout();
/*Line 0 - 'AtomAlert.js' */

/*Line 2 - 'AtomAlert.js' */Atom.confirm = function (msg, f) {

/*Line 4 - 'AtomAlert.js' */    var d = { Message: msg, ConfirmValue: false, Confirm: f ? true : false };

/*Line 6 - 'AtomAlert.js' */    var e = document.createElement("DIV");
/*Line 7 - 'AtomAlert.js' */    document.body.appendChild(e);
/*Line 8 - 'AtomAlert.js' */    var w = AtomUI.createControl(e, WebAtoms.AtomWindow, d);

/*Line 10 - 'AtomAlert.js' */    w.set_windowWidth(380);
/*Line 11 - 'AtomAlert.js' */    w.set_windowHeight(120);
/*Line 12 - 'AtomAlert.js' */    w.set_windowTemplate(w.getTemplate("alertTemplate"));
/*Line 13 - 'AtomAlert.js' */    w.set_title( f ? "Message" : "Confirm" );

/*Line 15 - 'AtomAlert.js' */    w.set_next(function () {

/*Line 17 - 'AtomAlert.js' */        w.dispose();
/*Line 18 - 'AtomAlert.js' */        $(e).remove();

/*Line 20 - 'AtomAlert.js' */        if (d.ConfirmValue) {
/*Line 21 - 'AtomAlert.js' */            if (f) {
/*Line 22 - 'AtomAlert.js' */                f();
/*Line 23 - 'AtomAlert.js' */            }
/*Line 24 - 'AtomAlert.js' */        }
/*Line 25 - 'AtomAlert.js' */    });

/*Line 27 - 'AtomAlert.js' */    w.refresh();

/*Line 29 - 'AtomAlert.js' */};

/*Line 31 - 'AtomAlert.js' */if (window.__chromeCSP) {

/*Line 33 - 'AtomAlert.js' */    Atom.alert = function (msg) {
/*Line 34 - 'AtomAlert.js' */        Atom.confirm(msg, null);
/*Line 35 - 'AtomAlert.js' */    };
/*Line 36 - 'AtomAlert.js' */} else {
/*Line 37 - 'AtomAlert.js' */    Atom.alert = function (msg) {
/*Line 38 - 'AtomAlert.js' */        alert(msg);
/*Line 39 - 'AtomAlert.js' */    }
/*Line 40 - 'AtomAlert.js' */}
/*Line 0 - 'ZZZZZInitializer.js' */

/*Line 2 - 'ZZZZZInitializer.js' */// http://jsfiddle.net/bZcth/33/#update


/*Line 5 - 'ZZZZZInitializer.js' */$(document).ready(function () {


/*Line 8 - 'ZZZZZInitializer.js' */    // commencing Web Atoms...
/*Line 9 - 'ZZZZZInitializer.js' */    var d = WebAtoms.dispatcher;

/*Line 11 - 'ZZZZZInitializer.js' */    d.setupControls();
/*Line 12 - 'ZZZZZInitializer.js' */    d.start();
/*Line 13 - 'ZZZZZInitializer.js' */});

/*Line 15 - 'ZZZZZInitializer.js' */$(window).unload(function () {

/*Line 17 - 'ZZZZZInitializer.js' */    function dispose(e) {
/*Line 18 - 'ZZZZZInitializer.js' */        if (!e)
/*Line 19 - 'ZZZZZInitializer.js' */            return;
/*Line 20 - 'ZZZZZInitializer.js' */        if (e.atomControl) {
/*Line 21 - 'ZZZZZInitializer.js' */            e.atomControl.dispose();
/*Line 22 - 'ZZZZZInitializer.js' */        } else {
/*Line 23 - 'ZZZZZInitializer.js' */            var ce = new ChildEnumerator(e);
/*Line 24 - 'ZZZZZInitializer.js' */            while (ce.next()) {
/*Line 25 - 'ZZZZZInitializer.js' */                dispose(ce.current());
/*Line 26 - 'ZZZZZInitializer.js' */            }
/*Line 27 - 'ZZZZZInitializer.js' */        }
/*Line 28 - 'ZZZZZInitializer.js' */    }

/*Line 30 - 'ZZZZZInitializer.js' */    dispose(document.body);
/*Line 31 - 'ZZZZZInitializer.js' */});


	})(window);