upgrade dojo to 1.8.3 (refs #570)

[tt-rss.git] / lib / dojo / tt-rss-layer.js.uncompressed.js

require({cache:{
'dijit/form/TextBox':function(){
require({cache:{
'url:dijit/form/templates/TextBox.html':"<div class=\"dijit dijitReset dijitInline dijitLeft\" id=\"widget_${id}\" role=\"presentation\"\n\t><div class=\"dijitReset dijitInputField dijitInputContainer\"\n\t\t><input class=\"dijitReset dijitInputInner\" data-dojo-attach-point='textbox,focusNode' autocomplete=\"off\"\n\t\t\t${!nameAttrSetting} type='${type}'\n\t/></div\n></div>\n"}});
define("dijit/form/TextBox", [
        "dojo/_base/declare", // declare
        "dojo/dom-construct", // domConstruct.create
        "dojo/dom-style", // domStyle.getComputedStyle
        "dojo/_base/kernel", // kernel.deprecated
        "dojo/_base/lang", // lang.hitch
        "dojo/sniff", // has("ie") has("mozilla")
        "./_FormValueWidget",
        "./_TextBoxMixin",
        "dojo/text!./templates/TextBox.html",
        "../main"       // to export dijit._setSelectionRange, remove in 2.0
], function(declare, domConstruct, domStyle, kernel, lang, has,
                        _FormValueWidget, _TextBoxMixin, template, dijit){

        // module:
        //              dijit/form/TextBox

        var TextBox = declare("dijit.form.TextBox", [_FormValueWidget, _TextBoxMixin], {
                // summary:
                //              A base class for textbox form inputs

                templateString: template,
                _singleNodeTemplate: '<input class="dijit dijitReset dijitLeft dijitInputField" data-dojo-attach-point="textbox,focusNode" autocomplete="off" type="${type}" ${!nameAttrSetting} />',

                _buttonInputDisabled: has("ie") ? "disabled" : "", // allows IE to disallow focus, but Firefox cannot be disabled for mousedown events

                baseClass: "dijitTextBox",

                postMixInProperties: function(){
                        var type = this.type.toLowerCase();
                        if(this.templateString && this.templateString.toLowerCase() == "input" || ((type == "hidden" || type == "file") && this.templateString == this.constructor.prototype.templateString)){
                                this.templateString = this._singleNodeTemplate;
                        }
                        this.inherited(arguments);
                },

                postCreate: function(){
                        this.inherited(arguments);

                        if(has("ie") < 9){
                                // IE INPUT tag fontFamily has to be set directly using STYLE
                                // the defer gives IE a chance to render the TextBox and to deal with font inheritance
                                this.defer(function(){
                                        try{
                                                var s = domStyle.getComputedStyle(this.domNode); // can throw an exception if widget is immediately destroyed
                                                if(s){
                                                        var ff = s.fontFamily;
                                                        if(ff){
                                                                var inputs = this.domNode.getElementsByTagName("INPUT");
                                                                if(inputs){
                                                                        for(var i=0; i < inputs.length; i++){
                                                                                inputs[i].style.fontFamily = ff;
                                                                        }
                                                                }
                                                        }
                                                }
                                        }catch(e){/*when used in a Dialog, and this is called before the dialog is
                                         shown, s.fontFamily would trigger "Invalid Argument" error.*/}
                                });
                        }
                },

                _onInput: function(e){
                        this.inherited(arguments);
                        if(this.intermediateChanges){ // _TextBoxMixin uses onInput
                                // allow the key to post to the widget input box
                                this.defer(function(){ this._handleOnChange(this.get('value'), false); });
                        }
                },

                _setPlaceHolderAttr: function(v){
                        this._set("placeHolder", v);
                        if(!this._phspan){
                                this._attachPoints.push('_phspan');
                                // dijitInputField class gives placeHolder same padding as the input field
                                // parent node already has dijitInputField class but it doesn't affect this <span>
                                // since it's position: absolute.
                                this._phspan = domConstruct.create('span',{ onmousedown:function(e){ e.preventDefault(); }, className:'dijitPlaceHolder dijitInputField'},this.textbox,'after');
                        }
                        this._phspan.innerHTML="";
                        this._phspan.appendChild(this._phspan.ownerDocument.createTextNode(v));
                        this._updatePlaceHolder();
                },

                _updatePlaceHolder: function(){
                        if(this._phspan){
                                this._phspan.style.display=(this.placeHolder&&!this.focused&&!this.textbox.value)?"":"none";
                        }
                },

                _setValueAttr: function(value, /*Boolean?*/ priorityChange, /*String?*/ formattedValue){
                        this.inherited(arguments);
                        this._updatePlaceHolder();
                },

                getDisplayedValue: function(){
                        // summary:
                        //              Deprecated.  Use get('displayedValue') instead.
                        // tags:
                        //              deprecated
                        kernel.deprecated(this.declaredClass+"::getDisplayedValue() is deprecated. Use get('displayedValue') instead.", "", "2.0");
                        return this.get('displayedValue');
                },

                setDisplayedValue: function(/*String*/ value){
                        // summary:
                        //              Deprecated.  Use set('displayedValue', ...) instead.
                        // tags:
                        //              deprecated
                        kernel.deprecated(this.declaredClass+"::setDisplayedValue() is deprecated. Use set('displayedValue', ...) instead.", "", "2.0");
                        this.set('displayedValue', value);
                },

                _onBlur: function(e){
                        if(this.disabled){ return; }
                        this.inherited(arguments);
                        this._updatePlaceHolder();

                        if(has("mozilla")){
                                if(this.selectOnClick){
                                        // clear selection so that the next mouse click doesn't reselect
                                        this.textbox.selectionStart = this.textbox.selectionEnd = undefined;
                                }
                        }
                },

                _onFocus: function(/*String*/ by){
                        if(this.disabled || this.readOnly){ return; }
                        this.inherited(arguments);
                        this._updatePlaceHolder();
                }
        });

        if(has("ie")){
                TextBox.prototype._isTextSelected = function(){
                        var range = this.ownerDocument.selection.createRange();
                        var parent = range.parentElement();
                        return parent == this.textbox && range.text.length > 0;
                };

                // Overrides definition of _setSelectionRange from _TextBoxMixin (TODO: move to _TextBoxMixin.js?)
                dijit._setSelectionRange = _TextBoxMixin._setSelectionRange = function(/*DomNode*/ element, /*Number?*/ start, /*Number?*/ stop){
                        if(element.createTextRange){
                                var r = element.createTextRange();
                                r.collapse(true);
                                r.moveStart("character", -99999); // move to 0
                                r.moveStart("character", start); // delta from 0 is the correct position
                                r.moveEnd("character", stop-start);
                                r.select();
                        }
                }
        }

        return TextBox;
});

},
'dijit/_base/scroll':function(){
define("dijit/_base/scroll", [
        "dojo/window", // windowUtils.scrollIntoView
        "../main"       // export symbol to dijit
], function(windowUtils, dijit){
        // module:
        //              dijit/_base/scroll

        /*=====
        return {
                // summary:
                //              Back compatibility module, new code should use windowUtils directly instead of using this module.
        };
        =====*/

        dijit.scrollIntoView = function(/*DomNode*/ node, /*Object?*/ pos){
                // summary:
                //              Scroll the passed node into view, if it is not already.
                //              Deprecated, use `windowUtils.scrollIntoView` instead.

                windowUtils.scrollIntoView(node, pos);
        };
});

},
'dijit/_TemplatedMixin':function(){
define("dijit/_TemplatedMixin", [
        "dojo/_base/lang", // lang.getObject
        "dojo/touch",
        "./_WidgetBase",
        "dojo/string", // string.substitute string.trim
        "dojo/cache",   // dojo.cache
        "dojo/_base/array", // array.forEach
        "dojo/_base/declare", // declare
        "dojo/dom-construct", // domConstruct.destroy, domConstruct.toDom
        "dojo/sniff", // has("ie")
        "dojo/_base/unload" // unload.addOnWindowUnload
], function(lang, touch, _WidgetBase, string, cache, array, declare, domConstruct, has, unload) {

        // module:
        //              dijit/_TemplatedMixin

        var _TemplatedMixin = declare("dijit._TemplatedMixin", null, {
                // summary:
                //              Mixin for widgets that are instantiated from a template

                // templateString: [protected] String
                //              A string that represents the widget template.
                //              Use in conjunction with dojo.cache() to load from a file.
                templateString: null,

                // templatePath: [protected deprecated] String
                //              Path to template (HTML file) for this widget relative to dojo.baseUrl.
                //              Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
                templatePath: null,

                // skipNodeCache: [protected] Boolean
                //              If using a cached widget template nodes poses issues for a
                //              particular widget class, it can set this property to ensure
                //              that its template is always re-built from a string
                _skipNodeCache: false,

                // _earlyTemplatedStartup: Boolean
                //              A fallback to preserve the 1.0 - 1.3 behavior of children in
                //              templates having their startup called before the parent widget
                //              fires postCreate. Defaults to 'false', causing child widgets to
                //              have their .startup() called immediately before a parent widget
                //              .startup(), but always after the parent .postCreate(). Set to
                //              'true' to re-enable to previous, arguably broken, behavior.
                _earlyTemplatedStartup: false,

/*=====
                // _attachPoints: [private] String[]
                //              List of widget attribute names associated with data-dojo-attach-point=... in the
                //              template, ex: ["containerNode", "labelNode"]
                _attachPoints: [],

                // _attachEvents: [private] Handle[]
                //              List of connections associated with data-dojo-attach-event=... in the
                //              template
                _attachEvents: [],
 =====*/

                constructor: function(/*===== params, srcNodeRef =====*/){
                        // summary:
                        //              Create the widget.
                        // params: Object|null
                        //              Hash of initialization parameters for widget, including scalar values (like title, duration etc.)
                        //              and functions, typically callbacks like onClick.
                        //              The hash can contain any of the widget's properties, excluding read-only properties.
                        // srcNodeRef: DOMNode|String?
                        //              If a srcNodeRef (DOM node) is specified, replace srcNodeRef with my generated DOM tree.

                        this._attachPoints = [];
                        this._attachEvents = [];
                },

                _stringRepl: function(tmpl){
                        // summary:
                        //              Does substitution of ${foo} type properties in template string
                        // tags:
                        //              private
                        var className = this.declaredClass, _this = this;
                        // Cache contains a string because we need to do property replacement
                        // do the property replacement
                        return string.substitute(tmpl, this, function(value, key){
                                if(key.charAt(0) == '!'){ value = lang.getObject(key.substr(1), false, _this); }
                                if(typeof value == "undefined"){ throw new Error(className+" template:"+key); } // a debugging aide
                                if(value == null){ return ""; }

                                // Substitution keys beginning with ! will skip the transform step,
                                // in case a user wishes to insert unescaped markup, e.g. ${!foo}
                                return key.charAt(0) == "!" ? value :
                                        // Safer substitution, see heading "Attribute values" in
                                        // http://www.w3.org/TR/REC-html40/appendix/notes.html#h-B.3.2
                                        value.toString().replace(/"/g,"&quot;"); //TODO: add &amp? use encodeXML method?
                        }, this);
                },

                buildRendering: function(){
                        // summary:
                        //              Construct the UI for this widget from a template, setting this.domNode.
                        // tags:
                        //              protected

                        if(!this.templateString){
                                this.templateString = cache(this.templatePath, {sanitize: true});
                        }

                        // Lookup cached version of template, and download to cache if it
                        // isn't there already.  Returns either a DomNode or a string, depending on
                        // whether or not the template contains ${foo} replacement parameters.
                        var cached = _TemplatedMixin.getCachedTemplate(this.templateString, this._skipNodeCache, this.ownerDocument);

                        var node;
                        if(lang.isString(cached)){
                                node = domConstruct.toDom(this._stringRepl(cached), this.ownerDocument);
                                if(node.nodeType != 1){
                                        // Flag common problems such as templates with multiple top level nodes (nodeType == 11)
                                        throw new Error("Invalid template: " + cached);
                                }
                        }else{
                                // if it's a node, all we have to do is clone it
                                node = cached.cloneNode(true);
                        }

                        this.domNode = node;

                        // Call down to _Widget.buildRendering() to get base classes assigned
                        // TODO: change the baseClass assignment to _setBaseClassAttr
                        this.inherited(arguments);

                        // recurse through the node, looking for, and attaching to, our
                        // attachment points and events, which should be defined on the template node.
                        this._attachTemplateNodes(node, function(n,p){ return n.getAttribute(p); });

                        this._beforeFillContent();              // hook for _WidgetsInTemplateMixin

                        this._fillContent(this.srcNodeRef);
                },

                _beforeFillContent: function(){
                },

                _fillContent: function(/*DomNode*/ source){
                        // summary:
                        //              Relocate source contents to templated container node.
                        //              this.containerNode must be able to receive children, or exceptions will be thrown.
                        // tags:
                        //              protected
                        var dest = this.containerNode;
                        if(source && dest){
                                while(source.hasChildNodes()){
                                        dest.appendChild(source.firstChild);
                                }
                        }
                },

                _attachTemplateNodes: function(rootNode, getAttrFunc){
                        // summary:
                        //              Iterate through the template and attach functions and nodes accordingly.
                        //              Alternately, if rootNode is an array of widgets, then will process data-dojo-attach-point
                        //              etc. for those widgets.
                        // description:
                        //              Map widget properties and functions to the handlers specified in
                        //              the dom node and it's descendants. This function iterates over all
                        //              nodes and looks for these properties:
                        //
                        //              - dojoAttachPoint/data-dojo-attach-point
                        //              - dojoAttachEvent/data-dojo-attach-event
                        // rootNode: DomNode|Widget[]
                        //              the node to search for properties. All children will be searched.
                        // getAttrFunc: Function
                        //              a function which will be used to obtain property for a given
                        //              DomNode/Widget
                        // tags:
                        //              private

                        var nodes = lang.isArray(rootNode) ? rootNode : (rootNode.all || rootNode.getElementsByTagName("*"));
                        var x = lang.isArray(rootNode) ? 0 : -1;
                        for(; x < 0 || nodes[x]; x++){  // don't access nodes.length on IE, see #14346
                                var baseNode = (x == -1) ? rootNode : nodes[x];
                                if(this.widgetsInTemplate && (getAttrFunc(baseNode, "dojoType") || getAttrFunc(baseNode, "data-dojo-type"))){
                                        continue;
                                }
                                // Process data-dojo-attach-point
                                var attachPoint = getAttrFunc(baseNode, "dojoAttachPoint") || getAttrFunc(baseNode, "data-dojo-attach-point");
                                if(attachPoint){
                                        var point, points = attachPoint.split(/\s*,\s*/);
                                        while((point = points.shift())){
                                                if(lang.isArray(this[point])){
                                                        this[point].push(baseNode);
                                                }else{
                                                        this[point]=baseNode;
                                                }
                                                this._attachPoints.push(point);
                                        }
                                }

                                // Process data-dojo-attach-event
                                var attachEvent = getAttrFunc(baseNode, "dojoAttachEvent") || getAttrFunc(baseNode, "data-dojo-attach-event");
                                if(attachEvent){
                                        // NOTE: we want to support attributes that have the form
                                        // "domEvent: nativeEvent; ..."
                                        var event, events = attachEvent.split(/\s*,\s*/);
                                        var trim = lang.trim;
                                        while((event = events.shift())){
                                                if(event){
                                                        var thisFunc = null;
                                                        if(event.indexOf(":") != -1){
                                                                // oh, if only JS had tuple assignment
                                                                var funcNameArr = event.split(":");
                                                                event = trim(funcNameArr[0]);
                                                                thisFunc = trim(funcNameArr[1]);
                                                        }else{
                                                                event = trim(event);
                                                        }
                                                        if(!thisFunc){
                                                                thisFunc = event;
                                                        }
                                                        // Map "press", "move" and "release" to keys.touch, keys.move, keys.release
                                                        this._attachEvents.push(this.connect(baseNode, touch[event] || event, thisFunc));
                                                }
                                        }
                                }
                        }
                },

                destroyRendering: function(){
                        // Delete all attach points to prevent IE6 memory leaks.
                        array.forEach(this._attachPoints, function(point){
                                delete this[point];
                        }, this);
                        this._attachPoints = [];

                        // And same for event handlers
                        array.forEach(this._attachEvents, this.disconnect, this);
                        this._attachEvents = [];

                        this.inherited(arguments);
                }
        });

        // key is templateString; object is either string or DOM tree
        _TemplatedMixin._templateCache = {};

        _TemplatedMixin.getCachedTemplate = function(templateString, alwaysUseString, doc){
                // summary:
                //              Static method to get a template based on the templatePath or
                //              templateString key
                // templateString: String
                //              The template
                // alwaysUseString: Boolean
                //              Don't cache the DOM tree for this template, even if it doesn't have any variables
                // doc: Document?
                //              The target document.   Defaults to document global if unspecified.
                // returns: Mixed
                //              Either string (if there are ${} variables that need to be replaced) or just
                //              a DOM tree (if the node can be cloned directly)

                // is it already cached?
                var tmplts = _TemplatedMixin._templateCache;
                var key = templateString;
                var cached = tmplts[key];
                if(cached){
                        try{
                                // if the cached value is an innerHTML string (no ownerDocument) or a DOM tree created within the
                                // current document, then use the current cached value
                                if(!cached.ownerDocument || cached.ownerDocument == (doc || document)){
                                        // string or node of the same document
                                        return cached;
                                }
                        }catch(e){ /* squelch */ } // IE can throw an exception if cached.ownerDocument was reloaded
                        domConstruct.destroy(cached);
                }

                templateString = string.trim(templateString);

                if(alwaysUseString || templateString.match(/\$\{([^\}]+)\}/g)){
                        // there are variables in the template so all we can do is cache the string
                        return (tmplts[key] = templateString); //String
                }else{
                        // there are no variables in the template so we can cache the DOM tree
                        var node = domConstruct.toDom(templateString, doc);
                        if(node.nodeType != 1){
                                throw new Error("Invalid template: " + templateString);
                        }
                        return (tmplts[key] = node); //Node
                }
        };

        if(has("ie")){
                unload.addOnWindowUnload(function(){
                        var cache = _TemplatedMixin._templateCache;
                        for(var key in cache){
                                var value = cache[key];
                                if(typeof value == "object"){ // value is either a string or a DOM node template
                                        domConstruct.destroy(value);
                                }
                                delete cache[key];
                        }
                });
        }

        // These arguments can be specified for widgets which are used in templates.
        // Since any widget can be specified as sub widgets in template, mix it
        // into the base widget class.  (This is a hack, but it's effective.).
        // Remove for 2.0.   Also, hide from API doc parser.
        lang.extend(_WidgetBase, /*===== {} || =====*/ {
                dojoAttachEvent: "",
                dojoAttachPoint: ""
        });

        return _TemplatedMixin;
});

},
'dijit/_CssStateMixin':function(){
define("dijit/_CssStateMixin", [
        "dojo/_base/array", // array.forEach array.map
        "dojo/_base/declare",   // declare
        "dojo/dom",                     // dom.isDescendant()
        "dojo/dom-class", // domClass.toggle
        "dojo/has",
        "dojo/_base/lang", // lang.hitch
        "dojo/on",
        "dojo/ready",
        "dojo/_base/window", // win.body
        "./registry"
], function(array, declare, dom, domClass, has, lang, on, ready, win, registry){

// module:
//              dijit/_CssStateMixin

var CssStateMixin = declare("dijit._CssStateMixin", [], {
        // summary:
        //              Mixin for widgets to set CSS classes on the widget DOM nodes depending on hover/mouse press/focus
        //              state changes, and also higher-level state changes such becoming disabled or selected.
        //
        // description:
        //              By mixing this class into your widget, and setting the this.baseClass attribute, it will automatically
        //              maintain CSS classes on the widget root node (this.domNode) depending on hover,
        //              active, focus, etc. state.   Ex: with a baseClass of dijitButton, it will apply the classes
        //              dijitButtonHovered and dijitButtonActive, as the user moves the mouse over the widget and clicks it.
        //
        //              It also sets CSS like dijitButtonDisabled based on widget semantic state.
        //
        //              By setting the cssStateNodes attribute, a widget can also track events on subnodes (like buttons
        //              within the widget).

        // cssStateNodes: [protected] Object
        //              List of sub-nodes within the widget that need CSS classes applied on mouse hover/press and focus
        //
        //              Each entry in the hash is a an attachpoint names (like "upArrowButton") mapped to a CSS class names
        //              (like "dijitUpArrowButton"). Example:
        //      |               {
        //      |                       "upArrowButton": "dijitUpArrowButton",
        //      |                       "downArrowButton": "dijitDownArrowButton"
        //      |               }
        //              The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
        //              is hovered, etc.
        cssStateNodes: {},

        // hovering: [readonly] Boolean
        //              True if cursor is over this widget
        hovering: false,

        // active: [readonly] Boolean
        //              True if mouse was pressed while over this widget, and hasn't been released yet
        active: false,

        _applyAttributes: function(){
                // This code would typically be in postCreate(), but putting in _applyAttributes() for
                // performance: so the class changes happen before DOM is inserted into the document.
                // Change back to postCreate() in 2.0.  See #11635.

                this.inherited(arguments);

                // Monitoring changes to disabled, readonly, etc. state, and update CSS class of root node
                array.forEach(["disabled", "readOnly", "checked", "selected", "focused", "state", "hovering", "active", "_opened"], function(attr){
                        this.watch(attr, lang.hitch(this, "_setStateClass"));
                }, this);

                // Track hover and active mouse events on widget root node, plus possibly on subnodes
                for(var ap in this.cssStateNodes){
                        this._trackMouseState(this[ap], this.cssStateNodes[ap]);
                }
                this._trackMouseState(this.domNode, this.baseClass);

                // Set state initially; there's probably no hover/active/focus state but widget might be
                // disabled/readonly/checked/selected so we want to set CSS classes for those conditions.
                this._setStateClass();
        },

        _cssMouseEvent: function(/*Event*/ event){
                // summary:
                //              Handler for CSS event on this.domNode. Sets hovering and active properties depending on mouse state,
                //              which triggers _setStateClass() to set appropriate CSS classes for this.domNode.

                if(!this.disabled){
                        switch(event.type){
                                case "mouseover":
                                        this._set("hovering", true);
                                        this._set("active", this._mouseDown);
                                        break;
                                case "mouseout":
                                        this._set("hovering", false);
                                        this._set("active", false);
                                        break;
                                case "mousedown":
                                case "touchstart":
                                        this._set("active", true);
                                        break;
                                case "mouseup":
                                case "touchend":
                                        this._set("active", false);
                                        break;
                        }
                }
        },

        _setStateClass: function(){
                // summary:
                //              Update the visual state of the widget by setting the css classes on this.domNode
                //              (or this.stateNode if defined) by combining this.baseClass with
                //              various suffixes that represent the current widget state(s).
                //
                // description:
                //              In the case where a widget has multiple
                //              states, it sets the class based on all possible
                //              combinations.  For example, an invalid form widget that is being hovered
                //              will be "dijitInput dijitInputInvalid dijitInputHover dijitInputInvalidHover".
                //
                //              The widget may have one or more of the following states, determined
                //              by this.state, this.checked, this.valid, and this.selected:
                //
                //              - Error - ValidationTextBox sets this.state to "Error" if the current input value is invalid
                //              - Incomplete - ValidationTextBox sets this.state to "Incomplete" if the current input value is not finished yet
                //              - Checked - ex: a checkmark or a ToggleButton in a checked state, will have this.checked==true
                //              - Selected - ex: currently selected tab will have this.selected==true
                //
                //              In addition, it may have one or more of the following states,
                //              based on this.disabled and flags set in _onMouse (this.active, this.hovering) and from focus manager (this.focused):
                //
                //              - Disabled      - if the widget is disabled
                //              - Active                - if the mouse (or space/enter key?) is being pressed down
                //              - Focused               - if the widget has focus
                //              - Hover         - if the mouse is over the widget

                // Compute new set of classes
                var newStateClasses = this.baseClass.split(" ");

                function multiply(modifier){
                        newStateClasses = newStateClasses.concat(array.map(newStateClasses, function(c){ return c+modifier; }), "dijit"+modifier);
                }

                if(!this.isLeftToRight()){
                        // For RTL mode we need to set an addition class like dijitTextBoxRtl.
                        multiply("Rtl");
                }

                var checkedState = this.checked == "mixed" ? "Mixed" : (this.checked ? "Checked" : "");
                if(this.checked){
                        multiply(checkedState);
                }
                if(this.state){
                        multiply(this.state);
                }
                if(this.selected){
                        multiply("Selected");
                }
                if(this._opened){
                        multiply("Opened");
                }

                if(this.disabled){
                        multiply("Disabled");
                }else if(this.readOnly){
                        multiply("ReadOnly");
                }else{
                        if(this.active){
                                multiply("Active");
                        }else if(this.hovering){
                                multiply("Hover");
                        }
                }

                if(this.focused){
                        multiply("Focused");
                }

                // Remove old state classes and add new ones.
                // For performance concerns we only write into domNode.className once.
                var tn = this.stateNode || this.domNode,
                        classHash = {}; // set of all classes (state and otherwise) for node

                array.forEach(tn.className.split(" "), function(c){ classHash[c] = true; });

                if("_stateClasses" in this){
                        array.forEach(this._stateClasses, function(c){ delete classHash[c]; });
                }

                array.forEach(newStateClasses, function(c){ classHash[c] = true; });

                var newClasses = [];
                for(var c in classHash){
                        newClasses.push(c);
                }
                tn.className = newClasses.join(" ");

                this._stateClasses = newStateClasses;
        },

        _subnodeCssMouseEvent: function(node, clazz, evt){
                // summary:
                //              Handler for hover/active mouse event on widget's subnode
                if(this.disabled || this.readOnly){
                        return;
                }
                function hover(isHovering){
                        domClass.toggle(node, clazz+"Hover", isHovering);
                }
                function active(isActive){
                        domClass.toggle(node, clazz+"Active", isActive);
                }
                function focused(isFocused){
                        domClass.toggle(node, clazz+"Focused", isFocused);
                }
                switch(evt.type){
                        case "mouseover":
                                hover(true);
                                break;
                        case "mouseout":
                                hover(false);
                                active(false);
                                break;
                        case "mousedown":
                        case "touchstart":
                                active(true);
                                break;
                        case "mouseup":
                        case "touchend":
                                active(false);
                                break;
                        case "focus":
                        case "focusin":
                                focused(true);
                                break;
                        case "blur":
                        case "focusout":
                                focused(false);
                                break;
                }
        },

        _trackMouseState: function(/*DomNode*/ node, /*String*/ clazz){
                // summary:
                //              Track mouse/focus events on specified node and set CSS class on that node to indicate
                //              current state.   Usually not called directly, but via cssStateNodes attribute.
                // description:
                //              Given class=foo, will set the following CSS class on the node
                //
                //              - fooActive: if the user is currently pressing down the mouse button while over the node
                //              - fooHover: if the user is hovering the mouse over the node, but not pressing down a button
                //              - fooFocus: if the node is focused
                //
                //              Note that it won't set any classes if the widget is disabled.
                // node: DomNode
                //              Should be a sub-node of the widget, not the top node (this.domNode), since the top node
                //              is handled specially and automatically just by mixing in this class.
                // clazz: String
                //              CSS class name (ex: dijitSliderUpArrow)

                // Flag for listener code below to call this._cssMouseEvent() or this._subnodeCssMouseEvent()
                // when node is hovered/active
                node._cssState = clazz;
        }
});

ready(function(){
        // Document level listener to catch hover etc. events on widget root nodes and subnodes.
        // Note that when the mouse is moved quickly, a single onmouseenter event could signal that multiple widgets
        // have been hovered or unhovered (try test_Accordion.html)
        function handler(evt){
                // Poor man's event propagation.  Don't propagate event to ancestors of evt.relatedTarget,
                // to avoid processing mouseout events moving from a widget's domNode to a descendant node;
                // such events shouldn't be interpreted as a mouseleave on the widget.
                if(!dom.isDescendant(evt.relatedTarget, evt.target)){
                        for(var node = evt.target; node && node != evt.relatedTarget; node = node.parentNode){
                                // Process any nodes with _cssState property.   They are generally widget root nodes,
                                // but could also be sub-nodes within a widget
                                if(node._cssState){
                                        var widget = registry.getEnclosingWidget(node);
                                        if(widget){
                                                if(node == widget.domNode){
                                                        // event on the widget's root node
                                                        widget._cssMouseEvent(evt);
                                                }else{
                                                        // event on widget's sub-node
                                                        widget._subnodeCssMouseEvent(node, node._cssState, evt);
                                                }
                                        }
                                }
                        }
                }
        }
        function ieHandler(evt){
                evt.target = evt.srcElement;
                handler(evt);
        }

        // Use addEventListener() (and attachEvent() on IE) to catch the relevant events even if other handlers
        // (on individual nodes) call evt.stopPropagation() or event.stopEvent().
        // Currently typematic.js is doing that, not sure why.
        // Don't monitor mouseover/mouseout on mobile because iOS generates "phantom" mouseover/mouseout events when
        // drag-scrolling, at the point in the viewport where the drag originated.   Test the Tree in api viewer.
        var body = win.body(),
                types = (has("touch") ? [] : ["mouseover", "mouseout"]).concat(["mousedown", "touchstart", "mouseup", "touchend"]);
        array.forEach(types, function(type){
                if(body.addEventListener){
                        body.addEventListener(type, handler, true);     // W3C
                }else{
                        body.attachEvent("on"+type, ieHandler); // IE
                }
        });

        // Track focus events on widget sub-nodes that have been registered via _trackMouseState().
        // However, don't track focus events on the widget root nodes, because focus is tracked via the
        // focus manager (and it's not really tracking focus, but rather tracking that focus is on one of the widget's
        // nodes or a subwidget's node or a popup node, etc.)
        // Remove for 2.0 (if focus CSS needed, just use :focus pseudo-selector).
        on(body, "focusin, focusout", function(evt){
                var node = evt.target;
                if(node._cssState && !node.getAttribute("widgetId")){
                        var widget = registry.getEnclosingWidget(node);
                        widget._subnodeCssMouseEvent(node, node._cssState, evt);
                }
        });
});

return CssStateMixin;
});

},
'dijit/layout/ScrollingTabController':function(){
require({cache:{
'url:dijit/layout/templates/ScrollingTabController.html':"<div class=\"dijitTabListContainer-${tabPosition}\" style=\"visibility:hidden\">\n\t<div data-dojo-type=\"dijit.layout._ScrollingTabControllerMenuButton\"\n\t\t\tclass=\"tabStripButton-${tabPosition}\"\n\t\t\tid=\"${id}_menuBtn\"\n\t\t\tdata-dojo-props=\"containerId: '${containerId}', iconClass: 'dijitTabStripMenuIcon',\n\t\t\t\t\tdropDownPosition: ['below-alt', 'above-alt']\"\n\t\t\tdata-dojo-attach-point=\"_menuBtn\" showLabel=\"false\" title=\"\">&#9660;</div>\n\t<div data-dojo-type=\"dijit.layout._ScrollingTabControllerButton\"\n\t\t\tclass=\"tabStripButton-${tabPosition}\"\n\t\t\tid=\"${id}_leftBtn\"\n\t\t\tdata-dojo-props=\"iconClass:'dijitTabStripSlideLeftIcon', showLabel:false, title:''\"\n\t\t\tdata-dojo-attach-point=\"_leftBtn\" data-dojo-attach-event=\"onClick: doSlideLeft\">&#9664;</div>\n\t<div data-dojo-type=\"dijit.layout._ScrollingTabControllerButton\"\n\t\t\tclass=\"tabStripButton-${tabPosition}\"\n\t\t\tid=\"${id}_rightBtn\"\n\t\t\tdata-dojo-props=\"iconClass:'dijitTabStripSlideRightIcon', showLabel:false, title:''\"\n\t\t\tdata-dojo-attach-point=\"_rightBtn\" data-dojo-attach-event=\"onClick: doSlideRight\">&#9654;</div>\n\t<div class='dijitTabListWrapper' data-dojo-attach-point='tablistWrapper'>\n\t\t<div role='tablist' data-dojo-attach-event='onkeypress:onkeypress'\n\t\t\t\tdata-dojo-attach-point='containerNode' class='nowrapTabStrip'></div>\n\t</div>\n</div>",
'url:dijit/layout/templates/_ScrollingTabControllerButton.html':"<div data-dojo-attach-event=\"onclick:_onClick\" class=\"dijitTabInnerDiv dijitTabContent dijitButtonContents\"  data-dojo-attach-point=\"focusNode\">\n\t<img role=\"presentation\" alt=\"\" src=\"${_blankGif}\" class=\"dijitTabStripIcon\" data-dojo-attach-point=\"iconNode\"/>\n\t<span data-dojo-attach-point=\"containerNode,titleNode\" class=\"dijitButtonText\"></span>\n</div>"}});
define("dijit/layout/ScrollingTabController", [
        "dojo/_base/array", // array.forEach
        "dojo/_base/declare", // declare
        "dojo/dom-class", // domClass.add domClass.contains
        "dojo/dom-geometry", // domGeometry.contentBox
        "dojo/dom-style", // domStyle.style
        "dojo/_base/fx", // Animation
        "dojo/_base/lang", // lang.hitch
        "dojo/on",
        "dojo/query", // query
        "dojo/sniff", // has("ie"), has("webkit"), has("quirks")
        "../registry",  // registry.byId()
        "dojo/text!./templates/ScrollingTabController.html",
        "dojo/text!./templates/_ScrollingTabControllerButton.html",
        "./TabController",
        "./utils",      // marginBox2contextBox, layoutChildren
        "../_WidgetsInTemplateMixin",
        "../Menu",
        "../MenuItem",
        "../form/Button",
        "../_HasDropDown",
        "dojo/NodeList-dom" // NodeList.style
], function(array, declare, domClass, domGeometry, domStyle, fx, lang, on, query, has,
        registry, tabControllerTemplate, buttonTemplate, TabController, layoutUtils, _WidgetsInTemplateMixin,
        Menu, MenuItem, Button, _HasDropDown){

// module:
//              dijit/layout/ScrollingTabController


var ScrollingTabController = declare("dijit.layout.ScrollingTabController", [TabController, _WidgetsInTemplateMixin], {
        // summary:
        //              Set of tabs with left/right arrow keys and a menu to switch between tabs not
        //              all fitting on a single row.
        //              Works only for horizontal tabs (either above or below the content, not to the left
        //              or right).
        // tags:
        //              private

        baseClass: "dijitTabController dijitScrollingTabController",

        templateString: tabControllerTemplate,

        // useMenu: [const] Boolean
        //              True if a menu should be used to select tabs when they are too
        //              wide to fit the TabContainer, false otherwise.
        useMenu: true,

        // useSlider: [const] Boolean
        //              True if a slider should be used to select tabs when they are too
        //              wide to fit the TabContainer, false otherwise.
        useSlider: true,

        // tabStripClass: [const] String
        //              The css class to apply to the tab strip, if it is visible.
        tabStripClass: "",

        widgetsInTemplate: true,

        // _minScroll: Number
        //              The distance in pixels from the edge of the tab strip which,
        //              if a scroll animation is less than, forces the scroll to
        //              go all the way to the left/right.
        _minScroll: 5,

        // Override default behavior mapping class to DOMNode
        _setClassAttr: { node: "containerNode", type: "class" },

        buildRendering: function(){
                this.inherited(arguments);
                var n = this.domNode;

                this.scrollNode = this.tablistWrapper;
                this._initButtons();

                if(!this.tabStripClass){
                        this.tabStripClass = "dijitTabContainer" +
                                this.tabPosition.charAt(0).toUpperCase() +
                                this.tabPosition.substr(1).replace(/-.*/, "") +
                                "None";
                        domClass.add(n, "tabStrip-disabled")
                }

                domClass.add(this.tablistWrapper, this.tabStripClass);
        },

        onStartup: function(){
                this.inherited(arguments);

                // TabController is hidden until it finishes drawing, to give
                // a less visually jumpy instantiation.   When it's finished, set visibility to ""
                // to that the tabs are hidden/shown depending on the container's visibility setting.
                domStyle.set(this.domNode, "visibility", "");
                this._postStartup = true;

                // changes to the tab button label or iconClass will have changed the width of the
                // buttons, so do a resize
                this.own(on(this.containerNode, "attrmodified-label, attrmodified-iconclass", lang.hitch(this, function(evt){
                        if(this._dim){
                                this.resize(this._dim);
                        }
                })));
        },

        onAddChild: function(page, insertIndex){
                this.inherited(arguments);

                // Increment the width of the wrapper when a tab is added
                // This makes sure that the buttons never wrap.
                // The value 200 is chosen as it should be bigger than most
                // Tab button widths.
                domStyle.set(this.containerNode, "width",
                        (domStyle.get(this.containerNode, "width") + 200) + "px");
        },

        onRemoveChild: function(page, insertIndex){
                // null out _selectedTab because we are about to delete that dom node
                var button = this.pane2button[page.id];
                if(this._selectedTab === button.domNode){
                        this._selectedTab = null;
                }

                this.inherited(arguments);
        },

        _initButtons: function(){
                // summary:
                //              Creates the buttons used to scroll to view tabs that
                //              may not be visible if the TabContainer is too narrow.

                // Make a list of the buttons to display when the tab labels become
                // wider than the TabContainer, and hide the other buttons.
                // Also gets the total width of the displayed buttons.
                this._btnWidth = 0;
                this._buttons = query("> .tabStripButton", this.domNode).filter(function(btn){
                        if((this.useMenu && btn == this._menuBtn.domNode) ||
                                (this.useSlider && (btn == this._rightBtn.domNode || btn == this._leftBtn.domNode))){
                                this._btnWidth += domGeometry.getMarginSize(btn).w;
                                return true;
                        }else{
                                domStyle.set(btn, "display", "none");
                                return false;
                        }
                }, this);
        },

        _getTabsWidth: function(){
                var children = this.getChildren();
                if(children.length){
                        var leftTab = children[this.isLeftToRight() ? 0 : children.length - 1].domNode,
                                rightTab = children[this.isLeftToRight() ? children.length - 1 : 0].domNode;
                        return rightTab.offsetLeft + rightTab.offsetWidth - leftTab.offsetLeft;
                }else{
                        return 0;
                }
        },

        _enableBtn: function(width){
                // summary:
                //              Determines if the tabs are wider than the width of the TabContainer, and
                //              thus that we need to display left/right/menu navigation buttons.
                var tabsWidth = this._getTabsWidth();
                width = width || domStyle.get(this.scrollNode, "width");
                return tabsWidth > 0 && width < tabsWidth;
        },

        resize: function(dim){
                // summary:
                //              Hides or displays the buttons used to scroll the tab list and launch the menu
                //              that selects tabs.

                // Save the dimensions to be used when a child is renamed.
                this._dim = dim;

                // Set my height to be my natural height (tall enough for one row of tab labels),
                // and my content-box width based on margin-box width specified in dim parameter.
                // But first reset scrollNode.height in case it was set by layoutChildren() call
                // in a previous run of this method.
                this.scrollNode.style.height = "auto";
                var cb = this._contentBox = layoutUtils.marginBox2contentBox(this.domNode, {h: 0, w: dim.w});
                cb.h = this.scrollNode.offsetHeight;
                domGeometry.setContentSize(this.domNode, cb);

                // Show/hide the left/right/menu navigation buttons depending on whether or not they
                // are needed.
                var enable = this._enableBtn(this._contentBox.w);
                this._buttons.style("display", enable ? "" : "none");

                // Position and size the navigation buttons and the tablist
                this._leftBtn.layoutAlign = "left";
                this._rightBtn.layoutAlign = "right";
                this._menuBtn.layoutAlign = this.isLeftToRight() ? "right" : "left";
                layoutUtils.layoutChildren(this.domNode, this._contentBox,
                        [this._menuBtn, this._leftBtn, this._rightBtn, {domNode: this.scrollNode, layoutAlign: "client"}]);

                // set proper scroll so that selected tab is visible
                if(this._selectedTab){
                        if(this._anim && this._anim.status() == "playing"){
                                this._anim.stop();
                        }
                        this.scrollNode.scrollLeft = this._convertToScrollLeft(this._getScrollForSelectedTab());
                }

                // Enable/disabled left right buttons depending on whether or not user can scroll to left or right
                this._setButtonClass(this._getScroll());

                this._postResize = true;

                // Return my size so layoutChildren() can use it.
                // Also avoids IE9 layout glitch on browser resize when scroll buttons present
                return {h: this._contentBox.h, w: dim.w};
        },

        _getScroll: function(){
                // summary:
                //              Returns the current scroll of the tabs where 0 means
                //              "scrolled all the way to the left" and some positive number, based on #
                //              of pixels of possible scroll (ex: 1000) means "scrolled all the way to the right"
                return (this.isLeftToRight() || has("ie") < 8 || (has("ie") && has("quirks")) || has("webkit")) ? this.scrollNode.scrollLeft :
                                domStyle.get(this.containerNode, "width") - domStyle.get(this.scrollNode, "width")
                                         + (has("ie") >= 8 ? -1 : 1) * this.scrollNode.scrollLeft;
        },

        _convertToScrollLeft: function(val){
                // summary:
                //              Given a scroll value where 0 means "scrolled all the way to the left"
                //              and some positive number, based on # of pixels of possible scroll (ex: 1000)
                //              means "scrolled all the way to the right", return value to set this.scrollNode.scrollLeft
                //              to achieve that scroll.
                //
                //              This method is to adjust for RTL funniness in various browsers and versions.
                if(this.isLeftToRight() || has("ie") < 8 || (has("ie") && has("quirks")) || has("webkit")){
                        return val;
                }else{
                        var maxScroll = domStyle.get(this.containerNode, "width") - domStyle.get(this.scrollNode, "width");
                        return (has("ie") >= 8 ? -1 : 1) * (val - maxScroll);
                }
        },

        onSelectChild: function(/*dijit/_WidgetBase*/ page){
                // summary:
                //              Smoothly scrolls to a tab when it is selected.

                var tab = this.pane2button[page.id];
                if(!tab || !page){return;}

                var node = tab.domNode;

                // Save the selection
                if(node != this._selectedTab){
                        this._selectedTab = node;

                        // Scroll to the selected tab, except on startup, when scrolling is handled in resize()
                        if(this._postResize){
                                var sl = this._getScroll();

                                if(sl > node.offsetLeft ||
                                                sl + domStyle.get(this.scrollNode, "width") <
                                                node.offsetLeft + domStyle.get(node, "width")){
                                        this.createSmoothScroll().play();
                                }
                        }
                }

                this.inherited(arguments);
        },

        _getScrollBounds: function(){
                // summary:
                //              Returns the minimum and maximum scroll setting to show the leftmost and rightmost
                //              tabs (respectively)
                var children = this.getChildren(),
                        scrollNodeWidth = domStyle.get(this.scrollNode, "width"),               // about 500px
                        containerWidth = domStyle.get(this.containerNode, "width"),     // 50,000px
                        maxPossibleScroll = containerWidth - scrollNodeWidth,   // scrolling until right edge of containerNode visible
                        tabsWidth = this._getTabsWidth();

                if(children.length && tabsWidth > scrollNodeWidth){
                        // Scrolling should happen
                        return {
                                min: this.isLeftToRight() ? 0 : children[children.length-1].domNode.offsetLeft,
                                max: this.isLeftToRight() ?
                                        (children[children.length-1].domNode.offsetLeft + children[children.length-1].domNode.offsetWidth) - scrollNodeWidth :
                                        maxPossibleScroll
                        };
                }else{
                        // No scrolling needed, all tabs visible, we stay either scrolled to far left or far right (depending on dir)
                        var onlyScrollPosition = this.isLeftToRight() ? 0 : maxPossibleScroll;
                        return {
                                min: onlyScrollPosition,
                                max: onlyScrollPosition
                        };
                }
        },

        _getScrollForSelectedTab: function(){
                // summary:
                //              Returns the scroll value setting so that the selected tab
                //              will appear in the center
                var w = this.scrollNode,
                        n = this._selectedTab,
                        scrollNodeWidth = domStyle.get(this.scrollNode, "width"),
                        scrollBounds = this._getScrollBounds();

                // TODO: scroll minimal amount (to either right or left) so that
                // selected tab is fully visible, and just return if it's already visible?
                var pos = (n.offsetLeft + domStyle.get(n, "width")/2) - scrollNodeWidth/2;
                pos = Math.min(Math.max(pos, scrollBounds.min), scrollBounds.max);

                // TODO:
                // If scrolling close to the left side or right side, scroll
                // all the way to the left or right.  See this._minScroll.
                // (But need to make sure that doesn't scroll the tab out of view...)
                return pos;
        },

        createSmoothScroll: function(x){
                // summary:
                //              Creates a dojo._Animation object that smoothly scrolls the tab list
                //              either to a fixed horizontal pixel value, or to the selected tab.
                // description:
                //              If an number argument is passed to the function, that horizontal
                //              pixel position is scrolled to.  Otherwise the currently selected
                //              tab is scrolled to.
                // x: Integer?
                //              An optional pixel value to scroll to, indicating distance from left.

                // Calculate position to scroll to
                if(arguments.length > 0){
                        // position specified by caller, just make sure it's within bounds
                        var scrollBounds = this._getScrollBounds();
                        x = Math.min(Math.max(x, scrollBounds.min), scrollBounds.max);
                }else{
                        // scroll to center the current tab
                        x = this._getScrollForSelectedTab();
                }

                if(this._anim && this._anim.status() == "playing"){
                        this._anim.stop();
                }

                var self = this,
                        w = this.scrollNode,
                        anim = new fx.Animation({
                                beforeBegin: function(){
                                        if(this.curve){ delete this.curve; }
                                        var oldS = w.scrollLeft,
                                                newS = self._convertToScrollLeft(x);
                                        anim.curve = new fx._Line(oldS, newS);
                                },
                                onAnimate: function(val){
                                        w.scrollLeft = val;
                                }
                        });
                this._anim = anim;

                // Disable/enable left/right buttons according to new scroll position
                this._setButtonClass(x);

                return anim; // dojo/_base/fx/Animation
        },

        _getBtnNode: function(/*Event*/ e){
                // summary:
                //              Gets a button DOM node from a mouse click event.
                // e:
                //              The mouse click event.
                var n = e.target;
                while(n && !domClass.contains(n, "tabStripButton")){
                        n = n.parentNode;
                }
                return n;
        },

        doSlideRight: function(/*Event*/ e){
                // summary:
                //              Scrolls the menu to the right.
                // e:
                //              The mouse click event.
                this.doSlide(1, this._getBtnNode(e));
        },

        doSlideLeft: function(/*Event*/ e){
                // summary:
                //              Scrolls the menu to the left.
                // e:
                //              The mouse click event.
                this.doSlide(-1,this._getBtnNode(e));
        },

        doSlide: function(/*Number*/ direction, /*DomNode*/ node){
                // summary:
                //              Scrolls the tab list to the left or right by 75% of the widget width.
                // direction:
                //              If the direction is 1, the widget scrolls to the right, if it is -1,
                //              it scrolls to the left.

                if(node && domClass.contains(node, "dijitTabDisabled")){return;}

                var sWidth = domStyle.get(this.scrollNode, "width");
                var d = (sWidth * 0.75) * direction;

                var to = this._getScroll() + d;

                this._setButtonClass(to);

                this.createSmoothScroll(to).play();
        },

        _setButtonClass: function(/*Number*/ scroll){
                // summary:
                //              Disables the left scroll button if the tabs are scrolled all the way to the left,
                //              or the right scroll button in the opposite case.
                // scroll: Integer
                //              amount of horizontal scroll

                var scrollBounds = this._getScrollBounds();
                this._leftBtn.set("disabled", scroll <= scrollBounds.min);
                this._rightBtn.set("disabled", scroll >= scrollBounds.max);
        }
});


var ScrollingTabControllerButtonMixin = declare("dijit.layout._ScrollingTabControllerButtonMixin", null, {
        baseClass: "dijitTab tabStripButton",

        templateString: buttonTemplate,

                // Override inherited tabIndex: 0 from dijit/form/Button, because user shouldn't be
                // able to tab to the left/right/menu buttons
        tabIndex: "",

        // Similarly, override FormWidget.isFocusable() because clicking a button shouldn't focus it
        // either (this override avoids focus() call in FormWidget.js)
        isFocusable: function(){ return false; }
});

// Class used in template
declare("dijit.layout._ScrollingTabControllerButton",
        [Button, ScrollingTabControllerButtonMixin]);

// Class used in template
declare(
        "dijit.layout._ScrollingTabControllerMenuButton",
        [Button, _HasDropDown, ScrollingTabControllerButtonMixin],
{
        // id of the TabContainer itself
        containerId: "",

        // -1 so user can't tab into the button, but so that button can still be focused programatically.
        // Because need to move focus to the button (or somewhere) before the menu is hidden or IE6 will crash.
        tabIndex: "-1",

        isLoaded: function(){
                // recreate menu every time, in case the TabContainer's list of children (or their icons/labels) have changed
                return false;
        },

        loadDropDown: function(callback){
                this.dropDown = new Menu({
                        id: this.containerId + "_menu",
                        ownerDocument: this.ownerDocument,
                        dir: this.dir,
                        lang: this.lang,
                        textDir: this.textDir
                });
                var container = registry.byId(this.containerId);
                array.forEach(container.getChildren(), function(page){
                        var menuItem = new MenuItem({
                                id: page.id + "_stcMi",
                                label: page.title,
                                iconClass: page.iconClass,
                                disabled: page.disabled,
                                ownerDocument: this.ownerDocument,
                                dir: page.dir,
                                lang: page.lang,
                                textDir: page.textDir,
                                onClick: function(){
                                        container.selectChild(page);
                                }
                        });
                        this.dropDown.addChild(menuItem);
                }, this);
                callback();
        },

        closeDropDown: function(/*Boolean*/ focus){
                this.inherited(arguments);
                if(this.dropDown){
                        this.dropDown.destroyRecursive();
                        delete this.dropDown;
                }
        }
});

return ScrollingTabController;
});

},
'dijit/DialogUnderlay':function(){
define("dijit/DialogUnderlay", [
        "dojo/_base/declare", // declare
        "dojo/dom-attr", // domAttr.set
        "dojo/window", // winUtils.getBox
        "./_Widget",
        "./_TemplatedMixin",
        "./BackgroundIframe"
], function(declare, domAttr, winUtils, _Widget, _TemplatedMixin, BackgroundIframe){

        // module:
        //              dijit/DialogUnderlay

        return declare("dijit.DialogUnderlay", [_Widget, _TemplatedMixin], {
                // summary:
                //              The component that blocks the screen behind a `dijit.Dialog`
                //
                // description:
                //              A component used to block input behind a `dijit.Dialog`. Only a single
                //              instance of this widget is created by `dijit.Dialog`, and saved as
                //              a reference to be shared between all Dialogs as `dijit._underlay`
                //
                //              The underlay itself can be styled based on and id:
                //      |       #myDialog_underlay { background-color:red; }
                //
                //              In the case of `dijit.Dialog`, this id is based on the id of the Dialog,
                //              suffixed with _underlay.

                // Template has two divs; outer div is used for fade-in/fade-out, and also to hold background iframe.
                // Inner div has opacity specified in CSS file.
                templateString: "<div class='dijitDialogUnderlayWrapper'><div class='dijitDialogUnderlay' data-dojo-attach-point='node'></div></div>",

                // Parameters on creation or updatable later

                // dialogId: String
                //              Id of the dialog.... DialogUnderlay's id is based on this id
                dialogId: "",

                // class: String
                //              This class name is used on the DialogUnderlay node, in addition to dijitDialogUnderlay
                "class": "",

                _setDialogIdAttr: function(id){
                        domAttr.set(this.node, "id", id + "_underlay");
                        this._set("dialogId", id);
                },

                _setClassAttr: function(clazz){
                        this.node.className = "dijitDialogUnderlay " + clazz;
                        this._set("class", clazz);
                },

                postCreate: function(){
                        // summary:
                        //              Append the underlay to the body
                        this.ownerDocumentBody.appendChild(this.domNode);
                },

                layout: function(){
                        // summary:
                        //              Sets the background to the size of the viewport
                        //
                        // description:
                        //              Sets the background to the size of the viewport (rather than the size
                        //              of the document) since we need to cover the whole browser window, even
                        //              if the document is only a few lines long.
                        // tags:
                        //              private

                        var is = this.node.style,
                                os = this.domNode.style;

                        // hide the background temporarily, so that the background itself isn't
                        // causing scrollbars to appear (might happen when user shrinks browser
                        // window and then we are called to resize)
                        os.display = "none";

                        // then resize and show
                        var viewport = winUtils.getBox(this.ownerDocument);
                        os.top = viewport.t + "px";
                        os.left = viewport.l + "px";
                        is.width = viewport.w + "px";
                        is.height = viewport.h + "px";
                        os.display = "block";
                },

                show: function(){
                        // summary:
                        //              Show the dialog underlay
                        this.domNode.style.display = "block";
                        this.layout();
                        this.bgIframe = new BackgroundIframe(this.domNode);
                },

                hide: function(){
                        // summary:
                        //              Hides the dialog underlay
                        this.bgIframe.destroy();
                        delete this.bgIframe;
                        this.domNode.style.display = "none";
                }
        });
});

},
'dijit/place':function(){
define("dijit/place", [
        "dojo/_base/array", // array.forEach array.map array.some
        "dojo/dom-geometry", // domGeometry.position
        "dojo/dom-style", // domStyle.getComputedStyle
        "dojo/_base/kernel", // kernel.deprecated
        "dojo/_base/window", // win.body
        "dojo/window", // winUtils.getBox
        "./main"        // dijit (defining dijit.place to match API doc)
], function(array, domGeometry, domStyle, kernel, win, winUtils, dijit){

        // module:
        //              dijit/place


        function _place(/*DomNode*/ node, choices, layoutNode, aroundNodeCoords){
                // summary:
                //              Given a list of spots to put node, put it at the first spot where it fits,
                //              of if it doesn't fit anywhere then the place with the least overflow
                // choices: Array
                //              Array of elements like: {corner: 'TL', pos: {x: 10, y: 20} }
                //              Above example says to put the top-left corner of the node at (10,20)
                // layoutNode: Function(node, aroundNodeCorner, nodeCorner, size)
                //              for things like tooltip, they are displayed differently (and have different dimensions)
                //              based on their orientation relative to the parent.       This adjusts the popup based on orientation.
                //              It also passes in the available size for the popup, which is useful for tooltips to
                //              tell them that their width is limited to a certain amount.       layoutNode() may return a value expressing
                //              how much the popup had to be modified to fit into the available space.   This is used to determine
                //              what the best placement is.
                // aroundNodeCoords: Object
                //              Size of aroundNode, ex: {w: 200, h: 50}

                // get {x: 10, y: 10, w: 100, h:100} type obj representing position of
                // viewport over document
                var view = winUtils.getBox(node.ownerDocument);

                // This won't work if the node is inside a <div style="position: relative">,
                // so reattach it to win.doc.body.       (Otherwise, the positioning will be wrong
                // and also it might get cutoff)
                if(!node.parentNode || String(node.parentNode.tagName).toLowerCase() != "body"){
                        win.body(node.ownerDocument).appendChild(node);
                }

                var best = null;
                array.some(choices, function(choice){
                        var corner = choice.corner;
                        var pos = choice.pos;
                        var overflow = 0;

                        // calculate amount of space available given specified position of node
                        var spaceAvailable = {
                                w: {
                                        'L': view.l + view.w - pos.x,
                                        'R': pos.x - view.l,
                                        'M': view.w
                                   }[corner.charAt(1)],
                                h: {
                                        'T': view.t + view.h - pos.y,
                                        'B': pos.y - view.t,
                                        'M': view.h
                                   }[corner.charAt(0)]
                        };

                        // Clear left/right position settings set earlier so they don't interfere with calculations,
                        // specifically when layoutNode() (a.k.a. Tooltip.orient()) measures natural width of Tooltip
                        var s = node.style;
                        s.left = s.right = "auto";

                        // configure node to be displayed in given position relative to button
                        // (need to do this in order to get an accurate size for the node, because
                        // a tooltip's size changes based on position, due to triangle)
                        if(layoutNode){
                                var res = layoutNode(node, choice.aroundCorner, corner, spaceAvailable, aroundNodeCoords);
                                overflow = typeof res == "undefined" ? 0 : res;
                        }

                        // get node's size
                        var style = node.style;
                        var oldDisplay = style.display;
                        var oldVis = style.visibility;
                        if(style.display == "none"){
                                style.visibility = "hidden";
                                style.display = "";
                        }
                        var bb = domGeometry.position(node);
                        style.display = oldDisplay;
                        style.visibility = oldVis;

                        // coordinates and size of node with specified corner placed at pos,
                        // and clipped by viewport
                        var
                                startXpos = {
                                        'L': pos.x,
                                        'R': pos.x - bb.w,
                                        'M': Math.max(view.l, Math.min(view.l + view.w, pos.x + (bb.w >> 1)) - bb.w) // M orientation is more flexible
                                }[corner.charAt(1)],
                                startYpos = {
                                        'T': pos.y,
                                        'B': pos.y - bb.h,
                                        'M': Math.max(view.t, Math.min(view.t + view.h, pos.y + (bb.h >> 1)) - bb.h)
                                }[corner.charAt(0)],
                                startX = Math.max(view.l, startXpos),
                                startY = Math.max(view.t, startYpos),
                                endX = Math.min(view.l + view.w, startXpos + bb.w),
                                endY = Math.min(view.t + view.h, startYpos + bb.h),
                                width = endX - startX,
                                height = endY - startY;

                        overflow += (bb.w - width) + (bb.h - height);

                        if(best == null || overflow < best.overflow){
                                best = {
                                        corner: corner,
                                        aroundCorner: choice.aroundCorner,
                                        x: startX,
                                        y: startY,
                                        w: width,
                                        h: height,
                                        overflow: overflow,
                                        spaceAvailable: spaceAvailable
                                };
                        }

                        return !overflow;
                });

                // In case the best position is not the last one we checked, need to call
                // layoutNode() again.
                if(best.overflow && layoutNode){
                        layoutNode(node, best.aroundCorner, best.corner, best.spaceAvailable, aroundNodeCoords);
                }

                // And then position the node.  Do this last, after the layoutNode() above
                // has sized the node, due to browser quirks when the viewport is scrolled
                // (specifically that a Tooltip will shrink to fit as though the window was
                // scrolled to the left).
                //
                // In RTL mode, set style.right rather than style.left so in the common case,
                // window resizes move the popup along with the aroundNode.
                var l = domGeometry.isBodyLtr(node.ownerDocument),
                        s = node.style;
                s.top = best.y + "px";
                s[l ? "left" : "right"] = (l ? best.x : view.w - best.x - best.w) + "px";
                s[l ? "right" : "left"] = "auto";       // needed for FF or else tooltip goes to far left

                return best;
        }

        var place = {
                // summary:
                //              Code to place a DOMNode relative to another DOMNode.
                //              Load using require(["dijit/place"], function(place){ ... }).

                at: function(node, pos, corners, padding){
                        // summary:
                        //              Positions one of the node's corners at specified position
                        //              such that node is fully visible in viewport.
                        // description:
                        //              NOTE: node is assumed to be absolutely or relatively positioned.
                        // node: DOMNode
                        //              The node to position
                        // pos: dijit/place.__Position
                        //              Object like {x: 10, y: 20}
                        // corners: String[]
                        //              Array of Strings representing order to try corners in, like ["TR", "BL"].
                        //              Possible values are:
                        //
                        //              - "BL" - bottom left
                        //              - "BR" - bottom right
                        //              - "TL" - top left
                        //              - "TR" - top right
                        // padding: dijit/place.__Position?
                        //              optional param to set padding, to put some buffer around the element you want to position.
                        // example:
                        //              Try to place node's top right corner at (10,20).
                        //              If that makes node go (partially) off screen, then try placing
                        //              bottom left corner at (10,20).
                        //      |       place(node, {x: 10, y: 20}, ["TR", "BL"])
                        var choices = array.map(corners, function(corner){
                                var c = { corner: corner, pos: {x:pos.x,y:pos.y} };
                                if(padding){
                                        c.pos.x += corner.charAt(1) == 'L' ? padding.x : -padding.x;
                                        c.pos.y += corner.charAt(0) == 'T' ? padding.y : -padding.y;
                                }
                                return c;
                        });

                        return _place(node, choices);
                },

                around: function(
                        /*DomNode*/             node,
                        /*DomNode|dijit/place.__Rectangle*/ anchor,
                        /*String[]*/    positions,
                        /*Boolean*/             leftToRight,
                        /*Function?*/   layoutNode){

                        // summary:
                        //              Position node adjacent or kitty-corner to anchor
                        //              such that it's fully visible in viewport.
                        // description:
                        //              Place node such that corner of node touches a corner of
                        //              aroundNode, and that node is fully visible.
                        // anchor:
                        //              Either a DOMNode or a rectangle (object with x, y, width, height).
                        // positions:
                        //              Ordered list of positions to try matching up.
                        //
                        //              - before: places drop down to the left of the anchor node/widget, or to the right in the case
                        //                      of RTL scripts like Hebrew and Arabic; aligns either the top of the drop down
                        //                      with the top of the anchor, or the bottom of the drop down with bottom of the anchor.
                        //              - after: places drop down to the right of the anchor node/widget, or to the left in the case
                        //                      of RTL scripts like Hebrew and Arabic; aligns either the top of the drop down
                        //                      with the top of the anchor, or the bottom of the drop down with bottom of the anchor.
                        //              - before-centered: centers drop down to the left of the anchor node/widget, or to the right
                        //                       in the case of RTL scripts like Hebrew and Arabic
                        //              - after-centered: centers drop down to the right of the anchor node/widget, or to the left
                        //                       in the case of RTL scripts like Hebrew and Arabic
                        //              - above-centered: drop down is centered above anchor node
                        //              - above: drop down goes above anchor node, left sides aligned
                        //              - above-alt: drop down goes above anchor node, right sides aligned
                        //              - below-centered: drop down is centered above anchor node
                        //              - below: drop down goes below anchor node
                        //              - below-alt: drop down goes below anchor node, right sides aligned
                        // layoutNode: Function(node, aroundNodeCorner, nodeCorner)
                        //              For things like tooltip, they are displayed differently (and have different dimensions)
                        //              based on their orientation relative to the parent.       This adjusts the popup based on orientation.
                        // leftToRight:
                        //              True if widget is LTR, false if widget is RTL.   Affects the behavior of "above" and "below"
                        //              positions slightly.
                        // example:
                        //      |       placeAroundNode(node, aroundNode, {'BL':'TL', 'TR':'BR'});
                        //              This will try to position node such that node's top-left corner is at the same position
                        //              as the bottom left corner of the aroundNode (ie, put node below
                        //              aroundNode, with left edges aligned).   If that fails it will try to put
                        //              the bottom-right corner of node where the top right corner of aroundNode is
                        //              (ie, put node above aroundNode, with right edges aligned)
                        //

                        // if around is a DOMNode (or DOMNode id), convert to coordinates
                        var aroundNodePos = (typeof anchor == "string" || "offsetWidth" in anchor)
                                ? domGeometry.position(anchor, true)
                                : anchor;

                        // Compute position and size of visible part of anchor (it may be partially hidden by ancestor nodes w/scrollbars)
                        if(anchor.parentNode){
                                // ignore nodes between position:relative and position:absolute
                                var sawPosAbsolute = domStyle.getComputedStyle(anchor).position == "absolute";
                                var parent = anchor.parentNode;
                                while(parent && parent.nodeType == 1 && parent.nodeName != "BODY"){  //ignoring the body will help performance
                                        var parentPos = domGeometry.position(parent, true),
                                                pcs = domStyle.getComputedStyle(parent);
                                        if(/relative|absolute/.test(pcs.position)){
                                                sawPosAbsolute = false;
                                        }
                                        if(!sawPosAbsolute && /hidden|auto|scroll/.test(pcs.overflow)){
                                                var bottomYCoord = Math.min(aroundNodePos.y + aroundNodePos.h, parentPos.y + parentPos.h);
                                                var rightXCoord = Math.min(aroundNodePos.x + aroundNodePos.w, parentPos.x + parentPos.w);
                                                aroundNodePos.x = Math.max(aroundNodePos.x, parentPos.x);
                                                aroundNodePos.y = Math.max(aroundNodePos.y, parentPos.y);
                                                aroundNodePos.h = bottomYCoord - aroundNodePos.y;
                                                aroundNodePos.w = rightXCoord - aroundNodePos.x;
                                        }
                                        if(pcs.position == "absolute"){
                                                sawPosAbsolute = true;
                                        }
                                        parent = parent.parentNode;
                                }
                        }                       

                        var x = aroundNodePos.x,
                                y = aroundNodePos.y,
                                width = "w" in aroundNodePos ? aroundNodePos.w : (aroundNodePos.w = aroundNodePos.width),
                                height = "h" in aroundNodePos ? aroundNodePos.h : (kernel.deprecated("place.around: dijit/place.__Rectangle: { x:"+x+", y:"+y+", height:"+aroundNodePos.height+", width:"+width+" } has been deprecated.  Please use { x:"+x+", y:"+y+", h:"+aroundNodePos.height+", w:"+width+" }", "", "2.0"), aroundNodePos.h = aroundNodePos.height);

                        // Convert positions arguments into choices argument for _place()
                        var choices = [];
                        function push(aroundCorner, corner){
                                choices.push({
                                        aroundCorner: aroundCorner,
                                        corner: corner,
                                        pos: {
                                                x: {
                                                        'L': x,
                                                        'R': x + width,
                                                        'M': x + (width >> 1)
                                                   }[aroundCorner.charAt(1)],
                                                y: {
                                                        'T': y,
                                                        'B': y + height,
                                                        'M': y + (height >> 1)
                                                   }[aroundCorner.charAt(0)]
                                        }
                                })
                        }
                        array.forEach(positions, function(pos){
                                var ltr =  leftToRight;
                                switch(pos){
                                        case "above-centered":
                                                push("TM", "BM");
                                                break;
                                        case "below-centered":
                                                push("BM", "TM");
                                                break;
                                        case "after-centered":
                                                ltr = !ltr;
                                                // fall through
                                        case "before-centered":
                                                push(ltr ? "ML" : "MR", ltr ? "MR" : "ML");
                                                break;
                                        case "after":
                                                ltr = !ltr;
                                                // fall through
                                        case "before":
                                                push(ltr ? "TL" : "TR", ltr ? "TR" : "TL");
                                                push(ltr ? "BL" : "BR", ltr ? "BR" : "BL");
                                                break;
                                        case "below-alt":
                                                ltr = !ltr;
                                                // fall through
                                        case "below":
                                                // first try to align left borders, next try to align right borders (or reverse for RTL mode)
                                                push(ltr ? "BL" : "BR", ltr ? "TL" : "TR");
                                                push(ltr ? "BR" : "BL", ltr ? "TR" : "TL");
                                                break;
                                        case "above-alt":
                                                ltr = !ltr;
                                                // fall through
                                        case "above":
                                                // first try to align left borders, next try to align right borders (or reverse for RTL mode)
                                                push(ltr ? "TL" : "TR", ltr ? "BL" : "BR");
                                                push(ltr ? "TR" : "TL", ltr ? "BR" : "BL");
                                                break;
                                        default:
                                                // To assist dijit/_base/place, accept arguments of type {aroundCorner: "BL", corner: "TL"}.
                                                // Not meant to be used directly.
                                                push(pos.aroundCorner, pos.corner);
                                }
                        });

                        var position = _place(node, choices, layoutNode, {w: width, h: height});
                        position.aroundNodePos = aroundNodePos;

                        return position;
                }
        };

        /*=====
        place.__Position = {
                // x: Integer
                //              horizontal coordinate in pixels, relative to document body
                // y: Integer
                //              vertical coordinate in pixels, relative to document body
        };
        place.__Rectangle = {
                // x: Integer
                //              horizontal offset in pixels, relative to document body
                // y: Integer
                //              vertical offset in pixels, relative to document body
                // w: Integer
                //              width in pixels.   Can also be specified as "width" for backwards-compatibility.
                // h: Integer
                //              height in pixels.   Can also be specified as "height" for backwards-compatibility.
        };
        =====*/

        return dijit.place = place;     // setting dijit.place for back-compat, remove for 2.0
});

},
'dijit/_HasDropDown':function(){
define("dijit/_HasDropDown", [
        "dojo/_base/declare", // declare
        "dojo/_base/Deferred",
        "dojo/_base/event", // event.stop
        "dojo/dom", // dom.isDescendant
        "dojo/dom-attr", // domAttr.set
        "dojo/dom-class", // domClass.add domClass.contains domClass.remove
        "dojo/dom-geometry", // domGeometry.marginBox domGeometry.position
        "dojo/dom-style", // domStyle.set
        "dojo/has",     // has("touch")
        "dojo/keys", // keys.DOWN_ARROW keys.ENTER keys.ESCAPE
        "dojo/_base/lang", // lang.hitch lang.isFunction
        "dojo/on",
        "dojo/window", // winUtils.getBox
        "./registry",   // registry.byNode()
        "./focus",
        "./popup",
        "./_FocusMixin"
], function(declare, Deferred, event,dom, domAttr, domClass, domGeometry, domStyle, has, keys, lang, on,
                        winUtils, registry, focus, popup, _FocusMixin){


        // module:
        //              dijit/_HasDropDown

        return declare("dijit._HasDropDown", _FocusMixin, {
                // summary:
                //              Mixin for widgets that need drop down ability.

                // _buttonNode: [protected] DomNode
                //              The button/icon/node to click to display the drop down.
                //              Can be set via a data-dojo-attach-point assignment.
                //              If missing, then either focusNode or domNode (if focusNode is also missing) will be used.
                _buttonNode: null,

                // _arrowWrapperNode: [protected] DomNode
                //              Will set CSS class dijitUpArrow, dijitDownArrow, dijitRightArrow etc. on this node depending
                //              on where the drop down is set to be positioned.
                //              Can be set via a data-dojo-attach-point assignment.
                //              If missing, then _buttonNode will be used.
                _arrowWrapperNode: null,

                // _popupStateNode: [protected] DomNode
                //              The node to set the popupActive class on.
                //              Can be set via a data-dojo-attach-point assignment.
                //              If missing, then focusNode or _buttonNode (if focusNode is missing) will be used.
                _popupStateNode: null,

                // _aroundNode: [protected] DomNode
                //              The node to display the popup around.
                //              Can be set via a data-dojo-attach-point assignment.
                //              If missing, then domNode will be used.
                _aroundNode: null,

                // dropDown: [protected] Widget
                //              The widget to display as a popup.  This widget *must* be
                //              defined before the startup function is called.
                dropDown: null,

                // autoWidth: [protected] Boolean
                //              Set to true to make the drop down at least as wide as this
                //              widget.  Set to false if the drop down should just be its
                //              default width
                autoWidth: true,

                // forceWidth: [protected] Boolean
                //              Set to true to make the drop down exactly as wide as this
                //              widget.  Overrides autoWidth.
                forceWidth: false,

                // maxHeight: [protected] Integer
                //              The max height for our dropdown.
                //              Any dropdown taller than this will have scrollbars.
                //              Set to 0 for no max height, or -1 to limit height to available space in viewport
                maxHeight: 0,

                // dropDownPosition: [const] String[]
                //              This variable controls the position of the drop down.
                //              It's an array of strings with the following values:
                //
                //              - before: places drop down to the left of the target node/widget, or to the right in
                //                the case of RTL scripts like Hebrew and Arabic
                //              - after: places drop down to the right of the target node/widget, or to the left in
                //                the case of RTL scripts like Hebrew and Arabic
                //              - above: drop down goes above target node
                //              - below: drop down goes below target node
                //
                //              The list is positions is tried, in order, until a position is found where the drop down fits
                //              within the viewport.
                //
                dropDownPosition: ["below","above"],

                // _stopClickEvents: Boolean
                //              When set to false, the click events will not be stopped, in
                //              case you want to use them in your subclass
                _stopClickEvents: true,

                _onDropDownMouseDown: function(/*Event*/ e){
                        // summary:
                        //              Callback when the user mousedown's on the arrow icon
                        if(this.disabled || this.readOnly){ return; }

                        // Prevent default to stop things like text selection, but don't stop propagation, so that:
                        //              1. TimeTextBox etc. can focus the <input> on mousedown
                        //              2. dropDownButtonActive class applied by _CssStateMixin (on button depress)
                        //              3. user defined onMouseDown handler fires
                        e.preventDefault();

                        this._docHandler = this.connect(this.ownerDocument, "mouseup", "_onDropDownMouseUp");

                        this.toggleDropDown();
                },

                _onDropDownMouseUp: function(/*Event?*/ e){
                        // summary:
                        //              Callback when the user lifts their mouse after mouse down on the arrow icon.
                        //              If the drop down is a simple menu and the mouse is over the menu, we execute it, otherwise, we focus our
                        //              drop down widget.  If the event is missing, then we are not
                        //              a mouseup event.
                        //
                        //              This is useful for the common mouse movement pattern
                        //              with native browser `<select>` nodes:
                        //
                        //              1. mouse down on the select node (probably on the arrow)
                        //              2. move mouse to a menu item while holding down the mouse button
                        //              3. mouse up.  this selects the menu item as though the user had clicked it.
                        if(e && this._docHandler){
                                this.disconnect(this._docHandler);
                        }
                        var dropDown = this.dropDown, overMenu = false;

                        if(e && this._opened){
                                // This code deals with the corner-case when the drop down covers the original widget,
                                // because it's so large.  In that case mouse-up shouldn't select a value from the menu.
                                // Find out if our target is somewhere in our dropdown widget,
                                // but not over our _buttonNode (the clickable node)
                                var c = domGeometry.position(this._buttonNode, true);
                                if(!(e.pageX >= c.x && e.pageX <= c.x + c.w) ||
                                        !(e.pageY >= c.y && e.pageY <= c.y + c.h)){
                                        var t = e.target;
                                        while(t && !overMenu){
                                                if(domClass.contains(t, "dijitPopup")){
                                                        overMenu = true;
                                                }else{
                                                        t = t.parentNode;
                                                }
                                        }
                                        if(overMenu){
                                                t = e.target;
                                                if(dropDown.onItemClick){
                                                        var menuItem;
                                                        while(t && !(menuItem = registry.byNode(t))){
                                                                t = t.parentNode;
                                                        }
                                                        if(menuItem && menuItem.onClick && menuItem.getParent){
                                                                menuItem.getParent().onItemClick(menuItem, e);
                                                        }
                                                }
                                                return;
                                        }
                                }
                        }
                        if(this._opened){
                                if(dropDown.focus && dropDown.autoFocus !== false){
                                        // Focus the dropdown widget - do it on a delay so that we
                                        // don't steal back focus from the dropdown.
                                        this._focusDropDownTimer = this.defer(function(){
                                                dropDown.focus();
                                                delete this._focusDropDownTimer;
                                        });
                                }
                        }else{
                                // The drop down arrow icon probably can't receive focus, but widget itself should get focus.
                                // defer() needed to make it work on IE (test DateTextBox)
                                this.defer("focus");
                        }

                        if(has("touch")){
                                this._justGotMouseUp = true;
                                this.defer(function(){
                                        this._justGotMouseUp = false;
                                });
                        }
                },

                _onDropDownClick: function(/*Event*/ e){
                        if(has("touch") && !this._justGotMouseUp){
                                // If there was no preceding mousedown/mouseup (like on android), then simulate them to
                                // toggle the drop down.
                                //
                                // The if(has("touch") is necessary since IE and desktop safari get spurious onclick events
                                // when there are nested tables (specifically, clicking on a table that holds a dijit/form/Select,
                                // but not on the Select itself, causes an onclick event on the Select)
                                this._onDropDownMouseDown(e);
                                this._onDropDownMouseUp(e);
                        }

                        // The drop down was already opened on mousedown/keydown; just need to call stopEvent().
                        if(this._stopClickEvents){
                                event.stop(e);
                        }
                },

                buildRendering: function(){
                        this.inherited(arguments);

                        this._buttonNode = this._buttonNode || this.focusNode || this.domNode;
                        this._popupStateNode = this._popupStateNode || this.focusNode || this._buttonNode;

                        // Add a class to the "dijitDownArrowButton" type class to _buttonNode so theme can set direction of arrow
                        // based on where drop down will normally appear
                        var defaultPos = {
                                        "after" : this.isLeftToRight() ? "Right" : "Left",
                                        "before" : this.isLeftToRight() ? "Left" : "Right",
                                        "above" : "Up",
                                        "below" : "Down",
                                        "left" : "Left",
                                        "right" : "Right"
                        }[this.dropDownPosition[0]] || this.dropDownPosition[0] || "Down";
                        domClass.add(this._arrowWrapperNode || this._buttonNode, "dijit" + defaultPos + "ArrowButton");
                },

                postCreate: function(){
                        // summary:
                        //              set up nodes and connect our mouse and keyboard events

                        this.inherited(arguments);

                        var keyboardEventNode = this.focusNode || this.domNode;
                        this.own(
                                on(this._buttonNode, "mousedown", lang.hitch(this, "_onDropDownMouseDown")),
                                on(this._buttonNode, "click", lang.hitch(this, "_onDropDownClick")),
                                on(keyboardEventNode, "keydown", lang.hitch(this, "_onKey")),
                                on(keyboardEventNode, "keyup", lang.hitch(this, "_onKeyUp"))
                        );
                },

                destroy: function(){
                        if(this.dropDown){
                                // Destroy the drop down, unless it's already been destroyed.  This can happen because
                                // the drop down is a direct child of <body> even though it's logically my child.
                                if(!this.dropDown._destroyed){
                                        this.dropDown.destroyRecursive();
                                }
                                delete this.dropDown;
                        }
                        this.inherited(arguments);
                },

                _onKey: function(/*Event*/ e){
                        // summary:
                        //              Callback when the user presses a key while focused on the button node

                        if(this.disabled || this.readOnly){ return; }
                        var d = this.dropDown, target = e.target;
                        if(d && this._opened && d.handleKey){
                                if(d.handleKey(e) === false){
                                        /* false return code means that the drop down handled the key */
                                        event.stop(e);
                                        return;
                                }
                        }
                        if(d && this._opened && e.keyCode == keys.ESCAPE){
                                this.closeDropDown();
                                event.stop(e);
                        }else if(!this._opened &&
                                        (e.keyCode == keys.DOWN_ARROW ||
                                                ( (e.keyCode == keys.ENTER || e.keyCode == keys.SPACE) &&
                                                  //ignore enter and space if the event is for a text input
                                                  ((target.tagName || "").toLowerCase() !== 'input' ||
                                                     (target.type && target.type.toLowerCase() !== 'text'))))){
                                // Toggle the drop down, but wait until keyup so that the drop down doesn't
                                // get a stray keyup event, or in the case of key-repeat (because user held
                                // down key for too long), stray keydown events
                                this._toggleOnKeyUp = true;
                                event.stop(e);
                        }
                },

                _onKeyUp: function(){
                        if(this._toggleOnKeyUp){
                                delete this._toggleOnKeyUp;
                                this.toggleDropDown();
                                var d = this.dropDown;  // drop down may not exist until toggleDropDown() call
                                if(d && d.focus){
                                        this.defer(lang.hitch(d, "focus"), 1);
                                }
                        }
                },

                _onBlur: function(){
                        // summary:
                        //              Called magically when focus has shifted away from this widget and it's dropdown

                        // Don't focus on button if the user has explicitly focused on something else (happens
                        // when user clicks another control causing the current popup to close)..
                        // But if focus is inside of the drop down then reset focus to me, because IE doesn't like
                        // it when you display:none a node with focus.
                        var focusMe = focus.curNode && this.dropDown && dom.isDescendant(focus.curNode, this.dropDown.domNode);

                        this.closeDropDown(focusMe);

                        this.inherited(arguments);
                },

                isLoaded: function(){
                        // summary:
                        //              Returns true if the dropdown exists and it's data is loaded.  This can
                        //              be overridden in order to force a call to loadDropDown().
                        // tags:
                        //              protected

                        return true;
                },

                loadDropDown: function(/*Function*/ loadCallback){
                        // summary:
                        //              Creates the drop down if it doesn't exist, loads the data
                        //              if there's an href and it hasn't been loaded yet, and then calls
                        //              the given callback.
                        // tags:
                        //              protected

                        // TODO: for 2.0, change API to return a Deferred, instead of calling loadCallback?
                        loadCallback();
                },

                loadAndOpenDropDown: function(){
                        // summary:
                        //              Creates the drop down if it doesn't exist, loads the data
                        //              if there's an href and it hasn't been loaded yet, and
                        //              then opens the drop down.  This is basically a callback when the
                        //              user presses the down arrow button to open the drop down.
                        // returns: Deferred
                        //              Deferred for the drop down widget that
                        //              fires when drop down is created and loaded
                        // tags:
                        //              protected
                        var d = new Deferred(),
                                afterLoad = lang.hitch(this, function(){
                                        this.openDropDown();
                                        d.resolve(this.dropDown);
                                });
                        if(!this.isLoaded()){
                                this.loadDropDown(afterLoad);
                        }else{
                                afterLoad();
                        }
                        return d;
                },

                toggleDropDown: function(){
                        // summary:
                        //              Callback when the user presses the down arrow button or presses
                        //              the down arrow key to open/close the drop down.
                        //              Toggle the drop-down widget; if it is up, close it, if not, open it
                        // tags:
                        //              protected

                        if(this.disabled || this.readOnly){ return; }
                        if(!this._opened){
                                this.loadAndOpenDropDown();
                        }else{
                                this.closeDropDown();
                        }
                },

                openDropDown: function(){
                        // summary:
                        //              Opens the dropdown for this widget.   To be called only when this.dropDown
                        //              has been created and is ready to display (ie, it's data is loaded).
                        // returns:
                        //              return value of dijit/popup.open()
                        // tags:
                        //              protected

                        var dropDown = this.dropDown,
                                ddNode = dropDown.domNode,
                                aroundNode = this._aroundNode || this.domNode,
                                self = this;

                        // Prepare our popup's height and honor maxHeight if it exists.

                        // TODO: isn't maxHeight dependent on the return value from dijit/popup.open(),
                        // ie, dependent on how much space is available (BK)

                        if(!this._preparedNode){
                                this._preparedNode = true;
                                // Check if we have explicitly set width and height on the dropdown widget dom node
                                if(ddNode.style.width){
                                        this._explicitDDWidth = true;
                                }
                                if(ddNode.style.height){
                                        this._explicitDDHeight = true;
                                }
                        }

                        // Code for resizing dropdown (height limitation, or increasing width to match my width)
                        if(this.maxHeight || this.forceWidth || this.autoWidth){
                                var myStyle = {
                                        display: "",
                                        visibility: "hidden"
                                };
                                if(!this._explicitDDWidth){
                                        myStyle.width = "";
                                }
                                if(!this._explicitDDHeight){
                                        myStyle.height = "";
                                }
                                domStyle.set(ddNode, myStyle);

                                // Figure out maximum height allowed (if there is a height restriction)
                                var maxHeight = this.maxHeight;
                                if(maxHeight == -1){
                                        // limit height to space available in viewport either above or below my domNode
                                        // (whichever side has more room)
                                        var viewport = winUtils.getBox(this.ownerDocument),
                                                position = domGeometry.position(aroundNode, false);
                                        maxHeight = Math.floor(Math.max(position.y, viewport.h - (position.y + position.h)));
                                }

                                // Attach dropDown to DOM and make make visibility:hidden rather than display:none
                                // so we call startup() and also get the size
                                popup.moveOffScreen(dropDown);

                                if(dropDown.startup && !dropDown._started){
                                        dropDown.startup(); // this has to be done after being added to the DOM
                                }
                                // Get size of drop down, and determine if vertical scroll bar needed.  If no scroll bar needed,
                                // use overflow:visible rather than overflow:hidden so off-by-one errors don't hide drop down border.
                                var mb = domGeometry.getMarginSize(ddNode);
                                var overHeight = (maxHeight && mb.h > maxHeight);
                                domStyle.set(ddNode, {
                                        overflowX: "visible",
                                        overflowY: overHeight ? "auto" : "visible"
                                });
                                if(overHeight){
                                        mb.h = maxHeight;
                                        if("w" in mb){
                                                mb.w += 16;     // room for vertical scrollbar
                                        }
                                }else{
                                        delete mb.h;
                                }

                                // Adjust dropdown width to match or be larger than my width
                                if(this.forceWidth){
                                        mb.w = aroundNode.offsetWidth;
                                }else if(this.autoWidth){
                                        mb.w = Math.max(mb.w, aroundNode.offsetWidth);
                                }else{
                                        delete mb.w;
                                }

                                // And finally, resize the dropdown to calculated height and width
                                if(lang.isFunction(dropDown.resize)){
                                        dropDown.resize(mb);
                                }else{
                                        domGeometry.setMarginBox(ddNode, mb);
                                }
                        }

                        var retVal = popup.open({
                                parent: this,
                                popup: dropDown,
                                around: aroundNode,
                                orient: this.dropDownPosition,
                                onExecute: function(){
                                        self.closeDropDown(true);
                                },
                                onCancel: function(){
                                        self.closeDropDown(true);
                                },
                                onClose: function(){
                                        domAttr.set(self._popupStateNode, "popupActive", false);
                                        domClass.remove(self._popupStateNode, "dijitHasDropDownOpen");
                                        self._set("_opened", false);    // use set() because _CssStateMixin is watching
                                }
                        });
                        domAttr.set(this._popupStateNode, "popupActive", "true");
                        domClass.add(this._popupStateNode, "dijitHasDropDownOpen");
                        this._set("_opened", true);     // use set() because _CssStateMixin is watching
                        this.domNode.setAttribute("aria-expanded", "true");
                        
                        return retVal;
                },

                closeDropDown: function(/*Boolean*/ focus){
                        // summary:
                        //              Closes the drop down on this widget
                        // focus:
                        //              If true, refocuses the button widget
                        // tags:
                        //              protected

                        if(this._focusDropDownTimer){
                                this._focusDropDownTimer.remove();
                                delete this._focusDropDownTimer;
                        }
                        if(this._opened){
                                this.domNode.setAttribute("aria-expanded", "false");
                                if(focus){ this.focus(); }
                                popup.close(this.dropDown);
                                this._opened = false;
                        }
                }

        });
});

},
'dijit/tree/TreeStoreModel':function(){
define("dijit/tree/TreeStoreModel", [
        "dojo/_base/array", // array.filter array.forEach array.indexOf array.some
        "dojo/aspect", // aspect.after
        "dojo/_base/declare", // declare
        "dojo/_base/lang" // lang.hitch
], function(array, aspect, declare, lang){

        // module:
        //              dijit/tree/TreeStoreModel

        return declare("dijit.tree.TreeStoreModel", null, {
                // summary:
                //              Implements dijit/Tree/model connecting to a dojo.data store with a single
                //              root item.  Any methods passed into the constructor will override
                //              the ones defined here.

                // store: dojo/data/api/Read
                //              Underlying store
                store: null,

                // childrenAttrs: String[]
                //              One or more attribute names (attributes in the dojo.data item) that specify that item's children
                childrenAttrs: ["children"],

                // newItemIdAttr: String
                //              Name of attribute in the Object passed to newItem() that specifies the id.
                //
                //              If newItemIdAttr is set then it's used when newItem() is called to see if an
                //              item with the same id already exists, and if so just links to the old item
                //              (so that the old item ends up with two parents).
                //
                //              Setting this to null or "" will make every drop create a new item.
                newItemIdAttr: "id",

                // labelAttr: String
                //              If specified, get label for tree node from this attribute, rather
                //              than by calling store.getLabel()
                labelAttr: "",

                // root: [readonly] dojo/data/Item
                //              Pointer to the root item (read only, not a parameter)
                root: null,

                // query: anything
                //              Specifies datastore query to return the root item for the tree.
                //              Must only return a single item.   Alternately can just pass in pointer
                //              to root item.
                // example:
                //      |       {id:'ROOT'}
                query: null,

                // deferItemLoadingUntilExpand: Boolean
                //              Setting this to true will cause the TreeStoreModel to defer calling loadItem on nodes
                //              until they are expanded. This allows for lazying loading where only one
                //              loadItem (and generally one network call, consequently) per expansion
                //              (rather than one for each child).
                //              This relies on partial loading of the children items; each children item of a
                //              fully loaded item should contain the label and info about having children.
                deferItemLoadingUntilExpand: false,

                constructor: function(/* Object */ args){
                        // summary:
                        //              Passed the arguments listed above (store, etc)
                        // tags:
                        //              private

                        lang.mixin(this, args);

                        this.connects = [];

                        var store = this.store;
                        if(!store.getFeatures()['dojo.data.api.Identity']){
                                throw new Error("dijit.tree.TreeStoreModel: store must support dojo.data.Identity");
                        }

                        // if the store supports Notification, subscribe to the notification events
                        if(store.getFeatures()['dojo.data.api.Notification']){
                                this.connects = this.connects.concat([
                                        aspect.after(store, "onNew", lang.hitch(this, "onNewItem"), true),
                                        aspect.after(store, "onDelete", lang.hitch(this, "onDeleteItem"), true),
                                        aspect.after(store, "onSet", lang.hitch(this, "onSetItem"), true)
                                ]);
                        }
                },

                destroy: function(){
                        var h;
                        while(h = this.connects.pop()){ h.remove(); }
                        // TODO: should cancel any in-progress processing of getRoot(), getChildren()
                },

                // =======================================================================
                // Methods for traversing hierarchy

                getRoot: function(onItem, onError){
                        // summary:
                        //              Calls onItem with the root item for the tree, possibly a fabricated item.
                        //              Calls onError on error.
                        if(this.root){
                                onItem(this.root);
                        }else{
                                this.store.fetch({
                                        query: this.query,
                                        onComplete: lang.hitch(this, function(items){
                                                if(items.length != 1){
                                                        throw new Error("dijit.tree.TreeStoreModel: root query returned " + items.length +
                                                                " items, but must return exactly one");
                                                }
                                                this.root = items[0];
                                                onItem(this.root);
                                        }),
                                        onError: onError
                                });
                        }
                },

                mayHaveChildren: function(/*dojo/data/Item*/ item){
                        // summary:
                        //              Tells if an item has or may have children.  Implementing logic here
                        //              avoids showing +/- expando icon for nodes that we know don't have children.
                        //              (For efficiency reasons we may not want to check if an element actually
                        //              has children until user clicks the expando node)
                        return array.some(this.childrenAttrs, function(attr){
                                return this.store.hasAttribute(item, attr);
                        }, this);
                },

                getChildren: function(/*dojo/data/Item*/ parentItem, /*function(items)*/ onComplete, /*function*/ onError){
                        // summary:
                        //              Calls onComplete() with array of child items of given parent item, all loaded.

                        var store = this.store;
                        if(!store.isItemLoaded(parentItem)){
                                // The parent is not loaded yet, we must be in deferItemLoadingUntilExpand
                                // mode, so we will load it and just return the children (without loading each
                                // child item)
                                var getChildren = lang.hitch(this, arguments.callee);
                                store.loadItem({
                                        item: parentItem,
                                        onItem: function(parentItem){
                                                getChildren(parentItem, onComplete, onError);
                                        },
                                        onError: onError
                                });
                                return;
                        }
                        // get children of specified item
                        var childItems = [];
                        for(var i=0; i<this.childrenAttrs.length; i++){
                                var vals = store.getValues(parentItem, this.childrenAttrs[i]);
                                childItems = childItems.concat(vals);
                        }

                        // count how many items need to be loaded
                        var _waitCount = 0;
                        if(!this.deferItemLoadingUntilExpand){
                                array.forEach(childItems, function(item){ if(!store.isItemLoaded(item)){ _waitCount++; } });
                        }

                        if(_waitCount == 0){
                                // all items are already loaded (or we aren't loading them).  proceed...
                                onComplete(childItems);
                        }else{
                                // still waiting for some or all of the items to load
                                array.forEach(childItems, function(item, idx){
                                        if(!store.isItemLoaded(item)){
                                                store.loadItem({
                                                        item: item,
                                                        onItem: function(item){
                                                                childItems[idx] = item;
                                                                if(--_waitCount == 0){
                                                                        // all nodes have been loaded, send them to the tree
                                                                        onComplete(childItems);
                                                                }
                                                        },
                                                        onError: onError
                                                });
                                        }
                                });
                        }
                },

                // =======================================================================
                // Inspecting items

                isItem: function(/* anything */ something){
                        return this.store.isItem(something);    // Boolean
                },

                fetchItemByIdentity: function(/* object */ keywordArgs){
                        this.store.fetchItemByIdentity(keywordArgs);
                },

                getIdentity: function(/* item */ item){
                        return this.store.getIdentity(item);    // Object
                },

                getLabel: function(/*dojo/data/Item*/ item){
                        // summary:
                        //              Get the label for an item
                        if(this.labelAttr){
                                return this.store.getValue(item,this.labelAttr);        // String
                        }else{
                                return this.store.getLabel(item);       // String
                        }
                },

                // =======================================================================
                // Write interface

                newItem: function(/* dijit/tree/dndSource.__Item */ args, /*dojo/data/api/Item*/ parent, /*int?*/ insertIndex){
                        // summary:
                        //              Creates a new item.   See `dojo/data/api/Write` for details on args.
                        //              Used in drag & drop when item from external source dropped onto tree.
                        // description:
                        //              Developers will need to override this method if new items get added
                        //              to parents with multiple children attributes, in order to define which
                        //              children attribute points to the new item.

                        var pInfo = {parent: parent, attribute: this.childrenAttrs[0]}, LnewItem;

                        if(this.newItemIdAttr && args[this.newItemIdAttr]){
                                // Maybe there's already a corresponding item in the store; if so, reuse it.
                                this.fetchItemByIdentity({identity: args[this.newItemIdAttr], scope: this, onItem: function(item){
                                        if(item){
                                                // There's already a matching item in store, use it
                                                this.pasteItem(item, null, parent, true, insertIndex);
                                        }else{
                                                // Create new item in the tree, based on the drag source.
                                                LnewItem=this.store.newItem(args, pInfo);
                                                if(LnewItem && (insertIndex!=undefined)){
                                                        // Move new item to desired position
                                                        this.pasteItem(LnewItem, parent, parent, false, insertIndex);
                                                }
                                        }
                                }});
                        }else{
                                // [as far as we know] there is no id so we must assume this is a new item
                                LnewItem=this.store.newItem(args, pInfo);
                                if(LnewItem && (insertIndex!=undefined)){
                                        // Move new item to desired position
                                        this.pasteItem(LnewItem, parent, parent, false, insertIndex);
                                }
                        }
                },

                pasteItem: function(/*Item*/ childItem, /*Item*/ oldParentItem, /*Item*/ newParentItem, /*Boolean*/ bCopy, /*int?*/ insertIndex){
                        // summary:
                        //              Move or copy an item from one parent item to another.
                        //              Used in drag & drop
                        var store = this.store,
                                parentAttr = this.childrenAttrs[0];     // name of "children" attr in parent item

                        // remove child from source item, and record the attribute that child occurred in
                        if(oldParentItem){
                                array.forEach(this.childrenAttrs, function(attr){
                                        if(store.containsValue(oldParentItem, attr, childItem)){
                                                if(!bCopy){
                                                        var values = array.filter(store.getValues(oldParentItem, attr), function(x){
                                                                return x != childItem;
                                                        });
                                                        store.setValues(oldParentItem, attr, values);
                                                }
                                                parentAttr = attr;
                                        }
                                });
                        }

                        // modify target item's children attribute to include this item
                        if(newParentItem){
                                if(typeof insertIndex == "number"){
                                        // call slice() to avoid modifying the original array, confusing the data store
                                        var childItems = store.getValues(newParentItem, parentAttr).slice();
                                        childItems.splice(insertIndex, 0, childItem);
                                        store.setValues(newParentItem, parentAttr, childItems);
                                }else{
                                        store.setValues(newParentItem, parentAttr,
                                                store.getValues(newParentItem, parentAttr).concat(childItem));
                                }
                        }
                },

                // =======================================================================
                // Callbacks

                onChange: function(/*dojo/data/Item*/ /*===== item =====*/){
                        // summary:
                        //              Callback whenever an item has changed, so that Tree
                        //              can update the label, icon, etc.   Note that changes
                        //              to an item's children or parent(s) will trigger an
                        //              onChildrenChange() so you can ignore those changes here.
                        // tags:
                        //              callback
                },

                onChildrenChange: function(/*===== parent, newChildrenList =====*/){
                        // summary:
                        //              Callback to do notifications about new, updated, or deleted items.
                        // parent: dojo/data/Item
                        // newChildrenList: dojo/data/Item[]
                        // tags:
                        //              callback
                },

                onDelete: function(/*dojo/data/Item*/ /*===== item =====*/){
                        // summary:
                        //              Callback when an item has been deleted.
                        // description:
                        //              Note that there will also be an onChildrenChange() callback for the parent
                        //              of this item.
                        // tags:
                        //              callback
                },

                // =======================================================================
                // Events from data store

                onNewItem: function(/* dojo/data/Item */ item, /* Object */ parentInfo){
                        // summary:
                        //              Handler for when new items appear in the store, either from a drop operation
                        //              or some other way.   Updates the tree view (if necessary).
                        // description:
                        //              If the new item is a child of an existing item,
                        //              calls onChildrenChange() with the new list of children
                        //              for that existing item.
                        //
                        // tags:
                        //              extension

                        // We only care about the new item if it has a parent that corresponds to a TreeNode
                        // we are currently displaying
                        if(!parentInfo){
                                return;
                        }

                        // Call onChildrenChange() on parent (ie, existing) item with new list of children
                        // In the common case, the new list of children is simply parentInfo.newValue or
                        // [ parentInfo.newValue ], although if items in the store has multiple
                        // child attributes (see `childrenAttr`), then it's a superset of parentInfo.newValue,
                        // so call getChildren() to be sure to get right answer.
                        this.getChildren(parentInfo.item, lang.hitch(this, function(children){
                                this.onChildrenChange(parentInfo.item, children);
                        }));
                },

                onDeleteItem: function(/*Object*/ item){
                        // summary:
                        //              Handler for delete notifications from underlying store
                        this.onDelete(item);
                },

                onSetItem: function(item, attribute /*===== , oldValue, newValue =====*/){
                        // summary:
                        //              Updates the tree view according to changes in the data store.
                        // description:
                        //              Handles updates to an item's children by calling onChildrenChange(), and
                        //              other updates to an item by calling onChange().
                        //
                        //              See `onNewItem` for more details on handling updates to an item's children.
                        // item: Item
                        // attribute: attribute-name-string
                        // oldValue: Object|Array
                        // newValue: Object|Array
                        // tags:
                        //              extension

                        if(array.indexOf(this.childrenAttrs, attribute) != -1){
                                // item's children list changed
                                this.getChildren(item, lang.hitch(this, function(children){
                                        // See comments in onNewItem() about calling getChildren()
                                        this.onChildrenChange(item, children);
                                }));
                        }else{
                                // item's label/icon/etc. changed.
                                this.onChange(item);
                        }
                }
        });
});

},
'dijit/_MenuBase':function(){
define("dijit/_MenuBase", [
        "dojo/_base/array",     // array.indexOf
        "dojo/_base/declare", // declare
        "dojo/dom", // dom.isDescendant domClass.replace
        "dojo/dom-attr",
        "dojo/dom-class", // domClass.replace
        "dojo/_base/lang", // lang.hitch
        "dojo/mouse",   // mouse.enter, mouse.leave
        "dojo/on",
        "dojo/window",
        "./a11yclick",
        "./popup",
        "./registry",
        "./_Widget",
        "./_KeyNavContainer",
        "./_TemplatedMixin"
], function(array, declare, dom, domAttr, domClass, lang, mouse, on, winUtils,
                        a11yclick, pm, registry, _Widget, _KeyNavContainer, _TemplatedMixin){


// module:
//              dijit/_MenuBase

return declare("dijit._MenuBase",
        [_Widget, _TemplatedMixin, _KeyNavContainer],
{
        // summary:
        //              Base class for Menu and MenuBar

        // parentMenu: [readonly] Widget
        //              pointer to menu that displayed me
        parentMenu: null,

        // popupDelay: Integer
        //              number of milliseconds before hovering (without clicking) causes the popup to automatically open.
        popupDelay: 500,

        // autoFocus: Boolean
        //              A toggle to control whether or not a Menu gets focused when opened as a drop down from a MenuBar
        //              or DropDownButton/ComboButton.   Note though that it always get focused when opened via the keyboard.
        autoFocus: false,

        childSelector: function(/*DOMNode*/ node){
                // summary:
                //              Selector (passed to on.selector()) used to identify MenuItem child widgets, but exclude inert children
                //              like MenuSeparator.  If subclass overrides to a string (ex: "> *"), the subclass must require dojo/query.
                // tags:
                //              protected

                var widget = registry.byNode(node);
                return node.parentNode == this.containerNode && widget && widget.focus;
        },

        postCreate: function(){
                var self = this,
                        matches = typeof this.childSelector == "string" ? this.childSelector : lang.hitch(this, "childSelector");
                this.own(
                        on(this.containerNode, on.selector(matches, mouse.enter), function(){
                                self.onItemHover(registry.byNode(this));
                        }),
                        on(this.containerNode, on.selector(matches, mouse.leave), function(){
                                self.onItemUnhover(registry.byNode(this));
                        }),
                        on(this.containerNode, on.selector(matches, a11yclick), function(evt){
                                self.onItemClick(registry.byNode(this), evt);
                                evt.stopPropagation();
                                evt.preventDefault();
                        })
                );
                this.inherited(arguments);
        },

        onExecute: function(){
                // summary:
                //              Attach point for notification about when a menu item has been executed.
                //              This is an internal mechanism used for Menus to signal to their parent to
                //              close them, because they are about to execute the onClick handler.  In
                //              general developers should not attach to or override this method.
                // tags:
                //              protected
        },

        onCancel: function(/*Boolean*/ /*===== closeAll =====*/){
                // summary:
                //              Attach point for notification about when the user cancels the current menu
                //              This is an internal mechanism used for Menus to signal to their parent to
                //              close them.  In general developers should not attach to or override this method.
                // tags:
                //              protected
        },

        _moveToPopup: function(/*Event*/ evt){
                // summary:
                //              This handles the right arrow key (left arrow key on RTL systems),
                //              which will either open a submenu, or move to the next item in the
                //              ancestor MenuBar
                // tags:
                //              private

                if(this.focusedChild && this.focusedChild.popup && !this.focusedChild.disabled){
                        this.onItemClick(this.focusedChild, evt);
                }else{
                        var topMenu = this._getTopMenu();
                        if(topMenu && topMenu._isMenuBar){
                                topMenu.focusNext();
                        }
                }
        },

        _onPopupHover: function(/*Event*/ /*===== evt =====*/){
                // summary:
                //              This handler is called when the mouse moves over the popup.
                // tags:
                //              private

                // if the mouse hovers over a menu popup that is in pending-close state,
                // then stop the close operation.
                // This can't be done in onItemHover since some popup targets don't have MenuItems (e.g. ColorPicker)
                if(this.currentPopup && this.currentPopup._pendingClose_timer){
                        var parentMenu = this.currentPopup.parentMenu;
                        // highlight the parent menu item pointing to this popup
                        if(parentMenu.focusedChild){
                                parentMenu.focusedChild._setSelected(false);
                        }
                        parentMenu.focusedChild = this.currentPopup.from_item;
                        parentMenu.focusedChild._setSelected(true);
                        // cancel the pending close
                        this._stopPendingCloseTimer(this.currentPopup);
                }
        },

        onItemHover: function(/*MenuItem*/ item){
                // summary:
                //              Called when cursor is over a MenuItem.
                // tags:
                //              protected

                // Don't do anything unless user has "activated" the menu by:
                //              1) clicking it
                //              2) opening it from a parent menu (which automatically focuses it)
                if(this.isActive){
                        this.focusChild(item);
                        if(this.focusedChild.popup && !this.focusedChild.disabled && !this.hover_timer){
                                this.hover_timer = this.defer("_openPopup", this.popupDelay);
                        }
                }
                // if the user is mixing mouse and keyboard navigation,
                // then the menu may not be active but a menu item has focus,
                // but it's not the item that the mouse just hovered over.
                // To avoid both keyboard and mouse selections, use the latest.
                if(this.focusedChild){
                        this.focusChild(item);
                }
                this._hoveredChild = item;

                item._set("hovering", true);
        },

        _onChildBlur: function(item){
                // summary:
                //              Called when a child MenuItem becomes inactive because focus
                //              has been removed from the MenuItem *and* it's descendant menus.
                // tags:
                //              private
                this._stopPopupTimer();
                item._setSelected(false);
                // Close all popups that are open and descendants of this menu
                var itemPopup = item.popup;
                if(itemPopup){
                        this._stopPendingCloseTimer(itemPopup);
                        itemPopup._pendingClose_timer = this.defer(function(){
                                itemPopup._pendingClose_timer = null;
                                if(itemPopup.parentMenu){
                                        itemPopup.parentMenu.currentPopup = null;
                                }
                                pm.close(itemPopup); // this calls onClose
                        }, this.popupDelay);
                }
        },

        onItemUnhover: function(/*MenuItem*/ item){
                // summary:
                //              Callback fires when mouse exits a MenuItem
                // tags:
                //              protected

                if(this.isActive){
                        this._stopPopupTimer();
                }
                if(this._hoveredChild == item){ this._hoveredChild = null; }

                item._set("hovering", false);
        },

        _stopPopupTimer: function(){
                // summary:
                //              Cancels the popup timer because the user has stop hovering
                //              on the MenuItem, etc.
                // tags:
                //              private
                if(this.hover_timer){
                        this.hover_timer = this.hover_timer.remove();
                }
        },

        _stopPendingCloseTimer: function(/*dijit/_WidgetBase*/ popup){
                // summary:
                //              Cancels the pending-close timer because the close has been preempted
                // tags:
                //              private
                if(popup._pendingClose_timer){
                        popup._pendingClose_timer = popup._pendingClose_timer.remove();
                }
        },

        _stopFocusTimer: function(){
                // summary:
                //              Cancels the pending-focus timer because the menu was closed before focus occured
                // tags:
                //              private
                if(this._focus_timer){
                        this._focus_timer = this._focus_timer.remove();
                }
        },

        _getTopMenu: function(){
                // summary:
                //              Returns the top menu in this chain of Menus
                // tags:
                //              private
                for(var top=this; top.parentMenu; top=top.parentMenu);
                return top;
        },

        onItemClick: function(/*dijit/_WidgetBase*/ item, /*Event*/ evt){
                // summary:
                //              Handle clicks on an item.
                // tags:
                //              private

                // this can't be done in _onFocus since the _onFocus events occurs asynchronously
                if(typeof this.isShowingNow == 'undefined'){ // non-popup menu
                        this._markActive();
                }

                this.focusChild(item);

                if(item.disabled){ return false; }

                if(item.popup){
                        this._openPopup(evt.type == "keypress");
                }else{
                        // before calling user defined handler, close hierarchy of menus
                        // and restore focus to place it was when menu was opened
                        this.onExecute();

                        // user defined handler for click
                        item._onClick ? item._onClick(evt) : item.onClick(evt);
                }
        },

        _openPopup: function(/*Boolean*/ focus){
                // summary:
                //              Open the popup to the side of/underneath the current menu item, and optionally focus first item
                // tags:
                //              protected

                this._stopPopupTimer();
                var from_item = this.focusedChild;
                if(!from_item){ return; } // the focused child lost focus since the timer was started
                var popup = from_item.popup;
                if(!popup.isShowingNow){
                        if(this.currentPopup){
                                this._stopPendingCloseTimer(this.currentPopup);
                                pm.close(this.currentPopup);
                        }
                        popup.parentMenu = this;
                        popup.from_item = from_item; // helps finding the parent item that should be focused for this popup
                        var self = this;
                        pm.open({
                                parent: this,
                                popup: popup,
                                around: from_item.domNode,
                                orient: this._orient || ["after", "before"],
                                onCancel: function(){ // called when the child menu is canceled
                                        // set isActive=false (_closeChild vs _cleanUp) so that subsequent hovering will NOT open child menus
                                        // which seems aligned with the UX of most applications (e.g. notepad, wordpad, paint shop pro)
                                        self.focusChild(from_item);     // put focus back on my node
                                        self._cleanUp();                        // close the submenu (be sure this is done _after_ focus is moved)
                                        from_item._setSelected(true); // oops, _cleanUp() deselected the item
                                        self.focusedChild = from_item;  // and unset focusedChild
                                },
                                onExecute: lang.hitch(this, "_cleanUp")
                        });

                        this.currentPopup = popup;
                        // detect mouseovers to handle lazy mouse movements that temporarily focus other menu items
                        popup.connect(popup.domNode, "onmouseenter", lang.hitch(self, "_onPopupHover")); // cleaned up when the popped-up widget is destroyed on close
                }

                if(focus && popup.focus){
                        // If user is opening the popup via keyboard (right arrow, or down arrow for MenuBar), then focus the popup.
                        // If the cursor happens to collide with the popup, it will generate an onmouseover event
                        // even though the mouse wasn't moved.  Use defer() to call popup.focus so that
                        // our focus() call overrides the onmouseover event, rather than vice-versa.  (#8742)
                        popup._focus_timer = this.defer(lang.hitch(popup, function(){
                                this._focus_timer = null;
                                this.focus();
                        }));
                }
        },

        _markActive: function(){
                // summary:
                //              Mark this menu's state as active.
                //              Called when this Menu gets focus from:
                //
                //              1. clicking it (mouse or via space/arrow key)
                //              2. being opened by a parent menu.
                //
                //              This is not called just from mouse hover.
                //              Focusing a menu via TAB does NOT automatically set isActive
                //              since TAB is a navigation operation and not a selection one.
                //              For Windows apps, pressing the ALT key focuses the menubar
                //              menus (similar to TAB navigation) but the menu is not active
                //              (ie no dropdown) until an item is clicked.
                this.isActive = true;
                domClass.replace(this.domNode, "dijitMenuActive", "dijitMenuPassive");
        },

        onOpen: function(/*Event*/ /*===== e =====*/){
                // summary:
                //              Callback when this menu is opened.
                //              This is called by the popup manager as notification that the menu
                //              was opened.
                // tags:
                //              private

                this.isShowingNow = true;
                this._markActive();
        },

        _markInactive: function(){
                // summary:
                //              Mark this menu's state as inactive.
                this.isActive = false; // don't do this in _onBlur since the state is pending-close until we get here
                domClass.replace(this.domNode, "dijitMenuPassive", "dijitMenuActive");
        },

        onClose: function(){
                // summary:
                //              Callback when this menu is closed.
                //              This is called by the popup manager as notification that the menu
                //              was closed.
                // tags:
                //              private

                this._stopFocusTimer();
                this._markInactive();
                this.isShowingNow = false;
                this.parentMenu = null;
        },

        _closeChild: function(){
                // summary:
                //              Called when submenu is clicked or focus is lost.  Close hierarchy of menus.
                // tags:
                //              private
                this._stopPopupTimer();

                if(this.currentPopup){
                        // If focus is on a descendant MenuItem then move focus to me,
                        // because IE doesn't like it when you display:none a node with focus,
                        // and also so keyboard users don't lose control.
                        // Likely, immediately after a user defined onClick handler will move focus somewhere
                        // else, like a Dialog.
                        if(array.indexOf(this._focusManager.activeStack, this.id) >= 0){
                                domAttr.set(this.focusedChild.focusNode, "tabIndex", this.tabIndex);
                                this.focusedChild.focusNode.focus();
                        }
                        // Close all popups that are open and descendants of this menu
                        pm.close(this.currentPopup);
                        this.currentPopup = null;
                }

                if(this.focusedChild){ // unhighlight the focused item
                        this.focusedChild._setSelected(false);
                        this.onItemUnhover(this.focusedChild);
                        this.focusedChild = null;
                }
        },

        _onItemFocus: function(/*MenuItem*/ item){
                // summary:
                //              Called when child of this Menu gets focus from:
                //
                //              1. clicking it
                //              2. tabbing into it
                //              3. being opened by a parent menu.
                //
                //              This is not called just from mouse hover.
                if(this._hoveredChild && this._hoveredChild != item){
                        this.onItemUnhover(this._hoveredChild); // any previous mouse movement is trumped by focus selection
                }
        },

        _onBlur: function(){
                // summary:
                //              Called when focus is moved away from this Menu and it's submenus.
                // tags:
                //              protected
                this._cleanUp();
                this.inherited(arguments);
        },

        _cleanUp: function(){
                // summary:
                //              Called when the user is done with this menu.  Closes hierarchy of menus.
                // tags:
                //              private

                this._closeChild(); // don't call this.onClose since that's incorrect for MenuBar's that never close
                if(typeof this.isShowingNow == 'undefined'){ // non-popup menu doesn't call onClose
                        this._markInactive();
                }
        }
});

});

},
'dijit/focus':function(){
define("dijit/focus", [
        "dojo/aspect",
        "dojo/_base/declare", // declare
        "dojo/dom", // domAttr.get dom.isDescendant
        "dojo/dom-attr", // domAttr.get dom.isDescendant
        "dojo/dom-construct", // connect to domConstruct.empty, domConstruct.destroy
        "dojo/Evented",
        "dojo/_base/lang", // lang.hitch
        "dojo/on",
        "dojo/ready",
        "dojo/sniff", // has("ie")
        "dojo/Stateful",
        "dojo/_base/unload", // unload.addOnWindowUnload
        "dojo/_base/window", // win.body
        "dojo/window", // winUtils.get
        "./a11y",       // a11y.isTabNavigable
        "./registry",   // registry.byId
        "./main"                // to set dijit.focus
], function(aspect, declare, dom, domAttr, domConstruct, Evented, lang, on, ready, has, Stateful, unload, win, winUtils,
                        a11y, registry, dijit){

        // module:
        //              dijit/focus

        var FocusManager = declare([Stateful, Evented], {
                // summary:
                //              Tracks the currently focused node, and which widgets are currently "active".
                //              Access via require(["dijit/focus"], function(focus){ ... }).
                //
                //              A widget is considered active if it or a descendant widget has focus,
                //              or if a non-focusable node of this widget or a descendant was recently clicked.
                //
                //              Call focus.watch("curNode", callback) to track the current focused DOMNode,
                //              or focus.watch("activeStack", callback) to track the currently focused stack of widgets.
                //
                //              Call focus.on("widget-blur", func) or focus.on("widget-focus", ...) to monitor when
                //              when widgets become active/inactive
                //
                //              Finally, focus(node) will focus a node, suppressing errors if the node doesn't exist.

                // curNode: DomNode
                //              Currently focused item on screen
                curNode: null,

                // activeStack: dijit/_WidgetBase[]
                //              List of currently active widgets (focused widget and it's ancestors)
                activeStack: [],

                constructor: function(){
                        // Don't leave curNode/prevNode pointing to bogus elements
                        var check = lang.hitch(this, function(node){
                                if(dom.isDescendant(this.curNode, node)){
                                        this.set("curNode", null);
                                }
                                if(dom.isDescendant(this.prevNode, node)){
                                        this.set("prevNode", null);
                                }
                        });
                        aspect.before(domConstruct, "empty", check);
                        aspect.before(domConstruct, "destroy", check);
                },

                registerIframe: function(/*DomNode*/ iframe){
                        // summary:
                        //              Registers listeners on the specified iframe so that any click
                        //              or focus event on that iframe (or anything in it) is reported
                        //              as a focus/click event on the `<iframe>` itself.
                        // description:
                        //              Currently only used by editor.
                        // returns:
                        //              Handle with remove() method to deregister.
                        return this.registerWin(iframe.contentWindow, iframe);
                },

                registerWin: function(/*Window?*/targetWindow, /*DomNode?*/ effectiveNode){
                        // summary:
                        //              Registers listeners on the specified window (either the main
                        //              window or an iframe's window) to detect when the user has clicked somewhere
                        //              or focused somewhere.
                        // description:
                        //              Users should call registerIframe() instead of this method.
                        // targetWindow:
                        //              If specified this is the window associated with the iframe,
                        //              i.e. iframe.contentWindow.
                        // effectiveNode:
                        //              If specified, report any focus events inside targetWindow as
                        //              an event on effectiveNode, rather than on evt.target.
                        // returns:
                        //              Handle with remove() method to deregister.

                        // TODO: make this function private in 2.0; Editor/users should call registerIframe(),

                        var _this = this;
                        var mousedownListener = function(evt){
                                _this._justMouseDowned = true;
                                setTimeout(function(){ _this._justMouseDowned = false; }, 0);

                                // workaround weird IE bug where the click is on an orphaned node
                                // (first time clicking a Select/DropDownButton inside a TooltipDialog)
                                if(has("ie") && evt && evt.srcElement && evt.srcElement.parentNode == null){
                                        return;
                                }

                                _this._onTouchNode(effectiveNode || evt.target || evt.srcElement, "mouse");
                        };

                        // Listen for blur and focus events on targetWindow's document.
                        // Using attachEvent()/addEventListener() rather than on() to try to catch mouseDown events even
                        // if other code calls evt.stopPropagation().  But rethink for 2.0 since that doesn't work for attachEvent(),
                        // which watches events at the bubbling phase rather than capturing phase, like addEventListener(..., false).
                        // Connect to <html> (rather than document) on IE to avoid memory leaks, but document on other browsers because
                        // (at least for FF) the focus event doesn't fire on <html> or <body>.
                        var doc = has("ie") ? targetWindow.document.documentElement : targetWindow.document;
                        if(doc){
                                if(has("ie")){
                                        targetWindow.document.body.attachEvent('onmousedown', mousedownListener);
                                        var focusinListener = function(evt){
                                                // IE reports that nodes like <body> have gotten focus, even though they have tabIndex=-1,
                                                // ignore those events
                                                var tag = evt.srcElement.tagName.toLowerCase();
                                                if(tag == "#document" || tag == "body"){ return; }

                                                // Previous code called _onTouchNode() for any activate event on a non-focusable node.   Can
                                                // probably just ignore such an event as it will be handled by onmousedown handler above, but
                                                // leaving the code for now.
                                                if(a11y.isTabNavigable(evt.srcElement)){
                                                        _this._onFocusNode(effectiveNode || evt.srcElement);
                                                }else{
                                                        _this._onTouchNode(effectiveNode || evt.srcElement);
                                                }
                                        };
                                        doc.attachEvent('onfocusin', focusinListener);
                                        var focusoutListener =  function(evt){
                                                _this._onBlurNode(effectiveNode || evt.srcElement);
                                        };
                                        doc.attachEvent('onfocusout', focusoutListener);

                                        return {
                                                remove: function(){
                                                        targetWindow.document.detachEvent('onmousedown', mousedownListener);
                                                        doc.detachEvent('onfocusin', focusinListener);
                                                        doc.detachEvent('onfocusout', focusoutListener);
                                                        doc = null;     // prevent memory leak (apparent circular reference via closure)
                                                }
                                        };
                                }else{
                                        doc.body.addEventListener('mousedown', mousedownListener, true);
                                        doc.body.addEventListener('touchstart', mousedownListener, true);
                                        var focusListener = function(evt){
                                                _this._onFocusNode(effectiveNode || evt.target);
                                        };
                                        doc.addEventListener('focus', focusListener, true);
                                        var blurListener = function(evt){
                                                _this._onBlurNode(effectiveNode || evt.target);
                                        };
                                        doc.addEventListener('blur', blurListener, true);

                                        return {
                                                remove: function(){
                                                        doc.body.removeEventListener('mousedown', mousedownListener, true);
                                                        doc.body.removeEventListener('touchstart', mousedownListener, true);
                                                        doc.removeEventListener('focus', focusListener, true);
                                                        doc.removeEventListener('blur', blurListener, true);
                                                        doc = null;     // prevent memory leak (apparent circular reference via closure)
                                                }
                                        };
                                }
                        }
                },

                _onBlurNode: function(/*DomNode*/ node){
                        // summary:
                        //              Called when focus leaves a node.
                        //              Usually ignored, _unless_ it *isn't* followed by touching another node,
                        //              which indicates that we tabbed off the last field on the page,
                        //              in which case every widget is marked inactive

                        // If the blur event isn't followed by a focus event, it means the user clicked on something unfocusable,
                        // so clear focus.
                        if(this._clearFocusTimer){
                                clearTimeout(this._clearFocusTimer);
                        }
                        this._clearFocusTimer = setTimeout(lang.hitch(this, function(){
                                this.set("prevNode", this.curNode);
                                this.set("curNode", null);
                        }), 0);

                        if(this._justMouseDowned){
                                // the mouse down caused a new widget to be marked as active; this blur event
                                // is coming late, so ignore it.
                                return;
                        }

                        // If the blur event isn't followed by a focus or touch event then mark all widgets as inactive.
                        if(this._clearActiveWidgetsTimer){
                                clearTimeout(this._clearActiveWidgetsTimer);
                        }
                        this._clearActiveWidgetsTimer = setTimeout(lang.hitch(this, function(){
                                delete this._clearActiveWidgetsTimer;
                                this._setStack([]);
                        }), 0);
                },

                _onTouchNode: function(/*DomNode*/ node, /*String*/ by){
                        // summary:
                        //              Callback when node is focused or mouse-downed
                        // node:
                        //              The node that was touched.
                        // by:
                        //              "mouse" if the focus/touch was caused by a mouse down event

                        // ignore the recent blurNode event
                        if(this._clearActiveWidgetsTimer){
                                clearTimeout(this._clearActiveWidgetsTimer);
                                delete this._clearActiveWidgetsTimer;
                        }

                        // compute stack of active widgets (ex: ComboButton --> Menu --> MenuItem)
                        var newStack=[];
                        try{
                                while(node){
                                        var popupParent = domAttr.get(node, "dijitPopupParent");
                                        if(popupParent){
                                                node=registry.byId(popupParent).domNode;
                                        }else if(node.tagName && node.tagName.toLowerCase() == "body"){
                                                // is this the root of the document or just the root of an iframe?
                                                if(node === win.body()){
                                                        // node is the root of the main document
                                                        break;
                                                }
                                                // otherwise, find the iframe this node refers to (can't access it via parentNode,
                                                // need to do this trick instead). window.frameElement is supported in IE/FF/Webkit
                                                node=winUtils.get(node.ownerDocument).frameElement;
                                        }else{
                                                // if this node is the root node of a widget, then add widget id to stack,
                                                // except ignore clicks on disabled widgets (actually focusing a disabled widget still works,
                                                // to support MenuItem)
                                                var id = node.getAttribute && node.getAttribute("widgetId"),
                                                        widget = id && registry.byId(id);
                                                if(widget && !(by == "mouse" && widget.get("disabled"))){
                                                        newStack.unshift(id);
                                                }
                                                node=node.parentNode;
                                        }
                                }
                        }catch(e){ /* squelch */ }

                        this._setStack(newStack, by);
                },

                _onFocusNode: function(/*DomNode*/ node){
                        // summary:
                        //              Callback when node is focused

                        if(!node){
                                return;
                        }

                        if(node.nodeType == 9){
                                // Ignore focus events on the document itself.  This is here so that
                                // (for example) clicking the up/down arrows of a spinner
                                // (which don't get focus) won't cause that widget to blur. (FF issue)
                                return;
                        }

                        // There was probably a blur event right before this event, but since we have a new focus, don't
                        // do anything with the blur
                        if(this._clearFocusTimer){
                                clearTimeout(this._clearFocusTimer);
                                delete this._clearFocusTimer;
                        }

                        this._onTouchNode(node);

                        if(node == this.curNode){ return; }
                        this.set("prevNode", this.curNode);
                        this.set("curNode", node);
                },

                _setStack: function(/*String[]*/ newStack, /*String*/ by){
                        // summary:
                        //              The stack of active widgets has changed.  Send out appropriate events and records new stack.
                        // newStack:
                        //              array of widget id's, starting from the top (outermost) widget
                        // by:
                        //              "mouse" if the focus/touch was caused by a mouse down event

                        var oldStack = this.activeStack;
                        this.set("activeStack", newStack);

                        // compare old stack to new stack to see how many elements they have in common
                        for(var nCommon=0; nCommon<Math.min(oldStack.length, newStack.length); nCommon++){
                                if(oldStack[nCommon] != newStack[nCommon]){
                                        break;
                                }
                        }

                        var widget;
                        // for all elements that have gone out of focus, set focused=false
                        for(var i=oldStack.length-1; i>=nCommon; i--){
                                widget = registry.byId(oldStack[i]);
                                if(widget){
                                        widget._hasBeenBlurred = true;          // TODO: used by form widgets, should be moved there
                                        widget.set("focused", false);
                                        if(widget._focusManager == this){
                                                widget._onBlur(by);
                                        }
                                        this.emit("widget-blur", widget, by);
                                }
                        }

                        // for all element that have come into focus, set focused=true
                        for(i=nCommon; i<newStack.length; i++){
                                widget = registry.byId(newStack[i]);
                                if(widget){
                                        widget.set("focused", true);
                                        if(widget._focusManager == this){
                                                widget._onFocus(by);
                                        }
                                        this.emit("widget-focus", widget, by);
                                }
                        }
                },

                focus: function(node){
                        // summary:
                        //              Focus the specified node, suppressing errors if they occur
                        if(node){
                                try{ node.focus(); }catch(e){/*quiet*/}
                        }
                }
        });

        var singleton = new FocusManager();

        // register top window and all the iframes it contains
        ready(function(){
                var handle = singleton.registerWin(winUtils.get(win.doc));
                if(has("ie")){
                        unload.addOnWindowUnload(function(){
                                if(handle){     // because this gets called twice when doh.robot is running
                                        handle.remove();
                                        handle = null;
                                }
                        });
                }
        });

        // Setup dijit.focus as a pointer to the singleton but also (for backwards compatibility)
        // as a function to set focus.   Remove for 2.0.
        dijit.focus = function(node){
                singleton.focus(node);  // indirection here allows dijit/_base/focus.js to override behavior
        };
        for(var attr in singleton){
                if(!/^_/.test(attr)){
                        dijit.focus[attr] = typeof singleton[attr] == "function" ? lang.hitch(singleton, attr) : singleton[attr];
                }
        }
        singleton.watch(function(attr, oldVal, newVal){
                dijit.focus[attr] = newVal;
        });

        return singleton;
});

},
'dojo/i18n':function(){
define("dojo/i18n", ["./_base/kernel", "require", "./has", "./_base/array", "./_base/config", "./_base/lang", "./_base/xhr", "./json", "module"],
        function(dojo, require, has, array, config, lang, xhr, json, module){

        // module:
        //              dojo/i18n

        has.add("dojo-preload-i18n-Api",
                // if true, define the preload localizations machinery
                1
        );

         1 || has.add("dojo-v1x-i18n-Api",
                // if true, define the v1.x i18n functions
                1
        );

        var
                thisModule = dojo.i18n =
                        {
                                // summary:
                                //              This module implements the dojo/i18n! plugin and the v1.6- i18n API
                                // description:
                                //              We choose to include our own plugin to leverage functionality already contained in dojo
                                //              and thereby reduce the size of the plugin compared to various loader implementations. Also, this
                                //              allows foreign AMD loaders to be used without their plugins.
                        },

                nlsRe =
                        // regexp for reconstructing the master bundle name from parts of the regexp match
                        // nlsRe.exec("foo/bar/baz/nls/en-ca/foo") gives:
                        // ["foo/bar/baz/nls/en-ca/foo", "foo/bar/baz/nls/", "/", "/", "en-ca", "foo"]
                        // nlsRe.exec("foo/bar/baz/nls/foo") gives:
                        // ["foo/bar/baz/nls/foo", "foo/bar/baz/nls/", "/", "/", "foo", ""]
                        // so, if match[5] is blank, it means this is the top bundle definition.
                        // courtesy of http://requirejs.org
                        /(^.*(^|\/)nls)(\/|$)([^\/]*)\/?([^\/]*)/,

                getAvailableLocales = function(
                        root,
                        locale,
                        bundlePath,
                        bundleName
                ){
                        // summary:
                        //              return a vector of module ids containing all available locales with respect to the target locale
                        //              For example, assuming:
                        //
                        //              - the root bundle indicates specific bundles for "fr" and "fr-ca",
                        //              -  bundlePath is "myPackage/nls"
                        //              - bundleName is "myBundle"
                        //
                        //              Then a locale argument of "fr-ca" would return
                        //
                        //                      ["myPackage/nls/myBundle", "myPackage/nls/fr/myBundle", "myPackage/nls/fr-ca/myBundle"]
                        //
                        //              Notice that bundles are returned least-specific to most-specific, starting with the root.
                        //
                        //              If root===false indicates we're working with a pre-AMD i18n bundle that doesn't tell about the available locales;
                        //              therefore, assume everything is available and get 404 errors that indicate a particular localization is not available

                        for(var result = [bundlePath + bundleName], localeParts = locale.split("-"), current = "", i = 0; i<localeParts.length; i++){
                                current += (current ? "-" : "") + localeParts[i];
                                if(!root || root[current]){
                                        result.push(bundlePath + current + "/" + bundleName);
                                }
                        }
                        return result;
                },

                cache = {},

                getBundleName = function(moduleName, bundleName, locale){
                        locale = locale ? locale.toLowerCase() : dojo.locale;
                        moduleName = moduleName.replace(/\./g, "/");
                        bundleName = bundleName.replace(/\./g, "/");
                        return (/root/i.test(locale)) ?
                                (moduleName + "/nls/" + bundleName) :
                                (moduleName + "/nls/" + locale + "/" + bundleName);
                },

                getL10nName = dojo.getL10nName = function(moduleName, bundleName, locale){
                        return moduleName = module.id + "!" + getBundleName(moduleName, bundleName, locale);
                },

                doLoad = function(require, bundlePathAndName, bundlePath, bundleName, locale, load){
                        // summary:
                        //              get the root bundle which instructs which other bundles are required to construct the localized bundle
                        require([bundlePathAndName], function(root){
                                var current = lang.clone(root.root),
                                        availableLocales = getAvailableLocales(!root._v1x && root, locale, bundlePath, bundleName);
                                require(availableLocales, function(){
                                        for (var i = 1; i<availableLocales.length; i++){
                                                current = lang.mixin(lang.clone(current), arguments[i]);
                                        }
                                        // target may not have been resolve (e.g., maybe only "fr" exists when "fr-ca" was requested)
                                        var target = bundlePathAndName + "/" + locale;
                                        cache[target] = current;
                                        load();
                                });
                        });
                },

                normalize = function(id, toAbsMid){
                        // summary:
                        //              id may be relative.
                        //              preload has form `*preload*<path>/nls/<module>*<flattened locales>` and
                        //              therefore never looks like a relative
                        return /^\./.test(id) ? toAbsMid(id) : id;
                },

                getLocalesToLoad = function(targetLocale){
                        var list = config.extraLocale || [];
                        list = lang.isArray(list) ? list : [list];
                        list.push(targetLocale);
                        return list;
                },

                load = function(id, require, load){
                        // summary:
                        //              id is in one of the following formats
                        //
                        //              1. <path>/nls/<bundle>
                        //                      => load the bundle, localized to config.locale; load all bundles localized to
                        //                      config.extraLocale (if any); return the loaded bundle localized to config.locale.
                        //
                        //              2. <path>/nls/<locale>/<bundle>
                        //                      => load then return the bundle localized to <locale>
                        //
                        //              3. *preload*<path>/nls/<module>*<JSON array of available locales>
                        //                      => for config.locale and all config.extraLocale, load all bundles found
                        //                      in the best-matching bundle rollup. A value of 1 is returned, which
                        //                      is meaningless other than to say the plugin is executing the requested
                        //                      preloads
                        //
                        //              In cases 1 and 2, <path> is always normalized to an absolute module id upon entry; see
                        //              normalize. In case 3, it <path> is assumed to be absolute; this is arranged by the builder.
                        //
                        //              To load a bundle means to insert the bundle into the plugin's cache and publish the bundle
                        //              value to the loader. Given <path>, <bundle>, and a particular <locale>, the cache key
                        //
                        //                      <path>/nls/<bundle>/<locale>
                        //
                        //              will hold the value. Similarly, then plugin will publish this value to the loader by
                        //
                        //                      define("<path>/nls/<bundle>/<locale>", <bundle-value>);
                        //
                        //              Given this algorithm, other machinery can provide fast load paths be preplacing
                        //              values in the plugin's cache, which is public. When a load is demanded the
                        //              cache is inspected before starting any loading. Explicitly placing values in the plugin
                        //              cache is an advanced/experimental feature that should not be needed; use at your own risk.
                        //
                        //              For the normal AMD algorithm, the root bundle is loaded first, which instructs the
                        //              plugin what additional localized bundles are required for a particular locale. These
                        //              additional locales are loaded and a mix of the root and each progressively-specific
                        //              locale is returned. For example:
                        //
                        //              1. The client demands "dojo/i18n!some/path/nls/someBundle
                        //
                        //              2. The loader demands load(some/path/nls/someBundle)
                        //
                        //              3. This plugin require's "some/path/nls/someBundle", which is the root bundle.
                        //
                        //              4. Assuming config.locale is "ab-cd-ef" and the root bundle indicates that localizations
                        //              are available for "ab" and "ab-cd-ef" (note the missing "ab-cd", then the plugin
                        //              requires "some/path/nls/ab/someBundle" and "some/path/nls/ab-cd-ef/someBundle"
                        //
                        //              5. Upon receiving all required bundles, the plugin constructs the value of the bundle
                        //              ab-cd-ef as...
                        //
                        //                              mixin(mixin(mixin({}, require("some/path/nls/someBundle"),
                        //                                      require("some/path/nls/ab/someBundle")),
                        //                                      require("some/path/nls/ab-cd-ef/someBundle"));
                        //
                        //              This value is inserted into the cache and published to the loader at the
                        //              key/module-id some/path/nls/someBundle/ab-cd-ef.
                        //
                        //              The special preload signature (case 3) instructs the plugin to stop servicing all normal requests
                        //              (further preload requests will be serviced) until all ongoing preloading has completed.
                        //
                        //              The preload signature instructs the plugin that a special rollup module is available that contains
                        //              one or more flattened, localized bundles. The JSON array of available locales indicates which locales
                        //              are available. Here is an example:
                        //
                        //                      *preload*some/path/nls/someModule*["root", "ab", "ab-cd-ef"]
                        //
                        //              This indicates the following rollup modules are available:
                        //
                        //                      some/path/nls/someModule_ROOT
                        //                      some/path/nls/someModule_ab
                        //                      some/path/nls/someModule_ab-cd-ef
                        //
                        //              Each of these modules is a normal AMD module that contains one or more flattened bundles in a hash.
                        //              For example, assume someModule contained the bundles some/bundle/path/someBundle and
                        //              some/bundle/path/someOtherBundle, then some/path/nls/someModule_ab would be expressed as follows:
                        //
                        //                      define({
                        //                              some/bundle/path/someBundle:<value of someBundle, flattened with respect to locale ab>,
                        //                              some/bundle/path/someOtherBundle:<value of someOtherBundle, flattened with respect to locale ab>,
                        //                      });
                        //
                        //              E.g., given this design, preloading for locale=="ab" can execute the following algorithm:
                        //
                        //                      require(["some/path/nls/someModule_ab"], function(rollup){
                        //                              for(var p in rollup){
                        //                                      var id = p + "/ab",
                        //                                      cache[id] = rollup[p];
                        //                                      define(id, rollup[p]);
                        //                              }
                        //                      });
                        //
                        //              Similarly, if "ab-cd" is requested, the algorithm can determine that "ab" is the best available and
                        //              load accordingly.
                        //
                        //              The builder will write such rollups for every layer if a non-empty localeList  profile property is
                        //              provided. Further, the builder will include the following cache entry in the cache associated with
                        //              any layer.
                        //
                        //                      "*now":function(r){r(['dojo/i18n!*preload*<path>/nls/<module>*<JSON array of available locales>']);}
                        //
                        //              The *now special cache module instructs the loader to apply the provided function to context-require
                        //              with respect to the particular layer being defined. This causes the plugin to hold all normal service
                        //              requests until all preloading is complete.
                        //
                        //              Notice that this algorithm is rarely better than the standard AMD load algorithm. Consider the normal case
                        //              where the target locale has a single segment and a layer depends on a single bundle:
                        //
                        //              Without Preloads:
                        //
                        //              1. Layer loads root bundle.
                        //              2. bundle is demanded; plugin loads single localized bundle.
                        //
                        //              With Preloads:
                        //
                        //              1. Layer causes preloading of target bundle.
                        //              2. bundle is demanded; service is delayed until preloading complete; bundle is returned.
                        //
                        //              In each case a single transaction is required to load the target bundle. In cases where multiple bundles
                        //              are required and/or the locale has multiple segments, preloads still requires a single transaction whereas
                        //              the normal path requires an additional transaction for each additional bundle/locale-segment. However all
                        //              of these additional transactions can be done concurrently. Owing to this analysis, the entire preloading
                        //              algorithm can be discard during a build by setting the has feature dojo-preload-i18n-Api to false.

                        if(has("dojo-preload-i18n-Api")){
                                var split = id.split("*"),
                                        preloadDemand = split[1] == "preload";
                                if(preloadDemand){
                                        if(!cache[id]){
                                                // use cache[id] to prevent multiple preloads of the same preload; this shouldn't happen, but
                                                // who knows what over-aggressive human optimizers may attempt
                                                cache[id] = 1;
                                                preloadL10n(split[2], json.parse(split[3]), 1, require);
                                        }
                                        // don't stall the loader!
                                        load(1);
                                }
                                if(preloadDemand || waitForPreloads(id, require, load)){
                                        return;
                                }
                        }

                        var match = nlsRe.exec(id),
                                bundlePath = match[1] + "/",
                                bundleName = match[5] || match[4],
                                bundlePathAndName = bundlePath + bundleName,
                                localeSpecified = (match[5] && match[4]),
                                targetLocale =  localeSpecified || dojo.locale,
                                loadTarget = bundlePathAndName + "/" + targetLocale,
                                loadList = localeSpecified ? [targetLocale] : getLocalesToLoad(targetLocale),
                                remaining = loadList.length,
                                finish = function(){
                                        if(!--remaining){
                                                load(lang.delegate(cache[loadTarget]));
                                        }
                                };
                        array.forEach(loadList, function(locale){
                                var target = bundlePathAndName + "/" + locale;
                                if(has("dojo-preload-i18n-Api")){
                                        checkForLegacyModules(target);
                                }
                                if(!cache[target]){
                                        doLoad(require, bundlePathAndName, bundlePath, bundleName, locale, finish);
                                }else{
                                        finish();
                                }
                        });
                };

        if(has("dojo-unit-tests")){
                var unitTests = thisModule.unitTests = [];
        }

        if(has("dojo-preload-i18n-Api") ||  1 ){
                var normalizeLocale = thisModule.normalizeLocale = function(locale){
                                var result = locale ? locale.toLowerCase() : dojo.locale;
                                return result == "root" ? "ROOT" : result;
                        },

                        isXd = function(mid, contextRequire){
                                return ( 1  &&  1 ) ?
                                        contextRequire.isXdUrl(require.toUrl(mid + ".js")) :
                                        true;
                        },

                        preloading = 0,

                        preloadWaitQueue = [],

                        preloadL10n = thisModule._preloadLocalizations = function(/*String*/bundlePrefix, /*Array*/localesGenerated, /*boolean?*/ guaranteedAmdFormat, /*function?*/ contextRequire){
                                // summary:
                                //              Load available flattened resource bundles associated with a particular module for dojo/locale and all dojo/config.extraLocale (if any)
                                // description:
                                //              Only called by built layer files. The entire locale hierarchy is loaded. For example,
                                //              if locale=="ab-cd", then ROOT, "ab", and "ab-cd" are loaded. This is different than v1.6-
                                //              in that the v1.6- would only load ab-cd...which was *always* flattened.
                                //
                                //              If guaranteedAmdFormat is true, then the module can be loaded with require thereby circumventing the detection algorithm
                                //              and the extra possible extra transaction.

                                // If this function is called from legacy code, then guaranteedAmdFormat and contextRequire will be undefined. Since the function
                                // needs a require in order to resolve module ids, fall back to the context-require associated with this dojo/i18n module, which
                                // itself may have been mapped.
                                contextRequire = contextRequire || require;

                                function doRequire(mid, callback){
                                        if(isXd(mid, contextRequire) || guaranteedAmdFormat){
                                                contextRequire([mid], callback);
                                        }else{
                                                syncRequire([mid], callback, contextRequire);
                                        }
                                }

                                function forEachLocale(locale, func){
                                        // given locale= "ab-cd-ef", calls func on "ab-cd-ef", "ab-cd", "ab", "ROOT"; stops calling the first time func returns truthy
                                        var parts = locale.split("-");
                                        while(parts.length){
                                                if(func(parts.join("-"))){
                                                        return;
                                                }
                                                parts.pop();
                                        }
                                        func("ROOT");
                                }

                                function preload(locale){
                                        locale = normalizeLocale(locale);
                                        forEachLocale(locale, function(loc){
                                                if(array.indexOf(localesGenerated, loc)>=0){
                                                        var mid = bundlePrefix.replace(/\./g, "/")+"_"+loc;
                                                        preloading++;
                                                        doRequire(mid, function(rollup){
                                                                for(var p in rollup){
                                                                        cache[require.toAbsMid(p) + "/" + loc] = rollup[p];
                                                                }
                                                                --preloading;
                                                                while(!preloading && preloadWaitQueue.length){
                                                                        load.apply(null, preloadWaitQueue.shift());
                                                                }
                                                        });
                                                        return true;
                                                }
                                                return false;
                                        });
                                }

                                preload();
                                array.forEach(dojo.config.extraLocale, preload);
                        },

                        waitForPreloads = function(id, require, load){
                                if(preloading){
                                        preloadWaitQueue.push([id, require, load]);
                                }
                                return preloading;
                        },

                        checkForLegacyModules = function()
                                {};
        }

        if( 1 ){
                // this code path assumes the dojo loader and won't work with a standard AMD loader
                var amdValue = {},
                        evalBundle =
                                // use the function ctor to keep the minifiers away (also come close to global scope, but this is secondary)
                                new Function(
                                        "__bundle",                                // the bundle to evalutate
                                        "__checkForLegacyModules", // a function that checks if __bundle defined __mid in the global space
                                        "__mid",                                   // the mid that __bundle is intended to define
                                        "__amdValue",

                                        // returns one of:
                                        //              1 => the bundle was an AMD bundle
                                        //              a legacy bundle object that is the value of __mid
                                        //              instance of Error => could not figure out how to evaluate bundle

                                          // used to detect when __bundle calls define
                                          "var define = function(mid, factory){define.called = 1; __amdValue.result = factory || mid;},"
                                        + "        require = function(){define.called = 1;};"

                                        + "try{"
                                        +               "define.called = 0;"
                                        +               "eval(__bundle);"
                                        +               "if(define.called==1)"
                                                                // bundle called define; therefore signal it's an AMD bundle
                                        +                       "return __amdValue;"

                                        +               "if((__checkForLegacyModules = __checkForLegacyModules(__mid)))"
                                                                // bundle was probably a v1.6- built NLS flattened NLS bundle that defined __mid in the global space
                                        +                       "return __checkForLegacyModules;"

                                        + "}catch(e){}"
                                        // evaulating the bundle was *neither* an AMD *nor* a legacy flattened bundle
                                        // either way, re-eval *after* surrounding with parentheses

                                        + "try{"
                                        +               "return eval('('+__bundle+')');"
                                        + "}catch(e){"
                                        +               "return e;"
                                        + "}"
                                ),

                        syncRequire = function(deps, callback, require){
                                var results = [];
                                array.forEach(deps, function(mid){
                                        var url = require.toUrl(mid + ".js");

                                        function load(text){
                                                var result = evalBundle(text, checkForLegacyModules, mid, amdValue);
                                                if(result===amdValue){
                                                        // the bundle was an AMD module; re-inject it through the normal AMD path
                                                        // we gotta do this since it could be an anonymous module and simply evaluating
                                                        // the text here won't provide the loader with the context to know what
                                                        // module is being defined()'d. With browser caching, this should be free; further
                                                        // this entire code path can be circumvented by using the AMD format to begin with
                                                        results.push(cache[url] = amdValue.result);
                                                }else{
                                                        if(result instanceof Error){
                                                                console.error("failed to evaluate i18n bundle; url=" + url, result);
                                                                result = {};
                                                        }
                                                        // nls/<locale>/<bundle-name> indicates not the root.
                                                        results.push(cache[url] = (/nls\/[^\/]+\/[^\/]+$/.test(url) ? result : {root:result, _v1x:1}));
                                                }
                                        }

                                        if(cache[url]){
                                                results.push(cache[url]);
                                        }else{
                                                var bundle = require.syncLoadNls(mid);
                                                // don't need to check for legacy since syncLoadNls returns a module if the module
                                                // (1) was already loaded, or (2) was in the cache. In case 1, if syncRequire is called
                                                // from getLocalization --> load, then load will have called checkForLegacyModules() before
                                                // calling syncRequire; if syncRequire is called from preloadLocalizations, then we
                                                // don't care about checkForLegacyModules() because that will be done when a particular
                                                // bundle is actually demanded. In case 2, checkForLegacyModules() is never relevant
                                                // because cached modules are always v1.7+ built modules.
                                                if(bundle){
                                                        results.push(bundle);
                                                }else{
                                                        if(!xhr){
                                                                try{
                                                                        require.getText(url, true, load);
                                                                }catch(e){
                                                                        results.push(cache[url] = {});
                                                                }
                                                        }else{
                                                                xhr.get({
                                                                        url:url,
                                                                        sync:true,
                                                                        load:load,
                                                                        error:function(){
                                                                                results.push(cache[url] = {});
                                                                        }
                                                                });
                                                        }
                                                }
                                        }
                                });
                                callback && callback.apply(null, results);
                        };

                checkForLegacyModules = function(target){
                        // legacy code may have already loaded [e.g] the raw bundle x/y/z at x.y.z; when true, push into the cache
                        for(var result, names = target.split("/"), object = dojo.global[names[0]], i = 1; object && i<names.length-1; object = object[names[i++]]){}
                        if(object){
                                result = object[names[i]];
                                if(!result){
                                        // fallback for incorrect bundle build of 1.6
                                        result = object[names[i].replace(/-/g,"_")];
                                }
                                if(result){
                                        cache[target] = result;
                                }
                        }
                        return result;
                };

                thisModule.getLocalization = function(moduleName, bundleName, locale){
                        var result,
                                l10nName = getBundleName(moduleName, bundleName, locale);
                        load(
                                l10nName,

                                // isXd() and syncRequire() need a context-require in order to resolve the mid with respect to a reference module.
                                // Since this legacy function does not have the concept of a reference module, resolve with respect to this
                                // dojo/i18n module, which, itself may have been mapped.
                                (!isXd(l10nName, require) ? function(deps, callback){ syncRequire(deps, callback, require); } : require),

                                function(result_){ result = result_; }
                        );
                        return result;
                };

                if(has("dojo-unit-tests")){
                        unitTests.push(function(doh){
                                doh.register("tests.i18n.unit", function(t){
                                        var check;

                                        check = evalBundle("{prop:1}", checkForLegacyModules, "nonsense", amdValue);
                                        t.is({prop:1}, check); t.is(undefined, check[1]);

                                        check = evalBundle("({prop:1})", checkForLegacyModules, "nonsense", amdValue);
                                        t.is({prop:1}, check); t.is(undefined, check[1]);

                                        check = evalBundle("{'prop-x':1}", checkForLegacyModules, "nonsense", amdValue);
                                        t.is({'prop-x':1}, check); t.is(undefined, check[1]);

                                        check = evalBundle("({'prop-x':1})", checkForLegacyModules, "nonsense", amdValue);
                                        t.is({'prop-x':1}, check); t.is(undefined, check[1]);

                                        check = evalBundle("define({'prop-x':1})", checkForLegacyModules, "nonsense", amdValue);
                                        t.is(amdValue, check); t.is({'prop-x':1}, amdValue.result);

                                        check = evalBundle("define('some/module', {'prop-x':1})", checkForLegacyModules, "nonsense", amdValue);
                                        t.is(amdValue, check); t.is({'prop-x':1}, amdValue.result);

                                        check = evalBundle("this is total nonsense and should throw an error", checkForLegacyModules, "nonsense", amdValue);
                                        t.is(check instanceof Error, true);
                                });
                        });
                }
        }

        return lang.mixin(thisModule, {
                dynamic:true,
                normalize:normalize,
                load:load,
                cache:cache
        });
});

},
'dijit/hccss':function(){
define("dijit/hccss", ["dojo/dom-class", "dojo/hccss", "dojo/ready", "dojo/_base/window"], function(domClass, has, ready, win){

        // module:
        //              dijit/hccss

        /*=====
        return function(){
                // summary:
                //              Test if computer is in high contrast mode, and sets `dijit_a11y` flag on `<body>` if it is.
                //              Deprecated, use ``dojo/hccss`` instead.
        };
        =====*/

        // Priority is 90 to run ahead of parser priority of 100.   For 2.0, remove the ready() call and instead
        // change this module to depend on dojo/domReady!
        ready(90, function(){
                if(has("highcontrast")){
                        domClass.add(win.body(), "dijit_a11y");
                }
        });

        return has;
});

},
'dijit/tree/ForestStoreModel':function(){
define("dijit/tree/ForestStoreModel", [
        "dojo/_base/array", // array.indexOf array.some
        "dojo/_base/declare", // declare
        "dojo/_base/kernel", // global
        "dojo/_base/lang", // lang.hitch
        "./TreeStoreModel"
], function(array, declare, kernel, lang, TreeStoreModel){

// module:
//              dijit/tree/ForestStoreModel

return declare("dijit.tree.ForestStoreModel", TreeStoreModel, {
        // summary:
        //              Interface between a dijit.Tree and a dojo.data store that doesn't have a root item,
        //              a.k.a. a store that has multiple "top level" items.
        //
        // description:
        //              Use this class to wrap a dojo.data store, making all the items matching the specified query
        //              appear as children of a fabricated "root item".  If no query is specified then all the
        //              items returned by fetch() on the underlying store become children of the root item.
        //              This class allows dijit.Tree to assume a single root item, even if the store doesn't have one.
        //
        //              When using this class the developer must override a number of methods according to their app and
        //              data, including:
        //
        //              - onNewRootItem
        //              - onAddToRoot
        //              - onLeaveRoot
        //              - onNewItem
        //              - onSetItem

        // Parameters to constructor

        // rootId: String
        //              ID of fabricated root item
        rootId: "$root$",

        // rootLabel: String
        //              Label of fabricated root item
        rootLabel: "ROOT",

        // query: String
        //              Specifies the set of children of the root item.
        // example:
        //      |       {type:'continent'}
        query: null,

        // End of parameters to constructor

        constructor: function(params){
                // summary:
                //              Sets up variables, etc.
                // tags:
                //              private

                // Make dummy root item
                this.root = {
                        store: this,
                        root: true,
                        id: params.rootId,
                        label: params.rootLabel,
                        children: params.rootChildren   // optional param
                };
        },

        // =======================================================================
        // Methods for traversing hierarchy

        mayHaveChildren: function(/*dojo/data/Item*/ item){
                // summary:
                //              Tells if an item has or may have children.  Implementing logic here
                //              avoids showing +/- expando icon for nodes that we know don't have children.
                //              (For efficiency reasons we may not want to check if an element actually
                //              has children until user clicks the expando node)
                // tags:
                //              extension
                return item === this.root || this.inherited(arguments);
        },

        getChildren: function(/*dojo/data/Item*/ parentItem, /*function(items)*/ callback, /*function*/ onError){
                // summary:
                //              Calls onComplete() with array of child items of given parent item, all loaded.
                if(parentItem === this.root){
                        if(this.root.children){
                                // already loaded, just return
                                callback(this.root.children);
                        }else{
                                this.store.fetch({
                                        query: this.query,
                                        onComplete: lang.hitch(this, function(items){
                                                this.root.children = items;
                                                callback(items);
                                        }),
                                        onError: onError
                                });
                        }
                }else{
                        this.inherited(arguments);
                }
        },

        // =======================================================================
        // Inspecting items

        isItem: function(/* anything */ something){
                return (something === this.root) ? true : this.inherited(arguments);
        },

        fetchItemByIdentity: function(/* object */ keywordArgs){
                if(keywordArgs.identity == this.root.id){
                        var scope = keywordArgs.scope || kernel.global;
                        if(keywordArgs.onItem){
                                keywordArgs.onItem.call(scope, this.root);
                        }
                }else{
                        this.inherited(arguments);
                }
        },

        getIdentity: function(/* item */ item){
                return (item === this.root) ? this.root.id : this.inherited(arguments);
        },

        getLabel: function(/* item */ item){
                return  (item === this.root) ? this.root.label : this.inherited(arguments);
        },

        // =======================================================================
        // Write interface

        newItem: function(/* dijit/tree/dndSource.__Item */ args, /*Item*/ parent, /*int?*/ insertIndex){
                // summary:
                //              Creates a new item.   See dojo/data/api/Write for details on args.
                //              Used in drag & drop when item from external source dropped onto tree.
                if(parent === this.root){
                        this.onNewRootItem(args);
                        return this.store.newItem(args);
                }else{
                        return this.inherited(arguments);
                }
        },

        onNewRootItem: function(/* dijit/tree/dndSource.__Item */ /*===== args =====*/){
                // summary:
                //              User can override this method to modify a new element that's being
                //              added to the root of the tree, for example to add a flag like root=true
        },

        pasteItem: function(/*Item*/ childItem, /*Item*/ oldParentItem, /*Item*/ newParentItem, /*Boolean*/ bCopy, /*int?*/ insertIndex){
                // summary:
                //              Move or copy an item from one parent item to another.
                //              Used in drag & drop
                if(oldParentItem === this.root){
                        if(!bCopy){
                                // It's onLeaveRoot()'s responsibility to modify the item so it no longer matches
                                // this.query... thus triggering an onChildrenChange() event to notify the Tree
                                // that this element is no longer a child of the root node
                                this.onLeaveRoot(childItem);
                        }
                }
                this.inherited(arguments, [childItem,
                        oldParentItem === this.root ? null : oldParentItem,
                        newParentItem === this.root ? null : newParentItem,
                        bCopy,
                        insertIndex
                ]);
                if(newParentItem === this.root){
                        // It's onAddToRoot()'s responsibility to modify the item so it matches
                        // this.query... thus triggering an onChildrenChange() event to notify the Tree
                        // that this element is now a child of the root node
                        this.onAddToRoot(childItem);
                }
        },

        // =======================================================================
        // Handling for top level children

        onAddToRoot: function(/* item */ item){
                // summary:
                //              Called when item added to root of tree; user must override this method
                //              to modify the item so that it matches the query for top level items
                // example:
                //      |       store.setValue(item, "root", true);
                // tags:
                //              extension
                console.log(this, ": item ", item, " added to root");
        },

        onLeaveRoot: function(/* item */ item){
                // summary:
                //              Called when item removed from root of tree; user must override this method
                //              to modify the item so it doesn't match the query for top level items
                // example:
                //      |       store.unsetAttribute(item, "root");
                // tags:
                //              extension
                console.log(this, ": item ", item, " removed from root");
        },

        // =======================================================================
        // Events from data store

        _requeryTop: function(){
                // reruns the query for the children of the root node,
                // sending out an onSet notification if those children have changed
                var oldChildren = this.root.children || [];
                this.store.fetch({
                        query: this.query,
                        onComplete: lang.hitch(this, function(newChildren){
                                this.root.children = newChildren;

                                // If the list of children or the order of children has changed...
                                if(oldChildren.length != newChildren.length ||
                                        array.some(oldChildren, function(item, idx){ return newChildren[idx] != item;})){
                                        this.onChildrenChange(this.root, newChildren);
                                }
                        })
                });
        },

        onNewItem: function(/* dojo/data/api/Item */ item, /* Object */ parentInfo){
                // summary:
                //              Handler for when new items appear in the store.  Developers should override this
                //              method to be more efficient based on their app/data.
                // description:
                //              Note that the default implementation requeries the top level items every time
                //              a new item is created, since any new item could be a top level item (even in
                //              addition to being a child of another item, since items can have multiple parents).
                //
                //              If developers can detect which items are possible top level items (based on the item and the
                //              parentInfo parameters), they should override this method to only call _requeryTop() for top
                //              level items.  Often all top level items have parentInfo==null, but
                //              that will depend on which store you use and what your data is like.
                // tags:
                //              extension
                this._requeryTop();

                this.inherited(arguments);
        },

        onDeleteItem: function(/*Object*/ item){
                // summary:
                //              Handler for delete notifications from underlying store

                // check if this was a child of root, and if so send notification that root's children
                // have changed
                if(array.indexOf(this.root.children, item) != -1){
                        this._requeryTop();
                }

                this.inherited(arguments);
        },

        onSetItem: function(/* item */ item,
                                        /* attribute-name-string */ attribute,
                                        /* Object|Array */ oldValue,
                                        /* Object|Array */ newValue){
                // summary:
                //              Updates the tree view according to changes to an item in the data store.
                //              Developers should override this method to be more efficient based on their app/data.
                // description:
                //              Handles updates to an item's children by calling onChildrenChange(), and
                //              other updates to an item by calling onChange().
                //
                //              Also, any change to any item re-executes the query for the tree's top-level items,
                //              since this modified item may have started/stopped matching the query for top level items.
                //
                //              If possible, developers should override this function to only call _requeryTop() when
                //              the change to the item has caused it to stop/start being a top level item in the tree.
                // tags:
                //              extension

                this._requeryTop();
                this.inherited(arguments);
        }

});

});

},
'url:dijit/layout/templates/AccordionButton.html':"<div data-dojo-attach-event='onclick:_onTitleClick' class='dijitAccordionTitle' role=\"presentation\">\n\t<div data-dojo-attach-point='titleNode,focusNode' data-dojo-attach-event='onkeypress:_onTitleKeyPress'\n\t\t\tclass='dijitAccordionTitleFocus' role=\"tab\" aria-expanded=\"false\"\n\t\t><span class='dijitInline dijitAccordionArrow' role=\"presentation\"></span\n\t\t><span class='arrowTextUp' role=\"presentation\">+</span\n\t\t><span class='arrowTextDown' role=\"presentation\">-</span\n\t\t><img src=\"${_blankGif}\" alt=\"\" class=\"dijitIcon\" data-dojo-attach-point='iconNode' style=\"vertical-align: middle\" role=\"presentation\"/>\n\t\t<span role=\"presentation\" data-dojo-attach-point='titleTextNode' class='dijitAccordionText'></span>\n\t</div>\n</div>\n",
'dijit/form/_ComboBoxMenuMixin':function(){
define("dijit/form/_ComboBoxMenuMixin", [
        "dojo/_base/array", // array.forEach
        "dojo/_base/declare", // declare
        "dojo/dom-attr", // domAttr.set
        "dojo/i18n", // i18n.getLocalization
        "dojo/i18n!./nls/ComboBox"
], function(array, declare, domAttr, i18n){

// module:
//              dijit/form/_ComboBoxMenuMixin

return declare( "dijit.form._ComboBoxMenuMixin", null, {
        // summary:
        //              Focus-less menu for internal use in `dijit/form/ComboBox`
        // tags:
        //              private

        // _messages: Object
        //              Holds "next" and "previous" text for paging buttons on drop down
        _messages: null,

        postMixInProperties: function(){
                this.inherited(arguments);
                this._messages = i18n.getLocalization("dijit.form", "ComboBox", this.lang);
        },

        buildRendering: function(){
                this.inherited(arguments);

                // fill in template with i18n messages
                this.previousButton.innerHTML = this._messages["previousMessage"];
                this.nextButton.innerHTML = this._messages["nextMessage"];
        },

        _setValueAttr: function(/*Object*/ value){
                this.value = value;
                this.onChange(value);
        },

        onClick: function(/*DomNode*/ node){
                if(node == this.previousButton){
                        this._setSelectedAttr(null);
                        this.onPage(-1);
                }else if(node == this.nextButton){
                        this._setSelectedAttr(null);
                        this.onPage(1);
                }else{
                        this.onChange(node);
                }
        },

        // stubs
        onChange: function(/*Number*/ /*===== direction =====*/){
                // summary:
                //              Notifies ComboBox/FilteringSelect that user selected an option.
                // tags:
                //              callback
        },

        onPage: function(/*Number*/ /*===== direction =====*/){
                // summary:
                //              Notifies ComboBox/FilteringSelect that user clicked to advance to next/previous page.
                // tags:
                //              callback
        },

        onClose: function(){
                // summary:
                //              Callback from dijit.popup code to this widget, notifying it that it closed
                // tags:
                //              private
                this._setSelectedAttr(null);
        },

        _createOption: function(/*Object*/ item, labelFunc){
                // summary:
                //              Creates an option to appear on the popup menu subclassed by
                //              `dijit/form/FilteringSelect`.

                var menuitem = this._createMenuItem();
                var labelObject = labelFunc(item);
                if(labelObject.html){
                        menuitem.innerHTML = labelObject.label;
                }else{
                        menuitem.appendChild(
                                menuitem.ownerDocument.createTextNode(labelObject.label)
                        );
                }
                // #3250: in blank options, assign a normal height
                if(menuitem.innerHTML == ""){
                        menuitem.innerHTML = "&#160;";  // &nbsp;
                }

                // update menuitem.dir if BidiSupport was required
                this.applyTextDir(menuitem, (menuitem.innerText || menuitem.textContent || ""));

                return menuitem;
        },

        createOptions: function(results, options, labelFunc){
                // summary:
                //              Fills in the items in the drop down list
                // results:
                //              Array of items
                // options:
                //              The options to the query function of the store
                //
                // labelFunc:
                //              Function to produce a label in the drop down list from a dojo.data item

                this.items = results;

                // display "Previous . . ." button
                this.previousButton.style.display = (options.start == 0) ? "none" : "";
                domAttr.set(this.previousButton, "id", this.id + "_prev");
                // create options using _createOption function defined by parent
                // ComboBox (or FilteringSelect) class
                // #2309:
                //              iterate over cache nondestructively
                array.forEach(results, function(item, i){
                        var menuitem = this._createOption(item, labelFunc);
                        menuitem.setAttribute("item", i);       // index to this.items; use indirection to avoid mem leak
                        domAttr.set(menuitem, "id", this.id + i);
                        this.nextButton.parentNode.insertBefore(menuitem, this.nextButton);
                }, this);
                // display "Next . . ." button
                var displayMore = false;
                // Try to determine if we should show 'more'...
                if(results.total && !results.total.then && results.total != -1){
                        if((options.start + options.count) < results.total){
                                displayMore = true;
                        }else if((options.start + options.count) > results.total && options.count == results.length){
                                // Weird return from a data store, where a start + count > maxOptions
                                // implies maxOptions isn't really valid and we have to go into faking it.
                                // And more or less assume more if count == results.length
                                displayMore = true;
                        }
                }else if(options.count == results.length){
                        //Don't know the size, so we do the best we can based off count alone.
                        //So, if we have an exact match to count, assume more.
                        displayMore = true;
                }

                this.nextButton.style.display = displayMore ? "" : "none";
                domAttr.set(this.nextButton,"id", this.id + "_next");
        },

        clearResultList: function(){
                // summary:
                //              Clears the entries in the drop down list, but of course keeps the previous and next buttons.
                var container = this.containerNode;
                while(container.childNodes.length > 2){
                        container.removeChild(container.childNodes[container.childNodes.length-2]);
                }
                this._setSelectedAttr(null);
        },

        highlightFirstOption: function(){
                // summary:
                //              Highlight the first real item in the list (not Previous Choices).
                this.selectFirstNode();
        },

        highlightLastOption: function(){
                // summary:
                //              Highlight the last real item in the list (not More Choices).
                this.selectLastNode();
        },

        selectFirstNode: function(){
                this.inherited(arguments);
                if(this.getHighlightedOption() == this.previousButton){
                        this.selectNextNode();
                }
        },

        selectLastNode: function(){
                this.inherited(arguments);
                if(this.getHighlightedOption() == this.nextButton){
                        this.selectPreviousNode();
                }
        },

        getHighlightedOption: function(){
                return this.selected;
        }
});

});

},
'dijit/form/_SearchMixin':function(){
define("dijit/form/_SearchMixin", [
        "dojo/data/util/filter", // patternToRegExp
        "dojo/_base/declare", // declare
        "dojo/_base/event", // event.stop
        "dojo/keys", // keys
        "dojo/_base/lang", // lang.clone lang.hitch
        "dojo/query", // query
        "dojo/sniff", // has("ie")
        "dojo/string", // string.substitute
        "dojo/when",
        "../registry"   // registry.byId
], function(filter, declare, event, keys, lang, query, has, string, when, registry){

        // module:
        //              dijit/form/_SearchMixin


        return declare("dijit.form._SearchMixin", null, {
                // summary:
                //              A mixin that implements the base functionality to search a store based upon user-entered text such as
                //              with `dijit/form/ComboBox` or `dijit/form/FilteringSelect`
                // tags:
                //              protected

                // pageSize: Integer
                //              Argument to data provider.
                //              Specifies maximum number of search results to return per query
                pageSize: Infinity,

                // store: [const] dojo/store/api/Store
                //              Reference to data provider object used by this ComboBox.
                //              The store must accept an object hash of properties for its query. See `query` and `queryExpr` for details.
                store: null,

                // fetchProperties: Object
                //              Mixin to the store's fetch.
                //              For example, to set the sort order of the ComboBox menu, pass:
                //      |       { sort: [{attribute:"name",descending: true}] }
                //              To override the default queryOptions so that deep=false, do:
                //      |       { queryOptions: {ignoreCase: true, deep: false} }
                fetchProperties:{},

                // query: Object
                //              A query that can be passed to `store` to initially filter the items.
                //              ComboBox overwrites any reference to the `searchAttr` and sets it to the `queryExpr` with the user's input substituted.
                query: {},

                // searchDelay: Integer
                //              Delay in milliseconds between when user types something and we start
                //              searching based on that value
                searchDelay: 200,

                // searchAttr: String
                //              Search for items in the data store where this attribute (in the item)
                //              matches what the user typed
                searchAttr: "name",

                // queryExpr: String
                //              This specifies what query is sent to the data store,
                //              based on what the user has typed.  Changing this expression will modify
                //              whether the results are only exact matches, a "starting with" match,
                //              etc.
                //              dojo.data query expression pattern.
                //              `${0}` will be substituted for the user text.
                //              `*` is used for wildcards.
                //              `${0}*` means "starts with", `*${0}*` means "contains", `${0}` means "is"
                queryExpr: "${0}*",

                // ignoreCase: Boolean
                //              Set true if the query should ignore case when matching possible items
                ignoreCase: true,

                _abortQuery: function(){
                        // stop in-progress query
                        if(this.searchTimer){
                                this.searchTimer = this.searchTimer.remove();
                        }
                        if(this._queryDeferHandle){
                                this._queryDeferHandle = this._queryDeferHandle.remove();
                        }
                        if(this._fetchHandle){
                                if(this._fetchHandle.abort){
                                        this._cancelingQuery = true;
                                        this._fetchHandle.abort();
                                        this._cancelingQuery = false;
                                }
                                if(this._fetchHandle.cancel){
                                        this._cancelingQuery = true;
                                        this._fetchHandle.cancel();
                                        this._cancelingQuery = false;
                                }
                                this._fetchHandle = null;
                        }
                },

                _processInput: function(/*Event*/ evt){
                        // summary:
                        //              Handles input (keyboard/paste) events
                        if(this.disabled || this.readOnly){ return; }
                        var key = evt.charOrCode;

                        // except for cutting/pasting case - ctrl + x/v
                        if(evt.altKey || ((evt.ctrlKey || evt.metaKey) && (key != 'x' && key != 'v')) || key == keys.SHIFT){
                                return; // throw out weird key combinations and spurious events
                        }

                        var doSearch = false;
                        this._prev_key_backspace = false;

                        switch(key){
                                case keys.DELETE:
                                case keys.BACKSPACE:
                                        this._prev_key_backspace = true;
                                        this._maskValidSubsetError = true;
                                        doSearch = true;
                                        break;

                                default:
                                        // Non char keys (F1-F12 etc..) shouldn't start a search..
                                        // Ascii characters and IME input (Chinese, Japanese etc.) should.
                                        //IME input produces keycode == 229.
                                        doSearch = typeof key == 'string' || key == 229;
                        }
                        if(doSearch){
                                // need to wait a tad before start search so that the event
                                // bubbles through DOM and we have value visible
                                if(!this.store){
                                        this.onSearch();
                                }else{
                                        this.searchTimer = this.defer("_startSearchFromInput", 1);
                                }
                        }
                },

                onSearch: function(/*===== results, query, options =====*/){
                        // summary:
                        //              Callback when a search completes.
                        //
                        // results: Object
                        //              An array of items from the originating _SearchMixin's store.
                        //
                        // query: Object
                        //              A copy of the originating _SearchMixin's query property.
                        //
                        // options: Object
                        //              The additional parameters sent to the originating _SearchMixin's store, including: start, count, queryOptions.
                        //
                        // tags:
                        //              callback
                },

                _startSearchFromInput: function(){
                        this._startSearch(this.focusNode.value.replace(/([\\\*\?])/g, "\\$1"));
                },

                _startSearch: function(/*String*/ text){
                        // summary:
                        //              Starts a search for elements matching text (text=="" means to return all items),
                        //              and calls onSearch(...) when the search completes, to display the results.

                        this._abortQuery();
                        var
                                _this = this,
                                // Setup parameters to be passed to store.query().
                                // Create a new query to prevent accidentally querying for a hidden
                                // value from FilteringSelect's keyField
                                query = lang.clone(this.query), // #5970
                                options = {
                                        start: 0,
                                        count: this.pageSize,
                                        queryOptions: {         // remove for 2.0
                                                ignoreCase: this.ignoreCase,
                                                deep: true
                                        }
                                },
                                qs = string.substitute(this.queryExpr, [text]),
                                q,
                                startQuery = function(){
                                        var resPromise = _this._fetchHandle = _this.store.query(query, options);
                                        if(_this.disabled || _this.readOnly || (q !== _this._lastQuery)){
                                                return;
                                        } // avoid getting unwanted notify
                                        when(resPromise, function(res){
                                                _this._fetchHandle = null;
                                                if(!_this.disabled && !_this.readOnly && (q === _this._lastQuery)){ // avoid getting unwanted notify
                                                        when(resPromise.total, function(total){
                                                                res.total = total;
                                                                var pageSize = _this.pageSize;
                                                                if(isNaN(pageSize) || pageSize > res.total){ pageSize = res.total; }
                                                                // Setup method to fetching the next page of results
                                                                res.nextPage = function(direction){
                                                                        //      tell callback the direction of the paging so the screen
                                                                        //      reader knows which menu option to shout
                                                                        options.direction = direction = direction !== false;
                                                                        options.count = pageSize;
                                                                        if(direction){
                                                                                options.start += res.length;
                                                                                if(options.start >= res.total){
                                                                                        options.count = 0;
                                                                                }
                                                                        }else{
                                                                                options.start -= pageSize;
                                                                                if(options.start < 0){
                                                                                        options.count = Math.max(pageSize + options.start, 0);
                                                                                        options.start = 0;
                                                                                }
                                                                        }
                                                                        if(options.count <= 0){
                                                                                res.length = 0;
                                                                                _this.onSearch(res, query, options);
                                                                        }else{
                                                                                startQuery();
                                                                        }
                                                                };
                                                                _this.onSearch(res, query, options);
                                                        });
                                                }
                                        }, function(err){
                                                _this._fetchHandle = null;
                                                if(!_this._cancelingQuery){     // don't treat canceled query as an error
                                                        console.error(_this.declaredClass + ' ' + err.toString());
                                                }
                                        });
                                };

                        lang.mixin(options, this.fetchProperties);

                        // Generate query
                        if(this.store._oldAPI){
                                // remove this branch for 2.0
                                q = qs;
                        }else{
                                // Query on searchAttr is a regex for benefit of dojo/store/Memory,
                                // but with a toString() method to help dojo/store/JsonRest.
                                // Search string like "Co*" converted to regex like /^Co.*$/i.
                                q = filter.patternToRegExp(qs, this.ignoreCase);
                                q.toString = function(){ return qs; };
                        }

                        // set _lastQuery, *then* start the timeout
                        // otherwise, if the user types and the last query returns before the timeout,
                        // _lastQuery won't be set and their input gets rewritten
                        this._lastQuery = query[this.searchAttr] = q;
                        this._queryDeferHandle = this.defer(startQuery, this.searchDelay);
                },

                //////////// INITIALIZATION METHODS ///////////////////////////////////////

                constructor: function(){
                        this.query={};
                        this.fetchProperties={};
                },

                postMixInProperties: function(){
                        if(!this.store){
                                var list = this.list;
                                if(list){
                                        this.store = registry.byId(list);
                                }
                        }
                        this.inherited(arguments);
                }
        });
});

},
'dojo/parser':function(){
define(
        "dojo/parser", ["require", "./_base/kernel", "./_base/lang", "./_base/array", "./_base/config", "./_base/html", "./_base/window",
                "./_base/url", "./_base/json", "./aspect", "./date/stamp", "./Deferred", "./has", "./query", "./on", "./ready"],
        function(require, dojo, dlang, darray, config, dhtml, dwindow, _Url, djson, aspect, dates, Deferred, has, query, don, ready){

        // module:
        //              dojo/parser

        new Date("X"); // workaround for #11279, new Date("") == NaN


        // Widgets like BorderContainer add properties to _Widget via dojo.extend().
        // If BorderContainer is loaded after _Widget's parameter list has been cached,
        // we need to refresh that parameter list (for _Widget and all widgets that extend _Widget).
        var extendCnt = 0;
        aspect.after(dlang, "extend", function(){
                extendCnt++;
        }, true);

        function getNameMap(ctor){
                // summary:
                //              Returns map from lowercase name to attribute name in class, ex: {onclick: "onClick"}
                var map = ctor._nameCaseMap, proto = ctor.prototype;

                // Create the map if it's undefined.
                // Refresh the map if a superclass was possibly extended with new methods since the map was created.
                if(!map || map._extendCnt < extendCnt){
                        map = ctor._nameCaseMap = {};
                        for(var name in proto){
                                if(name.charAt(0) === "_"){ continue; } // skip internal properties
                                map[name.toLowerCase()] = name;
                        }
                        map._extendCnt = extendCnt;
                }
                return map;
        }

        // Map from widget name or list of widget names(ex: "dijit/form/Button,acme/MyMixin") to a constructor.
        var _ctorMap = {};

        function getCtor(/*String[]*/ types){
                // summary:
                //              Retrieves a constructor.  If the types array contains more than one class/MID then the
                //              subsequent classes will be mixed into the first class and a unique constructor will be
                //              returned for that array.

                var ts = types.join();
                if(!_ctorMap[ts]){
                        var mixins = [];
                        for(var i = 0, l = types.length; i < l; i++){
                                var t = types[i];
                                // TODO: Consider swapping getObject and require in the future
                                mixins[mixins.length] = (_ctorMap[t] = _ctorMap[t] || (dlang.getObject(t) || (~t.indexOf('/') && require(t))));
                        }
                        var ctor = mixins.shift();
                        _ctorMap[ts] = mixins.length ? (ctor.createSubclass ? ctor.createSubclass(mixins) : ctor.extend.apply(ctor, mixins)) : ctor;
                }

                return _ctorMap[ts];
        }

        var parser = {
                // summary:
                //              The Dom/Widget parsing package

                _clearCache: function(){
                        // summary:
                        //              Clear cached data.   Used mainly for benchmarking.
                        extendCnt++;
                        _ctorMap = {};
                },

                _functionFromScript: function(script, attrData){
                        // summary:
                        //              Convert a `<script type="dojo/method" args="a, b, c"> ... </script>`
                        //              into a function
                        // script: DOMNode
                        //              The `<script>` DOMNode
                        // attrData: String
                        //              For HTML5 compliance, searches for attrData + "args" (typically
                        //              "data-dojo-args") instead of "args"
                        var preamble = "",
                                suffix = "",
                                argsStr = (script.getAttribute(attrData + "args") || script.getAttribute("args")),
                                withStr = script.getAttribute("with");

                        // Convert any arguments supplied in script tag into an array to be passed to the
                        var fnArgs = (argsStr || "").split(/\s*,\s*/);

                        if(withStr && withStr.length){
                                darray.forEach(withStr.split(/\s*,\s*/), function(part){
                                        preamble += "with("+part+"){";
                                        suffix += "}";
                                });
                        }

                        return new Function(fnArgs, preamble + script.innerHTML + suffix);
                },

                instantiate: function(nodes, mixin, options){
                        // summary:
                        //              Takes array of nodes, and turns them into class instances and
                        //              potentially calls a startup method to allow them to connect with
                        //              any children.
                        // nodes: Array
                        //              Array of DOM nodes
                        // mixin: Object?
                        //              An object that will be mixed in with each node in the array.
                        //              Values in the mixin will override values in the node, if they
                        //              exist.
                        // options: Object?
                        //              An object used to hold kwArgs for instantiation.
                        //              See parse.options argument for details.

                        mixin = mixin || {};
                        options = options || {};

                        var dojoType = (options.scope || dojo._scopeName) + "Type",             // typically "dojoType"
                                attrData = "data-" + (options.scope || dojo._scopeName) + "-",// typically "data-dojo-"
                                dataDojoType = attrData + "type",                                               // typically "data-dojo-type"
                                dataDojoMixins = attrData + "mixins";                                   // typically "data-dojo-mixins"

                        var list = [];
                        darray.forEach(nodes, function(node){
                                var type = dojoType in mixin ? mixin[dojoType] : node.getAttribute(dataDojoType) || node.getAttribute(dojoType);
                                if(type){
                                        var mixinsValue = node.getAttribute(dataDojoMixins),
                                                types = mixinsValue ? [type].concat(mixinsValue.split(/\s*,\s*/)) : [type];

                                        list.push({
                                                node: node,
                                                types: types
                                        });
                                }
                        });

                        // Instantiate the nodes and return the objects
                        return this._instantiate(list, mixin, options);
                },

                _instantiate: function(nodes, mixin, options){
                        // summary:
                        //              Takes array of objects representing nodes, and turns them into class instances and
                        //              potentially calls a startup method to allow them to connect with
                        //              any children.
                        // nodes: Array
                        //              Array of objects like
                        //      |               {
                        //      |                       ctor: Function (may be null)
                        //      |                       types: ["dijit/form/Button", "acme/MyMixin"] (used if ctor not specified)
                        //      |                       node: DOMNode,
                        //      |                       scripts: [ ... ],       // array of <script type="dojo/..."> children of node
                        //      |                       inherited: { ... }      // settings inherited from ancestors like dir, theme, etc.
                        //      |               }
                        // mixin: Object
                        //              An object that will be mixed in with each node in the array.
                        //              Values in the mixin will override values in the node, if they
                        //              exist.
                        // options: Object
                        //              An options object used to hold kwArgs for instantiation.
                        //              See parse.options argument for details.

                        // Call widget constructors
                        var thelist = darray.map(nodes, function(obj){
                                var ctor = obj.ctor || getCtor(obj.types);
                                // If we still haven't resolved a ctor, it is fatal now
                                if(!ctor){
                                        throw new Error("Unable to resolve constructor for: '" + obj.types.join() + "'");
                                }
                                return this.construct(ctor, obj.node, mixin, options, obj.scripts, obj.inherited);
                        }, this);

                        // Call startup on each top level instance if it makes sense (as for
                        // widgets).  Parent widgets will recursively call startup on their
                        // (non-top level) children
                        if(!mixin._started && !options.noStart){
                                darray.forEach(thelist, function(instance){
                                        if(typeof instance.startup === "function" && !instance._started){
                                                instance.startup();
                                        }
                                });
                        }

                        return thelist;
                },

                construct: function(ctor, node, mixin, options, scripts, inherited){
                        // summary:
                        //              Calls new ctor(params, node), where params is the hash of parameters specified on the node,
                        //              excluding data-dojo-type and data-dojo-mixins.   Does not call startup().   Returns the widget.
                        // ctor: Function
                        //              Widget constructor.
                        // node: DOMNode
                        //              This node will be replaced/attached to by the widget.  It also specifies the arguments to pass to ctor.
                        // mixin: Object?
                        //              Attributes in this object will be passed as parameters to ctor,
                        //              overriding attributes specified on the node.
                        // options: Object?
                        //              An options object used to hold kwArgs for instantiation.   See parse.options argument for details.
                        // scripts: DomNode[]?
                        //              Array of `<script type="dojo/*">` DOMNodes.  If not specified, will search for `<script>` tags inside node.
                        // inherited: Object?
                        //              Settings from dir=rtl or lang=... on a node above this node.   Overrides options.inherited.

                        var proto = ctor && ctor.prototype;
                        options = options || {};

                        // Setup hash to hold parameter settings for this widget.       Start with the parameter
                        // settings inherited from ancestors ("dir" and "lang").
                        // Inherited setting may later be overridden by explicit settings on node itself.
                        var params = {};

                        if(options.defaults){
                                // settings for the document itself (or whatever subtree is being parsed)
                                dlang.mixin(params, options.defaults);
                        }
                        if(inherited){
                                // settings from dir=rtl or lang=... on a node above this node
                                dlang.mixin(params, inherited);
                        }

                        // Get list of attributes explicitly listed in the markup
                        var attributes;
                        if(has("dom-attributes-explicit")){
                                // Standard path to get list of user specified attributes
                                attributes = node.attributes;
                        }else if(has("dom-attributes-specified-flag")){
                                // Special processing needed for IE8, to skip a few faux values in attributes[]
                                attributes = darray.filter(node.attributes, function(a){ return a.specified;});
                        }else{
                                // Special path for IE6-7, avoid (sometimes >100) bogus entries in node.attributes
                                var clone = /^input$|^img$/i.test(node.nodeName) ? node : node.cloneNode(false),
                                        attrs = clone.outerHTML.replace(/=[^\s"']+|="[^"]*"|='[^']*'/g, "").replace(/^\s*<[a-zA-Z0-9]*\s*/, "").replace(/\s*>.*$/, "");

                                attributes = darray.map(attrs.split(/\s+/), function(name){
                                        var lcName = name.toLowerCase();
                                        return {
                                                name: name,
                                                // getAttribute() doesn't work for button.value, returns innerHTML of button.
                                                // but getAttributeNode().value doesn't work for the form.encType or li.value
                                                value: (node.nodeName == "LI" && name == "value") || lcName == "enctype" ?
                                                                node.getAttribute(lcName) : node.getAttributeNode(lcName).value
                                        };
                                });
                        }

                        // Hash to convert scoped attribute name (ex: data-dojo17-params) to something friendly (ex: data-dojo-params)
                        // TODO: remove scope for 2.0
                        var scope = options.scope || dojo._scopeName,
                                attrData = "data-" + scope + "-",                                               // typically "data-dojo-"
                                hash = {};
                        if(scope !== "dojo"){
                                hash[attrData + "props"] = "data-dojo-props";
                                hash[attrData + "type"] = "data-dojo-type";
                                hash[attrData + "mixins"] = "data-dojo-mixins";
                                hash[scope + "type"] = "dojoType";
                                hash[attrData + "id"] = "data-dojo-id";
                        }

                        // Read in attributes and process them, including data-dojo-props, data-dojo-type,
                        // dojoAttachPoint, etc., as well as normal foo=bar attributes.
                        var i=0, item, funcAttrs=[], jsname, extra;
                        while(item = attributes[i++]){
                                var name = item.name,
                                        lcName = name.toLowerCase(),
                                        value = item.value;

                                switch(hash[lcName] || lcName){
                                // Already processed, just ignore
                                case "data-dojo-type":
                                case "dojotype":
                                case "data-dojo-mixins":
                                        break;

                                // Data-dojo-props.   Save for later to make sure it overrides direct foo=bar settings
                                case "data-dojo-props":
                                        extra = value;
                                        break;

                                // data-dojo-id or jsId. TODO: drop jsId in 2.0
                                case "data-dojo-id":
                                case "jsid":
                                        jsname = value;
                                        break;

                                // For the benefit of _Templated
                                case "data-dojo-attach-point":
                                case "dojoattachpoint":
                                        params.dojoAttachPoint = value;
                                        break;
                                case "data-dojo-attach-event":
                                case "dojoattachevent":
                                        params.dojoAttachEvent = value;
                                        break;

                                // Special parameter handling needed for IE
                                case "class":
                                        params["class"] = node.className;
                                        break;
                                case "style":
                                        params["style"] = node.style && node.style.cssText;
                                        break;
                                default:
                                        // Normal attribute, ex: value="123"

                                        // Find attribute in widget corresponding to specified name.
                                        // May involve case conversion, ex: onclick --> onClick
                                        if(!(name in proto)){
                                                var map = getNameMap(ctor);
                                                name = map[lcName] || name;
                                        }

                                        // Set params[name] to value, doing type conversion
                                        if(name in proto){
                                                switch(typeof proto[name]){
                                                case "string":
                                                        params[name] = value;
                                                        break;
                                                case "number":
                                                        params[name] = value.length ? Number(value) : NaN;
                                                        break;
                                                case "boolean":
                                                        // for checked/disabled value might be "" or "checked".  interpret as true.
                                                        params[name] = value.toLowerCase() != "false";
                                                        break;
                                                case "function":
                                                        if(value === "" || value.search(/[^\w\.]+/i) != -1){
                                                                // The user has specified some text for a function like "return x+5"
                                                                params[name] = new Function(value);
                                                        }else{
                                                                // The user has specified the name of a global function like "myOnClick"
                                                                // or a single word function "return"
                                                                params[name] = dlang.getObject(value, false) || new Function(value);
                                                        }
                                                        funcAttrs.push(name);   // prevent "double connect", see #15026
                                                        break;
                                                default:
                                                        var pVal = proto[name];
                                                        params[name] =
                                                                (pVal && "length" in pVal) ? (value ? value.split(/\s*,\s*/) : []) :    // array
                                                                        (pVal instanceof Date) ?
                                                                                (value == "" ? new Date("") :   // the NaN of dates
                                                                                value == "now" ? new Date() :   // current date
                                                                                dates.fromISOString(value)) :
                                                                (pVal instanceof _Url) ? (dojo.baseUrl + value) :
                                                                djson.fromJson(value);
                                                }
                                        }else{
                                                params[name] = value;
                                        }
                                }
                        }

                        // Remove function attributes from DOMNode to prevent "double connect" problem, see #15026.
                        // Do this as a separate loop since attributes[] is often a live collection (depends on the browser though).
                        for(var j=0; j<funcAttrs.length; j++){
                                var lcfname = funcAttrs[j].toLowerCase();
                                node.removeAttribute(lcfname);
                                node[lcfname] = null;
                        }

                        // Mix things found in data-dojo-props into the params, overriding any direct settings
                        if(extra){
                                try{
                                        extra = djson.fromJson.call(options.propsThis, "{" + extra + "}");
                                        dlang.mixin(params, extra);
                                }catch(e){
                                        // give the user a pointer to their invalid parameters. FIXME: can we kill this in production?
                                        throw new Error(e.toString() + " in data-dojo-props='" + extra + "'");
                                }
                        }

                        // Any parameters specified in "mixin" override everything else.
                        dlang.mixin(params, mixin);

                        // Get <script> nodes associated with this widget, if they weren't specified explicitly
                        if(!scripts){
                                scripts = (ctor && (ctor._noScript || proto._noScript) ? [] : query("> script[type^='dojo/']", node));
                        }

                        // Process <script type="dojo/*"> script tags
                        // <script type="dojo/method" event="foo"> tags are added to params, and passed to
                        // the widget on instantiation.
                        // <script type="dojo/method"> tags (with no event) are executed after instantiation
                        // <script type="dojo/connect" data-dojo-event="foo"> tags are dojo.connected after instantiation
                        // <script type="dojo/watch" data-dojo-prop="foo"> tags are dojo.watch after instantiation
                        // <script type="dojo/on" data-dojo-event="foo"> tags are dojo.on after instantiation
                        // note: dojo/* script tags cannot exist in self closing widgets, like <input />
                        var aspects = [],       // aspects to connect after instantiation
                                calls = [],             // functions to call after instantiation
                                watches = [],  // functions to watch after instantiation
                                ons = []; // functions to on after instantiation

                        if(scripts){
                                for(i=0; i<scripts.length; i++){
                                        var script = scripts[i];
                                        node.removeChild(script);
                                        // FIXME: drop event="" support in 2.0. use data-dojo-event="" instead
                                        var event = (script.getAttribute(attrData + "event") || script.getAttribute("event")),
                                                prop = script.getAttribute(attrData + "prop"),
                                                method = script.getAttribute(attrData + "method"),
                                                advice = script.getAttribute(attrData + "advice"),
                                                scriptType = script.getAttribute("type"),
                                                nf = this._functionFromScript(script, attrData);
                                        if(event){
                                                if(scriptType == "dojo/connect"){
                                                        aspects.push({ method: event, func: nf });
                                                }else if(scriptType == "dojo/on"){
                                                        ons.push({ event: event, func: nf });
                                                }else{
                                                        params[event] = nf;
                                                }
                                        }else if(scriptType == "dojo/aspect"){
                                                aspects.push({ method: method, advice: advice, func: nf });
                                        }else if(scriptType == "dojo/watch"){
                                                watches.push({ prop: prop, func: nf });
                                        }else{
                                                calls.push(nf);
                                        }
                                }
                        }

                        // create the instance
                        var markupFactory = ctor.markupFactory || proto.markupFactory;
                        var instance = markupFactory ? markupFactory(params, node, ctor) : new ctor(params, node);

                        // map it to the JS namespace if that makes sense
                        if(jsname){
                                dlang.setObject(jsname, instance);
                        }

                        // process connections and startup functions
                        for(i=0; i<aspects.length; i++){
                                aspect[aspects[i].advice || "after"](instance, aspects[i].method, dlang.hitch(instance, aspects[i].func), true);
                        }
                        for(i=0; i<calls.length; i++){
                                calls[i].call(instance);
                        }
                        for(i=0; i<watches.length; i++){
                                instance.watch(watches[i].prop, watches[i].func);
                        }
                        for(i=0; i<ons.length; i++){
                                don(instance, ons[i].event, ons[i].func);
                        }

                        return instance;
                },

                scan: function(root, options){
                        // summary:
                        //              Scan a DOM tree and return an array of objects representing the DOMNodes
                        //              that need to be turned into widgets.
                        // description:
                        //              Search specified node (or document root node) recursively for class instances
                        //              and return an array of objects that represent potential widgets to be
                        //              instantiated. Searches for either data-dojo-type="MID" or dojoType="MID" where
                        //              "MID" is a module ID like "dijit/form/Button" or a fully qualified Class name
                        //              like "dijit/form/Button".  If the MID is not currently available, scan will
                        //              attempt to require() in the module.
                        //
                        //              See parser.parse() for details of markup.
                        // root: DomNode?
                        //              A default starting root node from which to start the parsing. Can be
                        //              omitted, defaulting to the entire document. If omitted, the `options`
                        //              object can be passed in this place. If the `options` object has a
                        //              `rootNode` member, that is used.
                        // options: Object
                        //              a kwArgs options object, see parse() for details
                        //
                        // returns: Promise
                        //              A promise that is resolved with the nodes that have been parsed.

                        var list = [],  // Output List
                                mids = [], // An array of modules that are not yet loaded
                                midsHash = {}; // Used to keep the mids array unique

                        var dojoType = (options.scope || dojo._scopeName) + "Type",             // typically "dojoType"
                                attrData = "data-" + (options.scope || dojo._scopeName) + "-",  // typically "data-dojo-"
                                dataDojoType = attrData + "type",                                               // typically "data-dojo-type"
                                dataDojoTextDir = attrData + "textdir",                                 // typically "data-dojo-textdir"
                                dataDojoMixins = attrData + "mixins";                                   // typically "data-dojo-mixins"

                        // Info on DOMNode currently being processed
                        var node = root.firstChild;

                        // Info on parent of DOMNode currently being processed
                        //      - inherited: dir, lang, and textDir setting of parent, or inherited by parent
                        //      - parent: pointer to identical structure for my parent (or null if no parent)
                        //      - scripts: if specified, collects <script type="dojo/..."> type nodes from children
                        var inherited = options.inherited;
                        if(!inherited){
                                function findAncestorAttr(node, attr){
                                        return (node.getAttribute && node.getAttribute(attr)) ||
                                                (node.parentNode && findAncestorAttr(node.parentNode, attr));
                                }
                                inherited = {
                                        dir: findAncestorAttr(root, "dir"),
                                        lang: findAncestorAttr(root, "lang"),
                                        textDir: findAncestorAttr(root, dataDojoTextDir)
                                };
                                for(var key in inherited){
                                        if(!inherited[key]){ delete inherited[key]; }
                                }
                        }

                        // Metadata about parent node
                        var parent = {
                                inherited: inherited
                        };

                        // For collecting <script type="dojo/..."> type nodes (when null, we don't need to collect)
                        var scripts;

                        // when true, only look for <script type="dojo/..."> tags, and don't recurse to children
                        var scriptsOnly;

                        function getEffective(parent){
                                // summary:
                                //              Get effective dir, lang, textDir settings for specified obj
                                //              (matching "parent" object structure above), and do caching.
                                //              Take care not to return null entries.
                                if(!parent.inherited){
                                        parent.inherited = {};
                                        var node = parent.node,
                                                grandparent = getEffective(parent.parent);
                                        var inherited  = {
                                                dir: node.getAttribute("dir") || grandparent.dir,
                                                lang: node.getAttribute("lang") || grandparent.lang,
                                                textDir: node.getAttribute(dataDojoTextDir) || grandparent.textDir
                                        };
                                        for(var key in inherited){
                                                if(inherited[key]){
                                                        parent.inherited[key] = inherited[key];
                                                }
                                        }
                                }
                                return parent.inherited;
                        }

                        // DFS on DOM tree, collecting nodes with data-dojo-type specified.
                        while(true){
                                if(!node){
                                        // Finished this level, continue to parent's next sibling
                                        if(!parent || !parent.node){
                                                break;
                                        }
                                        node = parent.node.nextSibling;
                                        scriptsOnly = false;
                                        parent = parent.parent;
                                        scripts = parent.scripts;
                                        continue;
                                }

                                if(node.nodeType != 1){
                                        // Text or comment node, skip to next sibling
                                        node = node.nextSibling;
                                        continue;
                                }

                                if(scripts && node.nodeName.toLowerCase() == "script"){
                                        // Save <script type="dojo/..."> for parent, then continue to next sibling
                                        type = node.getAttribute("type");
                                        if(type && /^dojo\/\w/i.test(type)){
                                                scripts.push(node);
                                        }
                                        node = node.nextSibling;
                                        continue;
                                }
                                if(scriptsOnly){
                                        // scriptsOnly flag is set, we have already collected scripts if the parent wants them, so now we shouldn't
                                        // continue further analysis of the node and will continue to the next sibling
                                        node = node.nextSibling;
                                        continue;
                                }

                                // Check for data-dojo-type attribute, fallback to backward compatible dojoType
                                // TODO: Remove dojoType in 2.0
                                var type = node.getAttribute(dataDojoType) || node.getAttribute(dojoType);

                                // Short circuit for leaf nodes containing nothing [but text]
                                var firstChild = node.firstChild;
                                if(!type && (!firstChild || (firstChild.nodeType == 3 && !firstChild.nextSibling))){
                                        node = node.nextSibling;
                                        continue;
                                }

                                // Meta data about current node
                                var current;

                                var ctor = null;
                                if(type){
                                        // If dojoType/data-dojo-type specified, add to output array of nodes to instantiate.
                                        var mixinsValue = node.getAttribute(dataDojoMixins),
                                                types = mixinsValue ? [type].concat(mixinsValue.split(/\s*,\s*/)) : [type];

                                        // Note: won't find classes declared via dojo/Declaration or any modules that haven't been
                                        // loaded yet so use try/catch to avoid throw from require()
                                        try{
                                                ctor = getCtor(types);
                                        }catch(e){}

                                        // If the constructor was not found, check to see if it has modules that can be loaded
                                        if(!ctor){
                                                darray.forEach(types, function(t){
                                                        if(~t.indexOf('/') && !midsHash[t]){
                                                                // If the type looks like a MID and it currently isn't in the array of MIDs to load, add it.
                                                                midsHash[t] = true;
                                                                mids[mids.length] = t;
                                                        }
                                                });
                                        }

                                        var childScripts = ctor && !ctor.prototype._noScript ? [] : null; // <script> nodes that are parent's children

                                        // Setup meta data about this widget node, and save it to list of nodes to instantiate
                                        current = {
                                                types: types,
                                                ctor: ctor,
                                                parent: parent,
                                                node: node,
                                                scripts: childScripts
                                        };
                                        current.inherited = getEffective(current); // dir & lang settings for current node, explicit or inherited
                                        list.push(current);
                                }else{
                                        // Meta data about this non-widget node
                                        current = {
                                                node: node,
                                                scripts: scripts,
                                                parent: parent
                                        };
                                }

                                // Recurse, collecting <script type="dojo/..."> children, and also looking for
                                // descendant nodes with dojoType specified (unless the widget has the stopParser flag).
                                // When finished with children, go to my next sibling.
                                node = firstChild;
                                scripts = childScripts;
                                scriptsOnly = ctor && ctor.prototype.stopParser && !(options.template);
                                parent = current;
                        }

                        var d = new Deferred();

                        // If there are modules to load then require them in
                        if(mids.length){
                                // Warn that there are modules being auto-required
                                if(has("dojo-debug-messages")){
                                        console.warn("WARNING: Modules being Auto-Required: " + mids.join(", "));
                                }
                                require(mids, function(){
                                        // Go through list of widget nodes, filling in missing constructors, and filtering out nodes that shouldn't
                                        // be instantiated due to a stopParser flag on an ancestor that we belatedly learned about due to
                                        // auto-require of a module like ContentPane.   Assumes list is in DFS order.
                                        d.resolve(darray.filter(list, function(widget){
                                                if(!widget.ctor){
                                                        // Attempt to find the constructor again.   Still won't find classes defined via
                                                        // dijit/Declaration so need to try/catch.
                                                        try{
                                                                widget.ctor = getCtor(widget.types);
                                                        }catch(e){}
                                                }

                                                // Get the parent widget
                                                var parent = widget.parent;
                                                while(parent && !parent.types){
                                                        parent = parent.parent;
                                                }

                                                // Return false if this node should be skipped due to stopParser on an ancestor.
                                                // Since list[] is in DFS order, this loop will always set parent.instantiateChildren before
                                                // trying to compute widget.instantiate.
                                                var proto = widget.ctor && widget.ctor.prototype;
                                                widget.instantiateChildren = !(proto && proto.stopParser && !(options.template));
                                                widget.instantiate = !parent || (parent.instantiate && parent.instantiateChildren);
                                                return widget.instantiate;
                                        }));
                                });
                        }else{
                                // There were no modules to load, so just resolve with the parsed nodes.   This separate code path is for
                                // efficiency, to avoid running the require() and the callback code above.
                                d.resolve(list);
                        }

                        // Return the promise
                        return d.promise;
                },

                _require: function(/*DOMNode*/ script){
                        // summary:
                        //              Helper for _scanAMD().  Takes a `<script type=dojo/require>bar: "acme/bar", ...</script>` node,
                        //              calls require() to load the specified modules and (asynchronously) assign them to the specified global
                        //              variables, and returns a Promise for when that operation completes.
                        //
                        //              In the example above, it is effectively doing a require(["acme/bar", ...], function(a){ bar = a; }).

                        var hash = djson.fromJson("{" + script.innerHTML + "}"),
                                vars = [],
                                mids = [],
                                d = new Deferred();

                        for(var name in hash){
                                vars.push(name);
                                mids.push(hash[name]);
                        }

                        require(mids, function(){
                                for(var i=0; i<vars.length; i++){
                                        dlang.setObject(vars[i], arguments[i]);
                                }
                                d.resolve(arguments);
                        });

                        return d.promise;
                },

                _scanAmd: function(root){
                        // summary:
                        //              Scans the DOM for any declarative requires and returns their values.
                        // description:
                        //              Looks for `<script type=dojo/require>bar: "acme/bar", ...</script>` node, calls require() to load the
                        //              specified modules and (asynchronously) assign them to the specified global variables,
                        //               and returns a Promise for when those operations complete.
                        // root: DomNode
                        //              The node to base the scan from.

                        // Promise that resolves when all the <script type=dojo/require> nodes have finished loading.
                        var deferred = new Deferred(),
                                promise = deferred.promise;
                        deferred.resolve(true);

                        var self = this;
                        query("script[type='dojo/require']", root).forEach(function(node){
                                // Fire off require() call for specified modules.  Chain this require to fire after
                                // any previous requires complete, so that layers can be loaded before individual module require()'s fire.
                                promise = promise.then(function(){ return self._require(node); });

                                // Remove from DOM so it isn't seen again
                                node.parentNode.removeChild(node);
                        });

                        return promise;
                },

                parse: function(rootNode, options){
                        // summary:
                        //              Scan the DOM for class instances, and instantiate them.
                        // description:
                        //              Search specified node (or root node) recursively for class instances,
                        //              and instantiate them. Searches for either data-dojo-type="Class" or
                        //              dojoType="Class" where "Class" is a a fully qualified class name,
                        //              like `dijit/form/Button`
                        //
                        //              Using `data-dojo-type`:
                        //              Attributes using can be mixed into the parameters used to instantiate the
                        //              Class by using a `data-dojo-props` attribute on the node being converted.
                        //              `data-dojo-props` should be a string attribute to be converted from JSON.
                        //
                        //              Using `dojoType`:
                        //              Attributes are read from the original domNode and converted to appropriate
                        //              types by looking up the Class prototype values. This is the default behavior
                        //              from Dojo 1.0 to Dojo 1.5. `dojoType` support is deprecated, and will
                        //              go away in Dojo 2.0.
                        // rootNode: DomNode?
                        //              A default starting root node from which to start the parsing. Can be
                        //              omitted, defaulting to the entire document. If omitted, the `options`
                        //              object can be passed in this place. If the `options` object has a
                        //              `rootNode` member, that is used.
                        // options: Object?
                        //              A hash of options.
                        //
                        //              - noStart: Boolean?:
                        //                      when set will prevent the parser from calling .startup()
                        //                      when locating the nodes.
                        //              - rootNode: DomNode?:
                        //                      identical to the function's `rootNode` argument, though
                        //                      allowed to be passed in via this `options object.
                        //              - template: Boolean:
                        //                      If true, ignores ContentPane's stopParser flag and parses contents inside of
                        //                      a ContentPane inside of a template.   This allows dojoAttachPoint on widgets/nodes
                        //                      nested inside the ContentPane to work.
                        //              - inherited: Object:
                        //                      Hash possibly containing dir and lang settings to be applied to
                        //                      parsed widgets, unless there's another setting on a sub-node that overrides
                        //              - scope: String:
                        //                      Root for attribute names to search for.   If scopeName is dojo,
                        //                      will search for data-dojo-type (or dojoType).   For backwards compatibility
                        //                      reasons defaults to dojo._scopeName (which is "dojo" except when
                        //                      multi-version support is used, when it will be something like dojo16, dojo20, etc.)
                        //              - propsThis: Object:
                        //                      If specified, "this" referenced from data-dojo-props will refer to propsThis.
                        //                      Intended for use from the widgets-in-template feature of `dijit._WidgetsInTemplateMixin`
                        // returns: Mixed
                        //              Returns a blended object that is an array of the instantiated objects, but also can include
                        //              a promise that is resolved with the instantiated objects.  This is done for backwards
                        //              compatibility.  If the parser auto-requires modules, it will always behave in a promise
                        //              fashion and `parser.parse().then(function(instances){...})` should be used.
                        // example:
                        //              Parse all widgets on a page:
                        //      |               parser.parse();
                        // example:
                        //              Parse all classes within the node with id="foo"
                        //      |               parser.parse(dojo.byId('foo'));
                        // example:
                        //              Parse all classes in a page, but do not call .startup() on any
                        //              child
                        //      |               parser.parse({ noStart: true })
                        // example:
                        //              Parse all classes in a node, but do not call .startup()
                        //      |               parser.parse(someNode, { noStart:true });
                        //      |               // or
                        //      |               parser.parse({ noStart:true, rootNode: someNode });

                        // determine the root node and options based on the passed arguments.
                        var root;
                        if(!options && rootNode && rootNode.rootNode){
                                options = rootNode;
                                root = options.rootNode;
                        }else if(rootNode && dlang.isObject(rootNode) && !("nodeType" in rootNode)){
                                options = rootNode;
                        }else{
                                root = rootNode;
                        }
                        root = root ? dhtml.byId(root) : dwindow.body();

                        options = options || {};

                        var mixin = options.template ? { template: true } : {},
                                instances = [],
                                self = this;

                        // First scan for any <script type=dojo/require> nodes, and execute.
                        // Then scan for all nodes with data-dojo-type, and load any unloaded modules.
                        // Then build the object instances.  Add instances to already existing (but empty) instances[] array,
                        // which may already have been returned to caller.  Also, use otherwise to collect and throw any errors
                        // that occur during the parse().
                        var p =
                                this._scanAmd(root, options).then(function(){
                                        return self.scan(root, options);
                                }).then(function(parsedNodes){
                                        return instances = instances.concat(self._instantiate(parsedNodes, mixin, options));
                                }).otherwise(function(e){
                                        // TODO Modify to follow better pattern for promise error managment when available
                                        console.error("dojo/parser::parse() error", e);
                                        throw e;
                                });

                        // Blend the array with the promise
                        dlang.mixin(instances, p);
                        return instances;
                }
        };

        if( 1 ){
                dojo.parser  = parser;
        }

        // Register the parser callback. It should be the first callback
        // after the a11y test.
        if(config.parseOnLoad){
                ready(100, parser, "parse");
        }

        return parser;
});

},
'url:dijit/form/templates/DropDownButton.html':"<span class=\"dijit dijitReset dijitInline\"\n\t><span class='dijitReset dijitInline dijitButtonNode'\n\t\tdata-dojo-attach-event=\"ondijitclick:_onClick\" data-dojo-attach-point=\"_buttonNode\"\n\t\t><span class=\"dijitReset dijitStretch dijitButtonContents\"\n\t\t\tdata-dojo-attach-point=\"focusNode,titleNode,_arrowWrapperNode\"\n\t\t\trole=\"button\" aria-haspopup=\"true\" aria-labelledby=\"${id}_label\"\n\t\t\t><span class=\"dijitReset dijitInline dijitIcon\"\n\t\t\t\tdata-dojo-attach-point=\"iconNode\"\n\t\t\t></span\n\t\t\t><span class=\"dijitReset dijitInline dijitButtonText\"\n\t\t\t\tdata-dojo-attach-point=\"containerNode,_popupStateNode\"\n\t\t\t\tid=\"${id}_label\"\n\t\t\t></span\n\t\t\t><span class=\"dijitReset dijitInline dijitArrowButtonInner\"></span\n\t\t\t><span class=\"dijitReset dijitInline dijitArrowButtonChar\">&#9660;</span\n\t\t></span\n\t></span\n\t><input ${!nameAttrSetting} type=\"${type}\" value=\"${value}\" class=\"dijitOffScreen\" tabIndex=\"-1\"\n\t\tdata-dojo-attach-point=\"valueNode\" role=\"presentation\"\n/></span>\n",
'dojo/dnd/Manager':function(){
define("dojo/dnd/Manager", [
        "../_base/array",  "../_base/declare", "../_base/event", "../_base/lang", "../_base/window",
        "../dom-class", "../Evented", "../has", "../keys", "../on", "../topic", "../touch",
        "./common", "./autoscroll", "./Avatar"
], function(array, declare, event, lang, win, domClass, Evented, has, keys, on, topic, touch,
        dnd, autoscroll, Avatar){

// module:
//              dojo/dnd/Manager

var Manager = declare("dojo.dnd.Manager", [Evented], {
        // summary:
        //              the manager of DnD operations (usually a singleton)
        constructor: function(){
                this.avatar  = null;
                this.source = null;
                this.nodes = [];
                this.copy  = true;
                this.target = null;
                this.canDropFlag = false;
                this.events = [];
        },

        // avatar's offset from the mouse
        OFFSET_X: has("touch") ? 0 : 16,
        OFFSET_Y: has("touch") ? -64 : 16,

        // methods
        overSource: function(source){
                // summary:
                //              called when a source detected a mouse-over condition
                // source: Object
                //              the reporter
                if(this.avatar){
                        this.target = (source && source.targetState != "Disabled") ? source : null;
                        this.canDropFlag = Boolean(this.target);
                        this.avatar.update();
                }
                topic.publish("/dnd/source/over", source);
        },
        outSource: function(source){
                // summary:
                //              called when a source detected a mouse-out condition
                // source: Object
                //              the reporter
                if(this.avatar){
                        if(this.target == source){
                                this.target = null;
                                this.canDropFlag = false;
                                this.avatar.update();
                                topic.publish("/dnd/source/over", null);
                        }
                }else{
                        topic.publish("/dnd/source/over", null);
                }
        },
        startDrag: function(source, nodes, copy){
                // summary:
                //              called to initiate the DnD operation
                // source: Object
                //              the source which provides items
                // nodes: Array
                //              the list of transferred items
                // copy: Boolean
                //              copy items, if true, move items otherwise

                // Tell autoscroll that a drag is starting
                autoscroll.autoScrollStart(win.doc);

                this.source = source;
                this.nodes  = nodes;
                this.copy   = Boolean(copy); // normalizing to true boolean
                this.avatar = this.makeAvatar();
                win.body().appendChild(this.avatar.node);
                topic.publish("/dnd/start", source, nodes, this.copy);
                this.events = [
                        on(win.doc, touch.move, lang.hitch(this, "onMouseMove")),
                        on(win.doc, touch.release,   lang.hitch(this, "onMouseUp")),
                        on(win.doc, "keydown",   lang.hitch(this, "onKeyDown")),
                        on(win.doc, "keyup",     lang.hitch(this, "onKeyUp")),
                        // cancel text selection and text dragging
                        on(win.doc, "dragstart",   event.stop),
                        on(win.body(), "selectstart", event.stop)
                ];
                var c = "dojoDnd" + (copy ? "Copy" : "Move");
                domClass.add(win.body(), c);
        },
        canDrop: function(flag){
                // summary:
                //              called to notify if the current target can accept items
                var canDropFlag = Boolean(this.target && flag);
                if(this.canDropFlag != canDropFlag){
                        this.canDropFlag = canDropFlag;
                        this.avatar.update();
                }
        },
        stopDrag: function(){
                // summary:
                //              stop the DnD in progress
                domClass.remove(win.body(), ["dojoDndCopy", "dojoDndMove"]);
                array.forEach(this.events, function(handle){ handle.remove(); });
                this.events = [];
                this.avatar.destroy();
                this.avatar = null;
                this.source = this.target = null;
                this.nodes = [];
        },
        makeAvatar: function(){
                // summary:
                //              makes the avatar; it is separate to be overwritten dynamically, if needed
                return new Avatar(this);
        },
        updateAvatar: function(){
                // summary:
                //              updates the avatar; it is separate to be overwritten dynamically, if needed
                this.avatar.update();
        },

        // mouse event processors
        onMouseMove: function(e){
                // summary:
                //              event processor for onmousemove
                // e: Event
                //              mouse event
                var a = this.avatar;
                if(a){
                        autoscroll.autoScrollNodes(e);
                        //autoscroll.autoScroll(e);
                        var s = a.node.style;
                        s.left = (e.pageX + this.OFFSET_X) + "px";
                        s.top  = (e.pageY + this.OFFSET_Y) + "px";
                        var copy = Boolean(this.source.copyState(dnd.getCopyKeyState(e)));
                        if(this.copy != copy){
                                this._setCopyStatus(copy);
                        }
                }
                if(has("touch")){
                        // Prevent page from scrolling so that user can drag instead.
                        e.preventDefault();
                }
        },
        onMouseUp: function(e){
                // summary:
                //              event processor for onmouseup
                // e: Event
                //              mouse event
                if(this.avatar){
                        if(this.target && this.canDropFlag){
                                var copy = Boolean(this.source.copyState(dnd.getCopyKeyState(e)));
                                topic.publish("/dnd/drop/before", this.source, this.nodes, copy, this.target, e);
                                topic.publish("/dnd/drop", this.source, this.nodes, copy, this.target, e);
                        }else{
                                topic.publish("/dnd/cancel");
                        }
                        this.stopDrag();
                }
        },

        // keyboard event processors
        onKeyDown: function(e){
                // summary:
                //              event processor for onkeydown:
                //              watching for CTRL for copy/move status, watching for ESCAPE to cancel the drag
                // e: Event
                //              keyboard event
                if(this.avatar){
                        switch(e.keyCode){
                                case keys.CTRL:
                                        var copy = Boolean(this.source.copyState(true));
                                        if(this.copy != copy){
                                                this._setCopyStatus(copy);
                                        }
                                        break;
                                case keys.ESCAPE:
                                        topic.publish("/dnd/cancel");
                                        this.stopDrag();
                                        break;
                        }
                }
        },
        onKeyUp: function(e){
                // summary:
                //              event processor for onkeyup, watching for CTRL for copy/move status
                // e: Event
                //              keyboard event
                if(this.avatar && e.keyCode == keys.CTRL){
                        var copy = Boolean(this.source.copyState(false));
                        if(this.copy != copy){
                                this._setCopyStatus(copy);
                        }
                }
        },

        // utilities
        _setCopyStatus: function(copy){
                // summary:
                //              changes the copy status
                // copy: Boolean
                //              the copy status
                this.copy = copy;
                this.source._markDndStatus(this.copy);
                this.updateAvatar();
                domClass.replace(win.body(),
                        "dojoDnd" + (this.copy ? "Copy" : "Move"),
                        "dojoDnd" + (this.copy ? "Move" : "Copy"));
        }
});

// dnd._manager:
//              The manager singleton variable. Can be overwritten if needed.
dnd._manager = null;

Manager.manager = dnd.manager = function(){
        // summary:
        //              Returns the current DnD manager.  Creates one if it is not created yet.
        if(!dnd._manager){
                dnd._manager = new Manager();
        }
        return dnd._manager;    // Object
};

return Manager;
});

},
'dijit/form/ToggleButton':function(){
define("dijit/form/ToggleButton", [
        "dojo/_base/declare", // declare
        "dojo/_base/kernel", // kernel.deprecated
        "./Button",
        "./_ToggleButtonMixin"
], function(declare, kernel, Button, _ToggleButtonMixin){

        // module:
        //              dijit/form/ToggleButton


        return declare("dijit.form.ToggleButton", [Button, _ToggleButtonMixin], {
                // summary:
                //              A templated button widget that can be in two states (checked or not).
                //              Can be base class for things like tabs or checkbox or radio buttons.

                baseClass: "dijitToggleButton",

                setChecked: function(/*Boolean*/ checked){
                        // summary:
                        //              Deprecated.  Use set('checked', true/false) instead.
                        kernel.deprecated("setChecked("+checked+") is deprecated. Use set('checked',"+checked+") instead.", "", "2.0");
                        this.set('checked', checked);
                }
        });
});

},
'dojo/date/stamp':function(){
define("dojo/date/stamp", ["../_base/lang", "../_base/array"], function(lang, array){

// module:
//              dojo/date/stamp

var stamp = {
        // summary:
        //              TODOC
};
lang.setObject("dojo.date.stamp", stamp);

// Methods to convert dates to or from a wire (string) format using well-known conventions

stamp.fromISOString = function(/*String*/ formattedString, /*Number?*/ defaultTime){
        // summary:
        //              Returns a Date object given a string formatted according to a subset of the ISO-8601 standard.
        //
        // description:
        //              Accepts a string formatted according to a profile of ISO8601 as defined by
        //              [RFC3339](http://www.ietf.org/rfc/rfc3339.txt), except that partial input is allowed.
        //              Can also process dates as specified [by the W3C](http://www.w3.org/TR/NOTE-datetime)
        //              The following combinations are valid:
        //
        //              - dates only
        //                      - yyyy
        //                      - yyyy-MM
        //                      - yyyy-MM-dd
        //              - times only, with an optional time zone appended
        //                      - THH:mm
        //                      - THH:mm:ss
        //                      - THH:mm:ss.SSS
        //              - and "datetimes" which could be any combination of the above
        //
        //              timezones may be specified as Z (for UTC) or +/- followed by a time expression HH:mm
        //              Assumes the local time zone if not specified.  Does not validate.  Improperly formatted
        //              input may return null.  Arguments which are out of bounds will be handled
        //              by the Date constructor (e.g. January 32nd typically gets resolved to February 1st)
        //              Only years between 100 and 9999 are supported.
        // formattedString:
        //              A string such as 2005-06-30T08:05:00-07:00 or 2005-06-30 or T08:05:00
        // defaultTime:
        //              Used for defaults for fields omitted in the formattedString.
        //              Uses 1970-01-01T00:00:00.0Z by default.

        if(!stamp._isoRegExp){
                stamp._isoRegExp =
//TODO: could be more restrictive and check for 00-59, etc.
                        /^(?:(\d{4})(?:-(\d{2})(?:-(\d{2}))?)?)?(?:T(\d{2}):(\d{2})(?::(\d{2})(.\d+)?)?((?:[+-](\d{2}):(\d{2}))|Z)?)?$/;
        }

        var match = stamp._isoRegExp.exec(formattedString),
                result = null;

        if(match){
                match.shift();
                if(match[1]){match[1]--;} // Javascript Date months are 0-based
                if(match[6]){match[6] *= 1000;} // Javascript Date expects fractional seconds as milliseconds

                if(defaultTime){
                        // mix in defaultTime.  Relatively expensive, so use || operators for the fast path of defaultTime === 0
                        defaultTime = new Date(defaultTime);
                        array.forEach(array.map(["FullYear", "Month", "Date", "Hours", "Minutes", "Seconds", "Milliseconds"], function(prop){
                                return defaultTime["get" + prop]();
                        }), function(value, index){
                                match[index] = match[index] || value;
                        });
                }
                result = new Date(match[0]||1970, match[1]||0, match[2]||1, match[3]||0, match[4]||0, match[5]||0, match[6]||0); //TODO: UTC defaults
                if(match[0] < 100){
                        result.setFullYear(match[0] || 1970);
                }

                var offset = 0,
                        zoneSign = match[7] && match[7].charAt(0);
                if(zoneSign != 'Z'){
                        offset = ((match[8] || 0) * 60) + (Number(match[9]) || 0);
                        if(zoneSign != '-'){ offset *= -1; }
                }
                if(zoneSign){
                        offset -= result.getTimezoneOffset();
                }
                if(offset){
                        result.setTime(result.getTime() + offset * 60000);
                }
        }

        return result; // Date or null
};

/*=====
var __Options = {
        // selector: String
        //              "date" or "time" for partial formatting of the Date object.
        //              Both date and time will be formatted by default.
        // zulu: Boolean
        //              if true, UTC/GMT is used for a timezone
        // milliseconds: Boolean
        //              if true, output milliseconds
};
=====*/

stamp.toISOString = function(/*Date*/ dateObject, /*__Options?*/ options){
        // summary:
        //              Format a Date object as a string according a subset of the ISO-8601 standard
        //
        // description:
        //              When options.selector is omitted, output follows [RFC3339](http://www.ietf.org/rfc/rfc3339.txt)
        //              The local time zone is included as an offset from GMT, except when selector=='time' (time without a date)
        //              Does not check bounds.  Only years between 100 and 9999 are supported.
        //
        // dateObject:
        //              A Date object

        var _ = function(n){ return (n < 10) ? "0" + n : n; };
        options = options || {};
        var formattedDate = [],
                getter = options.zulu ? "getUTC" : "get",
                date = "";
        if(options.selector != "time"){
                var year = dateObject[getter+"FullYear"]();
                date = ["0000".substr((year+"").length)+year, _(dateObject[getter+"Month"]()+1), _(dateObject[getter+"Date"]())].join('-');
        }
        formattedDate.push(date);
        if(options.selector != "date"){
                var time = [_(dateObject[getter+"Hours"]()), _(dateObject[getter+"Minutes"]()), _(dateObject[getter+"Seconds"]())].join(':');
                var millis = dateObject[getter+"Milliseconds"]();
                if(options.milliseconds){
                        time += "."+ (millis < 100 ? "0" : "") + _(millis);
                }
                if(options.zulu){
                        time += "Z";
                }else if(options.selector != "time"){
                        var timezoneOffset = dateObject.getTimezoneOffset();
                        var absOffset = Math.abs(timezoneOffset);
                        time += (timezoneOffset > 0 ? "-" : "+") +
                                _(Math.floor(absOffset/60)) + ":" + _(absOffset%60);
                }
                formattedDate.push(time);
        }
        return formattedDate.join('T'); // String
};

return stamp;
});

},
'dojo/Stateful':function(){
define("dojo/Stateful", ["./_base/declare", "./_base/lang", "./_base/array", "dojo/when"], function(declare, lang, array, when){
        // module:
        //              dojo/Stateful

return declare("dojo.Stateful", null, {
        // summary:
        //              Base class for objects that provide named properties with optional getter/setter
        //              control and the ability to watch for property changes
        //
        //              The class also provides the functionality to auto-magically manage getters
        //              and setters for object attributes/properties.
        //              
        //              Getters and Setters should follow the format of _xxxGetter or _xxxSetter where 
        //              the xxx is a name of the attribute to handle.  So an attribute of "foo" 
        //              would have a custom getter of _fooGetter and a custom setter of _fooSetter.
        //
        // example:
        //      |       var obj = new dojo.Stateful();
        //      |       obj.watch("foo", function(){
        //      |               console.log("foo changed to " + this.get("foo"));
        //      |       });
        //      |       obj.set("foo","bar");

        // _attrPairNames: Hash
        //              Used across all instances a hash to cache attribute names and their getter 
        //              and setter names.
        _attrPairNames: {},

        _getAttrNames: function(name){
                // summary:
                //              Helper function for get() and set().
                //              Caches attribute name values so we don't do the string ops every time.
                // tags:
                //              private

                var apn = this._attrPairNames;
                if(apn[name]){ return apn[name]; }
                return (apn[name] = {
                        s: "_" + name + "Setter",
                        g: "_" + name + "Getter"
                });
        },

        postscript: function(/*Object?*/ params){
                // Automatic setting of params during construction
                if (params){ this.set(params); }
        },

        _get: function(name, names){
                // summary:
                //              Private function that does a get based off a hash of names
                // names:
                //              Hash of names of custom attributes
                return typeof this[names.g] === "function" ? this[names.g]() : this[name];
        },
        get: function(/*String*/name){
                // summary:
                //              Get a property on a Stateful instance.
                // name:
                //              The property to get.
                // returns:
                //              The property value on this Stateful instance.
                // description:
                //              Get a named property on a Stateful object. The property may
                //              potentially be retrieved via a getter method in subclasses. In the base class
                //              this just retrieves the object's property.
                //              For example:
                //      |       stateful = new dojo.Stateful({foo: 3});
                //      |       stateful.get("foo") // returns 3
                //      |       stateful.foo // returns 3

                return this._get(name, this._getAttrNames(name)); //Any
        },
        set: function(/*String*/name, /*Object*/value){
                // summary:
                //              Set a property on a Stateful instance
                // name:
                //              The property to set.
                // value:
                //              The value to set in the property.
                // returns:
                //              The function returns this dojo.Stateful instance.
                // description:
                //              Sets named properties on a stateful object and notifies any watchers of
                //              the property. A programmatic setter may be defined in subclasses.
                //              For example:
                //      |       stateful = new dojo.Stateful();
                //      |       stateful.watch(function(name, oldValue, value){
                //      |               // this will be called on the set below
                //      |       }
                //      |       stateful.set(foo, 5);
                //
                //      set() may also be called with a hash of name/value pairs, ex:
                //      |       myObj.set({
                //      |               foo: "Howdy",
                //      |               bar: 3
                //      |       })
                //      This is equivalent to calling set(foo, "Howdy") and set(bar, 3)

                // If an object is used, iterate through object
                if(typeof name === "object"){
                        for(var x in name){
                                if(name.hasOwnProperty(x) && x !="_watchCallbacks"){
                                        this.set(x, name[x]);
                                }
                        }
                        return this;
                }

                var names = this._getAttrNames(name),
                        oldValue = this._get(name, names),
                        setter = this[names.s],
                        result;
                if(typeof setter === "function"){
                        // use the explicit setter
                        result = setter.apply(this, Array.prototype.slice.call(arguments, 1));
                }else{
                        // no setter so set attribute directly
                        this[name] = value;
                }
                if(this._watchCallbacks){
                        var self = this;
                        // If setter returned a promise, wait for it to complete, otherwise call watches immediatly
                        when(result, function(){
                                self._watchCallbacks(name, oldValue, value);
                        });
                }
                return this; // dojo/Stateful
        },
        _changeAttrValue: function(name, value){
                // summary:
                //              Internal helper for directly changing an attribute value.
                //
                // name: String
                //              The property to set.
                // value: Mixed
                //              The value to set in the property.
                //
                // description:
                //              Directly change the value of an attribute on an object, bypassing any 
                //              accessor setter.  Also handles the calling of watch and emitting events. 
                //              It is designed to be used by descendent class when there are two values 
                //              of attributes that are linked, but calling .set() is not appropriate.

                var oldValue = this.get(name);
                this[name] = value;
                if(this._watchCallbacks){
                        this._watchCallbacks(name, oldValue, value);
                }
                return this; // dojo/Stateful
        },
        watch: function(/*String?*/name, /*Function*/callback){
                // summary:
                //              Watches a property for changes
                // name:
                //              Indicates the property to watch. This is optional (the callback may be the
                //              only parameter), and if omitted, all the properties will be watched
                // returns:
                //              An object handle for the watch. The unwatch method of this object
                //              can be used to discontinue watching this property:
                //              |       var watchHandle = obj.watch("foo", callback);
                //              |       watchHandle.unwatch(); // callback won't be called now
                // callback:
                //              The function to execute when the property changes. This will be called after
                //              the property has been changed. The callback will be called with the |this|
                //              set to the instance, the first argument as the name of the property, the
                //              second argument as the old value and the third argument as the new value.

                var callbacks = this._watchCallbacks;
                if(!callbacks){
                        var self = this;
                        callbacks = this._watchCallbacks = function(name, oldValue, value, ignoreCatchall){
                                var notify = function(propertyCallbacks){
                                        if(propertyCallbacks){
                                                propertyCallbacks = propertyCallbacks.slice();
                                                for(var i = 0, l = propertyCallbacks.length; i < l; i++){
                                                        propertyCallbacks[i].call(self, name, oldValue, value);
                                                }
                                        }
                                };
                                notify(callbacks['_' + name]);
                                if(!ignoreCatchall){
                                        notify(callbacks["*"]); // the catch-all
                                }
                        }; // we use a function instead of an object so it will be ignored by JSON conversion
                }
                if(!callback && typeof name === "function"){
                        callback = name;
                        name = "*";
                }else{
                        // prepend with dash to prevent name conflicts with function (like "name" property)
                        name = '_' + name;
                }
                var propertyCallbacks = callbacks[name];
                if(typeof propertyCallbacks !== "object"){
                        propertyCallbacks = callbacks[name] = [];
                }
                propertyCallbacks.push(callback);

                // TODO: Remove unwatch in 2.0
                var handle = {};
                handle.unwatch = handle.remove = function(){
                        var index = array.indexOf(propertyCallbacks, callback);
                        if(index > -1){
                                propertyCallbacks.splice(index, 1);
                        }
                };
                return handle; //Object
        }

});

});

},
'dijit/layout/AccordionContainer':function(){
require({cache:{
'url:dijit/layout/templates/AccordionButton.html':"<div data-dojo-attach-event='onclick:_onTitleClick' class='dijitAccordionTitle' role=\"presentation\">\n\t<div data-dojo-attach-point='titleNode,focusNode' data-dojo-attach-event='onkeypress:_onTitleKeyPress'\n\t\t\tclass='dijitAccordionTitleFocus' role=\"tab\" aria-expanded=\"false\"\n\t\t><span class='dijitInline dijitAccordionArrow' role=\"presentation\"></span\n\t\t><span class='arrowTextUp' role=\"presentation\">+</span\n\t\t><span class='arrowTextDown' role=\"presentation\">-</span\n\t\t><img src=\"${_blankGif}\" alt=\"\" class=\"dijitIcon\" data-dojo-attach-point='iconNode' style=\"vertical-align: middle\" role=\"presentation\"/>\n\t\t<span role=\"presentation\" data-dojo-attach-point='titleTextNode' class='dijitAccordionText'></span>\n\t</div>\n</div>\n"}});
define("dijit/layout/AccordionContainer", [
        "require",
        "dojo/_base/array", // array.forEach array.map
        "dojo/_base/declare", // declare
        "dojo/_base/event", // event.stop
        "dojo/_base/fx", // fx.Animation
        "dojo/dom", // dom.setSelectable
        "dojo/dom-attr", // domAttr.attr
        "dojo/dom-class", // domClass.remove
        "dojo/dom-construct", // domConstruct.place
        "dojo/dom-geometry",
        "dojo/keys", // keys
        "dojo/_base/lang", // lang.getObject lang.hitch
        "dojo/sniff", // has("ie") has("dijit-legacy-requires")
        "dojo/topic", // publish
        "../focus",                     // focus.focus()
        "../_base/manager",     // manager.defaultDuration
        "dojo/ready",
        "../_Widget",
        "../_Container",
        "../_TemplatedMixin",
        "../_CssStateMixin",
        "./StackContainer",
        "./ContentPane",
        "dojo/text!./templates/AccordionButton.html"
], function(require, array, declare, event, fx, dom, domAttr, domClass, domConstruct, domGeometry,
                        keys, lang, has, topic, focus, manager, ready,
                        _Widget, _Container, _TemplatedMixin, _CssStateMixin, StackContainer, ContentPane, template){

        // module:
        //              dijit/layout/AccordionContainer


        // Design notes:
        //
        // An AccordionContainer is a StackContainer, but each child (typically ContentPane)
        // is wrapped in a _AccordionInnerContainer.   This is hidden from the caller.
        //
        // The resulting markup will look like:
        //
        //      <div class=dijitAccordionContainer>
        //              <div class=dijitAccordionInnerContainer>        (one pane)
        //                              <div class=dijitAccordionTitle>         (title bar) ... </div>
        //                              <div class=dijtAccordionChildWrapper>   (content pane) </div>
        //              </div>
        //      </div>
        //
        // Normally the dijtAccordionChildWrapper is hidden for all but one child (the shown
        // child), so the space for the content pane is all the title bars + the one dijtAccordionChildWrapper,
        // which on claro has a 1px border plus a 2px bottom margin.
        //
        // During animation there are two dijtAccordionChildWrapper's shown, so we need
        // to compensate for that.


        var AccordionButton = declare("dijit.layout._AccordionButton", [_Widget, _TemplatedMixin, _CssStateMixin], {
                // summary:
                //              The title bar to click to open up an accordion pane.
                //              Internal widget used by AccordionContainer.
                // tags:
                //              private

                templateString: template,

                // label: String
                //              Title of the pane
                label: "",
                _setLabelAttr: {node: "titleTextNode", type: "innerHTML" },

                // title: String
                //              Tooltip that appears on hover
                title: "",
                _setTitleAttr: {node: "titleTextNode", type: "attribute", attribute: "title"},

                // iconClassAttr: String
                //              CSS class for icon to left of label
                iconClassAttr: "",
                _setIconClassAttr: { node: "iconNode", type: "class" },

                baseClass: "dijitAccordionTitle",

                getParent: function(){
                        // summary:
                        //              Returns the AccordionContainer parent.
                        // tags:
                        //              private
                        return this.parent;
                },

                buildRendering: function(){
                        this.inherited(arguments);
                        var titleTextNodeId = this.id.replace(' ','_');
                        domAttr.set(this.titleTextNode, "id", titleTextNodeId+"_title");
                        this.focusNode.setAttribute("aria-labelledby", domAttr.get(this.titleTextNode, "id"));
                        dom.setSelectable(this.domNode, false);
                },

                getTitleHeight: function(){
                        // summary:
                        //              Returns the height of the title dom node.
                        return domGeometry.getMarginSize(this.domNode).h;       // Integer
                },

                // TODO: maybe the parent should set these methods directly rather than forcing the code
                // into the button widget?
                _onTitleClick: function(){
                        // summary:
                        //              Callback when someone clicks my title.
                        var parent = this.getParent();
                                parent.selectChild(this.contentWidget, true);
                                focus.focus(this.focusNode);
                },

                _onTitleKeyPress: function(/*Event*/ evt){
                        return this.getParent()._onKeyPress(evt, this.contentWidget);
                },

                _setSelectedAttr: function(/*Boolean*/ isSelected){
                        this._set("selected", isSelected);
                        this.focusNode.setAttribute("aria-expanded", isSelected ? "true" : "false");
                        this.focusNode.setAttribute("aria-selected", isSelected ? "true" : "false");
                        this.focusNode.setAttribute("tabIndex", isSelected ? "0" : "-1");
                }
        });

        var AccordionInnerContainer = declare("dijit.layout._AccordionInnerContainer", [_Widget, _CssStateMixin], {
                // summary:
                //              Internal widget placed as direct child of AccordionContainer.containerNode.
                //              When other widgets are added as children to an AccordionContainer they are wrapped in
                //              this widget.

/*=====
                // buttonWidget: Function|String
                //              Class to use to instantiate title
                //              (Wish we didn't have a separate widget for just the title but maintaining it
                //              for backwards compatibility, is it worth it?)
                 buttonWidget: null,
=====*/

/*=====
                // contentWidget: dijit/_WidgetBase
                //              Pointer to the real child widget
                contentWidget: null,
=====*/

                baseClass: "dijitAccordionInnerContainer",

                // tell nested layout widget that we will take care of sizing
                isLayoutContainer: true,

                buildRendering: function(){
                        // Builds a template like:
                        //      <div class=dijitAccordionInnerContainer>
                        //              Button
                        //              <div class=dijitAccordionChildWrapper>
                        //                      ContentPane
                        //              </div>
                        //      </div>

                        // Create wrapper div, placed where the child is now
                        this.domNode = domConstruct.place("<div class='" + this.baseClass +
                                "' role='presentation'>", this.contentWidget.domNode, "after");

                        // wrapper div's first child is the button widget (ie, the title bar)
                        var child = this.contentWidget,
                                cls = lang.isString(this.buttonWidget) ? lang.getObject(this.buttonWidget) : this.buttonWidget;
                        this.button = child._buttonWidget = (new cls({
                                contentWidget: child,
                                label: child.title,
                                title: child.tooltip,
                                dir: child.dir,
                                lang: child.lang,
                                textDir: child.textDir,
                                iconClass: child.iconClass,
                                id: child.id + "_button",
                                parent: this.parent
                        })).placeAt(this.domNode);

                        // and then the actual content widget (changing it from prior-sibling to last-child),
                        // wrapped by a <div class=dijitAccordionChildWrapper>
                        this.containerNode = domConstruct.place("<div class='dijitAccordionChildWrapper' style='display:none'>", this.domNode);
                        domConstruct.place(this.contentWidget.domNode, this.containerNode);
                },

                postCreate: function(){
                        this.inherited(arguments);

                        // Map changes in content widget's title etc. to changes in the button
                        var button = this.button;
                        this._contentWidgetWatches = [
                                this.contentWidget.watch('title', lang.hitch(this, function(name, oldValue, newValue){
                                        button.set("label", newValue);
                                })),
                                this.contentWidget.watch('tooltip', lang.hitch(this, function(name, oldValue, newValue){
                                        button.set("title", newValue);
                                })),
                                this.contentWidget.watch('iconClass', lang.hitch(this, function(name, oldValue, newValue){
                                        button.set("iconClass", newValue);
                                }))
                        ];
                },

                _setSelectedAttr: function(/*Boolean*/ isSelected){
                        this._set("selected", isSelected);
                        this.button.set("selected", isSelected);
                        if(isSelected){
                                var cw = this.contentWidget;
                                if(cw.onSelected){ cw.onSelected(); }
                        }
                },

                startup: function(){
                        // Called by _Container.addChild()
                        this.contentWidget.startup();
                },

                destroy: function(){
                        this.button.destroyRecursive();

                        array.forEach(this._contentWidgetWatches || [], function(w){ w.unwatch(); });

                        delete this.contentWidget._buttonWidget;
                        delete this.contentWidget._wrapperWidget;

                        this.inherited(arguments);
                },

                destroyDescendants: function(/*Boolean*/ preserveDom){
                        // since getChildren isn't working for me, have to code this manually
                        this.contentWidget.destroyRecursive(preserveDom);
                }
        });

        var AccordionContainer = declare("dijit.layout.AccordionContainer", StackContainer, {
                // summary:
                //              Holds a set of panes where every pane's title is visible, but only one pane's content is visible at a time,
                //              and switching between panes is visualized by sliding the other panes up/down.
                // example:
                //      |       <div data-dojo-type="dijit/layout/AccordionContainer">
                //      |               <div data-dojo-type="dijit/layout/ContentPane" title="pane 1">
                //      |               </div>
                //      |               <div data-dojo-type="dijit/layout/ContentPane" title="pane 2">
                //      |                       <p>This is some text</p>
                //      |               </div>
                //      |       </div>

                // duration: Integer
                //              Amount of time (in ms) it takes to slide panes
                duration: manager.defaultDuration,

                // buttonWidget: [const] String
                //              The name of the widget used to display the title of each pane
                buttonWidget: AccordionButton,

/*=====
                // _verticalSpace: Number
                //              Pixels of space available for the open pane
                //              (my content box size minus the cumulative size of all the title bars)
                _verticalSpace: 0,
=====*/
                baseClass: "dijitAccordionContainer",

                buildRendering: function(){
                        this.inherited(arguments);
                        this.domNode.style.overflow = "hidden";         // TODO: put this in dijit.css
                        this.domNode.setAttribute("role", "tablist");   // TODO: put this in template
                },

                startup: function(){
                        if(this._started){ return; }
                        this.inherited(arguments);
                        if(this.selectedChildWidget){
                                this.selectedChildWidget._wrapperWidget.set("selected", true);
                        }
                },

                layout: function(){
                        // Implement _LayoutWidget.layout() virtual method.
                        // Set the height of the open pane based on what room remains.

                        var openPane = this.selectedChildWidget;

                        if(!openPane){ return;}

                        // space taken up by title, plus wrapper div (with border/margin) for open pane
                        var wrapperDomNode = openPane._wrapperWidget.domNode,
                                wrapperDomNodeMargin = domGeometry.getMarginExtents(wrapperDomNode),
                                wrapperDomNodePadBorder = domGeometry.getPadBorderExtents(wrapperDomNode),
                                wrapperContainerNode = openPane._wrapperWidget.containerNode,
                                wrapperContainerNodeMargin = domGeometry.getMarginExtents(wrapperContainerNode),
                                wrapperContainerNodePadBorder = domGeometry.getPadBorderExtents(wrapperContainerNode),
                                mySize = this._contentBox;

                        // get cumulative height of all the unselected title bars
                        var totalCollapsedHeight = 0;
                        array.forEach(this.getChildren(), function(child){
                    if(child != openPane){
                                        // Using domGeometry.getMarginSize() rather than domGeometry.position() since claro has 1px bottom margin
                                        // to separate accordion panes.  Not sure that works perfectly, it's probably putting a 1px
                                        // margin below the bottom pane (even though we don't want one).
                                        totalCollapsedHeight += domGeometry.getMarginSize(child._wrapperWidget.domNode).h;
                                }
                        });
                        this._verticalSpace = mySize.h - totalCollapsedHeight - wrapperDomNodeMargin.h
                                - wrapperDomNodePadBorder.h - wrapperContainerNodeMargin.h - wrapperContainerNodePadBorder.h
                                - openPane._buttonWidget.getTitleHeight();

                        // Memo size to make displayed child
                        this._containerContentBox = {
                                h: this._verticalSpace,
                                w: this._contentBox.w - wrapperDomNodeMargin.w - wrapperDomNodePadBorder.w
                                        - wrapperContainerNodeMargin.w - wrapperContainerNodePadBorder.w
                        };

                        if(openPane){
                                openPane.resize(this._containerContentBox);
                        }
                },

                _setupChild: function(child){
                        // Overrides _LayoutWidget._setupChild().
                        // Put wrapper widget around the child widget, showing title

                        child._wrapperWidget = AccordionInnerContainer({
                                contentWidget: child,
                                buttonWidget: this.buttonWidget,
                                id: child.id + "_wrapper",
                                dir: child.dir,
                                lang: child.lang,
                                textDir: child.textDir,
                                parent: this
                        });

                        this.inherited(arguments);
                },

                addChild: function(/*dijit/_WidgetBase*/ child, /*Integer?*/ insertIndex){
                        // Overrides _LayoutWidget.addChild().
                        if(this._started){
                                // Adding a child to a started Accordion is complicated because children have
                                // wrapper widgets.  Default code path (calling this.inherited()) would add
                                // the new child inside another child's wrapper.

                                // First add in child as a direct child of this AccordionContainer
                                var refNode = this.containerNode;
                                if(insertIndex && typeof insertIndex == "number"){
                                        var children = _Widget.prototype.getChildren.call(this);        // get wrapper panes
                                        if(children && children.length >= insertIndex){
                                                refNode = children[insertIndex-1].domNode;
                                                insertIndex = "after";
                                        }
                                }
                                domConstruct.place(child.domNode, refNode, insertIndex);

                                if(!child._started){
                                        child.startup();
                                }

                                // Then stick the wrapper widget around the child widget
                                this._setupChild(child);

                                // Code below copied from StackContainer
                                topic.publish(this.id+"-addChild", child, insertIndex); // publish
                                this.layout();
                                if(!this.selectedChildWidget){
                                        this.selectChild(child);
                                }
                        }else{
                                // We haven't been started yet so just add in the child widget directly,
                                // and the wrapper will be created on startup()
                                this.inherited(arguments);
                        }
                },

                removeChild: function(child){
                        // Overrides _LayoutWidget.removeChild().

                        // Destroy wrapper widget first, before StackContainer.getChildren() call.
                        // Replace wrapper widget with true child widget (ContentPane etc.).
                        // This step only happens if the AccordionContainer has been started; otherwise there's no wrapper.
                        if(child._wrapperWidget){
                                domConstruct.place(child.domNode, child._wrapperWidget.domNode, "after");
                                child._wrapperWidget.destroy();
                                delete child._wrapperWidget;
                        }

                        domClass.remove(child.domNode, "dijitHidden");

                        this.inherited(arguments);
                },

                getChildren: function(){
                        // Overrides _Container.getChildren() to return content panes rather than internal AccordionInnerContainer panes
                        return array.map(this.inherited(arguments), function(child){
                                return child.declaredClass == "dijit.layout._AccordionInnerContainer" ? child.contentWidget : child;
                        }, this);
                },

                destroy: function(){
                        if(this._animation){
                                this._animation.stop();
                        }
                        array.forEach(this.getChildren(), function(child){
                                // If AccordionContainer has been started, then each child has a wrapper widget which
                                // also needs to be destroyed.
                                if(child._wrapperWidget){
                                        child._wrapperWidget.destroy();
                                }else{
                                        child.destroyRecursive();
                                }
                        });
                        this.inherited(arguments);
                },

                _showChild: function(child){
                        // Override StackContainer._showChild() to set visibility of _wrapperWidget.containerNode
                        child._wrapperWidget.containerNode.style.display="block";
                        return this.inherited(arguments);
                },

                _hideChild: function(child){
                        // Override StackContainer._showChild() to set visibility of _wrapperWidget.containerNode
                        child._wrapperWidget.containerNode.style.display="none";
                        this.inherited(arguments);
                },

                _transition: function(/*dijit/_WidgetBase?*/ newWidget, /*dijit/_WidgetBase?*/ oldWidget, /*Boolean*/ animate){
                        // Overrides StackContainer._transition() to provide sliding of title bars etc.

                        if(has("ie") < 8){
                                // workaround animation bugs by not animating; not worth supporting animation for IE6 & 7
                                animate = false;
                        }

                        if(this._animation){
                                // there's an in-progress animation.  speedily end it so we can do the newly requested one
                                this._animation.stop(true);
                                delete this._animation;
                        }

                        var self = this;

                        if(newWidget){
                                newWidget._wrapperWidget.set("selected", true);

                                var d = this._showChild(newWidget);     // prepare widget to be slid in

                                // Size the new widget, in case this is the first time it's being shown,
                                // or I have been resized since the last time it was shown.
                                // Note that page must be visible for resizing to work.
                                if(this.doLayout && newWidget.resize){
                                        newWidget.resize(this._containerContentBox);
                                }
                        }

                        if(oldWidget){
                                oldWidget._wrapperWidget.set("selected", false);
                                if(!animate){
                                        this._hideChild(oldWidget);
                                }
                        }

                        if(animate){
                                var newContents = newWidget._wrapperWidget.containerNode,
                                        oldContents = oldWidget._wrapperWidget.containerNode;

                                // During the animation we will be showing two dijitAccordionChildWrapper nodes at once,
                                // which on claro takes up 4px extra space (compared to stable AccordionContainer).
                                // Have to compensate for that by immediately shrinking the pane being closed.
                                var wrapperContainerNode = newWidget._wrapperWidget.containerNode,
                                        wrapperContainerNodeMargin = domGeometry.getMarginExtents(wrapperContainerNode),
                                        wrapperContainerNodePadBorder = domGeometry.getPadBorderExtents(wrapperContainerNode),
                                        animationHeightOverhead = wrapperContainerNodeMargin.h + wrapperContainerNodePadBorder.h;

                                oldContents.style.height = (self._verticalSpace - animationHeightOverhead) + "px";

                                this._animation = new fx.Animation({
                                        node: newContents,
                                        duration: this.duration,
                                        curve: [1, this._verticalSpace - animationHeightOverhead - 1],
                                        onAnimate: function(value){
                                                value = Math.floor(value);      // avoid fractional values
                                                newContents.style.height = value + "px";
                                                oldContents.style.height = (self._verticalSpace - animationHeightOverhead - value) + "px";
                                        },
                                        onEnd: function(){
                                                delete self._animation;
                                                newContents.style.height = "auto";
                                                oldWidget._wrapperWidget.containerNode.style.display = "none";
                                                oldContents.style.height = "auto";
                                                self._hideChild(oldWidget);
                                        }
                                });
                                this._animation.onStop = this._animation.onEnd;
                                this._animation.play();
                        }

                        return d;       // If child has an href, promise that fires when the widget has finished loading
                },

                // note: we are treating the container as controller here
                _onKeyPress: function(/*Event*/ e, /*dijit/_WidgetBase*/ fromTitle){
                        // summary:
                        //              Handle keypress events
                        // description:
                        //              This is called from a handler on AccordionContainer.domNode
                        //              (setup in StackContainer), and is also called directly from
                        //              the click handler for accordion labels
                        if(this.disabled || e.altKey || !(fromTitle || e.ctrlKey)){
                                return;
                        }
                        var c = e.charOrCode;
                        if((fromTitle && (c == keys.LEFT_ARROW || c == keys.UP_ARROW)) ||
                                        (e.ctrlKey && c == keys.PAGE_UP)){
                                this._adjacent(false)._buttonWidget._onTitleClick();
                                event.stop(e);
                        }else if((fromTitle && (c == keys.RIGHT_ARROW || c == keys.DOWN_ARROW)) ||
                                        (e.ctrlKey && (c == keys.PAGE_DOWN || c == keys.TAB))){
                                this._adjacent(true)._buttonWidget._onTitleClick();
                                event.stop(e);
                        }
                }
        });

        // Back compat w/1.6, remove for 2.0
        if(has("dijit-legacy-requires")){
                ready(0, function(){
                        var requires = ["dijit/layout/AccordionPane"];
                        require(requires);      // use indirection so modules not rolled into a build
                });
        }

        // For monkey patching
        AccordionContainer._InnerContainer = AccordionInnerContainer;
        AccordionContainer._Button = AccordionButton;

        return AccordionContainer;
});

},
'dijit/form/_AutoCompleterMixin':function(){
define("dijit/form/_AutoCompleterMixin", [
        "dojo/data/util/filter", // patternToRegExp
        "dojo/_base/declare", // declare
        "dojo/dom-attr", // domAttr.get
        "dojo/_base/event", // event.stop
        "dojo/keys",
        "dojo/_base/lang", // lang.clone lang.hitch
        "dojo/query", // query
        "dojo/regexp", // regexp.escapeString
        "dojo/sniff", // has("ie")
        "dojo/string", // string.substitute
        "./DataList",
        "../registry",  // registry.byId
        "./_TextBoxMixin",      // defines _TextBoxMixin.selectInputText
        "./_SearchMixin"
], function(filter, declare, domAttr, event, keys, lang, query, regexp, has, string,
                        DataList, registry, _TextBoxMixin, SearchMixin){

        // module:
        //              dijit/form/_AutoCompleterMixin

        return declare("dijit.form._AutoCompleterMixin", SearchMixin, {
                // summary:
                //              A mixin that implements the base functionality for `dijit/form/ComboBox`/`dijit/form/FilteringSelect`
                // description:
                //              All widgets that mix in dijit/form/_AutoCompleterMixin must extend `dijit/form/_FormValueWidget`.
                // tags:
                //              protected

                // item: Object
                //              This is the item returned by the dojo/store/api/Store implementation that
                //              provides the data for this ComboBox, it's the currently selected item.
                item: null,

                // autoComplete: Boolean
                //              If user types in a partial string, and then tab out of the `<input>` box,
                //              automatically copy the first entry displayed in the drop down list to
                //              the `<input>` field
                autoComplete: true,

                // highlightMatch: String
                //              One of: "first", "all" or "none".
                //
                //              If the ComboBox/FilteringSelect opens with the search results and the searched
                //              string can be found, it will be highlighted.  If set to "all"
                //              then will probably want to change `queryExpr` parameter to '*${0}*'
                //
                //              Highlighting is only performed when `labelType` is "text", so as to not
                //              interfere with any HTML markup an HTML label might contain.
                highlightMatch: "first",

                // labelAttr: String?
                //              The entries in the drop down list come from this attribute in the
                //              dojo.data items.
                //              If not specified, the searchAttr attribute is used instead.
                labelAttr: "",

                // labelType: String
                //              Specifies how to interpret the labelAttr in the data store items.
                //              Can be "html" or "text".
                labelType: "text",

                // Flags to _HasDropDown to limit height of drop down to make it fit in viewport
                maxHeight: -1,

                // For backwards compatibility let onClick events propagate, even clicks on the down arrow button
                _stopClickEvents: false,

                _getCaretPos: function(/*DomNode*/ element){
                        // khtml 3.5.2 has selection* methods as does webkit nightlies from 2005-06-22
                        var pos = 0;
                        if(typeof(element.selectionStart) == "number"){
                                // FIXME: this is totally borked on Moz < 1.3. Any recourse?
                                pos = element.selectionStart;
                        }else if(has("ie")){
                                // in the case of a mouse click in a popup being handled,
                                // then the win.doc.selection is not the textarea, but the popup
                                // var r = win.doc.selection.createRange();
                                // hack to get IE 6 to play nice. What a POS browser.
                                var tr = element.ownerDocument.selection.createRange().duplicate();
                                var ntr = element.createTextRange();
                                tr.move("character",0);
                                ntr.move("character",0);
                                try{
                                        // If control doesn't have focus, you get an exception.
                                        // Seems to happen on reverse-tab, but can also happen on tab (seems to be a race condition - only happens sometimes).
                                        // There appears to be no workaround for this - googled for quite a while.
                                        ntr.setEndPoint("EndToEnd", tr);
                                        pos = String(ntr.text).replace(/\r/g,"").length;
                                }catch(e){
                                        // If focus has shifted, 0 is fine for caret pos.
                                }
                        }
                        return pos;
                },

                _setCaretPos: function(/*DomNode*/ element, /*Number*/ location){
                        location = parseInt(location);
                        _TextBoxMixin.selectInputText(element, location, location);
                },

                _setDisabledAttr: function(/*Boolean*/ value){
                        // Additional code to set disabled state of ComboBox node.
                        // Overrides _FormValueWidget._setDisabledAttr() or ValidationTextBox._setDisabledAttr().
                        this.inherited(arguments);
                        this.domNode.setAttribute("aria-disabled", value ? "true" : "false");
                },

                _onKey: function(/*Event*/ evt){
                        // summary:
                        //              Handles keyboard events

                        if(evt.charCode >= 32){ return; } // alphanumeric reserved for searching

                        var key = evt.charCode || evt.keyCode;

                        // except for cutting/pasting case - ctrl + x/v
                        if(key == keys.ALT || key == keys.CTRL || key == keys.META || key == keys.SHIFT){
                                return; // throw out spurious events
                        }

                        var pw = this.dropDown;
                        var highlighted = null;
                        this._abortQuery();

                        // _HasDropDown will do some of the work:
                        //
                        //      1. when drop down is not yet shown:
                        //              - if user presses the down arrow key, call loadDropDown()
                        //      2. when drop down is already displayed:
                        //              - on ESC key, call closeDropDown()
                        //              - otherwise, call dropDown.handleKey() to process the keystroke
                        this.inherited(arguments);

                        if(evt.altKey || evt.ctrlKey || evt.metaKey){ return; } // don't process keys with modifiers  - but we want shift+TAB

                        if(this._opened){
                                highlighted = pw.getHighlightedOption();
                        }
                        switch(key){
                                case keys.PAGE_DOWN:
                                case keys.DOWN_ARROW:
                                case keys.PAGE_UP:
                                case keys.UP_ARROW:
                                        // Keystroke caused ComboBox_menu to move to a different item.
                                        // Copy new item to <input> box.
                                        if(this._opened){
                                                this._announceOption(highlighted);
                                        }
                                        event.stop(evt);
                                        break;

                                case keys.ENTER:
                                        // prevent submitting form if user presses enter. Also
                                        // prevent accepting the value if either Next or Previous
                                        // are selected
                                        if(highlighted){
                                                // only stop event on prev/next
                                                if(highlighted == pw.nextButton){
                                                        this._nextSearch(1);
                                                        event.stop(evt); // prevent submit
                                                        break;
                                                }else if(highlighted == pw.previousButton){
                                                        this._nextSearch(-1);
                                                        event.stop(evt); // prevent submit
                                                        break;
                                                }
                                                event.stop(evt); // prevent submit if ENTER was to choose an item
                                        }else{
                                                // Update 'value' (ex: KY) according to currently displayed text
                                                this._setBlurValue(); // set value if needed
                                                this._setCaretPos(this.focusNode, this.focusNode.value.length); // move cursor to end and cancel highlighting
                                        }
                                        // fall through

                                case keys.TAB:
                                        var newvalue = this.get('displayedValue');
                                        //      if the user had More Choices selected fall into the
                                        //      _onBlur handler
                                        if(pw && (
                                                newvalue == pw._messages["previousMessage"] ||
                                                newvalue == pw._messages["nextMessage"])
                                        ){
                                                break;
                                        }
                                        if(highlighted){
                                                this._selectOption(highlighted);
                                        }
                                        // fall through

                                case keys.ESCAPE:
                                        if(this._opened){
                                                this._lastQuery = null; // in case results come back later
                                                this.closeDropDown();
                                        }
                                        break;
                        }
                },

                _autoCompleteText: function(/*String*/ text){
                        // summary:
                        //              Fill in the textbox with the first item from the drop down
                        //              list, and highlight the characters that were
                        //              auto-completed. For example, if user typed "CA" and the
                        //              drop down list appeared, the textbox would be changed to
                        //              "California" and "ifornia" would be highlighted.

                        var fn = this.focusNode;

                        // IE7: clear selection so next highlight works all the time
                        _TextBoxMixin.selectInputText(fn, fn.value.length);
                        // does text autoComplete the value in the textbox?
                        var caseFilter = this.ignoreCase? 'toLowerCase' : 'substr';
                        if(text[caseFilter](0).indexOf(this.focusNode.value[caseFilter](0)) == 0){
                                var cpos = this.autoComplete ? this._getCaretPos(fn) : fn.value.length;
                                // only try to extend if we added the last character at the end of the input
                                if((cpos+1) > fn.value.length){
                                        // only add to input node as we would overwrite Capitalisation of chars
                                        // actually, that is ok
                                        fn.value = text;//.substr(cpos);
                                        // visually highlight the autocompleted characters
                                        _TextBoxMixin.selectInputText(fn, cpos);
                                }
                        }else{
                                // text does not autoComplete; replace the whole value and highlight
                                fn.value = text;
                                _TextBoxMixin.selectInputText(fn);
                        }
                },

                _openResultList: function(/*Object*/ results, /*Object*/ query, /*Object*/ options){
                        // summary:
                        //              Callback when a search completes.
                        // description:
                        //              1. generates drop-down list and calls _showResultList() to display it
                        //              2. if this result list is from user pressing "more choices"/"previous choices"
                        //                      then tell screen reader to announce new option
                        var wasSelected = this.dropDown.getHighlightedOption();
                        this.dropDown.clearResultList();
                        if(!results.length && options.start == 0){ // if no results and not just the previous choices button
                                this.closeDropDown();
                                return;
                        }
                        this._nextSearch = this.dropDown.onPage = lang.hitch(this, function(direction){
                                results.nextPage(direction !== -1);
                                this.focus();
                        });

                        // Fill in the textbox with the first item from the drop down list,
                        // and highlight the characters that were auto-completed. For
                        // example, if user typed "CA" and the drop down list appeared, the
                        // textbox would be changed to "California" and "ifornia" would be
                        // highlighted.

                        this.dropDown.createOptions(
                                results,
                                options,
                                lang.hitch(this, "_getMenuLabelFromItem")
                        );

                        // show our list (only if we have content, else nothing)
                        this._showResultList();

                        // #4091:
                        //              tell the screen reader that the paging callback finished by
                        //              shouting the next choice
                        if("direction" in options){
                                if(options.direction){
                                        this.dropDown.highlightFirstOption();
                                }else if(!options.direction){
                                        this.dropDown.highlightLastOption();
                                }
                                if(wasSelected){
                                        this._announceOption(this.dropDown.getHighlightedOption());
                                }
                        }else if(this.autoComplete && !this._prev_key_backspace
                                // when the user clicks the arrow button to show the full list,
                                // startSearch looks for "*".
                                // it does not make sense to autocomplete
                                // if they are just previewing the options available.
                                && !/^[*]+$/.test(query[this.searchAttr].toString())){
                                        this._announceOption(this.dropDown.containerNode.firstChild.nextSibling); // 1st real item
                        }
                },

                _showResultList: function(){
                        // summary:
                        //              Display the drop down if not already displayed, or if it is displayed, then
                        //              reposition it if necessary (reposition may be necessary if drop down's height changed).
                        this.closeDropDown(true);
                        this.openDropDown();
                        this.domNode.setAttribute("aria-expanded", "true");
                },

                loadDropDown: function(/*Function*/ /*===== callback =====*/){
                        // Overrides _HasDropDown.loadDropDown().
                        // This is called when user has pressed button icon or pressed the down arrow key
                        // to open the drop down.
                        this._startSearchAll();
                },

                isLoaded: function(){
                        // signal to _HasDropDown that it needs to call loadDropDown() to load the
                        // drop down asynchronously before displaying it
                        return false;
                },

                closeDropDown: function(){
                        // Overrides _HasDropDown.closeDropDown().  Closes the drop down (assuming that it's open).
                        // This method is the callback when the user types ESC or clicking
                        // the button icon while the drop down is open.  It's also called by other code.
                        this._abortQuery();
                        if(this._opened){
                                this.inherited(arguments);
                                this.domNode.setAttribute("aria-expanded", "false");
                                this.focusNode.removeAttribute("aria-activedescendant");
                        }
                },

                _setBlurValue: function(){
                        // if the user clicks away from the textbox OR tabs away, set the
                        // value to the textbox value
                        // #4617:
                        //              if value is now more choices or previous choices, revert
                        //              the value
                        var newvalue = this.get('displayedValue');
                        var pw = this.dropDown;
                        if(pw && (
                                newvalue == pw._messages["previousMessage"] ||
                                newvalue == pw._messages["nextMessage"]
                                )
                        ){
                                this._setValueAttr(this._lastValueReported, true);
                        }else if(typeof this.item == "undefined"){
                                // Update 'value' (ex: KY) according to currently displayed text
                                this.item = null;
                                this.set('displayedValue', newvalue);
                        }else{
                                if(this.value != this._lastValueReported){
                                        this._handleOnChange(this.value, true);
                                }
                                this._refreshState();
                        }
                },

                _setItemAttr: function(/*item*/ item, /*Boolean?*/ priorityChange, /*String?*/ displayedValue){
                        // summary:
                        //              Set the displayed valued in the input box, and the hidden value
                        //              that gets submitted, based on a dojo.data store item.
                        // description:
                        //              Users shouldn't call this function; they should be calling
                        //              set('item', value)
                        // tags:
                        //              private
                        var value = '';
                        if(item){
                                if(!displayedValue){
                                        displayedValue = this.store._oldAPI ?   // remove getValue() for 2.0 (old dojo.data API)
                                                this.store.getValue(item, this.searchAttr) : item[this.searchAttr];
                                }
                                value = this._getValueField() != this.searchAttr ? this.store.getIdentity(item) : displayedValue;
                        }
                        this.set('value', value, priorityChange, displayedValue, item);
                },

                _announceOption: function(/*Node*/ node){
                        // summary:
                        //              a11y code that puts the highlighted option in the textbox.
                        //              This way screen readers will know what is happening in the
                        //              menu.

                        if(!node){
                                return;
                        }
                        // pull the text value from the item attached to the DOM node
                        var newValue;
                        if(node == this.dropDown.nextButton ||
                                node == this.dropDown.previousButton){
                                newValue = node.innerHTML;
                                this.item = undefined;
                                this.value = '';
                        }else{
                                var item = this.dropDown.items[node.getAttribute("item")];
                                newValue = (this.store._oldAPI ?        // remove getValue() for 2.0 (old dojo.data API)
                                        this.store.getValue(item, this.searchAttr) : item[this.searchAttr]).toString();
                                this.set('item', item, false, newValue);
                        }
                        // get the text that the user manually entered (cut off autocompleted text)
                        this.focusNode.value = this.focusNode.value.substring(0, this._lastInput.length);
                        // set up ARIA activedescendant
                        this.focusNode.setAttribute("aria-activedescendant", domAttr.get(node, "id"));
                        // autocomplete the rest of the option to announce change
                        this._autoCompleteText(newValue);
                },

                _selectOption: function(/*DomNode*/ target){
                        // summary:
                        //              Menu callback function, called when an item in the menu is selected.
                        this.closeDropDown();
                        if(target){
                                this._announceOption(target);
                        }
                        this._setCaretPos(this.focusNode, this.focusNode.value.length);
                        this._handleOnChange(this.value, true);
                },

                _startSearchAll: function(){
                        this._startSearch('');
                },

                _startSearchFromInput: function(){
                        this.item = undefined; // undefined means item needs to be set
                        this.inherited(arguments);
                },

                _startSearch: function(/*String*/ key){
                        // summary:
                        //              Starts a search for elements matching key (key=="" means to return all items),
                        //              and calls _openResultList() when the search completes, to display the results.
                        if(!this.dropDown){
                                var popupId = this.id + "_popup",
                                        dropDownConstructor = lang.isString(this.dropDownClass) ?
                                                lang.getObject(this.dropDownClass, false) : this.dropDownClass;
                                this.dropDown = new dropDownConstructor({
                                        onChange: lang.hitch(this, this._selectOption),
                                        id: popupId,
                                        dir: this.dir,
                                        textDir: this.textDir
                                });
                                this.focusNode.removeAttribute("aria-activedescendant");
                                this.textbox.setAttribute("aria-owns",popupId); // associate popup with textbox
                        }
                        this._lastInput = key; // Store exactly what was entered by the user.
                        this.inherited(arguments);
                },

                _getValueField: function(){
                        // summary:
                        //              Helper for postMixInProperties() to set this.value based on data inlined into the markup.
                        //              Returns the attribute name in the item (in dijit/form/_ComboBoxDataStore) to use as the value.
                        return this.searchAttr;
                },

                //////////// INITIALIZATION METHODS ///////////////////////////////////////

                postMixInProperties: function(){
                        this.inherited(arguments);
                        if(!this.store){
                                var srcNodeRef = this.srcNodeRef;
                                // if user didn't specify store, then assume there are option tags
                                this.store = new DataList({}, srcNodeRef);

                                // if there is no value set and there is an option list, set
                                // the value to the first value to be consistent with native Select
                                // Firefox and Safari set value
                                // IE6 and Opera set selectedIndex, which is automatically set
                                // by the selected attribute of an option tag
                                // IE6 does not set value, Opera sets value = selectedIndex
                                if(!("value" in this.params)){
                                        var item = (this.item = this.store.fetchSelectedItem());
                                        if(item){
                                                var valueField = this._getValueField();
                                                // remove getValue() for 2.0 (old dojo.data API)
                                                this.value = this.store._oldAPI ? this.store.getValue(item, valueField) : item[valueField];
                                        }
                                }
                        }
                },

                postCreate: function(){
                        // summary:
                        //              Subclasses must call this method from their postCreate() methods
                        // tags:
                        //              protected

                        // find any associated label element and add to ComboBox node.
                        var label=query('label[for="'+this.id+'"]');
                        if(label.length){
                                if(!label[0].id){ label[0].id = this.id + "_label"; }
                                this.domNode.setAttribute("aria-labelledby", label[0].id);

                        }
                        this.inherited(arguments);
                        this.connect(this, "onSearch", "_openResultList");
                },

                _getMenuLabelFromItem: function(/*Item*/ item){
                        var label = this.labelFunc(item, this.store),
                                labelType = this.labelType;
                        // If labelType is not "text" we don't want to screw any markup ot whatever.
                        if(this.highlightMatch != "none" && this.labelType == "text" && this._lastInput){
                                label = this.doHighlight(label, this._lastInput);
                                labelType = "html";
                        }
                        return {html: labelType == "html", label: label};
                },

                doHighlight: function(/*String*/ label, /*String*/ find){
                        // summary:
                        //              Highlights the string entered by the user in the menu.  By default this
                        //              highlights the first occurrence found. Override this method
                        //              to implement your custom highlighting.
                        // tags:
                        //              protected

                        var
                                // Add (g)lobal modifier when this.highlightMatch == "all" and (i)gnorecase when this.ignoreCase == true
                                modifiers = (this.ignoreCase ? "i" : "") + (this.highlightMatch == "all" ? "g" : ""),
                                i = this.queryExpr.indexOf("${0}");
                        find = regexp.escapeString(find); // escape regexp special chars
                        //If < appears in label, and user presses t, we don't want to highlight the t in the escaped "&lt;"
                        //first find out every occurences of "find", wrap each occurence in a pair of "\uFFFF" characters (which
                        //should not appear in any string). then html escape the whole string, and replace '\uFFFF" with the
                        //HTML highlight markup. 
                        return this._escapeHtml(label.replace(
                                new RegExp((i == 0 ? "^" : "") + "("+ find +")" + (i == (this.queryExpr.length - 4) ? "$" : ""), modifiers),
                                '\uFFFF$1\uFFFF')).replace(
                                        /\uFFFF([^\uFFFF]+)\uFFFF/g, '<span class="dijitComboBoxHighlightMatch">$1</span>'
                        ); // returns String, (almost) valid HTML (entities encoded)
                },

                _escapeHtml: function(/*String*/ str){
                        // TODO Should become dojo.html.entities(), when exists use instead
                        // summary:
                        //              Adds escape sequences for special characters in XML: `&<>"'`
                        str = String(str).replace(/&/gm, "&amp;").replace(/</gm, "&lt;")
                                .replace(/>/gm, "&gt;").replace(/"/gm, "&quot;"); //balance"
                        return str; // string
                },

                reset: function(){
                        // Overrides the _FormWidget.reset().
                        // Additionally reset the .item (to clean up).
                        this.item = null;
                        this.inherited(arguments);
                },

                labelFunc: function(item, store){
                        // summary:
                        //              Computes the label to display based on the dojo.data store item.
                        // item: Object
                        //              The item from the store
                        // store: dojo/store/api/Store
                        //              The store.
                        // returns:
                        //              The label that the ComboBox should display
                        // tags:
                        //              private

                        // Use toString() because XMLStore returns an XMLItem whereas this
                        // method is expected to return a String (#9354).
                        // Remove getValue() for 2.0 (old dojo.data API)
                        return (store._oldAPI ? store.getValue(item, this.labelAttr || this.searchAttr) :
                                item[this.labelAttr || this.searchAttr]).toString(); // String
                },

                _setValueAttr: function(/*String*/ value, /*Boolean?*/ priorityChange, /*String?*/ displayedValue, /*item?*/ item){
                        // summary:
                        //              Hook so set('value', value) works.
                        // description:
                        //              Sets the value of the select.
                        this._set("item", item||null); // value not looked up in store
                        if(value == null /* or undefined */){ value = ''; } // null translates to blank
                        this.inherited(arguments);
                },
                _setTextDirAttr: function(/*String*/ textDir){
                        // summary:
                        //              Setter for textDir, needed for the dropDown's textDir update.
                        // description:
                        //              Users shouldn't call this function; they should be calling
                        //              set('textDir', value)
                        // tags:
                        //              private
                        this.inherited(arguments);
                        // update the drop down also (_ComboBoxMenuMixin)
                        if(this.dropDown){
                                this.dropDown._set("textDir", textDir);
                        }
                }
        });
});

},
'url:dijit/templates/ColorPalette.html':"<div class=\"dijitInline dijitColorPalette\">\n\t<table dojoAttachPoint=\"paletteTableNode\" class=\"dijitPaletteTable\" cellSpacing=\"0\" cellPadding=\"0\" role=\"grid\">\n\t\t<tbody data-dojo-attach-point=\"gridNode\"></tbody>\n\t</table>\n</div>\n",
'url:dijit/layout/templates/_ScrollingTabControllerButton.html':"<div data-dojo-attach-event=\"onclick:_onClick\" class=\"dijitTabInnerDiv dijitTabContent dijitButtonContents\"  data-dojo-attach-point=\"focusNode\">\n\t<img role=\"presentation\" alt=\"\" src=\"${_blankGif}\" class=\"dijitTabStripIcon\" data-dojo-attach-point=\"iconNode\"/>\n\t<span data-dojo-attach-point=\"containerNode,titleNode\" class=\"dijitButtonText\"></span>\n</div>",
'dijit/form/MappedTextBox':function(){
define("dijit/form/MappedTextBox", [
        "dojo/_base/declare", // declare
        "dojo/dom-construct", // domConstruct.place
        "./ValidationTextBox"
], function(declare, domConstruct, ValidationTextBox){

        // module:
        //              dijit/form/MappedTextBox

        return declare("dijit.form.MappedTextBox", ValidationTextBox, {
                // summary:
                //              A dijit/form/ValidationTextBox subclass which provides a base class for widgets that have
                //              a visible formatted display value, and a serializable
                //              value in a hidden input field which is actually sent to the server.
                // description:
                //              The visible display may
                //              be locale-dependent and interactive.  The value sent to the server is stored in a hidden
                //              input field which uses the `name` attribute declared by the original widget.  That value sent
                //              to the server is defined by the dijit/form/MappedTextBox.serialize() method and is typically
                //              locale-neutral.
                // tags:
                //              protected

                postMixInProperties: function(){
                        this.inherited(arguments);

                        // we want the name attribute to go to the hidden <input>, not the displayed <input>,
                        // so override _FormWidget.postMixInProperties() setting of nameAttrSetting
                        this.nameAttrSetting = "";
                },

                // Override default behavior to assign name to focusNode
                _setNameAttr: null,

                serialize: function(val /*=====, options =====*/){
                        // summary:
                        //              Overridable function used to convert the get('value') result to a canonical
                        //              (non-localized) string.  For example, will print dates in ISO format, and
                        //              numbers the same way as they are represented in javascript.
                        // val: anything
                        // options: Object?
                        // tags:
                        //              protected extension
                        return val.toString ? val.toString() : ""; // String
                },

                toString: function(){
                        // summary:
                        //              Returns widget as a printable string using the widget's value
                        // tags:
                        //              protected
                        var val = this.filter(this.get('value')); // call filter in case value is nonstring and filter has been customized
                        return val != null ? (typeof val == "string" ? val : this.serialize(val, this.constraints)) : ""; // String
                },

                validate: function(){
                        // Overrides `dijit/form/TextBox.validate`
                        this.valueNode.value = this.toString();
                        return this.inherited(arguments);
                },

                buildRendering: function(){
                        // Overrides `dijit/_TemplatedMixin/buildRendering`

                        this.inherited(arguments);

                        // Create a hidden <input> node with the serialized value used for submit
                        // (as opposed to the displayed value).
                        // Passing in name as markup rather than calling domConstruct.create() with an attrs argument
                        // to make query(input[name=...]) work on IE. (see #8660)
                        this.valueNode = domConstruct.place("<input type='hidden'" + (this.name ? ' name="' + this.name.replace(/"/g, "&quot;") + '"' : "") + "/>", this.textbox, "after");
                },

                reset: function(){
                        // Overrides `dijit/form/ValidationTextBox.reset` to
                        // reset the hidden textbox value to ''
                        this.valueNode.value = '';
                        this.inherited(arguments);
                }
        });
});

},
'dijit/form/ComboBoxMixin':function(){
require({cache:{
'url:dijit/form/templates/DropDownBox.html':"<div class=\"dijit dijitReset dijitInline dijitLeft\"\n\tid=\"widget_${id}\"\n\trole=\"combobox\"\n\t><div class='dijitReset dijitRight dijitButtonNode dijitArrowButton dijitDownArrowButton dijitArrowButtonContainer'\n\t\tdata-dojo-attach-point=\"_buttonNode, _popupStateNode\" role=\"presentation\"\n\t\t><input class=\"dijitReset dijitInputField dijitArrowButtonInner\" value=\"&#9660; \" type=\"text\" tabIndex=\"-1\" readonly=\"readonly\" role=\"button presentation\" aria-hidden=\"true\"\n\t\t\t${_buttonInputDisabled}\n\t/></div\n\t><div class='dijitReset dijitValidationContainer'\n\t\t><input class=\"dijitReset dijitInputField dijitValidationIcon dijitValidationInner\" value=\"&#935; \" type=\"text\" tabIndex=\"-1\" readonly=\"readonly\" role=\"presentation\"\n\t/></div\n\t><div class=\"dijitReset dijitInputField dijitInputContainer\"\n\t\t><input class='dijitReset dijitInputInner' ${!nameAttrSetting} type=\"text\" autocomplete=\"off\"\n\t\t\tdata-dojo-attach-point=\"textbox,focusNode\" role=\"textbox\" aria-haspopup=\"true\"\n\t/></div\n></div>\n"}});
define("dijit/form/ComboBoxMixin", [
        "dojo/_base/declare", // declare
        "dojo/_base/Deferred",
        "dojo/_base/kernel", // kernel.deprecated
        "dojo/_base/lang", // lang.mixin
        "dojo/store/util/QueryResults",
        "./_AutoCompleterMixin",
        "./_ComboBoxMenu",
        "../_HasDropDown",
        "dojo/text!./templates/DropDownBox.html"
], function(declare, Deferred, kernel, lang, QueryResults, _AutoCompleterMixin, _ComboBoxMenu, _HasDropDown, template){


        // module:
        //              dijit/form/ComboBoxMixin

        return declare("dijit.form.ComboBoxMixin", [_HasDropDown, _AutoCompleterMixin], {
                // summary:
                //              Provides main functionality of ComboBox widget

                // dropDownClass: [protected extension] Function String
                //              Dropdown widget class used to select a date/time.
                //              Subclasses should specify this.
                dropDownClass: _ComboBoxMenu,

                // hasDownArrow: Boolean
                //              Set this textbox to have a down arrow button, to display the drop down list.
                //              Defaults to true.
                hasDownArrow: true,

                templateString: template,

                baseClass: "dijitTextBox dijitComboBox",

                /*=====
                // store: [const] dojo/store/api/Store|dojo/data/api/Read
                //              Reference to data provider object used by this ComboBox.
                //
                //              Should be dojo/store/api/Store, but dojo/data/api/Read supported
                //              for backwards compatibility.
                store: null,
                =====*/

                // Set classes like dijitDownArrowButtonHover depending on
                // mouse action over button node
                cssStateNodes: {
                        "_buttonNode": "dijitDownArrowButton"
                },

                _setHasDownArrowAttr: function(/*Boolean*/ val){
                        this._set("hasDownArrow", val);
                        this._buttonNode.style.display = val ? "" : "none";
                },

                _showResultList: function(){
                        // hide the tooltip
                        this.displayMessage("");
                        this.inherited(arguments);
                },

                _setStoreAttr: function(store){
                        // For backwards-compatibility, accept dojo.data store in addition to dojo/store/api/Store.  Remove in 2.0.
                        if(!store.get){
                                lang.mixin(store, {
                                        _oldAPI: true,
                                        get: function(id){
                                                // summary:
                                                //              Retrieves an object by it's identity. This will trigger a fetchItemByIdentity.
                                                //              Like dojo/store/DataStore.get() except returns native item.
                                                var deferred = new Deferred();
                                                this.fetchItemByIdentity({
                                                        identity: id,
                                                        onItem: function(object){
                                                                deferred.resolve(object);
                                                        },
                                                        onError: function(error){
                                                                deferred.reject(error);
                                                        }
                                                });
                                                return deferred.promise;
                                        },
                                        query: function(query, options){
                                                // summary:
                                                //              Queries the store for objects.   Like dojo/store/DataStore.query()
                                                //              except returned Deferred contains array of native items.
                                                var deferred = new Deferred(function(){ fetchHandle.abort && fetchHandle.abort(); });
                                                deferred.total = new Deferred();
                                                var fetchHandle = this.fetch(lang.mixin({
                                                        query: query,
                                                        onBegin: function(count){
                                                                deferred.total.resolve(count);
                                                        },
                                                        onComplete: function(results){
                                                                deferred.resolve(results);
                                                        },
                                                        onError: function(error){
                                                                deferred.reject(error);
                                                        }
                                                }, options));
                                                return QueryResults(deferred);
                                        }
                                });
                        }
                        this._set("store", store);
                },

                postMixInProperties: function(){
                        // Since _setValueAttr() depends on this.store, _setStoreAttr() needs to execute first.
                        // Unfortunately, without special code, it ends up executing second.
                        var store = this.params.store || this.store;
                        if(store){
                                this._setStoreAttr(store);
                        }

                        this.inherited(arguments);

                        // User may try to access this.store.getValue() etc.  in a custom labelFunc() function.
                        // It's not available with the new data store for handling inline <option> tags, so add it.
                        if(!this.params.store && !this.store._oldAPI){
                                var clazz = this.declaredClass;
                                lang.mixin(this.store, {
                                        getValue: function(item, attr){
                                                kernel.deprecated(clazz + ".store.getValue(item, attr) is deprecated for builtin store.  Use item.attr directly", "", "2.0");
                                                return item[attr];
                                        },
                                        getLabel: function(item){
                                                kernel.deprecated(clazz + ".store.getLabel(item) is deprecated for builtin store.  Use item.label directly", "", "2.0");
                                                return item.name;
                                        },
                                        fetch: function(args){
                                                kernel.deprecated(clazz + ".store.fetch() is deprecated for builtin store.", "Use store.query()", "2.0");
                                                var shim = ["dojo/data/ObjectStore"];   // indirection so it doesn't get rolled into a build
                                                require(shim, lang.hitch(this, function(ObjectStore){
                                                        new ObjectStore({objectStore: this}).fetch(args);
                                                }));
                                        }
                                });
                        }
                }
        });
});

},
'dijit/form/_TextBoxMixin':function(){
define("dijit/form/_TextBoxMixin", [
        "dojo/_base/array", // array.forEach
        "dojo/_base/declare", // declare
        "dojo/dom", // dom.byId
        "dojo/_base/event", // event.stop
        "dojo/keys", // keys.ALT keys.CAPS_LOCK keys.CTRL keys.META keys.SHIFT
        "dojo/_base/lang", // lang.mixin
        "dojo/on", // on
        "../main"       // for exporting dijit._setSelectionRange, dijit.selectInputText
], function(array, declare, dom, event, keys, lang, on, dijit){

// module:
//              dijit/form/_TextBoxMixin

var _TextBoxMixin = declare("dijit.form._TextBoxMixin", null, {
        // summary:
        //              A mixin for textbox form input widgets

        // trim: Boolean
        //              Removes leading and trailing whitespace if true.  Default is false.
        trim: false,

        // uppercase: Boolean
        //              Converts all characters to uppercase if true.  Default is false.
        uppercase: false,

        // lowercase: Boolean
        //              Converts all characters to lowercase if true.  Default is false.
        lowercase: false,

        // propercase: Boolean
        //              Converts the first character of each word to uppercase if true.
        propercase: false,

        // maxLength: String
        //              HTML INPUT tag maxLength declaration.
        maxLength: "",

        // selectOnClick: [const] Boolean
        //              If true, all text will be selected when focused with mouse
        selectOnClick: false,

        // placeHolder: String
        //              Defines a hint to help users fill out the input field (as defined in HTML 5).
        //              This should only contain plain text (no html markup).
        placeHolder: "",

        _getValueAttr: function(){
                // summary:
                //              Hook so get('value') works as we like.
                // description:
                //              For `dijit/form/TextBox` this basically returns the value of the `<input>`.
                //
                //              For `dijit/form/MappedTextBox` subclasses, which have both
                //              a "displayed value" and a separate "submit value",
                //              This treats the "displayed value" as the master value, computing the
                //              submit value from it via this.parse().
                return this.parse(this.get('displayedValue'), this.constraints);
        },

        _setValueAttr: function(value, /*Boolean?*/ priorityChange, /*String?*/ formattedValue){
                // summary:
                //              Hook so set('value', ...) works.
                //
                // description:
                //              Sets the value of the widget to "value" which can be of
                //              any type as determined by the widget.
                //
                // value:
                //              The visual element value is also set to a corresponding,
                //              but not necessarily the same, value.
                //
                // formattedValue:
                //              If specified, used to set the visual element value,
                //              otherwise a computed visual value is used.
                //
                // priorityChange:
                //              If true, an onChange event is fired immediately instead of
                //              waiting for the next blur event.

                var filteredValue;
                if(value !== undefined){
                        // TODO: this is calling filter() on both the display value and the actual value.
                        // I added a comment to the filter() definition about this, but it should be changed.
                        filteredValue = this.filter(value);
                        if(typeof formattedValue != "string"){
                                if(filteredValue !== null && ((typeof filteredValue != "number") || !isNaN(filteredValue))){
                                        formattedValue = this.filter(this.format(filteredValue, this.constraints));
                                }else{ formattedValue = ''; }
                        }
                }
                if(formattedValue != null /* and !undefined */ && ((typeof formattedValue) != "number" || !isNaN(formattedValue)) && this.textbox.value != formattedValue){
                        this.textbox.value = formattedValue;
                        this._set("displayedValue", this.get("displayedValue"));
                }

                if(this.textDir == "auto"){
                        this.applyTextDir(this.focusNode, formattedValue);
                }

                this.inherited(arguments, [filteredValue, priorityChange]);
        },

        // displayedValue: String
        //              For subclasses like ComboBox where the displayed value
        //              (ex: Kentucky) and the serialized value (ex: KY) are different,
        //              this represents the displayed value.
        //
        //              Setting 'displayedValue' through set('displayedValue', ...)
        //              updates 'value', and vice-versa.  Otherwise 'value' is updated
        //              from 'displayedValue' periodically, like onBlur etc.
        //
        //              TODO: move declaration to MappedTextBox?
        //              Problem is that ComboBox references displayedValue,
        //              for benefit of FilteringSelect.
        displayedValue: "",

        _getDisplayedValueAttr: function(){
                // summary:
                //              Hook so get('displayedValue') works.
                // description:
                //              Returns the displayed value (what the user sees on the screen),
                //              after filtering (ie, trimming spaces etc.).
                //
                //              For some subclasses of TextBox (like ComboBox), the displayed value
                //              is different from the serialized value that's actually
                //              sent to the server (see `dijit/form/ValidationTextBox.serialize()`)

                // TODO: maybe we should update this.displayedValue on every keystroke so that we don't need
                // this method
                // TODO: this isn't really the displayed value when the user is typing
                return this.filter(this.textbox.value);
        },

        _setDisplayedValueAttr: function(/*String*/ value){
                // summary:
                //              Hook so set('displayedValue', ...) works.
                // description:
                //              Sets the value of the visual element to the string "value".
                //              The widget value is also set to a corresponding,
                //              but not necessarily the same, value.

                if(value == null /* or undefined */){ value = '' }
                else if(typeof value != "string"){ value = String(value) }

                this.textbox.value = value;

                // sets the serialized value to something corresponding to specified displayedValue
                // (if possible), and also updates the textbox.value, for example converting "123"
                // to "123.00"
                this._setValueAttr(this.get('value'), undefined);

                this._set("displayedValue", this.get('displayedValue'));

                // textDir support
                if(this.textDir == "auto"){
                        this.applyTextDir(this.focusNode, value);
                }
        },

        format: function(value /*=====, constraints =====*/){
                // summary:
                //              Replaceable function to convert a value to a properly formatted string.
                // value: String
                // constraints: Object
                // tags:
                //              protected extension
                return value == null /* or undefined */ ? "" : (value.toString ? value.toString() : value);
        },

        parse: function(value /*=====, constraints =====*/){
                // summary:
                //              Replaceable function to convert a formatted string to a value
                // value: String
                // constraints: Object
                // tags:
                //              protected extension

                return value;   // String
        },

        _refreshState: function(){
                // summary:
                //              After the user types some characters, etc., this method is
                //              called to check the field for validity etc.  The base method
                //              in `dijit/form/TextBox` does nothing, but subclasses override.
                // tags:
                //              protected
        },

        /*=====
        onInput: function(event){
                // summary:
                //              Connect to this function to receive notifications of various user data-input events.
                //              Return false to cancel the event and prevent it from being processed.
                // event:
                //              keydown | keypress | cut | paste | input
                // tags:
                //              callback
        },
        =====*/
        onInput: function(){},

        __skipInputEvent: false,
        _onInput: function(/*Event*/ evt){
                // summary:
                //              Called AFTER the input event has happened

                // set text direction according to textDir that was defined in creation
                if(this.textDir == "auto"){
                        this.applyTextDir(this.focusNode, this.focusNode.value);
                }

                this._processInput(evt);
        },

        _processInput: function(/*Event*/ evt){
                // summary:
                //              Default action handler for user input events

                this._refreshState();

                // In case someone is watch()'ing for changes to displayedValue
                this._set("displayedValue", this.get("displayedValue"));
        },

        postCreate: function(){
                // setting the value here is needed since value="" in the template causes "undefined"
                // and setting in the DOM (instead of the JS object) helps with form reset actions
                this.textbox.setAttribute("value", this.textbox.value); // DOM and JS values should be the same

                this.inherited(arguments);

                // normalize input events to reduce spurious event processing
                //      onkeydown: do not forward modifier keys
                //                     set charOrCode to numeric keycode
                //      onkeypress: do not forward numeric charOrCode keys (already sent through onkeydown)
                //      onpaste & oncut: set charOrCode to 229 (IME)
                //      oninput: if primary event not already processed, set charOrCode to 229 (IME), else do not forward
                var handleEvent = function(e){
                        var charOrCode;
                        if(e.type == "keydown"){
                                charOrCode = e.keyCode;
                                switch(charOrCode){ // ignore state keys
                                        case keys.SHIFT:
                                        case keys.ALT:
                                        case keys.CTRL:
                                        case keys.META:
                                        case keys.CAPS_LOCK:
                                        case keys.NUM_LOCK:
                                        case keys.SCROLL_LOCK:
                                                return;
                                }
                                if(!e.ctrlKey && !e.metaKey && !e.altKey){ // no modifiers
                                        switch(charOrCode){ // ignore location keys
                                                case keys.NUMPAD_0:
                                                case keys.NUMPAD_1:
                                                case keys.NUMPAD_2:
                                                case keys.NUMPAD_3:
                                                case keys.NUMPAD_4:
                                                case keys.NUMPAD_5:
                                                case keys.NUMPAD_6:
                                                case keys.NUMPAD_7:
                                                case keys.NUMPAD_8:
                                                case keys.NUMPAD_9:
                                                case keys.NUMPAD_MULTIPLY:
                                                case keys.NUMPAD_PLUS:
                                                case keys.NUMPAD_ENTER:
                                                case keys.NUMPAD_MINUS:
                                                case keys.NUMPAD_PERIOD:
                                                case keys.NUMPAD_DIVIDE:
                                                        return;
                                        }
                                        if((charOrCode >= 65 && charOrCode <= 90) || (charOrCode >= 48 && charOrCode <= 57) || charOrCode == keys.SPACE){
                                                return; // keypress will handle simple non-modified printable keys
                                        }
                                        var named = false;
                                        for(var i in keys){
                                                if(keys[i] === e.keyCode){
                                                        named = true;
                                                        break;
                                                }
                                        }
                                        if(!named){ return; } // only allow named ones through
                                }
                        }
                        charOrCode = e.charCode >= 32 ? String.fromCharCode(e.charCode) : e.charCode;
                        if(!charOrCode){
                                charOrCode = (e.keyCode >= 65 && e.keyCode <= 90) || (e.keyCode >= 48 && e.keyCode <= 57) || e.keyCode == keys.SPACE ? String.fromCharCode(e.keyCode) : e.keyCode;
                        }
                        if(!charOrCode){
                                charOrCode = 229; // IME
                        }
                        if(e.type == "keypress"){
                                if(typeof charOrCode != "string"){ return; }
                                if((charOrCode >= 'a' && charOrCode <= 'z') || (charOrCode >= 'A' && charOrCode <= 'Z') || (charOrCode >= '0' && charOrCode <= '9') || (charOrCode === ' ')){
                                        if(e.ctrlKey || e.metaKey || e.altKey){ return; } // can only be stopped reliably in keydown
                                }
                        }
                        if(e.type == "input"){
                                if(this.__skipInputEvent){ // duplicate event
                                        this.__skipInputEvent = false;
                                        return;
                                }
                        }else{
                                this.__skipInputEvent = true;
                        }
                        // create fake event to set charOrCode and to know if preventDefault() was called
                        var faux = { faux: true }, attr;
                        for(attr in e){
                                if(attr != "layerX" && attr != "layerY"){ // prevent WebKit warnings
                                        var v = e[attr];
                                        if(typeof v != "function" && typeof v != "undefined"){ faux[attr] = v; }
                                }
                        }
                        lang.mixin(faux, {
                                charOrCode: charOrCode,
                                _wasConsumed: false,
                                preventDefault: function(){
                                        faux._wasConsumed = true;
                                        e.preventDefault();
                                },
                                stopPropagation: function(){ e.stopPropagation(); }
                        });
                        // give web page author a chance to consume the event
                        //console.log(faux.type + ', charOrCode = (' + (typeof charOrCode) + ') ' + charOrCode + ', ctrl ' + !!faux.ctrlKey + ', alt ' + !!faux.altKey + ', meta ' + !!faux.metaKey + ', shift ' + !!faux.shiftKey);
                        if(this.onInput(faux) === false){ // return false means stop
                                faux.preventDefault();
                                faux.stopPropagation();
                        }
                        if(faux._wasConsumed){ return; } // if preventDefault was called
                        this.defer(function(){ this._onInput(faux); }); // widget notification after key has posted
                };
                this.own(on(this.textbox, "keydown, keypress, paste, cut, input, compositionend", lang.hitch(this, handleEvent)));
        },

        _blankValue: '', // if the textbox is blank, what value should be reported
        filter: function(val){
                // summary:
                //              Auto-corrections (such as trimming) that are applied to textbox
                //              value on blur or form submit.
                // description:
                //              For MappedTextBox subclasses, this is called twice
                //
                //              - once with the display value
                //              - once the value as set/returned by set('value', ...)
                //
                //              and get('value'), ex: a Number for NumberTextBox.
                //
                //              In the latter case it does corrections like converting null to NaN.  In
                //              the former case the NumberTextBox.filter() method calls this.inherited()
                //              to execute standard trimming code in TextBox.filter().
                //
                //              TODO: break this into two methods in 2.0
                //
                // tags:
                //              protected extension
                if(val === null){ return this._blankValue; }
                if(typeof val != "string"){ return val; }
                if(this.trim){
                        val = lang.trim(val);
                }
                if(this.uppercase){
                        val = val.toUpperCase();
                }
                if(this.lowercase){
                        val = val.toLowerCase();
                }
                if(this.propercase){
                        val = val.replace(/[^\s]+/g, function(word){
                                return word.substring(0,1).toUpperCase() + word.substring(1);
                        });
                }
                return val;
        },

        _setBlurValue: function(){
                this._setValueAttr(this.get('value'), true);
        },

        _onBlur: function(e){
                if(this.disabled){ return; }
                this._setBlurValue();
                this.inherited(arguments);
        },

        _isTextSelected: function(){
                return this.textbox.selectionStart != this.textbox.selectionEnd;
        },

        _onFocus: function(/*String*/ by){
                if(this.disabled || this.readOnly){ return; }

                // Select all text on focus via click if nothing already selected.
                // Since mouse-up will clear the selection, need to defer selection until after mouse-up.
                // Don't do anything on focus by tabbing into the widget since there's no associated mouse-up event.
                if(this.selectOnClick && by == "mouse"){
                        this._selectOnClickHandle = this.connect(this.domNode, "onmouseup", function(){
                                // Only select all text on first click; otherwise users would have no way to clear
                                // the selection.
                                this.disconnect(this._selectOnClickHandle);
                                this._selectOnClickHandle = null;

                                // Check if the user selected some text manually (mouse-down, mouse-move, mouse-up)
                                // and if not, then select all the text
                                if(!this._isTextSelected()){
                                        _TextBoxMixin.selectInputText(this.textbox);
                                }
                        });
                        // in case the mouseup never comes
                        this.defer(function(){ 
                                if(this._selectOnClickHandle){
                                        this.disconnect(this._selectOnClickHandle);
                                        this._selectOnClickHandle = null;
                                }
                        }, 500); // if mouseup not received soon, then treat it as some gesture
                }
                // call this.inherited() before refreshState(), since this.inherited() will possibly scroll the viewport
                // (to scroll the TextBox into view), which will affect how _refreshState() positions the tooltip
                this.inherited(arguments);

                this._refreshState();
        },

        reset: function(){
                // Overrides `dijit/_FormWidget/reset()`.
                // Additionally resets the displayed textbox value to ''
                this.textbox.value = '';
                this.inherited(arguments);
        },

        _setTextDirAttr: function(/*String*/ textDir){
                // summary:
                //              Setter for textDir.
                // description:
                //              Users shouldn't call this function; they should be calling
                //              set('textDir', value)
                // tags:
                //              private

                // only if new textDir is different from the old one
                // and on widgets creation.
                if(!this._created
                        || this.textDir != textDir){
                                this._set("textDir", textDir);
                                // so the change of the textDir will take place immediately.
                                this.applyTextDir(this.focusNode, this.focusNode.value);
                }
        }
});


_TextBoxMixin._setSelectionRange = dijit._setSelectionRange = function(/*DomNode*/ element, /*Number?*/ start, /*Number?*/ stop){
        if(element.setSelectionRange){
                element.setSelectionRange(start, stop);
        }
};

_TextBoxMixin.selectInputText = dijit.selectInputText = function(/*DomNode*/ element, /*Number?*/ start, /*Number?*/ stop){
        // summary:
        //              Select text in the input element argument, from start (default 0), to stop (default end).

        // TODO: use functions in _editor/selection.js?
        element = dom.byId(element);
        if(isNaN(start)){ start = 0; }
        if(isNaN(stop)){ stop = element.value ? element.value.length : 0; }
        try{
                element.focus();
                _TextBoxMixin._setSelectionRange(element, start, stop);
        }catch(e){ /* squelch random errors (esp. on IE) from unexpected focus changes or DOM nodes being hidden */ }
};

return _TextBoxMixin;
});

},
'dijit/form/SimpleTextarea':function(){
define("dijit/form/SimpleTextarea", [
        "dojo/_base/declare", // declare
        "dojo/dom-class", // domClass.add
        "dojo/sniff", // has("ie") has("opera")
        "./TextBox"
], function(declare, domClass, has, TextBox){

// module:
//              dijit/form/SimpleTextarea


return declare("dijit.form.SimpleTextarea", TextBox, {
        // summary:
        //              A simple textarea that degrades, and responds to
        //              minimal LayoutContainer usage, and works with dijit/form/Form.
        //              Doesn't automatically size according to input, like Textarea.
        //
        // example:
        //      |       <textarea data-dojo-type="dijit/form/SimpleTextarea" name="foo" value="bar" rows=30 cols=40></textarea>
        //
        // example:
        //      |       new SimpleTextarea({ rows:20, cols:30 }, "foo");

        baseClass: "dijitTextBox dijitTextArea",

        // rows: Number
        //              The number of rows of text.
        rows: "3",

        // rows: Number
        //              The number of characters per line.
        cols: "20",

        templateString: "<textarea ${!nameAttrSetting} data-dojo-attach-point='focusNode,containerNode,textbox' autocomplete='off'></textarea>",

        postMixInProperties: function(){
                // Copy value from srcNodeRef, unless user specified a value explicitly (or there is no srcNodeRef)
                // TODO: parser will handle this in 2.0
                if(!this.value && this.srcNodeRef){
                        this.value = this.srcNodeRef.value;
                }
                this.inherited(arguments);
        },

        buildRendering: function(){
                this.inherited(arguments);
                if(has("ie") && this.cols){ // attribute selectors is not supported in IE6
                        domClass.add(this.textbox, "dijitTextAreaCols");
                }
        },

        filter: function(/*String*/ value){
                // Override TextBox.filter to deal with newlines... specifically (IIRC) this is for IE which writes newlines
                // as \r\n instead of just \n
                if(value){
                        value = value.replace(/\r/g,"");
                }
                return this.inherited(arguments);
        },

        _onInput: function(/*Event?*/ e){
                // Override TextBox._onInput() to enforce maxLength restriction
                if(this.maxLength){
                        var maxLength = parseInt(this.maxLength);
                        var value = this.textbox.value.replace(/\r/g,'');
                        var overflow = value.length - maxLength;
                        if(overflow > 0){
                                var textarea = this.textbox;
                                if(textarea.selectionStart){
                                        var pos = textarea.selectionStart;
                                        var cr = 0;
                                        if(has("opera")){
                                                cr = (this.textbox.value.substring(0,pos).match(/\r/g) || []).length;
                                        }
                                        this.textbox.value = value.substring(0,pos-overflow-cr)+value.substring(pos-cr);
                                        textarea.setSelectionRange(pos-overflow, pos-overflow);
                                }else if(this.ownerDocument.selection){ //IE
                                        textarea.focus();
                                        var range = this.ownerDocument.selection.createRange();
                                        // delete overflow characters
                                        range.moveStart("character", -overflow);
                                        range.text = '';
                                        // show cursor
                                        range.select();
                                }
                        }
                }
                this.inherited(arguments);
        }
});

});

},
'url:dijit/layout/templates/_TabButton.html':"<div role=\"presentation\" data-dojo-attach-point=\"titleNode,innerDiv,tabContent\" class=\"dijitTabInner dijitTabContent\">\n\t<img src=\"${_blankGif}\" alt=\"\" class=\"dijitIcon dijitTabButtonIcon\" data-dojo-attach-point='iconNode'/>\n\t<span data-dojo-attach-point='containerNode,focusNode' class='tabLabel'></span>\n\t<span class=\"dijitInline dijitTabCloseButton dijitTabCloseIcon\" data-dojo-attach-point='closeNode'\n\t\t  role=\"presentation\">\n\t\t<span data-dojo-attach-point='closeText' class='dijitTabCloseText'>[x]</span\n\t\t\t\t></span>\n</div>\n",
'dijit/_base/window':function(){
define("dijit/_base/window", [
        "dojo/window", // windowUtils.get
        "../main"       // export symbol to dijit
], function(windowUtils, dijit){
        // module:
        //              dijit/_base/window

        /*=====
        return {
                // summary:
                //              Back compatibility module, new code should use windowUtils directly instead of using this module.
        };
        =====*/

        dijit.getDocumentWindow = function(doc){
                return windowUtils.get(doc);
        };
});

},
'dojo/hccss':function(){
define("dojo/hccss", [
        "require",                      // require.toUrl
        "./_base/config", // config.blankGif
        "./dom-class", // domClass.add
        "./dom-style", // domStyle.getComputedStyle
        "./has",
        "./ready", // ready
        "./_base/window" // win.body
], function(require, config, domClass, domStyle, has, ready, win){

        // module:
        //              dojo/hccss

        /*=====
        return function(){
                // summary:
                //              Test if computer is in high contrast mode (i.e. if browser is not displaying background images).
                //              Defines `has("highcontrast")` and sets `dj_a11y` CSS class on `<body>` if machine is in high contrast mode.
                //              Returns `has()` method;
        };
        =====*/

        // Has() test for when background images aren't displayed.  Don't call has("highcontrast") before dojo/domReady!.
        has.add("highcontrast", function(){
                // note: if multiple documents, doesn't matter which one we use
                var div = win.doc.createElement("div");
                div.style.cssText = "border: 1px solid; border-color:red green; position: absolute; height: 5px; top: -999px;" +
                        "background-image: url(" + (config.blankGif || require.toUrl("./resources/blank.gif")) + ");";
                win.body().appendChild(div);

                var cs = domStyle.getComputedStyle(div),
                        bkImg = cs.backgroundImage,
                        hc = (cs.borderTopColor == cs.borderRightColor) ||
                                (bkImg && (bkImg == "none" || bkImg == "url(invalid-url:)" ));

                if(has("ie") <= 8){
                        div.outerHTML = "";             // prevent mixed-content warning, see http://support.microsoft.com/kb/925014
                }else{
                        win.body().removeChild(div);
                }

                return hc;
        });

        // Priority is 90 to run ahead of parser priority of 100.   For 2.0, remove the ready() call and instead
        // change this module to depend on dojo/domReady!
        ready(90, function(){
                if(has("highcontrast")){
                        domClass.add(win.body(), "dj_a11y");
                }
        });

        return has;
});

},
'dijit/form/RadioButton':function(){
define("dijit/form/RadioButton", [
        "dojo/_base/declare", // declare
        "./CheckBox",
        "./_RadioButtonMixin"
], function(declare, CheckBox, _RadioButtonMixin){

        // module:
        //              dijit/form/RadioButton

        return declare("dijit.form.RadioButton", [CheckBox, _RadioButtonMixin], {
                // summary:
                //              Same as an HTML radio, but with fancy styling.

                baseClass: "dijitRadio"
        });
});

},
'dijit/main':function(){
define("dijit/main", [
        "dojo/_base/kernel"
], function(dojo){
        // module:
        //              dijit/main

/*=====
return {
        // summary:
        //              The dijit package main module.
        //              Deprecated.   Users should access individual modules (ex: dijit/registry) directly.
};
=====*/

        return dojo.dijit;
});

},
'dijit/_OnDijitClickMixin':function(){
define("dijit/_OnDijitClickMixin", [
        "dojo/on",
        "dojo/_base/array", // array.forEach
        "dojo/keys", // keys.ENTER keys.SPACE
        "dojo/_base/declare", // declare
        "dojo/has", // has("dom-addeventlistener")
        "dojo/_base/unload", // unload.addOnWindowUnload
        "dojo/_base/window", // win.doc.addEventListener win.doc.attachEvent win.doc.detachEvent
        "./a11yclick"
], function(on, array, keys, declare, has, unload, win, a11yclick){

        // module:
        //              dijit/_OnDijitClickMixin

        var ret = declare("dijit._OnDijitClickMixin", null, {
                connect: function(
                                /*Object|null*/ obj,
                                /*String|Function*/ event,
                                /*String|Function*/ method){
                        // summary:
                        //              Connects specified obj/event to specified method of this object
                        //              and registers for disconnect() on widget destroy.
                        // description:
                        //              Provide widget-specific analog to connect.connect, except with the
                        //              implicit use of this widget as the target object.
                        //              This version of connect also provides a special "ondijitclick"
                        //              event which triggers on a click or space or enter keyup.
                        //              Events connected with `this.connect` are disconnected upon
                        //              destruction.
                        // returns:
                        //              A handle that can be passed to `disconnect` in order to disconnect before
                        //              the widget is destroyed.
                        // example:
                        //      |       var btn = new Button();
                        //      |       // when foo.bar() is called, call the listener we're going to
                        //      |       // provide in the scope of btn
                        //      |       btn.connect(foo, "bar", function(){
                        //      |               console.debug(this.toString());
                        //      |       });
                        // tags:
                        //              protected

                        return this.inherited(arguments, [obj, event == "ondijitclick" ? a11yclick : event, method]);
                }
        });

        ret.a11yclick = a11yclick;      // back compat

        return ret;
});

},
'dijit/InlineEditBox':function(){
require({cache:{
'url:dijit/templates/InlineEditBox.html':"<span data-dojo-attach-point=\"editNode\" role=\"presentation\" class=\"dijitReset dijitInline dijitOffScreen\"\n\tdata-dojo-attach-event=\"onkeypress: _onKeyPress\"\n\t><span data-dojo-attach-point=\"editorPlaceholder\"></span\n\t><span data-dojo-attach-point=\"buttonContainer\"\n\t\t><button data-dojo-type=\"dijit/form/Button\" data-dojo-props=\"label: '${buttonSave}', 'class': 'saveButton'\"\n\t\t\tdata-dojo-attach-point=\"saveButton\" data-dojo-attach-event=\"onClick:save\"></button\n\t\t><button data-dojo-type=\"dijit/form/Button\"  data-dojo-props=\"label: '${buttonCancel}', 'class': 'cancelButton'\"\n\t\t\tdata-dojo-attach-point=\"cancelButton\" data-dojo-attach-event=\"onClick:cancel\"></button\n\t></span\n></span>\n"}});
define("dijit/InlineEditBox", [
        "require",
        "dojo/_base/array", // array.forEach
        "dojo/_base/declare", // declare
        "dojo/dom-attr", // domAttr.set domAttr.get
        "dojo/dom-class", // domClass.add domClass.remove domClass.toggle
        "dojo/dom-construct", // domConstruct.create domConstruct.destroy
        "dojo/dom-style", // domStyle.getComputedStyle domStyle.set domStyle.get
        "dojo/_base/event", // event.stop
        "dojo/i18n", // i18n.getLocalization
        "dojo/_base/kernel", // kernel.deprecated
        "dojo/keys", // keys.ENTER keys.ESCAPE
        "dojo/_base/lang", // lang.getObject
        "dojo/sniff", // has("ie")
        "dojo/when",
        "./focus",
        "./_Widget",
        "./_TemplatedMixin",
        "./_WidgetsInTemplateMixin",
        "./_Container",
        "./form/Button",
        "./form/_TextBoxMixin",
        "./form/TextBox",
        "dojo/text!./templates/InlineEditBox.html",
        "dojo/i18n!./nls/common"
], function(require, array, declare, domAttr, domClass, domConstruct, domStyle, event, i18n, kernel, keys, lang, has, when,
                        fm, _Widget, _TemplatedMixin, _WidgetsInTemplateMixin, _Container, Button, _TextBoxMixin, TextBox, template){

        // module:
        //              dijit/InlineEditBox

        var InlineEditor = declare("dijit._InlineEditor", [_Widget, _TemplatedMixin, _WidgetsInTemplateMixin], {
                // summary:
                //              Internal widget used by InlineEditBox, displayed when in editing mode
                //              to display the editor and maybe save/cancel buttons.  Calling code should
                //              connect to save/cancel methods to detect when editing is finished
                //
                //              Has mainly the same parameters as InlineEditBox, plus these values:
                //
                // style: Object
                //              Set of CSS attributes of display node, to replicate in editor
                //
                // value: String
                //              Value as an HTML string or plain text string, depending on renderAsHTML flag

                templateString: template,

                postMixInProperties: function(){
                        this.inherited(arguments);
                        this.messages = i18n.getLocalization("dijit", "common", this.lang);
                        array.forEach(["buttonSave", "buttonCancel"], function(prop){
                                if(!this[prop]){
                                        this[prop] = this.messages[prop];
                                }
                        }, this);
                },

                buildRendering: function(){
                        this.inherited(arguments);

                        // Create edit widget in place in the template
                        // TODO: remove getObject() for 2.0
                        var Cls = typeof this.editor == "string" ? (lang.getObject(this.editor) || require(this.editor)) : this.editor;

                        // Copy the style from the source
                        // Don't copy ALL properties though, just the necessary/applicable ones.
                        // wrapperStyle/destStyle code is to workaround IE bug where getComputedStyle().fontSize
                        // is a relative value like 200%, rather than an absolute value like 24px, and
                        // the 200% can refer *either* to a setting on the node or it's ancestor (see #11175)
                        var srcStyle = this.sourceStyle,
                                editStyle = "line-height:" + srcStyle.lineHeight + ";",
                                destStyle = domStyle.getComputedStyle(this.domNode);
                        array.forEach(["Weight", "Family", "Size", "Style"], function(prop){
                                var textStyle = srcStyle["font" + prop],
                                        wrapperStyle = destStyle["font" + prop];
                                if(wrapperStyle != textStyle){
                                        editStyle += "font-" + prop + ":" + srcStyle["font" + prop] + ";";
                                }
                        }, this);
                        array.forEach(["marginTop", "marginBottom", "marginLeft", "marginRight", "position", "left", "top", "right", "bottom", "float", "clear", "display"], function(prop){
                                this.domNode.style[prop] = srcStyle[prop];
                        }, this);
                        var width = this.inlineEditBox.width;
                        if(width == "100%"){
                                // block mode
                                editStyle += "width:100%;";
                                this.domNode.style.display = "block";
                        }else{
                                // inline-block mode
                                editStyle += "width:" + (width + (Number(width) == width ? "px" : "")) + ";";
                        }
                        var editorParams = lang.delegate(this.inlineEditBox.editorParams, {
                                style: editStyle,
                                dir: this.dir,
                                lang: this.lang,
                                textDir: this.textDir
                        });
                        editorParams[ "displayedValue" in Cls.prototype ? "displayedValue" : "value"] = this.value;
                        this.editWidget = new Cls(editorParams, this.editorPlaceholder);

                        if(this.inlineEditBox.autoSave){
                                // Remove the save/cancel buttons since saving is done by simply tabbing away or
                                // selecting a value from the drop down list
                                domConstruct.destroy(this.buttonContainer);
                        }
                },

                postCreate: function(){
                        this.inherited(arguments);

                        var ew = this.editWidget;

                        if(this.inlineEditBox.autoSave){
                                // Selecting a value from a drop down list causes an onChange event and then we save
                                this.connect(ew, "onChange", "_onChange");

                                // ESC and TAB should cancel and save.  Note that edit widgets do a stopEvent() on ESC key (to
                                // prevent Dialog from closing when the user just wants to revert the value in the edit widget),
                                // so this is the only way we can see the key press event.
                                this.connect(ew, "onKeyPress", "_onKeyPress");
                        }else{
                                // If possible, enable/disable save button based on whether the user has changed the value
                                if("intermediateChanges" in ew){
                                        ew.set("intermediateChanges", true);
                                        this.connect(ew, "onChange", "_onIntermediateChange");
                                        this.saveButton.set("disabled", true);
                                }
                        }
                },

                startup: function(){
                        this.editWidget.startup();
                        this.inherited(arguments);
                },

                _onIntermediateChange: function(/*===== val =====*/){
                        // summary:
                        //              Called for editor widgets that support the intermediateChanges=true flag as a way
                        //              to detect when to enable/disabled the save button
                        this.saveButton.set("disabled", (this.getValue() == this._resetValue) || !this.enableSave());
                },

                destroy: function(){
                        this.editWidget.destroy(true); // let the parent wrapper widget clean up the DOM
                        this.inherited(arguments);
                },

                getValue: function(){
                        // summary:
                        //              Return the [display] value of the edit widget
                        var ew = this.editWidget;
                        return String(ew.get("displayedValue" in ew ? "displayedValue" : "value"));
                },

                _onKeyPress: function(e){
                        // summary:
                        //              Handler for keypress in the edit box in autoSave mode.
                        // description:
                        //              For autoSave widgets, if Esc/Enter, call cancel/save.
                        // tags:
                        //              private

                        if(this.inlineEditBox.autoSave && this.inlineEditBox.editing){
                                if(e.altKey || e.ctrlKey){
                                        return;
                                }
                                // If Enter/Esc pressed, treat as save/cancel.
                                if(e.charOrCode == keys.ESCAPE){
                                        event.stop(e);
                                        this.cancel(true); // sets editing=false which short-circuits _onBlur processing
                                }else if(e.charOrCode == keys.ENTER && e.target.tagName == "INPUT"){
                                        event.stop(e);
                                        this._onChange(); // fire _onBlur and then save
                                }

                                // _onBlur will handle TAB automatically by allowing
                                // the TAB to change focus before we mess with the DOM: #6227
                                // Expounding by request:
                                //      The current focus is on the edit widget input field.
                                //      save() will hide and destroy this widget.
                                //      We want the focus to jump from the currently hidden
                                //      displayNode, but since it's hidden, it's impossible to
                                //      unhide it, focus it, and then have the browser focus
                                //      away from it to the next focusable element since each
                                //      of these events is asynchronous and the focus-to-next-element
                                //      is already queued.
                                //      So we allow the browser time to unqueue the move-focus event
                                //      before we do all the hide/show stuff.
                        }
                },

                _onBlur: function(){
                        // summary:
                        //              Called when focus moves outside the editor
                        // tags:
                        //              private

                        this.inherited(arguments);
                        if(this.inlineEditBox.autoSave && this.inlineEditBox.editing){
                                if(this.getValue() == this._resetValue){
                                        this.cancel(false);
                                }else if(this.enableSave()){
                                        this.save(false);
                                }
                        }
                },

                _onChange: function(){
                        // summary:
                        //              Called when the underlying widget fires an onChange event,
                        //              such as when the user selects a value from the drop down list of a ComboBox,
                        //              which means that the user has finished entering the value and we should save.
                        // tags:
                        //              private

                        if(this.inlineEditBox.autoSave && this.inlineEditBox.editing && this.enableSave()){
                                fm.focus(this.inlineEditBox.displayNode); // fires _onBlur which will save the formatted value
                        }
                },

                enableSave: function(){
                        // summary:
                        //              User overridable function returning a Boolean to indicate
                        //              if the Save button should be enabled or not - usually due to invalid conditions
                        // tags:
                        //              extension
                        return this.editWidget.isValid ? this.editWidget.isValid() : true;
                },

                focus: function(){
                        // summary:
                        //              Focus the edit widget.
                        // tags:
                        //              protected

                        this.editWidget.focus();

                        if(this.editWidget.focusNode){
                                // IE can take 30ms to report the focus event, but focus manager needs to know before a 0ms timeout.
                                fm._onFocusNode(this.editWidget.focusNode);

                                if(this.editWidget.focusNode.tagName == "INPUT"){
                                        this.defer(function(){
                                                _TextBoxMixin.selectInputText(this.editWidget.focusNode);
                                        });
                                }
                        }
                }
        });


        var InlineEditBox = declare("dijit.InlineEditBox", _Widget, {
                // summary:
                //              An element with in-line edit capabilities
                //
                // description:
                //              Behavior for an existing node (`<p>`, `<div>`, `<span>`, etc.) so that
                //              when you click it, an editor shows up in place of the original
                //              text.  Optionally, Save and Cancel button are displayed below the edit widget.
                //              When Save is clicked, the text is pulled from the edit
                //              widget and redisplayed and the edit widget is again hidden.
                //              By default a plain Textarea widget is used as the editor (or for
                //              inline values a TextBox), but you can specify an editor such as
                //              dijit.Editor (for editing HTML) or a Slider (for adjusting a number).
                //              An edit widget must support the following API to be used:
                //
                //              - displayedValue or value as initialization parameter,
                //                      and available through set('displayedValue') / set('value')
                //              - void focus()
                //              - DOM-node focusNode = node containing editable text

                // editing: [readonly] Boolean
                //              Is the node currently in edit mode?
                editing: false,

                // autoSave: Boolean
                //              Changing the value automatically saves it; don't have to push save button
                //              (and save button isn't even displayed)
                autoSave: true,

                // buttonSave: String
                //              Save button label
                buttonSave: "",

                // buttonCancel: String
                //              Cancel button label
                buttonCancel: "",

                // renderAsHtml: Boolean
                //              Set this to true if the specified Editor's value should be interpreted as HTML
                //              rather than plain text (ex: `dijit.Editor`)
                renderAsHtml: false,

                // editor: String|Function
                //              MID (ex: "dijit/form/TextBox") or constructor for editor widget
                editor: TextBox,

                // editorWrapper: String|Function
                //              Class name (or reference to the Class) for widget that wraps the editor widget, displaying save/cancel
                //              buttons.
                editorWrapper: InlineEditor,

                // editorParams: Object
                //              Set of parameters for editor, like {required: true}
                editorParams: {},

                // disabled: Boolean
                //              If true, clicking the InlineEditBox to edit it will have no effect.
                disabled: false,

                onChange: function(/*===== value =====*/){
                        // summary:
                        //              Set this handler to be notified of changes to value.
                        // tags:
                        //              callback
                },

                onCancel: function(){
                        // summary:
                        //              Set this handler to be notified when editing is cancelled.
                        // tags:
                        //              callback
                },

                // width: String
                //              Width of editor.  By default it's width=100% (ie, block mode).
                width: "100%",

                // value: String
                //              The display value of the widget in read-only mode
                value: "",

                // noValueIndicator: [const] String
                //              The text that gets displayed when there is no value (so that the user has a place to click to edit)
                noValueIndicator: has("ie") <= 6 ? // font-family needed on IE6 but it messes up IE8
                        "<span style='font-family: wingdings; text-decoration: underline;'>&#160;&#160;&#160;&#160;&#x270d;&#160;&#160;&#160;&#160;</span>" :
                        "<span style='text-decoration: underline;'>&#160;&#160;&#160;&#160;&#x270d;&#160;&#160;&#160;&#160;</span>", // &#160; == &nbsp;

                constructor: function(/*===== params, srcNodeRef =====*/){
                        // summary:
                        //              Create the widget.
                        // params: Object|null
                        //              Hash of initialization parameters for widget, including scalar values (like title, duration etc.)
                        //              and functions, typically callbacks like onClick.
                        //              The hash can contain any of the widget's properties, excluding read-only properties.
                        // srcNodeRef: DOMNode|String?
                        //              If a srcNodeRef (DOM node) is specified:
                        //
                        //              - use srcNodeRef.innerHTML as my value
                        //              - replace srcNodeRef with my generated DOM tree

                        this.editorParams = {};
                },

                postMixInProperties: function(){
                        this.inherited(arguments);

                        // save pointer to original source node, since Widget nulls-out srcNodeRef
                        this.displayNode = this.srcNodeRef;

                        // connect handlers to the display node
                        var events = {
                                ondijitclick: "_onClick",
                                onmouseover: "_onMouseOver",
                                onmouseout: "_onMouseOut",
                                onfocus: "_onMouseOver",
                                onblur: "_onMouseOut"
                        };
                        for(var name in events){
                                this.connect(this.displayNode, name, events[name]);
                        }
                        this.displayNode.setAttribute("role", "button");
                        if(!this.displayNode.getAttribute("tabIndex")){
                                this.displayNode.setAttribute("tabIndex", 0);
                        }

                        if(!this.value && !("value" in this.params)){ // "" is a good value if specified directly so check params){
                                this.value = lang.trim(this.renderAsHtml ? this.displayNode.innerHTML :
                                        (this.displayNode.innerText || this.displayNode.textContent || ""));
                        }
                        if(!this.value){
                                this.displayNode.innerHTML = this.noValueIndicator;
                        }

                        domClass.add(this.displayNode, 'dijitInlineEditBoxDisplayMode');
                },

                setDisabled: function(/*Boolean*/ disabled){
                        // summary:
                        //              Deprecated.   Use set('disabled', ...) instead.
                        // tags:
                        //              deprecated
                        kernel.deprecated("dijit.InlineEditBox.setDisabled() is deprecated.  Use set('disabled', bool) instead.", "", "2.0");
                        this.set('disabled', disabled);
                },

                _setDisabledAttr: function(/*Boolean*/ disabled){
                        // summary:
                        //              Hook to make set("disabled", ...) work.
                        //              Set disabled state of widget.
                        this.domNode.setAttribute("aria-disabled", disabled ? "true" : "false");
                        if(disabled){
                                this.displayNode.removeAttribute("tabIndex");
                        }else{
                                this.displayNode.setAttribute("tabIndex", 0);
                        }
                        domClass.toggle(this.displayNode, "dijitInlineEditBoxDisplayModeDisabled", disabled);
                        this._set("disabled", disabled);
                },

                _onMouseOver: function(){
                        // summary:
                        //              Handler for onmouseover and onfocus event.
                        // tags:
                        //              private
                        if(!this.disabled){
                                domClass.add(this.displayNode, "dijitInlineEditBoxDisplayModeHover");
                        }
                },

                _onMouseOut: function(){
                        // summary:
                        //              Handler for onmouseout and onblur event.
                        // tags:
                        //              private
                        domClass.remove(this.displayNode, "dijitInlineEditBoxDisplayModeHover");
                },

                _onClick: function(/*Event*/ e){
                        // summary:
                        //              Handler for onclick event.
                        // tags:
                        //              private
                        if(this.disabled){
                                return;
                        }
                        if(e){
                                event.stop(e);
                        }
                        this._onMouseOut();

                        // Since FF gets upset if you move a node while in an event handler for that node...
                        this.defer("edit");
                },

                edit: function(){
                        // summary:
                        //              Display the editor widget in place of the original (read only) markup.
                        // tags:
                        //              private

                        if(this.disabled || this.editing){
                                return;
                        }
                        this._set('editing', true);

                        // save some display node values that can be restored later
                        this._savedTabIndex = domAttr.get(this.displayNode, "tabIndex") || "0";

                        if(this.wrapperWidget){
                                var ew = this.wrapperWidget.editWidget;
                                ew.set("displayedValue" in ew ? "displayedValue" : "value", this.value);
                        }else{
                                // Placeholder for edit widget
                                // Put place holder (and eventually editWidget) before the display node so that it's positioned correctly
                                // when Calendar dropdown appears, which happens automatically on focus.
                                var placeholder = domConstruct.create("span", null, this.domNode, "before");

                                // Create the editor wrapper (the thing that holds the editor widget and the save/cancel buttons)
                                var Ewc = typeof this.editorWrapper == "string" ? lang.getObject(this.editorWrapper) : this.editorWrapper;
                                this.wrapperWidget = new Ewc({
                                        value: this.value,
                                        buttonSave: this.buttonSave,
                                        buttonCancel: this.buttonCancel,
                                        dir: this.dir,
                                        lang: this.lang,
                                        tabIndex: this._savedTabIndex,
                                        editor: this.editor,
                                        inlineEditBox: this,
                                        sourceStyle: domStyle.getComputedStyle(this.displayNode),
                                        save: lang.hitch(this, "save"),
                                        cancel: lang.hitch(this, "cancel"),
                                        textDir: this.textDir
                                }, placeholder);
                                if(!this.wrapperWidget._started){
                                        this.wrapperWidget.startup();
                                }
                                if(!this._started){
                                        this.startup();
                                }
                        }
                        var ww = this.wrapperWidget;

                        // to avoid screen jitter, we first create the editor with position: absolute, visibility: hidden,
                        // and then when it's finished rendering, we switch from display mode to editor
                        // position: absolute releases screen space allocated to the display node
                        // opacity:0 is the same as visibility: hidden but is still focusable
                        // visibility: hidden removes focus outline

                        domClass.add(this.displayNode, "dijitOffScreen");
                        domClass.remove(ww.domNode, "dijitOffScreen");
                        domStyle.set(ww.domNode, { visibility: "visible" });
                        domAttr.set(this.displayNode, "tabIndex", "-1"); // needed by WebKit for TAB from editor to skip displayNode

                        // After edit widget has finished initializing (in particular need to wait for dijit.Editor),
                        // or immediately if there is no onLoadDeferred Deferred,
                        // replace the display widget with edit widget, leaving them both displayed for a brief time so that
                        // focus can be shifted without incident.
                        when(ww.editWidget.onLoadDeferred, lang.hitch(ww, function(){
                                this.defer(function(){ // defer needed so that the change of focus doesn't happen on mousedown which also sets focus
                                        this.focus(); // both nodes are showing, so we can switch focus safely
                                        this._resetValue = this.getValue();
                                });
                        }));
                },

                _onBlur: function(){
                        // summary:
                        //              Called when focus moves outside the InlineEditBox.
                        //              Performs garbage collection.
                        // tags:
                        //              private

                        this.inherited(arguments);
                        if(!this.editing){
                                /* causes IE focus problems, see TooltipDialog_a11y.html...
                                 this.defer(function(){
                                 if(this.wrapperWidget){
                                 this.wrapperWidget.destroy();
                                 delete this.wrapperWidget;
                                 }
                                 });
                                 */
                        }
                },

                destroy: function(){
                        if(this.wrapperWidget && !this.wrapperWidget._destroyed){
                                this.wrapperWidget.destroy();
                                delete this.wrapperWidget;
                        }
                        this.inherited(arguments);
                },

                _showText: function(/*Boolean*/ focus){
                        // summary:
                        //              Revert to display mode, and optionally focus on display node
                        // tags:
                        //              private

                        var ww = this.wrapperWidget;
                        domStyle.set(ww.domNode, { visibility: "hidden" }); // hide the editor from mouse/keyboard events
                        domClass.add(ww.domNode, "dijitOffScreen");
                        domClass.remove(this.displayNode, "dijitOffScreen");
                        domAttr.set(this.displayNode, "tabIndex", this._savedTabIndex);
                        if(focus){
                                fm.focus(this.displayNode);
                        }
                },

                save: function(/*Boolean*/ focus){
                        // summary:
                        //              Save the contents of the editor and revert to display mode.
                        // focus: Boolean
                        //              Focus on the display mode text
                        // tags:
                        //              private

                        if(this.disabled || !this.editing){
                                return;
                        }
                        this._set('editing', false);

                        var ww = this.wrapperWidget;
                        var value = ww.getValue();
                        this.set('value', value); // display changed, formatted value

                        this._showText(focus); // set focus as needed
                },

                setValue: function(/*String*/ val){
                        // summary:
                        //              Deprecated.   Use set('value', ...) instead.
                        // tags:
                        //              deprecated
                        kernel.deprecated("dijit.InlineEditBox.setValue() is deprecated.  Use set('value', ...) instead.", "", "2.0");
                        return this.set("value", val);
                },

                _setValueAttr: function(/*String*/ val){
                        // summary:
                        //              Hook to make set("value", ...) work.
                        //              Inserts specified HTML value into this node, or an "input needed" character if node is blank.

                        val = lang.trim(val);
                        var renderVal = this.renderAsHtml ? val : val.replace(/&/gm, "&amp;").replace(/</gm, "&lt;").replace(/>/gm, "&gt;").replace(/"/gm, "&quot;").replace(/\n/g, "<br>");
                        this.displayNode.innerHTML = renderVal || this.noValueIndicator;
                        this._set("value", val);

                        if(this._started){
                                // tell the world that we have changed
                                this.defer(function(){
                                        this.onChange(val);
                                }); // defer prevents browser freeze for long-running event handlers
                        }
                        // contextual (auto) text direction depends on the text value
                        if(this.textDir == "auto"){
                                this.applyTextDir(this.displayNode, this.displayNode.innerText);
                        }
                },

                getValue: function(){
                        // summary:
                        //              Deprecated.   Use get('value') instead.
                        // tags:
                        //              deprecated
                        kernel.deprecated("dijit.InlineEditBox.getValue() is deprecated.  Use get('value') instead.", "", "2.0");
                        return this.get("value");
                },

                cancel: function(/*Boolean*/ focus){
                        // summary:
                        //              Revert to display mode, discarding any changes made in the editor
                        // tags:
                        //              private

                        if(this.disabled || !this.editing){
                                return;
                        }
                        this._set('editing', false);

                        // tell the world that we have no changes
                        this.defer("onCancel"); // defer prevents browser freeze for long-running event handlers

                        this._showText(focus);
                },

                _setTextDirAttr: function(/*String*/ textDir){
                        // summary:
                        //              Setter for textDir.
                        // description:
                        //              Users shouldn't call this function; they should be calling
                        //              set('textDir', value)
                        // tags:
                        //              private
                        if(!this._created || this.textDir != textDir){
                                this._set("textDir", textDir);
                                this.applyTextDir(this.displayNode, this.displayNode.innerText);
                                this.displayNode.align = this.dir == "rtl" ? "right" : "left"; //fix the text alignment
                        }
                }
        });

        InlineEditBox._InlineEditor = InlineEditor;     // for monkey patching

        return InlineEditBox;
});
},
'dojo/selector/acme':function(){
define("dojo/selector/acme", [
        "../dom", "../sniff", "../_base/array", "../_base/lang", "../_base/window"
], function(dom, has, array, lang, win){

        // module:
        //              dojo/selector/acme

/*
        acme architectural overview:

                acme is a relatively full-featured CSS3 query library. It is
                designed to take any valid CSS3 selector and return the nodes matching
                the selector. To do this quickly, it processes queries in several
                steps, applying caching where profitable.

                The steps (roughly in reverse order of the way they appear in the code):
                        1.) check to see if we already have a "query dispatcher"
                                - if so, use that with the given parameterization. Skip to step 4.
                        2.) attempt to determine which branch to dispatch the query to:
                                - JS (optimized DOM iteration)
                                - native (FF3.1+, Safari 3.1+, IE 8+)
                        3.) tokenize and convert to executable "query dispatcher"
                                - this is where the lion's share of the complexity in the
                                        system lies. In the DOM version, the query dispatcher is
                                        assembled as a chain of "yes/no" test functions pertaining to
                                        a section of a simple query statement (".blah:nth-child(odd)"
                                        but not "div div", which is 2 simple statements). Individual
                                        statement dispatchers are cached (to prevent re-definition)
                                        as are entire dispatch chains (to make re-execution of the
                                        same query fast)
                        4.) the resulting query dispatcher is called in the passed scope
                                        (by default the top-level document)
                                - for DOM queries, this results in a recursive, top-down
                                        evaluation of nodes based on each simple query section
                                - for native implementations, this may mean working around spec
                                        bugs. So be it.
                        5.) matched nodes are pruned to ensure they are unique (if necessary)
*/


        ////////////////////////////////////////////////////////////////////////
        // Toolkit aliases
        ////////////////////////////////////////////////////////////////////////

        // if you are extracting acme for use in your own system, you will
        // need to provide these methods and properties. No other porting should be
        // necessary, save for configuring the system to use a class other than
        // dojo/NodeList as the return instance instantiator
        var trim =                      lang.trim;
        var each =                      array.forEach;

        var getDoc = function(){ return win.doc; };
        // NOTE(alex): the spec is idiotic. CSS queries should ALWAYS be case-sensitive, but nooooooo
        var cssCaseBug = (getDoc().compatMode) == "BackCompat";

        ////////////////////////////////////////////////////////////////////////
        // Global utilities
        ////////////////////////////////////////////////////////////////////////


        var specials = ">~+";

        // global thunk to determine whether we should treat the current query as
        // case sensitive or not. This switch is flipped by the query evaluator
        // based on the document passed as the context to search.
        var caseSensitive = false;

        // how high?
        var yesman = function(){ return true; };

        ////////////////////////////////////////////////////////////////////////
        // Tokenizer
        ////////////////////////////////////////////////////////////////////////

        var getQueryParts = function(query){
                // summary:
                //              state machine for query tokenization
                // description:
                //              instead of using a brittle and slow regex-based CSS parser,
                //              acme implements an AST-style query representation. This
                //              representation is only generated once per query. For example,
                //              the same query run multiple times or under different root nodes
                //              does not re-parse the selector expression but instead uses the
                //              cached data structure. The state machine implemented here
                //              terminates on the last " " (space) character and returns an
                //              ordered array of query component structures (or "parts"). Each
                //              part represents an operator or a simple CSS filtering
                //              expression. The structure for parts is documented in the code
                //              below.


                // NOTE:
                //              this code is designed to run fast and compress well. Sacrifices
                //              to readability and maintainability have been made.  Your best
                //              bet when hacking the tokenizer is to put The Donnas on *really*
                //              loud (may we recommend their "Spend The Night" release?) and
                //              just assume you're gonna make mistakes. Keep the unit tests
                //              open and run them frequently. Knowing is half the battle ;-)
                if(specials.indexOf(query.slice(-1)) >= 0){
                        // if we end with a ">", "+", or "~", that means we're implicitly
                        // searching all children, so make it explicit
                        query += " * ";
                }else{
                        // if you have not provided a terminator, one will be provided for
                        // you...
                        query += " ";
                }

                var ts = function(/*Integer*/ s, /*Integer*/ e){
                        // trim and slice.

                        // take an index to start a string slice from and an end position
                        // and return a trimmed copy of that sub-string
                        return trim(query.slice(s, e));
                };

                // the overall data graph of the full query, as represented by queryPart objects
                var queryParts = [];


                // state keeping vars
                var inBrackets = -1, inParens = -1, inMatchFor = -1,
                        inPseudo = -1, inClass = -1, inId = -1, inTag = -1, currentQuoteChar,
                        lc = "", cc = "", pStart;

                // iteration vars
                var x = 0, // index in the query
                        ql = query.length,
                        currentPart = null, // data structure representing the entire clause
                        _cp = null; // the current pseudo or attr matcher

                // several temporary variables are assigned to this structure during a
                // potential sub-expression match:
                //              attr:
                //                      a string representing the current full attribute match in a
                //                      bracket expression
                //              type:
                //                      if there's an operator in a bracket expression, this is
                //                      used to keep track of it
                //              value:
                //                      the internals of parenthetical expression for a pseudo. for
                //                      :nth-child(2n+1), value might be "2n+1"

                var endTag = function(){
                        // called when the tokenizer hits the end of a particular tag name.
                        // Re-sets state variables for tag matching and sets up the matcher
                        // to handle the next type of token (tag or operator).
                        if(inTag >= 0){
                                var tv = (inTag == x) ? null : ts(inTag, x); // .toLowerCase();
                                currentPart[ (specials.indexOf(tv) < 0) ? "tag" : "oper" ] = tv;
                                inTag = -1;
                        }
                };

                var endId = function(){
                        // called when the tokenizer might be at the end of an ID portion of a match
                        if(inId >= 0){
                                currentPart.id = ts(inId, x).replace(/\\/g, "");
                                inId = -1;
                        }
                };

                var endClass = function(){
                        // called when the tokenizer might be at the end of a class name
                        // match. CSS allows for multiple classes, so we augment the
                        // current item with another class in its list
                        if(inClass >= 0){
                                currentPart.classes.push(ts(inClass + 1, x).replace(/\\/g, ""));
                                inClass = -1;
                        }
                };

                var endAll = function(){
                        // at the end of a simple fragment, so wall off the matches
                        endId();
                        endTag();
                        endClass();
                };

                var endPart = function(){
                        endAll();
                        if(inPseudo >= 0){
                                currentPart.pseudos.push({ name: ts(inPseudo + 1, x) });
                        }
                        // hint to the selector engine to tell it whether or not it
                        // needs to do any iteration. Many simple selectors don't, and
                        // we can avoid significant construction-time work by advising
                        // the system to skip them
                        currentPart.loops = (
                                        currentPart.pseudos.length ||
                                        currentPart.attrs.length ||
                                        currentPart.classes.length      );

                        currentPart.oquery = currentPart.query = ts(pStart, x); // save the full expression as a string


                        // otag/tag are hints to suggest to the system whether or not
                        // it's an operator or a tag. We save a copy of otag since the
                        // tag name is cast to upper-case in regular HTML matches. The
                        // system has a global switch to figure out if the current
                        // expression needs to be case sensitive or not and it will use
                        // otag or tag accordingly
                        currentPart.otag = currentPart.tag = (currentPart["oper"]) ? null : (currentPart.tag || "*");

                        if(currentPart.tag){
                                // if we're in a case-insensitive HTML doc, we likely want
                                // the toUpperCase when matching on element.tagName. If we
                                // do it here, we can skip the string op per node
                                // comparison
                                currentPart.tag = currentPart.tag.toUpperCase();
                        }

                        // add the part to the list
                        if(queryParts.length && (queryParts[queryParts.length-1].oper)){
                                // operators are always infix, so we remove them from the
                                // list and attach them to the next match. The evaluator is
                                // responsible for sorting out how to handle them.
                                currentPart.infixOper = queryParts.pop();
                                currentPart.query = currentPart.infixOper.query + " " + currentPart.query;
                                /*
                                console.debug(  "swapping out the infix",
                                                                currentPart.infixOper,
                                                                "and attaching it to",
                                                                currentPart);
                                */
                        }
                        queryParts.push(currentPart);

                        currentPart = null;
                };

                // iterate over the query, character by character, building up a
                // list of query part objects
                for(; lc=cc, cc=query.charAt(x), x < ql; x++){
                        //              cc: the current character in the match
                        //              lc: the last character (if any)

                        // someone is trying to escape something, so don't try to match any
                        // fragments. We assume we're inside a literal.
                        if(lc == "\\"){ continue; }
                        if(!currentPart){ // a part was just ended or none has yet been created
                                // NOTE: I hate all this alloc, but it's shorter than writing tons of if's
                                pStart = x;
                                //      rules describe full CSS sub-expressions, like:
                                //              #someId
                                //              .className:first-child
                                //      but not:
                                //              thinger > div.howdy[type=thinger]
                                //      the indidual components of the previous query would be
                                //      split into 3 parts that would be represented a structure like:
                                //              [
                                //                      {
                                //                              query: "thinger",
                                //                              tag: "thinger",
                                //                      },
                                //                      {
                                //                              query: "div.howdy[type=thinger]",
                                //                              classes: ["howdy"],
                                //                              infixOper: {
                                //                                      query: ">",
                                //                                      oper: ">",
                                //                              }
                                //                      },
                                //              ]
                                currentPart = {
                                        query: null, // the full text of the part's rule
                                        pseudos: [], // CSS supports multiple pseud-class matches in a single rule
                                        attrs: [],      // CSS supports multi-attribute match, so we need an array
                                        classes: [], // class matches may be additive, e.g.: .thinger.blah.howdy
                                        tag: null,      // only one tag...
                                        oper: null, // ...or operator per component. Note that these wind up being exclusive.
                                        id: null,       // the id component of a rule
                                        getTag: function(){
                                                return caseSensitive ? this.otag : this.tag;
                                        }
                                };

                                // if we don't have a part, we assume we're going to start at
                                // the beginning of a match, which should be a tag name. This
                                // might fault a little later on, but we detect that and this
                                // iteration will still be fine.
                                inTag = x;
                        }

                        // Skip processing all quoted characters.
                        // If we are inside quoted text then currentQuoteChar stores the character that began the quote,
                        // thus that character that will end it.
                        if(currentQuoteChar){
                                if(cc == currentQuoteChar){
                                        currentQuoteChar = null;
                                }
                                continue;
                        }else if (cc == "'" || cc == '"'){
                                currentQuoteChar = cc;
                                continue;
                        }

                        if(inBrackets >= 0){
                                // look for a the close first
                                if(cc == "]"){ // if we're in a [...] clause and we end, do assignment
                                        if(!_cp.attr){
                                                // no attribute match was previously begun, so we
                                                // assume this is an attribute existence match in the
                                                // form of [someAttributeName]
                                                _cp.attr = ts(inBrackets+1, x);
                                        }else{
                                                // we had an attribute already, so we know that we're
                                                // matching some sort of value, as in [attrName=howdy]
                                                _cp.matchFor = ts((inMatchFor||inBrackets+1), x);
                                        }
                                        var cmf = _cp.matchFor;
                                        if(cmf){
                                                // try to strip quotes from the matchFor value. We want
                                                // [attrName=howdy] to match the same
                                                //      as [attrName = 'howdy' ]
                                                if(     (cmf.charAt(0) == '"') || (cmf.charAt(0) == "'") ){
                                                        _cp.matchFor = cmf.slice(1, -1);
                                                }
                                        }
                                        // remove backslash escapes from an attribute match, since DOM
                                        // querying will get attribute values without backslashes
                                        if(_cp.matchFor){
                                                _cp.matchFor = _cp.matchFor.replace(/\\/g, "");
                                        }

                                        // end the attribute by adding it to the list of attributes.
                                        currentPart.attrs.push(_cp);
                                        _cp = null; // necessary?
                                        inBrackets = inMatchFor = -1;
                                }else if(cc == "="){
                                        // if the last char was an operator prefix, make sure we
                                        // record it along with the "=" operator.
                                        var addToCc = ("|~^$*".indexOf(lc) >=0 ) ? lc : "";
                                        _cp.type = addToCc+cc;
                                        _cp.attr = ts(inBrackets+1, x-addToCc.length);
                                        inMatchFor = x+1;
                                }
                                // now look for other clause parts
                        }else if(inParens >= 0){
                                // if we're in a parenthetical expression, we need to figure
                                // out if it's attached to a pseudo-selector rule like
                                // :nth-child(1)
                                if(cc == ")"){
                                        if(inPseudo >= 0){
                                                _cp.value = ts(inParens+1, x);
                                        }
                                        inPseudo = inParens = -1;
                                }
                        }else if(cc == "#"){
                                // start of an ID match
                                endAll();
                                inId = x+1;
                        }else if(cc == "."){
                                // start of a class match
                                endAll();
                                inClass = x;
                        }else if(cc == ":"){
                                // start of a pseudo-selector match
                                endAll();
                                inPseudo = x;
                        }else if(cc == "["){
                                // start of an attribute match.
                                endAll();
                                inBrackets = x;
                                // provide a new structure for the attribute match to fill-in
                                _cp = {
                                        /*=====
                                        attr: null, type: null, matchFor: null
                                        =====*/
                                };
                        }else if(cc == "("){
                                // we really only care if we've entered a parenthetical
                                // expression if we're already inside a pseudo-selector match
                                if(inPseudo >= 0){
                                        // provide a new structure for the pseudo match to fill-in
                                        _cp = {
                                                name: ts(inPseudo+1, x),
                                                value: null
                                        };
                                        currentPart.pseudos.push(_cp);
                                }
                                inParens = x;
                        }else if(
                                (cc == " ") &&
                                // if it's a space char and the last char is too, consume the
                                // current one without doing more work
                                (lc != cc)
                        ){
                                endPart();
                        }
                }
                return queryParts;
        };


        ////////////////////////////////////////////////////////////////////////
        // DOM query infrastructure
        ////////////////////////////////////////////////////////////////////////

        var agree = function(first, second){
                // the basic building block of the yes/no chaining system. agree(f1,
                // f2) generates a new function which returns the boolean results of
                // both of the passed functions to a single logical-anded result. If
                // either are not passed, the other is used exclusively.
                if(!first){ return second; }
                if(!second){ return first; }

                return function(){
                        return first.apply(window, arguments) && second.apply(window, arguments);
                };
        };

        var getArr = function(i, arr){
                // helps us avoid array alloc when we don't need it
                var r = arr||[]; // FIXME: should this be 'new d._NodeListCtor()' ?
                if(i){ r.push(i); }
                return r;
        };

        var _isElement = function(n){ return (1 == n.nodeType); };

        // FIXME: need to coalesce _getAttr with defaultGetter
        var blank = "";
        var _getAttr = function(elem, attr){
                if(!elem){ return blank; }
                if(attr == "class"){
                        return elem.className || blank;
                }
                if(attr == "for"){
                        return elem.htmlFor || blank;
                }
                if(attr == "style"){
                        return elem.style.cssText || blank;
                }
                return (caseSensitive ? elem.getAttribute(attr) : elem.getAttribute(attr, 2)) || blank;
        };

        var attrs = {
                "*=": function(attr, value){
                        return function(elem){
                                // E[foo*="bar"]
                                //              an E element whose "foo" attribute value contains
                                //              the substring "bar"
                                return (_getAttr(elem, attr).indexOf(value)>=0);
                        };
                },
                "^=": function(attr, value){
                        // E[foo^="bar"]
                        //              an E element whose "foo" attribute value begins exactly
                        //              with the string "bar"
                        return function(elem){
                                return (_getAttr(elem, attr).indexOf(value)==0);
                        };
                },
                "$=": function(attr, value){
                        // E[foo$="bar"]
                        //              an E element whose "foo" attribute value ends exactly
                        //              with the string "bar"
                        return function(elem){
                                var ea = " "+_getAttr(elem, attr);
                                var lastIndex = ea.lastIndexOf(value);
                                return lastIndex > -1 && (lastIndex==(ea.length-value.length));
                        };
                },
                "~=": function(attr, value){
                        // E[foo~="bar"]
                        //              an E element whose "foo" attribute value is a list of
                        //              space-separated values, one of which is exactly equal
                        //              to "bar"

                        // return "[contains(concat(' ',@"+attr+",' '), ' "+ value +" ')]";
                        var tval = " "+value+" ";
                        return function(elem){
                                var ea = " "+_getAttr(elem, attr)+" ";
                                return (ea.indexOf(tval)>=0);
                        };
                },
                "|=": function(attr, value){
                        // E[hreflang|="en"]
                        //              an E element whose "hreflang" attribute has a
                        //              hyphen-separated list of values beginning (from the
                        //              left) with "en"
                        var valueDash = value+"-";
                        return function(elem){
                                var ea = _getAttr(elem, attr);
                                return (
                                        (ea == value) ||
                                        (ea.indexOf(valueDash)==0)
                                );
                        };
                },
                "=": function(attr, value){
                        return function(elem){
                                return (_getAttr(elem, attr) == value);
                        };
                }
        };

        // avoid testing for node type if we can. Defining this in the negative
        // here to avoid negation in the fast path.
        var _noNES = (typeof getDoc().firstChild.nextElementSibling == "undefined");
        var _ns = !_noNES ? "nextElementSibling" : "nextSibling";
        var _ps = !_noNES ? "previousElementSibling" : "previousSibling";
        var _simpleNodeTest = (_noNES ? _isElement : yesman);

        var _lookLeft = function(node){
                // look left
                while(node = node[_ps]){
                        if(_simpleNodeTest(node)){ return false; }
                }
                return true;
        };

        var _lookRight = function(node){
                // look right
                while(node = node[_ns]){
                        if(_simpleNodeTest(node)){ return false; }
                }
                return true;
        };

        var getNodeIndex = function(node){
                var root = node.parentNode;
                root = root.nodeType != 7 ? root : root.nextSibling; // PROCESSING_INSTRUCTION_NODE
                var i = 0,
                        tret = root.children || root.childNodes,
                        ci = (node["_i"]||node.getAttribute("_i")||-1),
                        cl = (root["_l"]|| (typeof root.getAttribute !== "undefined" ? root.getAttribute("_l") : -1));

                if(!tret){ return -1; }
                var l = tret.length;

                // we calculate the parent length as a cheap way to invalidate the
                // cache. It's not 100% accurate, but it's much more honest than what
                // other libraries do
                if( cl == l && ci >= 0 && cl >= 0 ){
                        // if it's legit, tag and release
                        return ci;
                }

                // else re-key things
                if(has("ie") && typeof root.setAttribute !== "undefined"){
                        root.setAttribute("_l", l);
                }else{
                        root["_l"] = l;
                }
                ci = -1;
                for(var te = root["firstElementChild"]||root["firstChild"]; te; te = te[_ns]){
                        if(_simpleNodeTest(te)){
                                if(has("ie")){
                                        te.setAttribute("_i", ++i);
                                }else{
                                        te["_i"] = ++i;
                                }
                                if(node === te){
                                        // NOTE:
                                        //      shortcutting the return at this step in indexing works
                                        //      very well for benchmarking but we avoid it here since
                                        //      it leads to potential O(n^2) behavior in sequential
                                        //      getNodexIndex operations on a previously un-indexed
                                        //      parent. We may revisit this at a later time, but for
                                        //      now we just want to get the right answer more often
                                        //      than not.
                                        ci = i;
                                }
                        }
                }
                return ci;
        };

        var isEven = function(elem){
                return !((getNodeIndex(elem)) % 2);
        };

        var isOdd = function(elem){
                return ((getNodeIndex(elem)) % 2);
        };

        var pseudos = {
                "checked": function(name, condition){
                        return function(elem){
                                return !!("checked" in elem ? elem.checked : elem.selected);
                        };
                },
                "disabled": function(name, condition){
                        return function(elem){
                                return elem.disabled;
                        };
                },
                "enabled": function(name, condition){
                        return function(elem){
                                return !elem.disabled;
                        };
                },
                "first-child": function(){ return _lookLeft; },
                "last-child": function(){ return _lookRight; },
                "only-child": function(name, condition){
                        return function(node){
                                return _lookLeft(node) && _lookRight(node);
                        };
                },
                "empty": function(name, condition){
                        return function(elem){
                                // DomQuery and jQuery get this wrong, oddly enough.
                                // The CSS 3 selectors spec is pretty explicit about it, too.
                                var cn = elem.childNodes;
                                var cnl = elem.childNodes.length;
                                // if(!cnl){ return true; }
                                for(var x=cnl-1; x >= 0; x--){
                                        var nt = cn[x].nodeType;
                                        if((nt === 1)||(nt == 3)){ return false; }
                                }
                                return true;
                        };
                },
                "contains": function(name, condition){
                        var cz = condition.charAt(0);
                        if( cz == '"' || cz == "'" ){ //remove quote
                                condition = condition.slice(1, -1);
                        }
                        return function(elem){
                                return (elem.innerHTML.indexOf(condition) >= 0);
                        };
                },
                "not": function(name, condition){
                        var p = getQueryParts(condition)[0];
                        var ignores = { el: 1 };
                        if(p.tag != "*"){
                                ignores.tag = 1;
                        }
                        if(!p.classes.length){
                                ignores.classes = 1;
                        }
                        var ntf = getSimpleFilterFunc(p, ignores);
                        return function(elem){
                                return (!ntf(elem));
                        };
                },
                "nth-child": function(name, condition){
                        var pi = parseInt;
                        // avoid re-defining function objects if we can
                        if(condition == "odd"){
                                return isOdd;
                        }else if(condition == "even"){
                                return isEven;
                        }
                        // FIXME: can we shorten this?
                        if(condition.indexOf("n") != -1){
                                var tparts = condition.split("n", 2);
                                var pred = tparts[0] ? ((tparts[0] == '-') ? -1 : pi(tparts[0])) : 1;
                                var idx = tparts[1] ? pi(tparts[1]) : 0;
                                var lb = 0, ub = -1;
                                if(pred > 0){
                                        if(idx < 0){
                                                idx = (idx % pred) && (pred + (idx % pred));
                                        }else if(idx>0){
                                                if(idx >= pred){
                                                        lb = idx - idx % pred;
                                                }
                                                idx = idx % pred;
                                        }
                                }else if(pred<0){
                                        pred *= -1;
                                        // idx has to be greater than 0 when pred is negative;
                                        // shall we throw an error here?
                                        if(idx > 0){
                                                ub = idx;
                                                idx = idx % pred;
                                        }
                                }
                                if(pred > 0){
                                        return function(elem){
                                                var i = getNodeIndex(elem);
                                                return (i>=lb) && (ub<0 || i<=ub) && ((i % pred) == idx);
                                        };
                                }else{
                                        condition = idx;
                                }
                        }
                        var ncount = pi(condition);
                        return function(elem){
                                return (getNodeIndex(elem) == ncount);
                        };
                }
        };

        var defaultGetter = (has("ie") < 9 || has("ie") == 9 && has("quirks")) ? function(cond){
                var clc = cond.toLowerCase();
                if(clc == "class"){ cond = "className"; }
                return function(elem){
                        return (caseSensitive ? elem.getAttribute(cond) : elem[cond]||elem[clc]);
                };
        } : function(cond){
                return function(elem){
                        return (elem && elem.getAttribute && elem.hasAttribute(cond));
                };
        };

        var getSimpleFilterFunc = function(query, ignores){
                // generates a node tester function based on the passed query part. The
                // query part is one of the structures generated by the query parser
                // when it creates the query AST. The "ignores" object specifies which
                // (if any) tests to skip, allowing the system to avoid duplicating
                // work where it may have already been taken into account by other
                // factors such as how the nodes to test were fetched in the first
                // place
                if(!query){ return yesman; }
                ignores = ignores||{};

                var ff = null;

                if(!("el" in ignores)){
                        ff = agree(ff, _isElement);
                }

                if(!("tag" in ignores)){
                        if(query.tag != "*"){
                                ff = agree(ff, function(elem){
                                        return (elem && ((caseSensitive ? elem.tagName : elem.tagName.toUpperCase()) == query.getTag()));
                                });
                        }
                }

                if(!("classes" in ignores)){
                        each(query.classes, function(cname, idx, arr){
                                // get the class name
                                /*
                                var isWildcard = cname.charAt(cname.length-1) == "*";
                                if(isWildcard){
                                        cname = cname.substr(0, cname.length-1);
                                }
                                // I dislike the regex thing, even if memoized in a cache, but it's VERY short
                                var re = new RegExp("(?:^|\\s)" + cname + (isWildcard ? ".*" : "") + "(?:\\s|$)");
                                */
                                var re = new RegExp("(?:^|\\s)" + cname + "(?:\\s|$)");
                                ff = agree(ff, function(elem){
                                        return re.test(elem.className);
                                });
                                ff.count = idx;
                        });
                }

                if(!("pseudos" in ignores)){
                        each(query.pseudos, function(pseudo){
                                var pn = pseudo.name;
                                if(pseudos[pn]){
                                        ff = agree(ff, pseudos[pn](pn, pseudo.value));
                                }
                        });
                }

                if(!("attrs" in ignores)){
                        each(query.attrs, function(attr){
                                var matcher;
                                var a = attr.attr;
                                // type, attr, matchFor
                                if(attr.type && attrs[attr.type]){
                                        matcher = attrs[attr.type](a, attr.matchFor);
                                }else if(a.length){
                                        matcher = defaultGetter(a);
                                }
                                if(matcher){
                                        ff = agree(ff, matcher);
                                }
                        });
                }

                if(!("id" in ignores)){
                        if(query.id){
                                ff = agree(ff, function(elem){
                                        return (!!elem && (elem.id == query.id));
                                });
                        }
                }

                if(!ff){
                        if(!("default" in ignores)){
                                ff = yesman;
                        }
                }
                return ff;
        };

        var _nextSibling = function(filterFunc){
                return function(node, ret, bag){
                        while(node = node[_ns]){
                                if(_noNES && (!_isElement(node))){ continue; }
                                if(
                                        (!bag || _isUnique(node, bag)) &&
                                        filterFunc(node)
                                ){
                                        ret.push(node);
                                }
                                break;
                        }
                        return ret;
                };
        };

        var _nextSiblings = function(filterFunc){
                return function(root, ret, bag){
                        var te = root[_ns];
                        while(te){
                                if(_simpleNodeTest(te)){
                                        if(bag && !_isUnique(te, bag)){
                                                break;
                                        }
                                        if(filterFunc(te)){
                                                ret.push(te);
                                        }
                                }
                                te = te[_ns];
                        }
                        return ret;
                };
        };

        // get an array of child *elements*, skipping text and comment nodes
        var _childElements = function(filterFunc){
                filterFunc = filterFunc||yesman;
                return function(root, ret, bag){
                        // get an array of child elements, skipping text and comment nodes
                        var te, x = 0, tret = root.children || root.childNodes;
                        while(te = tret[x++]){
                                if(
                                        _simpleNodeTest(te) &&
                                        (!bag || _isUnique(te, bag)) &&
                                        (filterFunc(te, x))
                                ){
                                        ret.push(te);
                                }
                        }
                        return ret;
                };
        };

        // test to see if node is below root
        var _isDescendant = function(node, root){
                var pn = node.parentNode;
                while(pn){
                        if(pn == root){
                                break;
                        }
                        pn = pn.parentNode;
                }
                return !!pn;
        };

        var _getElementsFuncCache = {};

        var getElementsFunc = function(query){
                var retFunc = _getElementsFuncCache[query.query];
                // if we've got a cached dispatcher, just use that
                if(retFunc){ return retFunc; }
                // else, generate a new on

                // NOTE:
                //              this function returns a function that searches for nodes and
                //              filters them.  The search may be specialized by infix operators
                //              (">", "~", or "+") else it will default to searching all
                //              descendants (the " " selector). Once a group of children is
                //              found, a test function is applied to weed out the ones we
                //              don't want. Many common cases can be fast-pathed. We spend a
                //              lot of cycles to create a dispatcher that doesn't do more work
                //              than necessary at any point since, unlike this function, the
                //              dispatchers will be called every time. The logic of generating
                //              efficient dispatchers looks like this in pseudo code:
                //
                //              # if it's a purely descendant query (no ">", "+", or "~" modifiers)
                //              if infixOperator == " ":
                //                      if only(id):
                //                              return def(root):
                //                                      return d.byId(id, root);
                //
                //                      elif id:
                //                              return def(root):
                //                                      return filter(d.byId(id, root));
                //
                //                      elif cssClass && getElementsByClassName:
                //                              return def(root):
                //                                      return filter(root.getElementsByClassName(cssClass));
                //
                //                      elif only(tag):
                //                              return def(root):
                //                                      return root.getElementsByTagName(tagName);
                //
                //                      else:
                //                              # search by tag name, then filter
                //                              return def(root):
                //                                      return filter(root.getElementsByTagName(tagName||"*"));
                //
                //              elif infixOperator == ">":
                //                      # search direct children
                //                      return def(root):
                //                              return filter(root.children);
                //
                //              elif infixOperator == "+":
                //                      # search next sibling
                //                      return def(root):
                //                              return filter(root.nextElementSibling);
                //
                //              elif infixOperator == "~":
                //                      # search rightward siblings
                //                      return def(root):
                //                              return filter(nextSiblings(root));

                var io = query.infixOper;
                var oper = (io ? io.oper : "");
                // the default filter func which tests for all conditions in the query
                // part. This is potentially inefficient, so some optimized paths may
                // re-define it to test fewer things.
                var filterFunc = getSimpleFilterFunc(query, { el: 1 });
                var qt = query.tag;
                var wildcardTag = ("*" == qt);
                var ecs = getDoc()["getElementsByClassName"];

                if(!oper){
                        // if there's no infix operator, then it's a descendant query. ID
                        // and "elements by class name" variants can be accelerated so we
                        // call them out explicitly:
                        if(query.id){
                                // testing shows that the overhead of yesman() is acceptable
                                // and can save us some bytes vs. re-defining the function
                                // everywhere.
                                filterFunc = (!query.loops && wildcardTag) ?
                                        yesman :
                                        getSimpleFilterFunc(query, { el: 1, id: 1 });

                                retFunc = function(root, arr){
                                        var te = dom.byId(query.id, (root.ownerDocument||root));
                                        if(!te || !filterFunc(te)){ return; }
                                        if(9 == root.nodeType){ // if root's a doc, we just return directly
                                                return getArr(te, arr);
                                        }else{ // otherwise check ancestry
                                                if(_isDescendant(te, root)){
                                                        return getArr(te, arr);
                                                }
                                        }
                                };
                        }else if(
                                ecs &&
                                // isAlien check. Workaround for Prototype.js being totally evil/dumb.
                                /\{\s*\[native code\]\s*\}/.test(String(ecs)) &&
                                query.classes.length &&
                                !cssCaseBug
                        ){
                                // it's a class-based query and we've got a fast way to run it.

                                // ignore class and ID filters since we will have handled both
                                filterFunc = getSimpleFilterFunc(query, { el: 1, classes: 1, id: 1 });
                                var classesString = query.classes.join(" ");
                                retFunc = function(root, arr, bag){
                                        var ret = getArr(0, arr), te, x=0;
                                        var tret = root.getElementsByClassName(classesString);
                                        while((te = tret[x++])){
                                                if(filterFunc(te, root) && _isUnique(te, bag)){
                                                        ret.push(te);
                                                }
                                        }
                                        return ret;
                                };

                        }else if(!wildcardTag && !query.loops){
                                // it's tag only. Fast-path it.
                                retFunc = function(root, arr, bag){
                                        var ret = getArr(0, arr), te, x=0;
                                        var tag = query.getTag(),
                                                tret = tag ? root.getElementsByTagName(tag) : [];
                                        while((te = tret[x++])){
                                                if(_isUnique(te, bag)){
                                                        ret.push(te);
                                                }
                                        }
                                        return ret;
                                };
                        }else{
                                // the common case:
                                //              a descendant selector without a fast path. By now it's got
                                //              to have a tag selector, even if it's just "*" so we query
                                //              by that and filter
                                filterFunc = getSimpleFilterFunc(query, { el: 1, tag: 1, id: 1 });
                                retFunc = function(root, arr, bag){
                                        var ret = getArr(0, arr), te, x=0;
                                        // we use getTag() to avoid case sensitivity issues
                                        var tag = query.getTag(),
                                                tret = tag ? root.getElementsByTagName(tag) : [];
                                        while((te = tret[x++])){
                                                if(filterFunc(te, root) && _isUnique(te, bag)){
                                                        ret.push(te);
                                                }
                                        }
                                        return ret;
                                };
                        }
                }else{
                        // the query is scoped in some way. Instead of querying by tag we
                        // use some other collection to find candidate nodes
                        var skipFilters = { el: 1 };
                        if(wildcardTag){
                                skipFilters.tag = 1;
                        }
                        filterFunc = getSimpleFilterFunc(query, skipFilters);
                        if("+" == oper){
                                retFunc = _nextSibling(filterFunc);
                        }else if("~" == oper){
                                retFunc = _nextSiblings(filterFunc);
                        }else if(">" == oper){
                                retFunc = _childElements(filterFunc);
                        }
                }
                // cache it and return
                return _getElementsFuncCache[query.query] = retFunc;
        };

        var filterDown = function(root, queryParts){
                // NOTE:
                //              this is the guts of the DOM query system. It takes a list of
                //              parsed query parts and a root and finds children which match
                //              the selector represented by the parts
                var candidates = getArr(root), qp, x, te, qpl = queryParts.length, bag, ret;

                for(var i = 0; i < qpl; i++){
                        ret = [];
                        qp = queryParts[i];
                        x = candidates.length - 1;
                        if(x > 0){
                                // if we have more than one root at this level, provide a new
                                // hash to use for checking group membership but tell the
                                // system not to post-filter us since we will already have been
                                // guaranteed to be unique
                                bag = {};
                                ret.nozip = true;
                        }
                        var gef = getElementsFunc(qp);
                        for(var j = 0; (te = candidates[j]); j++){
                                // for every root, get the elements that match the descendant
                                // selector, adding them to the "ret" array and filtering them
                                // via membership in this level's bag. If there are more query
                                // parts, then this level's return will be used as the next
                                // level's candidates
                                gef(te, ret, bag);
                        }
                        if(!ret.length){ break; }
                        candidates = ret;
                }
                return ret;
        };

        ////////////////////////////////////////////////////////////////////////
        // the query runner
        ////////////////////////////////////////////////////////////////////////

        // these are the primary caches for full-query results. The query
        // dispatcher functions are generated then stored here for hash lookup in
        // the future
        var _queryFuncCacheDOM = {},
                _queryFuncCacheQSA = {};

        // this is the second level of splitting, from full-length queries (e.g.,
        // "div.foo .bar") into simple query expressions (e.g., ["div.foo",
        // ".bar"])
        var getStepQueryFunc = function(query){
                var qparts = getQueryParts(trim(query));

                // if it's trivial, avoid iteration and zipping costs
                if(qparts.length == 1){
                        // we optimize this case here to prevent dispatch further down the
                        // chain, potentially slowing things down. We could more elegantly
                        // handle this in filterDown(), but it's slower for simple things
                        // that need to be fast (e.g., "#someId").
                        var tef = getElementsFunc(qparts[0]);
                        return function(root){
                                var r = tef(root, []);
                                if(r){ r.nozip = true; }
                                return r;
                        };
                }

                // otherwise, break it up and return a runner that iterates over the parts recursively
                return function(root){
                        return filterDown(root, qparts);
                };
        };

        // NOTES:
        //      * we can't trust QSA for anything but document-rooted queries, so
        //        caching is split into DOM query evaluators and QSA query evaluators
        //      * caching query results is dirty and leak-prone (or, at a minimum,
        //        prone to unbounded growth). Other toolkits may go this route, but
        //        they totally destroy their own ability to manage their memory
        //        footprint. If we implement it, it should only ever be with a fixed
        //        total element reference # limit and an LRU-style algorithm since JS
        //        has no weakref support. Caching compiled query evaluators is also
        //        potentially problematic, but even on large documents the size of the
        //        query evaluators is often < 100 function objects per evaluator (and
        //        LRU can be applied if it's ever shown to be an issue).
        //      * since IE's QSA support is currently only for HTML documents and even
        //        then only in IE 8's "standards mode", we have to detect our dispatch
        //        route at query time and keep 2 separate caches. Ugg.

        // we need to determine if we think we can run a given query via
        // querySelectorAll or if we'll need to fall back on DOM queries to get
        // there. We need a lot of information about the environment and the query
        // to make the determination (e.g. does it support QSA, does the query in
        // question work in the native QSA impl, etc.).

        // IE QSA queries may incorrectly include comment nodes, so we throw the
        // zipping function into "remove" comments mode instead of the normal "skip
        // it" which every other QSA-clued browser enjoys
        var noZip = has("ie") ? "commentStrip" : "nozip";

        var qsa = "querySelectorAll";
        var qsaAvail = !!getDoc()[qsa];

        //Don't bother with n+3 type of matches, IE complains if we modify those.
        var infixSpaceRe = /\\[>~+]|n\+\d|([^ \\])?([>~+])([^ =])?/g;
        var infixSpaceFunc = function(match, pre, ch, post){
                return ch ? (pre ? pre + " " : "") + ch + (post ? " " + post : "") : /*n+3*/ match;
        };
        
        //Don't apply the infixSpaceRe to attribute value selectors
        var attRe = /([^[]*)([^\]]*])?/g;
        var attFunc = function(match, nonAtt, att){
                return nonAtt.replace(infixSpaceRe, infixSpaceFunc) + (att||"");
        };
        var getQueryFunc = function(query, forceDOM){
                //Normalize query. The CSS3 selectors spec allows for omitting spaces around
                //infix operators, >, ~ and +
                //Do the work here since detection for spaces is used as a simple "not use QSA"
                //test below.
                query = query.replace(attRe, attFunc);

                if(qsaAvail){
                        // if we've got a cached variant and we think we can do it, run it!
                        var qsaCached = _queryFuncCacheQSA[query];
                        if(qsaCached && !forceDOM){ return qsaCached; }
                }

                // else if we've got a DOM cached variant, assume that we already know
                // all we need to and use it
                var domCached = _queryFuncCacheDOM[query];
                if(domCached){ return domCached; }

                // TODO:
                //              today we're caching DOM and QSA branches separately so we
                //              recalc useQSA every time. If we had a way to tag root+query
                //              efficiently, we'd be in good shape to do a global cache.

                var qcz = query.charAt(0);
                var nospace = (-1 == query.indexOf(" "));

                // byId searches are wicked fast compared to QSA, even when filtering
                // is required
                if( (query.indexOf("#") >= 0) && (nospace) ){
                        forceDOM = true;
                }

                var useQSA = (
                        qsaAvail && (!forceDOM) &&
                        // as per CSS 3, we can't currently start w/ combinator:
                        //              http://www.w3.org/TR/css3-selectors/#w3cselgrammar
                        (specials.indexOf(qcz) == -1) &&
                        // IE's QSA impl sucks on pseudos
                        (!has("ie") || (query.indexOf(":") == -1)) &&

                        (!(cssCaseBug && (query.indexOf(".") >= 0))) &&

                        // FIXME:
                        //              need to tighten up browser rules on ":contains" and "|=" to
                        //              figure out which aren't good
                        //              Latest webkit (around 531.21.8) does not seem to do well with :checked on option
                        //              elements, even though according to spec, selected options should
                        //              match :checked. So go nonQSA for it:
                        //              http://bugs.dojotoolkit.org/ticket/5179
                        (query.indexOf(":contains") == -1) && (query.indexOf(":checked") == -1) &&
                        (query.indexOf("|=") == -1) // some browsers don't grok it
                );

                // TODO:
                //              if we've got a descendant query (e.g., "> .thinger" instead of
                //              just ".thinger") in a QSA-able doc, but are passed a child as a
                //              root, it should be possible to give the item a synthetic ID and
                //              trivially rewrite the query to the form "#synid > .thinger" to
                //              use the QSA branch


                if(useQSA){
                        var tq = (specials.indexOf(query.charAt(query.length-1)) >= 0) ?
                                                (query + " *") : query;
                        return _queryFuncCacheQSA[query] = function(root){
                                try{
                                        // the QSA system contains an egregious spec bug which
                                        // limits us, effectively, to only running QSA queries over
                                        // entire documents.  See:
                                        //              http://ejohn.org/blog/thoughts-on-queryselectorall/
                                        //      despite this, we can also handle QSA runs on simple
                                        //      selectors, but we don't want detection to be expensive
                                        //      so we're just checking for the presence of a space char
                                        //      right now. Not elegant, but it's cheaper than running
                                        //      the query parser when we might not need to
                                        if(!((9 == root.nodeType) || nospace)){ throw ""; }
                                        var r = root[qsa](tq);
                                        // skip expensive duplication checks and just wrap in a NodeList
                                        r[noZip] = true;
                                        return r;
                                }catch(e){
                                        // else run the DOM branch on this query, ensuring that we
                                        // default that way in the future
                                        return getQueryFunc(query, true)(root);
                                }
                        };
                }else{
                        // DOM branch
                        var parts = query.match(/([^\s,](?:"(?:\\.|[^"])+"|'(?:\\.|[^'])+'|[^,])*)/g);
                        return _queryFuncCacheDOM[query] = ((parts.length < 2) ?
                                // if not a compound query (e.g., ".foo, .bar"), cache and return a dispatcher
                                getStepQueryFunc(query) :
                                // if it *is* a complex query, break it up into its
                                // constituent parts and return a dispatcher that will
                                // merge the parts when run
                                function(root){
                                        var pindex = 0, // avoid array alloc for every invocation
                                                ret = [],
                                                tp;
                                        while((tp = parts[pindex++])){
                                                ret = ret.concat(getStepQueryFunc(tp)(root));
                                        }
                                        return ret;
                                }
                        );
                }
        };

        var _zipIdx = 0;

        // NOTE:
        //              this function is Moo inspired, but our own impl to deal correctly
        //              with XML in IE
        var _nodeUID = has("ie") ? function(node){
                if(caseSensitive){
                        // XML docs don't have uniqueID on their nodes
                        return (node.getAttribute("_uid") || node.setAttribute("_uid", ++_zipIdx) || _zipIdx);

                }else{
                        return node.uniqueID;
                }
        } :
        function(node){
                return (node._uid || (node._uid = ++_zipIdx));
        };

        // determine if a node in is unique in a "bag". In this case we don't want
        // to flatten a list of unique items, but rather just tell if the item in
        // question is already in the bag. Normally we'd just use hash lookup to do
        // this for us but IE's DOM is busted so we can't really count on that. On
        // the upside, it gives us a built in unique ID function.
        var _isUnique = function(node, bag){
                if(!bag){ return 1; }
                var id = _nodeUID(node);
                if(!bag[id]){ return bag[id] = 1; }
                return 0;
        };

        // attempt to efficiently determine if an item in a list is a dupe,
        // returning a list of "uniques", hopefully in document order
        var _zipIdxName = "_zipIdx";
        var _zip = function(arr){
                if(arr && arr.nozip){
                        return arr;
                }
                var ret = [];
                if(!arr || !arr.length){ return ret; }
                if(arr[0]){
                        ret.push(arr[0]);
                }
                if(arr.length < 2){ return ret; }

                _zipIdx++;

                // we have to fork here for IE and XML docs because we can't set
                // expandos on their nodes (apparently). *sigh*
                var x, te;
                if(has("ie") && caseSensitive){
                        var szidx = _zipIdx+"";
                        arr[0].setAttribute(_zipIdxName, szidx);
                        for(x = 1; te = arr[x]; x++){
                                if(arr[x].getAttribute(_zipIdxName) != szidx){
                                        ret.push(te);
                                }
                                te.setAttribute(_zipIdxName, szidx);
                        }
                }else if(has("ie") && arr.commentStrip){
                        try{
                                for(x = 1; te = arr[x]; x++){
                                        if(_isElement(te)){
                                                ret.push(te);
                                        }
                                }
                        }catch(e){ /* squelch */ }
                }else{
                        if(arr[0]){ arr[0][_zipIdxName] = _zipIdx; }
                        for(x = 1; te = arr[x]; x++){
                                if(arr[x][_zipIdxName] != _zipIdx){
                                        ret.push(te);
                                }
                                te[_zipIdxName] = _zipIdx;
                        }
                }
                return ret;
        };

        // the main executor
        var query = function(/*String*/ query, /*String|DOMNode?*/ root){
                // summary:
                //              Returns nodes which match the given CSS3 selector, searching the
                //              entire document by default but optionally taking a node to scope
                //              the search by. Returns an array.
                // description:
                //              dojo.query() is the swiss army knife of DOM node manipulation in
                //              Dojo. Much like Prototype's "$$" (bling-bling) function or JQuery's
                //              "$" function, dojo.query provides robust, high-performance
                //              CSS-based node selector support with the option of scoping searches
                //              to a particular sub-tree of a document.
                //
                //              Supported Selectors:
                //              --------------------
                //
                //              acme supports a rich set of CSS3 selectors, including:
                //
                //              - class selectors (e.g., `.foo`)
                //              - node type selectors like `span`
                //              - ` ` descendant selectors
                //              - `>` child element selectors
                //              - `#foo` style ID selectors
                //              - `*` universal selector
                //              - `~`, the preceded-by sibling selector
                //              - `+`, the immediately preceded-by sibling selector
                //              - attribute queries:
                //                      - `[foo]` attribute presence selector
                //                      - `[foo='bar']` attribute value exact match
                //                      - `[foo~='bar']` attribute value list item match
                //                      - `[foo^='bar']` attribute start match
                //                      - `[foo$='bar']` attribute end match
                //                      - `[foo*='bar']` attribute substring match
                //              - `:first-child`, `:last-child`, and `:only-child` positional selectors
                //              - `:empty` content emtpy selector
                //              - `:checked` pseudo selector
                //              - `:nth-child(n)`, `:nth-child(2n+1)` style positional calculations
                //              - `:nth-child(even)`, `:nth-child(odd)` positional selectors
                //              - `:not(...)` negation pseudo selectors
                //
                //              Any legal combination of these selectors will work with
                //              `dojo.query()`, including compound selectors ("," delimited).
                //              Very complex and useful searches can be constructed with this
                //              palette of selectors and when combined with functions for
                //              manipulation presented by dojo/NodeList, many types of DOM
                //              manipulation operations become very straightforward.
                //
                //              Unsupported Selectors:
                //              ----------------------
                //
                //              While dojo.query handles many CSS3 selectors, some fall outside of
                //              what's reasonable for a programmatic node querying engine to
                //              handle. Currently unsupported selectors include:
                //
                //              - namespace-differentiated selectors of any form
                //              - all `::` pseduo-element selectors
                //              - certain pseudo-selectors which don't get a lot of day-to-day use:
                //                      - `:root`, `:lang()`, `:target`, `:focus`
                //              - all visual and state selectors:
                //                      - `:root`, `:active`, `:hover`, `:visited`, `:link`,
                //                                `:enabled`, `:disabled`
                //                      - `:*-of-type` pseudo selectors
                //
                //              dojo.query and XML Documents:
                //              -----------------------------
                //
                //              `dojo.query` (as of dojo 1.2) supports searching XML documents
                //              in a case-sensitive manner. If an HTML document is served with
                //              a doctype that forces case-sensitivity (e.g., XHTML 1.1
                //              Strict), dojo.query() will detect this and "do the right
                //              thing". Case sensitivity is dependent upon the document being
                //              searched and not the query used. It is therefore possible to
                //              use case-sensitive queries on strict sub-documents (iframes,
                //              etc.) or XML documents while still assuming case-insensitivity
                //              for a host/root document.
                //
                //              Non-selector Queries:
                //              ---------------------
                //
                //              If something other than a String is passed for the query,
                //              `dojo.query` will return a new `dojo/NodeList` instance
                //              constructed from that parameter alone and all further
                //              processing will stop. This means that if you have a reference
                //              to a node or NodeList, you can quickly construct a new NodeList
                //              from the original by calling `dojo.query(node)` or
                //              `dojo.query(list)`.
                //
                // query:
                //              The CSS3 expression to match against. For details on the syntax of
                //              CSS3 selectors, see <http://www.w3.org/TR/css3-selectors/#selectors>
                // root:
                //              A DOMNode (or node id) to scope the search from. Optional.
                // returns: Array
                // example:
                //              search the entire document for elements with the class "foo":
                //      |       dojo.query(".foo");
                //              these elements will match:
                //      |       <span class="foo"></span>
                //      |       <span class="foo bar"></span>
                //      |       <p class="thud foo"></p>
                // example:
                //              search the entire document for elements with the classes "foo" *and* "bar":
                //      |       dojo.query(".foo.bar");
                //              these elements will match:
                //      |       <span class="foo bar"></span>
                //              while these will not:
                //      |       <span class="foo"></span>
                //      |       <p class="thud foo"></p>
                // example:
                //              find `<span>` elements which are descendants of paragraphs and
                //              which have a "highlighted" class:
                //      |       dojo.query("p span.highlighted");
                //              the innermost span in this fragment matches:
                //      |       <p class="foo">
                //      |               <span>...
                //      |                       <span class="highlighted foo bar">...</span>
                //      |               </span>
                //      |       </p>
                // example:
                //              set an "odd" class on all odd table rows inside of the table
                //              `#tabular_data`, using the `>` (direct child) selector to avoid
                //              affecting any nested tables:
                //      |       dojo.query("#tabular_data > tbody > tr:nth-child(odd)").addClass("odd");
                // example:
                //              remove all elements with the class "error" from the document
                //              and store them in a list:
                //      |       var errors = dojo.query(".error").orphan();
                // example:
                //              add an onclick handler to every submit button in the document
                //              which causes the form to be sent via Ajax instead:
                //      |       dojo.query("input[type='submit']").onclick(function(e){
                //      |               dojo.stopEvent(e); // prevent sending the form
                //      |               var btn = e.target;
                //      |               dojo.xhrPost({
                //      |                       form: btn.form,
                //      |                       load: function(data){
                //      |                               // replace the form with the response
                //      |                               var div = dojo.doc.createElement("div");
                //      |                               dojo.place(div, btn.form, "after");
                //      |                               div.innerHTML = data;
                //      |                               dojo.style(btn.form, "display", "none");
                //      |                       }
                //      |               });
                //      |       });

                root = root || getDoc();

                // throw the big case sensitivity switch
                var od = root.ownerDocument || root;    // root is either Document or a node inside the document
                caseSensitive = (od.createElement("div").tagName === "div");

                // NOTE:
                //              adding "true" as the 2nd argument to getQueryFunc is useful for
                //              testing the DOM branch without worrying about the
                //              behavior/performance of the QSA branch.
                var r = getQueryFunc(query)(root);

                // FIXME:
                //              need to investigate this branch WRT #8074 and #8075
                if(r && r.nozip){
                        return r;
                }
                return _zip(r); // dojo/NodeList
        };
        query.filter = function(/*Node[]*/ nodeList, /*String*/ filter, /*String|DOMNode?*/ root){
                // summary:
                //              function for filtering a NodeList based on a selector, optimized for simple selectors
                var tmpNodeList = [],
                        parts = getQueryParts(filter),
                        filterFunc =
                                (parts.length == 1 && !/[^\w#\.]/.test(filter)) ?
                                getSimpleFilterFunc(parts[0]) :
                                function(node){
                                        return array.indexOf(query(filter, dom.byId(root)), node) != -1;
                                };
                for(var x = 0, te; te = nodeList[x]; x++){
                        if(filterFunc(te)){ tmpNodeList.push(te); }
                }
                return tmpNodeList;
        };
        return query;
});

},
'dojo/dnd/autoscroll':function(){
define("dojo/dnd/autoscroll", ["../_base/lang", "../sniff", "../_base/window", "../dom-geometry", "../dom-style", "../window"],
        function(lang, has, win, domGeom, domStyle, winUtils){

// module:
//              dojo/dnd/autoscroll

var exports = {
        // summary:
        //              Used by dojo/dnd/Manager to scroll document or internal node when the user
        //              drags near the edge of the viewport or a scrollable node
};
lang.setObject("dojo.dnd.autoscroll", exports);

exports.getViewport = winUtils.getBox;

exports.V_TRIGGER_AUTOSCROLL = 32;
exports.H_TRIGGER_AUTOSCROLL = 32;

exports.V_AUTOSCROLL_VALUE = 16;
exports.H_AUTOSCROLL_VALUE = 16;

// These are set by autoScrollStart().
// Set to default values in case autoScrollStart() isn't called. (back-compat, remove for 2.0)
var viewport,
        doc = win.doc,
        maxScrollTop = Infinity,
        maxScrollLeft = Infinity;

exports.autoScrollStart = function(d){
        // summary:
        //              Called at the start of a drag.
        // d: Document
        //              The document of the node being dragged.

        doc = d;
        viewport = winUtils.getBox(doc);

        // Save height/width of document at start of drag, before it gets distorted by a user dragging an avatar past
        // the document's edge
        var html = win.body(doc).parentNode;
        maxScrollTop = Math.max(html.scrollHeight - viewport.h, 0);
        maxScrollLeft = Math.max(html.scrollWidth - viewport.w, 0);     // usually 0
};

exports.autoScroll = function(e){
        // summary:
        //              a handler for mousemove and touchmove events, which scrolls the window, if
        //              necessary
        // e: Event
        //              mousemove/touchmove event

        // FIXME: needs more docs!
        var v = viewport || winUtils.getBox(doc), // getBox() call for back-compat, in case autoScrollStart() wasn't called
                html = win.body(doc).parentNode,
                dx = 0, dy = 0;
        if(e.clientX < exports.H_TRIGGER_AUTOSCROLL){
                dx = -exports.H_AUTOSCROLL_VALUE;
        }else if(e.clientX > v.w - exports.H_TRIGGER_AUTOSCROLL){
                dx = Math.min(exports.H_AUTOSCROLL_VALUE, maxScrollLeft - html.scrollLeft);     // don't scroll past edge of doc
        }
        if(e.clientY < exports.V_TRIGGER_AUTOSCROLL){
                dy = -exports.V_AUTOSCROLL_VALUE;
        }else if(e.clientY > v.h - exports.V_TRIGGER_AUTOSCROLL){
                dy = Math.min(exports.V_AUTOSCROLL_VALUE, maxScrollTop - html.scrollTop);       // don't scroll past edge of doc
        }
        window.scrollBy(dx, dy);
};

exports._validNodes = {"div": 1, "p": 1, "td": 1};
exports._validOverflow = {"auto": 1, "scroll": 1};

exports.autoScrollNodes = function(e){
        // summary:
        //              a handler for mousemove and touchmove events, which scrolls the first available
        //              Dom element, it falls back to exports.autoScroll()
        // e: Event
        //              mousemove/touchmove event

        // FIXME: needs more docs!

        var b, t, w, h, rx, ry, dx = 0, dy = 0, oldLeft, oldTop;

        for(var n = e.target; n;){
                if(n.nodeType == 1 && (n.tagName.toLowerCase() in exports._validNodes)){
                        var s = domStyle.getComputedStyle(n),
                                overflow = (s.overflow.toLowerCase() in exports._validOverflow),
                                overflowX = (s.overflowX.toLowerCase() in exports._validOverflow),
                                overflowY = (s.overflowY.toLowerCase() in exports._validOverflow);
                        if(overflow || overflowX || overflowY){
                                b = domGeom.getContentBox(n, s);
                                t = domGeom.position(n, true);
                        }
                        // overflow-x
                        if(overflow || overflowX){
                                w = Math.min(exports.H_TRIGGER_AUTOSCROLL, b.w / 2);
                                rx = e.pageX - t.x;
                                if(has("webkit") || has("opera")){
                                        // FIXME: this code should not be here, it should be taken into account
                                        // either by the event fixing code, or the domGeom.position()
                                        // FIXME: this code doesn't work on Opera 9.5 Beta
                                        rx += win.body().scrollLeft;
                                }
                                dx = 0;
                                if(rx > 0 && rx < b.w){
                                        if(rx < w){
                                                dx = -w;
                                        }else if(rx > b.w - w){
                                                dx = w;
                                        }
                                        oldLeft = n.scrollLeft;
                                        n.scrollLeft = n.scrollLeft + dx;
                                }
                        }
                        // overflow-y
                        if(overflow || overflowY){
                                //console.log(b.l, b.t, t.x, t.y, n.scrollLeft, n.scrollTop);
                                h = Math.min(exports.V_TRIGGER_AUTOSCROLL, b.h / 2);
                                ry = e.pageY - t.y;
                                if(has("webkit") || has("opera")){
                                        // FIXME: this code should not be here, it should be taken into account
                                        // either by the event fixing code, or the domGeom.position()
                                        // FIXME: this code doesn't work on Opera 9.5 Beta
                                        ry += win.body().scrollTop;
                                }
                                dy = 0;
                                if(ry > 0 && ry < b.h){
                                        if(ry < h){
                                                dy = -h;
                                        }else if(ry > b.h - h){
                                                dy = h;
                                        }
                                        oldTop = n.scrollTop;
                                        n.scrollTop  = n.scrollTop  + dy;
                                }
                        }
                        if(dx || dy){ return; }
                }
                try{
                        n = n.parentNode;
                }catch(x){
                        n = null;
                }
        }
        exports.autoScroll(e);
};

return exports;

});

},
'dijit/form/_RadioButtonMixin':function(){
define("dijit/form/_RadioButtonMixin", [
        "dojo/_base/array", // array.forEach
        "dojo/_base/declare", // declare
        "dojo/dom-attr", // domAttr.set
        "dojo/_base/event", // event.stop
        "dojo/_base/lang", // lang.hitch
        "dojo/query", // query
        "../registry"   // registry.getEnclosingWidget
], function(array, declare, domAttr, event, lang, query, registry){

        // module:
        //              dijit/form/_RadioButtonMixin

        return declare("dijit.form._RadioButtonMixin", null, {
                // summary:
                //              Mixin to provide widget functionality for an HTML radio button

                // type: [private] String
                //              type attribute on `<input>` node.
                //              Users should not change this value.
                type: "radio",

                _getRelatedWidgets: function(){
                        // Private function needed to help iterate over all radio buttons in a group.
                        var ary = [];
                        query("input[type=radio]", this.focusNode.form || this.ownerDocument).forEach( // can't use name= since query doesn't support [] in the name
                                lang.hitch(this, function(inputNode){
                                        if(inputNode.name == this.name && inputNode.form == this.focusNode.form){
                                                var widget = registry.getEnclosingWidget(inputNode);
                                                if(widget){
                                                        ary.push(widget);
                                                }
                                        }
                                })
                        );
                        return ary;
                },

                _setCheckedAttr: function(/*Boolean*/ value){
                        // If I am being checked then have to deselect currently checked radio button
                        this.inherited(arguments);
                        if(!this._created){ return; }
                        if(value){
                                array.forEach(this._getRelatedWidgets(), lang.hitch(this, function(widget){
                                        if(widget != this && widget.checked){
                                                widget.set('checked', false);
                                        }
                                }));
                        }
                },

                _getSubmitValue: function(/*String*/ value){
                        return value === null ? "on" : value;
                },

                _onClick: function(/*Event*/ e){
                        if(this.checked || this.disabled){ // nothing to do
                                event.stop(e);
                                return false;
                        }
                        if(this.readOnly){ // ignored by some browsers so we have to resync the DOM elements with widget values
                                event.stop(e);
                                array.forEach(this._getRelatedWidgets(), lang.hitch(this, function(widget){
                                        domAttr.set(this.focusNode || this.domNode, 'checked', widget.checked);
                                }));
                                return false;
                        }
                        return this.inherited(arguments);
                }
        });
});

},
'dojo/data/ItemFileWriteStore':function(){
define("dojo/data/ItemFileWriteStore", ["../_base/lang", "../_base/declare", "../_base/array", "../_base/json", "../_base/kernel",
        "./ItemFileReadStore", "../date/stamp"
], function(lang, declare, arrayUtil, jsonUtil, kernel, ItemFileReadStore, dateStamp){

// module:
//              dojo/data/ItemFileWriteStore

return declare("dojo.data.ItemFileWriteStore", ItemFileReadStore, {
        // summary:
        //              TODOC

        constructor: function(/* object */ keywordParameters){
                // keywordParameters:
                //              The structure of the typeMap object is as follows:
                // |    {
                // |            type0: function || object,
                // |            type1: function || object,
                // |            ...
                // |            typeN: function || object
                // |    }
                //              Where if it is a function, it is assumed to be an object constructor that takes the
                //              value of _value as the initialization parameters.  It is serialized assuming object.toString()
                //              serialization.  If it is an object, then it is assumed
                //              to be an object of general form:
                // |    {
                // |            type: function, //constructor.
                // |            deserialize:    function(value) //The function that parses the value and constructs the object defined by type appropriately.
                // |            serialize:      function(object) //The function that converts the object back into the proper file format form.
                // |    }

                // ItemFileWriteStore extends ItemFileReadStore to implement these additional dojo.data APIs
                this._features['dojo.data.api.Write'] = true;
                this._features['dojo.data.api.Notification'] = true;

                // For keeping track of changes so that we can implement isDirty and revert
                this._pending = {
                        _newItems:{},
                        _modifiedItems:{},
                        _deletedItems:{}
                };

                if(!this._datatypeMap['Date'].serialize){
                        this._datatypeMap['Date'].serialize = function(obj){
                                return dateStamp.toISOString(obj, {zulu:true});
                        };
                }
                //Disable only if explicitly set to false.
                if(keywordParameters && (keywordParameters.referenceIntegrity === false)){
                        this.referenceIntegrity = false;
                }

                // this._saveInProgress is set to true, briefly, from when save() is first called to when it completes
                this._saveInProgress = false;
        },

        referenceIntegrity: true, //Flag that defaultly enabled reference integrity tracking.  This way it can also be disabled pogrammatially or declaratively.

        _assert: function(/* boolean */ condition){
                if(!condition){
                        throw new Error("assertion failed in ItemFileWriteStore");
                }
        },

        _getIdentifierAttribute: function(){
                // this._assert((identifierAttribute === Number) || (dojo.isString(identifierAttribute)));
                return this.getFeatures()['dojo.data.api.Identity'];
        },


/* dojo/data/api/Write */

        newItem: function(/* Object? */ keywordArgs, /* Object? */ parentInfo){
                // summary:
                //              See dojo/data/api/Write.newItem()

                this._assert(!this._saveInProgress);

                if(!this._loadFinished){
                        // We need to do this here so that we'll be able to find out what
                        // identifierAttribute was specified in the data file.
                        this._forceLoad();
                }

                if(typeof keywordArgs != "object" && typeof keywordArgs != "undefined"){
                        throw new Error("newItem() was passed something other than an object");
                }
                var newIdentity = null;
                var identifierAttribute = this._getIdentifierAttribute();
                if(identifierAttribute === Number){
                        newIdentity = this._arrayOfAllItems.length;
                }else{
                        newIdentity = keywordArgs[identifierAttribute];
                        if(typeof newIdentity === "undefined"){
                                throw new Error("newItem() was not passed an identity for the new item");
                        }
                        if(lang.isArray(newIdentity)){
                                throw new Error("newItem() was not passed an single-valued identity");
                        }
                }

                // make sure this identity is not already in use by another item, if identifiers were
                // defined in the file.  Otherwise it would be the item count,
                // which should always be unique in this case.
                if(this._itemsByIdentity){
                        this._assert(typeof this._itemsByIdentity[newIdentity] === "undefined");
                }
                this._assert(typeof this._pending._newItems[newIdentity] === "undefined");
                this._assert(typeof this._pending._deletedItems[newIdentity] === "undefined");

                var newItem = {};
                newItem[this._storeRefPropName] = this;
                newItem[this._itemNumPropName] = this._arrayOfAllItems.length;
                if(this._itemsByIdentity){
                        this._itemsByIdentity[newIdentity] = newItem;
                        //We have to set the identifier now, otherwise we can't look it
                        //up at calls to setValueorValues in parentInfo handling.
                        newItem[identifierAttribute] = [newIdentity];
                }
                this._arrayOfAllItems.push(newItem);

                //We need to construct some data for the onNew call too...
                var pInfo = null;

                // Now we need to check to see where we want to assign this thingm if any.
                if(parentInfo && parentInfo.parent && parentInfo.attribute){
                        pInfo = {
                                item: parentInfo.parent,
                                attribute: parentInfo.attribute,
                                oldValue: undefined
                        };

                        //See if it is multi-valued or not and handle appropriately
                        //Generally, all attributes are multi-valued for this store
                        //So, we only need to append if there are already values present.
                        var values = this.getValues(parentInfo.parent, parentInfo.attribute);
                        if(values && values.length > 0){
                                var tempValues = values.slice(0, values.length);
                                if(values.length === 1){
                                        pInfo.oldValue = values[0];
                                }else{
                                        pInfo.oldValue = values.slice(0, values.length);
                                }
                                tempValues.push(newItem);
                                this._setValueOrValues(parentInfo.parent, parentInfo.attribute, tempValues, false);
                                pInfo.newValue = this.getValues(parentInfo.parent, parentInfo.attribute);
                        }else{
                                this._setValueOrValues(parentInfo.parent, parentInfo.attribute, newItem, false);
                                pInfo.newValue = newItem;
                        }
                }else{
                        //Toplevel item, add to both top list as well as all list.
                        newItem[this._rootItemPropName]=true;
                        this._arrayOfTopLevelItems.push(newItem);
                }

                this._pending._newItems[newIdentity] = newItem;

                //Clone over the properties to the new item
                for(var key in keywordArgs){
                        if(key === this._storeRefPropName || key === this._itemNumPropName){
                                // Bummer, the user is trying to do something like
                                // newItem({_S:"foo"}).  Unfortunately, our superclass,
                                // ItemFileReadStore, is already using _S in each of our items
                                // to hold private info.  To avoid a naming collision, we
                                // need to move all our private info to some other property
                                // of all the items/objects.  So, we need to iterate over all
                                // the items and do something like:
                                //        item.__S = item._S;
                                //        item._S = undefined;
                                // But first we have to make sure the new "__S" variable is
                                // not in use, which means we have to iterate over all the
                                // items checking for that.
                                throw new Error("encountered bug in ItemFileWriteStore.newItem");
                        }
                        var value = keywordArgs[key];
                        if(!lang.isArray(value)){
                                value = [value];
                        }
                        newItem[key] = value;
                        if(this.referenceIntegrity){
                                for(var i = 0; i < value.length; i++){
                                        var val = value[i];
                                        if(this.isItem(val)){
                                                this._addReferenceToMap(val, newItem, key);
                                        }
                                }
                        }
                }
                this.onNew(newItem, pInfo); // dojo/data/api/Notification call
                return newItem; // item
        },

        _removeArrayElement: function(/* Array */ array, /* anything */ element){
                var index = arrayUtil.indexOf(array, element);
                if(index != -1){
                        array.splice(index, 1);
                        return true;
                }
                return false;
        },

        deleteItem: function(/* dojo/data/api/Item */ item){
                // summary:
                //              See dojo/data/api/Write.deleteItem()
                this._assert(!this._saveInProgress);
                this._assertIsItem(item);

                // Remove this item from the _arrayOfAllItems, but leave a null value in place
                // of the item, so as not to change the length of the array, so that in newItem()
                // we can still safely do: newIdentity = this._arrayOfAllItems.length;
                var indexInArrayOfAllItems = item[this._itemNumPropName];
                var identity = this.getIdentity(item);

                //If we have reference integrity on, we need to do reference cleanup for the deleted item
                if(this.referenceIntegrity){
                        //First scan all the attributes of this items for references and clean them up in the map
                        //As this item is going away, no need to track its references anymore.

                        //Get the attributes list before we generate the backup so it
                        //doesn't pollute the attributes list.
                        var attributes = this.getAttributes(item);

                        //Backup the map, we'll have to restore it potentially, in a revert.
                        if(item[this._reverseRefMap]){
                                item["backup_" + this._reverseRefMap] = lang.clone(item[this._reverseRefMap]);
                        }

                        //TODO:  This causes a reversion problem.  This list won't be restored on revert since it is
                        //attached to the 'value'. item, not ours.  Need to back tese up somehow too.
                        //Maybe build a map of the backup of the entries and attach it to the deleted item to be restored
                        //later.  Or just record them and call _addReferenceToMap on them in revert.
                        arrayUtil.forEach(attributes, function(attribute){
                                arrayUtil.forEach(this.getValues(item, attribute), function(value){
                                        if(this.isItem(value)){
                                                //We have to back up all the references we had to others so they can be restored on a revert.
                                                if(!item["backupRefs_" + this._reverseRefMap]){
                                                        item["backupRefs_" + this._reverseRefMap] = [];
                                                }
                                                item["backupRefs_" + this._reverseRefMap].push({id: this.getIdentity(value), attr: attribute});
                                                this._removeReferenceFromMap(value, item, attribute);
                                        }
                                }, this);
                        }, this);

                        //Next, see if we have references to this item, if we do, we have to clean them up too.
                        var references = item[this._reverseRefMap];
                        if(references){
                                //Look through all the items noted as references to clean them up.
                                for(var itemId in references){
                                        var containingItem = null;
                                        if(this._itemsByIdentity){
                                                containingItem = this._itemsByIdentity[itemId];
                                        }else{
                                                containingItem = this._arrayOfAllItems[itemId];
                                        }
                                        //We have a reference to a containing item, now we have to process the
                                        //attributes and clear all references to the item being deleted.
                                        if(containingItem){
                                                for(var attribute in references[itemId]){
                                                        var oldValues = this.getValues(containingItem, attribute) || [];
                                                        var newValues = arrayUtil.filter(oldValues, function(possibleItem){
                                                                return !(this.isItem(possibleItem) && this.getIdentity(possibleItem) == identity);
                                                        }, this);
                                                        //Remove the note of the reference to the item and set the values on the modified attribute.
                                                        this._removeReferenceFromMap(item, containingItem, attribute);
                                                        if(newValues.length < oldValues.length){
                                                                this._setValueOrValues(containingItem, attribute, newValues, true);
                                                        }
                                                }
                                        }
                                }
                        }
                }

                this._arrayOfAllItems[indexInArrayOfAllItems] = null;

                item[this._storeRefPropName] = null;
                if(this._itemsByIdentity){
                        delete this._itemsByIdentity[identity];
                }
                this._pending._deletedItems[identity] = item;

                //Remove from the toplevel items, if necessary...
                if(item[this._rootItemPropName]){
                        this._removeArrayElement(this._arrayOfTopLevelItems, item);
                }
                this.onDelete(item); // dojo/data/api/Notification call
                return true;
        },

        setValue: function(/* dojo/data/api/Item */ item, /* attribute-name-string */ attribute, /* almost anything */ value){
                // summary:
                //              See dojo/data/api/Write.set()
                return this._setValueOrValues(item, attribute, value, true); // boolean
        },

        setValues: function(/* dojo/data/api/Item */ item, /* attribute-name-string */ attribute, /* array */ values){
                // summary:
                //              See dojo/data/api/Write.setValues()
                return this._setValueOrValues(item, attribute, values, true); // boolean
        },

        unsetAttribute: function(/* dojo/data/api/Item */ item, /* attribute-name-string */ attribute){
                // summary:
                //              See dojo/data/api/Write.unsetAttribute()
                return this._setValueOrValues(item, attribute, [], true);
        },

        _setValueOrValues: function(/* dojo/data/api/Item */ item, /* attribute-name-string */ attribute, /* anything */ newValueOrValues, /*boolean?*/ callOnSet){
                this._assert(!this._saveInProgress);

                // Check for valid arguments
                this._assertIsItem(item);
                this._assert(lang.isString(attribute));
                this._assert(typeof newValueOrValues !== "undefined");

                // Make sure the user isn't trying to change the item's identity
                var identifierAttribute = this._getIdentifierAttribute();
                if(attribute == identifierAttribute){
                        throw new Error("ItemFileWriteStore does not have support for changing the value of an item's identifier.");
                }

                // To implement the Notification API, we need to make a note of what
                // the old attribute value was, so that we can pass that info when
                // we call the onSet method.
                var oldValueOrValues = this._getValueOrValues(item, attribute);

                var identity = this.getIdentity(item);
                if(!this._pending._modifiedItems[identity]){
                        // Before we actually change the item, we make a copy of it to
                        // record the original state, so that we'll be able to revert if
                        // the revert method gets called.  If the item has already been
                        // modified then there's no need to do this now, since we already
                        // have a record of the original state.
                        var copyOfItemState = {};
                        for(var key in item){
                                if((key === this._storeRefPropName) || (key === this._itemNumPropName) || (key === this._rootItemPropName)){
                                        copyOfItemState[key] = item[key];
                                }else if(key === this._reverseRefMap){
                                        copyOfItemState[key] = lang.clone(item[key]);
                                }else{
                                        copyOfItemState[key] = item[key].slice(0, item[key].length);
                                }
                        }
                        // Now mark the item as dirty, and save the copy of the original state
                        this._pending._modifiedItems[identity] = copyOfItemState;
                }

                // Okay, now we can actually change this attribute on the item
                var success = false;

                if(lang.isArray(newValueOrValues) && newValueOrValues.length === 0){

                        // If we were passed an empty array as the value, that counts
                        // as "unsetting" the attribute, so we need to remove this
                        // attribute from the item.
                        success = delete item[attribute];
                        newValueOrValues = undefined; // used in the onSet Notification call below

                        if(this.referenceIntegrity && oldValueOrValues){
                                var oldValues = oldValueOrValues;
                                if(!lang.isArray(oldValues)){
                                        oldValues = [oldValues];
                                }
                                for(var i = 0; i < oldValues.length; i++){
                                        var value = oldValues[i];
                                        if(this.isItem(value)){
                                                this._removeReferenceFromMap(value, item, attribute);
                                        }
                                }
                        }
                }else{
                        var newValueArray;
                        if(lang.isArray(newValueOrValues)){
                                // Unfortunately, it's not safe to just do this:
                                //        newValueArray = newValueOrValues;
                                // Instead, we need to copy the array, which slice() does very nicely.
                                // This is so that our internal data structure won't
                                // get corrupted if the user mucks with the values array *after*
                                // calling setValues().
                                newValueArray = newValueOrValues.slice(0, newValueOrValues.length);
                        }else{
                                newValueArray = [newValueOrValues];
                        }

                        //We need to handle reference integrity if this is on.
                        //In the case of set, we need to see if references were added or removed
                        //and update the reference tracking map accordingly.
                        if(this.referenceIntegrity){
                                if(oldValueOrValues){
                                        var oldValues = oldValueOrValues;
                                        if(!lang.isArray(oldValues)){
                                                oldValues = [oldValues];
                                        }
                                        //Use an associative map to determine what was added/removed from the list.
                                        //Should be O(n) performant.  First look at all the old values and make a list of them
                                        //Then for any item not in the old list, we add it.  If it was already present, we remove it.
                                        //Then we pass over the map and any references left it it need to be removed (IE, no match in
                                        //the new values list).
                                        var map = {};
                                        arrayUtil.forEach(oldValues, function(possibleItem){
                                                if(this.isItem(possibleItem)){
                                                        var id = this.getIdentity(possibleItem);
                                                        map[id.toString()] = true;
                                                }
                                        }, this);
                                        arrayUtil.forEach(newValueArray, function(possibleItem){
                                                if(this.isItem(possibleItem)){
                                                        var id = this.getIdentity(possibleItem);
                                                        if(map[id.toString()]){
                                                                delete map[id.toString()];
                                                        }else{
                                                                this._addReferenceToMap(possibleItem, item, attribute);
                                                        }
                                                }
                                        }, this);
                                        for(var rId in map){
                                                var removedItem;
                                                if(this._itemsByIdentity){
                                                        removedItem = this._itemsByIdentity[rId];
                                                }else{
                                                        removedItem = this._arrayOfAllItems[rId];
                                                }
                                                this._removeReferenceFromMap(removedItem, item, attribute);
                                        }
                                }else{
                                        //Everything is new (no old values) so we have to just
                                        //insert all the references, if any.
                                        for(var i = 0; i < newValueArray.length; i++){
                                                var value = newValueArray[i];
                                                if(this.isItem(value)){
                                                        this._addReferenceToMap(value, item, attribute);
                                                }
                                        }
                                }
                        }
                        item[attribute] = newValueArray;
                        success = true;
                }

                // Now we make the dojo/data/api/Notification call
                if(callOnSet){
                        this.onSet(item, attribute, oldValueOrValues, newValueOrValues);
                }
                return success; // boolean
        },

        _addReferenceToMap: function(/* dojo/data/api/Item */ refItem, /* dojo/data/api/Item */ parentItem, /* string */ attribute){
                // summary:
                //              Method to add an reference map entry for an item and attribute.
                // description:
                //              Method to add an reference map entry for an item and attribute.
                // refItem:
                //              The item that is referenced.
                // parentItem:
                //              The item that holds the new reference to refItem.
                // attribute:
                //              The attribute on parentItem that contains the new reference.

                var parentId = this.getIdentity(parentItem);
                var references = refItem[this._reverseRefMap];

                if(!references){
                        references = refItem[this._reverseRefMap] = {};
                }
                var itemRef = references[parentId];
                if(!itemRef){
                        itemRef = references[parentId] = {};
                }
                itemRef[attribute] = true;
        },

        _removeReferenceFromMap: function(/* dojo/data/api/Item */ refItem, /* dojo/data/api/Item */ parentItem, /* string */ attribute){
                // summary:
                //              Method to remove an reference map entry for an item and attribute.
                // description:
                //              Method to remove an reference map entry for an item and attribute.  This will
                //              also perform cleanup on the map such that if there are no more references at all to
                //              the item, its reference object and entry are removed.
                // refItem:
                //              The item that is referenced.
                // parentItem:
                //              The item holding a reference to refItem.
                // attribute:
                //              The attribute on parentItem that contains the reference.
                var identity = this.getIdentity(parentItem);
                var references = refItem[this._reverseRefMap];
                var itemId;
                if(references){
                        for(itemId in references){
                                if(itemId == identity){
                                        delete references[itemId][attribute];
                                        if(this._isEmpty(references[itemId])){
                                                delete references[itemId];
                                        }
                                }
                        }
                        if(this._isEmpty(references)){
                                delete refItem[this._reverseRefMap];
                        }
                }
        },

        _dumpReferenceMap: function(){
                // summary:
                //              Function to dump the reverse reference map of all items in the store for debug purposes.
                // description:
                //              Function to dump the reverse reference map of all items in the store for debug purposes.
                var i;
                for(i = 0; i < this._arrayOfAllItems.length; i++){
                        var item = this._arrayOfAllItems[i];
                        if(item && item[this._reverseRefMap]){
                                console.log("Item: [" + this.getIdentity(item) + "] is referenced by: " + jsonUtil.toJson(item[this._reverseRefMap]));
                        }
                }
        },

        _getValueOrValues: function(/* dojo/data/api/Item */ item, /* attribute-name-string */ attribute){
                var valueOrValues = undefined;
                if(this.hasAttribute(item, attribute)){
                        var valueArray = this.getValues(item, attribute);
                        if(valueArray.length == 1){
                                valueOrValues = valueArray[0];
                        }else{
                                valueOrValues = valueArray;
                        }
                }
                return valueOrValues;
        },

        _flatten: function(/* anything */ value){
                if(this.isItem(value)){
                        // Given an item, return an serializable object that provides a
                        // reference to the item.
                        // For example, given kermit:
                        //        var kermit = store.newItem({id:2, name:"Kermit"});
                        // we want to return
                        //        {_reference:2}
                        return {_reference: this.getIdentity(value)};
                }else{
                        if(typeof value === "object"){
                                for(var type in this._datatypeMap){
                                        var typeMap = this._datatypeMap[type];
                                        if(lang.isObject(typeMap) && !lang.isFunction(typeMap)){
                                                if(value instanceof typeMap.type){
                                                        if(!typeMap.serialize){
                                                                throw new Error("ItemFileWriteStore:  No serializer defined for type mapping: [" + type + "]");
                                                        }
                                                        return {_type: type, _value: typeMap.serialize(value)};
                                                }
                                        }else if(value instanceof typeMap){
                                                //SImple mapping, therefore, return as a toString serialization.
                                                return {_type: type, _value: value.toString()};
                                        }
                                }
                        }
                        return value;
                }
        },

        _getNewFileContentString: function(){
                // summary:
                //              Generate a string that can be saved to a file.
                //              The result should look similar to:
                //              http://trac.dojotoolkit.org/browser/dojo/trunk/tests/data/countries.json
                var serializableStructure = {};

                var identifierAttribute = this._getIdentifierAttribute();
                if(identifierAttribute !== Number){
                        serializableStructure.identifier = identifierAttribute;
                }
                if(this._labelAttr){
                        serializableStructure.label = this._labelAttr;
                }
                serializableStructure.items = [];
                for(var i = 0; i < this._arrayOfAllItems.length; ++i){
                        var item = this._arrayOfAllItems[i];
                        if(item !== null){
                                var serializableItem = {};
                                for(var key in item){
                                        if(key !== this._storeRefPropName && key !== this._itemNumPropName && key !== this._reverseRefMap && key !== this._rootItemPropName){
                                                var valueArray = this.getValues(item, key);
                                                if(valueArray.length == 1){
                                                        serializableItem[key] = this._flatten(valueArray[0]);
                                                }else{
                                                        var serializableArray = [];
                                                        for(var j = 0; j < valueArray.length; ++j){
                                                                serializableArray.push(this._flatten(valueArray[j]));
                                                                serializableItem[key] = serializableArray;
                                                        }
                                                }
                                        }
                                }
                                serializableStructure.items.push(serializableItem);
                        }
                }
                var prettyPrint = true;
                return jsonUtil.toJson(serializableStructure, prettyPrint);
        },

        _isEmpty: function(something){
                // summary:
                //              Function to determine if an array or object has no properties or values.
                // something:
                //              The array or object to examine.
                var empty = true;
                if(lang.isObject(something)){
                        var i;
                        for(i in something){
                                empty = false;
                                break;
                        }
                }else if(lang.isArray(something)){
                        if(something.length > 0){
                                empty = false;
                        }
                }
                return empty; //boolean
        },

        save: function(/* object */ keywordArgs){
                // summary:
                //              See dojo/data/api/Write.save()
                this._assert(!this._saveInProgress);

                // this._saveInProgress is set to true, briefly, from when save is first called to when it completes
                this._saveInProgress = true;

                var self = this;
                var saveCompleteCallback = function(){
                        self._pending = {
                                _newItems:{},
                                _modifiedItems:{},
                                _deletedItems:{}
                        };

                        self._saveInProgress = false; // must come after this._pending is cleared, but before any callbacks
                        if(keywordArgs && keywordArgs.onComplete){
                                var scope = keywordArgs.scope || kernel.global;
                                keywordArgs.onComplete.call(scope);
                        }
                };
                var saveFailedCallback = function(err){
                        self._saveInProgress = false;
                        if(keywordArgs && keywordArgs.onError){
                                var scope = keywordArgs.scope || kernel.global;
                                keywordArgs.onError.call(scope, err);
                        }
                };

                if(this._saveEverything){
                        var newFileContentString = this._getNewFileContentString();
                        this._saveEverything(saveCompleteCallback, saveFailedCallback, newFileContentString);
                }
                if(this._saveCustom){
                        this._saveCustom(saveCompleteCallback, saveFailedCallback);
                }
                if(!this._saveEverything && !this._saveCustom){
                        // Looks like there is no user-defined save-handler function.
                        // That's fine, it just means the datastore is acting as a "mock-write"
                        // store -- changes get saved in memory but don't get saved to disk.
                        saveCompleteCallback();
                }
        },

        revert: function(){
                // summary:
                //              See dojo/data/api/Write.revert()
                this._assert(!this._saveInProgress);

                var identity;
                for(identity in this._pending._modifiedItems){
                        // find the original item and the modified item that replaced it
                        var copyOfItemState = this._pending._modifiedItems[identity];
                        var modifiedItem = null;
                        if(this._itemsByIdentity){
                                modifiedItem = this._itemsByIdentity[identity];
                        }else{
                                modifiedItem = this._arrayOfAllItems[identity];
                        }

                        // Restore the original item into a full-fledged item again, we want to try to
                        // keep the same object instance as if we don't it, causes bugs like #9022.
                        copyOfItemState[this._storeRefPropName] = this;
                        for(var key in modifiedItem){
                                delete modifiedItem[key];
                        }
                        lang.mixin(modifiedItem, copyOfItemState);
                }
                var deletedItem;
                for(identity in this._pending._deletedItems){
                        deletedItem = this._pending._deletedItems[identity];
                        deletedItem[this._storeRefPropName] = this;
                        var index = deletedItem[this._itemNumPropName];

                        //Restore the reverse refererence map, if any.
                        if(deletedItem["backup_" + this._reverseRefMap]){
                                deletedItem[this._reverseRefMap] = deletedItem["backup_" + this._reverseRefMap];
                                delete deletedItem["backup_" + this._reverseRefMap];
                        }
                        this._arrayOfAllItems[index] = deletedItem;
                        if(this._itemsByIdentity){
                                this._itemsByIdentity[identity] = deletedItem;
                        }
                        if(deletedItem[this._rootItemPropName]){
                                this._arrayOfTopLevelItems.push(deletedItem);
                        }
                }
                //We have to pass through it again and restore the reference maps after all the
                //undeletes have occurred.
                for(identity in this._pending._deletedItems){
                        deletedItem = this._pending._deletedItems[identity];
                        if(deletedItem["backupRefs_" + this._reverseRefMap]){
                                arrayUtil.forEach(deletedItem["backupRefs_" + this._reverseRefMap], function(reference){
                                        var refItem;
                                        if(this._itemsByIdentity){
                                                refItem = this._itemsByIdentity[reference.id];
                                        }else{
                                                refItem = this._arrayOfAllItems[reference.id];
                                        }
                                        this._addReferenceToMap(refItem, deletedItem, reference.attr);
                                }, this);
                                delete deletedItem["backupRefs_" + this._reverseRefMap];
                        }
                }

                for(identity in this._pending._newItems){
                        var newItem = this._pending._newItems[identity];
                        newItem[this._storeRefPropName] = null;
                        // null out the new item, but don't change the array index so
                        // so we can keep using _arrayOfAllItems.length.
                        this._arrayOfAllItems[newItem[this._itemNumPropName]] = null;
                        if(newItem[this._rootItemPropName]){
                                this._removeArrayElement(this._arrayOfTopLevelItems, newItem);
                        }
                        if(this._itemsByIdentity){
                                delete this._itemsByIdentity[identity];
                        }
                }

                this._pending = {
                        _newItems:{},
                        _modifiedItems:{},
                        _deletedItems:{}
                };
                return true; // boolean
        },

        isDirty: function(/* item? */ item){
                // summary:
                //              See dojo/data/api/Write.isDirty()
                if(item){
                        // return true if the item is dirty
                        var identity = this.getIdentity(item);
                        return new Boolean(this._pending._newItems[identity] ||
                                this._pending._modifiedItems[identity] ||
                                this._pending._deletedItems[identity]).valueOf(); // boolean
                }else{
                        // return true if the store is dirty -- which means return true
                        // if there are any new items, dirty items, or modified items
                        return !this._isEmpty(this._pending._newItems) ||
                                !this._isEmpty(this._pending._modifiedItems) ||
                                !this._isEmpty(this._pending._deletedItems); // boolean
                }
        },

/* dojo/data/api/Notification */

        onSet: function(/* dojo/data/api/Item */ item,
                                        /*attribute-name-string*/ attribute,
                                        /*object|array*/ oldValue,
                                        /*object|array*/ newValue){
                // summary:
                //              See dojo/data/api/Notification.onSet()

                // No need to do anything. This method is here just so that the
                // client code can connect observers to it.
        },

        onNew: function(/* dojo/data/api/Item */ newItem, /*object?*/ parentInfo){
                // summary:
                //              See dojo/data/api/Notification.onNew()

                // No need to do anything. This method is here just so that the
                // client code can connect observers to it.
        },

        onDelete: function(/* dojo/data/api/Item */ deletedItem){
                // summary:
                //              See dojo/data/api/Notification.onDelete()

                // No need to do anything. This method is here just so that the
                // client code can connect observers to it.
        },

        close: function(/* object? */ request){
                 // summary:
                 //             Over-ride of base close function of ItemFileReadStore to add in check for store state.
                 // description:
                 //             Over-ride of base close function of ItemFileReadStore to add in check for store state.
                 //             If the store is still dirty (unsaved changes), then an error will be thrown instead of
                 //             clearing the internal state for reload from the url.

                 //Clear if not dirty ... or throw an error
                 if(this.clearOnClose){
                         if(!this.isDirty()){
                                 this.inherited(arguments);
                         }else{
                                 //Only throw an error if the store was dirty and we were loading from a url (cannot reload from url until state is saved).
                                 throw new Error("dojo.data.ItemFileWriteStore: There are unsaved changes present in the store.  Please save or revert the changes before invoking close.");
                         }
                 }
        }
});

});

},
'url:dijit/templates/TreeNode.html':"<div class=\"dijitTreeNode\" role=\"presentation\"\n\t><div data-dojo-attach-point=\"rowNode\" class=\"dijitTreeRow dijitInline\" role=\"presentation\"\n\t\t><div data-dojo-attach-point=\"indentNode\" class=\"dijitInline\"></div\n\t\t><img src=\"${_blankGif}\" alt=\"\" data-dojo-attach-point=\"expandoNode\" class=\"dijitTreeExpando\" role=\"presentation\"\n\t\t/><span data-dojo-attach-point=\"expandoNodeText\" class=\"dijitExpandoText\" role=\"presentation\"\n\t\t></span\n\t\t><span data-dojo-attach-point=\"contentNode\"\n\t\t\tclass=\"dijitTreeContent\" role=\"presentation\">\n\t\t\t<img src=\"${_blankGif}\" alt=\"\" data-dojo-attach-point=\"iconNode\" class=\"dijitIcon dijitTreeIcon\" role=\"presentation\"\n\t\t\t/><span data-dojo-attach-point=\"labelNode\" class=\"dijitTreeLabel\" role=\"treeitem\" tabindex=\"-1\" aria-selected=\"false\"></span>\n\t\t</span\n\t></div>\n\t<div data-dojo-attach-point=\"containerNode\" class=\"dijitTreeContainer\" role=\"presentation\" style=\"display: none;\"></div>\n</div>\n",
'dojo/dnd/TimedMoveable':function(){
define("dojo/dnd/TimedMoveable", ["../_base/declare", "./Moveable" /*=====, "./Mover" =====*/], function(declare, Moveable /*=====, Mover =====*/){
        // module:
        //              dojo/dnd/TimedMoveable

        /*=====
        var __TimedMoveableArgs = declare([Moveable.__MoveableArgs], {
                // timeout: Number
                //              delay move by this number of ms,
                //              accumulating position changes during the timeout
                timeout: 0
        });
        =====*/

        // precalculate long expressions
        var oldOnMove = Moveable.prototype.onMove;

        return declare("dojo.dnd.TimedMoveable", Moveable, {
                // summary:
                //              A specialized version of Moveable to support an FPS throttling.
                //              This class puts an upper restriction on FPS, which may reduce
                //              the CPU load. The additional parameter "timeout" regulates
                //              the delay before actually moving the moveable object.

                // object attributes (for markup)
                timeout: 40,    // in ms, 40ms corresponds to 25 fps

                constructor: function(node, params){
                        // summary:
                        //              an object that makes a node moveable with a timer
                        // node: Node||String
                        //              a node (or node's id) to be moved
                        // params: __TimedMoveableArgs
                        //              object with additional parameters.

                        // sanitize parameters
                        if(!params){ params = {}; }
                        if(params.timeout && typeof params.timeout == "number" && params.timeout >= 0){
                                this.timeout = params.timeout;
                        }
                },

                onMoveStop: function(/*Mover*/ mover){
                        if(mover._timer){
                                // stop timer
                                clearTimeout(mover._timer);
                                // reflect the last received position
                                oldOnMove.call(this, mover, mover._leftTop);
                        }
                        Moveable.prototype.onMoveStop.apply(this, arguments);
                },
                onMove: function(/*Mover*/ mover, /*Object*/ leftTop){
                        mover._leftTop = leftTop;
                        if(!mover._timer){
                                var _t = this;  // to avoid using dojo.hitch()
                                mover._timer = setTimeout(function(){
                                        // we don't have any pending requests
                                        mover._timer = null;
                                        // reflect the last received position
                                        oldOnMove.call(_t, mover, mover._leftTop);
                                }, this.timeout);
                        }
                }
        });
});

},
'dojo/NodeList-fx':function(){
define("dojo/NodeList-fx", ["./query", "./_base/lang", "./_base/connect", "./_base/fx", "./fx"],
function(query, lang, connectLib, baseFx, coreFx){

// module:
//              dojo/NodeList-fx

/*=====
return function(){
        // summary:
        //              Adds dojo.fx animation support to dojo.query() by extending the NodeList class
        //              with additional FX functions.  NodeList is the array-like object used to hold query results.
};
=====*/

var NodeList = query.NodeList;

lang.extend(NodeList, {
        _anim: function(obj, method, args){
                args = args||{};
                var a = coreFx.combine(
                        this.map(function(item){
                                var tmpArgs = { node: item };
                                lang.mixin(tmpArgs, args);
                                return obj[method](tmpArgs);
                        })
                );
                return args.auto ? a.play() && this : a; // dojo/_base/fx.Animation|dojo/NodeList
        },

        wipeIn: function(args){
                // summary:
                //              wipe in all elements of this NodeList via `dojo/fx.wipeIn()`
                //
                // args: Object?
                //              Additional dojo/_base/fx.Animation arguments to mix into this set with the addition of
                //              an `auto` parameter.
                //
                // returns: dojo/_base/fx.Animation|dojo/NodeList
                //              A special args member `auto` can be passed to automatically play the animation.
                //              If args.auto is present, the original dojo/NodeList will be returned for further
                //              chaining. Otherwise the dojo/_base/fx.Animation instance is returned and must be .play()'ed
                //
                // example:
                //              Fade in all tables with class "blah":
                //              |       dojo.query("table.blah").wipeIn().play();
                //
                // example:
                //              Utilizing `auto` to get the NodeList back:
                //              |       dojo.query(".titles").wipeIn({ auto:true }).onclick(someFunction);
                //
                return this._anim(coreFx, "wipeIn", args); // dojo/_base/fx.Animation|dojo/NodeList
        },

        wipeOut: function(args){
                // summary:
                //              wipe out all elements of this NodeList via `dojo/fx.wipeOut()`
                //
                // args: Object?
                //              Additional dojo/_base/fx.Animation arguments to mix into this set with the addition of
                //              an `auto` parameter.
                //
                // returns: dojo/_base/fx.Animation|dojo/NodeList
                //              A special args member `auto` can be passed to automatically play the animation.
                //              If args.auto is present, the original dojo/NodeList will be returned for further
                //              chaining. Otherwise the dojo/_base/fx.Animation instance is returned and must be .play()'ed
                //
                // example:
                //              Wipe out all tables with class "blah":
                //              |       dojo.query("table.blah").wipeOut().play();
                return this._anim(coreFx, "wipeOut", args); // dojo/_base/fx.Animation|dojo/NodeList
        },

        slideTo: function(args){
                // summary:
                //              slide all elements of the node list to the specified place via `dojo/fx.slideTo()`
                //
                // args: Object?
                //              Additional dojo/_base/fx.Animation arguments to mix into this set with the addition of
                //              an `auto` parameter.
                //
                // returns: dojo/_base/fx.Animation|dojo/NodeList
                //              A special args member `auto` can be passed to automatically play the animation.
                //              If args.auto is present, the original dojo/NodeList will be returned for further
                //              chaining. Otherwise the dojo/_base/fx.Animation instance is returned and must be .play()'ed
                //
                // example:
                //              |       Move all tables with class "blah" to 300/300:
                //              |       dojo.query("table.blah").slideTo({
                //              |               left: 40,
                //              |               top: 50
                //              |       }).play();
                return this._anim(coreFx, "slideTo", args); // dojo/_base/fx.Animation|dojo/NodeList
        },


        fadeIn: function(args){
                // summary:
                //              fade in all elements of this NodeList via `dojo.fadeIn`
                //
                // args: Object?
                //              Additional dojo/_base/fx.Animation arguments to mix into this set with the addition of
                //              an `auto` parameter.
                //
                // returns: dojo/_base/fx.Animation|dojo/NodeList
                //              A special args member `auto` can be passed to automatically play the animation.
                //              If args.auto is present, the original dojo/NodeList will be returned for further
                //              chaining. Otherwise the dojo/_base/fx.Animation instance is returned and must be .play()'ed
                //
                // example:
                //              Fade in all tables with class "blah":
                //              |       dojo.query("table.blah").fadeIn().play();
                return this._anim(baseFx, "fadeIn", args); // dojo/_base/fx.Animation|dojo/NodeList
        },

        fadeOut: function(args){
                // summary:
                //              fade out all elements of this NodeList via `dojo.fadeOut`
                //
                // args: Object?
                //              Additional dojo/_base/fx.Animation arguments to mix into this set with the addition of
                //              an `auto` parameter.
                //
                // returns: dojo/_base/fx.Animation|dojo/NodeList
                //              A special args member `auto` can be passed to automatically play the animation.
                //              If args.auto is present, the original dojo/NodeList will be returned for further
                //              chaining. Otherwise the dojo/_base/fx.Animation instance is returned and must be .play()'ed
                //
                // example:
                //              Fade out all elements with class "zork":
                //              |       dojo.query(".zork").fadeOut().play();
                // example:
                //              Fade them on a delay and do something at the end:
                //              |       var fo = dojo.query(".zork").fadeOut();
                //              |       dojo.connect(fo, "onEnd", function(){ /*...*/ });
                //              |       fo.play();
                // example:
                //              Using `auto`:
                //              |       dojo.query("li").fadeOut({ auto:true }).filter(filterFn).forEach(doit);
                //
                return this._anim(baseFx, "fadeOut", args); // dojo/_base/fx.Animation|dojo/NodeList
        },

        animateProperty: function(args){
                // summary:
                //              Animate all elements of this NodeList across the properties specified.
                //              syntax identical to `dojo.animateProperty`
                //
                // args: Object?
                //              Additional dojo/_base/fx.Animation arguments to mix into this set with the addition of
                //              an `auto` parameter.
                //
                // returns: dojo/_base/fx.Animation|dojo/NodeList
                //              A special args member `auto` can be passed to automatically play the animation.
                //              If args.auto is present, the original dojo/NodeList will be returned for further
                //              chaining. Otherwise the dojo/_base/fx.Animation instance is returned and must be .play()'ed
                //
                // example:
                //      |       dojo.query(".zork").animateProperty({
                //      |               duration: 500,
                //      |               properties: {
                //      |                       color:          { start: "black", end: "white" },
                //      |                       left:           { end: 300 }
                //      |               }
                //      |       }).play();
                //
                // example:
                //      |       dojo.query(".grue").animateProperty({
                //      |               auto:true,
                //      |               properties: {
                //      |                       height:240
                //      |               }
                //      |       }).onclick(handler);
                return this._anim(baseFx, "animateProperty", args); // dojo/_base/fx.Animation|dojo/NodeList
        },

        anim: function( /*Object*/                      properties,
                                        /*Integer?*/            duration,
                                        /*Function?*/           easing,
                                        /*Function?*/           onEnd,
                                        /*Integer?*/            delay){
                // summary:
                //              Animate one or more CSS properties for all nodes in this list.
                //              The returned animation object will already be playing when it
                //              is returned. See the docs for `dojo.anim` for full details.
                // properties: Object
                //              the properties to animate. does NOT support the `auto` parameter like other
                //              NodeList-fx methods.
                // duration: Integer?
                //              Optional. The time to run the animations for
                // easing: Function?
                //              Optional. The easing function to use.
                // onEnd: Function?
                //              A function to be called when the animation ends
                // delay:
                //              how long to delay playing the returned animation
                // example:
                //              Another way to fade out:
                //      |       dojo.query(".thinger").anim({ opacity: 0 });
                // example:
                //              animate all elements with the "thigner" class to a width of 500
                //              pixels over half a second
                //      |       dojo.query(".thinger").anim({ width: 500 }, 700);
                var canim = coreFx.combine(
                        this.map(function(item){
                                return baseFx.animateProperty({
                                        node: item,
                                        properties: properties,
                                        duration: duration||350,
                                        easing: easing
                                });
                        })
                );
                if(onEnd){
                        connectLib.connect(canim, "onEnd", onEnd);
                }
                return canim.play(delay||0); // dojo/_base/fx.Animation
        }
});

return NodeList;
});

},
'dijit/form/_ListMouseMixin':function(){
define("dijit/form/_ListMouseMixin", [
        "dojo/_base/declare", // declare
        "dojo/mouse",
        "dojo/on",
        "dojo/touch",
        "./_ListBase"
], function(declare, mouse, on, touch, _ListBase){

// module:
//              dijit/form/_ListMouseMixin

return declare( "dijit.form._ListMouseMixin", _ListBase, {
        // summary:
        //              a Mixin to handle mouse or touch events for a focus-less menu
        //              Abstract methods that must be defined externally:
        //
        //              - onClick: item was chosen (mousedown somewhere on the menu and mouseup somewhere on the menu)
        // tags:
        //              private

        postCreate: function(){
                this.inherited(arguments);

                this.own(on(this.domNode, touch.press, function(evt){ evt.preventDefault(); })); // prevent focus shift on list scrollbar press

                this._listConnect(touch.press, "_onMouseDown");
                this._listConnect(touch.release, "_onMouseUp");
                this._listConnect(mouse.enter, "_onMouseOver");
                this._listConnect(mouse.leave, "_onMouseOut");
        },

        _onMouseDown: function(/*Event*/ evt, /*DomNode*/ target){
                if(this._hoveredNode){
                        this.onUnhover(this._hoveredNode);
                        this._hoveredNode = null;
                }
                this._isDragging = true;
                this._setSelectedAttr(target);
        },

        _onMouseUp: function(/*Event*/ evt, /*DomNode*/ target){
                this._isDragging = false;
                var selectedNode = this.selected;
                var hoveredNode = this._hoveredNode;
                if(selectedNode && target == selectedNode){
                        this.onClick(selectedNode);
                }else if(hoveredNode && target == hoveredNode){ // drag to select
                        this._setSelectedAttr(hoveredNode);
                        this.onClick(hoveredNode);
                }
        },

        _onMouseOut: function(/*Event*/ evt, /*DomNode*/ target){
                if(this._hoveredNode){
                        this.onUnhover(this._hoveredNode);
                        this._hoveredNode = null;
                }
                if(this._isDragging){
                        this._cancelDrag = (new Date()).getTime() + 1000; // cancel in 1 second if no _onMouseOver fires
                }
        },

        _onMouseOver: function(/*Event*/ evt, /*DomNode*/ target){
                if(this._cancelDrag){
                        var time = (new Date()).getTime();
                        if(time > this._cancelDrag){
                                this._isDragging = false;
                        }
                        this._cancelDrag = null;
                }
                this._hoveredNode = target;
                this.onHover(target);
                if(this._isDragging){
                        this._setSelectedAttr(target);
                }
        }
});

});

},
'url:dijit/templates/Tree.html':"<div class=\"dijitTree dijitTreeContainer\" role=\"tree\">\n\t<div class=\"dijitInline dijitTreeIndent\" style=\"position: absolute; top: -9999px\" data-dojo-attach-point=\"indentDetector\"></div>\n</div>\n",
'dojo/cookie':function(){
define("dojo/cookie", ["./_base/kernel", "./regexp"], function(dojo, regexp){

// module:
//              dojo/cookie

/*=====
var __cookieProps = {
        // expires: Date|String|Number?
        //              If a number, the number of days from today at which the cookie
        //              will expire. If a date, the date past which the cookie will expire.
        //              If expires is in the past, the cookie will be deleted.
        //              If expires is omitted or is 0, the cookie will expire when the browser closes.
        // path: String?
        //              The path to use for the cookie.
        // domain: String?
        //              The domain to use for the cookie.
        // secure: Boolean?
        //              Whether to only send the cookie on secure connections
};
=====*/


dojo.cookie = function(/*String*/name, /*String?*/ value, /*__cookieProps?*/ props){
        // summary:
        //              Get or set a cookie.
        // description:
        //              If one argument is passed, returns the value of the cookie
        //              For two or more arguments, acts as a setter.
        // name:
        //              Name of the cookie
        // value:
        //              Value for the cookie
        // props:
        //              Properties for the cookie
        // example:
        //              set a cookie with the JSON-serialized contents of an object which
        //              will expire 5 days from now:
        //      |       require(["dojo/cookie", "dojo/json"], function(cookie, json){
        //      |               cookie("configObj", json.stringify(config, {expires: 5 }));
        //      |       });
        //
        // example:
        //              de-serialize a cookie back into a JavaScript object:
        //      |       require(["dojo/cookie", "dojo/json"], function(cookie, json){
        //      |               config = json.parse(cookie("configObj"));
        //      |       });
        //
        // example:
        //              delete a cookie:
        //      |       require(["dojo/cookie"], function(cookie){
        //      |               cookie("configObj", null, {expires: -1});
        //      |       });
        var c = document.cookie, ret;
        if(arguments.length == 1){
                var matches = c.match(new RegExp("(?:^|; )" + regexp.escapeString(name) + "=([^;]*)"));
                ret = matches ? decodeURIComponent(matches[1]) : undefined; 
        }else{
                props = props || {};
// FIXME: expires=0 seems to disappear right away, not on close? (FF3)  Change docs?
                var exp = props.expires;
                if(typeof exp == "number"){
                        var d = new Date();
                        d.setTime(d.getTime() + exp*24*60*60*1000);
                        exp = props.expires = d;
                }
                if(exp && exp.toUTCString){ props.expires = exp.toUTCString(); }

                value = encodeURIComponent(value);
                var updatedCookie = name + "=" + value, propName;
                for(propName in props){
                        updatedCookie += "; " + propName;
                        var propValue = props[propName];
                        if(propValue !== true){ updatedCookie += "=" + propValue; }
                }
                document.cookie = updatedCookie;
        }
        return ret; // String|undefined
};

dojo.cookie.isSupported = function(){
        // summary:
        //              Use to determine if the current browser supports cookies or not.
        //
        //              Returns true if user allows cookies.
        //              Returns false if user doesn't allow cookies.

        if(!("cookieEnabled" in navigator)){
                this("__djCookieTest__", "CookiesAllowed");
                navigator.cookieEnabled = this("__djCookieTest__") == "CookiesAllowed";
                if(navigator.cookieEnabled){
                        this("__djCookieTest__", "", {expires: -1});
                }
        }
        return navigator.cookieEnabled;
};

return dojo.cookie;
});

},
'dojo/cache':function(){
define("dojo/cache", ["./_base/kernel", "./text"], function(dojo){
        // module:
        //              dojo/cache

        // dojo.cache is defined in dojo/text
        return dojo.cache;
});

},
'url:dijit/form/templates/DropDownBox.html':"<div class=\"dijit dijitReset dijitInline dijitLeft\"\n\tid=\"widget_${id}\"\n\trole=\"combobox\"\n\t><div class='dijitReset dijitRight dijitButtonNode dijitArrowButton dijitDownArrowButton dijitArrowButtonContainer'\n\t\tdata-dojo-attach-point=\"_buttonNode, _popupStateNode\" role=\"presentation\"\n\t\t><input class=\"dijitReset dijitInputField dijitArrowButtonInner\" value=\"&#9660; \" type=\"text\" tabIndex=\"-1\" readonly=\"readonly\" role=\"button presentation\" aria-hidden=\"true\"\n\t\t\t${_buttonInputDisabled}\n\t/></div\n\t><div class='dijitReset dijitValidationContainer'\n\t\t><input class=\"dijitReset dijitInputField dijitValidationIcon dijitValidationInner\" value=\"&#935; \" type=\"text\" tabIndex=\"-1\" readonly=\"readonly\" role=\"presentation\"\n\t/></div\n\t><div class=\"dijitReset dijitInputField dijitInputContainer\"\n\t\t><input class='dijitReset dijitInputInner' ${!nameAttrSetting} type=\"text\" autocomplete=\"off\"\n\t\t\tdata-dojo-attach-point=\"textbox,focusNode\" role=\"textbox\" aria-haspopup=\"true\"\n\t/></div\n></div>\n",
'dijit/ProgressBar':function(){
require({cache:{
'url:dijit/templates/ProgressBar.html':"<div class=\"dijitProgressBar dijitProgressBarEmpty\" role=\"progressbar\"\n\t><div  data-dojo-attach-point=\"internalProgress\" class=\"dijitProgressBarFull\"\n\t\t><div class=\"dijitProgressBarTile\" role=\"presentation\"></div\n\t\t><span style=\"visibility:hidden\">&#160;</span\n\t></div\n\t><div data-dojo-attach-point=\"labelNode\" class=\"dijitProgressBarLabel\" id=\"${id}_label\"></div\n\t><img data-dojo-attach-point=\"indeterminateHighContrastImage\" class=\"dijitProgressBarIndeterminateHighContrastImage\" alt=\"\"\n/></div>\n"}});
define("dijit/ProgressBar", [
        "require",                      // require.toUrl
        "dojo/_base/declare", // declare
        "dojo/dom-class", // domClass.toggle
        "dojo/_base/lang", // lang.mixin
        "dojo/number", // number.format
        "./_Widget",
        "./_TemplatedMixin",
        "dojo/text!./templates/ProgressBar.html"
], function(require, declare, domClass, lang, number, _Widget, _TemplatedMixin, template){

// module:
//              dijit/ProgressBar


return declare("dijit.ProgressBar", [_Widget, _TemplatedMixin], {
        // summary:
        //              A progress indication widget, showing the amount completed
        //              (often the percentage completed) of a task.
        //
        // example:
        // |    <div data-dojo-type="ProgressBar"
        // |             places="0"
        // |             value="..." maximum="...">
        // |    </div>

        // progress: [const] String (Percentage or Number)
        //              Number or percentage indicating amount of task completed.
        //              Deprecated.   Use "value" instead.
        progress: "0",

        // value: String (Percentage or Number)
        //              Number or percentage indicating amount of task completed.
        //              With "%": percentage value, 0% <= progress <= 100%, or
        //              without "%": absolute value, 0 <= progress <= maximum.
        //              Infinity means that the progress bar is indeterminate.
        value: "",

        // maximum: [const] Float
        //              Max sample number
        maximum: 100,

        // places: [const] Number
        //              Number of places to show in values; 0 by default
        places: 0,

        // indeterminate: [const] Boolean
        //              If false: show progress value (number or percentage).
        //              If true: show that a process is underway but that the amount completed is unknown.
        //              Deprecated.   Use "value" instead.
        indeterminate: false,

        // label: String?
        //              Label on progress bar.   Defaults to percentage for determinate progress bar and
        //              blank for indeterminate progress bar.
        label:"",

        // name: String
        //              this is the field name (for a form) if set. This needs to be set if you want to use
        //              this widget in a dijit/form/Form widget (such as dijit/Dialog)
        name: '',

        templateString: template,

        // _indeterminateHighContrastImagePath: [private] URL
        //              URL to image to use for indeterminate progress bar when display is in high contrast mode
        _indeterminateHighContrastImagePath:
                require.toUrl("./themes/a11y/indeterminate_progress.gif"),

        postMixInProperties: function(){
                this.inherited(arguments);

                // Back-compat for when constructor specifies indeterminate or progress, rather than value.   Remove for 2.0.
                if(!(this.params && "value" in this.params)){
                        this.value = this.indeterminate ? Infinity : this.progress;
                }
        },

        buildRendering: function(){
                this.inherited(arguments);
                this.indeterminateHighContrastImage.setAttribute("src",
                        this._indeterminateHighContrastImagePath.toString());
                this.update();
        },

        update: function(/*Object?*/attributes){
                // summary:
                //              Internal method to change attributes of ProgressBar, similar to set(hash).  Users should call
                //              set("value", ...) rather than calling this method directly.
                // attributes:
                //              May provide progress and/or maximum properties on this parameter;
                //              see attribute specs for details.
                // example:
                //      |       myProgressBar.update({'indeterminate': true});
                //      |       myProgressBar.update({'progress': 80});
                //      |       myProgressBar.update({'indeterminate': true, label:"Loading ..." })
                // tags:
                //              private

                // TODO: deprecate this method and use set() instead

                lang.mixin(this, attributes || {});
                var tip = this.internalProgress, ap = this.domNode;
                var percent = 1;
                if(this.indeterminate){
                        ap.removeAttribute("aria-valuenow");
                }else{
                        if(String(this.progress).indexOf("%") != -1){
                                percent = Math.min(parseFloat(this.progress)/100, 1);
                                this.progress = percent * this.maximum;
                        }else{
                                this.progress = Math.min(this.progress, this.maximum);
                                percent = this.maximum ? this.progress / this.maximum : 0;
                        }
                        ap.setAttribute("aria-valuenow", this.progress);
                }

                // Even indeterminate ProgressBars should have these attributes
                ap.setAttribute("aria-describedby", this.labelNode.id);
                ap.setAttribute("aria-valuemin", 0);
                ap.setAttribute("aria-valuemax", this.maximum);
                
                this.labelNode.innerHTML = this.report(percent);

                domClass.toggle(this.domNode, "dijitProgressBarIndeterminate", this.indeterminate);
                tip.style.width = (percent * 100) + "%";
                this.onChange();
        },

        _setValueAttr: function(v){
                this._set("value", v);
                if(v == Infinity){
                        this.update({indeterminate:true});
                }else{
                        this.update({indeterminate:false, progress:v});
                }
        },

        _setLabelAttr: function(label){
                this._set("label", label);
                this.update();
        },

        _setIndeterminateAttr: function(indeterminate){
                // Deprecated, use set("value", ...) instead
                this.indeterminate = indeterminate;
                this.update();
        },

        report: function(/*float*/percent){
                // summary:
                //              Generates message to show inside progress bar (normally indicating amount of task completed).
                //              May be overridden.
                // tags:
                //              extension

                return this.label ? this.label :
                                (this.indeterminate ? "&#160;" : number.format(percent, { type: "percent", places: this.places, locale: this.lang }));
        },

        onChange: function(){
                // summary:
                //              Callback fired when progress updates.
                // tags:
                //              extension
        }
});

});

},
'dijit/_base/popup':function(){
define("dijit/_base/popup", [
        "dojo/dom-class", // domClass.contains
        "dojo/_base/window",
        "../popup",
        "../BackgroundIframe"   // just loading for back-compat, in case client code is referencing it
], function(domClass, win, popup){

// module:
//              dijit/_base/popup

/*=====
return {
        // summary:
        //              Deprecated.   Old module for popups, new code should use dijit/popup directly.
};
=====*/


// Hack support for old API passing in node instead of a widget (to various methods)
var origCreateWrapper = popup._createWrapper;
popup._createWrapper = function(widget){
        if(!widget.declaredClass){
                // make fake widget to pass to new API
                widget = {
                        _popupWrapper: (widget.parentNode && domClass.contains(widget.parentNode, "dijitPopup")) ?
                                widget.parentNode : null,
                        domNode: widget,
                        destroy: function(){},
                        ownerDocument: widget.ownerDocument,
                        ownerDocumentBody: win.body(widget.ownerDocument)
                };
        }
        return origCreateWrapper.call(this, widget);
};

// Support old format of orient parameter
var origOpen = popup.open;
popup.open = function(/*__OpenArgs*/ args){
        // Convert old hash structure (ex: {"BL": "TL", ...}) of orient to format compatible w/new popup.open() API.
        // Don't do conversion for:
        //              - null parameter (that means to use the default positioning)
        //              - "R" or "L" strings used to indicate positioning for context menus (when there is no around node)
        //              - new format, ex: ["below", "above"]
        //              - return value from deprecated dijit.getPopupAroundAlignment() method,
        //                      ex: ["below", "above"]
        if(args.orient && typeof args.orient != "string" && !("length" in args.orient)){
                var ary = [];
                for(var key in args.orient){
                        ary.push({aroundCorner: key, corner: args.orient[key]});
                }
                args.orient = ary;
        }

        return origOpen.call(this, args);
};

return popup;
});

},
'dijit/ColorPalette':function(){
require({cache:{
'url:dijit/templates/ColorPalette.html':"<div class=\"dijitInline dijitColorPalette\">\n\t<table dojoAttachPoint=\"paletteTableNode\" class=\"dijitPaletteTable\" cellSpacing=\"0\" cellPadding=\"0\" role=\"grid\">\n\t\t<tbody data-dojo-attach-point=\"gridNode\"></tbody>\n\t</table>\n</div>\n"}});
define("dijit/ColorPalette", [
        "require",              // require.toUrl
        "dojo/text!./templates/ColorPalette.html",
        "./_Widget",    // used also to load dijit/hccss for setting has("highcontrast")
        "./_TemplatedMixin",
        "./_PaletteMixin",
        "./hccss",      // has("highcontrast")
        "dojo/i18n", // i18n.getLocalization
        "dojo/_base/Color", // dojo.Color dojo.Color.named
        "dojo/_base/declare", // declare
        "dojo/dom-construct", // domConstruct.place
        "dojo/string", // string.substitute
        "dojo/i18n!dojo/nls/colors",    // translations
        "dojo/colors"   // extend dojo.Color w/names of other colors
], function(require, template, _Widget, _TemplatedMixin, _PaletteMixin, has, i18n, Color,
        declare, domConstruct, string){

// module:
//              dijit/ColorPalette

var ColorPalette = declare("dijit.ColorPalette", [_Widget, _TemplatedMixin, _PaletteMixin], {
        // summary:
        //              A keyboard accessible color-picking widget
        // description:
        //              Grid showing various colors, so the user can pick a certain color.
        //              Can be used standalone, or as a popup.
        //
        // example:
        // |    <div data-dojo-type="dijit/ColorPalette"></div>
        //
        // example:
        // |    var picker = new dijit.ColorPalette({ },srcNode);
        // |    picker.startup();


        // palette: [const] String
        //              Size of grid, either "7x10" or "3x4".
        palette: "7x10",

        // _palettes: [protected] Map
        //              This represents the value of the colors.
        //              The first level is a hashmap of the different palettes available.
        //              The next two dimensions represent the columns and rows of colors.
        _palettes: {
                "7x10": [["white", "seashell", "cornsilk", "lemonchiffon","lightyellow", "palegreen", "paleturquoise", "lightcyan",     "lavender", "plum"],
                                ["lightgray", "pink", "bisque", "moccasin", "khaki", "lightgreen", "lightseagreen", "lightskyblue", "cornflowerblue", "violet"],
                                ["silver", "lightcoral", "sandybrown", "orange", "palegoldenrod", "chartreuse", "mediumturquoise", "skyblue", "mediumslateblue","orchid"],
                                ["gray", "red", "orangered", "darkorange", "yellow", "limegreen", "darkseagreen", "royalblue", "slateblue", "mediumorchid"],
                                ["dimgray", "crimson",  "chocolate", "coral", "gold", "forestgreen", "seagreen", "blue", "blueviolet", "darkorchid"],
                                ["darkslategray","firebrick","saddlebrown", "sienna", "olive", "green", "darkcyan", "mediumblue","darkslateblue", "darkmagenta" ],
                                ["black", "darkred", "maroon", "brown", "darkolivegreen", "darkgreen", "midnightblue", "navy", "indigo", "purple"]],

                "3x4": [["white", "lime", "green", "blue"],
                        ["silver", "yellow", "fuchsia", "navy"],
                        ["gray", "red", "purple", "black"]]
        },

        // templateString: String
        //              The template of this widget.
        templateString: template,

        baseClass: "dijitColorPalette",

        _dyeFactory: function(value, row, col, title){
                // Overrides _PaletteMixin._dyeFactory().
                return new this._dyeClass(value, row, col, title);
        },

        buildRendering: function(){
                // Instantiate the template, which makes a skeleton into which we'll insert a bunch of
                // <img> nodes
                this.inherited(arguments);

                //      Creates customized constructor for dye class (color of a single cell) for
                //      specified palette and high-contrast vs. normal mode.   Used in _getDye().
                this._dyeClass = declare(ColorPalette._Color, {
                        palette: this.palette
                });

                // Creates <img> nodes in each cell of the template.
                this._preparePalette(
                        this._palettes[this.palette],
                        i18n.getLocalization("dojo", "colors", this.lang));
        }
});

ColorPalette._Color = declare("dijit._Color", Color, {
        // summary:
        //              Object associated with each cell in a ColorPalette palette.
        //              Implements dijit/Dye.

        // Template for each cell in normal (non-high-contrast mode).  Each cell contains a wrapper
        // node for showing the border (called dijitPaletteImg for back-compat), and dijitColorPaletteSwatch
        // for showing the color.
        template:
                "<span class='dijitInline dijitPaletteImg'>" +
                        "<img src='${blankGif}' alt='${alt}' title='${title}' class='dijitColorPaletteSwatch' style='background-color: ${color}'/>" +
                "</span>",

        // Template for each cell in high contrast mode.  Each cell contains an image with the whole palette,
        // but scrolled and clipped to show the correct color only
        hcTemplate:
                "<span class='dijitInline dijitPaletteImg' style='position: relative; overflow: hidden; height: 12px; width: 14px;'>" +
                        "<img src='${image}' alt='${alt}' title='${title}' style='position: absolute; left: ${left}px; top: ${top}px; ${size}'/>" +
                "</span>",

        // _imagePaths: [protected] Map
        //              This is stores the path to the palette images used for high-contrast mode display
        _imagePaths: {
                "7x10": require.toUrl("./themes/a11y/colors7x10.png"),
                "3x4": require.toUrl("./themes/a11y/colors3x4.png")
        },

        constructor: function(alias, row, col, title){
                // summary:
                //              Constructor for ColorPalette._Color
                // alias: String
                //              English name of the color.
                // row: Number
                //              Vertical position in grid.
                // column: Number
                //              Horizontal position in grid.
                // title: String
                //              Localized name of the color.
                this._title = title;
                this._row = row;
                this._col = col;
                this.setColor(Color.named[alias]);
        },

        getValue: function(){
                // summary:
                //              Note that although dijit._Color is initialized with a value like "white" getValue() always
                //              returns a hex value
                return this.toHex();
        },

        fillCell: function(/*DOMNode*/ cell, /*String*/ blankGif){
                var html = string.substitute(has("highcontrast") ? this.hcTemplate : this.template, {
                        // substitution variables for normal mode
                        color: this.toHex(),
                        blankGif: blankGif,
                        alt: this._title,
                        title: this._title,

                        // variables used for high contrast mode
                        image: this._imagePaths[this.palette].toString(),
                        left: this._col * -20 - 5,
                        top: this._row * -20 - 5,
                        size: this.palette == "7x10" ? "height: 145px; width: 206px" : "height: 64px; width: 86px"
                });

                domConstruct.place(html, cell);
        }
});


return ColorPalette;
});

},
'url:dijit/form/templates/Button.html':"<span class=\"dijit dijitReset dijitInline\" role=\"presentation\"\n\t><span class=\"dijitReset dijitInline dijitButtonNode\"\n\t\tdata-dojo-attach-event=\"ondijitclick:_onClick\" role=\"presentation\"\n\t\t><span class=\"dijitReset dijitStretch dijitButtonContents\"\n\t\t\tdata-dojo-attach-point=\"titleNode,focusNode\"\n\t\t\trole=\"button\" aria-labelledby=\"${id}_label\"\n\t\t\t><span class=\"dijitReset dijitInline dijitIcon\" data-dojo-attach-point=\"iconNode\"></span\n\t\t\t><span class=\"dijitReset dijitToggleButtonIconChar\">&#x25CF;</span\n\t\t\t><span class=\"dijitReset dijitInline dijitButtonText\"\n\t\t\t\tid=\"${id}_label\"\n\t\t\t\tdata-dojo-attach-point=\"containerNode\"\n\t\t\t></span\n\t\t></span\n\t></span\n\t><input ${!nameAttrSetting} type=\"${type}\" value=\"${value}\" class=\"dijitOffScreen\"\n\t\ttabIndex=\"-1\" role=\"presentation\" data-dojo-attach-point=\"valueNode\"\n/></span>\n",
'dojo/_base/url':function(){
define("dojo/_base/url", ["./kernel"], function(dojo){
        // module:
        //              dojo/url

        var
                ore = new RegExp("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$"),
                ire = new RegExp("^((([^\\[:]+):)?([^@]+)@)?(\\[([^\\]]+)\\]|([^\\[:]*))(:([0-9]+))?$"),
                _Url = function(){
                        var n = null,
                                _a = arguments,
                                uri = [_a[0]];
                        // resolve uri components relative to each other
                        for(var i = 1; i<_a.length; i++){
                                if(!_a[i]){ continue; }

                                // Safari doesn't support this.constructor so we have to be explicit
                                // FIXME: Tracked (and fixed) in Webkit bug 3537.
                                //              http://bugs.webkit.org/show_bug.cgi?id=3537
                                var relobj = new _Url(_a[i]+""),
                                        uriobj = new _Url(uri[0]+"");

                                if(
                                        relobj.path == "" &&
                                        !relobj.scheme &&
                                        !relobj.authority &&
                                        !relobj.query
                                ){
                                        if(relobj.fragment != n){
                                                uriobj.fragment = relobj.fragment;
                                        }
                                        relobj = uriobj;
                                }else if(!relobj.scheme){
                                        relobj.scheme = uriobj.scheme;

                                        if(!relobj.authority){
                                                relobj.authority = uriobj.authority;

                                                if(relobj.path.charAt(0) != "/"){
                                                        var path = uriobj.path.substring(0,
                                                                uriobj.path.lastIndexOf("/") + 1) + relobj.path;

                                                        var segs = path.split("/");
                                                        for(var j = 0; j < segs.length; j++){
                                                                if(segs[j] == "."){
                                                                        // flatten "./" references
                                                                        if(j == segs.length - 1){
                                                                                segs[j] = "";
                                                                        }else{
                                                                                segs.splice(j, 1);
                                                                                j--;
                                                                        }
                                                                }else if(j > 0 && !(j == 1 && segs[0] == "") &&
                                                                        segs[j] == ".." && segs[j-1] != ".."){
                                                                        // flatten "../" references
                                                                        if(j == (segs.length - 1)){
                                                                                segs.splice(j, 1);
                                                                                segs[j - 1] = "";
                                                                        }else{
                                                                                segs.splice(j - 1, 2);
                                                                                j -= 2;
                                                                        }
                                                                }
                                                        }
                                                        relobj.path = segs.join("/");
                                                }
                                        }
                                }

                                uri = [];
                                if(relobj.scheme){
                                        uri.push(relobj.scheme, ":");
                                }
                                if(relobj.authority){
                                        uri.push("//", relobj.authority);
                                }
                                uri.push(relobj.path);
                                if(relobj.query){
                                        uri.push("?", relobj.query);
                                }
                                if(relobj.fragment){
                                        uri.push("#", relobj.fragment);
                                }
                        }

                        this.uri = uri.join("");

                        // break the uri into its main components
                        var r = this.uri.match(ore);

                        this.scheme = r[2] || (r[1] ? "" : n);
                        this.authority = r[4] || (r[3] ? "" : n);
                        this.path = r[5]; // can never be undefined
                        this.query = r[7] || (r[6] ? "" : n);
                        this.fragment    = r[9] || (r[8] ? "" : n);

                        if(this.authority != n){
                                // server based naming authority
                                r = this.authority.match(ire);

                                this.user = r[3] || n;
                                this.password = r[4] || n;
                                this.host = r[6] || r[7]; // ipv6 || ipv4
                                this.port = r[9] || n;
                        }
                };
        _Url.prototype.toString = function(){ return this.uri; };

        return dojo._Url = _Url;
});

},
'url:dijit/templates/MenuItem.html':"<tr class=\"dijitReset dijitMenuItem\" data-dojo-attach-point=\"focusNode\" role=\"menuitem\" tabIndex=\"-1\">\n\t<td class=\"dijitReset dijitMenuItemIconCell\" role=\"presentation\">\n\t\t<img src=\"${_blankGif}\" alt=\"\" class=\"dijitIcon dijitMenuItemIcon\" data-dojo-attach-point=\"iconNode\"/>\n\t</td>\n\t<td class=\"dijitReset dijitMenuItemLabel\" colspan=\"2\" data-dojo-attach-point=\"containerNode\"></td>\n\t<td class=\"dijitReset dijitMenuItemAccelKey\" style=\"display: none\" data-dojo-attach-point=\"accelKeyNode\"></td>\n\t<td class=\"dijitReset dijitMenuArrowCell\" role=\"presentation\">\n\t\t<div data-dojo-attach-point=\"arrowWrapper\" style=\"visibility: hidden\">\n\t\t\t<img src=\"${_blankGif}\" alt=\"\" class=\"dijitMenuExpand\"/>\n\t\t\t<span class=\"dijitMenuExpandA11y\">+</span>\n\t\t</div>\n\t</td>\n</tr>\n",
'dojo/text':function(){
define("dojo/text", ["./_base/kernel", "require", "./has", "./_base/xhr"], function(dojo, require, has, xhr){
        // module:
        //              dojo/text

        var getText;
        if( 1 ){
                getText= function(url, sync, load){
                        xhr("GET", {url: url, sync:!!sync, load: load, headers: dojo.config.textPluginHeaders || {}});
                };
        }else{
                // TODOC: only works for dojo AMD loader
                if(require.getText){
                        getText= require.getText;
                }else{
                        console.error("dojo/text plugin failed to load because loader does not support getText");
                }
        }

        var
                theCache = {},

                strip= function(text){
                        //Strips <?xml ...?> declarations so that external SVG and XML
                        //documents can be added to a document without worry. Also, if the string
                        //is an HTML document, only the part inside the body tag is returned.
                        if(text){
                                text= text.replace(/^\s*<\?xml(\s)+version=[\'\"](\d)*.(\d)*[\'\"](\s)*\?>/im, "");
                                var matches= text.match(/<body[^>]*>\s*([\s\S]+)\s*<\/body>/im);
                                if(matches){
                                        text= matches[1];
                                }
                        }else{
                                text = "";
                        }
                        return text;
                },

                notFound = {},

                pending = {};

        dojo.cache = function(/*String||Object*/module, /*String*/url, /*String||Object?*/value){
                // summary:
                //              A getter and setter for storing the string content associated with the
                //              module and url arguments.
                // description:
                //              If module is a string that contains slashes, then it is interpretted as a fully
                //              resolved path (typically a result returned by require.toUrl), and url should not be
                //              provided. This is the preferred signature. If module is a string that does not
                //              contain slashes, then url must also be provided and module and url are used to
                //              call `dojo.moduleUrl()` to generate a module URL. This signature is deprecated.
                //              If value is specified, the cache value for the moduleUrl will be set to
                //              that value. Otherwise, dojo.cache will fetch the moduleUrl and store it
                //              in its internal cache and return that cached value for the URL. To clear
                //              a cache value pass null for value. Since XMLHttpRequest (XHR) is used to fetch the
                //              the URL contents, only modules on the same domain of the page can use this capability.
                //              The build system can inline the cache values though, to allow for xdomain hosting.
                // module: String||Object
                //              If a String with slashes, a fully resolved path; if a String without slashes, the
                //              module name to use for the base part of the URL, similar to module argument
                //              to `dojo.moduleUrl`. If an Object, something that has a .toString() method that
                //              generates a valid path for the cache item. For example, a dojo._Url object.
                // url: String
                //              The rest of the path to append to the path derived from the module argument. If
                //              module is an object, then this second argument should be the "value" argument instead.
                // value: String||Object?
                //              If a String, the value to use in the cache for the module/url combination.
                //              If an Object, it can have two properties: value and sanitize. The value property
                //              should be the value to use in the cache, and sanitize can be set to true or false,
                //              to indicate if XML declarations should be removed from the value and if the HTML
                //              inside a body tag in the value should be extracted as the real value. The value argument
                //              or the value property on the value argument are usually only used by the build system
                //              as it inlines cache content.
                // example:
                //              To ask dojo.cache to fetch content and store it in the cache (the dojo["cache"] style
                //              of call is used to avoid an issue with the build system erroneously trying to intern
                //              this example. To get the build system to intern your dojo.cache calls, use the
                //              "dojo.cache" style of call):
                //              | //If template.html contains "<h1>Hello</h1>" that will be
                //              | //the value for the text variable.
                //              | var text = dojo["cache"]("my.module", "template.html");
                // example:
                //              To ask dojo.cache to fetch content and store it in the cache, and sanitize the input
                //               (the dojo["cache"] style of call is used to avoid an issue with the build system
                //              erroneously trying to intern this example. To get the build system to intern your
                //              dojo.cache calls, use the "dojo.cache" style of call):
                //              | //If template.html contains "<html><body><h1>Hello</h1></body></html>", the
                //              | //text variable will contain just "<h1>Hello</h1>".
                //              | var text = dojo["cache"]("my.module", "template.html", {sanitize: true});
                // example:
                //              Same example as previous, but demonstrates how an object can be passed in as
                //              the first argument, then the value argument can then be the second argument.
                //              | //If template.html contains "<html><body><h1>Hello</h1></body></html>", the
                //              | //text variable will contain just "<h1>Hello</h1>".
                //              | var text = dojo["cache"](new dojo._Url("my/module/template.html"), {sanitize: true});

                //       * (string string [value]) => (module, url, value)
                //       * (object [value])        => (module, value), url defaults to ""
                //
                //       * if module is an object, then it must be convertable to a string
                //       * (module, url) module + (url ? ("/" + url) : "") must be a legal argument to require.toUrl
                //       * value may be a string or an object; if an object then may have the properties "value" and/or "sanitize"
                var key;
                if(typeof module=="string"){
                        if(/\//.test(module)){
                                // module is a version 1.7+ resolved path
                                key = module;
                                value = url;
                        }else{
                                // module is a version 1.6- argument to dojo.moduleUrl
                                key = require.toUrl(module.replace(/\./g, "/") + (url ? ("/" + url) : ""));
                        }
                }else{
                        key = module + "";
                        value = url;
                }
                var
                        val = (value != undefined && typeof value != "string") ? value.value : value,
                        sanitize = value && value.sanitize;

                if(typeof val == "string"){
                        //We have a string, set cache value
                        theCache[key] = val;
                        return sanitize ? strip(val) : val;
                }else if(val === null){
                        //Remove cached value
                        delete theCache[key];
                        return null;
                }else{
                        //Allow cache values to be empty strings. If key property does
                        //not exist, fetch it.
                        if(!(key in theCache)){
                                getText(key, true, function(text){
                                        theCache[key]= text;
                                });
                        }
                        return sanitize ? strip(theCache[key]) : theCache[key];
                }
        };

        return {
                // summary:
                //              This module implements the dojo/text! plugin and the dojo.cache API.
                // description:
                //              We choose to include our own plugin to leverage functionality already contained in dojo
                //              and thereby reduce the size of the plugin compared to various foreign loader implementations.
                //              Also, this allows foreign AMD loaders to be used without their plugins.
                //
                //              CAUTION: this module is designed to optionally function synchronously to support the dojo v1.x synchronous
                //              loader. This feature is outside the scope of the CommonJS plugins specification.

                // the dojo/text caches it's own resources because of dojo.cache
                dynamic: true,

                normalize: function(id, toAbsMid){
                        // id is something like (path may be relative):
                        //
                        //       "path/to/text.html"
                        //       "path/to/text.html!strip"
                        var parts= id.split("!"),
                                url= parts[0];
                        return (/^\./.test(url) ? toAbsMid(url) : url) + (parts[1] ? "!" + parts[1] : "");
                },

                load: function(id, require, load){
                        // id: String
                        //              Path to the resource.
                        // require: Function
                        //              Object that include the function toUrl with given id returns a valid URL from which to load the text.
                        // load: Function
                        //              Callback function which will be called, when the loading finished.

                        // id is something like (path is always absolute):
                        //
                        //       "path/to/text.html"
                        //       "path/to/text.html!strip"
                        var
                                parts= id.split("!"),
                                stripFlag= parts.length>1,
                                absMid= parts[0],
                                url = require.toUrl(parts[0]),
                                requireCacheUrl = "url:" + url,
                                text = notFound,
                                finish = function(text){
                                        load(stripFlag ? strip(text) : text);
                                };
                        if(absMid in theCache){
                                text = theCache[absMid];
                        }else if(requireCacheUrl in require.cache){
                                text = require.cache[requireCacheUrl];
                        }else if(url in theCache){
                                text = theCache[url];
                        }
                        if(text===notFound){
                                if(pending[url]){
                                        pending[url].push(finish);
                                }else{
                                        var pendingList = pending[url] = [finish];
                                        getText(url, !require.async, function(text){
                                                theCache[absMid]= theCache[url]= text;
                                                for(var i = 0; i<pendingList.length;){
                                                        pendingList[i++](text);
                                                }
                                                delete pending[url];
                                        });
                                }
                        }else{
                                finish(text);
                        }
                }
        };

});


},
'url:dijit/form/templates/CheckBox.html':"<div class=\"dijit dijitReset dijitInline\" role=\"presentation\"\n\t><input\n\t \t${!nameAttrSetting} type=\"${type}\" role=\"${type}\" aria-checked=\"false\" ${checkedAttrSetting}\n\t\tclass=\"dijitReset dijitCheckBoxInput\"\n\t\tdata-dojo-attach-point=\"focusNode\"\n\t \tdata-dojo-attach-event=\"onclick:_onClick\"\n/></div>\n",
'dojo/uacss':function(){
define("dojo/uacss", ["./dom-geometry", "./_base/lang", "./ready", "./sniff", "./_base/window"],
        function(geometry, lang, ready, has, baseWindow){

        // module:
        //              dojo/uacss

        /*=====
        return {
                // summary:
                //              Applies pre-set CSS classes to the top-level HTML node, based on:
                //
                //              - browser (ex: dj_ie)
                //              - browser version (ex: dj_ie6)
                //              - box model (ex: dj_contentBox)
                //              - text direction (ex: dijitRtl)
                //
                //              In addition, browser, browser version, and box model are
                //              combined with an RTL flag when browser text is RTL. ex: dj_ie-rtl.
                //
                //              Returns the has() method.
        };
        =====*/

        var
                html = baseWindow.doc.documentElement,
                ie = has("ie"),
                opera = has("opera"),
                maj = Math.floor,
                ff = has("ff"),
                boxModel = geometry.boxModel.replace(/-/,''),

                classes = {
                        "dj_quirks": has("quirks"),

                        // NOTE: Opera not supported by dijit
                        "dj_opera": opera,

                        "dj_khtml": has("khtml"),

                        "dj_webkit": has("webkit"),
                        "dj_safari": has("safari"),
                        "dj_chrome": has("chrome"),

                        "dj_gecko": has("mozilla")
                }; // no dojo unsupported browsers

        if(ie){
                classes["dj_ie"] = true;
                classes["dj_ie" + maj(ie)] = true;
                classes["dj_iequirks"] = has("quirks");
        }
        if(ff){
                classes["dj_ff" + maj(ff)] = true;
        }

        classes["dj_" + boxModel] = true;

        // apply browser, browser version, and box model class names
        var classStr = "";
        for(var clz in classes){
                if(classes[clz]){
                        classStr += clz + " ";
                }
        }
        html.className = lang.trim(html.className + " " + classStr);

        // If RTL mode, then add dj_rtl flag plus repeat existing classes with -rtl extension.
        // We can't run the code below until the <body> tag has loaded (so we can check for dir=rtl).
        // priority is 90 to run ahead of parser priority of 100
        ready(90, function(){
                if(!geometry.isBodyLtr()){
                        var rtlClassStr = "dj_rtl dijitRtl " + classStr.replace(/ /g, "-rtl ");
                        html.className = lang.trim(html.className + " " + rtlClassStr + "dj_rtl dijitRtl " + classStr.replace(/ /g, "-rtl "));
                }
        });
        return has;
});

},
'dijit/Tooltip':function(){
require({cache:{
'url:dijit/templates/Tooltip.html':"<div class=\"dijitTooltip dijitTooltipLeft\" id=\"dojoTooltip\"\n\t><div class=\"dijitTooltipContainer dijitTooltipContents\" data-dojo-attach-point=\"containerNode\" role='alert'></div\n\t><div class=\"dijitTooltipConnector\" data-dojo-attach-point=\"connectorNode\"></div\n></div>\n"}});
define("dijit/Tooltip", [
        "dojo/_base/array", // array.forEach array.indexOf array.map
        "dojo/_base/declare", // declare
        "dojo/_base/fx", // fx.fadeIn fx.fadeOut
        "dojo/dom", // dom.byId
        "dojo/dom-class", // domClass.add
        "dojo/dom-geometry", // domGeometry.position
        "dojo/dom-style", // domStyle.set, domStyle.get
        "dojo/_base/lang", // lang.hitch lang.isArrayLike
        "dojo/mouse",
        "dojo/on",
        "dojo/sniff", // has("ie")
        "./_base/manager",      // manager.defaultDuration
        "./place",
        "./_Widget",
        "./_TemplatedMixin",
        "./BackgroundIframe",
        "dojo/text!./templates/Tooltip.html",
        "./main"                // sets dijit.showTooltip etc. for back-compat
], function(array, declare, fx, dom, domClass, domGeometry, domStyle, lang, mouse, on, has,
                        manager, place, _Widget, _TemplatedMixin, BackgroundIframe, template, dijit){

        // module:
        //              dijit/Tooltip


        // TODO: Tooltip should really share more positioning code with TooltipDialog, like:
        //              - the orient() method
        //              - the connector positioning code in show()
        //              - the dijitTooltip[Dialog] class
        //
        // The problem is that Tooltip's implementation supplies it's own <iframe> and interacts directly
        // with dijit/place, rather than going through dijit/popup like TooltipDialog and other popups (ex: Menu).

        var MasterTooltip = declare("dijit._MasterTooltip", [_Widget, _TemplatedMixin], {
                // summary:
                //              Internal widget that holds the actual tooltip markup,
                //              which occurs once per page.
                //              Called by Tooltip widgets which are just containers to hold
                //              the markup
                // tags:
                //              protected

                // duration: Integer
                //              Milliseconds to fade in/fade out
                duration: manager.defaultDuration,

                templateString: template,

                postCreate: function(){
                        this.ownerDocumentBody.appendChild(this.domNode);

                        this.bgIframe = new BackgroundIframe(this.domNode);

                        // Setup fade-in and fade-out functions.
                        this.fadeIn = fx.fadeIn({ node: this.domNode, duration: this.duration, onEnd: lang.hitch(this, "_onShow") });
                        this.fadeOut = fx.fadeOut({ node: this.domNode, duration: this.duration, onEnd: lang.hitch(this, "_onHide") });
                },

                show: function(innerHTML, aroundNode, position, rtl, textDir){
                        // summary:
                        //              Display tooltip w/specified contents to right of specified node
                        //              (To left if there's no space on the right, or if rtl == true)
                        // innerHTML: String
                        //              Contents of the tooltip
                        // aroundNode: DomNode|dijit/place.__Rectangle
                        //              Specifies that tooltip should be next to this node / area
                        // position: String[]?
                        //              List of positions to try to position tooltip (ex: ["right", "above"])
                        // rtl: Boolean?
                        //              Corresponds to `WidgetBase.dir` attribute, where false means "ltr" and true
                        //              means "rtl"; specifies GUI direction, not text direction.
                        // textDir: String?
                        //              Corresponds to `WidgetBase.textdir` attribute; specifies direction of text.


                        if(this.aroundNode && this.aroundNode === aroundNode && this.containerNode.innerHTML == innerHTML){
                                return;
                        }

                        if(this.fadeOut.status() == "playing"){
                                // previous tooltip is being hidden; wait until the hide completes then show new one
                                this._onDeck=arguments;
                                return;
                        }
                        this.containerNode.innerHTML=innerHTML;

                        if(textDir){
                                this.set("textDir", textDir);
                        }

                        this.containerNode.align = rtl? "right" : "left"; //fix the text alignment

                        var pos = place.around(this.domNode, aroundNode,
                                position && position.length ? position : Tooltip.defaultPosition, !rtl, lang.hitch(this, "orient"));

                        // Position the tooltip connector for middle alignment.
                        // This could not have been done in orient() since the tooltip wasn't positioned at that time.
                        var aroundNodeCoords = pos.aroundNodePos;
                        if(pos.corner.charAt(0) == 'M' && pos.aroundCorner.charAt(0) == 'M'){
                                this.connectorNode.style.top = aroundNodeCoords.y + ((aroundNodeCoords.h - this.connectorNode.offsetHeight) >> 1) - pos.y + "px";
                                this.connectorNode.style.left = "";
                        }else if(pos.corner.charAt(1) == 'M' && pos.aroundCorner.charAt(1) == 'M'){
                                this.connectorNode.style.left = aroundNodeCoords.x + ((aroundNodeCoords.w - this.connectorNode.offsetWidth) >> 1) - pos.x + "px";
                        }else{
                                // Not *-centered, but just above/below/after/before
                                this.connectorNode.style.left = "";
                                this.connectorNode.style.top = "";
                        }

                        // show it
                        domStyle.set(this.domNode, "opacity", 0);
                        this.fadeIn.play();
                        this.isShowingNow = true;
                        this.aroundNode = aroundNode;
                },

                orient: function(/*DomNode*/ node, /*String*/ aroundCorner, /*String*/ tooltipCorner, /*Object*/ spaceAvailable, /*Object*/ aroundNodeCoords){
                        // summary:
                        //              Private function to set CSS for tooltip node based on which position it's in.
                        //              This is called by the dijit popup code.   It will also reduce the tooltip's
                        //              width to whatever width is available
                        // tags:
                        //              protected

                        this.connectorNode.style.top = ""; //reset to default

                        var heightAvailable = spaceAvailable.h,
                                widthAvailable = spaceAvailable.w;

                        node.className = "dijitTooltip " +
                                {
                                        "MR-ML": "dijitTooltipRight",
                                        "ML-MR": "dijitTooltipLeft",
                                        "TM-BM": "dijitTooltipAbove",
                                        "BM-TM": "dijitTooltipBelow",
                                        "BL-TL": "dijitTooltipBelow dijitTooltipABLeft",
                                        "TL-BL": "dijitTooltipAbove dijitTooltipABLeft",
                                        "BR-TR": "dijitTooltipBelow dijitTooltipABRight",
                                        "TR-BR": "dijitTooltipAbove dijitTooltipABRight",
                                        "BR-BL": "dijitTooltipRight",
                                        "BL-BR": "dijitTooltipLeft"
                                }[aroundCorner + "-" + tooltipCorner];

                        // reset width; it may have been set by orient() on a previous tooltip show()
                        this.domNode.style.width = "auto";

                        // Reduce tooltip's width to the amount of width available, so that it doesn't overflow screen.
                        // Note that sometimes widthAvailable is negative, but we guard against setting style.width to a
                        // negative number since that causes an exception on IE.
                        var size = domGeometry.position(this.domNode);
                        if(has("ie") == 9){
                                // workaround strange IE9 bug where setting width to offsetWidth causes words to wrap
                                size.w += 2;
                        }

                        var width = Math.min((Math.max(widthAvailable,1)), size.w);

                        domGeometry.setMarginBox(this.domNode, {w: width});

                        // Reposition the tooltip connector.
                        if(tooltipCorner.charAt(0) == 'B' && aroundCorner.charAt(0) == 'B'){
                                var bb = domGeometry.position(node);
                                var tooltipConnectorHeight = this.connectorNode.offsetHeight;
                                if(bb.h > heightAvailable){
                                        // The tooltip starts at the top of the page and will extend past the aroundNode
                                        var aroundNodePlacement = heightAvailable - ((aroundNodeCoords.h + tooltipConnectorHeight) >> 1);
                                        this.connectorNode.style.top = aroundNodePlacement + "px";
                                        this.connectorNode.style.bottom = "";
                                }else{
                                        // Align center of connector with center of aroundNode, except don't let bottom
                                        // of connector extend below bottom of tooltip content, or top of connector
                                        // extend past top of tooltip content
                                        this.connectorNode.style.bottom = Math.min(
                                                Math.max(aroundNodeCoords.h/2 - tooltipConnectorHeight/2, 0),
                                                bb.h - tooltipConnectorHeight) + "px";
                                        this.connectorNode.style.top = "";
                                }
                        }else{
                                // reset the tooltip back to the defaults
                                this.connectorNode.style.top = "";
                                this.connectorNode.style.bottom = "";
                        }

                        return Math.max(0, size.w - widthAvailable);
                },

                _onShow: function(){
                        // summary:
                        //              Called at end of fade-in operation
                        // tags:
                        //              protected
                        if(has("ie")){
                                // the arrow won't show up on a node w/an opacity filter
                                this.domNode.style.filter="";
                        }
                },

                hide: function(aroundNode){
                        // summary:
                        //              Hide the tooltip

                        if(this._onDeck && this._onDeck[1] == aroundNode){
                                // this hide request is for a show() that hasn't even started yet;
                                // just cancel the pending show()
                                this._onDeck=null;
                        }else if(this.aroundNode === aroundNode){
                                // this hide request is for the currently displayed tooltip
                                this.fadeIn.stop();
                                this.isShowingNow = false;
                                this.aroundNode = null;
                                this.fadeOut.play();
                        }else{
                                // just ignore the call, it's for a tooltip that has already been erased
                        }
                },

                _onHide: function(){
                        // summary:
                        //              Called at end of fade-out operation
                        // tags:
                        //              protected

                        this.domNode.style.cssText="";  // to position offscreen again
                        this.containerNode.innerHTML="";
                        if(this._onDeck){
                                // a show request has been queued up; do it now
                                this.show.apply(this, this._onDeck);
                                this._onDeck=null;
                        }
                },

                _setAutoTextDir: function(/*Object*/node){
                        // summary:
                        //              Resolve "auto" text direction for children nodes
                        // tags:
                        //              private

                        this.applyTextDir(node, has("ie") ? node.outerText : node.textContent);
                        array.forEach(node.children, function(child){this._setAutoTextDir(child); }, this);
                },

                _setTextDirAttr: function(/*String*/ textDir){
                        // summary:
                        //              Setter for textDir.
                        // description:
                        //              Users shouldn't call this function; they should be calling
                        //              set('textDir', value)
                        // tags:
                        //              private

                        this._set("textDir", textDir);

                        if (textDir == "auto"){
                                this._setAutoTextDir(this.containerNode);
                        }else{
                                this.containerNode.dir = this.textDir;
                        }
                }
        });

        dijit.showTooltip = function(innerHTML, aroundNode, position, rtl, textDir){
                // summary:
                //              Static method to display tooltip w/specified contents in specified position.
                //              See description of dijit/Tooltip.defaultPosition for details on position parameter.
                //              If position is not specified then dijit/Tooltip.defaultPosition is used.
                // innerHTML: String
                //              Contents of the tooltip
                // aroundNode: place.__Rectangle
                //              Specifies that tooltip should be next to this node / area
                // position: String[]?
                //              List of positions to try to position tooltip (ex: ["right", "above"])
                // rtl: Boolean?
                //              Corresponds to `WidgetBase.dir` attribute, where false means "ltr" and true
                //              means "rtl"; specifies GUI direction, not text direction.
                // textDir: String?
                //              Corresponds to `WidgetBase.textdir` attribute; specifies direction of text.

                // After/before don't work, but for back-compat convert them to the working after-centered, before-centered.
                // Possibly remove this in 2.0.   Alternately, get before/after to work.
                if(position){
                        position = array.map(position, function(val){
                                return {after: "after-centered", before: "before-centered"}[val] || val;
                        });
                }

                if(!Tooltip._masterTT){ dijit._masterTT = Tooltip._masterTT = new MasterTooltip(); }
                return Tooltip._masterTT.show(innerHTML, aroundNode, position, rtl, textDir);
        };

        dijit.hideTooltip = function(aroundNode){
                // summary:
                //              Static method to hide the tooltip displayed via showTooltip()
                return Tooltip._masterTT && Tooltip._masterTT.hide(aroundNode);
        };

        var Tooltip = declare("dijit.Tooltip", _Widget, {
                // summary:
                //              Pops up a tooltip (a help message) when you hover over a node.
                //              Also provides static show() and hide() methods that can be used without instantiating a dijit/Tooltip.

                // label: String
                //              Text to display in the tooltip.
                //              Specified as innerHTML when creating the widget from markup.
                label: "",

                // showDelay: Integer
                //              Number of milliseconds to wait after hovering over/focusing on the object, before
                //              the tooltip is displayed.
                showDelay: 400,

                // connectId: String|String[]|DomNode|DomNode[]
                //              Id of domNode(s) to attach the tooltip to.
                //              When user hovers over specified dom node(s), the tooltip will appear.
                connectId: [],

                // position: String[]
                //              See description of `dijit/Tooltip.defaultPosition` for details on position parameter.
                position: [],

                // selector: String?
                //              CSS expression to apply this Tooltip to descendants of connectIds, rather than to
                //              the nodes specified by connectIds themselves.    Useful for applying a Tooltip to
                //              a range of rows in a table, tree, etc.   Use in conjunction with getContent() parameter.
                //              Ex: connectId: myTable, selector: "tr", getContent: function(node){ return ...; }
                //
                //              The application must require() an appropriate level of dojo/query to handle the selector.
                selector: "",

                // TODO: in 2.0 remove support for multiple connectIds.   selector gives the same effect.
                // So, change connectId to a "", remove addTarget()/removeTarget(), etc.

                _setConnectIdAttr: function(/*String|String[]}DomNode|DomNode[]*/ newId){
                        // summary:
                        //              Connect to specified node(s)

                        // Remove connections to old nodes (if there are any)
                        array.forEach(this._connections || [], function(nested){
                                array.forEach(nested, function(handle){ handle.remove(); });
                        }, this);

                        // Make array of id's to connect to, excluding entries for nodes that don't exist yet, see startup()
                        this._connectIds = array.filter(lang.isArrayLike(newId) ? newId : (newId ? [newId] : []),
                                        function(id){ return dom.byId(id, this.ownerDocument); }, this);

                        // Make connections
                        this._connections = array.map(this._connectIds, function(id){
                                var node = dom.byId(id, this.ownerDocument),
                                        selector = this.selector,
                                        delegatedEvent = selector ?
                                                function(eventType){ return on.selector(selector, eventType); } :
                                                function(eventType){ return eventType; },
                                        self = this;
                                return [
                                        on(node, delegatedEvent(mouse.enter), function(){
                                                self._onHover(this);
                                        }),
                                        on(node, delegatedEvent("focusin"), function(){
                                                self._onHover(this);
                                        }),
                                        on(node, delegatedEvent(mouse.leave), lang.hitch(self, "_onUnHover")),
                                        on(node, delegatedEvent("focusout"), lang.hitch(self, "_onUnHover"))
                                ];
                        }, this);

                        this._set("connectId", newId);
                },

                addTarget: function(/*OomNode|String*/ node){
                        // summary:
                        //              Attach tooltip to specified node if it's not already connected

                        // TODO: remove in 2.0 and just use set("connectId", ...) interface

                        var id = node.id || node;
                        if(array.indexOf(this._connectIds, id) == -1){
                                this.set("connectId", this._connectIds.concat(id));
                        }
                },

                removeTarget: function(/*DomNode|String*/ node){
                        // summary:
                        //              Detach tooltip from specified node

                        // TODO: remove in 2.0 and just use set("connectId", ...) interface

                        var id = node.id || node,       // map from DOMNode back to plain id string
                                idx = array.indexOf(this._connectIds, id);
                        if(idx >= 0){
                                // remove id (modifies original this._connectIds but that's OK in this case)
                                this._connectIds.splice(idx, 1);
                                this.set("connectId", this._connectIds);
                        }
                },

                buildRendering: function(){
                        this.inherited(arguments);
                        domClass.add(this.domNode,"dijitTooltipData");
                },

                startup: function(){
                        this.inherited(arguments);

                        // If this tooltip was created in a template, or for some other reason the specified connectId[s]
                        // didn't exist during the widget's initialization, then connect now.
                        var ids = this.connectId;
                        array.forEach(lang.isArrayLike(ids) ? ids : [ids], this.addTarget, this);
                },

                getContent: function(/*DomNode*/ node){
                        // summary:
                        //              User overridable function that return the text to display in the tooltip.
                        // tags:
                        //              extension
                        return this.label || this.domNode.innerHTML;
                },

                _onHover: function(/*DomNode*/ target){
                        // summary:
                        //              Despite the name of this method, it actually handles both hover and focus
                        //              events on the target node, setting a timer to show the tooltip.
                        // tags:
                        //              private
                        if(!this._showTimer){
                                this._showTimer = this.defer(function(){ this.open(target); }, this.showDelay);
                        }
                },

                _onUnHover: function(){
                        // summary:
                        //              Despite the name of this method, it actually handles both mouseleave and blur
                        //              events on the target node, hiding the tooltip.
                        // tags:
                        //              private

                        if(this._showTimer){
                                this._showTimer.remove();
                                delete this._showTimer;
                        }
                        this.close();
                },

                open: function(/*DomNode*/ target){
                        // summary:
                        //              Display the tooltip; usually not called directly.
                        // tags:
                        //              private

                        if(this._showTimer){
                                this._showTimer.remove();
                                delete this._showTimer;
                        }

                        var content = this.getContent(target);
                        if(!content){
                                return;
                        }
                        Tooltip.show(content, target, this.position, !this.isLeftToRight(), this.textDir);

                        this._connectNode = target;             // _connectNode means "tooltip currently displayed for this node"
                        this.onShow(target, this.position);
                },

                close: function(){
                        // summary:
                        //              Hide the tooltip or cancel timer for show of tooltip
                        // tags:
                        //              private

                        if(this._connectNode){
                                // if tooltip is currently shown
                                Tooltip.hide(this._connectNode);
                                delete this._connectNode;
                                this.onHide();
                        }
                        if(this._showTimer){
                                // if tooltip is scheduled to be shown (after a brief delay)
                                this._showTimer.remove();
                                delete this._showTimer;
                        }
                },

                onShow: function(/*===== target, position =====*/){
                        // summary:
                        //              Called when the tooltip is shown
                        // tags:
                        //              callback
                },

                onHide: function(){
                        // summary:
                        //              Called when the tooltip is hidden
                        // tags:
                        //              callback
                },

                destroy: function(){
                        this.close();

                        // Remove connections manually since they aren't registered to be removed by _WidgetBase
                        array.forEach(this._connections || [], function(nested){
                                array.forEach(nested, function(handle){ handle.remove(); });
                        }, this);

                        this.inherited(arguments);
                }
        });

        Tooltip._MasterTooltip = MasterTooltip;         // for monkey patching
        Tooltip.show = dijit.showTooltip;               // export function through module return value
        Tooltip.hide = dijit.hideTooltip;               // export function through module return value

        Tooltip.defaultPosition = ["after-centered", "before-centered"];

        /*=====
        lang.mixin(Tooltip, {
                 // defaultPosition: String[]
                 //             This variable controls the position of tooltips, if the position is not specified to
                 //             the Tooltip widget or *TextBox widget itself.  It's an array of strings with the values
                 //             possible for `dijit/place.around()`.   The recommended values are:
                 //
                 //             - before-centered: centers tooltip to the left of the anchor node/widget, or to the right
                 //               in the case of RTL scripts like Hebrew and Arabic
                 //             - after-centered: centers tooltip to the right of the anchor node/widget, or to the left
                 //               in the case of RTL scripts like Hebrew and Arabic
                 //             - above-centered: tooltip is centered above anchor node
                 //             - below-centered: tooltip is centered above anchor node
                 //
                 //             The list is positions is tried, in order, until a position is found where the tooltip fits
                 //             within the viewport.
                 //
                 //             Be careful setting this parameter.  A value of "above-centered" may work fine until the user scrolls
                 //             the screen so that there's no room above the target node.   Nodes with drop downs, like
                 //             DropDownButton or FilteringSelect, are especially problematic, in that you need to be sure
                 //             that the drop down and tooltip don't overlap, even when the viewport is scrolled so that there
                 //             is only room below (or above) the target node, but not both.
         });
        =====*/
        return Tooltip;
});

},
'dojo/string':function(){
define("dojo/string", [
        "./_base/kernel",       // kernel.global
        "./_base/lang"
], function(kernel, lang){

// module:
//              dojo/string

var string = {
        // summary:
        //              String utilities for Dojo
};
lang.setObject("dojo.string", string);

string.rep = function(/*String*/str, /*Integer*/num){
        // summary:
        //              Efficiently replicate a string `n` times.
        // str:
        //              the string to replicate
        // num:
        //              number of times to replicate the string

        if(num <= 0 || !str){ return ""; }

        var buf = [];
        for(;;){
                if(num & 1){
                        buf.push(str);
                }
                if(!(num >>= 1)){ break; }
                str += str;
        }
        return buf.join("");    // String
};

string.pad = function(/*String*/text, /*Integer*/size, /*String?*/ch, /*Boolean?*/end){
        // summary:
        //              Pad a string to guarantee that it is at least `size` length by
        //              filling with the character `ch` at either the start or end of the
        //              string. Pads at the start, by default.
        // text:
        //              the string to pad
        // size:
        //              length to provide padding
        // ch:
        //              character to pad, defaults to '0'
        // end:
        //              adds padding at the end if true, otherwise pads at start
        // example:
        //      |       // Fill the string to length 10 with "+" characters on the right.  Yields "Dojo++++++".
        //      |       string.pad("Dojo", 10, "+", true);

        if(!ch){
                ch = '0';
        }
        var out = String(text),
                pad = string.rep(ch, Math.ceil((size - out.length) / ch.length));
        return end ? out + pad : pad + out;     // String
};

string.substitute = function(   /*String*/              template,
                                                                        /*Object|Array*/map,
                                                                        /*Function?*/   transform,
                                                                        /*Object?*/             thisObject){
        // summary:
        //              Performs parameterized substitutions on a string. Throws an
        //              exception if any parameter is unmatched.
        // template:
        //              a string with expressions in the form `${key}` to be replaced or
        //              `${key:format}` which specifies a format function. keys are case-sensitive.
        // map:
        //              hash to search for substitutions
        // transform:
        //              a function to process all parameters before substitution takes
        //              place, e.g. mylib.encodeXML
        // thisObject:
        //              where to look for optional format function; default to the global
        //              namespace
        // example:
        //              Substitutes two expressions in a string from an Array or Object
        //      |       // returns "File 'foo.html' is not found in directory '/temp'."
        //      |       // by providing substitution data in an Array
        //      |       string.substitute(
        //      |               "File '${0}' is not found in directory '${1}'.",
        //      |               ["foo.html","/temp"]
        //      |       );
        //      |
        //      |       // also returns "File 'foo.html' is not found in directory '/temp'."
        //      |       // but provides substitution data in an Object structure.  Dotted
        //      |       // notation may be used to traverse the structure.
        //      |       string.substitute(
        //      |               "File '${name}' is not found in directory '${info.dir}'.",
        //      |               { name: "foo.html", info: { dir: "/temp" } }
        //      |       );
        // example:
        //              Use a transform function to modify the values:
        //      |       // returns "file 'foo.html' is not found in directory '/temp'."
        //      |       string.substitute(
        //      |               "${0} is not found in ${1}.",
        //      |               ["foo.html","/temp"],
        //      |               function(str){
        //      |                       // try to figure out the type
        //      |                       var prefix = (str.charAt(0) == "/") ? "directory": "file";
        //      |                       return prefix + " '" + str + "'";
        //      |               }
        //      |       );
        // example:
        //              Use a formatter
        //      |       // returns "thinger -- howdy"
        //      |       string.substitute(
        //      |               "${0:postfix}", ["thinger"], null, {
        //      |                       postfix: function(value, key){
        //      |                               return value + " -- howdy";
        //      |                       }
        //      |               }
        //      |       );

        thisObject = thisObject || kernel.global;
        transform = transform ?
                lang.hitch(thisObject, transform) : function(v){ return v; };

        return template.replace(/\$\{([^\s\:\}]+)(?:\:([^\s\:\}]+))?\}/g,
                function(match, key, format){
                        var value = lang.getObject(key, false, map);
                        if(format){
                                value = lang.getObject(format, false, thisObject).call(thisObject, value, key);
                        }
                        return transform(value, key).toString();
                }); // String
};

string.trim = String.prototype.trim ?
        lang.trim : // aliasing to the native function
        function(str){
                str = str.replace(/^\s+/, '');
                for(var i = str.length - 1; i >= 0; i--){
                        if(/\S/.test(str.charAt(i))){
                                str = str.substring(0, i + 1);
                                break;
                        }
                }
                return str;
        };

/*=====
 string.trim = function(str){
         // summary:
         //             Trims whitespace from both sides of the string
         // str: String
         //             String to be trimmed
         // returns: String
         //             Returns the trimmed string
         // description:
         //             This version of trim() was taken from [Steven Levithan's blog](http://blog.stevenlevithan.com/archives/faster-trim-javascript).
         //             The short yet performant version of this function is dojo.trim(),
         //             which is part of Dojo base.  Uses String.prototype.trim instead, if available.
         return "";     // String
 };
 =====*/

        return string;
});

},
'url:dijit/templates/MenuSeparator.html':"<tr class=\"dijitMenuSeparator\">\n\t<td class=\"dijitMenuSeparatorIconCell\">\n\t\t<div class=\"dijitMenuSeparatorTop\"></div>\n\t\t<div class=\"dijitMenuSeparatorBottom\"></div>\n\t</td>\n\t<td colspan=\"3\" class=\"dijitMenuSeparatorLabelCell\">\n\t\t<div class=\"dijitMenuSeparatorTop dijitMenuSeparatorLabel\"></div>\n\t\t<div class=\"dijitMenuSeparatorBottom\"></div>\n\t</td>\n</tr>",
'dijit/dijit':function(){
define("dijit/dijit", [
        "./main",
        "./_base",
        "dojo/parser",
        "./_Widget",
        "./_TemplatedMixin",
        "./_Container",
        "./layout/_LayoutWidget",
        "./form/_FormWidget",
        "./form/_FormValueWidget"
], function(dijit){

        // module:
        //              dijit/dijit

        /*=====
        return {
                // summary:
                //              A roll-up for common dijit methods
                //              All the stuff in _base (these are the function that are guaranteed available without an explicit dojo.require)
                //              And some other stuff that we tend to pull in all the time anyway
        };
        =====*/

        return dijit;
});

},
'dijit/form/DropDownButton':function(){
require({cache:{
'url:dijit/form/templates/DropDownButton.html':"<span class=\"dijit dijitReset dijitInline\"\n\t><span class='dijitReset dijitInline dijitButtonNode'\n\t\tdata-dojo-attach-event=\"ondijitclick:_onClick\" data-dojo-attach-point=\"_buttonNode\"\n\t\t><span class=\"dijitReset dijitStretch dijitButtonContents\"\n\t\t\tdata-dojo-attach-point=\"focusNode,titleNode,_arrowWrapperNode\"\n\t\t\trole=\"button\" aria-haspopup=\"true\" aria-labelledby=\"${id}_label\"\n\t\t\t><span class=\"dijitReset dijitInline dijitIcon\"\n\t\t\t\tdata-dojo-attach-point=\"iconNode\"\n\t\t\t></span\n\t\t\t><span class=\"dijitReset dijitInline dijitButtonText\"\n\t\t\t\tdata-dojo-attach-point=\"containerNode,_popupStateNode\"\n\t\t\t\tid=\"${id}_label\"\n\t\t\t></span\n\t\t\t><span class=\"dijitReset dijitInline dijitArrowButtonInner\"></span\n\t\t\t><span class=\"dijitReset dijitInline dijitArrowButtonChar\">&#9660;</span\n\t\t></span\n\t></span\n\t><input ${!nameAttrSetting} type=\"${type}\" value=\"${value}\" class=\"dijitOffScreen\" tabIndex=\"-1\"\n\t\tdata-dojo-attach-point=\"valueNode\" role=\"presentation\"\n/></span>\n"}});
define("dijit/form/DropDownButton", [
        "dojo/_base/declare", // declare
        "dojo/_base/lang",      // hitch
        "dojo/query", // query
        "../registry",  // registry.byNode
        "../popup",             // dijit.popup2.hide
        "./Button",
        "../_Container",
        "../_HasDropDown",
        "dojo/text!./templates/DropDownButton.html"
], function(declare, lang, query, registry, popup, Button, _Container, _HasDropDown, template){

// module:
//              dijit/form/DropDownButton


return declare("dijit.form.DropDownButton", [Button, _Container, _HasDropDown], {
        // summary:
        //              A button with a drop down
        //
        // example:
        // |    <button data-dojo-type="dijit/form/DropDownButton">
        // |            Hello world
        // |            <div data-dojo-type="dijit/Menu">...</div>
        // |    </button>
        //
        // example:
        // |    var button1 = new DropDownButton({ label: "hi", dropDown: new dijit.Menu(...) });
        // |    win.body().appendChild(button1);
        //

        baseClass : "dijitDropDownButton",

        templateString: template,

        _fillContent: function(){
                // Overrides Button._fillContent().
                //
                // My inner HTML contains both the button contents and a drop down widget, like
                // <DropDownButton>  <span>push me</span>  <Menu> ... </Menu> </DropDownButton>
                // The first node is assumed to be the button content. The widget is the popup.

                if(this.srcNodeRef){ // programatically created buttons might not define srcNodeRef
                        //FIXME: figure out how to filter out the widget and use all remaining nodes as button
                        //      content, not just nodes[0]
                        var nodes = query("*", this.srcNodeRef);
                        this.inherited(arguments, [nodes[0]]);

                        // save pointer to srcNode so we can grab the drop down widget after it's instantiated
                        this.dropDownContainer = this.srcNodeRef;
                }
        },

        startup: function(){
                if(this._started){ return; }

                // the child widget from srcNodeRef is the dropdown widget.  Insert it in the page DOM,
                // make it invisible, and store a reference to pass to the popup code.
                if(!this.dropDown && this.dropDownContainer){
                        var dropDownNode = query("[widgetId]", this.dropDownContainer)[0];
                        this.dropDown = registry.byNode(dropDownNode);
                        delete this.dropDownContainer;
                }
                if(this.dropDown){
                        popup.hide(this.dropDown);
                }

                this.inherited(arguments);
        },

        isLoaded: function(){
                // Returns whether or not we are loaded - if our dropdown has an href,
                // then we want to check that.
                var dropDown = this.dropDown;
                return (!!dropDown && (!dropDown.href || dropDown.isLoaded));
        },

        loadDropDown: function(/*Function*/ callback){
                // Default implementation assumes that drop down already exists,
                // but hasn't loaded it's data (ex: ContentPane w/href).
                // App must override if the drop down is lazy-created.
                var dropDown = this.dropDown;
                var handler = dropDown.on("load", lang.hitch(this, function(){
                        handler.remove();
                        callback();
                }));
                dropDown.refresh();             // tell it to load
        },

        isFocusable: function(){
                // Overridden so that focus is handled by the _HasDropDown mixin, not by
                // the _FormWidget mixin.
                return this.inherited(arguments) && !this._mouseDown;
        }
});

});

},
'dijit/form/_FormValueMixin':function(){
define("dijit/form/_FormValueMixin", [
        "dojo/_base/declare", // declare
        "dojo/dom-attr", // domAttr.set
        "dojo/keys", // keys.ESCAPE
        "dojo/sniff", // has("ie"), has("quirks")
        "./_FormWidgetMixin"
], function(declare, domAttr, keys, has, _FormWidgetMixin){

        // module:
        //              dijit/form/_FormValueMixin

        return declare("dijit.form._FormValueMixin", _FormWidgetMixin, {
                // summary:
                //              Mixin for widgets corresponding to native HTML elements such as `<input>` or `<select>`
                //              that have user changeable values.
                // description:
                //              Each _FormValueMixin represents a single input value, and has a (possibly hidden) `<input>` element,
                //              to which it serializes it's input value, so that form submission (either normal submission or via FormBind?)
                //              works as expected.

                // readOnly: Boolean
                //              Should this widget respond to user input?
                //              In markup, this is specified as "readOnly".
                //              Similar to disabled except readOnly form values are submitted.
                readOnly: false,

                _setReadOnlyAttr: function(/*Boolean*/ value){
                        domAttr.set(this.focusNode, 'readOnly', value);
                        this._set("readOnly", value);
                },

                postCreate: function(){
                        this.inherited(arguments);

                        if(has("ie")){ // IE won't stop the event with keypress
                                this.connect(this.focusNode || this.domNode, "onkeydown", this._onKeyDown);
                        }
                        // Update our reset value if it hasn't yet been set (because this.set()
                        // is only called when there *is* a value)
                        if(this._resetValue === undefined){
                                this._lastValueReported = this._resetValue = this.value;
                        }
                },

                _setValueAttr: function(/*anything*/ newValue, /*Boolean?*/ priorityChange){
                        // summary:
                        //              Hook so set('value', value) works.
                        // description:
                        //              Sets the value of the widget.
                        //              If the value has changed, then fire onChange event, unless priorityChange
                        //              is specified as null (or false?)
                        this._handleOnChange(newValue, priorityChange);
                },

                _handleOnChange: function(/*anything*/ newValue, /*Boolean?*/ priorityChange){
                        // summary:
                        //              Called when the value of the widget has changed.  Saves the new value in this.value,
                        //              and calls onChange() if appropriate.   See _FormWidget._handleOnChange() for details.
                        this._set("value", newValue);
                        this.inherited(arguments);
                },

                undo: function(){
                        // summary:
                        //              Restore the value to the last value passed to onChange
                        this._setValueAttr(this._lastValueReported, false);
                },

                reset: function(){
                        // summary:
                        //              Reset the widget's value to what it was at initialization time
                        this._hasBeenBlurred = false;
                        this._setValueAttr(this._resetValue, true);
                },

                _onKeyDown: function(e){
                        if(e.keyCode == keys.ESCAPE && !(e.ctrlKey || e.altKey || e.metaKey)){
                                if(has("ie") < 9 || (has("ie") && has("quirks"))){
                                        e.preventDefault(); // default behavior needs to be stopped here since keypress is too late
                                        var node = e.srcElement,
                                                te = node.ownerDocument.createEventObject();
                                        te.keyCode = keys.ESCAPE;
                                        te.shiftKey = e.shiftKey;
                                        node.fireEvent('onkeypress', te);
                                }
                        }
                }
        });
});

},
'dijit/form/_FormWidgetMixin':function(){
define("dijit/form/_FormWidgetMixin", [
        "dojo/_base/array", // array.forEach
        "dojo/_base/declare", // declare
        "dojo/dom-attr", // domAttr.set
        "dojo/dom-style", // domStyle.get
        "dojo/_base/lang", // lang.hitch lang.isArray
        "dojo/mouse", // mouse.isLeft
        "dojo/sniff", // has("webkit")
        "dojo/window", // winUtils.scrollIntoView
        "../a11y"       // a11y.hasDefaultTabStop
], function(array, declare, domAttr, domStyle, lang, mouse, has, winUtils, a11y){

// module:
//              dijit/form/_FormWidgetMixin

return declare("dijit.form._FormWidgetMixin", null, {
        // summary:
        //              Mixin for widgets corresponding to native HTML elements such as `<checkbox>` or `<button>`,
        //              which can be children of a `<form>` node or a `dijit/form/Form` widget.
        //
        // description:
        //              Represents a single HTML element.
        //              All these widgets should have these attributes just like native HTML input elements.
        //              You can set them during widget construction or afterwards, via `dijit/_WidgetBase.set()`.
        //
        //              They also share some common methods.

        // name: [const] String
        //              Name used when submitting form; same as "name" attribute or plain HTML elements
        name: "",

        // alt: String
        //              Corresponds to the native HTML `<input>` element's attribute.
        alt: "",

        // value: String
        //              Corresponds to the native HTML `<input>` element's attribute.
        value: "",

        // type: [const] String
        //              Corresponds to the native HTML `<input>` element's attribute.
        type: "text",

        // type: String
        //              Apply aria-label in markup to the widget's focusNode
        "aria-label": "focusNode",

        // tabIndex: String
        //              Order fields are traversed when user hits the tab key
        tabIndex: "0",
        _setTabIndexAttr: "focusNode",  // force copy even when tabIndex default value, needed since Button is <span>

        // disabled: Boolean
        //              Should this widget respond to user input?
        //              In markup, this is specified as "disabled='disabled'", or just "disabled".
        disabled: false,

        // intermediateChanges: Boolean
        //              Fires onChange for each value change or only on demand
        intermediateChanges: false,

        // scrollOnFocus: Boolean
        //              On focus, should this widget scroll into view?
        scrollOnFocus: true,

        // Override _WidgetBase mapping id to this.domNode, needs to be on focusNode so <label> etc.
        // works with screen reader
        _setIdAttr: "focusNode",

        _setDisabledAttr: function(/*Boolean*/ value){
                this._set("disabled", value);
                domAttr.set(this.focusNode, 'disabled', value);
                if(this.valueNode){
                        domAttr.set(this.valueNode, 'disabled', value);
                }
                this.focusNode.setAttribute("aria-disabled", value ? "true" : "false");

                if(value){
                        // reset these, because after the domNode is disabled, we can no longer receive
                        // mouse related events, see #4200
                        this._set("hovering", false);
                        this._set("active", false);

                        // clear tab stop(s) on this widget's focusable node(s)  (ComboBox has two focusable nodes)
                        var attachPointNames = "tabIndex" in this.attributeMap ? this.attributeMap.tabIndex :
                                ("_setTabIndexAttr" in this) ? this._setTabIndexAttr : "focusNode";
                        array.forEach(lang.isArray(attachPointNames) ? attachPointNames : [attachPointNames], function(attachPointName){
                                var node = this[attachPointName];
                                // complex code because tabIndex=-1 on a <div> doesn't work on FF
                                if(has("webkit") || a11y.hasDefaultTabStop(node)){      // see #11064 about webkit bug
                                        node.setAttribute('tabIndex', "-1");
                                }else{
                                        node.removeAttribute('tabIndex');
                                }
                        }, this);
                }else{
                        if(this.tabIndex != ""){
                                this.set('tabIndex', this.tabIndex);
                        }
                }
        },

        _onFocus: function(/*String*/ by){
                // If user clicks on the widget, even if the mouse is released outside of it,
                // this widget's focusNode should get focus (to mimic native browser hehavior).
                // Browsers often need help to make sure the focus via mouse actually gets to the focusNode.
                if(by == "mouse" && this.isFocusable()){
                        // IE exhibits strange scrolling behavior when refocusing a node so only do it when !focused.
                        var focusConnector = this.connect(this.focusNode, "onfocus", function(){
                                this.disconnect(mouseUpConnector);
                                this.disconnect(focusConnector);
                        });
                        // Set a global event to handle mouseup, so it fires properly
                        // even if the cursor leaves this.domNode before the mouse up event.
                        var mouseUpConnector = this.connect(this.ownerDocumentBody, "onmouseup", function(){
                                this.disconnect(mouseUpConnector);
                                this.disconnect(focusConnector);
                                // if here, then the mousedown did not focus the focusNode as the default action
                                if(this.focused){
                                        this.focus();
                                }
                        });
                }
                if(this.scrollOnFocus){
                        this.defer(function(){ winUtils.scrollIntoView(this.domNode); }); // without defer, the input caret position can change on mouse click
                }
                this.inherited(arguments);
        },

        isFocusable: function(){
                // summary:
                //              Tells if this widget is focusable or not.  Used internally by dijit.
                // tags:
                //              protected
                return !this.disabled && this.focusNode && (domStyle.get(this.domNode, "display") != "none");
        },

        focus: function(){
                // summary:
                //              Put focus on this widget
                if(!this.disabled && this.focusNode.focus){
                        try{ this.focusNode.focus(); }catch(e){}/*squelch errors from hidden nodes*/
                }
        },

        compare: function(/*anything*/ val1, /*anything*/ val2){
                // summary:
                //              Compare 2 values (as returned by get('value') for this widget).
                // tags:
                //              protected
                if(typeof val1 == "number" && typeof val2 == "number"){
                        return (isNaN(val1) && isNaN(val2)) ? 0 : val1 - val2;
                }else if(val1 > val2){
                        return 1;
                }else if(val1 < val2){
                        return -1;
                }else{
                        return 0;
                }
        },

        onChange: function(/*===== newValue =====*/){
                // summary:
                //              Callback when this widget's value is changed.
                // tags:
                //              callback
        },

        // _onChangeActive: [private] Boolean
        //              Indicates that changes to the value should call onChange() callback.
        //              This is false during widget initialization, to avoid calling onChange()
        //              when the initial value is set.
        _onChangeActive: false,

        _handleOnChange: function(/*anything*/ newValue, /*Boolean?*/ priorityChange){
                // summary:
                //              Called when the value of the widget is set.  Calls onChange() if appropriate
                // newValue:
                //              the new value
                // priorityChange:
                //              For a slider, for example, dragging the slider is priorityChange==false,
                //              but on mouse up, it's priorityChange==true.  If intermediateChanges==false,
                //              onChange is only called form priorityChange=true events.
                // tags:
                //              private
                if(this._lastValueReported == undefined && (priorityChange === null || !this._onChangeActive)){
                        // this block executes not for a change, but during initialization,
                        // and is used to store away the original value (or for ToggleButton, the original checked state)
                        this._resetValue = this._lastValueReported = newValue;
                }
                this._pendingOnChange = this._pendingOnChange
                        || (typeof newValue != typeof this._lastValueReported)
                        || (this.compare(newValue, this._lastValueReported) != 0);
                if((this.intermediateChanges || priorityChange || priorityChange === undefined) && this._pendingOnChange){
                        this._lastValueReported = newValue;
                        this._pendingOnChange = false;
                        if(this._onChangeActive){
                                if(this._onChangeHandle){
                                        this._onChangeHandle.remove();
                                }
                                // defer allows hidden value processing to run and
                                // also the onChange handler can safely adjust focus, etc
                                this._onChangeHandle = this.defer(
                                        function(){
                                                this._onChangeHandle = null;
                                                this.onChange(newValue);
                                        }); // try to collapse multiple onChange's fired faster than can be processed
                        }
                }
        },

        create: function(){
                // Overrides _Widget.create()
                this.inherited(arguments);
                this._onChangeActive = true;
        },

        destroy: function(){
                if(this._onChangeHandle){ // destroy called before last onChange has fired
                        this._onChangeHandle.remove();
                        this.onChange(this._lastValueReported);
                }
                this.inherited(arguments);
        }
});

});

},
'dijit/a11yclick':function(){
define("dijit/a11yclick", [
        "dojo/on",
        "dojo/_base/array", // array.forEach
        "dojo/keys", // keys.ENTER keys.SPACE
        "dojo/_base/declare", // declare
        "dojo/has", // has("dom-addeventlistener")
        "dojo/_base/unload", // unload.addOnWindowUnload
        "dojo/_base/window" // win.doc.addEventListener win.doc.attachEvent win.doc.detachEvent
], function(on, array, keys, declare, has, unload, win){

        // module:
        //              dijit/a11yclick

        // Keep track of where the last keydown event was, to help avoid generating
        // spurious ondijitclick events when:
        // 1. focus is on a <button> or <a>
        // 2. user presses then releases the ENTER key
        // 3. onclick handler fires and shifts focus to another node, with an ondijitclick handler
        // 4. onkeyup event fires, causing the ondijitclick handler to fire
        var lastKeyDownNode = null;
        if(has("dom-addeventlistener")){
                win.doc.addEventListener('keydown', function(evt){
                        lastKeyDownNode = evt.target;
                }, true);
        }else{
                // Fallback path for IE6-8
                (function(){
                        var keydownCallback = function(evt){
                                lastKeyDownNode = evt.srcElement;
                        };
                        win.doc.attachEvent('onkeydown', keydownCallback);
                        unload.addOnWindowUnload(function(){
                                win.doc.detachEvent('onkeydown', keydownCallback);
                        });
                })();
        }

        function clickKey(/*Event*/ e){
                return (e.keyCode === keys.ENTER || e.keyCode === keys.SPACE) &&
                        !e.ctrlKey && !e.shiftKey && !e.altKey && !e.metaKey;
        }

        return function(node, listener){
                // summary:
                //              Custom a11yclick (a.k.a. ondijitclick) event
                //              which triggers on a mouse click, touch, or space/enter keyup.

                if(/input|button/i.test(node.nodeName)){
                        // pass through, the browser already generates click event on SPACE/ENTER key
                        return on(node, "click", listener);
                }else{
                        // Don't fire the click event unless both the keydown and keyup occur on this node.
                        // Avoids problems where focus shifted to this node or away from the node on keydown,
                        // either causing this node to process a stray keyup event, or causing another node
                        // to get a stray keyup event.

                        var handles = [
                                on(node, "keydown", function(e){
                                        //console.log(this.id + ": onkeydown, e.target = ", e.target, ", lastKeyDownNode was ", lastKeyDownNode, ", equality is ", (e.target === lastKeyDownNode));
                                        if(clickKey(e)){
                                                // needed on IE for when focus changes between keydown and keyup - otherwise dropdown menus do not work
                                                lastKeyDownNode = e.target;

                                                // Prevent viewport scrolling on space key in IE<9.
                                                // (Reproducible on test_Button.html on any of the first dijit/form/Button examples)
                                                e.preventDefault();
                                        }
                                }),

                                on(node, "keyup", function(e){
                                        //console.log(this.id + ": onkeyup, e.target = ", e.target, ", lastKeyDownNode was ", lastKeyDownNode, ", equality is ", (e.target === lastKeyDownNode));
                                        if(clickKey(e) && e.target == lastKeyDownNode){ // === breaks greasemonkey
                                                //need reset here or have problems in FF when focus returns to trigger element after closing popup/alert
                                                lastKeyDownNode = null;
                                                on.emit(e.target, "click", {
                                                        cancelable: true,
                                                        bubbles: true
                                                });
                                        }
                                }),

                                on(node, "click", function(e){
                                        // catch mouse clicks, plus the on.emit() calls from above and below
                                        listener.call(this, e);
                                })
                        ];

                        if(has("touch")){
                                // touchstart-->touchend will automatically generate a click event, but there are problems
                                // on iOS after focus has been programatically shifted (#14604, #14918), so setup a failsafe
                                // if click doesn't fire naturally.

                                var clickTimer;
                                handles.push(
                                        on(node, "touchend", function(e){
                                                var target = e.target;
                                                clickTimer = setTimeout(function(){
                                                        clickTimer = null;
                                                        on.emit(target, "click", {
                                                                cancelable: true,
                                                                bubbles: true
                                                        });
                                                }, 600);
                                        }),
                                        on(node, "click", function(e){
                                                // If browser generates a click naturally, clear the timer to fire a synthetic click event
                                                if(clickTimer){
                                                        clearTimeout(clickTimer);
                                                }
                                        })
                                        // TODO: if the touchstart and touchend were <100ms apart, and then there's another touchstart
                                        // event <300ms after the touchend event, then clear the synthetic click timer, because user
                                        // is doing a zoom.   Alternately monitor screen.deviceXDPI (or something similar) to see if
                                        // zoom level has changed.
                                );
                        }

                        return {
                                remove: function(){
                                        array.forEach(handles, function(h){ h.remove(); });
                                        if(clickTimer){
                                                clearTimeout(clickTimer);
                                                clickTimer = null;
                                        }
                                }
                        };
                }
        };

        return ret;
});

},
'url:dijit/templates/ProgressBar.html':"<div class=\"dijitProgressBar dijitProgressBarEmpty\" role=\"progressbar\"\n\t><div  data-dojo-attach-point=\"internalProgress\" class=\"dijitProgressBarFull\"\n\t\t><div class=\"dijitProgressBarTile\" role=\"presentation\"></div\n\t\t><span style=\"visibility:hidden\">&#160;</span\n\t></div\n\t><div data-dojo-attach-point=\"labelNode\" class=\"dijitProgressBarLabel\" id=\"${id}_label\"></div\n\t><img data-dojo-attach-point=\"indeterminateHighContrastImage\" class=\"dijitProgressBarIndeterminateHighContrastImage\" alt=\"\"\n/></div>\n",
'dijit/Destroyable':function(){
define("dijit/Destroyable", [
        "dojo/_base/array", // array.forEach array.map
        "dojo/aspect",
        "dojo/_base/declare"
], function(array, aspect, declare){

// module:
//              dijit/Destroyable

return declare("dijit.Destroyable", null, {
        // summary:
        //              Mixin to track handles and release them when instance is destroyed.
        // description:
        //              Call this.own(...) on list of handles (returned from dojo/aspect, dojo/on,
        //              dojo/Stateful::watch, or any class (including widgets) with a destroyRecursive() or destroy() method.
        //              Then call destroy() later to destroy this instance and release the resources.

        destroy: function(/*Boolean*/ preserveDom){
                // summary:
                //              Destroy this class, releasing any resources registered via own().
                this._destroyed = true;
        },

        own: function(){
                // summary:
                //              Track specified handles and remove/destroy them when this instance is destroyed, unless they were
                //              already removed/destroyed manually.
                // tags:
                //              protected
                // returns:
                //              The array of specified handles, so you can do for example:
                //      |               var handle = this.own(on(...))[0];

                array.forEach(arguments, function(handle){
                        var destroyMethodName =
                                "destroyRecursive" in handle ? "destroyRecursive" :     // remove "destroyRecursive" for 2.0
                                "destroy" in handle ? "destroy" :
                                "remove";

                        // When this.destroy() is called, destroy handle.  Since I'm using aspect.before(),
                        // the handle will be destroyed before a subclass's destroy() method starts running, before it calls
                        // this.inherited() or even if it doesn't call this.inherited() at all.  If that's an issue, make an
                        // onDestroy() method and connect to that instead.
                        var odh = aspect.before(this, "destroy", function(preserveDom){
                                handle[destroyMethodName](preserveDom);
                        });

                        // If handle is destroyed manually before this.destroy() is called, remove the listener set directly above.
                        var hdh = aspect.after(handle, destroyMethodName, function(){
                                odh.remove();
                                hdh.remove();
                        }, true);
                }, this);

                return arguments;               // handle
        }
});

});

},
'dijit/layout/_ContentPaneResizeMixin':function(){
define("dijit/layout/_ContentPaneResizeMixin", [
        "dojo/_base/array", // array.filter array.forEach
        "dojo/_base/declare", // declare
        "dojo/dom-class",       // domClass.contains domClass.toggle
        "dojo/dom-geometry",// domGeometry.contentBox domGeometry.marginBox
        "dojo/dom-style",
        "dojo/_base/lang", // lang.mixin
        "dojo/query", // query
        "dojo/sniff", // has("ie")
        "../registry",  // registry.byId
        "../Viewport",
        "./utils"       // marginBox2contextBox
], function(array, declare, domClass, domGeometry, domStyle, lang, query, has,
                        registry, Viewport, layoutUtils){

// module:
//              dijit/layout/_ContentPaneResizeMixin


return declare("dijit.layout._ContentPaneResizeMixin", null, {
        // summary:
        //              Resize() functionality of ContentPane.   If there's a single layout widget
        //              child then it will call resize() with the same dimensions as the ContentPane.
        //              Otherwise just calls resize on each child.
        //
        //              Also implements basic startup() functionality, where starting the parent
        //              will start the children

        // doLayout: Boolean
        //              - false - don't adjust size of children
        //              - true - if there is a single visible child widget, set it's size to however big the ContentPane is
        doLayout: true,

        // isLayoutContainer: [protected] Boolean
        //              Indicates that this widget will call resize() on it's child widgets
        //              when they become visible.
        isLayoutContainer: true,

        startup: function(){
                // summary:
                //              See `dijit/layout/_LayoutWidget.startup()` for description.
                //              Although ContentPane doesn't extend _LayoutWidget, it does implement
                //              the same API.

                if(this._started){ return; }

                var parent = this.getParent();
                this._childOfLayoutWidget = parent && parent.isLayoutContainer;

                // I need to call resize() on my child/children (when I become visible), unless
                // I'm the child of a layout widget in which case my parent will call resize() on me and I'll do it then.
                this._needLayout = !this._childOfLayoutWidget;

                this.inherited(arguments);

                if(this._isShown()){
                        this._onShow();
                }

                if(!this._childOfLayoutWidget){
                        // Since my parent isn't a layout container, and my style *may be* width=height=100%
                        // or something similar (either set directly or via a CSS class),
                        // monitor when viewport size changes so that I can re-layout.
                        // This is more for subclasses of ContentPane than ContentPane itself, although it
                        // could be useful for a ContentPane if it has a single child widget inheriting ContentPane's size.
                        this.own(Viewport.on("resize", lang.hitch(this, "resize")));
                }
        },

        _checkIfSingleChild: function(){
                // summary:
                //              Test if we have exactly one visible widget as a child,
                //              and if so assume that we are a container for that widget,
                //              and should propagate startup() and resize() calls to it.
                //              Skips over things like data stores since they aren't visible.

                var candidateWidgets = [],
                        otherVisibleNodes = false;

                query("> *", this.containerNode).some(function(node){
                        var widget = registry.byNode(node);
                        if(widget && widget.resize){
                                candidateWidgets.push(widget);
                        }else if(node.offsetHeight){
                                otherVisibleNodes = true;
                        }
                });

                this._singleChild = candidateWidgets.length == 1 && !otherVisibleNodes ?
                        candidateWidgets[0] : null;

                // So we can set overflow: hidden to avoid a safari bug w/scrollbars showing up (#9449)
                domClass.toggle(this.containerNode, this.baseClass + "SingleChild", !!this._singleChild);
        },

        resize: function(changeSize, resultSize){
                // summary:
                //              See `dijit/layout/_LayoutWidget.resize()` for description.
                //              Although ContentPane doesn't extend _LayoutWidget, it does implement
                //              the same API.

                this._resizeCalled = true;

                this._scheduleLayout(changeSize, resultSize);
        },

        _scheduleLayout: function(changeSize, resultSize){
                // summary:
                //              Resize myself, and call resize() on each of my child layout widgets, either now
                //              (if I'm currently visible) or when I become visible
                if(this._isShown()){
                        this._layout(changeSize, resultSize);
                }else{
                        this._needLayout = true;
                        this._changeSize = changeSize;
                        this._resultSize = resultSize;
                }
        },

        _layout: function(changeSize, resultSize){
                // summary:
                //              Resize myself according to optional changeSize/resultSize parameters, like a layout widget.
                //              Also, since I am an isLayoutContainer widget, each of my children expects me to
                //              call resize() or layout() on it.
                //
                //              Should be called on initialization and also whenever we get new content
                //              (from an href, or from set('content', ...))... but deferred until
                //              the ContentPane is visible

                delete this._needLayout;

                // For the TabContainer --> BorderContainer --> ContentPane case, _onShow() is
                // never called directly, so resize() is our trigger to do the initial href download (see [20099]).
                // However, don't load href for closed TitlePanes.
                if(!this._wasShown && this.open !== false){
                        this._onShow();
                }

                // Set margin box size, unless it wasn't specified, in which case use current size.
                if(changeSize){
                        domGeometry.setMarginBox(this.domNode, changeSize);
                }

                // Compute content box size of containerNode in case we [later] need to size our single child.
                var cn = this.containerNode;
                if(cn === this.domNode){
                        // If changeSize or resultSize was passed to this method and this.containerNode ==
                        // this.domNode then we can compute the content-box size without querying the node,
                        // which is more reliable (similar to LayoutWidget.resize) (see for example #9449).
                        var mb = resultSize || {};
                        lang.mixin(mb, changeSize || {}); // changeSize overrides resultSize
                        if(!("h" in mb) || !("w" in mb)){
                                mb = lang.mixin(domGeometry.getMarginBox(cn), mb); // just use domGeometry.setMarginBox() to fill in missing values
                        }
                        this._contentBox = layoutUtils.marginBox2contentBox(cn, mb);
                }else{
                        this._contentBox = domGeometry.getContentBox(cn);
                }

                this._layoutChildren();
        },

        _layoutChildren: function(){
                // Call _checkIfSingleChild() again in case app has manually mucked w/the content
                // of the ContentPane (rather than changing it through the set("content", ...) API.
                if(this.doLayout){
                        this._checkIfSingleChild();
                }

                if(this._singleChild && this._singleChild.resize){
                        var cb = this._contentBox || domGeometry.getContentBox(this.containerNode);

                        // note: if widget has padding this._contentBox will have l and t set,
                        // but don't pass them to resize() or it will doubly-offset the child
                        this._singleChild.resize({w: cb.w, h: cb.h});
                }else{
                        // All my child widgets are independently sized (rather than matching my size),
                        // but I still need to call resize() on each child to make it layout.
                        array.forEach(this.getChildren(), function(widget){
                                if(widget.resize){
                                        widget.resize();
                                }
                        });
                }
        },

        _isShown: function(){
                // summary:
                //              Returns true if the content is currently shown.
                // description:
                //              If I am a child of a layout widget then it actually returns true if I've ever been visible,
                //              not whether I'm currently visible, since that's much faster than tracing up the DOM/widget
                //              tree every call, and at least solves the performance problem on page load by deferring loading
                //              hidden ContentPanes until they are first shown

                if(this._childOfLayoutWidget){
                        // If we are TitlePane, etc - we return that only *IF* we've been resized
                        if(this._resizeCalled && "open" in this){
                                return this.open;
                        }
                        return this._resizeCalled;
                }else if("open" in this){
                        return this.open;               // for TitlePane, etc.
                }else{
                        var node = this.domNode, parent = this.domNode.parentNode;
                        return (node.style.display != 'none') && (node.style.visibility != 'hidden') && !domClass.contains(node, "dijitHidden") &&
                                        parent && parent.style && (parent.style.display != 'none');
                }
        },

        _onShow: function(){
                // summary:
                //              Called when the ContentPane is made visible
                // description:
                //              For a plain ContentPane, this is called on initialization, from startup().
                //              If the ContentPane is a hidden pane of a TabContainer etc., then it's
                //              called whenever the pane is made visible.
                //
                //              Does layout/resize of child widget(s)

                // Need to keep track of whether ContentPane has been shown (which is different than
                // whether or not it's currently visible).
                this._wasShown = true;

                if(this._needLayout){
                        // If a layout has been scheduled for when we become visible, do it now
                        this._layout(this._changeSize, this._resultSize);
                }

                this.inherited(arguments);
        }
});

});

},
'dijit/WidgetSet':function(){
define("dijit/WidgetSet", [
        "dojo/_base/array", // array.forEach array.map
        "dojo/_base/declare", // declare
        "dojo/_base/kernel", // kernel.global
        "./registry"    // to add functions to dijit.registry
], function(array, declare, kernel, registry){

        // module:
        //              dijit/WidgetSet

        var WidgetSet = declare("dijit.WidgetSet", null, {
                // summary:
                //              A set of widgets indexed by id.
                //              Deprecated, will be removed in 2.0.
                //
                // example:
                //              Create a small list of widgets:
                //              |       require(["dijit/WidgetSet", "dijit/registry"],
                //              |               function(WidgetSet, registry){
                //              |               var ws = new WidgetSet();
                //              |               ws.add(registry.byId("one"));
                //              |               ws.add(registry.byId("two"));
                //              |               // destroy both:
                //              |               ws.forEach(function(w){ w.destroy(); });
                //              |       });

                constructor: function(){
                        this._hash = {};
                        this.length = 0;
                },

                add: function(/*dijit/_WidgetBase*/ widget){
                        // summary:
                        //              Add a widget to this list. If a duplicate ID is detected, a error is thrown.
                        //
                        // widget: dijit/_WidgetBase
                        //              Any dijit/_WidgetBase subclass.
                        if(this._hash[widget.id]){
                                throw new Error("Tried to register widget with id==" + widget.id + " but that id is already registered");
                        }
                        this._hash[widget.id] = widget;
                        this.length++;
                },

                remove: function(/*String*/ id){
                        // summary:
                        //              Remove a widget from this WidgetSet. Does not destroy the widget; simply
                        //              removes the reference.
                        if(this._hash[id]){
                                delete this._hash[id];
                                this.length--;
                        }
                },

                forEach: function(/*Function*/ func, /* Object? */thisObj){
                        // summary:
                        //              Call specified function for each widget in this set.
                        //
                        // func:
                        //              A callback function to run for each item. Is passed the widget, the index
                        //              in the iteration, and the full hash, similar to `array.forEach`.
                        //
                        // thisObj:
                        //              An optional scope parameter
                        //
                        // example:
                        //              Using the default `dijit.registry` instance:
                        //              |       require(["dijit/WidgetSet", "dijit/registry"],
                        //              |               function(WidgetSet, registry){
                        //              |               registry.forEach(function(widget){
                        //              |                       console.log(widget.declaredClass);
                        //              |               });
                        //              |       });
                        //
                        // returns:
                        //              Returns self, in order to allow for further chaining.

                        thisObj = thisObj || kernel.global;
                        var i = 0, id;
                        for(id in this._hash){
                                func.call(thisObj, this._hash[id], i++, this._hash);
                        }
                        return this;    // dijit/WidgetSet
                },

                filter: function(/*Function*/ filter, /* Object? */thisObj){
                        // summary:
                        //              Filter down this WidgetSet to a smaller new WidgetSet
                        //              Works the same as `array.filter` and `NodeList.filter`
                        //
                        // filter:
                        //              Callback function to test truthiness. Is passed the widget
                        //              reference and the pseudo-index in the object.
                        //
                        // thisObj: Object?
                        //              Option scope to use for the filter function.
                        //
                        // example:
                        //              Arbitrary: select the odd widgets in this list
                        //              |       
                        //              |               
                        //              |       
                        //              |       require(["dijit/WidgetSet", "dijit/registry"],
                        //              |               function(WidgetSet, registry){
                        //              |               registry.filter(function(w, i){
                        //              |                       return i % 2 == 0;
                        //              |               }).forEach(function(w){ /* odd ones */ });
                        //              |       });

                        thisObj = thisObj || kernel.global;
                        var res = new WidgetSet(), i = 0, id;
                        for(id in this._hash){
                                var w = this._hash[id];
                                if(filter.call(thisObj, w, i++, this._hash)){
                                        res.add(w);
                                }
                        }
                        return res; // dijit/WidgetSet
                },

                byId: function(/*String*/ id){
                        // summary:
                        //              Find a widget in this list by it's id.
                        // example:
                        //              Test if an id is in a particular WidgetSet
                        //              |       require(["dijit/WidgetSet", "dijit/registry"],
                        //              |               function(WidgetSet, registry){
                        //              |               var ws = new WidgetSet();
                        //              |               ws.add(registry.byId("bar"));
                        //              |               var t = ws.byId("bar") // returns a widget
                        //              |               var x = ws.byId("foo"); // returns undefined
                        //              |       });

                        return this._hash[id];  // dijit/_WidgetBase
                },

                byClass: function(/*String*/ cls){
                        // summary:
                        //              Reduce this widgetset to a new WidgetSet of a particular `declaredClass`
                        //
                        // cls: String
                        //              The Class to scan for. Full dot-notated string.
                        //
                        // example:
                        //              Find all `dijit.TitlePane`s in a page:
                        //              |       require(["dijit/WidgetSet", "dijit/registry"],
                        //              |               function(WidgetSet, registry){
                        //              |               registry.byClass("dijit.TitlePane").forEach(function(tp){ tp.close(); });
                        //              |       });

                        var res = new WidgetSet(), id, widget;
                        for(id in this._hash){
                                widget = this._hash[id];
                                if(widget.declaredClass == cls){
                                        res.add(widget);
                                }
                         }
                         return res; // dijit/WidgetSet
                },

                toArray: function(){
                        // summary:
                        //              Convert this WidgetSet into a true Array
                        //
                        // example:
                        //              Work with the widget .domNodes in a real Array
                        //              |       require(["dijit/WidgetSet", "dijit/registry"],
                        //              |               function(WidgetSet, registry){
                        //              |               array.map(registry.toArray(), function(w){ return w.domNode; });
                        //              |       });


                        var ar = [];
                        for(var id in this._hash){
                                ar.push(this._hash[id]);
                        }
                        return ar;      // dijit/_WidgetBase[]
                },

                map: function(/* Function */func, /* Object? */thisObj){
                        // summary:
                        //              Create a new Array from this WidgetSet, following the same rules as `array.map`
                        // example:
                        //              |       require(["dijit/WidgetSet", "dijit/registry"],
                        //              |               function(WidgetSet, registry){
                        //              |               var nodes = registry.map(function(w){ return w.domNode; });
                        //              |       });
                        //
                        // returns:
                        //              A new array of the returned values.
                        return array.map(this.toArray(), func, thisObj); // Array
                },

                every: function(func, thisObj){
                        // summary:
                        //              A synthetic clone of `array.every` acting explicitly on this WidgetSet
                        //
                        // func: Function
                        //              A callback function run for every widget in this list. Exits loop
                        //              when the first false return is encountered.
                        //
                        // thisObj: Object?
                        //              Optional scope parameter to use for the callback

                        thisObj = thisObj || kernel.global;
                        var x = 0, i;
                        for(i in this._hash){
                                if(!func.call(thisObj, this._hash[i], x++, this._hash)){
                                        return false; // Boolean
                                }
                        }
                        return true; // Boolean
                },

                some: function(func, thisObj){
                        // summary:
                        //              A synthetic clone of `array.some` acting explicitly on this WidgetSet
                        //
                        // func: Function
                        //              A callback function run for every widget in this list. Exits loop
                        //              when the first true return is encountered.
                        //
                        // thisObj: Object?
                        //              Optional scope parameter to use for the callback

                        thisObj = thisObj || kernel.global;
                        var x = 0, i;
                        for(i in this._hash){
                                if(func.call(thisObj, this._hash[i], x++, this._hash)){
                                        return true; // Boolean
                                }
                        }
                        return false; // Boolean
                }

        });

        // Add in 1.x compatibility methods to dijit/registry.
        // These functions won't show up in the API doc but since they are deprecated anyway,
        // that's probably for the best.
        array.forEach(["forEach", "filter", "byClass", "map", "every", "some"], function(func){
                registry[func] = WidgetSet.prototype[func];
        });


        return WidgetSet;
});

},
'dojo/dnd/Moveable':function(){
define("dojo/dnd/Moveable", [
        "../_base/array", "../_base/declare", "../_base/event", "../_base/lang",
        "../dom", "../dom-class", "../Evented", "../on", "../topic", "../touch", "./common", "./Mover", "../_base/window"
], function(array, declare, event, lang, dom, domClass, Evented, on, topic, touch, dnd, Mover, win){

// module:
//              dojo/dnd/Moveable


var Moveable = declare("dojo.dnd.Moveable", [Evented], {
        // summary:
        //              an object, which makes a node movable

        // object attributes (for markup)
        handle: "",
        delay: 0,
        skip: false,

        constructor: function(node, params){
                // node: Node
                //              a node (or node's id) to be moved
                // params: Moveable.__MoveableArgs?
                //              optional parameters
                this.node = dom.byId(node);
                if(!params){ params = {}; }
                this.handle = params.handle ? dom.byId(params.handle) : null;
                if(!this.handle){ this.handle = this.node; }
                this.delay = params.delay > 0 ? params.delay : 0;
                this.skip  = params.skip;
                this.mover = params.mover ? params.mover : Mover;
                this.events = [
                        on(this.handle, touch.press, lang.hitch(this, "onMouseDown")),
                        // cancel text selection and text dragging
                        on(this.handle, "dragstart",   lang.hitch(this, "onSelectStart")),
                        on(this.handle, "selectstart",   lang.hitch(this, "onSelectStart"))
                ];
        },

        // markup methods
        markupFactory: function(params, node, Ctor){
                return new Ctor(node, params);
        },

        // methods
        destroy: function(){
                // summary:
                //              stops watching for possible move, deletes all references, so the object can be garbage-collected
                array.forEach(this.events, function(handle){ handle.remove(); });
                this.events = this.node = this.handle = null;
        },

        // mouse event processors
        onMouseDown: function(e){
                // summary:
                //              event processor for onmousedown/ontouchstart, creates a Mover for the node
                // e: Event
                //              mouse/touch event
                if(this.skip && dnd.isFormElement(e)){ return; }
                if(this.delay){
                        this.events.push(
                                on(this.handle, touch.move, lang.hitch(this, "onMouseMove")),
                                on(this.handle, touch.release, lang.hitch(this, "onMouseUp"))
                        );
                        this._lastX = e.pageX;
                        this._lastY = e.pageY;
                }else{
                        this.onDragDetected(e);
                }
                event.stop(e);
        },
        onMouseMove: function(e){
                // summary:
                //              event processor for onmousemove/ontouchmove, used only for delayed drags
                // e: Event
                //              mouse/touch event
                if(Math.abs(e.pageX - this._lastX) > this.delay || Math.abs(e.pageY - this._lastY) > this.delay){
                        this.onMouseUp(e);
                        this.onDragDetected(e);
                }
                event.stop(e);
        },
        onMouseUp: function(e){
                // summary:
                //              event processor for onmouseup, used only for delayed drags
                // e: Event
                //              mouse event
                for(var i = 0; i < 2; ++i){
                        this.events.pop().remove();
                }
                event.stop(e);
        },
        onSelectStart: function(e){
                // summary:
                //              event processor for onselectevent and ondragevent
                // e: Event
                //              mouse event
                if(!this.skip || !dnd.isFormElement(e)){
                        event.stop(e);
                }
        },

        // local events
        onDragDetected: function(/*Event*/ e){
                // summary:
                //              called when the drag is detected;
                //              responsible for creation of the mover
                new this.mover(this.node, e, this);
        },
        onMoveStart: function(/*Mover*/ mover){
                // summary:
                //              called before every move operation
                topic.publish("/dnd/move/start", mover);
                domClass.add(win.body(), "dojoMove");
                domClass.add(this.node, "dojoMoveItem");
        },
        onMoveStop: function(/*Mover*/ mover){
                // summary:
                //              called after every move operation
                topic.publish("/dnd/move/stop", mover);
                domClass.remove(win.body(), "dojoMove");
                domClass.remove(this.node, "dojoMoveItem");
        },
        onFirstMove: function(/*===== mover, e =====*/){
                // summary:
                //              called during the very first move notification;
                //              can be used to initialize coordinates, can be overwritten.
                // mover: Mover
                // e: Event

                // default implementation does nothing
        },
        onMove: function(mover, leftTop /*=====, e =====*/){
                // summary:
                //              called during every move notification;
                //              should actually move the node; can be overwritten.
                // mover: Mover
                // leftTop: Object
                // e: Event
                this.onMoving(mover, leftTop);
                var s = mover.node.style;
                s.left = leftTop.l + "px";
                s.top  = leftTop.t + "px";
                this.onMoved(mover, leftTop);
        },
        onMoving: function(/*===== mover, leftTop =====*/){
                // summary:
                //              called before every incremental move; can be overwritten.
                // mover: Mover
                // leftTop: Object

                // default implementation does nothing
        },
        onMoved: function(/*===== mover, leftTop =====*/){
                // summary:
                //              called after every incremental move; can be overwritten.
                // mover: Mover
                // leftTop: Object

                // default implementation does nothing
        }
});

/*=====
Moveable.__MoveableArgs = declare([], {
        // handle: Node||String
        //              A node (or node's id), which is used as a mouse handle.
        //              If omitted, the node itself is used as a handle.
        handle: null,

        // delay: Number
        //              delay move by this number of pixels
        delay: 0,

        // skip: Boolean
        //              skip move of form elements
        skip: false,

        // mover: Object
        //              a constructor of custom Mover
        mover: dnd.Mover
});
=====*/

return Moveable;
});

},
'dojo/store/util/SimpleQueryEngine':function(){
define("dojo/store/util/SimpleQueryEngine", ["../../_base/array" /*=====, "../api/Store" =====*/], function(arrayUtil /*=====, Store =====*/){

// module:
//              dojo/store/util/SimpleQueryEngine

return function(query, options){
        // summary:
        //              Simple query engine that matches using filter functions, named filter
        //              functions or objects by name-value on a query object hash
        //
        // description:
        //              The SimpleQueryEngine provides a way of getting a QueryResults through
        //              the use of a simple object hash as a filter.  The hash will be used to
        //              match properties on data objects with the corresponding value given. In
        //              other words, only exact matches will be returned.
        //
        //              This function can be used as a template for more complex query engines;
        //              for example, an engine can be created that accepts an object hash that
        //              contains filtering functions, or a string that gets evaluated, etc.
        //
        //              When creating a new dojo.store, simply set the store's queryEngine
        //              field as a reference to this function.
        //
        // query: Object
        //              An object hash with fields that may match fields of items in the store.
        //              Values in the hash will be compared by normal == operator, but regular expressions
        //              or any object that provides a test() method are also supported and can be
        //              used to match strings by more complex expressions
        //              (and then the regex's or object's test() method will be used to match values).
        //
        // options: dojo/store/api/Store.QueryOptions?
        //              An object that contains optional information such as sort, start, and count.
        //
        // returns: Function
        //              A function that caches the passed query under the field "matches".  See any
        //              of the "query" methods on dojo.stores.
        //
        // example:
        //              Define a store with a reference to this engine, and set up a query method.
        //
        //      |       var myStore = function(options){
        //      |               //      ...more properties here
        //      |               this.queryEngine = SimpleQueryEngine;
        //      |               //      define our query method
        //      |               this.query = function(query, options){
        //      |                       return QueryResults(this.queryEngine(query, options)(this.data));
        //      |               };
        //      |       };

        // create our matching query function
        switch(typeof query){
                default:
                        throw new Error("Can not query with a " + typeof query);
                case "object": case "undefined":
                        var queryObject = query;
                        query = function(object){
                                for(var key in queryObject){
                                        var required = queryObject[key];
                                        if(required && required.test){
                                                // an object can provide a test method, which makes it work with regex
                                                if(!required.test(object[key], object)){
                                                        return false;
                                                }
                                        }else if(required != object[key]){
                                                return false;
                                        }
                                }
                                return true;
                        };
                        break;
                case "string":
                        // named query
                        if(!this[query]){
                                throw new Error("No filter function " + query + " was found in store");
                        }
                        query = this[query];
                        // fall through
                case "function":
                        // fall through
        }
        function execute(array){
                // execute the whole query, first we filter
                var results = arrayUtil.filter(array, query);
                // next we sort
                var sortSet = options && options.sort;
                if(sortSet){
                        results.sort(typeof sortSet == "function" ? sortSet : function(a, b){
                                for(var sort, i=0; sort = sortSet[i]; i++){
                                        var aValue = a[sort.attribute];
                                        var bValue = b[sort.attribute];
                                        if (aValue != bValue){
                                                return !!sort.descending == (aValue == null || aValue > bValue) ? -1 : 1;
                                        }
                                }
                                return 0;
                        });
                }
                // now we paginate
                if(options && (options.start || options.count)){
                        var total = results.length;
                        results = results.slice(options.start || 0, (options.start || 0) + (options.count || Infinity));
                        results.total = total;
                }
                return results;
        }
        execute.matches = query;
        return execute;
};

});

},
'dijit/typematic':function(){
define("dijit/typematic", [
        "dojo/_base/array", // array.forEach
        "dojo/_base/connect", // connect.connect
        "dojo/_base/event", // event.stop
        "dojo/_base/kernel", // kernel.deprecated
        "dojo/_base/lang", // lang.mixin, lang.hitch
        "dojo/on",
        "dojo/sniff", // has("ie")
        "./main"                // setting dijit.typematic global
], function(array, connect, event, kernel, lang, on, has, dijit){

// module:
//              dijit/typematic

var typematic = (dijit.typematic = {
        // summary:
        //              These functions are used to repetitively call a user specified callback
        //              method when a specific key or mouse click over a specific DOM node is
        //              held down for a specific amount of time.
        //              Only 1 such event is allowed to occur on the browser page at 1 time.

        _fireEventAndReload: function(){
                this._timer = null;
                this._callback(++this._count, this._node, this._evt);

                // Schedule next event, timer is at most minDelay (default 10ms) to avoid
                // browser overload (particularly avoiding starving DOH robot so it never gets to send a mouseup)
                this._currentTimeout = Math.max(
                        this._currentTimeout < 0 ? this._initialDelay :
                                (this._subsequentDelay > 1 ? this._subsequentDelay : Math.round(this._currentTimeout * this._subsequentDelay)),
                        this._minDelay);
                this._timer = setTimeout(lang.hitch(this, "_fireEventAndReload"), this._currentTimeout);
        },

        trigger: function(/*Event*/ evt, /*Object*/ _this, /*DOMNode*/ node, /*Function*/ callback, /*Object*/ obj, /*Number?*/ subsequentDelay, /*Number?*/ initialDelay, /*Number?*/ minDelay){
                // summary:
                //              Start a timed, repeating callback sequence.
                //              If already started, the function call is ignored.
                //              This method is not normally called by the user but can be
                //              when the normal listener code is insufficient.
                // evt:
                //              key or mouse event object to pass to the user callback
                // _this:
                //              pointer to the user's widget space.
                // node:
                //              the DOM node object to pass the the callback function
                // callback:
                //              function to call until the sequence is stopped called with 3 parameters:
                // count:
                //              integer representing number of repeated calls (0..n) with -1 indicating the iteration has stopped
                // node:
                //              the DOM node object passed in
                // evt:
                //              key or mouse event object
                // obj:
                //              user space object used to uniquely identify each typematic sequence
                // subsequentDelay:
                //              if > 1, the number of milliseconds until the 3->n events occur
                //              or else the fractional time multiplier for the next event's delay, default=0.9
                // initialDelay:
                //              the number of milliseconds until the 2nd event occurs, default=500ms
                // minDelay:
                //              the maximum delay in milliseconds for event to fire, default=10ms
                if(obj != this._obj){
                        this.stop();
                        this._initialDelay = initialDelay || 500;
                        this._subsequentDelay = subsequentDelay || 0.90;
                        this._minDelay = minDelay || 10;
                        this._obj = obj;
                        this._node = node;
                        this._currentTimeout = -1;
                        this._count = -1;
                        this._callback = lang.hitch(_this, callback);
                        this._evt = { faux: true };
                        for(var attr in evt){
                                if(attr != "layerX" && attr != "layerY"){ // prevent WebKit warnings
                                        var v = evt[attr];
                                        if(typeof v != "function" && typeof v != "undefined"){ this._evt[attr] = v }
                                }
                        }
                        this._fireEventAndReload();
                }
        },

        stop: function(){
                // summary:
                //              Stop an ongoing timed, repeating callback sequence.
                if(this._timer){
                        clearTimeout(this._timer);
                        this._timer = null;
                }
                if(this._obj){
                        this._callback(-1, this._node, this._evt);
                        this._obj = null;
                }
        },

        addKeyListener: function(/*DOMNode*/ node, /*Object*/ keyObject, /*Object*/ _this, /*Function*/ callback, /*Number*/ subsequentDelay, /*Number*/ initialDelay, /*Number?*/ minDelay){
                // summary:
                //              Start listening for a specific typematic key.
                //              See also the trigger method for other parameters.
                // keyObject:
                //              an object defining the key to listen for:
                //
                //              - charOrCode: the printable character (string) or keyCode (number) to listen for.
                //              - keyCode: (deprecated - use charOrCode) the keyCode (number) to listen for (implies charCode = 0).
                //              - charCode: (deprecated - use charOrCode) the charCode (number) to listen for.
                //              - ctrlKey: desired ctrl key state to initiate the callback sequence:
                //                      - pressed (true)
                //                      - released (false)
                //                      - either (unspecified)
                //              - altKey: same as ctrlKey but for the alt key
                //              - shiftKey: same as ctrlKey but for the shift key
                // returns:
                //              a connection handle

                if(keyObject.keyCode){
                        keyObject.charOrCode = keyObject.keyCode;
                        kernel.deprecated("keyCode attribute parameter for dijit.typematic.addKeyListener is deprecated. Use charOrCode instead.", "", "2.0");
                }else if(keyObject.charCode){
                        keyObject.charOrCode = String.fromCharCode(keyObject.charCode);
                        kernel.deprecated("charCode attribute parameter for dijit.typematic.addKeyListener is deprecated. Use charOrCode instead.", "", "2.0");
                }
                var handles = [
                        on(node, connect._keypress, lang.hitch(this, function(evt){
                                if(evt.charOrCode == keyObject.charOrCode &&
                                (keyObject.ctrlKey === undefined || keyObject.ctrlKey == evt.ctrlKey) &&
                                (keyObject.altKey === undefined || keyObject.altKey == evt.altKey) &&
                                (keyObject.metaKey === undefined || keyObject.metaKey == (evt.metaKey || false)) && // IE doesn't even set metaKey
                                (keyObject.shiftKey === undefined || keyObject.shiftKey == evt.shiftKey)){
                                        event.stop(evt);
                                        typematic.trigger(evt, _this, node, callback, keyObject, subsequentDelay, initialDelay, minDelay);
                                }else if(typematic._obj == keyObject){
                                        typematic.stop();
                                }
                        })),
                        on(node, "keyup", lang.hitch(this, function(){
                                if(typematic._obj == keyObject){
                                        typematic.stop();
                                }
                        }))
                ];
                return { remove: function(){ array.forEach(handles, function(h){ h.remove(); }); } };
        },

        addMouseListener: function(/*DOMNode*/ node, /*Object*/ _this, /*Function*/ callback, /*Number*/ subsequentDelay, /*Number*/ initialDelay, /*Number?*/ minDelay){
                // summary:
                //              Start listening for a typematic mouse click.
                //              See the trigger method for other parameters.
                // returns:
                //              a connection handle
                var handles = [
                        on(node, "mousedown", lang.hitch(this, function(evt){
                                evt.preventDefault();
                                typematic.trigger(evt, _this, node, callback, node, subsequentDelay, initialDelay, minDelay);
                        })),
                        on(node, "mouseup", lang.hitch(this, function(evt){
                                if(this._obj){
                                        evt.preventDefault();
                                }
                                typematic.stop();
                        })),
                        on(node, "mouseout", lang.hitch(this, function(evt){
                                if(this._obj){
                                        evt.preventDefault();
                                }
                                typematic.stop();
                        })),
                        on(node, "dblclick", lang.hitch(this, function(evt){
                                evt.preventDefault();
                                if(has("ie") < 9){
                                        typematic.trigger(evt, _this, node, callback, node, subsequentDelay, initialDelay, minDelay);
                                        setTimeout(lang.hitch(this, typematic.stop), 50);
                                }
                        }))
                ];
                return { remove: function(){ array.forEach(handles, function(h){ h.remove(); }); } };
        },

        addListener: function(/*Node*/ mouseNode, /*Node*/ keyNode, /*Object*/ keyObject, /*Object*/ _this, /*Function*/ callback, /*Number*/ subsequentDelay, /*Number*/ initialDelay, /*Number?*/ minDelay){
                // summary:
                //              Start listening for a specific typematic key and mouseclick.
                //              This is a thin wrapper to addKeyListener and addMouseListener.
                //              See the addMouseListener and addKeyListener methods for other parameters.
                // mouseNode:
                //              the DOM node object to listen on for mouse events.
                // keyNode:
                //              the DOM node object to listen on for key events.
                // returns:
                //              a connection handle
                var handles = [
                        this.addKeyListener(keyNode, keyObject, _this, callback, subsequentDelay, initialDelay, minDelay),
                        this.addMouseListener(mouseNode, _this, callback, subsequentDelay, initialDelay, minDelay)
                ];
                return { remove: function(){ array.forEach(handles, function(h){ h.remove(); }); } };
        }
});

return typematic;

});

},
'dijit/MenuItem':function(){
require({cache:{
'url:dijit/templates/MenuItem.html':"<tr class=\"dijitReset dijitMenuItem\" data-dojo-attach-point=\"focusNode\" role=\"menuitem\" tabIndex=\"-1\">\n\t<td class=\"dijitReset dijitMenuItemIconCell\" role=\"presentation\">\n\t\t<img src=\"${_blankGif}\" alt=\"\" class=\"dijitIcon dijitMenuItemIcon\" data-dojo-attach-point=\"iconNode\"/>\n\t</td>\n\t<td class=\"dijitReset dijitMenuItemLabel\" colspan=\"2\" data-dojo-attach-point=\"containerNode\"></td>\n\t<td class=\"dijitReset dijitMenuItemAccelKey\" style=\"display: none\" data-dojo-attach-point=\"accelKeyNode\"></td>\n\t<td class=\"dijitReset dijitMenuArrowCell\" role=\"presentation\">\n\t\t<div data-dojo-attach-point=\"arrowWrapper\" style=\"visibility: hidden\">\n\t\t\t<img src=\"${_blankGif}\" alt=\"\" class=\"dijitMenuExpand\"/>\n\t\t\t<span class=\"dijitMenuExpandA11y\">+</span>\n\t\t</div>\n\t</td>\n</tr>\n"}});
define("dijit/MenuItem", [
        "dojo/_base/declare", // declare
        "dojo/dom", // dom.setSelectable
        "dojo/dom-attr", // domAttr.set
        "dojo/dom-class", // domClass.toggle
        "dojo/_base/kernel", // kernel.deprecated
        "dojo/sniff", // has("ie")
        "./_Widget",
        "./_TemplatedMixin",
        "./_Contained",
        "./_CssStateMixin",
        "dojo/text!./templates/MenuItem.html"
], function(declare, dom, domAttr, domClass, kernel, has,
                        _Widget, _TemplatedMixin, _Contained, _CssStateMixin, template){

        // module:
        //              dijit/MenuItem

        return declare("dijit.MenuItem",
                [_Widget, _TemplatedMixin, _Contained, _CssStateMixin],
                {
                // summary:
                //              A line item in a Menu Widget

                // Make 3 columns
                // icon, label, and expand arrow (BiDi-dependent) indicating sub-menu
                templateString: template,

                baseClass: "dijitMenuItem",

                // label: String
                //              Menu text
                label: "",
                _setLabelAttr: function(val){
                        this.containerNode.innerHTML =  val;
                        this._set("label", val);
                        if(this.textDir === "auto"){
                                this.applyTextDir(this.focusNode, this.label);
                        }
                },

                // iconClass: String
                //              Class to apply to DOMNode to make it display an icon.
                iconClass: "dijitNoIcon",
                _setIconClassAttr: { node: "iconNode", type: "class" },

                // accelKey: String
                //              Text for the accelerator (shortcut) key combination.
                //              Note that although Menu can display accelerator keys there
                //              is no infrastructure to actually catch and execute these
                //              accelerators.
                accelKey: "",

                // disabled: Boolean
                //              If true, the menu item is disabled.
                //              If false, the menu item is enabled.
                disabled: false,

                _fillContent: function(/*DomNode*/ source){
                        // If button label is specified as srcNodeRef.innerHTML rather than
                        // this.params.label, handle it here.
                        if(source && !("label" in this.params)){
                                this.set('label', source.innerHTML);
                        }
                },

                buildRendering: function(){
                        this.inherited(arguments);
                        var label = this.id+"_text";
                        domAttr.set(this.containerNode, "id", label);
                        if(this.accelKeyNode){
                                domAttr.set(this.accelKeyNode, "id", this.id + "_accel");
                                label += " " + this.id + "_accel";
                        }
                        this.domNode.setAttribute("aria-labelledby", label);
                        dom.setSelectable(this.domNode, false);
                },

                onClick: function(/*Event*/){
                        // summary:
                        //              User defined function to handle clicks
                        // tags:
                        //              callback
                },

                focus: function(){
                        // summary:
                        //              Focus on this MenuItem
                        try{
                                if(has("ie") == 8){
                                        // needed for IE8 which won't scroll TR tags into view on focus yet calling scrollIntoView creates flicker (#10275)
                                        this.containerNode.focus();
                                }
                                this.focusNode.focus();
                        }catch(e){
                                // this throws on IE (at least) in some scenarios
                        }
                },

                _onFocus: function(){
                        // summary:
                        //              This is called by the focus manager when focus
                        //              goes to this MenuItem or a child menu.
                        // tags:
                        //              protected
                        this._setSelected(true);
                        this.getParent()._onItemFocus(this);

                        this.inherited(arguments);
                },

                _setSelected: function(selected){
                        // summary:
                        //              Indicate that this node is the currently selected one
                        // tags:
                        //              private

                        /***
                         * TODO: remove this method and calls to it, when _onBlur() is working for MenuItem.
                         * Currently _onBlur() gets called when focus is moved from the MenuItem to a child menu.
                         * That's not supposed to happen, but the problem is:
                         * In order to allow dijit.popup's getTopPopup() to work,a sub menu's popupParent
                         * points to the parent Menu, bypassing the parent MenuItem... thus the
                         * MenuItem is not in the chain of active widgets and gets a premature call to
                         * _onBlur()
                         */

                        domClass.toggle(this.domNode, "dijitMenuItemSelected", selected);
                },

                setLabel: function(/*String*/ content){
                        // summary:
                        //              Deprecated.   Use set('label', ...) instead.
                        // tags:
                        //              deprecated
                        kernel.deprecated("dijit.MenuItem.setLabel() is deprecated.  Use set('label', ...) instead.", "", "2.0");
                        this.set("label", content);
                },

                setDisabled: function(/*Boolean*/ disabled){
                        // summary:
                        //              Deprecated.   Use set('disabled', bool) instead.
                        // tags:
                        //              deprecated
                        kernel.deprecated("dijit.Menu.setDisabled() is deprecated.  Use set('disabled', bool) instead.", "", "2.0");
                        this.set('disabled', disabled);
                },
                _setDisabledAttr: function(/*Boolean*/ value){
                        // summary:
                        //              Hook for attr('disabled', ...) to work.
                        //              Enable or disable this menu item.

                        this.focusNode.setAttribute('aria-disabled', value ? 'true' : 'false');
                        this._set("disabled", value);
                },
                _setAccelKeyAttr: function(/*String*/ value){
                        // summary:
                        //              Hook for attr('accelKey', ...) to work.
                        //              Set accelKey on this menu item.

                        this.accelKeyNode.style.display=value?"":"none";
                        this.accelKeyNode.innerHTML=value;
                        //have to use colSpan to make it work in IE
                        domAttr.set(this.containerNode,'colSpan',value?"1":"2");

                        this._set("accelKey", value);
                },
                _setTextDirAttr: function(/*String*/ textDir){
                        // summary:
                        //              Setter for textDir.
                        // description:
                        //              Users shouldn't call this function; they should be calling
                        //              set('textDir', value)
                        // tags:
                        //              private

                        // only if new textDir is different from the old one
                        // and on widgets creation.
                        if(!this._created || this.textDir != textDir){
                                this._set("textDir", textDir);
                                this.applyTextDir(this.focusNode, this.label);
                        }
                }               
        });
});

},
'dijit/layout/TabController':function(){
require({cache:{
'url:dijit/layout/templates/_TabButton.html':"<div role=\"presentation\" data-dojo-attach-point=\"titleNode,innerDiv,tabContent\" class=\"dijitTabInner dijitTabContent\">\n\t<img src=\"${_blankGif}\" alt=\"\" class=\"dijitIcon dijitTabButtonIcon\" data-dojo-attach-point='iconNode'/>\n\t<span data-dojo-attach-point='containerNode,focusNode' class='tabLabel'></span>\n\t<span class=\"dijitInline dijitTabCloseButton dijitTabCloseIcon\" data-dojo-attach-point='closeNode'\n\t\t  role=\"presentation\">\n\t\t<span data-dojo-attach-point='closeText' class='dijitTabCloseText'>[x]</span\n\t\t\t\t></span>\n</div>\n"}});
define("dijit/layout/TabController", [
        "dojo/_base/declare", // declare
        "dojo/dom", // dom.setSelectable
        "dojo/dom-attr", // domAttr.attr
        "dojo/dom-class", // domClass.toggle
        "dojo/i18n", // i18n.getLocalization
        "dojo/_base/lang", // lang.hitch lang.trim
        "./StackController",
        "../registry",
        "../Menu",
        "../MenuItem",
        "dojo/text!./templates/_TabButton.html",
        "dojo/i18n!../nls/common"
], function(declare, dom, domAttr, domClass, i18n, lang, StackController, registry, Menu, MenuItem, template){

        // module:
        //              dijit/layout/TabController

        var TabButton = declare("dijit.layout._TabButton", StackController.StackButton, {
                // summary:
                //              A tab (the thing you click to select a pane).
                // description:
                //              Contains the title of the pane, and optionally a close-button to destroy the pane.
                //              This is an internal widget and should not be instantiated directly.
                // tags:
                //              private

                // baseClass: String
                //              The CSS class applied to the domNode.
                baseClass: "dijitTab",

                // Apply dijitTabCloseButtonHover when close button is hovered
                cssStateNodes: {
                        closeNode: "dijitTabCloseButton"
                },

                templateString: template,

                // Override _FormWidget.scrollOnFocus.
                // Don't scroll the whole tab container into view when the button is focused.
                scrollOnFocus: false,

                buildRendering: function(){
                        this.inherited(arguments);

                        dom.setSelectable(this.containerNode, false);
                },

                startup: function(){
                        this.inherited(arguments);
                        var n = this.domNode;

                        // Required to give IE6 a kick, as it initially hides the
                        // tabs until they are focused on.
                        this.defer(function(){
                                n.className = n.className;
                        }, 1);
                },

                _setCloseButtonAttr: function(/*Boolean*/ disp){
                        // summary:
                        //              Hide/show close button
                        this._set("closeButton", disp);
                        domClass.toggle(this.domNode, "dijitClosable", disp);
                        this.closeNode.style.display = disp ? "" : "none";
                        if(disp){
                                var _nlsResources = i18n.getLocalization("dijit", "common");
                                if(this.closeNode){
                                        domAttr.set(this.closeNode, "title", _nlsResources.itemClose);
                                }
                        }
                },

                _setDisabledAttr: function(/*Boolean*/ disabled){
                        // summary:
                        //              Make tab selected/unselectable

                        this.inherited(arguments);

                        // Don't show tooltip for close button when tab is disabled
                        if(this.closeNode){
                                if(disabled){
                                        domAttr.remove(this.closeNode, "title");
                                }else{
                                        var _nlsResources = i18n.getLocalization("dijit", "common");
                                        domAttr.set(this.closeNode, "title", _nlsResources.itemClose);
                                }
                        }
                },

                _setLabelAttr: function(/*String*/ content){
                        // summary:
                        //              Hook for set('label', ...) to work.
                        // description:
                        //              takes an HTML string.
                        //              Inherited ToggleButton implementation will Set the label (text) of the button;
                        //              Need to set the alt attribute of icon on tab buttons if no label displayed
                        this.inherited(arguments);
                        if(!this.showLabel && !this.params.title){
                                this.iconNode.alt = lang.trim(this.containerNode.innerText || this.containerNode.textContent || '');
                        }
                }
        });

        var TabController = declare("dijit.layout.TabController", StackController, {
                // summary:
                //              Set of tabs (the things with titles and a close button, that you click to show a tab panel).
                //              Used internally by `dijit/layout/TabContainer`.
                // description:
                //              Lets the user select the currently shown pane in a TabContainer or StackContainer.
                //              TabController also monitors the TabContainer, and whenever a pane is
                //              added or deleted updates itself accordingly.
                // tags:
                //              private

                baseClass: "dijitTabController",

                templateString: "<div role='tablist' data-dojo-attach-event='onkeypress:onkeypress'></div>",

                // tabPosition: String
                //              Defines where tabs go relative to the content.
                //              "top", "bottom", "left-h", "right-h"
                tabPosition: "top",

                // buttonWidget: Constructor
                //              The tab widget to create to correspond to each page
                buttonWidget: TabButton,

                // buttonWidgetCloseClass: String
                //              Class of [x] close icon, used by event delegation code to tell when close button was clicked
                buttonWidgetCloseClass: "dijitTabCloseButton",

                postCreate: function(){
                        this.inherited(arguments);

                        // Setup a close menu to be shared between all the closable tabs (excluding disabled tabs)
                        var closeMenu = new Menu({
                                id: this.id+"_Menu",
                                ownerDocument: this.ownerDocument,
                                dir: this.dir,
                                lang: this.lang,
                                textDir: this.textDir,
                                targetNodeIds: [this.domNode],
                                selector: function(node){
                                        return domClass.contains(node, "dijitClosable") && !domClass.contains(node, "dijitTabDisabled");
                                }
                        });
                        this.own(closeMenu);

                        var _nlsResources = i18n.getLocalization("dijit", "common"),
                                controller = this;
                        closeMenu.addChild(new MenuItem({
                                label: _nlsResources.itemClose,
                                ownerDocument: this.ownerDocument,
                                dir: this.dir,
                                lang: this.lang,
                                textDir: this.textDir,
                                onClick: function(evt){
                                        var button = registry.byNode(this.getParent().currentTarget);
                                        controller.onCloseButtonClick(button.page);
                                }
                        }));
                }
        });

        TabController.TabButton = TabButton;    // for monkey patching

        return TabController;
});

},
'dijit/layout/_LayoutWidget':function(){
define("dijit/layout/_LayoutWidget", [
        "dojo/_base/lang", // lang.mixin
        "../_Widget",
        "../_Container",
        "../_Contained",
        "../Viewport",
        "dojo/_base/declare", // declare
        "dojo/dom-class", // domClass.add domClass.remove
        "dojo/dom-geometry", // domGeometry.marginBox
        "dojo/dom-style" // domStyle.getComputedStyle
], function(lang, _Widget, _Container, _Contained, Viewport,
        declare, domClass, domGeometry, domStyle){

        // module:
        //              dijit/layout/_LayoutWidget


        return declare("dijit.layout._LayoutWidget", [_Widget, _Container, _Contained], {
                // summary:
                //              Base class for a _Container widget which is responsible for laying out its children.
                //              Widgets which mixin this code must define layout() to manage placement and sizing of the children.

                // baseClass: [protected extension] String
                //              This class name is applied to the widget's domNode
                //              and also may be used to generate names for sub nodes,
                //              for example dijitTabContainer-content.
                baseClass: "dijitLayoutContainer",

                // isLayoutContainer: [protected] Boolean
                //              Indicates that this widget is going to call resize() on its
                //              children widgets, setting their size, when they become visible.
                isLayoutContainer: true,

                buildRendering: function(){
                        this.inherited(arguments);
                        domClass.add(this.domNode, "dijitContainer");
                },

                startup: function(){
                        // summary:
                        //              Called after all the widgets have been instantiated and their
                        //              dom nodes have been inserted somewhere under win.doc.body.
                        //
                        //              Widgets should override this method to do any initialization
                        //              dependent on other widgets existing, and then call
                        //              this superclass method to finish things off.
                        //
                        //              startup() in subclasses shouldn't do anything
                        //              size related because the size of the widget hasn't been set yet.

                        if(this._started){ return; }

                        // Need to call inherited first - so that child widgets get started
                        // up correctly
                        this.inherited(arguments);

                        // If I am a not being controlled by a parent layout widget...
                        var parent = this.getParent && this.getParent();
                        if(!(parent && parent.isLayoutContainer)){
                                // Do recursive sizing and layout of all my descendants
                                // (passing in no argument to resize means that it has to glean the size itself)
                                this.resize();

                                // Since my parent isn't a layout container, and my style *may be* width=height=100%
                                // or something similar (either set directly or via a CSS class),
                                // monitor when viewport size changes so that I can re-layout.
                                this.own(Viewport.on("resize", lang.hitch(this, "resize")));
                        }
                },

                resize: function(changeSize, resultSize){
                        // summary:
                        //              Call this to resize a widget, or after its size has changed.
                        // description:
                        //              ####Change size mode:
                        //
                        //              When changeSize is specified, changes the marginBox of this widget
                        //              and forces it to re-layout its contents accordingly.
                        //              changeSize may specify height, width, or both.
                        //
                        //              If resultSize is specified it indicates the size the widget will
                        //              become after changeSize has been applied.
                        //
                        //              ####Notification mode:
                        //
                        //              When changeSize is null, indicates that the caller has already changed
                        //              the size of the widget, or perhaps it changed because the browser
                        //              window was resized.  Tells widget to re-layout its contents accordingly.
                        //
                        //              If resultSize is also specified it indicates the size the widget has
                        //              become.
                        //
                        //              In either mode, this method also:
                        //
                        //              1. Sets this._borderBox and this._contentBox to the new size of
                        //                      the widget.  Queries the current domNode size if necessary.
                        //              2. Calls layout() to resize contents (and maybe adjust child widgets).
                        // changeSize: Object?
                        //              Sets the widget to this margin-box size and position.
                        //              May include any/all of the following properties:
                        //      |       {w: int, h: int, l: int, t: int}
                        // resultSize: Object?
                        //              The margin-box size of this widget after applying changeSize (if
                        //              changeSize is specified).  If caller knows this size and
                        //              passes it in, we don't need to query the browser to get the size.
                        //      |       {w: int, h: int}

                        var node = this.domNode;

                        // set margin box size, unless it wasn't specified, in which case use current size
                        if(changeSize){
                                domGeometry.setMarginBox(node, changeSize);
                        }

                        // If either height or width wasn't specified by the user, then query node for it.
                        // But note that setting the margin box and then immediately querying dimensions may return
                        // inaccurate results, so try not to depend on it.
                        var mb = resultSize || {};
                        lang.mixin(mb, changeSize || {});       // changeSize overrides resultSize
                        if( !("h" in mb) || !("w" in mb) ){
                                mb = lang.mixin(domGeometry.getMarginBox(node), mb);    // just use domGeometry.marginBox() to fill in missing values
                        }

                        // Compute and save the size of my border box and content box
                        // (w/out calling domGeometry.getContentBox() since that may fail if size was recently set)
                        var cs = domStyle.getComputedStyle(node);
                        var me = domGeometry.getMarginExtents(node, cs);
                        var be = domGeometry.getBorderExtents(node, cs);
                        var bb = (this._borderBox = {
                                w: mb.w - (me.w + be.w),
                                h: mb.h - (me.h + be.h)
                        });
                        var pe = domGeometry.getPadExtents(node, cs);
                        this._contentBox = {
                                l: domStyle.toPixelValue(node, cs.paddingLeft),
                                t: domStyle.toPixelValue(node, cs.paddingTop),
                                w: bb.w - pe.w,
                                h: bb.h - pe.h
                        };

                        // Callback for widget to adjust size of its children
                        this.layout();
                },

                layout: function(){
                        // summary:
                        //              Widgets override this method to size and position their contents/children.
                        //              When this is called this._contentBox is guaranteed to be set (see resize()).
                        //
                        //              This is called after startup(), and also when the widget's size has been
                        //              changed.
                        // tags:
                        //              protected extension
                },

                _setupChild: function(/*dijit/_WidgetBase*/child){
                        // summary:
                        //              Common setup for initial children and children which are added after startup
                        // tags:
                        //              protected extension

                        var cls = this.baseClass + "-child "
                                + (child.baseClass ? this.baseClass + "-" + child.baseClass : "");
                        domClass.add(child.domNode, cls);
                },

                addChild: function(/*dijit/_WidgetBase*/ child, /*Integer?*/ insertIndex){
                        // Overrides _Container.addChild() to call _setupChild()
                        this.inherited(arguments);
                        if(this._started){
                                this._setupChild(child);
                        }
                },

                removeChild: function(/*dijit/_WidgetBase*/ child){
                        // Overrides _Container.removeChild() to remove class added by _setupChild()
                        var cls = this.baseClass + "-child"
                                        + (child.baseClass ?
                                                " " + this.baseClass + "-" + child.baseClass : "");
                        domClass.remove(child.domNode, cls);

                        this.inherited(arguments);
                }
        });
});

},
'dijit/popup':function(){
define("dijit/popup", [
        "dojo/_base/array", // array.forEach array.some
        "dojo/aspect",
        "dojo/_base/connect",   // connect._keypress
        "dojo/_base/declare", // declare
        "dojo/dom", // dom.isDescendant
        "dojo/dom-attr", // domAttr.set
        "dojo/dom-construct", // domConstruct.create domConstruct.destroy
        "dojo/dom-geometry", // domGeometry.isBodyLtr
        "dojo/dom-style", // domStyle.set
        "dojo/_base/event", // event.stop
        "dojo/keys",
        "dojo/_base/lang", // lang.hitch
        "dojo/on",
        "dojo/sniff", // has("ie") has("mozilla")
        "./place",
        "./BackgroundIframe",
        "./main"        // dijit (defining dijit.popup to match API doc)
], function(array, aspect, connect, declare, dom, domAttr, domConstruct, domGeometry, domStyle, event, keys, lang, on, has,
                        place, BackgroundIframe, dijit){

        // module:
        //              dijit/popup

        /*=====
        var __OpenArgs = {
                // popup: Widget
                //              widget to display
                // parent: Widget
                //              the button etc. that is displaying this popup
                // around: DomNode
                //              DOM node (typically a button); place popup relative to this node.  (Specify this *or* "x" and "y" parameters.)
                // x: Integer
                //              Absolute horizontal position (in pixels) to place node at.  (Specify this *or* "around" parameter.)
                // y: Integer
                //              Absolute vertical position (in pixels) to place node at.  (Specify this *or* "around" parameter.)
                // orient: Object|String
                //              When the around parameter is specified, orient should be a list of positions to try, ex:
                //      |       [ "below", "above" ]
                //              For backwards compatibility it can also be an (ordered) hash of tuples of the form
                //              (around-node-corner, popup-node-corner), ex:
                //      |       { "BL": "TL", "TL": "BL" }
                //              where BL means "bottom left" and "TL" means "top left", etc.
                //
                //              dijit/popup.open() tries to position the popup according to each specified position, in order,
                //              until the popup appears fully within the viewport.
                //
                //              The default value is ["below", "above"]
                //
                //              When an (x,y) position is specified rather than an around node, orient is either
                //              "R" or "L".  R (for right) means that it tries to put the popup to the right of the mouse,
                //              specifically positioning the popup's top-right corner at the mouse position, and if that doesn't
                //              fit in the viewport, then it tries, in order, the bottom-right corner, the top left corner,
                //              and the top-right corner.
                // onCancel: Function
                //              callback when user has canceled the popup by:
                //
                //              1. hitting ESC or
                //              2. by using the popup widget's proprietary cancel mechanism (like a cancel button in a dialog);
                //                 i.e. whenever popupWidget.onCancel() is called, args.onCancel is called
                // onClose: Function
                //              callback whenever this popup is closed
                // onExecute: Function
                //              callback when user "executed" on the popup/sub-popup by selecting a menu choice, etc. (top menu only)
                // padding: place.__Position
                //              adding a buffer around the opening position. This is only useful when around is not set.
        };
        =====*/

        function destroyWrapper(){
                // summary:
                //              Function to destroy wrapper when popup widget is destroyed.
                //              Left in this scope to avoid memory leak on IE8 on refresh page, see #15206.
                if(this._popupWrapper){
                        domConstruct.destroy(this._popupWrapper);
                        delete this._popupWrapper;
                }
        }

        var PopupManager = declare(null, {
                // summary:
                //              Used to show drop downs (ex: the select list of a ComboBox)
                //              or popups (ex: right-click context menus).

                // _stack: dijit/_WidgetBase[]
                //              Stack of currently popped up widgets.
                //              (someone opened _stack[0], and then it opened _stack[1], etc.)
                _stack: [],

                // _beginZIndex: Number
                //              Z-index of the first popup.   (If first popup opens other
                //              popups they get a higher z-index.)
                _beginZIndex: 1000,

                _idGen: 1,

                _createWrapper: function(/*Widget*/ widget){
                        // summary:
                        //              Initialization for widgets that will be used as popups.
                        //              Puts widget inside a wrapper DIV (if not already in one),
                        //              and returns pointer to that wrapper DIV.

                        var wrapper = widget._popupWrapper,
                                node = widget.domNode;

                        if(!wrapper){
                                // Create wrapper <div> for when this widget [in the future] will be used as a popup.
                                // This is done early because of IE bugs where creating/moving DOM nodes causes focus
                                // to go wonky, see tests/robot/Toolbar.html to reproduce
                                wrapper = domConstruct.create("div", {
                                        "class":"dijitPopup",
                                        style:{ display: "none"},
                                        role: "presentation"
                                }, widget.ownerDocumentBody);
                                wrapper.appendChild(node);

                                var s = node.style;
                                s.display = "";
                                s.visibility = "";
                                s.position = "";
                                s.top = "0px";

                                widget._popupWrapper = wrapper;
                                aspect.after(widget, "destroy", destroyWrapper, true);
                        }

                        return wrapper;
                },

                moveOffScreen: function(/*Widget*/ widget){
                        // summary:
                        //              Moves the popup widget off-screen.
                        //              Do not use this method to hide popups when not in use, because
                        //              that will create an accessibility issue: the offscreen popup is
                        //              still in the tabbing order.

                        // Create wrapper if not already there
                        var wrapper = this._createWrapper(widget);

                        domStyle.set(wrapper, {
                                visibility: "hidden",
                                top: "-9999px",         // prevent transient scrollbar causing misalign (#5776), and initial flash in upper left (#10111)
                                display: ""
                        });
                },

                hide: function(/*Widget*/ widget){
                        // summary:
                        //              Hide this popup widget (until it is ready to be shown).
                        //              Initialization for widgets that will be used as popups
                        //
                        //              Also puts widget inside a wrapper DIV (if not already in one)
                        //
                        //              If popup widget needs to layout it should
                        //              do so when it is made visible, and popup._onShow() is called.

                        // Create wrapper if not already there
                        var wrapper = this._createWrapper(widget);

                        domStyle.set(wrapper, "display", "none");
                },

                getTopPopup: function(){
                        // summary:
                        //              Compute the closest ancestor popup that's *not* a child of another popup.
                        //              Ex: For a TooltipDialog with a button that spawns a tree of menus, find the popup of the button.
                        var stack = this._stack;
                        for(var pi=stack.length-1; pi > 0 && stack[pi].parent === stack[pi-1].widget; pi--){
                                /* do nothing, just trying to get right value for pi */
                        }
                        return stack[pi];
                },

                open: function(/*__OpenArgs*/ args){
                        // summary:
                        //              Popup the widget at the specified position
                        //
                        // example:
                        //              opening at the mouse position
                        //              |               popup.open({popup: menuWidget, x: evt.pageX, y: evt.pageY});
                        //
                        // example:
                        //              opening the widget as a dropdown
                        //              |               popup.open({parent: this, popup: menuWidget, around: this.domNode, onClose: function(){...}});
                        //
                        //              Note that whatever widget called dijit/popup.open() should also listen to its own _onBlur callback
                        //              (fired from _base/focus.js) to know that focus has moved somewhere else and thus the popup should be closed.

                        var stack = this._stack,
                                widget = args.popup,
                                orient = args.orient || ["below", "below-alt", "above", "above-alt"],
                                ltr = args.parent ? args.parent.isLeftToRight() : domGeometry.isBodyLtr(widget.ownerDocument),
                                around = args.around,
                                id = (args.around && args.around.id) ? (args.around.id+"_dropdown") : ("popup_"+this._idGen++);

                        // If we are opening a new popup that isn't a child of a currently opened popup, then
                        // close currently opened popup(s).   This should happen automatically when the old popups
                        // gets the _onBlur() event, except that the _onBlur() event isn't reliable on IE, see [22198].
                        while(stack.length && (!args.parent || !dom.isDescendant(args.parent.domNode, stack[stack.length-1].widget.domNode))){
                                this.close(stack[stack.length-1].widget);
                        }

                        // Get pointer to popup wrapper, and create wrapper if it doesn't exist
                        var wrapper = this._createWrapper(widget);


                        domAttr.set(wrapper, {
                                id: id,
                                style: {
                                        zIndex: this._beginZIndex + stack.length
                                },
                                "class": "dijitPopup " + (widget.baseClass || widget["class"] || "").split(" ")[0] +"Popup",
                                dijitPopupParent: args.parent ? args.parent.id : ""
                        });

                        if(has("ie") || has("mozilla")){
                                if(!widget.bgIframe){
                                        // setting widget.bgIframe triggers cleanup in _Widget.destroy()
                                        widget.bgIframe = new BackgroundIframe(wrapper);
                                }
                        }

                        // position the wrapper node and make it visible
                        var best = around ?
                                place.around(wrapper, around, orient, ltr, widget.orient ? lang.hitch(widget, "orient") : null) :
                                place.at(wrapper, args, orient == 'R' ? ['TR','BR','TL','BL'] : ['TL','BL','TR','BR'], args.padding);

                        wrapper.style.display = "";
                        wrapper.style.visibility = "visible";
                        widget.domNode.style.visibility = "visible";    // counteract effects from _HasDropDown

                        var handlers = [];

                        // provide default escape and tab key handling
                        // (this will work for any widget, not just menu)
                        handlers.push(on(wrapper, connect._keypress, lang.hitch(this, function(evt){
                                if(evt.charOrCode == keys.ESCAPE && args.onCancel){
                                        event.stop(evt);
                                        args.onCancel();
                                }else if(evt.charOrCode === keys.TAB){
                                        event.stop(evt);
                                        var topPopup = this.getTopPopup();
                                        if(topPopup && topPopup.onCancel){
                                                topPopup.onCancel();
                                        }
                                }
                        })));

                        // watch for cancel/execute events on the popup and notify the caller
                        // (for a menu, "execute" means clicking an item)
                        if(widget.onCancel && args.onCancel){
                                handlers.push(widget.on("cancel", args.onCancel));
                        }

                        handlers.push(widget.on(widget.onExecute ? "execute" : "change", lang.hitch(this, function(){
                                var topPopup = this.getTopPopup();
                                if(topPopup && topPopup.onExecute){
                                        topPopup.onExecute();
                                }
                        })));

                        stack.push({
                                widget: widget,
                                parent: args.parent,
                                onExecute: args.onExecute,
                                onCancel: args.onCancel,
                                onClose: args.onClose,
                                handlers: handlers
                        });

                        if(widget.onOpen){
                                // TODO: in 2.0 standardize onShow() (used by StackContainer) and onOpen() (used here)
                                widget.onOpen(best);
                        }

                        return best;
                },

                close: function(/*Widget?*/ popup){
                        // summary:
                        //              Close specified popup and any popups that it parented.
                        //              If no popup is specified, closes all popups.

                        var stack = this._stack;

                        // Basically work backwards from the top of the stack closing popups
                        // until we hit the specified popup, but IIRC there was some issue where closing
                        // a popup would cause others to close too.  Thus if we are trying to close B in [A,B,C]
                        // closing C might close B indirectly and then the while() condition will run where stack==[A]...
                        // so the while condition is constructed defensively.
                        while((popup && array.some(stack, function(elem){return elem.widget == popup;})) ||
                                (!popup && stack.length)){
                                var top = stack.pop(),
                                        widget = top.widget,
                                        onClose = top.onClose;

                                if(widget.onClose){
                                        // TODO: in 2.0 standardize onHide() (used by StackContainer) and onClose() (used here)
                                        widget.onClose();
                                }

                                var h;
                                while(h = top.handlers.pop()){ h.remove(); }

                                // Hide the widget and it's wrapper unless it has already been destroyed in above onClose() etc.
                                if(widget && widget.domNode){
                                        this.hide(widget);
                                }

                                if(onClose){
                                        onClose();
                                }
                        }
                }
        });

        return (dijit.popup = new PopupManager());
});

},
'dijit/_base/manager':function(){
define("dijit/_base/manager", [
        "dojo/_base/array",
        "dojo/_base/config", // defaultDuration
        "dojo/_base/lang",
        "../registry",
        "../main"       // for setting exports to dijit namespace
], function(array, config, lang, registry, dijit){

        // module:
        //              dijit/_base/manager

        var exports = {
                // summary:
                //              Deprecated.  Shim to methods on registry, plus a few other declarations.
                //              New code should access dijit/registry directly when possible.
        };

        array.forEach(["byId", "getUniqueId", "findWidgets", "_destroyAll", "byNode", "getEnclosingWidget"], function(name){
                exports[name] = registry[name];
        });

         lang.mixin(exports, {
                 // defaultDuration: Integer
                 //             The default fx.animation speed (in ms) to use for all Dijit
                 //             transitional fx.animations, unless otherwise specified
                 //             on a per-instance basis. Defaults to 200, overrided by
                 //             `djConfig.defaultDuration`
                 defaultDuration: config["defaultDuration"] || 200
         });

        lang.mixin(dijit, exports);

        /*===== return exports; =====*/
        return dijit;   // for back compat :-(
});

},
'dijit/layout/StackController':function(){
define("dijit/layout/StackController", [
        "dojo/_base/array", // array.forEach array.indexOf array.map
        "dojo/_base/declare", // declare
        "dojo/dom-class",
        "dojo/_base/event", // event.stop
        "dojo/keys", // keys
        "dojo/_base/lang", // lang.getObject
        "dojo/on",
        "../focus",             // focus.focus()
        "../registry",  // registry.byId
        "../_Widget",
        "../_TemplatedMixin",
        "../_Container",
        "../form/ToggleButton",
        "dojo/i18n!../nls/common"
], function(array, declare, domClass, event, keys, lang, on,
                        focus, registry, _Widget, _TemplatedMixin, _Container, ToggleButton){

        // module:
        //              dijit/layout/StackController

        var StackButton = declare("dijit.layout._StackButton", ToggleButton, {
                // summary:
                //              Internal widget used by StackContainer.
                // description:
                //              The button-like or tab-like object you click to select or delete a page
                // tags:
                //              private

                // Override _FormWidget.tabIndex.
                // StackContainer buttons are not in the tab order by default.
                // Probably we should be calling this.startupKeyNavChildren() instead.
                tabIndex: "-1",

                // closeButton: Boolean
                //              When true, display close button for this tab
                closeButton: false,
                
                _aria_attr: "aria-selected",

                buildRendering: function(/*Event*/ evt){
                        this.inherited(arguments);
                        (this.focusNode || this.domNode).setAttribute("role", "tab");
                }
        });


        var StackController = declare("dijit.layout.StackController", [_Widget, _TemplatedMixin, _Container], {
                // summary:
                //              Set of buttons to select a page in a `dijit/layout/StackContainer`
                // description:
                //              Monitors the specified StackContainer, and whenever a page is
                //              added, deleted, or selected, updates itself accordingly.

                baseClass: "dijitStackController",

                templateString: "<span role='tablist' data-dojo-attach-event='onkeypress'></span>",

                // containerId: [const] String
                //              The id of the page container that I point to
                containerId: "",

                // buttonWidget: [const] Constructor
                //              The button widget to create to correspond to each page
                buttonWidget: StackButton,

                // buttonWidgetCloseClass: String
                //              CSS class of [x] close icon, used by event delegation code to tell when close button was clicked
                buttonWidgetCloseClass: "dijitStackCloseButton",

                constructor: function(params /*===== , srcNodeRef =====*/){
                        // summary:
                        //              Create the widget.
                        // params: Object|null
                        //              Hash of initialization parameters for widget, including scalar values (like title, duration etc.)
                        //              and functions, typically callbacks like onClick.
                        //              The hash can contain any of the widget's properties, excluding read-only properties.
                        // srcNodeRef: DOMNode|String?
                        //              If a srcNodeRef (DOM node) is specified, replace srcNodeRef with my generated DOM tree

                        this.pane2button = {};          // mapping from pane id to buttons
                },

                postCreate: function(){
                        this.inherited(arguments);

                        // Listen to notifications from StackContainer.
                        // TODO: do this through bubbled events instead of topics
                        this.subscribe(this.containerId+"-startup", "onStartup");
                        this.subscribe(this.containerId+"-addChild", "onAddChild");
                        this.subscribe(this.containerId+"-removeChild", "onRemoveChild");
                        this.subscribe(this.containerId+"-selectChild", "onSelectChild");
                        this.subscribe(this.containerId+"-containerKeyPress", "onContainerKeyPress");

                        // Listen for click events to select or close tabs.
                        // No need to worry about ENTER/SPACE key handling: tabs are selected via left/right arrow keys,
                        // and closed via shift-F10 (to show the close menu).
                        this.connect(this.containerNode, 'click', function(evt){
                                var button = registry.getEnclosingWidget(evt.target);
                                if(button != this.containerNode && !button.disabled && button.page){
                                        for(var target = evt.target; target !== this.containerNode; target = target.parentNode){
                                                if(domClass.contains(target, this.buttonWidgetCloseClass)){
                                                        this.onCloseButtonClick(button.page);
                                                        break;
                                                }else if(target == button.domNode){
                                                        this.onButtonClick(button.page);
                                                        break;
                                                }
                                        }
                                }
                        });
                },

                onStartup: function(/*Object*/ info){
                        // summary:
                        //              Called after StackContainer has finished initializing
                        // tags:
                        //              private
                        array.forEach(info.children, this.onAddChild, this);
                        if(info.selected){
                                // Show button corresponding to selected pane (unless selected
                                // is null because there are no panes)
                                this.onSelectChild(info.selected);
                        }

                        // Reflect events like page title changes to tab buttons
                        var containerNode = registry.byId(this.containerId).containerNode,
                                pane2button = this.pane2button,
                                paneToButtonAttr = {
                                        "title": "label",
                                        "showtitle": "showLabel",
                                        "iconclass": "iconClass",
                                        "closable": "closeButton",
                                        "tooltip": "title",
                                        "disabled": "disabled"
                                },
                                connectFunc = function(attr, buttonAttr){
                                        return on(containerNode, "attrmodified-" + attr, function(evt){
                                                var button = pane2button[evt.detail && evt.detail.widget && evt.detail.widget.id];
                                                if(button){
                                                        button.set(buttonAttr, evt.detail.newValue);
                                                }
                                        });
                                };
                        for(var attr in paneToButtonAttr){
                                this.own(connectFunc(attr, paneToButtonAttr[attr]));
                        }
                },

                destroy: function(){
                        // Since the buttons are internal to the StackController widget, destroy() should remove them, which is
                        // done by calling onRemoveChild().
                        for(var pane in this.pane2button){
                                this.onRemoveChild(registry.byId(pane));
                        }

                        // TODO: destroyRecursive() will call destroy() on each child button twice.   Once from the above code,
                        // and once because _WidgetBase.destroyDescendants() deletes anything inside of this.containerNode.
                        // Probably shouldn't attach that DOMNode as this.containerNode.

                        this.inherited(arguments);
                },

                onAddChild: function(/*dijit/_WidgetBase*/ page, /*Integer?*/ insertIndex){
                        // summary:
                        //              Called whenever a page is added to the container.
                        //              Create button corresponding to the page.
                        // tags:
                        //              private

                        // create an instance of the button widget
                        // (remove typeof buttonWidget == string support in 2.0)
                        var Cls = lang.isString(this.buttonWidget) ? lang.getObject(this.buttonWidget) : this.buttonWidget;
                        var button = new Cls({
                                id: this.id + "_" + page.id,
                                name: this.id + "_" + page.id,
                                label: page.title,
                                disabled: page.disabled,
                                ownerDocument: this.ownerDocument,
                                dir: page.dir,
                                lang: page.lang,
                                textDir: page.textDir,
                                showLabel: page.showTitle,
                                iconClass: page.iconClass,
                                closeButton: page.closable,
                                title: page.tooltip,
                                page: page
                        });

                        this.addChild(button, insertIndex);
                        this.pane2button[page.id] = button;
                        page.controlButton = button;    // this value might be overwritten if two tabs point to same container
                        if(!this._currentChild){
                                // If this is the first child then StackContainer will soon publish that it's selected,
                                // but before that StackContainer calls layout(), and before layout() is called the
                                // StackController needs to have the proper height... which means that the button needs
                                // to be marked as selected now.   See test_TabContainer_CSS.html for test.
                                this.onSelectChild(page);
                        }
                },

                onRemoveChild: function(/*dijit/_WidgetBase*/ page){
                        // summary:
                        //              Called whenever a page is removed from the container.
                        //              Remove the button corresponding to the page.
                        // tags:
                        //              private

                        if(this._currentChild === page){ this._currentChild = null; }

                        var button = this.pane2button[page.id];
                        if(button){
                                this.removeChild(button);
                                delete this.pane2button[page.id];
                                button.destroy();
                        }
                        delete page.controlButton;
                },

                onSelectChild: function(/*dijit/_WidgetBase*/ page){
                        // summary:
                        //              Called when a page has been selected in the StackContainer, either by me or by another StackController
                        // tags:
                        //              private

                        if(!page){ return; }

                        if(this._currentChild){
                                var oldButton=this.pane2button[this._currentChild.id];
                                oldButton.set('checked', false);
                                oldButton.focusNode.setAttribute("tabIndex", "-1");
                        }

                        var newButton=this.pane2button[page.id];
                        newButton.set('checked', true);
                        this._currentChild = page;
                        newButton.focusNode.setAttribute("tabIndex", "0");
                        var container = registry.byId(this.containerId);
                        container.containerNode.setAttribute("aria-labelledby", newButton.id);
                },

                onButtonClick: function(/*dijit/_WidgetBase*/ page){
                        // summary:
                        //              Called whenever one of my child buttons is pressed in an attempt to select a page
                        // tags:
                        //              private

                        var button = this.pane2button[page.id];

                        // For TabContainer where the tabs are <span>, need to set focus explicitly when left/right arrow
                        focus.focus(button.focusNode);

                        if(this._currentChild && this._currentChild.id === page.id) {
                                //In case the user clicked the checked button, keep it in the checked state because it remains to be the selected stack page.
                                button.set('checked', true);
                        }
                        var container = registry.byId(this.containerId);
                        container.selectChild(page);
                },

                onCloseButtonClick: function(/*dijit/_WidgetBase*/ page){
                        // summary:
                        //              Called whenever one of my child buttons [X] is pressed in an attempt to close a page
                        // tags:
                        //              private

                        var container = registry.byId(this.containerId);
                        container.closeChild(page);
                        if(this._currentChild){
                                var b = this.pane2button[this._currentChild.id];
                                if(b){
                                        focus.focus(b.focusNode || b.domNode);
                                }
                        }
                },

                // TODO: this is a bit redundant with forward, back api in StackContainer
                adjacent: function(/*Boolean*/ forward){
                        // summary:
                        //              Helper for onkeypress to find next/previous button
                        // tags:
                        //              private

                        if(!this.isLeftToRight() && (!this.tabPosition || /top|bottom/.test(this.tabPosition))){ forward = !forward; }
                        // find currently focused button in children array
                        var children = this.getChildren();
                        var idx = array.indexOf(children, this.pane2button[this._currentChild.id]),
                                current = children[idx];

                        // Pick next/previous non-disabled button to focus on.   If we get back to the original button it means
                        // that all buttons must be disabled, so return current child to avoid an infinite loop.
                        var child;
                        do{
                                idx = (idx + (forward ? 1 : children.length - 1)) % children.length;
                                child = children[idx];
                        }while(child.disabled && child != current);

                        return child; // dijit/_WidgetBase
                },

                onkeypress: function(/*Event*/ e){
                        // summary:
                        //              Handle keystrokes on the page list, for advancing to next/previous button
                        //              and closing the current page if the page is closable.
                        // tags:
                        //              private

                        if(this.disabled || e.altKey ){ return; }
                        var forward = null;
                        if(e.ctrlKey || !e._djpage){
                                switch(e.charOrCode){
                                        case keys.LEFT_ARROW:
                                        case keys.UP_ARROW:
                                                if(!e._djpage){ forward = false; }
                                                break;
                                        case keys.PAGE_UP:
                                                if(e.ctrlKey){ forward = false; }
                                                break;
                                        case keys.RIGHT_ARROW:
                                        case keys.DOWN_ARROW:
                                                if(!e._djpage){ forward = true; }
                                                break;
                                        case keys.PAGE_DOWN:
                                                if(e.ctrlKey){ forward = true; }
                                                break;
                                        case keys.HOME:
                                                // Navigate to first non-disabled child
                                                var children = this.getChildren();
                                                for(var idx = 0; idx < children.length; idx++){
                                                        var child = children[idx];
                                                        if(!child.disabled){
                                                                this.onButtonClick(child.page);
                                                                break;
                                                        }
                                                }
                                                event.stop(e);
                                                break;
                                        case keys.END:
                                                // Navigate to last non-disabled child
                                                var children = this.getChildren();
                                                for(var idx = children.length-1; idx >= 0; idx--){
                                                        var child = children[idx];
                                                        if(!child.disabled){
                                                                this.onButtonClick(child.page);
                                                                break;
                                                        }
                                                }
                                                event.stop(e);
                                                break;
                                        case keys.DELETE:
                                                if(this._currentChild.closable){
                                                        this.onCloseButtonClick(this._currentChild);
                                                }
                                                event.stop(e);
                                                break;
                                        default:
                                                if(e.ctrlKey){
                                                        if(e.charOrCode === keys.TAB){
                                                                this.onButtonClick(this.adjacent(!e.shiftKey).page);
                                                                event.stop(e);
                                                        }else if(e.charOrCode == "w"){
                                                                if(this._currentChild.closable){
                                                                        this.onCloseButtonClick(this._currentChild);
                                                                }
                                                                event.stop(e); // avoid browser tab closing.
                                                        }
                                                }
                                }
                                // handle next/previous page navigation (left/right arrow, etc.)
                                if(forward !== null){
                                        this.onButtonClick(this.adjacent(forward).page);
                                        event.stop(e);
                                }
                        }
                },

                onContainerKeyPress: function(/*Object*/ info){
                        // summary:
                        //              Called when there was a keypress on the container
                        // tags:
                        //              private
                        info.e._djpage = info.page;
                        this.onkeypress(info.e);
                }
        });

        StackController.StackButton = StackButton;      // for monkey patching

        return StackController;
});

},
'dojo/dnd/Mover':function(){
define("dojo/dnd/Mover", [
        "../_base/array", "../_base/declare", "../_base/event", "../_base/lang", "../sniff", "../_base/window",
        "../dom", "../dom-geometry", "../dom-style", "../Evented", "../on", "../touch", "./common", "./autoscroll"
], function(array, declare, event, lang, has, win, dom, domGeom, domStyle, Evented, on, touch, dnd, autoscroll){

// module:
//              dojo/dnd/Mover

return declare("dojo.dnd.Mover", [Evented], {
        // summary:
        //              an object which makes a node follow the mouse, or touch-drag on touch devices.
        //              Used as a default mover, and as a base class for custom movers.

        constructor: function(node, e, host){
                // node: Node
                //              a node (or node's id) to be moved
                // e: Event
                //              a mouse event, which started the move;
                //              only pageX and pageY properties are used
                // host: Object?
                //              object which implements the functionality of the move,
                //              and defines proper events (onMoveStart and onMoveStop)
                this.node = dom.byId(node);
                this.marginBox = {l: e.pageX, t: e.pageY};
                this.mouseButton = e.button;
                var h = (this.host = host), d = node.ownerDocument;
                this.events = [
                        // At the start of a drag, onFirstMove is called, and then the following
                        // listener is disconnected.
                        on(d, touch.move, lang.hitch(this, "onFirstMove")),

                        // These are called continually during the drag
                        on(d, touch.move, lang.hitch(this, "onMouseMove")),

                        // And these are called at the end of the drag
                        on(d, touch.release,  lang.hitch(this, "onMouseUp")),

                        // cancel text selection and text dragging
                        on(d, "dragstart",   event.stop),
                        on(d.body, "selectstart", event.stop)
                ];

                // Tell autoscroll that a drag is starting
                autoscroll.autoScrollStart(d);

                // notify that the move has started
                if(h && h.onMoveStart){
                        h.onMoveStart(this);
                }
        },
        // mouse event processors
        onMouseMove: function(e){
                // summary:
                //              event processor for onmousemove/ontouchmove
                // e: Event
                //              mouse/touch event
                autoscroll.autoScroll(e);
                var m = this.marginBox;
                this.host.onMove(this, {l: m.l + e.pageX, t: m.t + e.pageY}, e);
                event.stop(e);
        },
        onMouseUp: function(e){
                if(has("webkit") && has("mac") && this.mouseButton == 2 ?
                                e.button == 0 : this.mouseButton == e.button){ // TODO Should condition be met for touch devices, too?
                        this.destroy();
                }
                event.stop(e);
        },
        // utilities
        onFirstMove: function(e){
                // summary:
                //              makes the node absolute; it is meant to be called only once.
                //              relative and absolutely positioned nodes are assumed to use pixel units
                var s = this.node.style, l, t, h = this.host;
                switch(s.position){
                        case "relative":
                        case "absolute":
                                // assume that left and top values are in pixels already
                                l = Math.round(parseFloat(s.left)) || 0;
                                t = Math.round(parseFloat(s.top)) || 0;
                                break;
                        default:
                                s.position = "absolute";        // enforcing the absolute mode
                                var m = domGeom.getMarginBox(this.node);
                                // event.pageX/pageY (which we used to generate the initial
                                // margin box) includes padding and margin set on the body.
                                // However, setting the node's position to absolute and then
                                // doing domGeom.marginBox on it *doesn't* take that additional
                                // space into account - so we need to subtract the combined
                                // padding and margin.  We use getComputedStyle and
                                // _getMarginBox/_getContentBox to avoid the extra lookup of
                                // the computed style.
                                var b = win.doc.body;
                                var bs = domStyle.getComputedStyle(b);
                                var bm = domGeom.getMarginBox(b, bs);
                                var bc = domGeom.getContentBox(b, bs);
                                l = m.l - (bc.l - bm.l);
                                t = m.t - (bc.t - bm.t);
                                break;
                }
                this.marginBox.l = l - this.marginBox.l;
                this.marginBox.t = t - this.marginBox.t;
                if(h && h.onFirstMove){
                        h.onFirstMove(this, e);
                }

                // Disconnect touch.move that call this function
                this.events.shift().remove();
        },
        destroy: function(){
                // summary:
                //              stops the move, deletes all references, so the object can be garbage-collected
                array.forEach(this.events, function(handle){ handle.remove(); });
                // undo global settings
                var h = this.host;
                if(h && h.onMoveStop){
                        h.onMoveStop(this);
                }
                // destroy objects
                this.events = this.node = this.host = null;
        }
});

});

},
'dijit/layout/TabContainer':function(){
define("dijit/layout/TabContainer", [
        "dojo/_base/lang", // lang.getObject
        "dojo/_base/declare", // declare
        "./_TabContainerBase",
        "./TabController",
        "./ScrollingTabController"
], function(lang, declare, _TabContainerBase, TabController, ScrollingTabController){

        // module:
        //              dijit/layout/TabContainer


        return declare("dijit.layout.TabContainer", _TabContainerBase, {
                // summary:
                //              A Container with tabs to select each child (only one of which is displayed at a time).
                // description:
                //              A TabContainer is a container that has multiple panes, but shows only
                //              one pane at a time.  There are a set of tabs corresponding to each pane,
                //              where each tab has the name (aka title) of the pane, and optionally a close button.
                //
                //              See `StackContainer.ChildWidgetProperties` for details on the properties that can be set on
                //              children of a `TabContainer`.

                // useMenu: [const] Boolean
                //              True if a menu should be used to select tabs when they are too
                //              wide to fit the TabContainer, false otherwise.
                useMenu: true,

                // useSlider: [const] Boolean
                //              True if a slider should be used to select tabs when they are too
                //              wide to fit the TabContainer, false otherwise.
                useSlider: true,

                // controllerWidget: Class
                //              An optional parameter to override the widget used to display the tab labels
                controllerWidget: "",

                _makeController: function(/*DomNode*/ srcNode){
                        // summary:
                        //              Instantiate tablist controller widget and return reference to it.
                        //              Callback from _TabContainerBase.postCreate().
                        // tags:
                        //              protected extension

                        // "string" branch for back-compat, remove for 2.0
                        var cls = this.baseClass + "-tabs" + (this.doLayout ? "" : " dijitTabNoLayout"),
                                TabController = typeof this.controllerWidget == "string" ? lang.getObject(this.controllerWidget) :
                                                this.controllerWidget;

                        return new TabController({
                                id: this.id + "_tablist",
                                ownerDocument: this.ownerDocument,
                                dir: this.dir,
                                lang: this.lang,
                                textDir: this.textDir,
                                tabPosition: this.tabPosition,
                                doLayout: this.doLayout,
                                containerId: this.id,
                                "class": cls,
                                nested: this.nested,
                                useMenu: this.useMenu,
                                useSlider: this.useSlider,
                                tabStripClass: this.tabStrip ? this.baseClass + (this.tabStrip ? "":"No") + "Strip": null
                        }, srcNode);
                },

                postMixInProperties: function(){
                        this.inherited(arguments);

                        // Scrolling controller only works for horizontal non-nested tabs
                        if(!this.controllerWidget){
                                this.controllerWidget = (this.tabPosition == "top" || this.tabPosition == "bottom") && !this.nested ?
                                                        ScrollingTabController : TabController;
                        }
                }
        });
});

},
'dijit/BackgroundIframe':function(){
define("dijit/BackgroundIframe", [
        "require",                      // require.toUrl
        "./main",       // to export dijit.BackgroundIframe
        "dojo/_base/config",
        "dojo/dom-construct", // domConstruct.create
        "dojo/dom-style", // domStyle.set
        "dojo/_base/lang", // lang.extend lang.hitch
        "dojo/on",
        "dojo/sniff", // has("ie"), has("mozilla"), has("quirks")
        "dojo/_base/window" // win.doc.createElement
], function(require, dijit, config, domConstruct, domStyle, lang, on, has, win){

        // module:
        //              dijit/BackgroundIFrame

        // TODO: remove _frames, it isn't being used much, since popups never release their
        // iframes (see [22236])
        var _frames = new function(){
                // summary:
                //              cache of iframes

                var queue = [];

                this.pop = function(){
                        var iframe;
                        if(queue.length){
                                iframe = queue.pop();
                                iframe.style.display="";
                        }else{
                                if(has("ie") < 9){
                                        var burl = config["dojoBlankHtmlUrl"] || require.toUrl("dojo/resources/blank.html") || "javascript:\"\"";
                                        var html="<iframe src='" + burl + "' role='presentation'"
                                                + " style='position: absolute; left: 0px; top: 0px;"
                                                + "z-index: -1; filter:Alpha(Opacity=\"0\");'>";
                                        iframe = win.doc.createElement(html);
                                }else{
                                        iframe = domConstruct.create("iframe");
                                        iframe.src = 'javascript:""';
                                        iframe.className = "dijitBackgroundIframe";
                                        iframe.setAttribute("role", "presentation");
                                        domStyle.set(iframe, "opacity", 0.1);
                                }
                                iframe.tabIndex = -1; // Magic to prevent iframe from getting focus on tab keypress - as style didn't work.
                        }
                        return iframe;
                };

                this.push = function(iframe){
                        iframe.style.display="none";
                        queue.push(iframe);
                }
        }();


        dijit.BackgroundIframe = function(/*DomNode*/ node){
                // summary:
                //              For IE/FF z-index schenanigans. id attribute is required.
                //
                // description:
                //              new dijit.BackgroundIframe(node).
                //
                //              Makes a background iframe as a child of node, that fills
                //              area (and position) of node

                if(!node.id){ throw new Error("no id"); }
                if(has("ie") || has("mozilla")){
                        var iframe = (this.iframe = _frames.pop());
                        node.appendChild(iframe);
                        if(has("ie")<7 || has("quirks")){
                                this.resize(node);
                                this._conn = on(node, 'resize', lang.hitch(this, function(){
                                        this.resize(node);
                                }));
                        }else{
                                domStyle.set(iframe, {
                                        width: '100%',
                                        height: '100%'
                                });
                        }
                }
        };

        lang.extend(dijit.BackgroundIframe, {
                resize: function(node){
                        // summary:
                        //              Resize the iframe so it's the same size as node.
                        //              Needed on IE6 and IE/quirks because height:100% doesn't work right.
                        if(this.iframe){
                                domStyle.set(this.iframe, {
                                        width: node.offsetWidth + 'px',
                                        height: node.offsetHeight + 'px'
                                });
                        }
                },
                destroy: function(){
                        // summary:
                        //              destroy the iframe
                        if(this._conn){
                                this._conn.remove();
                                this._conn = null;
                        }
                        if(this.iframe){
                                _frames.push(this.iframe);
                                delete this.iframe;
                        }
                }
        });

        return dijit.BackgroundIframe;
});

},
'url:dijit/templates/Menu.html':"<table class=\"dijit dijitMenu dijitMenuPassive dijitReset dijitMenuTable\" role=\"menu\" tabIndex=\"${tabIndex}\"\n\t   data-dojo-attach-event=\"onkeypress:_onKeyPress\" cellspacing=\"0\">\n\t<tbody class=\"dijitReset\" data-dojo-attach-point=\"containerNode\"></tbody>\n</table>\n",
'dojo/dnd/Avatar':function(){
define("dojo/dnd/Avatar", [
        "../_base/declare",
        "../_base/window",
        "../dom",
        "../dom-attr",
        "../dom-class",
        "../dom-construct",
        "../hccss",
        "../query"
], function(declare, win, dom, domAttr, domClass, domConstruct, has, query){

// module:
//              dojo/dnd/Avatar

return declare("dojo.dnd.Avatar", null, {
        // summary:
        //              Object that represents transferred DnD items visually
        // manager: Object
        //              a DnD manager object

        constructor: function(manager){
                this.manager = manager;
                this.construct();
        },

        // methods
        construct: function(){
                // summary:
                //              constructor function;
                //              it is separate so it can be (dynamically) overwritten in case of need

                var a = domConstruct.create("table", {
                                "class": "dojoDndAvatar",
                                style: {
                                        position: "absolute",
                                        zIndex:   "1999",
                                        margin:   "0px"
                                }
                        }),
                        source = this.manager.source, node,
                        b = domConstruct.create("tbody", null, a),
                        tr = domConstruct.create("tr", null, b),
                        td = domConstruct.create("td", null, tr),
                        k = Math.min(5, this.manager.nodes.length), i = 0;

                if(has("highcontrast")){
                        domConstruct.create("span", {
                                id : "a11yIcon",
                                innerHTML : this.manager.copy ? '+' : "<"
                        }, td)
                }
                domConstruct.create("span", {
                        innerHTML: source.generateText ? this._generateText() : ""
                }, td);

                // we have to set the opacity on IE only after the node is live
                domAttr.set(tr, {
                        "class": "dojoDndAvatarHeader",
                        style: {opacity: 0.9}
                });
                for(; i < k; ++i){
                        if(source.creator){
                                // create an avatar representation of the node
                                node = source._normalizedCreator(source.getItem(this.manager.nodes[i].id).data, "avatar").node;
                        }else{
                                // or just clone the node and hope it works
                                node = this.manager.nodes[i].cloneNode(true);
                                if(node.tagName.toLowerCase() == "tr"){
                                        // insert extra table nodes
                                        var table = domConstruct.create("table"),
                                                tbody = domConstruct.create("tbody", null, table);
                                        tbody.appendChild(node);
                                        node = table;
                                }
                        }
                        node.id = "";
                        tr = domConstruct.create("tr", null, b);
                        td = domConstruct.create("td", null, tr);
                        td.appendChild(node);
                        domAttr.set(tr, {
                                "class": "dojoDndAvatarItem",
                                style: {opacity: (9 - i) / 10}
                        });
                }
                this.node = a;
        },
        destroy: function(){
                // summary:
                //              destructor for the avatar; called to remove all references so it can be garbage-collected
                domConstruct.destroy(this.node);
                this.node = false;
        },
        update: function(){
                // summary:
                //              updates the avatar to reflect the current DnD state
                domClass.toggle(this.node, "dojoDndAvatarCanDrop", this.manager.canDropFlag);
                if(has("highcontrast")){
                        var icon = dom.byId("a11yIcon");
                        var text = '+';   // assume canDrop && copy
                        if (this.manager.canDropFlag && !this.manager.copy){
                                text = '< '; // canDrop && move
                        }else if (!this.manager.canDropFlag && !this.manager.copy){
                                text = "o"; //!canDrop && move
                        }else if(!this.manager.canDropFlag){
                                text = 'x';  // !canDrop && copy
                        }
                        icon.innerHTML=text;
                }
                // replace text
                query(("tr.dojoDndAvatarHeader td span" +(has("highcontrast") ? " span" : "")), this.node).forEach(
                        function(node){
                                node.innerHTML = this.manager.source.generateText ? this._generateText() : "";
                        }, this);
        },
        _generateText: function(){
                // summary:
                //              generates a proper text to reflect copying or moving of items
                return this.manager.nodes.length.toString();
        }
});

});

},
'dijit/form/Button':function(){
require({cache:{
'url:dijit/form/templates/Button.html':"<span class=\"dijit dijitReset dijitInline\" role=\"presentation\"\n\t><span class=\"dijitReset dijitInline dijitButtonNode\"\n\t\tdata-dojo-attach-event=\"ondijitclick:_onClick\" role=\"presentation\"\n\t\t><span class=\"dijitReset dijitStretch dijitButtonContents\"\n\t\t\tdata-dojo-attach-point=\"titleNode,focusNode\"\n\t\t\trole=\"button\" aria-labelledby=\"${id}_label\"\n\t\t\t><span class=\"dijitReset dijitInline dijitIcon\" data-dojo-attach-point=\"iconNode\"></span\n\t\t\t><span class=\"dijitReset dijitToggleButtonIconChar\">&#x25CF;</span\n\t\t\t><span class=\"dijitReset dijitInline dijitButtonText\"\n\t\t\t\tid=\"${id}_label\"\n\t\t\t\tdata-dojo-attach-point=\"containerNode\"\n\t\t\t></span\n\t\t></span\n\t></span\n\t><input ${!nameAttrSetting} type=\"${type}\" value=\"${value}\" class=\"dijitOffScreen\"\n\t\ttabIndex=\"-1\" role=\"presentation\" data-dojo-attach-point=\"valueNode\"\n/></span>\n"}});
define("dijit/form/Button", [
        "require",
        "dojo/_base/declare", // declare
        "dojo/dom-class", // domClass.toggle
        "dojo/has",                     // has("dijit-legacy-requires")
        "dojo/_base/kernel", // kernel.deprecated
        "dojo/_base/lang", // lang.trim
        "dojo/ready",
        "./_FormWidget",
        "./_ButtonMixin",
        "dojo/text!./templates/Button.html"
], function(require, declare, domClass, has, kernel, lang, ready, _FormWidget, _ButtonMixin, template){

// module:
//              dijit/form/Button

// Back compat w/1.6, remove for 2.0
if(has("dijit-legacy-requires")){
        ready(0, function(){
                var requires = ["dijit/form/DropDownButton", "dijit/form/ComboButton", "dijit/form/ToggleButton"];
                require(requires);      // use indirection so modules not rolled into a build
        });
}

return declare("dijit.form.Button", [_FormWidget, _ButtonMixin], {
        // summary:
        //              Basically the same thing as a normal HTML button, but with special styling.
        // description:
        //              Buttons can display a label, an icon, or both.
        //              A label should always be specified (through innerHTML) or the label
        //              attribute.  It can be hidden via showLabel=false.
        // example:
        // |    <button data-dojo-type="dijit/form/Button" onClick="...">Hello world</button>
        //
        // example:
        // |    var button1 = new Button({label: "hello world", onClick: foo});
        // |    dojo.body().appendChild(button1.domNode);

        // showLabel: Boolean
        //              Set this to true to hide the label text and display only the icon.
        //              (If showLabel=false then iconClass must be specified.)
        //              Especially useful for toolbars.
        //              If showLabel=true, the label will become the title (a.k.a. tooltip/hint) of the icon.
        //
        //              The exception case is for computers in high-contrast mode, where the label
        //              will still be displayed, since the icon doesn't appear.
        showLabel: true,

        // iconClass: String
        //              Class to apply to DOMNode in button to make it display an icon
        iconClass: "dijitNoIcon",
        _setIconClassAttr: { node: "iconNode", type: "class" },

        baseClass: "dijitButton",

        templateString: template,

        // Map widget attributes to DOMNode attributes.
        _setValueAttr: "valueNode",

        _onClick: function(/*Event*/ e){
                // summary:
                //              Internal function to handle click actions
                var ok = this.inherited(arguments);
                if(ok){
                        if(this.valueNode){
                                this.valueNode.click();
                                e.preventDefault(); // cancel BUTTON click and continue with hidden INPUT click
                e.stopPropagation();    // avoid two events bubbling from Button widget
                                // leave ok = true so that subclasses can do what they need to do
                        }
                }
                return ok;
        },

        _fillContent: function(/*DomNode*/ source){
                // Overrides _Templated._fillContent().
                // If button label is specified as srcNodeRef.innerHTML rather than
                // this.params.label, handle it here.
                // TODO: remove the method in 2.0, parser will do it all for me
                if(source && (!this.params || !("label" in this.params))){
                        var sourceLabel = lang.trim(source.innerHTML);
                        if(sourceLabel){
                                this.label = sourceLabel; // _applyAttributes will be called after buildRendering completes to update the DOM
                        }
                }
        },

        _setShowLabelAttr: function(val){
                if(this.containerNode){
                        domClass.toggle(this.containerNode, "dijitDisplayNone", !val);
                }
                this._set("showLabel", val);
        },

        setLabel: function(/*String*/ content){
                // summary:
                //              Deprecated.  Use set('label', ...) instead.
                kernel.deprecated("dijit.form.Button.setLabel() is deprecated.  Use set('label', ...) instead.", "", "2.0");
                this.set("label", content);
        },

        _setLabelAttr: function(/*String*/ content){
                // summary:
                //              Hook for set('label', ...) to work.
                // description:
                //              Set the label (text) of the button; takes an HTML string.
                //              If the label is hidden (showLabel=false) then and no title has
                //              been specified, then label is also set as title attribute of icon.
                this.inherited(arguments);
                if(!this.showLabel && !("title" in this.params)){
                        this.titleNode.title = lang.trim(this.containerNode.innerText || this.containerNode.textContent || '');
                }
        }
});


});


},
'url:dijit/layout/templates/TabContainer.html':"<div class=\"dijitTabContainer\">\n\t<div class=\"dijitTabListWrapper\" data-dojo-attach-point=\"tablistNode\"></div>\n\t<div data-dojo-attach-point=\"tablistSpacer\" class=\"dijitTabSpacer ${baseClass}-spacer\"></div>\n\t<div class=\"dijitTabPaneWrapper ${baseClass}-container\" data-dojo-attach-point=\"containerNode\"></div>\n</div>\n",
'dojo/dnd/move':function(){
define("dojo/dnd/move", [
        "../_base/declare",
        "../dom-geometry", "../dom-style",
        "./common", "./Mover", "./Moveable"
], function(declare, domGeom, domStyle, dnd, Mover, Moveable){

// module:
//              dojo/dnd/move

/*=====
var __constrainedMoveableArgs = declare([Moveable.__MoveableArgs], {
        // constraints: Function
        //              Calculates a constraint box.
        //              It is called in a context of the moveable object.
        constraints: function(){},

        // within: Boolean
        //              restrict move within boundaries.
        within: false
});
=====*/

var constrainedMoveable = declare("dojo.dnd.move.constrainedMoveable", Moveable, {
        // object attributes (for markup)
        constraints: function(){},
        within: false,

        constructor: function(node, params){
                // summary:
                //              an object that makes a node moveable
                // node: Node
                //              a node (or node's id) to be moved
                // params: __constrainedMoveableArgs?
                //              an optional object with additional parameters;
                //              the rest is passed to the base class
                if(!params){ params = {}; }
                this.constraints = params.constraints;
                this.within = params.within;
        },
        onFirstMove: function(/*Mover*/ mover){
                // summary:
                //              called during the very first move notification;
                //              can be used to initialize coordinates, can be overwritten.
                var c = this.constraintBox = this.constraints.call(this, mover);
                c.r = c.l + c.w;
                c.b = c.t + c.h;
                if(this.within){
                        var mb = domGeom.getMarginSize(mover.node);
                        c.r -= mb.w;
                        c.b -= mb.h;
                }
        },
        onMove: function(/*Mover*/ mover, /*Object*/ leftTop){
                // summary:
                //              called during every move notification;
                //              should actually move the node; can be overwritten.
                var c = this.constraintBox, s = mover.node.style;
                this.onMoving(mover, leftTop);
                leftTop.l = leftTop.l < c.l ? c.l : c.r < leftTop.l ? c.r : leftTop.l;
                leftTop.t = leftTop.t < c.t ? c.t : c.b < leftTop.t ? c.b : leftTop.t;
                s.left = leftTop.l + "px";
                s.top  = leftTop.t + "px";
                this.onMoved(mover, leftTop);
        }
});

/*=====
var __boxConstrainedMoveableArgs = declare([__constrainedMoveableArgs], {
        // box: Object
        //              a constraint box
        box: {}
});
=====*/

var boxConstrainedMoveable = declare("dojo.dnd.move.boxConstrainedMoveable", constrainedMoveable, {
        // box:
        //              object attributes (for markup)
        box: {},

        constructor: function(node, params){
                // summary:
                //              an object, which makes a node moveable
                // node: Node
                //              a node (or node's id) to be moved
                // params: __boxConstrainedMoveableArgs?
                //              an optional object with parameters
                var box = params && params.box;
                this.constraints = function(){ return box; };
        }
});

/*=====
var __parentConstrainedMoveableArgs = declare( [__constrainedMoveableArgs], {
        // area: String
        //              A parent's area to restrict the move.
        //              Can be "margin", "border", "padding", or "content".
        area: ""
});
=====*/

var parentConstrainedMoveable = declare("dojo.dnd.move.parentConstrainedMoveable", constrainedMoveable, {
        // area:
        //              object attributes (for markup)
        area: "content",

        constructor: function(node, params){
                // summary:
                //              an object, which makes a node moveable
                // node: Node
                //              a node (or node's id) to be moved
                // params: __parentConstrainedMoveableArgs?
                //              an optional object with parameters
                var area = params && params.area;
                this.constraints = function(){
                        var n = this.node.parentNode,
                                s = domStyle.getComputedStyle(n),
                                mb = domGeom.getMarginBox(n, s);
                        if(area == "margin"){
                                return mb;      // Object
                        }
                        var t = domGeom.getMarginExtents(n, s);
                        mb.l += t.l, mb.t += t.t, mb.w -= t.w, mb.h -= t.h;
                        if(area == "border"){
                                return mb;      // Object
                        }
                        t = domGeom.getBorderExtents(n, s);
                        mb.l += t.l, mb.t += t.t, mb.w -= t.w, mb.h -= t.h;
                        if(area == "padding"){
                                return mb;      // Object
                        }
                        t = domGeom.getPadExtents(n, s);
                        mb.l += t.l, mb.t += t.t, mb.w -= t.w, mb.h -= t.h;
                        return mb;      // Object
                };
        }
});


return {
        // summary:
        //              TODOC
        constrainedMoveable: constrainedMoveable,
        boxConstrainedMoveable: boxConstrainedMoveable,
        parentConstrainedMoveable: parentConstrainedMoveable
};

});

},
'dijit/_WidgetBase':function(){
define("dijit/_WidgetBase", [
        "require",                      // require.toUrl
        "dojo/_base/array", // array.forEach array.map
        "dojo/aspect",
        "dojo/_base/config", // config.blankGif
        "dojo/_base/connect", // connect.connect
        "dojo/_base/declare", // declare
        "dojo/dom", // dom.byId
        "dojo/dom-attr", // domAttr.set domAttr.remove
        "dojo/dom-class", // domClass.add domClass.replace
        "dojo/dom-construct", // domConstruct.destroy domConstruct.place
        "dojo/dom-geometry",    // isBodyLtr
        "dojo/dom-style", // domStyle.set, domStyle.get
        "dojo/has",
        "dojo/_base/kernel",
        "dojo/_base/lang", // mixin(), isArray(), etc.
        "dojo/on",
        "dojo/ready",
        "dojo/Stateful", // Stateful
        "dojo/topic",
        "dojo/_base/window", // win.doc, win.body()
        "./Destroyable",
        "./registry"    // registry.getUniqueId(), registry.findWidgets()
], function(require, array, aspect, config, connect, declare,
                        dom, domAttr, domClass, domConstruct, domGeometry, domStyle, has, kernel,
                        lang, on, ready, Stateful, topic, win, Destroyable, registry){

// module:
//              dijit/_WidgetBase

// Flag to make dijit load modules the app didn't explicitly request, for backwards compatibility
has.add("dijit-legacy-requires", !kernel.isAsync);

// For back-compat, remove in 2.0.
if(has("dijit-legacy-requires")){
        ready(0, function(){
                var requires = ["dijit/_base/manager"];
                require(requires);      // use indirection so modules not rolled into a build
        });
}

// Nested hash listing attributes for each tag, all strings in lowercase.
// ex: {"div": {"style": true, "tabindex" true}, "form": { ...
var tagAttrs = {};
function getAttrs(obj){
        var ret = {};
        for(var attr in obj){
                ret[attr.toLowerCase()] = true;
        }
        return ret;
}

function nonEmptyAttrToDom(attr){
        // summary:
        //              Returns a setter function that copies the attribute to this.domNode,
        //              or removes the attribute from this.domNode, depending on whether the
        //              value is defined or not.
        return function(val){
                domAttr[val ? "set" : "remove"](this.domNode, attr, val);
                this._set(attr, val);
        };
}

return declare("dijit._WidgetBase", [Stateful, Destroyable], {
        // summary:
        //              Future base class for all Dijit widgets.
        // description:
        //              Future base class for all Dijit widgets.
        //              _Widget extends this class adding support for various features needed by desktop.
        //
        //              Provides stubs for widget lifecycle methods for subclasses to extend, like postMixInProperties(), buildRendering(),
        //              postCreate(), startup(), and destroy(), and also public API methods like set(), get(), and watch().
        //
        //              Widgets can provide custom setters/getters for widget attributes, which are called automatically by set(name, value).
        //              For an attribute XXX, define methods _setXXXAttr() and/or _getXXXAttr().
        //
        //              _setXXXAttr can also be a string/hash/array mapping from a widget attribute XXX to the widget's DOMNodes:
        //
        //              - DOM node attribute
        // |            _setFocusAttr: {node: "focusNode", type: "attribute"}
        // |            _setFocusAttr: "focusNode"      (shorthand)
        // |            _setFocusAttr: ""               (shorthand, maps to this.domNode)
        //              Maps this.focus to this.focusNode.focus, or (last example) this.domNode.focus
        //
        //              - DOM node innerHTML
        //      |               _setTitleAttr: { node: "titleNode", type: "innerHTML" }
        //              Maps this.title to this.titleNode.innerHTML
        //
        //              - DOM node innerText
        //      |               _setTitleAttr: { node: "titleNode", type: "innerText" }
        //              Maps this.title to this.titleNode.innerText
        //
        //              - DOM node CSS class
        // |            _setMyClassAttr: { node: "domNode", type: "class" }
        //              Maps this.myClass to this.domNode.className
        //
        //              If the value of _setXXXAttr is an array, then each element in the array matches one of the
        //              formats of the above list.
        //
        //              If the custom setter is null, no action is performed other than saving the new value
        //              in the widget (in this).
        //
        //              If no custom setter is defined for an attribute, then it will be copied
        //              to this.focusNode (if the widget defines a focusNode), or this.domNode otherwise.
        //              That's only done though for attributes that match DOMNode attributes (title,
        //              alt, aria-labelledby, etc.)

        // id: [const] String
        //              A unique, opaque ID string that can be assigned by users or by the
        //              system. If the developer passes an ID which is known not to be
        //              unique, the specified ID is ignored and the system-generated ID is
        //              used instead.
        id: "",
        _setIdAttr: "domNode",  // to copy to this.domNode even for auto-generated id's

        // lang: [const] String
        //              Rarely used.  Overrides the default Dojo locale used to render this widget,
        //              as defined by the [HTML LANG](http://www.w3.org/TR/html401/struct/dirlang.html#adef-lang) attribute.
        //              Value must be among the list of locales specified during by the Dojo bootstrap,
        //              formatted according to [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt) (like en-us).
        lang: "",
        // set on domNode even when there's a focus node.       but don't set lang="", since that's invalid.
        _setLangAttr: nonEmptyAttrToDom("lang"),

        // dir: [const] String
        //              Bi-directional support, as defined by the [HTML DIR](http://www.w3.org/TR/html401/struct/dirlang.html#adef-dir)
        //              attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
        //              default direction.
        dir: "",
        // set on domNode even when there's a focus node.       but don't set dir="", since that's invalid.
        _setDirAttr: nonEmptyAttrToDom("dir"),  // to set on domNode even when there's a focus node

        // textDir: String
        //              Bi-directional support, the main variable which is responsible for the direction of the text.
        //              The text direction can be different than the GUI direction by using this parameter in creation
        //              of a widget.
        //
        //              Allowed values:
        //
        //              1. "ltr"
        //              2. "rtl"
        //              3. "auto" - contextual the direction of a text defined by first strong letter.
        //
        //              By default is as the page direction.
        textDir: "",

        // class: String
        //              HTML class attribute
        "class": "",
        _setClassAttr: { node: "domNode", type: "class" },

        // style: String||Object
        //              HTML style attributes as cssText string or name/value hash
        style: "",

        // title: String
        //              HTML title attribute.
        //
        //              For form widgets this specifies a tooltip to display when hovering over
        //              the widget (just like the native HTML title attribute).
        //
        //              For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
        //              etc., it's used to specify the tab label, accordion pane title, etc.
        title: "",

        // tooltip: String
        //              When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
        //              this specifies the tooltip to appear when the mouse is hovered over that text.
        tooltip: "",

        // baseClass: [protected] String
        //              Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
        //              widget state.
        baseClass: "",

        // srcNodeRef: [readonly] DomNode
        //              pointer to original DOM node
        srcNodeRef: null,

        // domNode: [readonly] DomNode
        //              This is our visible representation of the widget! Other DOM
        //              Nodes may by assigned to other properties, usually through the
        //              template system's data-dojo-attach-point syntax, but the domNode
        //              property is the canonical "top level" node in widget UI.
        domNode: null,

        // containerNode: [readonly] DomNode
        //              Designates where children of the source DOM node will be placed.
        //              "Children" in this case refers to both DOM nodes and widgets.
        //              For example, for myWidget:
        //
        //              |       <div data-dojo-type=myWidget>
        //              |               <b> here's a plain DOM node
        //              |               <span data-dojo-type=subWidget>and a widget</span>
        //              |               <i> and another plain DOM node </i>
        //              |       </div>
        //
        //              containerNode would point to:
        //
        //              |               <b> here's a plain DOM node
        //              |               <span data-dojo-type=subWidget>and a widget</span>
        //              |               <i> and another plain DOM node </i>
        //
        //              In templated widgets, "containerNode" is set via a
        //              data-dojo-attach-point assignment.
        //
        //              containerNode must be defined for any widget that accepts innerHTML
        //              (like ContentPane or BorderContainer or even Button), and conversely
        //              is null for widgets that don't, like TextBox.
        containerNode: null,

        // ownerDocument: [const] Document?
        //              The document this widget belongs to.  If not specified to constructor, will default to
        //              srcNodeRef.ownerDocument, or if no sourceRef specified, then to dojo/_base/window::doc
        ownerDocument: null,
        _setOwnerDocumentAttr: function(val){
                // this setter is merely to avoid automatically trying to set this.domNode.ownerDocument
                this._set("ownerDocument", val);
        },

/*=====
        // _started: [readonly] Boolean
        //              startup() has completed.
        _started: false,
=====*/

        // attributeMap: [protected] Object
        //              Deprecated.     Instead of attributeMap, widget should have a _setXXXAttr attribute
        //              for each XXX attribute to be mapped to the DOM.
        //
        //              attributeMap sets up a "binding" between attributes (aka properties)
        //              of the widget and the widget's DOM.
        //              Changes to widget attributes listed in attributeMap will be
        //              reflected into the DOM.
        //
        //              For example, calling set('title', 'hello')
        //              on a TitlePane will automatically cause the TitlePane's DOM to update
        //              with the new title.
        //
        //              attributeMap is a hash where the key is an attribute of the widget,
        //              and the value reflects a binding to a:
        //
        //              - DOM node attribute
        // |            focus: {node: "focusNode", type: "attribute"}
        //              Maps this.focus to this.focusNode.focus
        //
        //              - DOM node innerHTML
        //      |               title: { node: "titleNode", type: "innerHTML" }
        //              Maps this.title to this.titleNode.innerHTML
        //
        //              - DOM node innerText
        //      |               title: { node: "titleNode", type: "innerText" }
        //              Maps this.title to this.titleNode.innerText
        //
        //              - DOM node CSS class
        // |            myClass: { node: "domNode", type: "class" }
        //              Maps this.myClass to this.domNode.className
        //
        //              If the value is an array, then each element in the array matches one of the
        //              formats of the above list.
        //
        //              There are also some shorthands for backwards compatibility:
        //
        //              - string --> { node: string, type: "attribute" }, for example:
        //
        //      |       "focusNode" ---> { node: "focusNode", type: "attribute" }
        //
        //              - "" --> { node: "domNode", type: "attribute" }
        attributeMap: {},

        // _blankGif: [protected] String
        //              Path to a blank 1x1 image.
        //              Used by `<img>` nodes in templates that really get their image via CSS background-image.
        _blankGif: config.blankGif || require.toUrl("dojo/resources/blank.gif"),

        //////////// INITIALIZATION METHODS ///////////////////////////////////////

        /*=====
        constructor: function(params, srcNodeRef){
                // summary:
                //              Create the widget.
                // params: Object|null
                //              Hash of initialization parameters for widget, including scalar values (like title, duration etc.)
                //              and functions, typically callbacks like onClick.
                //              The hash can contain any of the widget's properties, excluding read-only properties.
                // srcNodeRef: DOMNode|String?
                //              If a srcNodeRef (DOM node) is specified:
                //
                //              - use srcNodeRef.innerHTML as my contents
                //              - if this is a behavioral widget then apply behavior to that srcNodeRef
                //              - otherwise, replace srcNodeRef with my generated DOM tree
         },
        =====*/

        postscript: function(/*Object?*/params, /*DomNode|String*/srcNodeRef){
                // summary:
                //              Kicks off widget instantiation.  See create() for details.
                // tags:
                //              private
                this.create(params, srcNodeRef);
        },

        create: function(params, srcNodeRef){
                // summary:
                //              Kick off the life-cycle of a widget
                // description:
                //              Create calls a number of widget methods (postMixInProperties, buildRendering, postCreate,
                //              etc.), some of which of you'll want to override. See http://dojotoolkit.org/reference-guide/dijit/_WidgetBase.html
                //              for a discussion of the widget creation lifecycle.
                //
                //              Of course, adventurous developers could override create entirely, but this should
                //              only be done as a last resort.
                // params: Object|null
                //              Hash of initialization parameters for widget, including scalar values (like title, duration etc.)
                //              and functions, typically callbacks like onClick.
                //              The hash can contain any of the widget's properties, excluding read-only properties.
                // srcNodeRef: DOMNode|String?
                //              If a srcNodeRef (DOM node) is specified:
                //
                //              - use srcNodeRef.innerHTML as my contents
                //              - if this is a behavioral widget then apply behavior to that srcNodeRef
                //              - otherwise, replace srcNodeRef with my generated DOM tree
                // tags:
                //              private

                // store pointer to original DOM tree
                this.srcNodeRef = dom.byId(srcNodeRef);

                // No longer used, remove for 2.0.
                this._connects = [];
                this._supportingWidgets = [];

                // this is here for back-compat, remove in 2.0 (but check NodeList-instantiate.html test)
                if(this.srcNodeRef && (typeof this.srcNodeRef.id == "string")){ this.id = this.srcNodeRef.id; }

                // mix in our passed parameters
                if(params){
                        this.params = params;
                        lang.mixin(this, params);
                }
                this.postMixInProperties();

                // Generate an id for the widget if one wasn't specified, or it was specified as id: undefined.
                // Do this before buildRendering() because it might expect the id to be there.
                if(!this.id){
                        this.id = registry.getUniqueId(this.declaredClass.replace(/\./g,"_"));
                        if(this.params){
                                // if params contains {id: undefined}, prevent _applyAttributes() from processing it
                                delete this.params.id;
                        }
                }

                // The document and <body> node this widget is associated with
                this.ownerDocument = this.ownerDocument || (this.srcNodeRef ? this.srcNodeRef.ownerDocument : win.doc);
                this.ownerDocumentBody = win.body(this.ownerDocument);

                registry.add(this);

                this.buildRendering();

                var deleteSrcNodeRef;

                if(this.domNode){
                        // Copy attributes listed in attributeMap into the [newly created] DOM for the widget.
                        // Also calls custom setters for all attributes with custom setters.
                        this._applyAttributes();

                        // If srcNodeRef was specified, then swap out original srcNode for this widget's DOM tree.
                        // For 2.0, move this after postCreate().  postCreate() shouldn't depend on the
                        // widget being attached to the DOM since it isn't when a widget is created programmatically like
                        // new MyWidget({}).    See #11635.
                        var source = this.srcNodeRef;
                        if(source && source.parentNode && this.domNode !== source){
                                source.parentNode.replaceChild(this.domNode, source);
                                deleteSrcNodeRef = true;
                        }

                        // Note: for 2.0 may want to rename widgetId to dojo._scopeName + "_widgetId",
                        // assuming that dojo._scopeName even exists in 2.0
                        this.domNode.setAttribute("widgetId", this.id);
                }
                this.postCreate();

                // If srcNodeRef has been processed and removed from the DOM (e.g. TemplatedWidget) then delete it to allow GC.
                // I think for back-compatibility it isn't deleting srcNodeRef until after postCreate() has run.
                if(deleteSrcNodeRef){
                        delete this.srcNodeRef;
                }

                this._created = true;
        },

        _applyAttributes: function(){
                // summary:
                //              Step during widget creation to copy  widget attributes to the
                //              DOM according to attributeMap and _setXXXAttr objects, and also to call
                //              custom _setXXXAttr() methods.
                //
                //              Skips over blank/false attribute values, unless they were explicitly specified
                //              as parameters to the widget, since those are the default anyway,
                //              and setting tabIndex="" is different than not setting tabIndex at all.
                //
                //              For backwards-compatibility reasons attributeMap overrides _setXXXAttr when
                //              _setXXXAttr is a hash/string/array, but _setXXXAttr as a functions override attributeMap.
                // tags:
                //              private

                // Get list of attributes where this.set(name, value) will do something beyond
                // setting this[name] = value.  Specifically, attributes that have:
                //              - associated _setXXXAttr() method/hash/string/array
                //              - entries in attributeMap (remove this for 2.0);
                var ctor = this.constructor,
                        list = ctor._setterAttrs;
                if(!list){
                        list = (ctor._setterAttrs = []);
                        for(var attr in this.attributeMap){
                                list.push(attr);
                        }

                        var proto = ctor.prototype;
                        for(var fxName in proto){
                                if(fxName in this.attributeMap){ continue; }
                                var setterName = "_set" + fxName.replace(/^[a-z]|-[a-zA-Z]/g, function(c){ return c.charAt(c.length-1).toUpperCase(); }) + "Attr";
                                if(setterName in proto){
                                        list.push(fxName);
                                }
                        }
                }

                // Call this.set() for each property that was either specified as parameter to constructor,
                // or is in the list found above.       For correlated properties like value and displayedValue, the one
                // specified as a parameter should take precedence.
                // Particularly important for new DateTextBox({displayedValue: ...}) since DateTextBox's default value is
                // NaN and thus is not ignored like a default value of "".

                // Step 1: Save the current values of the widget properties that were specified as parameters to the constructor.
                // Generally this.foo == this.params.foo, except if postMixInProperties() changed the value of this.foo.
                var params = {};
                for(var key in this.params || {}){
                        params[key] = this[key];
                }

                // Step 2: Call set() for each property that wasn't passed as a parameter to the constructor
                array.forEach(list, function(attr){
                        if(attr in params){
                                // skip this one, do it below
                        }else if(this[attr]){
                                this.set(attr, this[attr]);
                        }
                }, this);

                // Step 3: Call set() for each property that was specified as parameter to constructor.
                // Use params hash created above to ignore side effects from step #2 above.
                for(key in params){
                        this.set(key, params[key]);
                }
        },

        postMixInProperties: function(){
                // summary:
                //              Called after the parameters to the widget have been read-in,
                //              but before the widget template is instantiated. Especially
                //              useful to set properties that are referenced in the widget
                //              template.
                // tags:
                //              protected
        },

        buildRendering: function(){
                // summary:
                //              Construct the UI for this widget, setting this.domNode.
                //              Most widgets will mixin `dijit._TemplatedMixin`, which implements this method.
                // tags:
                //              protected

                if(!this.domNode){
                        // Create root node if it wasn't created by _Templated
                        this.domNode = this.srcNodeRef || this.ownerDocument.createElement("div");
                }

                // baseClass is a single class name or occasionally a space-separated list of names.
                // Add those classes to the DOMNode.  If RTL mode then also add with Rtl suffix.
                // TODO: make baseClass custom setter
                if(this.baseClass){
                        var classes = this.baseClass.split(" ");
                        if(!this.isLeftToRight()){
                                classes = classes.concat( array.map(classes, function(name){ return name+"Rtl"; }));
                        }
                        domClass.add(this.domNode, classes);
                }
        },

        postCreate: function(){
                // summary:
                //              Processing after the DOM fragment is created
                // description:
                //              Called after the DOM fragment has been created, but not necessarily
                //              added to the document.  Do not include any operations which rely on
                //              node dimensions or placement.
                // tags:
                //              protected
        },

        startup: function(){
                // summary:
                //              Processing after the DOM fragment is added to the document
                // description:
                //              Called after a widget and its children have been created and added to the page,
                //              and all related widgets have finished their create() cycle, up through postCreate().
                //              This is useful for composite widgets that need to control or layout sub-widgets.
                //              Many layout widgets can use this as a wiring phase.
                if(this._started){ return; }
                this._started = true;
                array.forEach(this.getChildren(), function(obj){
                        if(!obj._started && !obj._destroyed && lang.isFunction(obj.startup)){
                                obj.startup();
                                obj._started = true;
                        }
                });
        },

        //////////// DESTROY FUNCTIONS ////////////////////////////////

        destroyRecursive: function(/*Boolean?*/ preserveDom){
                // summary:
                //              Destroy this widget and its descendants
                // description:
                //              This is the generic "destructor" function that all widget users
                //              should call to cleanly discard with a widget. Once a widget is
                //              destroyed, it is removed from the manager object.
                // preserveDom:
                //              If true, this method will leave the original DOM structure
                //              alone of descendant Widgets. Note: This will NOT work with
                //              dijit._Templated widgets.

                this._beingDestroyed = true;
                this.destroyDescendants(preserveDom);
                this.destroy(preserveDom);
        },

        destroy: function(/*Boolean*/ preserveDom){
                // summary:
                //              Destroy this widget, but not its descendants.
                //              This method will, however, destroy internal widgets such as those used within a template.
                // preserveDom: Boolean
                //              If true, this method will leave the original DOM structure alone.
                //              Note: This will not yet work with _Templated widgets

                this._beingDestroyed = true;
                this.uninitialize();

                function destroy(w){
                        if(w.destroyRecursive){
                                w.destroyRecursive(preserveDom);
                        }else if(w.destroy){
                                w.destroy(preserveDom);
                        }
                }

                // Back-compat, remove for 2.0
                array.forEach(this._connects, lang.hitch(this, "disconnect"));
                array.forEach(this._supportingWidgets, destroy);

                // Destroy supporting widgets, but not child widgets under this.containerNode (for 2.0, destroy child widgets
                // here too).   if() statement is to guard against exception if destroy() called multiple times (see #15815).
                if(this.domNode){
                        array.forEach(registry.findWidgets(this.domNode, this.containerNode), destroy);
                }

                this.destroyRendering(preserveDom);
                registry.remove(this.id);
                this._destroyed = true;
        },

        destroyRendering: function(/*Boolean?*/ preserveDom){
                // summary:
                //              Destroys the DOM nodes associated with this widget
                // preserveDom:
                //              If true, this method will leave the original DOM structure alone
                //              during tear-down. Note: this will not work with _Templated
                //              widgets yet.
                // tags:
                //              protected

                if(this.bgIframe){
                        this.bgIframe.destroy(preserveDom);
                        delete this.bgIframe;
                }

                if(this.domNode){
                        if(preserveDom){
                                domAttr.remove(this.domNode, "widgetId");
                        }else{
                                domConstruct.destroy(this.domNode);
                        }
                        delete this.domNode;
                }

                if(this.srcNodeRef){
                        if(!preserveDom){
                                domConstruct.destroy(this.srcNodeRef);
                        }
                        delete this.srcNodeRef;
                }
        },

        destroyDescendants: function(/*Boolean?*/ preserveDom){
                // summary:
                //              Recursively destroy the children of this widget and their
                //              descendants.
                // preserveDom:
                //              If true, the preserveDom attribute is passed to all descendant
                //              widget's .destroy() method. Not for use with _Templated
                //              widgets.

                // get all direct descendants and destroy them recursively
                array.forEach(this.getChildren(), function(widget){
                        if(widget.destroyRecursive){
                                widget.destroyRecursive(preserveDom);
                        }
                });
        },

        uninitialize: function(){
                // summary:
                //              Deprecated. Override destroy() instead to implement custom widget tear-down
                //              behavior.
                // tags:
                //              protected
                return false;
        },

        ////////////////// GET/SET, CUSTOM SETTERS, ETC. ///////////////////

        _setStyleAttr: function(/*String||Object*/ value){
                // summary:
                //              Sets the style attribute of the widget according to value,
                //              which is either a hash like {height: "5px", width: "3px"}
                //              or a plain string
                // description:
                //              Determines which node to set the style on based on style setting
                //              in attributeMap.
                // tags:
                //              protected

                var mapNode = this.domNode;

                // Note: technically we should revert any style setting made in a previous call
                // to his method, but that's difficult to keep track of.

                if(lang.isObject(value)){
                        domStyle.set(mapNode, value);
                }else{
                        if(mapNode.style.cssText){
                                mapNode.style.cssText += "; " + value;
                        }else{
                                mapNode.style.cssText = value;
                        }
                }

                this._set("style", value);
        },

        _attrToDom: function(/*String*/ attr, /*String*/ value, /*Object?*/ commands){
                // summary:
                //              Reflect a widget attribute (title, tabIndex, duration etc.) to
                //              the widget DOM, as specified by commands parameter.
                //              If commands isn't specified then it's looked up from attributeMap.
                //              Note some attributes like "type"
                //              cannot be processed this way as they are not mutable.
                // attr:
                //              Name of member variable (ex: "focusNode" maps to this.focusNode) pointing
                //              to DOMNode inside the widget, or alternately pointing to a subwidget
                // tags:
                //              private

                commands = arguments.length >= 3 ? commands : this.attributeMap[attr];

                array.forEach(lang.isArray(commands) ? commands : [commands], function(command){

                        // Get target node and what we are doing to that node
                        var mapNode = this[command.node || command || "domNode"];       // DOM node
                        var type = command.type || "attribute"; // class, innerHTML, innerText, or attribute

                        switch(type){
                                case "attribute":
                                        if(lang.isFunction(value)){ // functions execute in the context of the widget
                                                value = lang.hitch(this, value);
                                        }

                                        // Get the name of the DOM node attribute; usually it's the same
                                        // as the name of the attribute in the widget (attr), but can be overridden.
                                        // Also maps handler names to lowercase, like onSubmit --> onsubmit
                                        var attrName = command.attribute ? command.attribute :
                                                (/^on[A-Z][a-zA-Z]*$/.test(attr) ? attr.toLowerCase() : attr);

                                        if(mapNode.tagName){
                                                // Normal case, mapping to a DOMNode.  Note that modern browsers will have a mapNode.set()
                                                // method, but for consistency we still call domAttr
                                                domAttr.set(mapNode, attrName, value);
                                        }else{
                                                // mapping to a sub-widget
                                                mapNode.set(attrName, value);
                                        }
                                        break;
                                case "innerText":
                                        mapNode.innerHTML = "";
                                        mapNode.appendChild(this.ownerDocument.createTextNode(value));
                                        break;
                                case "innerHTML":
                                        mapNode.innerHTML = value;
                                        break;
                                case "class":
                                        domClass.replace(mapNode, value, this[attr]);
                                        break;
                        }
                }, this);
        },

        get: function(name){
                // summary:
                //              Get a property from a widget.
                // name:
                //              The property to get.
                // description:
                //              Get a named property from a widget. The property may
                //              potentially be retrieved via a getter method. If no getter is defined, this
                //              just retrieves the object's property.
                //
                //              For example, if the widget has properties `foo` and `bar`
                //              and a method named `_getFooAttr()`, calling:
                //              `myWidget.get("foo")` would be equivalent to calling
                //              `widget._getFooAttr()` and `myWidget.get("bar")`
                //              would be equivalent to the expression
                //              `widget.bar2`
                var names = this._getAttrNames(name);
                return this[names.g] ? this[names.g]() : this[name];
        },

        set: function(name, value){
                // summary:
                //              Set a property on a widget
                // name:
                //              The property to set.
                // value:
                //              The value to set in the property.
                // description:
                //              Sets named properties on a widget which may potentially be handled by a
                //              setter in the widget.
                //
                //              For example, if the widget has properties `foo` and `bar`
                //              and a method named `_setFooAttr()`, calling
                //              `myWidget.set("foo", "Howdy!")` would be equivalent to calling
                //              `widget._setFooAttr("Howdy!")` and `myWidget.set("bar", 3)`
                //              would be equivalent to the statement `widget.bar = 3;`
                //
                //              set() may also be called with a hash of name/value pairs, ex:
                //
                //      |       myWidget.set({
                //      |               foo: "Howdy",
                //      |               bar: 3
                //      |       });
                //
                //      This is equivalent to calling `set(foo, "Howdy")` and `set(bar, 3)`

                if(typeof name === "object"){
                        for(var x in name){
                                this.set(x, name[x]);
                        }
                        return this;
                }
                var names = this._getAttrNames(name),
                        setter = this[names.s];
                if(lang.isFunction(setter)){
                        // use the explicit setter
                        var result = setter.apply(this, Array.prototype.slice.call(arguments, 1));
                }else{
                        // Mapping from widget attribute to DOMNode/subwidget attribute/value/etc.
                        // Map according to:
                        //              1. attributeMap setting, if one exists (TODO: attributeMap deprecated, remove in 2.0)
                        //              2. _setFooAttr: {...} type attribute in the widget (if one exists)
                        //              3. apply to focusNode or domNode if standard attribute name, excluding funcs like onClick.
                        // Checks if an attribute is a "standard attribute" by whether the DOMNode JS object has a similar
                        // attribute name (ex: accept-charset attribute matches jsObject.acceptCharset).
                        // Note also that Tree.focusNode() is a function not a DOMNode, so test for that.
                        var defaultNode = this.focusNode && !lang.isFunction(this.focusNode) ? "focusNode" : "domNode",
                                tag = this[defaultNode].tagName,
                                attrsForTag = tagAttrs[tag] || (tagAttrs[tag] = getAttrs(this[defaultNode])),
                                map =   name in this.attributeMap ? this.attributeMap[name] :
                                                names.s in this ? this[names.s] :
                                                ((names.l in attrsForTag && typeof value != "function") ||
                                                        /^aria-|^data-|^role$/.test(name)) ? defaultNode : null;
                        if(map != null){
                                this._attrToDom(name, value, map);
                        }
                        this._set(name, value);
                }
                return result || this;
        },

        _attrPairNames: {},             // shared between all widgets
        _getAttrNames: function(name){
                // summary:
                //              Helper function for get() and set().
                //              Caches attribute name values so we don't do the string ops every time.
                // tags:
                //              private

                var apn = this._attrPairNames;
                if(apn[name]){ return apn[name]; }
                var uc = name.replace(/^[a-z]|-[a-zA-Z]/g, function(c){ return c.charAt(c.length-1).toUpperCase(); });
                return (apn[name] = {
                        n: name+"Node",
                        s: "_set"+uc+"Attr",    // converts dashes to camel case, ex: accept-charset --> _setAcceptCharsetAttr
                        g: "_get"+uc+"Attr",
                        l: uc.toLowerCase()             // lowercase name w/out dashes, ex: acceptcharset
                });
        },

        _set: function(/*String*/ name, /*anything*/ value){
                // summary:
                //              Helper function to set new value for specified attribute, and call handlers
                //              registered with watch() if the value has changed.
                var oldValue = this[name];
                this[name] = value;
                if(this._created && value !== oldValue){
                        if(this._watchCallbacks){
                                this._watchCallbacks(name, oldValue, value);
                        }
                        this.emit("attrmodified-" + name, {
                                detail: {
                                        prevValue: oldValue,
                                        newValue: value
                                }
                        });
                }
        },

        emit: function(/*String*/ type, /*Object?*/ eventObj, /*Array?*/ callbackArgs){
                // summary:
                //              Used by widgets to signal that a synthetic event occurred, ex:
                //      |       myWidget.emit("attrmodified-selectedChildWidget", {}).
                //
                //              Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
                //              Also calls onType() method, if present, and returns value from that method.
                //              By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
                //              Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
                // tags:
                //              protected

                // Specify fallback values for bubbles, cancelable in case they are not set in eventObj.
                // Also set pointer to widget, although since we can't add a pointer to the widget for native events
                // (see #14729), maybe we shouldn't do it here?
                eventObj = eventObj || {};
                if(eventObj.bubbles === undefined){ eventObj.bubbles = true; }
                if(eventObj.cancelable === undefined){ eventObj.cancelable = true; }
                if(!eventObj.detail){ eventObj.detail = {}; }
                eventObj.detail.widget = this;

                var ret, callback = this["on"+type];
                if(callback){
                        ret = callback.apply(this, callbackArgs ? callbackArgs : [eventObj]);
                }

                // Emit event, but avoid spurious emit()'s as parent sets properties on child during startup/destroy
                if(this._started && !this._beingDestroyed){
                        on.emit(this.domNode, type.toLowerCase(), eventObj);
                }

                return ret;
        },

        on: function(/*String|Function*/ type, /*Function*/ func){
                // summary:
                //              Call specified function when event occurs, ex: myWidget.on("click", function(){ ... }).
                // type:
                //              Name of event (ex: "click") or extension event like touch.press.
                // description:
                //              Call specified function when event `type` occurs, ex: `myWidget.on("click", function(){ ... })`.
                //              Note that the function is not run in any particular scope, so if (for example) you want it to run in the
                //              widget's scope you must do `myWidget.on("click", lang.hitch(myWidget, func))`.

                // For backwards compatibility, if there's an onType() method in the widget then connect to that.
                // Remove in 2.0.
                var widgetMethod = this._onMap(type);
                if(widgetMethod){
                        return aspect.after(this, widgetMethod, func, true);
                }

                // Otherwise, just listen for the event on this.domNode.
                return this.own(on(this.domNode, type, func))[0];
        },

        _onMap: function(/*String|Function*/ type){
                // summary:
                //              Maps on() type parameter (ex: "mousemove") to method name (ex: "onMouseMove").
                //              If type is a synthetic event like touch.press then returns undefined.
                var ctor = this.constructor, map = ctor._onMap;
                if(!map){
                        map = (ctor._onMap = {});
                        for(var attr in ctor.prototype){
                                if(/^on/.test(attr)){
                                        map[attr.replace(/^on/, "").toLowerCase()] = attr;
                                }
                        }
                }
                return map[typeof type == "string" && type.toLowerCase()];      // String
        },

        toString: function(){
                // summary:
                //              Returns a string that represents the widget
                // description:
                //              When a widget is cast to a string, this method will be used to generate the
                //              output. Currently, it does not implement any sort of reversible
                //              serialization.
                return '[Widget ' + this.declaredClass + ', ' + (this.id || 'NO ID') + ']'; // String
        },

        getChildren: function(){
                // summary:
                //              Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
                //              Does not return nested widgets, nor widgets that are part of this widget's template.
                return this.containerNode ? registry.findWidgets(this.containerNode) : []; // dijit/_WidgetBase[]
        },

        getParent: function(){
                // summary:
                //              Returns the parent widget of this widget
                return registry.getEnclosingWidget(this.domNode.parentNode);
        },

        connect: function(
                        /*Object|null*/ obj,
                        /*String|Function*/ event,
                        /*String|Function*/ method){
                // summary:
                //              Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                //
                //              Connects specified obj/event to specified method of this object
                //              and registers for disconnect() on widget destroy.
                //
                //              Provide widget-specific analog to dojo.connect, except with the
                //              implicit use of this widget as the target object.
                //              Events connected with `this.connect` are disconnected upon
                //              destruction.
                // returns:
                //              A handle that can be passed to `disconnect` in order to disconnect before
                //              the widget is destroyed.
                // example:
                //      |       var btn = new Button();
                //      |       // when foo.bar() is called, call the listener we're going to
                //      |       // provide in the scope of btn
                //      |       btn.connect(foo, "bar", function(){
                //      |               console.debug(this.toString());
                //      |       });
                // tags:
                //              protected

                return this.own(connect.connect(obj, event, this, method))[0];  // handle
        },

        disconnect: function(handle){
                // summary:
                //              Deprecated, will be removed in 2.0, use handle.remove() instead.
                //
                //              Disconnects handle created by `connect`.
                // tags:
                //              protected

                handle.remove();
        },

        subscribe: function(t, method){
                // summary:
                //              Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
                //
                //              Subscribes to the specified topic and calls the specified method
                //              of this object and registers for unsubscribe() on widget destroy.
                //
                //              Provide widget-specific analog to dojo.subscribe, except with the
                //              implicit use of this widget as the target object.
                // t: String
                //              The topic
                // method: Function
                //              The callback
                // example:
                //      |       var btn = new Button();
                //      |       // when /my/topic is published, this button changes its label to
                //      |       // be the parameter of the topic.
                //      |       btn.subscribe("/my/topic", function(v){
                //      |               this.set("label", v);
                //      |       });
                // tags:
                //              protected
                return this.own(topic.subscribe(t, lang.hitch(this, method)))[0];       // handle
        },

        unsubscribe: function(/*Object*/ handle){
                // summary:
                //              Deprecated, will be removed in 2.0, use handle.remove() instead.
                //
                //              Unsubscribes handle created by this.subscribe.
                //              Also removes handle from this widget's list of subscriptions
                // tags:
                //              protected

                handle.remove();
        },

        isLeftToRight: function(){
                // summary:
                //              Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
                // tags:
                //              protected
                return this.dir ? (this.dir == "ltr") : domGeometry.isBodyLtr(this.ownerDocument); //Boolean
        },

        isFocusable: function(){
                // summary:
                //              Return true if this widget can currently be focused
                //              and false if not
                return this.focus && (domStyle.get(this.domNode, "display") != "none");
        },

        placeAt: function(/* String|DomNode|_Widget */ reference, /* String|Int? */ position){
                // summary:
                //              Place this widget somewhere in the DOM based
                //              on standard domConstruct.place() conventions.
                // description:
                //              A convenience function provided in all _Widgets, providing a simple
                //              shorthand mechanism to put an existing (or newly created) Widget
                //              somewhere in the dom, and allow chaining.
                // reference:
                //              Widget, DOMNode, or id of widget or DOMNode
                // position:
                //              If reference is a widget (or id of widget), and that widget has an ".addChild" method,
                //              it will be called passing this widget instance into that method, supplying the optional
                //              position index passed.  In this case position (if specified) should be an integer.
                //
                //              If reference is a DOMNode (or id matching a DOMNode but not a widget),
                //              the position argument can be a numeric index or a string
                //              "first", "last", "before", or "after", same as dojo/dom-construct::place().
                // returns: dijit/_WidgetBase
                //              Provides a useful return of the newly created dijit._Widget instance so you
                //              can "chain" this function by instantiating, placing, then saving the return value
                //              to a variable.
                // example:
                //      |       // create a Button with no srcNodeRef, and place it in the body:
                //      |       var button = new Button({ label:"click" }).placeAt(win.body());
                //      |       // now, 'button' is still the widget reference to the newly created button
                //      |       button.on("click", function(e){ console.log('click'); }));
                // example:
                //      |       // create a button out of a node with id="src" and append it to id="wrapper":
                //      |       var button = new Button({},"src").placeAt("wrapper");
                // example:
                //      |       // place a new button as the first element of some div
                //      |       var button = new Button({ label:"click" }).placeAt("wrapper","first");
                // example:
                //      |       // create a contentpane and add it to a TabContainer
                //      |       var tc = dijit.byId("myTabs");
                //      |       new ContentPane({ href:"foo.html", title:"Wow!" }).placeAt(tc)

                var refWidget = !reference.tagName && registry.byId(reference);
                if(refWidget && refWidget.addChild && (!position || typeof position === "number")){
                        // Adding this to refWidget and can use refWidget.addChild() to handle everything.
                        refWidget.addChild(this, position);
                }else{
                        // "reference" is a plain DOMNode, or we can't use refWidget.addChild().   Use domConstruct.place() and
                        // target refWidget.containerNode for nested placement (position==number, "first", "last", "only"), and
                        // refWidget.domNode otherwise ("after"/"before"/"replace").  (But not supported officially, see #14946.)
                        var ref = refWidget ?
                                (refWidget.containerNode && !/after|before|replace/.test(position||"") ?
                                        refWidget.containerNode : refWidget.domNode) : dom.byId(reference, this.ownerDocument);
                        domConstruct.place(this.domNode, ref, position);

                        // Start this iff it has a parent widget that's already started.
                        if(!this._started && (this.getParent() || {})._started){
                                this.startup();
                        }
                }
                return this;
        },

        getTextDir: function(/*String*/ text,/*String*/ originalDir){
                // summary:
                //              Return direction of the text.
                //              The function overridden in the _BidiSupport module,
                //              its main purpose is to calculate the direction of the
                //              text, if was defined by the programmer through textDir.
                // tags:
                //              protected.
                return originalDir;
        },

        applyTextDir: function(/*===== element, text =====*/){
                // summary:
                //              The function overridden in the _BidiSupport module,
                //              originally used for setting element.dir according to this.textDir.
                //              In this case does nothing.
                // element: DOMNode
                // text: String
                // tags:
                //              protected.
        },

        defer: function(fcn, delay){ 
                // summary:
                //              Wrapper to setTimeout to avoid deferred functions executing
                //              after the originating widget has been destroyed.
                //              Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
                // fcn: function reference
                // delay: Optional number (defaults to 0)
                // tags:
                //              protected.
                var timer = setTimeout(lang.hitch(this, 
                        function(){ 
                                timer = null;
                                if(!this._destroyed){ 
                                        lang.hitch(this, fcn)(); 
                                } 
                        }),
                        delay || 0
                );
                return {
                        remove: function(){
                                        if(timer){
                                                clearTimeout(timer);
                                                timer = null;
                                        }
                                        return null; // so this works well: handle = handle.remove();
                                }
                };
        }
});

});

},
'dijit/layout/_TabContainerBase':function(){
require({cache:{
'url:dijit/layout/templates/TabContainer.html':"<div class=\"dijitTabContainer\">\n\t<div class=\"dijitTabListWrapper\" data-dojo-attach-point=\"tablistNode\"></div>\n\t<div data-dojo-attach-point=\"tablistSpacer\" class=\"dijitTabSpacer ${baseClass}-spacer\"></div>\n\t<div class=\"dijitTabPaneWrapper ${baseClass}-container\" data-dojo-attach-point=\"containerNode\"></div>\n</div>\n"}});
define("dijit/layout/_TabContainerBase", [
        "dojo/text!./templates/TabContainer.html",
        "./StackContainer",
        "./utils",      // marginBox2contextBox, layoutChildren
        "../_TemplatedMixin",
        "dojo/_base/declare", // declare
        "dojo/dom-class", // domClass.add
        "dojo/dom-geometry", // domGeometry.contentBox
        "dojo/dom-style" // domStyle.style
], function(template, StackContainer, layoutUtils, _TemplatedMixin, declare, domClass, domGeometry, domStyle){

// module:
//              dijit/layout/_TabContainerBase


return declare("dijit.layout._TabContainerBase", [StackContainer, _TemplatedMixin], {
        // summary:
        //              Abstract base class for TabContainer.   Must define _makeController() to instantiate
        //              and return the widget that displays the tab labels
        // description:
        //              A TabContainer is a container that has multiple panes, but shows only
        //              one pane at a time.  There are a set of tabs corresponding to each pane,
        //              where each tab has the name (aka title) of the pane, and optionally a close button.

        // tabPosition: String
        //              Defines where tabs go relative to tab content.
        //              "top", "bottom", "left-h", "right-h"
        tabPosition: "top",

        baseClass: "dijitTabContainer",

        // tabStrip: [const] Boolean
        //              Defines whether the tablist gets an extra class for layouting, putting a border/shading
        //              around the set of tabs.   Not supported by claro theme.
        tabStrip: false,

        // nested: [const] Boolean
        //              If true, use styling for a TabContainer nested inside another TabContainer.
        //              For tundra etc., makes tabs look like links, and hides the outer
        //              border since the outer TabContainer already has a border.
        nested: false,

        templateString: template,

        postMixInProperties: function(){
                // set class name according to tab position, ex: dijitTabContainerTop
                this.baseClass += this.tabPosition.charAt(0).toUpperCase() + this.tabPosition.substr(1).replace(/-.*/, "");

                this.srcNodeRef && domStyle.set(this.srcNodeRef, "visibility", "hidden");

                this.inherited(arguments);
        },

        buildRendering: function(){
                this.inherited(arguments);

                // Create the tab list that will have a tab (a.k.a. tab button) for each tab panel
                this.tablist = this._makeController(this.tablistNode);

                if(!this.doLayout){ domClass.add(this.domNode, "dijitTabContainerNoLayout"); }

                if(this.nested){
                        /* workaround IE's lack of support for "a > b" selectors by
                         * tagging each node in the template.
                         */
                        domClass.add(this.domNode, "dijitTabContainerNested");
                        domClass.add(this.tablist.containerNode, "dijitTabContainerTabListNested");
                        domClass.add(this.tablistSpacer, "dijitTabContainerSpacerNested");
                        domClass.add(this.containerNode, "dijitTabPaneWrapperNested");
                }else{
                        domClass.add(this.domNode, "tabStrip-" + (this.tabStrip ? "enabled" : "disabled"));
                }
        },

        _setupChild: function(/*dijit/_WidgetBase*/ tab){
                // Overrides StackContainer._setupChild().
                domClass.add(tab.domNode, "dijitTabPane");
                this.inherited(arguments);
        },

        startup: function(){
                if(this._started){ return; }

                // wire up the tablist and its tabs
                this.tablist.startup();

                this.inherited(arguments);
        },

        layout: function(){
                // Overrides StackContainer.layout().
                // Configure the content pane to take up all the space except for where the tabs are

                if(!this._contentBox || typeof(this._contentBox.l) == "undefined"){return;}

                var sc = this.selectedChildWidget;

                if(this.doLayout){
                        // position and size the titles and the container node
                        var titleAlign = this.tabPosition.replace(/-h/, "");
                        this.tablist.layoutAlign = titleAlign;
                        var children = [this.tablist, {
                                domNode: this.tablistSpacer,
                                layoutAlign: titleAlign
                        }, {
                                domNode: this.containerNode,
                                layoutAlign: "client"
                        }];
                        layoutUtils.layoutChildren(this.domNode, this._contentBox, children);

                        // Compute size to make each of my children.
                        // children[2] is the margin-box size of this.containerNode, set by layoutChildren() call above
                        this._containerContentBox = layoutUtils.marginBox2contentBox(this.containerNode, children[2]);

                        if(sc && sc.resize){
                                sc.resize(this._containerContentBox);
                        }
                }else{
                        // just layout the tab controller, so it can position left/right buttons etc.
                        if(this.tablist.resize){
                                //make the tabs zero width so that they don't interfere with width calc, then reset
                                var s = this.tablist.domNode.style;
                                s.width="0";
                                var width = domGeometry.getContentBox(this.domNode).w;
                                s.width="";
                                this.tablist.resize({w: width});
                        }

                        // and call resize() on the selected pane just to tell it that it's been made visible
                        if(sc && sc.resize){
                                sc.resize();
                        }
                }
        },

        destroy: function(){
                if(this.tablist){
                        this.tablist.destroy();
                }
                this.inherited(arguments);
        }
});

});

},
'dijit/form/Form':function(){
define("dijit/form/Form", [
        "dojo/_base/declare", // declare
        "dojo/dom-attr", // domAttr.set
        "dojo/_base/event", // event.stop
        "dojo/_base/kernel", // kernel.deprecated
        "dojo/sniff", // has("ie")
        "../_Widget",
        "../_TemplatedMixin",
        "./_FormMixin",
        "../layout/_ContentPaneResizeMixin"
], function(declare, domAttr, event, kernel, has, _Widget, _TemplatedMixin, _FormMixin, _ContentPaneResizeMixin){

        // module:
        //              dijit/form/Form


        return declare("dijit.form.Form", [_Widget, _TemplatedMixin, _FormMixin, _ContentPaneResizeMixin], {
                // summary:
                //              Widget corresponding to HTML form tag, for validation and serialization
                //
                // example:
                //      |       <form data-dojo-type="dijit/form/Form" id="myForm">
                //      |               Name: <input type="text" name="name" />
                //      |       </form>
                //      |       myObj = {name: "John Doe"};
                //      |       dijit.byId('myForm').set('value', myObj);
                //      |
                //      |       myObj=dijit.byId('myForm').get('value');

                // HTML <FORM> attributes

                // name: String?
                //              Name of form for scripting.
                name: "",

                // action: String?
                //              Server-side form handler.
                action: "",

                // method: String?
                //              HTTP method used to submit the form, either "GET" or "POST".
                method: "",

                // encType: String?
                //              Encoding type for the form, ex: application/x-www-form-urlencoded.
                encType: "",

                // accept-charset: String?
                //              List of supported charsets.
                "accept-charset": "",

                // accept: String?
                //              List of MIME types for file upload.
                accept: "",

                // target: String?
                //              Target frame for the document to be opened in.
                target: "",

                templateString: "<form data-dojo-attach-point='containerNode' data-dojo-attach-event='onreset:_onReset,onsubmit:_onSubmit' ${!nameAttrSetting}></form>",

                postMixInProperties: function(){
                        // Setup name=foo string to be referenced from the template (but only if a name has been specified)
                        // Unfortunately we can't use _setNameAttr to set the name due to IE limitations, see #8660
                        this.nameAttrSetting = this.name ? ("name='" + this.name + "'") : "";
                        this.inherited(arguments);
                },

                execute: function(/*Object*/ /*===== formContents =====*/){
                        // summary:
                        //              Deprecated: use submit()
                        // tags:
                        //              deprecated
                },

                onExecute: function(){
                        // summary:
                        //              Deprecated: use onSubmit()
                        // tags:
                        //              deprecated
                },

                _setEncTypeAttr: function(/*String*/ value){
                        this.encType = value;
                        domAttr.set(this.domNode, "encType", value);
                        if(has("ie")){ this.domNode.encoding = value; }
                },

                reset: function(/*Event?*/ e){
                        // summary:
                        //              restores all widget values back to their init values,
                        //              calls onReset() which can cancel the reset by returning false

                        // create fake event so we can know if preventDefault() is called
                        var faux = {
                                returnValue: true, // the IE way
                                preventDefault: function(){ // not IE
                                                        this.returnValue = false;
                                                },
                                stopPropagation: function(){},
                                currentTarget: e ? e.target : this.domNode,
                                target: e ? e.target : this.domNode
                        };
                        // if return value is not exactly false, and haven't called preventDefault(), then reset
                        if(!(this.onReset(faux) === false) && faux.returnValue){
                                this.inherited(arguments, []);
                        }
                },

                onReset: function(/*Event?*/ /*===== e =====*/){
                        // summary:
                        //              Callback when user resets the form. This method is intended
                        //              to be over-ridden. When the `reset` method is called
                        //              programmatically, the return value from `onReset` is used
                        //              to compute whether or not resetting should proceed
                        // tags:
                        //              callback
                        return true; // Boolean
                },

                _onReset: function(e){
                        this.reset(e);
                        event.stop(e);
                        return false;
                },

                _onSubmit: function(e){
                        var fp = this.constructor.prototype;
                        // TODO: remove this if statement beginning with 2.0
                        if(this.execute != fp.execute || this.onExecute != fp.onExecute){
                                kernel.deprecated("dijit.form.Form:execute()/onExecute() are deprecated. Use onSubmit() instead.", "", "2.0");
                                this.onExecute();
                                this.execute(this.getValues());
                        }
                        if(this.onSubmit(e) === false){ // only exactly false stops submit
                                event.stop(e);
                        }
                },

                onSubmit: function(/*Event?*/ /*===== e =====*/){
                        // summary:
                        //              Callback when user submits the form.
                        // description:
                        //              This method is intended to be over-ridden, but by default it checks and
                        //              returns the validity of form elements. When the `submit`
                        //              method is called programmatically, the return value from
                        //              `onSubmit` is used to compute whether or not submission
                        //              should proceed
                        // tags:
                        //              extension

                        return this.isValid(); // Boolean
                },

                submit: function(){
                        // summary:
                        //              programmatically submit form if and only if the `onSubmit` returns true
                        if(!(this.onSubmit() === false)){
                                this.containerNode.submit();
                        }
                }
        });
});

},
'dojo/store/Memory':function(){
define("dojo/store/Memory", ["../_base/declare", "./util/QueryResults", "./util/SimpleQueryEngine" /*=====, "./api/Store" =====*/],
function(declare, QueryResults, SimpleQueryEngine /*=====, Store =====*/){

// module:
//              dojo/store/Memory

// No base class, but for purposes of documentation, the base class is dojo/store/api/Store
var base = null;
/*===== base = Store; =====*/

return declare("dojo.store.Memory", base, {
        // summary:
        //              This is a basic in-memory object store. It implements dojo/store/api/Store.
        constructor: function(options){
                // summary:
                //              Creates a memory object store.
                // options: dojo/store/Memory
                //              This provides any configuration information that will be mixed into the store.
                //              This should generally include the data property to provide the starting set of data.
                for(var i in options){
                        this[i] = options[i];
                }
                this.setData(this.data || []);
        },
        // data: Array
        //              The array of all the objects in the memory store
        data:null,

        // idProperty: String
        //              Indicates the property to use as the identity property. The values of this
        //              property should be unique.
        idProperty: "id",

        // index: Object
        //              An index of data indices into the data array by id
        index:null,

        // queryEngine: Function
        //              Defines the query engine to use for querying the data store
        queryEngine: SimpleQueryEngine,
        get: function(id){
                // summary:
                //              Retrieves an object by its identity
                // id: Number
                //              The identity to use to lookup the object
                // returns: Object
                //              The object in the store that matches the given id.
                return this.data[this.index[id]];
        },
        getIdentity: function(object){
                // summary:
                //              Returns an object's identity
                // object: Object
                //              The object to get the identity from
                // returns: Number
                return object[this.idProperty];
        },
        put: function(object, options){
                // summary:
                //              Stores an object
                // object: Object
                //              The object to store.
                // options: dojo/store/api/Store.PutDirectives?
                //              Additional metadata for storing the data.  Includes an "id"
                //              property if a specific id is to be used.
                // returns: Number
                var data = this.data,
                        index = this.index,
                        idProperty = this.idProperty;
                var id = object[idProperty] = (options && "id" in options) ? options.id : idProperty in object ? object[idProperty] : Math.random();
                if(id in index){
                        // object exists
                        if(options && options.overwrite === false){
                                throw new Error("Object already exists");
                        }
                        // replace the entry in data
                        data[index[id]] = object;
                }else{
                        // add the new object
                        index[id] = data.push(object) - 1;
                }
                return id;
        },
        add: function(object, options){
                // summary:
                //              Creates an object, throws an error if the object already exists
                // object: Object
                //              The object to store.
                // options: dojo/store/api/Store.PutDirectives?
                //              Additional metadata for storing the data.  Includes an "id"
                //              property if a specific id is to be used.
                // returns: Number
                (options = options || {}).overwrite = false;
                // call put with overwrite being false
                return this.put(object, options);
        },
        remove: function(id){
                // summary:
                //              Deletes an object by its identity
                // id: Number
                //              The identity to use to delete the object
                // returns: Boolean
                //              Returns true if an object was removed, falsy (undefined) if no object matched the id
                var index = this.index;
                var data = this.data;
                if(id in index){
                        data.splice(index[id], 1);
                        // now we have to reindex
                        this.setData(data);
                        return true;
                }
        },
        query: function(query, options){
                // summary:
                //              Queries the store for objects.
                // query: Object
                //              The query to use for retrieving objects from the store.
                // options: dojo/store/api/Store.QueryOptions?
                //              The optional arguments to apply to the resultset.
                // returns: dojo/store/api/Store.QueryResults
                //              The results of the query, extended with iterative methods.
                //
                // example:
                //              Given the following store:
                //
                //      |       var store = new Memory({
                //      |               data: [
                //      |                       {id: 1, name: "one", prime: false },
                //      |                       {id: 2, name: "two", even: true, prime: true},
                //      |                       {id: 3, name: "three", prime: true},
                //      |                       {id: 4, name: "four", even: true, prime: false},
                //      |                       {id: 5, name: "five", prime: true}
                //      |               ]
                //      |       });
                //
                //      ...find all items where "prime" is true:
                //
                //      |       var results = store.query({ prime: true });
                //
                //      ...or find all items where "even" is true:
                //
                //      |       var results = store.query({ even: true });
                return QueryResults(this.queryEngine(query, options)(this.data));
        },
        setData: function(data){
                // summary:
                //              Sets the given data as the source for this store, and indexes it
                // data: Object[]
                //              An array of objects to use as the source of data.
                if(data.items){
                        // just for convenience with the data format IFRS expects
                        this.idProperty = data.identifier;
                        data = this.data = data.items;
                }else{
                        this.data = data;
                }
                this.index = {};
                for(var i = 0, l = data.length; i < l; i++){
                        this.index[data[i][this.idProperty]] = i;
                }
        }
});

});

},
'url:dijit/templates/Tooltip.html':"<div class=\"dijitTooltip dijitTooltipLeft\" id=\"dojoTooltip\"\n\t><div class=\"dijitTooltipContainer dijitTooltipContents\" data-dojo-attach-point=\"containerNode\" role='alert'></div\n\t><div class=\"dijitTooltipConnector\" data-dojo-attach-point=\"connectorNode\"></div\n></div>\n",
'dijit/_base/sniff':function(){
define("dijit/_base/sniff", [ "dojo/uacss" ], function(){

        // module:
        //              dijit/_base/sniff

        /*=====
        return {
                // summary:
                //              Deprecated, back compatibility module, new code should require dojo/uacss directly instead of this module.
        };
        =====*/
});

},
'dijit/Toolbar':function(){
define("dijit/Toolbar", [
        "require",
        "dojo/_base/declare", // declare
        "dojo/has",
        "dojo/keys", // keys.LEFT_ARROW keys.RIGHT_ARROW
        "dojo/ready",
        "./_Widget",
        "./_KeyNavContainer",
        "./_TemplatedMixin"
], function(require, declare, has, keys, ready, _Widget, _KeyNavContainer, _TemplatedMixin){

        // module:
        //              dijit/Toolbar


        // Back compat w/1.6, remove for 2.0
        if(has("dijit-legacy-requires")){
                ready(0, function(){
                        var requires = ["dijit/ToolbarSeparator"];
                        require(requires);      // use indirection so modules not rolled into a build
                });
        }

        return declare("dijit.Toolbar", [_Widget, _TemplatedMixin, _KeyNavContainer], {
                // summary:
                //              A Toolbar widget, used to hold things like `dijit.Editor` buttons

                templateString:
                        '<div class="dijit" role="toolbar" tabIndex="${tabIndex}" data-dojo-attach-point="containerNode">' +
                        '</div>',

                baseClass: "dijitToolbar",

                postCreate: function(){
                        this.inherited(arguments);

                        this.connectKeyNavHandlers(
                                this.isLeftToRight() ? [keys.LEFT_ARROW] : [keys.RIGHT_ARROW],
                                this.isLeftToRight() ? [keys.RIGHT_ARROW] : [keys.LEFT_ARROW]
                        );
                }
        });
});

},
'dijit/layout/StackContainer':function(){
define("dijit/layout/StackContainer", [
        "dojo/_base/array", // array.forEach array.indexOf array.some
        "dojo/cookie", // cookie
        "dojo/_base/declare", // declare
        "dojo/dom-class", // domClass.add domClass.replace
        "dojo/has",     // has("dijit-legacy-requires")
        "dojo/_base/lang",      // lang.extend
        "dojo/ready",
        "dojo/topic", // publish
        "../registry",  // registry.byId
        "../_WidgetBase",
        "./_LayoutWidget",
        "dojo/i18n!../nls/common"
], function(array, cookie, declare, domClass, has, lang, ready, topic,
                        registry, _WidgetBase, _LayoutWidget){

// module:
//              dijit/layout/StackContainer

// Back compat w/1.6, remove for 2.0
if(has("dijit-legacy-requires")){
        ready(0, function(){
                var requires = ["dijit/layout/StackController"];
                require(requires);      // use indirection so modules not rolled into a build
        });
}

var StackContainer = declare("dijit.layout.StackContainer", _LayoutWidget, {
        // summary:
        //              A container that has multiple children, but shows only
        //              one child at a time
        //
        // description:
        //              A container for widgets (ContentPanes, for example) That displays
        //              only one Widget at a time.
        //
        //              Publishes topics [widgetId]-addChild, [widgetId]-removeChild, and [widgetId]-selectChild
        //
        //              Can be base class for container, Wizard, Show, etc.
        //
        //              See `StackContainer.ChildWidgetProperties` for details on the properties that can be set on
        //              children of a `StackContainer`.

        // doLayout: Boolean
        //              If true, change the size of my currently displayed child to match my size
        doLayout: true,

        // persist: Boolean
        //              Remembers the selected child across sessions
        persist: false,

        baseClass: "dijitStackContainer",

/*=====
        // selectedChildWidget: [readonly] dijit._Widget
        //              References the currently selected child widget, if any.
        //              Adjust selected child with selectChild() method.
        selectedChildWidget: null,
=====*/

        buildRendering: function(){
                this.inherited(arguments);
                domClass.add(this.domNode, "dijitLayoutContainer");
                this.containerNode.setAttribute("role", "tabpanel");
        },

        postCreate: function(){
                this.inherited(arguments);
                this.connect(this.domNode, "onkeypress", this._onKeyPress);
        },

        startup: function(){
                if(this._started){ return; }

                var children = this.getChildren();

                // Setup each page panel to be initially hidden
                array.forEach(children, this._setupChild, this);

                // Figure out which child to initially display, defaulting to first one
                if(this.persist){
                        this.selectedChildWidget = registry.byId(cookie(this.id + "_selectedChild"));
                }else{
                        array.some(children, function(child){
                                if(child.selected){
                                        this.selectedChildWidget = child;
                                }
                                return child.selected;
                        }, this);
                }
                var selected = this.selectedChildWidget;
                if(!selected && children[0]){
                        selected = this.selectedChildWidget = children[0];
                        selected.selected = true;
                }

                // Publish information about myself so any StackControllers can initialize.
                // This needs to happen before this.inherited(arguments) so that for
                // TabContainer, this._contentBox doesn't include the space for the tab labels.
                topic.publish(this.id+"-startup", {children: children, selected: selected});

                // Startup each child widget, and do initial layout like setting this._contentBox,
                // then calls this.resize() which does the initial sizing on the selected child.
                this.inherited(arguments);
        },

        resize: function(){
                // Overrides _LayoutWidget.resize()
                // Resize is called when we are first made visible (it's called from startup()
                // if we are initially visible). If this is the first time we've been made
                // visible then show our first child.
                if(!this._hasBeenShown){
                        this._hasBeenShown = true;
                        var selected = this.selectedChildWidget;
                        if(selected){
                                this._showChild(selected);
                        }
                }
                this.inherited(arguments);
        },

        _setupChild: function(/*dijit/_WidgetBase*/ child){
                // Overrides _LayoutWidget._setupChild()

                this.inherited(arguments);

                domClass.replace(child.domNode, "dijitHidden", "dijitVisible");

                // remove the title attribute so it doesn't show up when i hover
                // over a node
                child.domNode.title = "";
        },

        addChild: function(/*dijit/_WidgetBase*/ child, /*Integer?*/ insertIndex){
                // Overrides _Container.addChild() to do layout and publish events

                this.inherited(arguments);

                if(this._started){
                        topic.publish(this.id+"-addChild", child, insertIndex); // publish

                        // in case the tab titles have overflowed from one line to two lines
                        // (or, if this if first child, from zero lines to one line)
                        // TODO: w/ScrollingTabController this is no longer necessary, although
                        // ScrollTabController.resize() does need to get called to show/hide
                        // the navigation buttons as appropriate, but that's handled in ScrollingTabController.onAddChild().
                        // If this is updated to not layout [except for initial child added / last child removed], update
                        // "childless startup" test in StackContainer.html to check for no resize event after second addChild()
                        this.layout();

                        // if this is the first child, then select it
                        if(!this.selectedChildWidget){
                                this.selectChild(child);
                        }
                }
        },

        removeChild: function(/*dijit/_WidgetBase*/ page){
                // Overrides _Container.removeChild() to do layout and publish events

                this.inherited(arguments);

                if(this._started){
                        // this will notify any tablists to remove a button; do this first because it may affect sizing
                        topic.publish(this.id + "-removeChild", page);  // publish
                }

                // If all our children are being destroyed than don't run the code below (to select another page),
                // because we are deleting every page one by one
                if(this._descendantsBeingDestroyed){ return; }

                // Select new page to display, also updating TabController to show the respective tab.
                // Do this before layout call because it can affect the height of the TabController.
                if(this.selectedChildWidget === page){
                        this.selectedChildWidget = undefined;
                        if(this._started){
                                var children = this.getChildren();
                                if(children.length){
                                        this.selectChild(children[0]);
                                }
                        }
                }

                if(this._started){
                        // In case the tab titles now take up one line instead of two lines
                        // (note though that ScrollingTabController never overflows to multiple lines),
                        // or the height has changed slightly because of addition/removal of tab which close icon
                        this.layout();
                }
        },

        selectChild: function(/*dijit/_WidgetBase|String*/ page, /*Boolean*/ animate){
                // summary:
                //              Show the given widget (which must be one of my children)
                // page:
                //              Reference to child widget or id of child widget

                page = registry.byId(page);

                if(this.selectedChildWidget != page){
                        // Deselect old page and select new one
                        var d = this._transition(page, this.selectedChildWidget, animate);
                        this._set("selectedChildWidget", page);
                        topic.publish(this.id+"-selectChild", page);    // publish

                        if(this.persist){
                                cookie(this.id + "_selectedChild", this.selectedChildWidget.id);
                        }
                }

                return d;               // If child has an href, promise that fires when the child's href finishes loading
        },

        _transition: function(newWidget, oldWidget /*===== ,  animate =====*/){
                // summary:
                //              Hide the old widget and display the new widget.
                //              Subclasses should override this.
                // newWidget: dijit/_WidgetBase
                //              The newly selected widget.
                // oldWidget: dijit/_WidgetBase
                //              The previously selected widget.
                // animate: Boolean
                //              Used by AccordionContainer to turn on/off slide effect.
                // tags:
                //              protected extension
                if(oldWidget){
                        this._hideChild(oldWidget);
                }
                var d = this._showChild(newWidget);

                // Size the new widget, in case this is the first time it's being shown,
                // or I have been resized since the last time it was shown.
                // Note that page must be visible for resizing to work.
                if(newWidget.resize){
                        if(this.doLayout){
                                newWidget.resize(this._containerContentBox || this._contentBox);
                        }else{
                                // the child should pick it's own size but we still need to call resize()
                                // (with no arguments) to let the widget lay itself out
                                newWidget.resize();
                        }
                }

                return d;       // If child has an href, promise that fires when the child's href finishes loading
        },

        _adjacent: function(/*Boolean*/ forward){
                // summary:
                //              Gets the next/previous child widget in this container from the current selection.

                // TODO: remove for 2.0 if this isn't being used.   Otherwise, fix to skip disabled tabs.

                var children = this.getChildren();
                var index = array.indexOf(children, this.selectedChildWidget);
                index += forward ? 1 : children.length - 1;
                return children[ index % children.length ]; // dijit/_WidgetBase
        },

        forward: function(){
                // summary:
                //              Advance to next page.
                return this.selectChild(this._adjacent(true), true);
        },

        back: function(){
                // summary:
                //              Go back to previous page.
                return this.selectChild(this._adjacent(false), true);
        },

        _onKeyPress: function(e){
                topic.publish(this.id+"-containerKeyPress", { e: e, page: this});       // publish
        },

        layout: function(){
                // Implement _LayoutWidget.layout() virtual method.
                var child = this.selectedChildWidget;
                if(child && child.resize){
                        if(this.doLayout){
                                child.resize(this._containerContentBox || this._contentBox);
                        }else{
                                child.resize();
                        }
                }
        },

        _showChild: function(/*dijit/_WidgetBase*/ page){
                // summary:
                //              Show the specified child by changing it's CSS, and call _onShow()/onShow() so
                //              it can do any updates it needs regarding loading href's etc.
                // returns:
                //              Promise that fires when page has finished showing, or true if there's no href
                var children = this.getChildren();
                page.isFirstChild = (page == children[0]);
                page.isLastChild = (page == children[children.length-1]);
                page._set("selected", true);

                domClass.replace(page.domNode, "dijitVisible", "dijitHidden");

                return (page._onShow && page._onShow()) || true;
        },

        _hideChild: function(/*dijit/_WidgetBase*/ page){
                // summary:
                //              Hide the specified child by changing it's CSS, and call _onHide() so
                //              it's notified.
                page._set("selected", false);
                domClass.replace(page.domNode, "dijitHidden", "dijitVisible");

                page.onHide && page.onHide();
        },

        closeChild: function(/*dijit/_WidgetBase*/ page){
                // summary:
                //              Callback when user clicks the [X] to remove a page.
                //              If onClose() returns true then remove and destroy the child.
                // tags:
                //              private
                var remove = page.onClose(this, page);
                if(remove){
                        this.removeChild(page);
                        // makes sure we can clean up executeScripts in ContentPane onUnLoad
                        page.destroyRecursive();
                }
        },

        destroyDescendants: function(/*Boolean*/ preserveDom){
                this._descendantsBeingDestroyed = true;
                this.selectedChildWidget = undefined;
                array.forEach(this.getChildren(), function(child){
                        if(!preserveDom){
                                this.removeChild(child);
                        }
                        child.destroyRecursive(preserveDom);
                }, this);
                this._descendantsBeingDestroyed = false;
        }
});

StackContainer.ChildWidgetProperties = {
        // summary:
        //              These properties can be specified for the children of a StackContainer.

        // selected: Boolean
        //              Specifies that this widget should be the initially displayed pane.
        //              Note: to change the selected child use `dijit/layout/StackContainer.selectChild`
        selected: false,

        // disabled: Boolean
        //              Specifies that the button to select this pane should be disabled.
        //              Doesn't affect programmatic selection of the pane, nor does it deselect the pane if it is currently selected.
        disabled: false,

        // closable: Boolean
        //              True if user can close (destroy) this child, such as (for example) clicking the X on the tab.
        closable: false,

        // iconClass: String
        //              CSS Class specifying icon to use in label associated with this pane.
        iconClass: "dijitNoIcon",

        // showTitle: Boolean
        //              When true, display title of this widget as tab label etc., rather than just using
        //              icon specified in iconClass
        showTitle: true
};

// Since any widget can be specified as a StackContainer child, mix them
// into the base widget class.  (This is a hack, but it's effective.)
// This is for the benefit of the parser.   Remove for 2.0.  Also, hide from doc viewer.
lang.extend(_WidgetBase, /*===== {} || =====*/ StackContainer.ChildWidgetProperties);

return StackContainer;
});

},
'dojo/regexp':function(){
define("dojo/regexp", ["./_base/kernel", "./_base/lang"], function(dojo, lang){

// module:
//              dojo/regexp

var regexp = {
        // summary:
        //              Regular expressions and Builder resources
};
lang.setObject("dojo.regexp", regexp);

regexp.escapeString = function(/*String*/str, /*String?*/except){
        // summary:
        //              Adds escape sequences for special characters in regular expressions
        // except:
        //              a String with special characters to be left unescaped

        return str.replace(/([\.$?*|{}\(\)\[\]\\\/\+^])/g, function(ch){
                if(except && except.indexOf(ch) != -1){
                        return ch;
                }
                return "\\" + ch;
        }); // String
};

regexp.buildGroupRE = function(/*Object|Array*/arr, /*Function*/re, /*Boolean?*/nonCapture){
        // summary:
        //              Builds a regular expression that groups subexpressions
        // description:
        //              A utility function used by some of the RE generators. The
        //              subexpressions are constructed by the function, re, in the second
        //              parameter.  re builds one subexpression for each elem in the array
        //              a, in the first parameter. Returns a string for a regular
        //              expression that groups all the subexpressions.
        // arr:
        //              A single value or an array of values.
        // re:
        //              A function. Takes one parameter and converts it to a regular
        //              expression.
        // nonCapture:
        //              If true, uses non-capturing match, otherwise matches are retained
        //              by regular expression. Defaults to false

        // case 1: a is a single value.
        if(!(arr instanceof Array)){
                return re(arr); // String
        }

        // case 2: a is an array
        var b = [];
        for(var i = 0; i < arr.length; i++){
                // convert each elem to a RE
                b.push(re(arr[i]));
        }

         // join the REs as alternatives in a RE group.
        return regexp.group(b.join("|"), nonCapture); // String
};

regexp.group = function(/*String*/expression, /*Boolean?*/nonCapture){
        // summary:
        //              adds group match to expression
        // nonCapture:
        //              If true, uses non-capturing match, otherwise matches are retained
        //              by regular expression.
        return "(" + (nonCapture ? "?:":"") + expression + ")"; // String
};

return regexp;
});

},
'dijit/DropDownMenu':function(){
require({cache:{
'url:dijit/templates/Menu.html':"<table class=\"dijit dijitMenu dijitMenuPassive dijitReset dijitMenuTable\" role=\"menu\" tabIndex=\"${tabIndex}\"\n\t   data-dojo-attach-event=\"onkeypress:_onKeyPress\" cellspacing=\"0\">\n\t<tbody class=\"dijitReset\" data-dojo-attach-point=\"containerNode\"></tbody>\n</table>\n"}});
define("dijit/DropDownMenu", [
        "dojo/_base/declare", // declare
        "dojo/_base/event", // event.stop
        "dojo/keys", // keys
        "dojo/text!./templates/Menu.html",
        "./_OnDijitClickMixin",
        "./_MenuBase"
], function(declare, event, keys, template, _OnDijitClickMixin, _MenuBase){

        // module:
        //              dijit/DropDownMenu

        return declare("dijit.DropDownMenu", [_MenuBase, _OnDijitClickMixin], {
                // summary:
                //              A menu, without features for context menu (Meaning, drop down menu)

                templateString: template,

                baseClass: "dijitMenu",

                postCreate: function(){
                        this.inherited(arguments);
                        var l = this.isLeftToRight();
                        this._openSubMenuKey = l ? keys.RIGHT_ARROW : keys.LEFT_ARROW;
                        this._closeSubMenuKey = l ? keys.LEFT_ARROW : keys.RIGHT_ARROW;
                        this.connectKeyNavHandlers([keys.UP_ARROW], [keys.DOWN_ARROW]);
                },

                _onKeyPress: function(/*Event*/ evt){
                        // summary:
                        //              Handle keyboard based menu navigation.
                        // tags:
                        //              protected

                        if(evt.ctrlKey || evt.altKey){ return; }

                        switch(evt.charOrCode){
                                case this._openSubMenuKey:
                                        this._moveToPopup(evt);
                                        event.stop(evt);
                                        break;
                                case this._closeSubMenuKey:
                                        if(this.parentMenu){
                                                if(this.parentMenu._isMenuBar){
                                                        this.parentMenu.focusPrev();
                                                }else{
                                                        this.onCancel(false);
                                                }
                                        }else{
                                                event.stop(evt);
                                        }
                                        break;
                        }
                }
        });
});

},
'dijit/form/_FormMixin':function(){
define("dijit/form/_FormMixin", [
        "dojo/_base/array", // array.every array.filter array.forEach array.indexOf array.map
        "dojo/_base/declare", // declare
        "dojo/_base/kernel", // kernel.deprecated
        "dojo/_base/lang", // lang.hitch lang.isArray
        "dojo/on",
        "dojo/window" // winUtils.scrollIntoView
], function(array, declare, kernel, lang, on, winUtils){

        // module:
        //              dijit/form/_FormMixin

        return declare("dijit.form._FormMixin", null, {
                // summary:
                //              Mixin for containers of form widgets (i.e. widgets that represent a single value
                //              and can be children of a `<form>` node or `dijit/form/Form` widget)
                // description:
                //              Can extract all the form widgets
                //              values and combine them into a single javascript object, or alternately
                //              take such an object and set the values for all the contained
                //              form widgets

        /*=====
                // value: Object
                //              Name/value hash for each child widget with a name and value.
                //              Child widgets without names are not part of the hash.
                //
                //              If there are multiple child widgets w/the same name, value is an array,
                //              unless they are radio buttons in which case value is a scalar (since only
                //              one radio button can be checked at a time).
                //
                //              If a child widget's name is a dot separated list (like a.b.c.d), it's a nested structure.
                //
                //              Example:
                //      |       { name: "John Smith", interests: ["sports", "movies"] }
        =====*/

                // state: [readonly] String
                //              Will be "Error" if one or more of the child widgets has an invalid value,
                //              "Incomplete" if not all of the required child widgets are filled in.  Otherwise, "",
                //              which indicates that the form is ready to be submitted.
                state: "",

                // TODO:
                //      * Repeater
                //      * better handling for arrays.  Often form elements have names with [] like
                //      * people[3].sex (for a list of people [{name: Bill, sex: M}, ...])


                _getDescendantFormWidgets: function(/*dijit/_WidgetBase[]?*/ children){
                        // summary:
                        //              Returns all form widget descendants, searching through non-form child widgets like BorderContainer
                        var res = [];
                        array.forEach(children || this.getChildren(), function(child){
                                if("value" in child){
                                        res.push(child);
                                }else{
                                        res = res.concat(this._getDescendantFormWidgets(child.getChildren()));
                                }
                        }, this);
                        return res;
                },

                reset: function(){
                        array.forEach(this._getDescendantFormWidgets(), function(widget){
                                if(widget.reset){
                                        widget.reset();
                                }
                        });
                },

                validate: function(){
                        // summary:
                        //              returns if the form is valid - same as isValid - but
                        //              provides a few additional (ui-specific) features:
                        //
                        //              1. it will highlight any sub-widgets that are not valid
                        //              2. it will call focus() on the first invalid sub-widget
                        var didFocus = false;
                        return array.every(array.map(this._getDescendantFormWidgets(), function(widget){
                                // Need to set this so that "required" widgets get their
                                // state set.
                                widget._hasBeenBlurred = true;
                                var valid = widget.disabled || !widget.validate || widget.validate();
                                if(!valid && !didFocus){
                                        // Set focus of the first non-valid widget
                                        winUtils.scrollIntoView(widget.containerNode || widget.domNode);
                                        widget.focus();
                                        didFocus = true;
                                }
                                return valid;
                        }), function(item){ return item; });
                },

                setValues: function(val){
                        kernel.deprecated(this.declaredClass+"::setValues() is deprecated. Use set('value', val) instead.", "", "2.0");
                        return this.set('value', val);
                },
                _setValueAttr: function(/*Object*/ obj){
                        // summary:
                        //              Fill in form values from according to an Object (in the format returned by get('value'))

                        // generate map from name --> [list of widgets with that name]
                        var map = { };
                        array.forEach(this._getDescendantFormWidgets(), function(widget){
                                if(!widget.name){ return; }
                                var entry = map[widget.name] || (map[widget.name] = [] );
                                entry.push(widget);
                        });

                        for(var name in map){
                                if(!map.hasOwnProperty(name)){
                                        continue;
                                }
                                var widgets = map[name],                                                // array of widgets w/this name
                                        values = lang.getObject(name, false, obj);      // list of values for those widgets

                                if(values === undefined){
                                        continue;
                                }
                                if(!lang.isArray(values)){
                                        values = [ values ];
                                }
                                if(typeof widgets[0].checked == 'boolean'){
                                        // for checkbox/radio, values is a list of which widgets should be checked
                                        array.forEach(widgets, function(w){
                                                w.set('value', array.indexOf(values, w.value) != -1);
                                        });
                                }else if(widgets[0].multiple){
                                        // it takes an array (e.g. multi-select)
                                        widgets[0].set('value', values);
                                }else{
                                        // otherwise, values is a list of values to be assigned sequentially to each widget
                                        array.forEach(widgets, function(w, i){
                                                w.set('value', values[i]);
                                        });
                                }
                        }

                        /***
                         *      TODO: code for plain input boxes (this shouldn't run for inputs that are part of widgets)

                        array.forEach(this.containerNode.elements, function(element){
                                if(element.name == ''){return}; // like "continue"
                                var namePath = element.name.split(".");
                                var myObj=obj;
                                var name=namePath[namePath.length-1];
                                for(var j=1,len2=namePath.length;j<len2;++j){
                                        var p=namePath[j - 1];
                                        // repeater support block
                                        var nameA=p.split("[");
                                        if(nameA.length > 1){
                                                if(typeof(myObj[nameA[0]]) == "undefined"){
                                                        myObj[nameA[0]]=[ ];
                                                } // if

                                                nameIndex=parseInt(nameA[1]);
                                                if(typeof(myObj[nameA[0]][nameIndex]) == "undefined"){
                                                        myObj[nameA[0]][nameIndex] = { };
                                                }
                                                myObj=myObj[nameA[0]][nameIndex];
                                                continue;
                                        } // repeater support ends

                                        if(typeof(myObj[p]) == "undefined"){
                                                myObj=undefined;
                                                break;
                                        };
                                        myObj=myObj[p];
                                }

                                if(typeof(myObj) == "undefined"){
                                        return;         // like "continue"
                                }
                                if(typeof(myObj[name]) == "undefined" && this.ignoreNullValues){
                                        return;         // like "continue"
                                }

                                // TODO: widget values (just call set('value', ...) on the widget)

                                // TODO: maybe should call dojo.getNodeProp() instead
                                switch(element.type){
                                        case "checkbox":
                                                element.checked = (name in myObj) &&
                                                        array.some(myObj[name], function(val){ return val == element.value; });
                                                break;
                                        case "radio":
                                                element.checked = (name in myObj) && myObj[name] == element.value;
                                                break;
                                        case "select-multiple":
                                                element.selectedIndex=-1;
                                                array.forEach(element.options, function(option){
                                                        option.selected = array.some(myObj[name], function(val){ return option.value == val; });
                                                });
                                                break;
                                        case "select-one":
                                                element.selectedIndex="0";
                                                array.forEach(element.options, function(option){
                                                        option.selected = option.value == myObj[name];
                                                });
                                                break;
                                        case "hidden":
                                        case "text":
                                        case "textarea":
                                        case "password":
                                                element.value = myObj[name] || "";
                                                break;
                                }
                        });
                        */

                        // Note: no need to call this._set("value", ...) as the child updates will trigger onChange events
                        // which I am monitoring.
                },

                getValues: function(){
                        kernel.deprecated(this.declaredClass+"::getValues() is deprecated. Use get('value') instead.", "", "2.0");
                        return this.get('value');
                },
                _getValueAttr: function(){
                        // summary:
                        //              Returns Object representing form values.   See description of `value` for details.
                        // description:

                        // The value is updated into this.value every time a child has an onChange event,
                        // so in the common case this function could just return this.value.   However,
                        // that wouldn't work when:
                        //
                        // 1. User presses return key to submit a form.  That doesn't fire an onchange event,
                        // and even if it did it would come too late due to the defer(...) in _handleOnChange()
                        //
                        // 2. app for some reason calls this.get("value") while the user is typing into a
                        // form field.   Not sure if that case needs to be supported or not.

                        // get widget values
                        var obj = { };
                        array.forEach(this._getDescendantFormWidgets(), function(widget){
                                var name = widget.name;
                                if(!name || widget.disabled){ return; }

                                // Single value widget (checkbox, radio, or plain <input> type widget)
                                var value = widget.get('value');

                                // Store widget's value(s) as a scalar, except for checkboxes which are automatically arrays
                                if(typeof widget.checked == 'boolean'){
                                        if(/Radio/.test(widget.declaredClass)){
                                                // radio button
                                                if(value !== false){
                                                        lang.setObject(name, value, obj);
                                                }else{
                                                        // give radio widgets a default of null
                                                        value = lang.getObject(name, false, obj);
                                                        if(value === undefined){
                                                                lang.setObject(name, null, obj);
                                                        }
                                                }
                                        }else{
                                                // checkbox/toggle button
                                                var ary=lang.getObject(name, false, obj);
                                                if(!ary){
                                                        ary=[];
                                                        lang.setObject(name, ary, obj);
                                                }
                                                if(value !== false){
                                                        ary.push(value);
                                                }
                                        }
                                }else{
                                        var prev=lang.getObject(name, false, obj);
                                        if(typeof prev != "undefined"){
                                                if(lang.isArray(prev)){
                                                        prev.push(value);
                                                }else{
                                                        lang.setObject(name, [prev, value], obj);
                                                }
                                        }else{
                                                // unique name
                                                lang.setObject(name, value, obj);
                                        }
                                }
                        });

                        /***
                         * code for plain input boxes (see also domForm.formToObject, can we use that instead of this code?
                         * but it doesn't understand [] notation, presumably)
                        var obj = { };
                        array.forEach(this.containerNode.elements, function(elm){
                                if(!elm.name)   {
                                        return;         // like "continue"
                                }
                                var namePath = elm.name.split(".");
                                var myObj=obj;
                                var name=namePath[namePath.length-1];
                                for(var j=1,len2=namePath.length;j<len2;++j){
                                        var nameIndex = null;
                                        var p=namePath[j - 1];
                                        var nameA=p.split("[");
                                        if(nameA.length > 1){
                                                if(typeof(myObj[nameA[0]]) == "undefined"){
                                                        myObj[nameA[0]]=[ ];
                                                } // if
                                                nameIndex=parseInt(nameA[1]);
                                                if(typeof(myObj[nameA[0]][nameIndex]) == "undefined"){
                                                        myObj[nameA[0]][nameIndex] = { };
                                                }
                                        }else if(typeof(myObj[nameA[0]]) == "undefined"){
                                                myObj[nameA[0]] = { }
                                        } // if

                                        if(nameA.length == 1){
                                                myObj=myObj[nameA[0]];
                                        }else{
                                                myObj=myObj[nameA[0]][nameIndex];
                                        } // if
                                } // for

                                if((elm.type != "select-multiple" && elm.type != "checkbox" && elm.type != "radio") || (elm.type == "radio" && elm.checked)){
                                        if(name == name.split("[")[0]){
                                                myObj[name]=elm.value;
                                        }else{
                                                // can not set value when there is no name
                                        }
                                }else if(elm.type == "checkbox" && elm.checked){
                                        if(typeof(myObj[name]) == 'undefined'){
                                                myObj[name]=[ ];
                                        }
                                        myObj[name].push(elm.value);
                                }else if(elm.type == "select-multiple"){
                                        if(typeof(myObj[name]) == 'undefined'){
                                                myObj[name]=[ ];
                                        }
                                        for(var jdx=0,len3=elm.options.length; jdx<len3; ++jdx){
                                                if(elm.options[jdx].selected){
                                                        myObj[name].push(elm.options[jdx].value);
                                                }
                                        }
                                } // if
                                name=undefined;
                        }); // forEach
                        ***/
                        return obj;
                },

                isValid: function(){
                        // summary:
                        //              Returns true if all of the widgets are valid.
                        //              Deprecated, will be removed in 2.0.  Use get("state") instead.

                        return this.state == "";
                },

                onValidStateChange: function(/*Boolean*/ /*===== isValid =====*/){
                        // summary:
                        //              Stub function to connect to if you want to do something
                        //              (like disable/enable a submit button) when the valid
                        //              state changes on the form as a whole.
                        //
                        //              Deprecated.  Will be removed in 2.0.  Use watch("state", ...) instead.
                },

                _getState: function(){
                        // summary:
                        //              Compute what this.state should be based on state of children
                        var states = array.map(this._descendants, function(w){
                                return w.get("state") || "";
                        });

                        return array.indexOf(states, "Error") >= 0 ? "Error" :
                                array.indexOf(states, "Incomplete") >= 0 ? "Incomplete" : "";
                },

                disconnectChildren: function(){
                        // summary:
                        //              Deprecated method.   Applications no longer need to call this.   Remove for 2.0.
                },

                connectChildren: function(/*Boolean*/ inStartup){
                        // summary:
                        //              You can call this function directly, ex. in the event that you
                        //              programmatically add a widget to the form *after* the form has been
                        //              initialized.

                        // TODO: rename for 2.0

                        this._descendants = this._getDescendantFormWidgets();

                        // To get notifications from children they need to be started.   Children didn't used to need to be started,
                        // so for back-compat, start them here
                        array.forEach(this._descendants, function(child){
                                if(!child._started){ child.startup(); }
                        });

                        if(!inStartup){
                                this._onChildChange();
                        }
                },

                _onChildChange: function(/*String*/ attr){
                        // summary:
                        //              Called when child's value or disabled state changes

                        // The unit tests expect state update to be synchronous, so update it immediately.
                        if(!attr || attr == "state" || attr == "disabled"){
                                this._set("state", this._getState());
                        }

                        // Use defer() to collapse value changes in multiple children into a single
                        // update to my value.   Multiple updates will occur on:
                        //      1. Form.set()
                        //      2. Form.reset()
                        //      3. user selecting a radio button (which will de-select another radio button,
                        //               causing two onChange events)
                        if(!attr || attr == "value" || attr == "disabled" || attr == "checked"){
                                if(this._onChangeDelayTimer){
                                        this._onChangeDelayTimer.remove();
                                }
                                this._onChangeDelayTimer = this.defer(function(){
                                        delete this._onChangeDelayTimer;
                                        this._set("value", this.get("value"));
                                }, 10);
                        }
                },

                startup: function(){
                        this.inherited(arguments);

                        // Set initial this.value and this.state.   Don't emit watch() notifications.
                        this._descendants = this._getDescendantFormWidgets();
                        this.value = this.get("value");
                        this.state = this._getState();

                        // Initialize value and valid/invalid state tracking.
                        var self = this;
                        this.own(
                                on(
                                        this.containerNode,
                                        "attrmodified-state, attrmodified-disabled, attrmodified-value, attrmodified-checked",
                                        function(evt){
                                                if(evt.target == self.domNode){
                                                        return; // ignore events that I fire on myself because my children changed
                                                }
                                                self._onChildChange(evt.type.replace("attrmodified-", ""));
                                        }
                                )
                        );

                        // Make state change call onValidStateChange(), will be removed in 2.0
                        this.watch("state", function(attr, oldVal, newVal){ this.onValidStateChange(newVal == ""); });
                },

                destroy: function(){
                        this.inherited(arguments);
                }

        });
});

},
'dojo/data/util/simpleFetch':function(){
define("dojo/data/util/simpleFetch", ["../../_base/lang", "../../_base/kernel", "./sorter"],
  function(lang, kernel, sorter){
        // module:
        //              dojo/data/util/simpleFetch
        // summary:
        //              The simpleFetch mixin is designed to serve as a set of function(s) that can
        //              be mixed into other datastore implementations to accelerate their development.

var simpleFetch = {};
lang.setObject("dojo.data.util.simpleFetch", simpleFetch);

simpleFetch.errorHandler = function(/*Object*/ errorData, /*Object*/ requestObject){
        // summary:
        //              The error handler when there is an error fetching items.  This function should not be called
        //              directly and is used by simpleFetch.fetch().
        if(requestObject.onError){
                var scope = requestObject.scope || kernel.global;
                requestObject.onError.call(scope, errorData, requestObject);
        }
};

simpleFetch.fetchHandler = function(/*Array*/ items, /*Object*/ requestObject){
        // summary:
        //              The handler when items are sucessfully fetched.  This function should not be called directly
        //              and is used by simpleFetch.fetch().
        var oldAbortFunction = requestObject.abort || null,
                aborted = false,

                startIndex = requestObject.start?requestObject.start: 0,
                endIndex = (requestObject.count && (requestObject.count !== Infinity))?(startIndex + requestObject.count):items.length;

        requestObject.abort = function(){
                aborted = true;
                if(oldAbortFunction){
                        oldAbortFunction.call(requestObject);
                }
        };

        var scope = requestObject.scope || kernel.global;
        if(!requestObject.store){
                requestObject.store = this;
        }
        if(requestObject.onBegin){
                requestObject.onBegin.call(scope, items.length, requestObject);
        }
        if(requestObject.sort){
                items.sort(sorter.createSortFunction(requestObject.sort, this));
        }
        if(requestObject.onItem){
                for(var i = startIndex; (i < items.length) && (i < endIndex); ++i){
                        var item = items[i];
                        if(!aborted){
                                requestObject.onItem.call(scope, item, requestObject);
                        }
                }
        }
        if(requestObject.onComplete && !aborted){
                var subset = null;
                if(!requestObject.onItem){
                        subset = items.slice(startIndex, endIndex);
                }
                requestObject.onComplete.call(scope, subset, requestObject);
        }
};

simpleFetch.fetch = function(/* Object? */ request){
        // summary:
        //              The simpleFetch mixin is designed to serve as a set of function(s) that can
        //              be mixed into other datastore implementations to accelerate their development.
        // description:
        //              The simpleFetch mixin should work well for any datastore that can respond to a _fetchItems()
        //              call by returning an array of all the found items that matched the query.  The simpleFetch mixin
        //              is not designed to work for datastores that respond to a fetch() call by incrementally
        //              loading items, or sequentially loading partial batches of the result
        //              set.  For datastores that mixin simpleFetch, simpleFetch
        //              implements a fetch method that automatically handles eight of the fetch()
        //              arguments -- onBegin, onItem, onComplete, onError, start, count, sort and scope
        //              The class mixing in simpleFetch should not implement fetch(),
        //              but should instead implement a _fetchItems() method.  The _fetchItems()
        //              method takes three arguments, the keywordArgs object that was passed
        //              to fetch(), a callback function to be called when the result array is
        //              available, and an error callback to be called if something goes wrong.
        //              The _fetchItems() method should ignore any keywordArgs parameters for
        //              start, count, onBegin, onItem, onComplete, onError, sort, and scope.
        //              The _fetchItems() method needs to correctly handle any other keywordArgs
        //              parameters, including the query parameter and any optional parameters
        //              (such as includeChildren).  The _fetchItems() method should create an array of
        //              result items and pass it to the fetchHandler along with the original request object --
        //              or, the _fetchItems() method may, if it wants to, create an new request object
        //              with other specifics about the request that are specific to the datastore and pass
        //              that as the request object to the handler.
        //
        //              For more information on this specific function, see dojo/data/api/Read.fetch()
        //
        // request:
        //              The keywordArgs parameter may either be an instance of
        //              conforming to dojo/data/api/Request or may be a simple anonymous object
        //              that may contain any of the following:
        // |    {
        // |            query: query-object or query-string,
        // |            queryOptions: object,
        // |            onBegin: Function,
        // |            onItem: Function,
        // |            onComplete: Function,
        // |            onError: Function,
        // |            scope: object,
        // |            start: int
        // |            count: int
        // |            sort: array
        // |    }
        //              All implementations should accept keywordArgs objects with any of
        //              the 9 standard properties: query, onBegin, onItem, onComplete, onError
        //              scope, sort, start, and count.  Some implementations may accept additional
        //              properties in the keywordArgs object as valid parameters, such as
        //              {includeOutliers:true}.
        //
        //              ####The *query* parameter
        //
        //              The query may be optional in some data store implementations.
        //              The dojo/data/api/Read API does not specify the syntax or semantics
        //              of the query itself -- each different data store implementation
        //              may have its own notion of what a query should look like.
        //              However, as of dojo 0.9, 1.0, and 1.1, all the provided datastores in dojo.data
        //              and dojox.data support an object structure query, where the object is a set of
        //              name/value parameters such as { attrFoo: valueBar, attrFoo1: valueBar1}.  Most of the
        //              dijit widgets, such as ComboBox assume this to be the case when working with a datastore
        //              when they dynamically update the query.  Therefore, for maximum compatibility with dijit
        //              widgets the recommended query parameter is a key/value object.  That does not mean that the
        //              the datastore may not take alternative query forms, such as a simple string, a Date, a number,
        //              or a mix of such.  Ultimately, The dojo/data/api/Read API is agnostic about what the query
        //              format.
        //
        //              Further note:  In general for query objects that accept strings as attribute
        //              value matches, the store should also support basic filtering capability, such as *
        //              (match any character) and ? (match single character).  An example query that is a query object
        //              would be like: { attrFoo: "value*"}.  Which generally means match all items where they have
        //              an attribute named attrFoo, with a value that starts with 'value'.
        //
        //              ####The *queryOptions* parameter
        //
        //              The queryOptions parameter is an optional parameter used to specify options that may modify
        //              the query in some fashion, such as doing a case insensitive search, or doing a deep search
        //              where all items in a hierarchical representation of data are scanned instead of just the root
        //              items.  It currently defines two options that all datastores should attempt to honor if possible:
        // |    {
        // |            ignoreCase: boolean, // Whether or not the query should match case sensitively or not.  Default behaviour is false.
        // |            deep: boolean   // Whether or not a fetch should do a deep search of items and all child
        // |                                            // items instead of just root-level items in a datastore.  Default is false.
        // |    }
        //
        //              ####The *onBegin* parameter.
        //
        //              function(size, request);
        //              If an onBegin callback function is provided, the callback function
        //              will be called just once, before the first onItem callback is called.
        //              The onBegin callback function will be passed two arguments, the
        //              the total number of items identified and the Request object.  If the total number is
        //              unknown, then size will be -1.  Note that size is not necessarily the size of the
        //              collection of items returned from the query, as the request may have specified to return only a
        //              subset of the total set of items through the use of the start and count parameters.
        //
        //              ####The *onItem* parameter.
        //
        //              function(item, request);
        //
        //              If an onItem callback function is provided, the callback function
        //              will be called as each item in the result is received. The callback
        //              function will be passed two arguments: the item itself, and the
        //              Request object.
        //
        //              ####The *onComplete* parameter.
        //
        //              function(items, request);
        //
        //              If an onComplete callback function is provided, the callback function
        //              will be called just once, after the last onItem callback is called.
        //              Note that if the onItem callback is not present, then onComplete will be passed
        //              an array containing all items which matched the query and the request object.
        //              If the onItem callback is present, then onComplete is called as:
        //              onComplete(null, request).
        //
        //              ####The *onError* parameter.
        //
        //              function(errorData, request);
        //
        //              If an onError callback function is provided, the callback function
        //              will be called if there is any sort of error while attempting to
        //              execute the query.
        //              The onError callback function will be passed two arguments:
        //              an Error object and the Request object.
        //
        //              ####The *scope* parameter.
        //
        //              If a scope object is provided, all of the callback functions (onItem,
        //              onComplete, onError, etc) will be invoked in the context of the scope
        //              object.  In the body of the callback function, the value of the "this"
        //              keyword will be the scope object.   If no scope object is provided,
        //              the callback functions will be called in the context of dojo.global().
        //              For example, onItem.call(scope, item, request) vs.
        //              onItem.call(dojo.global(), item, request)
        //
        //              ####The *start* parameter.
        //
        //              If a start parameter is specified, this is a indication to the datastore to
        //              only start returning items once the start number of items have been located and
        //              skipped.  When this parameter is paired with 'count', the store should be able
        //              to page across queries with millions of hits by only returning subsets of the
        //              hits for each query
        //
        //              ####The *count* parameter.
        //
        //              If a count parameter is specified, this is a indication to the datastore to
        //              only return up to that many items.  This allows a fetch call that may have
        //              millions of item matches to be paired down to something reasonable.
        //
        //              ####The *sort* parameter.
        //
        //              If a sort parameter is specified, this is a indication to the datastore to
        //              sort the items in some manner before returning the items.  The array is an array of
        //              javascript objects that must conform to the following format to be applied to the
        //              fetching of items:
        // |    {
        // |            attribute: attribute || attribute-name-string,
        // |            descending: true|false;   // Optional.  Default is false.
        // |    }
        //              Note that when comparing attributes, if an item contains no value for the attribute
        //              (undefined), then it the default ascending sort logic should push it to the bottom
        //              of the list.  In the descending order case, it such items should appear at the top of the list.

        request = request || {};
        if(!request.store){
                request.store = this;
        }

        this._fetchItems(request, lang.hitch(this, "fetchHandler"), lang.hitch(this, "errorHandler"));
        return request; // Object
};

return simpleFetch;
});

},
'dijit/Menu':function(){
define("dijit/Menu", [
        "require",
        "dojo/_base/array", // array.forEach
        "dojo/_base/declare", // declare
        "dojo/_base/event", // event.stop
        "dojo/dom", // dom.byId dom.isDescendant
        "dojo/dom-attr", // domAttr.get domAttr.set domAttr.has domAttr.remove
        "dojo/dom-geometry", // domStyle.getComputedStyle domGeometry.position
        "dojo/dom-style", // domStyle.getComputedStyle
        "dojo/keys",    // keys.F10
        "dojo/_base/lang", // lang.hitch
        "dojo/on",
        "dojo/sniff", // has("ie"), has("quirks")
        "dojo/_base/window", // win.body win.doc.documentElement win.doc.frames
        "dojo/window", // winUtils.get
        "./popup",
        "./DropDownMenu",
        "dojo/ready"
], function(require, array, declare, event, dom, domAttr, domGeometry, domStyle, keys, lang, on,
                        has, win, winUtils, pm, DropDownMenu, ready){

// module:
//              dijit/Menu

// Back compat w/1.6, remove for 2.0
if(has("dijit-legacy-requires")){
        ready(0, function(){
                var requires = ["dijit/MenuItem", "dijit/PopupMenuItem", "dijit/CheckedMenuItem", "dijit/MenuSeparator"];
                require(requires);      // use indirection so modules not rolled into a build
        });
}

return declare("dijit.Menu", DropDownMenu, {
        // summary:
        //              A context menu you can assign to multiple elements

        constructor: function(/*===== params, srcNodeRef =====*/){
                // summary:
                //              Create the widget.
                // params: Object|null
                //              Hash of initialization parameters for widget, including scalar values (like title, duration etc.)
                //              and functions, typically callbacks like onClick.
                //              The hash can contain any of the widget's properties, excluding read-only properties.
                // srcNodeRef: DOMNode|String?
                //              If a srcNodeRef (DOM node) is specified:
                //
                //              - use srcNodeRef.innerHTML as my contents
                //              - replace srcNodeRef with my generated DOM tree

                this._bindings = [];
        },

        // targetNodeIds: [const] String[]
        //              Array of dom node ids of nodes to attach to.
        //              Fill this with nodeIds upon widget creation and it becomes context menu for those nodes.
        targetNodeIds: [],

        // selector: String?
        //              CSS expression to apply this Menu to descendants of targetNodeIds, rather than to
        //              the nodes specified by targetNodeIds themselves.    Useful for applying a Menu to
        //              a range of rows in a table, tree, etc.
        //
        //              The application must require() an appropriate level of dojo/query to handle the selector.
        selector: "",

        // TODO: in 2.0 remove support for multiple targetNodeIds.   selector gives the same effect.
        // So, change targetNodeIds to a targetNodeId: "", remove bindDomNode()/unBindDomNode(), etc.

/*=====
        // currentTarget: [readonly] DOMNode
        //              For context menus, set to the current node that the Menu is being displayed for.
        //              Useful so that the menu actions can be tailored according to the node
        currentTarget: null,
=====*/

        // contextMenuForWindow: [const] Boolean
        //              If true, right clicking anywhere on the window will cause this context menu to open.
        //              If false, must specify targetNodeIds.
        contextMenuForWindow: false,

        // leftClickToOpen: [const] Boolean
        //              If true, menu will open on left click instead of right click, similar to a file menu.
        leftClickToOpen: false,

        // refocus: Boolean
        //              When this menu closes, re-focus the element which had focus before it was opened.
        refocus: true,

        postCreate: function(){
                if(this.contextMenuForWindow){
                        this.bindDomNode(this.ownerDocumentBody);
                }else{
                        // TODO: should have _setTargetNodeIds() method to handle initialization and a possible
                        // later set('targetNodeIds', ...) call.  There's also a problem that targetNodeIds[]
                        // gets stale after calls to bindDomNode()/unBindDomNode() as it still is just the original list (see #9610)
                        array.forEach(this.targetNodeIds, this.bindDomNode, this);
                }
                this.inherited(arguments);
        },

        // thanks burstlib!
        _iframeContentWindow: function(/* HTMLIFrameElement */iframe_el){
                // summary:
                //              Returns the window reference of the passed iframe
                // tags:
                //              private
                return winUtils.get(this._iframeContentDocument(iframe_el)) ||
                        // Moz. TODO: is this available when defaultView isn't?
                        this._iframeContentDocument(iframe_el)['__parent__'] ||
                        (iframe_el.name && win.doc.frames[iframe_el.name]) || null;     //      Window
        },

        _iframeContentDocument: function(/* HTMLIFrameElement */iframe_el){
                // summary:
                //              Returns a reference to the document object inside iframe_el
                // tags:
                //              protected
                return iframe_el.contentDocument // W3
                        || (iframe_el.contentWindow && iframe_el.contentWindow.document) // IE
                        || (iframe_el.name && win.doc.frames[iframe_el.name] && win.doc.frames[iframe_el.name].document)
                        || null;        //      HTMLDocument
        },

        bindDomNode: function(/*String|DomNode*/ node){
                // summary:
                //              Attach menu to given node
                node = dom.byId(node, this.ownerDocument);

                var cn; // Connect node

                // Support context menus on iframes.  Rather than binding to the iframe itself we need
                // to bind to the <body> node inside the iframe.
                if(node.tagName.toLowerCase() == "iframe"){
                        var iframe = node,
                                window = this._iframeContentWindow(iframe);
                        cn = win.body(window.document);
                }else{
                        // To capture these events at the top level, attach to <html>, not <body>.
                        // Otherwise right-click context menu just doesn't work.
                        cn = (node == win.body(this.ownerDocument) ? this.ownerDocument.documentElement : node);
                }


                // "binding" is the object to track our connection to the node (ie, the parameter to bindDomNode())
                var binding = {
                        node: node,
                        iframe: iframe
                };

                // Save info about binding in _bindings[], and make node itself record index(+1) into
                // _bindings[] array.  Prefix w/_dijitMenu to avoid setting an attribute that may
                // start with a number, which fails on FF/safari.
                domAttr.set(node, "_dijitMenu" + this.id, this._bindings.push(binding));

                // Setup the connections to monitor click etc., unless we are connecting to an iframe which hasn't finished
                // loading yet, in which case we need to wait for the onload event first, and then connect
                // On linux Shift-F10 produces the oncontextmenu event, but on Windows it doesn't, so
                // we need to monitor keyboard events in addition to the oncontextmenu event.
                var doConnects = lang.hitch(this, function(cn){
                        var selector = this.selector,
                                delegatedEvent = selector ?
                                        function(eventType){ return on.selector(selector, eventType); } :
                                        function(eventType){ return eventType; },
                                self = this;
                        return [
                                // TODO: when leftClickToOpen is true then shouldn't space/enter key trigger the menu,
                                // rather than shift-F10?
                                on(cn, delegatedEvent(this.leftClickToOpen ? "click" : "contextmenu"), function(evt){
                                        // Schedule context menu to be opened unless it's already been scheduled from onkeydown handler
                                        event.stop(evt);
                                        self._scheduleOpen(this, iframe, {x: evt.pageX, y: evt.pageY});
                                }),
                                on(cn, delegatedEvent("keydown"), function(evt){
                                        if(evt.shiftKey && evt.keyCode == keys.F10){
                                                event.stop(evt);
                                                self._scheduleOpen(this, iframe);       // no coords - open near target node
                                        }
                                })
                        ];
                });
                binding.connects = cn ? doConnects(cn) : [];

                if(iframe){
                        // Setup handler to [re]bind to the iframe when the contents are initially loaded,
                        // and every time the contents change.
                        // Need to do this b/c we are actually binding to the iframe's <body> node.
                        // Note: can't use connect.connect(), see #9609.

                        binding.onloadHandler = lang.hitch(this, function(){
                                // want to remove old connections, but IE throws exceptions when trying to
                                // access the <body> node because it's already gone, or at least in a state of limbo

                                var window = this._iframeContentWindow(iframe);
                                        cn = win.body(window.document)
                                binding.connects = doConnects(cn);
                        });
                        if(iframe.addEventListener){
                                iframe.addEventListener("load", binding.onloadHandler, false);
                        }else{
                                iframe.attachEvent("onload", binding.onloadHandler);
                        }
                }
        },

        unBindDomNode: function(/*String|DomNode*/ nodeName){
                // summary:
                //              Detach menu from given node

                var node;
                try{
                        node = dom.byId(nodeName, this.ownerDocument);
                }catch(e){
                        // On IE the dom.byId() call will get an exception if the attach point was
                        // the <body> node of an <iframe> that has since been reloaded (and thus the
                        // <body> node is in a limbo state of destruction.
                        return;
                }

                // node["_dijitMenu" + this.id] contains index(+1) into my _bindings[] array
                var attrName = "_dijitMenu" + this.id;
                if(node && domAttr.has(node, attrName)){
                        var bid = domAttr.get(node, attrName)-1, b = this._bindings[bid], h;
                        while((h = b.connects.pop())){
                                h.remove();
                        }

                        // Remove listener for iframe onload events
                        var iframe = b.iframe;
                        if(iframe){
                                if(iframe.removeEventListener){
                                        iframe.removeEventListener("load", b.onloadHandler, false);
                                }else{
                                        iframe.detachEvent("onload", b.onloadHandler);
                                }
                        }

                        domAttr.remove(node, attrName);
                        delete this._bindings[bid];
                }
        },

        _scheduleOpen: function(/*DomNode?*/ target, /*DomNode?*/ iframe, /*Object?*/ coords){
                // summary:
                //              Set timer to display myself.  Using a timer rather than displaying immediately solves
                //              two problems:
                //
                //              1. IE: without the delay, focus work in "open" causes the system
                //              context menu to appear in spite of stopEvent.
                //
                //              2. Avoid double-shows on linux, where shift-F10 generates an oncontextmenu event
                //              even after a event.stop(e).  (Shift-F10 on windows doesn't generate the
                //              oncontextmenu event.)

                if(!this._openTimer){
                        this._openTimer = this.defer(function(){
                                delete this._openTimer;
                                this._openMyself({
                                        target: target,
                                        iframe: iframe,
                                        coords: coords
                                });
                        }, 1);
                }
        },

        _openMyself: function(args){
                // summary:
                //              Internal function for opening myself when the user does a right-click or something similar.
                // args:
                //              This is an Object containing:
                //
                //              - target: The node that is being clicked
                //              - iframe: If an `<iframe>` is being clicked, iframe points to that iframe
                //              - coords: Put menu at specified x/y position in viewport, or if iframe is
                //                specified, then relative to iframe.
                //
                //              _openMyself() formerly took the event object, and since various code references
                //              evt.target (after connecting to _openMyself()), using an Object for parameters
                //              (so that old code still works).

                var target = args.target,
                        iframe = args.iframe,
                        coords = args.coords;

                // To be used by MenuItem event handlers to tell which node the menu was opened on
                this.currentTarget = target;

                // Get coordinates to open menu, either at specified (mouse) position or (if triggered via keyboard)
                // then near the node the menu is assigned to.
                if(coords){
                        if(iframe){
                                // Specified coordinates are on <body> node of an <iframe>, convert to match main document
                                var ifc = domGeometry.position(iframe, true),
                                        window = this._iframeContentWindow(iframe),
                                        scroll = domGeometry.docScroll(window.document);

                                var cs = domStyle.getComputedStyle(iframe),
                                        tp = domStyle.toPixelValue,
                                        left = (has("ie") && has("quirks") ? 0 : tp(iframe, cs.paddingLeft)) + (has("ie") && has("quirks") ? tp(iframe, cs.borderLeftWidth) : 0),
                                        top = (has("ie") && has("quirks") ? 0 : tp(iframe, cs.paddingTop)) + (has("ie") && has("quirks") ? tp(iframe, cs.borderTopWidth) : 0);

                                coords.x += ifc.x + left - scroll.x;
                                coords.y += ifc.y + top - scroll.y;
                        }
                }else{
                        coords = domGeometry.position(target, true);
                        coords.x += 10;
                        coords.y += 10;
                }

                var self=this;
                var prevFocusNode = this._focusManager.get("prevNode");
                var curFocusNode = this._focusManager.get("curNode");
                var savedFocusNode = !curFocusNode || (dom.isDescendant(curFocusNode, this.domNode)) ? prevFocusNode : curFocusNode;

                function closeAndRestoreFocus(){
                        // user has clicked on a menu or popup
                        if(self.refocus && savedFocusNode){
                                savedFocusNode.focus();
                        }
                        pm.close(self);
                }
                pm.open({
                        popup: this,
                        x: coords.x,
                        y: coords.y,
                        onExecute: closeAndRestoreFocus,
                        onCancel: closeAndRestoreFocus,
                        orient: this.isLeftToRight() ? 'L' : 'R'
                });
                this.focus();

                this._onBlur = function(){
                        this.inherited('_onBlur', arguments);
                        // Usually the parent closes the child widget but if this is a context
                        // menu then there is no parent
                        pm.close(this);
                        // don't try to restore focus; user has clicked another part of the screen
                        // and set focus there
                };
        },

        destroy: function(){
                array.forEach(this._bindings, function(b){ if(b){ this.unBindDomNode(b.node); } }, this);
                this.inherited(arguments);
        }
});

});

},
'dijit/form/_CheckBoxMixin':function(){
define("dijit/form/_CheckBoxMixin", [
        "dojo/_base/declare", // declare
        "dojo/dom-attr", // domAttr.set
        "dojo/_base/event" // event.stop
], function(declare, domAttr, event){

        // module:
        //              dijit/form/_CheckBoxMixin

        return declare("dijit.form._CheckBoxMixin", null, {
                // summary:
                //              Mixin to provide widget functionality corresponding to an HTML checkbox
                //
                // description:
                //              User interacts with real html inputs.
                //              On onclick (which occurs by mouse click, space-bar, or
                //              using the arrow keys to switch the selected radio button),
                //              we update the state of the checkbox/radio.
                //

                // type: [private] String
                //              type attribute on `<input>` node.
                //              Overrides `dijit/form/Button.type`.  Users should not change this value.
                type: "checkbox",

                // value: String
                //              As an initialization parameter, equivalent to value field on normal checkbox
                //              (if checked, the value is passed as the value when form is submitted).
                value: "on",

                // readOnly: Boolean
                //              Should this widget respond to user input?
                //              In markup, this is specified as "readOnly".
                //              Similar to disabled except readOnly form values are submitted.
                readOnly: false,
                
                // aria-pressed for toggle buttons, and aria-checked for checkboxes
                _aria_attr: "aria-checked",

                _setReadOnlyAttr: function(/*Boolean*/ value){
                        this._set("readOnly", value);
                        domAttr.set(this.focusNode, 'readOnly', value);
                },

                // Override dijit/form/Button._setLabelAttr() since we don't even have a containerNode.
                // Normally users won't try to set label, except when CheckBox or RadioButton is the child of a dojox/layout/TabContainer
                _setLabelAttr: undefined,

                _getSubmitValue: function(/*String*/ value){
                        return !value && value !== 0 ? "on" : value;
                },

                _setValueAttr: function(newValue){
                        newValue = this._getSubmitValue(newValue);      // "on" to match browser native behavior when value unspecified
                        this._set("value", newValue);
                        domAttr.set(this.focusNode, "value", newValue);
                },

                reset: function(){
                        this.inherited(arguments);
                        // Handle unlikely event that the <input type=checkbox> value attribute has changed
                        this._set("value", this.params.value || "on");
                        domAttr.set(this.focusNode, 'value', this.value);
                },

                _onClick: function(/*Event*/ e){
                        // summary:
                        //              Internal function to handle click actions - need to check
                        //              readOnly, since button no longer does that check.
                        if(this.readOnly){
                                event.stop(e);
                                return false;
                        }
                        return this.inherited(arguments);
                }
        });
});

},
'dijit/layout/ContentPane':function(){
define("dijit/layout/ContentPane", [
        "dojo/_base/kernel", // kernel.deprecated
        "dojo/_base/lang", // lang.mixin lang.delegate lang.hitch lang.isFunction lang.isObject
        "../_Widget",
        "../_Container",
        "./_ContentPaneResizeMixin",
        "dojo/string", // string.substitute
        "dojo/html", // html._ContentSetter
        "dojo/i18n!../nls/loading",
        "dojo/_base/array", // array.forEach
        "dojo/_base/declare", // declare
        "dojo/_base/Deferred", // Deferred
        "dojo/dom", // dom.byId
        "dojo/dom-attr", // domAttr.attr
        "dojo/dom-construct", // empty()
        "dojo/_base/xhr", // xhr.get
        "dojo/i18n", // i18n.getLocalization
        "dojo/when"
], function(kernel, lang, _Widget, _Container, _ContentPaneResizeMixin, string, html, nlsLoading,
        array, declare, Deferred, dom, domAttr, domConstruct, xhr, i18n, when){

// module:
//              dijit/layout/ContentPane


return declare("dijit.layout.ContentPane", [_Widget, _Container, _ContentPaneResizeMixin], {
        // summary:
        //              A widget containing an HTML fragment, specified inline
        //              or by uri.  Fragment may include widgets.
        //
        // description:
        //              This widget embeds a document fragment in the page, specified
        //              either by uri, javascript generated markup or DOM reference.
        //              Any widgets within this content are instantiated and managed,
        //              but laid out according to the HTML structure.  Unlike IFRAME,
        //              ContentPane embeds a document fragment as would be found
        //              inside the BODY tag of a full HTML document.  It should not
        //              contain the HTML, HEAD, or BODY tags.
        //              For more advanced functionality with scripts and
        //              stylesheets, see dojox/layout/ContentPane.  This widget may be
        //              used stand alone or as a base class for other widgets.
        //              ContentPane is useful as a child of other layout containers
        //              such as BorderContainer or TabContainer, but note that those
        //              widgets can contain any widget as a child.
        //
        // example:
        //              Some quick samples:
        //              To change the innerHTML:
        // |            cp.set('content', '<b>new content</b>')`
        //              Or you can send it a NodeList:
        // |            cp.set('content', dojo.query('div [class=selected]', userSelection))
        //              To do an ajax update:
        // |            cp.set('href', url)

        // href: String
        //              The href of the content that displays now.
        //              Set this at construction if you want to load data externally when the
        //              pane is shown.  (Set preload=true to load it immediately.)
        //              Changing href after creation doesn't have any effect; Use set('href', ...);
        href: "",

        // content: String|DomNode|NodeList|dijit/_Widget
        //              The innerHTML of the ContentPane.
        //              Note that the initialization parameter / argument to set("content", ...)
        //              can be a String, DomNode, Nodelist, or _Widget.
        content: "",

        // extractContent: Boolean
        //              Extract visible content from inside of `<body> .... </body>`.
        //              I.e., strip `<html>` and `<head>` (and it's contents) from the href
        extractContent: false,

        // parseOnLoad: Boolean
        //              Parse content and create the widgets, if any.
        parseOnLoad: true,

        // parserScope: String
        //              Flag passed to parser.  Root for attribute names to search for.   If scopeName is dojo,
        //              will search for data-dojo-type (or dojoType).  For backwards compatibility
        //              reasons defaults to dojo._scopeName (which is "dojo" except when
        //              multi-version support is used, when it will be something like dojo16, dojo20, etc.)
        parserScope: kernel._scopeName,

        // preventCache: Boolean
        //              Prevent caching of data from href's by appending a timestamp to the href.
        preventCache: false,

        // preload: Boolean
        //              Force load of data on initialization even if pane is hidden.
        preload: false,

        // refreshOnShow: Boolean
        //              Refresh (re-download) content when pane goes from hidden to shown
        refreshOnShow: false,

        // loadingMessage: String
        //              Message that shows while downloading
        loadingMessage: "<span class='dijitContentPaneLoading'><span class='dijitInline dijitIconLoading'></span>${loadingState}</span>",

        // errorMessage: String
        //              Message that shows if an error occurs
        errorMessage: "<span class='dijitContentPaneError'><span class='dijitInline dijitIconError'></span>${errorState}</span>",

        // isLoaded: [readonly] Boolean
        //              True if the ContentPane has data in it, either specified
        //              during initialization (via href or inline content), or set
        //              via set('content', ...) / set('href', ...)
        //
        //              False if it doesn't have any content, or if ContentPane is
        //              still in the process of downloading href.
        isLoaded: false,

        baseClass: "dijitContentPane",

        /*======
        // ioMethod: dojo/_base/xhr.get|dojo._base/xhr.post
        //              Function that should grab the content specified via href.
        ioMethod: dojo.xhrGet,
        ======*/

        // ioArgs: Object
        //              Parameters to pass to xhrGet() request, for example:
        // |    <div data-dojo-type="dijit/layout/ContentPane" data-dojo-props="href: './bar', ioArgs: {timeout: 500}">
        ioArgs: {},

        // onLoadDeferred: [readonly] dojo.Deferred
        //              This is the `dojo.Deferred` returned by set('href', ...) and refresh().
        //              Calling onLoadDeferred.then() registers your
        //              callback to be called only once, when the prior set('href', ...) call or
        //              the initial href parameter to the constructor finishes loading.
        //
        //              This is different than an onLoad() handler which gets called any time any href
        //              or content is loaded.
        onLoadDeferred: null,

        // Cancel _WidgetBase's _setTitleAttr because we don't want the title attribute (used to specify
        // tab labels) to be copied to ContentPane.domNode... otherwise a tooltip shows up over the
        // entire pane.
        _setTitleAttr: null,

        // Flag to parser that I'll parse my contents, so it shouldn't.
        stopParser: true,

        // template: [private] Boolean
        //              Flag from the parser that this ContentPane is inside a template
        //              so the contents are pre-parsed.
        // TODO: this declaration can be commented out in 2.0
        template: false,

        create: function(params, srcNodeRef){
                // Convert a srcNodeRef argument into a content parameter, so that the original contents are
                // processed in the same way as contents set via set("content", ...), calling the parser etc.
                // Avoid modifying original params object since that breaks NodeList instantiation, see #11906.
                if((!params || !params.template) && srcNodeRef && !("href" in params) && !("content" in params)){
                        srcNodeRef = dom.byId(srcNodeRef);
                        var df = srcNodeRef.ownerDocument.createDocumentFragment();
                        while(srcNodeRef.firstChild){
                                df.appendChild(srcNodeRef.firstChild);
                        }
                        params = lang.delegate(params, {content: df});
                }
                this.inherited(arguments, [params, srcNodeRef]);
        },

        postMixInProperties: function(){
                this.inherited(arguments);
                var messages = i18n.getLocalization("dijit", "loading", this.lang);
                this.loadingMessage = string.substitute(this.loadingMessage, messages);
                this.errorMessage = string.substitute(this.errorMessage, messages);
        },

        buildRendering: function(){
                this.inherited(arguments);

                // Since we have no template we need to set this.containerNode ourselves, to make getChildren() work.
                // For subclasses of ContentPane that do have a template, does nothing.
                if(!this.containerNode){
                        this.containerNode = this.domNode;
                }

                // remove the title attribute so it doesn't show up when hovering
                // over a node  (TODO: remove in 2.0, no longer needed after #11490)
                this.domNode.title = "";

                if(!domAttr.get(this.domNode,"role")){
                        this.domNode.setAttribute("role", "group");
                }
        },

        startup: function(){
                // summary:
                //              Call startup() on all children including non _Widget ones like dojo/dnd/Source objects

                // This starts all the widgets
                this.inherited(arguments);

                // And this catches stuff like dojo/dnd/Source
                if(this._contentSetter){
                        array.forEach(this._contentSetter.parseResults, function(obj){
                                if(!obj._started && !obj._destroyed && lang.isFunction(obj.startup)){
                                        obj.startup();
                                        obj._started = true;
                                }
                        }, this);
                }
        },

        _startChildren: function(){
                // summary:
                //              Called when content is loaded.   Calls startup on each child widget.   Similar to ContentPane.startup()
                //              itself, but avoids marking the ContentPane itself as "restarted" (see #15581).

                // This starts all the widgets
                array.forEach(this.getChildren(), function(obj){
                        if(!obj._started && !obj._destroyed && lang.isFunction(obj.startup)){
                                obj.startup();
                                obj._started = true;
                        }
                });

                // And this catches stuff like dojo/dnd/Source
                if(this._contentSetter){
                        array.forEach(this._contentSetter.parseResults, function(obj){
                                if(!obj._started && !obj._destroyed && lang.isFunction(obj.startup)){
                                        obj.startup();
                                        obj._started = true;
                                }
                        }, this);
                }
        },

        setHref: function(/*String|Uri*/ href){
                // summary:
                //              Deprecated.   Use set('href', ...) instead.
                kernel.deprecated("dijit.layout.ContentPane.setHref() is deprecated. Use set('href', ...) instead.", "", "2.0");
                return this.set("href", href);
        },
        _setHrefAttr: function(/*String|Uri*/ href){
                // summary:
                //              Hook so set("href", ...) works.
                // description:
                //              Reset the (external defined) content of this pane and replace with new url
                //              Note: It delays the download until widget is shown if preload is false.
                // href:
                //              url to the page you want to get, must be within the same domain as your mainpage

                // Cancel any in-flight requests (a set('href', ...) will cancel any in-flight set('href', ...))
                this.cancel();

                this.onLoadDeferred = new Deferred(lang.hitch(this, "cancel"));
                this.onLoadDeferred.then(lang.hitch(this, "onLoad"));

                this._set("href", href);

                // _setHrefAttr() is called during creation and by the user, after creation.
                // Assuming preload == false, only in the second case do we actually load the URL;
                // otherwise it's done in startup(), and only if this widget is shown.
                if(this.preload || (this._created && this._isShown())){
                        this._load();
                }else{
                        // Set flag to indicate that href needs to be loaded the next time the
                        // ContentPane is made visible
                        this._hrefChanged = true;
                }

                return this.onLoadDeferred;             // Deferred
        },

        setContent: function(/*String|DomNode|Nodelist*/data){
                // summary:
                //              Deprecated.   Use set('content', ...) instead.
                kernel.deprecated("dijit.layout.ContentPane.setContent() is deprecated.  Use set('content', ...) instead.", "", "2.0");
                this.set("content", data);
        },
        _setContentAttr: function(/*String|DomNode|Nodelist*/data){
                // summary:
                //              Hook to make set("content", ...) work.
                //              Replaces old content with data content, include style classes from old content
                // data:
                //              the new Content may be String, DomNode or NodeList
                //
                //              if data is a NodeList (or an array of nodes) nodes are copied
                //              so you can import nodes from another document implicitly

                // clear href so we can't run refresh and clear content
                // refresh should only work if we downloaded the content
                this._set("href", "");

                // Cancel any in-flight requests (a set('content', ...) will cancel any in-flight set('href', ...))
                this.cancel();

                // Even though user is just setting content directly, still need to define an onLoadDeferred
                // because the _onLoadHandler() handler is still getting called from setContent()
                this.onLoadDeferred = new Deferred(lang.hitch(this, "cancel"));
                if(this._created){
                        // For back-compat reasons, call onLoad() for set('content', ...)
                        // calls but not for content specified in srcNodeRef (ie: <div data-dojo-type=ContentPane>...</div>)
                        // or as initialization parameter (ie: new ContentPane({content: ...})
                        this.onLoadDeferred.then(lang.hitch(this, "onLoad"));
                }

                this._setContent(data || "");

                this._isDownloaded = false; // mark that content is from a set('content') not a set('href')

                return this.onLoadDeferred;     // Deferred
        },
        _getContentAttr: function(){
                // summary:
                //              Hook to make get("content") work
                return this.containerNode.innerHTML;
        },

        cancel: function(){
                // summary:
                //              Cancels an in-flight download of content
                if(this._xhrDfd && (this._xhrDfd.fired == -1)){
                        this._xhrDfd.cancel();
                }
                delete this._xhrDfd; // garbage collect

                this.onLoadDeferred = null;
        },

        destroy: function(){
                this.cancel();
                this.inherited(arguments);
        },

        destroyRecursive: function(/*Boolean*/ preserveDom){
                // summary:
                //              Destroy the ContentPane and its contents

                // if we have multiple controllers destroying us, bail after the first
                if(this._beingDestroyed){
                        return;
                }
                this.inherited(arguments);
        },

        _onShow: function(){
                // summary:
                //              Called when the ContentPane is made visible
                // description:
                //              For a plain ContentPane, this is called on initialization, from startup().
                //              If the ContentPane is a hidden pane of a TabContainer etc., then it's
                //              called whenever the pane is made visible.
                //
                //              Does necessary processing, including href download and layout/resize of
                //              child widget(s)

                this.inherited(arguments);

                if(this.href){
                        if(!this._xhrDfd && // if there's an href that isn't already being loaded
                                (!this.isLoaded || this._hrefChanged || this.refreshOnShow)
                        ){
                                return this.refresh();  // If child has an href, promise that fires when the load is complete
                        }
                }
        },

        refresh: function(){
                // summary:
                //              [Re]download contents of href and display
                // description:
                //              1. cancels any currently in-flight requests
                //              2. posts "loading..." message
                //              3. sends XHR to download new data

                // Cancel possible prior in-flight request
                this.cancel();

                this.onLoadDeferred = new Deferred(lang.hitch(this, "cancel"));
                this.onLoadDeferred.then(lang.hitch(this, "onLoad"));
                this._load();
                return this.onLoadDeferred;             // If child has an href, promise that fires when refresh is complete
        },

        _load: function(){
                // summary:
                //              Load/reload the href specified in this.href

                // display loading message
                this._setContent(this.onDownloadStart(), true);

                var self = this;
                var getArgs = {
                        preventCache: (this.preventCache || this.refreshOnShow),
                        url: this.href,
                        handleAs: "text"
                };
                if(lang.isObject(this.ioArgs)){
                        lang.mixin(getArgs, this.ioArgs);
                }

                var hand = (this._xhrDfd = (this.ioMethod || xhr.get)(getArgs)),
                        returnedHtml;

                hand.then(
                        function(html){
                                returnedHtml = html;
                                try{
                                        self._isDownloaded = true;
                                        return self._setContent(html, false);
                                }catch(err){
                                        self._onError('Content', err); // onContentError
                                }
                        },
                        function(err){
                                if(!hand.canceled){
                                        // show error message in the pane
                                        self._onError('Download', err); // onDownloadError
                                }
                                delete self._xhrDfd;
                                return err;
                        }
                ).then(function(){
                        self.onDownloadEnd();
                        delete self._xhrDfd;
                        return returnedHtml;
                });

                // Remove flag saying that a load is needed
                delete this._hrefChanged;
        },

        _onLoadHandler: function(data){
                // summary:
                //              This is called whenever new content is being loaded
                this._set("isLoaded", true);
                try{
                        this.onLoadDeferred.resolve(data);
                }catch(e){
                        console.error('Error '+this.widgetId+' running custom onLoad code: ' + e.message);
                }
        },

        _onUnloadHandler: function(){
                // summary:
                //              This is called whenever the content is being unloaded
                this._set("isLoaded", false);
                try{
                        this.onUnload();
                }catch(e){
                        console.error('Error '+this.widgetId+' running custom onUnload code: ' + e.message);
                }
        },

        destroyDescendants: function(/*Boolean*/ preserveDom){
                // summary:
                //              Destroy all the widgets inside the ContentPane and empty containerNode

                // Make sure we call onUnload (but only when the ContentPane has real content)
                if(this.isLoaded){
                        this._onUnloadHandler();
                }

                // Even if this.isLoaded == false there might still be a "Loading..." message
                // to erase, so continue...

                // For historical reasons we need to delete all widgets under this.containerNode,
                // even ones that the user has created manually.
                var setter = this._contentSetter;
                array.forEach(this.getChildren(), function(widget){
                        if(widget.destroyRecursive){
                                // All widgets will hit this branch
                                widget.destroyRecursive(preserveDom);
                        }else if(widget.destroy){
                                // Things like dojo/dnd/Source have destroy(), not destroyRecursive()
                                widget.destroy(preserveDom);
                        }
                        widget._destroyed = true;
                });
                if(setter){
                        // Most of the widgets in setter.parseResults have already been destroyed, but
                        // things like Menu that have been moved to <body> haven't yet
                        array.forEach(setter.parseResults, function(widget){
                                if(!widget._destroyed){
                                        if(widget.destroyRecursive){
                                                // All widgets will hit this branch
                                                widget.destroyRecursive(preserveDom);
                                        }else if(widget.destroy){
                                                // Things like dojo/dnd/Source have destroy(), not destroyRecursive()
                                                widget.destroy(preserveDom);
                                        }
                                        widget._destroyed = true;
                                }
                        });
                        delete setter.parseResults;
                }

                // And then clear away all the DOM nodes
                if(!preserveDom){
                        domConstruct.empty(this.containerNode);
                }

                // Delete any state information we have about current contents
                delete this._singleChild;
        },

        _setContent: function(/*String|DocumentFragment*/ cont, /*Boolean*/ isFakeContent){
                // summary:
                //              Insert the content into the container node
                // returns:
                //              Returns a Deferred promise that is resolved when the content is parsed.

                // first get rid of child widgets
                this.destroyDescendants();

                // html.set will take care of the rest of the details
                // we provide an override for the error handling to ensure the widget gets the errors
                // configure the setter instance with only the relevant widget instance properties
                // NOTE: unless we hook into attr, or provide property setters for each property,
                // we need to re-configure the ContentSetter with each use
                var setter = this._contentSetter;
                if(! (setter && setter instanceof html._ContentSetter)){
                        setter = this._contentSetter = new html._ContentSetter({
                                node: this.containerNode,
                                _onError: lang.hitch(this, this._onError),
                                onContentError: lang.hitch(this, function(e){
                                        // fires if a domfault occurs when we are appending this.errorMessage
                                        // like for instance if domNode is a UL and we try append a DIV
                                        var errMess = this.onContentError(e);
                                        try{
                                                this.containerNode.innerHTML = errMess;
                                        }catch(e){
                                                console.error('Fatal '+this.id+' could not change content due to '+e.message, e);
                                        }
                                })/*,
                                _onError */
                        });
                }

                var setterParams = lang.mixin({
                        cleanContent: this.cleanContent,
                        extractContent: this.extractContent,
                        parseContent: !cont.domNode && this.parseOnLoad,
                        parserScope: this.parserScope,
                        startup: false,
                        dir: this.dir,
                        lang: this.lang,
                        textDir: this.textDir
                }, this._contentSetterParams || {});

                var p = setter.set( (lang.isObject(cont) && cont.domNode) ? cont.domNode : cont, setterParams );

                // dojox/layout/html/_base::_ContentSetter.set() returns a Promise that indicates when everything is completed.
                // dojo/html::_ContentSetter.set() currently returns the DOMNode, but that will be changed for 2.0.
                // So, if set() returns a promise then use it, otherwise fallback to waiting on setter.parseDeferred
                var self = this;
                return when(p && p.then ? p : setter.parseDeferred, function(){
                        // setter params must be pulled afresh from the ContentPane each time
                        delete self._contentSetterParams;
                        
                        if(!isFakeContent){
                                if(self._started){
                                        // Startup each top level child widget (and they will start their children, recursively)
                                        self._startChildren();
                                        
                                        // Call resize() on each of my child layout widgets,
                                        // or resize() on my single child layout widget...
                                        // either now (if I'm currently visible) or when I become visible
                                        self._scheduleLayout();
                                }
                                self._onLoadHandler(cont);
                        }
                });
        },

        _onError: function(type, err, consoleText){
                this.onLoadDeferred.reject(err);

                // shows user the string that is returned by on[type]Error
                // override on[type]Error and return your own string to customize
                var errText = this['on' + type + 'Error'].call(this, err);
                if(consoleText){
                        console.error(consoleText, err);
                }else if(errText){// a empty string won't change current content
                        this._setContent(errText, true);
                }
        },

        // EVENT's, should be overide-able
        onLoad: function(/*===== data =====*/){
                // summary:
                //              Event hook, is called after everything is loaded and widgetified
                // tags:
                //              callback
        },

        onUnload: function(){
                // summary:
                //              Event hook, is called before old content is cleared
                // tags:
                //              callback
        },

        onDownloadStart: function(){
                // summary:
                //              Called before download starts.
                // description:
                //              The string returned by this function will be the html
                //              that tells the user we are loading something.
                //              Override with your own function if you want to change text.
                // tags:
                //              extension
                return this.loadingMessage;
        },

        onContentError: function(/*Error*/ /*===== error =====*/){
                // summary:
                //              Called on DOM faults, require faults etc. in content.
                //
                //              In order to display an error message in the pane, return
                //              the error message from this method, as an HTML string.
                //
                //              By default (if this method is not overriden), it returns
                //              nothing, so the error message is just printed to the console.
                // tags:
                //              extension
        },

        onDownloadError: function(/*Error*/ /*===== error =====*/){
                // summary:
                //              Called when download error occurs.
                //
                //              In order to display an error message in the pane, return
                //              the error message from this method, as an HTML string.
                //
                //              Default behavior (if this method is not overriden) is to display
                //              the error message inside the pane.
                // tags:
                //              extension
                return this.errorMessage;
        },

        onDownloadEnd: function(){
                // summary:
                //              Called when download is finished.
                // tags:
                //              callback
        }
});

});

},
'url:dijit/form/templates/ValidationTextBox.html':"<div class=\"dijit dijitReset dijitInline dijitLeft\"\n\tid=\"widget_${id}\" role=\"presentation\"\n\t><div class='dijitReset dijitValidationContainer'\n\t\t><input class=\"dijitReset dijitInputField dijitValidationIcon dijitValidationInner\" value=\"&#935; \" type=\"text\" tabIndex=\"-1\" readonly=\"readonly\" role=\"presentation\"\n\t/></div\n\t><div class=\"dijitReset dijitInputField dijitInputContainer\"\n\t\t><input class=\"dijitReset dijitInputInner\" data-dojo-attach-point='textbox,focusNode' autocomplete=\"off\"\n\t\t\t${!nameAttrSetting} type='${type}'\n\t/></div\n></div>\n",
'url:dijit/form/templates/TextBox.html':"<div class=\"dijit dijitReset dijitInline dijitLeft\" id=\"widget_${id}\" role=\"presentation\"\n\t><div class=\"dijitReset dijitInputField dijitInputContainer\"\n\t\t><input class=\"dijitReset dijitInputInner\" data-dojo-attach-point='textbox,focusNode' autocomplete=\"off\"\n\t\t\t${!nameAttrSetting} type='${type}'\n\t/></div\n></div>\n",
'dijit/_KeyNavContainer':function(){
define("dijit/_KeyNavContainer", [
        "dojo/_base/kernel", // kernel.deprecated
        "./_Container",
        "./_FocusMixin",
        "dojo/_base/array", // array.forEach
        "dojo/keys", // keys.END keys.HOME
        "dojo/_base/declare", // declare
        "dojo/_base/event", // event.stop
        "dojo/dom-attr", // domAttr.set
        "dojo/_base/lang" // lang.hitch
], function(kernel, _Container, _FocusMixin, array, keys, declare, event, domAttr, lang){


        // module:
        //              dijit/_KeyNavContainer

        return declare("dijit._KeyNavContainer", [_FocusMixin, _Container], {
                // summary:
                //              A _Container with keyboard navigation of its children.
                // description:
                //              To use this mixin, call connectKeyNavHandlers() in
                //              postCreate().
                //              It provides normalized keyboard and focusing code for Container
                //              widgets.

/*=====
                // focusedChild: [protected] Widget
                //              The currently focused child widget, or null if there isn't one
                focusedChild: null,
=====*/

                // tabIndex: String
                //              Tab index of the container; same as HTML tabIndex attribute.
                //              Note then when user tabs into the container, focus is immediately
                //              moved to the first item in the container.
                tabIndex: "0",

                connectKeyNavHandlers: function(/*keys[]*/ prevKeyCodes, /*keys[]*/ nextKeyCodes){
                        // summary:
                        //              Call in postCreate() to attach the keyboard handlers
                        //              to the container.
                        // preKeyCodes: keys[]
                        //              Key codes for navigating to the previous child.
                        // nextKeyCodes: keys[]
                        //              Key codes for navigating to the next child.
                        // tags:
                        //              protected

                        // TODO: call this automatically from my own postCreate()

                        var keyCodes = (this._keyNavCodes = {});
                        var prev = lang.hitch(this, "focusPrev");
                        var next = lang.hitch(this, "focusNext");
                        array.forEach(prevKeyCodes, function(code){ keyCodes[code] = prev; });
                        array.forEach(nextKeyCodes, function(code){ keyCodes[code] = next; });
                        keyCodes[keys.HOME] = lang.hitch(this, "focusFirstChild");
                        keyCodes[keys.END] = lang.hitch(this, "focusLastChild");
                        this.connect(this.domNode, "onkeypress", "_onContainerKeypress");
                        this.connect(this.domNode, "onfocus", "_onContainerFocus");
                },

                startupKeyNavChildren: function(){
                        kernel.deprecated("startupKeyNavChildren() call no longer needed", "", "2.0");
                },

                startup: function(){
                        this.inherited(arguments);
                        array.forEach(this.getChildren(), lang.hitch(this, "_startupChild"));
                },

                addChild: function(/*dijit/_WidgetBase*/ widget, /*int?*/ insertIndex){
                        this.inherited(arguments);
                        this._startupChild(widget);
                },

                focus: function(){
                        // summary:
                        //              Default focus() implementation: focus the first child.
                        this.focusFirstChild();
                },

                focusFirstChild: function(){
                        // summary:
                        //              Focus the first focusable child in the container.
                        // tags:
                        //              protected
                        this.focusChild(this._getFirstFocusableChild());
                },

                focusLastChild: function(){
                        // summary:
                        //              Focus the last focusable child in the container.
                        // tags:
                        //              protected
                        this.focusChild(this._getLastFocusableChild());
                },

                focusNext: function(){
                        // summary:
                        //              Focus the next widget
                        // tags:
                        //              protected
                        this.focusChild(this._getNextFocusableChild(this.focusedChild, 1));
                },

                focusPrev: function(){
                        // summary:
                        //              Focus the last focusable node in the previous widget
                        //              (ex: go to the ComboButton icon section rather than button section)
                        // tags:
                        //              protected
                        this.focusChild(this._getNextFocusableChild(this.focusedChild, -1), true);
                },

                focusChild: function(/*dijit/_WidgetBase*/ widget, /*Boolean*/ last){
                        // summary:
                        //              Focus specified child widget.
                        // widget:
                        //              Reference to container's child widget
                        // last:
                        //              If true and if widget has multiple focusable nodes, focus the
                        //              last one instead of the first one
                        // tags:
                        //              protected

                        if(!widget){ return; }

                        if(this.focusedChild && widget !== this.focusedChild){
                                this._onChildBlur(this.focusedChild);   // used by _MenuBase
                        }
                        widget.set("tabIndex", this.tabIndex);  // for IE focus outline to appear, must set tabIndex before focs
                        widget.focus(last ? "end" : "start");
                        this._set("focusedChild", widget);
                },

                _startupChild: function(/*dijit/_WidgetBase*/ widget){
                        // summary:
                        //              Setup for each child widget
                        // description:
                        //              Sets tabIndex=-1 on each child, so that the tab key will
                        //              leave the container rather than visiting each child.
                        // tags:
                        //              private

                        widget.set("tabIndex", "-1");

                        this.connect(widget, "_onFocus", function(){
                                // Set valid tabIndex so tabbing away from widget goes to right place, see #10272
                                widget.set("tabIndex", this.tabIndex);
                        });
                        this.connect(widget, "_onBlur", function(){
                                widget.set("tabIndex", "-1");
                        });
                },

                _onContainerFocus: function(evt){
                        // summary:
                        //              Handler for when the container gets focus
                        // description:
                        //              Initially the container itself has a tabIndex, but when it gets
                        //              focus, switch focus to first child...
                        // tags:
                        //              private

                        // Note that we can't use _onFocus() because switching focus from the
                        // _onFocus() handler confuses the focus.js code
                        // (because it causes _onFocusNode() to be called recursively)
                        // Also, _onFocus() would fire when focus went directly to a child widget due to mouse click.

                        // Ignore spurious focus events:
                        //      1. focus on a child widget bubbles on FF
                        //      2. on IE, clicking the scrollbar of a select dropdown moves focus from the focused child item to me
                        if(evt.target !== this.domNode || this.focusedChild){ return; }

                        this.focusFirstChild();

                        // and then set the container's tabIndex to -1,
                        // (don't remove as that breaks Safari 4)
                        // so that tab or shift-tab will go to the fields after/before
                        // the container, rather than the container itself
                        domAttr.set(this.domNode, "tabIndex", "-1");
                },

                _onBlur: function(evt){
                        // When focus is moved away the container, and its descendant (popup) widgets,
                        // then restore the container's tabIndex so that user can tab to it again.
                        // Note that using _onBlur() so that this doesn't happen when focus is shifted
                        // to one of my child widgets (typically a popup)
                        if(this.tabIndex){
                                domAttr.set(this.domNode, "tabIndex", this.tabIndex);
                        }
                        this.focusedChild = null;
                        this.inherited(arguments);
                },

                _onContainerKeypress: function(evt){
                        // summary:
                        //              When a key is pressed, if it's an arrow key etc. then
                        //              it's handled here.
                        // tags:
                        //              private
                        if(evt.ctrlKey || evt.altKey){ return; }
                        var func = this._keyNavCodes[evt.charOrCode];
                        if(func){
                                func();
                                event.stop(evt);
                        }
                },

                _onChildBlur: function(/*dijit/_WidgetBase*/ /*===== widget =====*/){
                        // summary:
                        //              Called when focus leaves a child widget to go
                        //              to a sibling widget.
                        //              Used by MenuBase.js (TODO: move code there)
                        // tags:
                        //              protected
                },

                _getFirstFocusableChild: function(){
                        // summary:
                        //              Returns first child that can be focused
                        return this._getNextFocusableChild(null, 1);    // dijit/_WidgetBase
                },

                _getLastFocusableChild: function(){
                        // summary:
                        //              Returns last child that can be focused
                        return this._getNextFocusableChild(null, -1);   // dijit/_WidgetBase
                },

                _getNextFocusableChild: function(child, dir){
                        // summary:
                        //              Returns the next or previous focusable child, compared
                        //              to "child"
                        // child: Widget
                        //              The current widget
                        // dir: Integer
                        //              - 1 = after
                        //              - -1 = before
                        if(child){
                                child = this._getSiblingOfChild(child, dir);
                        }
                        var children = this.getChildren();
                        for(var i=0; i < children.length; i++){
                                if(!child){
                                        child = children[(dir>0) ? 0 : (children.length-1)];
                                }
                                if(child.isFocusable()){
                                        return child;   // dijit/_WidgetBase
                                }
                                child = this._getSiblingOfChild(child, dir);
                        }
                        // no focusable child found
                        return null;    // dijit/_WidgetBase
                }
        });
});

},
'dijit/layout/utils':function(){
define("dijit/layout/utils", [
        "dojo/_base/array", // array.filter array.forEach
        "dojo/dom-class", // domClass.add domClass.remove
        "dojo/dom-geometry", // domGeometry.marginBox
        "dojo/dom-style", // domStyle.getComputedStyle
        "dojo/_base/lang", // lang.mixin
        "../main"       // for exporting symbols to dijit, remove in 2.0
], function(array, domClass, domGeometry, domStyle, lang, dijit){

        // module:
        //              dijit/layout/utils

        var layout = lang.getObject("layout", true, dijit);
        /*=====
        layout = {
                 // summary:
                 //             marginBox2contentBox() and layoutChildren()
         };
         =====*/

        layout.marginBox2contentBox = function(/*DomNode*/ node, /*Object*/ mb){
                // summary:
                //              Given the margin-box size of a node, return its content box size.
                //              Functions like domGeometry.contentBox() but is more reliable since it doesn't have
                //              to wait for the browser to compute sizes.
                var cs = domStyle.getComputedStyle(node);
                var me = domGeometry.getMarginExtents(node, cs);
                var pb = domGeometry.getPadBorderExtents(node, cs);
                return {
                        l: domStyle.toPixelValue(node, cs.paddingLeft),
                        t: domStyle.toPixelValue(node, cs.paddingTop),
                        w: mb.w - (me.w + pb.w),
                        h: mb.h - (me.h + pb.h)
                };
        };

        function capitalize(word){
                return word.substring(0,1).toUpperCase() + word.substring(1);
        }

        function size(widget, dim){
                // size the child
                var newSize = widget.resize ? widget.resize(dim) : domGeometry.setMarginBox(widget.domNode, dim);

                // record child's size
                if(newSize){
                        // if the child returned it's new size then use that
                        lang.mixin(widget, newSize);
                }else{
                        // otherwise, call getMarginBox(), but favor our own numbers when we have them.
                        // the browser lies sometimes
                        lang.mixin(widget, domGeometry.getMarginBox(widget.domNode));
                        lang.mixin(widget, dim);
                }
        }

        layout.layoutChildren = function(/*DomNode*/ container, /*Object*/ dim, /*Widget[]*/ children,
                        /*String?*/ changedRegionId, /*Number?*/ changedRegionSize){
                // summary:
                //              Layout a bunch of child dom nodes within a parent dom node
                // container:
                //              parent node
                // dim:
                //              {l, t, w, h} object specifying dimensions of container into which to place children
                // children:
                //              An array of Widgets or at least objects containing:
                //
                //              - domNode: pointer to DOM node to position
                //              - region or layoutAlign: position to place DOM node
                //              - resize(): (optional) method to set size of node
                //              - id: (optional) Id of widgets, referenced from resize object, below.
                // changedRegionId:
                //              If specified, the slider for the region with the specified id has been dragged, and thus
                //              the region's height or width should be adjusted according to changedRegionSize
                // changedRegionSize:
                //              See changedRegionId.

                // copy dim because we are going to modify it
                dim = lang.mixin({}, dim);

                domClass.add(container, "dijitLayoutContainer");

                // Move "client" elements to the end of the array for layout.  a11y dictates that the author
                // needs to be able to put them in the document in tab-order, but this algorithm requires that
                // client be last.    TODO: move these lines to LayoutContainer?   Unneeded other places I think.
                children = array.filter(children, function(item){ return item.region != "center" && item.layoutAlign != "client"; })
                        .concat(array.filter(children, function(item){ return item.region == "center" || item.layoutAlign == "client"; }));

                // set positions/sizes
                array.forEach(children, function(child){
                        var elm = child.domNode,
                                pos = (child.region || child.layoutAlign);
                        if(!pos){
                                throw new Error("No region setting for " + child.id)
                        }

                        // set elem to upper left corner of unused space; may move it later
                        var elmStyle = elm.style;
                        elmStyle.left = dim.l+"px";
                        elmStyle.top = dim.t+"px";
                        elmStyle.position = "absolute";

                        domClass.add(elm, "dijitAlign" + capitalize(pos));

                        // Size adjustments to make to this child widget
                        var sizeSetting = {};

                        // Check for optional size adjustment due to splitter drag (height adjustment for top/bottom align
                        // panes and width adjustment for left/right align panes.
                        if(changedRegionId && changedRegionId == child.id){
                                sizeSetting[child.region == "top" || child.region == "bottom" ? "h" : "w"] = changedRegionSize;
                        }

                        // set size && adjust record of remaining space.
                        // note that setting the width of a <div> may affect its height.
                        if(pos == "top" || pos == "bottom"){
                                sizeSetting.w = dim.w;
                                size(child, sizeSetting);
                                dim.h -= child.h;
                                if(pos == "top"){
                                        dim.t += child.h;
                                }else{
                                        elmStyle.top = dim.t + dim.h + "px";
                                }
                        }else if(pos == "left" || pos == "right"){
                                sizeSetting.h = dim.h;
                                size(child, sizeSetting);
                                dim.w -= child.w;
                                if(pos == "left"){
                                        dim.l += child.w;
                                }else{
                                        elmStyle.left = dim.l + dim.w + "px";
                                }
                        }else if(pos == "client" || pos == "center"){
                                size(child, dim);
                        }
                });
        };


        return {
                marginBox2contentBox: layout.marginBox2contentBox,
                layoutChildren: layout.layoutChildren
        };
});

},
'dijit/_Contained':function(){
define("dijit/_Contained", [
        "dojo/_base/declare", // declare
        "./registry"    // registry.getEnclosingWidget(), registry.byNode()
], function(declare, registry){

        // module:
        //              dijit/_Contained

        return declare("dijit._Contained", null, {
                // summary:
                //              Mixin for widgets that are children of a container widget
                //
                // example:
                //      |       // make a basic custom widget that knows about it's parents
                //      |       declare("my.customClass",[dijit._Widget,dijit._Contained],{});

                _getSibling: function(/*String*/ which){
                        // summary:
                        //              Returns next or previous sibling
                        // which:
                        //              Either "next" or "previous"
                        // tags:
                        //              private
                        var node = this.domNode;
                        do{
                                node = node[which+"Sibling"];
                        }while(node && node.nodeType != 1);
                        return node && registry.byNode(node);   // dijit/_WidgetBase
                },

                getPreviousSibling: function(){
                        // summary:
                        //              Returns null if this is the first child of the parent,
                        //              otherwise returns the next element sibling to the "left".

                        return this._getSibling("previous"); // dijit/_WidgetBase
                },

                getNextSibling: function(){
                        // summary:
                        //              Returns null if this is the last child of the parent,
                        //              otherwise returns the next element sibling to the "right".

                        return this._getSibling("next"); // dijit/_WidgetBase
                },

                getIndexInParent: function(){
                        // summary:
                        //              Returns the index of this widget within its container parent.
                        //              It returns -1 if the parent does not exist, or if the parent
                        //              is not a dijit._Container

                        var p = this.getParent();
                        if(!p || !p.getIndexOfChild){
                                return -1; // int
                        }
                        return p.getIndexOfChild(this); // int
                }
        });
});

},
'dijit/form/DataList':function(){
define("dijit/form/DataList", [
        "dojo/_base/declare", // declare
        "dojo/dom", // dom.byId
        "dojo/_base/lang", // lang.trim
        "dojo/query", // query
        "dojo/store/Memory",
        "../registry"   // registry.add registry.remove
], function(declare, dom, lang, query, MemoryStore, registry){

        // module:
        //              dijit/form/DataList

        function toItem(/*DOMNode*/ option){
                // summary:
                //              Convert `<option>` node to hash
                return {
                        id: option.value,
                        value: option.value,
                        name: lang.trim(option.innerText || option.textContent || '')
                };
        }

        return declare("dijit.form.DataList", MemoryStore, {
                // summary:
                //              Inefficient but small data store specialized for inlined data via OPTION tags
                //
                // description:
                //              Provides a store for inlined data like:
                //
                //      |       <datalist>
                //      |               <option value="AL">Alabama</option>
                //      |               ...

                constructor: function(params, srcNodeRef){
                        // summary:
                        //              Create the widget.
                        // params: Object|null
                        //              Hash of initialization parameters for widget, including scalar values (like title, duration etc.)
                        //              and functions, typically callbacks like onClick.
                        //              The hash can contain any of the widget's properties, excluding read-only properties.
                        // srcNodeRef: DOMNode|String
                        //              Attach widget to this DOM node.

                        // store pointer to original DOM tree
                        this.domNode = dom.byId(srcNodeRef);

                        lang.mixin(this, params);
                        if(this.id){
                                registry.add(this); // add to registry so it can be easily found by id
                        }
                        this.domNode.style.display = "none";

                        this.inherited(arguments, [{
                                data: query("option", this.domNode).map(toItem)
                        }]);
                },

                destroy: function(){
                        registry.remove(this.id);
                },

                fetchSelectedItem: function(){
                        // summary:
                        //              Get the option marked as selected, like `<option selected>`.
                        //              Not part of dojo.data API.
                        var option = query("> option[selected]", this.domNode)[0] || query("> option", this.domNode)[0];
                        return option && toItem(option);
                }
        });
});

},
'url:dijit/templates/Dialog.html':"<div class=\"dijitDialog\" role=\"dialog\" aria-labelledby=\"${id}_title\">\n\t<div data-dojo-attach-point=\"titleBar\" class=\"dijitDialogTitleBar\">\n\t\t<span data-dojo-attach-point=\"titleNode\" class=\"dijitDialogTitle\" id=\"${id}_title\"\n\t\t\t\trole=\"heading\" level=\"1\"></span>\n\t\t<span data-dojo-attach-point=\"closeButtonNode\" class=\"dijitDialogCloseIcon\" data-dojo-attach-event=\"ondijitclick: onCancel\" title=\"${buttonCancel}\" role=\"button\" tabIndex=\"-1\">\n\t\t\t<span data-dojo-attach-point=\"closeText\" class=\"closeText\" title=\"${buttonCancel}\">x</span>\n\t\t</span>\n\t</div>\n\t<div data-dojo-attach-point=\"containerNode\" class=\"dijitDialogPaneContent\"></div>\n</div>\n",
'dijit/form/CheckBox':function(){
require({cache:{
'url:dijit/form/templates/CheckBox.html':"<div class=\"dijit dijitReset dijitInline\" role=\"presentation\"\n\t><input\n\t \t${!nameAttrSetting} type=\"${type}\" role=\"${type}\" aria-checked=\"false\" ${checkedAttrSetting}\n\t\tclass=\"dijitReset dijitCheckBoxInput\"\n\t\tdata-dojo-attach-point=\"focusNode\"\n\t \tdata-dojo-attach-event=\"onclick:_onClick\"\n/></div>\n"}});
define("dijit/form/CheckBox", [
        "require",
        "dojo/_base/declare", // declare
        "dojo/dom-attr", // domAttr.set
        "dojo/has",             // has("dijit-legacy-requires")
        "dojo/query", // query
        "dojo/ready",
        "./ToggleButton",
        "./_CheckBoxMixin",
        "dojo/text!./templates/CheckBox.html",
        "dojo/NodeList-dom" // NodeList.addClass/removeClass
], function(require, declare, domAttr, has, query, ready, ToggleButton, _CheckBoxMixin, template){

        // module:
        //              dijit/form/CheckBox

        // Back compat w/1.6, remove for 2.0
        if(has("dijit-legacy-requires")){
                ready(0, function(){
                        var requires = ["dijit/form/RadioButton"];
                        require(requires);      // use indirection so modules not rolled into a build
                });
        }

        return declare("dijit.form.CheckBox", [ToggleButton, _CheckBoxMixin], {
                // summary:
                //              Same as an HTML checkbox, but with fancy styling.
                //
                // description:
                //              User interacts with real html inputs.
                //              On onclick (which occurs by mouse click, space-bar, or
                //              using the arrow keys to switch the selected radio button),
                //              we update the state of the checkbox/radio.
                //
                //              There are two modes:
                //
                //              1. High contrast mode
                //              2. Normal mode
                //
                //              In case 1, the regular html inputs are shown and used by the user.
                //              In case 2, the regular html inputs are invisible but still used by
                //              the user. They are turned quasi-invisible and overlay the background-image.

                templateString: template,

                baseClass: "dijitCheckBox",

                _setValueAttr: function(/*String|Boolean*/ newValue, /*Boolean*/ priorityChange){
                        // summary:
                        //              Handler for value= attribute to constructor, and also calls to
                        //              set('value', val).
                        // description:
                        //              During initialization, just saves as attribute to the `<input type=checkbox>`.
                        //
                        //              After initialization,
                        //              when passed a boolean, controls whether or not the CheckBox is checked.
                        //              If passed a string, changes the value attribute of the CheckBox (the one
                        //              specified as "value" when the CheckBox was constructed
                        //              (ex: `<input data-dojo-type="dijit/CheckBox" value="chicken">`).
                        //
                        //              `widget.set('value', string)` will check the checkbox and change the value to the
                        //              specified string.
                        //
                        //              `widget.set('value', boolean)` will change the checked state.

                        if(typeof newValue == "string"){
                                this.inherited(arguments);
                                newValue = true;
                        }
                        if(this._created){
                                this.set('checked', newValue, priorityChange);
                        }
                },
                _getValueAttr: function(){
                        // summary:
                        //              Hook so get('value') works.
                        // description:
                        //              If the CheckBox is checked, returns the value attribute.
                        //              Otherwise returns false.
                        return (this.checked ? this.value : false);
                },

                // Override behavior from Button, since we don't have an iconNode
                _setIconClassAttr: null,

                postMixInProperties: function(){
                        this.inherited(arguments);

                        // Need to set initial checked state as part of template, so that form submit works.
                        // domAttr.set(node, "checked", bool) doesn't work on IE until node has been attached
                        // to <body>, see #8666
                        this.checkedAttrSetting = this.checked ? "checked" : "";
                },

                 _fillContent: function(){
                        // Override Button::_fillContent() since it doesn't make sense for CheckBox,
                        // since CheckBox doesn't even have a container
                },

                _onFocus: function(){
                        if(this.id){
                                query("label[for='"+this.id+"']").addClass("dijitFocusedLabel");
                        }
                        this.inherited(arguments);
                },

                _onBlur: function(){
                        if(this.id){
                                query("label[for='"+this.id+"']").removeClass("dijitFocusedLabel");
                        }
                        this.inherited(arguments);
                }
        });
});

},
'dijit/tree/_dndSelector':function(){
define("dijit/tree/_dndSelector", [
        "dojo/_base/array", // array.filter array.forEach array.map
        "dojo/_base/connect", // connect.isCopyKey
        "dojo/_base/declare", // declare
        "dojo/_base/Deferred", // Deferred
        "dojo/_base/kernel",    // global
        "dojo/_base/lang", // lang.hitch
        "dojo/cookie", // cookie
        "dojo/mouse", // mouse.isLeft
        "dojo/on",
        "dojo/touch",
        "./_dndContainer"
], function(array, connect, declare, Deferred, kernel, lang, cookie, mouse, on, touch, _dndContainer){

        // module:
        //              dijit/tree/_dndSelector


        return declare("dijit.tree._dndSelector", _dndContainer, {
                // summary:
                //              This is a base class for `dijit/tree/dndSource` , and isn't meant to be used directly.
                //              It's based on `dojo/dnd/Selector`.
                // tags:
                //              protected

                /*=====
                // selection: Object
                //              (id to DomNode) map for every TreeNode that's currently selected.
                //              The DOMNode is the TreeNode.rowNode.
                selection: {},
                =====*/

                constructor: function(){
                        // summary:
                        //              Initialization
                        // tags:
                        //              private

                        this.selection={};
                        this.anchor = null;

                        if(!this.cookieName && this.tree.id){
                                this.cookieName = this.tree.id + "SaveSelectedCookie";
                        }

                        this.events.push(
                                on(this.tree.domNode, touch.press, lang.hitch(this,"onMouseDown")),
                                on(this.tree.domNode, touch.release, lang.hitch(this,"onMouseUp")),
                                on(this.tree.domNode, touch.move, lang.hitch(this,"onMouseMove"))
                        );
                },

                // singular: Boolean
                //              Allows selection of only one element, if true.
                //              Tree hasn't been tested in singular=true mode, unclear if it works.
                singular: false,

                // methods
                getSelectedTreeNodes: function(){
                        // summary:
                        //              Returns a list of selected node(s).
                        //              Used by dndSource on the start of a drag.
                        // tags:
                        //              protected
                        var nodes=[], sel = this.selection;
                        for(var i in sel){
                                nodes.push(sel[i]);
                        }
                        return nodes;
                },

                selectNone: function(){
                        // summary:
                        //              Unselects all items
                        // tags:
                        //              private

                        this.setSelection([]);
                        return this;    // self
                },

                destroy: function(){
                        // summary:
                        //              Prepares the object to be garbage-collected
                        this.inherited(arguments);
                        this.selection = this.anchor = null;
                },
                addTreeNode: function(/*dijit/Tree._TreeNode*/ node, /*Boolean?*/isAnchor){
                        // summary:
                        //              add node to current selection
                        // node: Node
                        //              node to add
                        // isAnchor: Boolean
                        //              Whether the node should become anchor.

                        this.setSelection(this.getSelectedTreeNodes().concat( [node] ));
                        if(isAnchor){ this.anchor = node; }
                        return node;
                },
                removeTreeNode: function(/*dijit/Tree._TreeNode*/ node){
                        // summary:
                        //              remove node from current selection
                        // node: Node
                        //              node to remove
                        this.setSelection(this._setDifference(this.getSelectedTreeNodes(), [node]));
                        return node;
                },
                isTreeNodeSelected: function(/*dijit/Tree._TreeNode*/ node){
                        // summary:
                        //              return true if node is currently selected
                        // node: Node
                        //              the node to check whether it's in the current selection

                        return node.id && !!this.selection[node.id];
                },
                setSelection: function(/*dijit/Tree._TreeNode[]*/ newSelection){
                        // summary:
                        //              set the list of selected nodes to be exactly newSelection. All changes to the
                        //              selection should be passed through this function, which ensures that derived
                        //              attributes are kept up to date. Anchor will be deleted if it has been removed
                        //              from the selection, but no new anchor will be added by this function.
                        // newSelection: Node[]
                        //              list of tree nodes to make selected
                        var oldSelection = this.getSelectedTreeNodes();
                        array.forEach(this._setDifference(oldSelection, newSelection), lang.hitch(this, function(node){
                                node.setSelected(false);
                                if(this.anchor == node){
                                        delete this.anchor;
                                }
                                delete this.selection[node.id];
                        }));
                        array.forEach(this._setDifference(newSelection, oldSelection), lang.hitch(this, function(node){
                                node.setSelected(true);
                                this.selection[node.id] = node;
                        }));
                        this._updateSelectionProperties();
                },
                _setDifference: function(xs,ys){
                        // summary:
                        //              Returns a copy of xs which lacks any objects
                        //              occurring in ys. Checks for membership by
                        //              modifying and then reading the object, so it will
                        //              not properly handle sets of numbers or strings.

                        array.forEach(ys, function(y){ y.__exclude__ = true; });
                        var ret = array.filter(xs, function(x){ return !x.__exclude__; });

                        // clean up after ourselves.
                        array.forEach(ys, function(y){ delete y['__exclude__'] });
                        return ret;
                },
                _updateSelectionProperties: function(){
                        // summary:
                        //              Update the following tree properties from the current selection:
                        //              path[s], selectedItem[s], selectedNode[s]

                        var selected = this.getSelectedTreeNodes();
                        var paths = [], nodes = [], selects = [];
                        array.forEach(selected, function(node){
                                var ary = node.getTreePath(), model = this.tree.model;
                                nodes.push(node);
                                paths.push(ary);
                                ary = array.map(ary, function(item){
                                        return model.getIdentity(item);
                                }, this);
                                selects.push(ary.join("/"))
                        }, this);
                        var items = array.map(nodes,function(node){ return node.item; });
                        this.tree._set("paths", paths);
                        this.tree._set("path", paths[0] || []);
                        this.tree._set("selectedNodes", nodes);
                        this.tree._set("selectedNode", nodes[0] || null);
                        this.tree._set("selectedItems", items);
                        this.tree._set("selectedItem", items[0] || null);
            if (this.tree.persist && selects.length > 0) {
                cookie(this.cookieName, selects.join(","), {expires:365});
            }
                },
                _getSavedPaths: function(){
                        // summary:
                        //              Returns paths of nodes that were selected previously and saved in the cookie.

                        var tree = this.tree;
                        if(tree.persist && tree.dndController.cookieName){
                                var oreo, paths = [];
                                oreo = cookie(tree.dndController.cookieName);
                                if(oreo){
                                        paths = array.map(oreo.split(","), function(path){
                                           return path.split("/");
                                        })
                                }
                                return paths;
                        }
                },
                // mouse events
                onMouseDown: function(e){
                        // summary:
                        //              Event processor for onmousedown/ontouchstart
                        // e: Event
                        //              onmousedown/ontouchstart event
                        // tags:
                        //              protected

                        // ignore click on expando node
                        if(!this.current || this.tree.isExpandoNode(e.target, this.current)){ return; }

                        if(mouse.isLeft(e)){
                                // Prevent text selection while dragging on desktop, see #16328.   But don't call preventDefault()
                                // for mobile because it will break things completely, see #15838.
                                e.preventDefault();
                        }else if(e.type != "touchstart"){
                                // Ignore right click
                                return;
                        }

                        var treeNode = this.current,
                          copy = connect.isCopyKey(e), id = treeNode.id;

                        // if shift key is not pressed, and the node is already in the selection,
                        // delay deselection until onmouseup so in the case of DND, deselection
                        // will be canceled by onmousemove.
                        if(!this.singular && !e.shiftKey && this.selection[id]){
                                this._doDeselect = true;
                                return;
                        }else{
                                this._doDeselect = false;
                        }
                        this.userSelect(treeNode, copy, e.shiftKey);
                },

                onMouseUp: function(e){
                        // summary:
                        //              Event processor for onmouseup/ontouchend
                        // e: Event
                        //              onmouseup/ontouchend event
                        // tags:
                        //              protected

                        // _doDeselect is the flag to indicate that the user wants to either ctrl+click on
                        // a already selected item (to deselect the item), or click on a not-yet selected item
                        // (which should remove all current selection, and add the clicked item). This can not
                        // be done in onMouseDown, because the user may start a drag after mousedown. By moving
                        // the deselection logic here, the user can drags an already selected item.
                        if(!this._doDeselect){ return; }
                        this._doDeselect = false;
                        this.userSelect(this.current, connect.isCopyKey(e), e.shiftKey);
                },
                onMouseMove: function(/*===== e =====*/){
                        // summary:
                        //              event processor for onmousemove/ontouchmove
                        // e: Event
                        //              onmousemove/ontouchmove event
                        this._doDeselect = false;
                },

                _compareNodes: function(n1, n2){
                        if(n1 === n2){
                                return 0;
                        }

                        if('sourceIndex' in document.documentElement){ //IE
                                //TODO: does not yet work if n1 and/or n2 is a text node
                                return n1.sourceIndex - n2.sourceIndex;
                        }else if('compareDocumentPosition' in document.documentElement){ //FF, Opera
                                return n1.compareDocumentPosition(n2) & 2 ? 1: -1;
                        }else if(document.createRange){ //Webkit
                                var r1 = doc.createRange();
                                r1.setStartBefore(n1);

                                var r2 = doc.createRange();
                                r2.setStartBefore(n2);

                                return r1.compareBoundaryPoints(r1.END_TO_END, r2);
                        }else{
                                throw Error("dijit.tree._compareNodes don't know how to compare two different nodes in this browser");
                        }
                },

                userSelect: function(node, multi, range){
                        // summary:
                        //              Add or remove the given node from selection, responding
                        //              to a user action such as a click or keypress.
                        // multi: Boolean
                        //              Indicates whether this is meant to be a multi-select action (e.g. ctrl-click)
                        // range: Boolean
                        //              Indicates whether this is meant to be a ranged action (e.g. shift-click)
                        // tags:
                        //              protected

                        if(this.singular){
                                if(this.anchor == node && multi){
                                        this.selectNone();
                                }else{
                                        this.setSelection([node]);
                                        this.anchor = node;
                                }
                        }else{
                                if(range && this.anchor){
                                        var cr = this._compareNodes(this.anchor.rowNode, node.rowNode),
                                        begin, end, anchor = this.anchor;

                                        if(cr < 0){ //current is after anchor
                                                begin = anchor;
                                                end = node;
                                        }else{ //current is before anchor
                                                begin = node;
                                                end = anchor;
                                        }
                                        var nodes = [];
                                        //add everything betweeen begin and end inclusively
                                        while(begin != end){
                                                nodes.push(begin);
                                                begin = this.tree._getNextNode(begin);
                                        }
                                        nodes.push(end);

                                        this.setSelection(nodes);
                                }else{
                                        if( this.selection[ node.id ] && multi ){
                                                this.removeTreeNode( node );
                                        }else if(multi){
                                                this.addTreeNode(node, true);
                                        }else{
                                                this.setSelection([node]);
                                                this.anchor = node;
                                        }
                                }
                        }
                },

                getItem: function(/*String*/ key){
                        // summary:
                        //              Returns the dojo/dnd/Container._Item (representing a dragged node) by it's key (id).
                        //              Called by dojo/dnd/Source.checkAcceptance().
                        // tags:
                        //              protected

                        var widget = this.selection[key];
                        return {
                                data: widget,
                                type: ["treeNode"]
                        }; // dojo/dnd/Container._Item
                },

                forInSelectedItems: function(/*Function*/ f, /*Object?*/ o){
                        // summary:
                        //              Iterates over selected items;
                        //              see `dojo/dnd/Container.forInItems()` for details
                        o = o || kernel.global;
                        for(var id in this.selection){
                                // console.log("selected item id: " + id);
                                f.call(o, this.getItem(id), id, this);
                        }
                }
        });
});

},
'dijit/_Container':function(){
define("dijit/_Container", [
        "dojo/_base/array", // array.forEach array.indexOf
        "dojo/_base/declare", // declare
        "dojo/dom-construct" // domConstruct.place
], function(array, declare, domConstruct){

        // module:
        //              dijit/_Container

        return declare("dijit._Container", null, {
                // summary:
                //              Mixin for widgets that contain HTML and/or a set of widget children.

                buildRendering: function(){
                        this.inherited(arguments);
                        if(!this.containerNode){
                                // all widgets with descendants must set containerNode
                                this.containerNode = this.domNode;
                        }
                },

                addChild: function(/*dijit/_WidgetBase*/ widget, /*int?*/ insertIndex){
                        // summary:
                        //              Makes the given widget a child of this widget.
                        // description:
                        //              Inserts specified child widget's dom node as a child of this widget's
                        //              container node, and possibly does other processing (such as layout).
                        //
                        //              Functionality is undefined if this widget contains anything besides
                        //              a list of child widgets (ie, if it contains arbitrary non-widget HTML).

                        var refNode = this.containerNode;
                        if(insertIndex && typeof insertIndex == "number"){
                                var children = this.getChildren();
                                if(children && children.length >= insertIndex){
                                        refNode = children[insertIndex-1].domNode;
                                        insertIndex = "after";
                                }
                        }
                        domConstruct.place(widget.domNode, refNode, insertIndex);

                        // If I've been started but the child widget hasn't been started,
                        // start it now.  Make sure to do this after widget has been
                        // inserted into the DOM tree, so it can see that it's being controlled by me,
                        // so it doesn't try to size itself.
                        if(this._started && !widget._started){
                                widget.startup();
                        }
                },

                removeChild: function(/*Widget|int*/ widget){
                        // summary:
                        //              Removes the passed widget instance from this widget but does
                        //              not destroy it.  You can also pass in an integer indicating
                        //              the index within the container to remove (ie, removeChild(5) removes the sixth widget).

                        if(typeof widget == "number"){
                                widget = this.getChildren()[widget];
                        }

                        if(widget){
                                var node = widget.domNode;
                                if(node && node.parentNode){
                                        node.parentNode.removeChild(node); // detach but don't destroy
                                }
                        }
                },

                hasChildren: function(){
                        // summary:
                        //              Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
                        return this.getChildren().length > 0;   // Boolean
                },

                _getSiblingOfChild: function(/*dijit/_WidgetBase*/ child, /*int*/ dir){
                        // summary:
                        //              Get the next or previous widget sibling of child
                        // dir:
                        //              if 1, get the next sibling
                        //              if -1, get the previous sibling
                        // tags:
                        //              private
                        var children = this.getChildren(),
                                idx = array.indexOf(this.getChildren(), child); // int
                        return children[idx + dir];
                },

                getIndexOfChild: function(/*dijit/_WidgetBase*/ child){
                        // summary:
                        //              Gets the index of the child in this container or -1 if not found
                        return array.indexOf(this.getChildren(), child);        // int
                }
        });
});

},
'dojo/data/ItemFileReadStore':function(){
define("dojo/data/ItemFileReadStore", ["../_base/kernel", "../_base/lang", "../_base/declare", "../_base/array", "../_base/xhr",
        "../Evented", "./util/filter", "./util/simpleFetch", "../date/stamp"
], function(kernel, lang, declare, array, xhr, Evented, filterUtil, simpleFetch, dateStamp){

// module:
//              dojo/data/ItemFileReadStore

var ItemFileReadStore = declare("dojo.data.ItemFileReadStore", [Evented],{
        // summary:
        //              The ItemFileReadStore implements the dojo/data/api/Read API and reads
        //              data from JSON files that have contents in this format --
        // |    { items: [
        // |            { name:'Kermit', color:'green', age:12, friends:['Gonzo', {_reference:{name:'Fozzie Bear'}}]},
        // |            { name:'Fozzie Bear', wears:['hat', 'tie']},
        // |            { name:'Miss Piggy', pets:'Foo-Foo'}
        // |    ]}
        //              Note that it can also contain an 'identifier' property that specified which attribute on the items
        //              in the array of items that acts as the unique identifier for that item.

        constructor: function(/* Object */ keywordParameters){
                // summary:
                //              constructor
                // keywordParameters:
                //              {url: String} {data: jsonObject} {typeMap: object}
                //              The structure of the typeMap object is as follows:
                // |    {
                // |            type0: function || object,
                // |            type1: function || object,
                // |            ...
                // |            typeN: function || object
                // |    }
                //              Where if it is a function, it is assumed to be an object constructor that takes the
                //              value of _value as the initialization parameters.  If it is an object, then it is assumed
                //              to be an object of general form:
                // |    {
                // |            type: function, //constructor.
                // |            deserialize:    function(value) //The function that parses the value and constructs the object defined by type appropriately.
                // |    }

                this._arrayOfAllItems = [];
                this._arrayOfTopLevelItems = [];
                this._loadFinished = false;
                this._jsonFileUrl = keywordParameters.url;
                this._ccUrl = keywordParameters.url;
                this.url = keywordParameters.url;
                this._jsonData = keywordParameters.data;
                this.data = null;
                this._datatypeMap = keywordParameters.typeMap || {};
                if(!this._datatypeMap['Date']){
                        //If no default mapping for dates, then set this as default.
                        //We use the dojo/date/stamp here because the ISO format is the 'dojo way'
                        //of generically representing dates.
                        this._datatypeMap['Date'] = {
                                type: Date,
                                deserialize: function(value){
                                        return dateStamp.fromISOString(value);
                                }
                        };
                }
                this._features = {'dojo.data.api.Read':true, 'dojo.data.api.Identity':true};
                this._itemsByIdentity = null;
                this._storeRefPropName = "_S"; // Default name for the store reference to attach to every item.
                this._itemNumPropName = "_0"; // Default Item Id for isItem to attach to every item.
                this._rootItemPropName = "_RI"; // Default Item Id for isItem to attach to every item.
                this._reverseRefMap = "_RRM"; // Default attribute for constructing a reverse reference map for use with reference integrity
                this._loadInProgress = false; //Got to track the initial load to prevent duelling loads of the dataset.
                this._queuedFetches = [];
                if(keywordParameters.urlPreventCache !== undefined){
                        this.urlPreventCache = keywordParameters.urlPreventCache?true:false;
                }
                if(keywordParameters.hierarchical !== undefined){
                        this.hierarchical = keywordParameters.hierarchical?true:false;
                }
                if(keywordParameters.clearOnClose){
                        this.clearOnClose = true;
                }
                if("failOk" in keywordParameters){
                        this.failOk = keywordParameters.failOk?true:false;
                }
        },

        url: "",        // use "" rather than undefined for the benefit of the parser (#3539)

        //Internal var, crossCheckUrl.  Used so that setting either url or _jsonFileUrl, can still trigger a reload
        //when clearOnClose and close is used.
        _ccUrl: "",

        data: null,     // define this so that the parser can populate it

        typeMap: null, //Define so parser can populate.

        // clearOnClose: Boolean
        //              Parameter to allow users to specify if a close call should force a reload or not.
        //              By default, it retains the old behavior of not clearing if close is called.  But
        //              if set true, the store will be reset to default state.  Note that by doing this,
        //              all item handles will become invalid and a new fetch must be issued.
        clearOnClose: false,

        // urlPreventCache: Boolean
        //              Parameter to allow specifying if preventCache should be passed to the xhrGet call or not when loading data from a url.
        //              Note this does not mean the store calls the server on each fetch, only that the data load has preventCache set as an option.
        //              Added for tracker: #6072
        urlPreventCache: false,

        // failOk: Boolean
        //              Parameter for specifying that it is OK for the xhrGet call to fail silently.
        failOk: false,

        // hierarchical: Boolean
        //              Parameter to indicate to process data from the url as hierarchical
        //              (data items can contain other data items in js form).  Default is true
        //              for backwards compatibility.  False means only root items are processed
        //              as items, all child objects outside of type-mapped objects and those in
        //              specific reference format, are left straight JS data objects.
        hierarchical: true,

        _assertIsItem: function(/* dojo/data/api/Item */ item){
                // summary:
                //              This function tests whether the item passed in is indeed an item in the store.
                // item:
                //              The item to test for being contained by the store.
                if(!this.isItem(item)){
                        throw new Error(this.declaredClass + ": Invalid item argument.");
                }
        },

        _assertIsAttribute: function(/* attribute-name-string */ attribute){
                // summary:
                //              This function tests whether the item passed in is indeed a valid 'attribute' like type for the store.
                // attribute:
                //              The attribute to test for being contained by the store.
                if(typeof attribute !== "string"){
                        throw new Error(this.declaredClass + ": Invalid attribute argument.");
                }
        },

        getValue: function(     /* dojo/data/api/Item */ item,
                                                   /* attribute-name-string */ attribute,
                                                   /* value? */ defaultValue){
                // summary:
                //              See dojo/data/api/Read.getValue()
                var values = this.getValues(item, attribute);
                return (values.length > 0)?values[0]:defaultValue; // mixed
        },

        getValues: function(/* dojo/data/api/Item */ item,
                                                /* attribute-name-string */ attribute){
                // summary:
                //              See dojo/data/api/Read.getValues()

                this._assertIsItem(item);
                this._assertIsAttribute(attribute);
                // Clone it before returning.  refs: #10474
                return (item[attribute] || []).slice(0); // Array
        },

        getAttributes: function(/* dojo/data/api/Item */ item){
                // summary:
                //              See dojo/data/api/Read.getAttributes()
                this._assertIsItem(item);
                var attributes = [];
                for(var key in item){
                        // Save off only the real item attributes, not the special id marks for O(1) isItem.
                        if((key !== this._storeRefPropName) && (key !== this._itemNumPropName) && (key !== this._rootItemPropName) && (key !== this._reverseRefMap)){
                                attributes.push(key);
                        }
                }
                return attributes; // Array
        },

        hasAttribute: function( /* dojo/data/api/Item */ item,
                                                           /* attribute-name-string */ attribute){
                // summary:
                //              See dojo/data/api/Read.hasAttribute()
                this._assertIsItem(item);
                this._assertIsAttribute(attribute);
                return (attribute in item);
        },

        containsValue: function(/* dojo/data/api/Item */ item,
                                                        /* attribute-name-string */ attribute,
                                                        /* anything */ value){
                // summary:
                //              See dojo/data/api/Read.containsValue()
                var regexp = undefined;
                if(typeof value === "string"){
                        regexp = filterUtil.patternToRegExp(value, false);
                }
                return this._containsValue(item, attribute, value, regexp); //boolean.
        },

        _containsValue: function(       /* dojo/data/api/Item */ item,
                                                                 /* attribute-name-string */ attribute,
                                                                 /* anything */ value,
                                                                 /* RegExp?*/ regexp){
                // summary:
                //              Internal function for looking at the values contained by the item.
                // description:
                //              Internal function for looking at the values contained by the item.  This
                //              function allows for denoting if the comparison should be case sensitive for
                //              strings or not (for handling filtering cases where string case should not matter)
                // item:
                //              The data item to examine for attribute values.
                // attribute:
                //              The attribute to inspect.
                // value:
                //              The value to match.
                // regexp:
                //              Optional regular expression generated off value if value was of string type to handle wildcarding.
                //              If present and attribute values are string, then it can be used for comparison instead of 'value'
                return array.some(this.getValues(item, attribute), function(possibleValue){
                        if(possibleValue !== null && !lang.isObject(possibleValue) && regexp){
                                if(possibleValue.toString().match(regexp)){
                                        return true; // Boolean
                                }
                        }else if(value === possibleValue){
                                return true; // Boolean
                        }
                });
        },

        isItem: function(/* anything */ something){
                // summary:
                //              See dojo/data/api/Read.isItem()
                if(something && something[this._storeRefPropName] === this){
                        if(this._arrayOfAllItems[something[this._itemNumPropName]] === something){
                                return true;
                        }
                }
                return false; // Boolean
        },

        isItemLoaded: function(/* anything */ something){
                // summary:
                //              See dojo/data/api/Read.isItemLoaded()
                return this.isItem(something); //boolean
        },

        loadItem: function(/* object */ keywordArgs){
                // summary:
                //              See dojo/data/api/Read.loadItem()
                this._assertIsItem(keywordArgs.item);
        },

        getFeatures: function(){
                // summary:
                //              See dojo/data/api/Read.getFeatures()
                return this._features; //Object
        },

        getLabel: function(/* dojo/data/api/Item */ item){
                // summary:
                //              See dojo/data/api/Read.getLabel()
                if(this._labelAttr && this.isItem(item)){
                        return this.getValue(item,this._labelAttr); //String
                }
                return undefined; //undefined
        },

        getLabelAttributes: function(/* dojo/data/api/Item */ item){
                // summary:
                //              See dojo/data/api/Read.getLabelAttributes()
                if(this._labelAttr){
                        return [this._labelAttr]; //array
                }
                return null; //null
        },

        filter: function(/* Object */ requestArgs, /* item[] */ arrayOfItems, /* Function */ findCallback){
                // summary:
                //              This method handles the basic filtering needs for ItemFile* based stores.
                var items = [],
                        i, key;

                if(requestArgs.query){
                        var value,
                                ignoreCase = requestArgs.queryOptions ? requestArgs.queryOptions.ignoreCase : false;

                        //See if there are any string values that can be regexp parsed first to avoid multiple regexp gens on the
                        //same value for each item examined.  Much more efficient.
                        var regexpList = {};
                        for(key in requestArgs.query){
                                value = requestArgs.query[key];
                                if(typeof value === "string"){
                                        regexpList[key] = filterUtil.patternToRegExp(value, ignoreCase);
                                }else if(value instanceof RegExp){
                                        regexpList[key] = value;
                                }
                        }
                        for(i = 0; i < arrayOfItems.length; ++i){
                                var match = true;
                                var candidateItem = arrayOfItems[i];
                                if(candidateItem === null){
                                        match = false;
                                }else{
                                        for(key in requestArgs.query){
                                                value = requestArgs.query[key];
                                                if(!this._containsValue(candidateItem, key, value, regexpList[key])){
                                                        match = false;
                                                }
                                        }
                                }
                                if(match){
                                        items.push(candidateItem);
                                }
                        }
                        findCallback(items, requestArgs);
                }else{
                        // We want a copy to pass back in case the parent wishes to sort the array.
                        // We shouldn't allow resort of the internal list, so that multiple callers
                        // can get lists and sort without affecting each other.  We also need to
                        // filter out any null values that have been left as a result of deleteItem()
                        // calls in ItemFileWriteStore.
                        for(i = 0; i < arrayOfItems.length; ++i){
                                var item = arrayOfItems[i];
                                if(item !== null){
                                        items.push(item);
                                }
                        }
                        findCallback(items, requestArgs);
                }
        },

        _fetchItems: function(  /* Object */ keywordArgs,
                                                          /* Function */ findCallback,
                                                          /* Function */ errorCallback){
                // summary:
                //              See dojo/data/util.simpleFetch.fetch()
                var self = this;

                if(this._loadFinished){
                        this.filter(keywordArgs, this._getItemsArray(keywordArgs.queryOptions), findCallback);
                }else{
                        //Do a check on the JsonFileUrl and crosscheck it.
                        //If it doesn't match the cross-check, it needs to be updated
                        //This allows for either url or _jsonFileUrl to he changed to
                        //reset the store load location.  Done this way for backwards
                        //compatibility.  People use _jsonFileUrl (even though officially
                        //private.
                        if(this._jsonFileUrl !== this._ccUrl){
                                kernel.deprecated(this.declaredClass + ": ",
                                        "To change the url, set the url property of the store," +
                                                " not _jsonFileUrl.  _jsonFileUrl support will be removed in 2.0");
                                this._ccUrl = this._jsonFileUrl;
                                this.url = this._jsonFileUrl;
                        }else if(this.url !== this._ccUrl){
                                this._jsonFileUrl = this.url;
                                this._ccUrl = this.url;
                        }

                        //See if there was any forced reset of data.
                        if(this.data != null){
                                this._jsonData = this.data;
                                this.data = null;
                        }

                        if(this._jsonFileUrl){
                                //If fetches come in before the loading has finished, but while
                                //a load is in progress, we have to defer the fetching to be
                                //invoked in the callback.
                                if(this._loadInProgress){
                                        this._queuedFetches.push({args: keywordArgs, filter: lang.hitch(self, "filter"), findCallback: lang.hitch(self, findCallback)});
                                }else{
                                        this._loadInProgress = true;
                                        var getArgs = {
                                                url: self._jsonFileUrl,
                                                handleAs: "json-comment-optional",
                                                preventCache: this.urlPreventCache,
                                                failOk: this.failOk
                                        };
                                        var getHandler = xhr.get(getArgs);
                                        getHandler.addCallback(function(data){
                                                try{
                                                        self._getItemsFromLoadedData(data);
                                                        self._loadFinished = true;
                                                        self._loadInProgress = false;

                                                        self.filter(keywordArgs, self._getItemsArray(keywordArgs.queryOptions), findCallback);
                                                        self._handleQueuedFetches();
                                                }catch(e){
                                                        self._loadFinished = true;
                                                        self._loadInProgress = false;
                                                        errorCallback(e, keywordArgs);
                                                }
                                        });
                                        getHandler.addErrback(function(error){
                                                self._loadInProgress = false;
                                                errorCallback(error, keywordArgs);
                                        });

                                        //Wire up the cancel to abort of the request
                                        //This call cancel on the deferred if it hasn't been called
                                        //yet and then will chain to the simple abort of the
                                        //simpleFetch keywordArgs
                                        var oldAbort = null;
                                        if(keywordArgs.abort){
                                                oldAbort = keywordArgs.abort;
                                        }
                                        keywordArgs.abort = function(){
                                                var df = getHandler;
                                                if(df && df.fired === -1){
                                                        df.cancel();
                                                        df = null;
                                                }
                                                if(oldAbort){
                                                        oldAbort.call(keywordArgs);
                                                }
                                        };
                                }
                        }else if(this._jsonData){
                                try{
                                        this._loadFinished = true;
                                        this._getItemsFromLoadedData(this._jsonData);
                                        this._jsonData = null;
                                        self.filter(keywordArgs, this._getItemsArray(keywordArgs.queryOptions), findCallback);
                                }catch(e){
                                        errorCallback(e, keywordArgs);
                                }
                        }else{
                                errorCallback(new Error(this.declaredClass + ": No JSON source data was provided as either URL or a nested Javascript object."), keywordArgs);
                        }
                }
        },

        _handleQueuedFetches: function(){
                // summary:
                //              Internal function to execute delayed request in the store.
                
                //Execute any deferred fetches now.
                if(this._queuedFetches.length > 0){
                        for(var i = 0; i < this._queuedFetches.length; i++){
                                var fData = this._queuedFetches[i],
                                        delayedQuery = fData.args,
                                        delayedFilter = fData.filter,
                                        delayedFindCallback = fData.findCallback;
                                if(delayedFilter){
                                        delayedFilter(delayedQuery, this._getItemsArray(delayedQuery.queryOptions), delayedFindCallback);
                                }else{
                                        this.fetchItemByIdentity(delayedQuery);
                                }
                        }
                        this._queuedFetches = [];
                }
        },

        _getItemsArray: function(/*object?*/queryOptions){
                // summary:
                //              Internal function to determine which list of items to search over.
                // queryOptions: The query options parameter, if any.
                if(queryOptions && queryOptions.deep){
                        return this._arrayOfAllItems;
                }
                return this._arrayOfTopLevelItems;
        },

        close: function(/*dojo/data/api/Request|Object?*/ request){
                // summary:
                //              See dojo/data/api/Read.close()
                if(this.clearOnClose &&
                        this._loadFinished &&
                        !this._loadInProgress){
                        //Reset all internalsback to default state.  This will force a reload
                        //on next fetch.  This also checks that the data or url param was set
                        //so that the store knows it can get data.  Without one of those being set,
                        //the next fetch will trigger an error.

                        if(((this._jsonFileUrl == "" || this._jsonFileUrl == null) &&
                                (this.url == "" || this.url == null)
                                ) && this.data == null){
                                console.debug(this.declaredClass + ": WARNING!  Data reload " +
                                        " information has not been provided." +
                                        "  Please set 'url' or 'data' to the appropriate value before" +
                                        " the next fetch");
                        }
                        this._arrayOfAllItems = [];
                        this._arrayOfTopLevelItems = [];
                        this._loadFinished = false;
                        this._itemsByIdentity = null;
                        this._loadInProgress = false;
                        this._queuedFetches = [];
                }
        },

        _getItemsFromLoadedData: function(/* Object */ dataObject){
                // summary:
                //              Function to parse the loaded data into item format and build the internal items array.
                // description:
                //              Function to parse the loaded data into item format and build the internal items array.
                // dataObject:
                //              The JS data object containing the raw data to convery into item format.
                // returns: Array
                //              Array of items in store item format.

                // First, we define a couple little utility functions...
                var addingArrays = false,
                        self = this;

                function valueIsAnItem(/* anything */ aValue){
                        // summary:
                        //              Given any sort of value that could be in the raw json data,
                        //              return true if we should interpret the value as being an
                        //              item itself, rather than a literal value or a reference.
                        // example:
                        //      |       false == valueIsAnItem("Kermit");
                        //      |       false == valueIsAnItem(42);
                        //      |       false == valueIsAnItem(new Date());
                        //      |       false == valueIsAnItem({_type:'Date', _value:'1802-05-14'});
                        //      |       false == valueIsAnItem({_reference:'Kermit'});
                        //      |       true == valueIsAnItem({name:'Kermit', color:'green'});
                        //      |       true == valueIsAnItem({iggy:'pop'});
                        //      |       true == valueIsAnItem({foo:42});
                        return (aValue !== null) &&
                                (typeof aValue === "object") &&
                                (!lang.isArray(aValue) || addingArrays) &&
                                (!lang.isFunction(aValue)) &&
                                (aValue.constructor == Object || lang.isArray(aValue)) &&
                                (typeof aValue._reference === "undefined") &&
                                (typeof aValue._type === "undefined") &&
                                (typeof aValue._value === "undefined") &&
                                self.hierarchical;
                }

                function addItemAndSubItemsToArrayOfAllItems(/* dojo/data/api/Item */ anItem){
                        self._arrayOfAllItems.push(anItem);
                        for(var attribute in anItem){
                                var valueForAttribute = anItem[attribute];
                                if(valueForAttribute){
                                        if(lang.isArray(valueForAttribute)){
                                                var valueArray = valueForAttribute;
                                                for(var k = 0; k < valueArray.length; ++k){
                                                        var singleValue = valueArray[k];
                                                        if(valueIsAnItem(singleValue)){
                                                                addItemAndSubItemsToArrayOfAllItems(singleValue);
                                                        }
                                                }
                                        }else{
                                                if(valueIsAnItem(valueForAttribute)){
                                                        addItemAndSubItemsToArrayOfAllItems(valueForAttribute);
                                                }
                                        }
                                }
                        }
                }

                this._labelAttr = dataObject.label;

                // We need to do some transformations to convert the data structure
                // that we read from the file into a format that will be convenient
                // to work with in memory.

                // Step 1: Walk through the object hierarchy and build a list of all items
                var i,
                        item;
                this._arrayOfAllItems = [];
                this._arrayOfTopLevelItems = dataObject.items;

                for(i = 0; i < this._arrayOfTopLevelItems.length; ++i){
                        item = this._arrayOfTopLevelItems[i];
                        if(lang.isArray(item)){
                                addingArrays = true;
                        }
                        addItemAndSubItemsToArrayOfAllItems(item);
                        item[this._rootItemPropName]=true;
                }

                // Step 2: Walk through all the attribute values of all the items,
                // and replace single values with arrays.  For example, we change this:
                //              { name:'Miss Piggy', pets:'Foo-Foo'}
                // into this:
                //              { name:['Miss Piggy'], pets:['Foo-Foo']}
                //
                // We also store the attribute names so we can validate our store
                // reference and item id special properties for the O(1) isItem
                var allAttributeNames = {},
                        key;

                for(i = 0; i < this._arrayOfAllItems.length; ++i){
                        item = this._arrayOfAllItems[i];
                        for(key in item){
                                if(key !== this._rootItemPropName){
                                        var value = item[key];
                                        if(value !== null){
                                                if(!lang.isArray(value)){
                                                        item[key] = [value];
                                                }
                                        }else{
                                                item[key] = [null];
                                        }
                                }
                                allAttributeNames[key]=key;
                        }
                }

                // Step 3: Build unique property names to use for the _storeRefPropName and _itemNumPropName
                // This should go really fast, it will generally never even run the loop.
                while(allAttributeNames[this._storeRefPropName]){
                        this._storeRefPropName += "_";
                }
                while(allAttributeNames[this._itemNumPropName]){
                        this._itemNumPropName += "_";
                }
                while(allAttributeNames[this._reverseRefMap]){
                        this._reverseRefMap += "_";
                }

                // Step 4: Some data files specify an optional 'identifier', which is
                // the name of an attribute that holds the identity of each item.
                // If this data file specified an identifier attribute, then build a
                // hash table of items keyed by the identity of the items.
                var arrayOfValues;

                var identifier = dataObject.identifier;
                if(identifier){
                        this._itemsByIdentity = {};
                        this._features['dojo.data.api.Identity'] = identifier;
                        for(i = 0; i < this._arrayOfAllItems.length; ++i){
                                item = this._arrayOfAllItems[i];
                                arrayOfValues = item[identifier];
                                var identity = arrayOfValues[0];
                                if(!Object.hasOwnProperty.call(this._itemsByIdentity, identity)){
                                        this._itemsByIdentity[identity] = item;
                                }else{
                                        if(this._jsonFileUrl){
                                                throw new Error(this.declaredClass + ":  The json data as specified by: [" + this._jsonFileUrl + "] is malformed.  Items within the list have identifier: [" + identifier + "].  Value collided: [" + identity + "]");
                                        }else if(this._jsonData){
                                                throw new Error(this.declaredClass + ":  The json data provided by the creation arguments is malformed.  Items within the list have identifier: [" + identifier + "].  Value collided: [" + identity + "]");
                                        }
                                }
                        }
                }else{
                        this._features['dojo.data.api.Identity'] = Number;
                }

                // Step 5: Walk through all the items, and set each item's properties
                // for _storeRefPropName and _itemNumPropName, so that store.isItem() will return true.
                for(i = 0; i < this._arrayOfAllItems.length; ++i){
                        item = this._arrayOfAllItems[i];
                        item[this._storeRefPropName] = this;
                        item[this._itemNumPropName] = i;
                }

                // Step 6: We walk through all the attribute values of all the items,
                // looking for type/value literals and item-references.
                //
                // We replace item-references with pointers to items.  For example, we change:
                //              { name:['Kermit'], friends:[{_reference:{name:'Miss Piggy'}}] }
                // into this:
                //              { name:['Kermit'], friends:[miss_piggy] }
                // (where miss_piggy is the object representing the 'Miss Piggy' item).
                //
                // We replace type/value pairs with typed-literals.  For example, we change:
                //              { name:['Nelson Mandela'], born:[{_type:'Date', _value:'1918-07-18'}] }
                // into this:
                //              { name:['Kermit'], born:(new Date(1918, 6, 18)) }
                //
                // We also generate the associate map for all items for the O(1) isItem function.
                for(i = 0; i < this._arrayOfAllItems.length; ++i){
                        item = this._arrayOfAllItems[i]; // example: { name:['Kermit'], friends:[{_reference:{name:'Miss Piggy'}}] }
                        for(key in item){
                                arrayOfValues = item[key]; // example: [{_reference:{name:'Miss Piggy'}}]
                                for(var j = 0; j < arrayOfValues.length; ++j){
                                        value = arrayOfValues[j]; // example: {_reference:{name:'Miss Piggy'}}
                                        if(value !== null && typeof value == "object"){
                                                if(("_type" in value) && ("_value" in value)){
                                                        var type = value._type; // examples: 'Date', 'Color', or 'ComplexNumber'
                                                        var mappingObj = this._datatypeMap[type]; // examples: Date, dojo.Color, foo.math.ComplexNumber, {type: dojo.Color, deserialize(value){ return new dojo.Color(value)}}
                                                        if(!mappingObj){
                                                                throw new Error("dojo.data.ItemFileReadStore: in the typeMap constructor arg, no object class was specified for the datatype '" + type + "'");
                                                        }else if(lang.isFunction(mappingObj)){
                                                                arrayOfValues[j] = new mappingObj(value._value);
                                                        }else if(lang.isFunction(mappingObj.deserialize)){
                                                                arrayOfValues[j] = mappingObj.deserialize(value._value);
                                                        }else{
                                                                throw new Error("dojo.data.ItemFileReadStore: Value provided in typeMap was neither a constructor, nor a an object with a deserialize function");
                                                        }
                                                }
                                                if(value._reference){
                                                        var referenceDescription = value._reference; // example: {name:'Miss Piggy'}
                                                        if(!lang.isObject(referenceDescription)){
                                                                // example: 'Miss Piggy'
                                                                // from an item like: { name:['Kermit'], friends:[{_reference:'Miss Piggy'}]}
                                                                arrayOfValues[j] = this._getItemByIdentity(referenceDescription);
                                                        }else{
                                                                // example: {name:'Miss Piggy'}
                                                                // from an item like: { name:['Kermit'], friends:[{_reference:{name:'Miss Piggy'}}] }
                                                                for(var k = 0; k < this._arrayOfAllItems.length; ++k){
                                                                        var candidateItem = this._arrayOfAllItems[k],
                                                                                found = true;
                                                                        for(var refKey in referenceDescription){
                                                                                if(candidateItem[refKey] != referenceDescription[refKey]){
                                                                                        found = false;
                                                                                }
                                                                        }
                                                                        if(found){
                                                                                arrayOfValues[j] = candidateItem;
                                                                        }
                                                                }
                                                        }
                                                        if(this.referenceIntegrity){
                                                                var refItem = arrayOfValues[j];
                                                                if(this.isItem(refItem)){
                                                                        this._addReferenceToMap(refItem, item, key);
                                                                }
                                                        }
                                                }else if(this.isItem(value)){
                                                        //It's a child item (not one referenced through _reference).
                                                        //We need to treat this as a referenced item, so it can be cleaned up
                                                        //in a write store easily.
                                                        if(this.referenceIntegrity){
                                                                this._addReferenceToMap(value, item, key);
                                                        }
                                                }
                                        }
                                }
                        }
                }
        },

        _addReferenceToMap: function(/*item*/ refItem, /*item*/ parentItem, /*string*/ attribute){
                // summary:
                //              Method to add an reference map entry for an item and attribute.
                // description:
                //              Method to add an reference map entry for an item and attribute.
                // refItem:
                //              The item that is referenced.
                // parentItem:
                //              The item that holds the new reference to refItem.
                // attribute:
                //              The attribute on parentItem that contains the new reference.

                //Stub function, does nothing.  Real processing is in ItemFileWriteStore.
        },

        getIdentity: function(/* dojo/data/api/Item */ item){
                // summary:
                //              See dojo/data/api/Identity.getIdentity()
                var identifier = this._features['dojo.data.api.Identity'];
                if(identifier === Number){
                        return item[this._itemNumPropName]; // Number
                }else{
                        var arrayOfValues = item[identifier];
                        if(arrayOfValues){
                                return arrayOfValues[0]; // Object|String
                        }
                }
                return null; // null
        },

        fetchItemByIdentity: function(/* Object */ keywordArgs){
                // summary:
                //              See dojo/data/api/Identity.fetchItemByIdentity()

                // Hasn't loaded yet, we have to trigger the load.
                var item,
                        scope;
                if(!this._loadFinished){
                        var self = this;
                        //Do a check on the JsonFileUrl and crosscheck it.
                        //If it doesn't match the cross-check, it needs to be updated
                        //This allows for either url or _jsonFileUrl to he changed to
                        //reset the store load location.  Done this way for backwards
                        //compatibility.  People use _jsonFileUrl (even though officially
                        //private.
                        if(this._jsonFileUrl !== this._ccUrl){
                                kernel.deprecated(this.declaredClass + ": ",
                                        "To change the url, set the url property of the store," +
                                                " not _jsonFileUrl.  _jsonFileUrl support will be removed in 2.0");
                                this._ccUrl = this._jsonFileUrl;
                                this.url = this._jsonFileUrl;
                        }else if(this.url !== this._ccUrl){
                                this._jsonFileUrl = this.url;
                                this._ccUrl = this.url;
                        }

                        //See if there was any forced reset of data.
                        if(this.data != null && this._jsonData == null){
                                this._jsonData = this.data;
                                this.data = null;
                        }

                        if(this._jsonFileUrl){

                                if(this._loadInProgress){
                                        this._queuedFetches.push({args: keywordArgs});
                                }else{
                                        this._loadInProgress = true;
                                        var getArgs = {
                                                url: self._jsonFileUrl,
                                                handleAs: "json-comment-optional",
                                                preventCache: this.urlPreventCache,
                                                failOk: this.failOk
                                        };
                                        var getHandler = xhr.get(getArgs);
                                        getHandler.addCallback(function(data){
                                                var scope = keywordArgs.scope?keywordArgs.scope:kernel.global;
                                                try{
                                                        self._getItemsFromLoadedData(data);
                                                        self._loadFinished = true;
                                                        self._loadInProgress = false;
                                                        item = self._getItemByIdentity(keywordArgs.identity);
                                                        if(keywordArgs.onItem){
                                                                keywordArgs.onItem.call(scope, item);
                                                        }
                                                        self._handleQueuedFetches();
                                                }catch(error){
                                                        self._loadInProgress = false;
                                                        if(keywordArgs.onError){
                                                                keywordArgs.onError.call(scope, error);
                                                        }
                                                }
                                        });
                                        getHandler.addErrback(function(error){
                                                self._loadInProgress = false;
                                                if(keywordArgs.onError){
                                                        var scope = keywordArgs.scope?keywordArgs.scope:kernel.global;
                                                        keywordArgs.onError.call(scope, error);
                                                }
                                        });
                                }

                        }else if(this._jsonData){
                                // Passed in data, no need to xhr.
                                self._getItemsFromLoadedData(self._jsonData);
                                self._jsonData = null;
                                self._loadFinished = true;
                                item = self._getItemByIdentity(keywordArgs.identity);
                                if(keywordArgs.onItem){
                                        scope = keywordArgs.scope?keywordArgs.scope:kernel.global;
                                        keywordArgs.onItem.call(scope, item);
                                }
                        }
                }else{
                        // Already loaded.  We can just look it up and call back.
                        item = this._getItemByIdentity(keywordArgs.identity);
                        if(keywordArgs.onItem){
                                scope = keywordArgs.scope?keywordArgs.scope:kernel.global;
                                keywordArgs.onItem.call(scope, item);
                        }
                }
        },

        _getItemByIdentity: function(/* Object */ identity){
                // summary:
                //              Internal function to look an item up by its identity map.
                var item = null;
                if(this._itemsByIdentity){
                        // If this map is defined, we need to just try to get it.  If it fails
                        // the item does not exist.
                        if(Object.hasOwnProperty.call(this._itemsByIdentity, identity)){
                                item = this._itemsByIdentity[identity];
                        }
                }else if (Object.hasOwnProperty.call(this._arrayOfAllItems, identity)){
                        item = this._arrayOfAllItems[identity];
                }
                if(item === undefined){
                        item = null;
                }
                return item; // Object
        },

        getIdentityAttributes: function(/* dojo/data/api/Item */ item){
                // summary:
                //              See dojo/data/api/Identity.getIdentityAttributes()

                var identifier = this._features['dojo.data.api.Identity'];
                if(identifier === Number){
                        // If (identifier === Number) it means getIdentity() just returns
                        // an integer item-number for each item.  The dojo/data/api/Identity
                        // spec says we need to return null if the identity is not composed
                        // of attributes
                        return null; // null
                }else{
                        return [identifier]; // Array
                }
        },

        _forceLoad: function(){
                // summary:
                //              Internal function to force a load of the store if it hasn't occurred yet.  This is required
                //              for specific functions to work properly.
                var self = this;
                //Do a check on the JsonFileUrl and crosscheck it.
                //If it doesn't match the cross-check, it needs to be updated
                //This allows for either url or _jsonFileUrl to he changed to
                //reset the store load location.  Done this way for backwards
                //compatibility.  People use _jsonFileUrl (even though officially
                //private.
                if(this._jsonFileUrl !== this._ccUrl){
                        kernel.deprecated(this.declaredClass + ": ",
                                "To change the url, set the url property of the store," +
                                        " not _jsonFileUrl.  _jsonFileUrl support will be removed in 2.0");
                        this._ccUrl = this._jsonFileUrl;
                        this.url = this._jsonFileUrl;
                }else if(this.url !== this._ccUrl){
                        this._jsonFileUrl = this.url;
                        this._ccUrl = this.url;
                }

                //See if there was any forced reset of data.
                if(this.data != null){
                        this._jsonData = this.data;
                        this.data = null;
                }

                if(this._jsonFileUrl){
                        var getArgs = {
                                url: this._jsonFileUrl,
                                handleAs: "json-comment-optional",
                                preventCache: this.urlPreventCache,
                                failOk: this.failOk,
                                sync: true
                        };
                        var getHandler = xhr.get(getArgs);
                        getHandler.addCallback(function(data){
                                try{
                                        //Check to be sure there wasn't another load going on concurrently
                                        //So we don't clobber data that comes in on it.  If there is a load going on
                                        //then do not save this data.  It will potentially clobber current data.
                                        //We mainly wanted to sync/wait here.
                                        //TODO:  Revisit the loading scheme of this store to improve multi-initial
                                        //request handling.
                                        if(self._loadInProgress !== true && !self._loadFinished){
                                                self._getItemsFromLoadedData(data);
                                                self._loadFinished = true;
                                        }else if(self._loadInProgress){
                                                //Okay, we hit an error state we can't recover from.  A forced load occurred
                                                //while an async load was occurring.  Since we cannot block at this point, the best
                                                //that can be managed is to throw an error.
                                                throw new Error(this.declaredClass + ":  Unable to perform a synchronous load, an async load is in progress.");
                                        }
                                }catch(e){
                                        console.log(e);
                                        throw e;
                                }
                        });
                        getHandler.addErrback(function(error){
                                throw error;
                        });
                }else if(this._jsonData){
                        self._getItemsFromLoadedData(self._jsonData);
                        self._jsonData = null;
                        self._loadFinished = true;
                }
        }
});
//Mix in the simple fetch implementation to this class.
lang.extend(ItemFileReadStore,simpleFetch);

return ItemFileReadStore;

});

},
'dojo/html':function(){
define("dojo/html", ["./_base/kernel", "./_base/lang", "./_base/array", "./_base/declare", "./dom", "./dom-construct", "./parser"],
        function(kernel, lang, darray, declare, dom, domConstruct, parser){
        // module:
        //              dojo/html

        var html = {
                // summary:
                //              TODOC
        };
        lang.setObject("dojo.html", html);

        // the parser might be needed..

        // idCounter is incremented with each instantiation to allow assignment of a unique id for tracking, logging purposes
        var idCounter = 0;

        html._secureForInnerHtml = function(/*String*/ cont){
                // summary:
                //              removes !DOCTYPE and title elements from the html string.
                //
                //              khtml is picky about dom faults, you can't attach a style or `<title>` node as child of body
                //              must go into head, so we need to cut out those tags
                // cont:
                //              An html string for insertion into the dom
                //
                return cont.replace(/(?:\s*<!DOCTYPE\s[^>]+>|<title[^>]*>[\s\S]*?<\/title>)/ig, ""); // String
        };

        html._emptyNode = domConstruct.empty;
        /*=====
         dojo.html._emptyNode = function(node){
                 // summary:
                 //             Removes all child nodes from the given node.   Deprecated, should use dojo/dom-constuct.empty() directly
                 //             instead.
                 // node: DOMNode
                 //             the parent element
         };
         =====*/

                html._setNodeContent = function(/*DomNode*/ node, /*String|DomNode|NodeList*/ cont){
                // summary:
                //              inserts the given content into the given node
                // node:
                //              the parent element
                // content:
                //              the content to be set on the parent element.
                //              This can be an html string, a node reference or a NodeList, dojo/NodeList, Array or other enumerable list of nodes

                // always empty
                domConstruct.empty(node);

                if(cont){
                        if(typeof cont == "string"){
                                cont = domConstruct.toDom(cont, node.ownerDocument);
                        }
                        if(!cont.nodeType && lang.isArrayLike(cont)){
                                // handle as enumerable, but it may shrink as we enumerate it
                                for(var startlen=cont.length, i=0; i<cont.length; i=startlen==cont.length ? i+1 : 0){
                                        domConstruct.place( cont[i], node, "last");
                                }
                        }else{
                                // pass nodes, documentFragments and unknowns through to dojo.place
                                domConstruct.place(cont, node, "last");
                        }
                }

                // return DomNode
                return node;
        };

        // we wrap up the content-setting operation in a object
        html._ContentSetter = declare("dojo.html._ContentSetter", null,
                {
                        // node: DomNode|String
                        //              An node which will be the parent element that we set content into
                        node: "",

                        // content: String|DomNode|DomNode[]
                        //              The content to be placed in the node. Can be an HTML string, a node reference, or a enumerable list of nodes
                        content: "",

                        // id: String?
                        //              Usually only used internally, and auto-generated with each instance
                        id: "",

                        // cleanContent: Boolean
                        //              Should the content be treated as a full html document,
                        //              and the real content stripped of <html>, <body> wrapper before injection
                        cleanContent: false,

                        // extractContent: Boolean
                        //              Should the content be treated as a full html document,
                        //              and the real content stripped of `<html> <body>` wrapper before injection
                        extractContent: false,

                        // parseContent: Boolean
                        //              Should the node by passed to the parser after the new content is set
                        parseContent: false,

                        // parserScope: String
                        //              Flag passed to parser.  Root for attribute names to search for.   If scopeName is dojo,
                        //              will search for data-dojo-type (or dojoType).  For backwards compatibility
                        //              reasons defaults to dojo._scopeName (which is "dojo" except when
                        //              multi-version support is used, when it will be something like dojo16, dojo20, etc.)
                        parserScope: kernel._scopeName,

                        // startup: Boolean
                        //              Start the child widgets after parsing them.       Only obeyed if parseContent is true.
                        startup: true,

                        // lifecycle methods
                        constructor: function(/*Object*/ params, /*String|DomNode*/ node){
                                // summary:
                                //              Provides a configurable, extensible object to wrap the setting on content on a node
                                //              call the set() method to actually set the content..

                                // the original params are mixed directly into the instance "this"
                                lang.mixin(this, params || {});

                                // give precedence to params.node vs. the node argument
                                // and ensure its a node, not an id string
                                node = this.node = dom.byId( this.node || node );

                                if(!this.id){
                                        this.id = [
                                                "Setter",
                                                (node) ? node.id || node.tagName : "",
                                                idCounter++
                                        ].join("_");
                                }
                        },
                        set: function(/* String|DomNode|NodeList? */ cont, /*Object?*/ params){
                                // summary:
                                //              front-end to the set-content sequence
                                // cont:
                                //              An html string, node or enumerable list of nodes for insertion into the dom
                                //              If not provided, the object's content property will be used
                                if(undefined !== cont){
                                        this.content = cont;
                                }
                                // in the re-use scenario, set needs to be able to mixin new configuration
                                if(params){
                                        this._mixin(params);
                                }

                                this.onBegin();
                                this.setContent();

                                var ret = this.onEnd();

                                if(ret && ret.then){
                                        // Make dojox/html/_ContentSetter.set() return a Promise that resolves when load and parse complete.
                                        return ret;
                                }else{
                                        // Vanilla dojo/html._ContentSetter.set() returns a DOMNode for back compat.   For 2.0, switch it to
                                        // return a Deferred like above.
                                        return this.node;
                                }
                        },

                        setContent: function(){
                                // summary:
                                //              sets the content on the node

                                var node = this.node;
                                if(!node){
                                        // can't proceed
                                        throw new Error(this.declaredClass + ": setContent given no node");
                                }
                                try{
                                        node = html._setNodeContent(node, this.content);
                                }catch(e){
                                        // check if a domfault occurs when we are appending this.errorMessage
                                        // like for instance if domNode is a UL and we try append a DIV

                                        // FIXME: need to allow the user to provide a content error message string
                                        var errMess = this.onContentError(e);
                                        try{
                                                node.innerHTML = errMess;
                                        }catch(e){
                                                console.error('Fatal ' + this.declaredClass + '.setContent could not change content due to '+e.message, e);
                                        }
                                }
                                // always put back the node for the next method
                                this.node = node; // DomNode
                        },

                        empty: function(){
                                // summary:
                                //              cleanly empty out existing content
                                
                                // If there is a parse in progress, cancel it.
                                if(this.parseDeferred){
                                        if(!this.parseDeferred.isResolved()){
                                                this.parseDeferred.cancel();
                                        }
                                        delete this.parseDeferred;
                                }

                                // destroy any widgets from a previous run
                                // NOTE: if you don't want this you'll need to empty
                                // the parseResults array property yourself to avoid bad things happening
                                if(this.parseResults && this.parseResults.length){
                                        darray.forEach(this.parseResults, function(w){
                                                if(w.destroy){
                                                        w.destroy();
                                                }
                                        });
                                        delete this.parseResults;
                                }
                                // this is fast, but if you know its already empty or safe, you could
                                // override empty to skip this step
                                domConstruct.empty(this.node);
                        },

                        onBegin: function(){
                                // summary:
                                //              Called after instantiation, but before set();
                                //              It allows modification of any of the object properties -
                                //              including the node and content provided - before the set operation actually takes place
                                //              This default implementation checks for cleanContent and extractContent flags to
                                //              optionally pre-process html string content
                                var cont = this.content;

                                if(lang.isString(cont)){
                                        if(this.cleanContent){
                                                cont = html._secureForInnerHtml(cont);
                                        }

                                        if(this.extractContent){
                                                var match = cont.match(/<body[^>]*>\s*([\s\S]+)\s*<\/body>/im);
                                                if(match){ cont = match[1]; }
                                        }
                                }

                                // clean out the node and any cruft associated with it - like widgets
                                this.empty();

                                this.content = cont;
                                return this.node; // DomNode
                        },

                        onEnd: function(){
                                // summary:
                                //              Called after set(), when the new content has been pushed into the node
                                //              It provides an opportunity for post-processing before handing back the node to the caller
                                //              This default implementation checks a parseContent flag to optionally run the dojo parser over the new content
                                if(this.parseContent){
                                        // populates this.parseResults and this.parseDeferred if you need those..
                                        this._parse();
                                }
                                return this.node; // DomNode
                                // TODO: for 2.0 return a Promise indicating that the parse completed.
                        },

                        tearDown: function(){
                                // summary:
                                //              manually reset the Setter instance if its being re-used for example for another set()
                                // description:
                                //              tearDown() is not called automatically.
                                //              In normal use, the Setter instance properties are simply allowed to fall out of scope
                                //              but the tearDown method can be called to explicitly reset this instance.
                                delete this.parseResults;
                                delete this.parseDeferred;
                                delete this.node;
                                delete this.content;
                        },

                        onContentError: function(err){
                                return "Error occurred setting content: " + err;
                        },

                        onExecError: function(err){
                                return "Error occurred executing scripts: " + err;
                        },

                        _mixin: function(params){
                                // mix properties/methods into the instance
                                // TODO: the intention with tearDown is to put the Setter's state
                                // back to that of the original constructor (vs. deleting/resetting everything regardless of ctor params)
                                // so we could do something here to move the original properties aside for later restoration
                                var empty = {}, key;
                                for(key in params){
                                        if(key in empty){ continue; }
                                        // TODO: here's our opportunity to mask the properties we don't consider configurable/overridable
                                        // .. but history shows we'll almost always guess wrong
                                        this[key] = params[key];
                                }
                        },
                        _parse: function(){
                                // summary:
                                //              runs the dojo parser over the node contents, storing any results in this.parseResults
                                //              and the parse promise in this.parseDeferred
                                //              Any errors resulting from parsing are passed to _onError for handling

                                var rootNode = this.node;
                                try{
                                        // store the results (widgets, whatever) for potential retrieval
                                        var inherited = {};
                                        darray.forEach(["dir", "lang", "textDir"], function(name){
                                                if(this[name]){
                                                        inherited[name] = this[name];
                                                }
                                        }, this);
                                        var self = this;
                                        this.parseDeferred = parser.parse({
                                                rootNode: rootNode,
                                                noStart: !this.startup,
                                                inherited: inherited,
                                                scope: this.parserScope
                                        }).then(function(results){
                                                return self.parseResults = results;
                                        });
                                }catch(e){
                                        this._onError('Content', e, "Error parsing in _ContentSetter#"+this.id);
                                }
                        },

                        _onError: function(type, err, consoleText){
                                // summary:
                                //              shows user the string that is returned by on[type]Error
                                //              override/implement on[type]Error and return your own string to customize
                                var errText = this['on' + type + 'Error'].call(this, err);
                                if(consoleText){
                                        console.error(consoleText, err);
                                }else if(errText){ // a empty string won't change current content
                                        html._setNodeContent(this.node, errText, true);
                                }
                        }
        }); // end declare()

        html.set = function(/*DomNode*/ node, /*String|DomNode|NodeList*/ cont, /*Object?*/ params){
                        // summary:
                        //              inserts (replaces) the given content into the given node. dojo.place(cont, node, "only")
                        //              may be a better choice for simple HTML insertion.
                        // description:
                        //              Unless you need to use the params capabilities of this method, you should use
                        //              dojo.place(cont, node, "only"). dojo.place() has more robust support for injecting
                        //              an HTML string into the DOM, but it only handles inserting an HTML string as DOM
                        //              elements, or inserting a DOM node. dojo.place does not handle NodeList insertions
                        //              or the other capabilities as defined by the params object for this method.
                        // node:
                        //              the parent element that will receive the content
                        // cont:
                        //              the content to be set on the parent element.
                        //              This can be an html string, a node reference or a NodeList, dojo/NodeList, Array or other enumerable list of nodes
                        // params:
                        //              Optional flags/properties to configure the content-setting. See dojo/html/_ContentSetter
                        // example:
                        //              A safe string/node/nodelist content replacement/injection with hooks for extension
                        //              Example Usage:
                        //      |       html.set(node, "some string");
                        //      |       html.set(node, contentNode, {options});
                        //      |       html.set(node, myNode.childNodes, {options});
                if(undefined == cont){
                        console.warn("dojo.html.set: no cont argument provided, using empty string");
                        cont = "";
                }
                if(!params){
                        // simple and fast
                        return html._setNodeContent(node, cont, true);
                }else{
                        // more options but slower
                        // note the arguments are reversed in order, to match the convention for instantiation via the parser
                        var op = new html._ContentSetter(lang.mixin(
                                        params,
                                        { content: cont, node: node }
                        ));
                        return op.set();
                }
        };

        return html;
});

},
'dijit/_PaletteMixin':function(){
define("dijit/_PaletteMixin", [
        "dojo/_base/declare", // declare
        "dojo/dom-attr", // domAttr.set
        "dojo/dom-class", // domClass.add domClass.remove
        "dojo/dom-construct", // domConstruct.create domConstruct.place
        "dojo/_base/event", // event.stop
        "dojo/keys", // keys
        "dojo/_base/lang", // lang.getObject
        "./_CssStateMixin",
        "./focus",
        "./typematic"
], function(declare, domAttr, domClass, domConstruct, event, keys, lang, _CssStateMixin, focus, typematic){

// module:
//              dijit/_PaletteMixin

return declare("dijit._PaletteMixin", [_CssStateMixin], {
        // summary:
        //              A keyboard accessible palette, for picking a color/emoticon/etc.
        // description:
        //              A mixin for a grid showing various entities, so the user can pick a certain entity.

        // defaultTimeout: Number
        //              Number of milliseconds before a held key or button becomes typematic
        defaultTimeout: 500,

        // timeoutChangeRate: Number
        //              Fraction of time used to change the typematic timer between events
        //              1.0 means that each typematic event fires at defaultTimeout intervals
        //              Less than 1.0 means that each typematic event fires at an increasing faster rate
        timeoutChangeRate: 0.90,

        // value: String
        //              Currently selected color/emoticon/etc.
        value: "",

        // _selectedCell: [private] Integer
        //              Index of the currently selected cell. Initially, none selected
        _selectedCell: -1,

/*=====
        // _currentFocus: [private] DomNode
        //              The currently focused cell (if the palette itself has focus), or otherwise
        //              the cell to be focused when the palette itself gets focus.
        //              Different from value, which represents the selected (i.e. clicked) cell.
        _currentFocus: null,
=====*/

/*=====
        // _xDim: [protected] Integer
        //              This is the number of cells horizontally across.
        _xDim: null,
=====*/

/*=====
        // _yDim: [protected] Integer
        //              This is the number of cells vertically down.
        _yDim: null,
=====*/

        // tabIndex: String
        //              Widget tab index.
        tabIndex: "0",

        // cellClass: [protected] String
        //              CSS class applied to each cell in the palette
        cellClass: "dijitPaletteCell",

        // dyeClass: [protected] Constructor
        //              Constructor for Object created for each cell of the palette.
        //              dyeClass should implements dijit.Dye interface
        dyeClass: null,
        
        // summary: String
        //              Localized summary for the palette table
        summary: '',
        _setSummaryAttr: "paletteTableNode",

        _dyeFactory: function(value /*===== , row, col, title =====*/){
                // summary:
                //              Return instance of dijit.Dye for specified cell of palette
                // tags:
                //              extension

                // Remove string support for 2.0
                var dyeClassObj = typeof this.dyeClass == "string" ? lang.getObject(this.dyeClass) : this.dyeClass;
                return new dyeClassObj(value);
        },

        _preparePalette: function(choices, titles) {
                // summary:
                //              Subclass must call _preparePalette() from postCreate(), passing in the tooltip
                //              for each cell
                // choices: String[][]
                //              id's for each cell of the palette, used to create Dye JS object for each cell
                // titles: String[]
                //              Localized tooltip for each cell

                this._cells = [];
                var url = this._blankGif;

                this.connect(this.gridNode, "ondijitclick", "_onCellClick");

                for(var row=0; row < choices.length; row++){
                        var rowNode = domConstruct.create("tr", {tabIndex: "-1"}, this.gridNode);
                        for(var col=0; col < choices[row].length; col++){
                                var value = choices[row][col];
                                if(value){
                                        var cellObject = this._dyeFactory(value, row, col, titles[value]);

                                        var cellNode = domConstruct.create("td", {
                                                "class": this.cellClass,
                                                tabIndex: "-1",
                                                title: titles[value],
                                                role: "gridcell"
                                        }, rowNode);

                                        // prepare cell inner structure
                                        cellObject.fillCell(cellNode, url);

                                        cellNode.idx = this._cells.length;

                                        // save cell info into _cells
                                        this._cells.push({node:cellNode, dye:cellObject});
                                }
                        }
                }
                this._xDim = choices[0].length;
                this._yDim = choices.length;

                // Now set all events
                // The palette itself is navigated to with the tab key on the keyboard
                // Keyboard navigation within the Palette is with the arrow keys
                // Spacebar selects the cell.
                // For the up key the index is changed by negative the x dimension.

                var keyIncrementMap = {
                        UP_ARROW: -this._xDim,
                        // The down key the index is increase by the x dimension.
                        DOWN_ARROW: this._xDim,
                        // Right and left move the index by 1.
                        RIGHT_ARROW: this.isLeftToRight() ? 1 : -1,
                        LEFT_ARROW: this.isLeftToRight() ? -1 : 1
                };
                for(var key in keyIncrementMap){
                        this.own(
                                typematic.addKeyListener(
                                        this.domNode,
                                        {charOrCode:keys[key], ctrlKey:false, altKey:false, shiftKey:false},
                                        this,
                                        function(){
                                                var increment = keyIncrementMap[key];
                                                return function(count){ this._navigateByKey(increment, count); };
                                        }(),
                                        this.timeoutChangeRate,
                                        this.defaultTimeout
                                )
                        );
                }
        },

        postCreate: function(){
                this.inherited(arguments);

                // Set initial navigable node.
                this._setCurrent(this._cells[0].node);
        },

        focus: function(){
                // summary:
                //              Focus this widget.  Puts focus on the most recently focused cell.

                // The cell already has tabIndex set, just need to set CSS and focus it
                focus.focus(this._currentFocus);
        },

        _onCellClick: function(/*Event*/ evt){
                // summary:
                //              Handler for click, enter key & space key. Selects the cell.
                // evt:
                //              The event.
                // tags:
                //              private

                var target = evt.target;

                // Find TD associated with click event.   For ColorPalette user likely clicked IMG inside of TD
                while(target.tagName != "TD"){
                        if(!target.parentNode || target == this.gridNode){      // probably can never happen, but just in case
                                return;
                        }
                        target = target.parentNode;
                }

                var value = this._getDye(target).getValue();

                // First focus the clicked cell, and then send onChange() notification.
                // onChange() (via _setValueAttr) must be after the focus call, because
                // it may trigger a refocus to somewhere else (like the Editor content area), and that
                // second focus should win.
                this._setCurrent(target);
                focus.focus(target);
                this._setValueAttr(value, true);

                event.stop(evt);
        },

        _setCurrent: function(/*DomNode*/ node){
                // summary:
                //              Sets which node is the focused cell.
                // description:
                //              At any point in time there's exactly one
                //              cell with tabIndex != -1.   If focus is inside the palette then
                //              focus is on that cell.
                //
                //              After calling this method, arrow key handlers and mouse click handlers
                //              should focus the cell in a setTimeout().
                // tags:
                //              protected
                if("_currentFocus" in this){
                        // Remove tabIndex on old cell
                        domAttr.set(this._currentFocus, "tabIndex", "-1");
                }

                // Set tabIndex of new cell
                this._currentFocus = node;
                if(node){
                        domAttr.set(node, "tabIndex", this.tabIndex);
                }
        },

        _setValueAttr: function(value, priorityChange){
                // summary:
                //              This selects a cell. It triggers the onChange event.
                // value: String
                //              Value of the cell to select
                // tags:
                //              protected
                // priorityChange: Boolean?
                //              Optional parameter used to tell the select whether or not to fire
                //              onChange event.

                // clear old selected cell
                if(this._selectedCell >= 0){
                        domClass.remove(this._cells[this._selectedCell].node, this.cellClass + "Selected");
                }
                this._selectedCell = -1;

                // search for cell matching specified value
                if(value){
                        for(var i = 0; i < this._cells.length; i++){
                                if(value == this._cells[i].dye.getValue()){
                                        this._selectedCell = i;
                                        domClass.add(this._cells[i].node, this.cellClass + "Selected");
                                        break;
                                }
                        }
                }

                // record new value, or null if no matching cell
                this._set("value", this._selectedCell >= 0 ? value : null);

                if(priorityChange || priorityChange === undefined){
                        this.onChange(value);
                }
        },

        onChange: function(/*===== value =====*/){
                // summary:
                //              Callback when a cell is selected.
                // value: String
                //              Value corresponding to cell.
        },

        _navigateByKey: function(increment, typeCount){
                // summary:
                //              This is the callback for typematic.
                //              It changes the focus and the highlighed cell.
                // increment:
                //              How much the key is navigated.
                // typeCount:
                //              How many times typematic has fired.
                // tags:
                //              private

                // typecount == -1 means the key is released.
                if(typeCount == -1){ return; }

                var newFocusIndex = this._currentFocus.idx + increment;
                if(newFocusIndex < this._cells.length && newFocusIndex > -1){
                        var focusNode = this._cells[newFocusIndex].node;
                        this._setCurrent(focusNode);

                        // Actually focus the node, for the benefit of screen readers.
                        // Use defer because IE doesn't like changing focus inside of an event handler
                        this.defer(lang.hitch(focus, "focus", focusNode));
                }
        },

        _getDye: function(/*DomNode*/ cell){
                // summary:
                //              Get JS object for given cell DOMNode

                return this._cells[cell.idx].dye;
        }
});

/*=====
declare("dijit.Dye",
        null,
        {
                // summary:
                //              Interface for the JS Object associated with a palette cell (i.e. DOMNode)

                constructor: function(alias, row, col){
                        // summary:
                        //              Initialize according to value or alias like "white"
                        // alias: String
                },

                getValue: function(){
                        // summary:
                        //              Return "value" of cell; meaning of "value" varies by subclass.
                        // description:
                        //              For example color hex value, emoticon ascii value etc, entity hex value.
                },

                fillCell: function(cell, blankGif){
                        // summary:
                        //              Add cell DOMNode inner structure
                        // cell: DomNode
                        //              The surrounding cell
                        // blankGif: String
                        //              URL for blank cell image
                }
        }
);
=====*/

});

},
'dijit/form/ValidationTextBox':function(){
require({cache:{
'url:dijit/form/templates/ValidationTextBox.html':"<div class=\"dijit dijitReset dijitInline dijitLeft\"\n\tid=\"widget_${id}\" role=\"presentation\"\n\t><div class='dijitReset dijitValidationContainer'\n\t\t><input class=\"dijitReset dijitInputField dijitValidationIcon dijitValidationInner\" value=\"&#935; \" type=\"text\" tabIndex=\"-1\" readonly=\"readonly\" role=\"presentation\"\n\t/></div\n\t><div class=\"dijitReset dijitInputField dijitInputContainer\"\n\t\t><input class=\"dijitReset dijitInputInner\" data-dojo-attach-point='textbox,focusNode' autocomplete=\"off\"\n\t\t\t${!nameAttrSetting} type='${type}'\n\t/></div\n></div>\n"}});
define("dijit/form/ValidationTextBox", [
        "dojo/_base/declare", // declare
        "dojo/_base/kernel", // kernel.deprecated
        "dojo/i18n", // i18n.getLocalization
        "./TextBox",
        "../Tooltip",
        "dojo/text!./templates/ValidationTextBox.html",
        "dojo/i18n!./nls/validate"
], function(declare, kernel, i18n, TextBox, Tooltip, template){

        // module:
        //              dijit/form/ValidationTextBox


        /*=====
        var __Constraints = {
                // locale: String
                //              locale used for validation, picks up value from this widget's lang attribute
                // _flags_: anything
                //              various flags passed to pattern function
        };
        =====*/

        var ValidationTextBox;
        return ValidationTextBox = declare("dijit.form.ValidationTextBox", TextBox, {
                // summary:
                //              Base class for textbox widgets with the ability to validate content of various types and provide user feedback.

                templateString: template,

                // required: Boolean
                //              User is required to enter data into this field.
                required: false,

                // promptMessage: String
                //              If defined, display this hint string immediately on focus to the textbox, if empty.
                //              Also displays if the textbox value is Incomplete (not yet valid but will be with additional input).
                //              Think of this like a tooltip that tells the user what to do, not an error message
                //              that tells the user what they've done wrong.
                //
                //              Message disappears when user starts typing.
                promptMessage: "",

                // invalidMessage: String
                //              The message to display if value is invalid.
                //              The translated string value is read from the message file by default.
                //              Set to "" to use the promptMessage instead.
                invalidMessage: "$_unset_$",

                // missingMessage: String
                //              The message to display if value is empty and the field is required.
                //              The translated string value is read from the message file by default.
                //              Set to "" to use the invalidMessage instead.
                missingMessage: "$_unset_$",

                // message: String
                //              Currently error/prompt message.
                //              When using the default tooltip implementation, this will only be
                //              displayed when the field is focused.
                message: "",

                // constraints: __Constraints
                //              user-defined object needed to pass parameters to the validator functions
                constraints: {},

                // pattern: [extension protected] String|Function(constraints) returning a string.
                //              This defines the regular expression used to validate the input.
                //              Do not add leading ^ or $ characters since the widget adds these.
                //              A function may be used to generate a valid pattern when dependent on constraints or other runtime factors.
                //              set('pattern', String|Function).
                pattern: ".*",

                // regExp: Deprecated [extension protected] String.  Use "pattern" instead.
                regExp: "",

                regExpGen: function(/*__Constraints*/ /*===== constraints =====*/){
                        // summary:
                        //              Deprecated.  Use set('pattern', Function) instead.
                },

                // state: [readonly] String
                //              Shows current state (ie, validation result) of input (""=Normal, Incomplete, or Error)
                state: "",

                // tooltipPosition: String[]
                //              See description of `dijit/Tooltip.defaultPosition` for details on this parameter.
                tooltipPosition: [],

                _deprecateRegExp: function(attr, value){
                        if(value != ValidationTextBox.prototype[attr]){
                                kernel.deprecated("ValidationTextBox id="+this.id+", set('" + attr + "', ...) is deprecated.  Use set('pattern', ...) instead.", "", "2.0");
                                this.set('pattern', value);
                        }
                },
                _setRegExpGenAttr: function(/*Function*/ newFcn){
                        this._deprecateRegExp("regExpGen", newFcn);
                        this.regExpGen = this._getPatternAttr; // backward compat with this.regExpGen(this.constraints)
                },
                _setRegExpAttr: function(/*String*/ value){
                        this._deprecateRegExp("regExp", value);
                },

                _setValueAttr: function(){
                        // summary:
                        //              Hook so set('value', ...) works.
                        this.inherited(arguments);
                        this.validate(this.focused);
                },

                validator: function(/*anything*/ value, /*__Constraints*/ constraints){
                        // summary:
                        //              Overridable function used to validate the text input against the regular expression.
                        // tags:
                        //              protected
                        return (new RegExp("^(?:" + this._getPatternAttr(constraints) + ")"+(this.required?"":"?")+"$")).test(value) &&
                                (!this.required || !this._isEmpty(value)) &&
                                (this._isEmpty(value) || this.parse(value, constraints) !== undefined); // Boolean
                },

                _isValidSubset: function(){
                        // summary:
                        //              Returns true if the value is either already valid or could be made valid by appending characters.
                        //              This is used for validation while the user [may be] still typing.
                        return this.textbox.value.search(this._partialre) == 0;
                },

                isValid: function(/*Boolean*/ /*===== isFocused =====*/){
                        // summary:
                        //              Tests if value is valid.
                        //              Can override with your own routine in a subclass.
                        // tags:
                        //              protected
                        return this.validator(this.textbox.value, this.constraints);
                },

                _isEmpty: function(value){
                        // summary:
                        //              Checks for whitespace
                        return (this.trim ? /^\s*$/ : /^$/).test(value); // Boolean
                },

                getErrorMessage: function(/*Boolean*/ /*===== isFocused =====*/){
                        // summary:
                        //              Return an error message to show if appropriate
                        // tags:
                        //              protected
                        var invalid = this.invalidMessage == "$_unset_$" ? this.messages.invalidMessage :
                                !this.invalidMessage ? this.promptMessage : this.invalidMessage;
                        var missing = this.missingMessage == "$_unset_$" ? this.messages.missingMessage :
                                !this.missingMessage ? invalid : this.missingMessage;
                        return (this.required && this._isEmpty(this.textbox.value)) ? missing : invalid; // String
                },

                getPromptMessage: function(/*Boolean*/ /*===== isFocused =====*/){
                        // summary:
                        //              Return a hint message to show when widget is first focused
                        // tags:
                        //              protected
                        return this.promptMessage; // String
                },

                _maskValidSubsetError: true,
                validate: function(/*Boolean*/ isFocused){
                        // summary:
                        //              Called by oninit, onblur, and onkeypress.
                        // description:
                        //              Show missing or invalid messages if appropriate, and highlight textbox field.
                        // tags:
                        //              protected
                        var message = "";
                        var isValid = this.disabled || this.isValid(isFocused);
                        if(isValid){ this._maskValidSubsetError = true; }
                        var isEmpty = this._isEmpty(this.textbox.value);
                        var isValidSubset = !isValid && isFocused && this._isValidSubset();
                        this._set("state", isValid ? "" : (((((!this._hasBeenBlurred || isFocused) && isEmpty) || isValidSubset) && (this._maskValidSubsetError || (isValidSubset && !this._hasBeenBlurred && isFocused))) ? "Incomplete" : "Error"));
                        this.focusNode.setAttribute("aria-invalid", isValid ? "false" : "true");

                        if(this.state == "Error"){
                                this._maskValidSubsetError = isFocused && isValidSubset; // we want the error to show up after a blur and refocus
                                message = this.getErrorMessage(isFocused);
                        }else if(this.state == "Incomplete"){
                                message = this.getPromptMessage(isFocused); // show the prompt whenever the value is not yet complete
                                this._maskValidSubsetError = !this._hasBeenBlurred || isFocused; // no Incomplete warnings while focused
                        }else if(isEmpty){
                                message = this.getPromptMessage(isFocused); // show the prompt whenever there's no error and no text
                        }
                        this.set("message", message);

                        return isValid;
                },

                displayMessage: function(/*String*/ message){
                        // summary:
                        //              Overridable method to display validation errors/hints.
                        //              By default uses a tooltip.
                        // tags:
                        //              extension
                        if(message && this.focused){
                                Tooltip.show(message, this.domNode, this.tooltipPosition, !this.isLeftToRight());
                        }else{
                                Tooltip.hide(this.domNode);
                        }
                },

                _refreshState: function(){
                        // Overrides TextBox._refreshState()
                        if(this._created){
                                this.validate(this.focused);
                        }
                        this.inherited(arguments);
                },

                //////////// INITIALIZATION METHODS ///////////////////////////////////////

                constructor: function(params /*===== , srcNodeRef =====*/){
                        // summary:
                        //              Create the widget.
                        // params: Object|null
                        //              Hash of initialization parameters for widget, including scalar values (like title, duration etc.)
                        //              and functions, typically callbacks like onClick.
                        //              The hash can contain any of the widget's properties, excluding read-only properties.
                        // srcNodeRef: DOMNode|String?
                        //              If a srcNodeRef (DOM node) is specified, replace srcNodeRef with my generated DOM tree.

                        this.constraints = {};
                        this.baseClass += ' dijitValidationTextBox';
                },

                startup: function(){
                        this.inherited(arguments);
                        this._refreshState(); // after all _set* methods have run
                },

                _setConstraintsAttr: function(/*__Constraints*/ constraints){
                        if(!constraints.locale && this.lang){
                                constraints.locale = this.lang;
                        }
                        this._set("constraints", constraints);
                        this._refreshState();
                },

                _setPatternAttr: function(/*String|Function*/ pattern){
                        this._set("pattern", pattern); // don't set on INPUT to avoid native HTML5 validation
                },

                _getPatternAttr: function(/*__Constraints*/ constraints){
                        // summary:
                        //              Hook to get the current regExp and to compute the partial validation RE.
                        var p = this.pattern;
                        var type = (typeof p).toLowerCase();
                        if(type == "function"){
                                p = this.pattern(constraints || this.constraints);
                        }
                        if(p != this._lastRegExp){
                                var partialre = "";
                                this._lastRegExp = p;
                                // parse the regexp and produce a new regexp that matches valid subsets
                                // if the regexp is .* then there's no use in matching subsets since everything is valid
                                if(p != ".*"){
                                        p.replace(/\\.|\[\]|\[.*?[^\\]{1}\]|\{.*?\}|\(\?[=:!]|./g,
                                        function(re){
                                                switch(re.charAt(0)){
                                                        case '{':
                                                        case '+':
                                                        case '?':
                                                        case '*':
                                                        case '^':
                                                        case '$':
                                                        case '|':
                                                        case '(':
                                                                partialre += re;
                                                                break;
                                                        case ")":
                                                                partialre += "|$)";
                                                                break;
                                                         default:
                                                                partialre += "(?:"+re+"|$)";
                                                                break;
                                                }
                                        });
                                }
                                try{ // this is needed for now since the above regexp parsing needs more test verification
                                        "".search(partialre);
                                }catch(e){ // should never be here unless the original RE is bad or the parsing is bad
                                        partialre = this.pattern;
                                        console.warn('RegExp error in ' + this.declaredClass + ': ' + this.pattern);
                                } // should never be here unless the original RE is bad or the parsing is bad
                                this._partialre = "^(?:" + partialre + ")$";
                        }
                        return p;
                },

                postMixInProperties: function(){
                        this.inherited(arguments);
                        this.messages = i18n.getLocalization("dijit.form", "validate", this.lang);
                        this._setConstraintsAttr(this.constraints); // this needs to happen now (and later) due to codependency on _set*Attr calls attachPoints
                },

                _setDisabledAttr: function(/*Boolean*/ value){
                        this.inherited(arguments);      // call FormValueWidget._setDisabledAttr()
                        this._refreshState();
                },

                _setRequiredAttr: function(/*Boolean*/ value){
                        this._set("required", value);
                        this.focusNode.setAttribute("aria-required", value);
                        this._refreshState();
                },

                _setMessageAttr: function(/*String*/ message){
                        this._set("message", message);
                        this.displayMessage(message);
                },

                reset:function(){
                        // Overrides dijit/form/TextBox.reset() by also
                        // hiding errors about partial matches
                        this._maskValidSubsetError = true;
                        this.inherited(arguments);
                },

                _onBlur: function(){
                        // the message still exists but for back-compat, and to erase the tooltip
                        // (if the message is being displayed as a tooltip), call displayMessage('')
                        this.displayMessage('');

                        this.inherited(arguments);
                }
        });
});

},
'dijit/_base/typematic':function(){
define("dijit/_base/typematic", ["../typematic"], function(){

        /*=====
        return {
                // summary:
                //              Deprecated, for back-compat, just loads top level module
        };
        =====*/

});

},
'dijit/layout/BorderContainer':function(){
define("dijit/layout/BorderContainer", [
        "dojo/_base/array", // array.filter array.forEach array.map
        "dojo/cookie", // cookie
        "dojo/_base/declare", // declare
        "dojo/dom-class", // domClass.add domClass.remove domClass.toggle
        "dojo/dom-construct", // domConstruct.destroy domConstruct.place
        "dojo/dom-geometry", // domGeometry.marginBox
        "dojo/dom-style", // domStyle.style
        "dojo/_base/event", // event.stop
        "dojo/keys",
        "dojo/_base/lang", // lang.getObject lang.hitch
        "dojo/on",
        "dojo/touch",
        "../_WidgetBase",
        "../_Widget",
        "../_TemplatedMixin",
        "./_LayoutWidget",
        "./utils"               // layoutUtils.layoutChildren
], function(array, cookie, declare, domClass, domConstruct, domGeometry, domStyle, event, keys, lang, on, touch,
                        _WidgetBase, _Widget, _TemplatedMixin, _LayoutWidget, layoutUtils){

// module:
//              dijit/layout/BorderContainer

var _Splitter = declare("dijit.layout._Splitter", [_Widget, _TemplatedMixin ],
{
        // summary:
        //              A draggable spacer between two items in a `dijit/layout/BorderContainer`.
        // description:
        //              This is instantiated by `dijit/layout/BorderContainer`.  Users should not
        //              create it directly.
        // tags:
        //              private

/*=====
        // container: [const] dijit/layout/BorderContainer
        //              Pointer to the parent BorderContainer
        container: null,

        // child: [const] dijit/layout/_LayoutWidget
        //              Pointer to the pane associated with this splitter
        child: null,

        // region: [const] String
        //              Region of pane associated with this splitter.
        //              "top", "bottom", "left", "right".
        region: null,
=====*/

        // live: [const] Boolean
        //              If true, the child's size changes and the child widget is redrawn as you drag the splitter;
        //              otherwise, the size doesn't change until you drop the splitter (by mouse-up)
        live: true,

        templateString: '<div class="dijitSplitter" data-dojo-attach-event="onkeypress:_onKeyPress,press:_startDrag,onmouseenter:_onMouse,onmouseleave:_onMouse" tabIndex="0" role="separator"><div class="dijitSplitterThumb"></div></div>',

        constructor: function(){
                this._handlers = [];
        },

        postMixInProperties: function(){
                this.inherited(arguments);

                this.horizontal = /top|bottom/.test(this.region);
                this._factor = /top|left/.test(this.region) ? 1 : -1;
                this._cookieName = this.container.id + "_" + this.region;
        },

        buildRendering: function(){
                this.inherited(arguments);

                domClass.add(this.domNode, "dijitSplitter" + (this.horizontal ? "H" : "V"));

                if(this.container.persist){
                        // restore old size
                        var persistSize = cookie(this._cookieName);
                        if(persistSize){
                                this.child.domNode.style[this.horizontal ? "height" : "width"] = persistSize;
                        }
                }
        },

        _computeMaxSize: function(){
                // summary:
                //              Return the maximum size that my corresponding pane can be set to

                var dim = this.horizontal ? 'h' : 'w',
                        childSize = domGeometry.getMarginBox(this.child.domNode)[dim],
                        center = array.filter(this.container.getChildren(), function(child){ return child.region == "center";})[0],
                        spaceAvailable = domGeometry.getMarginBox(center.domNode)[dim]; // can expand until center is crushed to 0

                return Math.min(this.child.maxSize, childSize + spaceAvailable);
        },

        _startDrag: function(e){
                if(!this.cover){
                        this.cover = domConstruct.place("<div class=dijitSplitterCover></div>", this.child.domNode, "after");
                }
                domClass.add(this.cover, "dijitSplitterCoverActive");

                // Safeguard in case the stop event was missed.  Shouldn't be necessary if we always get the mouse up.
                if(this.fake){ domConstruct.destroy(this.fake); }
                if(!(this._resize = this.live)){ //TODO: disable live for IE6?
                        // create fake splitter to display at old position while we drag
                        (this.fake = this.domNode.cloneNode(true)).removeAttribute("id");
                        domClass.add(this.domNode, "dijitSplitterShadow");
                        domConstruct.place(this.fake, this.domNode, "after");
                }
                domClass.add(this.domNode, "dijitSplitterActive dijitSplitter" + (this.horizontal ? "H" : "V") + "Active");
                if(this.fake){
                        domClass.remove(this.fake, "dijitSplitterHover dijitSplitter" + (this.horizontal ? "H" : "V") + "Hover");
                }

                //Performance: load data info local vars for onmousevent function closure
                var factor = this._factor,
                        isHorizontal = this.horizontal,
                        axis = isHorizontal ? "pageY" : "pageX",
                        pageStart = e[axis],
                        splitterStyle = this.domNode.style,
                        dim = isHorizontal ? 'h' : 'w',
                        childStart = domGeometry.getMarginBox(this.child.domNode)[dim],
                        max = this._computeMaxSize(),
                        min = this.child.minSize || 20,
                        region = this.region,
                        splitterAttr = region == "top" || region == "bottom" ? "top" : "left",  // style attribute of splitter to adjust
                        splitterStart = parseInt(splitterStyle[splitterAttr], 10),
                        resize = this._resize,
                        layoutFunc = lang.hitch(this.container, "_layoutChildren", this.child.id),
                        de = this.ownerDocument;

                this._handlers = this._handlers.concat([
                        on(de, touch.move, this._drag = function(e, forceResize){
                                var delta = e[axis] - pageStart,
                                        childSize = factor * delta + childStart,
                                        boundChildSize = Math.max(Math.min(childSize, max), min);

                                if(resize || forceResize){
                                        layoutFunc(boundChildSize);
                                }
                                // TODO: setting style directly (usually) sets content box size, need to set margin box size
                                splitterStyle[splitterAttr] = delta + splitterStart + factor*(boundChildSize - childSize) + "px";
                        }),
                        on(de, "dragstart", event.stop),
                        on(this.ownerDocumentBody, "selectstart", event.stop),
                        on(de, touch.release, lang.hitch(this, "_stopDrag"))
                ]);
                event.stop(e);
        },

        _onMouse: function(e){
                // summary:
                //              Handler for onmouseenter / onmouseleave events
                var o = (e.type == "mouseover" || e.type == "mouseenter");
                domClass.toggle(this.domNode, "dijitSplitterHover", o);
                domClass.toggle(this.domNode, "dijitSplitter" + (this.horizontal ? "H" : "V") + "Hover", o);
        },

        _stopDrag: function(e){
                try{
                        if(this.cover){
                                domClass.remove(this.cover, "dijitSplitterCoverActive");
                        }
                        if(this.fake){ domConstruct.destroy(this.fake); }
                        domClass.remove(this.domNode, "dijitSplitterActive dijitSplitter"
                                + (this.horizontal ? "H" : "V") + "Active dijitSplitterShadow");
                        this._drag(e); //TODO: redundant with onmousemove?
                        this._drag(e, true);
                }finally{
                        this._cleanupHandlers();
                        delete this._drag;
                }

                if(this.container.persist){
                        cookie(this._cookieName, this.child.domNode.style[this.horizontal ? "height" : "width"], {expires:365});
                }
        },

        _cleanupHandlers: function(){
                var h;
                while(h = this._handlers.pop()){ h.remove(); }
        },

        _onKeyPress: function(/*Event*/ e){
                // should we apply typematic to this?
                this._resize = true;
                var horizontal = this.horizontal;
                var tick = 1;
                switch(e.charOrCode){
                        case horizontal ? keys.UP_ARROW : keys.LEFT_ARROW:
                                tick *= -1;
//                              break;
                        case horizontal ? keys.DOWN_ARROW : keys.RIGHT_ARROW:
                                break;
                        default:
//                              this.inherited(arguments);
                                return;
                }
                var childSize = domGeometry.getMarginSize(this.child.domNode)[ horizontal ? 'h' : 'w' ] + this._factor * tick;
                this.container._layoutChildren(this.child.id, Math.max(Math.min(childSize, this._computeMaxSize()), this.child.minSize));
                event.stop(e);
        },

        destroy: function(){
                this._cleanupHandlers();
                delete this.child;
                delete this.container;
                delete this.cover;
                delete this.fake;
                this.inherited(arguments);
        }
});

var _Gutter = declare("dijit.layout._Gutter", [_Widget, _TemplatedMixin],
{
        // summary:
        //              Just a spacer div to separate side pane from center pane.
        //              Basically a trick to lookup the gutter/splitter width from the theme.
        // description:
        //              Instantiated by `dijit/layout/BorderContainer`.  Users should not
        //              create directly.
        // tags:
        //              private

        templateString: '<div class="dijitGutter" role="presentation"></div>',

        postMixInProperties: function(){
                this.inherited(arguments);
                this.horizontal = /top|bottom/.test(this.region);
        },

        buildRendering: function(){
                this.inherited(arguments);
                domClass.add(this.domNode, "dijitGutter" + (this.horizontal ? "H" : "V"));
        }
});

var BorderContainer = declare("dijit.layout.BorderContainer", _LayoutWidget, {
        // summary:
        //              Provides layout in up to 5 regions, a mandatory center with optional borders along its 4 sides.
        // description:
        //              A BorderContainer is a box with a specified size, such as style="width: 500px; height: 500px;",
        //              that contains a child widget marked region="center" and optionally children widgets marked
        //              region equal to "top", "bottom", "leading", "trailing", "left" or "right".
        //              Children along the edges will be laid out according to width or height dimensions and may
        //              include optional splitters (splitter="true") to make them resizable by the user.  The remaining
        //              space is designated for the center region.
        //
        //              The outer size must be specified on the BorderContainer node.  Width must be specified for the sides
        //              and height for the top and bottom, respectively.  No dimensions should be specified on the center;
        //              it will fill the remaining space.  Regions named "leading" and "trailing" may be used just like
        //              "left" and "right" except that they will be reversed in right-to-left environments.
        //
        //              For complex layouts, multiple children can be specified for a single region.   In this case, the
        //              layoutPriority flag on the children determines which child is closer to the edge (low layoutPriority)
        //              and which child is closer to the center (high layoutPriority).   layoutPriority can also be used
        //              instead of the design attribute to control layout precedence of horizontal vs. vertical panes.
        //
        //              See `BorderContainer.ChildWidgetProperties` for details on the properties that can be set on
        //              children of a `BorderContainer`.
        // example:
        // |    <div data-dojo-type="dijit/layout/BorderContainer" data-dojo-props="design: 'sidebar', gutters: false"
        // |            style="width: 400px; height: 300px;">
        // |            <div data-dojo-type="dijit/layout/ContentPane" data-dojo-props="region: 'top'">header text</div>
        // |            <div data-dojo-type="dijit/layout/ContentPane" data-dojo-props="region: 'right', splitter: true" style="width: 200px;">table of contents</div>
        // |            <div data-dojo-type="dijit/layout/ContentPane" data-dojo-props="region: 'center'">client area</div>
        // |    </div>

        // design: String
        //              Which design is used for the layout:
        //
        //              - "headline" (default) where the top and bottom extend the full width of the container
        //              - "sidebar" where the left and right sides extend from top to bottom.
        design: "headline",

        // gutters: [const] Boolean
        //              Give each pane a border and margin.
        //              Margin determined by domNode.paddingLeft.
        //              When false, only resizable panes have a gutter (i.e. draggable splitter) for resizing.
        gutters: true,

        // liveSplitters: [const] Boolean
        //              Specifies whether splitters resize as you drag (true) or only upon mouseup (false)
        liveSplitters: true,

        // persist: Boolean
        //              Save splitter positions in a cookie.
        persist: false,

        baseClass: "dijitBorderContainer",

        // _splitterClass: Function||String
        //              Optional hook to override the default Splitter widget used by BorderContainer
        _splitterClass: _Splitter,

        postMixInProperties: function(){
                // change class name to indicate that BorderContainer is being used purely for
                // layout (like LayoutContainer) rather than for pretty formatting.
                if(!this.gutters){
                        this.baseClass += "NoGutter";
                }
                this.inherited(arguments);
        },

        startup: function(){
                if(this._started){ return; }
                array.forEach(this.getChildren(), this._setupChild, this);
                this.inherited(arguments);
        },

        _setupChild: function(/*dijit/_WidgetBase*/ child){
                // Override _LayoutWidget._setupChild().

                var region = child.region;
                if(region){
                        this.inherited(arguments);

                        domClass.add(child.domNode, this.baseClass+"Pane");

                        var ltr = this.isLeftToRight();
                        if(region == "leading"){ region = ltr ? "left" : "right"; }
                        if(region == "trailing"){ region = ltr ? "right" : "left"; }

                        // Create draggable splitter for resizing pane,
                        // or alternately if splitter=false but BorderContainer.gutters=true then
                        // insert dummy div just for spacing
                        if(region != "center" && (child.splitter || this.gutters) && !child._splitterWidget){
                                var _Splitter = child.splitter ? this._splitterClass : _Gutter;
                                if(lang.isString(_Splitter)){
                                        _Splitter = lang.getObject(_Splitter);  // for back-compat, remove in 2.0
                                }
                                var splitter = new _Splitter({
                                        id: child.id + "_splitter",
                                        container: this,
                                        child: child,
                                        region: region,
                                        live: this.liveSplitters
                                });
                                splitter.isSplitter = true;
                                child._splitterWidget = splitter;

                                domConstruct.place(splitter.domNode, child.domNode, "after");

                                // Splitters aren't added as Contained children, so we need to call startup explicitly
                                splitter.startup();
                        }
                        child.region = region;  // TODO: technically wrong since it overwrites "trailing" with "left" etc.
                }
        },

        layout: function(){
                // Implement _LayoutWidget.layout() virtual method.
                this._layoutChildren();
        },

        addChild: function(/*dijit/_WidgetBase*/ child, /*Integer?*/ insertIndex){
                // Override _LayoutWidget.addChild().
                this.inherited(arguments);
                if(this._started){
                        this.layout(); //OPT
                }
        },

        removeChild: function(/*dijit/_WidgetBase*/ child){
                // Override _LayoutWidget.removeChild().

                var region = child.region;
                var splitter = child._splitterWidget;
                if(splitter){
                        splitter.destroy();
                        delete child._splitterWidget;
                }
                this.inherited(arguments);

                if(this._started){
                        this._layoutChildren();
                }
                // Clean up whatever style changes we made to the child pane.
                // Unclear how height and width should be handled.
                domClass.remove(child.domNode, this.baseClass+"Pane");
                domStyle.set(child.domNode, {
                        top: "auto",
                        bottom: "auto",
                        left: "auto",
                        right: "auto",
                        position: "static"
                });
                domStyle.set(child.domNode, region == "top" || region == "bottom" ? "width" : "height", "auto");
        },

        getChildren: function(){
                // Override _LayoutWidget.getChildren() to only return real children, not the splitters.
                return array.filter(this.inherited(arguments), function(widget){
                        return !widget.isSplitter;
                });
        },

        // TODO: remove in 2.0
        getSplitter: function(/*String*/region){
                // summary:
                //              Returns the widget responsible for rendering the splitter associated with region
                // tags:
                //              deprecated
                return array.filter(this.getChildren(), function(child){
                        return child.region == region;
                })[0]._splitterWidget;
        },

        resize: function(newSize, currentSize){
                // Overrides _LayoutWidget.resize().

                // resetting potential padding to 0px to provide support for 100% width/height + padding
                // TODO: this hack doesn't respect the box model and is a temporary fix
                if(!this.cs || !this.pe){
                        var node = this.domNode;
                        this.cs = domStyle.getComputedStyle(node);
                        this.pe = domGeometry.getPadExtents(node, this.cs);
                        this.pe.r = domStyle.toPixelValue(node, this.cs.paddingRight);
                        this.pe.b = domStyle.toPixelValue(node, this.cs.paddingBottom);

                        domStyle.set(node, "padding", "0px");
                }

                this.inherited(arguments);
        },

        _layoutChildren: function(/*String?*/ changedChildId, /*Number?*/ changedChildSize){
                // summary:
                //              This is the main routine for setting size/position of each child.
                // description:
                //              With no arguments, measures the height of top/bottom panes, the width
                //              of left/right panes, and then sizes all panes accordingly.
                //
                //              With changedRegion specified (as "left", "top", "bottom", or "right"),
                //              it changes that region's width/height to changedRegionSize and
                //              then resizes other regions that were affected.
                // changedChildId:
                //              Id of the child which should be resized because splitter was dragged.
                // changedChildSize:
                //              The new width/height (in pixels) to make specified child

                if(!this._borderBox || !this._borderBox.h){
                        // We are currently hidden, or we haven't been sized by our parent yet.
                        // Abort.   Someone will resize us later.
                        return;
                }

                // Generate list of wrappers of my children in the order that I want layoutChildren()
                // to process them (i.e. from the outside to the inside)
                var wrappers = array.map(this.getChildren(), function(child, idx){
                        return {
                                pane: child,
                                weight: [
                                        child.region == "center" ? Infinity : 0,
                                        child.layoutPriority,
                                        (this.design == "sidebar" ? 1 : -1) * (/top|bottom/.test(child.region) ? 1 : -1),
                                        idx
                                ]
                        };
                }, this);
                wrappers.sort(function(a, b){
                        var aw = a.weight, bw = b.weight;
                        for(var i=0; i<aw.length; i++){
                                if(aw[i] != bw[i]){
                                        return aw[i] - bw[i];
                                }
                        }
                        return 0;
                });

                // Make new list, combining the externally specified children with splitters and gutters
                var childrenAndSplitters = [];
                array.forEach(wrappers, function(wrapper){
                        var pane = wrapper.pane;
                        childrenAndSplitters.push(pane);
                        if(pane._splitterWidget){
                                childrenAndSplitters.push(pane._splitterWidget);
                        }
                });

                // Compute the box in which to lay out my children
                var dim = {
                        l: this.pe.l,
                        t: this.pe.t,
                        w: this._borderBox.w - this.pe.w,
                        h: this._borderBox.h - this.pe.h
                };

                // Layout the children, possibly changing size due to a splitter drag
                layoutUtils.layoutChildren(this.domNode, dim, childrenAndSplitters,
                        changedChildId, changedChildSize);
        },

        destroyRecursive: function(){
                // Destroy splitters first, while getChildren() still works
                array.forEach(this.getChildren(), function(child){
                        var splitter = child._splitterWidget;
                        if(splitter){
                                splitter.destroy();
                        }
                        delete child._splitterWidget;
                });

                // Then destroy the real children, and myself
                this.inherited(arguments);
        }
});

BorderContainer.ChildWidgetProperties = {
        // summary:
        //              These properties can be specified for the children of a BorderContainer.

        // region: [const] String
        //              Values: "top", "bottom", "leading", "trailing", "left", "right", "center".
        //              See the `dijit/layout/BorderContainer` description for details.
        region: '',

        // layoutPriority: [const] Number
        //              Children with a higher layoutPriority will be placed closer to the BorderContainer center,
        //              between children with a lower layoutPriority.
        layoutPriority: 0,

        // splitter: [const] Boolean
        //              Parameter for children where region != "center".
        //              If true, enables user to resize the widget by putting a draggable splitter between
        //              this widget and the region=center widget.
        splitter: false,

        // minSize: [const] Number
        //              Specifies a minimum size (in pixels) for this widget when resized by a splitter.
        minSize: 0,

        // maxSize: [const] Number
        //              Specifies a maximum size (in pixels) for this widget when resized by a splitter.
        maxSize: Infinity
};

// Since any widget can be specified as a LayoutContainer child, mix it
// into the base widget class.  (This is a hack, but it's effective.)
// This is for the benefit of the parser.   Remove for 2.0.  Also, hide from doc viewer.
lang.extend(_WidgetBase, /*===== {} || =====*/ BorderContainer.ChildWidgetProperties);

// For monkey patching
BorderContainer._Splitter = _Splitter;
BorderContainer._Gutter = _Gutter;

return BorderContainer;
});

},
'dijit/_base':function(){
define("dijit/_base", [
        "./main",
        "./a11y",       // used to be in dijit/_base/manager
        "./WidgetSet",  // used to be in dijit/_base/manager
        "./_base/focus",
        "./_base/manager",
        "./_base/place",
        "./_base/popup",
        "./_base/scroll",
        "./_base/sniff",
        "./_base/typematic",
        "./_base/wai",
        "./_base/window"
], function(dijit){

        // module:
        //              dijit/_base

        /*=====
        return {
                // summary:
                //              Includes all the modules in dijit/_base
        };
        =====*/

        return dijit._base;
});

},
'dojo/window':function(){
define("dojo/window", ["./_base/lang", "./sniff", "./_base/window", "./dom", "./dom-geometry", "./dom-style"],
        function(lang, has, baseWindow, dom, geom, style){

        // module:
        //              dojo/window

        var window = {
                // summary:
                //              TODOC

                getBox: function(/*Document?*/ doc){
                        // summary:
                        //              Returns the dimensions and scroll position of the viewable area of a browser window

                        doc = doc || baseWindow.doc;

                        var
                                scrollRoot = (doc.compatMode == 'BackCompat') ? baseWindow.body(doc) : doc.documentElement,
                                // get scroll position
                                scroll = geom.docScroll(doc), // scrollRoot.scrollTop/Left should work
                                w, h;

                        if(has("touch")){ // if(scrollbars not supported)
                                var uiWindow = window.get(doc);   // use UI window, not dojo.global window
                                // on mobile, scrollRoot.clientHeight <= uiWindow.innerHeight <= scrollRoot.offsetHeight, return uiWindow.innerHeight
                                w = uiWindow.innerWidth || scrollRoot.clientWidth; // || scrollRoot.clientXXX probably never evaluated
                                h = uiWindow.innerHeight || scrollRoot.clientHeight;
                        }else{
                                // on desktops, scrollRoot.clientHeight <= scrollRoot.offsetHeight <= uiWindow.innerHeight, return scrollRoot.clientHeight
                                // uiWindow.innerWidth/Height includes the scrollbar and cannot be used
                                w = scrollRoot.clientWidth;
                                h = scrollRoot.clientHeight;
                        }
                        return {
                                l: scroll.x,
                                t: scroll.y,
                                w: w,
                                h: h
                        };
                },

                get: function(/*Document*/ doc){
                        // summary:
                        //              Get window object associated with document doc.
                        // doc:
                        //              The document to get the associated window for.

                        // In some IE versions (at least 6.0), document.parentWindow does not return a
                        // reference to the real window object (maybe a copy), so we must fix it as well
                        // We use IE specific execScript to attach the real window reference to
                        // document._parentWindow for later use
                        if(has("ie") && window !== document.parentWindow){
                                /*
                                In IE 6, only the variable "window" can be used to connect events (others
                                may be only copies).
                                */
                                doc.parentWindow.execScript("document._parentWindow = window;", "Javascript");
                                //to prevent memory leak, unset it after use
                                //another possibility is to add an onUnload handler which seems overkill to me (liucougar)
                                var win = doc._parentWindow;
                                doc._parentWindow = null;
                                return win;     //      Window
                        }

                        return doc.parentWindow || doc.defaultView;     //      Window
                },

                scrollIntoView: function(/*DomNode*/ node, /*Object?*/ pos){
                        // summary:
                        //              Scroll the passed node into view, if it is not already.

                        // don't rely on node.scrollIntoView working just because the function is there

                        try{ // catch unexpected/unrecreatable errors (#7808) since we can recover using a semi-acceptable native method
                                node = dom.byId(node);
                                var doc = node.ownerDocument || baseWindow.doc, // TODO: why baseWindow.doc?  Isn't node.ownerDocument always defined?
                                        body = baseWindow.body(doc),
                                        html = doc.documentElement || body.parentNode,
                                        isIE = has("ie"), isWK = has("webkit");
                                // if an untested browser, then use the native method
                                if((!(has("mozilla") || isIE || isWK || has("opera")) || node == body || node == html) && (typeof node.scrollIntoView != "undefined")){
                                        node.scrollIntoView(false); // short-circuit to native if possible
                                        return;
                                }
                                var backCompat = doc.compatMode == 'BackCompat',
                                        clientAreaRoot = (isIE >= 9 && "frameElement" in node.ownerDocument.parentWindow)
                                                ? ((html.clientHeight > 0 && html.clientWidth > 0 && (body.clientHeight == 0 || body.clientWidth == 0 || body.clientHeight > html.clientHeight || body.clientWidth > html.clientWidth)) ? html : body)
                                                : (backCompat ? body : html),
                                        scrollRoot = isWK ? body : clientAreaRoot,
                                        rootWidth = clientAreaRoot.clientWidth,
                                        rootHeight = clientAreaRoot.clientHeight,
                                        rtl = !geom.isBodyLtr(doc),
                                        nodePos = pos || geom.position(node),
                                        el = node.parentNode,
                                        isFixed = function(el){
                                                return ((isIE <= 6 || (isIE && backCompat))? false : (style.get(el, 'position').toLowerCase() == "fixed"));
                                        };
                                if(isFixed(node)){ return; } // nothing to do

                                while(el){
                                        if(el == body){ el = scrollRoot; }
                                        var elPos = geom.position(el),
                                                fixedPos = isFixed(el);

                                        if(el == scrollRoot){
                                                elPos.w = rootWidth; elPos.h = rootHeight;
                                                if(scrollRoot == html && isIE && rtl){ elPos.x += scrollRoot.offsetWidth-elPos.w; } // IE workaround where scrollbar causes negative x
                                                if(elPos.x < 0 || !isIE){ elPos.x = 0; } // IE can have values > 0
                                                if(elPos.y < 0 || !isIE){ elPos.y = 0; }
                                        }else{
                                                var pb = geom.getPadBorderExtents(el);
                                                elPos.w -= pb.w; elPos.h -= pb.h; elPos.x += pb.l; elPos.y += pb.t;
                                                var clientSize = el.clientWidth,
                                                        scrollBarSize = elPos.w - clientSize;
                                                if(clientSize > 0 && scrollBarSize > 0){
                                                        elPos.w = clientSize;
                                                        elPos.x += (rtl && (isIE || el.clientLeft > pb.l/*Chrome*/)) ? scrollBarSize : 0;
                                                }
                                                clientSize = el.clientHeight;
                                                scrollBarSize = elPos.h - clientSize;
                                                if(clientSize > 0 && scrollBarSize > 0){
                                                        elPos.h = clientSize;
                                                }
                                        }
                                        if(fixedPos){ // bounded by viewport, not parents
                                                if(elPos.y < 0){
                                                        elPos.h += elPos.y; elPos.y = 0;
                                                }
                                                if(elPos.x < 0){
                                                        elPos.w += elPos.x; elPos.x = 0;
                                                }
                                                if(elPos.y + elPos.h > rootHeight){
                                                        elPos.h = rootHeight - elPos.y;
                                                }
                                                if(elPos.x + elPos.w > rootWidth){
                                                        elPos.w = rootWidth - elPos.x;
                                                }
                                        }
                                        // calculate overflow in all 4 directions
                                        var l = nodePos.x - elPos.x, // beyond left: < 0
                                                t = nodePos.y - Math.max(elPos.y, 0), // beyond top: < 0
                                                r = l + nodePos.w - elPos.w, // beyond right: > 0
                                                bot = t + nodePos.h - elPos.h; // beyond bottom: > 0
                                        if(r * l > 0){
                                                var s = Math[l < 0? "max" : "min"](l, r);
                                                if(rtl && ((isIE == 8 && !backCompat) || isIE >= 9)){ s = -s; }
                                                nodePos.x += el.scrollLeft;
                                                el.scrollLeft += s;
                                                nodePos.x -= el.scrollLeft;
                                        }
                                        if(bot * t > 0){
                                                nodePos.y += el.scrollTop;
                                                el.scrollTop += Math[t < 0? "max" : "min"](t, bot);
                                                nodePos.y -= el.scrollTop;
                                        }
                                        el = (el != scrollRoot) && !fixedPos && el.parentNode;
                                }
                        }catch(error){
                                console.error('scrollIntoView: ' + error);
                                node.scrollIntoView(false);
                        }
                }
        };

         1  && lang.setObject("dojo.window", window);

        return window;
});

},
'dojo/number':function(){
define("dojo/number", [/*===== "./_base/declare", =====*/ "./_base/lang", "./i18n", "./i18n!./cldr/nls/number", "./string", "./regexp"],
        function(/*===== declare, =====*/ lang, i18n, nlsNumber, dstring, dregexp){

// module:
//              dojo/number

var number = {
        // summary:
        //              localized formatting and parsing routines for Number
};
lang.setObject("dojo.number", number);

/*=====
number.__FormatOptions = declare(null, {
        // pattern: String?
        //              override [formatting pattern](http://www.unicode.org/reports/tr35/#Number_Format_Patterns)
        //              with this string.  Default value is based on locale.  Overriding this property will defeat
        //              localization.  Literal characters in patterns are not supported.
        // type: String?
        //              choose a format type based on the locale from the following:
        //              decimal, scientific (not yet supported), percent, currency. decimal by default.
        // places: Number?
        //              fixed number of decimal places to show.  This overrides any
        //              information in the provided pattern.
        // round: Number?
        //              5 rounds to nearest .5; 0 rounds to nearest whole (default). -1
        //              means do not round.
        // locale: String?
        //              override the locale used to determine formatting rules
        // fractional: Boolean?
        //              If false, show no decimal places, overriding places and pattern settings.
});
=====*/

number.format = function(/*Number*/ value, /*number.__FormatOptions?*/ options){
        // summary:
        //              Format a Number as a String, using locale-specific settings
        // description:
        //              Create a string from a Number using a known localized pattern.
        //              Formatting patterns appropriate to the locale are chosen from the
        //              [Common Locale Data Repository](http://unicode.org/cldr) as well as the appropriate symbols and
        //              delimiters.
        //              If value is Infinity, -Infinity, or is not a valid JavaScript number, return null.
        // value:
        //              the number to be formatted

        options = lang.mixin({}, options || {});
        var locale = i18n.normalizeLocale(options.locale),
                bundle = i18n.getLocalization("dojo.cldr", "number", locale);
        options.customs = bundle;
        var pattern = options.pattern || bundle[(options.type || "decimal") + "Format"];
        if(isNaN(value) || Math.abs(value) == Infinity){ return null; } // null
        return number._applyPattern(value, pattern, options); // String
};

//number._numberPatternRE = /(?:[#0]*,?)*[#0](?:\.0*#*)?/; // not precise, but good enough
number._numberPatternRE = /[#0,]*[#0](?:\.0*#*)?/; // not precise, but good enough

number._applyPattern = function(/*Number*/ value, /*String*/ pattern, /*number.__FormatOptions?*/ options){
        // summary:
        //              Apply pattern to format value as a string using options. Gives no
        //              consideration to local customs.
        // value:
        //              the number to be formatted.
        // pattern:
        //              a pattern string as described by
        //              [unicode.org TR35](http://www.unicode.org/reports/tr35/#Number_Format_Patterns)
        // options: number.__FormatOptions?
        //              _applyPattern is usually called via `dojo/number.format()` which
        //              populates an extra property in the options parameter, "customs".
        //              The customs object specifies group and decimal parameters if set.

        //TODO: support escapes
        options = options || {};
        var group = options.customs.group,
                decimal = options.customs.decimal,
                patternList = pattern.split(';'),
                positivePattern = patternList[0];
        pattern = patternList[(value < 0) ? 1 : 0] || ("-" + positivePattern);

        //TODO: only test against unescaped
        if(pattern.indexOf('%') != -1){
                value *= 100;
        }else if(pattern.indexOf('\u2030') != -1){
                value *= 1000; // per mille
        }else if(pattern.indexOf('\u00a4') != -1){
                group = options.customs.currencyGroup || group;//mixins instead?
                decimal = options.customs.currencyDecimal || decimal;// Should these be mixins instead?
                pattern = pattern.replace(/\u00a4{1,3}/, function(match){
                        var prop = ["symbol", "currency", "displayName"][match.length-1];
                        return options[prop] || options.currency || "";
                });
        }else if(pattern.indexOf('E') != -1){
                throw new Error("exponential notation not supported");
        }

        //TODO: support @ sig figs?
        var numberPatternRE = number._numberPatternRE;
        var numberPattern = positivePattern.match(numberPatternRE);
        if(!numberPattern){
                throw new Error("unable to find a number expression in pattern: "+pattern);
        }
        if(options.fractional === false){ options.places = 0; }
        return pattern.replace(numberPatternRE,
                number._formatAbsolute(value, numberPattern[0], {decimal: decimal, group: group, places: options.places, round: options.round}));
};

number.round = function(/*Number*/ value, /*Number?*/ places, /*Number?*/ increment){
        // summary:
        //              Rounds to the nearest value with the given number of decimal places, away from zero
        // description:
        //              Rounds to the nearest value with the given number of decimal places, away from zero if equal.
        //              Similar to Number.toFixed(), but compensates for browser quirks. Rounding can be done by
        //              fractional increments also, such as the nearest quarter.
        //              NOTE: Subject to floating point errors.  See dojox/math/round for experimental workaround.
        // value:
        //              The number to round
        // places:
        //              The number of decimal places where rounding takes place.  Defaults to 0 for whole rounding.
        //              Must be non-negative.
        // increment:
        //              Rounds next place to nearest value of increment/10.  10 by default.
        // example:
        // |    >>> number.round(-0.5)
        // |    -1
        // |    >>> number.round(162.295, 2)
        // |    162.29  // note floating point error.  Should be 162.3
        // |    >>> number.round(10.71, 0, 2.5)
        // |    10.75
        var factor = 10 / (increment || 10);
        return (factor * +value).toFixed(places) / factor; // Number
};

if((0.9).toFixed() == 0){
        // (isIE) toFixed() bug workaround: Rounding fails on IE when most significant digit
        // is just after the rounding place and is >=5
        var round = number.round;
        number.round = function(v, p, m){
                var d = Math.pow(10, -p || 0), a = Math.abs(v);
                if(!v || a >= d){
                        d = 0;
                }else{
                        a /= d;
                        if(a < 0.5 || a >= 0.95){
                                d = 0;
                        }
                }
                return round(v, p, m) + (v > 0 ? d : -d);
        };

        // Use "doc hint" so the doc parser ignores this new definition of round(), and uses the one above.
        /*===== number.round = round; =====*/
}

/*=====
number.__FormatAbsoluteOptions = declare(null, {
        // decimal: String?
        //              the decimal separator
        // group: String?
        //              the group separator
        // places: Number|String?
        //              number of decimal places.  the range "n,m" will format to m places.
        // round: Number?
        //              5 rounds to nearest .5; 0 rounds to nearest whole (default). -1
        //              means don't round.
});
=====*/

number._formatAbsolute = function(/*Number*/ value, /*String*/ pattern, /*number.__FormatAbsoluteOptions?*/ options){
        // summary:
        //              Apply numeric pattern to absolute value using options. Gives no
        //              consideration to local customs.
        // value:
        //              the number to be formatted, ignores sign
        // pattern:
        //              the number portion of a pattern (e.g. `#,##0.00`)
        options = options || {};
        if(options.places === true){options.places=0;}
        if(options.places === Infinity){options.places=6;} // avoid a loop; pick a limit

        var patternParts = pattern.split("."),
                comma = typeof options.places == "string" && options.places.indexOf(","),
                maxPlaces = options.places;
        if(comma){
                maxPlaces = options.places.substring(comma + 1);
        }else if(!(maxPlaces >= 0)){
                maxPlaces = (patternParts[1] || []).length;
        }
        if(!(options.round < 0)){
                value = number.round(value, maxPlaces, options.round);
        }

        var valueParts = String(Math.abs(value)).split("."),
                fractional = valueParts[1] || "";
        if(patternParts[1] || options.places){
                if(comma){
                        options.places = options.places.substring(0, comma);
                }
                // Pad fractional with trailing zeros
                var pad = options.places !== undefined ? options.places : (patternParts[1] && patternParts[1].lastIndexOf("0") + 1);
                if(pad > fractional.length){
                        valueParts[1] = dstring.pad(fractional, pad, '0', true);
                }

                // Truncate fractional
                if(maxPlaces < fractional.length){
                        valueParts[1] = fractional.substr(0, maxPlaces);
                }
        }else{
                if(valueParts[1]){ valueParts.pop(); }
        }

        // Pad whole with leading zeros
        var patternDigits = patternParts[0].replace(',', '');
        pad = patternDigits.indexOf("0");
        if(pad != -1){
                pad = patternDigits.length - pad;
                if(pad > valueParts[0].length){
                        valueParts[0] = dstring.pad(valueParts[0], pad);
                }

                // Truncate whole
                if(patternDigits.indexOf("#") == -1){
                        valueParts[0] = valueParts[0].substr(valueParts[0].length - pad);
                }
        }

        // Add group separators
        var index = patternParts[0].lastIndexOf(','),
                groupSize, groupSize2;
        if(index != -1){
                groupSize = patternParts[0].length - index - 1;
                var remainder = patternParts[0].substr(0, index);
                index = remainder.lastIndexOf(',');
                if(index != -1){
                        groupSize2 = remainder.length - index - 1;
                }
        }
        var pieces = [];
        for(var whole = valueParts[0]; whole;){
                var off = whole.length - groupSize;
                pieces.push((off > 0) ? whole.substr(off) : whole);
                whole = (off > 0) ? whole.slice(0, off) : "";
                if(groupSize2){
                        groupSize = groupSize2;
                        delete groupSize2;
                }
        }
        valueParts[0] = pieces.reverse().join(options.group || ",");

        return valueParts.join(options.decimal || ".");
};

/*=====
number.__RegexpOptions = declare(null, {
        // pattern: String?
        //              override [formatting pattern](http://www.unicode.org/reports/tr35/#Number_Format_Patterns)
        //              with this string.  Default value is based on locale.  Overriding this property will defeat
        //              localization.
        // type: String?
        //              choose a format type based on the locale from the following:
        //              decimal, scientific (not yet supported), percent, currency. decimal by default.
        // locale: String?
        //              override the locale used to determine formatting rules
        // strict: Boolean?
        //              strict parsing, false by default.  Strict parsing requires input as produced by the format() method.
        //              Non-strict is more permissive, e.g. flexible on white space, omitting thousands separators
        // places: Number|String?
        //              number of decimal places to accept: Infinity, a positive number, or
        //              a range "n,m".  Defined by pattern or Infinity if pattern not provided.
});
=====*/
number.regexp = function(/*number.__RegexpOptions?*/ options){
        // summary:
        //              Builds the regular needed to parse a number
        // description:
        //              Returns regular expression with positive and negative match, group
        //              and decimal separators
        return number._parseInfo(options).regexp; // String
};

number._parseInfo = function(/*Object?*/ options){
        options = options || {};
        var locale = i18n.normalizeLocale(options.locale),
                bundle = i18n.getLocalization("dojo.cldr", "number", locale),
                pattern = options.pattern || bundle[(options.type || "decimal") + "Format"],
//TODO: memoize?
                group = bundle.group,
                decimal = bundle.decimal,
                factor = 1;

        if(pattern.indexOf('%') != -1){
                factor /= 100;
        }else if(pattern.indexOf('\u2030') != -1){
                factor /= 1000; // per mille
        }else{
                var isCurrency = pattern.indexOf('\u00a4') != -1;
                if(isCurrency){
                        group = bundle.currencyGroup || group;
                        decimal = bundle.currencyDecimal || decimal;
                }
        }

        //TODO: handle quoted escapes
        var patternList = pattern.split(';');
        if(patternList.length == 1){
                patternList.push("-" + patternList[0]);
        }

        var re = dregexp.buildGroupRE(patternList, function(pattern){
                pattern = "(?:"+dregexp.escapeString(pattern, '.')+")";
                return pattern.replace(number._numberPatternRE, function(format){
                        var flags = {
                                signed: false,
                                separator: options.strict ? group : [group,""],
                                fractional: options.fractional,
                                decimal: decimal,
                                exponent: false
                                },

                                parts = format.split('.'),
                                places = options.places;

                        // special condition for percent (factor != 1)
                        // allow decimal places even if not specified in pattern
                        if(parts.length == 1 && factor != 1){
                            parts[1] = "###";
                        }
                        if(parts.length == 1 || places === 0){
                                flags.fractional = false;
                        }else{
                                if(places === undefined){ places = options.pattern ? parts[1].lastIndexOf('0') + 1 : Infinity; }
                                if(places && options.fractional == undefined){flags.fractional = true;} // required fractional, unless otherwise specified
                                if(!options.places && (places < parts[1].length)){ places += "," + parts[1].length; }
                                flags.places = places;
                        }
                        var groups = parts[0].split(',');
                        if(groups.length > 1){
                                flags.groupSize = groups.pop().length;
                                if(groups.length > 1){
                                        flags.groupSize2 = groups.pop().length;
                                }
                        }
                        return "("+number._realNumberRegexp(flags)+")";
                });
        }, true);

        if(isCurrency){
                // substitute the currency symbol for the placeholder in the pattern
                re = re.replace(/([\s\xa0]*)(\u00a4{1,3})([\s\xa0]*)/g, function(match, before, target, after){
                        var prop = ["symbol", "currency", "displayName"][target.length-1],
                                symbol = dregexp.escapeString(options[prop] || options.currency || "");
                        before = before ? "[\\s\\xa0]" : "";
                        after = after ? "[\\s\\xa0]" : "";
                        if(!options.strict){
                                if(before){before += "*";}
                                if(after){after += "*";}
                                return "(?:"+before+symbol+after+")?";
                        }
                        return before+symbol+after;
                });
        }

//TODO: substitute localized sign/percent/permille/etc.?

        // normalize whitespace and return
        return {regexp: re.replace(/[\xa0 ]/g, "[\\s\\xa0]"), group: group, decimal: decimal, factor: factor}; // Object
};

/*=====
number.__ParseOptions = declare(null, {
        // pattern: String?
        //              override [formatting pattern](http://www.unicode.org/reports/tr35/#Number_Format_Patterns)
        //              with this string.  Default value is based on locale.  Overriding this property will defeat
        //              localization.  Literal characters in patterns are not supported.
        // type: String?
        //              choose a format type based on the locale from the following:
        //              decimal, scientific (not yet supported), percent, currency. decimal by default.
        // locale: String?
        //              override the locale used to determine formatting rules
        // strict: Boolean?
        //              strict parsing, false by default.  Strict parsing requires input as produced by the format() method.
        //              Non-strict is more permissive, e.g. flexible on white space, omitting thousands separators
        // fractional: Boolean|Array?
        //              Whether to include the fractional portion, where the number of decimal places are implied by pattern
        //              or explicit 'places' parameter.  The value [true,false] makes the fractional portion optional.
});
=====*/
number.parse = function(/*String*/ expression, /*number.__ParseOptions?*/ options){
        // summary:
        //              Convert a properly formatted string to a primitive Number, using
        //              locale-specific settings.
        // description:
        //              Create a Number from a string using a known localized pattern.
        //              Formatting patterns are chosen appropriate to the locale
        //              and follow the syntax described by
        //              [unicode.org TR35](http://www.unicode.org/reports/tr35/#Number_Format_Patterns)
        //              Note that literal characters in patterns are not supported.
        // expression:
        //              A string representation of a Number
        var info = number._parseInfo(options),
                results = (new RegExp("^"+info.regexp+"$")).exec(expression);
        if(!results){
                return NaN; //NaN
        }
        var absoluteMatch = results[1]; // match for the positive expression
        if(!results[1]){
                if(!results[2]){
                        return NaN; //NaN
                }
                // matched the negative pattern
                absoluteMatch =results[2];
                info.factor *= -1;
        }

        // Transform it to something Javascript can parse as a number.  Normalize
        // decimal point and strip out group separators or alternate forms of whitespace
        absoluteMatch = absoluteMatch.
                replace(new RegExp("["+info.group + "\\s\\xa0"+"]", "g"), "").
                replace(info.decimal, ".");
        // Adjust for negative sign, percent, etc. as necessary
        return absoluteMatch * info.factor; //Number
};

/*=====
number.__RealNumberRegexpFlags = declare(null, {
        // places: Number?
        //              The integer number of decimal places or a range given as "n,m".  If
        //              not given, the decimal part is optional and the number of places is
        //              unlimited.
        // decimal: String?
        //              A string for the character used as the decimal point.  Default
        //              is ".".
        // fractional: Boolean|Array?
        //              Whether decimal places are used.  Can be true, false, or [true,
        //              false].  Default is [true, false] which means optional.
        // exponent: Boolean|Array?
        //              Express in exponential notation.  Can be true, false, or [true,
        //              false]. Default is [true, false], (i.e. will match if the
        //              exponential part is present are not).
        // eSigned: Boolean|Array?
        //              The leading plus-or-minus sign on the exponent.  Can be true,
        //              false, or [true, false].  Default is [true, false], (i.e. will
        //              match if it is signed or unsigned).  flags in regexp.integer can be
        //              applied.
});
=====*/

number._realNumberRegexp = function(/*__RealNumberRegexpFlags?*/ flags){
        // summary:
        //              Builds a regular expression to match a real number in exponential
        //              notation

        // assign default values to missing parameters
        flags = flags || {};
        //TODO: use mixin instead?
        if(!("places" in flags)){ flags.places = Infinity; }
        if(typeof flags.decimal != "string"){ flags.decimal = "."; }
        if(!("fractional" in flags) || /^0/.test(flags.places)){ flags.fractional = [true, false]; }
        if(!("exponent" in flags)){ flags.exponent = [true, false]; }
        if(!("eSigned" in flags)){ flags.eSigned = [true, false]; }

        var integerRE = number._integerRegexp(flags),
                decimalRE = dregexp.buildGroupRE(flags.fractional,
                function(q){
                        var re = "";
                        if(q && (flags.places!==0)){
                                re = "\\" + flags.decimal;
                                if(flags.places == Infinity){
                                        re = "(?:" + re + "\\d+)?";
                                }else{
                                        re += "\\d{" + flags.places + "}";
                                }
                        }
                        return re;
                },
                true
        );

        var exponentRE = dregexp.buildGroupRE(flags.exponent,
                function(q){
                        if(q){ return "([eE]" + number._integerRegexp({ signed: flags.eSigned}) + ")"; }
                        return "";
                }
        );

        var realRE = integerRE + decimalRE;
        // allow for decimals without integers, e.g. .25
        if(decimalRE){realRE = "(?:(?:"+ realRE + ")|(?:" + decimalRE + "))";}
        return realRE + exponentRE; // String
};

/*=====
number.__IntegerRegexpFlags = declare(null, {
        // signed: Boolean?
        //              The leading plus-or-minus sign. Can be true, false, or `[true,false]`.
        //              Default is `[true, false]`, (i.e. will match if it is signed
        //              or unsigned).
        // separator: String?
        //              The character used as the thousands separator. Default is no
        //              separator. For more than one symbol use an array, e.g. `[",", ""]`,
        //              makes ',' optional.
        // groupSize: Number?
        //              group size between separators
        // groupSize2: Number?
        //              second grouping, where separators 2..n have a different interval than the first separator (for India)
});
=====*/

number._integerRegexp = function(/*number.__IntegerRegexpFlags?*/ flags){
        // summary:
        //              Builds a regular expression that matches an integer

        // assign default values to missing parameters
        flags = flags || {};
        if(!("signed" in flags)){ flags.signed = [true, false]; }
        if(!("separator" in flags)){
                flags.separator = "";
        }else if(!("groupSize" in flags)){
                flags.groupSize = 3;
        }

        var signRE = dregexp.buildGroupRE(flags.signed,
                function(q){ return q ? "[-+]" : ""; },
                true
        );

        var numberRE = dregexp.buildGroupRE(flags.separator,
                function(sep){
                        if(!sep){
                                return "(?:\\d+)";
                        }

                        sep = dregexp.escapeString(sep);
                        if(sep == " "){ sep = "\\s"; }
                        else if(sep == "\xa0"){ sep = "\\s\\xa0"; }

                        var grp = flags.groupSize, grp2 = flags.groupSize2;
                        //TODO: should we continue to enforce that numbers with separators begin with 1-9?  See #6933
                        if(grp2){
                                var grp2RE = "(?:0|[1-9]\\d{0," + (grp2-1) + "}(?:[" + sep + "]\\d{" + grp2 + "})*[" + sep + "]\\d{" + grp + "})";
                                return ((grp-grp2) > 0) ? "(?:" + grp2RE + "|(?:0|[1-9]\\d{0," + (grp-1) + "}))" : grp2RE;
                        }
                        return "(?:0|[1-9]\\d{0," + (grp-1) + "}(?:[" + sep + "]\\d{" + grp + "})*)";
                },
                true
        );

        return signRE + numberRE; // String
};

return number;
});

},
'dijit/_FocusMixin':function(){
define("dijit/_FocusMixin", [
        "./focus",
        "./_WidgetBase",
        "dojo/_base/declare", // declare
        "dojo/_base/lang" // lang.extend
], function(focus, _WidgetBase, declare, lang){

        // module:
        //              dijit/_FocusMixin

        // We don't know where _FocusMixin will occur in the inheritance chain, but we need the _onFocus()/_onBlur() below
        // to be last in the inheritance chain, so mixin to _WidgetBase.
        lang.extend(_WidgetBase, {
                // focused: [readonly] Boolean
                //              This widget or a widget it contains has focus, or is "active" because
                //              it was recently clicked.
                focused: false,

                onFocus: function(){
                        // summary:
                        //              Called when the widget becomes "active" because
                        //              it or a widget inside of it either has focus, or has recently
                        //              been clicked.
                        // tags:
                        //              callback
                },

                onBlur: function(){
                        // summary:
                        //              Called when the widget stops being "active" because
                        //              focus moved to something outside of it, or the user
                        //              clicked somewhere outside of it, or the widget was
                        //              hidden.
                        // tags:
                        //              callback
                },

                _onFocus: function(){
                        // summary:
                        //              This is where widgets do processing for when they are active,
                        //              such as changing CSS classes.  See onFocus() for more details.
                        // tags:
                        //              protected
                        this.onFocus();
                },

                _onBlur: function(){
                        // summary:
                        //              This is where widgets do processing for when they stop being active,
                        //              such as changing CSS classes.  See onBlur() for more details.
                        // tags:
                        //              protected
                        this.onBlur();
                }
        });

        return declare("dijit._FocusMixin", null, {
                // summary:
                //              Mixin to widget to provide _onFocus() and _onBlur() methods that
                //              fire when a widget or its descendants get/lose focus

                // flag that I want _onFocus()/_onBlur() notifications from focus manager
                _focusManager: focus
        });

});

},
'dojo/data/util/filter':function(){
define("dojo/data/util/filter", ["../../_base/lang"], function(lang){
        // module:
        //              dojo/data/util/filter
        // summary:
        //              TODOC

var filter = {};
lang.setObject("dojo.data.util.filter", filter);

filter.patternToRegExp = function(/*String*/pattern, /*boolean?*/ ignoreCase){
        // summary:
        //              Helper function to convert a simple pattern to a regular expression for matching.
        // description:
        //              Returns a regular expression object that conforms to the defined conversion rules.
        //              For example:
        //
        //              - ca*   -> /^ca.*$/
        //              - *ca*  -> /^.*ca.*$/
        //              - *c\*a*  -> /^.*c\*a.*$/
        //              - *c\*a?*  -> /^.*c\*a..*$/
        //
        //              and so on.
        // pattern: string
        //              A simple matching pattern to convert that follows basic rules:
        //
        //              - * Means match anything, so ca* means match anything starting with ca
        //              - ? Means match single character.  So, b?b will match to bob and bab, and so on.
        //              - \ is an escape character.  So for example, \* means do not treat * as a match, but literal character *.
        //
        //              To use a \ as a character in the string, it must be escaped.  So in the pattern it should be
        //              represented by \\ to be treated as an ordinary \ character instead of an escape.
        // ignoreCase:
        //              An optional flag to indicate if the pattern matching should be treated as case-sensitive or not when comparing
        //              By default, it is assumed case sensitive.

        var rxp = "^";
        var c = null;
        for(var i = 0; i < pattern.length; i++){
                c = pattern.charAt(i);
                switch(c){
                        case '\\':
                                rxp += c;
                                i++;
                                rxp += pattern.charAt(i);
                                break;
                        case '*':
                                rxp += ".*"; break;
                        case '?':
                                rxp += "."; break;
                        case '$':
                        case '^':
                        case '/':
                        case '+':
                        case '.':
                        case '|':
                        case '(':
                        case ')':
                        case '{':
                        case '}':
                        case '[':
                        case ']':
                                rxp += "\\"; //fallthrough
                        default:
                                rxp += c;
                }
        }
        rxp += "$";
        if(ignoreCase){
                return new RegExp(rxp,"mi"); //RegExp
        }else{
                return new RegExp(rxp,"m"); //RegExp
        }

};

return filter;
});

},
'dijit/_WidgetsInTemplateMixin':function(){
define("dijit/_WidgetsInTemplateMixin", [
        "dojo/_base/array", // array.forEach
        "dojo/_base/declare", // declare
        "dojo/parser" // parser.parse
], function(array, declare, parser){

        // module:
        //              dijit/_WidgetsInTemplateMixin

        return declare("dijit._WidgetsInTemplateMixin", null, {
                // summary:
                //              Mixin to supplement _TemplatedMixin when template contains widgets

                // _earlyTemplatedStartup: Boolean
                //              A fallback to preserve the 1.0 - 1.3 behavior of children in
                //              templates having their startup called before the parent widget
                //              fires postCreate. Defaults to 'false', causing child widgets to
                //              have their .startup() called immediately before a parent widget
                //              .startup(), but always after the parent .postCreate(). Set to
                //              'true' to re-enable to previous, arguably broken, behavior.
                _earlyTemplatedStartup: false,

                // widgetsInTemplate: [protected] Boolean
                //              Should we parse the template to find widgets that might be
                //              declared in markup inside it?  (Remove for 2.0 and assume true)
                widgetsInTemplate: true,

                _beforeFillContent: function(){
                        if(this.widgetsInTemplate){
                                // Before copying over content, instantiate widgets in template
                                var node = this.domNode;

                                var cw = (this._startupWidgets = parser.parse(node, {
                                        noStart: !this._earlyTemplatedStartup,
                                        template: true,
                                        inherited: {dir: this.dir, lang: this.lang, textDir: this.textDir},
                                        propsThis: this,        // so data-dojo-props of widgets in the template can reference "this" to refer to me
                                        scope: "dojo"   // even in multi-version mode templates use dojoType/data-dojo-type
                                }));

                                if(!cw.isFulfilled()){
                                        throw new Error(this.declaredClass + ": parser returned unfilled promise (probably waiting for module auto-load), " +
                                                "unsupported by _WidgetsInTemplateMixin.   Must pre-load all supporting widgets before instantiation.");
                                }

                                // _WidgetBase::destroy() will destroy any supporting widgets under this.domNode.
                                // If we wanted to, we could call this.own() on anything in this._startupWidgets that was moved outside
                                // of this.domNode (like Dialog, which is moved to <body>).

                                this._attachTemplateNodes(cw, function(n,p){
                                        return n[p];
                                });
                        }
                },

                startup: function(){
                        array.forEach(this._startupWidgets, function(w){
                                if(w && !w._started && w.startup){
                                        w.startup();
                                }
                        });
                        this.inherited(arguments);
                }
        });
});

},
'dojo/fx/Toggler':function(){
define("dojo/fx/Toggler", ["../_base/lang","../_base/declare","../_base/fx", "../_base/connect"], 
  function(lang, declare, baseFx, connectUtil){
        // module:
        //              dojo/fx/Toggler

return declare("dojo.fx.Toggler", null, {
        // summary:
        //              A simple `dojo.Animation` toggler API.
        // description:
        //              class constructor for an animation toggler. It accepts a packed
        //              set of arguments about what type of animation to use in each
        //              direction, duration, etc. All available members are mixed into
        //              these animations from the constructor (for example, `node`,
        //              `showDuration`, `hideDuration`).
        // example:
        //      |       var t = new dojo/fx/Toggler({
        //      |               node: "nodeId",
        //      |               showDuration: 500,
        //      |               // hideDuration will default to "200"
        //      |               showFunc: dojo/fx/wipeIn,
        //      |               // hideFunc will default to "fadeOut"
        //      |       });
        //      |       t.show(100); // delay showing for 100ms
        //      |       // ...time passes...
        //      |       t.hide();

        // node: DomNode
        //              the node to target for the showing and hiding animations
        node: null,

        // showFunc: Function
        //              The function that returns the `dojo.Animation` to show the node
        showFunc: baseFx.fadeIn,

        // hideFunc: Function
        //              The function that returns the `dojo.Animation` to hide the node
        hideFunc: baseFx.fadeOut,

        // showDuration:
        //              Time in milliseconds to run the show Animation
        showDuration: 200,

        // hideDuration:
        //              Time in milliseconds to run the hide Animation
        hideDuration: 200,

        // FIXME: need a policy for where the toggler should "be" the next
        // time show/hide are called if we're stopped somewhere in the
        // middle.
        // FIXME: also would be nice to specify individual showArgs/hideArgs mixed into
        // each animation individually.
        // FIXME: also would be nice to have events from the animations exposed/bridged

        /*=====
        _showArgs: null,
        _showAnim: null,

        _hideArgs: null,
        _hideAnim: null,

        _isShowing: false,
        _isHiding: false,
        =====*/

        constructor: function(args){
                var _t = this;

                lang.mixin(_t, args);
                _t.node = args.node;
                _t._showArgs = lang.mixin({}, args);
                _t._showArgs.node = _t.node;
                _t._showArgs.duration = _t.showDuration;
                _t.showAnim = _t.showFunc(_t._showArgs);

                _t._hideArgs = lang.mixin({}, args);
                _t._hideArgs.node = _t.node;
                _t._hideArgs.duration = _t.hideDuration;
                _t.hideAnim = _t.hideFunc(_t._hideArgs);

                connectUtil.connect(_t.showAnim, "beforeBegin", lang.hitch(_t.hideAnim, "stop", true));
                connectUtil.connect(_t.hideAnim, "beforeBegin", lang.hitch(_t.showAnim, "stop", true));
        },

        show: function(delay){
                // summary:
                //              Toggle the node to showing
                // delay: Integer?
                //              Amount of time to stall playing the show animation
                return this.showAnim.play(delay || 0);
        },

        hide: function(delay){
                // summary:
                //              Toggle the node to hidden
                // delay: Integer?
                //              Amount of time to stall playing the hide animation
                return this.hideAnim.play(delay || 0);
        }
});

});

},
'dijit/form/FilteringSelect':function(){
define("dijit/form/FilteringSelect", [
        "dojo/data/util/filter", // filter.patternToRegExp
        "dojo/_base/declare", // declare
        "dojo/_base/lang", // lang.mixin
        "dojo/when",
        "./MappedTextBox",
        "./ComboBoxMixin"
], function(filter, declare, lang, when, MappedTextBox, ComboBoxMixin){

        // module:
        //              dijit/form/FilteringSelect

        return declare("dijit.form.FilteringSelect", [MappedTextBox, ComboBoxMixin], {
                // summary:
                //              An enhanced version of the HTML SELECT tag, populated dynamically
                //
                // description:
                //              An enhanced version of the HTML SELECT tag, populated dynamically. It works
                //              very nicely with very large data sets because it can load and page data as needed.
                //              It also resembles ComboBox, but does not allow values outside of the provided ones.
                //              If OPTION tags are used as the data provider via markup, then the
                //              OPTION tag's child text node is used as the displayed value when selected
                //              while the OPTION tag's value attribute is used as the widget value on form submit.
                //              To set the default value when using OPTION tags, specify the selected
                //              attribute on 1 of the child OPTION tags.
                //
                //              Similar features:
                //
                //              - There is a drop down list of possible values.
                //              - You can only enter a value from the drop down list.  (You can't
                //                      enter an arbitrary value.)
                //              - The value submitted with the form is the hidden value (ex: CA),
                //                      not the displayed value a.k.a. label (ex: California)
                //
                //              Enhancements over plain HTML version:
                //
                //              - If you type in some text then it will filter down the list of
                //                      possible values in the drop down list.
                //              - List can be specified either as a static list or via a javascript
                //                      function (that can get the list from a server)

                // required: Boolean
                //              True (default) if user is required to enter a value into this field.
                required: true,

                _lastDisplayedValue: "",

                _isValidSubset: function(){
                        return this._opened;
                },

                isValid: function(){
                        // Overrides ValidationTextBox.isValid()
                        return !!this.item || (!this.required && this.get('displayedValue') == ""); // #5974
                },

                _refreshState: function(){
                        if(!this.searchTimer){ // state will be refreshed after results are returned
                                this.inherited(arguments);
                        }
                },

                _callbackSetLabel: function(
                                                /*Array*/ result,
                                                /*Object*/ query,
                                                /*Object*/ options,
                                                /*Boolean?*/ priorityChange){
                        // summary:
                        //              Callback from dojo.store after lookup of user entered value finishes

                        // setValue does a synchronous lookup,
                        // so it calls _callbackSetLabel directly,
                        // and so does not pass dataObject
                        // still need to test against _lastQuery in case it came too late
                        if((query && query[this.searchAttr] !== this._lastQuery) || (!query && result.length && this.store.getIdentity(result[0]) != this._lastQuery)){
                                return;
                        }
                        if(!result.length){
                                //#3268: don't modify display value on bad input
                                //#3285: change CSS to indicate error
                                this.set("value", '', priorityChange || (priorityChange === undefined && !this.focused), this.textbox.value, null);
                        }else{
                                this.set('item', result[0], priorityChange);
                        }
                },

                _openResultList: function(/*Object*/ results, /*Object*/ query, /*Object*/ options){
                        // Callback when a data store query completes.
                        // Overrides ComboBox._openResultList()

                        // #3285: tap into search callback to see if user's query resembles a match
                        if(query[this.searchAttr] !== this._lastQuery){
                                return;
                        }
                        this.inherited(arguments);

                        if(this.item === undefined){ // item == undefined for keyboard search
                                // If the search returned no items that means that the user typed
                                // in something invalid (and they can't make it valid by typing more characters),
                                // so flag the FilteringSelect as being in an invalid state
                                this.validate(true);
                        }
                },

                _getValueAttr: function(){
                        // summary:
                        //              Hook for get('value') to work.

                        // don't get the textbox value but rather the previously set hidden value.
                        // Use this.valueNode.value which isn't always set for other MappedTextBox widgets until blur
                        return this.valueNode.value;
                },

                _getValueField: function(){
                        // Overrides ComboBox._getValueField()
                        return "value";
                },

                _setValueAttr: function(/*String*/ value, /*Boolean?*/ priorityChange, /*String?*/ displayedValue, /*item?*/ item){
                        // summary:
                        //              Hook so set('value', value) works.
                        // description:
                        //              Sets the value of the select.
                        //              Also sets the label to the corresponding value by reverse lookup.
                        if(!this._onChangeActive){ priorityChange = null; }

                        if(item === undefined){
                                if(value === null || value === ''){
                                        value = '';
                                        if(!lang.isString(displayedValue)){
                                                this._setDisplayedValueAttr(displayedValue||'', priorityChange);
                                                return;
                                        }
                                }

                                var self = this;
                                this._lastQuery = value;
                                when(this.store.get(value), function(item){
                                        self._callbackSetLabel(item? [item] : [], undefined, undefined, priorityChange);
                                });
                        }else{
                                this.valueNode.value = value;
                                this.inherited(arguments);
                        }
                },

                _setItemAttr: function(/*item*/ item, /*Boolean?*/ priorityChange, /*String?*/ displayedValue){
                        // summary:
                        //              Set the displayed valued in the input box, and the hidden value
                        //              that gets submitted, based on a dojo.data store item.
                        // description:
                        //              Users shouldn't call this function; they should be calling
                        //              set('item', value)
                        // tags:
                        //              private
                        this.inherited(arguments);
                        this._lastDisplayedValue = this.textbox.value;
                },

                _getDisplayQueryString: function(/*String*/ text){
                        return text.replace(/([\\\*\?])/g, "\\$1");
                },

                _setDisplayedValueAttr: function(/*String*/ label, /*Boolean?*/ priorityChange){
                        // summary:
                        //              Hook so set('displayedValue', label) works.
                        // description:
                        //              Sets textbox to display label. Also performs reverse lookup
                        //              to set the hidden value.  label should corresponding to item.searchAttr.

                        if(label == null){ label = ''; }

                        // This is called at initialization along with every custom setter.
                        // Usually (or always?) the call can be ignored.   If it needs to be
                        // processed then at least make sure that the XHR request doesn't trigger an onChange()
                        // event, even if it returns after creation has finished
                        if(!this._created){
                                if(!("displayedValue" in this.params)){
                                        return;
                                }
                                priorityChange = false;
                        }

                        // Do a reverse lookup to map the specified displayedValue to the hidden value.
                        // Note that if there's a custom labelFunc() this code
                        if(this.store){
                                this.closeDropDown();
                                var query = lang.clone(this.query); // #6196: populate query with user-specifics

                                // Generate query
                                var qs = this._getDisplayQueryString(label), q;
                                if(this.store._oldAPI){
                                        // remove this branch for 2.0
                                        q = qs;
                                }else{
                                        // Query on searchAttr is a regex for benefit of dojo/store/Memory,
                                        // but with a toString() method to help dojo/store/JsonRest.
                                        // Search string like "Co*" converted to regex like /^Co.*$/i.
                                        q = filter.patternToRegExp(qs, this.ignoreCase);
                                        q.toString = function(){ return qs; };
                                }
                                this._lastQuery = query[this.searchAttr] = q;

                                // If the label is not valid, the callback will never set it,
                                // so the last valid value will get the warning textbox.   Set the
                                // textbox value now so that the impending warning will make
                                // sense to the user
                                this.textbox.value = label;
                                this._lastDisplayedValue = label;
                                this._set("displayedValue", label);     // for watch("displayedValue") notification
                                var _this = this;
                                var options = {
                                        ignoreCase: this.ignoreCase,
                                        deep: true
                                };
                                lang.mixin(options, this.fetchProperties);
                                this._fetchHandle = this.store.query(query, options);
                                when(this._fetchHandle, function(result){
                                        _this._fetchHandle = null;
                                        _this._callbackSetLabel(result || [], query, options, priorityChange);
                                }, function(err){
                                        _this._fetchHandle = null;
                                        if(!_this._cancelingQuery){     // don't treat canceled query as an error
                                                console.error('dijit.form.FilteringSelect: ' + err.toString());
                                        }
                                });
                        }
                },

                undo: function(){
                        this.set('displayedValue', this._lastDisplayedValue);
                }
        });
});

},
'dojo/data/util/sorter':function(){
define("dojo/data/util/sorter", ["../../_base/lang"], function(lang){
        // module:
        //              dojo/data/util/sorter
        // summary:
        //              TODOC

var sorter = {};
lang.setObject("dojo.data.util.sorter", sorter);

sorter.basicComparator = function(      /*anything*/ a,
                                                                                                        /*anything*/ b){
        // summary:
        //              Basic comparison function that compares if an item is greater or less than another item
        // description:
        //              returns 1 if a > b, -1 if a < b, 0 if equal.
        //              'null' values (null, undefined) are treated as larger values so that they're pushed to the end of the list.
        //              And compared to each other, null is equivalent to undefined.

        //null is a problematic compare, so if null, we set to undefined.
        //Makes the check logic simple, compact, and consistent
        //And (null == undefined) === true, so the check later against null
        //works for undefined and is less bytes.
        var r = -1;
        if(a === null){
                a = undefined;
        }
        if(b === null){
                b = undefined;
        }
        if(a == b){
                r = 0;
        }else if(a > b || a == null){
                r = 1;
        }
        return r; //int {-1,0,1}
};

sorter.createSortFunction = function(   /* attributes[] */sortSpec, /*dojo/data/api/Read*/ store){
        // summary:
        //              Helper function to generate the sorting function based off the list of sort attributes.
        // description:
        //              The sort function creation will look for a property on the store called 'comparatorMap'.  If it exists
        //              it will look in the mapping for comparisons function for the attributes.  If one is found, it will
        //              use it instead of the basic comparator, which is typically used for strings, ints, booleans, and dates.
        //              Returns the sorting function for this particular list of attributes and sorting directions.
        // sortSpec:
        //              A JS object that array that defines out what attribute names to sort on and whether it should be descenting or asending.
        //              The objects should be formatted as follows:
        // |    {
        // |            attribute: "attributeName-string" || attribute,
        // |            descending: true|false;   // Default is false.
        // |    }
        // store:
        //              The datastore object to look up item values from.

        var sortFunctions=[];

        function createSortFunction(attr, dir, comp, s){
                //Passing in comp and s (comparator and store), makes this
                //function much faster.
                return function(itemA, itemB){
                        var a = s.getValue(itemA, attr);
                        var b = s.getValue(itemB, attr);
                        return dir * comp(a,b); //int
                };
        }
        var sortAttribute;
        var map = store.comparatorMap;
        var bc = sorter.basicComparator;
        for(var i = 0; i < sortSpec.length; i++){
                sortAttribute = sortSpec[i];
                var attr = sortAttribute.attribute;
                if(attr){
                        var dir = (sortAttribute.descending) ? -1 : 1;
                        var comp = bc;
                        if(map){
                                if(typeof attr !== "string" && ("toString" in attr)){
                                         attr = attr.toString();
                                }
                                comp = map[attr] || bc;
                        }
                        sortFunctions.push(createSortFunction(attr,
                                dir, comp, store));
                }
        }
        return function(rowA, rowB){
                var i=0;
                while(i < sortFunctions.length){
                        var ret = sortFunctions[i++](rowA, rowB);
                        if(ret !== 0){
                                return ret;//int
                        }
                }
                return 0; //int
        }; // Function
};

return sorter;
});

},
'dijit/form/_ButtonMixin':function(){
define("dijit/form/_ButtonMixin", [
        "dojo/_base/declare", // declare
        "dojo/dom", // dom.setSelectable
        "dojo/_base/event", // event.stop
        "../registry"           // registry.byNode
], function(declare, dom, event, registry){

// module:
//              dijit/form/_ButtonMixin

return declare("dijit.form._ButtonMixin", null, {
        // summary:
        //              A mixin to add a thin standard API wrapper to a normal HTML button
        // description:
        //              A label should always be specified (through innerHTML) or the label attribute.
        //
        //              Attach points:
        //
        //              - focusNode (required): this node receives focus
        //              - valueNode (optional): this node's value gets submitted with FORM elements
        //              - containerNode (optional): this node gets the innerHTML assignment for label
        // example:
        // |    <button data-dojo-type="dijit/form/Button" onClick="...">Hello world</button>
        // example:
        // |    var button1 = new Button({label: "hello world", onClick: foo});
        // |    dojo.body().appendChild(button1.domNode);

        // label: HTML String
        //              Content to display in button.
        label: "",

        // type: [const] String
        //              Type of button (submit, reset, button, checkbox, radio)
        type: "button",

        _onClick: function(/*Event*/ e){
                // summary:
                //              Internal function to handle click actions
                if(this.disabled){
                        event.stop(e);
                        return false;
                }
                var preventDefault = this.onClick(e) === false; // user click actions
                if(!preventDefault && this.type == "submit" && !(this.valueNode||this.focusNode).form){ // see if a non-form widget needs to be signalled
                        for(var node=this.domNode; node.parentNode; node=node.parentNode){
                                var widget=registry.byNode(node);
                                if(widget && typeof widget._onSubmit == "function"){
                                        widget._onSubmit(e);
                                        preventDefault = true;
                                        break;
                                }
                        }
                }
                if(preventDefault){
                        e.preventDefault();
                }
                return !preventDefault;
        },

        postCreate: function(){
                this.inherited(arguments);
                dom.setSelectable(this.focusNode, false);
        },

        onClick: function(/*Event*/ /*===== e =====*/){
                // summary:
                //              Callback for when button is clicked.
                //              If type="submit", return true to perform submit, or false to cancel it.
                // type:
                //              callback
                return true;            // Boolean
        },

        _setLabelAttr: function(/*String*/ content){
                // summary:
                //              Hook for set('label', ...) to work.
                // description:
                //              Set the label (text) of the button; takes an HTML string.
                this._set("label", content);
                (this.containerNode||this.focusNode).innerHTML = content;
        }
});

});

},
'dojo/colors':function(){
define("dojo/colors", ["./_base/kernel", "./_base/lang", "./_base/Color", "./_base/array"], function(dojo, lang, Color, ArrayUtil){
        // module:
        //              dojo/colors

        /*=====
        return {
                // summary:
                //              Color utilities, extending Base dojo.Color
        };
        =====*/

        var ColorExt = {};
        lang.setObject("dojo.colors", ColorExt);

//TODO: this module appears to break naming conventions

        // this is a standard conversion prescribed by the CSS3 Color Module
        var hue2rgb = function(m1, m2, h){
                if(h < 0){ ++h; }
                if(h > 1){ --h; }
                var h6 = 6 * h;
                if(h6 < 1){ return m1 + (m2 - m1) * h6; }
                if(2 * h < 1){ return m2; }
                if(3 * h < 2){ return m1 + (m2 - m1) * (2 / 3 - h) * 6; }
                return m1;
        };
        // Override base Color.fromRgb with the impl in this module
        dojo.colorFromRgb = Color.fromRgb = function(/*String*/ color, /*dojo/_base/Color?*/ obj){
                // summary:
                //              get rgb(a) array from css-style color declarations
                // description:
                //              this function can handle all 4 CSS3 Color Module formats: rgb,
                //              rgba, hsl, hsla, including rgb(a) with percentage values.
                var m = color.toLowerCase().match(/^(rgba?|hsla?)\(([\s\.\-,%0-9]+)\)/);
                if(m){
                        var c = m[2].split(/\s*,\s*/), l = c.length, t = m[1], a;
                        if((t == "rgb" && l == 3) || (t == "rgba" && l == 4)){
                                var r = c[0];
                                if(r.charAt(r.length - 1) == "%"){
                                        // 3 rgb percentage values
                                        a = ArrayUtil.map(c, function(x){
                                                return parseFloat(x) * 2.56;
                                        });
                                        if(l == 4){ a[3] = c[3]; }
                                        return Color.fromArray(a, obj); // dojo/_base/Color
                                }
                                return Color.fromArray(c, obj); // dojo/_base/Color
                        }
                        if((t == "hsl" && l == 3) || (t == "hsla" && l == 4)){
                                // normalize hsl values
                                var H = ((parseFloat(c[0]) % 360) + 360) % 360 / 360,
                                        S = parseFloat(c[1]) / 100,
                                        L = parseFloat(c[2]) / 100,
                                        // calculate rgb according to the algorithm
                                        // recommended by the CSS3 Color Module
                                        m2 = L <= 0.5 ? L * (S + 1) : L + S - L * S,
                                        m1 = 2 * L - m2;
                                a = [
                                        hue2rgb(m1, m2, H + 1 / 3) * 256,
                                        hue2rgb(m1, m2, H) * 256,
                                        hue2rgb(m1, m2, H - 1 / 3) * 256,
                                        1
                                ];
                                if(l == 4){ a[3] = c[3]; }
                                return Color.fromArray(a, obj); // dojo/_base/Color
                        }
                }
                return null;    // dojo/_base/Color
        };

        var confine = function(c, low, high){
                // summary:
                //              sanitize a color component by making sure it is a number,
                //              and clamping it to valid values
                c = Number(c);
                return isNaN(c) ? high : c < low ? low : c > high ? high : c;   // Number
        };

        Color.prototype.sanitize = function(){
                // summary:
                //              makes sure that the object has correct attributes
                var t = this;
                t.r = Math.round(confine(t.r, 0, 255));
                t.g = Math.round(confine(t.g, 0, 255));
                t.b = Math.round(confine(t.b, 0, 255));
                t.a = confine(t.a, 0, 1);
                return this;    // dojo/_base/Color
        };

        ColorExt.makeGrey = Color.makeGrey = function(/*Number*/ g, /*Number?*/ a){
                // summary:
                //              creates a greyscale color with an optional alpha
                return Color.fromArray([g, g, g, a]);   // dojo/_base/Color
        };

        // mixin all CSS3 named colors not already in _base, along with SVG 1.0 variant spellings
        lang.mixin(Color.named, {
                "aliceblue":    [240,248,255],
                "antiquewhite": [250,235,215],
                "aquamarine":   [127,255,212],
                "azure":        [240,255,255],
                "beige":        [245,245,220],
                "bisque":       [255,228,196],
                "blanchedalmond":       [255,235,205],
                "blueviolet":   [138,43,226],
                "brown":        [165,42,42],
                "burlywood":    [222,184,135],
                "cadetblue":    [95,158,160],
                "chartreuse":   [127,255,0],
                "chocolate":    [210,105,30],
                "coral":        [255,127,80],
                "cornflowerblue":       [100,149,237],
                "cornsilk": [255,248,220],
                "crimson":      [220,20,60],
                "cyan": [0,255,255],
                "darkblue": [0,0,139],
                "darkcyan": [0,139,139],
                "darkgoldenrod":        [184,134,11],
                "darkgray": [169,169,169],
                "darkgreen":    [0,100,0],
                "darkgrey": [169,169,169],
                "darkkhaki":    [189,183,107],
                "darkmagenta":  [139,0,139],
                "darkolivegreen":       [85,107,47],
                "darkorange":   [255,140,0],
                "darkorchid":   [153,50,204],
                "darkred":      [139,0,0],
                "darksalmon":   [233,150,122],
                "darkseagreen": [143,188,143],
                "darkslateblue":        [72,61,139],
                "darkslategray":        [47,79,79],
                "darkslategrey":        [47,79,79],
                "darkturquoise":        [0,206,209],
                "darkviolet":   [148,0,211],
                "deeppink": [255,20,147],
                "deepskyblue":  [0,191,255],
                "dimgray":      [105,105,105],
                "dimgrey":      [105,105,105],
                "dodgerblue":   [30,144,255],
                "firebrick":    [178,34,34],
                "floralwhite":  [255,250,240],
                "forestgreen":  [34,139,34],
                "gainsboro":    [220,220,220],
                "ghostwhite":   [248,248,255],
                "gold": [255,215,0],
                "goldenrod":    [218,165,32],
                "greenyellow":  [173,255,47],
                "grey": [128,128,128],
                "honeydew": [240,255,240],
                "hotpink":      [255,105,180],
                "indianred":    [205,92,92],
                "indigo":       [75,0,130],
                "ivory":        [255,255,240],
                "khaki":        [240,230,140],
                "lavender": [230,230,250],
                "lavenderblush":        [255,240,245],
                "lawngreen":    [124,252,0],
                "lemonchiffon": [255,250,205],
                "lightblue":    [173,216,230],
                "lightcoral":   [240,128,128],
                "lightcyan":    [224,255,255],
                "lightgoldenrodyellow": [250,250,210],
                "lightgray":    [211,211,211],
                "lightgreen":   [144,238,144],
                "lightgrey":    [211,211,211],
                "lightpink":    [255,182,193],
                "lightsalmon":  [255,160,122],
                "lightseagreen":        [32,178,170],
                "lightskyblue": [135,206,250],
                "lightslategray":       [119,136,153],
                "lightslategrey":       [119,136,153],
                "lightsteelblue":       [176,196,222],
                "lightyellow":  [255,255,224],
                "limegreen":    [50,205,50],
                "linen":        [250,240,230],
                "magenta":      [255,0,255],
                "mediumaquamarine": [102,205,170],
                "mediumblue":   [0,0,205],
                "mediumorchid": [186,85,211],
                "mediumpurple": [147,112,219],
                "mediumseagreen":       [60,179,113],
                "mediumslateblue":      [123,104,238],
                "mediumspringgreen":    [0,250,154],
                "mediumturquoise":      [72,209,204],
                "mediumvioletred":      [199,21,133],
                "midnightblue": [25,25,112],
                "mintcream":    [245,255,250],
                "mistyrose":    [255,228,225],
                "moccasin": [255,228,181],
                "navajowhite":  [255,222,173],
                "oldlace":      [253,245,230],
                "olivedrab":    [107,142,35],
                "orange":       [255,165,0],
                "orangered":    [255,69,0],
                "orchid":       [218,112,214],
                "palegoldenrod":        [238,232,170],
                "palegreen":    [152,251,152],
                "paleturquoise":        [175,238,238],
                "palevioletred":        [219,112,147],
                "papayawhip":   [255,239,213],
                "peachpuff":    [255,218,185],
                "peru": [205,133,63],
                "pink": [255,192,203],
                "plum": [221,160,221],
                "powderblue":   [176,224,230],
                "rosybrown":    [188,143,143],
                "royalblue":    [65,105,225],
                "saddlebrown":  [139,69,19],
                "salmon":       [250,128,114],
                "sandybrown":   [244,164,96],
                "seagreen": [46,139,87],
                "seashell": [255,245,238],
                "sienna":       [160,82,45],
                "skyblue":      [135,206,235],
                "slateblue":    [106,90,205],
                "slategray":    [112,128,144],
                "slategrey":    [112,128,144],
                "snow": [255,250,250],
                "springgreen":  [0,255,127],
                "steelblue":    [70,130,180],
                "tan":  [210,180,140],
                "thistle":      [216,191,216],
                "tomato":       [255,99,71],
                "turquoise":    [64,224,208],
                "violet":       [238,130,238],
                "wheat":        [245,222,179],
                "whitesmoke":   [245,245,245],
                "yellowgreen":  [154,205,50]
        });

        return Color;   // TODO: return ColorExt, not Color
});

},
'dijit/registry':function(){
define("dijit/registry", [
        "dojo/_base/array", // array.forEach array.map
        "dojo/sniff", // has("ie")
        "dojo/_base/unload", // unload.addOnWindowUnload
        "dojo/_base/window", // win.body
        "./main"        // dijit._scopeName
], function(array, has, unload, win, dijit){

        // module:
        //              dijit/registry

        var _widgetTypeCtr = {}, hash = {};

        var registry =  {
                // summary:
                //              Registry of existing widget on page, plus some utility methods.

                // length: Number
                //              Number of registered widgets
                length: 0,

                add: function(widget){
                        // summary:
                        //              Add a widget to the registry. If a duplicate ID is detected, a error is thrown.
                        // widget: dijit/_WidgetBase
                        //              Any dijit/_WidgetBase subclass.
                        if(hash[widget.id]){
                                throw new Error("Tried to register widget with id==" + widget.id + " but that id is already registered");
                        }
                        hash[widget.id] = widget;
                        this.length++;
                },

                remove: function(/*String*/ id){
                        // summary:
                        //              Remove a widget from the registry. Does not destroy the widget; simply
                        //              removes the reference.
                        if(hash[id]){
                                delete hash[id];
                                this.length--;
                        }
                },

                byId: function(/*String|Widget*/ id){
                        // summary:
                        //              Find a widget by it's id.
                        //              If passed a widget then just returns the widget.
                        return typeof id == "string" ? hash[id] : id;   // dijit/_WidgetBase
                },

                byNode: function(/*DOMNode*/ node){
                        // summary:
                        //              Returns the widget corresponding to the given DOMNode
                        return hash[node.getAttribute("widgetId")]; // dijit/_WidgetBase
                },

                toArray: function(){
                        // summary:
                        //              Convert registry into a true Array
                        //
                        // example:
                        //              Work with the widget .domNodes in a real Array
                        //              |       array.map(registry.toArray(), function(w){ return w.domNode; });

                        var ar = [];
                        for(var id in hash){
                                ar.push(hash[id]);
                        }
                        return ar;      // dijit/_WidgetBase[]
                },

                getUniqueId: function(/*String*/widgetType){
                        // summary:
                        //              Generates a unique id for a given widgetType

                        var id;
                        do{
                                id = widgetType + "_" +
                                        (widgetType in _widgetTypeCtr ?
                                                ++_widgetTypeCtr[widgetType] : _widgetTypeCtr[widgetType] = 0);
                        }while(hash[id]);
                        return dijit._scopeName == "dijit" ? id : dijit._scopeName + "_" + id; // String
                },

                findWidgets: function(root, skipNode){
                        // summary:
                        //              Search subtree under root returning widgets found.
                        //              Doesn't search for nested widgets (ie, widgets inside other widgets).
                        // root: DOMNode
                        //              Node to search under.
                        // skipNode: DOMNode
                        //              If specified, don't search beneath this node (usually containerNode).

                        var outAry = [];

                        function getChildrenHelper(root){
                                for(var node = root.firstChild; node; node = node.nextSibling){
                                        if(node.nodeType == 1){
                                                var widgetId = node.getAttribute("widgetId");
                                                if(widgetId){
                                                        var widget = hash[widgetId];
                                                        if(widget){     // may be null on page w/multiple dojo's loaded
                                                                outAry.push(widget);
                                                        }
                                                }else if(node !== skipNode){
                                                        getChildrenHelper(node);
                                                }
                                        }
                                }
                        }

                        getChildrenHelper(root);
                        return outAry;
                },

                _destroyAll: function(){
                        // summary:
                        //              Code to destroy all widgets and do other cleanup on page unload

                        // Clean up focus manager lingering references to widgets and nodes
                        dijit._curFocus = null;
                        dijit._prevFocus = null;
                        dijit._activeStack = [];

                        // Destroy all the widgets, top down
                        array.forEach(registry.findWidgets(win.body()), function(widget){
                                // Avoid double destroy of widgets like Menu that are attached to <body>
                                // even though they are logically children of other widgets.
                                if(!widget._destroyed){
                                        if(widget.destroyRecursive){
                                                widget.destroyRecursive();
                                        }else if(widget.destroy){
                                                widget.destroy();
                                        }
                                }
                        });
                },

                getEnclosingWidget: function(/*DOMNode*/ node){
                        // summary:
                        //              Returns the widget whose DOM tree contains the specified DOMNode, or null if
                        //              the node is not contained within the DOM tree of any widget
                        while(node){
                                var id = node.nodeType == 1 && node.getAttribute("widgetId");
                                if(id){
                                        return hash[id];
                                }
                                node = node.parentNode;
                        }
                        return null;
                },

                // In case someone needs to access hash.
                // Actually, this is accessed from WidgetSet back-compatibility code
                _hash: hash
        };

        dijit.registry = registry;

        return registry;
});

},
'dijit/tree/_dndContainer':function(){
define("dijit/tree/_dndContainer", [
        "dojo/aspect",  // aspect.after
        "dojo/_base/declare", // declare
        "dojo/dom-class", // domClass.add domClass.remove domClass.replace
        "dojo/_base/event",     // event.stop
        "dojo/_base/lang", // lang.mixin lang.hitch
        "dojo/on",
        "dojo/touch"
], function(aspect, declare,domClass, event, lang, on, touch){

        // module:
        //              dijit/tree/_dndContainer

        /*=====
         var __Args = {
                 // summary:
                 //             A dict of parameters for Tree source configuration.
                 // isSource: Boolean?
                 //             Can be used as a DnD source. Defaults to true.
                 // accept: String[]
                 //             List of accepted types (text strings) for a target; defaults to
                 //             ["text", "treeNode"]
                 // copyOnly: Boolean?
                 //             Copy items, if true, use a state of Ctrl key otherwise,
                 // dragThreshold: Number
                 //             The move delay in pixels before detecting a drag; 0 by default
                 // betweenThreshold: Integer
                 //             Distance from upper/lower edge of node to allow drop to reorder nodes
         };
         =====*/

        return declare("dijit.tree._dndContainer", null, {

                // summary:
                //              This is a base class for `dijit/tree/_dndSelector`, and isn't meant to be used directly.
                //              It's modeled after `dojo/dnd/Container`.
                // tags:
                //              protected

                /*=====
                // current: DomNode
                //              The currently hovered TreeNode.rowNode (which is the DOM node
                //              associated w/a given node in the tree, excluding it's descendants)
                current: null,
                =====*/

                constructor: function(tree, params){
                        // summary:
                        //              A constructor of the Container
                        // tree: Node
                        //              Node or node's id to build the container on
                        // params: __Args
                        //              A dict of parameters, which gets mixed into the object
                        // tags:
                        //              private
                        this.tree = tree;
                        this.node = tree.domNode;       // TODO: rename; it's not a TreeNode but the whole Tree
                        lang.mixin(this, params);

                        // class-specific variables
                        this.current = null;    // current TreeNode's DOM node

                        // states
                        this.containerState = "";
                        domClass.add(this.node, "dojoDndContainer");

                        // set up events
                        this.events = [
                                // Mouse (or touch) enter/leave on Tree itself
                                on(this.node, touch.enter, lang.hitch(this, "onOverEvent")),
                                on(this.node, touch.leave,      lang.hitch(this, "onOutEvent")),

                                // switching between TreeNodes
                                aspect.after(this.tree, "_onNodeMouseEnter", lang.hitch(this, "onMouseOver"), true),
                                aspect.after(this.tree, "_onNodeMouseLeave", lang.hitch(this, "onMouseOut"), true),

                                // cancel text selection and text dragging
                                on(this.node, "dragstart", lang.hitch(event, "stop")),
                                on(this.node, "selectstart", lang.hitch(event, "stop"))
                        ];
                },

                destroy: function(){
                        // summary:
                        //              Prepares this object to be garbage-collected

                        var h;
                        while(h = this.events.pop()){ h.remove(); }

                        // this.clearItems();
                        this.node = this.parent = null;
                },

                // mouse events
                onMouseOver: function(widget /*===== , evt =====*/){
                        // summary:
                        //              Called when mouse is moved over a TreeNode
                        // widget: TreeNode
                        // evt: Event
                        // tags:
                        //              protected
                        this.current = widget;
                },

                onMouseOut: function(/*===== widget, evt =====*/){
                        // summary:
                        //              Called when mouse is moved away from a TreeNode
                        // widget: TreeNode
                        // evt: Event
                        // tags:
                        //              protected
                        this.current = null;
                },

                _changeState: function(type, newState){
                        // summary:
                        //              Changes a named state to new state value
                        // type: String
                        //              A name of the state to change
                        // newState: String
                        //              new state
                        var prefix = "dojoDnd" + type;
                        var state = type.toLowerCase() + "State";
                        //domClass.replace(this.node, prefix + newState, prefix + this[state]);
                        domClass.replace(this.node, prefix + newState, prefix + this[state]);
                        this[state] = newState;
                },

                _addItemClass: function(node, type){
                        // summary:
                        //              Adds a class with prefix "dojoDndItem"
                        // node: Node
                        //              A node
                        // type: String
                        //              A variable suffix for a class name
                        domClass.add(node, "dojoDndItem" + type);
                },

                _removeItemClass: function(node, type){
                        // summary:
                        //              Removes a class with prefix "dojoDndItem"
                        // node: Node
                        //              A node
                        // type: String
                        //              A variable suffix for a class name
                        domClass.remove(node, "dojoDndItem" + type);
                },

                onOverEvent: function(){
                        // summary:
                        //              This function is called once, when mouse is over our container
                        // tags:
                        //              protected
                        this._changeState("Container", "Over");
                },

                onOutEvent: function(){
                        // summary:
                        //              This function is called once, when mouse is out of our container
                        // tags:
                        //              protected
                        this._changeState("Container", "");
                }
        });
});

},
'url:dijit/templates/InlineEditBox.html':"<span data-dojo-attach-point=\"editNode\" role=\"presentation\" class=\"dijitReset dijitInline dijitOffScreen\"\n\tdata-dojo-attach-event=\"onkeypress: _onKeyPress\"\n\t><span data-dojo-attach-point=\"editorPlaceholder\"></span\n\t><span data-dojo-attach-point=\"buttonContainer\"\n\t\t><button data-dojo-type=\"dijit/form/Button\" data-dojo-props=\"label: '${buttonSave}', 'class': 'saveButton'\"\n\t\t\tdata-dojo-attach-point=\"saveButton\" data-dojo-attach-event=\"onClick:save\"></button\n\t\t><button data-dojo-type=\"dijit/form/Button\"  data-dojo-props=\"label: '${buttonCancel}', 'class': 'cancelButton'\"\n\t\t\tdata-dojo-attach-point=\"cancelButton\" data-dojo-attach-event=\"onClick:cancel\"></button\n\t></span\n></span>\n",
'dijit/_base/wai':function(){
define("dijit/_base/wai", [
        "dojo/dom-attr", // domAttr.attr
        "dojo/_base/lang", // lang.mixin
        "../main",      // export symbols to dijit
        "../hccss"                      // not using this module directly, but loading it sets CSS flag on <html>
], function(domAttr, lang, dijit){

        // module:
        //              dijit/_base/wai

        var exports = {
                // summary:
                //              Deprecated methods for setting/getting wai roles and states.
                //              New code should call setAttribute()/getAttribute() directly.
                //
                //              Also loads hccss to apply dj_a11y class to root node if machine is in high-contrast mode.

                hasWaiRole: function(/*Element*/ elem, /*String?*/ role){
                        // summary:
                        //              Determines if an element has a particular role.
                        // returns:
                        //              True if elem has the specific role attribute and false if not.
                        //              For backwards compatibility if role parameter not provided,
                        //              returns true if has a role
                        var waiRole = this.getWaiRole(elem);
                        return role ? (waiRole.indexOf(role) > -1) : (waiRole.length > 0);
                },

                getWaiRole: function(/*Element*/ elem){
                        // summary:
                        //              Gets the role for an element (which should be a wai role).
                        // returns:
                        //              The role of elem or an empty string if elem
                        //              does not have a role.
                         return lang.trim((domAttr.get(elem, "role") || "").replace("wairole:",""));
                },

                setWaiRole: function(/*Element*/ elem, /*String*/ role){
                        // summary:
                        //              Sets the role on an element.
                        // description:
                        //              Replace existing role attribute with new role.

                        domAttr.set(elem, "role", role);
                },

                removeWaiRole: function(/*Element*/ elem, /*String*/ role){
                        // summary:
                        //              Removes the specified role from an element.
                        //              Removes role attribute if no specific role provided (for backwards compat.)

                        var roleValue = domAttr.get(elem, "role");
                        if(!roleValue){ return; }
                        if(role){
                                var t = lang.trim((" " + roleValue + " ").replace(" " + role + " ", " "));
                                domAttr.set(elem, "role", t);
                        }else{
                                elem.removeAttribute("role");
                        }
                },

                hasWaiState: function(/*Element*/ elem, /*String*/ state){
                        // summary:
                        //              Determines if an element has a given state.
                        // description:
                        //              Checks for an attribute called "aria-"+state.
                        // returns:
                        //              true if elem has a value for the given state and
                        //              false if it does not.

                        return elem.hasAttribute ? elem.hasAttribute("aria-"+state) : !!elem.getAttribute("aria-"+state);
                },

                getWaiState: function(/*Element*/ elem, /*String*/ state){
                        // summary:
                        //              Gets the value of a state on an element.
                        // description:
                        //              Checks for an attribute called "aria-"+state.
                        // returns:
                        //              The value of the requested state on elem
                        //              or an empty string if elem has no value for state.

                        return elem.getAttribute("aria-"+state) || "";
                },

                setWaiState: function(/*Element*/ elem, /*String*/ state, /*String*/ value){
                        // summary:
                        //              Sets a state on an element.
                        // description:
                        //              Sets an attribute called "aria-"+state.

                        elem.setAttribute("aria-"+state, value);
                },

                removeWaiState: function(/*Element*/ elem, /*String*/ state){
                        // summary:
                        //              Removes a state from an element.
                        // description:
                        //              Sets an attribute called "aria-"+state.

                        elem.removeAttribute("aria-"+state);
                }
        };

        lang.mixin(dijit, exports);

        /*===== return exports; =====*/
        return dijit;   // for back compat :-(
});

},
'dijit/form/_FormSelectWidget':function(){
define("dijit/form/_FormSelectWidget", [
        "dojo/_base/array", // array.filter array.forEach array.map array.some
        "dojo/_base/Deferred",
        "dojo/aspect", // aspect.after
        "dojo/data/util/sorter", // util.sorter.createSortFunction
        "dojo/_base/declare", // declare
        "dojo/dom", // dom.setSelectable
        "dojo/dom-class", // domClass.toggle
        "dojo/_base/kernel",    // _scopeName
        "dojo/_base/lang", // lang.delegate lang.isArray lang.isObject lang.hitch
        "dojo/query", // query
        "dojo/when",
        "dojo/store/util/QueryResults",
        "./_FormValueWidget"
], function(array, Deferred, aspect, sorter, declare, dom, domClass, kernel, lang, query, when,
                        QueryResults, _FormValueWidget){

// module:
//              dijit/form/_FormSelectWidget

/*=====
var __SelectOption = {
        // value: String
        //              The value of the option.  Setting to empty (or missing) will
        //              place a separator at that location
        // label: String
        //              The label for our option.  It can contain html tags.
        // selected: Boolean
        //              Whether or not we are a selected option
        // disabled: Boolean
        //              Whether or not this specific option is disabled
};
=====*/

var _FormSelectWidget = declare("dijit.form._FormSelectWidget", _FormValueWidget, {
        // summary:
        //              Extends _FormValueWidget in order to provide "select-specific"
        //              values - i.e., those values that are unique to `<select>` elements.
        //              This also provides the mechanism for reading the elements from
        //              a store, if desired.

        // multiple: [const] Boolean
        //              Whether or not we are multi-valued
        multiple: false,

        // options: __SelectOption[]
        //              The set of options for our select item.  Roughly corresponds to
        //              the html `<option>` tag.
        options: null,

        // store: dojo/store/api/Store
        //              A store to use for getting our list of options - rather than reading them
        //              from the `<option>` html tags.   Should support getIdentity().
        //              For back-compat store can also be a dojo/data/api/Identity.
        store: null,

        // query: object
        //              A query to use when fetching items from our store
        query: null,

        // queryOptions: object
        //              Query options to use when fetching from the store
        queryOptions: null,

        // labelAttr: String?
        //              The entries in the drop down list come from this attribute in the dojo.store items.
        //              If ``store`` is set, labelAttr must be set too, unless store is an old-style
        //              dojo.data store rather than a new dojo/store.
        labelAttr: "",

        // onFetch: Function
        //              A callback to do with an onFetch - but before any items are actually
        //              iterated over (i.e. to filter even further what you want to add)
        onFetch: null,

        // sortByLabel: Boolean
        //              Flag to sort the options returned from a store by the label of
        //              the store.
        sortByLabel: true,


        // loadChildrenOnOpen: Boolean
        //              By default loadChildren is called when the items are fetched from the
        //              store.  This property allows delaying loadChildren (and the creation
        //              of the options/menuitems) until the user clicks the button to open the
        //              dropdown.
        loadChildrenOnOpen: false,

        // onLoadDeferred: [readonly] dojo.Deferred
        //              This is the `dojo.Deferred` returned by setStore().
        //              Calling onLoadDeferred.then() registers your
        //              callback to be called only once, when the prior setStore completes.
        onLoadDeferred: null,

        getOptions: function(/*anything*/ valueOrIdx){
                // summary:
                //              Returns a given option (or options).
                // valueOrIdx:
                //              If passed in as a string, that string is used to look up the option
                //              in the array of options - based on the value property.
                //              (See dijit/form/_FormSelectWidget.__SelectOption).
                //
                //              If passed in a number, then the option with the given index (0-based)
                //              within this select will be returned.
                //
                //              If passed in a dijit/form/_FormSelectWidget.__SelectOption, the same option will be
                //              returned if and only if it exists within this select.
                //
                //              If passed an array, then an array will be returned with each element
                //              in the array being looked up.
                //
                //              If not passed a value, then all options will be returned
                //
                // returns:
                //              The option corresponding with the given value or index.  null
                //              is returned if any of the following are true:
                //
                //              - A string value is passed in which doesn't exist
                //              - An index is passed in which is outside the bounds of the array of options
                //              - A dijit/form/_FormSelectWidget.__SelectOption is passed in which is not a part of the select

                // NOTE: the compare for passing in a dijit/form/_FormSelectWidget.__SelectOption checks
                //              if the value property matches - NOT if the exact option exists
                // NOTE: if passing in an array, null elements will be placed in the returned
                //              array when a value is not found.
                var lookupValue = valueOrIdx, opts = this.options || [], l = opts.length;

                if(lookupValue === undefined){
                        return opts; // __SelectOption[]
                }
                if(lang.isArray(lookupValue)){
                        return array.map(lookupValue, "return this.getOptions(item);", this); // __SelectOption[]
                }
                if(lang.isObject(valueOrIdx)){
                        // We were passed an option - so see if it's in our array (directly),
                        // and if it's not, try and find it by value.
                        if(!array.some(this.options, function(o, idx){
                                if(o === lookupValue ||
                                        (o.value && o.value === lookupValue.value)){
                                        lookupValue = idx;
                                        return true;
                                }
                                return false;
                        })){
                                lookupValue = -1;
                        }
                }
                if(typeof lookupValue == "string"){
                        for(var i=0; i<l; i++){
                                if(opts[i].value === lookupValue){
                                        lookupValue = i;
                                        break;
                                }
                        }
                }
                if(typeof lookupValue == "number" && lookupValue >= 0 && lookupValue < l){
                        return this.options[lookupValue]; // __SelectOption
                }
                return null; // null
        },

        addOption: function(/*__SelectOption|__SelectOption[]*/ option){
                // summary:
                //              Adds an option or options to the end of the select.  If value
                //              of the option is empty or missing, a separator is created instead.
                //              Passing in an array of options will yield slightly better performance
                //              since the children are only loaded once.
                if(!lang.isArray(option)){ option = [option]; }
                array.forEach(option, function(i){
                        if(i && lang.isObject(i)){
                                this.options.push(i);
                        }
                }, this);
                this._loadChildren();
        },

        removeOption: function(/*String|__SelectOption|Number|Array*/ valueOrIdx){
                // summary:
                //              Removes the given option or options.  You can remove by string
                //              (in which case the value is removed), number (in which case the
                //              index in the options array is removed), or select option (in
                //              which case, the select option with a matching value is removed).
                //              You can also pass in an array of those values for a slightly
                //              better performance since the children are only loaded once.
                if(!lang.isArray(valueOrIdx)){ valueOrIdx = [valueOrIdx]; }
                var oldOpts = this.getOptions(valueOrIdx);
                array.forEach(oldOpts, function(i){
                        // We can get null back in our array - if our option was not found.  In
                        // that case, we don't want to blow up...
                        if(i){
                                this.options = array.filter(this.options, function(node){
                                        return (node.value !== i.value || node.label !== i.label);
                                });
                                this._removeOptionItem(i);
                        }
                }, this);
                this._loadChildren();
        },

        updateOption: function(/*__SelectOption|__SelectOption[]*/ newOption){
                // summary:
                //              Updates the values of the given option.  The option to update
                //              is matched based on the value of the entered option.  Passing
                //              in an array of new options will yield better performance since
                //              the children will only be loaded once.
                if(!lang.isArray(newOption)){ newOption = [newOption]; }
                array.forEach(newOption, function(i){
                        var oldOpt = this.getOptions(i), k;
                        if(oldOpt){
                                for(k in i){ oldOpt[k] = i[k]; }
                        }
                }, this);
                this._loadChildren();
        },

        setStore: function(store,
                                                selectedValue,
                                                fetchArgs){
                // summary:
                //              Sets the store you would like to use with this select widget.
                //              The selected value is the value of the new store to set.  This
                //              function returns the original store, in case you want to reuse
                //              it or something.
                // store: dojo/store/api/Store
                //              The dojo.store you would like to use - it MUST implement getIdentity()
                //              and MAY implement observe().
                //              For backwards-compatibility this can also be a data.data store, in which case
                //              it MUST implement dojo/data/api/Identity,
                //              and MAY implement dojo/data/api/Notification.
                // selectedValue: anything?
                //              The value that this widget should set itself to *after* the store
                //              has been loaded
                // fetchArgs: Object?
                //              Hash of parameters to set filter on store, etc.
                //
                //              - query: new value for Select.query,
                //              - queryOptions: new value for Select.queryOptions,
                //              - onFetch: callback function for each item in data (Deprecated)
                var oStore = this.store;
                fetchArgs = fetchArgs || {};

                if(oStore !== store){
                        // Our store has changed, so cancel any listeners on old store (remove for 2.0)
                        var h;
                        while((h = this._notifyConnections.pop())){ h.remove(); }

                        // For backwards-compatibility, accept dojo.data store in addition to dojo.store.store.  Remove in 2.0.
                        if(!store.get){
                                lang.mixin(store, {
                                        _oldAPI: true,
                                        get: function(id){
                                                // summary:
                                                //              Retrieves an object by it's identity. This will trigger a fetchItemByIdentity.
                                                //              Like dojo.store.DataStore.get() except returns native item.
                                                var deferred = new Deferred();
                                                this.fetchItemByIdentity({
                                                        identity: id,
                                                        onItem: function(object){
                                                                deferred.resolve(object);
                                                        },
                                                        onError: function(error){
                                                                deferred.reject(error);
                                                        }
                                                });
                                                return deferred.promise;
                                        },
                                        query: function(query, options){
                                                // summary:
                                                //              Queries the store for objects.   Like dojo/store/DataStore.query()
                                                //              except returned Deferred contains array of native items.
                                                var deferred = new Deferred(function(){ if(fetchHandle.abort){ fetchHandle.abort(); } } );
                                                deferred.total = new Deferred();
                                                var fetchHandle = this.fetch(lang.mixin({
                                                        query: query,
                                                        onBegin: function(count){
                                                                deferred.total.resolve(count);
                                                        },
                                                        onComplete: function(results){
                                                                deferred.resolve(results);
                                                        },
                                                        onError: function(error){
                                                                deferred.reject(error);
                                                        }
                                                }, options));
                                                return new QueryResults(deferred);
                                        }
                                });

                                if(store.getFeatures()["dojo.data.api.Notification"]){
                                        this._notifyConnections = [
                                                aspect.after(store, "onNew", lang.hitch(this, "_onNewItem"), true),
                                                aspect.after(store, "onDelete", lang.hitch(this, "_onDeleteItem"), true),
                                                aspect.after(store, "onSet", lang.hitch(this, "_onSetItem"), true)
                                        ];
                                }
                        }
                        this._set("store", store);                      // Our store has changed, so update our notifications
                }

                // Remove existing options (if there are any)
                if(this.options && this.options.length){
                        this.removeOption(this.options);
                }

                // Cancel listener for updates to old store
                if(this._queryRes && this._queryRes.close){
                        this._queryRes.close();
                }

                // If user has specified new query and query options along with this new store, then use them.
                if(fetchArgs.query){
                        this._set("query", fetchArgs.query);
                        this._set("queryOptions", fetchArgs.queryOptions);
                }

                // Add our new options
                if(store){
                        this._loadingStore = true;
                        this.onLoadDeferred = new Deferred();

                        // Run query
                        // Save result in this._queryRes so we can cancel the listeners we register below
                        this._queryRes = store.query(this.query, this.queryOptions);
                        when(this._queryRes, lang.hitch(this, function(items){

                                if(this.sortByLabel && !fetchArgs.sort && items.length){
                                        if(items[0].getValue){
                                                // Old dojo.data API to access items, remove for 2.0
                                                items.sort(sorter.createSortFunction([{
                                                        attribute: store.getLabelAttributes(items[0])[0]
                                                }], store));
                                        }else{
                                                var labelAttr = this.labelAttr;
                                                items.sort(function(a, b){
                                                        return a[labelAttr] > b[labelAttr] ? 1 :  b[labelAttr] > a[labelAttr] ? -1 : 0;
                                                });
                                        }
                                }

                                if(fetchArgs.onFetch){
                                                items = fetchArgs.onFetch.call(this, items, fetchArgs);
                                }

                                // TODO: Add these guys as a batch, instead of separately
                                array.forEach(items, function(i){
                                        this._addOptionForItem(i);
                                }, this);

                                // Register listener for store updates
                                if(this._queryRes.observe){
                                        this._queryRes.observe(lang.hitch(this, function(object, deletedFrom, insertedInto){
                                                if(deletedFrom == insertedInto){
                                                        this._onSetItem(object);
                                                }else{
                                                        if(deletedFrom != -1){
                                                                this._onDeleteItem(object);
                                                        }
                                                        if(insertedInto != -1){
                                                                this._onNewItem(object);
                                                        }
                                                }
                                        }), true);
                                }

                                // Set our value (which might be undefined), and then tweak
                                // it to send a change event with the real value
                                this._loadingStore = false;
                                this.set("value", "_pendingValue" in this ? this._pendingValue : selectedValue);
                                delete this._pendingValue;

                                if(!this.loadChildrenOnOpen){
                                        this._loadChildren();
                                }else{
                                        this._pseudoLoadChildren(items);
                                }
                                this.onLoadDeferred.resolve(true);
                                this.onSetStore();
                        }), function(err){
                                        console.error('dijit.form.Select: ' + err.toString());
                                        this.onLoadDeferred.reject(err);
                        });
                }
                return oStore;  // dojo/data/api/Identity
        },

        // TODO: implement set() and watch() for store and query, although not sure how to handle
        // setting them individually rather than together (as in setStore() above)

        _setValueAttr: function(/*anything*/ newValue, /*Boolean?*/ priorityChange){
                // summary:
                //              set the value of the widget.
                //              If a string is passed, then we set our value from looking it up.
                if(!this._onChangeActive){ priorityChange = null; }
                if(this._loadingStore){
                        // Our store is loading - so save our value, and we'll set it when
                        // we're done
                        this._pendingValue = newValue;
                        return;
                }
                var opts = this.getOptions() || [];
                if(!lang.isArray(newValue)){
                        newValue = [newValue];
                }
                array.forEach(newValue, function(i, idx){
                        if(!lang.isObject(i)){
                                i = i + "";
                        }
                        if(typeof i === "string"){
                                newValue[idx] = array.filter(opts, function(node){
                                        return node.value === i;
                                })[0] || {value: "", label: ""};
                        }
                }, this);

                // Make sure some sane default is set
                newValue = array.filter(newValue, function(i){ return i && i.value; });
                if(!this.multiple && (!newValue[0] || !newValue[0].value) && opts.length){
                        newValue[0] = opts[0];
                }
                array.forEach(opts, function(i){
                        i.selected = array.some(newValue, function(v){ return v.value === i.value; });
                });
                var     val = array.map(newValue, function(i){ return i.value; }),
                        disp = array.map(newValue, function(i){ return i.label; });

                if(typeof val == "undefined" || typeof val[0] == "undefined"){ return; } // not fully initialized yet or a failed value lookup
                this._setDisplay(this.multiple ? disp : disp[0]);
                this.inherited(arguments, [ this.multiple ? val : val[0], priorityChange ]);
                this._updateSelection();
        },

        _getDisplayedValueAttr: function(){
                // summary:
                //              returns the displayed value of the widget
                var val = this.get("value");
                if(!lang.isArray(val)){
                        val = [val];
                }
                var ret = array.map(this.getOptions(val), function(v){
                        if(v && "label" in v){
                                return v.label;
                        }else if(v){
                                return v.value;
                        }
                        return null;
                }, this);
                return this.multiple ? ret : ret[0];
        },

        _loadChildren: function(){
                // summary:
                //              Loads the children represented by this widget's options.
                //              reset the menu to make it populatable on the next click
                if(this._loadingStore){ return; }
                array.forEach(this._getChildren(), function(child){
                        child.destroyRecursive();
                });
                // Add each menu item
                array.forEach(this.options, this._addOptionItem, this);

                // Update states
                this._updateSelection();
        },

        _updateSelection: function(){
                // summary:
                //              Sets the "selected" class on the item for styling purposes
                this._set("value", this._getValueFromOpts());
                var val = this.value;
                if(!lang.isArray(val)){
                        val = [val];
                }
                if(val && val[0]){
                        array.forEach(this._getChildren(), function(child){
                                var isSelected = array.some(val, function(v){
                                        return child.option && (v === child.option.value);
                                });
                                domClass.toggle(child.domNode, this.baseClass.replace(/\s+|$/g, "SelectedOption "), isSelected);
                                child.domNode.setAttribute("aria-selected", isSelected ? "true" : "false");
                        }, this);
                }
        },

        _getValueFromOpts: function(){
                // summary:
                //              Returns the value of the widget by reading the options for
                //              the selected flag
                var opts = this.getOptions() || [];
                if(!this.multiple && opts.length){
                        // Mirror what a select does - choose the first one
                        var opt = array.filter(opts, function(i){
                                return i.selected;
                        })[0];
                        if(opt && opt.value){
                                return opt.value;
                        }else{
                                opts[0].selected = true;
                                return opts[0].value;
                        }
                }else if(this.multiple){
                        // Set value to be the sum of all selected
                        return array.map(array.filter(opts, function(i){
                                return i.selected;
                        }), function(i){
                                return i.value;
                        }) || [];
                }
                return "";
        },

        // Internal functions to call when we have store notifications come in
        _onNewItem: function(/*item*/ item, /*Object?*/ parentInfo){
                if(!parentInfo || !parentInfo.parent){
                        // Only add it if we are top-level
                        this._addOptionForItem(item);
                }
        },
        _onDeleteItem: function(/*item*/ item){
                var store = this.store;
                this.removeOption(store.getIdentity(item));
        },
        _onSetItem: function(/*item*/ item){
                this.updateOption(this._getOptionObjForItem(item));
        },

        _getOptionObjForItem: function(item){
                // summary:
                //              Returns an option object based off the given item.  The "value"
                //              of the option item will be the identity of the item, the "label"
                //              of the option will be the label of the item.

                // remove getLabel() call for 2.0 (it's to support the old dojo.data API)
                var store = this.store,
                        label = (this.labelAttr && this.labelAttr in item) ? item[this.labelAttr] : store.getLabel(item),
                        value = (label ? store.getIdentity(item) : null);
                return {value: value, label: label, item: item}; // __SelectOption
        },

        _addOptionForItem: function(/*item*/ item){
                // summary:
                //              Creates (and adds) the option for the given item
                var store = this.store;
                if(store.isItemLoaded && !store.isItemLoaded(item)){
                        // We are not loaded - so let's load it and add later.
                        // Remove for 2.0 (it's the old dojo.data API)
                        store.loadItem({item: item, onItem: function(i){
                                this._addOptionForItem(i);
                        },
                        scope: this});
                        return;
                }
                var newOpt = this._getOptionObjForItem(item);
                this.addOption(newOpt);
        },

        constructor: function(params /*===== , srcNodeRef =====*/){
                // summary:
                //              Create the widget.
                // params: Object|null
                //              Hash of initialization parameters for widget, including scalar values (like title, duration etc.)
                //              and functions, typically callbacks like onClick.
                //              The hash can contain any of the widget's properties, excluding read-only properties.
                // srcNodeRef: DOMNode|String?
                //              If a srcNodeRef (DOM node) is specified, replace srcNodeRef with my generated DOM tree

                //              Saves off our value, if we have an initial one set so we
                //              can use it if we have a store as well (see startup())
                this._oValue = (params || {}).value || null;
                this._notifyConnections = [];   // remove for 2.0
        },

        buildRendering: function(){
                this.inherited(arguments);
                dom.setSelectable(this.focusNode, false);
        },

        _fillContent: function(){
                // summary:
                //              Loads our options and sets up our dropdown correctly.  We
                //              don't want any content, so we don't call any inherit chain
                //              function.
                if(!this.options){
                        this.options =
                                this.srcNodeRef
                                ? query("> *", this.srcNodeRef).map(
                                        function(node){
                                                if(node.getAttribute("type") === "separator"){
                                                        return { value: "", label: "", selected: false, disabled: false };
                                                }
                                                return {
                                                        value: (node.getAttribute("data-" + kernel._scopeName + "-value") || node.getAttribute("value")),
                                                        label: String(node.innerHTML),
                                                        // FIXME: disabled and selected are not valid on complex markup children (which is why we're
                                                        // looking for data-dojo-value above.  perhaps we should data-dojo-props="" this whole thing?)
                                                        // decide before 1.6
                                                        selected: node.getAttribute("selected") || false,
                                                        disabled: node.getAttribute("disabled") || false
                                                };
                                        },
                                        this)
                                : [];
                }
                if(!this.value){
                        this._set("value", this._getValueFromOpts());
                }else if(this.multiple && typeof this.value == "string"){
                        this._set("value", this.value.split(","));
                }
        },

        postCreate: function(){
                // summary:
                //              sets up our event handling that we need for functioning
                //              as a select
                this.inherited(arguments);

                // Make our event connections for updating state
                this.connect(this, "onChange", "_updateSelection");

                // moved from startup
                //              Connects in our store, if we have one defined
                var store = this.store;
                if(store && (store.getIdentity || store.getFeatures()["dojo.data.api.Identity"])){
                        // Temporarily set our store to null so that it will get set
                        // and connected appropriately
                        this.store = null;
                        this.setStore(store, this._oValue);
                }
        },

        startup: function(){
                // summary:
                this._loadChildren();
                this.inherited(arguments);
        },

        destroy: function(){
                // summary:
                //              Clean up our connections

                var h;
                while((h = this._notifyConnections.pop())){ h.remove(); }

                // Cancel listener for store updates
                if(this._queryRes && this._queryRes.close){
                        this._queryRes.close();
                }

                this.inherited(arguments);
        },

        _addOptionItem: function(/*__SelectOption*/ /*===== option =====*/){
                // summary:
                //              User-overridable function which, for the given option, adds an
                //              item to the select.  If the option doesn't have a value, then a
                //              separator is added in that place.  Make sure to store the option
                //              in the created option widget.
        },

        _removeOptionItem: function(/*__SelectOption*/ /*===== option =====*/){
                // summary:
                //              User-overridable function which, for the given option, removes
                //              its item from the select.
        },

        _setDisplay: function(/*String or String[]*/ /*===== newDisplay =====*/){
                // summary:
                //              Overridable function which will set the display for the
                //              widget.  newDisplay is either a string (in the case of
                //              single selects) or array of strings (in the case of multi-selects)
        },

        _getChildren: function(){
                // summary:
                //              Overridable function to return the children that this widget contains.
                return [];
        },

        _getSelectedOptionsAttr: function(){
                // summary:
                //              hooks into this.attr to provide a mechanism for getting the
                //              option items for the current value of the widget.
                return this.getOptions(this.get("value"));
        },

        _pseudoLoadChildren: function(/*item[]*/ /*===== items =====*/){
                // summary:
                //              a function that will "fake" loading children, if needed, and
                //              if we have set to not load children until the widget opens.
                // items:
                //              An array of items that will be loaded, when needed
        },

        onSetStore: function(){
                // summary:
                //              a function that can be connected to in order to receive a
                //              notification that the store has finished loading and all options
                //              from that store are available
        }
});

/*=====
_FormSelectWidget.__SelectOption = __SelectOption;
=====*/

return _FormSelectWidget;

});

},
'dijit/form/Select':function(){
require({cache:{
'url:dijit/form/templates/Select.html':"<table class=\"dijit dijitReset dijitInline dijitLeft\"\n\tdata-dojo-attach-point=\"_buttonNode,tableNode,focusNode\" cellspacing='0' cellpadding='0'\n\trole=\"listbox\" aria-haspopup=\"true\"\n\t><tbody role=\"presentation\"><tr role=\"presentation\"\n\t\t><td class=\"dijitReset dijitStretch dijitButtonContents\" role=\"presentation\"\n\t\t\t><div class=\"dijitReset dijitInputField dijitButtonText\"  data-dojo-attach-point=\"containerNode,_popupStateNode\" role=\"presentation\"></div\n\t\t\t><div class=\"dijitReset dijitValidationContainer\"\n\t\t\t\t><input class=\"dijitReset dijitInputField dijitValidationIcon dijitValidationInner\" value=\"&#935; \" type=\"text\" tabIndex=\"-1\" readonly=\"readonly\" role=\"presentation\"\n\t\t\t/></div\n\t\t\t><input type=\"hidden\" ${!nameAttrSetting} data-dojo-attach-point=\"valueNode\" value=\"${value}\" aria-hidden=\"true\"\n\t\t/></td\n\t\t><td class=\"dijitReset dijitRight dijitButtonNode dijitArrowButton dijitDownArrowButton dijitArrowButtonContainer\"\n\t\t\tdata-dojo-attach-point=\"titleNode\" role=\"presentation\"\n\t\t\t><input class=\"dijitReset dijitInputField dijitArrowButtonInner\" value=\"&#9660; \" type=\"text\" tabIndex=\"-1\" readonly=\"readonly\" role=\"presentation\"\n\t\t\t\t${_buttonInputDisabled}\n\t\t/></td\n\t></tr></tbody\n></table>\n"}});
define("dijit/form/Select", [
        "dojo/_base/array", // array.forEach
        "dojo/_base/declare", // declare
        "dojo/dom-attr", // domAttr.set
        "dojo/dom-class", // domClass.add domClass.remove domClass.toggle
        "dojo/dom-geometry", // domGeometry.setMarginBox
        "dojo/_base/event", // event.stop
        "dojo/i18n", // i18n.getLocalization
        "dojo/_base/lang", // lang.hitch
        "dojo/sniff", // has("ie")
        "./_FormSelectWidget",
        "../_HasDropDown",
        "../Menu",
        "../MenuItem",
        "../MenuSeparator",
        "../Tooltip",
        "dojo/text!./templates/Select.html",
        "dojo/i18n!./nls/validate"
], function(array, declare, domAttr, domClass, domGeometry, event, i18n, lang, has,
                        _FormSelectWidget, _HasDropDown, Menu, MenuItem, MenuSeparator, Tooltip, template){

// module:
//              dijit/form/Select


var _SelectMenu = declare("dijit.form._SelectMenu", Menu, {
        // summary:
        //              An internally-used menu for dropdown that allows us a vertical scrollbar

        // Override Menu.autoFocus setting so that opening a Select highlights the current value.
        autoFocus: true,

        buildRendering: function(){
                // summary:
                //              Stub in our own changes, so that our domNode is not a table
                //              otherwise, we won't respond correctly to heights/overflows
                this.inherited(arguments);
                var o = (this.menuTableNode = this.domNode);
                var n = (this.domNode = this.ownerDocument.createElement("div"));
                n.style.cssText = "overflow-x: hidden; overflow-y: scroll";
                if(o.parentNode){
                        o.parentNode.replaceChild(n, o);
                }
                domClass.remove(o, "dijitMenuTable");
                n.className = o.className + " dijitSelectMenu";
                o.className = "dijitReset dijitMenuTable";
                o.setAttribute("role", "listbox");
                n.setAttribute("role", "presentation");
                n.appendChild(o);
        },

        postCreate: function(){
                // summary:
                //              stop mousemove from selecting text on IE to be consistent with other browsers

                this.inherited(arguments);

                this.connect(this.domNode, "onselectstart", event.stop);
        },


        focus: function(){
                // summary:
                //              Overridden so that the previously selected value will be focused instead of only the first item
                var     found = false,
                        val = this.parentWidget.value;
                if(lang.isArray(val)){
                        val = val[val.length-1];
                }
                if(val){ // if focus selected
                        array.forEach(this.parentWidget._getChildren(), function(child){
                                if(child.option && (val === child.option.value)){ // find menu item widget with this value
                                        found = true;
                                        this.focusChild(child, false); // focus previous selection
                                }
                        }, this);
                }
                if(!found){
                        this.inherited(arguments); // focus first item by default
                }
        },

        resize: function(/*Object*/ mb){
                // summary:
                //              Overridden so that we are able to handle resizing our
                //              internal widget.  Note that this is not a "full" resize
                //              implementation - it only works correctly if you pass it a
                //              marginBox.
                //
                // mb: Object
                //              The margin box to set this dropdown to.
                if(mb){
                        domGeometry.setMarginBox(this.domNode, mb);
                        if("w" in mb){
                                // We've explicitly set the wrapper <div>'s width, so set <table> width to match.
                                // 100% is safer than a pixel value because there may be a scroll bar with
                                // browser/OS specific width.
                                this.menuTableNode.style.width = "100%";
                        }
                }
        }
});

var Select = declare("dijit.form.Select", [_FormSelectWidget, _HasDropDown], {
        // summary:
        //              This is a "styleable" select box - it is basically a DropDownButton which
        //              can take a `<select>` as its input.

        baseClass: "dijitSelect dijitValidationTextBox",

        templateString: template,

        _buttonInputDisabled: has("ie") ? "disabled" : "", // allows IE to disallow focus, but Firefox cannot be disabled for mousedown events

        // required: Boolean
        //              Can be true or false, default is false.
        required: false,

        // state: [readonly] String
        //              "Incomplete" if this select is required but unset (i.e. blank value), "" otherwise
        state: "",

        // message: String
        //              Currently displayed error/prompt message
        message: "",

        // tooltipPosition: String[]
        //              See description of `dijit/Tooltip.defaultPosition` for details on this parameter.
        tooltipPosition: [],

        // emptyLabel: string
        //              What to display in an "empty" dropdown
        emptyLabel: "&#160;",   // &nbsp;

        // _isLoaded: Boolean
        //              Whether or not we have been loaded
        _isLoaded: false,

        // _childrenLoaded: Boolean
        //              Whether or not our children have been loaded
        _childrenLoaded: false,

        _fillContent: function(){
                // summary:
                //              Set the value to be the first, or the selected index
                this.inherited(arguments);
                // set value from selected option
                if(this.options.length && !this.value && this.srcNodeRef){
                        var si = this.srcNodeRef.selectedIndex || 0; // || 0 needed for when srcNodeRef is not a SELECT
                        this.value = this.options[si >= 0 ? si : 0].value;
                }
                // Create the dropDown widget
                this.dropDown = new _SelectMenu({ id: this.id + "_menu", parentWidget: this });
                domClass.add(this.dropDown.domNode, this.baseClass.replace(/\s+|$/g, "Menu "));
        },

        _getMenuItemForOption: function(/*_FormSelectWidget.__SelectOption*/ option){
                // summary:
                //              For the given option, return the menu item that should be
                //              used to display it.  This can be overridden as needed
                if(!option.value && !option.label){
                        // We are a separator (no label set for it)
                        return new MenuSeparator({ownerDocument: this.ownerDocument});
                }else{
                        // Just a regular menu option
                        var click = lang.hitch(this, "_setValueAttr", option);
                        var item = new MenuItem({
                                option: option,
                                label: option.label || this.emptyLabel,
                                onClick: click,
                                ownerDocument: this.ownerDocument,
                                dir: this.dir,
                                disabled: option.disabled || false
                        });
                        item.focusNode.setAttribute("role", "option");
                        return item;
                }
        },

        _addOptionItem: function(/*_FormSelectWidget.__SelectOption*/ option){
                // summary:
                //              For the given option, add an option to our dropdown.
                //              If the option doesn't have a value, then a separator is added
                //              in that place.
                if(this.dropDown){
                        this.dropDown.addChild(this._getMenuItemForOption(option));
                }
        },

        _getChildren: function(){
                if(!this.dropDown){
                        return [];
                }
                return this.dropDown.getChildren();
        },

        _loadChildren: function(/*Boolean*/ loadMenuItems){
                // summary:
                //              Resets the menu and the length attribute of the button - and
                //              ensures that the label is appropriately set.
                // loadMenuItems: Boolean
                //              actually loads the child menu items - we only do this when we are
                //              populating for showing the dropdown.

                if(loadMenuItems === true){
                        // this.inherited destroys this.dropDown's child widgets (MenuItems).
                        // Avoid this.dropDown (Menu widget) having a pointer to a destroyed widget (which will cause
                        // issues later in _setSelected). (see #10296)
                        if(this.dropDown){
                                delete this.dropDown.focusedChild;
                        }
                        if(this.options.length){
                                this.inherited(arguments);
                        }else{
                                // Drop down menu is blank but add one blank entry just so something appears on the screen
                                // to let users know that they are no choices (mimicing native select behavior)
                                array.forEach(this._getChildren(), function(child){ child.destroyRecursive(); });
                                var item = new MenuItem({
                                        ownerDocument: this.ownerDocument,
                                        label: this.emptyLabel
                                });
                                this.dropDown.addChild(item);
                        }
                }else{
                        this._updateSelection();
                }

                this._isLoaded = false;
                this._childrenLoaded = true;

                if(!this._loadingStore){
                        // Don't call this if we are loading - since we will handle it later
                        this._setValueAttr(this.value, false);
                }
        },

        _refreshState: function(){
                if(this._started){
                        this.validate(this.focused);
                }
        },

        startup: function(){
                this.inherited(arguments);
                this._refreshState(); // after all _set* methods have run
        },

        _setValueAttr: function(value){
                this.inherited(arguments);
                domAttr.set(this.valueNode, "value", this.get("value"));
                this._refreshState();   // to update this.state
        },

        _setDisabledAttr: function(/*Boolean*/ value){
                this.inherited(arguments);
                this._refreshState();   // to update this.state
        },

        _setRequiredAttr: function(/*Boolean*/ value){
                this._set("required", value);
                this.focusNode.setAttribute("aria-required", value);
                this._refreshState();   // to update this.state
        },

        _setOptionsAttr: function(/*Array*/ options){
                this._isLoaded = false;
                this._set('options', options);
        },

        _setDisplay: function(/*String*/ newDisplay){
                // summary:
                //              sets the display for the given value (or values)
                var lbl = newDisplay || this.emptyLabel;
                this.containerNode.innerHTML = '<span role="option" class="dijitReset dijitInline ' + this.baseClass.replace(/\s+|$/g, "Label ")+'">' + lbl + '</span>';
        },

        validate: function(/*Boolean*/ isFocused){
                // summary:
                //              Called by oninit, onblur, and onkeypress, and whenever required/disabled state changes
                // description:
                //              Show missing or invalid messages if appropriate, and highlight textbox field.
                //              Used when a select is initially set to no value and the user is required to
                //              set the value.

                var isValid = this.disabled || this.isValid(isFocused);
                this._set("state", isValid ? "" : (this._hasBeenBlurred ? "Error" : "Incomplete"));
                this.focusNode.setAttribute("aria-invalid", isValid ? "false" : "true");
                var message = isValid ? "" : this._missingMsg;
                if(message && this.focused && this._hasBeenBlurred){
                        Tooltip.show(message, this.domNode, this.tooltipPosition, !this.isLeftToRight());
                }else{
                        Tooltip.hide(this.domNode);
                }
                this._set("message", message);
                return isValid;
        },

        isValid: function(/*Boolean*/ /*===== isFocused =====*/){
                // summary:
                //              Whether or not this is a valid value.  The only way a Select
                //              can be invalid is when it's required but nothing is selected.
                return (!this.required || this.value === 0 || !(/^\s*$/.test(this.value || ""))); // handle value is null or undefined
        },

        reset: function(){
                // summary:
                //              Overridden so that the state will be cleared.
                this.inherited(arguments);
                Tooltip.hide(this.domNode);
                this._refreshState();   // to update this.state
        },

        postMixInProperties: function(){
                // summary:
                //              set the missing message
                this.inherited(arguments);
                this._missingMsg = i18n.getLocalization("dijit.form", "validate", this.lang).missingMessage;
        },

        postCreate: function(){
                // summary:
                //              stop mousemove from selecting text on IE to be consistent with other browsers

                this.inherited(arguments);
 
                this.connect(this.domNode, "onselectstart", event.stop);
                this.domNode.setAttribute("aria-expanded", "false");
                
                if(has("ie") < 9){
                        // IE INPUT tag fontFamily has to be set directly using STYLE
                        // the defer gives IE a chance to render the TextBox and to deal with font inheritance
                        this.defer(function(){
                                try{
                                        var s = domStyle.getComputedStyle(this.domNode); // can throw an exception if widget is immediately destroyed
                                        if(s){
                                                var ff = s.fontFamily;
                                                if(ff){
                                                        var inputs = this.domNode.getElementsByTagName("INPUT");
                                                        if(inputs){
                                                                for(var i=0; i < inputs.length; i++){
                                                                        inputs[i].style.fontFamily = ff;
                                                                }
                                                        }
                                                }
                                        }
                                }catch(e){/*when used in a Dialog, and this is called before the dialog is
                                 shown, s.fontFamily would trigger "Invalid Argument" error.*/}
                        });
                }
        },

        _setStyleAttr: function(/*String||Object*/ value){
                this.inherited(arguments);
                domClass.toggle(this.domNode, this.baseClass.replace(/\s+|$/g, "FixedWidth "), !!this.domNode.style.width);
        },

        isLoaded: function(){
                return this._isLoaded;
        },

        loadDropDown: function(/*Function*/ loadCallback){
                // summary:
                //              populates the menu
                this._loadChildren(true);
                this._isLoaded = true;
                loadCallback();
        },

        closeDropDown: function(){
                // overriding _HasDropDown.closeDropDown()
                this.inherited(arguments);

                if(this.dropDown && this.dropDown.menuTableNode){
                        // Erase possible width: 100% setting from _SelectMenu.resize().
                        // Leaving it would interfere with the next openDropDown() call, which
                        // queries the natural size of the drop down.
                        this.dropDown.menuTableNode.style.width = "";
                }
        },

        destroy: function(preserveDom){
                if(this.dropDown && !this.dropDown._destroyed){
                        this.dropDown.destroyRecursive(preserveDom);
                        delete this.dropDown;
                }
                this.inherited(arguments);
        },

        _onFocus: function(){
                this.validate(true);    // show tooltip if second focus of required tooltip, but no selection
                this.inherited(arguments);
        },

        _onBlur: function(){
                Tooltip.hide(this.domNode);
                this.inherited(arguments);
                this.validate(false);
        }
});

Select._Menu = _SelectMenu;     // for monkey patching

return Select;
});

},
'dojo/store/util/QueryResults':function(){
define("dojo/store/util/QueryResults", ["../../_base/array", "../../_base/lang", "../../_base/Deferred"
], function(array, lang, Deferred){

// module:
//              dojo/store/util/QueryResults

var QueryResults = function(results){
        // summary:
        //              A function that wraps the results of a store query with additional
        //              methods.
        // description:
        //              QueryResults is a basic wrapper that allows for array-like iteration
        //              over any kind of returned data from a query.  While the simplest store
        //              will return a plain array of data, other stores may return deferreds or
        //              promises; this wrapper makes sure that *all* results can be treated
        //              the same.
        //
        //              Additional methods include `forEach`, `filter` and `map`.
        // results: Array|dojo/promise/Promise
        //              The result set as an array, or a promise for an array.
        // returns:
        //              An array-like object that can be used for iterating over.
        // example:
        //              Query a store and iterate over the results.
        //
        //      |       store.query({ prime: true }).forEach(function(item){
        //      |               //      do something
        //      |       });

        if(!results){
                return results;
        }
        // if it is a promise it may be frozen
        if(results.then){
                results = lang.delegate(results);
        }
        function addIterativeMethod(method){
                if(!results[method]){
                        results[method] = function(){
                                var args = arguments;
                                return Deferred.when(results, function(results){
                                        Array.prototype.unshift.call(args, results);
                                        return QueryResults(array[method].apply(array, args));
                                });
                        };
                }
        }
        addIterativeMethod("forEach");
        addIterativeMethod("filter");
        addIterativeMethod("map");
        if(!results.total){
                results.total = Deferred.when(results, function(results){
                        return results.length;
                });
        }
        return results; // Object
};

lang.setObject("dojo.store.util.QueryResults", QueryResults);

return QueryResults;

});

},
'dijit/form/_ListBase':function(){
define("dijit/form/_ListBase", [
        "dojo/_base/declare",   // declare
        "dojo/on",
        "dojo/window" // winUtils.scrollIntoView
], function(declare, on, winUtils){

// module:
//              dijit/form/_ListBase

return declare( "dijit.form._ListBase", null, {
        // summary:
        //              Focus-less menu to handle UI events consistently
        //              Abstract methods that must be defined externally:
        //
        //              - onSelect: item is active (mousedown but not yet mouseup, or keyboard arrow selected but no Enter)
        //              - onDeselect:  cancels onSelect
        // tags:
        //              private

        // selected: DOMNode
        //              currently selected node
        selected: null,

        _listConnect: function(/*String|Function*/ eventType, /*String*/ callbackFuncName){
                // summary:
                //              Connects 'containerNode' to specified method of this object
                //              and automatically registers for 'disconnect' on widget destroy.
                // description:
                //              Provide widget-specific analog to 'connect'.
                //              The callback function is called with the normal event object,
                //              but also a second parameter is passed that indicates which list item
                //              actually received the event.
                // returns:
                //              A handle that can be passed to `disconnect` in order to disconnect
                //              before the widget is destroyed.
                // tags:
                //              private

                var self = this;
                return self.own(on(self.containerNode,
                        on.selector(
                                function(eventTarget, selector, target){
                                        return eventTarget.parentNode == target;
                                },
                                eventType
                        ),
                        function(evt){
                                evt.preventDefault();
                                self[callbackFuncName](evt, this);
                        }
                ));
        },

        selectFirstNode: function(){
                // summary:
                //              Select the first displayed item in the list.
                var first = this.containerNode.firstChild;
                while(first && first.style.display == "none"){
                        first = first.nextSibling;
                }
                this._setSelectedAttr(first);
        },

        selectLastNode: function(){
                // summary:
                //              Select the last displayed item in the list
                var last = this.containerNode.lastChild;
                while(last && last.style.display == "none"){
                        last = last.previousSibling;
                }
                this._setSelectedAttr(last);
        },

        selectNextNode: function(){
                // summary:
                //              Select the item just below the current selection.
                //              If nothing selected, select first node.
                var selectedNode = this.selected;
                if(!selectedNode){
                        this.selectFirstNode();
                }else{
                        var next = selectedNode.nextSibling;
                        while(next && next.style.display == "none"){
                                next = next.nextSibling;
                        }
                        if(!next){
                                this.selectFirstNode();
                        }else{
                                this._setSelectedAttr(next);
                        }
                }
        },

        selectPreviousNode: function(){
                // summary:
                //              Select the item just above the current selection.
                //              If nothing selected, select last node (if
                //              you select Previous and try to keep scrolling up the list).
                var selectedNode = this.selected;
                if(!selectedNode){
                        this.selectLastNode();
                }else{
                        var prev = selectedNode.previousSibling;
                        while(prev && prev.style.display == "none"){
                                prev = prev.previousSibling;
                        }
                        if(!prev){
                                this.selectLastNode();
                        }else{
                                this._setSelectedAttr(prev);
                        }
                }
        },

        _setSelectedAttr: function(/*DomNode*/ node){
                // summary:
                //              Does the actual select.
                if(this.selected != node){
                        var selectedNode = this.selected;
                        if(selectedNode){
                                this.onDeselect(selectedNode);
                                this.selected = null;
                        }
                        if(node){
                                this.selected = node;
                                winUtils.scrollIntoView(node);
                                this.onSelect(node);
                        }
                }else if(node){
                        this.onSelect(node);
                }
        }
});

});

},
'dijit/form/_FormWidget':function(){
define("dijit/form/_FormWidget", [
        "dojo/_base/declare",   // declare
        "dojo/has",                             // has("dijit-legacy-requires")
        "dojo/_base/kernel",    // kernel.deprecated
        "dojo/ready",
        "../_Widget",
        "../_CssStateMixin",
        "../_TemplatedMixin",
        "./_FormWidgetMixin"
], function(declare, has, kernel, ready, _Widget, _CssStateMixin, _TemplatedMixin, _FormWidgetMixin){


// module:
//              dijit/form/_FormWidget

// Back compat w/1.6, remove for 2.0
if(has("dijit-legacy-requires")){
        ready(0, function(){
                var requires = ["dijit/form/_FormValueWidget"];
                require(requires);      // use indirection so modules not rolled into a build
        });
}

return declare("dijit.form._FormWidget", [_Widget, _TemplatedMixin, _CssStateMixin, _FormWidgetMixin], {
        // summary:
        //              Base class for widgets corresponding to native HTML elements such as `<checkbox>` or `<button>`,
        //              which can be children of a `<form>` node or a `dijit/form/Form` widget.
        //
        // description:
        //              Represents a single HTML element.
        //              All these widgets should have these attributes just like native HTML input elements.
        //              You can set them during widget construction or afterwards, via `dijit/_WidgetBase.set()`.
        //
        //              They also share some common methods.

        setDisabled: function(/*Boolean*/ disabled){
                // summary:
                //              Deprecated.  Use set('disabled', ...) instead.
                kernel.deprecated("setDisabled("+disabled+") is deprecated. Use set('disabled',"+disabled+") instead.", "", "2.0");
                this.set('disabled', disabled);
        },

        setValue: function(/*String*/ value){
                // summary:
                //              Deprecated.  Use set('value', ...) instead.
                kernel.deprecated("dijit.form._FormWidget:setValue("+value+") is deprecated.  Use set('value',"+value+") instead.", "", "2.0");
                this.set('value', value);
        },

        getValue: function(){
                // summary:
                //              Deprecated.  Use get('value') instead.
                kernel.deprecated(this.declaredClass+"::getValue() is deprecated. Use get('value') instead.", "", "2.0");
                return this.get('value');
        },

        postMixInProperties: function(){
                // Setup name=foo string to be referenced from the template (but only if a name has been specified)
                // Unfortunately we can't use _setNameAttr to set the name due to IE limitations, see #8484, #8660.
                // Regarding escaping, see heading "Attribute values" in
                // http://www.w3.org/TR/REC-html40/appendix/notes.html#h-B.3.2
                this.nameAttrSetting = this.name ? ('name="' + this.name.replace(/"/g, "&quot;") + '"') : '';
                this.inherited(arguments);
        },

        // Override automatic assigning type --> focusNode, it causes exception on IE.
        // Instead, type must be specified as ${type} in the template, as part of the original DOM
        _setTypeAttr: null
});

});

},
'dojo/DeferredList':function(){
define("dojo/DeferredList", ["./_base/kernel", "./_base/Deferred", "./_base/array"], function(dojo, Deferred, darray){
        // module:
        //              dojo/DeferredList


dojo.DeferredList = function(/*Array*/ list, /*Boolean?*/ fireOnOneCallback, /*Boolean?*/ fireOnOneErrback, /*Boolean?*/ consumeErrors, /*Function?*/ canceller){
        // summary:
        //              Deprecated, use dojo/promise/all instead.
        //              Provides event handling for a group of Deferred objects.
        // description:
        //              DeferredList takes an array of existing deferreds and returns a new deferred of its own
        //              this new deferred will typically have its callback fired when all of the deferreds in
        //              the given list have fired their own deferreds.  The parameters `fireOnOneCallback` and
        //              fireOnOneErrback, will fire before all the deferreds as appropriate
        // list:
        //              The list of deferreds to be synchronizied with this DeferredList
        // fireOnOneCallback:
        //              Will cause the DeferredLists callback to be fired as soon as any
        //              of the deferreds in its list have been fired instead of waiting until
        //              the entire list has finished
        // fireonOneErrback:
        //              Will cause the errback to fire upon any of the deferreds errback
        // canceller:
        //              A deferred canceller function, see dojo.Deferred
        var resultList = [];
        Deferred.call(this);
        var self = this;
        if(list.length === 0 && !fireOnOneCallback){
                this.resolve([0, []]);
        }
        var finished = 0;
        darray.forEach(list, function(item, i){
                item.then(function(result){
                        if(fireOnOneCallback){
                                self.resolve([i, result]);
                        }else{
                                addResult(true, result);
                        }
                },function(error){
                        if(fireOnOneErrback){
                                self.reject(error);
                        }else{
                                addResult(false, error);
                        }
                        if(consumeErrors){
                                return null;
                        }
                        throw error;
                });
                function addResult(succeeded, result){
                        resultList[i] = [succeeded, result];
                        finished++;
                        if(finished === list.length){
                                self.resolve(resultList);
                        }

                }
        });
};
dojo.DeferredList.prototype = new Deferred();

dojo.DeferredList.prototype.gatherResults = function(deferredList){
        // summary:
        //              Gathers the results of the deferreds for packaging
        //              as the parameters to the Deferred Lists' callback
        // deferredList: dojo/DeferredList
        //              The deferred list from which this function gathers results.
        // returns: dojo/DeferredList
        //              The newly created deferred list which packs results as
        //              parameters to its callback.

        var d = new dojo.DeferredList(deferredList, false, true, false);
        d.addCallback(function(results){
                var ret = [];
                darray.forEach(results, function(result){
                        ret.push(result[1]);
                });
                return ret;
        });
        return d;
};

return dojo.DeferredList;
});

},
'dojo/dnd/common':function(){
define("dojo/dnd/common", ["../_base/connect", "../_base/kernel", "../_base/lang", "../dom"],
        function(connect, kernel, lang, dom){

// module:
//              dojo/dnd/common

var exports = lang.getObject("dojo.dnd", true);
/*=====
// TODO: for 2.0, replace line above with this code.
var exports = {
        // summary:
        //              TODOC
};
=====*/

exports.getCopyKeyState = connect.isCopyKey;

exports._uniqueId = 0;
exports.getUniqueId = function(){
        // summary:
        //              returns a unique string for use with any DOM element
        var id;
        do{
                id = kernel._scopeName + "Unique" + (++exports._uniqueId);
        }while(dom.byId(id));
        return id;
};

exports._empty = {};

exports.isFormElement = function(/*Event*/ e){
        // summary:
        //              returns true if user clicked on a form element
        var t = e.target;
        if(t.nodeType == 3 /*TEXT_NODE*/){
                t = t.parentNode;
        }
        return " button textarea input select option ".indexOf(" " + t.tagName.toLowerCase() + " ") >= 0;       // Boolean
};

return exports;
});

},
'dijit/Viewport':function(){
define("dijit/Viewport", [
        "dojo/Evented",
        "dojo/on",
        "dojo/ready",
        "dojo/sniff",
        "dojo/_base/window", // global
        "dojo/window" // getBox()
], function(Evented, on, ready, has, win, winUtils){

        // module:
        //              dijit/Viewport

        /*=====
        return {
                // summary:
                //              Utility singleton to watch for viewport resizes, avoiding duplicate notifications
                //              which can lead to infinite loops.
                // description:
                //              Usage: Viewport.on("resize", myCallback).
                //
                //              myCallback() is called without arguments in case it's _WidgetBase.resize(),
                //              which would interpret the argument as the size to make the widget.
        };
        =====*/

        var Viewport = new Evented();

        ready(200, function(){
                var oldBox = winUtils.getBox();
                Viewport._rlh = on(win.global, "resize", function(){
                        var newBox = winUtils.getBox();
                        if(oldBox.h == newBox.h && oldBox.w == newBox.w){ return; }
                        oldBox = newBox;
                        Viewport.emit("resize");
                });

                // Also catch zoom changes on IE8, since they don't naturally generate resize events
                if(has("ie") == 8){
                        var deviceXDPI = screen.deviceXDPI;
                        setInterval(function(){
                                if(screen.deviceXDPI != deviceXDPI){
                                        deviceXDPI = screen.deviceXDPI;
                                        Viewport.emit("resize");
                                }
                        }, 500);
                }
        });

        return Viewport;
});

},
'dijit/_base/place':function(){
define("dijit/_base/place", [
        "dojo/_base/array", // array.forEach
        "dojo/_base/lang", // lang.isArray, lang.mixin
        "dojo/window", // windowUtils.getBox
        "../place",
        "../main"       // export to dijit namespace
], function(array, lang, windowUtils, place, dijit){

        // module:
        //              dijit/_base/place


        var exports = {
                // summary:
                //              Deprecated back compatibility module, new code should use dijit/place directly instead of using this module.
        };

        exports.getViewport = function(){
                // summary:
                //              Deprecated method to return the dimensions and scroll position of the viewable area of a browser window.
                //              New code should use windowUtils.getBox()

                return windowUtils.getBox();
        };

        exports.placeOnScreen = place.at;

        exports.placeOnScreenAroundElement = function(node, aroundNode, aroundCorners, layoutNode){
                // summary:
                //              Like dijit.placeOnScreenAroundNode(), except it accepts an arbitrary object
                //              for the "around" argument and finds a proper processor to place a node.
                //              Deprecated, new code should use dijit/place.around() instead.

                // Convert old style {"BL": "TL", "BR": "TR"} type argument
                // to style needed by dijit.place code:
                //              [
                //                      {aroundCorner: "BL", corner: "TL" },
                //                      {aroundCorner: "BR", corner: "TR" }
                //              ]
                var positions;
                if(lang.isArray(aroundCorners)){
                        positions = aroundCorners;
                }else{
                        positions = [];
                        for(var key in aroundCorners){
                                positions.push({aroundCorner: key, corner: aroundCorners[key]});
                        }
                }

                return place.around(node, aroundNode, positions, true, layoutNode);
        };

        exports.placeOnScreenAroundNode = exports.placeOnScreenAroundElement;
        /*=====
        exports.placeOnScreenAroundNode = function(node, aroundNode, aroundCorners, layoutNode){
                // summary:
                //              Position node adjacent or kitty-corner to aroundNode
                //              such that it's fully visible in viewport.
                //              Deprecated, new code should use dijit/place.around() instead.
        };
        =====*/

        exports.placeOnScreenAroundRectangle = exports.placeOnScreenAroundElement;
        /*=====
        exports.placeOnScreenAroundRectangle = function(node, aroundRect, aroundCorners, layoutNode){
                // summary:
                //              Like dijit.placeOnScreenAroundNode(), except that the "around"
                //              parameter is an arbitrary rectangle on the screen (x, y, width, height)
                //              instead of a dom node.
                //              Deprecated, new code should use dijit/place.around() instead.
        };
        =====*/

        exports.getPopupAroundAlignment = function(/*Array*/ position, /*Boolean*/ leftToRight){
                // summary:
                //              Deprecated method, unneeded when using dijit/place directly.
                //              Transforms the passed array of preferred positions into a format suitable for
                //              passing as the aroundCorners argument to dijit/place.placeOnScreenAroundElement.
                // position: String[]
                //              This variable controls the position of the drop down.
                //              It's an array of strings with the following values:
                //
                //              - before: places drop down to the left of the target node/widget, or to the right in
                //                the case of RTL scripts like Hebrew and Arabic
                //              - after: places drop down to the right of the target node/widget, or to the left in
                //                the case of RTL scripts like Hebrew and Arabic
                //              - above: drop down goes above target node
                //              - below: drop down goes below target node
                //
                //              The list is positions is tried, in order, until a position is found where the drop down fits
                //              within the viewport.
                // leftToRight: Boolean
                //              Whether the popup will be displaying in leftToRight mode.

                var align = {};
                array.forEach(position, function(pos){
                        var ltr = leftToRight;
                        switch(pos){
                                case "after":
                                        align[leftToRight ? "BR" : "BL"] = leftToRight ? "BL" : "BR";
                                        break;
                                case "before":
                                        align[leftToRight ? "BL" : "BR"] = leftToRight ? "BR" : "BL";
                                        break;
                                case "below-alt":
                                        ltr = !ltr;
                                        // fall through
                                case "below":
                                        // first try to align left borders, next try to align right borders (or reverse for RTL mode)
                                        align[ltr ? "BL" : "BR"] = ltr ? "TL" : "TR";
                                        align[ltr ? "BR" : "BL"] = ltr ? "TR" : "TL";
                                        break;
                                case "above-alt":
                                        ltr = !ltr;
                                        // fall through
                                case "above":
                                default:
                                        // first try to align left borders, next try to align right borders (or reverse for RTL mode)
                                        align[ltr ? "TL" : "TR"] = ltr ? "BL" : "BR";
                                        align[ltr ? "TR" : "TL"] = ltr ? "BR" : "BL";
                                        break;
                        }
                });
                return align;
        };

        lang.mixin(dijit, exports);

        /*===== return exports; =====*/
        return dijit;   // for back compat :-(
});

},
'dijit/MenuSeparator':function(){
require({cache:{
'url:dijit/templates/MenuSeparator.html':"<tr class=\"dijitMenuSeparator\">\n\t<td class=\"dijitMenuSeparatorIconCell\">\n\t\t<div class=\"dijitMenuSeparatorTop\"></div>\n\t\t<div class=\"dijitMenuSeparatorBottom\"></div>\n\t</td>\n\t<td colspan=\"3\" class=\"dijitMenuSeparatorLabelCell\">\n\t\t<div class=\"dijitMenuSeparatorTop dijitMenuSeparatorLabel\"></div>\n\t\t<div class=\"dijitMenuSeparatorBottom\"></div>\n\t</td>\n</tr>"}});
define("dijit/MenuSeparator", [
        "dojo/_base/declare", // declare
        "dojo/dom", // dom.setSelectable
        "./_WidgetBase",
        "./_TemplatedMixin",
        "./_Contained",
        "dojo/text!./templates/MenuSeparator.html"
], function(declare, dom, _WidgetBase, _TemplatedMixin, _Contained, template){

        // module:
        //              dijit/MenuSeparator

        return declare("dijit.MenuSeparator", [_WidgetBase, _TemplatedMixin, _Contained], {
                // summary:
                //              A line between two menu items

                templateString: template,

                buildRendering: function(){
                        this.inherited(arguments);
                        dom.setSelectable(this.domNode, false);
                },

                isFocusable: function(){
                        // summary:
                        //              Override to always return false
                        // tags:
                        //              protected

                        return false; // Boolean
                }
        });
});

},
'dijit/form/_ComboBoxMenu':function(){
define("dijit/form/_ComboBoxMenu", [
        "dojo/_base/declare", // declare
        "dojo/dom-class", // domClass.add domClass.remove
        "dojo/dom-style", // domStyle.get
        "dojo/keys", // keys.DOWN_ARROW keys.PAGE_DOWN keys.PAGE_UP keys.UP_ARROW
        "../_WidgetBase",
        "../_TemplatedMixin",
        "./_ComboBoxMenuMixin",
        "./_ListMouseMixin"
], function(declare, domClass, domStyle, keys,
                        _WidgetBase, _TemplatedMixin, _ComboBoxMenuMixin, _ListMouseMixin){


        // module:
        //              dijit/form/_ComboBoxMenu

        return declare("dijit.form._ComboBoxMenu",[_WidgetBase, _TemplatedMixin, _ListMouseMixin, _ComboBoxMenuMixin], {
                // summary:
                //              Focus-less menu for internal use in `dijit/form/ComboBox`
                //              Abstract methods that must be defined externally:
                //
                //              - onChange: item was explicitly chosen (mousedown somewhere on the menu and mouseup somewhere on the menu)
                //              - onPage: next(1) or previous(-1) button pressed
                // tags:
                //              private

                templateString: "<div class='dijitReset dijitMenu' data-dojo-attach-point='containerNode' style='overflow: auto; overflow-x: hidden;' role='listbox'>"
                                +"<div class='dijitMenuItem dijitMenuPreviousButton' data-dojo-attach-point='previousButton' role='option'></div>"
                                +"<div class='dijitMenuItem dijitMenuNextButton' data-dojo-attach-point='nextButton' role='option'></div>"
                                +"</div>",

                baseClass: "dijitComboBoxMenu",

                postCreate: function(){
                        this.inherited(arguments);
                        if(!this.isLeftToRight()){
                                domClass.add(this.previousButton, "dijitMenuItemRtl");
                                domClass.add(this.nextButton, "dijitMenuItemRtl");
                        }
                },

                _createMenuItem: function(){
                        // note: not using domConstruct.create() because need to specify document
                        var item = this.ownerDocument.createElement("div");
                        item.className = "dijitReset dijitMenuItem" +(this.isLeftToRight() ? "" : " dijitMenuItemRtl");
                        item.setAttribute("role", "option");
                        return item;
                },

                onHover: function(/*DomNode*/ node){
                        // summary:
                        //              Add hover CSS
                        domClass.add(node, "dijitMenuItemHover");
                },

                onUnhover: function(/*DomNode*/ node){
                        // summary:
                        //              Remove hover CSS
                        domClass.remove(node, "dijitMenuItemHover");
                },

                onSelect: function(/*DomNode*/ node){
                        // summary:
                        //              Add selected CSS
                        domClass.add(node, "dijitMenuItemSelected");
                },

                onDeselect: function(/*DomNode*/ node){
                        // summary:
                        //              Remove selected CSS
                        domClass.remove(node, "dijitMenuItemSelected");
                },

                _page: function(/*Boolean*/ up){
                        // summary:
                        //              Handles page-up and page-down keypresses

                        var scrollamount = 0;
                        var oldscroll = this.domNode.scrollTop;
                        var height = domStyle.get(this.domNode, "height");
                        // if no item is highlighted, highlight the first option
                        if(!this.getHighlightedOption()){
                                this.selectNextNode();
                        }
                        while(scrollamount<height){
                                var highlighted_option = this.getHighlightedOption();
                                if(up){
                                        // stop at option 1
                                        if(!highlighted_option.previousSibling ||
                                                highlighted_option.previousSibling.style.display == "none"){
                                                break;
                                        }
                                        this.selectPreviousNode();
                                }else{
                                        // stop at last option
                                        if(!highlighted_option.nextSibling ||
                                                highlighted_option.nextSibling.style.display == "none"){
                                                break;
                                        }
                                        this.selectNextNode();
                                }
                                // going backwards
                                var newscroll = this.domNode.scrollTop;
                                scrollamount += (newscroll-oldscroll)*(up ? -1:1);
                                oldscroll = newscroll;
                        }
                },

                handleKey: function(evt){
                        // summary:
                        //              Handle keystroke event forwarded from ComboBox, returning false if it's
                        //              a keystroke I recognize and process, true otherwise.
                        switch(evt.keyCode){
                                case keys.DOWN_ARROW:
                                        this.selectNextNode();
                                        return false;
                                case keys.PAGE_DOWN:
                                        this._page(false);
                                        return false;
                                case keys.UP_ARROW:
                                        this.selectPreviousNode();
                                        return false;
                                case keys.PAGE_UP:
                                        this._page(true);
                                        return false;
                                default:
                                        return true;
                        }
                }
        });
});

},
'url:dijit/layout/templates/ScrollingTabController.html':"<div class=\"dijitTabListContainer-${tabPosition}\" style=\"visibility:hidden\">\n\t<div data-dojo-type=\"dijit.layout._ScrollingTabControllerMenuButton\"\n\t\t\tclass=\"tabStripButton-${tabPosition}\"\n\t\t\tid=\"${id}_menuBtn\"\n\t\t\tdata-dojo-props=\"containerId: '${containerId}', iconClass: 'dijitTabStripMenuIcon',\n\t\t\t\t\tdropDownPosition: ['below-alt', 'above-alt']\"\n\t\t\tdata-dojo-attach-point=\"_menuBtn\" showLabel=\"false\" title=\"\">&#9660;</div>\n\t<div data-dojo-type=\"dijit.layout._ScrollingTabControllerButton\"\n\t\t\tclass=\"tabStripButton-${tabPosition}\"\n\t\t\tid=\"${id}_leftBtn\"\n\t\t\tdata-dojo-props=\"iconClass:'dijitTabStripSlideLeftIcon', showLabel:false, title:''\"\n\t\t\tdata-dojo-attach-point=\"_leftBtn\" data-dojo-attach-event=\"onClick: doSlideLeft\">&#9664;</div>\n\t<div data-dojo-type=\"dijit.layout._ScrollingTabControllerButton\"\n\t\t\tclass=\"tabStripButton-${tabPosition}\"\n\t\t\tid=\"${id}_rightBtn\"\n\t\t\tdata-dojo-props=\"iconClass:'dijitTabStripSlideRightIcon', showLabel:false, title:''\"\n\t\t\tdata-dojo-attach-point=\"_rightBtn\" data-dojo-attach-event=\"onClick: doSlideRight\">&#9654;</div>\n\t<div class='dijitTabListWrapper' data-dojo-attach-point='tablistWrapper'>\n\t\t<div role='tablist' data-dojo-attach-event='onkeypress:onkeypress'\n\t\t\t\tdata-dojo-attach-point='containerNode' class='nowrapTabStrip'></div>\n\t</div>\n</div>",
'dijit/Dialog':function(){
require({cache:{
'url:dijit/templates/Dialog.html':"<div class=\"dijitDialog\" role=\"dialog\" aria-labelledby=\"${id}_title\">\n\t<div data-dojo-attach-point=\"titleBar\" class=\"dijitDialogTitleBar\">\n\t\t<span data-dojo-attach-point=\"titleNode\" class=\"dijitDialogTitle\" id=\"${id}_title\"\n\t\t\t\trole=\"heading\" level=\"1\"></span>\n\t\t<span data-dojo-attach-point=\"closeButtonNode\" class=\"dijitDialogCloseIcon\" data-dojo-attach-event=\"ondijitclick: onCancel\" title=\"${buttonCancel}\" role=\"button\" tabIndex=\"-1\">\n\t\t\t<span data-dojo-attach-point=\"closeText\" class=\"closeText\" title=\"${buttonCancel}\">x</span>\n\t\t</span>\n\t</div>\n\t<div data-dojo-attach-point=\"containerNode\" class=\"dijitDialogPaneContent\"></div>\n</div>\n"}});
define("dijit/Dialog", [
        "require",
        "dojo/_base/array", // array.forEach array.indexOf array.map
        "dojo/_base/connect", // connect._keypress
        "dojo/_base/declare", // declare
        "dojo/_base/Deferred", // Deferred
        "dojo/dom", // dom.isDescendant
        "dojo/dom-class", // domClass.add domClass.contains
        "dojo/dom-geometry", // domGeometry.position
        "dojo/dom-style", // domStyle.set
        "dojo/_base/event", // event.stop
        "dojo/_base/fx", // fx.fadeIn fx.fadeOut
        "dojo/i18n", // i18n.getLocalization
        "dojo/keys",
        "dojo/_base/lang", // lang.mixin lang.hitch
        "dojo/on",
        "dojo/ready",
        "dojo/sniff", // has("ie") has("opera") has("dijit-legacy-requires")
        "dojo/window", // winUtils.getBox, winUtils.get
        "dojo/dnd/Moveable", // Moveable
        "dojo/dnd/TimedMoveable", // TimedMoveable
        "./focus",
        "./_base/manager",      // manager.defaultDuration
        "./_Widget",
        "./_TemplatedMixin",
        "./_CssStateMixin",
        "./form/_FormMixin",
        "./_DialogMixin",
        "./DialogUnderlay",
        "./layout/ContentPane",
        "dojo/text!./templates/Dialog.html",
        "./main",                       // for back-compat, exporting dijit._underlay (remove in 2.0)
        "dojo/i18n!./nls/common"
], function(require, array, connect, declare, Deferred,
                        dom, domClass, domGeometry, domStyle, event, fx, i18n, keys, lang, on, ready, has, winUtils,
                        Moveable, TimedMoveable, focus, manager, _Widget, _TemplatedMixin, _CssStateMixin, _FormMixin, _DialogMixin,
                        DialogUnderlay, ContentPane, template, dijit){

        // module:
        //              dijit/Dialog

        /*=====
        dijit._underlay = function(kwArgs){
                // summary:
                //              A shared instance of a `dijit.DialogUnderlay`
                //
                // description:
                //              A shared instance of a `dijit.DialogUnderlay` created and
                //              used by `dijit.Dialog`, though never created until some Dialog
                //              or subclass thereof is shown.
        };
        =====*/

        var _DialogBase = declare("dijit._DialogBase", [_TemplatedMixin, _FormMixin, _DialogMixin, _CssStateMixin], {
                templateString: template,

                baseClass: "dijitDialog",

                cssStateNodes: {
                        closeButtonNode: "dijitDialogCloseIcon"
                },

                // Map widget attributes to DOMNode attributes.
                _setTitleAttr: [
                        { node: "titleNode", type: "innerHTML" },
                        { node: "titleBar", type: "attribute" }
                ],

                // open: [readonly] Boolean
                //              True if Dialog is currently displayed on screen.
                open: false,

                // duration: Integer
                //              The time in milliseconds it takes the dialog to fade in and out
                duration: manager.defaultDuration,

                // refocus: Boolean
                //              A Toggle to modify the default focus behavior of a Dialog, which
                //              is to re-focus the element which had focus before being opened.
                //              False will disable refocusing. Default: true
                refocus: true,

                // autofocus: Boolean
                //              A Toggle to modify the default focus behavior of a Dialog, which
                //              is to focus on the first dialog element after opening the dialog.
                //              False will disable autofocusing. Default: true
                autofocus: true,

                // _firstFocusItem: [private readonly] DomNode
                //              The pointer to the first focusable node in the dialog.
                //              Set by `dijit/_DialogMixin._getFocusItems()`.
                _firstFocusItem: null,

                // _lastFocusItem: [private readonly] DomNode
                //              The pointer to which node has focus prior to our dialog.
                //              Set by `dijit/_DialogMixin._getFocusItems()`.
                _lastFocusItem: null,

                // doLayout: [protected] Boolean
                //              Don't change this parameter from the default value.
                //              This ContentPane parameter doesn't make sense for Dialog, since Dialog
                //              is never a child of a layout container, nor can you specify the size of
                //              Dialog in order to control the size of an inner widget.
                doLayout: false,

                // draggable: Boolean
                //              Toggles the moveable aspect of the Dialog. If true, Dialog
                //              can be dragged by it's title. If false it will remain centered
                //              in the viewport.
                draggable: true,

                _setDraggableAttr: function(/*Boolean*/ val){
                        // Avoid _WidgetBase behavior of copying draggable attribute to this.domNode,
                        // as that prevents text select on modern browsers (#14452)
                        this._set("draggable", val);
                },

                // aria-describedby: String
                //              Allows the user to add an aria-describedby attribute onto the dialog. The value should
                //              be the id of the container element of text that describes the dialog purpose (usually
                //              the first text in the dialog).
                //      |       <div data-dojo-type="dijit/Dialog" aria-describedby="intro" .....>
                //      |               <div id="intro">Introductory text</div>
                //      |               <div>rest of dialog contents</div>
                //      |       </div>
                "aria-describedby": "",

                // maxRatio: Number
                //              Maximum size to allow the dialog to expand to, relative to viewport size
                maxRatio: 0.9,

                postMixInProperties: function(){
                        var _nlsResources = i18n.getLocalization("dijit", "common");
                        lang.mixin(this, _nlsResources);
                        this.inherited(arguments);
                },

                postCreate: function(){
                        domStyle.set(this.domNode, {
                                display: "none",
                                position:"absolute"
                        });
                        this.ownerDocumentBody.appendChild(this.domNode);

                        this.inherited(arguments);

                        this.connect(this, "onExecute", "hide");
                        this.connect(this, "onCancel", "hide");
                        this._modalconnects = [];
                },

                onLoad: function(){
                        // summary:
                        //              Called when data has been loaded from an href.
                        //              Unlike most other callbacks, this function can be connected to (via `dojo.connect`)
                        //              but should *not* be overridden.
                        // tags:
                        //              callback

                        // when href is specified we need to reposition the dialog after the data is loaded
                        // and find the focusable elements
                        this._position();
                        if(this.autofocus && DialogLevelManager.isTop(this)){
                                this._getFocusItems(this.domNode);
                                focus.focus(this._firstFocusItem);
                        }
                        this.inherited(arguments);
                },

                _onBlur: function(by){
                        this.inherited(arguments);

                        // If focus was accidentally removed from the dialog, such as if the user clicked a blank
                        // area of the screen, or clicked the browser's address bar and then tabbed into the page,
                        // then refocus.   Won't do anything if focus was removed because the Dialog was closed, or
                        // because a new Dialog popped up on top of the old one.
                        var refocus = lang.hitch(this, function(){
                                if(this.open && !this._destroyed && DialogLevelManager.isTop(this)){
                                        this._getFocusItems(this.domNode);
                                        focus.focus(this._firstFocusItem);
                                }
                        });
                        if(by == "mouse"){
                                // wait for mouse up, and then refocus dialog; otherwise doesn't work
                                on.once(this.ownerDocument, "mouseup", refocus);
                        }else{
                                refocus();
                        }
                },

                _endDrag: function(){
                        // summary:
                        //              Called after dragging the Dialog. Saves the position of the dialog in the viewport,
                        //              and also adjust position to be fully within the viewport, so user doesn't lose access to handle
                        var nodePosition = domGeometry.position(this.domNode),
                                viewport = winUtils.getBox(this.ownerDocument);
                        nodePosition.y = Math.min(Math.max(nodePosition.y, 0), (viewport.h - nodePosition.h));
                        nodePosition.x = Math.min(Math.max(nodePosition.x, 0), (viewport.w - nodePosition.w));
                        this._relativePosition = nodePosition;
                        this._position();
                },

                _setup: function(){
                        // summary:
                        //              Stuff we need to do before showing the Dialog for the first
                        //              time (but we defer it until right beforehand, for
                        //              performance reasons).
                        // tags:
                        //              private

                        var node = this.domNode;

                        if(this.titleBar && this.draggable){
                                this._moveable = new ((has("ie") == 6) ? TimedMoveable // prevent overload, see #5285
                                        : Moveable)(node, { handle: this.titleBar });
                                this.connect(this._moveable, "onMoveStop", "_endDrag");
                        }else{
                                domClass.add(node,"dijitDialogFixed");
                        }

                        this.underlayAttrs = {
                                dialogId: this.id,
                                "class": array.map(this["class"].split(/\s/), function(s){ return s+"_underlay"; }).join(" "),
                                ownerDocument: this.ownerDocument
                        };
                },

                _size: function(){
                        // summary:
                        //              If necessary, shrink dialog contents so dialog fits in viewport
                        // tags:
                        //              private

                        this._checkIfSingleChild();

                        // If we resized the dialog contents earlier, reset them back to original size, so
                        // that if the user later increases the viewport size, the dialog can display w/out a scrollbar.
                        // Need to do this before the domGeometry.position(this.domNode) call below.
                        if(this._singleChild){
                                if(typeof this._singleChildOriginalStyle != "undefined"){
                                        this._singleChild.domNode.style.cssText = this._singleChildOriginalStyle;
                                        delete this._singleChildOriginalStyle;
                                }
                        }else{
                                domStyle.set(this.containerNode, {
                                        width:"auto",
                                        height:"auto"
                                });
                        }

                        var bb = domGeometry.position(this.domNode);

                        // Get viewport size but then reduce it by a bit; Dialog should always have some space around it
                        // to indicate that it's a popup.  This will also compensate for possible scrollbars on viewport.
                        var viewport = winUtils.getBox(this.ownerDocument);
                        viewport.w *= this.maxRatio;
                        viewport.h *= this.maxRatio;

                        if(bb.w >= viewport.w || bb.h >= viewport.h){
                                // Reduce size of dialog contents so that dialog fits in viewport

                                var containerSize = domGeometry.position(this.containerNode),
                                        w = Math.min(bb.w, viewport.w) - (bb.w - containerSize.w),
                                        h = Math.min(bb.h, viewport.h) - (bb.h - containerSize.h);

                                if(this._singleChild && this._singleChild.resize){
                                        if(typeof this._singleChildOriginalStyle == "undefined"){
                                                this._singleChildOriginalStyle = this._singleChild.domNode.style.cssText;
                                        }
                                        this._singleChild.resize({w: w, h: h});
                                }else{
                                        domStyle.set(this.containerNode, {
                                                width: w + "px",
                                                height: h + "px",
                                                overflow: "auto",
                                                position: "relative"    // workaround IE bug moving scrollbar or dragging dialog
                                        });
                                }
                        }else{
                                if(this._singleChild && this._singleChild.resize){
                                        this._singleChild.resize();
                                }
                        }
                },

                _position: function(){
                        // summary:
                        //              Position modal dialog in the viewport. If no relative offset
                        //              in the viewport has been determined (by dragging, for instance),
                        //              center the node. Otherwise, use the Dialog's stored relative offset,
                        //              and position the node to top: left: values based on the viewport.
                        if(!domClass.contains(this.ownerDocumentBody, "dojoMove")){     // don't do anything if called during auto-scroll
                                var node = this.domNode,
                                        viewport = winUtils.getBox(this.ownerDocument),
                                        p = this._relativePosition,
                                        bb = p ? null : domGeometry.position(node),
                                        l = Math.floor(viewport.l + (p ? p.x : (viewport.w - bb.w) / 2)),
                                        t = Math.floor(viewport.t + (p ? p.y : (viewport.h - bb.h) / 2))
                                ;
                                domStyle.set(node,{
                                        left: l + "px",
                                        top: t + "px"
                                });
                        }
                },

                _onKey: function(/*Event*/ evt){
                        // summary:
                        //              Handles the keyboard events for accessibility reasons
                        // tags:
                        //              private

                        if(evt.charOrCode){
                                var node = evt.target;
                                if(evt.charOrCode === keys.TAB){
                                        this._getFocusItems(this.domNode);
                                }
                                var singleFocusItem = (this._firstFocusItem == this._lastFocusItem);
                                // see if we are shift-tabbing from first focusable item on dialog
                                if(node == this._firstFocusItem && evt.shiftKey && evt.charOrCode === keys.TAB){
                                        if(!singleFocusItem){
                                                focus.focus(this._lastFocusItem); // send focus to last item in dialog
                                        }
                                        event.stop(evt);
                                }else if(node == this._lastFocusItem && evt.charOrCode === keys.TAB && !evt.shiftKey){
                                        if(!singleFocusItem){
                                                focus.focus(this._firstFocusItem); // send focus to first item in dialog
                                        }
                                        event.stop(evt);
                                }else{
                                        // see if the key is for the dialog
                                        while(node){
                                                if(node == this.domNode || domClass.contains(node, "dijitPopup")){
                                                        if(evt.charOrCode == keys.ESCAPE){
                                                                this.onCancel();
                                                        }else{
                                                                return; // just let it go
                                                        }
                                                }
                                                node = node.parentNode;
                                        }
                                        // this key is for the disabled document window
                                        if(evt.charOrCode !== keys.TAB){ // allow tabbing into the dialog for a11y
                                                event.stop(evt);
                                        // opera won't tab to a div
                                        }else if(!has("opera")){
                                                try{
                                                        this._firstFocusItem.focus();
                                                }catch(e){ /*squelch*/ }
                                        }
                                }
                        }
                },

                show: function(){
                        // summary:
                        //              Display the dialog
                        // returns: dojo/_base/Deferred
                        //              Deferred object that resolves when the display animation is complete

                        if(this.open){ return; }

                        if(!this._started){
                                this.startup();
                        }

                        // first time we show the dialog, there's some initialization stuff to do
                        if(!this._alreadyInitialized){
                                this._setup();
                                this._alreadyInitialized=true;
                        }

                        if(this._fadeOutDeferred){
                                this._fadeOutDeferred.cancel();
                        }

                        // Recenter Dialog if user scrolls browser.  Connecting to document doesn't work on IE, need to use window.
                        var win = winUtils.get(this.ownerDocument);
                        this._modalconnects.push(on(win, "scroll", lang.hitch(this, "resize")));

                        this._modalconnects.push(on(this.domNode, connect._keypress, lang.hitch(this, "_onKey")));

                        domStyle.set(this.domNode, {
                                opacity:0,
                                display:""
                        });

                        this._set("open", true);
                        this._onShow(); // lazy load trigger

                        this._size();
                        this._position();

                        // fade-in Animation object, setup below
                        var fadeIn;

                        this._fadeInDeferred = new Deferred(lang.hitch(this, function(){
                                fadeIn.stop();
                                delete this._fadeInDeferred;
                        }));

                        fadeIn = fx.fadeIn({
                                node: this.domNode,
                                duration: this.duration,
                                beforeBegin: lang.hitch(this, function(){
                                        DialogLevelManager.show(this, this.underlayAttrs);
                                }),
                                onEnd: lang.hitch(this, function(){
                                        if(this.autofocus && DialogLevelManager.isTop(this)){
                                                // find focusable items each time dialog is shown since if dialog contains a widget the
                                                // first focusable items can change
                                                this._getFocusItems(this.domNode);
                                                focus.focus(this._firstFocusItem);
                                        }
                                        this._fadeInDeferred.resolve(true);
                                        delete this._fadeInDeferred;
                                })
                        }).play();

                        return this._fadeInDeferred;
                },

                hide: function(){
                        // summary:
                        //              Hide the dialog
                        // returns: dojo/_base/Deferred
                        //              Deferred object that resolves when the hide animation is complete

                        // If we haven't been initialized yet then we aren't showing and we can just return.
                        // Likewise if we are already hidden, or are currently fading out.
                        if(!this._alreadyInitialized || !this.open){
                                return;
                        }
                        if(this._fadeInDeferred){
                                this._fadeInDeferred.cancel();
                        }

                        // fade-in Animation object, setup below
                        var fadeOut;

                        this._fadeOutDeferred = new Deferred(lang.hitch(this, function(){
                                fadeOut.stop();
                                delete this._fadeOutDeferred;
                        }));
                        // fire onHide when the promise resolves.
                        this._fadeOutDeferred.then(lang.hitch(this, 'onHide'));

                        fadeOut = fx.fadeOut({
                                node: this.domNode,
                                duration: this.duration,
                                onEnd: lang.hitch(this, function(){
                                        this.domNode.style.display = "none";
                                        DialogLevelManager.hide(this);
                                        this._fadeOutDeferred.resolve(true);
                                        delete this._fadeOutDeferred;
                                })
                         }).play();

                        if(this._scrollConnected){
                                this._scrollConnected = false;
                        }
                        var h;
                        while(h = this._modalconnects.pop()){
                                h.remove();
                        }

                        if(this._relativePosition){
                                delete this._relativePosition;
                        }
                        this._set("open", false);

                        return this._fadeOutDeferred;
                },

                resize: function(){
                        // summary:
                        //              Called when viewport scrolled or size changed.  Position the Dialog and the underlay.
                        // tags:
                        //              private
                        if(this.domNode.style.display != "none"){
                                if(DialogUnderlay._singleton){  // avoid race condition during show()
                                        DialogUnderlay._singleton.layout();
                                }
                                this._position();
                                this._size();
                        }
                },

                destroy: function(){
                        if(this._fadeInDeferred){
                                this._fadeInDeferred.cancel();
                        }
                        if(this._fadeOutDeferred){
                                this._fadeOutDeferred.cancel();
                        }
                        if(this._moveable){
                                this._moveable.destroy();
                        }
                        var h;
                        while(h = this._modalconnects.pop()){
                                h.remove();
                        }

                        DialogLevelManager.hide(this);

                        this.inherited(arguments);
                }
        });

        var Dialog = declare("dijit.Dialog", [ContentPane, _DialogBase], {
                // summary:
                //              A modal dialog Widget.
                // description:
                //              Pops up a modal dialog window, blocking access to the screen
                //              and also graying out the screen Dialog is extended from
                //              ContentPane so it supports all the same parameters (href, etc.).
                // example:
                // |    <div data-dojo-type="dijit/Dialog" data-dojo-props="href: 'test.html'"></div>
                // example:
                // |    var foo = new Dialog({ title: "test dialog", content: "test content" };
                // |    foo.placeAt(win.body());
                // |    foo.startup();
        });
        Dialog._DialogBase = _DialogBase;       // for monkey patching and dojox/widget/DialogSimple

        var DialogLevelManager = Dialog._DialogLevelManager = {
                // summary:
                //              Controls the various active "levels" on the page, starting with the
                //              stuff initially visible on the page (at z-index 0), and then having an entry for
                //              each Dialog shown.

                _beginZIndex: 950,

                show: function(/*dijit/_WidgetBase*/ dialog, /*Object*/ underlayAttrs){
                        // summary:
                        //              Call right before fade-in animation for new dialog.
                        //              Saves current focus, displays/adjusts underlay for new dialog,
                        //              and sets the z-index of the dialog itself.
                        //
                        //              New dialog will be displayed on top of all currently displayed dialogs.
                        //
                        //              Caller is responsible for setting focus in new dialog after the fade-in
                        //              animation completes.

                        // Save current focus
                        ds[ds.length-1].focus = focus.curNode;

                        // Display the underlay, or if already displayed then adjust for this new dialog
                        // TODO: one underlay per document (based on dialog.ownerDocument)
                        var underlay = DialogUnderlay._singleton;
                        if(!underlay || underlay._destroyed){
                                underlay = dijit._underlay = DialogUnderlay._singleton = new DialogUnderlay(underlayAttrs);
                        }else{
                                underlay.set(dialog.underlayAttrs);
                        }

                        // Set z-index a bit above previous dialog
                        var zIndex = ds[ds.length-1].dialog ? ds[ds.length-1].zIndex + 2 : Dialog._DialogLevelManager._beginZIndex;
                        if(ds.length == 1){     // first dialog
                                underlay.show();
                        }
                        domStyle.set(DialogUnderlay._singleton.domNode, 'zIndex', zIndex - 1);

                        // Dialog
                        domStyle.set(dialog.domNode, 'zIndex', zIndex);

                        ds.push({dialog: dialog, underlayAttrs: underlayAttrs, zIndex: zIndex});
                },

                hide: function(/*dijit/_WidgetBase*/ dialog){
                        // summary:
                        //              Called when the specified dialog is hidden/destroyed, after the fade-out
                        //              animation ends, in order to reset page focus, fix the underlay, etc.
                        //              If the specified dialog isn't open then does nothing.
                        //
                        //              Caller is responsible for either setting display:none on the dialog domNode,
                        //              or calling dijit/popup.hide(), or removing it from the page DOM.

                        if(ds[ds.length-1].dialog == dialog){
                                // Removing the top (or only) dialog in the stack, return focus
                                // to previous dialog

                                ds.pop();

                                var pd = ds[ds.length-1];       // the new active dialog (or the base page itself)

                                // Adjust underlay, unless the underlay widget has already been destroyed
                                // because we are being called during page unload (when all widgets are destroyed)
                                if(!DialogUnderlay._singleton._destroyed){
                                        if(ds.length == 1){
                                                // Returning to original page.  Hide the underlay.
                                                DialogUnderlay._singleton.hide();
                                        }else{
                                                // Popping back to previous dialog, adjust underlay.
                                                domStyle.set(DialogUnderlay._singleton.domNode, 'zIndex', pd.zIndex - 1);
                                                DialogUnderlay._singleton.set(pd.underlayAttrs);
                                        }
                                }

                                // Adjust focus
                                if(dialog.refocus){
                                        // If we are returning control to a previous dialog but for some reason
                                        // that dialog didn't have a focused field, set focus to first focusable item.
                                        // This situation could happen if two dialogs appeared at nearly the same time,
                                        // since a dialog doesn't set it's focus until the fade-in is finished.
                                        var focus = pd.focus;
                                        if(pd.dialog && (!focus || !dom.isDescendant(focus, pd.dialog.domNode))){
                                                pd.dialog._getFocusItems(pd.dialog.domNode);
                                                focus = pd.dialog._firstFocusItem;
                                        }

                                        if(focus){
                                                // Refocus the button that spawned the Dialog.   This will fail in corner cases including
                                                // page unload on IE, because the dijit/form/Button that launched the Dialog may get destroyed
                                                // before this code runs.  (#15058)
                                                try{
                                                        focus.focus();
                                                }catch(e){}
                                        }
                                }
                        }else{
                                // Removing a dialog out of order (#9944, #10705).
                                // Don't need to mess with underlay or z-index or anything.
                                var idx = array.indexOf(array.map(ds, function(elem){return elem.dialog}), dialog);
                                if(idx != -1){
                                        ds.splice(idx, 1);
                                }
                        }
                },

                isTop: function(/*dijit/_WidgetBase*/ dialog){
                        // summary:
                        //              Returns true if specified Dialog is the top in the task
                        return ds[ds.length-1].dialog == dialog;
                }
        };

        // Stack representing the various active "levels" on the page, starting with the
        // stuff initially visible on the page (at z-index 0), and then having an entry for
        // each Dialog shown.
        // Each element in stack has form {
        //              dialog: dialogWidget,
        //              focus: returnFromGetFocus(),
        //              underlayAttrs: attributes to set on underlay (when this widget is active)
        // }
        var ds = Dialog._dialogStack = [
                {dialog: null, focus: null, underlayAttrs: null}        // entry for stuff at z-index: 0
        ];

        // Back compat w/1.6, remove for 2.0
        if(has("dijit-legacy-requires")){
                ready(0, function(){
                        var requires = ["dijit/TooltipDialog"];
                        require(requires);      // use indirection so modules not rolled into a build
                });
        }

        return Dialog;
});

},
'dijit/_base/focus':function(){
define("dijit/_base/focus", [
        "dojo/_base/array", // array.forEach
        "dojo/dom", // dom.isDescendant
        "dojo/_base/lang", // lang.isArray
        "dojo/topic", // publish
        "dojo/_base/window", // win.doc win.doc.selection win.global win.global.getSelection win.withGlobal
        "../focus",
        "../main"       // for exporting symbols to dijit
], function(array, dom, lang, topic, win, focus, dijit){

        // module:
        //              dijit/_base/focus

        var exports = {
                // summary:
                //              Deprecated module to monitor currently focused node and stack of currently focused widgets.
                //              New code should access dijit/focus directly.

                // _curFocus: DomNode
                //              Currently focused item on screen
                _curFocus: null,

                // _prevFocus: DomNode
                //              Previously focused item on screen
                _prevFocus: null,

                isCollapsed: function(){
                        // summary:
                        //              Returns true if there is no text selected
                        return dijit.getBookmark().isCollapsed;
                },

                getBookmark: function(){
                        // summary:
                        //              Retrieves a bookmark that can be used with moveToBookmark to return to the same range
                        var bm, rg, tg, sel = win.doc.selection, cf = focus.curNode;

                        if(win.global.getSelection){
                                //W3C Range API for selections.
                                sel = win.global.getSelection();
                                if(sel){
                                        if(sel.isCollapsed){
                                                tg = cf? cf.tagName : "";
                                                if(tg){
                                                        //Create a fake rangelike item to restore selections.
                                                        tg = tg.toLowerCase();
                                                        if(tg == "textarea" ||
                                                                        (tg == "input" && (!cf.type || cf.type.toLowerCase() == "text"))){
                                                                sel = {
                                                                        start: cf.selectionStart,
                                                                        end: cf.selectionEnd,
                                                                        node: cf,
                                                                        pRange: true
                                                                };
                                                                return {isCollapsed: (sel.end <= sel.start), mark: sel}; //Object.
                                                        }
                                                }
                                                bm = {isCollapsed:true};
                                                if(sel.rangeCount){
                                                        bm.mark = sel.getRangeAt(0).cloneRange();
                                                }
                                        }else{
                                                rg = sel.getRangeAt(0);
                                                bm = {isCollapsed: false, mark: rg.cloneRange()};
                                        }
                                }
                        }else if(sel){
                                // If the current focus was a input of some sort and no selection, don't bother saving
                                // a native bookmark.  This is because it causes issues with dialog/page selection restore.
                                // So, we need to create psuedo bookmarks to work with.
                                tg = cf ? cf.tagName : "";
                                tg = tg.toLowerCase();
                                if(cf && tg && (tg == "button" || tg == "textarea" || tg == "input")){
                                        if(sel.type && sel.type.toLowerCase() == "none"){
                                                return {
                                                        isCollapsed: true,
                                                        mark: null
                                                }
                                        }else{
                                                rg = sel.createRange();
                                                return {
                                                        isCollapsed: rg.text && rg.text.length?false:true,
                                                        mark: {
                                                                range: rg,
                                                                pRange: true
                                                        }
                                                };
                                        }
                                }
                                bm = {};

                                //'IE' way for selections.
                                try{
                                        // createRange() throws exception when dojo in iframe
                                        //and nothing selected, see #9632
                                        rg = sel.createRange();
                                        bm.isCollapsed = !(sel.type == 'Text' ? rg.htmlText.length : rg.length);
                                }catch(e){
                                        bm.isCollapsed = true;
                                        return bm;
                                }
                                if(sel.type.toUpperCase() == 'CONTROL'){
                                        if(rg.length){
                                                bm.mark=[];
                                                var i=0,len=rg.length;
                                                while(i<len){
                                                        bm.mark.push(rg.item(i++));
                                                }
                                        }else{
                                                bm.isCollapsed = true;
                                                bm.mark = null;
                                        }
                                }else{
                                        bm.mark = rg.getBookmark();
                                }
                        }else{
                                console.warn("No idea how to store the current selection for this browser!");
                        }
                        return bm; // Object
                },

                moveToBookmark: function(/*Object*/ bookmark){
                        // summary:
                        //              Moves current selection to a bookmark
                        // bookmark:
                        //              This should be a returned object from dijit.getBookmark()

                        var _doc = win.doc,
                                mark = bookmark.mark;
                        if(mark){
                                if(win.global.getSelection){
                                        //W3C Rangi API (FF, WebKit, Opera, etc)
                                        var sel = win.global.getSelection();
                                        if(sel && sel.removeAllRanges){
                                                if(mark.pRange){
                                                        var n = mark.node;
                                                        n.selectionStart = mark.start;
                                                        n.selectionEnd = mark.end;
                                                }else{
                                                        sel.removeAllRanges();
                                                        sel.addRange(mark);
                                                }
                                        }else{
                                                console.warn("No idea how to restore selection for this browser!");
                                        }
                                }else if(_doc.selection && mark){
                                        //'IE' way.
                                        var rg;
                                        if(mark.pRange){
                                                rg = mark.range;
                                        }else if(lang.isArray(mark)){
                                                rg = _doc.body.createControlRange();
                                                //rg.addElement does not have call/apply method, so can not call it directly
                                                //rg is not available in "range.addElement(item)", so can't use that either
                                                array.forEach(mark, function(n){
                                                        rg.addElement(n);
                                                });
                                        }else{
                                                rg = _doc.body.createTextRange();
                                                rg.moveToBookmark(mark);
                                        }
                                        rg.select();
                                }
                        }
                },

                getFocus: function(/*Widget?*/ menu, /*Window?*/ openedForWindow){
                        // summary:
                        //              Called as getFocus(), this returns an Object showing the current focus
                        //              and selected text.
                        //
                        //              Called as getFocus(widget), where widget is a (widget representing) a button
                        //              that was just pressed, it returns where focus was before that button
                        //              was pressed.   (Pressing the button may have either shifted focus to the button,
                        //              or removed focus altogether.)   In this case the selected text is not returned,
                        //              since it can't be accurately determined.
                        //
                        // menu: dijit/_WidgetBase|{domNode: DomNode} structure
                        //              The button that was just pressed.  If focus has disappeared or moved
                        //              to this button, returns the previous focus.  In this case the bookmark
                        //              information is already lost, and null is returned.
                        //
                        // openedForWindow:
                        //              iframe in which menu was opened
                        //
                        // returns:
                        //              A handle to restore focus/selection, to be passed to `dijit.focus`
                        var node = !focus.curNode || (menu && dom.isDescendant(focus.curNode, menu.domNode)) ? dijit._prevFocus : focus.curNode;
                        return {
                                node: node,
                                bookmark: node && (node == focus.curNode) && win.withGlobal(openedForWindow || win.global, dijit.getBookmark),
                                openedForWindow: openedForWindow
                        }; // Object
                },

                // _activeStack: dijit/_WidgetBase[]
                //              List of currently active widgets (focused widget and it's ancestors)
                _activeStack: [],

                registerIframe: function(/*DomNode*/ iframe){
                        // summary:
                        //              Registers listeners on the specified iframe so that any click
                        //              or focus event on that iframe (or anything in it) is reported
                        //              as a focus/click event on the `<iframe>` itself.
                        // description:
                        //              Currently only used by editor.
                        // returns:
                        //              Handle to pass to unregisterIframe()
                        return focus.registerIframe(iframe);
                },

                unregisterIframe: function(/*Object*/ handle){
                        // summary:
                        //              Unregisters listeners on the specified iframe created by registerIframe.
                        //              After calling be sure to delete or null out the handle itself.
                        // handle:
                        //              Handle returned by registerIframe()

                        handle && handle.remove();
                },

                registerWin: function(/*Window?*/targetWindow, /*DomNode?*/ effectiveNode){
                        // summary:
                        //              Registers listeners on the specified window (either the main
                        //              window or an iframe's window) to detect when the user has clicked somewhere
                        //              or focused somewhere.
                        // description:
                        //              Users should call registerIframe() instead of this method.
                        // targetWindow:
                        //              If specified this is the window associated with the iframe,
                        //              i.e. iframe.contentWindow.
                        // effectiveNode:
                        //              If specified, report any focus events inside targetWindow as
                        //              an event on effectiveNode, rather than on evt.target.
                        // returns:
                        //              Handle to pass to unregisterWin()

                        return focus.registerWin(targetWindow, effectiveNode);
                },

                unregisterWin: function(/*Handle*/ handle){
                        // summary:
                        //              Unregisters listeners on the specified window (either the main
                        //              window or an iframe's window) according to handle returned from registerWin().
                        //              After calling be sure to delete or null out the handle itself.

                        handle && handle.remove();
                }
        };

        // Override focus singleton's focus function so that dijit.focus()
        // has backwards compatible behavior of restoring selection (although
        // probably no one is using that).
        focus.focus = function(/*Object|DomNode */ handle){
                // summary:
                //              Sets the focused node and the selection according to argument.
                //              To set focus to an iframe's content, pass in the iframe itself.
                // handle:
                //              object returned by get(), or a DomNode

                if(!handle){ return; }

                var node = "node" in handle ? handle.node : handle,             // because handle is either DomNode or a composite object
                        bookmark = handle.bookmark,
                        openedForWindow = handle.openedForWindow,
                        collapsed = bookmark ? bookmark.isCollapsed : false;

                // Set the focus
                // Note that for iframe's we need to use the <iframe> to follow the parentNode chain,
                // but we need to set focus to iframe.contentWindow
                if(node){
                        var focusNode = (node.tagName.toLowerCase() == "iframe") ? node.contentWindow : node;
                        if(focusNode && focusNode.focus){
                                try{
                                        // Gecko throws sometimes if setting focus is impossible,
                                        // node not displayed or something like that
                                        focusNode.focus();
                                }catch(e){/*quiet*/}
                        }
                        focus._onFocusNode(node);
                }

                // set the selection
                // do not need to restore if current selection is not empty
                // (use keyboard to select a menu item) or if previous selection was collapsed
                // as it may cause focus shift (Esp in IE).
                if(bookmark && win.withGlobal(openedForWindow || win.global, dijit.isCollapsed) && !collapsed){
                        if(openedForWindow){
                                openedForWindow.focus();
                        }
                        try{
                                win.withGlobal(openedForWindow || win.global, dijit.moveToBookmark, null, [bookmark]);
                        }catch(e2){
                                /*squelch IE internal error, see http://trac.dojotoolkit.org/ticket/1984 */
                        }
                }
        };

        // For back compatibility, monitor changes to focused node and active widget stack,
        // publishing events and copying changes from focus manager variables into dijit (top level) variables
        focus.watch("curNode", function(name, oldVal, newVal){
                dijit._curFocus = newVal;
                dijit._prevFocus = oldVal;
                if(newVal){
                        topic.publish("focusNode", newVal);     // publish
                }
        });
        focus.watch("activeStack", function(name, oldVal, newVal){
                dijit._activeStack = newVal;
        });

        focus.on("widget-blur", function(widget, by){
                topic.publish("widgetBlur", widget, by);        // publish
        });
        focus.on("widget-focus", function(widget, by){
                topic.publish("widgetFocus", widget, by);       // publish
        });

        lang.mixin(dijit, exports);

        /*===== return exports; =====*/
        return dijit;   // for back compat :-(
});

},
'dijit/tree/dndSource':function(){
define("dijit/tree/dndSource", [
        "dojo/_base/array", // array.forEach array.indexOf array.map
        "dojo/_base/connect", // isCopyKey
        "dojo/_base/declare", // declare
        "dojo/dom-class", // domClass.add
        "dojo/dom-geometry", // domGeometry.position
        "dojo/_base/lang", // lang.mixin lang.hitch
        "dojo/on", // subscribe
        "dojo/touch",
        "dojo/topic",
        "dojo/dnd/Manager", // DNDManager.manager
        "./_dndSelector"
], function(array, connect, declare, domClass, domGeometry, lang, on, touch, topic, DNDManager, _dndSelector){

// module:
//              dijit/tree/dndSource
// summary:
//              Handles drag and drop operations (as a source or a target) for `dijit.Tree`

/*=====
var __Item = {
        // summary:
        //              New item to be added to the Tree, like:
        // id: Anything
        id: "",
        // name: String
        name: ""
};
=====*/

var dndSource = declare("dijit.tree.dndSource", _dndSelector, {
        // summary:
        //              Handles drag and drop operations (as a source or a target) for `dijit.Tree`

        // isSource: Boolean
        //              Can be used as a DnD source.
        isSource: true,

        // accept: String[]
        //              List of accepted types (text strings) for the Tree; defaults to
        //              ["text"]
        accept: ["text", "treeNode"],

        // copyOnly: [private] Boolean
        //              Copy items, if true, use a state of Ctrl key otherwise
        copyOnly: false,

        // dragThreshold: Number
        //              The move delay in pixels before detecting a drag; 5 by default
        dragThreshold: 5,

        // betweenThreshold: Integer
        //              Distance from upper/lower edge of node to allow drop to reorder nodes
        betweenThreshold: 0,

        // Flag used by Avatar.js to signal to generate text node when dragging
        generateText: true,

        constructor: function(/*dijit/Tree*/ tree, /*dijit/tree/dndSource*/ params){
                // summary:
                //              a constructor of the Tree DnD Source
                // tags:
                //              private
                if(!params){ params = {}; }
                lang.mixin(this, params);
                var type = params.accept instanceof Array ? params.accept : ["text", "treeNode"];
                this.accept = null;
                if(type.length){
                        this.accept = {};
                        for(var i = 0; i < type.length; ++i){
                                this.accept[type[i]] = 1;
                        }
                }

                // class-specific variables
                this.isDragging = false;
                this.mouseDown = false;
                this.targetAnchor = null;       // DOMNode corresponding to the currently moused over TreeNode
                this.targetBox = null;  // coordinates of this.targetAnchor
                this.dropPosition = ""; // whether mouse is over/after/before this.targetAnchor
                this._lastX = 0;
                this._lastY = 0;

                // states
                this.sourceState = "";
                if(this.isSource){
                        domClass.add(this.node, "dojoDndSource");
                }
                this.targetState = "";
                if(this.accept){
                        domClass.add(this.node, "dojoDndTarget");
                }

                // set up events
                this.topics = [
                        topic.subscribe("/dnd/source/over", lang.hitch(this, "onDndSourceOver")),
                        topic.subscribe("/dnd/start", lang.hitch(this, "onDndStart")),
                        topic.subscribe("/dnd/drop", lang.hitch(this, "onDndDrop")),
                        topic.subscribe("/dnd/cancel", lang.hitch(this, "onDndCancel"))
                ];
        },

        // methods
        checkAcceptance: function(/*===== source, nodes =====*/){
                // summary:
                //              Checks if the target can accept nodes from this source
                // source: dijit/tree/dndSource
                //              The source which provides items
                // nodes: DOMNode[]
                //              Array of DOM nodes corresponding to nodes being dropped, dijitTreeRow nodes if
                //              source is a dijit/Tree.
                // tags:
                //              extension
                return true;    // Boolean
        },

        copyState: function(keyPressed){
                // summary:
                //              Returns true, if we need to copy items, false to move.
                //              It is separated to be overwritten dynamically, if needed.
                // keyPressed: Boolean
                //              The "copy" control key was pressed
                // tags:
                //              protected
                return this.copyOnly || keyPressed;     // Boolean
        },
        destroy: function(){
                // summary:
                //              Prepares the object to be garbage-collected.
                this.inherited(arguments);
                var h;
                while(h = this.topics.pop()){ h.remove(); }
                this.targetAnchor = null;
        },

        _onDragMouse: function(e, firstTime){
                // summary:
                //              Helper method for processing onmousemove/onmouseover events while drag is in progress.
                //              Keeps track of current drop target.
                // e: Event
                //              The mousemove event.
                // firstTime: Boolean?
                //              If this flag is set, this is the first mouse move event of the drag, so call m.canDrop() etc.
                //              even if newTarget == null because the user quickly dragged a node in the Tree to a position
                //              over Tree.containerNode but not over any TreeNode (#7971)

                var m = DNDManager.manager(),
                        oldTarget = this.targetAnchor,                  // the TreeNode corresponding to TreeNode mouse was previously over
                        newTarget = this.current,                               // TreeNode corresponding to TreeNode mouse is currently over
                        oldDropPosition = this.dropPosition;    // the previous drop position (over/before/after)

                // calculate if user is indicating to drop the dragged node before, after, or over
                // (i.e., to become a child of) the target node
                var newDropPosition = "Over";
                if(newTarget && this.betweenThreshold > 0){
                        // If mouse is over a new TreeNode, then get new TreeNode's position and size
                        if(!this.targetBox || oldTarget != newTarget){
                                this.targetBox = domGeometry.position(newTarget.rowNode, true);
                        }
                        if((e.pageY - this.targetBox.y) <= this.betweenThreshold){
                                newDropPosition = "Before";
                        }else if((e.pageY - this.targetBox.y) >= (this.targetBox.h - this.betweenThreshold)){
                                newDropPosition = "After";
                        }
                }

                if(firstTime || newTarget != oldTarget || newDropPosition != oldDropPosition){
                        if(oldTarget){
                                this._removeItemClass(oldTarget.rowNode, oldDropPosition);
                        }
                        if(newTarget){
                                this._addItemClass(newTarget.rowNode, newDropPosition);
                        }

                        // Check if it's ok to drop the dragged node on/before/after the target node.
                        if(!newTarget){
                                m.canDrop(false);
                        }else if(newTarget == this.tree.rootNode && newDropPosition != "Over"){
                                // Can't drop before or after tree's root node; the dropped node would just disappear (at least visually)
                                m.canDrop(false);
                        }else{
                                // Guard against dropping onto yourself (TODO: guard against dropping onto your descendant, #7140)
                                var sameId = false;
                                if(m.source == this){
                                        for(var dragId in this.selection){
                                                var dragNode = this.selection[dragId];
                                                if(dragNode.item === newTarget.item){
                                                        sameId = true;
                                                        break;
                                                }
                                        }
                                }
                                if(sameId){
                                        m.canDrop(false);
                                }else if(this.checkItemAcceptance(newTarget.rowNode, m.source, newDropPosition.toLowerCase())
                                                && !this._isParentChildDrop(m.source, newTarget.rowNode)){
                                        m.canDrop(true);
                                }else{
                                        m.canDrop(false);
                                }
                        }

                        this.targetAnchor = newTarget;
                        this.dropPosition = newDropPosition;
                }
        },

        onMouseMove: function(e){
                // summary:
                //              Called for any onmousemove/ontouchmove events over the Tree
                // e: Event
                //              onmousemouse/ontouchmove event
                // tags:
                //              private
                if(this.isDragging && this.targetState == "Disabled"){ return; }
                this.inherited(arguments);
                var m = DNDManager.manager();
                if(this.isDragging){
                        this._onDragMouse(e);
                }else{
                        if(this.mouseDown && this.isSource &&
                                 (Math.abs(e.pageX-this._lastX)>=this.dragThreshold || Math.abs(e.pageY-this._lastY)>=this.dragThreshold)){
                                var nodes = this.getSelectedTreeNodes();
                                if(nodes.length){
                                        if(nodes.length > 1){
                                                //filter out all selected items which has one of their ancestor selected as well
                                                var seen = this.selection, i = 0, r = [], n, p;
                                                nextitem: while((n = nodes[i++])){
                                                        for(p = n.getParent(); p && p !== this.tree; p = p.getParent()){
                                                                if(seen[p.id]){ //parent is already selected, skip this node
                                                                        continue nextitem;
                                                                }
                                                        }
                                                        //this node does not have any ancestors selected, add it
                                                        r.push(n);
                                                }
                                                nodes = r;
                                        }
                                        nodes = array.map(nodes, function(n){return n.domNode});
                                        m.startDrag(this, nodes, this.copyState(connect.isCopyKey(e)));
                                        this._onDragMouse(e, true);     // because this may be the only mousemove event we get before the drop
                                }
                        }
                }
        },

        onMouseDown: function(e){
                // summary:
                //              Event processor for onmousedown/ontouchstart
                // e: Event
                //              onmousedown/ontouchend event
                // tags:
                //              private
                this.mouseDown = true;
                this.mouseButton = e.button;
                this._lastX = e.pageX;
                this._lastY = e.pageY;
                this.inherited(arguments);
        },

        onMouseUp: function(e){
                // summary:
                //              Event processor for onmouseup/ontouchend
                // e: Event
                //              onmouseup/ontouchend event
                // tags:
                //              private
                if(this.mouseDown){
                        this.mouseDown = false;
                        this.inherited(arguments);
                }
        },

        onMouseOut: function(){
                // summary:
                //              Event processor for when mouse is moved away from a TreeNode
                // tags:
                //              private
                this.inherited(arguments);
                this._unmarkTargetAnchor();
        },

        checkItemAcceptance: function(/*===== target, source, position =====*/){
                // summary:
                //              Stub function to be overridden if one wants to check for the ability to drop at the node/item level
                // description:
                //              In the base case, this is called to check if target can become a child of source.
                //              When betweenThreshold is set, position="before" or "after" means that we
                //              are asking if the source node can be dropped before/after the target node.
                // target: DOMNode
                //              The dijitTreeRoot DOM node inside of the TreeNode that we are dropping on to
                //              Use dijit.getEnclosingWidget(target) to get the TreeNode.
                // source: dijit/tree/dndSource
                //              The (set of) nodes we are dropping
                // position: String
                //              "over", "before", or "after"
                // tags:
                //              extension
                return true;
        },

        // topic event processors
        onDndSourceOver: function(source){
                // summary:
                //              Topic event processor for /dnd/source/over, called when detected a current source.
                // source: Object
                //              The dijit/tree/dndSource / dojo/dnd/Source which has the mouse over it
                // tags:
                //              private
                if(this != source){
                        this.mouseDown = false;
                        this._unmarkTargetAnchor();
                }else if(this.isDragging){
                        var m = DNDManager.manager();
                        m.canDrop(false);
                }
        },
        onDndStart: function(source, nodes, copy){
                // summary:
                //              Topic event processor for /dnd/start, called to initiate the DnD operation
                // source: Object
                //              The dijit/tree/dndSource / dojo/dnd/Source which is providing the items
                // nodes: DomNode[]
                //              The list of transferred items, dndTreeNode nodes if dragging from a Tree
                // copy: Boolean
                //              Copy items, if true, move items otherwise
                // tags:
                //              private

                if(this.isSource){
                        this._changeState("Source", this == source ? (copy ? "Copied" : "Moved") : "");
                }
                var accepted = this.checkAcceptance(source, nodes);

                this._changeState("Target", accepted ? "" : "Disabled");

                if(this == source){
                        DNDManager.manager().overSource(this);
                }

                this.isDragging = true;
        },

        itemCreator: function(nodes /*===== , target, source =====*/){
                // summary:
                //              Returns objects passed to `Tree.model.newItem()` based on DnD nodes
                //              dropped onto the tree.   Developer must override this method to enable
                //              dropping from external sources onto this Tree, unless the Tree.model's items
                //              happen to look like {id: 123, name: "Apple" } with no other attributes.
                // description:
                //              For each node in nodes[], which came from source, create a hash of name/value
                //              pairs to be passed to Tree.model.newItem().  Returns array of those hashes.
                // nodes: DomNode[]
                // target: DomNode
                // source: dojo/dnd/Source
                // returns: __Item[]
                //              Array of name/value hashes for each new item to be added to the Tree
                // tags:
                //              extension

                // TODO: for 2.0 refactor so itemCreator() is called once per drag node, and
                // make signature itemCreator(sourceItem, node, target) (or similar).

                return array.map(nodes, function(node){
                        return {
                                "id": node.id,
                                "name": node.textContent || node.innerText || ""
                        };
                }); // Object[]
        },

        onDndDrop: function(source, nodes, copy){
                // summary:
                //              Topic event processor for /dnd/drop, called to finish the DnD operation.
                // description:
                //              Updates data store items according to where node was dragged from and dropped
                //              to.   The tree will then respond to those data store updates and redraw itself.
                // source: Object
                //              The dijit/tree/dndSource / dojo/dnd/Source which is providing the items
                // nodes: DomNode[]
                //              The list of transferred items, dndTreeNode nodes if dragging from a Tree
                // copy: Boolean
                //              Copy items, if true, move items otherwise
                // tags:
                //              protected
                if(this.containerState == "Over"){
                        var tree = this.tree,
                                model = tree.model,
                                target = this.targetAnchor;

                        this.isDragging = false;

                        // Compute the new parent item
                        var newParentItem;
                        var insertIndex;
                        var before;             // drop source before (aka previous sibling) of target
                        newParentItem = (target && target.item) || tree.item;
                        if(this.dropPosition == "Before" || this.dropPosition == "After"){
                                // TODO: if there is no parent item then disallow the drop.
                                // Actually this should be checked during onMouseMove too, to make the drag icon red.
                                newParentItem = (target.getParent() && target.getParent().item) || tree.item;
                                // Compute the insert index for reordering
                                insertIndex = target.getIndexInParent();
                                if(this.dropPosition == "After"){
                                        insertIndex = target.getIndexInParent() + 1;
                                        before = target.getNextSibling() && target.getNextSibling().item;
                                }else{
                                        before = target.item;
                                }
                        }else{
                                newParentItem = (target && target.item) || tree.item;
                        }

                        // If necessary, use this variable to hold array of hashes to pass to model.newItem()
                        // (one entry in the array for each dragged node).
                        var newItemsParams;

                        array.forEach(nodes, function(node, idx){
                                // dojo/dnd/Item representing the thing being dropped.
                                // Don't confuse the use of item here (meaning a DnD item) with the
                                // uses below where item means dojo.data item.
                                var sourceItem = source.getItem(node.id);

                                // Information that's available if the source is another Tree
                                // (possibly but not necessarily this tree, possibly but not
                                // necessarily the same model as this Tree)
                                if(array.indexOf(sourceItem.type, "treeNode") != -1){
                                        var childTreeNode = sourceItem.data,
                                                childItem = childTreeNode.item,
                                                oldParentItem = childTreeNode.getParent().item;
                                }

                                if(source == this){
                                        // This is a node from my own tree, and we are moving it, not copying.
                                        // Remove item from old parent's children attribute.
                                        // TODO: dijit/tree/dndSelector should implement deleteSelectedNodes()
                                        // and this code should go there.

                                        if(typeof insertIndex == "number"){
                                                if(newParentItem == oldParentItem && childTreeNode.getIndexInParent() < insertIndex){
                                                        insertIndex -= 1;
                                                }
                                        }
                                        model.pasteItem(childItem, oldParentItem, newParentItem, copy, insertIndex, before);
                                }else if(model.isItem(childItem)){
                                        // Item from same model
                                        // (maybe we should only do this branch if the source is a tree?)
                                        model.pasteItem(childItem, oldParentItem, newParentItem, copy, insertIndex, before);
                                }else{
                                        // Get the hash to pass to model.newItem().  A single call to
                                        // itemCreator() returns an array of hashes, one for each drag source node.
                                        if(!newItemsParams){
                                                newItemsParams = this.itemCreator(nodes, target.rowNode, source);
                                        }

                                        // Create new item in the tree, based on the drag source.
                                        model.newItem(newItemsParams[idx], newParentItem, insertIndex, before);
                                }
                        }, this);

                        // Expand the target node (if it's currently collapsed) so the user can see
                        // where their node was dropped.   In particular since that node is still selected.
                        this.tree._expandNode(target);
                }
                this.onDndCancel();
        },

        onDndCancel: function(){
                // summary:
                //              Topic event processor for /dnd/cancel, called to cancel the DnD operation
                // tags:
                //              private
                this._unmarkTargetAnchor();
                this.isDragging = false;
                this.mouseDown = false;
                delete this.mouseButton;
                this._changeState("Source", "");
                this._changeState("Target", "");
        },

        // When focus moves in/out of the entire Tree
        onOverEvent: function(){
                // summary:
                //              This method is called when mouse is moved over our container (like onmouseenter)
                // tags:
                //              private
                this.inherited(arguments);
                DNDManager.manager().overSource(this);
        },
        onOutEvent: function(){
                // summary:
                //              This method is called when mouse is moved out of our container (like onmouseleave)
                // tags:
                //              private
                this._unmarkTargetAnchor();
                var m = DNDManager.manager();
                if(this.isDragging){
                        m.canDrop(false);
                }
                m.outSource(this);

                this.inherited(arguments);
        },

        _isParentChildDrop: function(source, targetRow){
                // summary:
                //              Checks whether the dragged items are parent rows in the tree which are being
                //              dragged into their own children.
                //
                // source:
                //              The DragSource object.
                //
                // targetRow:
                //              The tree row onto which the dragged nodes are being dropped.
                //
                // tags:
                //              private

                // If the dragged object is not coming from the tree this widget belongs to,
                // it cannot be invalid.
                if(!source.tree || source.tree != this.tree){
                        return false;
                }


                var root = source.tree.domNode;
                var ids = source.selection;

                var node = targetRow.parentNode;

                // Iterate up the DOM hierarchy from the target drop row,
                // checking of any of the dragged nodes have the same ID.
                while(node != root && !ids[node.id]){
                        node = node.parentNode;
                }

                return node.id && ids[node.id];
        },

        _unmarkTargetAnchor: function(){
                // summary:
                //              Removes hover class of the current target anchor
                // tags:
                //              private
                if(!this.targetAnchor){ return; }
                this._removeItemClass(this.targetAnchor.rowNode, this.dropPosition);
                this.targetAnchor = null;
                this.targetBox = null;
                this.dropPosition = null;
        },

        _markDndStatus: function(copy){
                // summary:
                //              Changes source's state based on "copy" status
                this._changeState("Source", copy ? "Copied" : "Moved");
        }
});

/*=====
dndSource.__Item = __Item;
=====*/

return dndSource;
});

},
'dijit/a11y':function(){
define("dijit/a11y", [
        "dojo/_base/array", // array.forEach array.map
        "dojo/_base/config", // defaultDuration
        "dojo/_base/declare", // declare
        "dojo/dom",                     // dom.byId
        "dojo/dom-attr", // domAttr.attr domAttr.has
        "dojo/dom-style", // style.style
        "dojo/sniff", // has("ie")
        "./main"        // for exporting methods to dijit namespace
], function(array, config, declare, dom, domAttr, domStyle, has, dijit){

        // module:
        //              dijit/a11y

        var shown = (dijit._isElementShown = function(/*Element*/ elem){
                var s = domStyle.get(elem);
                return (s.visibility != "hidden")
                        && (s.visibility != "collapsed")
                        && (s.display != "none")
                        && (domAttr.get(elem, "type") != "hidden");
        });

        dijit.hasDefaultTabStop = function(/*Element*/ elem){
                // summary:
                //              Tests if element is tab-navigable even without an explicit tabIndex setting

                // No explicit tabIndex setting, need to investigate node type
                switch(elem.nodeName.toLowerCase()){
                        case "a":
                                // An <a> w/out a tabindex is only navigable if it has an href
                                return domAttr.has(elem, "href");
                        case "area":
                        case "button":
                        case "input":
                        case "object":
                        case "select":
                        case "textarea":
                                // These are navigable by default
                                return true;
                        case "iframe":
                                // If it's an editor <iframe> then it's tab navigable.
                                var body;
                                try{
                                        // non-IE
                                        var contentDocument = elem.contentDocument;
                                        if("designMode" in contentDocument && contentDocument.designMode == "on"){
                                                return true;
                                        }
                                        body = contentDocument.body;
                                }catch(e1){
                                        // contentWindow.document isn't accessible within IE7/8
                                        // if the iframe.src points to a foreign url and this
                                        // page contains an element, that could get focus
                                        try{
                                                body = elem.contentWindow.document.body;
                                        }catch(e2){
                                                return false;
                                        }
                                }
                                return body && (body.contentEditable == 'true' ||
                                        (body.firstChild && body.firstChild.contentEditable == 'true'));
                        default:
                                return elem.contentEditable == 'true';
                }
        };

        var isTabNavigable = (dijit.isTabNavigable = function(/*Element*/ elem){
                // summary:
                //              Tests if an element is tab-navigable

                // TODO: convert (and rename method) to return effective tabIndex; will save time in _getTabNavigable()
                if(domAttr.get(elem, "disabled")){
                        return false;
                }else if(domAttr.has(elem, "tabIndex")){
                        // Explicit tab index setting
                        return domAttr.get(elem, "tabIndex") >= 0; // boolean
                }else{
                        // No explicit tabIndex setting, so depends on node type
                        return dijit.hasDefaultTabStop(elem);
                }
        });

        dijit._getTabNavigable = function(/*DOMNode*/ root){
                // summary:
                //              Finds descendants of the specified root node.
                // description:
                //              Finds the following descendants of the specified root node:
                //
                //              - the first tab-navigable element in document order
                //                without a tabIndex or with tabIndex="0"
                //              - the last tab-navigable element in document order
                //                without a tabIndex or with tabIndex="0"
                //              - the first element in document order with the lowest
                //                positive tabIndex value
                //              - the last element in document order with the highest
                //                positive tabIndex value
                var first, last, lowest, lowestTabindex, highest, highestTabindex, radioSelected = {};

                function radioName(node){
                        // If this element is part of a radio button group, return the name for that group.
                        return node && node.tagName.toLowerCase() == "input" &&
                                node.type && node.type.toLowerCase() == "radio" &&
                                node.name && node.name.toLowerCase();
                }

                var walkTree = function(/*DOMNode*/ parent){
                        for(var child = parent.firstChild; child; child = child.nextSibling){
                                // Skip text elements, hidden elements, and also non-HTML elements (those in custom namespaces) in IE,
                                // since show() invokes getAttribute("type"), which crash on VML nodes in IE.
                                if(child.nodeType != 1 || (has("ie") <= 9 && child.scopeName !== "HTML") || !shown(child)){
                                        continue;
                                }

                                if(isTabNavigable(child)){
                                        var tabindex = +domAttr.get(child, "tabIndex"); // + to convert string --> number
                                        if(!domAttr.has(child, "tabIndex") || tabindex == 0){
                                                if(!first){
                                                        first = child;
                                                }
                                                last = child;
                                        }else if(tabindex > 0){
                                                if(!lowest || tabindex < lowestTabindex){
                                                        lowestTabindex = tabindex;
                                                        lowest = child;
                                                }
                                                if(!highest || tabindex >= highestTabindex){
                                                        highestTabindex = tabindex;
                                                        highest = child;
                                                }
                                        }
                                        var rn = radioName(child);
                                        if(domAttr.get(child, "checked") && rn){
                                                radioSelected[rn] = child;
                                        }
                                }
                                if(child.nodeName.toUpperCase() != 'SELECT'){
                                        walkTree(child);
                                }
                        }
                };
                if(shown(root)){
                        walkTree(root);
                }
                function rs(node){
                        // substitute checked radio button for unchecked one, if there is a checked one with the same name.
                        return radioSelected[radioName(node)] || node;
                }

                return { first: rs(first), last: rs(last), lowest: rs(lowest), highest: rs(highest) };
        };
        dijit.getFirstInTabbingOrder = function(/*String|DOMNode*/ root, /*Document?*/ doc){
                // summary:
                //              Finds the descendant of the specified root node
                //              that is first in the tabbing order
                var elems = dijit._getTabNavigable(dom.byId(root, doc));
                return elems.lowest ? elems.lowest : elems.first; // DomNode
        };

        dijit.getLastInTabbingOrder = function(/*String|DOMNode*/ root, /*Document?*/ doc){
                // summary:
                //              Finds the descendant of the specified root node
                //              that is last in the tabbing order
                var elems = dijit._getTabNavigable(dom.byId(root, doc));
                return elems.last ? elems.last : elems.highest; // DomNode
        };

        return {
                // summary:
                //              Accessibility utility functions (keyboard, tab stops, etc.)

                hasDefaultTabStop: dijit.hasDefaultTabStop,
                isTabNavigable: dijit.isTabNavigable,
                _getTabNavigable: dijit._getTabNavigable,
                getFirstInTabbingOrder: dijit.getFirstInTabbingOrder,
                getLastInTabbingOrder: dijit.getLastInTabbingOrder
        };
});

},
'dijit/form/_ToggleButtonMixin':function(){
define("dijit/form/_ToggleButtonMixin", [
        "dojo/_base/declare", // declare
        "dojo/dom-attr" // domAttr.set
], function(declare, domAttr){

// module:
//              dijit/form/_ToggleButtonMixin

return declare("dijit.form._ToggleButtonMixin", null, {
        // summary:
        //              A mixin to provide functionality to allow a button that can be in two states (checked or not).

        // checked: Boolean
        //              Corresponds to the native HTML `<input>` element's attribute.
        //              In markup, specified as "checked='checked'" or just "checked".
        //              True if the button is depressed, or the checkbox is checked,
        //              or the radio button is selected, etc.
        checked: false,

        // aria-pressed for toggle buttons, and aria-checked for checkboxes
        _aria_attr: "aria-pressed",

        _onClick: function(/*Event*/ evt){
                var original = this.checked;
                this._set('checked', !original); // partially set the toggled value, assuming the toggle will work, so it can be overridden in the onclick handler
                var ret = this.inherited(arguments); // the user could reset the value here
                this.set('checked', ret ? this.checked : original); // officially set the toggled or user value, or reset it back
                return ret;
        },

        _setCheckedAttr: function(/*Boolean*/ value, /*Boolean?*/ priorityChange){
                this._set("checked", value);
                var node = this.focusNode || this.domNode;
                domAttr.set(node, "checked", !!value); // "mixed" -> true
                if(value){
                        node.setAttribute("checked", "");
                }else{
                        node.removeAttribute("checked");
                }
                node.setAttribute(this._aria_attr, String(value)); // aria values should be strings
                this._handleOnChange(value, priorityChange);
        },

        reset: function(){
                // summary:
                //              Reset the widget's value to what it was at initialization time

                this._hasBeenBlurred = false;

                // set checked state to original setting
                this.set('checked', this.params.checked || false);
        }
});

});

},
'dijit/_Widget':function(){
define("dijit/_Widget", [
        "dojo/aspect",  // aspect.around
        "dojo/_base/config",    // config.isDebug
        "dojo/_base/connect",   // connect.connect
        "dojo/_base/declare", // declare
        "dojo/has",
        "dojo/_base/kernel", // kernel.deprecated
        "dojo/_base/lang", // lang.hitch
        "dojo/query",
        "dojo/ready",
        "./registry",   // registry.byNode
        "./_WidgetBase",
        "./_OnDijitClickMixin",
        "./_FocusMixin",
        "dojo/uacss",           // browser sniffing (included for back-compat; subclasses may be using)
        "./hccss"               // high contrast mode sniffing (included to set CSS classes on <body>, module ret value unused)
], function(aspect, config, connect, declare, has, kernel, lang, query, ready,
                        registry, _WidgetBase, _OnDijitClickMixin, _FocusMixin){


// module:
//              dijit/_Widget


function connectToDomNode(){
        // summary:
        //              If user connects to a widget method === this function, then they will
        //              instead actually be connecting the equivalent event on this.domNode
}

// Trap dojo.connect() calls to connectToDomNode methods, and redirect to _Widget.on()
function aroundAdvice(originalConnect){
        return function(obj, event, scope, method){
                if(obj && typeof event == "string" && obj[event] == connectToDomNode){
                        return obj.on(event.substring(2).toLowerCase(), lang.hitch(scope, method));
                }
                return originalConnect.apply(connect, arguments);
        };
}
aspect.around(connect, "connect", aroundAdvice);
if(kernel.connect){
        aspect.around(kernel, "connect", aroundAdvice);
}

var _Widget = declare("dijit._Widget", [_WidgetBase, _OnDijitClickMixin, _FocusMixin], {
        // summary:
        //              Old base class for widgets.   New widgets should extend `dijit/_WidgetBase` instead
        // description:
        //              Old Base class for Dijit widgets.
        //
        //              Extends _WidgetBase, adding support for:
        //
        //              - declaratively/programatically specifying widget initialization parameters like
        //                      onMouseMove="foo" that call foo when this.domNode gets a mousemove event
        //              - ondijitclick:
        //                      Support new data-dojo-attach-event="ondijitclick: ..." that is triggered by a mouse click or a SPACE/ENTER keypress
        //              - focus related functions:
        //                      In particular, the onFocus()/onBlur() callbacks.   Driven internally by
        //                      dijit/_base/focus.js.
        //              - deprecated methods
        //              - onShow(), onHide(), onClose()
        //
        //              Also, by loading code in dijit/_base, turns on:
        //
        //              - browser sniffing (putting browser class like `dj_ie` on `<html>` node)
        //              - high contrast mode sniffing (add `dijit_a11y` class to `<body>` if machine is in high contrast mode)


        ////////////////// DEFERRED CONNECTS ///////////////////

        onClick: connectToDomNode,
        /*=====
        onClick: function(event){
                // summary:
                //              Connect to this function to receive notifications of mouse click events.
                // event:
                //              mouse Event
                // tags:
                //              callback
        },
        =====*/
        onDblClick: connectToDomNode,
        /*=====
        onDblClick: function(event){
                // summary:
                //              Connect to this function to receive notifications of mouse double click events.
                // event:
                //              mouse Event
                // tags:
                //              callback
        },
        =====*/
        onKeyDown: connectToDomNode,
        /*=====
        onKeyDown: function(event){
                // summary:
                //              Connect to this function to receive notifications of keys being pressed down.
                // event:
                //              key Event
                // tags:
                //              callback
        },
        =====*/
        onKeyPress: connectToDomNode,
        /*=====
        onKeyPress: function(event){
                // summary:
                //              Connect to this function to receive notifications of printable keys being typed.
                // event:
                //              key Event
                // tags:
                //              callback
        },
        =====*/
        onKeyUp: connectToDomNode,
        /*=====
        onKeyUp: function(event){
                // summary:
                //              Connect to this function to receive notifications of keys being released.
                // event:
                //              key Event
                // tags:
                //              callback
        },
        =====*/
        onMouseDown: connectToDomNode,
        /*=====
        onMouseDown: function(event){
                // summary:
                //              Connect to this function to receive notifications of when the mouse button is pressed down.
                // event:
                //              mouse Event
                // tags:
                //              callback
        },
        =====*/
        onMouseMove: connectToDomNode,
        /*=====
        onMouseMove: function(event){
                // summary:
                //              Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
                // event:
                //              mouse Event
                // tags:
                //              callback
        },
        =====*/
        onMouseOut: connectToDomNode,
        /*=====
        onMouseOut: function(event){
                // summary:
                //              Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
                // event:
                //              mouse Event
                // tags:
                //              callback
        },
        =====*/
        onMouseOver: connectToDomNode,
        /*=====
        onMouseOver: function(event){
                // summary:
                //              Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
                // event:
                //              mouse Event
                // tags:
                //              callback
        },
        =====*/
        onMouseLeave: connectToDomNode,
        /*=====
        onMouseLeave: function(event){
                // summary:
                //              Connect to this function to receive notifications of when the mouse moves off of this widget.
                // event:
                //              mouse Event
                // tags:
                //              callback
        },
        =====*/
        onMouseEnter: connectToDomNode,
        /*=====
        onMouseEnter: function(event){
                // summary:
                //              Connect to this function to receive notifications of when the mouse moves onto this widget.
                // event:
                //              mouse Event
                // tags:
                //              callback
        },
        =====*/
        onMouseUp: connectToDomNode,
        /*=====
        onMouseUp: function(event){
                // summary:
                //              Connect to this function to receive notifications of when the mouse button is released.
                // event:
                //              mouse Event
                // tags:
                //              callback
        },
        =====*/

        constructor: function(params /*===== ,srcNodeRef =====*/){
                // summary:
                //              Create the widget.
                // params: Object|null
                //              Hash of initialization parameters for widget, including scalar values (like title, duration etc.)
                //              and functions, typically callbacks like onClick.
                //              The hash can contain any of the widget's properties, excluding read-only properties.
                // srcNodeRef: DOMNode|String?
                //              If a srcNodeRef (DOM node) is specified:
                //
                //              - use srcNodeRef.innerHTML as my contents
                //              - if this is a behavioral widget then apply behavior to that srcNodeRef
                //              - otherwise, replace srcNodeRef with my generated DOM tree

                // extract parameters like onMouseMove that should connect directly to this.domNode
                this._toConnect = {};
                for(var name in params){
                        if(this[name] === connectToDomNode){
                                this._toConnect[name.replace(/^on/, "").toLowerCase()] = params[name];
                                delete params[name];
                        }
                }
        },

        postCreate: function(){
                this.inherited(arguments);

                // perform connection from this.domNode to user specified handlers (ex: onMouseMove)
                for(var name in this._toConnect){
                        this.on(name, this._toConnect[name]);
                }
                delete this._toConnect;
        },

        on: function(/*String|Function*/ type, /*Function*/ func){
                if(this[this._onMap(type)] === connectToDomNode){
                        // Use connect.connect() rather than on() to get handling for "onmouseenter" on non-IE,
                        // normalization of onkeypress/onkeydown to behave like firefox, etc.
                        // Also, need to specify context as "this" rather than the default context of the DOMNode
                        // Remove in 2.0.
                        return connect.connect(this.domNode, type.toLowerCase(), this, func);
                }
                return this.inherited(arguments);
        },

        _setFocusedAttr: function(val){
                // Remove this method in 2.0 (or sooner), just here to set _focused == focused, for back compat
                // (but since it's a private variable we aren't required to keep supporting it).
                this._focused = val;
                this._set("focused", val);
        },

        ////////////////// DEPRECATED METHODS ///////////////////

        setAttribute: function(/*String*/ attr, /*anything*/ value){
                // summary:
                //              Deprecated.  Use set() instead.
                // tags:
                //              deprecated
                kernel.deprecated(this.declaredClass+"::setAttribute(attr, value) is deprecated. Use set() instead.", "", "2.0");
                this.set(attr, value);
        },

        attr: function(/*String|Object*/name, /*Object?*/value){
                // summary:
                //              Set or get properties on a widget instance.
                // name:
                //              The property to get or set. If an object is passed here and not
                //              a string, its keys are used as names of attributes to be set
                //              and the value of the object as values to set in the widget.
                // value:
                //              Optional. If provided, attr() operates as a setter. If omitted,
                //              the current value of the named property is returned.
                // description:
                //              This method is deprecated, use get() or set() directly.

                // Print deprecation warning but only once per calling function
                if(config.isDebug){
                        var alreadyCalledHash = arguments.callee._ach || (arguments.callee._ach = {}),
                                caller = (arguments.callee.caller || "unknown caller").toString();
                        if(!alreadyCalledHash[caller]){
                                kernel.deprecated(this.declaredClass + "::attr() is deprecated. Use get() or set() instead, called from " +
                                caller, "", "2.0");
                                alreadyCalledHash[caller] = true;
                        }
                }

                var args = arguments.length;
                if(args >= 2 || typeof name === "object"){ // setter
                        return this.set.apply(this, arguments);
                }else{ // getter
                        return this.get(name);
                }
        },

        getDescendants: function(){
                // summary:
                //              Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
                //              This method should generally be avoided as it returns widgets declared in templates, which are
                //              supposed to be internal/hidden, but it's left here for back-compat reasons.

                kernel.deprecated(this.declaredClass+"::getDescendants() is deprecated. Use getChildren() instead.", "", "2.0");
                return this.containerNode ? query('[widgetId]', this.containerNode).map(registry.byNode) : []; // dijit/_WidgetBase[]
        },

        ////////////////// MISCELLANEOUS METHODS ///////////////////

        _onShow: function(){
                // summary:
                //              Internal method called when this widget is made visible.
                //              See `onShow` for details.
                this.onShow();
        },

        onShow: function(){
                // summary:
                //              Called when this widget becomes the selected pane in a
                //              `dijit/layout/TabContainer`, `dijit/layout/StackContainer`,
                //              `dijit/layout/AccordionContainer`, etc.
                //
                //              Also called to indicate display of a `dijit.Dialog`, `dijit.TooltipDialog`, or `dijit.TitlePane`.
                // tags:
                //              callback
        },

        onHide: function(){
                // summary:
                //              Called when another widget becomes the selected pane in a
                //              `dijit/layout/TabContainer`, `dijit/layout/StackContainer`,
                //              `dijit/layout/AccordionContainer`, etc.
                //
                //              Also called to indicate hide of a `dijit.Dialog`, `dijit.TooltipDialog`, or `dijit.TitlePane`.
                // tags:
                //              callback
        },

        onClose: function(){
                // summary:
                //              Called when this widget is being displayed as a popup (ex: a Calendar popped
                //              up from a DateTextBox), and it is hidden.
                //              This is called from the dijit.popup code, and should not be called directly.
                //
                //              Also used as a parameter for children of `dijit/layout/StackContainer` or subclasses.
                //              Callback if a user tries to close the child.   Child will be closed if this function returns true.
                // tags:
                //              extension

                return true;            // Boolean
        }
});

// For back-compat, remove in 2.0.
if(has("dijit-legacy-requires")){
        ready(0, function(){
                var requires = ["dijit/_base"];
                require(requires);      // use indirection so modules not rolled into a build
        });
}
return _Widget;
});

},
'dojo/touch':function(){
define("dojo/touch", ["./_base/kernel", "./aspect", "./dom", "./on", "./has", "./mouse", "./ready", "./_base/window"],
function(dojo, aspect, dom, on, has, mouse, ready, win){

        // module:
        //              dojo/touch

        var hasTouch = has("touch");

        // TODO: get iOS version from dojo/sniff after #15827 is fixed
        var ios4 = false;
        if(has("ios")){
                var ua = navigator.userAgent;
                var v = ua.match(/OS ([\d_]+)/) ? RegExp.$1 : "1";
                var os = parseFloat(v.replace(/_/, '.').replace(/_/g, ''));
                ios4 = os < 5;
        }

        var touchmove, hoveredNode;

        if(hasTouch){
                ready(function(){
                        // Keep track of currently hovered node
                        hoveredNode = win.body();       // currently hovered node

                        win.doc.addEventListener("touchstart", function(evt){
                                // Precede touchstart event with touch.over event.  DnD depends on this.
                                // Use addEventListener(cb, true) to run cb before any touchstart handlers on node run,
                                // and to ensure this code runs even if the listener on the node does event.stop().
                                var oldNode = hoveredNode;
                                hoveredNode = evt.target;
                                on.emit(oldNode, "dojotouchout", {
                                        target: oldNode,
                                        relatedTarget: hoveredNode,
                                        bubbles: true
                                });
                                on.emit(hoveredNode, "dojotouchover", {
                                        target: hoveredNode,
                                        relatedTarget: oldNode,
                                        bubbles: true
                                });
                        }, true);

                        // Fire synthetic touchover and touchout events on nodes since the browser won't do it natively.
                        on(win.doc, "touchmove", function(evt){
                                var newNode = win.doc.elementFromPoint(
                                        evt.pageX - (ios4 ? 0 : win.global.pageXOffset), // iOS 4 expects page coords
                                        evt.pageY - (ios4 ? 0 : win.global.pageYOffset)
                                );
                                if(newNode && hoveredNode !== newNode){
                                        // touch out on the old node
                                        on.emit(hoveredNode, "dojotouchout", {
                                                target: hoveredNode,
                                                relatedTarget: newNode,
                                                bubbles: true
                                        });

                                        // touchover on the new node
                                        on.emit(newNode, "dojotouchover", {
                                                target: newNode,
                                                relatedTarget: hoveredNode,
                                                bubbles: true
                                        });

                                        hoveredNode = newNode;
                                }
                        });
                });

                // Define synthetic touch.move event that unlike the native touchmove, fires for the node the finger is
                // currently dragging over rather than the node where the touch started.
                touchmove = function(node, listener){
                        return on(win.doc, "touchmove", function(evt){
                                if(node === win.doc || dom.isDescendant(hoveredNode, node)){
                                        evt.target = hoveredNode;
                                        listener.call(this, evt);
                                }
                        });
                };
        }


        function _handle(type){
                // type: String
                //              press | move | release | cancel

                return function(node, listener){//called by on(), see dojo.on
                        return on(node, type, listener);
                };
        }

        //device neutral events - touch.press|move|release|cancel/over/out
        var touch = {
                press: _handle(hasTouch ? "touchstart": "mousedown"),
                move: hasTouch ? touchmove :_handle("mousemove"),
                release: _handle(hasTouch ? "touchend": "mouseup"),
                cancel: hasTouch ? _handle("touchcancel") : mouse.leave,
                over: _handle(hasTouch ? "dojotouchover": "mouseover"),
                out: _handle(hasTouch ? "dojotouchout": "mouseout"),
                enter: mouse._eventHandler(hasTouch ? "dojotouchover" : "mouseover"),
                leave: mouse._eventHandler(hasTouch ? "dojotouchout" : "mouseout")
        };
        /*=====
        touch = {
                // summary:
                //              This module provides unified touch event handlers by exporting
                //              press, move, release and cancel which can also run well on desktop.
                //              Based on http://dvcs.w3.org/hg/webevents/raw-file/tip/touchevents.html
                //
                // example:
                //              Used with dojo.on
                //              |       define(["dojo/on", "dojo/touch"], function(on, touch){
                //              |               on(node, touch.press, function(e){});
                //              |               on(node, touch.move, function(e){});
                //              |               on(node, touch.release, function(e){});
                //              |               on(node, touch.cancel, function(e){});
                // example:
                //              Used with touch.* directly
                //              |       touch.press(node, function(e){});
                //              |       touch.move(node, function(e){});
                //              |       touch.release(node, function(e){});
                //              |       touch.cancel(node, function(e){});

                press: function(node, listener){
                        // summary:
                        //              Register a listener to 'touchstart'|'mousedown' for the given node
                        // node: Dom
                        //              Target node to listen to
                        // listener: Function
                        //              Callback function
                        // returns:
                        //              A handle which will be used to remove the listener by handle.remove()
                },
                move: function(node, listener){
                        // summary:
                        //              Register a listener to 'touchmove'|'mousemove' for the given node
                        // node: Dom
                        //              Target node to listen to
                        // listener: Function
                        //              Callback function
                        // returns:
                        //              A handle which will be used to remove the listener by handle.remove()
                },
                release: function(node, listener){
                        // summary:
                        //              Register a listener to 'touchend'|'mouseup' for the given node
                        // node: Dom
                        //              Target node to listen to
                        // listener: Function
                        //              Callback function
                        // returns:
                        //              A handle which will be used to remove the listener by handle.remove()
                },
                cancel: function(node, listener){
                        // summary:
                        //              Register a listener to 'touchcancel'|'mouseleave' for the given node
                        // node: Dom
                        //              Target node to listen to
                        // listener: Function
                        //              Callback function
                        // returns:
                        //              A handle which will be used to remove the listener by handle.remove()
                },
                over: function(node, listener){
                        // summary:
                        //              Register a listener to 'mouseover' or touch equivalent for the given node
                        // node: Dom
                        //              Target node to listen to
                        // listener: Function
                        //              Callback function
                        // returns:
                        //              A handle which will be used to remove the listener by handle.remove()
                },
                out: function(node, listener){
                        // summary:
                        //              Register a listener to 'mouseout' or touch equivalent for the given node
                        // node: Dom
                        //              Target node to listen to
                        // listener: Function
                        //              Callback function
                        // returns:
                        //              A handle which will be used to remove the listener by handle.remove()
                },
                enter: function(node, listener){
                        // summary:
                        //              Register a listener to mouse.enter or touch equivalent for the given node
                        // node: Dom
                        //              Target node to listen to
                        // listener: Function
                        //              Callback function
                        // returns:
                        //              A handle which will be used to remove the listener by handle.remove()
                },
                leave: function(node, listener){
                        // summary:
                        //              Register a listener to mouse.leave or touch equivalent for the given node
                        // node: Dom
                        //              Target node to listen to
                        // listener: Function
                        //              Callback function
                        // returns:
                        //              A handle which will be used to remove the listener by handle.remove()
                }
        };
        =====*/

         1  && (dojo.touch = touch);

        return touch;
});

},
'url:dijit/form/templates/Select.html':"<table class=\"dijit dijitReset dijitInline dijitLeft\"\n\tdata-dojo-attach-point=\"_buttonNode,tableNode,focusNode\" cellspacing='0' cellpadding='0'\n\trole=\"listbox\" aria-haspopup=\"true\"\n\t><tbody role=\"presentation\"><tr role=\"presentation\"\n\t\t><td class=\"dijitReset dijitStretch dijitButtonContents\" role=\"presentation\"\n\t\t\t><div class=\"dijitReset dijitInputField dijitButtonText\"  data-dojo-attach-point=\"containerNode,_popupStateNode\" role=\"presentation\"></div\n\t\t\t><div class=\"dijitReset dijitValidationContainer\"\n\t\t\t\t><input class=\"dijitReset dijitInputField dijitValidationIcon dijitValidationInner\" value=\"&#935; \" type=\"text\" tabIndex=\"-1\" readonly=\"readonly\" role=\"presentation\"\n\t\t\t/></div\n\t\t\t><input type=\"hidden\" ${!nameAttrSetting} data-dojo-attach-point=\"valueNode\" value=\"${value}\" aria-hidden=\"true\"\n\t\t/></td\n\t\t><td class=\"dijitReset dijitRight dijitButtonNode dijitArrowButton dijitDownArrowButton dijitArrowButtonContainer\"\n\t\t\tdata-dojo-attach-point=\"titleNode\" role=\"presentation\"\n\t\t\t><input class=\"dijitReset dijitInputField dijitArrowButtonInner\" value=\"&#9660; \" type=\"text\" tabIndex=\"-1\" readonly=\"readonly\" role=\"presentation\"\n\t\t\t\t${_buttonInputDisabled}\n\t\t/></td\n\t></tr></tbody\n></table>\n",
'dojo/fx':function(){
define("dojo/fx", [
        "./_base/lang",
        "./Evented",
        "./_base/kernel",
        "./_base/array",
        "./_base/connect",
        "./_base/fx",
        "./dom",
        "./dom-style",
        "./dom-geometry",
        "./ready",
        "require" // for context sensitive loading of Toggler
], function(lang, Evented, dojo, arrayUtil, connect, baseFx, dom, domStyle, geom, ready, require){

        // module:
        //              dojo/fx
        
        // For back-compat, remove in 2.0.
        if(!dojo.isAsync){
                ready(0, function(){
                        var requires = ["./fx/Toggler"];
                        require(requires);      // use indirection so modules not rolled into a build
                });
        }

        var coreFx = dojo.fx = {
                // summary:
                //              Effects library on top of Base animations
        };

        var _baseObj = {
                        _fire: function(evt, args){
                                if(this[evt]){
                                        this[evt].apply(this, args||[]);
                                }
                                return this;
                        }
                };

        var _chain = function(animations){
                this._index = -1;
                this._animations = animations||[];
                this._current = this._onAnimateCtx = this._onEndCtx = null;

                this.duration = 0;
                arrayUtil.forEach(this._animations, function(a){
                        this.duration += a.duration;
                        if(a.delay){ this.duration += a.delay; }
                }, this);
        };
        _chain.prototype = new Evented();
        lang.extend(_chain, {
                _onAnimate: function(){
                        this._fire("onAnimate", arguments);
                },
                _onEnd: function(){
                        connect.disconnect(this._onAnimateCtx);
                        connect.disconnect(this._onEndCtx);
                        this._onAnimateCtx = this._onEndCtx = null;
                        if(this._index + 1 == this._animations.length){
                                this._fire("onEnd");
                        }else{
                                // switch animations
                                this._current = this._animations[++this._index];
                                this._onAnimateCtx = connect.connect(this._current, "onAnimate", this, "_onAnimate");
                                this._onEndCtx = connect.connect(this._current, "onEnd", this, "_onEnd");
                                this._current.play(0, true);
                        }
                },
                play: function(/*int?*/ delay, /*Boolean?*/ gotoStart){
                        if(!this._current){ this._current = this._animations[this._index = 0]; }
                        if(!gotoStart && this._current.status() == "playing"){ return this; }
                        var beforeBegin = connect.connect(this._current, "beforeBegin", this, function(){
                                        this._fire("beforeBegin");
                                }),
                                onBegin = connect.connect(this._current, "onBegin", this, function(arg){
                                        this._fire("onBegin", arguments);
                                }),
                                onPlay = connect.connect(this._current, "onPlay", this, function(arg){
                                        this._fire("onPlay", arguments);
                                        connect.disconnect(beforeBegin);
                                        connect.disconnect(onBegin);
                                        connect.disconnect(onPlay);
                                });
                        if(this._onAnimateCtx){
                                connect.disconnect(this._onAnimateCtx);
                        }
                        this._onAnimateCtx = connect.connect(this._current, "onAnimate", this, "_onAnimate");
                        if(this._onEndCtx){
                                connect.disconnect(this._onEndCtx);
                        }
                        this._onEndCtx = connect.connect(this._current, "onEnd", this, "_onEnd");
                        this._current.play.apply(this._current, arguments);
                        return this;
                },
                pause: function(){
                        if(this._current){
                                var e = connect.connect(this._current, "onPause", this, function(arg){
                                                this._fire("onPause", arguments);
                                                connect.disconnect(e);
                                        });
                                this._current.pause();
                        }
                        return this;
                },
                gotoPercent: function(/*Decimal*/percent, /*Boolean?*/ andPlay){
                        this.pause();
                        var offset = this.duration * percent;
                        this._current = null;
                        arrayUtil.some(this._animations, function(a){
                                if(a.duration <= offset){
                                        this._current = a;
                                        return true;
                                }
                                offset -= a.duration;
                                return false;
                        });
                        if(this._current){
                                this._current.gotoPercent(offset / this._current.duration, andPlay);
                        }
                        return this;
                },
                stop: function(/*boolean?*/ gotoEnd){
                        if(this._current){
                                if(gotoEnd){
                                        for(; this._index + 1 < this._animations.length; ++this._index){
                                                this._animations[this._index].stop(true);
                                        }
                                        this._current = this._animations[this._index];
                                }
                                var e = connect.connect(this._current, "onStop", this, function(arg){
                                                this._fire("onStop", arguments);
                                                connect.disconnect(e);
                                        });
                                this._current.stop();
                        }
                        return this;
                },
                status: function(){
                        return this._current ? this._current.status() : "stopped";
                },
                destroy: function(){
                        if(this._onAnimateCtx){ connect.disconnect(this._onAnimateCtx); }
                        if(this._onEndCtx){ connect.disconnect(this._onEndCtx); }
                }
        });
        lang.extend(_chain, _baseObj);

        coreFx.chain = function(/*dojo/_base/fx.Animation[]*/ animations){
                // summary:
                //              Chain a list of `dojo.Animation`s to run in sequence
                //
                // description:
                //              Return a `dojo.Animation` which will play all passed
                //              `dojo.Animation` instances in sequence, firing its own
                //              synthesized events simulating a single animation. (eg:
                //              onEnd of this animation means the end of the chain,
                //              not the individual animations within)
                //
                // example:
                //      Once `node` is faded out, fade in `otherNode`
                //      |       fx.chain([
                //      |               dojo.fadeIn({ node:node }),
                //      |               dojo.fadeOut({ node:otherNode })
                //      |       ]).play();
                //
                return new _chain(animations); // dojo/_base/fx.Animation
        };

        var _combine = function(animations){
                this._animations = animations||[];
                this._connects = [];
                this._finished = 0;

                this.duration = 0;
                arrayUtil.forEach(animations, function(a){
                        var duration = a.duration;
                        if(a.delay){ duration += a.delay; }
                        if(this.duration < duration){ this.duration = duration; }
                        this._connects.push(connect.connect(a, "onEnd", this, "_onEnd"));
                }, this);

                this._pseudoAnimation = new baseFx.Animation({curve: [0, 1], duration: this.duration});
                var self = this;
                arrayUtil.forEach(["beforeBegin", "onBegin", "onPlay", "onAnimate", "onPause", "onStop", "onEnd"],
                        function(evt){
                                self._connects.push(connect.connect(self._pseudoAnimation, evt,
                                        function(){ self._fire(evt, arguments); }
                                ));
                        }
                );
        };
        lang.extend(_combine, {
                _doAction: function(action, args){
                        arrayUtil.forEach(this._animations, function(a){
                                a[action].apply(a, args);
                        });
                        return this;
                },
                _onEnd: function(){
                        if(++this._finished > this._animations.length){
                                this._fire("onEnd");
                        }
                },
                _call: function(action, args){
                        var t = this._pseudoAnimation;
                        t[action].apply(t, args);
                },
                play: function(/*int?*/ delay, /*Boolean?*/ gotoStart){
                        this._finished = 0;
                        this._doAction("play", arguments);
                        this._call("play", arguments);
                        return this;
                },
                pause: function(){
                        this._doAction("pause", arguments);
                        this._call("pause", arguments);
                        return this;
                },
                gotoPercent: function(/*Decimal*/percent, /*Boolean?*/ andPlay){
                        var ms = this.duration * percent;
                        arrayUtil.forEach(this._animations, function(a){
                                a.gotoPercent(a.duration < ms ? 1 : (ms / a.duration), andPlay);
                        });
                        this._call("gotoPercent", arguments);
                        return this;
                },
                stop: function(/*boolean?*/ gotoEnd){
                        this._doAction("stop", arguments);
                        this._call("stop", arguments);
                        return this;
                },
                status: function(){
                        return this._pseudoAnimation.status();
                },
                destroy: function(){
                        arrayUtil.forEach(this._connects, connect.disconnect);
                }
        });
        lang.extend(_combine, _baseObj);

        coreFx.combine = function(/*dojo/_base/fx.Animation[]*/ animations){
                // summary:
                //              Combine a list of `dojo.Animation`s to run in parallel
                //
                // description:
                //              Combine an array of `dojo.Animation`s to run in parallel,
                //              providing a new `dojo.Animation` instance encompasing each
                //              animation, firing standard animation events.
                //
                // example:
                //      Fade out `node` while fading in `otherNode` simultaneously
                //      |       fx.combine([
                //      |               dojo.fadeIn({ node:node }),
                //      |               dojo.fadeOut({ node:otherNode })
                //      |       ]).play();
                //
                // example:
                //      When the longest animation ends, execute a function:
                //      |       var anim = fx.combine([
                //      |               dojo.fadeIn({ node: n, duration:700 }),
                //      |               dojo.fadeOut({ node: otherNode, duration: 300 })
                //      |       ]);
                //      |       dojo.connect(anim, "onEnd", function(){
                //      |               // overall animation is done.
                //      |       });
                //      |       anim.play(); // play the animation
                //
                return new _combine(animations); // dojo/_base/fx.Animation
        };

        coreFx.wipeIn = function(/*Object*/ args){
                // summary:
                //              Expand a node to it's natural height.
                //
                // description:
                //              Returns an animation that will expand the
                //              node defined in 'args' object from it's current height to
                //              it's natural height (with no scrollbar).
                //              Node must have no margin/border/padding.
                //
                // args: Object
                //              A hash-map of standard `dojo.Animation` constructor properties
                //              (such as easing: node: duration: and so on)
                //
                // example:
                //      |       fx.wipeIn({
                //      |               node:"someId"
                //      |       }).play()
                var node = args.node = dom.byId(args.node), s = node.style, o;

                var anim = baseFx.animateProperty(lang.mixin({
                        properties: {
                                height: {
                                        // wrapped in functions so we wait till the last second to query (in case value has changed)
                                        start: function(){
                                                // start at current [computed] height, but use 1px rather than 0
                                                // because 0 causes IE to display the whole panel
                                                o = s.overflow;
                                                s.overflow = "hidden";
                                                if(s.visibility == "hidden" || s.display == "none"){
                                                        s.height = "1px";
                                                        s.display = "";
                                                        s.visibility = "";
                                                        return 1;
                                                }else{
                                                        var height = domStyle.get(node, "height");
                                                        return Math.max(height, 1);
                                                }
                                        },
                                        end: function(){
                                                return node.scrollHeight;
                                        }
                                }
                        }
                }, args));

                var fini = function(){
                        s.height = "auto";
                        s.overflow = o;
                };
                connect.connect(anim, "onStop", fini);
                connect.connect(anim, "onEnd", fini);

                return anim; // dojo/_base/fx.Animation
        };

        coreFx.wipeOut = function(/*Object*/ args){
                // summary:
                //              Shrink a node to nothing and hide it.
                //
                // description:
                //              Returns an animation that will shrink node defined in "args"
                //              from it's current height to 1px, and then hide it.
                //
                // args: Object
                //              A hash-map of standard `dojo.Animation` constructor properties
                //              (such as easing: node: duration: and so on)
                //
                // example:
                //      |       fx.wipeOut({ node:"someId" }).play()

                var node = args.node = dom.byId(args.node), s = node.style, o;

                var anim = baseFx.animateProperty(lang.mixin({
                        properties: {
                                height: {
                                        end: 1 // 0 causes IE to display the whole panel
                                }
                        }
                }, args));

                connect.connect(anim, "beforeBegin", function(){
                        o = s.overflow;
                        s.overflow = "hidden";
                        s.display = "";
                });
                var fini = function(){
                        s.overflow = o;
                        s.height = "auto";
                        s.display = "none";
                };
                connect.connect(anim, "onStop", fini);
                connect.connect(anim, "onEnd", fini);

                return anim; // dojo/_base/fx.Animation
        };

        coreFx.slideTo = function(/*Object*/ args){
                // summary:
                //              Slide a node to a new top/left position
                //
                // description:
                //              Returns an animation that will slide "node"
                //              defined in args Object from its current position to
                //              the position defined by (args.left, args.top).
                //
                // args: Object
                //              A hash-map of standard `dojo.Animation` constructor properties
                //              (such as easing: node: duration: and so on). Special args members
                //              are `top` and `left`, which indicate the new position to slide to.
                //
                // example:
                //      |       .slideTo({ node: node, left:"40", top:"50", units:"px" }).play()

                var node = args.node = dom.byId(args.node),
                        top = null, left = null;

                var init = (function(n){
                        return function(){
                                var cs = domStyle.getComputedStyle(n);
                                var pos = cs.position;
                                top = (pos == 'absolute' ? n.offsetTop : parseInt(cs.top) || 0);
                                left = (pos == 'absolute' ? n.offsetLeft : parseInt(cs.left) || 0);
                                if(pos != 'absolute' && pos != 'relative'){
                                        var ret = geom.position(n, true);
                                        top = ret.y;
                                        left = ret.x;
                                        n.style.position="absolute";
                                        n.style.top=top+"px";
                                        n.style.left=left+"px";
                                }
                        };
                })(node);
                init();

                var anim = baseFx.animateProperty(lang.mixin({
                        properties: {
                                top: args.top || 0,
                                left: args.left || 0
                        }
                }, args));
                connect.connect(anim, "beforeBegin", anim, init);

                return anim; // dojo/_base/fx.Animation
        };

        return coreFx;
});

},
'dijit/_DialogMixin':function(){
define("dijit/_DialogMixin", [
        "dojo/_base/declare", // declare
        "./a11y"        // _getTabNavigable
], function(declare, a11y){

        // module:
        //              dijit/_DialogMixin

        return declare("dijit._DialogMixin", null, {
                // summary:
                //              This provides functions useful to Dialog and TooltipDialog

                execute: function(/*Object*/ /*===== formContents =====*/){
                        // summary:
                        //              Callback when the user hits the submit button.
                        //              Override this method to handle Dialog execution.
                        // description:
                        //              After the user has pressed the submit button, the Dialog
                        //              first calls onExecute() to notify the container to hide the
                        //              dialog and restore focus to wherever it used to be.
                        //
                        //              *Then* this method is called.
                        // type:
                        //              callback
                },

                onCancel: function(){
                        // summary:
                        //              Called when user has pressed the Dialog's cancel button, to notify container.
                        // description:
                        //              Developer shouldn't override or connect to this method;
                        //              it's a private communication device between the TooltipDialog
                        //              and the thing that opened it (ex: `dijit/form/DropDownButton`)
                        // type:
                        //              protected
                },

                onExecute: function(){
                        // summary:
                        //              Called when user has pressed the dialog's OK button, to notify container.
                        // description:
                        //              Developer shouldn't override or connect to this method;
                        //              it's a private communication device between the TooltipDialog
                        //              and the thing that opened it (ex: `dijit/form/DropDownButton`)
                        // type:
                        //              protected
                },

                _onSubmit: function(){
                        // summary:
                        //              Callback when user hits submit button
                        // type:
                        //              protected
                        this.onExecute();       // notify container that we are about to execute
                        this.execute(this.get('value'));
                },

                _getFocusItems: function(){
                        // summary:
                        //              Finds focusable items in dialog,
                        //              and sets this._firstFocusItem and this._lastFocusItem
                        // tags:
                        //              protected

                        var elems = a11y._getTabNavigable(this.containerNode);
                        this._firstFocusItem = elems.lowest || elems.first || this.closeButtonNode || this.domNode;
                        this._lastFocusItem = elems.last || elems.highest || this._firstFocusItem;
                }
        });
});

},
'dijit/Tree':function(){
require({cache:{
'url:dijit/templates/TreeNode.html':"<div class=\"dijitTreeNode\" role=\"presentation\"\n\t><div data-dojo-attach-point=\"rowNode\" class=\"dijitTreeRow dijitInline\" role=\"presentation\"\n\t\t><div data-dojo-attach-point=\"indentNode\" class=\"dijitInline\"></div\n\t\t><img src=\"${_blankGif}\" alt=\"\" data-dojo-attach-point=\"expandoNode\" class=\"dijitTreeExpando\" role=\"presentation\"\n\t\t/><span data-dojo-attach-point=\"expandoNodeText\" class=\"dijitExpandoText\" role=\"presentation\"\n\t\t></span\n\t\t><span data-dojo-attach-point=\"contentNode\"\n\t\t\tclass=\"dijitTreeContent\" role=\"presentation\">\n\t\t\t<img src=\"${_blankGif}\" alt=\"\" data-dojo-attach-point=\"iconNode\" class=\"dijitIcon dijitTreeIcon\" role=\"presentation\"\n\t\t\t/><span data-dojo-attach-point=\"labelNode\" class=\"dijitTreeLabel\" role=\"treeitem\" tabindex=\"-1\" aria-selected=\"false\"></span>\n\t\t</span\n\t></div>\n\t<div data-dojo-attach-point=\"containerNode\" class=\"dijitTreeContainer\" role=\"presentation\" style=\"display: none;\"></div>\n</div>\n",
'url:dijit/templates/Tree.html':"<div class=\"dijitTree dijitTreeContainer\" role=\"tree\">\n\t<div class=\"dijitInline dijitTreeIndent\" style=\"position: absolute; top: -9999px\" data-dojo-attach-point=\"indentDetector\"></div>\n</div>\n"}});
define("dijit/Tree", [
        "dojo/_base/array", // array.filter array.forEach array.map
        "dojo/_base/connect",   // connect.isCopyKey()
        "dojo/cookie", // cookie
        "dojo/_base/declare", // declare
        "dojo/Deferred", // Deferred
        "dojo/DeferredList", // DeferredList
        "dojo/dom", // dom.isDescendant
        "dojo/dom-class", // domClass.add domClass.remove domClass.replace domClass.toggle
        "dojo/dom-geometry", // domGeometry.setMarginBox domGeometry.position
        "dojo/dom-style",// domStyle.set
        "dojo/_base/event", // event.stop
        "dojo/errors/create",   // createError
        "dojo/fx", // fxUtils.wipeIn fxUtils.wipeOut
        "dojo/_base/kernel", // kernel.deprecated
        "dojo/keys",    // arrows etc.
        "dojo/_base/lang", // lang.getObject lang.mixin lang.hitch
        "dojo/on",              // on(), on.selector()
        "dojo/topic",
        "dojo/touch",
        "dojo/when",
        "./focus",
        "./registry",   // registry.byNode(), registry.getEnclosingWidget()
        "./_base/manager",      // manager.defaultDuration
        "./_Widget",
        "./_TemplatedMixin",
        "./_Container",
        "./_Contained",
        "./_CssStateMixin",
        "dojo/text!./templates/TreeNode.html",
        "dojo/text!./templates/Tree.html",
        "./tree/TreeStoreModel",
        "./tree/ForestStoreModel",
        "./tree/_dndSelector"
], function(array, connect, cookie, declare, Deferred, DeferredList,
                        dom, domClass, domGeometry, domStyle, event, createError, fxUtils, kernel, keys, lang, on, topic, touch, when,
                        focus, registry, manager, _Widget, _TemplatedMixin, _Container, _Contained, _CssStateMixin,
                        treeNodeTemplate, treeTemplate, TreeStoreModel, ForestStoreModel, _dndSelector){

// module:
//              dijit/Tree

// Back-compat shim
Deferred = declare(Deferred, {
        addCallback: function(callback){ this.then(callback); },
        addErrback: function(errback){ this.then(null, errback); }
});

var TreeNode = declare(
        "dijit._TreeNode",
        [_Widget, _TemplatedMixin, _Container, _Contained, _CssStateMixin],
{
        // summary:
        //              Single node within a tree.   This class is used internally
        //              by Tree and should not be accessed directly.
        // tags:
        //              private

        // item: [const] Item
        //              the dojo.data entry this tree represents
        item: null,

        // isTreeNode: [protected] Boolean
        //              Indicates that this is a TreeNode.   Used by `dijit.Tree` only,
        //              should not be accessed directly.
        isTreeNode: true,

        // label: String
        //              Text of this tree node
        label: "",
        _setLabelAttr: {node: "labelNode", type: "innerText"},

        // isExpandable: [private] Boolean
        //              This node has children, so show the expando node (+ sign)
        isExpandable: null,

        // isExpanded: [readonly] Boolean
        //              This node is currently expanded (ie, opened)
        isExpanded: false,

        // state: [private] String
        //              Dynamic loading-related stuff.
        //              When an empty folder node appears, it is "UNCHECKED" first,
        //              then after dojo.data query it becomes "LOADING" and, finally "LOADED"
        state: "UNCHECKED",

        templateString: treeNodeTemplate,

        baseClass: "dijitTreeNode",

        // For hover effect for tree node, and focus effect for label
        cssStateNodes: {
                rowNode: "dijitTreeRow"
        },

        // Tooltip is defined in _WidgetBase but we need to handle the mapping to DOM here
        _setTooltipAttr: {node: "rowNode", type: "attribute", attribute: "title"},

        buildRendering: function(){
                this.inherited(arguments);

                // set expand icon for leaf
                this._setExpando();

                // set icon and label class based on item
                this._updateItemClasses(this.item);

                if(this.isExpandable){
                        this.labelNode.setAttribute("aria-expanded", this.isExpanded);
                }

                //aria-selected should be false on all selectable elements.
                this.setSelected(false);
        },

        _setIndentAttr: function(indent){
                // summary:
                //              Tell this node how many levels it should be indented
                // description:
                //              0 for top level nodes, 1 for their children, 2 for their
                //              grandchildren, etc.

                // Math.max() is to prevent negative padding on hidden root node (when indent == -1)
                var pixels = (Math.max(indent, 0) * this.tree._nodePixelIndent) + "px";

                domStyle.set(this.domNode, "backgroundPosition", pixels + " 0px");      // TODOC: what is this for???
                domStyle.set(this.indentNode, this.isLeftToRight() ? "paddingLeft" : "paddingRight", pixels);

                array.forEach(this.getChildren(), function(child){
                        child.set("indent", indent+1);
                });

                this._set("indent", indent);
        },

        markProcessing: function(){
                // summary:
                //              Visually denote that tree is loading data, etc.
                // tags:
                //              private
                this.state = "LOADING";
                this._setExpando(true);
        },

        unmarkProcessing: function(){
                // summary:
                //              Clear markup from markProcessing() call
                // tags:
                //              private
                this._setExpando(false);
        },

        _updateItemClasses: function(item){
                // summary:
                //              Set appropriate CSS classes for icon and label dom node
                //              (used to allow for item updates to change respective CSS)
                // tags:
                //              private
                var tree = this.tree, model = tree.model;
                if(tree._v10Compat && item === model.root){
                        // For back-compat with 1.0, need to use null to specify root item (TODO: remove in 2.0)
                        item = null;
                }
                this._applyClassAndStyle(item, "icon", "Icon");
                this._applyClassAndStyle(item, "label", "Label");
                this._applyClassAndStyle(item, "row", "Row");

                this.tree._startPaint(true);            // signifies paint started and finished (synchronously)
        },

        _applyClassAndStyle: function(item, lower, upper){
                // summary:
                //              Set the appropriate CSS classes and styles for labels, icons and rows.
                //
                // item:
                //              The data item.
                //
                // lower:
                //              The lower case attribute to use, e.g. 'icon', 'label' or 'row'.
                //
                // upper:
                //              The upper case attribute to use, e.g. 'Icon', 'Label' or 'Row'.
                //
                // tags:
                //              private

                var clsName = "_" + lower + "Class";
                var nodeName = lower + "Node";
                var oldCls = this[clsName];

                this[clsName] = this.tree["get" + upper + "Class"](item, this.isExpanded);
                domClass.replace(this[nodeName], this[clsName] || "", oldCls || "");

                domStyle.set(this[nodeName], this.tree["get" + upper + "Style"](item, this.isExpanded) || {});
        },

        _updateLayout: function(){
                // summary:
                //              Set appropriate CSS classes for this.domNode
                // tags:
                //              private
                var parent = this.getParent();
                if(!parent || !parent.rowNode || parent.rowNode.style.display == "none"){
                        /* if we are hiding the root node then make every first level child look like a root node */
                        domClass.add(this.domNode, "dijitTreeIsRoot");
                }else{
                        domClass.toggle(this.domNode, "dijitTreeIsLast", !this.getNextSibling());
                }
        },

        _setExpando: function(/*Boolean*/ processing){
                // summary:
                //              Set the right image for the expando node
                // tags:
                //              private

                var styles = ["dijitTreeExpandoLoading", "dijitTreeExpandoOpened",
                                                "dijitTreeExpandoClosed", "dijitTreeExpandoLeaf"],
                        _a11yStates = ["*","-","+","*"],
                        idx = processing ? 0 : (this.isExpandable ?     (this.isExpanded ? 1 : 2) : 3);

                // apply the appropriate class to the expando node
                domClass.replace(this.expandoNode, styles[idx], styles);

                // provide a non-image based indicator for images-off mode
                this.expandoNodeText.innerHTML = _a11yStates[idx];

        },

        expand: function(){
                // summary:
                //              Show my children
                // returns:
                //              Deferred that fires when expansion is complete

                // If there's already an expand in progress or we are already expanded, just return
                if(this._expandDeferred){
                        return this._expandDeferred;            // dojo/_base/Deferred
                }

                // cancel in progress collapse operation
                if(this._collapseDeferred){
                        this._collapseDeferred.cancel();
                        delete this._collapseDeferred;
                }

                // All the state information for when a node is expanded, maybe this should be
                // set when the animation completes instead
                this.isExpanded = true;
                this.labelNode.setAttribute("aria-expanded", "true");
                if(this.tree.showRoot || this !== this.tree.rootNode){
                        this.containerNode.setAttribute("role", "group");
                }
                domClass.add(this.contentNode,'dijitTreeContentExpanded');
                this._setExpando();
                this._updateItemClasses(this.item);
                
                if(this == this.tree.rootNode && this.tree.showRoot){
                        this.tree.domNode.setAttribute("aria-expanded", "true");
                }

                var def,
                        wipeIn = fxUtils.wipeIn({
                                node: this.containerNode,
                                duration: manager.defaultDuration,
                                onEnd: function(){
                                        def.resolve(true);
                                }
                        });

                // Deferred that fires when expand is complete
                def = (this._expandDeferred = new Deferred(function(){
                        // Canceller
                        wipeIn.stop();
                }));

                wipeIn.play();

                return def;             // dojo/_base/Deferred
        },

        collapse: function(){
                // summary:
                //              Collapse this node (if it's expanded)

                if(this._collapseDeferred){
                        // Node is already collapsed, or there's a collapse in progress, just return that Deferred
                        return this._collapseDeferred;
                }

                // cancel in progress expand operation
                if(this._expandDeferred){
                        this._expandDeferred.cancel();
                        delete this._expandDeferred;
                }

                this.isExpanded = false;
                this.labelNode.setAttribute("aria-expanded", "false");
                if(this == this.tree.rootNode && this.tree.showRoot){
                        this.tree.domNode.setAttribute("aria-expanded", "false");
                }
                domClass.remove(this.contentNode,'dijitTreeContentExpanded');
                this._setExpando();
                this._updateItemClasses(this.item);

                var def,
                        wipeOut = fxUtils.wipeOut({
                                node: this.containerNode,
                                duration: manager.defaultDuration,
                                onEnd: function(){
                                        def.resolve(true);
                                }
                        });

                // Deferred that fires when expand is complete
                def = (this._collapseDeferred = new Deferred(function(){
                        // Canceller
                        wipeOut.stop();
                }));

                wipeOut.play();

                return def;             // dojo/_base/Deferred
        },

        // indent: Integer
        //              Levels from this node to the root node
        indent: 0,

        setChildItems: function(/* Object[] */ items){
                // summary:
                //              Sets the child items of this node, removing/adding nodes
                //              from current children to match specified items[] array.
                //              Also, if this.persist == true, expands any children that were previously
                //              opened.
                // returns:
                //              Deferred object that fires after all previously opened children
                //              have been expanded again (or fires instantly if there are no such children).

                var tree = this.tree,
                        model = tree.model,
                        defs = [];      // list of deferreds that need to fire before I am complete


                // Orphan all my existing children.
                // If items contains some of the same items as before then we will reattach them.
                // Don't call this.removeChild() because that will collapse the tree etc.
                var oldChildren = this.getChildren();
                array.forEach(oldChildren, function(child){
                        _Container.prototype.removeChild.call(this, child);
                }, this);

                // All the old children of this TreeNode are subject for destruction if
                //              1) they aren't listed in the new children array (items)
                //              2) they aren't immediately adopted by another node (DnD)
                this.defer(function(){
                        array.forEach(oldChildren, function(node){
                                if(!node._destroyed && !node.getParent()){
                                        // If node is in selection then remove it.
                                        tree.dndController.removeTreeNode(node);

                                        // Deregister mapping from item id --> this node
                                        var id = model.getIdentity(node.item),
                                                ary = tree._itemNodesMap[id];
                                        if(ary.length == 1){
                                                delete tree._itemNodesMap[id];
                                        }else{
                                                var index = array.indexOf(ary, node);
                                                if(index != -1){
                                                        ary.splice(index, 1);
                                                }
                                        }

                                        // And finally we can destroy the node
                                        node.destroyRecursive();
                                }
                        });
                });

                this.state = "LOADED";

                if(items && items.length > 0){
                        this.isExpandable = true;

                        // Create _TreeNode widget for each specified tree node, unless one already
                        // exists and isn't being used (presumably it's from a DnD move and was recently
                        // released
                        array.forEach(items, function(item){    // MARKER: REUSE NODE
                                var id = model.getIdentity(item),
                                        existingNodes = tree._itemNodesMap[id],
                                        node;
                                if(existingNodes){
                                        for(var i=0;i<existingNodes.length;i++){
                                                if(existingNodes[i] && !existingNodes[i].getParent()){
                                                        node = existingNodes[i];
                                                        node.set('indent', this.indent+1);
                                                        break;
                                                }
                                        }
                                }
                                if(!node){
                                        node = this.tree._createTreeNode({
                                                item: item,
                                                tree: tree,
                                                isExpandable: model.mayHaveChildren(item),
                                                label: tree.getLabel(item),
                                                tooltip: tree.getTooltip(item),
                                                ownerDocument: tree.ownerDocument,
                                                dir: tree.dir,
                                                lang: tree.lang,
                                                textDir: tree.textDir,
                                                indent: this.indent + 1
                                        });
                                        if(existingNodes){
                                                existingNodes.push(node);
                                        }else{
                                                tree._itemNodesMap[id] = [node];
                                        }
                                }
                                this.addChild(node);

                                // If node was previously opened then open it again now (this may trigger
                                // more data store accesses, recursively)
                                if(this.tree.autoExpand || this.tree._state(node)){
                                        defs.push(tree._expandNode(node));
                                }
                        }, this);

                        // note that updateLayout() needs to be called on each child after
                        // _all_ the children exist
                        array.forEach(this.getChildren(), function(child){
                                child._updateLayout();
                        });
                }else{
                        this.isExpandable=false;
                }

                if(this._setExpando){
                        // change expando to/from dot or + icon, as appropriate
                        this._setExpando(false);
                }

                // Set leaf icon or folder icon, as appropriate
                this._updateItemClasses(this.item);

                // On initial tree show, make the selected TreeNode as either the root node of the tree,
                // or the first child, if the root node is hidden
                if(this == tree.rootNode){
                        var fc = this.tree.showRoot ? this : this.getChildren()[0];
                        if(fc){
                                fc.setFocusable(true);
                                tree.lastFocused = fc;
                        }else{
                                // fallback: no nodes in tree so focus on Tree <div> itself
                                tree.domNode.setAttribute("tabIndex", "0");
                        }
                }

                var def =  new DeferredList(defs);
                this.tree._startPaint(def);             // to reset TreeNode widths after an item is added/removed from the Tree
                return def;             // dojo/_base/Deferred
        },

        getTreePath: function(){
                var node = this;
                var path = [];
                while(node && node !== this.tree.rootNode){
                                path.unshift(node.item);
                                node = node.getParent();
                }
                path.unshift(this.tree.rootNode.item);

                return path;
        },

        getIdentity: function(){
                return this.tree.model.getIdentity(this.item);
        },

        removeChild: function(/* treeNode */ node){
                this.inherited(arguments);

                var children = this.getChildren();
                if(children.length == 0){
                        this.isExpandable = false;
                        this.collapse();
                }

                array.forEach(children, function(child){
                                child._updateLayout();
                });
        },

        makeExpandable: function(){
                // summary:
                //              if this node wasn't already showing the expando node,
                //              turn it into one and call _setExpando()

                // TODO: hmm this isn't called from anywhere, maybe should remove it for 2.0

                this.isExpandable = true;
                this._setExpando(false);
        },

        setSelected: function(/*Boolean*/ selected){
                // summary:
                //              A Tree has a (single) currently selected node.
                //              Mark that this node is/isn't that currently selected node.
                // description:
                //              In particular, setting a node as selected involves setting tabIndex
                //              so that when user tabs to the tree, focus will go to that node (only).
                this.labelNode.setAttribute("aria-selected", selected ? "true" : "false");
                domClass.toggle(this.rowNode, "dijitTreeRowSelected", selected);
        },

        setFocusable: function(/*Boolean*/ selected){
                // summary:
                //              A Tree has a (single) node that's focusable.
                //              Mark that this node is/isn't that currently focsuable node.
                // description:
                //              In particular, setting a node as selected involves setting tabIndex
                //              so that when user tabs to the tree, focus will go to that node (only).

                this.labelNode.setAttribute("tabIndex", selected ? "0" : "-1");
        },


        _setTextDirAttr: function(textDir){
                if(textDir &&((this.textDir != textDir) || !this._created)){
                        this._set("textDir", textDir);
                        this.applyTextDir(this.labelNode, this.labelNode.innerText || this.labelNode.textContent || "");
                        array.forEach(this.getChildren(), function(childNode){
                                childNode.set("textDir", textDir);
                        }, this);
                }
        }
});

var Tree = declare("dijit.Tree", [_Widget, _TemplatedMixin], {
        // summary:
        //              This widget displays hierarchical data from a store.

        // store: [deprecated] String|dojo/data/Store
        //              Deprecated.  Use "model" parameter instead.
        //              The store to get data to display in the tree.
        store: null,

        // model: dijit/tree/model
        //              Interface to read tree data, get notifications of changes to tree data,
        //              and for handling drop operations (i.e drag and drop onto the tree)
        model: null,

        // query: [deprecated] anything
        //              Deprecated.  User should specify query to the model directly instead.
        //              Specifies datastore query to return the root item or top items for the tree.
        query: null,

        // label: [deprecated] String
        //              Deprecated.  Use dijit/tree/ForestStoreModel directly instead.
        //              Used in conjunction with query parameter.
        //              If a query is specified (rather than a root node id), and a label is also specified,
        //              then a fake root node is created and displayed, with this label.
        label: "",

        // showRoot: [const] Boolean
        //              Should the root node be displayed, or hidden?
        showRoot: true,

        // childrenAttr: [deprecated] String[]
        //              Deprecated.   This information should be specified in the model.
        //              One ore more attributes that holds children of a tree node
        childrenAttr: ["children"],

        // paths: String[][] or Item[][]
        //              Full paths from rootNode to selected nodes expressed as array of items or array of ids.
        //              Since setting the paths may be asynchronous (because of waiting on dojo.data), set("paths", ...)
        //              returns a Deferred to indicate when the set is complete.
        paths: [],

        // path: String[] or Item[]
        //              Backward compatible singular variant of paths.
        path: [],

        // selectedItems: [readonly] Item[]
        //              The currently selected items in this tree.
        //              This property can only be set (via set('selectedItems', ...)) when that item is already
        //              visible in the tree.   (I.e. the tree has already been expanded to show that node.)
        //              Should generally use `paths` attribute to set the selected items instead.
        selectedItems: null,

        // selectedItem: [readonly] Item
        //              Backward compatible singular variant of selectedItems.
        selectedItem: null,

        // openOnClick: Boolean
        //              If true, clicking a folder node's label will open it, rather than calling onClick()
        openOnClick: false,

        // openOnDblClick: Boolean
        //              If true, double-clicking a folder node's label will open it, rather than calling onDblClick()
        openOnDblClick: false,

        templateString: treeTemplate,

        // persist: Boolean
        //              Enables/disables use of cookies for state saving.
        persist: true,

        // autoExpand: Boolean
        //              Fully expand the tree on load.   Overrides `persist`.
        autoExpand: false,

        // dndController: [protected] Function|String
        //              Class to use as as the dnd controller.  Specifying this class enables DnD.
        //              Generally you should specify this as dijit/tree/dndSource.
        //              Setting of dijit/tree/_dndSelector handles selection only (no actual DnD).
        dndController: _dndSelector,

        // parameters to pull off of the tree and pass on to the dndController as its params
        dndParams: ["onDndDrop","itemCreator","onDndCancel","checkAcceptance", "checkItemAcceptance", "dragThreshold", "betweenThreshold"],

        //declare the above items so they can be pulled from the tree's markup

        // onDndDrop: [protected] Function
        //              Parameter to dndController, see `dijit/tree/dndSource.onDndDrop()`.
        //              Generally this doesn't need to be set.
        onDndDrop: null,

        itemCreator: null,
        /*=====
        itemCreator: function(nodes, target, source){
                // summary:
                //              Returns objects passed to `Tree.model.newItem()` based on DnD nodes
                //              dropped onto the tree.   Developer must override this method to enable
                //              dropping from external sources onto this Tree, unless the Tree.model's items
                //              happen to look like {id: 123, name: "Apple" } with no other attributes.
                //
                //              For each node in nodes[], which came from source, create a hash of name/value
                //              pairs to be passed to Tree.model.newItem().  Returns array of those hashes.
                // nodes: DomNode[]
                //              The DOMNodes dragged from the source container
                // target: DomNode
                //              The target TreeNode.rowNode
                // source: dojo/dnd/Source
                //              The source container the nodes were dragged from, perhaps another Tree or a plain dojo/dnd/Source
                // returns: Object[]
                //              Array of name/value hashes for each new item to be added to the Tree, like:
                // |    [
                // |            { id: 123, label: "apple", foo: "bar" },
                // |            { id: 456, label: "pear", zaz: "bam" }
                // |    ]
                // tags:
                //              extension
                return [{}];
        },
        =====*/

        // onDndCancel: [protected] Function
        //              Parameter to dndController, see `dijit/tree/dndSource.onDndCancel()`.
        //              Generally this doesn't need to be set.
        onDndCancel: null,

/*=====
        checkAcceptance: function(source, nodes){
                // summary:
                //              Checks if the Tree itself can accept nodes from this source
                // source: dijit/tree/dndSource
                //              The source which provides items
                // nodes: DOMNode[]
                //              Array of DOM nodes corresponding to nodes being dropped, dijitTreeRow nodes if
                //              source is a dijit/Tree.
                // tags:
                //              extension
                return true;    // Boolean
        },
=====*/
        checkAcceptance: null,

/*=====
        checkItemAcceptance: function(target, source, position){
                // summary:
                //              Stub function to be overridden if one wants to check for the ability to drop at the node/item level
                // description:
                //              In the base case, this is called to check if target can become a child of source.
                //              When betweenThreshold is set, position="before" or "after" means that we
                //              are asking if the source node can be dropped before/after the target node.
                // target: DOMNode
                //              The dijitTreeRoot DOM node inside of the TreeNode that we are dropping on to
                //              Use registry.getEnclosingWidget(target) to get the TreeNode.
                // source: dijit/tree/dndSource
                //              The (set of) nodes we are dropping
                // position: String
                //              "over", "before", or "after"
                // tags:
                //              extension
                return true;    // Boolean
        },
=====*/
        checkItemAcceptance: null,

        // dragThreshold: Integer
        //              Number of pixels mouse moves before it's considered the start of a drag operation
        dragThreshold: 5,

        // betweenThreshold: Integer
        //              Set to a positive value to allow drag and drop "between" nodes.
        //
        //              If during DnD mouse is over a (target) node but less than betweenThreshold
        //              pixels from the bottom edge, dropping the the dragged node will make it
        //              the next sibling of the target node, rather than the child.
        //
        //              Similarly, if mouse is over a target node but less that betweenThreshold
        //              pixels from the top edge, dropping the dragged node will make it
        //              the target node's previous sibling rather than the target node's child.
        betweenThreshold: 0,

        // _nodePixelIndent: Integer
        //              Number of pixels to indent tree nodes (relative to parent node).
        //              Default is 19 but can be overridden by setting CSS class dijitTreeIndent
        //              and calling resize() or startup() on tree after it's in the DOM.
        _nodePixelIndent: 19,

        _publish: function(/*String*/ topicName, /*Object*/ message){
                // summary:
                //              Publish a message for this widget/topic
                topic.publish(this.id, lang.mixin({tree: this, event: topicName}, message || {}));      // publish
        },

        postMixInProperties: function(){
                this.tree = this;

                if(this.autoExpand){
                        // There's little point in saving opened/closed state of nodes for a Tree
                        // that initially opens all it's nodes.
                        this.persist = false;
                }

                this._itemNodesMap = {};

                if(!this.cookieName && this.id){
                        this.cookieName = this.id + "SaveStateCookie";
                }

                // Deferred that fires when all the children have loaded.
                this.expandChildrenDeferred  = new Deferred();

                // Deferred that fires when all pending operations complete.
                this.pendingCommandsDeferred = this.expandChildrenDeferred;

                this.inherited(arguments);
        },

        postCreate: function(){
                this._initState();

                // Catch events on TreeNodes
                var self = this;
                this.own(
                        on(this.domNode, on.selector(".dijitTreeNode", touch.enter), function(evt){
                                self._onNodeMouseEnter(registry.byNode(this), evt);
                        }),
                        on(this.domNode, on.selector(".dijitTreeNode", touch.leave), function(evt){
                                self._onNodeMouseLeave(registry.byNode(this), evt);
                        }),
                        on(this.domNode, on.selector(".dijitTreeNode", "click"), function(evt){
                                self._onClick(registry.byNode(this), evt);
                        }),
                        on(this.domNode, on.selector(".dijitTreeNode", "dblclick"), function(evt){
                                self._onDblClick(registry.byNode(this), evt);
                        }),
                        on(this.domNode, on.selector(".dijitTreeNode", "keypress"), function(evt){
                                self._onKeyPress(registry.byNode(this), evt);
                        }),
                        on(this.domNode, on.selector(".dijitTreeNode", "keydown"), function(evt){
                                self._onKeyDown(registry.byNode(this), evt);
                        }),
                        on(this.domNode, on.selector(".dijitTreeRow", "focusin"), function(evt){
                                self._onNodeFocus(registry.getEnclosingWidget(this), evt);
                        })
                );

                // Create glue between store and Tree, if not specified directly by user
                if(!this.model){
                        this._store2model();
                }

                // monitor changes to items
                this.connect(this.model, "onChange", "_onItemChange");
                this.connect(this.model, "onChildrenChange", "_onItemChildrenChange");
                this.connect(this.model, "onDelete", "_onItemDelete");

                this.inherited(arguments);

                if(this.dndController){
                        if(lang.isString(this.dndController)){
                                this.dndController = lang.getObject(this.dndController);
                        }
                        var params={};
                        for(var i=0; i<this.dndParams.length;i++){
                                if(this[this.dndParams[i]]){
                                        params[this.dndParams[i]] = this[this.dndParams[i]];
                                }
                        }
                        this.dndController = new this.dndController(this, params);
                }

                this._load();

                // If no path was specified to the constructor, use path saved in cookie
                if(!this.params.path && !this.params.paths && this.persist){
                        this.set("paths", this.dndController._getSavedPaths());
                }

                // onLoadDeferred should fire when all commands that are part of initialization have completed.
                // It will include all the set("paths", ...) commands that happen during initialization.
                this.onLoadDeferred = this.pendingCommandsDeferred;
                                
                this.onLoadDeferred.then(lang.hitch(this, "onLoad"));
        },

        _store2model: function(){
                // summary:
                //              User specified a store&query rather than model, so create model from store/query
                this._v10Compat = true;
                kernel.deprecated("Tree: from version 2.0, should specify a model object rather than a store/query");

                var modelParams = {
                        id: this.id + "_ForestStoreModel",
                        store: this.store,
                        query: this.query,
                        childrenAttrs: this.childrenAttr
                };

                // Only override the model's mayHaveChildren() method if the user has specified an override
                if(this.params.mayHaveChildren){
                        modelParams.mayHaveChildren = lang.hitch(this, "mayHaveChildren");
                }

                if(this.params.getItemChildren){
                        modelParams.getChildren = lang.hitch(this, function(item, onComplete, onError){
                                this.getItemChildren((this._v10Compat && item === this.model.root) ? null : item, onComplete, onError);
                        });
                }
                this.model = new ForestStoreModel(modelParams);

                // For backwards compatibility, the visibility of the root node is controlled by
                // whether or not the user has specified a label
                this.showRoot = Boolean(this.label);
        },

        onLoad: function(){
                // summary:
                //              Called when tree finishes loading and expanding.
                // description:
                //              If persist == true the loading may encompass many levels of fetches
                //              from the data store, each asynchronous.   Waits for all to finish.
                // tags:
                //              callback
        },

        _load: function(){
                // summary:
                //              Initial load of the tree.
                //              Load root node (possibly hidden) and it's children.
                this.model.getRoot(
                        lang.hitch(this, function(item){
                                var rn = (this.rootNode = this.tree._createTreeNode({
                                        item: item,
                                        tree: this,
                                        isExpandable: true,
                                        label: this.label || this.getLabel(item),
                                        textDir: this.textDir,
                                        indent: this.showRoot ? 0 : -1
                                }));
                                
                                if(!this.showRoot){
                                        rn.rowNode.style.display="none";
                                        // if root is not visible, move tree role to the invisible
                                        // root node's containerNode, see #12135
                                        this.domNode.setAttribute("role", "presentation");
                                        this.domNode.removeAttribute("aria-expanded");
                                        this.domNode.removeAttribute("aria-multiselectable");
                                        
                                        rn.labelNode.setAttribute("role", "presentation");
                                        rn.containerNode.setAttribute("role", "tree");
                                        rn.containerNode.setAttribute("aria-expanded","true");
                                        rn.containerNode.setAttribute("aria-multiselectable", !this.dndController.singular);
                                }else{
                                  this.domNode.setAttribute("aria-multiselectable", !this.dndController.singular);
                                }
                                
                                this.domNode.appendChild(rn.domNode);
                                var identity = this.model.getIdentity(item);
                                if(this._itemNodesMap[identity]){
                                        this._itemNodesMap[identity].push(rn);
                                }else{
                                        this._itemNodesMap[identity] = [rn];
                                }

                                rn._updateLayout();             // sets "dijitTreeIsRoot" CSS classname

                                // Load top level children, and if persist==true, all nodes that were previously opened
                                this._expandNode(rn).then(lang.hitch(this, function(){
                                        // Then, select the nodes that were selected last time, or
                                        // the ones specified by params.paths[].

                                        this.expandChildrenDeferred.resolve(true);
                                }));
                        }),
                        lang.hitch(this, function(err){
                                console.error(this, ": error loading root: ", err);
                        })
                );
        },

        getNodesByItem: function(/*Item or id*/ item){
                // summary:
                //              Returns all tree nodes that refer to an item
                // returns:
                //              Array of tree nodes that refer to passed item

                if(!item){ return []; }
                var identity = lang.isString(item) ? item : this.model.getIdentity(item);
                // return a copy so widget don't get messed up by changes to returned array
                return [].concat(this._itemNodesMap[identity]);
        },

        _setSelectedItemAttr: function(/*Item or id*/ item){
                this.set('selectedItems', [item]);
        },

        _setSelectedItemsAttr: function(/*Items or ids*/ items){
                // summary:
                //              Select tree nodes related to passed items.
                //              WARNING: if model use multi-parented items or desired tree node isn't already loaded
                //              behavior is undefined. Use set('paths', ...) instead.
                var tree = this;
                return this.pendingCommandsDeferred = this.pendingCommandsDeferred.then( lang.hitch(this, function(){
                        var identities = array.map(items, function(item){
                                return (!item || lang.isString(item)) ? item : tree.model.getIdentity(item);
                        });
                        var nodes = [];
                        array.forEach(identities, function(id){
                                nodes = nodes.concat(tree._itemNodesMap[id] || []);
                        });
                        this.set('selectedNodes', nodes);
                }));
        },

        _setPathAttr: function(/*Item[]|String[]*/ path){
                // summary:
                //              Singular variant of _setPathsAttr
                if(path.length){
                        return this.set("paths", [path]);
                }else{
                        // Empty list is interpreted as "select nothing"
                        return this.set("paths", []);
                }
        },

        _setPathsAttr: function(/*Item[][]|String[][]*/ paths){
                // summary:
                //              Select the tree nodes identified by passed paths.
                // paths:
                //              Array of arrays of items or item id's
                // returns:
                //              Deferred to indicate when the set is complete

                var tree = this;

                // Let any previous set("path", ...) commands complete before this one starts.
                return this.pendingCommandsDeferred = this.pendingCommandsDeferred.then(function(){
                        // We may need to wait for some nodes to expand, so setting
                        // each path will involve a Deferred. We bring those deferreds
                        // together with a DeferredList.
                        return new DeferredList(array.map(paths, function(path){
                                var d = new Deferred();

                                // normalize path to use identity
                                path = array.map(path, function(item){
                                        return lang.isString(item) ? item : tree.model.getIdentity(item);
                                });

                                if(path.length){
                                        // Wait for the tree to load, if it hasn't already.
                                        selectPath(path, [tree.rootNode], d);
                                }else{
                                        d.reject(new Tree.PathError("Empty path"));
                                }
                                return d;
                        }));
                }).then(setNodes);

                function selectPath(path, nodes, def){
                        // Traverse path; the next path component should be among "nodes".
                        var nextPath = path.shift();
                        var nextNode = array.filter(nodes, function(node){
                                return node.getIdentity() == nextPath;
                        })[0];
                        if(!!nextNode){
                                if(path.length){
                                        tree._expandNode(nextNode).then(function(){ selectPath(path, nextNode.getChildren(), def); });
                                }else{
                                        // Successfully reached the end of this path
                                        def.resolve(nextNode);
                                }
                        }else{
                                def.reject(new Tree.PathError("Could not expand path at " + nextPath));
                        }
                }

                function setNodes(newNodes){
                        // After all expansion is finished, set the selection to
                        // the set of nodes successfully found.
                        tree.set("selectedNodes", array.map(
                                array.filter(newNodes,function(x){return x[0];}),
                                function(x){return x[1];}));
                }
        },

        _setSelectedNodeAttr: function(node){
                this.set('selectedNodes', [node]);
        },
        _setSelectedNodesAttr: function(nodes){
                // summary:
                //              Marks the specified TreeNodes as selected.
                // nodes: TreeNode[]
                //              TreeNodes to mark.
                this.dndController.setSelection(nodes);
        },


        expandAll: function(){
                // summary:
                //              Expand all nodes in the tree
                // returns:
                //              Deferred that fires when all nodes have expanded

                var _this = this;

                function expand(node){
                        var def = new dojo.Deferred();

                        // Expand the node
                        _this._expandNode(node).then(function(){
                                // When node has expanded, call expand() recursively on each non-leaf child
                                var childBranches = array.filter(node.getChildren() || [], function(node){
                                                return node.isExpandable;
                                        }),
                                        defs = array.map(childBranches, expand);

                                // And when all those recursive calls finish, signal that I'm finished
                                new dojo.DeferredList(defs).then(function(){
                                        def.resolve(true);
                                });
                        });

                        return def;
                }

                return expand(this.rootNode);
        },

        collapseAll: function(){
                // summary:
                //              Collapse all nodes in the tree
                // returns:
                //              Deferred that fires when all nodes have collapsed

                var _this = this;

                function collapse(node){
                        var def = new dojo.Deferred();
                        def.label = "collapseAllDeferred";

                        // Collapse children first
                        var childBranches = array.filter(node.getChildren() || [], function(node){
                                        return node.isExpandable;
                                }),
                                defs = array.map(childBranches, collapse);

                        // And when all those recursive calls finish, collapse myself, unless I'm the invisible root node,
                        // in which case collapseAll() is finished
                        new dojo.DeferredList(defs).then(function(){
                                if(!node.isExpanded || (node == _this.rootNode && !_this.showRoot)){
                                        def.resolve(true);
                                }else{
                                        _this._collapseNode(node).then(function(){
                                                // When node has collapsed, signal that call is finished
                                                def.resolve(true);
                                        });
                                }
                        });


                        return def;
                }

                return collapse(this.rootNode);
        },

        ////////////// Data store related functions //////////////////////
        // These just get passed to the model; they are here for back-compat

        mayHaveChildren: function(/*dojo/data/Item*/ /*===== item =====*/){
                // summary:
                //              Deprecated.   This should be specified on the model itself.
                //
                //              Overridable function to tell if an item has or may have children.
                //              Controls whether or not +/- expando icon is shown.
                //              (For efficiency reasons we may not want to check if an element actually
                //              has children until user clicks the expando node)
                // tags:
                //              deprecated
        },

        getItemChildren: function(/*===== parentItem, onComplete =====*/){
                // summary:
                //              Deprecated.   This should be specified on the model itself.
                //
                //              Overridable function that return array of child items of given parent item,
                //              or if parentItem==null then return top items in tree
                // tags:
                //              deprecated
        },

        ///////////////////////////////////////////////////////
        // Functions for converting an item to a TreeNode
        getLabel: function(/*dojo/data/Item*/ item){
                // summary:
                //              Overridable function to get the label for a tree node (given the item)
                // tags:
                //              extension
                return this.model.getLabel(item);       // String
        },

        getIconClass: function(/*dojo/data/Item*/ item, /*Boolean*/ opened){
                // summary:
                //              Overridable function to return CSS class name to display icon
                // tags:
                //              extension
                return (!item || this.model.mayHaveChildren(item)) ? (opened ? "dijitFolderOpened" : "dijitFolderClosed") : "dijitLeaf"
        },

        getLabelClass: function(/*===== item, opened =====*/){
                // summary:
                //              Overridable function to return CSS class name to display label
                // item: dojo/data/Item
                // opened: Boolean
                // returns: String
                //              CSS class name
                // tags:
                //              extension
        },

        getRowClass: function(/*===== item, opened =====*/){
                // summary:
                //              Overridable function to return CSS class name to display row
                // item: dojo/data/Item
                // opened: Boolean
                // returns: String
                //              CSS class name
                // tags:
                //              extension
        },

        getIconStyle: function(/*===== item, opened =====*/){
                // summary:
                //              Overridable function to return CSS styles to display icon
                // item: dojo/data/Item
                // opened: Boolean
                // returns: Object
                //              Object suitable for input to dojo.style() like {backgroundImage: "url(...)"}
                // tags:
                //              extension
        },

        getLabelStyle: function(/*===== item, opened =====*/){
                // summary:
                //              Overridable function to return CSS styles to display label
                // item: dojo/data/Item
                // opened: Boolean
                // returns:
                //              Object suitable for input to dojo.style() like {color: "red", background: "green"}
                // tags:
                //              extension
        },

        getRowStyle: function(/*===== item, opened =====*/){
                // summary:
                //              Overridable function to return CSS styles to display row
                // item: dojo/data/Item
                // opened: Boolean
                // returns:
                //              Object suitable for input to dojo.style() like {background-color: "#bbb"}
                // tags:
                //              extension
        },

        getTooltip: function(/*dojo/data/Item*/ /*===== item =====*/){
                // summary:
                //              Overridable function to get the tooltip for a tree node (given the item)
                // tags:
                //              extension
                return "";      // String
        },

        /////////// Keyboard and Mouse handlers ////////////////////

        _onKeyPress: function(/*TreeNode*/ treeNode, /*Event*/ e){
                // summary:
                //              Handles keystrokes for printable keys, doing search navigation

                if(e.charCode <= 32){
                        // Avoid duplicate events on firefox (this is an arrow key that will be handled by keydown handler)
                        return;
                }

                if(!e.altKey && !e.ctrlKey && !e.shiftKey && !e.metaKey){
                        var c = String.fromCharCode(e.charCode);
                        this._onLetterKeyNav( { node: treeNode, key: c.toLowerCase() } );
                        event.stop(e);
                }
        },

        _onKeyDown: function(/*TreeNode*/ treeNode, /*Event*/ e){
                // summary:
                //              Handles arrow, space, and enter keys

                var key = e.keyCode;

                var map = this._keyHandlerMap;
                if(!map){
                        // Setup table mapping keys to events.
                        // On WebKit based browsers, the combination ctrl-enter does not get passed through. To allow accessible
                        // multi-select on those browsers, the space key is also used for selection.
                        // Therefore, also allow space key for keyboard "click" operation.
                        map = {};
                        map[keys.ENTER] = map[keys.SPACE] = map[" "] = "_onEnterKey";
                        map[this.isLeftToRight() ? keys.LEFT_ARROW : keys.RIGHT_ARROW] = "_onLeftArrow";
                        map[this.isLeftToRight() ? keys.RIGHT_ARROW : keys.LEFT_ARROW] = "_onRightArrow";
                        map[keys.UP_ARROW] = "_onUpArrow";
                        map[keys.DOWN_ARROW] = "_onDownArrow";
                        map[keys.HOME] = "_onHomeKey";
                        map[keys.END] = "_onEndKey";
                        this._keyHandlerMap = map;
                }

                if(this._keyHandlerMap[key]){
                        // clear record of recent printables (being saved for multi-char letter navigation),
                        // because "a", down-arrow, "b" shouldn't search for "ab"
                        if(this._curSearch){
                                this._curSearch.timer.remove();
                                delete this._curSearch;
                        }

                        this[this._keyHandlerMap[key]]( { node: treeNode, item: treeNode.item, evt: e } );
                        event.stop(e);
                }
        },

        _onEnterKey: function(/*Object*/ message){
                this._publish("execute", { item: message.item, node: message.node } );
                this.dndController.userSelect(message.node, connect.isCopyKey( message.evt ), message.evt.shiftKey);
                this.onClick(message.item, message.node, message.evt);
        },

        _onDownArrow: function(/*Object*/ message){
                // summary:
                //              down arrow pressed; get next visible node, set focus there
                var node = this._getNextNode(message.node);
                if(node && node.isTreeNode){
                        this.focusNode(node);
                }
        },

        _onUpArrow: function(/*Object*/ message){
                // summary:
                //              Up arrow pressed; move to previous visible node

                var node = message.node;

                // if younger siblings
                var previousSibling = node.getPreviousSibling();
                if(previousSibling){
                        node = previousSibling;
                        // if the previous node is expanded, dive in deep
                        while(node.isExpandable && node.isExpanded && node.hasChildren()){
                                // move to the last child
                                var children = node.getChildren();
                                node = children[children.length-1];
                        }
                }else{
                        // if this is the first child, return the parent
                        // unless the parent is the root of a tree with a hidden root
                        var parent = node.getParent();
                        if(!(!this.showRoot && parent === this.rootNode)){
                                node = parent;
                        }
                }

                if(node && node.isTreeNode){
                        this.focusNode(node);
                }
        },

        _onRightArrow: function(/*Object*/ message){
                // summary:
                //              Right arrow pressed; go to child node
                var node = message.node;

                // if not expanded, expand, else move to 1st child
                if(node.isExpandable && !node.isExpanded){
                        this._expandNode(node);
                }else if(node.hasChildren()){
                        node = node.getChildren()[0];
                        if(node && node.isTreeNode){
                                this.focusNode(node);
                        }
                }
        },

        _onLeftArrow: function(/*Object*/ message){
                // summary:
                //              Left arrow pressed.
                //              If not collapsed, collapse, else move to parent.

                var node = message.node;

                if(node.isExpandable && node.isExpanded){
                        this._collapseNode(node);
                }else{
                        var parent = node.getParent();
                        if(parent && parent.isTreeNode && !(!this.showRoot && parent === this.rootNode)){
                                this.focusNode(parent);
                        }
                }
        },

        _onHomeKey: function(){
                // summary:
                //              Home key pressed; get first visible node, and set focus there
                var node = this._getRootOrFirstNode();
                if(node){
                        this.focusNode(node);
                }
        },

        _onEndKey: function(){
                // summary:
                //              End key pressed; go to last visible node.

                var node = this.rootNode;
                while(node.isExpanded){
                        var c = node.getChildren();
                        node = c[c.length - 1];
                }

                if(node && node.isTreeNode){
                        this.focusNode(node);
                }
        },

        // multiCharSearchDuration: Number
        //              If multiple characters are typed where each keystroke happens within
        //              multiCharSearchDuration of the previous keystroke,
        //              search for nodes matching all the keystrokes.
        //
        //              For example, typing "ab" will search for entries starting with
        //              "ab" unless the delay between "a" and "b" is greater than multiCharSearchDuration.
        multiCharSearchDuration: 250,

        _onLetterKeyNav: function(message){
                // summary:
                //              Called when user presses a prinatable key; search for node starting with recently typed letters.
                // message: Object
                //              Like { node: TreeNode, key: 'a' } where key is the key the user pressed.

                // Branch depending on whether this key starts a new search, or modifies an existing search
                var cs = this._curSearch;
                if(cs){
                        // We are continuing a search.  Ex: user has pressed 'a', and now has pressed
                        // 'b', so we want to search for nodes starting w/"ab".
                        cs.pattern = cs.pattern + message.key;
                        cs.timer.remove();
                }else{
                        // We are starting a new search
                        cs = this._curSearch = {
                                        pattern: message.key,
                                        startNode: message.node
                        };
                }

                // set/reset timer to forget recent keystrokes
                cs.timer = this.defer(function(){
                        delete this._curSearch;
                }, this.multiCharSearchDuration);

                // Navigate to TreeNode matching keystrokes [entered so far].
                var node = cs.startNode;
                do{
                        node = this._getNextNode(node);
                        //check for last node, jump to first node if necessary
                        if(!node){
                                node = this._getRootOrFirstNode();
                        }
                }while(node !== cs.startNode && (node.label.toLowerCase().substr(0, cs.pattern.length) != cs.pattern));
                if(node && node.isTreeNode){
                        // no need to set focus if back where we started
                        if(node !== cs.startNode){
                                this.focusNode(node);
                        }
                }
        },

        isExpandoNode: function(node, widget){
                // summary:
                //              check whether a dom node is the expandoNode for a particular TreeNode widget
                return dom.isDescendant(node, widget.expandoNode) || dom.isDescendant(node, widget.expandoNodeText);
        },

        _onClick: function(/*TreeNode*/ nodeWidget, /*Event*/ e){
                // summary:
                //              Translates click events into commands for the controller to process

                var domElement = e.target,
                        isExpandoClick = this.isExpandoNode(domElement, nodeWidget);

                if( (this.openOnClick && nodeWidget.isExpandable) || isExpandoClick ){
                        // expando node was clicked, or label of a folder node was clicked; open it
                        if(nodeWidget.isExpandable){
                                this._onExpandoClick({node:nodeWidget});
                        }
                }else{
                        this._publish("execute", { item: nodeWidget.item, node: nodeWidget, evt: e } );
                        this.onClick(nodeWidget.item, nodeWidget, e);
                        this.focusNode(nodeWidget);
                }
                event.stop(e);
        },
        _onDblClick: function(/*TreeNode*/ nodeWidget, /*Event*/ e){
                // summary:
                //              Translates double-click events into commands for the controller to process

                var domElement = e.target,
                        isExpandoClick = (domElement == nodeWidget.expandoNode || domElement == nodeWidget.expandoNodeText);

                if( (this.openOnDblClick && nodeWidget.isExpandable) ||isExpandoClick ){
                        // expando node was clicked, or label of a folder node was clicked; open it
                        if(nodeWidget.isExpandable){
                                this._onExpandoClick({node:nodeWidget});
                        }
                }else{
                        this._publish("execute", { item: nodeWidget.item, node: nodeWidget, evt: e } );
                        this.onDblClick(nodeWidget.item, nodeWidget, e);
                        this.focusNode(nodeWidget);
                }
                event.stop(e);
        },

        _onExpandoClick: function(/*Object*/ message){
                // summary:
                //              User clicked the +/- icon; expand or collapse my children.
                var node = message.node;

                // If we are collapsing, we might be hiding the currently focused node.
                // Also, clicking the expando node might have erased focus from the current node.
                // For simplicity's sake just focus on the node with the expando.
                this.focusNode(node);

                if(node.isExpanded){
                        this._collapseNode(node);
                }else{
                        this._expandNode(node);
                }
        },

        onClick: function(/*===== item, node, evt =====*/){
                // summary:
                //              Callback when a tree node is clicked
                // item: Object
                //              Object from the dojo/store corresponding to this TreeNode
                // node: TreeNode
                //              The TreeNode itself
                // evt: Event
                //              The event
                // tags:
                //              callback
        },
        onDblClick: function(/*===== item, node, evt =====*/){
                // summary:
                //              Callback when a tree node is double-clicked
                // item: Object
                //              Object from the dojo/store corresponding to this TreeNode
                // node: TreeNode
                //              The TreeNode itself
                // evt: Event
                //              The event
                // tags:
                //              callback
        },
        onOpen: function(/*===== item, node =====*/){
                // summary:
                //              Callback when a node is opened
                // item: dojo/data/Item
                // node: TreeNode
                // tags:
                //              callback
        },
        onClose: function(/*===== item, node =====*/){
                // summary:
                //              Callback when a node is closed
                // item: Object
                //              Object from the dojo/store corresponding to this TreeNode
                // node: TreeNode
                //              The TreeNode itself
                // tags:
                //              callback
        },

        _getNextNode: function(node){
                // summary:
                //              Get next visible node

                if(node.isExpandable && node.isExpanded && node.hasChildren()){
                        // if this is an expanded node, get the first child
                        return node.getChildren()[0];           // TreeNode
                }else{
                        // find a parent node with a sibling
                        while(node && node.isTreeNode){
                                var returnNode = node.getNextSibling();
                                if(returnNode){
                                        return returnNode;              // TreeNode
                                }
                                node = node.getParent();
                        }
                        return null;
                }
        },

        _getRootOrFirstNode: function(){
                // summary:
                //              Get first visible node
                return this.showRoot ? this.rootNode : this.rootNode.getChildren()[0];
        },

        _collapseNode: function(/*TreeNode*/ node){
                // summary:
                //              Called when the user has requested to collapse the node
                // returns:
                //              Deferred that fires when the node is closed

                if(node._expandNodeDeferred){
                        delete node._expandNodeDeferred;
                }

                if(node.state == "LOADING"){
                        // ignore clicks while we are in the process of loading data
                        return;
                }

                if(node.isExpanded){
                        var ret = node.collapse();

                        this.onClose(node.item, node);
                        this._state(node, false);

                        this._startPaint(ret);  // after this finishes, need to reset widths of TreeNodes

                        return ret;
                }
        },

        _expandNode: function(/*TreeNode*/ node){
                // summary:
                //              Called when the user has requested to expand the node
                // returns:
                //              Deferred that fires when the node is loaded and opened and (if persist=true) all it's descendants
                //              that were previously opened too

                // Signal that this call is complete
                var def = new Deferred();

                if(node._expandNodeDeferred){
                        // there's already an expand in progress, or completed, so just return
                        return node._expandNodeDeferred;        // dojo/_base/Deferred
                }

                var model = this.model,
                        item = node.item,
                        _this = this;

                // Load data if it's not already loaded
                if(!node._loadDeferred){
                        // need to load all the children before expanding
                        node.markProcessing();

                        // Setup deferred to signal when the load and expand are finished.
                        // Save that deferred in this._expandDeferred as a flag that operation is in progress.
                        node._loadDeferred = new Deferred();

                        // Get the children
                        model.getChildren(
                                item,
                                function(items){
                                        node.unmarkProcessing();

                                        // Display the children and also start expanding any children that were previously expanded
                                        // (if this.persist == true).   The returned Deferred will fire when those expansions finish.
                                        node.setChildItems(items).then(function(){
                                                node._loadDeferred.resolve(items);
                                        });
                                },
                                function(err){
                                        console.error(_this, ": error loading " + node.label + " children: ", err);
                                        node._loadDeferred.reject(err);
                                }
                        );
                }

                // Expand the node after data has loaded
                node._loadDeferred.then(lang.hitch(this, function(){
                        node.expand().then(function(){
                                def.resolve(true);      // signal that this _expandNode() call is complete
                        });

                        // seems like these should be inside of then(), but left here for back-compat about
                        // when this.isOpen flag gets set (ie, at the beginning of the animation)
                        this.onOpen(node.item, node);
                        this._state(node, true);
                }));

                this._startPaint(def);  // after this finishes, need to reset widths of TreeNodes

                return def;     // dojo/_base/Deferred
        },

        ////////////////// Miscellaneous functions ////////////////

        focusNode: function(/* _tree.Node */ node){
                // summary:
                //              Focus on the specified node (which must be visible)
                // tags:
                //              protected

                // set focus so that the label will be voiced using screen readers
                focus.focus(node.labelNode);
        },

        _onNodeFocus: function(/*dijit/_WidgetBase*/ node){
                // summary:
                //              Called when a TreeNode gets focus, either by user clicking
                //              it, or programatically by arrow key handling code.
                // description:
                //              It marks that the current node is the selected one, and the previously
                //              selected node no longer is.

                if(node && node != this.lastFocused){
                        if(this.lastFocused && !this.lastFocused._destroyed){
                                // mark that the previously focsable node is no longer focusable
                                this.lastFocused.setFocusable(false);
                        }

                        // mark that the new node is the currently selected one
                        node.setFocusable(true);
                        this.lastFocused = node;
                }
        },

        _onNodeMouseEnter: function(/*dijit/_WidgetBase*/ /*===== node =====*/){
                // summary:
                //              Called when mouse is over a node (onmouseenter event),
                //              this is monitored by the DND code
        },

        _onNodeMouseLeave: function(/*dijit/_WidgetBase*/ /*===== node =====*/){
                // summary:
                //              Called when mouse leaves a node (onmouseleave event),
                //              this is monitored by the DND code
        },

        //////////////// Events from the model //////////////////////////

        _onItemChange: function(/*Item*/ item){
                // summary:
                //              Processes notification of a change to an item's scalar values like label
                var model = this.model,
                        identity = model.getIdentity(item),
                        nodes = this._itemNodesMap[identity];

                if(nodes){
                        var label = this.getLabel(item),
                                tooltip = this.getTooltip(item);
                        array.forEach(nodes, function(node){
                                node.set({
                                        item: item,             // theoretically could be new JS Object representing same item
                                        label: label,
                                        tooltip: tooltip
                                });
                                node._updateItemClasses(item);
                        });
                }
        },

        _onItemChildrenChange: function(/*dojo/data/Item*/ parent, /*dojo/data/Item[]*/ newChildrenList){
                // summary:
                //              Processes notification of a change to an item's children
                var model = this.model,
                        identity = model.getIdentity(parent),
                        parentNodes = this._itemNodesMap[identity];

                if(parentNodes){
                        array.forEach(parentNodes,function(parentNode){
                                parentNode.setChildItems(newChildrenList);
                        });
                }
        },

        _onItemDelete: function(/*Item*/ item){
                // summary:
                //              Processes notification of a deletion of an item.
                //              Not called from new dojo.store interface but there's cleanup code in setChildItems() instead.

                var model = this.model,
                        identity = model.getIdentity(item),
                        nodes = this._itemNodesMap[identity];

                if(nodes){
                        array.forEach(nodes,function(node){
                                // Remove node from set of selected nodes (if it's selected)
                                this.dndController.removeTreeNode(node);

                                var parent = node.getParent();
                                if(parent){
                                        // if node has not already been orphaned from a _onSetItem(parent, "children", ..) call...
                                        parent.removeChild(node);
                                }
                                node.destroyRecursive();
                        }, this);
                        delete this._itemNodesMap[identity];
                }
        },

        /////////////// Miscellaneous funcs

        _initState: function(){
                // summary:
                //              Load in which nodes should be opened automatically
                this._openedNodes = {};
                if(this.persist && this.cookieName){
                        var oreo = cookie(this.cookieName);
                        if(oreo){
                                array.forEach(oreo.split(','), function(item){
                                        this._openedNodes[item] = true;
                                }, this);
                        }
                }
        },
        _state: function(node, expanded){
                // summary:
                //              Query or set expanded state for an node
                if(!this.persist){
                        return false;
                }
                var path = array.map(node.getTreePath(), function(item){
                                return this.model.getIdentity(item);
                        }, this).join("/");
                if(arguments.length === 1){
                        return this._openedNodes[path];
                }else{
                        if(expanded){
                                this._openedNodes[path] = true;
                        }else{
                                delete this._openedNodes[path];
                        }
                        if(this.persist && this.cookieName){
                                var ary = [];
                                for(var id in this._openedNodes){
                                        ary.push(id);
                                }
                                cookie(this.cookieName, ary.join(","), {expires:365});
                        }
                }
        },

        destroy: function(){
                if(this._curSearch){
                        this._curSearch.timer.remove();
                        delete this._curSearch;
                }
                if(this.rootNode){
                        this.rootNode.destroyRecursive();
                }
                if(this.dndController && !lang.isString(this.dndController)){
                        this.dndController.destroy();
                }
                this.rootNode = null;
                this.inherited(arguments);
        },

        destroyRecursive: function(){
                // A tree is treated as a leaf, not as a node with children (like a grid),
                // but defining destroyRecursive for back-compat.
                this.destroy();
        },

        resize: function(changeSize){
                if(changeSize){
                        domGeometry.setMarginBox(this.domNode, changeSize);
                }

                // The main JS sizing involved w/tree is the indentation, which is specified
                // in CSS and read in through this dummy indentDetector node (tree must be
                // visible and attached to the DOM to read this).
                // If the Tree is hidden domGeometry.position(this.tree.indentDetector).w will return 0, in which case just
                // keep the default value.
                this._nodePixelIndent = domGeometry.position(this.tree.indentDetector).w || this._nodePixelIndent;

                // resize() may be called before this.rootNode is created, so wait until it's available
                this.expandChildrenDeferred.then(lang.hitch(this, function(){
                        // If tree has already loaded, then reset indent for all the nodes
                        this.rootNode.set('indent', this.showRoot ? 0 : -1);

                        // Also, adjust widths of all rows to match width of Tree
                        this._adjustWidths();
                }));
        },

        _outstandingPaintOperations: 0,
        _startPaint: function(/*Promise|Boolean*/ p){
                // summary:
                //              Called at the start of an operation that will change what's displayed.
                // p:
                //              Promise that tells when the operation will complete.  Alternately, if it's just a Boolean, it signifies
                //              that the operation was synchronous, and already completed.

                this._outstandingPaintOperations++;
                if(this._adjustWidthsTimer){
                        this._adjustWidthsTimer.remove();
                        delete this._adjustWidthsTimer;
                }

                var oc = lang.hitch(this, function(){
                        this._outstandingPaintOperations--;

                        if(this._outstandingPaintOperations <= 0 && !this._adjustWidthsTimer && this._started){
                                // Use defer() to avoid a width adjustment when another operation will immediately follow,
                                // such as a sequence of opening a node, then it's children, then it's grandchildren, etc.
                                this._adjustWidthsTimer = this.defer("_adjustWidths");
                        }
                });
                when(p, oc, oc);
        },

        _adjustWidths: function(){
                // summary:
                //              Get width of widest TreeNode, or the width of the Tree itself, whichever is greater,
                //              and then set all TreeNodes to that width, so that selection/hover highlighting
                //              extends to the edge of the Tree (#13141)

                if(this._adjustWidthsTimer){
                        this._adjustWidthsTimer.remove();
                        delete this._adjustWidthsTimer;
                }

                var maxWidth = 0,
                        nodes = [];
                function collect(/*TreeNode*/ parent){
                        var node = parent.rowNode;
                        node.style.width = "auto";              // erase setting from previous run
                        maxWidth = Math.max(maxWidth, node.clientWidth);
                        nodes.push(node);
                        if(parent.isExpanded){
                                array.forEach(parent.getChildren(), collect);
                        }
                }
                collect(this.rootNode);
                maxWidth = Math.max(maxWidth, domGeometry.getContentBox(this.domNode).w);       // do after node.style.width="auto"
                array.forEach(nodes, function(node){
                        node.style.width = maxWidth + "px";             // assumes no horizontal padding, border, or margin on rowNode
                });
        },

        _createTreeNode: function(/*Object*/ args){
                // summary:
                //              creates a TreeNode
                // description:
                //              Developers can override this method to define their own TreeNode class;
                //              However it will probably be removed in a future release in favor of a way
                //              of just specifying a widget for the label, rather than one that contains
                //              the children too.
                return new TreeNode(args);
        },

        _setTextDirAttr: function(textDir){
                if(textDir && this.textDir!= textDir){
                        this._set("textDir",textDir);
                        this.rootNode.set("textDir", textDir);
                }
        }
});

Tree.PathError = createError("TreePathError");
Tree._TreeNode = TreeNode;      // for monkey patching or creating subclasses of TreeNode

return Tree;
});

},
'dijit/form/_FormValueWidget':function(){
define("dijit/form/_FormValueWidget", [
        "dojo/_base/declare", // declare
        "dojo/sniff", // has("ie")
        "./_FormWidget",
        "./_FormValueMixin"
], function(declare, has, _FormWidget, _FormValueMixin){

// module:
//              dijit/form/_FormValueWidget

return declare("dijit.form._FormValueWidget", [_FormWidget, _FormValueMixin],
{
        // summary:
        //              Base class for widgets corresponding to native HTML elements such as `<input>` or `<select>`
        //              that have user changeable values.
        // description:
        //              Each _FormValueWidget represents a single input value, and has a (possibly hidden) `<input>` element,
        //              to which it serializes it's input value, so that form submission (either normal submission or via FormBind?)
        //              works as expected.

        // Don't attempt to mixin the 'type', 'name' attributes here programatically -- they must be declared
        // directly in the template as read by the parser in order to function. IE is known to specifically
        // require the 'name' attribute at element creation time.  See #8484, #8660.

        _layoutHackIE7: function(){
                // summary:
                //              Work around table sizing bugs on IE7 by forcing redraw

                if(has("ie") == 7){ // fix IE7 layout bug when the widget is scrolled out of sight
                        var domNode = this.domNode;
                        var parent = domNode.parentNode;
                        var pingNode = domNode.firstChild || domNode; // target node most unlikely to have a custom filter
                        var origFilter = pingNode.style.filter; // save custom filter, most likely nothing
                        var _this = this;
                        while(parent && parent.clientHeight == 0){ // search for parents that haven't rendered yet
                                (function ping(){
                                        var disconnectHandle = _this.connect(parent, "onscroll",
                                                function(){
                                                        _this.disconnect(disconnectHandle); // only call once
                                                        pingNode.style.filter = (new Date()).getMilliseconds(); // set to anything that's unique
                                                        _this.defer(function(){ pingNode.style.filter = origFilter; }); // restore custom filter, if any
                                                }
                                        );
                                })();
                                parent = parent.parentNode;
                        }
                }
        }
});

});

},
'*now':function(r){r(['dojo/i18n!*preload*dojo/nls/tt-rss-layer*["ar","ca","cs","da","de","el","en-gb","en-us","es-es","fi-fi","fr-fr","he-il","hu","it-it","ja-jp","ko-kr","nl-nl","nb","pl","pt-br","pt-pt","ru","sk","sl","sv","th","tr","zh-tw","zh-cn","ROOT"]']);}
}});
define("dojo/tt-rss-layer", [], 1);