/*
Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
Available via Academic Free License >= 2.1 OR the modified BSD license.
see: http://dojotoolkit.org/license for details
*/
/*
This is an optimized version of Dojo, built for deployment and not for
development. To get sources and documentation, please visit:
http://dojotoolkit.org
*/
//>>built
require({cache:{
'dojo/uacss':function(){
define(["./dom-geometry", "./_base/lang", "./ready", "./_base/sniff", "./_base/window"],
function(geometry, lang, ready, has, baseWindow){
// module:
// dojo/uacss
// summary:
// Applies pre-set CSS classes to the top-level HTML node, based on:
// - browser (ex: dj_ie)
// - browser version (ex: dj_ie6)
// - box model (ex: dj_contentBox)
// - text direction (ex: dijitRtl)
//
// In addition, browser, browser version, and box model are
// combined with an RTL flag when browser text is RTL. ex: dj_ie-rtl.
var
html = baseWindow.doc.documentElement,
ie = has("ie"),
opera = has("opera"),
maj = Math.floor,
ff = has("ff"),
boxModel = geometry.boxModel.replace(/-/,''),
classes = {
"dj_ie": ie,
"dj_ie6": maj(ie) == 6,
"dj_ie7": maj(ie) == 7,
"dj_ie8": maj(ie) == 8,
"dj_ie9": maj(ie) == 9,
"dj_quirks": has("quirks"),
"dj_iequirks": ie && has("quirks"),
// NOTE: Opera not supported by dijit
"dj_opera": opera,
"dj_khtml": has("khtml"),
"dj_webkit": has("webkit"),
"dj_safari": has("safari"),
"dj_chrome": has("chrome"),
"dj_gecko": has("mozilla"),
"dj_ff3": maj(ff) == 3
}; // no dojo unsupported browsers
classes["dj_" + boxModel] = true;
// apply browser, browser version, and box model class names
var classStr = "";
for(var clz in classes){
if(classes[clz]){
classStr += clz + " ";
}
}
html.className = lang.trim(html.className + " " + classStr);
// If RTL mode, then add dj_rtl flag plus repeat existing classes with -rtl extension.
// We can't run the code below until the
tag has loaded (so we can check for dir=rtl).
// priority is 90 to run ahead of parser priority of 100
ready(90, function(){
if(!geometry.isBodyLtr()){
var rtlClassStr = "dj_rtl dijitRtl " + classStr.replace(/ /g, "-rtl ");
html.className = lang.trim(html.className + " " + rtlClassStr + "dj_rtl dijitRtl " + classStr.replace(/ /g, "-rtl "));
}
});
return has;
});
},
'dojo/text':function(){
define(["./_base/kernel", "require", "./has", "./_base/xhr"], function(dojo, require, has, xhr){
// module:
// dojo/text
// summary:
// This module implements the !dojo/text plugin and the dojo.cache API.
// description:
// We choose to include our own plugin to leverage functionality already contained in dojo
// and thereby reduce the size of the plugin compared to various foreign loader implementations.
// Also, this allows foreign AMD loaders to be used without their plugins.
//
// CAUTION: this module is designed to optionally function synchronously to support the dojo v1.x synchronous
// loader. This feature is outside the scope of the CommonJS plugins specification.
var getText;
if(1){
getText= function(url, sync, load){
xhr("GET", {url:url, sync:!!sync, load:load});
};
}else{
// TODOC: only works for dojo AMD loader
if(require.getText){
getText= require.getText;
}else{
console.error("dojo/text plugin failed to load because loader does not support getText");
}
}
var
theCache= {},
strip= function(text){
//Strips declarations so that external SVG and XML
//documents can be added to a document without worry. Also, if the string
//is an HTML document, only the part inside the body tag is returned.
if(text){
text= text.replace(/^\s*<\?xml(\s)+version=[\'\"](\d)*.(\d)*[\'\"](\s)*\?>/im, "");
var matches= text.match(/]*>\s*([\s\S]+)\s*<\/body>/im);
if(matches){
text= matches[1];
}
}else{
text = "";
}
return text;
},
notFound = {},
pending = {},
result= {
dynamic:
// the dojo/text caches it's own resources because of dojo.cache
true,
normalize:function(id, toAbsMid){
// id is something like (path may be relative):
//
// "path/to/text.html"
// "path/to/text.html!strip"
var parts= id.split("!"),
url= parts[0];
return (/^\./.test(url) ? toAbsMid(url) : url) + (parts[1] ? "!" + parts[1] : "");
},
load:function(id, require, load){
// id is something like (path is always absolute):
//
// "path/to/text.html"
// "path/to/text.html!strip"
var
parts= id.split("!"),
stripFlag= parts.length>1,
absMid= parts[0],
url = require.toUrl(parts[0]),
text = notFound,
finish = function(text){
load(stripFlag ? strip(text) : text);
};
if(absMid in theCache){
text = theCache[absMid];
}else if(url in require.cache){
text = require.cache[url];
}else if(url in theCache){
text = theCache[url];
}
if(text===notFound){
if(pending[url]){
pending[url].push(finish);
}else{
var pendingList = pending[url] = [finish];
getText(url, !require.async, function(text){
theCache[absMid]= theCache[url]= text;
for(var i = 0; i (module, url, value)
// * (object [value]) => (module, value), url defaults to ""
//
// * if module is an object, then it must be convertable to a string
// * (module, url) module + (url ? ("/" + url) : "") must be a legal argument to require.toUrl
// * value may be a string or an object; if an object then may have the properties "value" and/or "sanitize"
var key;
if(typeof module=="string"){
if(/\//.test(module)){
// module is a version 1.7+ resolved path
key = module;
value = url;
}else{
// module is a version 1.6- argument to dojo.moduleUrl
key = require.toUrl(module.replace(/\./g, "/") + (url ? ("/" + url) : ""));
}
}else{
key = module + "";
value = url;
}
var
val = (value != undefined && typeof value != "string") ? value.value : value,
sanitize = value && value.sanitize;
if(typeof val == "string"){
//We have a string, set cache value
theCache[key] = val;
return sanitize ? strip(val) : val;
}else if(val === null){
//Remove cached value
delete theCache[key];
return null;
}else{
//Allow cache values to be empty strings. If key property does
//not exist, fetch it.
if(!(key in theCache)){
getText(key, true, function(text){
theCache[key]= text;
});
}
return sanitize ? strip(theCache[key]) : theCache[key];
}
};
return result;
/*=====
dojo.cache = function(module, url, value){
// summary:
// A getter and setter for storing the string content associated with the
// module and url arguments.
// description:
// If module is a string that contains slashes, then it is interpretted as a fully
// resolved path (typically a result returned by require.toUrl), and url should not be
// provided. This is the preferred signature. If module is a string that does not
// contain slashes, then url must also be provided and module and url are used to
// call `dojo.moduleUrl()` to generate a module URL. This signature is deprecated.
// If value is specified, the cache value for the moduleUrl will be set to
// that value. Otherwise, dojo.cache will fetch the moduleUrl and store it
// in its internal cache and return that cached value for the URL. To clear
// a cache value pass null for value. Since XMLHttpRequest (XHR) is used to fetch the
// the URL contents, only modules on the same domain of the page can use this capability.
// The build system can inline the cache values though, to allow for xdomain hosting.
// module: String||Object
// If a String with slashes, a fully resolved path; if a String without slashes, the
// module name to use for the base part of the URL, similar to module argument
// to `dojo.moduleUrl`. If an Object, something that has a .toString() method that
// generates a valid path for the cache item. For example, a dojo._Url object.
// url: String
// The rest of the path to append to the path derived from the module argument. If
// module is an object, then this second argument should be the "value" argument instead.
// value: String||Object?
// If a String, the value to use in the cache for the module/url combination.
// If an Object, it can have two properties: value and sanitize. The value property
// should be the value to use in the cache, and sanitize can be set to true or false,
// to indicate if XML declarations should be removed from the value and if the HTML
// inside a body tag in the value should be extracted as the real value. The value argument
// or the value property on the value argument are usually only used by the build system
// as it inlines cache content.
// example:
// To ask dojo.cache to fetch content and store it in the cache (the dojo["cache"] style
// of call is used to avoid an issue with the build system erroneously trying to intern
// this example. To get the build system to intern your dojo.cache calls, use the
// "dojo.cache" style of call):
// | //If template.html contains "Hello
" that will be
// | //the value for the text variable.
// | var text = dojo["cache"]("my.module", "template.html");
// example:
// To ask dojo.cache to fetch content and store it in the cache, and sanitize the input
// (the dojo["cache"] style of call is used to avoid an issue with the build system
// erroneously trying to intern this example. To get the build system to intern your
// dojo.cache calls, use the "dojo.cache" style of call):
// | //If template.html contains "Hello
", the
// | //text variable will contain just "Hello
".
// | var text = dojo["cache"]("my.module", "template.html", {sanitize: true});
// example:
// Same example as previous, but demostrates how an object can be passed in as
// the first argument, then the value argument can then be the second argument.
// | //If template.html contains "Hello
", the
// | //text variable will contain just "Hello
".
// | var text = dojo["cache"](new dojo._Url("my/module/template.html"), {sanitize: true});
return val; //String
};
=====*/
});
},
'dijit/hccss':function(){
define("dijit/hccss", [
"require", // require.toUrl
"dojo/_base/config", // config.blankGif
"dojo/dom-class", // domClass.add domConstruct.create domStyle.getComputedStyle
"dojo/dom-construct", // domClass.add domConstruct.create domStyle.getComputedStyle
"dojo/dom-style", // domClass.add domConstruct.create domStyle.getComputedStyle
"dojo/ready", // ready
"dojo/_base/sniff", // has("ie") has("mozilla")
"dojo/_base/window" // win.body
], function(require, config, domClass, domConstruct, domStyle, ready, has, win){
// module:
// dijit/hccss
// summary:
// Test if computer is in high contrast mode, and sets dijit_a11y flag on if it is.
if(has("ie") || has("mozilla")){ // NOTE: checking in Safari messes things up
// priority is 90 to run ahead of parser priority of 100
ready(90, function(){
// summary:
// Detects if we are in high-contrast mode or not
// create div for testing if high contrast mode is on or images are turned off
var div = domConstruct.create("div",{
id: "a11yTestNode",
style:{
cssText:'border: 1px solid;'
+ 'border-color:red green;'
+ 'position: absolute;'
+ 'height: 5px;'
+ 'top: -999px;'
+ 'background-image: url("' + (config.blankGif || require.toUrl("dojo/resources/blank.gif")) + '");'
}
}, win.body());
// test it
var cs = domStyle.getComputedStyle(div);
if(cs){
var bkImg = cs.backgroundImage;
var needsA11y = (cs.borderTopColor == cs.borderRightColor) || (bkImg != null && (bkImg == "none" || bkImg == "url(invalid-url:)" ));
if(needsA11y){
domClass.add(win.body(), "dijit_a11y");
}
if(has("ie")){
div.outerHTML = ""; // prevent mixed-content warning, see http://support.microsoft.com/kb/925014
}else{
win.body().removeChild(div);
}
}
});
}
});
},
'dijit/_Contained':function(){
define("dijit/_Contained", [
"dojo/_base/declare", // declare
"./registry" // registry.getEnclosingWidget(), registry.byNode()
], function(declare, registry){
// module:
// dijit/_Contained
// summary:
// Mixin for widgets that are children of a container widget
return declare("dijit._Contained", null, {
// summary:
// Mixin for widgets that are children of a container widget
//
// example:
// | // make a basic custom widget that knows about it's parents
// | declare("my.customClass",[dijit._Widget,dijit._Contained],{});
_getSibling: function(/*String*/ which){
// summary:
// Returns next or previous sibling
// which:
// Either "next" or "previous"
// tags:
// private
var node = this.domNode;
do{
node = node[which+"Sibling"];
}while(node && node.nodeType != 1);
return node && registry.byNode(node); // dijit._Widget
},
getPreviousSibling: function(){
// summary:
// Returns null if this is the first child of the parent,
// otherwise returns the next element sibling to the "left".
return this._getSibling("previous"); // dijit._Widget
},
getNextSibling: function(){
// summary:
// Returns null if this is the last child of the parent,
// otherwise returns the next element sibling to the "right".
return this._getSibling("next"); // dijit._Widget
},
getIndexInParent: function(){
// summary:
// Returns the index of this widget within its container parent.
// It returns -1 if the parent does not exist, or if the parent
// is not a dijit._Container
var p = this.getParent();
if(!p || !p.getIndexOfChild){
return -1; // int
}
return p.getIndexOfChild(this); // int
}
});
});
},
'dojo/parser':function(){
define(
["./_base/kernel", "./_base/lang", "./_base/array", "./_base/html", "./_base/window", "./_base/url",
"./_base/json", "./aspect", "./date/stamp", "./query", "./on", "./ready"],
function(dojo, dlang, darray, dhtml, dwindow, _Url, djson, aspect, dates, query, don){
// module:
// dojo/parser
// summary:
// The Dom/Widget parsing package
new Date("X"); // workaround for #11279, new Date("") == NaN
var features = {
// Feature detection for when node.attributes only lists the attributes specified in the markup
// rather than old IE/quirks behavior where it lists every default value too
"dom-attributes-explicit": document.createElement("div").attributes.length < 40
};
function has(feature){
return features[feature];
}
dojo.parser = new function(){
// summary:
// The Dom/Widget parsing package
var _nameMap = {
// Map from widget name (ex: "dijit.form.Button") to structure mapping
// lowercase version of attribute names to the version in the widget ex:
// {
// label: "label",
// onclick: "onClick"
// }
};
function getNameMap(proto){
// summary:
// Returns map from lowercase name to attribute name in class, ex: {onclick: "onClick"}
var map = {};
for(var name in proto){
if(name.charAt(0)=="_"){ continue; } // skip internal properties
map[name.toLowerCase()] = name;
}
return map;
}
// Widgets like BorderContainer add properties to _Widget via dojo.extend().
// If BorderContainer is loaded after _Widget's parameter list has been cached,
// we need to refresh that parameter list (for _Widget and all widgets that extend _Widget).
aspect.after(dlang, "extend", function(){
_nameMap = {};
}, true);
// Map from widget name (ex: "dijit.form.Button") to constructor
var _ctorMap = {};
this._functionFromScript = function(script, attrData){
// summary:
// Convert a
// into a function
// script: DOMNode
// The