You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
505 lines
19 KiB
JavaScript
505 lines
19 KiB
JavaScript
/*
|
|
Copyright (c) 2004-2010, 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
|
|
*/
|
|
|
|
|
|
/*=====
|
|
// note:
|
|
// 'djConfig' does not exist under 'dojo.*' so that it can be set before the
|
|
// 'dojo' variable exists.
|
|
// note:
|
|
// Setting any of these variables *after* the library has loaded does
|
|
// nothing at all.
|
|
|
|
djConfig = {
|
|
// summary:
|
|
// Application code can set the global 'djConfig' prior to loading
|
|
// the library to override certain global settings for how dojo works.
|
|
//
|
|
// isDebug: Boolean
|
|
// Defaults to `false`. If set to `true`, ensures that Dojo provides
|
|
// extended debugging feedback via Firebug. If Firebug is not available
|
|
// on your platform, setting `isDebug` to `true` will force Dojo to
|
|
// pull in (and display) the version of Firebug Lite which is
|
|
// integrated into the Dojo distribution, thereby always providing a
|
|
// debugging/logging console when `isDebug` is enabled. Note that
|
|
// Firebug's `console.*` methods are ALWAYS defined by Dojo. If
|
|
// `isDebug` is false and you are on a platform without Firebug, these
|
|
// methods will be defined as no-ops.
|
|
isDebug: false,
|
|
// debugAtAllCosts: Boolean
|
|
// Defaults to `false`. If set to `true`, this triggers an alternate
|
|
// mode of the package system in which dependencies are detected and
|
|
// only then are resources evaluated in dependency order via
|
|
// `<script>` tag inclusion. This may double-request resources and
|
|
// cause problems with scripts which expect `dojo.require()` to
|
|
// preform synchronously. `debugAtAllCosts` can be an invaluable
|
|
// debugging aid, but when using it, ensure that all code which
|
|
// depends on Dojo modules is wrapped in `dojo.addOnLoad()` handlers.
|
|
// Due to the somewhat unpredictable side-effects of using
|
|
// `debugAtAllCosts`, it is strongly recommended that you enable this
|
|
// flag as a last resort. `debugAtAllCosts` has no effect when loading
|
|
// resources across domains. For usage information, see the
|
|
// [Dojo Book](http://dojotoolkit.org/book/book-dojo/part-4-meta-dojo-making-your-dojo-code-run-faster-and-better/debugging-facilities/deb)
|
|
debugAtAllCosts: false,
|
|
// locale: String
|
|
// The locale to assume for loading localized resources in this page,
|
|
// specified according to [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt).
|
|
// Must be specified entirely in lowercase, e.g. `en-us` and `zh-cn`.
|
|
// See the documentation for `dojo.i18n` and `dojo.requireLocalization`
|
|
// for details on loading localized resources. If no locale is specified,
|
|
// Dojo assumes the locale of the user agent, according to `navigator.userLanguage`
|
|
// or `navigator.language` properties.
|
|
locale: undefined,
|
|
// extraLocale: Array
|
|
// No default value. Specifies additional locales whose
|
|
// resources should also be loaded alongside the default locale when
|
|
// calls to `dojo.requireLocalization()` are processed.
|
|
extraLocale: undefined,
|
|
// baseUrl: String
|
|
// The directory in which `dojo.js` is located. Under normal
|
|
// conditions, Dojo auto-detects the correct location from which it
|
|
// was loaded. You may need to manually configure `baseUrl` in cases
|
|
// where you have renamed `dojo.js` or in which `<base>` tags confuse
|
|
// some browsers (e.g. IE 6). The variable `dojo.baseUrl` is assigned
|
|
// either the value of `djConfig.baseUrl` if one is provided or the
|
|
// auto-detected root if not. Other modules are located relative to
|
|
// this path. The path should end in a slash.
|
|
baseUrl: undefined,
|
|
// modulePaths: Object
|
|
// A map of module names to paths relative to `dojo.baseUrl`. The
|
|
// key/value pairs correspond directly to the arguments which
|
|
// `dojo.registerModulePath` accepts. Specifiying
|
|
// `djConfig.modulePaths = { "foo": "../../bar" }` is the equivalent
|
|
// of calling `dojo.registerModulePath("foo", "../../bar");`. Multiple
|
|
// modules may be configured via `djConfig.modulePaths`.
|
|
modulePaths: {},
|
|
// afterOnLoad: Boolean
|
|
// Indicates Dojo was added to the page after the page load. In this case
|
|
// Dojo will not wait for the page DOMContentLoad/load events and fire
|
|
// its dojo.addOnLoad callbacks after making sure all outstanding
|
|
// dojo.required modules have loaded. Only works with a built dojo.js,
|
|
// it does not work the dojo.js directly from source control.
|
|
afterOnLoad: false,
|
|
// addOnLoad: Function or Array
|
|
// Adds a callback via dojo.addOnLoad. Useful when Dojo is added after
|
|
// the page loads and djConfig.afterOnLoad is true. Supports the same
|
|
// arguments as dojo.addOnLoad. When using a function reference, use
|
|
// `djConfig.addOnLoad = function(){};`. For object with function name use
|
|
// `djConfig.addOnLoad = [myObject, "functionName"];` and for object with
|
|
// function reference use
|
|
// `djConfig.addOnLoad = [myObject, function(){}];`
|
|
addOnLoad: null,
|
|
// require: Array
|
|
// An array of module names to be loaded immediately after dojo.js has been included
|
|
// in a page.
|
|
require: [],
|
|
// defaultDuration: Array
|
|
// Default duration, in milliseconds, for wipe and fade animations within dijits.
|
|
// Assigned to dijit.defaultDuration.
|
|
defaultDuration: 200,
|
|
// dojoBlankHtmlUrl: String
|
|
// Used by some modules to configure an empty iframe. Used by dojo.io.iframe and
|
|
// dojo.back, and dijit popup support in IE where an iframe is needed to make sure native
|
|
// controls do not bleed through the popups. Normally this configuration variable
|
|
// does not need to be set, except when using cross-domain/CDN Dojo builds.
|
|
// Save dojo/resources/blank.html to your domain and set `djConfig.dojoBlankHtmlUrl`
|
|
// to the path on your domain your copy of blank.html.
|
|
dojoBlankHtmlUrl: undefined,
|
|
// ioPublish: Boolean?
|
|
// Set this to true to enable publishing of topics for the different phases of
|
|
// IO operations. Publishing is done via dojo.publish. See dojo.__IoPublish for a list
|
|
// of topics that are published.
|
|
ioPublish: false,
|
|
// useCustomLogger: Anything?
|
|
// If set to a value that evaluates to true such as a string or array and
|
|
// isDebug is true and Firebug is not available or running, then it bypasses
|
|
// the creation of Firebug Lite allowing you to define your own console object.
|
|
useCustomLogger: undefined,
|
|
// transparentColor: Array
|
|
// Array containing the r, g, b components used as transparent color in dojo.Color;
|
|
// if undefined, [255,255,255] (white) will be used.
|
|
transparentColor: undefined,
|
|
// skipIeDomLoaded: Boolean
|
|
// For IE only, skip the DOMContentLoaded hack used. Sometimes it can cause an Operation
|
|
// Aborted error if the rest of the page triggers script defers before the DOM is ready.
|
|
// If this is config value is set to true, then dojo.addOnLoad callbacks will not be
|
|
// triggered until the page load event, which is after images and iframes load. If you
|
|
// want to trigger the callbacks sooner, you can put a script block in the bottom of
|
|
// your HTML that calls dojo._loadInit();. If you are using multiversion support, change
|
|
// "dojo." to the appropriate scope name for dojo.
|
|
skipIeDomLoaded: false
|
|
}
|
|
=====*/
|
|
|
|
(function(){
|
|
// firebug stubs
|
|
|
|
if(typeof this["loadFirebugConsole"] == "function"){
|
|
// for Firebug 1.2
|
|
this["loadFirebugConsole"]();
|
|
}else{
|
|
this.console = this.console || {};
|
|
|
|
// Be careful to leave 'log' always at the end
|
|
var cn = [
|
|
"assert", "count", "debug", "dir", "dirxml", "error", "group",
|
|
"groupEnd", "info", "profile", "profileEnd", "time", "timeEnd",
|
|
"trace", "warn", "log"
|
|
];
|
|
var i=0, tn;
|
|
while((tn=cn[i++])){
|
|
if(!console[tn]){
|
|
(function(){
|
|
var tcn = tn+"";
|
|
console[tcn] = ('log' in console) ? function(){
|
|
var a = Array.apply({}, arguments);
|
|
a.unshift(tcn+":");
|
|
console["log"](a.join(" "));
|
|
} : function(){}
|
|
console[tcn]._fake = true;
|
|
})();
|
|
}
|
|
}
|
|
}
|
|
|
|
//TODOC: HOW TO DOC THIS?
|
|
// dojo is the root variable of (almost all) our public symbols -- make sure it is defined.
|
|
if(typeof dojo == "undefined"){
|
|
dojo = {
|
|
_scopeName: "dojo",
|
|
_scopePrefix: "",
|
|
_scopePrefixArgs: "",
|
|
_scopeSuffix: "",
|
|
_scopeMap: {},
|
|
_scopeMapRev: {}
|
|
};
|
|
}
|
|
|
|
var d = dojo;
|
|
|
|
//Need placeholders for dijit and dojox for scoping code.
|
|
if(typeof dijit == "undefined"){
|
|
dijit = {_scopeName: "dijit"};
|
|
}
|
|
if(typeof dojox == "undefined"){
|
|
dojox = {_scopeName: "dojox"};
|
|
}
|
|
|
|
if(!d._scopeArgs){
|
|
d._scopeArgs = [dojo, dijit, dojox];
|
|
}
|
|
|
|
/*=====
|
|
dojo.global = {
|
|
// summary:
|
|
// Alias for the global scope
|
|
// (e.g. the window object in a browser).
|
|
// description:
|
|
// Refer to 'dojo.global' rather than referring to window to ensure your
|
|
// code runs correctly in contexts other than web browsers (e.g. Rhino on a server).
|
|
}
|
|
=====*/
|
|
d.global = this;
|
|
|
|
d.config =/*===== djConfig = =====*/{
|
|
isDebug: false,
|
|
debugAtAllCosts: false
|
|
};
|
|
|
|
if(typeof djConfig != "undefined"){
|
|
for(var opt in djConfig){
|
|
d.config[opt] = djConfig[opt];
|
|
}
|
|
}
|
|
|
|
/*=====
|
|
// Override locale setting, if specified
|
|
dojo.locale = {
|
|
// summary: the locale as defined by Dojo (read-only)
|
|
};
|
|
=====*/
|
|
dojo.locale = d.config.locale;
|
|
|
|
var rev = "$Rev: 22487 $".match(/\d+/);
|
|
|
|
/*=====
|
|
dojo.version = function(){
|
|
// summary:
|
|
// Version number of the Dojo Toolkit
|
|
// major: Integer
|
|
// Major version. If total version is "1.2.0beta1", will be 1
|
|
// minor: Integer
|
|
// Minor version. If total version is "1.2.0beta1", will be 2
|
|
// patch: Integer
|
|
// Patch version. If total version is "1.2.0beta1", will be 0
|
|
// flag: String
|
|
// Descriptor flag. If total version is "1.2.0beta1", will be "beta1"
|
|
// revision: Number
|
|
// The SVN rev from which dojo was pulled
|
|
this.major = 0;
|
|
this.minor = 0;
|
|
this.patch = 0;
|
|
this.flag = "";
|
|
this.revision = 0;
|
|
}
|
|
=====*/
|
|
dojo.version = {
|
|
major: 1, minor: 5, patch: 0, flag: "",
|
|
revision: rev ? +rev[0] : NaN,
|
|
toString: function(){
|
|
with(d.version){
|
|
return major + "." + minor + "." + patch + flag + " (" + revision + ")"; // String
|
|
}
|
|
}
|
|
}
|
|
|
|
// Register with the OpenAjax hub
|
|
if(typeof OpenAjax != "undefined"){
|
|
OpenAjax.hub.registerLibrary(dojo._scopeName, "http://dojotoolkit.org", d.version.toString());
|
|
}
|
|
|
|
var extraNames, extraLen, empty = {};
|
|
for(var i in {toString: 1}){ extraNames = []; break; }
|
|
dojo._extraNames = extraNames = extraNames || ["hasOwnProperty", "valueOf", "isPrototypeOf",
|
|
"propertyIsEnumerable", "toLocaleString", "toString", "constructor"];
|
|
extraLen = extraNames.length;
|
|
|
|
dojo._mixin = function(/*Object*/ target, /*Object*/ source){
|
|
// summary:
|
|
// Adds all properties and methods of source to target. This addition
|
|
// is "prototype extension safe", so that instances of objects
|
|
// will not pass along prototype defaults.
|
|
var name, s, i;
|
|
for(name in source){
|
|
// the "tobj" condition avoid copying properties in "source"
|
|
// inherited from Object.prototype. For example, if target has a custom
|
|
// toString() method, don't overwrite it with the toString() method
|
|
// that source inherited from Object.prototype
|
|
s = source[name];
|
|
if(!(name in target) || (target[name] !== s && (!(name in empty) || empty[name] !== s))){
|
|
target[name] = s;
|
|
}
|
|
}
|
|
// IE doesn't recognize some custom functions in for..in
|
|
if(extraLen && source){
|
|
for(i = 0; i < extraLen; ++i){
|
|
name = extraNames[i];
|
|
s = source[name];
|
|
if(!(name in target) || (target[name] !== s && (!(name in empty) || empty[name] !== s))){
|
|
target[name] = s;
|
|
}
|
|
}
|
|
}
|
|
return target; // Object
|
|
}
|
|
|
|
dojo.mixin = function(/*Object*/obj, /*Object...*/props){
|
|
// summary:
|
|
// Adds all properties and methods of props to obj and returns the
|
|
// (now modified) obj.
|
|
// description:
|
|
// `dojo.mixin` can mix multiple source objects into a
|
|
// destination object which is then returned. Unlike regular
|
|
// `for...in` iteration, `dojo.mixin` is also smart about avoiding
|
|
// extensions which other toolkits may unwisely add to the root
|
|
// object prototype
|
|
// obj:
|
|
// The object to mix properties into. Also the return value.
|
|
// props:
|
|
// One or more objects whose values are successively copied into
|
|
// obj. If more than one of these objects contain the same value,
|
|
// the one specified last in the function call will "win".
|
|
// example:
|
|
// make a shallow copy of an object
|
|
// | var copy = dojo.mixin({}, source);
|
|
// example:
|
|
// many class constructors often take an object which specifies
|
|
// values to be configured on the object. In this case, it is
|
|
// often simplest to call `dojo.mixin` on the `this` object:
|
|
// | dojo.declare("acme.Base", null, {
|
|
// | constructor: function(properties){
|
|
// | // property configuration:
|
|
// | dojo.mixin(this, properties);
|
|
// |
|
|
// | console.log(this.quip);
|
|
// | // ...
|
|
// | },
|
|
// | quip: "I wasn't born yesterday, you know - I've seen movies.",
|
|
// | // ...
|
|
// | });
|
|
// |
|
|
// | // create an instance of the class and configure it
|
|
// | var b = new acme.Base({quip: "That's what it does!" });
|
|
// example:
|
|
// copy in properties from multiple objects
|
|
// | var flattened = dojo.mixin(
|
|
// | {
|
|
// | name: "Frylock",
|
|
// | braces: true
|
|
// | },
|
|
// | {
|
|
// | name: "Carl Brutanananadilewski"
|
|
// | }
|
|
// | );
|
|
// |
|
|
// | // will print "Carl Brutanananadilewski"
|
|
// | console.log(flattened.name);
|
|
// | // will print "true"
|
|
// | console.log(flattened.braces);
|
|
if(!obj){ obj = {}; }
|
|
for(var i=1, l=arguments.length; i<l; i++){
|
|
d._mixin(obj, arguments[i]);
|
|
}
|
|
return obj; // Object
|
|
}
|
|
|
|
dojo._getProp = function(/*Array*/parts, /*Boolean*/create, /*Object*/context){
|
|
var obj=context || d.global;
|
|
for(var i=0, p; obj && (p=parts[i]); i++){
|
|
if(i == 0 && d._scopeMap[p]){
|
|
p = d._scopeMap[p];
|
|
}
|
|
obj = (p in obj ? obj[p] : (create ? obj[p]={} : undefined));
|
|
}
|
|
return obj; // mixed
|
|
}
|
|
|
|
dojo.setObject = function(/*String*/name, /*Object*/value, /*Object?*/context){
|
|
// summary:
|
|
// Set a property from a dot-separated string, such as "A.B.C"
|
|
// description:
|
|
// Useful for longer api chains where you have to test each object in
|
|
// the chain, or when you have an object reference in string format.
|
|
// Objects are created as needed along `path`. Returns the passed
|
|
// value if setting is successful or `undefined` if not.
|
|
// name:
|
|
// Path to a property, in the form "A.B.C".
|
|
// context:
|
|
// Optional. Object to use as root of path. Defaults to
|
|
// `dojo.global`.
|
|
// example:
|
|
// set the value of `foo.bar.baz`, regardless of whether
|
|
// intermediate objects already exist:
|
|
// | dojo.setObject("foo.bar.baz", value);
|
|
// example:
|
|
// without `dojo.setObject`, we often see code like this:
|
|
// | // ensure that intermediate objects are available
|
|
// | if(!obj["parent"]){ obj.parent = {}; }
|
|
// | if(!obj.parent["child"]){ obj.parent.child= {}; }
|
|
// | // now we can safely set the property
|
|
// | obj.parent.child.prop = "some value";
|
|
// wheras with `dojo.setObject`, we can shorten that to:
|
|
// | dojo.setObject("parent.child.prop", "some value", obj);
|
|
var parts=name.split("."), p=parts.pop(), obj=d._getProp(parts, true, context);
|
|
return obj && p ? (obj[p]=value) : undefined; // Object
|
|
}
|
|
|
|
dojo.getObject = function(/*String*/name, /*Boolean?*/create, /*Object?*/context){
|
|
// summary:
|
|
// Get a property from a dot-separated string, such as "A.B.C"
|
|
// description:
|
|
// Useful for longer api chains where you have to test each object in
|
|
// the chain, or when you have an object reference in string format.
|
|
// name:
|
|
// Path to an property, in the form "A.B.C".
|
|
// create:
|
|
// Optional. Defaults to `false`. If `true`, Objects will be
|
|
// created at any point along the 'path' that is undefined.
|
|
// context:
|
|
// Optional. Object to use as root of path. Defaults to
|
|
// 'dojo.global'. Null may be passed.
|
|
return d._getProp(name.split("."), create, context); // Object
|
|
}
|
|
|
|
dojo.exists = function(/*String*/name, /*Object?*/obj){
|
|
// summary:
|
|
// determine if an object supports a given method
|
|
// description:
|
|
// useful for longer api chains where you have to test each object in
|
|
// the chain. Useful only for object and method detection.
|
|
// Not useful for testing generic properties on an object.
|
|
// In particular, dojo.exists("foo.bar") when foo.bar = ""
|
|
// will return false. Use ("bar" in foo) to test for those cases.
|
|
// name:
|
|
// Path to an object, in the form "A.B.C".
|
|
// obj:
|
|
// Object to use as root of path. Defaults to
|
|
// 'dojo.global'. Null may be passed.
|
|
// example:
|
|
// | // define an object
|
|
// | var foo = {
|
|
// | bar: { }
|
|
// | };
|
|
// |
|
|
// | // search the global scope
|
|
// | dojo.exists("foo.bar"); // true
|
|
// | dojo.exists("foo.bar.baz"); // false
|
|
// |
|
|
// | // search from a particular scope
|
|
// | dojo.exists("bar", foo); // true
|
|
// | dojo.exists("bar.baz", foo); // false
|
|
return !!d.getObject(name, false, obj); // Boolean
|
|
}
|
|
|
|
dojo["eval"] = function(/*String*/ scriptFragment){
|
|
// summary:
|
|
// A legacy method created for use exclusively by internal Dojo methods. Do not use
|
|
// this method directly, the behavior of this eval will differ from the normal
|
|
// browser eval.
|
|
// description:
|
|
// Placed in a separate function to minimize size of trapped
|
|
// exceptions. Calling eval() directly from some other scope may
|
|
// complicate tracebacks on some platforms.
|
|
// returns:
|
|
// The result of the evaluation. Often `undefined`
|
|
return d.global.eval ? d.global.eval(scriptFragment) : eval(scriptFragment); // Object
|
|
}
|
|
|
|
/*=====
|
|
dojo.deprecated = function(behaviour, extra, removal){
|
|
// summary:
|
|
// Log a debug message to indicate that a behavior has been
|
|
// deprecated.
|
|
// behaviour: String
|
|
// The API or behavior being deprecated. Usually in the form
|
|
// of "myApp.someFunction()".
|
|
// extra: String?
|
|
// Text to append to the message. Often provides advice on a
|
|
// new function or facility to achieve the same goal during
|
|
// the deprecation period.
|
|
// removal: String?
|
|
// Text to indicate when in the future the behavior will be
|
|
// removed. Usually a version number.
|
|
// example:
|
|
// | dojo.deprecated("myApp.getTemp()", "use myApp.getLocaleTemp() instead", "1.0");
|
|
}
|
|
|
|
dojo.experimental = function(moduleName, extra){
|
|
// summary: Marks code as experimental.
|
|
// description:
|
|
// This can be used to mark a function, file, or module as
|
|
// experimental. Experimental code is not ready to be used, and the
|
|
// APIs are subject to change without notice. Experimental code may be
|
|
// completed deleted without going through the normal deprecation
|
|
// process.
|
|
// moduleName: String
|
|
// The name of a module, or the name of a module file or a specific
|
|
// function
|
|
// extra: String?
|
|
// some additional message for the user
|
|
// example:
|
|
// | dojo.experimental("dojo.data.Result");
|
|
// example:
|
|
// | dojo.experimental("dojo.weather.toKelvin()", "PENDING approval from NOAA");
|
|
}
|
|
=====*/
|
|
|
|
//Real functions declared in dojo._firebug.firebug.
|
|
d.deprecated = d.experimental = function(){};
|
|
|
|
})();
|
|
// vim:ai:ts=4:noet
|