+
+
+
+
+
+
+
+
+
+
+
diff --git a/js/libs/dijit/BackgroundIframe.js b/js/libs/dijit/BackgroundIframe.js
new file mode 100644
index 0000000..b802a7c
--- /dev/null
+++ b/js/libs/dijit/BackgroundIframe.js
@@ -0,0 +1,63 @@
+//>>built
+define("dijit/BackgroundIframe",["require",".","dojo/_base/config","dojo/dom-construct","dojo/dom-style","dojo/_base/lang","dojo/on","dojo/_base/sniff","dojo/_base/window"],function(_1,_2,_3,_4,_5,_6,on,_7,_8){
+var _9=new function(){
+var _a=[];
+this.pop=function(){
+var _b;
+if(_a.length){
+_b=_a.pop();
+_b.style.display="";
+}else{
+if(_7("ie")<9){
+var _c=_3["dojoBlankHtmlUrl"]||_1.toUrl("dojo/resources/blank.html")||"javascript:\"\"";
+var _d="");
+}
+};
+_8.setInitialState=function(_23){
+_e=_1b(_c,_23,_d);
+};
+_8.addToHistory=function(_24){
+_12=[];
+var _25=null;
+var url=null;
+if(!_11){
+if(_1.config["useXDomain"]&&!_1.config["dojoIframeHistoryUrl"]){
+console.warn("dojo.back: When using cross-domain Dojo builds,"+" please save iframe_history.html to your domain and set djConfig.dojoIframeHistoryUrl"+" to the path on your domain to iframe_history.html");
+}
+_11=window.frames["dj_history"];
+}
+if(!_10){
+_10=_5.create("a",{style:{display:"none"}},_6.body());
+}
+if(_24["changeUrl"]){
+_25=""+((_24["changeUrl"]!==true)?_24["changeUrl"]:(new Date()).getTime());
+if(_13.length==0&&_e.urlHash==_25){
+_e=_1b(url,_24,_25);
+return;
+}else{
+if(_13.length>0&&_13[_13.length-1].urlHash==_25){
+_13[_13.length-1]=_1b(url,_24,_25);
+return;
+}
+}
+_15=true;
+setTimeout(function(){
+_a(_25);
+_15=false;
+},1);
+_10.href=_25;
+if(_3("ie")){
+url=_20();
+var _26=_24["back"]||_24["backButton"]||_24["handle"];
+var tcb=function(_27){
+if(_9()!=""){
+setTimeout(function(){
+_a(_25);
+},1);
+}
+_26.apply(this,[_27]);
+};
+if(_24["back"]){
+_24.back=tcb;
+}else{
+if(_24["backButton"]){
+_24.backButton=tcb;
+}else{
+if(_24["handle"]){
+_24.handle=tcb;
+}
+}
+}
+var _28=_24["forward"]||_24["forwardButton"]||_24["handle"];
+var tfw=function(_29){
+if(_9()!=""){
+_a(_25);
+}
+if(_28){
+_28.apply(this,[_29]);
+}
+};
+if(_24["forward"]){
+_24.forward=tfw;
+}else{
+if(_24["forwardButton"]){
+_24.forwardButton=tfw;
+}else{
+if(_24["handle"]){
+_24.handle=tfw;
+}
+}
+}
+}else{
+if(!_3("ie")){
+if(!_f){
+_f=setInterval(_21,200);
+}
+}
+}
+}else{
+url=_20();
+}
+_13.push(_1b(url,_24,_25));
+};
+_8._iframeLoaded=function(evt,_2a){
+var _2b=_1e(_2a.href);
+if(_2b==null){
+if(_13.length==1){
+_16();
+}
+return;
+}
+if(_14){
+_14=false;
+return;
+}
+if(_13.length>=2&&_2b==_1e(_13[_13.length-2].url)){
+_16();
+}else{
+if(_12.length>0&&_2b==_1e(_12[_12.length-1].url)){
+_19();
+}
+}
+};
+return _1.back;
+});
diff --git a/js/libs/dojo/back.js.uncompressed.js b/js/libs/dojo/back.js.uncompressed.js
new file mode 100644
index 0000000..09ded6e
--- /dev/null
+++ b/js/libs/dojo/back.js.uncompressed.js
@@ -0,0 +1,398 @@
+//>>built
+define("dojo/back", ["./_base/kernel", "./_base/lang", "./_base/sniff", "./dom", "./dom-construct", "./_base/window", "require"], function(dojo, lang, sniff, dom, domConstruct, baseWindow, require) {
+ // module:
+ // dojo/back
+ // summary:
+ // TODOC
+
+ lang.getObject("back", true, dojo);
+
+/*=====
+dojo.back = {
+ // summary: Browser history management resources
+};
+=====*/
+
+ var back = dojo.back,
+
+ // everyone deals with encoding the hash slightly differently
+
+ getHash = back.getHash = function(){
+ var h = window.location.hash;
+ if(h.charAt(0) == "#"){ h = h.substring(1); }
+ return sniff("mozilla") ? h : decodeURIComponent(h);
+ },
+
+ setHash = back.setHash = function(h){
+ if(!h){ h = ""; }
+ window.location.hash = encodeURIComponent(h);
+ historyCounter = history.length;
+ };
+
+ var initialHref = (typeof(window) !== "undefined") ? window.location.href : "";
+ var initialHash = (typeof(window) !== "undefined") ? getHash() : "";
+ var initialState = null;
+
+ var locationTimer = null;
+ var bookmarkAnchor = null;
+ var historyIframe = null;
+ var forwardStack = [];
+ var historyStack = [];
+ var moveForward = false;
+ var changingUrl = false;
+ var historyCounter;
+
+ function handleBackButton(){
+ //summary: private method. Do not call this directly.
+
+ //The "current" page is always at the top of the history stack.
+ var current = historyStack.pop();
+ if(!current){ return; }
+ var last = historyStack[historyStack.length-1];
+ if(!last && historyStack.length == 0){
+ last = initialState;
+ }
+ if(last){
+ if(last.kwArgs["back"]){
+ last.kwArgs["back"]();
+ }else if(last.kwArgs["backButton"]){
+ last.kwArgs["backButton"]();
+ }else if(last.kwArgs["handle"]){
+ last.kwArgs.handle("back");
+ }
+ }
+ forwardStack.push(current);
+ }
+
+ back.goBack = handleBackButton;
+
+ function handleForwardButton(){
+ //summary: private method. Do not call this directly.
+ var last = forwardStack.pop();
+ if(!last){ return; }
+ if(last.kwArgs["forward"]){
+ last.kwArgs.forward();
+ }else if(last.kwArgs["forwardButton"]){
+ last.kwArgs.forwardButton();
+ }else if(last.kwArgs["handle"]){
+ last.kwArgs.handle("forward");
+ }
+ historyStack.push(last);
+ }
+
+ back.goForward = handleForwardButton;
+
+ function createState(url, args, hash){
+ //summary: private method. Do not call this directly.
+ return {"url": url, "kwArgs": args, "urlHash": hash}; //Object
+ }
+
+ function getUrlQuery(url){
+ //summary: private method. Do not call this directly.
+ var segments = url.split("?");
+ if(segments.length < 2){
+ return null; //null
+ }
+ else{
+ return segments[1]; //String
+ }
+ }
+
+ function loadIframeHistory(){
+ //summary: private method. Do not call this directly.
+ var url = (dojo.config["dojoIframeHistoryUrl"] || require.toUrl("./resources/iframe_history.html")) + "?" + (new Date()).getTime();
+ moveForward = true;
+ if(historyIframe){
+ sniff("webkit") ? historyIframe.location = url : window.frames[historyIframe.name].location = url;
+ }else{
+ //console.warn("dojo.back: Not initialised. You need to call dojo.back.init() from a
+ //
+ return new dojo.NodeList(); // dojo.NodeList
+};
+=====*/
+
+function queryForEngine(engine, NodeList){
+ var query = function(/*String*/ query, /*String|DOMNode?*/ root){
+ // summary:
+ // Returns nodes which match the given CSS selector, searching the
+ // entire document by default but optionally taking a node to scope
+ // the search by. Returns an instance of dojo.NodeList.
+ if(typeof root == "string"){
+ root = dom.byId(root);
+ if(!root){
+ return new NodeList([]);
+ }
+ }
+ var results = typeof query == "string" ? engine(query, root) : query.orphan ? query : [query];
+ if(results.orphan){
+ // already wrapped
+ return results;
+ }
+ return new NodeList(results);
+ };
+ query.matches = engine.match || function(node, selector, root){
+ // summary:
+ // Test to see if a node matches a selector
+ return query.filter([node], selector, root).length > 0;
+ };
+ // the engine provides a filtering function, use it to for matching
+ query.filter = engine.filter || function(nodes, selector, root){
+ // summary:
+ // Filters an array of nodes. Note that this does not guarantee to return a dojo.NodeList, just an array.
+ return query(selector, root).filter(function(node){
+ return array.indexOf(nodes, node) > -1;
+ });
+ };
+ if(typeof engine != "function"){
+ var search = engine.search;
+ engine = function(selector, root){
+ // Slick does it backwards (or everyone else does it backwards, probably the latter)
+ return search(root || document, selector);
+ };
+ }
+ return query;
+}
+var query = queryForEngine(defaultEngine, NodeList);
+// the query that is returned from this module is slightly different than dojo.query,
+// because dojo.query has to maintain backwards compatibility with returning a
+// true array which has performance problems. The query returned from the module
+// does not use true arrays, but rather inherits from Array, making it much faster to
+// instantiate.
+dojo.query = queryForEngine(defaultEngine, function(array){
+ // call it without the new operator to invoke the back-compat behavior that returns a true array
+ return NodeList(array);
+});
+
+query.load = /*===== dojo.query.load= ======*/ function(id, parentRequire, loaded, config){
+ // summary: can be used as AMD plugin to conditionally load new query engine
+ // example:
+ // | define(["dojo/query!custom"], function(qsa){
+ // | // loaded selector/custom.js as engine
+ // | qsa("#foobar").forEach(...);
+ // | });
+ loader.load(id, parentRequire, function(engine){
+ loaded(queryForEngine(engine, NodeList));
+ });
+};
+
+dojo._filterQueryResult = query._filterResult = function(nodes, selector, root){
+ return new NodeList(query.filter(nodes, selector, root));
+};
+dojo.NodeList = query.NodeList = NodeList;
+return query;
+});
+
+},
+'dojo/has':function(){
+define(["require"], function(require) {
+ // module:
+ // dojo/has
+ // summary:
+ // Defines the has.js API and several feature tests used by dojo.
+ // description:
+ // This module defines the has API as described by the project has.js with the following additional features:
+ //
+ // * the has test cache is exposed at has.cache.
+ // * the method has.add includes a forth parameter that controls whether or not existing tests are replaced
+ // * the loader's has cache may be optionally copied into this module's has cahce.
+ //
+ // This module adopted from https://github.com/phiggins42/has.js; thanks has.js team!
+
+ // try to pull the has implementation from the loader; both the dojo loader and bdLoad provide one
+ // WARNING: if a foreign loader defines require.has to be something other than the has.js API, then this implementation fail
+ var has = require.has || function(){};
+ if(!1){
+ // notice the condition is written so that if 1 is transformed to 1 during a build
+ // the conditional will be (!1 && typeof has=="function") which is statically false and the closure
+ // compiler will discard the block.
+ var
+ isBrowser =
+ // the most fundamental decision: are we in the browser?
+ typeof window != "undefined" &&
+ typeof location != "undefined" &&
+ typeof document != "undefined" &&
+ window.location == location && window.document == document,
+
+ // has API variables
+ global = this,
+ doc = isBrowser && document,
+ element = doc && doc.createElement("DiV"),
+ cache = {};
+
+ has = /*===== dojo.has= =====*/ function(name){
+ // summary:
+ // Return the current value of the named feature.
+ //
+ // name: String|Integer
+ // The name (if a string) or identifier (if an integer) of the feature to test.
+ //
+ // description:
+ // Returns the value of the feature named by name. The feature must have been
+ // previously added to the cache by has.add.
+
+ return typeof cache[name] == "function" ? (cache[name] = cache[name](global, doc, element)) : cache[name]; // Boolean
+ };
+
+ has.cache = cache;
+
+ has.add = /*====== dojo.has.add= ======*/ function(name, test, now, force){
+ // summary:
+ // Register a new feature test for some named feature.
+ //
+ // name: String|Integer
+ // The name (if a string) or identifier (if an integer) of the feature to test.
+ //
+ // test: Function
+ // A test function to register. If a function, queued for testing until actually
+ // needed. The test function should return a boolean indicating
+ // the presence of a feature or bug.
+ //
+ // now: Boolean?
+ // Optional. Omit if `test` is not a function. Provides a way to immediately
+ // run the test and cache the result.
+ //
+ // force: Boolean?
+ // Optional. If the test already exists and force is truthy, then the existing
+ // test will be replaced; otherwise, add does not replace an existing test (that
+ // is, by default, the first test advice wins).
+ //
+ // example:
+ // A redundant test, testFn with immediate execution:
+ // | has.add("javascript", function(){ return true; }, true);
+ //
+ // example:
+ // Again with the redundantness. You can do this in your tests, but we should
+ // not be doing this in any internal has.js tests
+ // | has.add("javascript", true);
+ //
+ // example:
+ // Three things are passed to the testFunction. `global`, `document`, and a generic element
+ // from which to work your test should the need arise.
+ // | has.add("bug-byid", function(g, d, el){
+ // | // g == global, typically window, yadda yadda
+ // | // d == document object
+ // | // el == the generic element. a `has` element.
+ // | return false; // fake test, byid-when-form-has-name-matching-an-id is slightly longer
+ // | });
+
+ (typeof cache[name]=="undefined" || force) && (cache[name]= test);
+ return now && has(name);
+ };
+
+ // since we're operating under a loader that doesn't provide a has API, we must explicitly initialize
+ // has as it would have otherwise been initialized by the dojo loader; use has.add to the builder
+ // can optimize these away iff desired
+ true || has.add("host-browser", isBrowser);
+ true || has.add("dom", isBrowser);
+ true || has.add("dojo-dom-ready-api", 1);
+ true || has.add("dojo-sniff", 1);
+ }
+
+ if(1){
+ var agent = navigator.userAgent;
+ // Common application level tests
+ has.add("dom-addeventlistener", !!document.addEventListener);
+ has.add("touch", "ontouchstart" in document);
+ // I don't know if any of these tests are really correct, just a rough guess
+ has.add("device-width", screen.availWidth || innerWidth);
+ has.add("agent-ios", !!agent.match(/iPhone|iP[ao]d/));
+ has.add("agent-android", agent.indexOf("android") > 1);
+ }
+
+ has.clearElement = /*===== dojo.has.clearElement= ======*/ function(element) {
+ // summary:
+ // Deletes the contents of the element passed to test functions.
+ element.innerHTML= "";
+ return element;
+ };
+
+ has.normalize = /*===== dojo.has.normalize= ======*/ function(id, toAbsMid){
+ // summary:
+ // Resolves id into a module id based on possibly-nested tenary expression that branches on has feature test value(s).
+ //
+ // toAbsMid: Function
+ // Resolves a relative module id into an absolute module id
+ var
+ tokens = id.match(/[\?:]|[^:\?]*/g), i = 0,
+ get = function(skip){
+ var term = tokens[i++];
+ if(term == ":"){
+ // empty string module name, resolves to 0
+ return 0;
+ }else{
+ // postfixed with a ? means it is a feature to branch on, the term is the name of the feature
+ if(tokens[i++] == "?"){
+ if(!skip && has(term)){
+ // matched the feature, get the first value from the options
+ return get();
+ }else{
+ // did not match, get the second value, passing over the first
+ get(true);
+ return get(skip);
+ }
+ }
+ // a module
+ return term || 0;
+ }
+ };
+ id = get();
+ return id && toAbsMid(id);
+ };
+
+ has.load = /*===== dojo.has.load= ======*/ function(id, parentRequire, loaded){
+ // summary:
+ // Conditional loading of AMD modules based on a has feature test value.
+ //
+ // id: String
+ // Gives the resolved module id to load.
+ //
+ // parentRequire: Function
+ // The loader require function with respect to the module that contained the plugin resource in it's
+ // dependency list.
+ //
+ // loaded: Function
+ // Callback to loader that consumes result of plugin demand.
+
+ if(id){
+ parentRequire([id], loaded);
+ }else{
+ loaded();
+ }
+ };
+
+ return has;
+});
+
+},
+'dojo/_base/loader':function(){
+define(["./kernel", "../has", "require", "module", "./json", "./lang", "./array"], function(dojo, has, require, thisModule, json, lang, array) {
+ // module:
+ // dojo/_base/lader
+ // summary:
+ // This module defines the v1.x synchronous loader API.
+
+ // signal the loader in sync mode...
+ //>>pure-amd
+
+ if (!1){
+ console.error("cannot load the Dojo v1.x loader with a foreign loader");
+ return 0;
+ }
+
+ var makeErrorToken = function(id){
+ return {src:thisModule.id, id:id};
+ },
+
+ slashName = function(name){
+ return name.replace(/\./g, "/");
+ },
+
+ buildDetectRe = /\/\/>>built/,
+
+ dojoRequireCallbacks = [],
+ dojoRequireModuleStack = [],
+
+ dojoRequirePlugin = function(mid, require, loaded){
+ dojoRequireCallbacks.push(loaded);
+ array.forEach(mid.split(","), function(mid){
+ var module = getModule(mid, require.module);
+ dojoRequireModuleStack.push(module);
+ injectModule(module);
+ });
+ checkDojoRequirePlugin();
+ },
+
+ touched,
+
+ traverse = function(m){
+ if(touched[m.mid] || /loadInit\!/.test(m.mid)){
+ // loadInit plugin modules are dependencies of modules in dojoRequireModuleStack...
+ // which would cause a circular dependency chain that would never be resolved if checked here
+ // notice all dependencies of any particular loadInit plugin module will already
+ // be checked since those are pushed into dojoRequireModuleStack explicitly by the
+ // plugin...so if a particular loadInitPlugin module's dependencies are not really
+ // on board, that *will* be detected elsewhere in the traversal.
+ return true;
+ }
+ touched[m.mid] = 1;
+ if(m.injected!==arrived && !m.executed){
+ return false;
+ }
+ for(var deps = m.deps || [], i= 0; i a built module, always AMD
+ // extractResult==0 => no sync API
+ return 0;
+ }
+
+ // manufacture a synthetic module id that can never be a real mdule id (just like require does)
+ id = module.mid + "-*loadInit";
+
+ // construct the dojo/loadInit names vector which causes any relocated names to be defined as lexical variables under their not-relocated name
+ // the dojo/loadInit plugin assumes the first name in names is "dojo"
+
+ for(var p in getModule("dojo", module).result.scopeMap){
+ names.push(p);
+ namesAsStrings.push('"' + p + '"');
+ }
+
+ // rewrite the module as a synthetic dojo/loadInit plugin resource + the module expressed as an AMD module that depends on this synthetic resource
+ return "// xdomain rewrite of " + module.path + "\n" +
+ "define('" + id + "',{\n" +
+ "\tnames:" + dojo.toJson(names) + ",\n" +
+ "\tdef:function(" + names.join(",") + "){" + extractResult[1] + "}" +
+ "});\n\n" +
+ "define(" + dojo.toJson(names.concat(["dojo/loadInit!"+id])) + ", function(" + names.join(",") + "){\n" + extractResult[0] + "});";
+ },
+
+ loaderVars = require.initSyncLoader(dojoRequirePlugin, checkDojoRequirePlugin, transformToAmd),
+
+ sync =
+ loaderVars.sync,
+
+ xd =
+ loaderVars.xd,
+
+ arrived =
+ loaderVars.arrived,
+
+ nonmodule =
+ loaderVars.nonmodule,
+
+ executing =
+ loaderVars.executing,
+
+ executed =
+ loaderVars.executed,
+
+ syncExecStack =
+ loaderVars.syncExecStack,
+
+ modules =
+ loaderVars.modules,
+
+ execQ =
+ loaderVars.execQ,
+
+ getModule =
+ loaderVars.getModule,
+
+ injectModule =
+ loaderVars.injectModule,
+
+ setArrived =
+ loaderVars.setArrived,
+
+ signal =
+ loaderVars.signal,
+
+ finishExec =
+ loaderVars.finishExec,
+
+ execModule =
+ loaderVars.execModule,
+
+ getLegacyMode =
+ loaderVars.getLegacyMode;
+
+ dojo.provide = function(mid){
+ var executingModule = syncExecStack[0],
+ module = lang.mixin(getModule(slashName(mid), require.module), {
+ executed:executing,
+ result:lang.getObject(mid, true)
+ });
+ setArrived(module);
+ if(executingModule){
+ (executingModule.provides || (executingModule.provides = [])).push(function(){
+ module.result = lang.getObject(mid);
+ delete module.provides;
+ module.executed!==executed && finishExec(module);
+ });
+ }// else dojo.provide called not consequent to loading; therefore, give up trying to publish module value to loader namespace
+ return module.result;
+ };
+
+ has.add("config-publishRequireResult", 1, 0, 0);
+
+ dojo.require = function(moduleName, omitModuleCheck) {
+ // summary:
+ // loads a Javascript module from the appropriate URI
+ //
+ // moduleName: String
+ // module name to load, using periods for separators,
+ // e.g. "dojo.date.locale". Module paths are de-referenced by dojo's
+ // internal mapping of locations to names and are disambiguated by
+ // longest prefix. See `dojo.registerModulePath()` for details on
+ // registering new modules.
+ //
+ // omitModuleCheck: Boolean?
+ // if `true`, omitModuleCheck skips the step of ensuring that the
+ // loaded file actually defines the symbol it is referenced by.
+ // For example if it called as `dojo.require("a.b.c")` and the
+ // file located at `a/b/c.js` does not define an object `a.b.c`,
+ // and exception will be throws whereas no exception is raised
+ // when called as `dojo.require("a.b.c", true)`
+ //
+ // description:
+ // Modules are loaded via dojo.require by using one of two loaders: the normal loader
+ // and the xdomain loader. The xdomain loader is used when dojo was built with a
+ // custom build that specified loader=xdomain and the module lives on a modulePath
+ // that is a whole URL, with protocol and a domain. The versions of Dojo that are on
+ // the Google and AOL CDNs use the xdomain loader.
+ //
+ // If the module is loaded via the xdomain loader, it is an asynchronous load, since
+ // the module is added via a dynamically created script tag. This
+ // means that dojo.require() can return before the module has loaded. However, this
+ // should only happen in the case where you do dojo.require calls in the top-level
+ // HTML page, or if you purposely avoid the loader checking for dojo.require
+ // dependencies in your module by using a syntax like dojo["require"] to load the module.
+ //
+ // Sometimes it is useful to not have the loader detect the dojo.require calls in the
+ // module so that you can dynamically load the modules as a result of an action on the
+ // page, instead of right at module load time.
+ //
+ // Also, for script blocks in an HTML page, the loader does not pre-process them, so
+ // it does not know to download the modules before the dojo.require calls occur.
+ //
+ // So, in those two cases, when you want on-the-fly module loading or for script blocks
+ // in the HTML page, special care must be taken if the dojo.required code is loaded
+ // asynchronously. To make sure you can execute code that depends on the dojo.required
+ // modules, be sure to add the code that depends on the modules in a dojo.addOnLoad()
+ // callback. dojo.addOnLoad waits for all outstanding modules to finish loading before
+ // executing.
+ //
+ // This type of syntax works with both xdomain and normal loaders, so it is good
+ // practice to always use this idiom for on-the-fly code loading and in HTML script
+ // blocks. If at some point you change loaders and where the code is loaded from,
+ // it will all still work.
+ //
+ // More on how dojo.require
+ // `dojo.require("A.B")` first checks to see if symbol A.B is
+ // defined. If it is, it is simply returned (nothing to do).
+ //
+ // If it is not defined, it will look for `A/B.js` in the script root
+ // directory.
+ //
+ // `dojo.require` throws an exception if it cannot find a file
+ // to load, or if the symbol `A.B` is not defined after loading.
+ //
+ // It returns the object `A.B`, but note the caveats above about on-the-fly loading and
+ // HTML script blocks when the xdomain loader is loading a module.
+ //
+ // `dojo.require()` does nothing about importing symbols into
+ // the current namespace. It is presumed that the caller will
+ // take care of that.
+ //
+ // example:
+ // To use dojo.require in conjunction with dojo.ready:
+ //
+ // | dojo.require("foo");
+ // | dojo.require("bar");
+ // | dojo.addOnLoad(function(){
+ // | //you can now safely do something with foo and bar
+ // | });
+ //
+ // example:
+ // For example, to import all symbols into a local block, you might write:
+ //
+ // | with (dojo.require("A.B")) {
+ // | ...
+ // | }
+ //
+ // And to import just the leaf symbol to a local variable:
+ //
+ // | var B = dojo.require("A.B");
+ // | ...
+ //
+ // returns:
+ // the required namespace object
+ function doRequire(mid, omitModuleCheck){
+ var module = getModule(slashName(mid), require.module);
+ if(syncExecStack.length && syncExecStack[0].finish){
+ // switched to async loading in the middle of evaluating a legacy module; stop
+ // applying dojo.require so the remaining dojo.requires are applied in order
+ syncExecStack[0].finish.push(mid);
+ return undefined;
+ }
+
+ // recall module.executed has values {0, executing, executed}; therefore, truthy indicates executing or executed
+ if(module.executed){
+ return module.result;
+ }
+ omitModuleCheck && (module.result = nonmodule);
+
+ var currentMode = getLegacyMode();
+
+ // recall, in sync mode to inject is to *eval* the module text
+ // if the module is a legacy module, this is the same as executing
+ // but if the module is an AMD module, this means defining, not executing
+ injectModule(module);
+ // the inject may have changed the mode
+ currentMode = getLegacyMode();
+
+ // in sync mode to dojo.require is to execute
+ if(module.executed!==executed && module.injected===arrived){
+ // the module was already here before injectModule was called probably finishing up a xdomain
+ // load, but maybe a module given to the loader directly rather than having the loader retrieve it
+ loaderVars.holdIdle();
+ execModule(module);
+ loaderVars.releaseIdle();
+ }
+ if(module.executed){
+ return module.result;
+ }
+
+ if(currentMode==sync){
+ // the only way to get here is in sync mode and dojo.required a module that
+ // * was loaded async in the injectModule application a few lines up
+ // * was an AMD module that had deps that are being loaded async and therefore couldn't execute
+ if(module.cjs){
+ // the module was an AMD module; unshift, not push, which causes the current traversal to be reattempted from the top
+ execQ.unshift(module);
+ }else{
+ // the module was a legacy module
+ syncExecStack.length && (syncExecStack[0].finish= [mid]);
+ }
+ }else{
+ // the loader wasn't in sync mode on entry; probably async mode; therefore, no expectation of getting
+ // the module value synchronously; make sure it gets executed though
+ execQ.push(module);
+ }
+ return undefined;
+ }
+
+ var result = doRequire(moduleName, omitModuleCheck);
+ if(has("config-publishRequireResult") && !lang.exists(moduleName) && result!==undefined){
+ lang.setObject(moduleName, result);
+ }
+ return result;
+ };
+
+ dojo.loadInit = function(f) {
+ f();
+ };
+
+ dojo.registerModulePath = function(/*String*/moduleName, /*String*/prefix){
+ // summary:
+ // Maps a module name to a path
+ // description:
+ // An unregistered module is given the default path of ../[module],
+ // relative to Dojo root. For example, module acme is mapped to
+ // ../acme. If you want to use a different module name, use
+ // dojo.registerModulePath.
+ // example:
+ // If your dojo.js is located at this location in the web root:
+ // | /myapp/js/dojo/dojo/dojo.js
+ // and your modules are located at:
+ // | /myapp/js/foo/bar.js
+ // | /myapp/js/foo/baz.js
+ // | /myapp/js/foo/thud/xyzzy.js
+ // Your application can tell Dojo to locate the "foo" namespace by calling:
+ // | dojo.registerModulePath("foo", "../../foo");
+ // At which point you can then use dojo.require() to load the
+ // modules (assuming they provide() the same things which are
+ // required). The full code might be:
+ // |
+ // |
+
+ var paths = {};
+ paths[moduleName.replace(/\./g, "/")] = prefix;
+ require({paths:paths});
+ };
+
+ dojo.platformRequire = function(/*Object*/modMap){
+ // summary:
+ // require one or more modules based on which host environment
+ // Dojo is currently operating in
+ // description:
+ // This method takes a "map" of arrays which one can use to
+ // optionally load dojo modules. The map is indexed by the
+ // possible dojo.name_ values, with two additional values:
+ // "default" and "common". The items in the "default" array will
+ // be loaded if none of the other items have been choosen based on
+ // dojo.name_, set by your host environment. The items in the
+ // "common" array will *always* be loaded, regardless of which
+ // list is chosen.
+ // example:
+ // | dojo.platformRequire({
+ // | browser: [
+ // | "foo.sample", // simple module
+ // | "foo.test",
+ // | ["foo.bar.baz", true] // skip object check in _loadModule (dojo.require)
+ // | ],
+ // | default: [ "foo.sample._base" ],
+ // | common: [ "important.module.common" ]
+ // | });
+
+ var result = (modMap.common || []).concat(modMap[dojo._name] || modMap["default"] || []),
+ temp;
+ while(result.length){
+ if(lang.isArray(temp = result.shift())){
+ dojo.require.apply(dojo, temp);
+ }else{
+ dojo.require(temp);
+ }
+ }
+ };
+
+ dojo.requireIf = dojo.requireAfterIf = function(/*Boolean*/ condition, /*String*/ moduleName, /*Boolean?*/omitModuleCheck){
+ // summary:
+ // If the condition is true then call `dojo.require()` for the specified
+ // resource
+ //
+ // example:
+ // | dojo.requireIf(dojo.isBrowser, "my.special.Module");
+
+ if(condition){
+ dojo.require(moduleName, omitModuleCheck);
+ }
+ };
+
+ dojo.requireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale){
+ require(["../i18n"], function(i18n){
+ i18n.getLocalization(moduleName, bundleName, locale);
+ });
+ };
+
+ return {
+ extractLegacyApiApplications:extractLegacyApiApplications,
+ require:loaderVars.dojoRequirePlugin,
+ loadInit:dojoLoadInitPlugin
+ };
+});
+
+},
+'dojo/json':function(){
+define(["./has"], function(has){
+ "use strict";
+ var hasJSON = typeof JSON != "undefined";
+ has.add("json-parse", hasJSON); // all the parsers work fine
+ // Firefox 3.5/Gecko 1.9 fails to use replacer in stringify properly https://bugzilla.mozilla.org/show_bug.cgi?id=509184
+ has.add("json-stringify", hasJSON && JSON.stringify({a:0}, function(k,v){return v||1;}) == '{"a":1}');
+ if(has("json-stringify")){
+ return JSON;
+ }
+ else{
+ var escapeString = function(/*String*/str){
+ //summary:
+ // Adds escape sequences for non-visual characters, double quote and
+ // backslash and surrounds with double quotes to form a valid string
+ // literal.
+ return ('"' + str.replace(/(["\\])/g, '\\$1') + '"').
+ replace(/[\f]/g, "\\f").replace(/[\b]/g, "\\b").replace(/[\n]/g, "\\n").
+ replace(/[\t]/g, "\\t").replace(/[\r]/g, "\\r"); // string
+ };
+ return {
+ parse: has("json-parse") ? JSON.parse : function(str, strict){
+ // summary:
+ // Parses a [JSON](http://json.org) string to return a JavaScript object.
+ // description:
+ // This function follows [native JSON API](https://developer.mozilla.org/en/JSON)
+ // Throws for invalid JSON strings. This delegates to eval() if native JSON
+ // support is not available. By default this will evaluate any valid JS expression.
+ // With the strict parameter set to true, the parser will ensure that only
+ // valid JSON strings are parsed (otherwise throwing an error). Without the strict
+ // parameter, the content passed to this method must come
+ // from a trusted source.
+ // str:
+ // a string literal of a JSON item, for instance:
+ // `'{ "foo": [ "bar", 1, { "baz": "thud" } ] }'`
+ // strict:
+ // When set to true, this will ensure that only valid, secure JSON is ever parsed.
+ // Make sure this is set to true for untrusted content. Note that on browsers/engines
+ // without native JSON support, setting this to true will run slower.
+ if(strict && !/^([\s\[\{]*(?:"(?:\\.|[^"])+"|-?\d[\d\.]*(?:[Ee][+-]?\d+)?|null|true|false|)[\s\]\}]*(?:,|:|$))+$/.test(str)){
+ throw new SyntaxError("Invalid characters in JSON");
+ }
+ return eval('(' + str + ')');
+ },
+ stringify: function(value, replacer, spacer){
+ // summary:
+ // Returns a [JSON](http://json.org) serialization of an object.
+ // description:
+ // Returns a [JSON](http://json.org) serialization of an object.
+ // This function follows [native JSON API](https://developer.mozilla.org/en/JSON)
+ // Note that this doesn't check for infinite recursion, so don't do that!
+ // value:
+ // A value to be serialized.
+ // replacer:
+ // A replacer function that is called for each value and can return a replacement
+ // spacer:
+ // A spacer string to be used for pretty printing of JSON
+ //
+ // example:
+ // simple serialization of a trivial object
+ // | define(["dojo/json"], function(JSON){
+ // | var jsonStr = JSON.stringify({ howdy: "stranger!", isStrange: true });
+ // | doh.is('{"howdy":"stranger!","isStrange":true}', jsonStr);
+ var undef;
+ if(typeof replacer == "string"){
+ spacer = replacer;
+ replacer = null;
+ }
+ function stringify(it, indent, key){
+ if(replacer){
+ it = replacer(key, it);
+ }
+ var val, objtype = typeof it;
+ if(objtype == "number"){
+ return isFinite(it) ? it + "" : "null";
+ }
+ if(objtype == "boolean"){
+ return it + "";
+ }
+ if(it === null){
+ return "null";
+ }
+ if(typeof it == "string"){
+ return escapeString(it);
+ }
+ if(objtype == "function" || objtype == "undefined"){
+ return undef; // undefined
+ }
+ // short-circuit for objects that support "json" serialization
+ // if they return "self" then just pass-through...
+ if(typeof it.toJSON == "function"){
+ return stringify(it.toJSON(key), indent, key);
+ }
+ if(it instanceof Date){
+ return '"{FullYear}-{Month+}-{Date}T{Hours}:{Minutes}:{Seconds}Z"'.replace(/\{(\w+)(\+)?\}/g, function(t, prop, plus){
+ var num = it["getUTC" + prop]() + (plus ? 1 : 0);
+ return num < 10 ? "0" + num : num;
+ });
+ }
+ if(it.valueOf() !== it){
+ // primitive wrapper, try again unwrapped:
+ return stringify(it.valueOf(), indent, key);
+ }
+ var nextIndent= spacer ? (indent + spacer) : "";
+ /* we used to test for DOM nodes and throw, but FF serializes them as {}, so cross-browser consistency is probably not efficiently attainable */
+
+ var sep = spacer ? " " : "";
+ var newLine = spacer ? "\n" : "";
+
+ // array
+ if(it instanceof Array){
+ var itl = it.length, res = [];
+ for(key = 0; key < itl; key++){
+ var obj = it[key];
+ val = stringify(obj, nextIndent, key);
+ if(typeof val != "string"){
+ val = "null";
+ }
+ res.push(newLine + nextIndent + val);
+ }
+ return "[" + res.join(",") + newLine + indent + "]";
+ }
+ // generic object code path
+ var output = [];
+ for(key in it){
+ var keyStr;
+ if(typeof key == "number"){
+ keyStr = '"' + key + '"';
+ }else if(typeof key == "string"){
+ keyStr = escapeString(key);
+ }else{
+ // skip non-string or number keys
+ continue;
+ }
+ val = stringify(it[key], nextIndent, key);
+ if(typeof val != "string"){
+ // skip non-serializable values
+ continue;
+ }
+ // At this point, the most non-IE browsers don't get in this branch
+ // (they have native JSON), so push is definitely the way to
+ output.push(newLine + nextIndent + keyStr + ":" + sep + val);
+ }
+ return "{" + output.join(",") + newLine + indent + "}"; // String
+ }
+ return stringify(value, "", "");
+ }
+ };
+ }
+});
+
+},
+'dojo/_base/declare':function(){
+define(["./kernel", "../has", "./lang"], function(dojo, has, lang){
+ // module:
+ // dojo/_base/declare
+ // summary:
+ // This module defines dojo.declare.
+
+ var mix = lang.mixin, op = Object.prototype, opts = op.toString,
+ xtor = new Function, counter = 0, cname = "constructor";
+
+ function err(msg, cls){ throw new Error("declare" + (cls ? " " + cls : "") + ": " + msg); }
+
+ // C3 Method Resolution Order (see http://www.python.org/download/releases/2.3/mro/)
+ function c3mro(bases, className){
+ var result = [], roots = [{cls: 0, refs: []}], nameMap = {}, clsCount = 1,
+ l = bases.length, i = 0, j, lin, base, top, proto, rec, name, refs;
+
+ // build a list of bases naming them if needed
+ for(; i < l; ++i){
+ base = bases[i];
+ if(!base){
+ err("mixin #" + i + " is unknown. Did you use dojo.require to pull it in?", className);
+ }else if(opts.call(base) != "[object Function]"){
+ err("mixin #" + i + " is not a callable constructor.", className);
+ }
+ lin = base._meta ? base._meta.bases : [base];
+ top = 0;
+ // add bases to the name map
+ for(j = lin.length - 1; j >= 0; --j){
+ proto = lin[j].prototype;
+ if(!proto.hasOwnProperty("declaredClass")){
+ proto.declaredClass = "uniqName_" + (counter++);
+ }
+ name = proto.declaredClass;
+ if(!nameMap.hasOwnProperty(name)){
+ nameMap[name] = {count: 0, refs: [], cls: lin[j]};
+ ++clsCount;
+ }
+ rec = nameMap[name];
+ if(top && top !== rec){
+ rec.refs.push(top);
+ ++top.count;
+ }
+ top = rec;
+ }
+ ++top.count;
+ roots[0].refs.push(top);
+ }
+
+ // remove classes without external references recursively
+ while(roots.length){
+ top = roots.pop();
+ result.push(top.cls);
+ --clsCount;
+ // optimization: follow a single-linked chain
+ while(refs = top.refs, refs.length == 1){
+ top = refs[0];
+ if(!top || --top.count){
+ // branch or end of chain => do not end to roots
+ top = 0;
+ break;
+ }
+ result.push(top.cls);
+ --clsCount;
+ }
+ if(top){
+ // branch
+ for(i = 0, l = refs.length; i < l; ++i){
+ top = refs[i];
+ if(!--top.count){
+ roots.push(top);
+ }
+ }
+ }
+ }
+ if(clsCount){
+ err("can't build consistent linearization", className);
+ }
+
+ // calculate the superclass offset
+ base = bases[0];
+ result[0] = base ?
+ base._meta && base === result[result.length - base._meta.bases.length] ?
+ base._meta.bases.length : 1 : 0;
+
+ return result;
+ }
+
+ function inherited(args, a, f){
+ var name, chains, bases, caller, meta, base, proto, opf, pos,
+ cache = this._inherited = this._inherited || {};
+
+ // crack arguments
+ if(typeof args == "string"){
+ name = args;
+ args = a;
+ a = f;
+ }
+ f = 0;
+
+ caller = args.callee;
+ name = name || caller.nom;
+ if(!name){
+ err("can't deduce a name to call inherited()", this.declaredClass);
+ }
+
+ meta = this.constructor._meta;
+ bases = meta.bases;
+
+ pos = cache.p;
+ if(name != cname){
+ // method
+ if(cache.c !== caller){
+ // cache bust
+ pos = 0;
+ base = bases[0];
+ meta = base._meta;
+ if(meta.hidden[name] !== caller){
+ // error detection
+ chains = meta.chains;
+ if(chains && typeof chains[name] == "string"){
+ err("calling chained method with inherited: " + name, this.declaredClass);
+ }
+ // find caller
+ do{
+ meta = base._meta;
+ proto = base.prototype;
+ if(meta && (proto[name] === caller && proto.hasOwnProperty(name) || meta.hidden[name] === caller)){
+ break;
+ }
+ }while(base = bases[++pos]); // intentional assignment
+ pos = base ? pos : -1;
+ }
+ }
+ // find next
+ base = bases[++pos];
+ if(base){
+ proto = base.prototype;
+ if(base._meta && proto.hasOwnProperty(name)){
+ f = proto[name];
+ }else{
+ opf = op[name];
+ do{
+ proto = base.prototype;
+ f = proto[name];
+ if(f && (base._meta ? proto.hasOwnProperty(name) : f !== opf)){
+ break;
+ }
+ }while(base = bases[++pos]); // intentional assignment
+ }
+ }
+ f = base && f || op[name];
+ }else{
+ // constructor
+ if(cache.c !== caller){
+ // cache bust
+ pos = 0;
+ meta = bases[0]._meta;
+ if(meta && meta.ctor !== caller){
+ // error detection
+ chains = meta.chains;
+ if(!chains || chains.constructor !== "manual"){
+ err("calling chained constructor with inherited", this.declaredClass);
+ }
+ // find caller
+ while(base = bases[++pos]){ // intentional assignment
+ meta = base._meta;
+ if(meta && meta.ctor === caller){
+ break;
+ }
+ }
+ pos = base ? pos : -1;
+ }
+ }
+ // find next
+ while(base = bases[++pos]){ // intentional assignment
+ meta = base._meta;
+ f = meta ? meta.ctor : base;
+ if(f){
+ break;
+ }
+ }
+ f = base && f;
+ }
+
+ // cache the found super method
+ cache.c = f;
+ cache.p = pos;
+
+ // now we have the result
+ if(f){
+ return a === true ? f : f.apply(this, a || args);
+ }
+ // intentionally no return if a super method was not found
+ }
+
+ function getInherited(name, args){
+ if(typeof name == "string"){
+ return this.__inherited(name, args, true);
+ }
+ return this.__inherited(name, true);
+ }
+
+ function inherited__debug(args, a1, a2){
+ var f = this.getInherited(args, a1);
+ if(f){ return f.apply(this, a2 || a1 || args); }
+ // intentionally no return if a super method was not found
+ }
+
+ var inheritedImpl = dojo.config.isDebug ? inherited__debug : inherited;
+
+ // emulation of "instanceof"
+ function isInstanceOf(cls){
+ var bases = this.constructor._meta.bases;
+ for(var i = 0, l = bases.length; i < l; ++i){
+ if(bases[i] === cls){
+ return true;
+ }
+ }
+ return this instanceof cls;
+ }
+
+ function mixOwn(target, source){
+ // add props adding metadata for incoming functions skipping a constructor
+ for(var name in source){
+ if(name != cname && source.hasOwnProperty(name)){
+ target[name] = source[name];
+ }
+ }
+ if(has("bug-for-in-skips-shadowed")){
+ for(var extraNames= lang._extraNames, i= extraNames.length; i;){
+ name = extraNames[--i];
+ if(name != cname && source.hasOwnProperty(name)){
+ target[name] = source[name];
+ }
+ }
+ }
+ }
+
+ // implementation of safe mixin function
+ function safeMixin(target, source){
+ var name, t;
+ // add props adding metadata for incoming functions skipping a constructor
+ for(name in source){
+ t = source[name];
+ if((t !== op[name] || !(name in op)) && name != cname){
+ if(opts.call(t) == "[object Function]"){
+ // non-trivial function method => attach its name
+ t.nom = name;
+ }
+ target[name] = t;
+ }
+ }
+ if(has("bug-for-in-skips-shadowed")){
+ for(var extraNames= lang._extraNames, i= extraNames.length; i;){
+ name = extraNames[--i];
+ t = source[name];
+ if((t !== op[name] || !(name in op)) && name != cname){
+ if(opts.call(t) == "[object Function]"){
+ // non-trivial function method => attach its name
+ t.nom = name;
+ }
+ target[name] = t;
+ }
+ }
+ }
+ return target;
+ }
+
+ function extend(source){
+ declare.safeMixin(this.prototype, source);
+ return this;
+ }
+
+ // chained constructor compatible with the legacy dojo.declare()
+ function chainedConstructor(bases, ctorSpecial){
+ return function(){
+ var a = arguments, args = a, a0 = a[0], f, i, m,
+ l = bases.length, preArgs;
+
+ if(!(this instanceof a.callee)){
+ // not called via new, so force it
+ return applyNew(a);
+ }
+
+ //this._inherited = {};
+ // perform the shaman's rituals of the original dojo.declare()
+ // 1) call two types of the preamble
+ if(ctorSpecial && (a0 && a0.preamble || this.preamble)){
+ // full blown ritual
+ preArgs = new Array(bases.length);
+ // prepare parameters
+ preArgs[0] = a;
+ for(i = 0;;){
+ // process the preamble of the 1st argument
+ a0 = a[0];
+ if(a0){
+ f = a0.preamble;
+ if(f){
+ a = f.apply(this, a) || a;
+ }
+ }
+ // process the preamble of this class
+ f = bases[i].prototype;
+ f = f.hasOwnProperty("preamble") && f.preamble;
+ if(f){
+ a = f.apply(this, a) || a;
+ }
+ // one peculiarity of the preamble:
+ // it is called if it is not needed,
+ // e.g., there is no constructor to call
+ // let's watch for the last constructor
+ // (see ticket #9795)
+ if(++i == l){
+ break;
+ }
+ preArgs[i] = a;
+ }
+ }
+ // 2) call all non-trivial constructors using prepared arguments
+ for(i = l - 1; i >= 0; --i){
+ f = bases[i];
+ m = f._meta;
+ f = m ? m.ctor : f;
+ if(f){
+ f.apply(this, preArgs ? preArgs[i] : a);
+ }
+ }
+ // 3) continue the original ritual: call the postscript
+ f = this.postscript;
+ if(f){
+ f.apply(this, args);
+ }
+ };
+ }
+
+
+ // chained constructor compatible with the legacy dojo.declare()
+ function singleConstructor(ctor, ctorSpecial){
+ return function(){
+ var a = arguments, t = a, a0 = a[0], f;
+
+ if(!(this instanceof a.callee)){
+ // not called via new, so force it
+ return applyNew(a);
+ }
+
+ //this._inherited = {};
+ // perform the shaman's rituals of the original dojo.declare()
+ // 1) call two types of the preamble
+ if(ctorSpecial){
+ // full blown ritual
+ if(a0){
+ // process the preamble of the 1st argument
+ f = a0.preamble;
+ if(f){
+ t = f.apply(this, t) || t;
+ }
+ }
+ f = this.preamble;
+ if(f){
+ // process the preamble of this class
+ f.apply(this, t);
+ // one peculiarity of the preamble:
+ // it is called even if it is not needed,
+ // e.g., there is no constructor to call
+ // let's watch for the last constructor
+ // (see ticket #9795)
+ }
+ }
+ // 2) call a constructor
+ if(ctor){
+ ctor.apply(this, a);
+ }
+ // 3) continue the original ritual: call the postscript
+ f = this.postscript;
+ if(f){
+ f.apply(this, a);
+ }
+ };
+ }
+
+ // plain vanilla constructor (can use inherited() to call its base constructor)
+ function simpleConstructor(bases){
+ return function(){
+ var a = arguments, i = 0, f, m;
+
+ if(!(this instanceof a.callee)){
+ // not called via new, so force it
+ return applyNew(a);
+ }
+
+ //this._inherited = {};
+ // perform the shaman's rituals of the original dojo.declare()
+ // 1) do not call the preamble
+ // 2) call the top constructor (it can use this.inherited())
+ for(; f = bases[i]; ++i){ // intentional assignment
+ m = f._meta;
+ f = m ? m.ctor : f;
+ if(f){
+ f.apply(this, a);
+ break;
+ }
+ }
+ // 3) call the postscript
+ f = this.postscript;
+ if(f){
+ f.apply(this, a);
+ }
+ };
+ }
+
+ function chain(name, bases, reversed){
+ return function(){
+ var b, m, f, i = 0, step = 1;
+ if(reversed){
+ i = bases.length - 1;
+ step = -1;
+ }
+ for(; b = bases[i]; i += step){ // intentional assignment
+ m = b._meta;
+ f = (m ? m.hidden : b.prototype)[name];
+ if(f){
+ f.apply(this, arguments);
+ }
+ }
+ };
+ }
+
+ // forceNew(ctor)
+ // return a new object that inherits from ctor.prototype but
+ // without actually running ctor on the object.
+ function forceNew(ctor){
+ // create object with correct prototype using a do-nothing
+ // constructor
+ xtor.prototype = ctor.prototype;
+ var t = new xtor;
+ xtor.prototype = null; // clean up
+ return t;
+ }
+
+ // applyNew(args)
+ // just like 'new ctor()' except that the constructor and its arguments come
+ // from args, which must be an array or an arguments object
+ function applyNew(args){
+ // create an object with ctor's prototype but without
+ // calling ctor on it.
+ var ctor = args.callee, t = forceNew(ctor);
+ // execute the real constructor on the new object
+ ctor.apply(t, args);
+ return t;
+ }
+
+ function declare(className, superclass, props){
+ // crack parameters
+ if(typeof className != "string"){
+ props = superclass;
+ superclass = className;
+ className = "";
+ }
+ props = props || {};
+
+ var proto, i, t, ctor, name, bases, chains, mixins = 1, parents = superclass;
+
+ // build a prototype
+ if(opts.call(superclass) == "[object Array]"){
+ // C3 MRO
+ bases = c3mro(superclass, className);
+ t = bases[0];
+ mixins = bases.length - t;
+ superclass = bases[mixins];
+ }else{
+ bases = [0];
+ if(superclass){
+ if(opts.call(superclass) == "[object Function]"){
+ t = superclass._meta;
+ bases = bases.concat(t ? t.bases : superclass);
+ }else{
+ err("base class is not a callable constructor.", className);
+ }
+ }else if(superclass !== null){
+ err("unknown base class. Did you use dojo.require to pull it in?", className);
+ }
+ }
+ if(superclass){
+ for(i = mixins - 1;; --i){
+ proto = forceNew(superclass);
+ if(!i){
+ // stop if nothing to add (the last base)
+ break;
+ }
+ // mix in properties
+ t = bases[i];
+ (t._meta ? mixOwn : mix)(proto, t.prototype);
+ // chain in new constructor
+ ctor = new Function;
+ ctor.superclass = superclass;
+ ctor.prototype = proto;
+ superclass = proto.constructor = ctor;
+ }
+ }else{
+ proto = {};
+ }
+ // add all properties
+ declare.safeMixin(proto, props);
+ // add constructor
+ t = props.constructor;
+ if(t !== op.constructor){
+ t.nom = cname;
+ proto.constructor = t;
+ }
+
+ // collect chains and flags
+ for(i = mixins - 1; i; --i){ // intentional assignment
+ t = bases[i]._meta;
+ if(t && t.chains){
+ chains = mix(chains || {}, t.chains);
+ }
+ }
+ if(proto["-chains-"]){
+ chains = mix(chains || {}, proto["-chains-"]);
+ }
+
+ // build ctor
+ t = !chains || !chains.hasOwnProperty(cname);
+ bases[0] = ctor = (chains && chains.constructor === "manual") ? simpleConstructor(bases) :
+ (bases.length == 1 ? singleConstructor(props.constructor, t) : chainedConstructor(bases, t));
+
+ // add meta information to the constructor
+ ctor._meta = {bases: bases, hidden: props, chains: chains,
+ parents: parents, ctor: props.constructor};
+ ctor.superclass = superclass && superclass.prototype;
+ ctor.extend = extend;
+ ctor.prototype = proto;
+ proto.constructor = ctor;
+
+ // add "standard" methods to the prototype
+ proto.getInherited = getInherited;
+ proto.isInstanceOf = isInstanceOf;
+ proto.inherited = inheritedImpl;
+ proto.__inherited = inherited;
+
+ // add name if specified
+ if(className){
+ proto.declaredClass = className;
+ lang.setObject(className, ctor);
+ }
+
+ // build chains and add them to the prototype
+ if(chains){
+ for(name in chains){
+ if(proto[name] && typeof chains[name] == "string" && name != cname){
+ t = proto[name] = chain(name, bases, chains[name] === "after");
+ t.nom = name;
+ }
+ }
+ }
+ // chained methods do not return values
+ // no need to chain "invisible" functions
+
+ return ctor; // Function
+ }
+
+ /*=====
+ dojo.declare = function(className, superclass, props){
+ // summary:
+ // Create a feature-rich constructor from compact notation.
+ // className: String?:
+ // The optional name of the constructor (loosely, a "class")
+ // stored in the "declaredClass" property in the created prototype.
+ // It will be used as a global name for a created constructor.
+ // superclass: Function|Function[]:
+ // May be null, a Function, or an Array of Functions. This argument
+ // specifies a list of bases (the left-most one is the most deepest
+ // base).
+ // props: Object:
+ // An object whose properties are copied to the created prototype.
+ // Add an instance-initialization function by making it a property
+ // named "constructor".
+ // returns:
+ // New constructor function.
+ // description:
+ // Create a constructor using a compact notation for inheritance and
+ // prototype extension.
+ //
+ // Mixin ancestors provide a type of multiple inheritance.
+ // Prototypes of mixin ancestors are copied to the new class:
+ // changes to mixin prototypes will not affect classes to which
+ // they have been mixed in.
+ //
+ // Ancestors can be compound classes created by this version of
+ // dojo.declare. In complex cases all base classes are going to be
+ // linearized according to C3 MRO algorithm
+ // (see http://www.python.org/download/releases/2.3/mro/ for more
+ // details).
+ //
+ // "className" is cached in "declaredClass" property of the new class,
+ // if it was supplied. The immediate super class will be cached in
+ // "superclass" property of the new class.
+ //
+ // Methods in "props" will be copied and modified: "nom" property
+ // (the declared name of the method) will be added to all copied
+ // functions to help identify them for the internal machinery. Be
+ // very careful, while reusing methods: if you use the same
+ // function under different names, it can produce errors in some
+ // cases.
+ //
+ // It is possible to use constructors created "manually" (without
+ // dojo.declare) as bases. They will be called as usual during the
+ // creation of an instance, their methods will be chained, and even
+ // called by "this.inherited()".
+ //
+ // Special property "-chains-" governs how to chain methods. It is
+ // a dictionary, which uses method names as keys, and hint strings
+ // as values. If a hint string is "after", this method will be
+ // called after methods of its base classes. If a hint string is
+ // "before", this method will be called before methods of its base
+ // classes.
+ //
+ // If "constructor" is not mentioned in "-chains-" property, it will
+ // be chained using the legacy mode: using "after" chaining,
+ // calling preamble() method before each constructor, if available,
+ // and calling postscript() after all constructors were executed.
+ // If the hint is "after", it is chained as a regular method, but
+ // postscript() will be called after the chain of constructors.
+ // "constructor" cannot be chained "before", but it allows
+ // a special hint string: "manual", which means that constructors
+ // are not going to be chained in any way, and programmer will call
+ // them manually using this.inherited(). In the latter case
+ // postscript() will be called after the construction.
+ //
+ // All chaining hints are "inherited" from base classes and
+ // potentially can be overridden. Be very careful when overriding
+ // hints! Make sure that all chained methods can work in a proposed
+ // manner of chaining.
+ //
+ // Once a method was chained, it is impossible to unchain it. The
+ // only exception is "constructor". You don't need to define a
+ // method in order to supply a chaining hint.
+ //
+ // If a method is chained, it cannot use this.inherited() because
+ // all other methods in the hierarchy will be called automatically.
+ //
+ // Usually constructors and initializers of any kind are chained
+ // using "after" and destructors of any kind are chained as
+ // "before". Note that chaining assumes that chained methods do not
+ // return any value: any returned value will be discarded.
+ //
+ // example:
+ // | dojo.declare("my.classes.bar", my.classes.foo, {
+ // | // properties to be added to the class prototype
+ // | someValue: 2,
+ // | // initialization function
+ // | constructor: function(){
+ // | this.myComplicatedObject = new ReallyComplicatedObject();
+ // | },
+ // | // other functions
+ // | someMethod: function(){
+ // | doStuff();
+ // | }
+ // | });
+ //
+ // example:
+ // | var MyBase = dojo.declare(null, {
+ // | // constructor, properties, and methods go here
+ // | // ...
+ // | });
+ // | var MyClass1 = dojo.declare(MyBase, {
+ // | // constructor, properties, and methods go here
+ // | // ...
+ // | });
+ // | var MyClass2 = dojo.declare(MyBase, {
+ // | // constructor, properties, and methods go here
+ // | // ...
+ // | });
+ // | var MyDiamond = dojo.declare([MyClass1, MyClass2], {
+ // | // constructor, properties, and methods go here
+ // | // ...
+ // | });
+ //
+ // example:
+ // | var F = function(){ console.log("raw constructor"); };
+ // | F.prototype.method = function(){
+ // | console.log("raw method");
+ // | };
+ // | var A = dojo.declare(F, {
+ // | constructor: function(){
+ // | console.log("A.constructor");
+ // | },
+ // | method: function(){
+ // | console.log("before calling F.method...");
+ // | this.inherited(arguments);
+ // | console.log("...back in A");
+ // | }
+ // | });
+ // | new A().method();
+ // | // will print:
+ // | // raw constructor
+ // | // A.constructor
+ // | // before calling F.method...
+ // | // raw method
+ // | // ...back in A
+ //
+ // example:
+ // | var A = dojo.declare(null, {
+ // | "-chains-": {
+ // | destroy: "before"
+ // | }
+ // | });
+ // | var B = dojo.declare(A, {
+ // | constructor: function(){
+ // | console.log("B.constructor");
+ // | },
+ // | destroy: function(){
+ // | console.log("B.destroy");
+ // | }
+ // | });
+ // | var C = dojo.declare(B, {
+ // | constructor: function(){
+ // | console.log("C.constructor");
+ // | },
+ // | destroy: function(){
+ // | console.log("C.destroy");
+ // | }
+ // | });
+ // | new C().destroy();
+ // | // prints:
+ // | // B.constructor
+ // | // C.constructor
+ // | // C.destroy
+ // | // B.destroy
+ //
+ // example:
+ // | var A = dojo.declare(null, {
+ // | "-chains-": {
+ // | constructor: "manual"
+ // | }
+ // | });
+ // | var B = dojo.declare(A, {
+ // | constructor: function(){
+ // | // ...
+ // | // call the base constructor with new parameters
+ // | this.inherited(arguments, [1, 2, 3]);
+ // | // ...
+ // | }
+ // | });
+ //
+ // example:
+ // | var A = dojo.declare(null, {
+ // | "-chains-": {
+ // | m1: "before"
+ // | },
+ // | m1: function(){
+ // | console.log("A.m1");
+ // | },
+ // | m2: function(){
+ // | console.log("A.m2");
+ // | }
+ // | });
+ // | var B = dojo.declare(A, {
+ // | "-chains-": {
+ // | m2: "after"
+ // | },
+ // | m1: function(){
+ // | console.log("B.m1");
+ // | },
+ // | m2: function(){
+ // | console.log("B.m2");
+ // | }
+ // | });
+ // | var x = new B();
+ // | x.m1();
+ // | // prints:
+ // | // B.m1
+ // | // A.m1
+ // | x.m2();
+ // | // prints:
+ // | // A.m2
+ // | // B.m2
+ return new Function(); // Function
+ };
+ =====*/
+
+ /*=====
+ dojo.safeMixin = function(target, source){
+ // summary:
+ // Mix in properties skipping a constructor and decorating functions
+ // like it is done by dojo.declare.
+ // target: Object
+ // Target object to accept new properties.
+ // source: Object
+ // Source object for new properties.
+ // description:
+ // This function is used to mix in properties like lang.mixin does,
+ // but it skips a constructor property and decorates functions like
+ // dojo.declare does.
+ //
+ // It is meant to be used with classes and objects produced with
+ // dojo.declare. Functions mixed in with dojo.safeMixin can use
+ // this.inherited() like normal methods.
+ //
+ // This function is used to implement extend() method of a constructor
+ // produced with dojo.declare().
+ //
+ // example:
+ // | var A = dojo.declare(null, {
+ // | m1: function(){
+ // | console.log("A.m1");
+ // | },
+ // | m2: function(){
+ // | console.log("A.m2");
+ // | }
+ // | });
+ // | var B = dojo.declare(A, {
+ // | m1: function(){
+ // | this.inherited(arguments);
+ // | console.log("B.m1");
+ // | }
+ // | });
+ // | B.extend({
+ // | m2: function(){
+ // | this.inherited(arguments);
+ // | console.log("B.m2");
+ // | }
+ // | });
+ // | var x = new B();
+ // | dojo.safeMixin(x, {
+ // | m1: function(){
+ // | this.inherited(arguments);
+ // | console.log("X.m1");
+ // | },
+ // | m2: function(){
+ // | this.inherited(arguments);
+ // | console.log("X.m2");
+ // | }
+ // | });
+ // | x.m2();
+ // | // prints:
+ // | // A.m1
+ // | // B.m1
+ // | // X.m1
+ };
+ =====*/
+
+ /*=====
+ Object.inherited = function(name, args, newArgs){
+ // summary:
+ // Calls a super method.
+ // name: String?
+ // The optional method name. Should be the same as the caller's
+ // name. Usually "name" is specified in complex dynamic cases, when
+ // the calling method was dynamically added, undecorated by
+ // dojo.declare, and it cannot be determined.
+ // args: Arguments
+ // The caller supply this argument, which should be the original
+ // "arguments".
+ // newArgs: Object?
+ // If "true", the found function will be returned without
+ // executing it.
+ // If Array, it will be used to call a super method. Otherwise
+ // "args" will be used.
+ // returns:
+ // Whatever is returned by a super method, or a super method itself,
+ // if "true" was specified as newArgs.
+ // description:
+ // This method is used inside method of classes produced with
+ // dojo.declare to call a super method (next in the chain). It is
+ // used for manually controlled chaining. Consider using the regular
+ // chaining, because it is faster. Use "this.inherited()" only in
+ // complex cases.
+ //
+ // This method cannot me called from automatically chained
+ // constructors including the case of a special (legacy)
+ // constructor chaining. It cannot be called from chained methods.
+ //
+ // If "this.inherited()" cannot find the next-in-chain method, it
+ // does nothing and returns "undefined". The last method in chain
+ // can be a default method implemented in Object, which will be
+ // called last.
+ //
+ // If "name" is specified, it is assumed that the method that
+ // received "args" is the parent method for this call. It is looked
+ // up in the chain list and if it is found the next-in-chain method
+ // is called. If it is not found, the first-in-chain method is
+ // called.
+ //
+ // If "name" is not specified, it will be derived from the calling
+ // method (using a methoid property "nom").
+ //
+ // example:
+ // | var B = dojo.declare(A, {
+ // | method1: function(a, b, c){
+ // | this.inherited(arguments);
+ // | },
+ // | method2: function(a, b){
+ // | return this.inherited(arguments, [a + b]);
+ // | }
+ // | });
+ // | // next method is not in the chain list because it is added
+ // | // manually after the class was created.
+ // | B.prototype.method3 = function(){
+ // | console.log("This is a dynamically-added method.");
+ // | this.inherited("method3", arguments);
+ // | };
+ // example:
+ // | var B = dojo.declare(A, {
+ // | method: function(a, b){
+ // | var super = this.inherited(arguments, true);
+ // | // ...
+ // | if(!super){
+ // | console.log("there is no super method");
+ // | return 0;
+ // | }
+ // | return super.apply(this, arguments);
+ // | }
+ // | });
+ return {}; // Object
+ }
+ =====*/
+
+ /*=====
+ Object.getInherited = function(name, args){
+ // summary:
+ // Returns a super method.
+ // name: String?
+ // The optional method name. Should be the same as the caller's
+ // name. Usually "name" is specified in complex dynamic cases, when
+ // the calling method was dynamically added, undecorated by
+ // dojo.declare, and it cannot be determined.
+ // args: Arguments
+ // The caller supply this argument, which should be the original
+ // "arguments".
+ // returns:
+ // Returns a super method (Function) or "undefined".
+ // description:
+ // This method is a convenience method for "this.inherited()".
+ // It uses the same algorithm but instead of executing a super
+ // method, it returns it, or "undefined" if not found.
+ //
+ // example:
+ // | var B = dojo.declare(A, {
+ // | method: function(a, b){
+ // | var super = this.getInherited(arguments);
+ // | // ...
+ // | if(!super){
+ // | console.log("there is no super method");
+ // | return 0;
+ // | }
+ // | return super.apply(this, arguments);
+ // | }
+ // | });
+ return {}; // Object
+ }
+ =====*/
+
+ /*=====
+ Object.isInstanceOf = function(cls){
+ // summary:
+ // Checks the inheritance chain to see if it is inherited from this
+ // class.
+ // cls: Function
+ // Class constructor.
+ // returns:
+ // "true", if this object is inherited from this class, "false"
+ // otherwise.
+ // description:
+ // This method is used with instances of classes produced with
+ // dojo.declare to determine of they support a certain interface or
+ // not. It models "instanceof" operator.
+ //
+ // example:
+ // | var A = dojo.declare(null, {
+ // | // constructor, properties, and methods go here
+ // | // ...
+ // | });
+ // | var B = dojo.declare(null, {
+ // | // constructor, properties, and methods go here
+ // | // ...
+ // | });
+ // | var C = dojo.declare([A, B], {
+ // | // constructor, properties, and methods go here
+ // | // ...
+ // | });
+ // | var D = dojo.declare(A, {
+ // | // constructor, properties, and methods go here
+ // | // ...
+ // | });
+ // |
+ // | var a = new A(), b = new B(), c = new C(), d = new D();
+ // |
+ // | console.log(a.isInstanceOf(A)); // true
+ // | console.log(b.isInstanceOf(A)); // false
+ // | console.log(c.isInstanceOf(A)); // true
+ // | console.log(d.isInstanceOf(A)); // true
+ // |
+ // | console.log(a.isInstanceOf(B)); // false
+ // | console.log(b.isInstanceOf(B)); // true
+ // | console.log(c.isInstanceOf(B)); // true
+ // | console.log(d.isInstanceOf(B)); // false
+ // |
+ // | console.log(a.isInstanceOf(C)); // false
+ // | console.log(b.isInstanceOf(C)); // false
+ // | console.log(c.isInstanceOf(C)); // true
+ // | console.log(d.isInstanceOf(C)); // false
+ // |
+ // | console.log(a.isInstanceOf(D)); // false
+ // | console.log(b.isInstanceOf(D)); // false
+ // | console.log(c.isInstanceOf(D)); // false
+ // | console.log(d.isInstanceOf(D)); // true
+ return {}; // Object
+ }
+ =====*/
+
+ /*=====
+ Object.extend = function(source){
+ // summary:
+ // Adds all properties and methods of source to constructor's
+ // prototype, making them available to all instances created with
+ // constructor. This method is specific to constructors created with
+ // dojo.declare.
+ // source: Object
+ // Source object which properties are going to be copied to the
+ // constructor's prototype.
+ // description:
+ // Adds source properties to the constructor's prototype. It can
+ // override existing properties.
+ //
+ // This method is similar to dojo.extend function, but it is specific
+ // to constructors produced by dojo.declare. It is implemented
+ // using dojo.safeMixin, and it skips a constructor property,
+ // and properly decorates copied functions.
+ //
+ // example:
+ // | var A = dojo.declare(null, {
+ // | m1: function(){},
+ // | s1: "Popokatepetl"
+ // | });
+ // | A.extend({
+ // | m1: function(){},
+ // | m2: function(){},
+ // | f1: true,
+ // | d1: 42
+ // | });
+ };
+ =====*/
+
+ dojo.safeMixin = declare.safeMixin = safeMixin;
+ dojo.declare = declare;
+
+ return declare;
+});
+
+},
+'dojo/dom':function(){
+define(["./_base/sniff", "./_base/lang", "./_base/window"],
+ function(has, lang, win){
+ // module:
+ // dojo/dom
+ // summary:
+ // This module defines the core dojo DOM API.
+
+ // FIXME: need to add unit tests for all the semi-public methods
+
+ try{
+ document.execCommand("BackgroundImageCache", false, true);
+ }catch(e){
+ // sane browsers don't have cache "issues"
+ }
+
+ // =============================
+ // DOM Functions
+ // =============================
+
+ /*=====
+ dojo.byId = function(id, doc){
+ // summary:
+ // Returns DOM node with matching `id` attribute or `null`
+ // if not found. If `id` is a DomNode, this function is a no-op.
+ //
+ // id: String|DOMNode
+ // A string to match an HTML id attribute or a reference to a DOM Node
+ //
+ // doc: Document?
+ // Document to work in. Defaults to the current value of
+ // dojo.doc. Can be used to retrieve
+ // node references from other documents.
+ //
+ // example:
+ // Look up a node by ID:
+ // | var n = dojo.byId("foo");
+ //
+ // example:
+ // Check if a node exists, and use it.
+ // | var n = dojo.byId("bar");
+ // | if(n){ doStuff() ... }
+ //
+ // example:
+ // Allow string or DomNode references to be passed to a custom function:
+ // | var foo = function(nodeOrId){
+ // | nodeOrId = dojo.byId(nodeOrId);
+ // | // ... more stuff
+ // | }
+ =====*/
+
+ /*=====
+ dojo.isDescendant = function(node, ancestor){
+ // summary:
+ // Returns true if node is a descendant of ancestor
+ // node: DOMNode|String
+ // string id or node reference to test
+ // ancestor: DOMNode|String
+ // string id or node reference of potential parent to test against
+ //
+ // example:
+ // Test is node id="bar" is a descendant of node id="foo"
+ // | if(dojo.isDescendant("bar", "foo")){ ... }
+ };
+ =====*/
+
+ // TODO: do we need this function in the base?
+
+ /*=====
+ dojo.setSelectable = function(node, selectable){
+ // summary:
+ // Enable or disable selection on a node
+ // node: DOMNode|String
+ // id or reference to node
+ // selectable: Boolean
+ // state to put the node in. false indicates unselectable, true
+ // allows selection.
+ // example:
+ // Make the node id="bar" unselectable
+ // | dojo.setSelectable("bar");
+ // example:
+ // Make the node id="bar" selectable
+ // | dojo.setSelectable("bar", true);
+ };
+ =====*/
+
+ var dom = {}; // the result object
+
+ if(has("ie")){
+ dom.byId = function(id, doc){
+ if(typeof id != "string"){
+ return id;
+ }
+ var _d = doc || win.doc, te = id && _d.getElementById(id);
+ // attributes.id.value is better than just id in case the
+ // user has a name=id inside a form
+ if(te && (te.attributes.id.value == id || te.id == id)){
+ return te;
+ }else{
+ var eles = _d.all[id];
+ if(!eles || eles.nodeName){
+ eles = [eles];
+ }
+ // if more than 1, choose first with the correct id
+ var i = 0;
+ while((te = eles[i++])){
+ if((te.attributes && te.attributes.id && te.attributes.id.value == id) || te.id == id){
+ return te;
+ }
+ }
+ }
+ };
+ }else{
+ dom.byId = function(id, doc){
+ // inline'd type check.
+ // be sure to return null per documentation, to match IE branch.
+ return ((typeof id == "string") ? (doc || win.doc).getElementById(id) : id) || null; // DOMNode
+ };
+ }
+ /*=====
+ };
+ =====*/
+
+ dom.isDescendant = function(/*DOMNode|String*/node, /*DOMNode|String*/ancestor){
+ try{
+ node = dom.byId(node);
+ ancestor = dom.byId(ancestor);
+ while(node){
+ if(node == ancestor){
+ return true; // Boolean
+ }
+ node = node.parentNode;
+ }
+ }catch(e){ /* squelch, return false */ }
+ return false; // Boolean
+ };
+
+ // TODO: do we need this function in the base?
+
+ dom.setSelectable = function(/*DOMNode|String*/node, /*Boolean*/selectable){
+ node = dom.byId(node);
+ if(has("mozilla")){
+ node.style.MozUserSelect = selectable ? "" : "none";
+ }else if(has("khtml") || has("webkit")){
+ node.style.KhtmlUserSelect = selectable ? "auto" : "none";
+ }else if(has("ie")){
+ var v = (node.unselectable = selectable ? "" : "on"),
+ cs = node.getElementsByTagName("*"), i = 0, l = cs.length;
+ for(; i < l; ++i){
+ cs.item(i).unselectable = v;
+ }
+ }
+ //FIXME: else? Opera?
+ };
+
+ return dom;
+});
+
+},
+'dojo/_base/browser':function(){
+if(require.has){
+ require.has.add("config-selectorEngine", "acme");
+}
+define("dojo/_base/browser", [
+ "../ready",
+ "./kernel",
+ "./connect", // until we decide if connect is going back into non-browser environments
+ "./unload",
+ "./window",
+ "./event",
+ "./html",
+ "./NodeList",
+ "../query",
+ "./xhr",
+ "./fx"], function(dojo) {
+ // module:
+ // dojo/_base/browser
+ // summary:
+ // This module causes the browser-only base modules to be loaded.
+ return dojo;
+});
+
+},
+'dojo/selector/acme':function(){
+define(["../_base/kernel", "../has", "../dom", "../_base/sniff", "../_base/array", "../_base/lang", "../_base/window"], function(dojo, has, dom){
+ // module:
+ // dojo/selector/acme
+ // summary:
+ // This module defines the Acme selector engine
+
+/*
+ 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 = dojo.trim;
+ var each = dojo.forEach;
+ // d.isIE; // float
+ // d.isSafari; // float
+ // d.isOpera; // float
+ // d.isWebKit; // float
+ // d.doc ; // document element
+
+ var getDoc = function(){ return dojo.doc; };
+ // NOTE(alex): the spec is idiotic. CSS queries should ALWAYS be case-sensitive, but nooooooo
+ var cssCaseBug = ((dojo.isWebKit||dojo.isMozilla) && ((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,
+ 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;
+ }
+
+ 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);
+ }
+ }
+ // 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);
+ return (ea.lastIndexOf(value)==(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;
+ var i = 0,
+ tret = root.children || root.childNodes,
+ ci = (node["_i"]||-1),
+ cl = (root["_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
+ root["_l"] = l;
+ ci = -1;
+ for(var te = root["firstElementChild"]||root["firstChild"]; te; te = te[_ns]){
+ if(_simpleNodeTest(te)){
+ 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);
+ }
+ },
+ "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 = (dojo.isIE && (dojo.isIE < 9 || dojo.isQuirks)) ? 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 && (elem.tagName == 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;
+ };
+ };
+
+ /*
+ // thanks, Dean!
+ var itemIsAfterRoot = d.isIE ? function(item, root){
+ return (item.sourceIndex > root.sourceIndex);
+ } : function(item, root){
+ return (item.compareDocumentPosition(root) == 2);
+ };
+ */
+
+ // 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 tret = root.getElementsByTagName(query.getTag());
+ 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 tret = root.getElementsByTagName(query.getTag());
+ 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
+ // gauranteed 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 spliting, 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 determiniation (e.g. does it support QSA, does the query in
+ // question work in the native QSA impl, etc.).
+ var nua = navigator.userAgent;
+ // some versions of Safari provided QSA, but it was buggy and crash-prone.
+ // We need te detect the right "internal" webkit version to make this work.
+ var wk = "WebKit/";
+ var is525 = (
+ dojo.isWebKit &&
+ (nua.indexOf(wk) > 0) &&
+ (parseFloat(nua.split(wk)[1]) > 528)
+ );
+
+ // 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 = dojo.isIE ? "commentStrip" : "nozip";
+
+ var qsa = "querySelectorAll";
+ var qsaAvail = (
+ !!getDoc()[qsa] &&
+ // see #5832
+ (!dojo.isSafari || (dojo.isSafari > 3.1) || is525 )
+ );
+
+ //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;
+ };
+
+ 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(infixSpaceRe, infixSpaceFunc);
+
+ 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
+ (!dojo.isIE || (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.split(/\s*,\s*/);
+ 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 = dojo.isIE ? 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 doucment 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*
+ if(dojo.isIE && caseSensitive){
+ var szidx = _zipIdx+"";
+ arr[0].setAttribute(_zipIdxName, szidx);
+ for(var x = 1, te; te = arr[x]; x++){
+ if(arr[x].getAttribute(_zipIdxName) != szidx){
+ ret.push(te);
+ }
+ te.setAttribute(_zipIdxName, szidx);
+ }
+ }else if(dojo.isIE && arr.commentStrip){
+ try{
+ for(var x = 1, te; te = arr[x]; x++){
+ if(_isElement(te)){
+ ret.push(te);
+ }
+ }
+ }catch(e){ /* squelch */ }
+ }else{
+ if(arr[0]){ arr[0][_zipIdxName] = _zipIdx; }
+ for(var x = 1, te; 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 pseduo-selectors which don't get a lot of day-to-day use:
+ // | * `:root`, `:lang()`, `:target`, `:focus`
+ // * all visual and state selectors:
+ // | * `:root`, `:active`, `:hover`, `:visisted`, `: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
+ // 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:
+ // |
+ // |
+ // |
+ // example:
+ // search the entire document for elements with the classes "foo" *and* "bar":
+ // | dojo.query(".foo.bar");
+ // these elements will match:
+ // |
+ // while these will not:
+ // |
+ // |
+ // example:
+ // find `` elements which are descendants of paragraphs and
+ // which have a "highlighted" class:
+ // | dojo.query("p span.highlighted");
+ // the innermost span in this fragment matches:
+ // |
+ // | ...
+ // | ...
+ // |
+ // |
+ // 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();
+ var od = root.ownerDocument||root.documentElement;
+
+ // throw the big case sensitivity switch
+
+ // NOTE:
+ // Opera in XHTML mode doesn't detect case-sensitivity correctly
+ // and it's not clear that there's any way to test for it
+ caseSensitive = (root.contentType && root.contentType=="application/xml") ||
+ (dojo.isOpera && (root.doctype || od.toString() == "[object XMLDocument]")) ||
+ (!!od) &&
+ (dojo.isIE ? od.xml : (root.xmlVersion || od.xmlVersion));
+
+ // 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 dojo.query(filter, root).indexOf(node) != -1;
+ };
+ for(var x = 0, te; te = nodeList[x]; x++){
+ if(filterFunc(te)){ tmpNodeList.push(te); }
+ }
+ return tmpNodeList;
+ };
+ return query;
+});//end defineQuery
+
+},
+'dojo/dom-style':function(){
+define(["./_base/sniff", "./dom"], function(has, dom){
+ // module:
+ // dojo/dom-style
+ // summary:
+ // This module defines the core dojo DOM style API.
+
+ // =============================
+ // Style Functions
+ // =============================
+
+ // getComputedStyle drives most of the style code.
+ // Wherever possible, reuse the returned object.
+ //
+ // API functions below that need to access computed styles accept an
+ // optional computedStyle parameter.
+ // If this parameter is omitted, the functions will call getComputedStyle themselves.
+ // This way, calling code can access computedStyle once, and then pass the reference to
+ // multiple API functions.
+
+ /*=====
+ dojo.getComputedStyle = function(node){
+ // summary:
+ // Returns a "computed style" object.
+ //
+ // description:
+ // Gets a "computed style" object which can be used to gather
+ // information about the current state of the rendered node.
+ //
+ // Note that this may behave differently on different browsers.
+ // Values may have different formats and value encodings across
+ // browsers.
+ //
+ // Note also that this method is expensive. Wherever possible,
+ // reuse the returned object.
+ //
+ // Use the dojo.style() method for more consistent (pixelized)
+ // return values.
+ //
+ // node: DOMNode
+ // A reference to a DOM node. Does NOT support taking an
+ // ID string for speed reasons.
+ // example:
+ // | dojo.getComputedStyle(dojo.byId('foo')).borderWidth;
+ //
+ // example:
+ // Reusing the returned object, avoiding multiple lookups:
+ // | var cs = dojo.getComputedStyle(dojo.byId("someNode"));
+ // | var w = cs.width, h = cs.height;
+ return; // CSS2Properties
+ }
+ =====*/
+
+ /*=====
+ dojo.toPixelValue = function(node, value){
+ // summary:
+ // converts style value to pixels on IE or return a numeric value.
+ // node: DOMNode
+ // value: String
+ // returns: Number
+ };
+ =====*/
+
+ /*=====
+ dojo._toPixelValue = function(node, value){
+ // summary:
+ // Existing alias for `dojo._toPixelValue`. Deprecated, will be removed in 2.0.
+ };
+ =====*/
+
+ /*=====
+ dojo.getStyle = function(node, name){
+ // summary:
+ // Accesses styles on a node.
+ // description:
+ // Getting the style value uses the computed style for the node, so the value
+ // will be a calculated value, not just the immediate node.style value.
+ // Also when getting values, use specific style names,
+ // like "borderBottomWidth" instead of "border" since compound values like
+ // "border" are not necessarily reflected as expected.
+ // If you want to get node dimensions, use `dojo.marginBox()`,
+ // `dojo.contentBox()` or `dojo.position()`.
+ // node: DOMNode|String
+ // id or reference to node to get style for
+ // name: String?
+ // the style property to get
+ // example:
+ // Passing only an ID or node returns the computed style object of
+ // the node:
+ // | dojo.getStyle("thinger");
+ // example:
+ // Passing a node and a style property returns the current
+ // normalized, computed value for that property:
+ // | dojo.getStyle("thinger", "opacity"); // 1 by default
+ };
+ =====*/
+
+ /*=====
+ dojo.setStyle = function(node, name, value){
+ // summary:
+ // Sets styles on a node.
+ // node: DOMNode|String
+ // id or reference to node to set style for
+ // name: String|Object
+ // the style property to set in DOM-accessor format
+ // ("borderWidth", not "border-width") or an object with key/value
+ // pairs suitable for setting each property.
+ // value: String?
+ // If passed, sets value on the node for style, handling
+ // cross-browser concerns. When setting a pixel value,
+ // be sure to include "px" in the value. For instance, top: "200px".
+ // Otherwise, in some cases, some browsers will not apply the style.
+ //
+ // example:
+ // Passing a node, a style property, and a value changes the
+ // current display of the node and returns the new computed value
+ // | dojo.setStyle("thinger", "opacity", 0.5); // == 0.5
+ //
+ // example:
+ // Passing a node, an object-style style property sets each of the values in turn and returns the computed style object of the node:
+ // | dojo.setStyle("thinger", {
+ // | "opacity": 0.5,
+ // | "border": "3px solid black",
+ // | "height": "300px"
+ // | });
+ //
+ // example:
+ // When the CSS style property is hyphenated, the JavaScript property is camelCased.
+ // font-size becomes fontSize, and so on.
+ // | dojo.setStyle("thinger",{
+ // | fontSize:"14pt",
+ // | letterSpacing:"1.2em"
+ // | });
+ //
+ // example:
+ // dojo.NodeList implements .style() using the same syntax, omitting the "node" parameter, calling
+ // dojo.style() on every element of the list. See: `dojo.query()` and `dojo.NodeList()`
+ // | dojo.query(".someClassName").style("visibility","hidden");
+ // | // or
+ // | dojo.query("#baz > div").style({
+ // | opacity:0.75,
+ // | fontSize:"13pt"
+ // | });
+ };
+ =====*/
+
+ // Although we normally eschew argument validation at this
+ // level, here we test argument 'node' for (duck)type,
+ // by testing nodeType, ecause 'document' is the 'parentNode' of 'body'
+ // it is frequently sent to this function even
+ // though it is not Element.
+ var getComputedStyle, style = {};
+ if(has("webkit")){
+ getComputedStyle = function(/*DomNode*/node){
+ var s;
+ if(node.nodeType == 1){
+ var dv = node.ownerDocument.defaultView;
+ s = dv.getComputedStyle(node, null);
+ if(!s && node.style){
+ node.style.display = "";
+ s = dv.getComputedStyle(node, null);
+ }
+ }
+ return s || {};
+ };
+ }else if(has("ie") && (has("ie") < 9 || has("quirks"))){
+ getComputedStyle = function(node){
+ // IE (as of 7) doesn't expose Element like sane browsers
+ return node.nodeType == 1 /* ELEMENT_NODE*/ ? node.currentStyle : {};
+ };
+ }else{
+ getComputedStyle = function(node){
+ return node.nodeType == 1 ?
+ node.ownerDocument.defaultView.getComputedStyle(node, null) : {};
+ };
+ }
+ style.getComputedStyle = getComputedStyle;
+
+ var toPixel;
+ if(!has("ie")){
+ toPixel = function(element, value){
+ // style values can be floats, client code may want
+ // to round for integer pixels.
+ return parseFloat(value) || 0;
+ };
+ }else{
+ toPixel = function(element, avalue){
+ if(!avalue){ return 0; }
+ // on IE7, medium is usually 4 pixels
+ if(avalue == "medium"){ return 4; }
+ // style values can be floats, client code may
+ // want to round this value for integer pixels.
+ if(avalue.slice && avalue.slice(-2) == 'px'){ return parseFloat(avalue); }
+ var s = element.style, rs = element.runtimeStyle, cs = element.currentStyle,
+ sLeft = s.left, rsLeft = rs.left;
+ rs.left = cs.left;
+ try{
+ // 'avalue' may be incompatible with style.left, which can cause IE to throw
+ // this has been observed for border widths using "thin", "medium", "thick" constants
+ // those particular constants could be trapped by a lookup
+ // but perhaps there are more
+ s.left = avalue;
+ avalue = s.pixelLeft;
+ }catch(e){
+ avalue = 0;
+ }
+ s.left = sLeft;
+ rs.left = rsLeft;
+ return avalue;
+ }
+ }
+ style.toPixelValue = toPixel;
+
+ // FIXME: there opacity quirks on FF that we haven't ported over. Hrm.
+
+ var astr = "DXImageTransform.Microsoft.Alpha";
+ var af = function(n, f){
+ try{
+ return n.filters.item(astr);
+ }catch(e){
+ return f ? {} : null;
+ }
+ };
+
+ var _getOpacity =
+ has("ie") < 9 || (has("ie") && has("quirks")) ? function(node){
+ try{
+ return af(node).Opacity / 100; // Number
+ }catch(e){
+ return 1; // Number
+ }
+ } :
+ function(node){
+ return getComputedStyle(node).opacity;
+ };
+
+ var _setOpacity =
+ has("ie") < 9 || (has("ie") && has("quirks")) ? function(/*DomNode*/node, /*Number*/opacity){
+ var ov = opacity * 100, opaque = opacity == 1;
+ node.style.zoom = opaque ? "" : 1;
+
+ if(!af(node)){
+ if(opaque){
+ return opacity;
+ }
+ node.style.filter += " progid:" + astr + "(Opacity=" + ov + ")";
+ }else{
+ af(node, 1).Opacity = ov;
+ }
+
+ // on IE7 Alpha(Filter opacity=100) makes text look fuzzy so disable it altogether (bug #2661),
+ //but still update the opacity value so we can get a correct reading if it is read later.
+ af(node, 1).Enabled = !opaque;
+
+ if(node.tagName.toLowerCase() == "tr"){
+ for(var td = node.firstChild; td; td = td.nextSibling){
+ if(td.tagName.toLowerCase() == "td"){
+ _setOpacity(td, opacity);
+ }
+ }
+ }
+ return opacity;
+ } :
+ function(node, opacity){
+ return node.style.opacity = opacity;
+ };
+
+ var _pixelNamesCache = {
+ left: true, top: true
+ };
+ var _pixelRegExp = /margin|padding|width|height|max|min|offset/; // |border
+ function _toStyleValue(node, type, value){
+ //TODO: should we really be doing string case conversion here? Should we cache it? Need to profile!
+ type = type.toLowerCase();
+ if(has("ie")){
+ if(value == "auto"){
+ if(type == "height"){ return node.offsetHeight; }
+ if(type == "width"){ return node.offsetWidth; }
+ }
+ if(type == "fontweight"){
+ switch(value){
+ case 700: return "bold";
+ case 400:
+ default: return "normal";
+ }
+ }
+ }
+ if(!(type in _pixelNamesCache)){
+ _pixelNamesCache[type] = _pixelRegExp.test(type);
+ }
+ return _pixelNamesCache[type] ? toPixel(node, value) : value;
+ }
+
+ var _floatStyle = has("ie") ? "styleFloat" : "cssFloat",
+ _floatAliases = {"cssFloat": _floatStyle, "styleFloat": _floatStyle, "float": _floatStyle};
+
+ // public API
+
+ style.get = function getStyle(/*DOMNode|String*/ node, /*String?*/ name){
+ var n = dom.byId(node), l = arguments.length, op = (name == "opacity");
+ if(l == 2 && op){
+ return _getOpacity(n);
+ }
+ name = _floatAliases[name] || name;
+ var s = style.getComputedStyle(n);
+ return (l == 1) ? s : _toStyleValue(n, name, s[name] || n.style[name]); /* CSS2Properties||String||Number */
+ };
+
+ style.set = function setStyle(/*DOMNode|String*/ node, /*String|Object*/ name, /*String?*/ value){
+ var n = dom.byId(node), l = arguments.length, op = (name == "opacity");
+ name = _floatAliases[name] || name;
+ if(l == 3){
+ return op ? _setOpacity(n, value) : n.style[name] = value; // Number
+ }
+ for(var x in name){
+ style.set(node, x, name[x]);
+ }
+ return style.getComputedStyle(n);
+ };
+
+ return style;
+});
+
+},
+'dojo/dom-geometry':function(){
+define(["./_base/sniff", "./_base/window","./dom", "./dom-style"],
+ function(has, win, dom, style){
+ // module:
+ // dojo/dom-geometry
+ // summary:
+ // This module defines the core dojo DOM geometry API.
+
+ var geom = {}; // the result object
+
+ // Box functions will assume this model.
+ // On IE/Opera, BORDER_BOX will be set if the primary document is in quirks mode.
+ // Can be set to change behavior of box setters.
+
+ // can be either:
+ // "border-box"
+ // "content-box" (default)
+ geom.boxModel = "content-box";
+
+ // We punt per-node box mode testing completely.
+ // If anybody cares, we can provide an additional (optional) unit
+ // that overrides existing code to include per-node box sensitivity.
+
+ // Opera documentation claims that Opera 9 uses border-box in BackCompat mode.
+ // but experiments (Opera 9.10.8679 on Windows Vista) indicate that it actually continues to use content-box.
+ // IIRC, earlier versions of Opera did in fact use border-box.
+ // Opera guys, this is really confusing. Opera being broken in quirks mode is not our fault.
+
+ if(has("ie") /*|| has("opera")*/){
+ // client code may have to adjust if compatMode varies across iframes
+ geom.boxModel = document.compatMode == "BackCompat" ? "border-box" : "content-box";
+ }
+
+ // =============================
+ // Box Functions
+ // =============================
+
+ /*=====
+ dojo.getPadExtents = function(node, computedStyle){
+ // summary:
+ // Returns object with special values specifically useful for node
+ // fitting.
+ // description:
+ // Returns an object with `w`, `h`, `l`, `t` properties:
+ // | l/t/r/b = left/top/right/bottom padding (respectively)
+ // | w = the total of the left and right padding
+ // | h = the total of the top and bottom padding
+ // If 'node' has position, l/t forms the origin for child nodes.
+ // The w/h are used for calculating boxes.
+ // Normally application code will not need to invoke this
+ // directly, and will use the ...box... functions instead.
+ // node: DOMNode
+ // computedStyle: Object?
+ // This parameter accepts computed styles object.
+ // If this parameter is omitted, the functions will call
+ // dojo.getComputedStyle to get one. It is a better way, calling
+ // dojo.computedStyle once, and then pass the reference to this
+ // computedStyle parameter. Wherever possible, reuse the returned
+ // object of dojo.getComputedStyle.
+
+
+ };
+ =====*/
+
+ /*=====
+ dojo._getPadExtents = function(node, computedStyle){
+ // summary:
+ // Existing alias for `dojo.getPadExtents`. Deprecated, will be removed in 2.0.
+ };
+ =====*/
+
+ /*=====
+ dojo.getBorderExtents = function(node, computedStyle){
+ // summary:
+ // returns an object with properties useful for noting the border
+ // dimensions.
+ // description:
+ // * l/t/r/b = the sum of left/top/right/bottom border (respectively)
+ // * w = the sum of the left and right border
+ // * h = the sum of the top and bottom border
+ //
+ // The w/h are used for calculating boxes.
+ // Normally application code will not need to invoke this
+ // directly, and will use the ...box... functions instead.
+ // node: DOMNode
+ // computedStyle: Object?
+ // This parameter accepts computed styles object.
+ // If this parameter is omitted, the functions will call
+ // dojo.getComputedStyle to get one. It is a better way, calling
+ // dojo.computedStyle once, and then pass the reference to this
+ // computedStyle parameter. Wherever possible, reuse the returned
+ // object of dojo.getComputedStyle.
+
+
+ };
+ =====*/
+
+ /*=====
+ dojo._getBorderExtents = function(node, computedStyle){
+ // summary:
+ // Existing alias for `dojo.getBorderExtents`. Deprecated, will be removed in 2.0.
+ };
+ =====*/
+
+ /*=====
+ dojo.getPadBorderExtents = function(node, computedStyle){
+ // summary:
+ // Returns object with properties useful for box fitting with
+ // regards to padding.
+ // description:
+ // * l/t/r/b = the sum of left/top/right/bottom padding and left/top/right/bottom border (respectively)
+ // * w = the sum of the left and right padding and border
+ // * h = the sum of the top and bottom padding and border
+ //
+ // The w/h are used for calculating boxes.
+ // Normally application code will not need to invoke this
+ // directly, and will use the ...box... functions instead.
+ // node: DOMNode
+ // computedStyle: Object?
+ // This parameter accepts computed styles object.
+ // If this parameter is omitted, the functions will call
+ // dojo.getComputedStyle to get one. It is a better way, calling
+ // dojo.computedStyle once, and then pass the reference to this
+ // computedStyle parameter. Wherever possible, reuse the returned
+ // object of dojo.getComputedStyle.
+
+
+ };
+ =====*/
+
+ /*=====
+ dojo._getPadBorderExtents = function(node, computedStyle){
+ // summary:
+ // Existing alias for `dojo.getPadBorderExtents`. Deprecated, will be removed in 2.0.
+ };
+ =====*/
+
+ /*=====
+ dojo.getMarginExtents = function(node, computedStyle){
+ // summary:
+ // returns object with properties useful for box fitting with
+ // regards to box margins (i.e., the outer-box).
+ //
+ // * l/t = marginLeft, marginTop, respectively
+ // * w = total width, margin inclusive
+ // * h = total height, margin inclusive
+ //
+ // The w/h are used for calculating boxes.
+ // Normally application code will not need to invoke this
+ // directly, and will use the ...box... functions instead.
+ // node: DOMNode
+ // computedStyle: Object?
+ // This parameter accepts computed styles object.
+ // If this parameter is omitted, the functions will call
+ // dojo.getComputedStyle to get one. It is a better way, calling
+ // dojo.computedStyle once, and then pass the reference to this
+ // computedStyle parameter. Wherever possible, reuse the returned
+ // object of dojo.getComputedStyle.
+ };
+ =====*/
+
+ /*=====
+ dojo._getMarginExtents = function(node, computedStyle){
+ // summary:
+ // Existing alias for `dojo.getMarginExtents`. Deprecated, will be removed in 2.0.
+ };
+ =====*/
+
+ /*=====
+ dojo.getMarginSize = function(node, computedStyle){
+ // summary:
+ // returns an object that encodes the width and height of
+ // the node's margin box
+ // node: DOMNode|String
+ // computedStyle: Object?
+ // This parameter accepts computed styles object.
+ // If this parameter is omitted, the functions will call
+ // dojo.getComputedStyle to get one. It is a better way, calling
+ // dojo.computedStyle once, and then pass the reference to this
+ // computedStyle parameter. Wherever possible, reuse the returned
+ // object of dojo.getComputedStyle.
+ };
+ =====*/
+
+ /*=====
+ dojo._getMarginSize = function(node, computedStyle){
+ // summary:
+ // Existing alias for `dojo.getMarginSize`. Deprecated, will be removed in 2.0.
+ };
+ =====*/
+
+ /*=====
+ dojo.getMarginBox = function(node, computedStyle){
+ // summary:
+ // returns an object that encodes the width, height, left and top
+ // positions of the node's margin box.
+ // node: DOMNode
+ // computedStyle: Object?
+ // This parameter accepts computed styles object.
+ // If this parameter is omitted, the functions will call
+ // dojo.getComputedStyle to get one. It is a better way, calling
+ // dojo.computedStyle once, and then pass the reference to this
+ // computedStyle parameter. Wherever possible, reuse the returned
+ // object of dojo.getComputedStyle.
+ };
+ =====*/
+
+ /*=====
+ dojo._getMarginBox = function(node, computedStyle){
+ // summary:
+ // Existing alias for `dojo.getMarginBox`. Deprecated, will be removed in 2.0.
+ };
+ =====*/
+
+ /*=====
+ dojo.setMarginBox = function(node, box, computedStyle){
+ // summary:
+ // sets the size of the node's margin box and placement
+ // (left/top), irrespective of box model. Think of it as a
+ // passthrough to setBox that handles box-model vagaries for
+ // you.
+ // node: DOMNode
+ // box: Object
+ // hash with optional "l", "t", "w", and "h" properties for "left", "right", "width", and "height"
+ // respectively. All specified properties should have numeric values in whole pixels.
+ // computedStyle: Object?
+ // This parameter accepts computed styles object.
+ // If this parameter is omitted, the functions will call
+ // dojo.getComputedStyle to get one. It is a better way, calling
+ // dojo.computedStyle once, and then pass the reference to this
+ // computedStyle parameter. Wherever possible, reuse the returned
+ // object of dojo.getComputedStyle.
+ };
+ =====*/
+
+ /*=====
+ dojo.getContentBox = function(node, computedStyle){
+ // summary:
+ // Returns an object that encodes the width, height, left and top
+ // positions of the node's content box, irrespective of the
+ // current box model.
+ // node: DOMNode
+ // computedStyle: Object?
+ // This parameter accepts computed styles object.
+ // If this parameter is omitted, the functions will call
+ // dojo.getComputedStyle to get one. It is a better way, calling
+ // dojo.computedStyle once, and then pass the reference to this
+ // computedStyle parameter. Wherever possible, reuse the returned
+ // object of dojo.getComputedStyle.
+ };
+ =====*/
+
+ /*=====
+ dojo._getContentBox = function(node, computedStyle){
+ // summary:
+ // Existing alias for `dojo.getContentBox`. Deprecated, will be removed in 2.0.
+ };
+ =====*/
+
+ /*=====
+ dojo.setContentSize = function(node, box, computedStyle){
+ // summary:
+ // Sets the size of the node's contents, irrespective of margins,
+ // padding, or borders.
+ // node: DOMNode
+ // box: Object
+ // hash with optional "w", and "h" properties for "width", and "height"
+ // respectively. All specified properties should have numeric values in whole pixels.
+ // computedStyle: Object?
+ // This parameter accepts computed styles object.
+ // If this parameter is omitted, the functions will call
+ // dojo.getComputedStyle to get one. It is a better way, calling
+ // dojo.computedStyle once, and then pass the reference to this
+ // computedStyle parameter. Wherever possible, reuse the returned
+ // object of dojo.getComputedStyle.
+ };
+ =====*/
+
+ /*=====
+ dojo.isBodyLtr = function(){
+ // summary:
+ // Returns true if the current language is left-to-right, and false otherwise.
+ // returns: Boolean
+ };
+ =====*/
+
+ /*=====
+ dojo._isBodyLtr = function(){
+ // summary:
+ // Existing alias for `dojo.isBodyLtr`. Deprecated, will be removed in 2.0.
+ };
+ =====*/
+
+ /*=====
+ dojo.docScroll = function(){
+ // summary:
+ // Returns an object with {node, x, y} with corresponding offsets.
+ // returns: Object
+ };
+ =====*/
+
+ /*=====
+ dojo._docScroll = function(){
+ // summary:
+ // Existing alias for `dojo.docScroll`. Deprecated, will be removed in 2.0.
+ };
+ =====*/
+
+ /*=====
+ dojo.getIeDocumentElementOffset = function(){
+ // summary:
+ // returns the offset in x and y from the document body to the
+ // visual edge of the page for IE
+ // description:
+ // The following values in IE contain an offset:
+ // | event.clientX
+ // | event.clientY
+ // | node.getBoundingClientRect().left
+ // | node.getBoundingClientRect().top
+ // But other position related values do not contain this offset,
+ // such as node.offsetLeft, node.offsetTop, node.style.left and
+ // node.style.top. The offset is always (2, 2) in LTR direction.
+ // When the body is in RTL direction, the offset counts the width
+ // of left scroll bar's width. This function computes the actual
+ // offset.
+ };
+ =====*/
+
+ /*=====
+ dojo._getIeDocumentElementOffset = function(){
+ // summary:
+ // Existing alias for `dojo.getIeDocumentElementOffset`. Deprecated, will be removed in 2.0.
+ };
+ =====*/
+
+ /*=====
+ dojo.fixIeBiDiScrollLeft = function(scrollLeft){
+ // summary:
+ // In RTL direction, scrollLeft should be a negative value, but IE
+ // returns a positive one. All codes using documentElement.scrollLeft
+ // must call this function to fix this error, otherwise the position
+ // will offset to right when there is a horizontal scrollbar.
+ // scrollLeft: NUmber
+ // returns: Number
+ };
+ =====*/
+
+ /*=====
+ dojo._fixIeBiDiScrollLeft = function(scrollLeft){
+ // summary:
+ // Existing alias for `dojo.fixIeBiDiScrollLeft`. Deprecated, will be removed in 2.0.
+ };
+ =====*/
+
+ /*=====
+ dojo.position = function(node, includeScroll){
+ // summary:
+ // Gets the position and size of the passed element relative to
+ // the viewport (if includeScroll==false), or relative to the
+ // document root (if includeScroll==true).
+ //
+ // description:
+ // Returns an object of the form:
+ // { x: 100, y: 300, w: 20, h: 15 }
+ // If includeScroll==true, the x and y values will include any
+ // document offsets that may affect the position relative to the
+ // viewport.
+ // Uses the border-box model (inclusive of border and padding but
+ // not margin). Does not act as a setter.
+ // node: DOMNode|String
+ // includeScroll: Boolean?
+ // returns: Object
+ };
+ =====*/
+
+ geom.getPadExtents = function getPadExtents(/*DomNode*/node, /*Object*/computedStyle){
+ node = dom.byId(node);
+ var s = computedStyle || style.getComputedStyle(node), px = style.toPixelValue,
+ l = px(node, s.paddingLeft), t = px(node, s.paddingTop), r = px(node, s.paddingRight), b = px(node, s.paddingBottom);
+ return {l: l, t: t, r: r, b: b, w: l + r, h: t + b};
+ };
+
+ var none = "none";
+
+ geom.getBorderExtents = function getBorderExtents(/*DomNode*/node, /*Object*/computedStyle){
+ node = dom.byId(node);
+ var px = style.toPixelValue, s = computedStyle || style.getComputedStyle(node),
+ l = s.borderLeftStyle != none ? px(node, s.borderLeftWidth) : 0,
+ t = s.borderTopStyle != none ? px(node, s.borderTopWidth) : 0,
+ r = s.borderRightStyle != none ? px(node, s.borderRightWidth) : 0,
+ b = s.borderBottomStyle != none ? px(node, s.borderBottomWidth) : 0;
+ return {l: l, t: t, r: r, b: b, w: l + r, h: t + b};
+ };
+
+ geom.getPadBorderExtents = function getPadBorderExtents(/*DomNode*/node, /*Object*/computedStyle){
+ node = dom.byId(node);
+ var s = computedStyle || style.getComputedStyle(node),
+ p = geom.getPadExtents(node, s),
+ b = geom.getBorderExtents(node, s);
+ return {
+ l: p.l + b.l,
+ t: p.t + b.t,
+ r: p.r + b.r,
+ b: p.b + b.b,
+ w: p.w + b.w,
+ h: p.h + b.h
+ };
+ };
+
+ geom.getMarginExtents = function getMarginExtents(node, computedStyle){
+ node = dom.byId(node);
+ var s = computedStyle || style.getComputedStyle(node), px = style.toPixelValue,
+ l = px(node, s.marginLeft), t = px(node, s.marginTop), r = px(node, s.marginRight), b = px(node, s.marginBottom);
+ if(has("webkit") && (s.position != "absolute")){
+ // FIXME: Safari's version of the computed right margin
+ // is the space between our right edge and the right edge
+ // of our offsetParent.
+ // What we are looking for is the actual margin value as
+ // determined by CSS.
+ // Hack solution is to assume left/right margins are the same.
+ r = l;
+ }
+ return {l: l, t: t, r: r, b: b, w: l + r, h: t + b};
+ };
+
+ // Box getters work in any box context because offsetWidth/clientWidth
+ // are invariant wrt box context
+ //
+ // They do *not* work for display: inline objects that have padding styles
+ // because the user agent ignores padding (it's bogus styling in any case)
+ //
+ // Be careful with IMGs because they are inline or block depending on
+ // browser and browser mode.
+
+ // Although it would be easier to read, there are not separate versions of
+ // _getMarginBox for each browser because:
+ // 1. the branching is not expensive
+ // 2. factoring the shared code wastes cycles (function call overhead)
+ // 3. duplicating the shared code wastes bytes
+
+ geom.getMarginBox = function getMarginBox(/*DomNode*/node, /*Object*/computedStyle){
+ // summary:
+ // returns an object that encodes the width, height, left and top
+ // positions of the node's margin box.
+ node = dom.byId(node);
+ var s = computedStyle || style.getComputedStyle(node), me = geom.getMarginExtents(node, s),
+ l = node.offsetLeft - me.l, t = node.offsetTop - me.t, p = node.parentNode, px = style.toPixelValue, pcs;
+ if(has("mozilla")){
+ // Mozilla:
+ // If offsetParent has a computed overflow != visible, the offsetLeft is decreased
+ // by the parent's border.
+ // We don't want to compute the parent's style, so instead we examine node's
+ // computed left/top which is more stable.
+ var sl = parseFloat(s.left), st = parseFloat(s.top);
+ if(!isNaN(sl) && !isNaN(st)){
+ l = sl, t = st;
+ }else{
+ // If child's computed left/top are not parseable as a number (e.g. "auto"), we
+ // have no choice but to examine the parent's computed style.
+ if(p && p.style){
+ pcs = style.getComputedStyle(p);
+ if(pcs.overflow != "visible"){
+ l += pcs.borderLeftStyle != none ? px(node, pcs.borderLeftWidth) : 0;
+ t += pcs.borderTopStyle != none ? px(node, pcs.borderTopWidth) : 0;
+ }
+ }
+ }
+ }else if(has("opera") || (has("ie") == 8 && !has("quirks"))){
+ // On Opera and IE 8, offsetLeft/Top includes the parent's border
+ if(p){
+ pcs = style.getComputedStyle(p);
+ l -= pcs.borderLeftStyle != none ? px(node, pcs.borderLeftWidth) : 0;
+ t -= pcs.borderTopStyle != none ? px(node, pcs.borderTopWidth) : 0;
+ }
+ }
+ return {l: l, t: t, w: node.offsetWidth + me.w, h: node.offsetHeight + me.h};
+ };
+
+ geom.getContentBox = function getContentBox(node, computedStyle){
+ // clientWidth/Height are important since the automatically account for scrollbars
+ // fallback to offsetWidth/Height for special cases (see #3378)
+ node = dom.byId(node);
+ var s = computedStyle || style.getComputedStyle(node), w = node.clientWidth, h,
+ pe = geom.getPadExtents(node, s), be = geom.getBorderExtents(node, s);
+ if(!w){
+ w = node.offsetWidth;
+ h = node.offsetHeight;
+ }else{
+ h = node.clientHeight;
+ be.w = be.h = 0;
+ }
+ // On Opera, offsetLeft includes the parent's border
+ if(has("opera")){
+ pe.l += be.l;
+ pe.t += be.t;
+ }
+ return {l: pe.l, t: pe.t, w: w - pe.w - be.w, h: h - pe.h - be.h};
+ };
+
+ // Box setters depend on box context because interpretation of width/height styles
+ // vary wrt box context.
+ //
+ // The value of dojo.boxModel is used to determine box context.
+ // dojo.boxModel can be set directly to change behavior.
+ //
+ // Beware of display: inline objects that have padding styles
+ // because the user agent ignores padding (it's a bogus setup anyway)
+ //
+ // Be careful with IMGs because they are inline or block depending on
+ // browser and browser mode.
+ //
+ // Elements other than DIV may have special quirks, like built-in
+ // margins or padding, or values not detectable via computedStyle.
+ // In particular, margins on TABLE do not seems to appear
+ // at all in computedStyle on Mozilla.
+
+ function setBox(/*DomNode*/node, /*Number?*/l, /*Number?*/t, /*Number?*/w, /*Number?*/h, /*String?*/u){
+ // summary:
+ // sets width/height/left/top in the current (native) box-model
+ // dimensions. Uses the unit passed in u.
+ // node:
+ // DOM Node reference. Id string not supported for performance
+ // reasons.
+ // l:
+ // left offset from parent.
+ // t:
+ // top offset from parent.
+ // w:
+ // width in current box model.
+ // h:
+ // width in current box model.
+ // u:
+ // unit measure to use for other measures. Defaults to "px".
+ u = u || "px";
+ var s = node.style;
+ if(!isNaN(l)){
+ s.left = l + u;
+ }
+ if(!isNaN(t)){
+ s.top = t + u;
+ }
+ if(w >= 0){
+ s.width = w + u;
+ }
+ if(h >= 0){
+ s.height = h + u;
+ }
+ }
+
+ function isButtonTag(/*DomNode*/node){
+ // summary:
+ // True if the node is BUTTON or INPUT.type="button".
+ return node.tagName.toLowerCase() == "button" ||
+ node.tagName.toLowerCase() == "input" && (node.getAttribute("type") || "").toLowerCase() == "button"; // boolean
+ }
+
+ function usesBorderBox(/*DomNode*/node){
+ // summary:
+ // True if the node uses border-box layout.
+
+ // We could test the computed style of node to see if a particular box
+ // has been specified, but there are details and we choose not to bother.
+
+ // TABLE and BUTTON (and INPUT type=button) are always border-box by default.
+ // If you have assigned a different box to either one via CSS then
+ // box functions will break.
+
+ return geom.boxModel == "border-box" || node.tagName.toLowerCase() == "table" || isButtonTag(node); // boolean
+ }
+
+ geom.setContentSize = function setContentSize(/*DomNode*/node, /*Object*/box, /*Object*/computedStyle){
+ // summary:
+ // Sets the size of the node's contents, irrespective of margins,
+ // padding, or borders.
+
+ node = dom.byId(node);
+ var w = box.w, h = box.h;
+ if(usesBorderBox(node)){
+ var pb = geom.getPadBorderExtents(node, computedStyle);
+ if(w >= 0){
+ w += pb.w;
+ }
+ if(h >= 0){
+ h += pb.h;
+ }
+ }
+ setBox(node, NaN, NaN, w, h);
+ };
+
+ var nilExtents = {l: 0, t: 0, w: 0, h: 0};
+
+ geom.setMarginBox = function setMarginBox(/*DomNode*/node, /*Object*/box, /*Object*/computedStyle){
+ node = dom.byId(node);
+ var s = computedStyle || style.getComputedStyle(node), w = box.w, h = box.h,
+ // Some elements have special padding, margin, and box-model settings.
+ // To use box functions you may need to set padding, margin explicitly.
+ // Controlling box-model is harder, in a pinch you might set dojo.boxModel.
+ pb = usesBorderBox(node) ? nilExtents : geom.getPadBorderExtents(node, s),
+ mb = geom.getMarginExtents(node, s);
+ if(has("webkit")){
+ // on Safari (3.1.2), button nodes with no explicit size have a default margin
+ // setting an explicit size eliminates the margin.
+ // We have to swizzle the width to get correct margin reading.
+ if(isButtonTag(node)){
+ var ns = node.style;
+ if(w >= 0 && !ns.width){
+ ns.width = "4px";
+ }
+ if(h >= 0 && !ns.height){
+ ns.height = "4px";
+ }
+ }
+ }
+ if(w >= 0){
+ w = Math.max(w - pb.w - mb.w, 0);
+ }
+ if(h >= 0){
+ h = Math.max(h - pb.h - mb.h, 0);
+ }
+ setBox(node, box.l, box.t, w, h);
+ };
+
+ // =============================
+ // Positioning
+ // =============================
+
+ geom.isBodyLtr = function isBodyLtr(){
+ return (win.body().dir || win.doc.documentElement.dir || "ltr").toLowerCase() == "ltr"; // Boolean
+ };
+
+ geom.docScroll = function docScroll(){
+ var node = win.doc.parentWindow || win.doc.defaultView; // use UI window, not dojo.global window
+ return "pageXOffset" in node ? {x: node.pageXOffset, y: node.pageYOffset } :
+ (node = has("quirks") ? win.body() : win.doc.documentElement,
+ {x: geom.fixIeBiDiScrollLeft(node.scrollLeft || 0), y: node.scrollTop || 0 });
+ };
+
+ geom.getIeDocumentElementOffset = function getIeDocumentElementOffset(){
+ //NOTE: assumes we're being called in an IE browser
+
+ var de = win.doc.documentElement; // only deal with HTML element here, position() handles body/quirks
+
+ if(has("ie") < 8){
+ var r = de.getBoundingClientRect(), // works well for IE6+
+ l = r.left, t = r.top;
+ if(has("ie") < 7){
+ l += de.clientLeft; // scrollbar size in strict/RTL, or,
+ t += de.clientTop; // HTML border size in strict
+ }
+ return {
+ x: l < 0 ? 0 : l, // FRAME element border size can lead to inaccurate negative values
+ y: t < 0 ? 0 : t
+ };
+ }else{
+ return {
+ x: 0,
+ y: 0
+ };
+ }
+ };
+
+ geom.fixIeBiDiScrollLeft = function fixIeBiDiScrollLeft(/*Integer*/ scrollLeft){
+ // In RTL direction, scrollLeft should be a negative value, but IE
+ // returns a positive one. All codes using documentElement.scrollLeft
+ // must call this function to fix this error, otherwise the position
+ // will offset to right when there is a horizontal scrollbar.
+
+ var ie = has("ie");
+ if(ie && !geom.isBodyLtr()){
+ var qk = has("quirks"),
+ de = qk ? win.body() : win.doc.documentElement;
+ if(ie == 6 && !qk && win.global.frameElement && de.scrollHeight > de.clientHeight){
+ scrollLeft += de.clientLeft; // workaround ie6+strict+rtl+iframe+vertical-scrollbar bug where clientWidth is too small by clientLeft pixels
+ }
+ return (ie < 8 || qk) ? (scrollLeft + de.clientWidth - de.scrollWidth) : -scrollLeft; // Integer
+ }
+ return scrollLeft; // Integer
+ };
+
+ geom.position = function(/*DomNode*/node, /*Boolean?*/includeScroll){
+ node = dom.byId(node);
+ var db = win.body(),
+ dh = db.parentNode,
+ ret = node.getBoundingClientRect();
+ ret = {x: ret.left, y: ret.top, w: ret.right - ret.left, h: ret.bottom - ret.top};
+ if(has("ie")){
+ // On IE there's a 2px offset that we need to adjust for, see dojo.getIeDocumentElementOffset()
+ var offset = geom.getIeDocumentElementOffset();
+
+ // fixes the position in IE, quirks mode
+ ret.x -= offset.x + (has("quirks") ? db.clientLeft + db.offsetLeft : 0);
+ ret.y -= offset.y + (has("quirks") ? db.clientTop + db.offsetTop : 0);
+ }else if(has("ff") == 3){
+ // In FF3 you have to subtract the document element margins.
+ // Fixed in FF3.5 though.
+ var cs = style.getComputedStyle(dh), px = style.toPixelValue;
+ ret.x -= px(dh, cs.marginLeft) + px(dh, cs.borderLeftWidth);
+ ret.y -= px(dh, cs.marginTop) + px(dh, cs.borderTopWidth);
+ }
+ // account for document scrolling
+ // if offsetParent is used, ret value already includes scroll position
+ // so we may have to actually remove that value if !includeScroll
+ if(includeScroll){
+ var scroll = geom.docScroll();
+ ret.x += scroll.x;
+ ret.y += scroll.y;
+ }
+
+ return ret; // Object
+ };
+
+ // random "private" functions wildly used throughout the toolkit
+
+ geom.getMarginSize = function getMarginSize(/*DomNode*/node, /*Object*/computedStyle){
+ node = dom.byId(node);
+ var me = geom.getMarginExtents(node, computedStyle || style.getComputedStyle(node));
+ var size = node.getBoundingClientRect();
+ return {
+ w: (size.right - size.left) + me.w,
+ h: (size.bottom - size.top) + me.h
+ }
+ };
+
+ geom.normalizeEvent = function(event){
+ // summary:
+ // Normalizes the geometry of a DOM event, normalizing the pageX, pageY,
+ // offsetX, offsetY, layerX, and layerX properties
+ // event: Object
+ if(!("layerX" in event)){
+ event.layerX = event.offsetX;
+ event.layerY = event.offsetY;
+ }
+ if(!has("dom-addeventlistener")){
+ // old IE version
+ // FIXME: scroll position query is duped from dojo.html to
+ // avoid dependency on that entire module. Now that HTML is in
+ // Base, we should convert back to something similar there.
+ var se = event.target;
+ var doc = (se && se.ownerDocument) || document;
+ // DO NOT replace the following to use dojo.body(), in IE, document.documentElement should be used
+ // here rather than document.body
+ var docBody = has("quirks") ? doc.body : doc.documentElement;
+ var offset = geom.getIeDocumentElementOffset();
+ event.pageX = event.clientX + geom.fixIeBiDiScrollLeft(docBody.scrollLeft || 0) - offset.x;
+ event.pageY = event.clientY + (docBody.scrollTop || 0) - offset.y;
+ }
+ };
+
+ // TODO: evaluate separate getters/setters for position and sizes?
+
+ return geom;
+});
+
+},
+'dojo/dom-prop':function(){
+define("dojo/dom-prop", ["exports", "./_base/kernel", "./_base/sniff", "./_base/lang", "./dom", "./dom-style", "./dom-construct", "./_base/connect"],
+ function(exports, dojo, has, lang, dom, style, ctr, conn){
+ // module:
+ // dojo/dom-prop
+ // summary:
+ // This module defines the core dojo DOM properties API.
+ // Indirectly depends on dojo.empty() and dojo.toDom().
+
+ // =============================
+ // Element properties Functions
+ // =============================
+
+ /*=====
+ prop.get = function(node, name){
+ // summary:
+ // Gets a property on an HTML element.
+ // description:
+ // Handles normalized getting of properties on DOM nodes.
+ //
+ // node: DOMNode|String
+ // id or reference to the element to get the property on
+ // name: String
+ // the name of the property to get.
+ // returns:
+ // the value of the requested property or its default value
+ //
+ // example:
+ // | // get the current value of the "foo" property on a node
+ // | dojo.getProp(dojo.byId("nodeId"), "foo");
+ // | // or we can just pass the id:
+ // | dojo.getProp("nodeId", "foo");
+ };
+ =====*/
+
+ /*=====
+ prop.set = function(node, name, value){
+ // summary:
+ // Sets a property on an HTML element.
+ // description:
+ // Handles normalized setting of properties on DOM nodes.
+ //
+ // When passing functions as values, note that they will not be
+ // directly assigned to slots on the node, but rather the default
+ // behavior will be removed and the new behavior will be added
+ // using `dojo.connect()`, meaning that event handler properties
+ // will be normalized and that some caveats with regards to
+ // non-standard behaviors for onsubmit apply. Namely that you
+ // should cancel form submission using `dojo.stopEvent()` on the
+ // passed event object instead of returning a boolean value from
+ // the handler itself.
+ // node: DOMNode|String
+ // id or reference to the element to set the property on
+ // name: String|Object
+ // the name of the property to set, or a hash object to set
+ // multiple properties at once.
+ // value: String?
+ // The value to set for the property
+ // returns:
+ // the DOM node
+ //
+ // example:
+ // | // use prop() to set the tab index
+ // | dojo.setProp("nodeId", "tabIndex", 3);
+ // |
+ //
+ // example:
+ // Set multiple values at once, including event handlers:
+ // | dojo.setProp("formId", {
+ // | "foo": "bar",
+ // | "tabIndex": -1,
+ // | "method": "POST",
+ // | "onsubmit": function(e){
+ // | // stop submitting the form. Note that the IE behavior
+ // | // of returning true or false will have no effect here
+ // | // since our handler is connect()ed to the built-in
+ // | // onsubmit behavior and so we need to use
+ // | // dojo.stopEvent() to ensure that the submission
+ // | // doesn't proceed.
+ // | dojo.stopEvent(e);
+ // |
+ // | // submit the form with Ajax
+ // | dojo.xhrPost({ form: "formId" });
+ // | }
+ // | });
+ //
+ // example:
+ // Style is s special case: Only set with an object hash of styles
+ // | dojo.setProp("someNode",{
+ // | id:"bar",
+ // | style:{
+ // | width:"200px", height:"100px", color:"#000"
+ // | }
+ // | });
+ //
+ // example:
+ // Again, only set style as an object hash of styles:
+ // | var obj = { color:"#fff", backgroundColor:"#000" };
+ // | dojo.setProp("someNode", "style", obj);
+ // |
+ // | // though shorter to use `dojo.style()` in this case:
+ // | dojo.style("someNode", obj);
+ };
+ =====*/
+
+ // helper to connect events
+ var _evtHdlrMap = {}, _ctr = 0, _attrId = dojo._scopeName + "attrid";
+
+ // the next dictionary lists elements with read-only innerHTML on IE
+ var _roInnerHtml = {col: 1, colgroup: 1,
+ // frameset: 1, head: 1, html: 1, style: 1,
+ table: 1, tbody: 1, tfoot: 1, thead: 1, tr: 1, title: 1};
+
+ exports.names = {
+ // properties renamed to avoid clashes with reserved words
+ "class": "className",
+ "for": "htmlFor",
+ // properties written as camelCase
+ tabindex: "tabIndex",
+ readonly: "readOnly",
+ colspan: "colSpan",
+ frameborder: "frameBorder",
+ rowspan: "rowSpan",
+ valuetype: "valueType"
+ };
+
+ exports.get = function getProp(/*DOMNode|String*/node, /*String*/name){
+ node = dom.byId(node);
+ var lc = name.toLowerCase(), propName = exports.names[lc] || name;
+ return node[propName]; // Anything
+ };
+
+ exports.set = function setProp(/*DOMNode|String*/node, /*String|Object*/name, /*String?*/value){
+ node = dom.byId(node);
+ var l = arguments.length;
+ if(l == 2 && typeof name != "string"){ // inline'd type check
+ // the object form of setter: the 2nd argument is a dictionary
+ for(var x in name){
+ exports.set(node, x, name[x]);
+ }
+ return node; // DomNode
+ }
+ var lc = name.toLowerCase(), propName = exports.names[lc] || name;
+ if(propName == "style" && typeof value != "string"){ // inline'd type check
+ // special case: setting a style
+ style.style(node, value);
+ return node; // DomNode
+ }
+ if(propName == "innerHTML"){
+ // special case: assigning HTML
+ if(has("ie") && node.tagName.toLowerCase() in _roInnerHtml){
+ ctr.empty(node);
+ node.appendChild(ctr.toDom(value, node.ownerDocument));
+ }else{
+ node[propName] = value;
+ }
+ return node; // DomNode
+ }
+ if(lang.isFunction(value)){
+ // special case: assigning an event handler
+ // clobber if we can
+ var attrId = node[_attrId];
+ if(!attrId){
+ attrId = _ctr++;
+ node[_attrId] = attrId;
+ }
+ if(!_evtHdlrMap[attrId]){
+ _evtHdlrMap[attrId] = {};
+ }
+ var h = _evtHdlrMap[attrId][propName];
+ if(h){
+ //h.remove();
+ conn.disconnect(h);
+ }else{
+ try{
+ delete node[propName];
+ }catch(e){}
+ }
+ // ensure that event objects are normalized, etc.
+ if(value){
+ //_evtHdlrMap[attrId][propName] = on(node, propName, value);
+ _evtHdlrMap[attrId][propName] = conn.connect(node, propName, value);
+ }else{
+ node[propName] = null;
+ }
+ return node; // DomNode
+ }
+ node[propName] = value;
+ return node; // DomNode
+ };
+});
+
+},
+'dojo/dom-attr':function(){
+define(["exports", "./_base/sniff", "./_base/lang", "./dom", "./dom-style", "./dom-prop"],
+ function(exports, has, lang, dom, style, prop){
+ // module:
+ // dojo/dom-attr
+ // summary:
+ // This module defines the core dojo DOM attributes API.
+
+ // =============================
+ // Element attribute Functions
+ // =============================
+
+ // This module will be obsolete soon. Use dojo.prop instead.
+
+ // dojo.attr() should conform to http://www.w3.org/TR/DOM-Level-2-Core/
+
+ // attribute-related functions (to be obsolete soon)
+
+ /*=====
+ dojo.hasAttr = function(node, name){
+ // summary:
+ // Returns true if the requested attribute is specified on the
+ // given element, and false otherwise.
+ // node: DOMNode|String
+ // id or reference to the element to check
+ // name: String
+ // the name of the attribute
+ // returns: Boolean
+ // true if the requested attribute is specified on the
+ // given element, and false otherwise
+ };
+ =====*/
+
+ /*=====
+ dojo.getAttr = function(node, name){
+ // summary:
+ // Gets an attribute on an HTML element.
+ // description:
+ // Handles normalized getting of attributes on DOM Nodes.
+ // node: DOMNode|String
+ // id or reference to the element to get the attribute on
+ // name: String
+ // the name of the attribute to get.
+ // returns:
+ // the value of the requested attribute or null if that attribute does not have a specified or
+ // default value;
+ //
+ // example:
+ // | // get the current value of the "foo" attribute on a node
+ // | dojo.getAttr(dojo.byId("nodeId"), "foo");
+ // | // or we can just pass the id:
+ // | dojo.getAttr("nodeId", "foo");
+ };
+ =====*/
+
+ /*=====
+ dojo.setAttr = function(node, name, value){
+ // summary:
+ // Sets an attribute on an HTML element.
+ // description:
+ // Handles normalized setting of attributes on DOM Nodes.
+ //
+ // When passing functions as values, note that they will not be
+ // directly assigned to slots on the node, but rather the default
+ // behavior will be removed and the new behavior will be added
+ // using `dojo.connect()`, meaning that event handler properties
+ // will be normalized and that some caveats with regards to
+ // non-standard behaviors for onsubmit apply. Namely that you
+ // should cancel form submission using `dojo.stopEvent()` on the
+ // passed event object instead of returning a boolean value from
+ // the handler itself.
+ // node: DOMNode|String
+ // id or reference to the element to set the attribute on
+ // name: String|Object
+ // the name of the attribute to set, or a hash of key-value pairs to set.
+ // value: String?
+ // the value to set for the attribute, if the name is a string.
+ // returns:
+ // the DOM node
+ //
+ // example:
+ // | // use attr() to set the tab index
+ // | dojo.setAttr("nodeId", "tabIndex", 3);
+ //
+ // example:
+ // Set multiple values at once, including event handlers:
+ // | dojo.setAttr("formId", {
+ // | "foo": "bar",
+ // | "tabIndex": -1,
+ // | "method": "POST",
+ // | "onsubmit": function(e){
+ // | // stop submitting the form. Note that the IE behavior
+ // | // of returning true or false will have no effect here
+ // | // since our handler is connect()ed to the built-in
+ // | // onsubmit behavior and so we need to use
+ // | // dojo.stopEvent() to ensure that the submission
+ // | // doesn't proceed.
+ // | dojo.stopEvent(e);
+ // |
+ // | // submit the form with Ajax
+ // | dojo.xhrPost({ form: "formId" });
+ // | }
+ // | });
+ //
+ // example:
+ // Style is s special case: Only set with an object hash of styles
+ // | dojo.setAttr("someNode",{
+ // | id:"bar",
+ // | style:{
+ // | width:"200px", height:"100px", color:"#000"
+ // | }
+ // | });
+ //
+ // example:
+ // Again, only set style as an object hash of styles:
+ // | var obj = { color:"#fff", backgroundColor:"#000" };
+ // | dojo.setAttr("someNode", "style", obj);
+ // |
+ // | // though shorter to use `dojo.style()` in this case:
+ // | dojo.setStyle("someNode", obj);
+ };
+ =====*/
+
+ /*=====
+ dojo.removeAttr = function(node, name){
+ // summary:
+ // Removes an attribute from an HTML element.
+ // node: DOMNode|String
+ // id or reference to the element to remove the attribute from
+ // name: String
+ // the name of the attribute to remove
+ };
+ =====*/
+
+ /*=====
+ dojo.getNodeProp = function(node, name){
+ // summary:
+ // Returns an effective value of a property or an attribute.
+ // node: DOMNode|String
+ // id or reference to the element to remove the attribute from
+ // name: String
+ // the name of the attribute
+ // returns:
+ // the value of the attribute
+ };
+ =====*/
+
+ var forcePropNames = {
+ innerHTML: 1,
+ className: 1,
+ htmlFor: has("ie"),
+ value: 1
+ },
+ attrNames = {
+ // original attribute names
+ classname: "class",
+ htmlfor: "for",
+ // for IE
+ tabindex: "tabIndex",
+ readonly: "readOnly"
+ };
+
+ function _hasAttr(node, name){
+ var attr = node.getAttributeNode && node.getAttributeNode(name);
+ return attr && attr.specified; // Boolean
+ }
+
+ // There is a difference in the presence of certain properties and their default values
+ // between browsers. For example, on IE "disabled" is present on all elements,
+ // but it is value is "false"; "tabIndex" of
returns 0 by default on IE, yet other browsers
+ // can return -1.
+
+ exports.has = function hasAttr(/*DOMNode|String*/node, /*String*/name){
+ var lc = name.toLowerCase();
+ return forcePropNames[prop.names[lc] || name] || _hasAttr(dom.byId(node), attrNames[lc] || name); // Boolean
+ };
+
+ exports.get = function getAttr(/*DOMNode|String*/node, /*String*/name){
+ node = dom.byId(node);
+ var lc = name.toLowerCase(),
+ propName = prop.names[lc] || name,
+ forceProp = forcePropNames[propName];
+ // should we access this attribute via a property or via getAttribute()?
+ value = node[propName];
+ if(forceProp && typeof value != "undefined"){
+ // node's property
+ return value; // Anything
+ }
+ if(propName != "href" && (typeof value == "boolean" || lang.isFunction(value))){
+ // node's property
+ return value; // Anything
+ }
+ // node's attribute
+ // we need _hasAttr() here to guard against IE returning a default value
+ var attrName = attrNames[lc] || name;
+ return _hasAttr(node, attrName) ? node.getAttribute(attrName) : null; // Anything
+ };
+
+ exports.set = function setAttr(/*DOMNode|String*/node, /*String|Object*/name, /*String?*/value){
+ node = dom.byId(node);
+ if(arguments.length == 2){ // inline'd type check
+ // the object form of setter: the 2nd argument is a dictionary
+ for(var x in name){
+ exports.set(node, x, name[x]);
+ }
+ return node; // DomNode
+ }
+ var lc = name.toLowerCase(),
+ propName = prop.names[lc] || name,
+ forceProp = forcePropNames[propName];
+ if(propName == "style" && typeof value != "string"){ // inline'd type check
+ // special case: setting a style
+ style.set(node, value);
+ return node; // DomNode
+ }
+ if(forceProp || typeof value == "boolean" || lang.isFunction(value)){
+ return prop.set(node, name, value)
+ }
+ // node's attribute
+ node.setAttribute(attrNames[lc] || name, value);
+ return node; // DomNode
+ };
+
+ exports.remove = function removeAttr(/*DOMNode|String*/ node, /*String*/ name){
+ dom.byId(node).removeAttribute(attrNames[name.toLowerCase()] || name);
+ };
+
+ exports.getNodeProp = function getNodeProp(/*DomNode|String*/ node, /*String*/ name){
+ node = dom.byId(node);
+ var lc = name.toLowerCase(), propName = prop.names[lc] || name;
+ if((propName in node) && propName != "href"){
+ // node's property
+ return node[propName]; // Anything
+ }
+ // node's attribute
+ var attrName = attrNames[lc] || name;
+ return _hasAttr(node, attrName) ? node.getAttribute(attrName) : null; // Anything
+ };
+});
+
+},
+'dojo/dom-construct':function(){
+define("dojo/dom-construct", ["exports", "./_base/kernel", "./_base/sniff", "./_base/window", "./dom", "./dom-attr", "./on"],
+ function(exports, dojo, has, win, dom, attr, on){
+ // module:
+ // dojo/dom-construct
+ // summary:
+ // This module defines the core dojo DOM construction API.
+
+ /*=====
+ dojo.toDom = function(frag, doc){
+ // summary:
+ // instantiates an HTML fragment returning the corresponding DOM.
+ // frag: String
+ // the HTML fragment
+ // doc: DocumentNode?
+ // optional document to use when creating DOM nodes, defaults to
+ // dojo.doc if not specified.
+ // returns: DocumentFragment
+ //
+ // example:
+ // Create a table row:
+ // | var tr = dojo.toDom("
First!
");
+ };
+ =====*/
+
+ /*=====
+ dojo._toDom = function(frag, doc){
+ // summary:
+ // Existing alias for `dojo.toDom`. Deprecated, will be removed in 2.0.
+ };
+ =====*/
+
+ /*=====
+ dojo.place = function(node, refNode, position){
+ // summary:
+ // Attempt to insert node into the DOM, choosing from various positioning options.
+ // Returns the first argument resolved to a DOM node.
+ //
+ // node: DOMNode|String
+ // id or node reference, or HTML fragment starting with "<" to place relative to refNode
+ //
+ // refNode: DOMNode|String
+ // id or node reference to use as basis for placement
+ //
+ // position: String|Number?
+ // string noting the position of node relative to refNode or a
+ // number indicating the location in the childNodes collection of refNode.
+ // Accepted string values are:
+ // | * before
+ // | * after
+ // | * replace
+ // | * only
+ // | * first
+ // | * last
+ // "first" and "last" indicate positions as children of refNode, "replace" replaces refNode,
+ // "only" replaces all children. position defaults to "last" if not specified
+ //
+ // returns: DOMNode
+ // Returned values is the first argument resolved to a DOM node.
+ //
+ // .place() is also a method of `dojo.NodeList`, allowing `dojo.query` node lookups.
+ //
+ // example:
+ // Place a node by string id as the last child of another node by string id:
+ // | dojo.place("someNode", "anotherNode");
+ //
+ // example:
+ // Place a node by string id before another node by string id
+ // | dojo.place("someNode", "anotherNode", "before");
+ //
+ // example:
+ // Create a Node, and place it in the body element (last child):
+ // | dojo.place("", dojo.body());
+ //
+ // example:
+ // Put a new LI as the first child of a list by id:
+ // | dojo.place("", "someUl", "first");
+ };
+ =====*/
+
+ /*=====
+ dojo.create = function(tag, attrs, refNode, pos){
+ // summary:
+ // Create an element, allowing for optional attribute decoration
+ // and placement.
+ //
+ // description:
+ // A DOM Element creation function. A shorthand method for creating a node or
+ // a fragment, and allowing for a convenient optional attribute setting step,
+ // as well as an optional DOM placement reference.
+ //|
+ // Attributes are set by passing the optional object through `dojo.setAttr`.
+ // See `dojo.setAttr` for noted caveats and nuances, and API if applicable.
+ //|
+ // Placement is done via `dojo.place`, assuming the new node to be the action
+ // node, passing along the optional reference node and position.
+ //
+ // tag: DOMNode|String
+ // A string of the element to create (eg: "div", "a", "p", "li", "script", "br"),
+ // or an existing DOM node to process.
+ //
+ // attrs: Object
+ // An object-hash of attributes to set on the newly created node.
+ // Can be null, if you don't want to set any attributes/styles.
+ // See: `dojo.setAttr` for a description of available attributes.
+ //
+ // refNode: DOMNode?|String?
+ // Optional reference node. Used by `dojo.place` to place the newly created
+ // node somewhere in the dom relative to refNode. Can be a DomNode reference
+ // or String ID of a node.
+ //
+ // pos: String?
+ // Optional positional reference. Defaults to "last" by way of `dojo.place`,
+ // though can be set to "first","after","before","last", "replace" or "only"
+ // to further control the placement of the new node relative to the refNode.
+ // 'refNode' is required if a 'pos' is specified.
+ //
+ // returns: DOMNode
+ //
+ // example:
+ // Create a DIV:
+ // | var n = dojo.create("div");
+ //
+ // example:
+ // Create a DIV with content:
+ // | var n = dojo.create("div", { innerHTML:"
hi
" });
+ //
+ // example:
+ // Place a new DIV in the BODY, with no attributes set
+ // | var n = dojo.create("div", null, dojo.body());
+ //
+ // example:
+ // Create an UL, and populate it with LI's. Place the list as the first-child of a
+ // node with id="someId":
+ // | var ul = dojo.create("ul", null, "someId", "first");
+ // | var items = ["one", "two", "three", "four"];
+ // | dojo.forEach(items, function(data){
+ // | dojo.create("li", { innerHTML: data }, ul);
+ // | });
+ //
+ // example:
+ // Create an anchor, with an href. Place in BODY:
+ // | dojo.create("a", { href:"foo.html", title:"Goto FOO!" }, dojo.body());
+ //
+ // example:
+ // Create a `dojo.NodeList()` from a new element (for syntatic sugar):
+ // | dojo.query(dojo.create('div'))
+ // | .addClass("newDiv")
+ // | .onclick(function(e){ console.log('clicked', e.target) })
+ // | .place("#someNode"); // redundant, but cleaner.
+ };
+ =====*/
+
+ /*=====
+ dojo.empty = function(node){
+ // summary:
+ // safely removes all children of the node.
+ // node: DOMNode|String
+ // a reference to a DOM node or an id.
+ // example:
+ // Destroy node's children byId:
+ // | dojo.empty("someId");
+ //
+ // example:
+ // Destroy all nodes' children in a list by reference:
+ // | dojo.query(".someNode").forEach(dojo.empty);
+ }
+ =====*/
+
+ /*=====
+ dojo.destroy = function(node){
+ // summary:
+ // Removes a node from its parent, clobbering it and all of its
+ // children.
+ //
+ // description:
+ // Removes a node from its parent, clobbering it and all of its
+ // children. Function only works with DomNodes, and returns nothing.
+ //
+ // node: DOMNode|String
+ // A String ID or DomNode reference of the element to be destroyed
+ //
+ // example:
+ // Destroy a node byId:
+ // | dojo.destroy("someId");
+ //
+ // example:
+ // Destroy all nodes in a list by reference:
+ // | dojo.query(".someNode").forEach(dojo.destroy);
+ };
+ =====*/
+
+ /*=====
+ dojo._destroyElement = function(node){
+ // summary:
+ // Existing alias for `dojo.destroy`. Deprecated, will be removed in 2.0.
+ };
+ =====*/
+
+ // support stuff for dojo.toDom
+ var tagWrap = {
+ option: ["select"],
+ tbody: ["table"],
+ thead: ["table"],
+ tfoot: ["table"],
+ tr: ["table", "tbody"],
+ td: ["table", "tbody", "tr"],
+ th: ["table", "thead", "tr"],
+ legend: ["fieldset"],
+ caption: ["table"],
+ colgroup: ["table"],
+ col: ["table", "colgroup"],
+ li: ["ul"]
+ },
+ reTag = /<\s*([\w\:]+)/,
+ masterNode = {}, masterNum = 0,
+ masterName = "__" + dojo._scopeName + "ToDomId";
+
+ // generate start/end tag strings to use
+ // for the injection for each special tag wrap case.
+ for(var param in tagWrap){
+ if(tagWrap.hasOwnProperty(param)){
+ var tw = tagWrap[param];
+ tw.pre = param == "option" ? '