| Index: chrome/test/data/dromaeo/lib/dojo.js
|
| ===================================================================
|
| --- chrome/test/data/dromaeo/lib/dojo.js (revision 0)
|
| +++ chrome/test/data/dromaeo/lib/dojo.js (revision 0)
|
| @@ -0,0 +1,8458 @@
|
| +/*
|
| + Copyright (c) 2004-2008, 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 a compiled version of Dojo, built for deployment and not for
|
| + development. To get an editable version, please visit:
|
| +
|
| + http://dojotoolkit.org
|
| +
|
| + for documentation and information on getting the source.
|
| +*/
|
| +
|
| +;(function(){
|
| +
|
| + /*
|
| + dojo, dijit, and dojox must always be the first three, and in that order.
|
| + djConfig.scopeMap = [
|
| + ["dojo", "fojo"],
|
| + ["dijit", "fijit"],
|
| + ["dojox", "fojox"]
|
| +
|
| + ]
|
| + */
|
| +
|
| + /**Build will replace this comment with a scoped djConfig **/
|
| +
|
| + //The null below can be relaced by a build-time value used instead of djConfig.scopeMap.
|
| + var sMap = null;
|
| +
|
| + //See if new scopes need to be defined.
|
| + if((sMap || (typeof djConfig != "undefined" && djConfig.scopeMap)) && (typeof window != "undefined")){
|
| + var scopeDef = "", scopePrefix = "", scopeSuffix = "", scopeMap = {}, scopeMapRev = {};
|
| + sMap = sMap || djConfig.scopeMap;
|
| + for(var i = 0; i < sMap.length; i++){
|
| + //Make local variables, then global variables that use the locals.
|
| + var newScope = sMap[i];
|
| + scopeDef += "var " + newScope[0] + " = {}; " + newScope[1] + " = " + newScope[0] + ";" + newScope[1] + "._scopeName = '" + newScope[1] + "';";
|
| + scopePrefix += (i == 0 ? "" : ",") + newScope[0];
|
| + scopeSuffix += (i == 0 ? "" : ",") + newScope[1];
|
| + scopeMap[newScope[0]] = newScope[1];
|
| + scopeMapRev[newScope[1]] = newScope[0];
|
| + }
|
| +
|
| + eval(scopeDef + "dojo._scopeArgs = [" + scopeSuffix + "];");
|
| +
|
| + dojo._scopePrefixArgs = scopePrefix;
|
| + dojo._scopePrefix = "(function(" + scopePrefix + "){";
|
| + dojo._scopeSuffix = "})(" + scopeSuffix + ")";
|
| + dojo._scopeMap = scopeMap;
|
| + dojo._scopeMapRev = scopeMapRev;
|
| + }
|
| +
|
| +/*=====
|
| +// 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.
|
| + 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.
|
| + 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: []
|
| +}
|
| +=====*/
|
| +
|
| +(function(){
|
| + // firebug stubs
|
| +
|
| + // if((!this["console"])||(!console["firebug"])){
|
| +
|
| + if(!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(){}
|
| + })();
|
| + }
|
| + }
|
| +
|
| + //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"){
|
| + this.dojo = {
|
| + _scopeName: "dojo",
|
| + _scopePrefix: "",
|
| + _scopePrefixArgs: "",
|
| + _scopeSuffix: "",
|
| + _scopeMap: {},
|
| + _scopeMapRev: {}
|
| + };
|
| + }
|
| +
|
| + var d = dojo;
|
| +
|
| + //Need placeholders for dijit and dojox for scoping code.
|
| + if(typeof dijit == "undefined"){
|
| + this.dijit = {_scopeName: "dijit"};
|
| + }
|
| + if(typeof dojox == "undefined"){
|
| + this.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];
|
| + }
|
| + }
|
| +
|
| + var _platforms = ["Browser", "Rhino", "Spidermonkey", "Mobile"];
|
| + var t;
|
| + while((t=_platforms.shift())){
|
| + d["is"+t] = false;
|
| + }
|
| +
|
| +/*=====
|
| + // Override locale setting, if specified
|
| + dojo.locale = {
|
| + // summary: the locale as defined by Dojo (read-only)
|
| + };
|
| +=====*/
|
| + dojo.locale = d.config.locale;
|
| +
|
| + var rev = "$Rev: 15729 $".match(/\d+/);
|
| +
|
| + dojo.version = {
|
| + // summary:
|
| + // version number of dojo
|
| + // 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
|
| + major: 1, minor: 2, patch: 2, flag: "",
|
| + revision: rev ? +rev[0] : 999999, //FIXME: use 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());
|
| + }
|
| +
|
| + dojo._mixin = function(/*Object*/ obj, /*Object*/ props){
|
| + // summary:
|
| + // Adds all properties and methods of props to obj. This addition
|
| + // is "prototype extension safe", so that instances of objects
|
| + // will not pass along prototype defaults.
|
| + var tobj = {};
|
| + for(var x in props){
|
| + // the "tobj" condition avoid copying properties in "props"
|
| + // inherited from Object.prototype. For example, if obj has a custom
|
| + // toString() method, don't overwrite it with the toString() method
|
| + // that props inherited from Object.prototype
|
| + if(tobj[x] === undefined || tobj[x] != props[x]){
|
| + obj[x] = props[x];
|
| + }
|
| + }
|
| + // IE doesn't recognize custom toStrings in for..in
|
| + if(d["isIE"] && props){
|
| + var p = props.toString;
|
| + if(typeof p == "function" && p != obj.toString && p != tobj.toString &&
|
| + p != "\nfunction toString() {\n [native code]\n}\n"){
|
| + obj.toString = props.toString;
|
| + }
|
| + }
|
| + return obj; // 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
|
| + // destionation 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);
|
| + // |
|
| + // |
|
| + // | // ...
|
| + // | },
|
| + // | 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"
|
| + // |
|
| + // | // will print "true"
|
| + // |
|
| + 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 && this._scopeMap[p]){
|
| + p = this._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".
|
| + // context:
|
| + // Optional. Object to use as root of path. Defaults to
|
| + // 'dojo.global'. Null may be passed.
|
| + // create:
|
| + // Optional. Defaults to `false`. If `true`, Objects will be
|
| + // created at any point along the 'path' that is undefined.
|
| + 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
|
| + // 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:
|
| + // Perform an evaluation in the global scope. Use this rather than
|
| + // calling 'eval()' directly.
|
| + // 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`
|
| +
|
| +
|
| + // note:
|
| + // - JSC eval() takes an optional second argument which can be 'unsafe'.
|
| + // - Mozilla/SpiderMonkey eval() takes an optional second argument which is the
|
| + // scope object for new symbols.
|
| +
|
| + // FIXME: investigate Joseph Smarr's technique for IE:
|
| + // http://josephsmarr.com/2007/01/31/fixing-eval-to-use-global-scope-in-ie/
|
| + // see also:
|
| + // http://trac.dojotoolkit.org/ticket/744
|
| + 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
|
| +
|
| +/*
|
| + * loader.js - A bootstrap module. Runs before the hostenv_*.js file. Contains
|
| + * all of the package loading methods.
|
| + */
|
| +
|
| +(function(){
|
| + var d = dojo;
|
| +
|
| + d.mixin(d, {
|
| + _loadedModules: {},
|
| + _inFlightCount: 0,
|
| + _hasResource: {},
|
| +
|
| + _modulePrefixes: {
|
| + dojo: { name: "dojo", value: "." },
|
| + // dojox: { name: "dojox", value: "../dojox" },
|
| + // dijit: { name: "dijit", value: "../dijit" },
|
| + doh: { name: "doh", value: "../util/doh" },
|
| + tests: { name: "tests", value: "tests" }
|
| + },
|
| +
|
| + _moduleHasPrefix: function(/*String*/module){
|
| + // summary: checks to see if module has been established
|
| + var mp = this._modulePrefixes;
|
| + return !!(mp[module] && mp[module].value); // Boolean
|
| + },
|
| +
|
| + _getModulePrefix: function(/*String*/module){
|
| + // summary: gets the prefix associated with module
|
| + var mp = this._modulePrefixes;
|
| + if(this._moduleHasPrefix(module)){
|
| + return mp[module].value; // String
|
| + }
|
| + return module; // String
|
| + },
|
| +
|
| + _loadedUrls: [],
|
| +
|
| + //WARNING:
|
| + // This variable is referenced by packages outside of bootstrap:
|
| + // FloatingPane.js and undo/browser.js
|
| + _postLoad: false,
|
| +
|
| + //Egad! Lots of test files push on this directly instead of using dojo.addOnLoad.
|
| + _loaders: [],
|
| + _unloaders: [],
|
| + _loadNotifying: false
|
| + });
|
| +
|
| +
|
| + dojo._loadPath = function(/*String*/relpath, /*String?*/module, /*Function?*/cb){
|
| + // summary:
|
| + // Load a Javascript module given a relative path
|
| + //
|
| + // description:
|
| + // Loads and interprets the script located at relpath, which is
|
| + // relative to the script root directory. If the script is found but
|
| + // its interpretation causes a runtime exception, that exception is
|
| + // not caught by us, so the caller will see it. We return a true
|
| + // value if and only if the script is found.
|
| + //
|
| + // relpath:
|
| + // A relative path to a script (no leading '/', and typically ending
|
| + // in '.js').
|
| + // module:
|
| + // A module whose existance to check for after loading a path. Can be
|
| + // used to determine success or failure of the load.
|
| + // cb:
|
| + // a callback function to pass the result of evaluating the script
|
| +
|
| + var uri = ((relpath.charAt(0) == '/' || relpath.match(/^\w+:/)) ? "" : this.baseUrl) + relpath;
|
| + try{
|
| + return !module ? this._loadUri(uri, cb) : this._loadUriAndCheck(uri, module, cb); // Boolean
|
| + }catch(e){
|
| + console.error(e);
|
| + return false; // Boolean
|
| + }
|
| + }
|
| +
|
| + dojo._loadUri = function(/*String*/uri, /*Function?*/cb){
|
| + // summary:
|
| + // Loads JavaScript from a URI
|
| + // description:
|
| + // Reads the contents of the URI, and evaluates the contents. This is
|
| + // used to load modules as well as resource bundles. Returns true if
|
| + // it succeeded. Returns false if the URI reading failed. Throws if
|
| + // the evaluation throws.
|
| + // uri: a uri which points at the script to be loaded
|
| + // cb:
|
| + // a callback function to process the result of evaluating the script
|
| + // as an expression, typically used by the resource bundle loader to
|
| + // load JSON-style resources
|
| +
|
| + if(this._loadedUrls[uri]){
|
| + return true; // Boolean
|
| + }
|
| + var contents = this._getText(uri, true);
|
| + if(!contents){ return false; } // Boolean
|
| + this._loadedUrls[uri] = true;
|
| + this._loadedUrls.push(uri);
|
| + if(cb){
|
| + contents = '('+contents+')';
|
| + }else{
|
| + //Only do the scoping if no callback. If a callback is specified,
|
| + //it is most likely the i18n bundle stuff.
|
| + contents = this._scopePrefix + contents + this._scopeSuffix;
|
| + }
|
| + if(d.isMoz){ contents += "\r\n//@ sourceURL=" + uri; } // debugging assist for Firebug
|
| + var value = d["eval"](contents);
|
| + if(cb){ cb(value); }
|
| + return true; // Boolean
|
| + }
|
| +
|
| + // FIXME: probably need to add logging to this method
|
| + dojo._loadUriAndCheck = function(/*String*/uri, /*String*/moduleName, /*Function?*/cb){
|
| + // summary: calls loadUri then findModule and returns true if both succeed
|
| + var ok = false;
|
| + try{
|
| + ok = this._loadUri(uri, cb);
|
| + }catch(e){
|
| + console.error("failed loading " + uri + " with error: " + e);
|
| + }
|
| + return !!(ok && this._loadedModules[moduleName]); // Boolean
|
| + }
|
| +
|
| + dojo.loaded = function(){
|
| + // summary:
|
| + // signal fired when initial environment and package loading is
|
| + // complete. You may use dojo.addOnLoad() or dojo.connect() to
|
| + // this method in order to handle initialization tasks that
|
| + // require the environment to be initialized. In a browser host,
|
| + // declarative widgets will be constructed when this function
|
| + // finishes runing.
|
| + this._loadNotifying = true;
|
| + this._postLoad = true;
|
| + var mll = d._loaders;
|
| +
|
| + //Clear listeners so new ones can be added
|
| + //For other xdomain package loads after the initial load.
|
| + this._loaders = [];
|
| +
|
| + for(var x = 0; x < mll.length; x++){
|
| + mll[x]();
|
| + }
|
| +
|
| + this._loadNotifying = false;
|
| +
|
| + //Make sure nothing else got added to the onload queue
|
| + //after this first run. If something did, and we are not waiting for any
|
| + //more inflight resources, run again.
|
| + if(d._postLoad && d._inFlightCount == 0 && mll.length){
|
| + d._callLoaded();
|
| + }
|
| + }
|
| +
|
| + dojo.unloaded = function(){
|
| + // summary:
|
| + // signal fired by impending environment destruction. You may use
|
| + // dojo.addOnUnload() or dojo.connect() to this method to perform
|
| + // page/application cleanup methods. See dojo.addOnUnload for more info.
|
| + var mll = this._unloaders;
|
| + while(mll.length){
|
| + (mll.pop())();
|
| + }
|
| + }
|
| +
|
| + d._onto = function(arr, obj, fn){
|
| + if(!fn){
|
| + arr.push(obj);
|
| + }else if(fn){
|
| + var func = (typeof fn == "string") ? obj[fn] : fn;
|
| + arr.push(function(){ func.call(obj); });
|
| + }
|
| + }
|
| +
|
| + dojo.addOnLoad = function(/*Object?*/obj, /*String|Function*/functionName){
|
| + // summary:
|
| + // Registers a function to be triggered after the DOM has finished
|
| + // loading and widgets declared in markup have been instantiated.
|
| + // Images and CSS files may or may not have finished downloading when
|
| + // the specified function is called. (Note that widgets' CSS and HTML
|
| + // code is guaranteed to be downloaded before said widgets are
|
| + // instantiated.)
|
| + // example:
|
| + // | dojo.addOnLoad(functionPointer);
|
| + // | dojo.addOnLoad(object, "functionName");
|
| + // | dojo.addOnLoad(object, function(){ /* ... */});
|
| +
|
| + d._onto(d._loaders, obj, functionName);
|
| +
|
| + //Added for xdomain loading. dojo.addOnLoad is used to
|
| + //indicate callbacks after doing some dojo.require() statements.
|
| + //In the xdomain case, if all the requires are loaded (after initial
|
| + //page load), then immediately call any listeners.
|
| + if(d._postLoad && d._inFlightCount == 0 && !d._loadNotifying){
|
| + d._callLoaded();
|
| + }
|
| + }
|
| +
|
| + //Support calling dojo.addOnLoad via djConfig.addOnLoad. Support all the
|
| + //call permutations of dojo.addOnLoad. Mainly useful when dojo is added
|
| + //to the page after the page has loaded.
|
| + var dca = d.config.addOnLoad;
|
| + if(dca){
|
| + d.addOnLoad[(dca instanceof Array ? "apply" : "call")](d, dca);
|
| + }
|
| +
|
| + dojo.addOnUnload = function(/*Object?*/obj, /*String|Function?*/functionName){
|
| + // summary:
|
| + // registers a function to be triggered when the page unloads. In a browser
|
| + // enviroment, the functions will be triggered during the window.onbeforeunload
|
| + // event. Be careful doing work during window.onbeforeunload. onbeforeunload
|
| + // can be triggered if a link to download a file is clicked, or if the link is a
|
| + // javascript: link. In these cases, the onbeforeunload event fires, but the
|
| + // document is not actually destroyed. So be careful about doing destructive
|
| + // operations in a dojo.addOnUnload callback.
|
| + // example:
|
| + // | dojo.addOnUnload(functionPointer)
|
| + // | dojo.addOnUnload(object, "functionName")
|
| + // | dojo.addOnUnload(object, function(){ /* ... */});
|
| +
|
| + d._onto(d._unloaders, obj, functionName);
|
| + }
|
| +
|
| + dojo._modulesLoaded = function(){
|
| + if(d._postLoad){ return; }
|
| + if(d._inFlightCount > 0){
|
| + console.warn("files still in flight!");
|
| + return;
|
| + }
|
| + d._callLoaded();
|
| + }
|
| +
|
| + dojo._callLoaded = function(){
|
| +
|
| + // The "object" check is for IE, and the other opera check fixes an
|
| + // issue in Opera where it could not find the body element in some
|
| + // widget test cases. For 0.9, maybe route all browsers through the
|
| + // setTimeout (need protection still for non-browser environments
|
| + // though). This might also help the issue with FF 2.0 and freezing
|
| + // issues where we try to do sync xhr while background css images are
|
| + // being loaded (trac #2572)? Consider for 0.9.
|
| + if(typeof setTimeout == "object" || (dojo.config.useXDomain && d.isOpera)){
|
| + if(dojo.isAIR){
|
| + setTimeout(function(){dojo.loaded();}, 0);
|
| + }else{
|
| + setTimeout(dojo._scopeName + ".loaded();", 0);
|
| + }
|
| + }else{
|
| + d.loaded();
|
| + }
|
| + }
|
| +
|
| + dojo._getModuleSymbols = function(/*String*/modulename){
|
| + // summary:
|
| + // Converts a module name in dotted JS notation to an array
|
| + // representing the path in the source tree
|
| + var syms = modulename.split(".");
|
| + for(var i = syms.length; i>0; i--){
|
| + var parentModule = syms.slice(0, i).join(".");
|
| + if((i==1) && !this._moduleHasPrefix(parentModule)){
|
| + // Support default module directory (sibling of dojo) for top-level modules
|
| + syms[0] = "../" + syms[0];
|
| + }else{
|
| + var parentModulePath = this._getModulePrefix(parentModule);
|
| + if(parentModulePath != parentModule){
|
| + syms.splice(0, i, parentModulePath);
|
| + break;
|
| + }
|
| + }
|
| + }
|
| + //
|
| + return syms; // Array
|
| + }
|
| +
|
| + dojo._global_omit_module_check = false;
|
| +
|
| + dojo.loadInit = function(/*Function*/init){
|
| + // summary:
|
| + // Executes a function that needs to be executed for the loader's dojo.requireIf
|
| + // resolutions to work. This is needed mostly for the xdomain loader case where
|
| + // a function needs to be executed to set up the possible values for a dojo.requireIf
|
| + // call.
|
| + // init:
|
| + // a function reference. Executed immediately.
|
| + // description: This function is mainly a marker for the xdomain loader to know parts of
|
| + // code that needs be executed outside the function wrappper that is placed around modules.
|
| + // The init function could be executed more than once, and it should make no assumptions
|
| + // on what is loaded, or what modules are available. Only the functionality in Dojo Base
|
| + // is allowed to be used. Avoid using this method. For a valid use case,
|
| + // see the source for dojox.gfx.
|
| + init();
|
| + }
|
| +
|
| + dojo._loadModule = dojo.require = function(/*String*/moduleName, /*Boolean?*/omitModuleCheck){
|
| + // summary:
|
| + // loads a Javascript module from the appropriate URI
|
| + // moduleName:
|
| + // 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:
|
| + // 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:
|
| + // `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 excpetion 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`.
|
| + //
|
| + // `dojo.require()` does nothing about importing symbols into
|
| + // the current namespace. It is presumed that the caller will
|
| + // take care of that. 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
|
| + omitModuleCheck = this._global_omit_module_check || omitModuleCheck;
|
| +
|
| + //Check if it is already loaded.
|
| + var module = this._loadedModules[moduleName];
|
| + if(module){
|
| + return module;
|
| + }
|
| +
|
| + // convert periods to slashes
|
| + var relpath = this._getModuleSymbols(moduleName).join("/") + '.js';
|
| +
|
| + var modArg = (!omitModuleCheck) ? moduleName : null;
|
| + var ok = this._loadPath(relpath, modArg);
|
| +
|
| + if(!ok && !omitModuleCheck){
|
| + throw new Error("Could not load '" + moduleName + "'; last tried '" + relpath + "'");
|
| + }
|
| +
|
| + // check that the symbol was defined
|
| + // Don't bother if we're doing xdomain (asynchronous) loading.
|
| + if(!omitModuleCheck && !this._isXDomain){
|
| + // pass in false so we can give better error
|
| + module = this._loadedModules[moduleName];
|
| + if(!module){
|
| + throw new Error("symbol '" + moduleName + "' is not defined after loading '" + relpath + "'");
|
| + }
|
| + }
|
| +
|
| + return module;
|
| + }
|
| +
|
| + dojo.provide = function(/*String*/ resourceName){
|
| + // summary:
|
| + // Each javascript source file must have at least one
|
| + // `dojo.provide()` call at the top of the file, corresponding to
|
| + // the file name. For example, `js/dojo/foo.js` must have
|
| + // `dojo.provide("dojo.foo");` before any calls to
|
| + // `dojo.require()` are made.
|
| + // description:
|
| + // Each javascript source file is called a resource. When a
|
| + // resource is loaded by the browser, `dojo.provide()` registers
|
| + // that it has been loaded.
|
| + //
|
| + // For backwards compatibility reasons, in addition to registering
|
| + // the resource, `dojo.provide()` also ensures that the javascript
|
| + // object for the module exists. For example,
|
| + // `dojo.provide("dojox.data.FlickrStore")`, in addition to
|
| + // registering that `FlickrStore.js` is a resource for the
|
| + // `dojox.data` module, will ensure that the `dojox.data`
|
| + // javascript object exists, so that calls like
|
| + // `dojo.data.foo = function(){ ... }` don't fail.
|
| + //
|
| + // In the case of a build where multiple javascript source files
|
| + // are combined into one bigger file (similar to a .lib or .jar
|
| + // file), that file may contain multiple dojo.provide() calls, to
|
| + // note that it includes multiple resources.
|
| +
|
| + //Make sure we have a string.
|
| + resourceName = resourceName + "";
|
| + return (d._loadedModules[resourceName] = d.getObject(resourceName, true)); // Object
|
| + }
|
| +
|
| + //Start of old bootstrap2:
|
| +
|
| + 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 common = modMap.common || [];
|
| + var result = common.concat(modMap[d._name] || modMap["default"] || []);
|
| +
|
| + for(var x=0; x<result.length; x++){
|
| + var curr = result[x];
|
| + if(curr.constructor == Array){
|
| + d._loadModule.apply(d, curr);
|
| + }else{
|
| + d._loadModule(curr);
|
| + }
|
| + }
|
| + }
|
| +
|
| + dojo.requireIf = function(/*Boolean*/ condition, /*String*/ resourceName){
|
| + // summary:
|
| + // If the condition is true then call dojo.require() for the specified
|
| + // resource
|
| + if(condition === true){
|
| + // FIXME: why do we support chained require()'s here? does the build system?
|
| + var args = [];
|
| + for(var i = 1; i < arguments.length; i++){
|
| + args.push(arguments[i]);
|
| + }
|
| + d.require.apply(d, args);
|
| + }
|
| + }
|
| +
|
| + dojo.requireAfterIf = d.requireIf;
|
| +
|
| + dojo.registerModulePath = function(/*String*/module, /*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:
|
| + // | <script type="text/javascript"
|
| + // | src="/myapp/js/dojo/dojo/dojo.js"></script>
|
| + // | <script type="text/javascript">
|
| + // | dojo.registerModulePath("foo", "../../foo");
|
| + // | dojo.require("foo.bar");
|
| + // | dojo.require("foo.baz");
|
| + // | dojo.require("foo.thud.xyzzy");
|
| + // | </script>
|
| + d._modulePrefixes[module] = { name: module, value: prefix };
|
| + }
|
| +
|
| + dojo.requireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale, /*String?*/availableFlatLocales){
|
| + // summary:
|
| + // Declares translated resources and loads them if necessary, in the
|
| + // same style as dojo.require. Contents of the resource bundle are
|
| + // typically strings, but may be any name/value pair, represented in
|
| + // JSON format. See also `dojo.i18n.getLocalization`.
|
| + //
|
| + // description:
|
| + // Load translated resource bundles provided underneath the "nls"
|
| + // directory within a package. Translated resources may be located in
|
| + // different packages throughout the source tree.
|
| + //
|
| + // Each directory is named for a locale as specified by RFC 3066,
|
| + // (http://www.ietf.org/rfc/rfc3066.txt), normalized in lowercase.
|
| + // Note that the two bundles in the example do not define all the
|
| + // same variants. For a given locale, bundles will be loaded for
|
| + // that locale and all more general locales above it, including a
|
| + // fallback at the root directory. For example, a declaration for
|
| + // the "de-at" locale will first load `nls/de-at/bundleone.js`,
|
| + // then `nls/de/bundleone.js` and finally `nls/bundleone.js`. The
|
| + // data will be flattened into a single Object so that lookups
|
| + // will follow this cascading pattern. An optional build step can
|
| + // preload the bundles to avoid data redundancy and the multiple
|
| + // network hits normally required to load these resources.
|
| + //
|
| + // moduleName:
|
| + // name of the package containing the "nls" directory in which the
|
| + // bundle is found
|
| + //
|
| + // bundleName:
|
| + // bundle name, i.e. the filename without the '.js' suffix
|
| + //
|
| + // locale:
|
| + // the locale to load (optional) By default, the browser's user
|
| + // locale as defined by dojo.locale
|
| + //
|
| + // availableFlatLocales:
|
| + // A comma-separated list of the available, flattened locales for this
|
| + // bundle. This argument should only be set by the build process.
|
| + //
|
| + // example:
|
| + // A particular widget may define one or more resource bundles,
|
| + // structured in a program as follows, where moduleName is
|
| + // mycode.mywidget and bundleNames available include bundleone and
|
| + // bundletwo:
|
| + // | ...
|
| + // | mycode/
|
| + // | mywidget/
|
| + // | nls/
|
| + // | bundleone.js (the fallback translation, English in this example)
|
| + // | bundletwo.js (also a fallback translation)
|
| + // | de/
|
| + // | bundleone.js
|
| + // | bundletwo.js
|
| + // | de-at/
|
| + // | bundleone.js
|
| + // | en/
|
| + // | (empty; use the fallback translation)
|
| + // | en-us/
|
| + // | bundleone.js
|
| + // | en-gb/
|
| + // | bundleone.js
|
| + // | es/
|
| + // | bundleone.js
|
| + // | bundletwo.js
|
| + // | ...etc
|
| + // | ...
|
| + //
|
| +
|
| + d.require("dojo.i18n");
|
| + d.i18n._requireLocalization.apply(d.hostenv, arguments);
|
| + };
|
| +
|
| +
|
| + var ore = new RegExp("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$");
|
| + var ire = new RegExp("^((([^\\[:]+):)?([^@]+)@)?(\\[([^\\]]+)\\]|([^\\[:]*))(:([0-9]+))?$");
|
| +
|
| + dojo._Url = function(/*dojo._Url||String...*/){
|
| + // summary:
|
| + // Constructor to create an object representing a URL.
|
| + // It is marked as private, since we might consider removing
|
| + // or simplifying it.
|
| + // description:
|
| + // Each argument is evaluated in order relative to the next until
|
| + // a canonical uri is produced. To get an absolute Uri relative to
|
| + // the current document use:
|
| + // new dojo._Url(document.baseURI, url)
|
| +
|
| + var n = null;
|
| +
|
| + var _a = arguments;
|
| + var uri = [_a[0]];
|
| + // resolve uri components relative to each other
|
| + for(var i = 1; i<_a.length; i++){
|
| + if(!_a[i]){ continue; }
|
| +
|
| + // Safari doesn't support this.constructor so we have to be explicit
|
| + // FIXME: Tracked (and fixed) in Webkit bug 3537.
|
| + // http://bugs.webkit.org/show_bug.cgi?id=3537
|
| + var relobj = new d._Url(_a[i]+"");
|
| + var uriobj = new d._Url(uri[0]+"");
|
| +
|
| + if(
|
| + relobj.path == "" &&
|
| + !relobj.scheme &&
|
| + !relobj.authority &&
|
| + !relobj.query
|
| + ){
|
| + if(relobj.fragment != n){
|
| + uriobj.fragment = relobj.fragment;
|
| + }
|
| + relobj = uriobj;
|
| + }else if(!relobj.scheme){
|
| + relobj.scheme = uriobj.scheme;
|
| +
|
| + if(!relobj.authority){
|
| + relobj.authority = uriobj.authority;
|
| +
|
| + if(relobj.path.charAt(0) != "/"){
|
| + var path = uriobj.path.substring(0,
|
| + uriobj.path.lastIndexOf("/") + 1) + relobj.path;
|
| +
|
| + var segs = path.split("/");
|
| + for(var j = 0; j < segs.length; j++){
|
| + if(segs[j] == "."){
|
| + // flatten "./" references
|
| + if(j == segs.length - 1){
|
| + segs[j] = "";
|
| + }else{
|
| + segs.splice(j, 1);
|
| + j--;
|
| + }
|
| + }else if(j > 0 && !(j == 1 && segs[0] == "") &&
|
| + segs[j] == ".." && segs[j-1] != ".."){
|
| + // flatten "../" references
|
| + if(j == (segs.length - 1)){
|
| + segs.splice(j, 1);
|
| + segs[j - 1] = "";
|
| + }else{
|
| + segs.splice(j - 1, 2);
|
| + j -= 2;
|
| + }
|
| + }
|
| + }
|
| + relobj.path = segs.join("/");
|
| + }
|
| + }
|
| + }
|
| +
|
| + uri = [];
|
| + if(relobj.scheme){
|
| + uri.push(relobj.scheme, ":");
|
| + }
|
| + if(relobj.authority){
|
| + uri.push("//", relobj.authority);
|
| + }
|
| + uri.push(relobj.path);
|
| + if(relobj.query){
|
| + uri.push("?", relobj.query);
|
| + }
|
| + if(relobj.fragment){
|
| + uri.push("#", relobj.fragment);
|
| + }
|
| + }
|
| +
|
| + this.uri = uri.join("");
|
| +
|
| + // break the uri into its main components
|
| + var r = this.uri.match(ore);
|
| +
|
| + this.scheme = r[2] || (r[1] ? "" : n);
|
| + this.authority = r[4] || (r[3] ? "" : n);
|
| + this.path = r[5]; // can never be undefined
|
| + this.query = r[7] || (r[6] ? "" : n);
|
| + this.fragment = r[9] || (r[8] ? "" : n);
|
| +
|
| + if(this.authority != n){
|
| + // server based naming authority
|
| + r = this.authority.match(ire);
|
| +
|
| + this.user = r[3] || n;
|
| + this.password = r[4] || n;
|
| + this.host = r[6] || r[7]; // ipv6 || ipv4
|
| + this.port = r[9] || n;
|
| + }
|
| + }
|
| +
|
| + dojo._Url.prototype.toString = function(){ return this.uri; };
|
| +
|
| + dojo.moduleUrl = function(/*String*/module, /*dojo._Url||String*/url){
|
| + // summary:
|
| + // Returns a `dojo._Url` object relative to a module.
|
| + // example:
|
| + // | var pngPath = dojo.moduleUrl("acme","images/small.png");
|
| + // | // list the object properties
|
| + // | // create an image and set it's source to pngPath's value:
|
| + // | var img = document.createElement("img");
|
| + // | // NOTE: we assign the string representation of the url object
|
| + // | img.src = pngPath.toString();
|
| + // | // add our image to the document
|
| + // | dojo.body().appendChild(img);
|
| + // example:
|
| + // you may de-reference as far as you like down the package
|
| + // hierarchy. This is sometimes handy to avoid lenghty relative
|
| + // urls or for building portable sub-packages. In this example,
|
| + // the `acme.widget` and `acme.util` directories may be located
|
| + // under different roots (see `dojo.registerModulePath`) but the
|
| + // the modules which reference them can be unaware of their
|
| + // relative locations on the filesystem:
|
| + // | // somewhere in a configuration block
|
| + // | dojo.registerModulePath("acme.widget", "../../acme/widget");
|
| + // | dojo.registerModulePath("acme.util", "../../util");
|
| + // |
|
| + // | // ...
|
| + // |
|
| + // | // code in a module using acme resources
|
| + // | var tmpltPath = dojo.moduleUrl("acme.widget","templates/template.html");
|
| + // | var dataPath = dojo.moduleUrl("acme.util","resources/data.json");
|
| +
|
| + var loc = d._getModuleSymbols(module).join('/');
|
| + if(!loc){ return null; }
|
| + if(loc.lastIndexOf("/") != loc.length-1){
|
| + loc += "/";
|
| + }
|
| +
|
| + //If the path is an absolute path (starts with a / or is on another
|
| + //domain/xdomain) then don't add the baseUrl.
|
| + var colonIndex = loc.indexOf(":");
|
| + if(loc.charAt(0) != "/" && (colonIndex == -1 || colonIndex > loc.indexOf("/"))){
|
| + loc = d.baseUrl + loc;
|
| + }
|
| +
|
| + return new d._Url(loc, url); // String
|
| + }
|
| +})();
|
| +
|
| +/*=====
|
| +dojo.isBrowser = {
|
| + // example:
|
| + // | if(dojo.isBrowser){ ... }
|
| +};
|
| +
|
| +dojo.isFF = {
|
| + // example:
|
| + // | if(dojo.isFF > 1){ ... }
|
| +};
|
| +
|
| +dojo.isIE = {
|
| + // example:
|
| + // | if(dojo.isIE > 6){
|
| + // | // we are IE7
|
| + // | }
|
| +};
|
| +
|
| +dojo.isSafari = {
|
| + // example:
|
| + // | if(dojo.isSafari){ ... }
|
| + // example:
|
| + // Detect iPhone:
|
| + // | if(dojo.isSafari && navigator.userAgent.indexOf("iPhone") != -1){
|
| + // | // we are iPhone. Note, iPod touch reports "iPod" above and fails this test.
|
| + // | }
|
| +};
|
| +
|
| +dojo = {
|
| + // isBrowser: Boolean
|
| + // True if the client is a web-browser
|
| + isBrowser: true,
|
| + // isFF: Number | undefined
|
| + // Version as a Number if client is FireFox. undefined otherwise. Corresponds to
|
| + // major detected FireFox version (1.5, 2, 3, etc.)
|
| + isFF: 2,
|
| + // isIE: Number | undefined
|
| + // Version as a Number if client is MSIE(PC). undefined otherwise. Corresponds to
|
| + // major detected IE version (6, 7, 8, etc.)
|
| + isIE: 6,
|
| + // isKhtml: Number | undefined
|
| + // Version as a Number if client is a KTHML-derived browser (Konqueror,
|
| + // Safari, etc.). undefined otherwise. Corresponds to major detected version.
|
| + isKhtml: 0,
|
| + // isMozilla: Number | undefined
|
| + // Version as a Number if client is a Mozilla-based browser (Firefox,
|
| + // SeaMonkey). undefined otherwise. Corresponds to major detected version.
|
| + isMozilla: 0,
|
| + // isOpera: Number | undefined
|
| + // Version as a Number if client is Opera. undefined otherwise. Corresponds to
|
| + // major detected version.
|
| + isOpera: 0,
|
| + // isSafari: Number | undefined
|
| + // Version as a Number if client is Safari or iPhone. undefined otherwise.
|
| + isSafari: 0
|
| +}
|
| +=====*/
|
| +
|
| +if(typeof window != 'undefined'){
|
| + dojo.isBrowser = true;
|
| + dojo._name = "browser";
|
| +
|
| +
|
| + // attempt to figure out the path to dojo if it isn't set in the config
|
| + (function(){
|
| + var d = dojo;
|
| + // this is a scope protection closure. We set browser versions and grab
|
| + // the URL we were loaded from here.
|
| +
|
| + // grab the node we were loaded from
|
| + if(document && document.getElementsByTagName){
|
| + var scripts = document.getElementsByTagName("script");
|
| + var rePkg = /dojo(\.xd)?\.js(\W|$)/i;
|
| + for(var i = 0; i < scripts.length; i++){
|
| + var src = scripts[i].getAttribute("src");
|
| + if(!src){ continue; }
|
| + var m = src.match(rePkg);
|
| + if(m){
|
| + // find out where we came from
|
| + if(!d.config.baseUrl){
|
| + d.config.baseUrl = src.substring(0, m.index);
|
| + }
|
| + // and find out if we need to modify our behavior
|
| + var cfg = scripts[i].getAttribute("djConfig");
|
| + if(cfg){
|
| + var cfgo = eval("({ "+cfg+" })");
|
| + for(var x in cfgo){
|
| + dojo.config[x] = cfgo[x];
|
| + }
|
| + }
|
| + break; // "first Dojo wins"
|
| + }
|
| + }
|
| + }
|
| + d.baseUrl = d.config.baseUrl;
|
| +
|
| + // fill in the rendering support information in dojo.render.*
|
| + var n = navigator;
|
| + var dua = n.userAgent;
|
| + var dav = n.appVersion;
|
| + var tv = parseFloat(dav);
|
| +
|
| + if(dua.indexOf("Opera") >= 0){ d.isOpera = tv; }
|
| + // safari detection derived from:
|
| + // http://developer.apple.com/internet/safari/faq.html#anchor2
|
| + // http://developer.apple.com/internet/safari/uamatrix.html
|
| + var index = Math.max(dav.indexOf("WebKit"), dav.indexOf("Safari"), 0);
|
| + if(index){
|
| + // try to grab the explicit Safari version first. If we don't get
|
| + // one, look for 419.3+ as the indication that we're on something
|
| + // "Safari 3-ish". Lastly, default to "Safari 2" handling.
|
| + d.isSafari = parseFloat(dav.split("Version/")[1]) ||
|
| + (parseFloat(dav.substr(index + 7)) > 419.3) ? 3 : 2;
|
| + }
|
| + if(dua.indexOf("AdobeAIR") >= 0){ d.isAIR = 1; }
|
| + if(dav.indexOf("Konqueror") >= 0 || d.isSafari){ d.isKhtml = tv; }
|
| + if(dua.indexOf("Gecko") >= 0 && !d.isKhtml){ d.isMozilla = d.isMoz = tv; }
|
| + if(d.isMoz){
|
| + d.isFF = parseFloat(dua.split("Firefox/")[1]) || undefined;
|
| + }
|
| + if(document.all && !d.isOpera){
|
| + d.isIE = parseFloat(dav.split("MSIE ")[1]) || undefined;
|
| + }
|
| +
|
| + //Workaround to get local file loads of dojo to work on IE 7
|
| + //by forcing to not use native xhr.
|
| + if(dojo.isIE && window.location.protocol === "file:"){
|
| + dojo.config.ieForceActiveXXhr=true;
|
| + }
|
| +
|
| + var cm = document.compatMode;
|
| + d.isQuirks = cm == "BackCompat" || cm == "QuirksMode" || d.isIE < 6;
|
| +
|
| + // TODO: is the HTML LANG attribute relevant?
|
| + d.locale = dojo.config.locale || (d.isIE ? n.userLanguage : n.language).toLowerCase();
|
| +
|
| + // These are in order of decreasing likelihood; this will change in time.
|
| + d._XMLHTTP_PROGIDS = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'];
|
| +
|
| + d._xhrObj = function(){
|
| + // summary:
|
| + // does the work of portably generating a new XMLHTTPRequest
|
| + // object.
|
| + var http = null;
|
| + var last_e = null;
|
| + if(!dojo.isIE || !dojo.config.ieForceActiveXXhr){
|
| + try{ http = new XMLHttpRequest(); }catch(e){}
|
| + }
|
| + if(!http){
|
| + for(var i=0; i<3; ++i){
|
| + var progid = d._XMLHTTP_PROGIDS[i];
|
| + try{
|
| + http = new ActiveXObject(progid);
|
| + }catch(e){
|
| + last_e = e;
|
| + }
|
| +
|
| + if(http){
|
| + d._XMLHTTP_PROGIDS = [progid]; // so faster next time
|
| + break;
|
| + }
|
| + }
|
| + }
|
| +
|
| + if(!http){
|
| + throw new Error("XMLHTTP not available: "+last_e);
|
| + }
|
| +
|
| + return http; // XMLHTTPRequest instance
|
| + }
|
| +
|
| + d._isDocumentOk = function(http){
|
| + var stat = http.status || 0;
|
| + return (stat >= 200 && stat < 300) || // Boolean
|
| + stat == 304 || // allow any 2XX response code
|
| + stat == 1223 || // get it out of the cache
|
| + (!stat && (location.protocol=="file:" || location.protocol=="chrome:") ); // Internet Explorer mangled the status code
|
| + }
|
| +
|
| + //See if base tag is in use.
|
| + //This is to fix http://trac.dojotoolkit.org/ticket/3973,
|
| + //but really, we need to find out how to get rid of the dojo._Url reference
|
| + //below and still have DOH work with the dojo.i18n test following some other
|
| + //test that uses the test frame to load a document (trac #2757).
|
| + //Opera still has problems, but perhaps a larger issue of base tag support
|
| + //with XHR requests (hasBase is true, but the request is still made to document
|
| + //path, not base path).
|
| + var owloc = window.location+"";
|
| + var base = document.getElementsByTagName("base");
|
| + var hasBase = (base && base.length > 0);
|
| +
|
| + d._getText = function(/*URI*/ uri, /*Boolean*/ fail_ok){
|
| + // summary: Read the contents of the specified uri and return those contents.
|
| + // uri:
|
| + // A relative or absolute uri. If absolute, it still must be in
|
| + // the same "domain" as we are.
|
| + // fail_ok:
|
| + // Default false. If fail_ok and loading fails, return null
|
| + // instead of throwing.
|
| + // returns: The response text. null is returned when there is a
|
| + // failure and failure is okay (an exception otherwise)
|
| +
|
| + // alert("_getText: " + uri);
|
| +
|
| + // NOTE: must be declared before scope switches ie. this._xhrObj()
|
| + var http = this._xhrObj();
|
| +
|
| + if(!hasBase && dojo._Url){
|
| + uri = (new dojo._Url(owloc, uri)).toString();
|
| + }
|
| + /*
|
| +
|
| +
|
| + alert(uri);
|
| + */
|
| +
|
| + if(d.config.cacheBust){
|
| + //Make sure we have a string before string methods are used on uri
|
| + uri += "";
|
| + uri += (uri.indexOf("?") == -1 ? "?" : "&") + String(d.config.cacheBust).replace(/\W+/g,"");
|
| + }
|
| +
|
| + http.open('GET', uri, false);
|
| + try{
|
| + http.send(null);
|
| + // alert(http);
|
| + if(!d._isDocumentOk(http)){
|
| + var err = Error("Unable to load "+uri+" status:"+ http.status);
|
| + err.status = http.status;
|
| + err.responseText = http.responseText;
|
| + throw err;
|
| + }
|
| + }catch(e){
|
| + if(fail_ok){ return null; } // null
|
| + // rethrow the exception
|
| + throw e;
|
| + }
|
| + return http.responseText; // String
|
| + }
|
| +
|
| + d._windowUnloaders = [];
|
| +
|
| + d.windowUnloaded = function(){
|
| + // summary:
|
| + // signal fired by impending window destruction. You may use
|
| + // dojo.addOnWIndowUnload() or dojo.connect() to this method to perform
|
| + // page/application cleanup methods. See dojo.addOnWindowUnload for more info.
|
| + var mll = this._windowUnloaders;
|
| + while(mll.length){
|
| + (mll.pop())();
|
| + }
|
| + }
|
| +
|
| + d.addOnWindowUnload = function(/*Object?*/obj, /*String|Function?*/functionName){
|
| + // summary:
|
| + // registers a function to be triggered when window.onunload fires.
|
| + // Be careful trying to modify the DOM or access JavaScript properties
|
| + // during this phase of page unloading: they may not always be available.
|
| + // Consider dojo.addOnUnload() if you need to modify the DOM or do heavy
|
| + // JavaScript work.
|
| + // example:
|
| + // | dojo.addOnWindowUnload(functionPointer)
|
| + // | dojo.addOnWindowUnload(object, "functionName")
|
| + // | dojo.addOnWindowUnload(object, function(){ /* ... */});
|
| +
|
| + d._onto(d._windowUnloaders, obj, functionName);
|
| + }
|
| + })();
|
| +
|
| + dojo._initFired = false;
|
| + // BEGIN DOMContentLoaded, from Dean Edwards (http://dean.edwards.name/weblog/2006/06/again/)
|
| + dojo._loadInit = function(e){
|
| + dojo._initFired = true;
|
| + // allow multiple calls, only first one will take effect
|
| + // A bug in khtml calls events callbacks for document for event which isnt supported
|
| + // for example a created contextmenu event calls DOMContentLoaded, workaround
|
| + var type = (e && e.type) ? e.type.toLowerCase() : "load";
|
| + if(arguments.callee.initialized || (type != "domcontentloaded" && type != "load")){ return; }
|
| + arguments.callee.initialized = true;
|
| + if("_khtmlTimer" in dojo){
|
| + clearInterval(dojo._khtmlTimer);
|
| + delete dojo._khtmlTimer;
|
| + }
|
| +
|
| + if(dojo._inFlightCount == 0){
|
| + dojo._modulesLoaded();
|
| + }
|
| + }
|
| +
|
| + dojo._fakeLoadInit = function(){
|
| + dojo._loadInit({type: "load"});
|
| + }
|
| +
|
| + if(!dojo.config.afterOnLoad){
|
| + // START DOMContentLoaded
|
| + // Mozilla and Opera 9 expose the event we could use
|
| + if(document.addEventListener){
|
| + // NOTE:
|
| + // due to a threading issue in Firefox 2.0, we can't enable
|
| + // DOMContentLoaded on that platform. For more information, see:
|
| + // http://trac.dojotoolkit.org/ticket/1704
|
| + if(dojo.isOpera || dojo.isFF >= 3 || (dojo.isMoz && dojo.config.enableMozDomContentLoaded === true)){
|
| + document.addEventListener("DOMContentLoaded", dojo._loadInit, null);
|
| + }
|
| +
|
| + // mainly for Opera 8.5, won't be fired if DOMContentLoaded fired already.
|
| + // also used for Mozilla because of trac #1640
|
| + window.addEventListener("load", dojo._loadInit, null);
|
| + }
|
| +
|
| + if(dojo.isAIR){
|
| + window.addEventListener("load", dojo._loadInit, null);
|
| + }else if(/(WebKit|khtml)/i.test(navigator.userAgent)){ // sniff
|
| + dojo._khtmlTimer = setInterval(function(){
|
| + if(/loaded|complete/.test(document.readyState)){
|
| + dojo._loadInit(); // call the onload handler
|
| + }
|
| + }, 10);
|
| + }
|
| + // END DOMContentLoaded
|
| + }
|
| +
|
| + (function(){
|
| + var _w = window;
|
| + var _handleNodeEvent = function(/*String*/evtName, /*Function*/fp){
|
| + // summary:
|
| + // non-destructively adds the specified function to the node's
|
| + // evtName handler.
|
| + // evtName: should be in the form "onclick" for "onclick" handlers.
|
| + // Make sure you pass in the "on" part.
|
| + var oldHandler = _w[evtName] || function(){};
|
| + _w[evtName] = function(){
|
| + fp.apply(_w, arguments);
|
| + oldHandler.apply(_w, arguments);
|
| + };
|
| + };
|
| +
|
| + if(dojo.isIE){
|
| + // for Internet Explorer. readyState will not be achieved on init
|
| + // call, but dojo doesn't need it however, we'll include it
|
| + // because we don't know if there are other functions added that
|
| + // might. Note that this has changed because the build process
|
| + // strips all comments -- including conditional ones.
|
| + if(!dojo.config.afterOnLoad){
|
| + document.write('<scr'+'ipt defer src="//:" '
|
| + + 'onreadystatechange="if(this.readyState==\'complete\'){' + dojo._scopeName + '._loadInit();}">'
|
| + + '</scr'+'ipt>'
|
| + );
|
| + }
|
| +
|
| + try{
|
| + document.namespaces.add("v","urn:schemas-microsoft-com:vml");
|
| + document.createStyleSheet().addRule("v\\:*", "behavior:url(#default#VML)");
|
| + }catch(e){}
|
| + }
|
| +
|
| + // FIXME: dojo.unloaded requires dojo scope, so using anon function wrapper.
|
| + _handleNodeEvent("onbeforeunload", function() { dojo.unloaded(); });
|
| + _handleNodeEvent("onunload", function() { dojo.windowUnloaded(); });
|
| + })();
|
| +
|
| + /*
|
| + OpenAjax.subscribe("OpenAjax", "onload", function(){
|
| + if(dojo._inFlightCount == 0){
|
| + dojo._modulesLoaded();
|
| + }
|
| + });
|
| +
|
| + OpenAjax.subscribe("OpenAjax", "onunload", function(){
|
| + dojo.unloaded();
|
| + });
|
| + */
|
| +} //if (typeof window != 'undefined')
|
| +
|
| +//Register any module paths set up in djConfig. Need to do this
|
| +//in the hostenvs since hostenv_browser can read djConfig from a
|
| +//script tag's attribute.
|
| +(function(){
|
| + var mp = dojo.config["modulePaths"];
|
| + if(mp){
|
| + for(var param in mp){
|
| + dojo.registerModulePath(param, mp[param]);
|
| + }
|
| + }
|
| +})();
|
| +
|
| +//Load debug code if necessary.
|
| +if(dojo.config.isDebug){
|
| + dojo.require("dojo._firebug.firebug");
|
| +}
|
| +
|
| +if(dojo.config.debugAtAllCosts){
|
| + dojo.config.useXDomain = true;
|
| + dojo.require("dojo._base._loader.loader_xd");
|
| + dojo.require("dojo._base._loader.loader_debug");
|
| + dojo.require("dojo.i18n");
|
| +}
|
| +
|
| +if(!dojo._hasResource["dojo._base.lang"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
|
| +dojo._hasResource["dojo._base.lang"] = true;
|
| +dojo.provide("dojo._base.lang");
|
| +
|
| +// Crockford (ish) functions
|
| +
|
| +dojo.isString = function(/*anything*/ it){
|
| + // summary:
|
| + // Return true if it is a String
|
| + return !!arguments.length && it != null && (typeof it == "string" || it instanceof String); // Boolean
|
| +}
|
| +
|
| +dojo.isArray = function(/*anything*/ it){
|
| + // summary:
|
| + // Return true if it is an Array
|
| + return it && (it instanceof Array || typeof it == "array"); // Boolean
|
| +}
|
| +
|
| +/*=====
|
| +dojo.isFunction = function(it){
|
| + // summary: Return true if it is a Function
|
| + // it: anything
|
| + return; // Boolean
|
| +}
|
| +=====*/
|
| +
|
| +dojo.isFunction = (function(){
|
| + var _isFunction = function(/*anything*/ it){
|
| + return it && (typeof it == "function" || it instanceof Function); // Boolean
|
| + };
|
| +
|
| + return dojo.isSafari ?
|
| + // only slow this down w/ gratuitious casting in Safari since it's what's b0rken
|
| + function(/*anything*/ it){
|
| + if(typeof it == "function" && it == "[object NodeList]"){ return false; }
|
| + return _isFunction(it); // Boolean
|
| + } : _isFunction;
|
| +})();
|
| +
|
| +dojo.isObject = function(/*anything*/ it){
|
| + // summary:
|
| + // Returns true if it is a JavaScript object (or an Array, a Function
|
| + // or null)
|
| + return it !== undefined &&
|
| + (it === null || typeof it == "object" || dojo.isArray(it) || dojo.isFunction(it)); // Boolean
|
| +}
|
| +
|
| +dojo.isArrayLike = function(/*anything*/ it){
|
| + // summary:
|
| + // similar to dojo.isArray() but more permissive
|
| + // description:
|
| + // Doesn't strongly test for "arrayness". Instead, settles for "isn't
|
| + // a string or number and has a length property". Arguments objects
|
| + // and DOM collections will return true when passed to
|
| + // dojo.isArrayLike(), but will return false when passed to
|
| + // dojo.isArray().
|
| + // returns:
|
| + // If it walks like a duck and quicks like a duck, return `true`
|
| + var d = dojo;
|
| + return it && it !== undefined && // Boolean
|
| + // keep out built-in constructors (Number, String, ...) which have length
|
| + // properties
|
| + !d.isString(it) && !d.isFunction(it) &&
|
| + !(it.tagName && it.tagName.toLowerCase() == 'form') &&
|
| + (d.isArray(it) || isFinite(it.length));
|
| +}
|
| +
|
| +dojo.isAlien = function(/*anything*/ it){
|
| + // summary:
|
| + // Returns true if it is a built-in function or some other kind of
|
| + // oddball that *should* report as a function but doesn't
|
| + return it && !dojo.isFunction(it) && /\{\s*\[native code\]\s*\}/.test(String(it)); // Boolean
|
| +}
|
| +
|
| +dojo.extend = function(/*Object*/ constructor, /*Object...*/ props){
|
| + // summary:
|
| + // Adds all properties and methods of props to constructor's
|
| + // prototype, making them available to all instances created with
|
| + // constructor.
|
| + for(var i=1, l=arguments.length; i<l; i++){
|
| + dojo._mixin(constructor.prototype, arguments[i]);
|
| + }
|
| + return constructor; // Object
|
| +}
|
| +
|
| +dojo._hitchArgs = function(scope, method /*,...*/){
|
| + var pre = dojo._toArray(arguments, 2);
|
| + var named = dojo.isString(method);
|
| + return function(){
|
| + // arrayify arguments
|
| + var args = dojo._toArray(arguments);
|
| + // locate our method
|
| + var f = named ? (scope||dojo.global)[method] : method;
|
| + // invoke with collected args
|
| + return f && f.apply(scope || this, pre.concat(args)); // mixed
|
| + } // Function
|
| +}
|
| +
|
| +dojo.hitch = function(/*Object*/scope, /*Function|String*/method /*,...*/){
|
| + // summary:
|
| + // Returns a function that will only ever execute in the a given scope.
|
| + // This allows for easy use of object member functions
|
| + // in callbacks and other places in which the "this" keyword may
|
| + // otherwise not reference the expected scope.
|
| + // Any number of default positional arguments may be passed as parameters
|
| + // beyond "method".
|
| + // Each of these values will be used to "placehold" (similar to curry)
|
| + // for the hitched function.
|
| + // scope:
|
| + // The scope to use when method executes. If method is a string,
|
| + // scope is also the object containing method.
|
| + // method:
|
| + // A function to be hitched to scope, or the name of the method in
|
| + // scope to be hitched.
|
| + // example:
|
| + // | dojo.hitch(foo, "bar")();
|
| + // runs foo.bar() in the scope of foo
|
| + // example:
|
| + // | dojo.hitch(foo, myFunction);
|
| + // returns a function that runs myFunction in the scope of foo
|
| + if(arguments.length > 2){
|
| + return dojo._hitchArgs.apply(dojo, arguments); // Function
|
| + }
|
| + if(!method){
|
| + method = scope;
|
| + scope = null;
|
| + }
|
| + if(dojo.isString(method)){
|
| + scope = scope || dojo.global;
|
| + if(!scope[method]){ throw(['dojo.hitch: scope["', method, '"] is null (scope="', scope, '")'].join('')); }
|
| + return function(){ return scope[method].apply(scope, arguments || []); }; // Function
|
| + }
|
| + return !scope ? method : function(){ return method.apply(scope, arguments || []); }; // Function
|
| +}
|
| +
|
| +/*=====
|
| +dojo.delegate = function(obj, props){
|
| + // summary:
|
| + // returns a new object which "looks" to obj for properties which it
|
| + // does not have a value for. Optionally takes a bag of properties to
|
| + // seed the returned object with initially.
|
| + // description:
|
| + // This is a small implementaton of the Boodman/Crockford delegation
|
| + // pattern in JavaScript. An intermediate object constructor mediates
|
| + // the prototype chain for the returned object, using it to delegate
|
| + // down to obj for property lookup when object-local lookup fails.
|
| + // This can be thought of similarly to ES4's "wrap", save that it does
|
| + // not act on types but rather on pure objects.
|
| + // obj:
|
| + // The object to delegate to for properties not found directly on the
|
| + // return object or in props.
|
| + // props:
|
| + // an object containing properties to assign to the returned object
|
| + // returns:
|
| + // an Object of anonymous type
|
| + // example:
|
| + // | var foo = { bar: "baz" };
|
| + // | var thinger = dojo.delegate(foo, { thud: "xyzzy"});
|
| + // | thinger.bar == "baz"; // delegated to foo
|
| + // | foo.thud == undefined; // by definition
|
| + // | thinger.thud == "xyzzy"; // mixed in from props
|
| + // | foo.bar = "thonk";
|
| + // | thinger.bar == "thonk"; // still delegated to foo's bar
|
| +}
|
| +=====*/
|
| +
|
| +dojo.delegate = dojo._delegate = (function(){
|
| + // boodman/crockford delegation w/ cornford optimization
|
| + function TMP(){};
|
| + return function(obj, props){
|
| + TMP.prototype = obj;
|
| + var tmp = new TMP();
|
| + if(props){
|
| + dojo._mixin(tmp, props);
|
| + }
|
| + return tmp; // Object
|
| + }
|
| +})();
|
| +
|
| +/*=====
|
| +dojo._toArray = function(obj, offset, startWith){
|
| + // summary:
|
| + // Converts an array-like object (i.e. arguments, DOMCollection) to an
|
| + // array. Returns a new Array with the elements of obj.
|
| + // obj: Object
|
| + // the object to "arrayify". We expect the object to have, at a
|
| + // minimum, a length property which corresponds to integer-indexed
|
| + // properties.
|
| + // offset: Number?
|
| + // the location in obj to start iterating from. Defaults to 0.
|
| + // Optional.
|
| + // startWith: Array?
|
| + // An array to pack with the properties of obj. If provided,
|
| + // properties in obj are appended at the end of startWith and
|
| + // startWith is the returned array.
|
| +}
|
| +=====*/
|
| +
|
| +(function(){
|
| + var efficient = function(obj, offset, startWith){
|
| + return (startWith||[]).concat(Array.prototype.slice.call(obj, offset||0));
|
| + };
|
| +
|
| + var slow = function(obj, offset, startWith){
|
| + var arr = startWith||[];
|
| + for(var x = offset || 0; x < obj.length; x++){
|
| + arr.push(obj[x]);
|
| + }
|
| + return arr;
|
| + };
|
| +
|
| + dojo._toArray = (!dojo.isIE) ? efficient : function(obj){
|
| + return ((obj.item) ? slow : efficient).apply(this, arguments);
|
| + };
|
| +
|
| +})();
|
| +
|
| +dojo.partial = function(/*Function|String*/method /*, ...*/){
|
| + // summary:
|
| + // similar to hitch() except that the scope object is left to be
|
| + // whatever the execution context eventually becomes.
|
| + // description:
|
| + // Calling dojo.partial is the functional equivalent of calling:
|
| + // | dojo.hitch(null, funcName, ...);
|
| + var arr = [ null ];
|
| + return dojo.hitch.apply(dojo, arr.concat(dojo._toArray(arguments))); // Function
|
| +}
|
| +
|
| +dojo.clone = function(/*anything*/ o){
|
| + // summary:
|
| + // Clones objects (including DOM nodes) and all children.
|
| + // Warning: do not clone cyclic structures.
|
| + if(!o){ return o; }
|
| + if(dojo.isArray(o)){
|
| + var r = [];
|
| + for(var i = 0; i < o.length; ++i){
|
| + r.push(dojo.clone(o[i]));
|
| + }
|
| + return r; // Array
|
| + }
|
| + if(!dojo.isObject(o)){
|
| + return o; /*anything*/
|
| + }
|
| + if(o.nodeType && o.cloneNode){ // isNode
|
| + return o.cloneNode(true); // Node
|
| + }
|
| + if(o instanceof Date){
|
| + return new Date(o.getTime()); // Date
|
| + }
|
| + // Generic objects
|
| + var r = new o.constructor(); // specific to dojo.declare()'d classes!
|
| + for(var i in o){
|
| + if(!(i in r) || r[i] != o[i]){
|
| + r[i] = dojo.clone(o[i]);
|
| + }
|
| + }
|
| + return r; // Object
|
| +}
|
| +
|
| +dojo.trim = function(/*String*/ str){
|
| + // summary:
|
| + // trims whitespaces from both sides of the string
|
| + // description:
|
| + // This version of trim() was selected for inclusion into the base due
|
| + // to its compact size and relatively good performance (see Steven
|
| + // Levithan's blog:
|
| + // http://blog.stevenlevithan.com/archives/faster-trim-javascript).
|
| + // The fastest but longest version of this function is located at
|
| + // dojo.string.trim()
|
| + return str.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); // String
|
| +}
|
| +
|
| +}
|
| +
|
| +if(!dojo._hasResource["dojo._base.declare"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
|
| +dojo._hasResource["dojo._base.declare"] = true;
|
| +dojo.provide("dojo._base.declare");
|
| +
|
| +
|
| +// this file courtesy of the TurboAjax Group, licensed under a Dojo CLA
|
| +
|
| +dojo.declare = function(/*String*/ className, /*Function|Function[]*/ superclass, /*Object*/ props){
|
| + // summary:
|
| + // Create a feature-rich constructor from compact notation
|
| + // className:
|
| + // The name of the constructor (loosely, a "class")
|
| + // stored in the "declaredClass" property in the created prototype
|
| + // superclass:
|
| + // May be null, a Function, or an Array of Functions. If an array,
|
| + // the first element is used as the prototypical ancestor and
|
| + // any following Functions become mixin ancestors.
|
| + // props:
|
| + // An object whose properties are copied to the
|
| + // created prototype.
|
| + // Add an instance-initialization function by making it a property
|
| + // named "constructor".
|
| + // description:
|
| + // Create a constructor using a compact notation for inheritance and
|
| + // prototype extension.
|
| + //
|
| + // All superclasses (including mixins) must be Functions (not simple Objects).
|
| + //
|
| + // 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.
|
| + //
|
| + // "className" is cached in "declaredClass" property of the new class.
|
| + //
|
| + // 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();
|
| + // | }
|
| + // | );
|
| +
|
| + // process superclass argument
|
| + var dd = arguments.callee, mixins;
|
| + if(dojo.isArray(superclass)){
|
| + mixins = superclass;
|
| + superclass = mixins.shift();
|
| + }
|
| + // construct intermediate classes for mixins
|
| + if(mixins){
|
| + dojo.forEach(mixins, function(m){
|
| + if(!m){ throw(className + ": mixin #" + i + " is null"); } // It's likely a required module is not loaded
|
| + superclass = dd._delegate(superclass, m);
|
| + });
|
| + }
|
| + // create constructor
|
| + var ctor = dd._delegate(superclass);
|
| + // extend with "props"
|
| + props = props || {};
|
| + ctor.extend(props);
|
| + // more prototype decoration
|
| + dojo.extend(ctor, {declaredClass: className, _constructor: props.constructor/*, preamble: null*/});
|
| + // special help for IE
|
| + ctor.prototype.constructor = ctor;
|
| + // create named reference
|
| + return dojo.setObject(className, ctor); // Function
|
| +};
|
| +
|
| +dojo.mixin(dojo.declare, {
|
| + _delegate: function(base, mixin){
|
| + var bp = (base||0).prototype, mp = (mixin||0).prototype, dd=dojo.declare;
|
| + // fresh constructor, fresh prototype
|
| + var ctor = dd._makeCtor();
|
| + // cache ancestry
|
| + dojo.mixin(ctor, {superclass: bp, mixin: mp, extend: dd._extend});
|
| + // chain prototypes
|
| + if(base){ctor.prototype = dojo._delegate(bp);}
|
| + // add mixin and core
|
| + dojo.extend(ctor, dd._core, mp||0, {_constructor: null, preamble: null});
|
| + // special help for IE
|
| + ctor.prototype.constructor = ctor;
|
| + // name this class for debugging
|
| + ctor.prototype.declaredClass = (bp||0).declaredClass + '_' + (mp||0).declaredClass;
|
| + return ctor;
|
| + },
|
| + _extend: function(props){
|
| + var i, fn;
|
| + for(i in props){ if(dojo.isFunction(fn=props[i]) && !0[i]){fn.nom=i;fn.ctor=this;} }
|
| + dojo.extend(this, props);
|
| + },
|
| + _makeCtor: function(){
|
| + // we have to make a function, but don't want to close over anything
|
| + return function(){ this._construct(arguments); };
|
| + },
|
| + _core: {
|
| + _construct: function(args){
|
| + var c=args.callee, s=c.superclass, ct=s&&s.constructor, m=c.mixin, mct=m&&m.constructor, a=args, ii, fn;
|
| + // side-effect of = used on purpose here, lint may complain, don't try this at home
|
| + if(a[0]){
|
| + // FIXME: preambles for each mixin should be allowed
|
| + // FIXME:
|
| + // should we allow the preamble here NOT to modify the
|
| + // default args, but instead to act on each mixin
|
| + // independently of the class instance being constructed
|
| + // (for impedence matching)?
|
| +
|
| + // allow any first argument w/ a "preamble" property to act as a
|
| + // class preamble (not exclusive of the prototype preamble)
|
| + if(/*dojo.isFunction*/((fn = a[0].preamble))){
|
| + a = fn.apply(this, a) || a;
|
| + }
|
| + }
|
| + // prototype preamble
|
| + if((fn = c.prototype.preamble)){a = fn.apply(this, a) || a;}
|
| + // FIXME:
|
| + // need to provide an optional prototype-settable
|
| + // "_explicitSuper" property which disables this
|
| + // initialize superclass
|
| + if(ct&&ct.apply){ct.apply(this, a);}
|
| + // initialize mixin
|
| + if(mct&&mct.apply){mct.apply(this, a);}
|
| + // initialize self
|
| + if((ii=c.prototype._constructor)){ii.apply(this, args);}
|
| + // post construction
|
| + if(this.constructor.prototype==c.prototype && (ct=this.postscript)){ ct.apply(this, args); }
|
| + },
|
| + _findMixin: function(mixin){
|
| + var c = this.constructor, p, m;
|
| + while(c){
|
| + p = c.superclass;
|
| + m = c.mixin;
|
| + if(m==mixin || (m instanceof mixin.constructor)){return p;}
|
| + if(m && m._findMixin && (m=m._findMixin(mixin))){return m;}
|
| + c = p && p.constructor;
|
| + }
|
| + },
|
| + _findMethod: function(name, method, ptype, has){
|
| + // consciously trading readability for bytes and speed in this low-level method
|
| + var p=ptype, c, m, f;
|
| + do{
|
| + c = p.constructor;
|
| + m = c.mixin;
|
| + // find method by name in our mixin ancestor
|
| + if(m && (m=this._findMethod(name, method, m, has))){return m;}
|
| + // if we found a named method that either exactly-is or exactly-is-not 'method'
|
| + if((f=p[name])&&(has==(f==method))){return p;}
|
| + // ascend chain
|
| + p = c.superclass;
|
| + }while(p);
|
| + // if we couldn't find an ancestor in our primary chain, try a mixin chain
|
| + return !has && (p=this._findMixin(ptype)) && this._findMethod(name, method, p, has);
|
| + },
|
| + inherited: function(name, args, newArgs){
|
| + // optionalize name argument
|
| + var a = arguments;
|
| + if(!dojo.isString(a[0])){newArgs=args; args=name; name=args.callee.nom;}
|
| + a = newArgs||args;
|
| + var c = args.callee, p = this.constructor.prototype, fn, mp;
|
| + // if not an instance override
|
| + if(this[name] != c || p[name] == c){
|
| + // start from memoized prototype, or
|
| + // find a prototype that has property 'name' == 'c'
|
| + mp = (c.ctor||0).superclass || this._findMethod(name, c, p, true);
|
| + if(!mp){throw(this.declaredClass + ': inherited method "' + name + '" mismatch');}
|
| + // find a prototype that has property 'name' != 'c'
|
| + p = this._findMethod(name, c, mp, false);
|
| + }
|
| + // we expect 'name' to be in prototype 'p'
|
| + fn = p && p[name];
|
| + if(!fn){throw(mp.declaredClass + ': inherited method "' + name + '" not found');}
|
| + // if the function exists, invoke it in our scope
|
| + return fn.apply(this, a);
|
| + }
|
| + }
|
| +});
|
| +
|
| +}
|
| +
|
| +if(!dojo._hasResource["dojo._base.connect"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
|
| +dojo._hasResource["dojo._base.connect"] = true;
|
| +dojo.provide("dojo._base.connect");
|
| +
|
| +
|
| +// this file courtesy of the TurboAjax Group, licensed under a Dojo CLA
|
| +
|
| +// low-level delegation machinery
|
| +dojo._listener = {
|
| + // create a dispatcher function
|
| + getDispatcher: function(){
|
| + // following comments pulled out-of-line to prevent cloning them
|
| + // in the returned function.
|
| + // - indices (i) that are really in the array of listeners (ls) will
|
| + // not be in Array.prototype. This is the 'sparse array' trick
|
| + // that keeps us safe from libs that take liberties with built-in
|
| + // objects
|
| + // - listener is invoked with current scope (this)
|
| + return function(){
|
| + var ap=Array.prototype, c=arguments.callee, ls=c._listeners, t=c.target;
|
| + // return value comes from original target function
|
| + var r = t && t.apply(this, arguments);
|
| + // make local copy of listener array so it is immutable during processing
|
| + var lls;
|
| + lls = [].concat(ls);
|
| +
|
| + // invoke listeners after target function
|
| + for(var i in lls){
|
| + if(!(i in ap)){
|
| + lls[i].apply(this, arguments);
|
| + }
|
| + }
|
| + // return value comes from original target function
|
| + return r;
|
| + }
|
| + },
|
| + // add a listener to an object
|
| + add: function(/*Object*/ source, /*String*/ method, /*Function*/ listener){
|
| + // Whenever 'method' is invoked, 'listener' will have the same scope.
|
| + // Trying to supporting a context object for the listener led to
|
| + // complexity.
|
| + // Non trivial to provide 'once' functionality here
|
| + // because listener could be the result of a dojo.hitch call,
|
| + // in which case two references to the same hitch target would not
|
| + // be equivalent.
|
| + source = source || dojo.global;
|
| + // The source method is either null, a dispatcher, or some other function
|
| + var f = source[method];
|
| + // Ensure a dispatcher
|
| + if(!f||!f._listeners){
|
| + var d = dojo._listener.getDispatcher();
|
| + // original target function is special
|
| + d.target = f;
|
| + // dispatcher holds a list of listeners
|
| + d._listeners = [];
|
| + // redirect source to dispatcher
|
| + f = source[method] = d;
|
| + }
|
| + // The contract is that a handle is returned that can
|
| + // identify this listener for disconnect.
|
| + //
|
| + // The type of the handle is private. Here is it implemented as Integer.
|
| + // DOM event code has this same contract but handle is Function
|
| + // in non-IE browsers.
|
| + //
|
| + // We could have separate lists of before and after listeners.
|
| + return f._listeners.push(listener) ; /*Handle*/
|
| + },
|
| + // remove a listener from an object
|
| + remove: function(/*Object*/ source, /*String*/ method, /*Handle*/ handle){
|
| + var f = (source||dojo.global)[method];
|
| + // remember that handle is the index+1 (0 is not a valid handle)
|
| + if(f && f._listeners && handle--){
|
| + delete f._listeners[handle];
|
| + }
|
| + }
|
| +};
|
| +
|
| +// Multiple delegation for arbitrary methods.
|
| +
|
| +// This unit knows nothing about DOM,
|
| +// but we include DOM aware
|
| +// documentation and dontFix
|
| +// argument here to help the autodocs.
|
| +// Actual DOM aware code is in event.js.
|
| +
|
| +dojo.connect = function(/*Object|null*/ obj,
|
| + /*String*/ event,
|
| + /*Object|null*/ context,
|
| + /*String|Function*/ method,
|
| + /*Boolean*/ dontFix){
|
| + // summary:
|
| + // Create a link that calls one function when another executes.
|
| + //
|
| + // description:
|
| + // Connects method to event, so that after event fires, method
|
| + // does too. All connected functions are passed the same arguments as
|
| + // the event function was initially called with. You may connect as
|
| + // many methods to event as needed.
|
| + //
|
| + // event must be a string. If obj is null, dojo.global is used.
|
| + //
|
| + // null arguments may simply be omitted.
|
| + //
|
| + // obj[event] can resolve to a function or undefined (null).
|
| + // If obj[event] is null, it is assigned a function.
|
| + //
|
| + // The return value is a handle that is needed to
|
| + // remove this connection with dojo.disconnect.
|
| + //
|
| + // obj:
|
| + // The source object for the event function.
|
| + // Defaults to dojo.global if null.
|
| + // If obj is a DOM node, the connection is delegated
|
| + // to the DOM event manager (unless dontFix is true).
|
| + //
|
| + // event:
|
| + // String name of the event function in obj.
|
| + // I.e. identifies a property obj[event].
|
| + //
|
| + // context:
|
| + // The object that method will receive as "this".
|
| + //
|
| + // If context is null and method is a function, then method
|
| + // inherits the context of event.
|
| + //
|
| + // If method is a string then context must be the source
|
| + // object object for method (context[method]). If context is null,
|
| + // dojo.global is used.
|
| + //
|
| + // method:
|
| + // A function reference, or name of a function in context.
|
| + // The function identified by method fires after event does.
|
| + // method receives the same arguments as the event.
|
| + // See context argument comments for information on method's scope.
|
| + //
|
| + // dontFix:
|
| + // If obj is a DOM node, set dontFix to true to prevent delegation
|
| + // of this connection to the DOM event manager.
|
| + //
|
| + // example:
|
| + // When obj.onchange(), do ui.update():
|
| + // | dojo.connect(obj, "onchange", ui, "update");
|
| + // | dojo.connect(obj, "onchange", ui, ui.update); // same
|
| + //
|
| + // example:
|
| + // Using return value for disconnect:
|
| + // | var link = dojo.connect(obj, "onchange", ui, "update");
|
| + // | ...
|
| + // | dojo.disconnect(link);
|
| + //
|
| + // example:
|
| + // When onglobalevent executes, watcher.handler is invoked:
|
| + // | dojo.connect(null, "onglobalevent", watcher, "handler");
|
| + //
|
| + // example:
|
| + // When ob.onCustomEvent executes, customEventHandler is invoked:
|
| + // | dojo.connect(ob, "onCustomEvent", null, "customEventHandler");
|
| + // | dojo.connect(ob, "onCustomEvent", "customEventHandler"); // same
|
| + //
|
| + // example:
|
| + // When ob.onCustomEvent executes, customEventHandler is invoked
|
| + // with the same scope (this):
|
| + // | dojo.connect(ob, "onCustomEvent", null, customEventHandler);
|
| + // | dojo.connect(ob, "onCustomEvent", customEventHandler); // same
|
| + //
|
| + // example:
|
| + // When globalEvent executes, globalHandler is invoked
|
| + // with the same scope (this):
|
| + // | dojo.connect(null, "globalEvent", null, globalHandler);
|
| + // | dojo.connect("globalEvent", globalHandler); // same
|
| +
|
| + // normalize arguments
|
| + var a=arguments, args=[], i=0;
|
| + // if a[0] is a String, obj was ommited
|
| + args.push(dojo.isString(a[0]) ? null : a[i++], a[i++]);
|
| + // if the arg-after-next is a String or Function, context was NOT omitted
|
| + var a1 = a[i+1];
|
| + args.push(dojo.isString(a1)||dojo.isFunction(a1) ? a[i++] : null, a[i++]);
|
| + // absorb any additional arguments
|
| + for(var l=a.length; i<l; i++){ args.push(a[i]); }
|
| + // do the actual work
|
| + return dojo._connect.apply(this, args); /*Handle*/
|
| +}
|
| +
|
| +// used by non-browser hostenvs. always overriden by event.js
|
| +dojo._connect = function(obj, event, context, method){
|
| + var l=dojo._listener, h=l.add(obj, event, dojo.hitch(context, method));
|
| + return [obj, event, h, l]; // Handle
|
| +}
|
| +
|
| +dojo.disconnect = function(/*Handle*/ handle){
|
| + // summary:
|
| + // Remove a link created by dojo.connect.
|
| + // description:
|
| + // Removes the connection between event and the method referenced by handle.
|
| + // handle:
|
| + // the return value of the dojo.connect call that created the connection.
|
| + if(handle && handle[0] !== undefined){
|
| + dojo._disconnect.apply(this, handle);
|
| + // let's not keep this reference
|
| + delete handle[0];
|
| + }
|
| +}
|
| +
|
| +dojo._disconnect = function(obj, event, handle, listener){
|
| + listener.remove(obj, event, handle);
|
| +}
|
| +
|
| +// topic publish/subscribe
|
| +
|
| +dojo._topics = {};
|
| +
|
| +dojo.subscribe = function(/*String*/ topic, /*Object|null*/ context, /*String|Function*/ method){
|
| + // summary:
|
| + // Attach a listener to a named topic. The listener function is invoked whenever the
|
| + // named topic is published (see: dojo.publish).
|
| + // Returns a handle which is needed to unsubscribe this listener.
|
| + // context:
|
| + // Scope in which method will be invoked, or null for default scope.
|
| + // method:
|
| + // The name of a function in context, or a function reference. This is the function that
|
| + // is invoked when topic is published.
|
| + // example:
|
| + // | dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };
|
| + // | dojo.publish("alerts", [ "read this", "hello world" ]);
|
| +
|
| + // support for 2 argument invocation (omitting context) depends on hitch
|
| + return [topic, dojo._listener.add(dojo._topics, topic, dojo.hitch(context, method))]; /*Handle*/
|
| +}
|
| +
|
| +dojo.unsubscribe = function(/*Handle*/ handle){
|
| + // summary:
|
| + // Remove a topic listener.
|
| + // handle:
|
| + // The handle returned from a call to subscribe.
|
| + // example:
|
| + // | var alerter = dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };
|
| + // | ...
|
| + // | dojo.unsubscribe(alerter);
|
| + if(handle){
|
| + dojo._listener.remove(dojo._topics, handle[0], handle[1]);
|
| + }
|
| +}
|
| +
|
| +dojo.publish = function(/*String*/ topic, /*Array*/ args){
|
| + // summary:
|
| + // Invoke all listener method subscribed to topic.
|
| + // topic:
|
| + // The name of the topic to publish.
|
| + // args:
|
| + // An array of arguments. The arguments will be applied
|
| + // to each topic subscriber (as first class parameters, via apply).
|
| + // example:
|
| + // | dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };
|
| + // | dojo.publish("alerts", [ "read this", "hello world" ]);
|
| +
|
| + // Note that args is an array, which is more efficient vs variable length
|
| + // argument list. Ideally, var args would be implemented via Array
|
| + // throughout the APIs.
|
| + var f = dojo._topics[topic];
|
| + if(f){
|
| + f.apply(this, args||[]);
|
| + }
|
| +}
|
| +
|
| +dojo.connectPublisher = function( /*String*/ topic,
|
| + /*Object|null*/ obj,
|
| + /*String*/ event){
|
| + // summary:
|
| + // Ensure that everytime obj.event() is called, a message is published
|
| + // on the topic. Returns a handle which can be passed to
|
| + // dojo.disconnect() to disable subsequent automatic publication on
|
| + // the topic.
|
| + // topic:
|
| + // The name of the topic to publish.
|
| + // obj:
|
| + // The source object for the event function. Defaults to dojo.global
|
| + // if null.
|
| + // event:
|
| + // The name of the event function in obj.
|
| + // I.e. identifies a property obj[event].
|
| + // example:
|
| + // | dojo.connectPublisher("/ajax/start", dojo, "xhrGet");
|
| + var pf = function(){ dojo.publish(topic, arguments); }
|
| + return (event) ? dojo.connect(obj, event, pf) : dojo.connect(obj, pf); //Handle
|
| +};
|
| +
|
| +}
|
| +
|
| +if(!dojo._hasResource["dojo._base.Deferred"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
|
| +dojo._hasResource["dojo._base.Deferred"] = true;
|
| +dojo.provide("dojo._base.Deferred");
|
| +
|
| +
|
| +dojo.Deferred = function(/*Function?*/ canceller){
|
| + // summary:
|
| + // Encapsulates a sequence of callbacks in response to a value that
|
| + // may not yet be available. This is modeled after the Deferred class
|
| + // from Twisted <http://twistedmatrix.com>.
|
| + // description:
|
| + // JavaScript has no threads, and even if it did, threads are hard.
|
| + // Deferreds are a way of abstracting non-blocking events, such as the
|
| + // final response to an XMLHttpRequest. Deferreds create a promise to
|
| + // return a response a some point in the future and an easy way to
|
| + // register your interest in receiving that response.
|
| + //
|
| + // The most important methods for Deffered users are:
|
| + //
|
| + // * addCallback(handler)
|
| + // * addErrback(handler)
|
| + // * callback(result)
|
| + // * errback(result)
|
| + //
|
| + // In general, when a function returns a Deferred, users then "fill
|
| + // in" the second half of the contract by registering callbacks and
|
| + // error handlers. You may register as many callback and errback
|
| + // handlers as you like and they will be executed in the order
|
| + // registered when a result is provided. Usually this result is
|
| + // provided as the result of an asynchronous operation. The code
|
| + // "managing" the Deferred (the code that made the promise to provide
|
| + // an answer later) will use the callback() and errback() methods to
|
| + // communicate with registered listeners about the result of the
|
| + // operation. At this time, all registered result handlers are called
|
| + // *with the most recent result value*.
|
| + //
|
| + // Deferred callback handlers are treated as a chain, and each item in
|
| + // the chain is required to return a value that will be fed into
|
| + // successive handlers. The most minimal callback may be registered
|
| + // like this:
|
| + //
|
| + // | var d = new dojo.Deferred();
|
| + // | d.addCallback(function(result){ return result; });
|
| + //
|
| + // Perhaps the most common mistake when first using Deferreds is to
|
| + // forget to return a value (in most cases, the value you were
|
| + // passed).
|
| + //
|
| + // The sequence of callbacks is internally represented as a list of
|
| + // 2-tuples containing the callback/errback pair. For example, the
|
| + // following call sequence:
|
| + //
|
| + // | var d = new dojo.Deferred();
|
| + // | d.addCallback(myCallback);
|
| + // | d.addErrback(myErrback);
|
| + // | d.addBoth(myBoth);
|
| + // | d.addCallbacks(myCallback, myErrback);
|
| + //
|
| + // is translated into a Deferred with the following internal
|
| + // representation:
|
| + //
|
| + // | [
|
| + // | [myCallback, null],
|
| + // | [null, myErrback],
|
| + // | [myBoth, myBoth],
|
| + // | [myCallback, myErrback]
|
| + // | ]
|
| + //
|
| + // The Deferred also keeps track of its current status (fired). Its
|
| + // status may be one of three things:
|
| + //
|
| + // * -1: no value yet (initial condition)
|
| + // * 0: success
|
| + // * 1: error
|
| + //
|
| + // A Deferred will be in the error state if one of the following three
|
| + // conditions are met:
|
| + //
|
| + // 1. The result given to callback or errback is "instanceof" Error
|
| + // 2. The previous callback or errback raised an exception while
|
| + // executing
|
| + // 3. The previous callback or errback returned a value
|
| + // "instanceof" Error
|
| + //
|
| + // Otherwise, the Deferred will be in the success state. The state of
|
| + // the Deferred determines the next element in the callback sequence
|
| + // to run.
|
| + //
|
| + // When a callback or errback occurs with the example deferred chain,
|
| + // something equivalent to the following will happen (imagine
|
| + // that exceptions are caught and returned):
|
| + //
|
| + // | // d.callback(result) or d.errback(result)
|
| + // | if(!(result instanceof Error)){
|
| + // | result = myCallback(result);
|
| + // | }
|
| + // | if(result instanceof Error){
|
| + // | result = myErrback(result);
|
| + // | }
|
| + // | result = myBoth(result);
|
| + // | if(result instanceof Error){
|
| + // | result = myErrback(result);
|
| + // | }else{
|
| + // | result = myCallback(result);
|
| + // | }
|
| + //
|
| + // The result is then stored away in case another step is added to the
|
| + // callback sequence. Since the Deferred already has a value
|
| + // available, any new callbacks added will be called immediately.
|
| + //
|
| + // There are two other "advanced" details about this implementation
|
| + // that are useful:
|
| + //
|
| + // Callbacks are allowed to return Deferred instances themselves, so
|
| + // you can build complicated sequences of events with ease.
|
| + //
|
| + // The creator of the Deferred may specify a canceller. The canceller
|
| + // is a function that will be called if Deferred.cancel is called
|
| + // before the Deferred fires. You can use this to implement clean
|
| + // aborting of an XMLHttpRequest, etc. Note that cancel will fire the
|
| + // deferred with a CancelledError (unless your canceller returns
|
| + // another kind of error), so the errbacks should be prepared to
|
| + // handle that error for cancellable Deferreds.
|
| + // example:
|
| + // | var deferred = new dojo.Deferred();
|
| + // | setTimeout(function(){ deferred.callback({success: true}); }, 1000);
|
| + // | return deferred;
|
| + // example:
|
| + // Deferred objects are often used when making code asynchronous. It
|
| + // may be easiest to write functions in a synchronous manner and then
|
| + // split code using a deferred to trigger a response to a long-lived
|
| + // operation. For example, instead of register a callback function to
|
| + // denote when a rendering operation completes, the function can
|
| + // simply return a deferred:
|
| + //
|
| + // | // callback style:
|
| + // | function renderLotsOfData(data, callback){
|
| + // | var success = false
|
| + // | try{
|
| + // | for(var x in data){
|
| + // | renderDataitem(data[x]);
|
| + // | }
|
| + // | success = true;
|
| + // | }catch(e){ }
|
| + // | if(callback){
|
| + // | callback(success);
|
| + // | }
|
| + // | }
|
| + //
|
| + // | // using callback style
|
| + // | renderLotsOfData(someDataObj, function(success){
|
| + // | // handles success or failure
|
| + // | if(!success){
|
| + // | promptUserToRecover();
|
| + // | }
|
| + // | });
|
| + // | // NOTE: no way to add another callback here!!
|
| + // example:
|
| + // Using a Deferred doesn't simplify the sending code any, but it
|
| + // provides a standard interface for callers and senders alike,
|
| + // providing both with a simple way to service multiple callbacks for
|
| + // an operation and freeing both sides from worrying about details
|
| + // such as "did this get called already?". With Deferreds, new
|
| + // callbacks can be added at any time.
|
| + //
|
| + // | // Deferred style:
|
| + // | function renderLotsOfData(data){
|
| + // | var d = new dojo.Deferred();
|
| + // | try{
|
| + // | for(var x in data){
|
| + // | renderDataitem(data[x]);
|
| + // | }
|
| + // | d.callback(true);
|
| + // | }catch(e){
|
| + // | d.errback(new Error("rendering failed"));
|
| + // | }
|
| + // | return d;
|
| + // | }
|
| + //
|
| + // | // using Deferred style
|
| + // | renderLotsOfData(someDataObj).addErrback(function(){
|
| + // | promptUserToRecover();
|
| + // | });
|
| + // | // NOTE: addErrback and addCallback both return the Deferred
|
| + // | // again, so we could chain adding callbacks or save the
|
| + // | // deferred for later should we need to be notified again.
|
| + // example:
|
| + // In this example, renderLotsOfData is syncrhonous and so both
|
| + // versions are pretty artificial. Putting the data display on a
|
| + // timeout helps show why Deferreds rock:
|
| + //
|
| + // | // Deferred style and async func
|
| + // | function renderLotsOfData(data){
|
| + // | var d = new dojo.Deferred();
|
| + // | setTimeout(function(){
|
| + // | try{
|
| + // | for(var x in data){
|
| + // | renderDataitem(data[x]);
|
| + // | }
|
| + // | d.callback(true);
|
| + // | }catch(e){
|
| + // | d.errback(new Error("rendering failed"));
|
| + // | }
|
| + // | }, 100);
|
| + // | return d;
|
| + // | }
|
| + //
|
| + // | // using Deferred style
|
| + // | renderLotsOfData(someDataObj).addErrback(function(){
|
| + // | promptUserToRecover();
|
| + // | });
|
| + //
|
| + // Note that the caller doesn't have to change his code at all to
|
| + // handle the asynchronous case.
|
| +
|
| + this.chain = [];
|
| + this.id = this._nextId();
|
| + this.fired = -1;
|
| + this.paused = 0;
|
| + this.results = [null, null];
|
| + this.canceller = canceller;
|
| + this.silentlyCancelled = false;
|
| +};
|
| +
|
| +dojo.extend(dojo.Deferred, {
|
| + /*
|
| + makeCalled: function(){
|
| + // summary:
|
| + // returns a new, empty deferred, which is already in the called
|
| + // state. Calling callback() or errback() on this deferred will
|
| + // yeild an error and adding new handlers to it will result in
|
| + // them being called immediately.
|
| + var deferred = new dojo.Deferred();
|
| + deferred.callback();
|
| + return deferred;
|
| + },
|
| +
|
| + toString: function(){
|
| + var state;
|
| + if(this.fired == -1){
|
| + state = 'unfired';
|
| + }else{
|
| + state = this.fired ? 'success' : 'error';
|
| + }
|
| + return 'Deferred(' + this.id + ', ' + state + ')';
|
| + },
|
| + */
|
| +
|
| + _nextId: (function(){
|
| + var n = 1;
|
| + return function(){ return n++; };
|
| + })(),
|
| +
|
| + cancel: function(){
|
| + // summary:
|
| + // Cancels a Deferred that has not yet received a value, or is
|
| + // waiting on another Deferred as its value.
|
| + // description:
|
| + // If a canceller is defined, the canceller is called. If the
|
| + // canceller did not return an error, or there was no canceller,
|
| + // then the errback chain is started.
|
| + var err;
|
| + if(this.fired == -1){
|
| + if(this.canceller){
|
| + err = this.canceller(this);
|
| + }else{
|
| + this.silentlyCancelled = true;
|
| + }
|
| + if(this.fired == -1){
|
| + if(!(err instanceof Error)){
|
| + var res = err;
|
| + err = new Error("Deferred Cancelled");
|
| + err.dojoType = "cancel";
|
| + err.cancelResult = res;
|
| + }
|
| + this.errback(err);
|
| + }
|
| + }else if( (this.fired == 0) &&
|
| + (this.results[0] instanceof dojo.Deferred)
|
| + ){
|
| + this.results[0].cancel();
|
| + }
|
| + },
|
| +
|
| +
|
| + _resback: function(res){
|
| + // summary:
|
| + // The private primitive that means either callback or errback
|
| + this.fired = ((res instanceof Error) ? 1 : 0);
|
| + this.results[this.fired] = res;
|
| + this._fire();
|
| + },
|
| +
|
| + _check: function(){
|
| + if(this.fired != -1){
|
| + if(!this.silentlyCancelled){
|
| + throw new Error("already called!");
|
| + }
|
| + this.silentlyCancelled = false;
|
| + return;
|
| + }
|
| + },
|
| +
|
| + callback: function(res){
|
| + // summary:
|
| + // Begin the callback sequence with a non-error value.
|
| +
|
| + /*
|
| + callback or errback should only be called once on a given
|
| + Deferred.
|
| + */
|
| + this._check();
|
| + this._resback(res);
|
| + },
|
| +
|
| + errback: function(/*Error*/res){
|
| + // summary:
|
| + // Begin the callback sequence with an error result.
|
| + this._check();
|
| + if(!(res instanceof Error)){
|
| + res = new Error(res);
|
| + }
|
| + this._resback(res);
|
| + },
|
| +
|
| + addBoth: function(/*Function|Object*/cb, /*String?*/cbfn){
|
| + // summary:
|
| + // Add the same function as both a callback and an errback as the
|
| + // next element on the callback sequence.This is useful for code
|
| + // that you want to guarantee to run, e.g. a finalizer.
|
| + var enclosed = dojo.hitch.apply(dojo, arguments);
|
| + return this.addCallbacks(enclosed, enclosed); // dojo.Deferred
|
| + },
|
| +
|
| + addCallback: function(/*Function|Object*/cb, /*String?*/cbfn /*...*/){
|
| + // summary:
|
| + // Add a single callback to the end of the callback sequence.
|
| + return this.addCallbacks(dojo.hitch.apply(dojo, arguments)); // dojo.Deferred
|
| + },
|
| +
|
| + addErrback: function(cb, cbfn){
|
| + // summary:
|
| + // Add a single callback to the end of the callback sequence.
|
| + return this.addCallbacks(null, dojo.hitch.apply(dojo, arguments)); // dojo.Deferred
|
| + },
|
| +
|
| + addCallbacks: function(cb, eb){
|
| + // summary:
|
| + // Add separate callback and errback to the end of the callback
|
| + // sequence.
|
| + this.chain.push([cb, eb])
|
| + if(this.fired >= 0){
|
| + this._fire();
|
| + }
|
| + return this; // dojo.Deferred
|
| + },
|
| +
|
| + _fire: function(){
|
| + // summary:
|
| + // Used internally to exhaust the callback sequence when a result
|
| + // is available.
|
| + var chain = this.chain;
|
| + var fired = this.fired;
|
| + var res = this.results[fired];
|
| + var self = this;
|
| + var cb = null;
|
| + while(
|
| + (chain.length > 0) &&
|
| + (this.paused == 0)
|
| + ){
|
| + // Array
|
| + var f = chain.shift()[fired];
|
| + if(!f){ continue; }
|
| + var func = function(){
|
| + var ret = f(res);
|
| + //If no response, then use previous response.
|
| + if(typeof ret != "undefined"){
|
| + res = ret;
|
| + }
|
| + fired = ((res instanceof Error) ? 1 : 0);
|
| + if(res instanceof dojo.Deferred){
|
| + cb = function(res){
|
| + self._resback(res);
|
| + // inlined from _pause()
|
| + self.paused--;
|
| + if(
|
| + (self.paused == 0) &&
|
| + (self.fired >= 0)
|
| + ){
|
| + self._fire();
|
| + }
|
| + }
|
| + // inlined from _unpause
|
| + this.paused++;
|
| + }
|
| + };
|
| + if(dojo.config.isDebug){
|
| + func.call(this);
|
| + }else{
|
| + try{
|
| + func.call(this);
|
| + }catch(err){
|
| + fired = 1;
|
| + res = err;
|
| + }
|
| + }
|
| + }
|
| + this.fired = fired;
|
| + this.results[fired] = res;
|
| + if((cb)&&(this.paused)){
|
| + // this is for "tail recursion" in case the dependent
|
| + // deferred is already fired
|
| + res.addBoth(cb);
|
| + }
|
| + }
|
| +});
|
| +
|
| +}
|
| +
|
| +if(!dojo._hasResource["dojo._base.json"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
|
| +dojo._hasResource["dojo._base.json"] = true;
|
| +dojo.provide("dojo._base.json");
|
| +
|
| +dojo.fromJson = function(/*String*/ json){
|
| + // summary:
|
| + // Parses a [JSON](http://json.org) string to return a JavaScript object. Throws for invalid JSON strings.
|
| + // json:
|
| + // a string literal of a JSON item, for instance:
|
| + // `'{ "foo": [ "bar", 1, { "baz": "thud" } ] }'`
|
| +
|
| + return eval("(" + json + ")"); // Object
|
| +}
|
| +
|
| +dojo._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
|
| +}
|
| +
|
| +dojo.toJsonIndentStr = "\t";
|
| +dojo.toJson = function(/*Object*/ it, /*Boolean?*/ prettyPrint, /*String?*/ _indentStr){
|
| + // summary:
|
| + // Returns a [JSON](http://json.org) serialization of an object.
|
| + //
|
| + // description:
|
| + // Returns a [JSON](http://json.org) serialization of an object.
|
| + // Note that this doesn't check for infinite recursion, so don't do that!
|
| + //
|
| + // it:
|
| + // an object to be serialized. Objects may define their own
|
| + // serialization via a special "__json__" or "json" function
|
| + // property. If a specialized serializer has been defined, it will
|
| + // be used as a fallback.
|
| + //
|
| + // prettyPrint:
|
| + // if true, we indent objects and arrays to make the output prettier.
|
| + // The variable dojo.toJsonIndentStr is used as the indent string
|
| + // -- to use something other than the default (tab),
|
| + // change that variable before calling dojo.toJson().
|
| + //
|
| + // _indentStr:
|
| + // private variable for recursive calls when pretty printing, do not use.
|
| +
|
| + if(it === undefined){
|
| + return "undefined";
|
| + }
|
| + var objtype = typeof it;
|
| + if(objtype == "number" || objtype == "boolean"){
|
| + return it + "";
|
| + }
|
| + if(it === null){
|
| + return "null";
|
| + }
|
| + if(dojo.isString(it)){
|
| + return dojo._escapeString(it);
|
| + }
|
| + // recurse
|
| + var recurse = arguments.callee;
|
| + // short-circuit for objects that support "json" serialization
|
| + // if they return "self" then just pass-through...
|
| + var newObj;
|
| + _indentStr = _indentStr || "";
|
| + var nextIndent = prettyPrint ? _indentStr + dojo.toJsonIndentStr : "";
|
| + var tf = it.__json__||it.json;
|
| + if(dojo.isFunction(tf)){
|
| + newObj = tf.call(it);
|
| + if(it !== newObj){
|
| + return recurse(newObj, prettyPrint, nextIndent);
|
| + }
|
| + }
|
| + if(it.nodeType && it.cloneNode){ // isNode
|
| + // we can't seriailize DOM nodes as regular objects because they have cycles
|
| + // DOM nodes could be serialized with something like outerHTML, but
|
| + // that can be provided by users in the form of .json or .__json__ function.
|
| + throw new Error("Can't serialize DOM nodes");
|
| + }
|
| +
|
| + var sep = prettyPrint ? " " : "";
|
| + var newLine = prettyPrint ? "\n" : "";
|
| +
|
| + // array
|
| + if(dojo.isArray(it)){
|
| + var res = dojo.map(it, function(obj){
|
| + var val = recurse(obj, prettyPrint, nextIndent);
|
| + if(typeof val != "string"){
|
| + val = "undefined";
|
| + }
|
| + return newLine + nextIndent + val;
|
| + });
|
| + return "[" + res.join("," + sep) + newLine + _indentStr + "]";
|
| + }
|
| + /*
|
| + // look in the registry
|
| + try {
|
| + window.o = it;
|
| + newObj = dojo.json.jsonRegistry.match(it);
|
| + return recurse(newObj, prettyPrint, nextIndent);
|
| + }catch(e){
|
| + //
|
| + }
|
| + // it's a function with no adapter, skip it
|
| + */
|
| + if(objtype == "function"){
|
| + return null; // null
|
| + }
|
| + // generic object code path
|
| + var output = [], key;
|
| + for(key in it){
|
| + var keyStr, val;
|
| + if(typeof key == "number"){
|
| + keyStr = '"' + key + '"';
|
| + }else if(typeof key == "string"){
|
| + keyStr = dojo._escapeString(key);
|
| + }else{
|
| + // skip non-string or number keys
|
| + continue;
|
| + }
|
| + val = recurse(it[key], prettyPrint, nextIndent);
|
| + if(typeof val != "string"){
|
| + // skip non-serializable values
|
| + continue;
|
| + }
|
| + // FIXME: use += on Moz!!
|
| + // MOW NOTE: using += is a pain because you have to account for the dangling comma...
|
| + output.push(newLine + nextIndent + keyStr + ":" + sep + val);
|
| + }
|
| + return "{" + output.join("," + sep) + newLine + _indentStr + "}"; // String
|
| +}
|
| +
|
| +}
|
| +
|
| +if(!dojo._hasResource["dojo._base.array"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
|
| +dojo._hasResource["dojo._base.array"] = true;
|
| +
|
| +dojo.provide("dojo._base.array");
|
| +
|
| +(function(){
|
| + var _getParts = function(arr, obj, cb){
|
| + return [
|
| + dojo.isString(arr) ? arr.split("") : arr,
|
| + obj || dojo.global,
|
| + // FIXME: cache the anonymous functions we create here?
|
| + dojo.isString(cb) ? new Function("item", "index", "array", cb) : cb
|
| + ];
|
| + };
|
| +
|
| + dojo.mixin(dojo, {
|
| + indexOf: function( /*Array*/ array,
|
| + /*Object*/ value,
|
| + /*Integer?*/ fromIndex,
|
| + /*Boolean?*/ findLast){
|
| + // summary:
|
| + // locates the first index of the provided value in the
|
| + // passed array. If the value is not found, -1 is returned.
|
| + // description:
|
| + // For details on this method, see:
|
| + // http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:indexOf
|
| +
|
| + var step = 1, end = array.length || 0, i = 0;
|
| + if(findLast){
|
| + i = end - 1;
|
| + step = end = -1;
|
| + }
|
| + if(fromIndex != undefined){ i = fromIndex; }
|
| + if((findLast && i > end) || i < end){
|
| + for(; i != end; i += step){
|
| + if(array[i] == value){ return i; }
|
| + }
|
| + }
|
| + return -1; // Number
|
| + },
|
| +
|
| + lastIndexOf: function(/*Array*/array, /*Object*/value, /*Integer?*/fromIndex){
|
| + // summary:
|
| + // locates the last index of the provided value in the passed
|
| + // array. If the value is not found, -1 is returned.
|
| + // description:
|
| + // For details on this method, see:
|
| + // http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:lastIndexOf
|
| + return dojo.indexOf(array, value, fromIndex, true); // Number
|
| + },
|
| +
|
| + forEach: function(/*Array|String*/arr, /*Function|String*/callback, /*Object?*/thisObject){
|
| + // summary:
|
| + // for every item in arr, callback is invoked. Return values are ignored.
|
| + // arr:
|
| + // the array to iterate over. If a string, operates on individual characters.
|
| + // callback:
|
| + // a function is invoked with three arguments: item, index, and array
|
| + // thisObject:
|
| + // may be used to scope the call to callback
|
| + // description:
|
| + // This function corresponds to the JavaScript 1.6
|
| + // Array.forEach() method. For more details, see:
|
| + // http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:forEach
|
| + // example:
|
| + // | // log out all members of the array:
|
| + // | dojo.forEach(
|
| + // | [ "thinger", "blah", "howdy", 10 ],
|
| + // | function(item){
|
| + // |
|
| + // | }
|
| + // | );
|
| + // example:
|
| + // | // log out the members and their indexes
|
| + // | dojo.forEach(
|
| + // | [ "thinger", "blah", "howdy", 10 ],
|
| + // | function(item, idx, arr){
|
| + // |
|
| + // | }
|
| + // | );
|
| + // example:
|
| + // | // use a scoped object member as the callback
|
| + // |
|
| + // | var obj = {
|
| + // | prefix: "logged via obj.callback:",
|
| + // | callback: function(item){
|
| + // |
|
| + // | }
|
| + // | };
|
| + // |
|
| + // | // specifying the scope function executes the callback in that scope
|
| + // | dojo.forEach(
|
| + // | [ "thinger", "blah", "howdy", 10 ],
|
| + // | obj.callback,
|
| + // | obj
|
| + // | );
|
| + // |
|
| + // | // alternately, we can accomplish the same thing with dojo.hitch()
|
| + // | dojo.forEach(
|
| + // | [ "thinger", "blah", "howdy", 10 ],
|
| + // | dojo.hitch(obj, "callback")
|
| + // | );
|
| +
|
| + // match the behavior of the built-in forEach WRT empty arrs
|
| + if(!arr || !arr.length){ return; }
|
| +
|
| + // FIXME: there are several ways of handilng thisObject. Is
|
| + // dojo.global always the default context?
|
| + var _p = _getParts(arr, thisObject, callback); arr = _p[0];
|
| + for(var i=0,l=arr.length; i<l; ++i){
|
| + _p[2].call(_p[1], arr[i], i, arr);
|
| + }
|
| + },
|
| +
|
| + _everyOrSome: function(/*Boolean*/every, /*Array|String*/arr, /*Function|String*/callback, /*Object?*/thisObject){
|
| + var _p = _getParts(arr, thisObject, callback); arr = _p[0];
|
| + for(var i=0,l=arr.length; i<l; ++i){
|
| + var result = !!_p[2].call(_p[1], arr[i], i, arr);
|
| + if(every ^ result){
|
| + return result; // Boolean
|
| + }
|
| + }
|
| + return every; // Boolean
|
| + },
|
| +
|
| + every: function(/*Array|String*/arr, /*Function|String*/callback, /*Object?*/thisObject){
|
| + // summary:
|
| + // Determines whether or not every item in arr satisfies the
|
| + // condition implemented by callback.
|
| + // arr:
|
| + // the array to iterate on. If a string, operates on individual characters.
|
| + // callback:
|
| + // a function is invoked with three arguments: item, index,
|
| + // and array and returns true if the condition is met.
|
| + // thisObject:
|
| + // may be used to scope the call to callback
|
| + // description:
|
| + // This function corresponds to the JavaScript 1.6
|
| + // Array.every() method. For more details, see:
|
| + // http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:every
|
| + // example:
|
| + // | // returns false
|
| + // | dojo.every([1, 2, 3, 4], function(item){ return item>1; });
|
| + // example:
|
| + // | // returns true
|
| + // | dojo.every([1, 2, 3, 4], function(item){ return item>0; });
|
| + return this._everyOrSome(true, arr, callback, thisObject); // Boolean
|
| + },
|
| +
|
| + some: function(/*Array|String*/arr, /*Function|String*/callback, /*Object?*/thisObject){
|
| + // summary:
|
| + // Determines whether or not any item in arr satisfies the
|
| + // condition implemented by callback.
|
| + // arr:
|
| + // the array to iterate over. If a string, operates on individual characters.
|
| + // callback:
|
| + // a function is invoked with three arguments: item, index,
|
| + // and array and returns true if the condition is met.
|
| + // thisObject:
|
| + // may be used to scope the call to callback
|
| + // description:
|
| + // This function corresponds to the JavaScript 1.6
|
| + // Array.some() method. For more details, see:
|
| + // http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:some
|
| + // example:
|
| + // | // is true
|
| + // | dojo.some([1, 2, 3, 4], function(item){ return item>1; });
|
| + // example:
|
| + // | // is false
|
| + // | dojo.some([1, 2, 3, 4], function(item){ return item<1; });
|
| + return this._everyOrSome(false, arr, callback, thisObject); // Boolean
|
| + },
|
| +
|
| + map: function(/*Array|String*/arr, /*Function|String*/callback, /*Function?*/thisObject){
|
| + // summary:
|
| + // applies callback to each element of arr and returns
|
| + // an Array with the results
|
| + // arr:
|
| + // the array to iterate on. If a string, operates on
|
| + // individual characters.
|
| + // callback:
|
| + // a function is invoked with three arguments, (item, index,
|
| + // array), and returns a value
|
| + // thisObject:
|
| + // may be used to scope the call to callback
|
| + // description:
|
| + // This function corresponds to the JavaScript 1.6 Array.map()
|
| + // method. For more details, see:
|
| + // http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:map
|
| + // example:
|
| + // | // returns [2, 3, 4, 5]
|
| + // | dojo.map([1, 2, 3, 4], function(item){ return item+1 });
|
| +
|
| + var _p = _getParts(arr, thisObject, callback); arr = _p[0];
|
| + var outArr = (arguments[3] ? (new arguments[3]()) : []);
|
| + for(var i=0,l=arr.length; i<l; ++i){
|
| + outArr.push(_p[2].call(_p[1], arr[i], i, arr));
|
| + }
|
| + return outArr; // Array
|
| + },
|
| +
|
| + filter: function(/*Array*/arr, /*Function|String*/callback, /*Object?*/thisObject){
|
| + // summary:
|
| + // Returns a new Array with those items from arr that match the
|
| + // condition implemented by callback.
|
| + // arr:
|
| + // the array to iterate over.
|
| + // callback:
|
| + // a function that is invoked with three arguments (item,
|
| + // index, array). The return of this function is expected to
|
| + // be a boolean which determines whether the passed-in item
|
| + // will be included in the returned array.
|
| + // thisObject:
|
| + // may be used to scope the call to callback
|
| + // description:
|
| + // This function corresponds to the JavaScript 1.6
|
| + // Array.filter() method. For more details, see:
|
| + // http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:filter
|
| + // example:
|
| + // | // returns [2, 3, 4]
|
| + // | dojo.filter([1, 2, 3, 4], function(item){ return item>1; });
|
| +
|
| + var _p = _getParts(arr, thisObject, callback); arr = _p[0];
|
| + var outArr = [];
|
| + for(var i=0,l=arr.length; i<l; ++i){
|
| + if(_p[2].call(_p[1], arr[i], i, arr)){
|
| + outArr.push(arr[i]);
|
| + }
|
| + }
|
| + return outArr; // Array
|
| + }
|
| + });
|
| +})();
|
| +
|
| +}
|
| +
|
| +if(!dojo._hasResource["dojo._base.Color"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
|
| +dojo._hasResource["dojo._base.Color"] = true;
|
| +dojo.provide("dojo._base.Color");
|
| +
|
| +
|
| +
|
| +dojo.Color = function(/*Array|String|Object*/ color){
|
| + // summary:
|
| + // takes a named string, hex string, array of rgb or rgba values,
|
| + // an object with r, g, b, and a properties, or another dojo.Color object
|
| + if(color){ this.setColor(color); }
|
| +};
|
| +
|
| +// FIXME: there's got to be a more space-efficient way to encode or discover these!! Use hex?
|
| +dojo.Color.named = {
|
| + black: [0,0,0],
|
| + silver: [192,192,192],
|
| + gray: [128,128,128],
|
| + white: [255,255,255],
|
| + maroon: [128,0,0],
|
| + red: [255,0,0],
|
| + purple: [128,0,128],
|
| + fuchsia: [255,0,255],
|
| + green: [0,128,0],
|
| + lime: [0,255,0],
|
| + olive: [128,128,0],
|
| + yellow: [255,255,0],
|
| + navy: [0,0,128],
|
| + blue: [0,0,255],
|
| + teal: [0,128,128],
|
| + aqua: [0,255,255]
|
| +};
|
| +
|
| +
|
| +dojo.extend(dojo.Color, {
|
| + r: 255, g: 255, b: 255, a: 1,
|
| + _set: function(r, g, b, a){
|
| + var t = this; t.r = r; t.g = g; t.b = b; t.a = a;
|
| + },
|
| + setColor: function(/*Array|String|Object*/ color){
|
| + // summary:
|
| + // takes a named string, hex string, array of rgb or rgba values,
|
| + // an object with r, g, b, and a properties, or another dojo.Color object
|
| + var d = dojo;
|
| + if(d.isString(color)){
|
| + d.colorFromString(color, this);
|
| + }else if(d.isArray(color)){
|
| + d.colorFromArray(color, this);
|
| + }else{
|
| + this._set(color.r, color.g, color.b, color.a);
|
| + if(!(color instanceof d.Color)){ this.sanitize(); }
|
| + }
|
| + return this; // dojo.Color
|
| + },
|
| + sanitize: function(){
|
| + // summary:
|
| + // makes sure that the object has correct attributes
|
| + // description:
|
| + // the default implementation does nothing, include dojo.colors to
|
| + // augment it to real checks
|
| + return this; // dojo.Color
|
| + },
|
| + toRgb: function(){
|
| + // summary: returns 3 component array of rgb values
|
| + var t = this;
|
| + return [t.r, t.g, t.b]; // Array
|
| + },
|
| + toRgba: function(){
|
| + // summary: returns a 4 component array of rgba values
|
| + var t = this;
|
| + return [t.r, t.g, t.b, t.a]; // Array
|
| + },
|
| + toHex: function(){
|
| + // summary: returns a css color string in hexadecimal representation
|
| + var arr = dojo.map(["r", "g", "b"], function(x){
|
| + var s = this[x].toString(16);
|
| + return s.length < 2 ? "0" + s : s;
|
| + }, this);
|
| + return "#" + arr.join(""); // String
|
| + },
|
| + toCss: function(/*Boolean?*/ includeAlpha){
|
| + // summary: returns a css color string in rgb(a) representation
|
| + var t = this, rgb = t.r + ", " + t.g + ", " + t.b;
|
| + return (includeAlpha ? "rgba(" + rgb + ", " + t.a : "rgb(" + rgb) + ")"; // String
|
| + },
|
| + toString: function(){
|
| + // summary: returns a visual representation of the color
|
| + return this.toCss(true); // String
|
| + }
|
| +});
|
| +
|
| +dojo.blendColors = function(
|
| + /*dojo.Color*/ start,
|
| + /*dojo.Color*/ end,
|
| + /*Number*/ weight,
|
| + /*dojo.Color?*/ obj
|
| +){
|
| + // summary:
|
| + // blend colors end and start with weight from 0 to 1, 0.5 being a 50/50 blend,
|
| + // can reuse a previously allocated dojo.Color object for the result
|
| + var d = dojo, t = obj || new dojo.Color();
|
| + d.forEach(["r", "g", "b", "a"], function(x){
|
| + t[x] = start[x] + (end[x] - start[x]) * weight;
|
| + if(x != "a"){ t[x] = Math.round(t[x]); }
|
| + });
|
| + return t.sanitize(); // dojo.Color
|
| +};
|
| +
|
| +dojo.colorFromRgb = function(/*String*/ color, /*dojo.Color?*/ obj){
|
| + // summary: get rgb(a) array from css-style color declarations
|
| + var m = color.toLowerCase().match(/^rgba?\(([\s\.,0-9]+)\)/);
|
| + return m && dojo.colorFromArray(m[1].split(/\s*,\s*/), obj); // dojo.Color
|
| +};
|
| +
|
| +dojo.colorFromHex = function(/*String*/ color, /*dojo.Color?*/ obj){
|
| + // summary: converts a hex string with a '#' prefix to a color object.
|
| + // Supports 12-bit #rgb shorthand.
|
| + var d = dojo, t = obj || new d.Color(),
|
| + bits = (color.length == 4) ? 4 : 8,
|
| + mask = (1 << bits) - 1;
|
| + color = Number("0x" + color.substr(1));
|
| + if(isNaN(color)){
|
| + return null; // dojo.Color
|
| + }
|
| + d.forEach(["b", "g", "r"], function(x){
|
| + var c = color & mask;
|
| + color >>= bits;
|
| + t[x] = bits == 4 ? 17 * c : c;
|
| + });
|
| + t.a = 1;
|
| + return t; // dojo.Color
|
| +};
|
| +
|
| +dojo.colorFromArray = function(/*Array*/ a, /*dojo.Color?*/ obj){
|
| + // summary: builds a color from 1, 2, 3, or 4 element array
|
| + var t = obj || new dojo.Color();
|
| + t._set(Number(a[0]), Number(a[1]), Number(a[2]), Number(a[3]));
|
| + if(isNaN(t.a)){ t.a = 1; }
|
| + return t.sanitize(); // dojo.Color
|
| +};
|
| +
|
| +dojo.colorFromString = function(/*String*/ str, /*dojo.Color?*/ obj){
|
| + // summary:
|
| + // parses str for a color value.
|
| + // description:
|
| + // Acceptable input values for str may include arrays of any form
|
| + // accepted by dojo.colorFromArray, hex strings such as "#aaaaaa", or
|
| + // rgb or rgba strings such as "rgb(133, 200, 16)" or "rgba(10, 10,
|
| + // 10, 50)"
|
| + // returns:
|
| + // a dojo.Color object. If obj is passed, it will be the return value.
|
| + var a = dojo.Color.named[str];
|
| + return a && dojo.colorFromArray(a, obj) || dojo.colorFromRgb(str, obj) || dojo.colorFromHex(str, obj);
|
| +};
|
| +
|
| +}
|
| +
|
| +if(!dojo._hasResource["dojo._base"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
|
| +dojo._hasResource["dojo._base"] = true;
|
| +dojo.provide("dojo._base");
|
| +
|
| +
|
| +
|
| +
|
| +
|
| +
|
| +
|
| +
|
| +
|
| +}
|
| +
|
| +if(!dojo._hasResource["dojo._base.window"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
|
| +dojo._hasResource["dojo._base.window"] = true;
|
| +dojo.provide("dojo._base.window");
|
| +
|
| +/*=====
|
| +dojo.doc = {
|
| + // summary:
|
| + // Alias for the current document. 'dojo.doc' can be modified
|
| + // for temporary context shifting. Also see dojo.withDoc().
|
| + // description:
|
| + // Refer to dojo.doc rather
|
| + // than referring to 'window.document' to ensure your code runs
|
| + // correctly in managed contexts.
|
| + // example:
|
| + // | n.appendChild(dojo.doc.createElement('div'));
|
| +}
|
| +=====*/
|
| +dojo.doc = window["document"] || null;
|
| +
|
| +dojo.body = function(){
|
| + // summary:
|
| + // Return the body element of the document
|
| + // return the body object associated with dojo.doc
|
| + // example:
|
| + // | dojo.body().appendChild(dojo.doc.createElement('div'));
|
| +
|
| + // Note: document.body is not defined for a strict xhtml document
|
| + // Would like to memoize this, but dojo.doc can change vi dojo.withDoc().
|
| + return dojo.doc.body || dojo.doc.getElementsByTagName("body")[0]; // Node
|
| +}
|
| +
|
| +dojo.setContext = function(/*Object*/globalObject, /*DocumentElement*/globalDocument){
|
| + // summary:
|
| + // changes the behavior of many core Dojo functions that deal with
|
| + // namespace and DOM lookup, changing them to work in a new global
|
| + // context (e.g., an iframe). The varibles dojo.global and dojo.doc
|
| + // are modified as a result of calling this function and the result of
|
| + // `dojo.body()` likewise differs.
|
| + dojo.global = globalObject;
|
| + dojo.doc = globalDocument;
|
| +};
|
| +
|
| +dojo._fireCallback = function(callback, context, cbArguments){
|
| + if(context && dojo.isString(callback)){
|
| + callback = context[callback];
|
| + }
|
| + return callback.apply(context, cbArguments || [ ]);
|
| +}
|
| +
|
| +dojo.withGlobal = function( /*Object*/globalObject,
|
| + /*Function*/callback,
|
| + /*Object?*/thisObject,
|
| + /*Array?*/cbArguments){
|
| + // summary:
|
| + // Call callback with globalObject as dojo.global and
|
| + // globalObject.document as dojo.doc. If provided, globalObject
|
| + // will be executed in the context of object thisObject
|
| + // description:
|
| + // When callback() returns or throws an error, the dojo.global
|
| + // and dojo.doc will be restored to its previous state.
|
| + var rval;
|
| + var oldGlob = dojo.global;
|
| + var oldDoc = dojo.doc;
|
| + try{
|
| + dojo.setContext(globalObject, globalObject.document);
|
| + rval = dojo._fireCallback(callback, thisObject, cbArguments);
|
| + }finally{
|
| + dojo.setContext(oldGlob, oldDoc);
|
| + }
|
| + return rval;
|
| +}
|
| +
|
| +dojo.withDoc = function( /*Object*/documentObject,
|
| + /*Function*/callback,
|
| + /*Object?*/thisObject,
|
| + /*Array?*/cbArguments){
|
| + // summary:
|
| + // Call callback with documentObject as dojo.doc. If provided,
|
| + // callback will be executed in the context of object thisObject
|
| + // description:
|
| + // When callback() returns or throws an error, the dojo.doc will
|
| + // be restored to its previous state.
|
| + var rval;
|
| + var oldDoc = dojo.doc;
|
| + try{
|
| + dojo.doc = documentObject;
|
| + rval = dojo._fireCallback(callback, thisObject, cbArguments);
|
| + }finally{
|
| + dojo.doc = oldDoc;
|
| + }
|
| + return rval;
|
| +};
|
| +
|
| +}
|
| +
|
| +if(!dojo._hasResource["dojo._base.event"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
|
| +dojo._hasResource["dojo._base.event"] = true;
|
| +dojo.provide("dojo._base.event");
|
| +
|
| +
|
| +// this file courtesy of the TurboAjax Group, licensed under a Dojo CLA
|
| +
|
| +(function(){
|
| + // DOM event listener machinery
|
| + var del = (dojo._event_listener = {
|
| + add: function(/*DOMNode*/node, /*String*/name, /*Function*/fp){
|
| + if(!node){return;}
|
| + name = del._normalizeEventName(name);
|
| + fp = del._fixCallback(name, fp);
|
| + var oname = name;
|
| + if(!dojo.isIE && (name == "mouseenter" || name == "mouseleave")){
|
| + var ofp = fp;
|
| + //oname = name;
|
| + name = (name == "mouseenter") ? "mouseover" : "mouseout";
|
| + fp = function(e){
|
| + // check tagName to fix a FF2 bug with invalid nodes (hidden child DIV of INPUT)
|
| + // which causes isDecendant to return false which causes
|
| + // spurious, and more importantly, incorrect mouse events to fire.
|
| + // TODO: remove tagName check when Firefox 2 is no longer supported
|
| + try{ e.relatedTarget.tagName; } catch(e2){ return; }
|
| + if(!dojo.isDescendant(e.relatedTarget, node)){
|
| + // e.type = oname; // FIXME: doesn't take? SJM: event.type is generally immutable.
|
| + return ofp.call(this, e);
|
| + }
|
| + }
|
| + }
|
| + node.addEventListener(name, fp, false);
|
| + return fp; /*Handle*/
|
| + },
|
| + remove: function(/*DOMNode*/node, /*String*/event, /*Handle*/handle){
|
| + // summary:
|
| + // clobbers the listener from the node
|
| + // node:
|
| + // DOM node to attach the event to
|
| + // event:
|
| + // the name of the handler to remove the function from
|
| + // handle:
|
| + // the handle returned from add
|
| + if (node){
|
| + event = del._normalizeEventName(event);
|
| + if(!dojo.isIE && (event == "mouseenter" || event == "mouseleave")){
|
| + event = (event == "mouseenter") ? "mouseover" : "mouseout";
|
| + }
|
| +
|
| + node.removeEventListener(event, handle, false);
|
| + }
|
| + },
|
| + _normalizeEventName: function(/*String*/name){
|
| + // Generally, name should be lower case, unless it is special
|
| + // somehow (e.g. a Mozilla DOM event).
|
| + // Remove 'on'.
|
| + return name.slice(0,2) =="on" ? name.slice(2) : name;
|
| + },
|
| + _fixCallback: function(/*String*/name, fp){
|
| + // By default, we only invoke _fixEvent for 'keypress'
|
| + // If code is added to _fixEvent for other events, we have
|
| + // to revisit this optimization.
|
| + // This also applies to _fixEvent overrides for Safari and Opera
|
| + // below.
|
| + return name != "keypress" ? fp : function(e){ return fp.call(this, del._fixEvent(e, this)); };
|
| + },
|
| + _fixEvent: function(evt, sender){
|
| + // _fixCallback only attaches us to keypress.
|
| + // Switch on evt.type anyway because we might
|
| + // be called directly from dojo.fixEvent.
|
| + switch(evt.type){
|
| + case "keypress":
|
| + del._setKeyChar(evt);
|
| + break;
|
| + }
|
| + return evt;
|
| + },
|
| + _setKeyChar: function(evt){
|
| + evt.keyChar = evt.charCode ? String.fromCharCode(evt.charCode) : '';
|
| + evt.charOrCode = evt.keyChar || evt.keyCode;
|
| + },
|
| + // For IE and Safari: some ctrl-key combinations (mostly w/punctuation) do not emit a char code in IE
|
| + // we map those virtual key codes to ascii here
|
| + // not valid for all (non-US) keyboards, so maybe we shouldn't bother
|
| + _punctMap: {
|
| + 106:42,
|
| + 111:47,
|
| + 186:59,
|
| + 187:43,
|
| + 188:44,
|
| + 189:45,
|
| + 190:46,
|
| + 191:47,
|
| + 192:96,
|
| + 219:91,
|
| + 220:92,
|
| + 221:93,
|
| + 222:39
|
| + }
|
| + });
|
| +
|
| + // DOM events
|
| +
|
| + dojo.fixEvent = function(/*Event*/evt, /*DOMNode*/sender){
|
| + // summary:
|
| + // normalizes properties on the event object including event
|
| + // bubbling methods, keystroke normalization, and x/y positions
|
| + // evt: Event
|
| + // native event object
|
| + // sender: DOMNode
|
| + // node to treat as "currentTarget"
|
| + return del._fixEvent(evt, sender);
|
| + }
|
| +
|
| + dojo.stopEvent = function(/*Event*/evt){
|
| + // summary:
|
| + // prevents propagation and clobbers the default action of the
|
| + // passed event
|
| + // evt: Event
|
| + // The event object. If omitted, window.event is used on IE.
|
| + evt.preventDefault();
|
| + evt.stopPropagation();
|
| + // NOTE: below, this method is overridden for IE
|
| + }
|
| +
|
| + // the default listener to use on dontFix nodes, overriden for IE
|
| + var node_listener = dojo._listener;
|
| +
|
| + // Unify connect and event listeners
|
| + dojo._connect = function(obj, event, context, method, dontFix){
|
| + // FIXME: need a more strict test
|
| + var isNode = obj && (obj.nodeType||obj.attachEvent||obj.addEventListener);
|
| + // choose one of three listener options: raw (connect.js), DOM event on a Node, custom event on a Node
|
| + // we need the third option to provide leak prevention on broken browsers (IE)
|
| + var lid = !isNode ? 0 : (!dontFix ? 1 : 2), l = [dojo._listener, del, node_listener][lid];
|
| + // create a listener
|
| + var h = l.add(obj, event, dojo.hitch(context, method));
|
| + // formerly, the disconnect package contained "l" directly, but if client code
|
| + // leaks the disconnect package (by connecting it to a node), referencing "l"
|
| + // compounds the problem.
|
| + // instead we return a listener id, which requires custom _disconnect below.
|
| + // return disconnect package
|
| + return [ obj, event, h, lid ];
|
| + }
|
| +
|
| + dojo._disconnect = function(obj, event, handle, listener){
|
| + ([dojo._listener, del, node_listener][listener]).remove(obj, event, handle);
|
| + }
|
| +
|
| + // Constants
|
| +
|
| + // Public: client code should test
|
| + // keyCode against these named constants, as the
|
| + // actual codes can vary by browser.
|
| + dojo.keys = {
|
| + // summary: definitions for common key values
|
| + BACKSPACE: 8,
|
| + TAB: 9,
|
| + CLEAR: 12,
|
| + ENTER: 13,
|
| + SHIFT: 16,
|
| + CTRL: 17,
|
| + ALT: 18,
|
| + PAUSE: 19,
|
| + CAPS_LOCK: 20,
|
| + ESCAPE: 27,
|
| + SPACE: 32,
|
| + PAGE_UP: 33,
|
| + PAGE_DOWN: 34,
|
| + END: 35,
|
| + HOME: 36,
|
| + LEFT_ARROW: 37,
|
| + UP_ARROW: 38,
|
| + RIGHT_ARROW: 39,
|
| + DOWN_ARROW: 40,
|
| + INSERT: 45,
|
| + DELETE: 46,
|
| + HELP: 47,
|
| + LEFT_WINDOW: 91,
|
| + RIGHT_WINDOW: 92,
|
| + SELECT: 93,
|
| + NUMPAD_0: 96,
|
| + NUMPAD_1: 97,
|
| + NUMPAD_2: 98,
|
| + NUMPAD_3: 99,
|
| + NUMPAD_4: 100,
|
| + NUMPAD_5: 101,
|
| + NUMPAD_6: 102,
|
| + NUMPAD_7: 103,
|
| + NUMPAD_8: 104,
|
| + NUMPAD_9: 105,
|
| + NUMPAD_MULTIPLY: 106,
|
| + NUMPAD_PLUS: 107,
|
| + NUMPAD_ENTER: 108,
|
| + NUMPAD_MINUS: 109,
|
| + NUMPAD_PERIOD: 110,
|
| + NUMPAD_DIVIDE: 111,
|
| + F1: 112,
|
| + F2: 113,
|
| + F3: 114,
|
| + F4: 115,
|
| + F5: 116,
|
| + F6: 117,
|
| + F7: 118,
|
| + F8: 119,
|
| + F9: 120,
|
| + F10: 121,
|
| + F11: 122,
|
| + F12: 123,
|
| + F13: 124,
|
| + F14: 125,
|
| + F15: 126,
|
| + NUM_LOCK: 144,
|
| + SCROLL_LOCK: 145
|
| + };
|
| +
|
| + // IE event normalization
|
| + if(dojo.isIE){
|
| + var _trySetKeyCode = function(e, code){
|
| + try{
|
| + // squelch errors when keyCode is read-only
|
| + // (e.g. if keyCode is ctrl or shift)
|
| + return (e.keyCode = code);
|
| + }catch(e){
|
| + return 0;
|
| + }
|
| + }
|
| +
|
| + // by default, use the standard listener
|
| + var iel = dojo._listener;
|
| + var listenersName = dojo._ieListenersName = "_" + dojo._scopeName + "_listeners";
|
| + // dispatcher tracking property
|
| + if(!dojo.config._allow_leaks){
|
| + // custom listener that handles leak protection for DOM events
|
| + node_listener = iel = dojo._ie_listener = {
|
| + // support handler indirection: event handler functions are
|
| + // referenced here. Event dispatchers hold only indices.
|
| + handlers: [],
|
| + // add a listener to an object
|
| + add: function(/*Object*/ source, /*String*/ method, /*Function*/ listener){
|
| + source = source || dojo.global;
|
| + var f = source[method];
|
| + if(!f||!f[listenersName]){
|
| + var d = dojo._getIeDispatcher();
|
| + // original target function is special
|
| + d.target = f && (ieh.push(f) - 1);
|
| + // dispatcher holds a list of indices into handlers table
|
| + d[listenersName] = [];
|
| + // redirect source to dispatcher
|
| + f = source[method] = d;
|
| + }
|
| + return f[listenersName].push(ieh.push(listener) - 1) ; /*Handle*/
|
| + },
|
| + // remove a listener from an object
|
| + remove: function(/*Object*/ source, /*String*/ method, /*Handle*/ handle){
|
| + var f = (source||dojo.global)[method], l = f && f[listenersName];
|
| + if(f && l && handle--){
|
| + delete ieh[l[handle]];
|
| + delete l[handle];
|
| + }
|
| + }
|
| + };
|
| + // alias used above
|
| + var ieh = iel.handlers;
|
| + }
|
| +
|
| + dojo.mixin(del, {
|
| + add: function(/*DOMNode*/node, /*String*/event, /*Function*/fp){
|
| + if(!node){return;} // undefined
|
| + event = del._normalizeEventName(event);
|
| + if(event=="onkeypress"){
|
| + // we need to listen to onkeydown to synthesize
|
| + // keypress events that otherwise won't fire
|
| + // on IE
|
| + var kd = node.onkeydown;
|
| + if(!kd || !kd[listenersName] || !kd._stealthKeydownHandle){
|
| + var h = del.add(node, "onkeydown", del._stealthKeyDown);
|
| + kd = node.onkeydown;
|
| + kd._stealthKeydownHandle = h;
|
| + kd._stealthKeydownRefs = 1;
|
| + }else{
|
| + kd._stealthKeydownRefs++;
|
| + }
|
| + }
|
| + return iel.add(node, event, del._fixCallback(fp));
|
| + },
|
| + remove: function(/*DOMNode*/node, /*String*/event, /*Handle*/handle){
|
| + event = del._normalizeEventName(event);
|
| + iel.remove(node, event, handle);
|
| + if(event=="onkeypress"){
|
| + var kd = node.onkeydown;
|
| + if(--kd._stealthKeydownRefs <= 0){
|
| + iel.remove(node, "onkeydown", kd._stealthKeydownHandle);
|
| + delete kd._stealthKeydownHandle;
|
| + }
|
| + }
|
| + },
|
| + _normalizeEventName: function(/*String*/eventName){
|
| + // Generally, eventName should be lower case, unless it is
|
| + // special somehow (e.g. a Mozilla event)
|
| + // ensure 'on'
|
| + return eventName.slice(0,2) != "on" ? "on" + eventName : eventName;
|
| + },
|
| + _nop: function(){},
|
| + _fixEvent: function(/*Event*/evt, /*DOMNode*/sender){
|
| + // summary:
|
| + // normalizes properties on the event object including event
|
| + // bubbling methods, keystroke normalization, and x/y positions
|
| + // evt: native event object
|
| + // sender: node to treat as "currentTarget"
|
| + if(!evt){
|
| + var w = sender && (sender.ownerDocument || sender.document || sender).parentWindow || window;
|
| + evt = w.event;
|
| + }
|
| + if(!evt){return(evt);}
|
| + evt.target = evt.srcElement;
|
| + evt.currentTarget = (sender || evt.srcElement);
|
| + evt.layerX = evt.offsetX;
|
| + evt.layerY = evt.offsetY;
|
| + // 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 = evt.srcElement, 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 = ((dojo.isIE < 6) || (doc["compatMode"] == "BackCompat")) ? doc.body : doc.documentElement;
|
| + var offset = dojo._getIeDocumentElementOffset();
|
| + evt.pageX = evt.clientX + dojo._fixIeBiDiScrollLeft(docBody.scrollLeft || 0) - offset.x;
|
| + evt.pageY = evt.clientY + (docBody.scrollTop || 0) - offset.y;
|
| + if(evt.type == "mouseover"){
|
| + evt.relatedTarget = evt.fromElement;
|
| + }
|
| + if(evt.type == "mouseout"){
|
| + evt.relatedTarget = evt.toElement;
|
| + }
|
| + evt.stopPropagation = del._stopPropagation;
|
| + evt.preventDefault = del._preventDefault;
|
| + return del._fixKeys(evt);
|
| + },
|
| + _fixKeys: function(evt){
|
| + switch(evt.type){
|
| + case "keypress":
|
| + var c = ("charCode" in evt ? evt.charCode : evt.keyCode);
|
| + if (c==10){
|
| + // CTRL-ENTER is CTRL-ASCII(10) on IE, but CTRL-ENTER on Mozilla
|
| + c=0;
|
| + evt.keyCode = 13;
|
| + }else if(c==13||c==27){
|
| + c=0; // Mozilla considers ENTER and ESC non-printable
|
| + }else if(c==3){
|
| + c=99; // Mozilla maps CTRL-BREAK to CTRL-c
|
| + }
|
| + // Mozilla sets keyCode to 0 when there is a charCode
|
| + // but that stops the event on IE.
|
| + evt.charCode = c;
|
| + del._setKeyChar(evt);
|
| + break;
|
| + }
|
| + return evt;
|
| + },
|
| + _stealthKeyDown: function(evt){
|
| + // IE doesn't fire keypress for most non-printable characters.
|
| + // other browsers do, we simulate it here.
|
| + var kp = evt.currentTarget.onkeypress;
|
| + // only works if kp exists and is a dispatcher
|
| + if(!kp || !kp[listenersName]){ return; }
|
| + // munge key/charCode
|
| + var k=evt.keyCode;
|
| + // These are Windows Virtual Key Codes
|
| + // http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/WinUI/WindowsUserInterface/UserInput/VirtualKeyCodes.asp
|
| + var unprintable = (k!=13)&&(k!=32)&&(k!=27)&&(k<48||k>90)&&(k<96||k>111)&&(k<186||k>192)&&(k<219||k>222);
|
| + // synthesize keypress for most unprintables and CTRL-keys
|
| + if(unprintable||evt.ctrlKey){
|
| + var c = unprintable ? 0 : k;
|
| + if(evt.ctrlKey){
|
| + if(k==3 || k==13){
|
| + return; // IE will post CTRL-BREAK, CTRL-ENTER as keypress natively
|
| + }else if(c>95 && c<106){
|
| + c -= 48; // map CTRL-[numpad 0-9] to ASCII
|
| + }else if((!evt.shiftKey)&&(c>=65&&c<=90)){
|
| + c += 32; // map CTRL-[A-Z] to lowercase
|
| + }else{
|
| + c = del._punctMap[c] || c; // map other problematic CTRL combinations to ASCII
|
| + }
|
| + }
|
| + // simulate a keypress event
|
| + var faux = del._synthesizeEvent(evt, {type: 'keypress', faux: true, charCode: c});
|
| + kp.call(evt.currentTarget, faux);
|
| + evt.cancelBubble = faux.cancelBubble;
|
| + evt.returnValue = faux.returnValue;
|
| + _trySetKeyCode(evt, faux.keyCode);
|
| + }
|
| + },
|
| + // Called in Event scope
|
| + _stopPropagation: function(){
|
| + this.cancelBubble = true;
|
| + },
|
| + _preventDefault: function(){
|
| + // Setting keyCode to 0 is the only way to prevent certain keypresses (namely
|
| + // ctrl-combinations that correspond to menu accelerator keys).
|
| + // Otoh, it prevents upstream listeners from getting this information
|
| + // Try to split the difference here by clobbering keyCode only for ctrl
|
| + // combinations. If you still need to access the key upstream, bubbledKeyCode is
|
| + // provided as a workaround.
|
| + this.bubbledKeyCode = this.keyCode;
|
| + if(this.ctrlKey){_trySetKeyCode(this, 0);}
|
| + this.returnValue = false;
|
| + }
|
| + });
|
| +
|
| + // override stopEvent for IE
|
| + dojo.stopEvent = function(evt){
|
| + evt = evt || window.event;
|
| + del._stopPropagation.call(evt);
|
| + del._preventDefault.call(evt);
|
| + }
|
| + }
|
| +
|
| + del._synthesizeEvent = function(evt, props){
|
| + var faux = dojo.mixin({}, evt, props);
|
| + del._setKeyChar(faux);
|
| + // FIXME: would prefer to use dojo.hitch: dojo.hitch(evt, evt.preventDefault);
|
| + // but it throws an error when preventDefault is invoked on Safari
|
| + // does Event.preventDefault not support "apply" on Safari?
|
| + faux.preventDefault = function(){ evt.preventDefault(); };
|
| + faux.stopPropagation = function(){ evt.stopPropagation(); };
|
| + return faux;
|
| + }
|
| +
|
| + // Opera event normalization
|
| + if(dojo.isOpera){
|
| + dojo.mixin(del, {
|
| + _fixEvent: function(evt, sender){
|
| + switch(evt.type){
|
| + case "keypress":
|
| + var c = evt.which;
|
| + if(c==3){
|
| + c=99; // Mozilla maps CTRL-BREAK to CTRL-c
|
| + }
|
| + // can't trap some keys at all, like INSERT and DELETE
|
| + // there is no differentiating info between DELETE and ".", or INSERT and "-"
|
| + c = ((c<41)&&(!evt.shiftKey) ? 0 : c);
|
| + if((evt.ctrlKey)&&(!evt.shiftKey)&&(c>=65)&&(c<=90)){
|
| + // lowercase CTRL-[A-Z] keys
|
| + c += 32;
|
| + }
|
| + return del._synthesizeEvent(evt, { charCode: c });
|
| + }
|
| + return evt;
|
| + }
|
| + });
|
| + }
|
| +
|
| + // Safari event normalization
|
| + if(dojo.isSafari){
|
| + del._add = del.add;
|
| + del._remove = del.remove;
|
| +
|
| + dojo.mixin(del, {
|
| + add: function(/*DOMNode*/node, /*String*/event, /*Function*/fp){
|
| + if(!node){return;} // undefined
|
| + var handle = del._add(node, event, fp);
|
| + if(del._normalizeEventName(event) == "keypress"){
|
| + // we need to listen to onkeydown to synthesize
|
| + // keypress events that otherwise won't fire
|
| + // in Safari 3.1+: https://lists.webkit.org/pipermail/webkit-dev/2007-December/002992.html
|
| + handle._stealthKeyDownHandle = del._add(node, "keydown", function(evt){
|
| + //A variation on the IE _stealthKeydown function
|
| + //Synthesize an onkeypress event, but only for unprintable characters.
|
| + var k=evt.keyCode;
|
| + // These are Windows Virtual Key Codes
|
| + // http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/WinUI/WindowsUserInterface/UserInput/VirtualKeyCodes.asp
|
| + var unprintable = (k!=13)&&(k!=32)&&(k!=27)&&(k<48||k>90)&&(k<96||k>111)&&(k<186||k>192)&&(k<219||k>222);
|
| + // synthesize keypress for most unprintables and CTRL-keys
|
| + if(unprintable||evt.ctrlKey){
|
| + var c = unprintable ? 0 : k;
|
| + if(evt.ctrlKey){
|
| + if(k==3 || k==13){
|
| + return; // IE will post CTRL-BREAK, CTRL-ENTER as keypress natively
|
| + }else if(c>95 && c<106){
|
| + c -= 48; // map CTRL-[numpad 0-9] to ASCII
|
| + }else if((!evt.shiftKey)&&(c>=65&&c<=90)){
|
| + c += 32; // map CTRL-[A-Z] to lowercase
|
| + }else{
|
| + c = del._punctMap[c] || c; // map other problematic CTRL combinations to ASCII
|
| + }
|
| + }
|
| + // simulate a keypress event
|
| + var faux = del._synthesizeEvent(evt, {type: 'keypress', faux: true, charCode: c});
|
| + fp.call(evt.currentTarget, faux);
|
| + }
|
| + });
|
| + }
|
| + return handle; /*Handle*/
|
| + },
|
| +
|
| + remove: function(/*DOMNode*/node, /*String*/event, /*Handle*/handle){
|
| + if(node){
|
| + if(handle._stealthKeyDownHandle){
|
| + del._remove(node, "keydown", handle._stealthKeyDownHandle);
|
| + }
|
| + del._remove(node, event, handle);
|
| + }
|
| + },
|
| + _fixEvent: function(evt, sender){
|
| + switch(evt.type){
|
| + case "keypress":
|
| + if(evt.faux){ return evt; }
|
| + var c = evt.charCode;
|
| + c = c>=32? c : 0;
|
| + return del._synthesizeEvent(evt, {charCode: c, faux: true});
|
| + }
|
| + return evt;
|
| + }
|
| + });
|
| + }
|
| +})();
|
| +
|
| +if(dojo.isIE){
|
| + // keep this out of the closure
|
| + // closing over 'iel' or 'ieh' b0rks leak prevention
|
| + // ls[i] is an index into the master handler array
|
| + dojo._ieDispatcher = function(args, sender){
|
| + var ap=Array.prototype, h=dojo._ie_listener.handlers, c=args.callee, ls=c[dojo._ieListenersName], t=h[c.target];
|
| + // return value comes from original target function
|
| + var r = t && t.apply(sender, args);
|
| + // make local copy of listener array so it's immutable during processing
|
| + var lls = [].concat(ls);
|
| + // invoke listeners after target function
|
| + for(var i in lls){
|
| + if(!(i in ap)){
|
| + h[lls[i]].apply(sender, args);
|
| + }
|
| + }
|
| + return r;
|
| + }
|
| + dojo._getIeDispatcher = function(){
|
| + // ensure the returned function closes over nothing ("new Function" apparently doesn't close)
|
| + return new Function(dojo._scopeName + "._ieDispatcher(arguments, this)"); // function
|
| + }
|
| + // keep this out of the closure to reduce RAM allocation
|
| + dojo._event_listener._fixCallback = function(fp){
|
| + var f = dojo._event_listener._fixEvent;
|
| + return function(e){ return fp.call(this, f(e, this)); };
|
| + }
|
| +}
|
| +
|
| +}
|
| +
|
| +if(!dojo._hasResource["dojo._base.html"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
|
| +dojo._hasResource["dojo._base.html"] = true;
|
| +
|
| +dojo.provide("dojo._base.html");
|
| +
|
| +// 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, similar to "$" function in another library.
|
| + // 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.
|
| +=====*/
|
| +if(dojo.isIE || dojo.isOpera){
|
| + dojo.byId = function(id, doc){
|
| + if(dojo.isString(id)){
|
| + var _d = doc || dojo.doc;
|
| + var te = _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){
|
| + return te;
|
| + }else{
|
| + var eles = _d.all[id];
|
| + if(!eles || !eles.length){ return eles; }
|
| + // if more than 1, choose first with the correct id
|
| + var i=0;
|
| + while((te=eles[i++])){
|
| + if(te.attributes.id.value == id){ return te; }
|
| + }
|
| + }
|
| + }else{
|
| + return id; // DomNode
|
| + }
|
| + }
|
| +}else{
|
| + dojo.byId = function(id, doc){
|
| + return dojo.isString(id) ? (doc || dojo.doc).getElementById(id) : id; // DomNode
|
| + }
|
| +}
|
| +/*=====
|
| +}
|
| +=====*/
|
| +
|
| +(function(){
|
| + var d = dojo;
|
| +
|
| + var _destroyContainer = null;
|
| + dojo.addOnWindowUnload(function(){
|
| + _destroyContainer=null; //prevent IE leak
|
| + });
|
| +
|
| + dojo._destroyElement = function(/*String||DomNode*/node){
|
| + // summary:
|
| + // removes node from its parent, clobbers it and all of its
|
| + // children.
|
| + // node:
|
| + // the element to be destroyed, either as an ID or a reference
|
| +
|
| + node = d.byId(node);
|
| + try{
|
| + if(!_destroyContainer || _destroyContainer.ownerDocument != node.ownerDocument){
|
| + _destroyContainer = node.ownerDocument.createElement("div");
|
| + }
|
| + _destroyContainer.appendChild(node.parentNode ? node.parentNode.removeChild(node) : node);
|
| + // NOTE: see http://trac.dojotoolkit.org/ticket/2931. This may be a bug and not a feature
|
| + _destroyContainer.innerHTML = "";
|
| + }catch(e){
|
| + /* squelch */
|
| + }
|
| + };
|
| +
|
| + dojo.isDescendant = function(/*DomNode|String*/node, /*DomNode|String*/ancestor){
|
| + // summary:
|
| + // Returns true if node is a descendant of ancestor
|
| + // node: id or node reference to test
|
| + // ancestor: id or node reference of potential parent to test against
|
| + try{
|
| + node = d.byId(node);
|
| + ancestor = d.byId(ancestor);
|
| + while(node){
|
| + if(node === ancestor){
|
| + return true; // Boolean
|
| + }
|
| + node = node.parentNode;
|
| + }
|
| + }catch(e){ /* squelch, return false */ }
|
| + return false; // Boolean
|
| + };
|
| +
|
| + dojo.setSelectable = function(/*DomNode|String*/node, /*Boolean*/selectable){
|
| + // summary: enable or disable selection on a node
|
| + // node:
|
| + // id or reference to node
|
| + // selectable:
|
| + node = d.byId(node);
|
| + if(d.isMozilla){
|
| + node.style.MozUserSelect = selectable ? "" : "none";
|
| + }else if(d.isKhtml){
|
| + node.style.KhtmlUserSelect = selectable ? "auto" : "none";
|
| + }else if(d.isIE){
|
| + var v = (node.unselectable = selectable ? "" : "on");
|
| + d.query("*", node).forEach("item.unselectable = '"+v+"'");
|
| + }
|
| + //FIXME: else? Opera?
|
| + };
|
| +
|
| + var _insertBefore = function(/*Node*/node, /*Node*/ref){
|
| + ref.parentNode.insertBefore(node, ref);
|
| + return true; // boolean
|
| + }
|
| +
|
| + var _insertAfter = function(/*Node*/node, /*Node*/ref){
|
| + // summary:
|
| + // Try to insert node after ref
|
| + var pn = ref.parentNode;
|
| + if(ref == pn.lastChild){
|
| + pn.appendChild(node);
|
| + }else{
|
| + return _insertBefore(node, ref.nextSibling); // boolean
|
| + }
|
| + return true; // boolean
|
| + }
|
| +
|
| + dojo.place = function(/*String|DomNode*/node, /*String|DomNode*/refNode, /*String?|Number?*/position){
|
| + // summary:
|
| + // Attempt to insert node into the DOM, choosing from various positioning options.
|
| + // Returns true if successful, false otherwise.
|
| + // node:
|
| + // id or node reference to place relative to refNode
|
| + // refNode:
|
| + // id or node reference to use as basis for placement
|
| + // position:
|
| + // 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
|
| + // * first
|
| + // * last
|
| + //
|
| + // "first" and "last" indicate positions as children of refNode. position defaults
|
| + // to "last" if not specified
|
| +
|
| + // FIXME: need to write tests for this!!!!
|
| + if(!node || !refNode){
|
| + return false; // boolean
|
| + }
|
| + node = d.byId(node);
|
| + refNode = d.byId(refNode);
|
| + if(typeof position == "number"){
|
| + var cn = refNode.childNodes;
|
| + if(!cn.length || cn.length <= position){
|
| + refNode.appendChild(node);
|
| + return true;
|
| + }
|
| + return _insertBefore(node, position <= 0 ? refNode.firstChild : cn[position]);
|
| + }
|
| + switch(position){
|
| + case "before":
|
| + return _insertBefore(node, refNode); // boolean
|
| + case "after":
|
| + return _insertAfter(node, refNode); // boolean
|
| + case "first":
|
| + if(refNode.firstChild){
|
| + return _insertBefore(node, refNode.firstChild); // boolean
|
| + }
|
| + // else fallthrough...
|
| + default: // aka: last
|
| + refNode.appendChild(node);
|
| + return true; // boolean
|
| + }
|
| + }
|
| +
|
| + // 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)
|
| + dojo.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(d.isIE /*|| dojo.isOpera*/){
|
| + var _dcm = document.compatMode;
|
| + // client code may have to adjust if compatMode varies across iframes
|
| + d.boxModel = _dcm == "BackCompat" || _dcm == "QuirksMode" || d.isIE<6 ? "border-box" : "content-box"; // FIXME: remove IE < 6 support?
|
| + }
|
| +
|
| + // =============================
|
| + // 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;
|
| + return; // CSS2Properties
|
| + }
|
| +=====*/
|
| +
|
| + // Although we normally eschew argument validation at this
|
| + // level, here we test argument 'node' for (duck)type.
|
| + // Argument node must also implement Element. (Note: we check
|
| + // against HTMLElement rather than Element for interop with prototype.js)
|
| + // Because 'document' is the 'parentNode' of 'body'
|
| + // it is frequently sent to this function even
|
| + // though it is not Element.
|
| + var gcs;
|
| + if(d.isSafari){
|
| + gcs = function(/*DomNode*/node){
|
| + var s;
|
| + if(node instanceof HTMLElement){
|
| + 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(d.isIE){
|
| + gcs = function(node){
|
| + // IE (as of 7) doesn't expose Element like sane browsers
|
| + return node.nodeType == 1 /* ELEMENT_NODE*/ ? node.currentStyle : {};
|
| + };
|
| + }else{
|
| + gcs = function(node){
|
| + return node instanceof HTMLElement ?
|
| + node.ownerDocument.defaultView.getComputedStyle(node, null) : {};
|
| + };
|
| + }
|
| + dojo.getComputedStyle = gcs;
|
| +
|
| + if(!d.isIE){
|
| + dojo._toPixelValue = function(element, value){
|
| + // style values can be floats, client code may want
|
| + // to round for integer pixels.
|
| + return parseFloat(value) || 0;
|
| + };
|
| + }else{
|
| + dojo._toPixelValue = 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); }
|
| + with(element){
|
| + var sLeft = style.left;
|
| + var rsLeft = runtimeStyle.left;
|
| + runtimeStyle.left = currentStyle.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
|
| + style.left = avalue;
|
| + avalue = style.pixelLeft;
|
| + }catch(e){
|
| + avalue = 0;
|
| + }
|
| + style.left = sLeft;
|
| + runtimeStyle.left = rsLeft;
|
| + }
|
| + return avalue;
|
| + }
|
| + }
|
| + var px = d._toPixelValue;
|
| +
|
| + // FIXME: there opacity quirks on FF that we haven't ported over. Hrm.
|
| + /*=====
|
| + dojo._getOpacity = function(node){
|
| + // summary:
|
| + // Returns the current opacity of the passed node as a
|
| + // floating-point value between 0 and 1.
|
| + // node: DomNode
|
| + // a reference to a DOM node. Does NOT support taking an
|
| + // ID string for speed reasons.
|
| + // returns: Number between 0 and 1
|
| + return; // Number
|
| + }
|
| + =====*/
|
| +
|
| + var astr = "DXImageTransform.Microsoft.Alpha";
|
| + var af = function(n, f){
|
| + try{
|
| + return n.filters.item(astr);
|
| + }catch(e){
|
| + return f ? {} : null;
|
| + }
|
| + }
|
| +
|
| + dojo._getOpacity = d.isIE ? function(node){
|
| + try{
|
| + return af(node).Opacity / 100; // Number
|
| + }catch(e){
|
| + return 1; // Number
|
| + }
|
| + } : function(node){
|
| + return gcs(node).opacity;
|
| + };
|
| +
|
| + /*=====
|
| + dojo._setOpacity = function(node, opacity){
|
| + // summary:
|
| + // set the opacity of the passed node portably. Returns the
|
| + // new opacity of the node.
|
| + // node: DOMNode
|
| + // a reference to a DOM node. Does NOT support taking an
|
| + // ID string for performance reasons.
|
| + // opacity: Number
|
| + // A Number between 0 and 1. 0 specifies transparent.
|
| + // returns: Number between 0 and 1
|
| + return; // Number
|
| + }
|
| + =====*/
|
| +
|
| + dojo._setOpacity = d.isIE ? function(/*DomNode*/node, /*Number*/opacity){
|
| + var ov = opacity * 100;
|
| + node.style.zoom = 1.0;
|
| +
|
| + // 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 = (opacity == 1 ? false : true);
|
| +
|
| + if(!af(node)){
|
| + node.style.filter += " progid:"+astr+"(Opacity="+ov+")";
|
| + }else{
|
| + af(node, 1).Opacity = ov;
|
| + }
|
| +
|
| + if(node.nodeName.toLowerCase() == "tr"){
|
| + d.query("> td", node).forEach(function(i){
|
| + d._setOpacity(i, 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
|
| + var _toStyleValue = function(node, type, value){
|
| + type = type.toLowerCase(); // FIXME: should we really be doing string case conversion here? Should we cache it? Need to profile!
|
| + if(d.isIE){
|
| + 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] ? px(node, value) : value;
|
| + }
|
| +
|
| + var _floatStyle = d.isIE ? "styleFloat" : "cssFloat";
|
| + var _floatAliases = { "cssFloat": _floatStyle, "styleFloat": _floatStyle, "float": _floatStyle };
|
| +
|
| + // public API
|
| +
|
| + dojo.style = function( /*DomNode|String*/ node,
|
| + /*String?|Object?*/ style,
|
| + /*String?*/ value){
|
| + // summary:
|
| + // Accesses styles on a node. If 2 arguments are
|
| + // passed, acts as a getter. If 3 arguments are passed, acts
|
| + // as a setter.
|
| + // node:
|
| + // id or reference to node to get/set style for
|
| + // style:
|
| + // 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:
|
| + // If passed, sets value on the node for style, handling
|
| + // cross-browser concerns.
|
| + // example:
|
| + // Passing only an ID or node returns the computed style object of
|
| + // the node:
|
| + // | dojo.style("thinger");
|
| + // example:
|
| + // Passing a node and a style property returns the current
|
| + // normalized, computed value for that property:
|
| + // | dojo.style("thinger", "opacity"); // 1 by default
|
| + //
|
| + // example:
|
| + // Passing a node, a style property, and a value changes the
|
| + // current display of the node and returns the new computed value
|
| + // | dojo.style("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.style("thinger", {
|
| + // | "opacity": 0.5,
|
| + // | "border": "3px solid black",
|
| + // | "height": 300
|
| + // | });
|
| + //
|
| + // example:
|
| + // When the CSS style property is hyphenated, the JavaScript property is camelCased.
|
| + // font-size becomes fontSize, and so on.
|
| + // | dojo.style("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"
|
| + // | });
|
| +
|
| + var n = d.byId(node), args = arguments.length, op = (style=="opacity");
|
| + style = _floatAliases[style] || style;
|
| + if(args == 3){
|
| + return op ? d._setOpacity(n, value) : n.style[style] = value; /*Number*/
|
| + }
|
| + if(args == 2 && op){
|
| + return d._getOpacity(n);
|
| + }
|
| + var s = gcs(n);
|
| + if(args == 2 && !d.isString(style)){
|
| + for(var x in style){
|
| + d.style(node, x, style[x]);
|
| + }
|
| + return s;
|
| + }
|
| + return (args == 1) ? s : _toStyleValue(n, style, s[style]||n.style[style]); /* CSS2Properties||String||Number */
|
| + }
|
| +
|
| + // =============================
|
| + // Box Functions
|
| + // =============================
|
| +
|
| + dojo._getPadExtents = function(/*DomNode*/n, /*Object*/computedStyle){
|
| + // summary:
|
| + // Returns object with special values specifically useful for node
|
| + // fitting.
|
| + //
|
| + // * l/t = left/top 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.
|
| + var
|
| + s = computedStyle||gcs(n),
|
| + l = px(n, s.paddingLeft),
|
| + t = px(n, s.paddingTop);
|
| + return {
|
| + l: l,
|
| + t: t,
|
| + w: l+px(n, s.paddingRight),
|
| + h: t+px(n, s.paddingBottom)
|
| + };
|
| + }
|
| +
|
| + dojo._getBorderExtents = function(/*DomNode*/n, /*Object*/computedStyle){
|
| + // summary:
|
| + // returns an object with properties useful for noting the border
|
| + // dimensions.
|
| + //
|
| + // * l/t = the sum of left/top 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.
|
| + var
|
| + ne = "none",
|
| + s = computedStyle||gcs(n),
|
| + bl = (s.borderLeftStyle != ne ? px(n, s.borderLeftWidth) : 0),
|
| + bt = (s.borderTopStyle != ne ? px(n, s.borderTopWidth) : 0);
|
| + return {
|
| + l: bl,
|
| + t: bt,
|
| + w: bl + (s.borderRightStyle!=ne ? px(n, s.borderRightWidth) : 0),
|
| + h: bt + (s.borderBottomStyle!=ne ? px(n, s.borderBottomWidth) : 0)
|
| + };
|
| + }
|
| +
|
| + dojo._getPadBorderExtents = function(/*DomNode*/n, /*Object*/computedStyle){
|
| + // summary:
|
| + // returns object with properties useful for box fitting with
|
| + // regards to padding.
|
| + //
|
| + // * l/t = the sum of left/top padding and left/top 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.
|
| + var
|
| + s = computedStyle||gcs(n),
|
| + p = d._getPadExtents(n, s),
|
| + b = d._getBorderExtents(n, s);
|
| + return {
|
| + l: p.l + b.l,
|
| + t: p.t + b.t,
|
| + w: p.w + b.w,
|
| + h: p.h + b.h
|
| + };
|
| + }
|
| +
|
| + dojo._getMarginExtents = function(n, 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.
|
| + var
|
| + s = computedStyle||gcs(n),
|
| + l = px(n, s.marginLeft),
|
| + t = px(n, s.marginTop),
|
| + r = px(n, s.marginRight),
|
| + b = px(n, s.marginBottom);
|
| + if(d.isSafari && (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,
|
| + 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
|
| +
|
| + dojo._getMarginBox = function(/*DomNode*/node, /*Object*/computedStyle){
|
| + // summary:
|
| + // returns an object that encodes the width, height, left and top
|
| + // positions of the node's margin box.
|
| + var s = computedStyle||gcs(node), me = d._getMarginExtents(node, s);
|
| + var l = node.offsetLeft - me.l, t = node.offsetTop - me.t, p = node.parentNode;
|
| + if(d.isMoz){
|
| + // 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){
|
| + var pcs = gcs(p);
|
| + if(pcs.overflow != "visible"){
|
| + var be = d._getBorderExtents(p, pcs);
|
| + l += be.l, t += be.t;
|
| + }
|
| + }
|
| + }
|
| + }else if(d.isOpera){
|
| + // On Opera, offsetLeft includes the parent's border
|
| + if(p){
|
| + var be = d._getBorderExtents(p);
|
| + l -= be.l;
|
| + t -= be.t;
|
| + }
|
| + }
|
| + return {
|
| + l: l,
|
| + t: t,
|
| + w: node.offsetWidth + me.w,
|
| + h: node.offsetHeight + me.h
|
| + };
|
| + }
|
| +
|
| + 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.
|
| +
|
| + // clientWidth/Height are important since the automatically account for scrollbars
|
| + // fallback to offsetWidth/Height for special cases (see #3378)
|
| + var s=computedStyle||gcs(node), pe=d._getPadExtents(node, s), be=d._getBorderExtents(node, s), w=node.clientWidth, h;
|
| + 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(d.isOpera){ 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
|
| + };
|
| + }
|
| +
|
| + dojo._getBorderBox = function(node, computedStyle){
|
| + var s=computedStyle||gcs(node), pe=d._getPadExtents(node, s), cb=d._getContentBox(node, s);
|
| + return {
|
| + l: cb.l - pe.l,
|
| + t: cb.t - pe.t,
|
| + w: cb.w + pe.w,
|
| + h: cb.h + pe.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.
|
| +
|
| + dojo._setBox = function(/*DomNode*/node, /*Number?*/l, /*Number?*/t, /*Number?*/w, /*Number?*/h, /*String?*/u){
|
| + // summary:
|
| + // sets width/height/left/top in the current (native) box-model
|
| + // dimentions. Uses the unit passed in u.
|
| + // node: DOM Node reference. Id string not supported for performance reasons.
|
| + // l: optional. left offset from parent.
|
| + // t: optional. top offset from parent.
|
| + // w: optional. width in current box model.
|
| + // h: optional. width in current box model.
|
| + // u: optional. 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; }
|
| + }
|
| +
|
| + dojo._isButtonTag = function(/*DomNode*/node) {
|
| + // summary:
|
| + // True if the node is BUTTON or INPUT.type="button".
|
| + return node.tagName == "BUTTON"
|
| + || node.tagName=="INPUT" && node.getAttribute("type").toUpperCase() == "BUTTON"; // boolean
|
| + }
|
| +
|
| + dojo._usesBorderBox = function(/*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.
|
| +
|
| + var n = node.tagName;
|
| + return d.boxModel=="border-box" || n=="TABLE" || dojo._isButtonTag(node); // boolean
|
| + }
|
| +
|
| + dojo._setContentSize = function(/*DomNode*/node, /*Number*/widthPx, /*Number*/heightPx, /*Object*/computedStyle){
|
| + // summary:
|
| + // Sets the size of the node's contents, irrespective of margins,
|
| + // padding, or borders.
|
| + if(d._usesBorderBox(node)){
|
| + var pb = d._getPadBorderExtents(node, computedStyle);
|
| + if(widthPx >= 0){ widthPx += pb.w; }
|
| + if(heightPx >= 0){ heightPx += pb.h; }
|
| + }
|
| + d._setBox(node, NaN, NaN, widthPx, heightPx);
|
| + }
|
| +
|
| + dojo._setMarginBox = function(/*DomNode*/node, /*Number?*/leftPx, /*Number?*/topPx,
|
| + /*Number?*/widthPx, /*Number?*/heightPx,
|
| + /*Object*/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 dojo._setBox that handles box-model vagaries for
|
| + // you.
|
| +
|
| + var s = computedStyle||gcs(node);
|
| + // 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.
|
| + var bb=d._usesBorderBox(node),
|
| + pb=bb ? _nilExtents : d._getPadBorderExtents(node, s);
|
| + if (dojo.isSafari) {
|
| + // 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 (dojo._isButtonTag(node)){
|
| + var ns = node.style;
|
| + if (widthPx>=0 && !ns.width) { ns.width = "4px"; }
|
| + if (heightPx>=0 && !ns.height) { ns.height = "4px"; }
|
| + }
|
| + }
|
| + var mb=d._getMarginExtents(node, s);
|
| + if(widthPx>=0){ widthPx = Math.max(widthPx - pb.w - mb.w, 0); }
|
| + if(heightPx>=0){ heightPx = Math.max(heightPx - pb.h - mb.h, 0); }
|
| + d._setBox(node, leftPx, topPx, widthPx, heightPx);
|
| + }
|
| +
|
| + var _nilExtents = { l:0, t:0, w:0, h:0 };
|
| +
|
| + // public API
|
| +
|
| + dojo.marginBox = function(/*DomNode|String*/node, /*Object?*/box){
|
| + // summary:
|
| + // Getter/setter for the margin-box of node.
|
| + // description:
|
| + // Returns an object in the expected format of box (regardless
|
| + // if box is passed). The object might look like:
|
| + // `{ l: 50, t: 200, w: 300: h: 150 }`
|
| + // for a node offset from its parent 50px to the left, 200px from
|
| + // the top with a margin width of 300px and a margin-height of
|
| + // 150px.
|
| + // node:
|
| + // id or reference to DOM Node to get/set box for
|
| + // box:
|
| + // If passed, denotes that dojo.marginBox() should
|
| + // update/set the margin box for node. Box is an object in the
|
| + // above format. All properties are optional if passed.
|
| + var n=d.byId(node), s=gcs(n), b=box;
|
| + return !b ? d._getMarginBox(n, s) : d._setMarginBox(n, b.l, b.t, b.w, b.h, s); // Object
|
| + }
|
| +
|
| + dojo.contentBox = function(/*DomNode|String*/node, /*Object?*/box){
|
| + // summary:
|
| + // Getter/setter for the content-box of node.
|
| + // description:
|
| + // Returns an object in the expected format of box (regardless if box is passed).
|
| + // The object might look like:
|
| + // `{ l: 50, t: 200, w: 300: h: 150 }`
|
| + // for a node offset from its parent 50px to the left, 200px from
|
| + // the top with a content width of 300px and a content-height of
|
| + // 150px. Note that the content box may have a much larger border
|
| + // or margin box, depending on the box model currently in use and
|
| + // CSS values set/inherited for node.
|
| + // node:
|
| + // id or reference to DOM Node to get/set box for
|
| + // box:
|
| + // If passed, denotes that dojo.contentBox() should
|
| + // update/set the content box for node. Box is an object in the
|
| + // above format. All properties are optional if passed.
|
| + var n=d.byId(node), s=gcs(n), b=box;
|
| + return !b ? d._getContentBox(n, s) : d._setContentSize(n, b.w, b.h, s); // Object
|
| + }
|
| +
|
| + // =============================
|
| + // Positioning
|
| + // =============================
|
| +
|
| + var _sumAncestorProperties = function(node, prop){
|
| + if(!(node = (node||0).parentNode)){return 0};
|
| + var val, retVal = 0, _b = d.body();
|
| + while(node && node.style){
|
| + if(gcs(node).position == "fixed"){
|
| + return 0;
|
| + }
|
| + val = node[prop];
|
| + if(val){
|
| + retVal += val - 0;
|
| + // opera and khtml #body & #html has the same values, we only
|
| + // need one value
|
| + if(node == _b){ break; }
|
| + }
|
| + node = node.parentNode;
|
| + }
|
| + return retVal; // integer
|
| + }
|
| +
|
| + dojo._docScroll = function(){
|
| + var
|
| + _b = d.body(),
|
| + _w = d.global,
|
| + de = d.doc.documentElement;
|
| + return {
|
| + y: (_w.pageYOffset || de.scrollTop || _b.scrollTop || 0),
|
| + x: (_w.pageXOffset || d._fixIeBiDiScrollLeft(de.scrollLeft) || _b.scrollLeft || 0)
|
| + };
|
| + };
|
| +
|
| + dojo._isBodyLtr = function(){
|
| + //FIXME: could check html and body tags directly instead of computed style? need to ignore case, accept empty values
|
| + return !("_bodyLtr" in d) ?
|
| + d._bodyLtr = gcs(d.body()).direction == "ltr" :
|
| + d._bodyLtr; // Boolean
|
| + }
|
| +
|
| + dojo._getIeDocumentElementOffset = function(){
|
| + // summary
|
| + // 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.
|
| +
|
| + //NOTE: assumes we're being called in an IE browser
|
| +
|
| + var de = d.doc.documentElement;
|
| + //FIXME: use this instead? var de = d.compatMode == "BackCompat" ? d.body : d.documentElement;
|
| +
|
| + return (d.isIE >= 7) ?
|
| + {x: de.getBoundingClientRect().left, y: de.getBoundingClientRect().top}
|
| + :
|
| + // IE 6.0
|
| + {x: d._isBodyLtr() || window.parent == window ?
|
| + de.clientLeft : de.offsetWidth - de.clientWidth - de.clientLeft,
|
| + y: de.clientTop}; // Object
|
| + };
|
| +
|
| + dojo._fixIeBiDiScrollLeft = function(/*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 dd = d.doc;
|
| + if(d.isIE && !dojo._isBodyLtr()){
|
| + var de = dd.compatMode == "BackCompat" ? dd.body : dd.documentElement;
|
| + return scrollLeft + de.clientWidth - de.scrollWidth; // Integer
|
| + }
|
| + return scrollLeft; // Integer
|
| + }
|
| +
|
| + dojo._abs = function(/*DomNode*/node, /*Boolean?*/includeScroll){
|
| + // summary:
|
| + // Gets the position of the passed element relative to
|
| + // the viewport (if includeScroll==false), or relative to the
|
| + // document root (if includeScroll==true).
|
| + //
|
| + // Returns an object of the form:
|
| + // { x: 100, y: 300 }
|
| + // if includeScroll is passed, the x and y values will include any
|
| + // document offsets that may affect the position relative to the
|
| + // viewport.
|
| +
|
| + // FIXME: need to decide in the brave-new-world if we're going to be
|
| + // margin-box or border-box.
|
| + var ownerDocument = node.ownerDocument;
|
| + var ret = {
|
| + x: 0,
|
| + y: 0
|
| + };
|
| +
|
| + // targetBoxType == "border-box"
|
| + var db = d.body();
|
| + if(d.isIE || (d.isFF >= 3)){
|
| + var client = node.getBoundingClientRect();
|
| + var cs;
|
| + if(d.isFF){
|
| + // in FF3 you have to subract the document element margins
|
| + var dv = node.ownerDocument.defaultView;
|
| + cs=dv.getComputedStyle(db.parentNode, null);
|
| + }
|
| + var offset = (d.isIE) ? d._getIeDocumentElementOffset() : { x: px(db.parentNode,cs.marginLeft), y: px(db.parentNode,cs.marginTop)};
|
| + ret.x = client.left - offset.x;
|
| + ret.y = client.top - offset.y;
|
| + }else{
|
| + if(node["offsetParent"]){
|
| + var endNode;
|
| + // in Safari, if the node is an absolutely positioned child of
|
| + // the body and the body has a margin the offset of the child
|
| + // and the body contain the body's margins, so we need to end
|
| + // at the body
|
| + // FIXME: getting contrary results to the above in latest WebKit.
|
| + if(d.isSafari &&
|
| + //(node.style.getPropertyValue("position") == "absolute") &&
|
| + (gcs(node).position == "absolute") &&
|
| + (node.parentNode == db)){
|
| + endNode = db;
|
| + }else{
|
| + endNode = db.parentNode;
|
| + }
|
| + // Opera seems to be double counting for some elements
|
| + var cs=gcs(node);
|
| + var n=node;
|
| + if(d.isOpera&&cs.position!="absolute"){
|
| + n=n.offsetParent;
|
| + }
|
| + ret.x -= _sumAncestorProperties(n, "scrollLeft");
|
| + ret.y -= _sumAncestorProperties(n, "scrollTop");
|
| +
|
| + var curnode = node;
|
| + do{
|
| + var n = curnode.offsetLeft;
|
| + //FIXME: ugly hack to workaround the submenu in
|
| + //popupmenu2 does not shown up correctly in opera.
|
| + //Someone have a better workaround?
|
| + if(!d.isOpera || n > 0){
|
| + ret.x += isNaN(n) ? 0 : n;
|
| + }
|
| + var t = curnode.offsetTop;
|
| + ret.y += isNaN(t) ? 0 : t;
|
| + var cs = gcs(curnode);
|
| + if(curnode != node){
|
| + if(d.isSafari){
|
| + ret.x += px(curnode, cs.borderLeftWidth);
|
| + ret.y += px(curnode, cs.borderTopWidth);
|
| + }else if(d.isFF){
|
| + // tried left+right with differently sized left/right borders
|
| + // it really is 2xleft border in FF, not left+right, even in RTL!
|
| + ret.x += 2*px(curnode,cs.borderLeftWidth);
|
| + ret.y += 2*px(curnode,cs.borderTopWidth);
|
| + }
|
| + }
|
| + // static children in a static div in FF2 are affected by the div's border as well
|
| + // but offsetParent will skip this div!
|
| + if(d.isFF&&cs.position=="static"){
|
| + var parent=curnode.parentNode;
|
| + while(parent!=curnode.offsetParent){
|
| + var pcs=gcs(parent);
|
| + if(pcs.position=="static"){
|
| + ret.x += px(curnode,pcs.borderLeftWidth);
|
| + ret.y += px(curnode,pcs.borderTopWidth);
|
| + }
|
| + parent=parent.parentNode;
|
| + }
|
| + }
|
| + curnode = curnode.offsetParent;
|
| + }while((curnode != endNode) && curnode);
|
| + }else if(node.x && node.y){
|
| + ret.x += isNaN(node.x) ? 0 : node.x;
|
| + ret.y += isNaN(node.y) ? 0 : node.y;
|
| + }
|
| + }
|
| + // 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 = d._docScroll();
|
| + ret.y += scroll.y;
|
| + ret.x += scroll.x;
|
| + }
|
| +
|
| + return ret; // object
|
| + }
|
| +
|
| + // FIXME: need a setter for coords or a moveTo!!
|
| + dojo.coords = function(/*DomNode|String*/node, /*Boolean?*/includeScroll){
|
| + // summary:
|
| + // Returns an object that measures margin box width/height and
|
| + // absolute positioning data from dojo._abs().
|
| + //
|
| + // description:
|
| + // Returns an object that measures margin box width/height and
|
| + // absolute positioning data from dojo._abs().
|
| + // Return value will be in the form:
|
| + // `{ l: 50, t: 200, w: 300: h: 150, x: 100, y: 300 }`
|
| + // Does not act as a setter. If includeScroll is passed, the x and
|
| + // y params are affected as one would expect in dojo._abs().
|
| + var n=d.byId(node), s=gcs(n), mb=d._getMarginBox(n, s);
|
| + var abs = d._abs(n, includeScroll);
|
| + mb.x = abs.x;
|
| + mb.y = abs.y;
|
| + return mb;
|
| + }
|
| +
|
| + // =============================
|
| + // Element attribute Functions
|
| + // =============================
|
| +
|
| + var ieLT8 = d.isIE < 8;
|
| +
|
| + var _fixAttrName = function(/*String*/name){
|
| + switch(name.toLowerCase()){
|
| + case "tabindex":
|
| + // Internet Explorer will only set or remove tabindex
|
| + // if it is spelled "tabIndex"
|
| + //
|
| + return ieLT8 ? "tabIndex" : "tabindex";
|
| + case "for": case "htmlfor":
|
| + // to pick up for attrib set in markup via getAttribute() IE<8 uses "htmlFor" and others use "for"
|
| + // get/setAttribute works in all as long use same value for both get/set
|
| + return ieLT8 ? "htmlFor" : "for";
|
| + case "class" :
|
| + return d.isIE ? "className" : "class";
|
| + default:
|
| + return name;
|
| + }
|
| + }
|
| +
|
| + // non-deprecated HTML4 attributes with default values
|
| + // http://www.w3.org/TR/html401/index/attributes.html
|
| + // FF and Safari will return the default values if you
|
| + // access the attributes via a property but not
|
| + // via getAttribute()
|
| + var _attrProps = {
|
| + colspan: "colSpan",
|
| + enctype: "enctype",
|
| + frameborder: "frameborder",
|
| + method: "method",
|
| + rowspan: "rowSpan",
|
| + scrolling: "scrolling",
|
| + shape: "shape",
|
| + span: "span",
|
| + type: "type",
|
| + valuetype: "valueType"
|
| + }
|
| +
|
| + dojo.hasAttr = function(/*DomNode|String*/node, /*String*/name){
|
| + // summary:
|
| + // Returns true if the requested attribute is specified on the
|
| + // given element, and false otherwise.
|
| + // node:
|
| + // id or reference to the element to check
|
| + // name:
|
| + // the name of the attribute
|
| + // returns:
|
| + // true if the requested attribute is specified on the
|
| + // given element, and false otherwise
|
| + node = d.byId(node);
|
| + var fixName = _fixAttrName(name);
|
| + fixName = fixName == "htmlFor" ? "for" : fixName; //IE<8 uses htmlFor except in this case
|
| + var attr = node.getAttributeNode && node.getAttributeNode(fixName);
|
| + return attr ? attr.specified : false; // Boolean
|
| + }
|
| +
|
| + var _evtHdlrMap = {
|
| +
|
| + }
|
| +
|
| + var _ctr = 0;
|
| + var _attrId = dojo._scopeName + "attrid";
|
| +
|
| + dojo.attr = function(/*DomNode|String*/node, /*String|Object*/name, /*String?*/value){
|
| + // summary:
|
| + // Gets or sets an attribute on an HTML element.
|
| + // description:
|
| + // Handles normalized getting and setting of attributes on DOM
|
| + // Nodes. If 2 arguments are passed, and a the second argumnt is a
|
| + // string, acts as a getter.
|
| + //
|
| + // If a third argument is passed, or if the second argumnt is a
|
| + // map of attributes, acts as a setter.
|
| + //
|
| + // 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:
|
| + // id or reference to the element to get or set the attribute on
|
| + // name:
|
| + // the name of the attribute to get or set.
|
| + // value:
|
| + // The value to set for the attribute
|
| + // returns:
|
| + // when used as a getter, the value of the requested attribute
|
| + // or null if that attribute does not have a specified or
|
| + // default value;
|
| + //
|
| + // when user as a setter, undefined
|
| + //
|
| + // example:
|
| + // | // get the current value of the "foo" attribute on a node
|
| + // | dojo.attr(dojo.byId("nodeId"), "foo");
|
| + // | // or we can just pass the id:
|
| + // | dojo.attr("nodeId", "foo");
|
| + //
|
| + // example:
|
| + // | // use attr() to set the tab index
|
| + // | dojo.attr("nodeId", "tabindex", 3);
|
| + // |
|
| + //
|
| + // example:
|
| + // | // set multiple values at once, including event handlers:
|
| + // | dojo.attr("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" });
|
| + // | }
|
| + // | });
|
| +
|
| + var args = arguments.length;
|
| + if(args == 2 && !d.isString(name)){
|
| + for(var x in name){ d.attr(node, x, name[x]); }
|
| + return;
|
| + }
|
| + node = d.byId(node);
|
| + name = _fixAttrName(name);
|
| + if(args == 3){
|
| + // FIXME:
|
| + // what about when the name is "style" and value is an object?
|
| + // It seems natural to pass it in to dojo.style(node,
|
| + // value)...should we support this?
|
| + if(d.isFunction(value)){
|
| + // clobber if we can
|
| + var attrId = d.attr(node, _attrId);
|
| + if(!attrId){
|
| + attrId = _ctr++;
|
| + d.attr(node, _attrId, attrId);
|
| + }
|
| + if(!_evtHdlrMap[attrId]){
|
| + _evtHdlrMap[attrId] = {};
|
| + }
|
| + var h = _evtHdlrMap[attrId][name];
|
| + if(h){
|
| + d.disconnect(h);
|
| + }else{
|
| + try{
|
| + delete node[name];
|
| + }catch(e){}
|
| + }
|
| +
|
| + // ensure that event objects are normalized, etc.
|
| + _evtHdlrMap[attrId][name] = d.connect(node, name, value);
|
| +
|
| + }else if(
|
| + (typeof value == "boolean")|| // e.g. onsubmit, disabled
|
| + (name == "innerHTML")
|
| + ){
|
| + node[name] = value;
|
| + }else if((name == "style")&&(!d.isString(value))){
|
| + d.style(node, value);
|
| + }else{
|
| + node.setAttribute(name, value);
|
| + }
|
| + return;
|
| + }else{
|
| + // should we access this attribute via a property or
|
| + // via getAttribute()?
|
| + var prop = _attrProps[name.toLowerCase()];
|
| + if(prop){
|
| + return node[prop];
|
| + }else{
|
| + var attrValue = node[name];
|
| + return (typeof attrValue == 'boolean' || typeof attrValue == 'function') ? attrValue
|
| + : (d.hasAttr(node, name) ? node.getAttribute(name) : null);
|
| + }
|
| + }
|
| + }
|
| +
|
| + dojo.removeAttr = function(/*DomNode|String*/node, /*String*/name){
|
| + // summary:
|
| + // Removes an attribute from an HTML element.
|
| + // node:
|
| + // id or reference to the element to remove the attribute from
|
| + // name:
|
| + // the name of the attribute to remove
|
| + d.byId(node).removeAttribute(_fixAttrName(name));
|
| + }
|
| +
|
| + /*
|
| + dojo.createElement = function(type, attrs, parent, position){
|
| + // TODO: need to finish this!
|
| + }
|
| + */
|
| +
|
| + // =============================
|
| + // (CSS) Class Functions
|
| + // =============================
|
| + var _className = "className";
|
| +
|
| + dojo.hasClass = function(/*DomNode|String*/node, /*String*/classStr){
|
| + // summary:
|
| + // Returns whether or not the specified classes are a portion of the
|
| + // class list currently applied to the node.
|
| + return ((" "+ d.byId(node)[_className] +" ").indexOf(" "+ classStr +" ") >= 0); // Boolean
|
| + };
|
| +
|
| + dojo.addClass = function(/*DomNode|String*/node, /*String*/classStr){
|
| + // summary:
|
| + // Adds the specified classes to the end of the class list on the
|
| + // passed node.
|
| + node = d.byId(node);
|
| + var cls = node[_className];
|
| + if((" "+ cls +" ").indexOf(" " + classStr + " ") < 0){
|
| + node[_className] = cls + (cls ? ' ' : '') + classStr;
|
| + }
|
| + };
|
| +
|
| + dojo.removeClass = function(/*DomNode|String*/node, /*String*/classStr){
|
| + // summary: Removes the specified classes from node.
|
| + node = d.byId(node);
|
| + var t = d.trim((" " + node[_className] + " ").replace(" " + classStr + " ", " "));
|
| + if(node[_className] != t){ node[_className] = t; }
|
| + };
|
| +
|
| + dojo.toggleClass = function(/*DomNode|String*/node, /*String*/classStr, /*Boolean?*/condition){
|
| + // summary:
|
| + // Adds a class to node if not present, or removes if present.
|
| + // Pass a boolean condition if you want to explicitly add or remove.
|
| + // condition:
|
| + // If passed, true means to add the class, false means to remove.
|
| + if(condition === undefined){
|
| + condition = !d.hasClass(node, classStr);
|
| + }
|
| + d[condition ? "addClass" : "removeClass"](node, classStr);
|
| + };
|
| +
|
| +})();
|
| +
|
| +}
|
| +
|
| +if(!dojo._hasResource["dojo._base.NodeList"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
|
| +dojo._hasResource["dojo._base.NodeList"] = true;
|
| +dojo.provide("dojo._base.NodeList");
|
| +
|
| +
|
| +
|
| +(function(){
|
| +
|
| + var d = dojo;
|
| +
|
| + var tnl = function(arr){
|
| + // decorate an array to make it look like a NodeList
|
| + arr.constructor = dojo.NodeList;
|
| + dojo._mixin(arr, dojo.NodeList.prototype);
|
| + return arr;
|
| + }
|
| +
|
| + var _mapIntoDojo = function(func, alwaysThis){
|
| + // returns a function which, when executed in the scope of its caller,
|
| + // applies the passed arguments to a particular dojo.* function (named
|
| + // in func) and aggregates the returns. if alwaysThis is true, it
|
| + // always returns the scope object and not the collected returns from
|
| + // the Dojo method
|
| + return function(){
|
| + var _a = arguments;
|
| + var aa = d._toArray(_a, 0, [null]);
|
| + var s = this.map(function(i){
|
| + aa[0] = i;
|
| + return d[func].apply(d, aa);
|
| + });
|
| + return (alwaysThis || ( (_a.length > 1) || !d.isString(_a[0]) )) ? this : s; // String||dojo.NodeList
|
| + }
|
| + };
|
| +
|
| + dojo.NodeList = function(){
|
| + // summary:
|
| + // dojo.NodeList is as subclass of Array which adds syntactic
|
| + // sugar for chaining, common iteration operations, animation,
|
| + // and node manipulation. NodeLists are most often returned as
|
| + // the result of dojo.query() calls.
|
| + // example:
|
| + // create a node list from a node
|
| + // | new dojo.NodeList(dojo.byId("foo"));
|
| +
|
| + return tnl(Array.apply(null, arguments));
|
| + }
|
| +
|
| + dojo.NodeList._wrap = tnl;
|
| +
|
| + dojo.extend(dojo.NodeList, {
|
| + // http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array#Methods
|
| +
|
| + // FIXME: handle return values for #3244
|
| + // http://trac.dojotoolkit.org/ticket/3244
|
| +
|
| + // FIXME:
|
| + // need to wrap or implement:
|
| + // join (perhaps w/ innerHTML/outerHTML overload for toString() of items?)
|
| + // reduce
|
| + // reduceRight
|
| +
|
| + slice: function(/*===== begin, end =====*/){
|
| + // summary:
|
| + // Returns a new NodeList, maintaining this one in place
|
| + // description:
|
| + // This method behaves exactly like the Array.slice method
|
| + // with the caveat that it returns a dojo.NodeList and not a
|
| + // raw Array. For more details, see:
|
| + // http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:slice
|
| + // begin: Integer
|
| + // Can be a positive or negative integer, with positive
|
| + // integers noting the offset to begin at, and negative
|
| + // integers denoting an offset from the end (i.e., to the left
|
| + // of the end)
|
| + // end: Integer?
|
| + // Optional parameter to describe what position relative to
|
| + // the NodeList's zero index to end the slice at. Like begin,
|
| + // can be positive or negative.
|
| + var a = d._toArray(arguments);
|
| + return tnl(a.slice.apply(this, a));
|
| + },
|
| +
|
| + splice: function(/*===== index, howmany, item =====*/){
|
| + // summary:
|
| + // Returns a new NodeList, manipulating this NodeList based on
|
| + // the arguments passed, potentially splicing in new elements
|
| + // at an offset, optionally deleting elements
|
| + // description:
|
| + // This method behaves exactly like the Array.splice method
|
| + // with the caveat that it returns a dojo.NodeList and not a
|
| + // raw Array. For more details, see:
|
| + // <http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:splice>
|
| + // index: Integer
|
| + // begin can be a positive or negative integer, with positive
|
| + // integers noting the offset to begin at, and negative
|
| + // integers denoting an offset from the end (i.e., to the left
|
| + // of the end)
|
| + // howmany: Integer?
|
| + // Optional parameter to describe what position relative to
|
| + // the NodeList's zero index to end the slice at. Like begin,
|
| + // can be positive or negative.
|
| + // item: Object...?
|
| + // Any number of optional parameters may be passed in to be
|
| + // spliced into the NodeList
|
| + // returns:
|
| + // dojo.NodeList
|
| + var a = d._toArray(arguments);
|
| + return tnl(a.splice.apply(this, a));
|
| + },
|
| +
|
| + concat: function(/*===== item =====*/){
|
| + // summary:
|
| + // Returns a new NodeList comprised of items in this NodeList
|
| + // as well as items passed in as parameters
|
| + // description:
|
| + // This method behaves exactly like the Array.concat method
|
| + // with the caveat that it returns a dojo.NodeList and not a
|
| + // raw Array. For more details, see:
|
| + // <http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:concat>
|
| + // item: Object...?
|
| + // Any number of optional parameters may be passed in to be
|
| + // spliced into the NodeList
|
| + // returns:
|
| + // dojo.NodeList
|
| + var a = d._toArray(arguments, 0, [this]);
|
| + return tnl(a.concat.apply([], a));
|
| + },
|
| +
|
| + indexOf: function(/*Object*/ value, /*Integer?*/ fromIndex){
|
| + // summary:
|
| + // see dojo.indexOf(). The primary difference is that the acted-on
|
| + // array is implicitly this NodeList
|
| + // value:
|
| + // The value to search for.
|
| + // fromIndex:
|
| + // The loction to start searching from. Optional. Defaults to 0.
|
| + // description:
|
| + // For more details on the behavior of indexOf, see:
|
| + // <http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:indexOf>
|
| + // returns:
|
| + // Positive Integer or 0 for a match, -1 of not found.
|
| + return d.indexOf(this, value, fromIndex); // Integer
|
| + },
|
| +
|
| + lastIndexOf: function(/*===== value, fromIndex =====*/){
|
| + // summary:
|
| + // see dojo.lastIndexOf(). The primary difference is that the
|
| + // acted-on array is implicitly this NodeList
|
| + // description:
|
| + // For more details on the behavior of lastIndexOf, see:
|
| + // <http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:lastIndexOf>
|
| + // value: Object
|
| + // The value to search for.
|
| + // fromIndex: Integer?
|
| + // The loction to start searching from. Optional. Defaults to 0.
|
| + // returns:
|
| + // Positive Integer or 0 for a match, -1 of not found.
|
| + return d.lastIndexOf.apply(d, d._toArray(arguments, 0, [this])); // Integer
|
| + },
|
| +
|
| + every: function(/*Function*/callback, /*Object?*/thisObject){
|
| + // summary:
|
| + // see `dojo.every()` and:
|
| + // <http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:every>
|
| + // Takes the same structure of arguments and returns as
|
| + // dojo.every() with the caveat that the passed array is
|
| + // implicitly this NodeList
|
| + return d.every(this, callback, thisObject); // Boolean
|
| + },
|
| +
|
| + some: function(/*Function*/callback, /*Object?*/thisObject){
|
| + // summary:
|
| + // see dojo.some() and:
|
| + // http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:some
|
| + // Takes the same structure of arguments and returns as
|
| + // dojo.some() with the caveat that the passed array is
|
| + // implicitly this NodeList
|
| + return d.some(this, callback, thisObject); // Boolean
|
| + },
|
| +
|
| + map: function(/*Function*/ func, /*Function?*/ obj){
|
| + // summary:
|
| + // see dojo.map(). The primary difference is that the acted-on
|
| + // array is implicitly this NodeList and the return is a
|
| + // dojo.NodeList (a subclass of Array)
|
| +
|
| + return d.map(this, func, obj, d.NodeList); // dojo.NodeList
|
| + },
|
| +
|
| + forEach: function(callback, thisObj){
|
| + // summary:
|
| + // see dojo.forEach(). The primary difference is that the acted-on
|
| + // array is implicitly this NodeList
|
| +
|
| + d.forEach(this, callback, thisObj);
|
| + // non-standard return to allow easier chaining
|
| + return this; // dojo.NodeList
|
| + },
|
| +
|
| + // custom methods
|
| +
|
| + coords: function(){
|
| + // summary:
|
| + // Returns the box objects all elements in a node list as
|
| + // an Array (*not* a NodeList)
|
| +
|
| + return d.map(this, d.coords); // Array
|
| + },
|
| +
|
| + /*=====
|
| + attr: function(property, value){
|
| + // summary:
|
| + // gets or sets the DOM attribute for every element in the
|
| + // NodeList
|
| + // property: String
|
| + // the attribute to get/set
|
| + // value: String?
|
| + // optional. The value to set the property to
|
| + // returns:
|
| + // if no value is passed, the result is an array of attribute values
|
| + // If a value is passed, the return is this NodeList
|
| + return; // dojo.NodeList
|
| + return; // Array
|
| + },
|
| +
|
| + style: function(property, value){
|
| + // summary:
|
| + // gets or sets the CSS property for every element in the NodeList
|
| + // property: String
|
| + // the CSS property to get/set, in JavaScript notation
|
| + // ("lineHieght" instead of "line-height")
|
| + // value: String?
|
| + // optional. The value to set the property to
|
| + // returns:
|
| + // if no value is passed, the result is an array of strings.
|
| + // If a value is passed, the return is this NodeList
|
| + return; // dojo.NodeList
|
| + return; // Array
|
| + },
|
| +
|
| + addClass: function(className){
|
| + // summary:
|
| + // adds the specified class to every node in the list
|
| + // className: String
|
| + // the CSS class to add
|
| + return; // dojo.NodeList
|
| + },
|
| +
|
| + removeClass: function(className){
|
| + // summary:
|
| + // removes the specified class from every node in the list
|
| + // className: String
|
| + // the CSS class to add
|
| + // returns:
|
| + // dojo.NodeList, this list
|
| + return; // dojo.NodeList
|
| + },
|
| +
|
| + toggleClass: function(className, condition){
|
| + // summary:
|
| + // Adds a class to node if not present, or removes if present.
|
| + // Pass a boolean condition if you want to explicitly add or remove.
|
| + // condition: Boolean?
|
| + // If passed, true means to add the class, false means to remove.
|
| + // className: String
|
| + // the CSS class to add
|
| + return; // dojo.NodeList
|
| + },
|
| +
|
| + connect: function(methodName, objOrFunc, funcName){
|
| + // summary:
|
| + // attach event handlers to every item of the NodeList. Uses dojo.connect()
|
| + // so event properties are normalized
|
| + // methodName: String
|
| + // the name of the method to attach to. For DOM events, this should be
|
| + // the lower-case name of the event
|
| + // objOrFunc: Object|Function|String
|
| + // if 2 arguments are passed (methodName, objOrFunc), objOrFunc should
|
| + // reference a function or be the name of the function in the global
|
| + // namespace to attach. If 3 arguments are provided
|
| + // (methodName, objOrFunc, funcName), objOrFunc must be the scope to
|
| + // locate the bound function in
|
| + // funcName: String?
|
| + // optional. A string naming the function in objOrFunc to bind to the
|
| + // event. May also be a function reference.
|
| + // example:
|
| + // add an onclick handler to every button on the page
|
| + // | dojo.query("div:nth-child(odd)").connect("onclick", function(e){
|
| + // |
|
| + // | });
|
| + // example:
|
| + // attach foo.bar() to every odd div's onmouseover
|
| + // | dojo.query("div:nth-child(odd)").connect("onmouseover", foo, "bar");
|
| + },
|
| + =====*/
|
| + attr: _mapIntoDojo("attr"),
|
| + style: _mapIntoDojo("style"),
|
| + addClass: _mapIntoDojo("addClass", true),
|
| + removeClass: _mapIntoDojo("removeClass", true),
|
| + toggleClass: _mapIntoDojo("toggleClass", true),
|
| + connect: _mapIntoDojo("connect", true),
|
| +
|
| + // FIXME: connectPublisher()? connectRunOnce()?
|
| +
|
| + place: function(/*String||Node*/ queryOrNode, /*String*/ position){
|
| + // summary:
|
| + // places elements of this node list relative to the first element matched
|
| + // by queryOrNode. Returns the original NodeList.
|
| + // queryOrNode:
|
| + // may be a string representing any valid CSS3 selector or a DOM node.
|
| + // In the selector case, only the first matching element will be used
|
| + // for relative positioning.
|
| + // position:
|
| + // can be one of:
|
| + // * "last"||"end" (default)
|
| + // * "first||"start"
|
| + // * "before"
|
| + // * "after"
|
| + // or an offset in the childNodes property
|
| + var item = d.query(queryOrNode)[0];
|
| + return this.forEach(function(i){ d.place(i, item, position); }); // dojo.NodeList
|
| + },
|
| +
|
| + orphan: function(/*String?*/ simpleFilter){
|
| + // summary:
|
| + // removes elements in this list that match the simple
|
| + // filter from their parents and returns them as a new
|
| + // NodeList.
|
| + // simpleFilter:
|
| + // single-expression CSS filter
|
| + // returns:
|
| + // `dojo.NodeList` containing the orpahned elements
|
| + return (simpleFilter ? d._filterQueryResult(this, simpleFilter) : this). // dojo.NodeList
|
| + forEach("if(item.parentNode){ item.parentNode.removeChild(item); }");
|
| + },
|
| +
|
| + adopt: function(/*String||Array||DomNode*/ queryOrListOrNode, /*String?*/ position){
|
| + // summary:
|
| + // places any/all elements in queryOrListOrNode at a
|
| + // position relative to the first element in this list.
|
| + // Returns a dojo.NodeList of the adopted elements.
|
| + // queryOrListOrNode:
|
| + // a DOM node or a query string or a query result.
|
| + // Represents the nodes to be adopted relative to the
|
| + // first element of this NodeList.
|
| + // position:
|
| + // can be one of:
|
| + // * "last"||"end" (default)
|
| + // * "first||"start"
|
| + // * "before"
|
| + // * "after"
|
| + // or an offset in the childNodes property
|
| + var item = this[0];
|
| + return d.query(queryOrListOrNode).forEach(function(ai){ // dojo.NodeList
|
| + d.place(ai, item, position || "last");
|
| + });
|
| + },
|
| +
|
| + // FIXME: do we need this?
|
| + query: function(/*String*/ queryStr){
|
| + // summary:
|
| + // Returns a new, flattened NodeList. Elements of the new list
|
| + // satisfy the passed query but use elements of the
|
| + // current NodeList as query roots.
|
| +
|
| + if(!queryStr){ return this; }
|
| +
|
| + // FIXME: probably slow
|
| + // FIXME: use map?
|
| + var ret = d.NodeList();
|
| + this.forEach(function(item){
|
| + // FIXME: why would we ever get undefined here?
|
| + ret = ret.concat(d.query(queryStr, item).filter(function(subItem){ return (subItem !== undefined); }));
|
| + });
|
| + return ret; // dojo.NodeList
|
| + },
|
| +
|
| + filter: function(/*String*/ simpleQuery){
|
| + // summary:
|
| + // "masks" the built-in javascript filter() method to support
|
| + // passing a simple string filter in addition to supporting
|
| + // filtering function objects.
|
| + // example:
|
| + // "regular" JS filter syntax as exposed in dojo.filter:
|
| + // | dojo.query("*").filter(function(item){
|
| + // | // highlight every paragraph
|
| + // | return (item.nodeName == "p");
|
| + // | }).styles("backgroundColor", "yellow");
|
| + // example:
|
| + // the same filtering using a CSS selector
|
| + // | dojo.query("*").filter("p").styles("backgroundColor", "yellow");
|
| +
|
| + var items = this;
|
| + var _a = arguments;
|
| + var r = d.NodeList();
|
| + var rp = function(t){
|
| + if(t !== undefined){
|
| + r.push(t);
|
| + }
|
| + }
|
| + if(d.isString(simpleQuery)){
|
| + items = d._filterQueryResult(this, _a[0]);
|
| + if(_a.length == 1){
|
| + // if we only got a string query, pass back the filtered results
|
| + return items; // dojo.NodeList
|
| + }
|
| + // if we got a callback, run it over the filtered items
|
| + _a.shift();
|
| + }
|
| + // handle the (callback, [thisObject]) case
|
| + d.forEach(d.filter(items, _a[0], _a[1]), rp);
|
| + return r; // dojo.NodeList
|
| + },
|
| +
|
| + /*
|
| + // FIXME: should this be "copyTo" and include parenting info?
|
| + clone: function(){
|
| + // summary:
|
| + // creates node clones of each element of this list
|
| + // and returns a new list containing the clones
|
| + },
|
| + */
|
| +
|
| + addContent: function(/*String*/ content, /*String||Integer?*/ position){
|
| + // summary:
|
| + // add a node or some HTML as a string to every item in the list.
|
| + // Returns the original list.
|
| + // description:
|
| + // a copy of the HTML content is added to each item in the
|
| + // list, with an optional position argument. If no position
|
| + // argument is provided, the content is appended to the end of
|
| + // each item.
|
| + // content:
|
| + // the HTML in string format to add at position to every item
|
| + // position:
|
| + // can be one of:
|
| + // * "last"||"end" (default)
|
| + // * "first||"start"
|
| + // * "before"
|
| + // * "after"
|
| + // or an offset in the childNodes property
|
| + // example:
|
| + // appends content to the end if the position is ommitted
|
| + // | dojo.query("h3 > p").addContent("hey there!");
|
| + // example:
|
| + // add something to the front of each element that has a "thinger" property:
|
| + // | dojo.query("[thinger]").addContent("...", "first");
|
| + // example:
|
| + // adds a header before each element of the list
|
| + // | dojo.query(".note").addContent("<h4>NOTE:</h4>", "before");
|
| + var ta = d.doc.createElement("span");
|
| + if(d.isString(content)){
|
| + ta.innerHTML = content;
|
| + }else{
|
| + ta.appendChild(content);
|
| + }
|
| + if(position === undefined){
|
| + position = "last";
|
| + }
|
| + var ct = (position == "first" || position == "after") ? "lastChild" : "firstChild";
|
| + this.forEach(function(item){
|
| + var tn = ta.cloneNode(true);
|
| + while(tn[ct]){
|
| + d.place(tn[ct], item, position);
|
| + }
|
| + });
|
| + return this; // dojo.NodeList
|
| + },
|
| +
|
| + empty: function(){
|
| + // summary:
|
| + // clears all content from each node in the list
|
| + return this.forEach("item.innerHTML='';"); // dojo.NodeList
|
| +
|
| + // FIXME: should we be checking for and/or disposing of widgets below these nodes?
|
| + },
|
| +
|
| + instantiate: function(/*String|Object*/ declaredClass, /*Object?*/ properties){
|
| + // summary:
|
| + // Create a new instance of a specified class, using the
|
| + // specified properties and each node in the nodeList as a
|
| + // srcNodeRef
|
| + //
|
| + var c = d.isFunction(declaredClass) ? declaredClass : d.getObject(declaredClass);
|
| + return this.forEach(function(i){
|
| + new c(properties||{},i);
|
| + }) // dojo.NodeList
|
| + },
|
| +
|
| + at: function(/*===== index =====*/){
|
| + // summary:
|
| + // Returns a new NodeList comprised of items in this NodeList
|
| + // at the given index or indices.
|
| + // index: Integer...
|
| + // One or more 0-based indices of items in the current NodeList.
|
| + // returns:
|
| + // dojo.NodeList
|
| + var nl = new dojo.NodeList();
|
| + dojo.forEach(arguments, function(i) { if(this[i]) { nl.push(this[i]); } }, this);
|
| + return nl; // dojo.NodeList
|
| + }
|
| +
|
| + });
|
| +
|
| + // syntactic sugar for DOM events
|
| + d.forEach([
|
| + "blur", "focus", "click", "keydown", "keypress", "keyup", "mousedown",
|
| + "mouseenter", "mouseleave", "mousemove", "mouseout", "mouseover",
|
| + "mouseup", "submit", "load", "error"
|
| + ], function(evt){
|
| + var _oe = "on"+evt;
|
| + d.NodeList.prototype[_oe] = function(a, b){
|
| + return this.connect(_oe, a, b);
|
| + }
|
| + // FIXME: should these events trigger publishes?
|
| + /*
|
| + return (a ? this.connect(_oe, a, b) :
|
| + this.forEach(function(n){
|
| + // FIXME:
|
| + // listeners get buried by
|
| + // addEventListener and can't be dug back
|
| + // out to be triggered externally.
|
| + // see:
|
| + // http://developer.mozilla.org/en/docs/DOM:element
|
| +
|
| +
|
| +
|
| + // FIXME: need synthetic event support!
|
| + var _e = { target: n, faux: true, type: evt };
|
| + // dojo._event_listener._synthesizeEvent({}, { target: n, faux: true, type: evt });
|
| + try{ n[evt](_e); }catch(e){ }
|
| + try{ n[_oe](_e); }catch(e){ }
|
| + })
|
| + );
|
| + }
|
| + */
|
| + }
|
| + );
|
| +
|
| +})();
|
| +
|
| +}
|
| +
|
| +if(!dojo._hasResource["dojo._base.query"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
|
| +dojo._hasResource["dojo._base.query"] = true;
|
| +dojo.provide("dojo._base.query");
|
| +
|
| +
|
| +/*
|
| + dojo.query() architectural overview:
|
| +
|
| + dojo.query 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)
|
| + - xpath (for browsers that support it and where it's fast)
|
| + - native (not available in any browser yet)
|
| + 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)
|
| + - in the xpath path, tokenization yields a concatenation of
|
| + parameterized xpath selectors. As with the DOM version, both
|
| + simple selector blocks and overall evaluators are cached to
|
| + prevent re-defintion
|
| + 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
|
| + - xpath queries can, thankfully, be executed in one shot
|
| + 5.) matched nodes are pruned to ensure they are unique
|
| +*/
|
| +
|
| +;(function(){
|
| + // define everything in a closure for compressability reasons. "d" is an
|
| + // alias to "dojo" since it's so frequently used. This seems a
|
| + // transformation that the build system could perform on a per-file basis.
|
| +
|
| + ////////////////////////////////////////////////////////////////////////
|
| + // Utility code
|
| + ////////////////////////////////////////////////////////////////////////
|
| +
|
| + var d = dojo;
|
| + var childNodesName = dojo.isIE ? "children" : "childNodes";
|
| + var caseSensitive = false;
|
| +
|
| + var getQueryParts = function(query){
|
| + // summary: state machine for query tokenization
|
| + if(">~+".indexOf(query.charAt(query.length-1)) >= 0){
|
| + query += " *"
|
| + }
|
| + query += " "; // ensure that we terminate the state machine
|
| +
|
| + var ts = function(s, e){
|
| + return d.trim(query.slice(s, e));
|
| + }
|
| +
|
| + // the overall data graph of the full query, as represented by queryPart objects
|
| + var qparts = [];
|
| + // state keeping vars
|
| + var inBrackets = -1;
|
| + var inParens = -1;
|
| + var inMatchFor = -1;
|
| + var inPseudo = -1;
|
| + var inClass = -1;
|
| + var inId = -1;
|
| + var inTag = -1;
|
| + var lc = ""; // the last character
|
| + var cc = ""; // the current character
|
| + var pStart;
|
| + // iteration vars
|
| + var x = 0; // index in the query
|
| + var ql = query.length;
|
| + var currentPart = null; // data structure representing the entire clause
|
| + var _cp = null; // the current pseudo or attr matcher
|
| +
|
| + var endTag = function(){
|
| + if(inTag >= 0){
|
| + var tv = (inTag == x) ? null : ts(inTag, x); // .toLowerCase();
|
| + currentPart[ (">~+".indexOf(tv) < 0) ? "tag" : "oper" ] = tv;
|
| + inTag = -1;
|
| + }
|
| + }
|
| +
|
| + var endId = function(){
|
| + if(inId >= 0){
|
| + currentPart.id = ts(inId, x).replace(/\\/g, "");
|
| + inId = -1;
|
| + }
|
| + }
|
| +
|
| + var endClass = function(){
|
| + if(inClass >= 0){
|
| + currentPart.classes.push(ts(inClass+1, x).replace(/\\/g, ""));
|
| + inClass = -1;
|
| + }
|
| + }
|
| +
|
| + var endAll = function(){
|
| + endId(); endTag(); endClass();
|
| + }
|
| +
|
| + for(; lc=cc, cc=query.charAt(x),x<ql; x++){
|
| + if(lc == "\\"){ continue; }
|
| + if(!currentPart){
|
| + // NOTE: I hate all this alloc, but it's shorter than writing tons of if's
|
| + pStart = x;
|
| + currentPart = {
|
| + query: null,
|
| + pseudos: [],
|
| + attrs: [],
|
| + classes: [],
|
| + tag: null,
|
| + oper: null,
|
| + id: null
|
| + };
|
| + inTag = x;
|
| + }
|
| +
|
| + if(inBrackets >= 0){
|
| + // look for a the close first
|
| + if(cc == "]"){
|
| + if(!_cp.attr){
|
| + _cp.attr = ts(inBrackets+1, x);
|
| + }else{
|
| + _cp.matchFor = ts((inMatchFor||inBrackets+1), x);
|
| + }
|
| + var cmf = _cp.matchFor;
|
| + if(cmf){
|
| + if( (cmf.charAt(0) == '"') || (cmf.charAt(0) == "'") ){
|
| + _cp.matchFor = cmf.substring(1, cmf.length-1);
|
| + }
|
| + }
|
| + currentPart.attrs.push(_cp);
|
| + _cp = null; // necessaray?
|
| + inBrackets = inMatchFor = -1;
|
| + }else if(cc == "="){
|
| + 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(cc == ")"){
|
| + if(inPseudo >= 0){
|
| + _cp.value = ts(inParens+1, x);
|
| + }
|
| + inPseudo = inParens = -1;
|
| + }
|
| + }else if(cc == "#"){
|
| + endAll();
|
| + inId = x+1;
|
| + }else if(cc == "."){
|
| + endAll();
|
| + inClass = x;
|
| + }else if(cc == ":"){
|
| + endAll();
|
| + inPseudo = x;
|
| + }else if(cc == "["){
|
| + endAll();
|
| + inBrackets = x;
|
| + _cp = {
|
| + /*=====
|
| + attr: null, type: null, matchFor: null
|
| + =====*/
|
| + };
|
| + }else if(cc == "("){
|
| + if(inPseudo >= 0){
|
| + _cp = {
|
| + name: ts(inPseudo+1, x),
|
| + value: null
|
| + }
|
| + currentPart.pseudos.push(_cp);
|
| + }
|
| + inParens = x;
|
| + }else if(cc == " " && lc != cc){
|
| + // note that we expect the string to be " " terminated
|
| + endAll();
|
| + if(inPseudo >= 0){
|
| + currentPart.pseudos.push({ name: ts(inPseudo+1, x) });
|
| + }
|
| + currentPart.hasLoops = (
|
| + currentPart.pseudos.length ||
|
| + currentPart.attrs.length ||
|
| + currentPart.classes.length );
|
| + currentPart.query = ts(pStart, x);
|
| + currentPart.otag = currentPart.tag = (currentPart["oper"]) ? null : (currentPart.tag || "*");
|
| + if(currentPart.tag){ // FIXME: not valid in case-sensitive documents
|
| + currentPart.tag = currentPart.tag.toUpperCase();
|
| + }
|
| + qparts.push(currentPart);
|
| + currentPart = null;
|
| + }
|
| + }
|
| + return qparts;
|
| + };
|
| +
|
| +
|
| + ////////////////////////////////////////////////////////////////////////
|
| + // XPath query code
|
| + ////////////////////////////////////////////////////////////////////////
|
| +
|
| + // this array is a lookup used to generate an attribute matching function.
|
| + // There is a similar lookup/generator list for the DOM branch with similar
|
| + // calling semantics.
|
| + var xPathAttrs = {
|
| + "*=": function(attr, value){
|
| + return "[contains(@"+attr+", '"+ value +"')]";
|
| + },
|
| + "^=": function(attr, value){
|
| + return "[starts-with(@"+attr+", '"+ value +"')]";
|
| + },
|
| + "$=": function(attr, value){
|
| + return "[substring(@"+attr+", string-length(@"+attr+")-"+(value.length-1)+")='"+value+"']";
|
| + },
|
| + "~=": function(attr, value){
|
| + return "[contains(concat(' ',@"+attr+",' '), ' "+ value +" ')]";
|
| + },
|
| + "|=": function(attr, value){
|
| + return "[contains(concat(' ',@"+attr+",' '), ' "+ value +"-')]";
|
| + },
|
| + "=": function(attr, value){
|
| + return "[@"+attr+"='"+ value +"']";
|
| + }
|
| + };
|
| +
|
| + // takes a list of attribute searches, the overall query, a function to
|
| + // generate a default matcher, and a closure-bound method for providing a
|
| + // matching function that generates whatever type of yes/no distinguisher
|
| + // the query method needs. The method is a bit tortured and hard to read
|
| + // because it needs to be used in both the XPath and DOM branches.
|
| + var handleAttrs = function( attrList,
|
| + query,
|
| + getDefault,
|
| + handleMatch){
|
| + d.forEach(query.attrs, function(attr){
|
| + var matcher;
|
| + // type, attr, matchFor
|
| + if(attr.type && attrList[attr.type]){
|
| + matcher = attrList[attr.type](attr.attr, attr.matchFor);
|
| + }else if(attr.attr.length){
|
| + matcher = getDefault(attr.attr);
|
| + }
|
| + if(matcher){ handleMatch(matcher); }
|
| + });
|
| + }
|
| +
|
| + var buildPath = function(query){
|
| + var xpath = ".";
|
| + var qparts = getQueryParts(d.trim(query));
|
| + while(qparts.length){
|
| + var tqp = qparts.shift();
|
| + var prefix;
|
| + var postfix = "";
|
| + if(tqp.oper == ">"){
|
| + prefix = "/";
|
| + // prefix = "/child::*";
|
| + tqp = qparts.shift();
|
| + }else if(tqp.oper == "~"){
|
| + prefix = "/following-sibling::"; // get element following siblings
|
| + tqp = qparts.shift();
|
| + }else if(tqp.oper == "+"){
|
| + // FIXME:
|
| + // fails when selecting subsequent siblings by node type
|
| + // because the position() checks the position in the list
|
| + // of matching elements and not the localized siblings
|
| + prefix = "/following-sibling::";
|
| + postfix = "[position()=1]";
|
| + tqp = qparts.shift();
|
| + }else{
|
| + prefix = "//";
|
| + // prefix = "/descendant::*"
|
| + }
|
| +
|
| + // get the tag name (if any)
|
| +
|
| + xpath += prefix + tqp.tag + postfix;
|
| +
|
| + // check to see if it's got an id. Needs to come first in xpath.
|
| + if(tqp.id){
|
| + xpath += "[@id='"+tqp.id+"'][1]";
|
| + }
|
| +
|
| + d.forEach(tqp.classes, function(cn){
|
| + var cnl = cn.length;
|
| + var padding = " ";
|
| + if(cn.charAt(cnl-1) == "*"){
|
| + padding = ""; cn = cn.substr(0, cnl-1);
|
| + }
|
| + xpath +=
|
| + "[contains(concat(' ',@class,' '), ' "+
|
| + cn + padding + "')]";
|
| + });
|
| +
|
| + handleAttrs(xPathAttrs, tqp,
|
| + function(condition){
|
| + return "[@"+condition+"]";
|
| + },
|
| + function(matcher){
|
| + xpath += matcher;
|
| + }
|
| + );
|
| +
|
| + // FIXME: need to implement pseudo-class checks!!
|
| + };
|
| + return xpath;
|
| + };
|
| +
|
| + var _xpathFuncCache = {};
|
| + var getXPathFunc = function(path){
|
| + if(_xpathFuncCache[path]){
|
| + return _xpathFuncCache[path];
|
| + }
|
| +
|
| + var doc = d.doc;
|
| + // don't need to memoize. The closure scope handles it for us.
|
| + var xpath = buildPath(path);
|
| +
|
| + var tf = function(parent){
|
| + // XPath query strings are memoized.
|
| +
|
| + var ret = [];
|
| + var xpathResult;
|
| + var tdoc = doc;
|
| + if(parent){
|
| + tdoc = (parent.nodeType == 9) ? parent : parent.ownerDocument;
|
| + }
|
| + try{
|
| + xpathResult = tdoc.evaluate(xpath, parent, null,
|
| + // XPathResult.UNORDERED_NODE_ITERATOR_TYPE, null);
|
| + XPathResult.ANY_TYPE, null);
|
| + }catch(e){
|
| +
|
| +
|
| + }
|
| + var result = xpathResult.iterateNext();
|
| + while(result){
|
| + ret.push(result);
|
| + result = xpathResult.iterateNext();
|
| + }
|
| + return ret;
|
| + }
|
| + return _xpathFuncCache[path] = tf;
|
| + };
|
| +
|
| + /*
|
| + d.xPathMatch = function(query){
|
| + // XPath based DOM query system. Handles a small subset of CSS
|
| + // selectors, subset is identical to the non-XPath version of this
|
| + // function.
|
| +
|
| + return getXPathFunc(query)();
|
| + }
|
| + */
|
| +
|
| + ////////////////////////////////////////////////////////////////////////
|
| + // DOM query code
|
| + ////////////////////////////////////////////////////////////////////////
|
| +
|
| + var _filtersCache = {};
|
| + var _simpleFiltersCache = {};
|
| +
|
| + // 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.
|
| + var agree = function(first, second){
|
| + if(!first){ return second; }
|
| + if(!second){ return first; }
|
| +
|
| + return function(){
|
| + return first.apply(window, arguments) && second.apply(window, arguments);
|
| + }
|
| + }
|
| +
|
| + var _childElements = function(root){
|
| + var ret = [];
|
| + var te, x = 0, tret = root[childNodesName];
|
| + while((te = tret[x++])){
|
| + if(te.nodeType == 1){ ret.push(te); }
|
| + }
|
| + return ret;
|
| + }
|
| +
|
| + var _nextSiblings = function(root, single){
|
| + var ret = [];
|
| + var te = root;
|
| + while(te = te.nextSibling){
|
| + if(te.nodeType == 1){
|
| + ret.push(te);
|
| + if(single){ break; }
|
| + }
|
| + }
|
| + return ret;
|
| + }
|
| +
|
| + // FIXME:
|
| + // we need to re-write the way "~" and "+" selectors are handled since
|
| + // the left-hand selector simply modifies the right (which is the
|
| + // actual search selector). We need to locate on search selector
|
| + // instead of modifier to speed up these searches.
|
| +
|
| + var _filterDown = function(element, queryParts, matchArr, idx){
|
| + // NOTE:
|
| + // in the fast path! this function is called recursively and for
|
| + // every run of a query.
|
| + var nidx = idx+1;
|
| + var isFinal = (queryParts.length == nidx);
|
| + var tqp = queryParts[idx];
|
| +
|
| + // see if we can constrain our next level to direct children
|
| + if(tqp.oper){
|
| + // find some eligable children to search
|
| + var ecn = (tqp.oper == ">") ?
|
| + _childElements(element) :
|
| + _nextSiblings(element, (tqp.oper == "+"));
|
| +
|
| + if(!ecn || !ecn.length){
|
| + return;
|
| + }
|
| + nidx++;
|
| + isFinal = (queryParts.length == nidx);
|
| + // kinda janky, too much array alloc
|
| + var tf = getFilterFunc(queryParts[idx+1]);
|
| + // for(var x=ecn.length-1, te; x>=0, te=ecn[x]; x--){
|
| + for(var x=0, ecnl=ecn.length, te; x<ecnl, te=ecn[x]; x++){
|
| + if(tf(te)){
|
| + if(isFinal){
|
| + matchArr.push(te);
|
| + }else{
|
| + _filterDown(te, queryParts, matchArr, nidx);
|
| + }
|
| + }
|
| + /*
|
| + if(x==0){
|
| + break;
|
| + }
|
| + */
|
| + }
|
| + }
|
| +
|
| + // otherwise, keep going down, unless we'er at the end
|
| + var candidates = getElementsFunc(tqp)(element);
|
| + if(isFinal){
|
| + while(candidates.length){
|
| + matchArr.push(candidates.shift());
|
| + }
|
| + /*
|
| + candidates.unshift(0, matchArr.length-1);
|
| + matchArr.splice.apply(matchArr, candidates);
|
| + */
|
| + }else{
|
| + // if we're not yet at the bottom, keep going!
|
| + while(candidates.length){
|
| + _filterDown(candidates.shift(), queryParts, matchArr, nidx);
|
| + }
|
| + }
|
| + }
|
| +
|
| + var filterDown = function(elements, queryParts){
|
| + var ret = [];
|
| +
|
| + // for every root, get the elements that match the descendant selector
|
| + // for(var x=elements.length-1, te; x>=0, te=elements[x]; x--){
|
| + var x = elements.length - 1, te;
|
| + while((te = elements[x--])){
|
| + _filterDown(te, queryParts, ret, 0);
|
| + }
|
| + return ret;
|
| + }
|
| +
|
| + var getFilterFunc = function(q){
|
| + // note: query can't have spaces!
|
| + if(_filtersCache[q.query]){
|
| + return _filtersCache[q.query];
|
| + }
|
| + var ff = null;
|
| +
|
| + // does it have a tagName component?
|
| + if(q.tag){
|
| + if(q.tag == "*"){
|
| + ff = agree(ff,
|
| + function(elem){
|
| + return (elem.nodeType == 1);
|
| + }
|
| + );
|
| + }else{
|
| + // tag name match
|
| + ff = agree(ff,
|
| + function(elem){
|
| + return (
|
| + (elem.nodeType == 1) &&
|
| + (q[ caseSensitive ? "otag" : "tag" ] == elem.tagName)
|
| + // (q.tag == elem.tagName.toLowerCase())
|
| + );
|
| + // return isTn;
|
| + }
|
| + );
|
| + }
|
| + }
|
| +
|
| + // does the node have an ID?
|
| + if(q.id){
|
| + ff = agree(ff,
|
| + function(elem){
|
| + return (
|
| + (elem.nodeType == 1) &&
|
| + (elem.id == q.id)
|
| + );
|
| + }
|
| + );
|
| + }
|
| +
|
| + if(q.hasLoops){
|
| + // if we have other query param parts, make sure we add them to the
|
| + // filter chain
|
| + ff = agree(ff, getSimpleFilterFunc(q));
|
| + }
|
| +
|
| + return _filtersCache[q.query] = ff;
|
| + }
|
| +
|
| + var getNodeIndex = function(node){
|
| + // NOTE:
|
| + // we could have a more accurate caching mechanism by invalidating
|
| + // caches after the query has finished, but I think that'd lead to
|
| + // significantly more cache churn than the cache would provide
|
| + // value for in the common case. Generally, we're more
|
| + // conservative (and therefore, more accurate) than jQuery and
|
| + // DomQuery WRT node node indexes, but there may be corner cases
|
| + // in which we fall down. How much we care about them is TBD.
|
| +
|
| + var pn = node.parentNode;
|
| + var pnc = pn.childNodes;
|
| +
|
| + // check to see if we can trust the cache. If not, re-key the whole
|
| + // thing and return our node match from that.
|
| +
|
| + var nidx = -1;
|
| + var child = pn.firstChild;
|
| + if(!child){
|
| + return nidx;
|
| + }
|
| +
|
| + var ci = node["__cachedIndex"];
|
| + var cl = pn["__cachedLength"];
|
| +
|
| + // only handle cache building if we've gone out of sync
|
| + if(((typeof cl == "number")&&(cl != pnc.length))||(typeof ci != "number")){
|
| + // rip though the whole set, building cache indexes as we go
|
| + pn["__cachedLength"] = pnc.length;
|
| + var idx = 1;
|
| + do{
|
| + // we only assign indexes for nodes with nodeType == 1, as per:
|
| + // http://www.w3.org/TR/css3-selectors/#nth-child-pseudo
|
| + // only elements are counted in the search order, and they
|
| + // begin at 1 for the first child's index
|
| +
|
| + if(child === node){
|
| + nidx = idx;
|
| + }
|
| + if(child.nodeType == 1){
|
| + child["__cachedIndex"] = idx;
|
| + idx++;
|
| + }
|
| + child = child.nextSibling;
|
| + }while(child);
|
| + }else{
|
| + // NOTE:
|
| + // could be incorrect in some cases (node swaps involving the
|
| + // passed node, etc.), but we ignore those due to the relative
|
| + // unlikelihood of that occuring
|
| + nidx = ci;
|
| + }
|
| + return nidx;
|
| + }
|
| +
|
| + var firedCount = 0;
|
| +
|
| + var blank = "";
|
| + var _getAttr = function(elem, attr){
|
| + 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"
|
| + var tval = " "+value;
|
| + 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 = " "+(elem.getAttribute(attr, 2) || "");
|
| + return (
|
| + (ea == value) ||
|
| + (ea.indexOf(valueDash)==0)
|
| + );
|
| + }
|
| + },
|
| + "=": function(attr, value){
|
| + return function(elem){
|
| + return (_getAttr(elem, attr) == value);
|
| + }
|
| + }
|
| + };
|
| +
|
| + var pseudos = {
|
| + "checked": function(name, condition){
|
| + return function(elem){
|
| + return !!d.attr(elem, "checked");
|
| + }
|
| + },
|
| + "first-child": function(name, condition){
|
| + return function(elem){
|
| + if(elem.nodeType != 1){ return false; }
|
| + // check to see if any of the previous siblings are elements
|
| + var fc = elem.previousSibling;
|
| + while(fc && (fc.nodeType != 1)){
|
| + fc = fc.previousSibling;
|
| + }
|
| + return (!fc);
|
| + }
|
| + },
|
| + "last-child": function(name, condition){
|
| + return function(elem){
|
| + if(elem.nodeType != 1){ return false; }
|
| + // check to see if any of the next siblings are elements
|
| + var nc = elem.nextSibling;
|
| + while(nc && (nc.nodeType != 1)){
|
| + nc = nc.nextSibling;
|
| + }
|
| + return (!nc);
|
| + }
|
| + },
|
| + "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){
|
| + return function(elem){
|
| + // FIXME: I dislike this version of "contains", as
|
| + // whimsical attribute could set it off. An inner-text
|
| + // based version might be more accurate, but since
|
| + // jQuery and DomQuery also potentially get this wrong,
|
| + // I'm leaving it for now.
|
| + if(condition.charAt(0)=='"' || condition.charAt(0)=="'"){//remove quote
|
| + condition=condition.substr(1,condition.length-2);
|
| + }
|
| + return (elem.innerHTML.indexOf(condition) >= 0);
|
| + }
|
| + },
|
| + "not": function(name, condition){
|
| + var ntf = getFilterFunc(getQueryParts(condition)[0]);
|
| + return function(elem){
|
| + return (!ntf(elem));
|
| + }
|
| + },
|
| + "nth-child": function(name, condition){
|
| + var pi = parseInt;
|
| + if(condition == "odd"){
|
| + condition = "2n+1";
|
| + }else if(condition == "even"){
|
| + condition = "2n";
|
| + }
|
| + 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;
|
| + if(idx>0){
|
| + ub = idx;
|
| + idx = idx % pred;
|
| + } //idx has to be greater than 0 when pred is negative; shall we throw an error here?
|
| + }
|
| + if(pred>0){
|
| + return function(elem){
|
| + var i=getNodeIndex(elem);
|
| + return (i>=lb) && (ub<0 || i<=ub) && ((i % pred) == idx);
|
| + }
|
| + }else{
|
| + condition=idx;
|
| + }
|
| + }
|
| + //if(condition.indexOf("n") == -1){
|
| + var ncount = pi(condition);
|
| + return function(elem){
|
| + return (getNodeIndex(elem) == ncount);
|
| + }
|
| + }
|
| + };
|
| +
|
| + var defaultGetter = (d.isIE) ? function(cond){
|
| + var clc = cond.toLowerCase();
|
| + 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){
|
| +
|
| + var fcHit = (_simpleFiltersCache[query.query]||_filtersCache[query.query]);
|
| + if(fcHit){ return fcHit; }
|
| +
|
| + var ff = null;
|
| +
|
| + // the only case where we'll need the tag name is if we came from an ID query
|
| + if(query.id){ // do we have an ID component?
|
| + if(query.tag != "*"){
|
| + ff = agree(ff, function(elem){
|
| + return (elem.tagName == query[ caseSensitive ? "otag" : "tag" ]);
|
| + });
|
| + }
|
| + }
|
| +
|
| + // if there's a class in our query, generate a match function for it
|
| + d.forEach(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 memozied in a cache, but it's VERY short
|
| + var re = new RegExp("(?:^|\\s)" + cname + (isWildcard ? ".*" : "") + "(?:\\s|$)");
|
| + ff = agree(ff, function(elem){
|
| + return re.test(elem.className);
|
| + });
|
| + ff.count = idx;
|
| + });
|
| +
|
| + d.forEach(query.pseudos, function(pseudo){
|
| + if(pseudos[pseudo.name]){
|
| + ff = agree(ff, pseudos[pseudo.name](pseudo.name, pseudo.value));
|
| + }
|
| + });
|
| +
|
| + handleAttrs(attrs, query, defaultGetter,
|
| + function(tmatcher){ ff = agree(ff, tmatcher); }
|
| + );
|
| + if(!ff){
|
| + ff = function(){ return true; };
|
| + }
|
| + return _simpleFiltersCache[query.query] = ff;
|
| + }
|
| +
|
| + var _getElementsFuncCache = { };
|
| +
|
| + var getElementsFunc = function(query, root){
|
| + var fHit = _getElementsFuncCache[query.query];
|
| + if(fHit){ return fHit; }
|
| +
|
| + // NOTE: this function is in the fast path! not memoized!!!
|
| +
|
| + // the query doesn't contain any spaces, so there's only so many
|
| + // things it could be
|
| +
|
| + if(query.id && !query.hasLoops && !query.tag){
|
| + // ID-only query. Easy.
|
| + return _getElementsFuncCache[query.query] = function(root){
|
| + // FIXME: if root != document, check for parenting!
|
| + return [ d.byId(query.id) ];
|
| + }
|
| + }
|
| +
|
| + var filterFunc = getSimpleFilterFunc(query);
|
| +
|
| + var retFunc;
|
| + if(query.tag && query.id && !query.hasLoops){
|
| + // we got a filtered ID search (e.g., "h4#thinger")
|
| + retFunc = function(root){
|
| + var te = d.byId(query.id, (root.ownerDocument||root)); //root itself may be a document
|
| + if(filterFunc(te)){
|
| + return [ te ];
|
| + }
|
| + }
|
| + }else{
|
| + var tret;
|
| +
|
| + if(!query.hasLoops){
|
| + // it's just a plain-ol elements-by-tag-name query from the root
|
| + retFunc = function(root){
|
| + var ret = [];
|
| + var te, x=0, tret = root.getElementsByTagName(query[ caseSensitive ? "otag" : "tag"]);
|
| + while((te = tret[x++])){
|
| + ret.push(te);
|
| + }
|
| + return ret;
|
| + }
|
| + }else{
|
| + retFunc = function(root){
|
| + var ret = [];
|
| + var te, x = 0, tret = root.getElementsByTagName(query[ caseSensitive ? "otag" : "tag"]);
|
| + while((te = tret[x++])){
|
| + if(filterFunc(te)){
|
| + ret.push(te);
|
| + }
|
| + }
|
| + return ret;
|
| + }
|
| + }
|
| + }
|
| + return _getElementsFuncCache[query.query] = retFunc;
|
| + }
|
| +
|
| + var _partsCache = {};
|
| +
|
| + ////////////////////////////////////////////////////////////////////////
|
| + // the query runner
|
| + ////////////////////////////////////////////////////////////////////////
|
| +
|
| + // 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 _queryFuncCache = {
|
| + "*": d.isIE ?
|
| + function(root){
|
| + return root.all;
|
| + } :
|
| + function(root){
|
| + return root.getElementsByTagName("*");
|
| + },
|
| + "~": _nextSiblings,
|
| + "+": function(root){ return _nextSiblings(root, true); },
|
| + ">": _childElements
|
| + };
|
| +
|
| + var getStepQueryFunc = function(query){
|
| + // if it's trivial, get a fast-path dispatcher
|
| + var qparts = getQueryParts(d.trim(query));
|
| + // if(query[query.length-1] == ">"){ query += " *"; }
|
| + if(qparts.length == 1){
|
| + var tt = getElementsFunc(qparts[0]);
|
| + tt.nozip = true; // FIXME: is this right? Shouldn't this be wrapped in a closure to mark the return?
|
| + return tt;
|
| + }
|
| +
|
| + // otherwise, break it up and return a runner that iterates over the parts recursively
|
| + var sqf = function(root){
|
| + var localQueryParts = qparts.slice(0); // clone the src arr
|
| + var candidates;
|
| + if(localQueryParts[0].oper == ">"){ // FIXME: what if it's + or ~?
|
| + candidates = [ root ];
|
| + // root = document;
|
| + }else{
|
| + candidates = getElementsFunc(localQueryParts.shift())(root);
|
| + }
|
| + return filterDown(candidates, localQueryParts);
|
| + }
|
| + return sqf;
|
| + }
|
| +
|
| + // a specialized method that implements our primoridal "query optimizer".
|
| + // This allows us to dispatch queries to the fastest subsystem we can get.
|
| + var _getQueryFunc = (
|
| + // NOTE:
|
| + // XPath on the Webkit is slower than it's DOM iteration for most
|
| + // test cases
|
| + // FIXME:
|
| + // we should try to capture some runtime speed data for each query
|
| + // function to determine on the fly if we should stick w/ the
|
| + // potentially optimized variant or if we should try something
|
| + // new.
|
| + (document["evaluate"] && !d.isSafari) ?
|
| + function(query, root){
|
| + // has xpath support that's faster than DOM
|
| + var qparts = query.split(" ");
|
| + // can we handle it?
|
| + if( (!caseSensitive) && // not strictly necessaray, but simplifies lots of stuff
|
| + (document["evaluate"]) &&
|
| + (query.indexOf(":") == -1) &&
|
| + (query.indexOf("+") == -1) // skip direct sibling matches. See line ~344
|
| + ){
|
| + // dojo.debug(query);
|
| + // should we handle it?
|
| +
|
| + // kind of a lame heuristic, but it works
|
| + if(
|
| + // a "div div div" style query
|
| + ((qparts.length > 2)&&(query.indexOf(">") == -1))||
|
| + // or something else with moderate complexity. kinda janky
|
| + (qparts.length > 3)||
|
| + (query.indexOf("[")>=0)||
|
| + // or if it's a ".thinger" query
|
| + ((1 == qparts.length)&&(0 <= query.indexOf(".")))
|
| +
|
| + ){
|
| + // use get and cache a xpath runner for this selector
|
| + return getXPathFunc(query);
|
| + }
|
| + }
|
| +
|
| + // fallthrough
|
| + return getStepQueryFunc(query);
|
| + } : getStepQueryFunc
|
| + );
|
| + // uncomment to disable XPath for testing and tuning the DOM path
|
| + // _getQueryFunc = getStepQueryFunc;
|
| +
|
| + // FIXME: we've got problems w/ the NodeList query()/filter() functions if we go XPath for everything
|
| +
|
| + // uncomment to disable DOM queries for testing and tuning XPath
|
| + // _getQueryFunc = getXPathFunc;
|
| +
|
| + // this is the primary caching for full-query results. The query dispatcher
|
| + // functions are generated here and then pickled for hash lookup in the
|
| + // future
|
| + var getQueryFunc = function(query){
|
| + // return a cached version if one is available
|
| + var qcz = query.charAt(0);
|
| + if(d.doc["querySelectorAll"] &&
|
| + ( (!d.isSafari) || (d.isSafari > 3.1) ) && // see #5832
|
| + // as per CSS 3, we can't currently start w/ combinator:
|
| + // http://www.w3.org/TR/css3-selectors/#w3cselgrammar
|
| + (">+~".indexOf(qcz) == -1)
|
| + ){
|
| + return function(root){
|
| + var r = root.querySelectorAll(query);
|
| + r.nozip = true; // skip expensive duplication checks and just wrap in a NodeList
|
| + return r;
|
| + };
|
| + }
|
| + if(_queryFuncCache[query]){ return _queryFuncCache[query]; }
|
| + if(0 > query.indexOf(",")){
|
| + // if it's not a compound query (e.g., ".foo, .bar"), cache and return a dispatcher
|
| + return _queryFuncCache[query] = _getQueryFunc(query);
|
| + }else{
|
| + // if it's a complex query, break it up into it's constituent parts
|
| + // and return a dispatcher that will merge the parts when run
|
| +
|
| + // var parts = query.split(", ");
|
| + var parts = query.split(/\s*,\s*/);
|
| + var tf = function(root){
|
| + var pindex = 0; // avoid array alloc for every invocation
|
| + var ret = [];
|
| + var tp;
|
| + while((tp = parts[pindex++])){
|
| + ret = ret.concat(_getQueryFunc(tp, tp.indexOf(" "))(root));
|
| + }
|
| + return ret;
|
| + }
|
| + // ...cache and return
|
| + return _queryFuncCache[query] = tf;
|
| + }
|
| + }
|
| +
|
| + // FIXME:
|
| + // Dean's Base2 uses a system whereby queries themselves note if
|
| + // they'll need duplicate filtering. We need to get on that plan!!
|
| +
|
| + // attempt to efficiently determine if an item in a list is a dupe,
|
| + // returning a list of "uniques", hopefully in doucment order
|
| + var _zipIdx = 0;
|
| + var _zip = function(arr){
|
| + if(arr && arr.nozip){ return d.NodeList._wrap(arr); }
|
| + var ret = new d.NodeList();
|
| + if(!arr){ 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(d.isIE && caseSensitive){
|
| + var szidx = _zipIdx+"";
|
| + arr[0].setAttribute("_zipIdx", szidx);
|
| + for(var x = 1, te; te = arr[x]; x++){
|
| + if(arr[x].getAttribute("_zipIdx") != szidx){
|
| + ret.push(te);
|
| + }
|
| + te.setAttribute("_zipIdx", szidx);
|
| + }
|
| + }else{
|
| + arr[0]["_zipIdx"] = _zipIdx;
|
| + for(var x = 1, te; te = arr[x]; x++){
|
| + if(arr[x]["_zipIdx"] != _zipIdx){
|
| + ret.push(te);
|
| + }
|
| + te["_zipIdx"] = _zipIdx;
|
| + }
|
| + }
|
| + // FIXME: should we consider stripping these properties?
|
| + return ret;
|
| + }
|
| +
|
| + // the main executor
|
| + d.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 instance of dojo.NodeList.
|
| + // 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:
|
| + // --------------------
|
| + //
|
| + // dojo.query() 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 immediately preceeded-by sibling selector
|
| + // * `+`, the preceeded-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` positional selectors
|
| + // * `:empty` content emtpy selector
|
| + // * `: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
|
| + // maniplation 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 resaonable 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` currently only supports searching XML documents
|
| + // whose tags and attributes are 100% lower-case. This is a known
|
| + // limitation and will [be addressed soon](http://trac.dojotoolkit.org/ticket/3866)
|
| + // Non-selector Queries:
|
| + // ---------------------
|
| + //
|
| + // If something other than a String is passed for the query,
|
| + // `dojo.query` will return a new `dojo.NodeList` constructed from
|
| + // that parameter alone and all further processing will stop. This
|
| + // means that if you have a reference to a node or NodeList, you
|
| + // can quickly construct a new NodeList from the original by
|
| + // calling `dojo.query(node)` or `dojo.query(list)`.
|
| + //
|
| + // query:
|
| + // The CSS3 expression to match against. For details on the syntax of
|
| + // CSS3 selectors, see <http://www.w3.org/TR/css3-selectors/#selectors>
|
| + // root:
|
| + // A DOMNode (or node id) to scope the search from. Optional.
|
| + // returns: dojo.NodeList
|
| + // An instance of `dojo.NodeList`. Many methods are available on
|
| + // NodeLists for searching, iterating, manipulating, and handling
|
| + // events on the matched nodes in the returned list.
|
| + // example:
|
| + // search the entire document for elements with the class "foo":
|
| + // | dojo.query(".foo");
|
| + // these elements will match:
|
| + // | <span class="foo"></span>
|
| + // | <span class="foo bar"></span>
|
| + // | <p class="thud foo"></p>
|
| + // example:
|
| + // search the entire document for elements with the classes "foo" *and* "bar":
|
| + // | dojo.query(".foo.bar");
|
| + // these elements will match:
|
| + // | <span class="foo bar"></span>
|
| + // while these will not:
|
| + // | <span class="foo"></span>
|
| + // | <p class="thud foo"></p>
|
| + // example:
|
| + // find `<span>` elements which are descendants of paragraphs and
|
| + // which have a "highlighted" class:
|
| + // | dojo.query("p span.highlighted");
|
| + // the innermost span in this fragment matches:
|
| + // | <p class="foo">
|
| + // | <span>...
|
| + // | <span class="highlighted foo bar">...</span>
|
| + // | </span>
|
| + // | </p>
|
| + // example:
|
| + // set an "odd" class on all odd table rows inside of the table
|
| + // `#tabular_data`, using the `>` (direct child) selector to avoid
|
| + // affecting any nested tables:
|
| + // | dojo.query("#tabular_data > tbody > tr:nth-child(odd)").addClass("odd");
|
| + // example:
|
| + // remove all elements with the class "error" from the document
|
| + // and store them in a list:
|
| + // | var errors = dojo.query(".error").orphan();
|
| + // example:
|
| + // add an onclick handler to every submit button in the document
|
| + // which causes the form to be sent via Ajax instead:
|
| + // | dojo.query("input[type='submit']").onclick(function(e){
|
| + // | dojo.stopEvent(e); // prevent sending the form
|
| + // | var btn = e.target;
|
| + // | dojo.xhrPost({
|
| + // | form: btn.form,
|
| + // | load: function(data){
|
| + // | // replace the form with the response
|
| + // | var div = dojo.doc.createElement("div");
|
| + // | dojo.place(div, btn.form, "after");
|
| + // | div.innerHTML = data;
|
| + // | dojo.style(btn.form, "display", "none");
|
| + // | }
|
| + // | });
|
| + // | });
|
| +
|
| +
|
| + // NOTE: elementsById is not currently supported
|
| + // NOTE: ignores xpath-ish queries for now
|
| +
|
| + if(query.constructor == d.NodeList){
|
| + return query;
|
| + }
|
| + if(!d.isString(query)){
|
| + return new d.NodeList(query); // dojo.NodeList
|
| + }
|
| + if(d.isString(root)){
|
| + root = d.byId(root);
|
| + }
|
| +
|
| + root = root||d.doc;
|
| + var od = root.ownerDocument||root.documentElement;
|
| + caseSensitive = (root.contentType && root.contentType=="application/xml") || (!!od) && (d.isIE ? od.xml : (root.xmlVersion||od.xmlVersion));
|
| + return _zip(getQueryFunc(query)(root)); // dojo.NodeList
|
| + }
|
| +
|
| + /*
|
| + // exposing this was a mistake
|
| + d.query.attrs = attrs;
|
| + */
|
| + // exposing this because new pseudo matches are only executed through the
|
| + // DOM query path (never through the xpath optimizing branch)
|
| + d.query.pseudos = pseudos;
|
| +
|
| + // one-off function for filtering a NodeList based on a simple selector
|
| + d._filterQueryResult = function(nodeList, simpleFilter){
|
| + var tnl = new d.NodeList();
|
| + var ff = (simpleFilter) ? getFilterFunc(getQueryParts(simpleFilter)[0]) : function(){ return true; };
|
| + for(var x = 0, te; te = nodeList[x]; x++){
|
| + if(ff(te)){ tnl.push(te); }
|
| + }
|
| + return tnl;
|
| + }
|
| +})();
|
| +
|
| +}
|
| +
|
| +if(!dojo._hasResource["dojo._base.xhr"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
|
| +dojo._hasResource["dojo._base.xhr"] = true;
|
| +dojo.provide("dojo._base.xhr");
|
| +
|
| +
|
| +
|
| +
|
| +
|
| +(function(){
|
| + var _d = dojo;
|
| + function setValue(/*Object*/obj, /*String*/name, /*String*/value){
|
| + //summary:
|
| + // For the named property in object, set the value. If a value
|
| + // already exists and it is a string, convert the value to be an
|
| + // array of values.
|
| + var val = obj[name];
|
| + if(_d.isString(val)){
|
| + obj[name] = [val, value];
|
| + }else if(_d.isArray(val)){
|
| + val.push(value);
|
| + }else{
|
| + obj[name] = value;
|
| + }
|
| + }
|
| +
|
| + dojo.formToObject = function(/*DOMNode||String*/ formNode){
|
| + // summary:
|
| + // dojo.formToObject returns the values encoded in an HTML form as
|
| + // string properties in an object which it then returns. Disabled form
|
| + // elements, buttons, and other non-value form elements are skipped.
|
| + // Multi-select elements are returned as an array of string values.
|
| + // description:
|
| + // This form:
|
| + //
|
| + // | <form id="test_form">
|
| + // | <input type="text" name="blah" value="blah">
|
| + // | <input type="text" name="no_value" value="blah" disabled>
|
| + // | <input type="button" name="no_value2" value="blah">
|
| + // | <select type="select" multiple name="multi" size="5">
|
| + // | <option value="blah">blah</option>
|
| + // | <option value="thud" selected>thud</option>
|
| + // | <option value="thonk" selected>thonk</option>
|
| + // | </select>
|
| + // | </form>
|
| + //
|
| + // yields this object structure as the result of a call to
|
| + // formToObject():
|
| + //
|
| + // | {
|
| + // | blah: "blah",
|
| + // | multi: [
|
| + // | "thud",
|
| + // | "thonk"
|
| + // | ]
|
| + // | };
|
| +
|
| + var ret = {};
|
| + var exclude = "file|submit|image|reset|button|";
|
| + _d.forEach(dojo.byId(formNode).elements, function(item){
|
| + var _in = item.name;
|
| + var type = (item.type||"").toLowerCase();
|
| + if(_in && type && exclude.indexOf(type) == -1 && !item.disabled){
|
| + if(type == "radio" || type == "checkbox"){
|
| + if(item.checked){ setValue(ret, _in, item.value); }
|
| + }else if(item.multiple){
|
| + ret[_in] = [];
|
| + _d.query("option", item).forEach(function(opt){
|
| + if(opt.selected){
|
| + setValue(ret, _in, opt.value);
|
| + }
|
| + });
|
| + }else{
|
| + setValue(ret, _in, item.value);
|
| + if(type == "image"){
|
| + ret[_in+".x"] = ret[_in+".y"] = ret[_in].x = ret[_in].y = 0;
|
| + }
|
| + }
|
| + }
|
| + });
|
| + return ret; // Object
|
| + }
|
| +
|
| + dojo.objectToQuery = function(/*Object*/ map){
|
| + // summary:
|
| + // takes a name/value mapping object and returns a string representing
|
| + // a URL-encoded version of that object.
|
| + // example:
|
| + // this object:
|
| + //
|
| + // | {
|
| + // | blah: "blah",
|
| + // | multi: [
|
| + // | "thud",
|
| + // | "thonk"
|
| + // | ]
|
| + // | };
|
| + //
|
| + // yields the following query string:
|
| + //
|
| + // | "blah=blah&multi=thud&multi=thonk"
|
| +
|
| + // FIXME: need to implement encodeAscii!!
|
| + var enc = encodeURIComponent;
|
| + var pairs = [];
|
| + var backstop = {};
|
| + for(var name in map){
|
| + var value = map[name];
|
| + if(value != backstop[name]){
|
| + var assign = enc(name) + "=";
|
| + if(_d.isArray(value)){
|
| + for(var i=0; i < value.length; i++){
|
| + pairs.push(assign + enc(value[i]));
|
| + }
|
| + }else{
|
| + pairs.push(assign + enc(value));
|
| + }
|
| + }
|
| + }
|
| + return pairs.join("&"); // String
|
| + }
|
| +
|
| + dojo.formToQuery = function(/*DOMNode||String*/ formNode){
|
| + // summary:
|
| + // Returns a URL-encoded string representing the form passed as either a
|
| + // node or string ID identifying the form to serialize
|
| + return _d.objectToQuery(_d.formToObject(formNode)); // String
|
| + }
|
| +
|
| + dojo.formToJson = function(/*DOMNode||String*/ formNode, /*Boolean?*/prettyPrint){
|
| + // summary:
|
| + // return a serialized JSON string from a form node or string
|
| + // ID identifying the form to serialize
|
| + return _d.toJson(_d.formToObject(formNode), prettyPrint); // String
|
| + }
|
| +
|
| + dojo.queryToObject = function(/*String*/ str){
|
| + // summary:
|
| + // returns an object representing a de-serialized query section of a
|
| + // URL. Query keys with multiple values are returned in an array.
|
| + // description:
|
| + // This string:
|
| + //
|
| + // | "foo=bar&foo=baz&thinger=%20spaces%20=blah&zonk=blarg&"
|
| + //
|
| + // results in this object structure:
|
| + //
|
| + // | {
|
| + // | foo: [ "bar", "baz" ],
|
| + // | thinger: " spaces =blah",
|
| + // | zonk: "blarg"
|
| + // | }
|
| + //
|
| + // Note that spaces and other urlencoded entities are correctly
|
| + // handled.
|
| +
|
| + // FIXME: should we grab the URL string if we're not passed one?
|
| + var ret = {};
|
| + var qp = str.split("&");
|
| + var dec = decodeURIComponent;
|
| + _d.forEach(qp, function(item){
|
| + if(item.length){
|
| + var parts = item.split("=");
|
| + var name = dec(parts.shift());
|
| + var val = dec(parts.join("="));
|
| + if(_d.isString(ret[name])){
|
| + ret[name] = [ret[name]];
|
| + }
|
| + if(_d.isArray(ret[name])){
|
| + ret[name].push(val);
|
| + }else{
|
| + ret[name] = val;
|
| + }
|
| + }
|
| + });
|
| + return ret; // Object
|
| + }
|
| +
|
| + /*
|
| + from refactor.txt:
|
| +
|
| + all bind() replacement APIs take the following argument structure:
|
| +
|
| + {
|
| + url: "blah.html",
|
| +
|
| + // all below are optional, but must be supported in some form by
|
| + // every IO API
|
| + timeout: 1000, // milliseconds
|
| + handleAs: "text", // replaces the always-wrong "mimetype"
|
| + content: {
|
| + key: "value"
|
| + },
|
| +
|
| + // browser-specific, MAY be unsupported
|
| + sync: true, // defaults to false
|
| + form: dojo.byId("someForm")
|
| + }
|
| + */
|
| +
|
| + // need to block async callbacks from snatching this thread as the result
|
| + // of an async callback might call another sync XHR, this hangs khtml forever
|
| + // must checked by watchInFlight()
|
| +
|
| + dojo._blockAsync = false;
|
| +
|
| + dojo._contentHandlers = {
|
| + "text": function(xhr){ return xhr.responseText; },
|
| + "json": function(xhr){
|
| + return _d.fromJson(xhr.responseText || null);
|
| + },
|
| + "json-comment-filtered": function(xhr){
|
| + // NOTE: the json-comment-filtered option was implemented to prevent
|
| + // "JavaScript Hijacking", but it is less secure than standard JSON. Use
|
| + // standard JSON instead. JSON prefixing can be used to subvert hijacking.
|
| + if(!dojo.config.useCommentedJson){
|
| + console.warn("Consider using the standard mimetype:application/json."
|
| + + " json-commenting can introduce security issues. To"
|
| + + " decrease the chances of hijacking, use the standard the 'json' handler and"
|
| + + " prefix your json with: {}&&\n"
|
| + + "Use djConfig.useCommentedJson=true to turn off this message.");
|
| + }
|
| +
|
| + var value = xhr.responseText;
|
| + var cStartIdx = value.indexOf("\/*");
|
| + var cEndIdx = value.lastIndexOf("*\/");
|
| + if(cStartIdx == -1 || cEndIdx == -1){
|
| + throw new Error("JSON was not comment filtered");
|
| + }
|
| + return _d.fromJson(value.substring(cStartIdx+2, cEndIdx));
|
| + },
|
| + "javascript": function(xhr){
|
| + // FIXME: try Moz and IE specific eval variants?
|
| + return _d.eval(xhr.responseText);
|
| + },
|
| + "xml": function(xhr){
|
| + var result = xhr.responseXML;
|
| + if(_d.isIE && (!result || result.documentElement == null)){
|
| + _d.forEach(["MSXML2", "Microsoft", "MSXML", "MSXML3"], function(prefix){
|
| + try{
|
| + var dom = new ActiveXObject(prefix + ".XMLDOM");
|
| + dom.async = false;
|
| + dom.loadXML(xhr.responseText);
|
| + result = dom;
|
| + }catch(e){ /* Not available. Squelch and try next one. */ }
|
| + });
|
| + }
|
| + return result; // DOMDocument
|
| + }
|
| + };
|
| +
|
| + dojo._contentHandlers["json-comment-optional"] = function(xhr){
|
| + var handlers = _d._contentHandlers;
|
| + if(xhr.responseText && xhr.responseText.indexOf("\/*") != -1){
|
| + return handlers["json-comment-filtered"](xhr);
|
| + }else{
|
| + return handlers["json"](xhr);
|
| + }
|
| + };
|
| +
|
| + /*=====
|
| + dojo.__IoArgs = function(){
|
| + // url: String
|
| + // URL to server endpoint.
|
| + // content: Object?
|
| + // Contains properties with string values. These
|
| + // properties will be serialized as name1=value2 and
|
| + // passed in the request.
|
| + // timeout: Integer?
|
| + // Milliseconds to wait for the response. If this time
|
| + // passes, the then error callbacks are called.
|
| + // form: DOMNode?
|
| + // DOM node for a form. Used to extract the form values
|
| + // and send to the server.
|
| + // preventCache: Boolean?
|
| + // Default is false. If true, then a
|
| + // "dojo.preventCache" parameter is sent in the request
|
| + // with a value that changes with each request
|
| + // (timestamp). Useful only with GET-type requests.
|
| + // handleAs: String?
|
| + // Acceptable values depend on the type of IO
|
| + // transport (see specific IO calls for more information).
|
| + // load: Function?
|
| + // function(response, ioArgs){} response is of type Object, ioArgs
|
| + // is of type dojo.__IoCallbackArgs. This function will be
|
| + // called on a successful HTTP response code.
|
| + // error: Function?
|
| + // function(response, ioArgs){} response is of type Object, ioArgs
|
| + // is of type dojo.__IoCallbackArgs. This function will
|
| + // be called when the request fails due to a network or server error, the url
|
| + // is invalid, etc. It will also be called if the load or handle callback throws an
|
| + // exception, unless djConfig.isDebug is true. This allows deployed applications
|
| + // to continue to run even when a logic error happens in the callback, while making
|
| + // it easier to troubleshoot while in debug mode.
|
| + // handle: Function?
|
| + // function(response, ioArgs){} response is of type Object, ioArgs
|
| + // is of type dojo.__IoCallbackArgs. This function will
|
| + // be called at the end of every request, whether or not an error occurs.
|
| + this.url = url;
|
| + this.content = content;
|
| + this.timeout = timeout;
|
| + this.form = form;
|
| + this.preventCache = preventCache;
|
| + this.handleAs = handleAs;
|
| + this.load = load;
|
| + this.error = error;
|
| + this.handle = handle;
|
| + }
|
| + =====*/
|
| +
|
| + /*=====
|
| + dojo.__IoCallbackArgs = function(args, xhr, url, query, handleAs, id, canDelete, json){
|
| + // args: Object
|
| + // the original object argument to the IO call.
|
| + // xhr: XMLHttpRequest
|
| + // For XMLHttpRequest calls only, the
|
| + // XMLHttpRequest object that was used for the
|
| + // request.
|
| + // url: String
|
| + // The final URL used for the call. Many times it
|
| + // will be different than the original args.url
|
| + // value.
|
| + // query: String
|
| + // For non-GET requests, the
|
| + // name1=value1&name2=value2 parameters sent up in
|
| + // the request.
|
| + // handleAs: String
|
| + // The final indicator on how the response will be
|
| + // handled.
|
| + // id: String
|
| + // For dojo.io.script calls only, the internal
|
| + // script ID used for the request.
|
| + // canDelete: Boolean
|
| + // For dojo.io.script calls only, indicates
|
| + // whether the script tag that represents the
|
| + // request can be deleted after callbacks have
|
| + // been called. Used internally to know when
|
| + // cleanup can happen on JSONP-type requests.
|
| + // json: Object
|
| + // For dojo.io.script calls only: holds the JSON
|
| + // response for JSONP-type requests. Used
|
| + // internally to hold on to the JSON responses.
|
| + // You should not need to access it directly --
|
| + // the same object should be passed to the success
|
| + // callbacks directly.
|
| + this.args = args;
|
| + this.xhr = xhr;
|
| + this.url = url;
|
| + this.query = query;
|
| + this.handleAs = handleAs;
|
| + this.id = id;
|
| + this.canDelete = canDelete;
|
| + this.json = json;
|
| + }
|
| + =====*/
|
| +
|
| +
|
| +
|
| + dojo._ioSetArgs = function(/*dojo.__IoArgs*/args,
|
| + /*Function*/canceller,
|
| + /*Function*/okHandler,
|
| + /*Function*/errHandler){
|
| + // summary:
|
| + // sets up the Deferred and ioArgs property on the Deferred so it
|
| + // can be used in an io call.
|
| + // args:
|
| + // The args object passed into the public io call. Recognized properties on
|
| + // the args object are:
|
| + // canceller:
|
| + // The canceller function used for the Deferred object. The function
|
| + // will receive one argument, the Deferred object that is related to the
|
| + // canceller.
|
| + // okHandler:
|
| + // The first OK callback to be registered with Deferred. It has the opportunity
|
| + // to transform the OK response. It will receive one argument -- the Deferred
|
| + // object returned from this function.
|
| + // errHandler:
|
| + // The first error callback to be registered with Deferred. It has the opportunity
|
| + // to do cleanup on an error. It will receive two arguments: error (the
|
| + // Error object) and dfd, the Deferred object returned from this function.
|
| +
|
| + var ioArgs = {args: args, url: args.url};
|
| +
|
| + //Get values from form if requestd.
|
| + var formObject = null;
|
| + if(args.form){
|
| + var form = _d.byId(args.form);
|
| + //IE requires going through getAttributeNode instead of just getAttribute in some form cases,
|
| + //so use it for all. See #2844
|
| + var actnNode = form.getAttributeNode("action");
|
| + ioArgs.url = ioArgs.url || (actnNode ? actnNode.value : null);
|
| + formObject = _d.formToObject(form);
|
| + }
|
| +
|
| + // set up the query params
|
| + var miArgs = [{}];
|
| +
|
| + if(formObject){
|
| + // potentially over-ride url-provided params w/ form values
|
| + miArgs.push(formObject);
|
| + }
|
| + if(args.content){
|
| + // stuff in content over-rides what's set by form
|
| + miArgs.push(args.content);
|
| + }
|
| + if(args.preventCache){
|
| + miArgs.push({"dojo.preventCache": new Date().valueOf()});
|
| + }
|
| + ioArgs.query = _d.objectToQuery(_d.mixin.apply(null, miArgs));
|
| +
|
| + // .. and the real work of getting the deferred in order, etc.
|
| + ioArgs.handleAs = args.handleAs || "text";
|
| + var d = new _d.Deferred(canceller);
|
| + d.addCallbacks(okHandler, function(error){
|
| + return errHandler(error, d);
|
| + });
|
| +
|
| + //Support specifying load, error and handle callback functions from the args.
|
| + //For those callbacks, the "this" object will be the args object.
|
| + //The callbacks will get the deferred result value as the
|
| + //first argument and the ioArgs object as the second argument.
|
| + var ld = args.load;
|
| + if(ld && _d.isFunction(ld)){
|
| + d.addCallback(function(value){
|
| + return ld.call(args, value, ioArgs);
|
| + });
|
| + }
|
| + var err = args.error;
|
| + if(err && _d.isFunction(err)){
|
| + d.addErrback(function(value){
|
| + return err.call(args, value, ioArgs);
|
| + });
|
| + }
|
| + var handle = args.handle;
|
| + if(handle && _d.isFunction(handle)){
|
| + d.addBoth(function(value){
|
| + return handle.call(args, value, ioArgs);
|
| + });
|
| + }
|
| +
|
| + d.ioArgs = ioArgs;
|
| +
|
| + // FIXME: need to wire up the xhr object's abort method to something
|
| + // analagous in the Deferred
|
| + return d;
|
| + }
|
| +
|
| + var _deferredCancel = function(/*Deferred*/dfd){
|
| + //summary: canceller function for dojo._ioSetArgs call.
|
| +
|
| + dfd.canceled = true;
|
| + var xhr = dfd.ioArgs.xhr;
|
| + var _at = typeof xhr.abort;
|
| + if(_at == "function" || _at == "object" || _at == "unknown"){
|
| + xhr.abort();
|
| + }
|
| + var err = dfd.ioArgs.error;
|
| + if(!err){
|
| + err = new Error("xhr cancelled");
|
| + err.dojoType="cancel";
|
| + }
|
| + return err;
|
| + }
|
| + var _deferredOk = function(/*Deferred*/dfd){
|
| + //summary: okHandler function for dojo._ioSetArgs call.
|
| +
|
| + var ret = _d._contentHandlers[dfd.ioArgs.handleAs](dfd.ioArgs.xhr);
|
| + return (typeof ret == "undefined") ? null : ret;
|
| + }
|
| + var _deferError = function(/*Error*/error, /*Deferred*/dfd){
|
| + //summary: errHandler function for dojo._ioSetArgs call.
|
| +
|
| +
|
| + return error;
|
| + }
|
| +
|
| + // avoid setting a timer per request. It degrades performance on IE
|
| + // something fierece if we don't use unified loops.
|
| + var _inFlightIntvl = null;
|
| + var _inFlight = [];
|
| + var _watchInFlight = function(){
|
| + //summary:
|
| + // internal method that checks each inflight XMLHttpRequest to see
|
| + // if it has completed or if the timeout situation applies.
|
| +
|
| + var now = (new Date()).getTime();
|
| + // make sure sync calls stay thread safe, if this callback is called
|
| + // during a sync call and this results in another sync call before the
|
| + // first sync call ends the browser hangs
|
| + if(!_d._blockAsync){
|
| + // we need manual loop because we often modify _inFlight (and therefore 'i') while iterating
|
| + // note: the second clause is an assigment on purpose, lint may complain
|
| + for(var i = 0, tif; i < _inFlight.length && (tif = _inFlight[i]); i++){
|
| + var dfd = tif.dfd;
|
| + var func = function(){
|
| + if(!dfd || dfd.canceled || !tif.validCheck(dfd)){
|
| + _inFlight.splice(i--, 1);
|
| + }else if(tif.ioCheck(dfd)){
|
| + _inFlight.splice(i--, 1);
|
| + tif.resHandle(dfd);
|
| + }else if(dfd.startTime){
|
| + //did we timeout?
|
| + if(dfd.startTime + (dfd.ioArgs.args.timeout || 0) < now){
|
| + _inFlight.splice(i--, 1);
|
| + var err = new Error("timeout exceeded");
|
| + err.dojoType = "timeout";
|
| + dfd.errback(err);
|
| + //Cancel the request so the io module can do appropriate cleanup.
|
| + dfd.cancel();
|
| + }
|
| + }
|
| + };
|
| + if(dojo.config.isDebug){
|
| + func.call(this);
|
| + }else{
|
| + try{
|
| + func.call(this);
|
| + }catch(e){
|
| + dfd.errback(e);
|
| + }
|
| + }
|
| + }
|
| + }
|
| +
|
| + if(!_inFlight.length){
|
| + clearInterval(_inFlightIntvl);
|
| + _inFlightIntvl = null;
|
| + return;
|
| + }
|
| +
|
| + }
|
| +
|
| + dojo._ioCancelAll = function(){
|
| + //summary: Cancels all pending IO requests, regardless of IO type
|
| + //(xhr, script, iframe).
|
| + try{
|
| + _d.forEach(_inFlight, function(i){
|
| + try{
|
| + i.dfd.cancel();
|
| + }catch(e){/*squelch*/}
|
| + });
|
| + }catch(e){/*squelch*/}
|
| + }
|
| +
|
| + //Automatically call cancel all io calls on unload
|
| + //in IE for trac issue #2357.
|
| + if(_d.isIE){
|
| + _d.addOnWindowUnload(_d._ioCancelAll);
|
| + }
|
| +
|
| + _d._ioWatch = function(/*Deferred*/dfd,
|
| + /*Function*/validCheck,
|
| + /*Function*/ioCheck,
|
| + /*Function*/resHandle){
|
| + //summary: watches the io request represented by dfd to see if it completes.
|
| + //dfd:
|
| + // The Deferred object to watch.
|
| + //validCheck:
|
| + // Function used to check if the IO request is still valid. Gets the dfd
|
| + // object as its only argument.
|
| + //ioCheck:
|
| + // Function used to check if basic IO call worked. Gets the dfd
|
| + // object as its only argument.
|
| + //resHandle:
|
| + // Function used to process response. Gets the dfd
|
| + // object as its only argument.
|
| + if(dfd.ioArgs.args.timeout){
|
| + dfd.startTime = (new Date()).getTime();
|
| + }
|
| + _inFlight.push({dfd: dfd, validCheck: validCheck, ioCheck: ioCheck, resHandle: resHandle});
|
| + if(!_inFlightIntvl){
|
| + _inFlightIntvl = setInterval(_watchInFlight, 50);
|
| + }
|
| + _watchInFlight(); // handle sync requests
|
| + }
|
| +
|
| + var _defaultContentType = "application/x-www-form-urlencoded";
|
| +
|
| + var _validCheck = function(/*Deferred*/dfd){
|
| + return dfd.ioArgs.xhr.readyState; //boolean
|
| + }
|
| + var _ioCheck = function(/*Deferred*/dfd){
|
| + return 4 == dfd.ioArgs.xhr.readyState; //boolean
|
| + }
|
| + var _resHandle = function(/*Deferred*/dfd){
|
| + var xhr = dfd.ioArgs.xhr;
|
| + if(_d._isDocumentOk(xhr)){
|
| + dfd.callback(dfd);
|
| + }else{
|
| + var err = new Error("Unable to load " + dfd.ioArgs.url + " status:" + xhr.status);
|
| + err.status = xhr.status;
|
| + err.responseText = xhr.responseText;
|
| + dfd.errback(err);
|
| + }
|
| + }
|
| +
|
| + dojo._ioAddQueryToUrl = function(/*dojo.__IoCallbackArgs*/ioArgs){
|
| + //summary: Adds query params discovered by the io deferred construction to the URL.
|
| + //Only use this for operations which are fundamentally GET-type operations.
|
| + if(ioArgs.query.length){
|
| + ioArgs.url += (ioArgs.url.indexOf("?") == -1 ? "?" : "&") + ioArgs.query;
|
| + ioArgs.query = null;
|
| + }
|
| + }
|
| +
|
| + /*=====
|
| + dojo.declare("dojo.__XhrArgs", dojo.__IoArgs, {
|
| + constructor: function(){
|
| + // summary:
|
| + // In addition to the properties listed for the dojo._IoArgs type,
|
| + // the following properties are allowed for dojo.xhr* methods.
|
| + // handleAs: String?
|
| + // Acceptable values are: text (default), json, json-comment-optional,
|
| + // json-comment-filtered, javascript, xml
|
| + // sync: Boolean?
|
| + // false is default. Indicates whether the request should
|
| + // be a synchronous (blocking) request.
|
| + // headers: Object?
|
| + // Additional HTTP headers to send in the request.
|
| + this.handleAs = handleAs;
|
| + this.sync = sync;
|
| + this.headers = headers;
|
| + }
|
| + });
|
| + =====*/
|
| +
|
| + dojo.xhr = function(/*String*/ method, /*dojo.__XhrArgs*/ args, /*Boolean?*/ hasBody){
|
| + // summary:
|
| + // Sends an HTTP request with the given method.
|
| + // description:
|
| + // Sends an HTTP request with the given method.
|
| + // See also dojo.xhrGet(), xhrPost(), xhrPut() and dojo.xhrDelete() for shortcuts
|
| + // for those HTTP methods. There are also methods for "raw" PUT and POST methods
|
| + // via dojo.rawXhrPut() and dojo.rawXhrPost() respectively.
|
| + // method:
|
| + // HTTP method to be used, such as GET, POST, PUT, DELETE. Should be uppercase.
|
| + // hasBody:
|
| + // If the request has an HTTP body, then pass true for hasBody.
|
| +
|
| + //Make the Deferred object for this xhr request.
|
| + var dfd = _d._ioSetArgs(args, _deferredCancel, _deferredOk, _deferError);
|
| +
|
| + //Pass the args to _xhrObj, to allow xhr iframe proxy interceptions.
|
| + dfd.ioArgs.xhr = _d._xhrObj(dfd.ioArgs.args);
|
| +
|
| + if(hasBody){
|
| + if("postData" in args){
|
| + dfd.ioArgs.query = args.postData;
|
| + }else if("putData" in args){
|
| + dfd.ioArgs.query = args.putData;
|
| + }
|
| + }else{
|
| + _d._ioAddQueryToUrl(dfd.ioArgs);
|
| + }
|
| +
|
| + // IE 6 is a steaming pile. It won't let you call apply() on the native function (xhr.open).
|
| + // workaround for IE6's apply() "issues"
|
| + var ioArgs = dfd.ioArgs;
|
| + var xhr = ioArgs.xhr;
|
| + xhr.open(method, ioArgs.url, args.sync !== true, args.user || undefined, args.password || undefined);
|
| + if(args.headers){
|
| + for(var hdr in args.headers){
|
| + if(hdr.toLowerCase() === "content-type" && !args.contentType){
|
| + args.contentType = args.headers[hdr];
|
| + }else{
|
| + xhr.setRequestHeader(hdr, args.headers[hdr]);
|
| + }
|
| + }
|
| + }
|
| + // FIXME: is this appropriate for all content types?
|
| + xhr.setRequestHeader("Content-Type", args.contentType || _defaultContentType);
|
| + if(!args.headers || !args.headers["X-Requested-With"]){
|
| + xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
|
| + }
|
| + // FIXME: set other headers here!
|
| + if(dojo.config.isDebug){
|
| + xhr.send(ioArgs.query);
|
| + }else{
|
| + try{
|
| + xhr.send(ioArgs.query);
|
| + }catch(e){
|
| + dfd.ioArgs.error = e;
|
| + dfd.cancel();
|
| + }
|
| + }
|
| + _d._ioWatch(dfd, _validCheck, _ioCheck, _resHandle);
|
| + xhr = null;
|
| + return dfd; // dojo.Deferred
|
| + }
|
| +
|
| + dojo.xhrGet = function(/*dojo.__XhrArgs*/ args){
|
| + // summary:
|
| + // Sends an HTTP GET request to the server.
|
| + return _d.xhr("GET", args); // dojo.Deferred
|
| + }
|
| +
|
| + dojo.rawXhrPost = dojo.xhrPost = function(/*dojo.__XhrArgs*/ args){
|
| + // summary:
|
| + // Sends an HTTP POST request to the server. In addtion to the properties
|
| + // listed for the dojo.__XhrArgs type, the following property is allowed:
|
| + // postData:
|
| + // String. Send raw data in the body of the POST request.
|
| + return _d.xhr("POST", args, true); // dojo.Deferred
|
| + }
|
| +
|
| + dojo.rawXhrPut = dojo.xhrPut = function(/*dojo.__XhrArgs*/ args){
|
| + // summary:
|
| + // Sends an HTTP PUT request to the server. In addtion to the properties
|
| + // listed for the dojo.__XhrArgs type, the following property is allowed:
|
| + // putData:
|
| + // String. Send raw data in the body of the PUT request.
|
| + return _d.xhr("PUT", args, true); // dojo.Deferred
|
| + }
|
| +
|
| + dojo.xhrDelete = function(/*dojo.__XhrArgs*/ args){
|
| + // summary:
|
| + // Sends an HTTP DELETE request to the server.
|
| + return _d.xhr("DELETE", args); //dojo.Deferred
|
| + }
|
| +
|
| + /*
|
| + dojo.wrapForm = function(formNode){
|
| + //summary:
|
| + // A replacement for FormBind, but not implemented yet.
|
| +
|
| + // FIXME: need to think harder about what extensions to this we might
|
| + // want. What should we allow folks to do w/ this? What events to
|
| + // set/send?
|
| + throw new Error("dojo.wrapForm not yet implemented");
|
| + }
|
| + */
|
| +})();
|
| +
|
| +}
|
| +
|
| +if(!dojo._hasResource["dojo._base.fx"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
|
| +dojo._hasResource["dojo._base.fx"] = true;
|
| +dojo.provide("dojo._base.fx");
|
| +
|
| +
|
| +
|
| +
|
| +
|
| +
|
| +/*
|
| + Animation losely package based on Dan Pupius' work, contributed under CLA:
|
| + http://pupius.co.uk/js/Toolkit.Drawing.js
|
| +*/
|
| +(function(){
|
| +
|
| + var d = dojo;
|
| +
|
| + dojo._Line = function(/*int*/ start, /*int*/ end){
|
| + // summary:
|
| + // dojo._Line is the object used to generate values from a start value
|
| + // to an end value
|
| + // start: int
|
| + // Beginning value for range
|
| + // end: int
|
| + // Ending value for range
|
| + this.start = start;
|
| + this.end = end;
|
| + this.getValue = function(/*float*/ n){
|
| + // summary: returns the point on the line
|
| + // n: a floating point number greater than 0 and less than 1
|
| + return ((this.end - this.start) * n) + this.start; // Decimal
|
| + }
|
| + }
|
| +
|
| + d.declare("dojo._Animation", null, {
|
| + // summary
|
| + // A generic animation class that fires callbacks into its handlers
|
| + // object at various states. Nearly all dojo animation functions
|
| + // return an instance of this method, usually without calling the
|
| + // .play() method beforehand. Therefore, you will likely need to
|
| + // call .play() on instances of dojo._Animation when one is
|
| + // returned.
|
| + constructor: function(/*Object*/ args){
|
| + d.mixin(this, args);
|
| + if(d.isArray(this.curve)){
|
| + /* curve: Array
|
| + pId: a */
|
| + this.curve = new d._Line(this.curve[0], this.curve[1]);
|
| + }
|
| + },
|
| +
|
| + // duration: Integer
|
| + // The time in milliseonds the animation will take to run
|
| + duration: 350,
|
| +
|
| + /*=====
|
| + // curve: dojo._Line||Array
|
| + // A two element array of start and end values, or a dojo._Line instance to be
|
| + // used in the Animation.
|
| + curve: null,
|
| +
|
| + // easing: Function
|
| + // A Function to adjust the acceleration (or deceleration) of the progress
|
| + // across a dojo._Line
|
| + easing: null,
|
| + =====*/
|
| +
|
| + // repeat: Integer
|
| + // The number of times to loop the animation
|
| + repeat: 0,
|
| +
|
| + // rate: Integer
|
| + // the time in milliseconds to wait before advancing to next frame
|
| + // (used as a fps timer: rate/1000 = fps)
|
| + rate: 10 /* 100 fps */,
|
| +
|
| + /*=====
|
| + // delay: Integer
|
| + // The time in milliseconds to wait before starting animation after it has been .play()'ed
|
| + delay: null,
|
| +
|
| + // events
|
| + //
|
| + // beforeBegin: Event
|
| + // Synthetic event fired before a dojo._Animation begins playing (synchronous)
|
| + beforeBegin: null,
|
| +
|
| + // onBegin: Event
|
| + // Synthetic event fired as a dojo._Animation begins playing (useful?)
|
| + onBegin: null,
|
| +
|
| + // onAnimate: Event
|
| + // Synthetic event fired at each interval of a dojo._Animation
|
| + onAnimate: null,
|
| +
|
| + // onEnd: Event
|
| + // Synthetic event fired after the final frame of a dojo._Animation
|
| + onEnd: null,
|
| +
|
| + // onPlay: Event
|
| + // Synthetic event fired any time a dojo._Animation is play()'ed
|
| + onPlay: null,
|
| +
|
| + // onPause: Event
|
| + // Synthetic event fired when a dojo._Animation is paused
|
| + onPause: null,
|
| +
|
| + // onStop: Event
|
| + // Synthetic event fires when a dojo._Animation is stopped
|
| + onStop: null,
|
| +
|
| + =====*/
|
| +
|
| + _percent: 0,
|
| + _startRepeatCount: 0,
|
| +
|
| + _fire: function(/*Event*/ evt, /*Array?*/ args){
|
| + // summary:
|
| + // Convenience function. Fire event "evt" and pass it the
|
| + // arguments specified in "args".
|
| + // evt:
|
| + // The event to fire.
|
| + // args:
|
| + // The arguments to pass to the event.
|
| + if(this[evt]){
|
| + if(dojo.config.isDebug){
|
| + this[evt].apply(this, args||[]);
|
| + }else{
|
| + try{
|
| + this[evt].apply(this, args||[]);
|
| + }catch(e){
|
| + // squelch and log because we shouldn't allow exceptions in
|
| + // synthetic event handlers to cause the internal timer to run
|
| + // amuck, potentially pegging the CPU. I'm not a fan of this
|
| + // squelch, but hopefully logging will make it clear what's
|
| + // going on
|
| + console.error("exception in animation handler for:", evt);
|
| + console.error(e);
|
| + }
|
| + }
|
| + }
|
| + return this; // dojo._Animation
|
| + },
|
| +
|
| + play: function(/*int?*/ delay, /*Boolean?*/ gotoStart){
|
| + // summary:
|
| + // Start the animation.
|
| + // delay:
|
| + // How many milliseconds to delay before starting.
|
| + // gotoStart:
|
| + // If true, starts the animation from the beginning; otherwise,
|
| + // starts it from its current position.
|
| + var _t = this;
|
| + if(gotoStart){
|
| + _t._stopTimer();
|
| + _t._active = _t._paused = false;
|
| + _t._percent = 0;
|
| + }else if(_t._active && !_t._paused){
|
| + return _t; // dojo._Animation
|
| + }
|
| +
|
| + _t._fire("beforeBegin");
|
| +
|
| + var de = delay||_t.delay;
|
| + var _p = dojo.hitch(_t, "_play", gotoStart);
|
| + if(de > 0){
|
| + setTimeout(_p, de);
|
| + return _t; // dojo._Animation
|
| + }
|
| + _p();
|
| + return _t;
|
| + },
|
| +
|
| + _play: function(gotoStart){
|
| + var _t = this;
|
| + _t._startTime = new Date().valueOf();
|
| + if(_t._paused){
|
| + _t._startTime -= _t.duration * _t._percent;
|
| + }
|
| + _t._endTime = _t._startTime + _t.duration;
|
| +
|
| + _t._active = true;
|
| + _t._paused = false;
|
| +
|
| + var value = _t.curve.getValue(_t._percent);
|
| + if(!_t._percent){
|
| + if(!_t._startRepeatCount){
|
| + _t._startRepeatCount = _t.repeat;
|
| + }
|
| + _t._fire("onBegin", [value]);
|
| + }
|
| +
|
| + _t._fire("onPlay", [value]);
|
| +
|
| + _t._cycle();
|
| + return _t; // dojo._Animation
|
| + },
|
| +
|
| + pause: function(){
|
| + // summary: Pauses a running animation.
|
| + this._stopTimer();
|
| + if(!this._active){ return this; /*dojo._Animation*/ }
|
| + this._paused = true;
|
| + this._fire("onPause", [this.curve.getValue(this._percent)]);
|
| + return this; // dojo._Animation
|
| + },
|
| +
|
| + gotoPercent: function(/*Decimal*/ percent, /*Boolean?*/ andPlay){
|
| + // summary:
|
| + // Sets the progress of the animation.
|
| + // percent:
|
| + // A percentage in decimal notation (between and including 0.0 and 1.0).
|
| + // andPlay:
|
| + // If true, play the animation after setting the progress.
|
| + this._stopTimer();
|
| + this._active = this._paused = true;
|
| + this._percent = percent;
|
| + if(andPlay){ this.play(); }
|
| + return this; // dojo._Animation
|
| + },
|
| +
|
| + stop: function(/*boolean?*/ gotoEnd){
|
| + // summary: Stops a running animation.
|
| + // gotoEnd: If true, the animation will end.
|
| + if(!this._timer){ return this; /* dojo._Animation */ }
|
| + this._stopTimer();
|
| + if(gotoEnd){
|
| + this._percent = 1;
|
| + }
|
| + this._fire("onStop", [this.curve.getValue(this._percent)]);
|
| + this._active = this._paused = false;
|
| + return this; // dojo._Animation
|
| + },
|
| +
|
| + status: function(){
|
| + // summary: Returns a string token representation of the status of
|
| + // the animation, one of: "paused", "playing", "stopped"
|
| + if(this._active){
|
| + return this._paused ? "paused" : "playing"; // String
|
| + }
|
| + return "stopped"; // String
|
| + },
|
| +
|
| + _cycle: function(){
|
| + var _t = this;
|
| + if(_t._active){
|
| + var curr = new Date().valueOf();
|
| + var step = (curr - _t._startTime) / (_t._endTime - _t._startTime);
|
| +
|
| + if(step >= 1){
|
| + step = 1;
|
| + }
|
| + _t._percent = step;
|
| +
|
| + // Perform easing
|
| + if(_t.easing){
|
| + step = _t.easing(step);
|
| + }
|
| +
|
| + _t._fire("onAnimate", [_t.curve.getValue(step)]);
|
| +
|
| + if(_t._percent < 1){
|
| + _t._startTimer();
|
| + }else{
|
| + _t._active = false;
|
| +
|
| + if(_t.repeat > 0){
|
| + _t.repeat--;
|
| + _t.play(null, true);
|
| + }else if(_t.repeat == -1){
|
| + _t.play(null, true);
|
| + }else{
|
| + if(_t._startRepeatCount){
|
| + _t.repeat = _t._startRepeatCount;
|
| + _t._startRepeatCount = 0;
|
| + }
|
| + }
|
| + _t._percent = 0;
|
| + _t._fire("onEnd");
|
| + _t._stopTimer();
|
| + }
|
| + }
|
| + return _t; // dojo._Animation
|
| + }
|
| + });
|
| +
|
| + var ctr = 0;
|
| + var _globalTimerList = [];
|
| + var runner = {
|
| + run: function(){ }
|
| + };
|
| + var timer = null;
|
| + dojo._Animation.prototype._startTimer = function(){
|
| + // this._timer = setTimeout(dojo.hitch(this, "_cycle"), this.rate);
|
| + if(!this._timer){
|
| + this._timer = d.connect(runner, "run", this, "_cycle");
|
| + ctr++;
|
| + }
|
| + if(!timer){
|
| + timer = setInterval(d.hitch(runner, "run"), this.rate);
|
| + }
|
| + };
|
| +
|
| + dojo._Animation.prototype._stopTimer = function(){
|
| + if(this._timer){
|
| + d.disconnect(this._timer);
|
| + this._timer = null;
|
| + ctr--;
|
| + }
|
| + if(ctr <= 0){
|
| + clearInterval(timer);
|
| + timer = null;
|
| + ctr = 0;
|
| + }
|
| + };
|
| +
|
| + var _makeFadeable = (d.isIE) ? function(node){
|
| + // only set the zoom if the "tickle" value would be the same as the
|
| + // default
|
| + var ns = node.style;
|
| + // don't set the width to auto if it didn't already cascade that way.
|
| + // We don't want to f anyones designs
|
| + if(!ns.width.length && d.style(node, "width") == "auto"){
|
| + ns.width = "auto";
|
| + }
|
| + } : function(){};
|
| +
|
| + dojo._fade = function(/*Object*/ args){
|
| + // summary:
|
| + // Returns an animation that will fade the node defined by
|
| + // args.node from the start to end values passed (args.start
|
| + // args.end) (end is mandatory, start is optional)
|
| +
|
| + args.node = d.byId(args.node);
|
| + var fArgs = d.mixin({ properties: {} }, args);
|
| + var props = (fArgs.properties.opacity = {});
|
| + props.start = !("start" in fArgs) ?
|
| + function(){
|
| + return Number(d.style(fArgs.node, "opacity"));
|
| + } : fArgs.start;
|
| + props.end = fArgs.end;
|
| +
|
| + var anim = d.animateProperty(fArgs);
|
| + d.connect(anim, "beforeBegin", d.partial(_makeFadeable, fArgs.node));
|
| +
|
| + return anim; // dojo._Animation
|
| + }
|
| +
|
| + /*=====
|
| + dojo.__FadeArgs = function(node, duration, easing){
|
| + // node: DOMNode|String
|
| + // The node referenced in the animation
|
| + // duration: Integer?
|
| + // Duration of the animation in milliseconds.
|
| + // easing: Function?
|
| + // An easing function.
|
| + this.node = node;
|
| + this.duration = duration;
|
| + this.easing = easing;
|
| + }
|
| + =====*/
|
| +
|
| + dojo.fadeIn = function(/*dojo.__FadeArgs*/ args){
|
| + // summary:
|
| + // Returns an animation that will fade node defined in 'args' from
|
| + // its current opacity to fully opaque.
|
| + return d._fade(d.mixin({ end: 1 }, args)); // dojo._Animation
|
| + }
|
| +
|
| + dojo.fadeOut = function(/*dojo.__FadeArgs*/ args){
|
| + // summary:
|
| + // Returns an animation that will fade node defined in 'args'
|
| + // from its current opacity to fully transparent.
|
| + return d._fade(d.mixin({ end: 0 }, args)); // dojo._Animation
|
| + }
|
| +
|
| + dojo._defaultEasing = function(/*Decimal?*/ n){
|
| + // summary: The default easing function for dojo._Animation(s)
|
| + return 0.5 + ((Math.sin((n + 1.5) * Math.PI))/2);
|
| + }
|
| +
|
| + var PropLine = function(properties){
|
| + // PropLine is an internal class which is used to model the values of
|
| + // an a group of CSS properties across an animation lifecycle. In
|
| + // particular, the "getValue" function handles getting interpolated
|
| + // values between start and end for a particular CSS value.
|
| + this._properties = properties;
|
| + for(var p in properties){
|
| + var prop = properties[p];
|
| + if(prop.start instanceof d.Color){
|
| + // create a reusable temp color object to keep intermediate results
|
| + prop.tempColor = new d.Color();
|
| + }
|
| + }
|
| + this.getValue = function(r){
|
| + var ret = {};
|
| + for(var p in this._properties){
|
| + var prop = this._properties[p];
|
| + var start = prop.start;
|
| + if(start instanceof d.Color){
|
| + ret[p] = d.blendColors(start, prop.end, r, prop.tempColor).toCss();
|
| + }else if(!d.isArray(start)){
|
| + ret[p] = ((prop.end - start) * r) + start + (p != "opacity" ? prop.units||"px" : "");
|
| + }
|
| + }
|
| + return ret;
|
| + }
|
| + }
|
| +
|
| + /*=====
|
| + dojo.declare("dojo.__AnimArgs", [dojo.__FadeArgs], {
|
| + // Properties: Object?
|
| + // A hash map of style properties to Objects describing the transition,
|
| + // such as the properties of dojo._Line with an additional 'unit' property
|
| + properties: {}
|
| +
|
| + //TODOC: add event callbacks
|
| + });
|
| + =====*/
|
| +
|
| + dojo.animateProperty = function(/*dojo.__AnimArgs*/ args){
|
| + // summary:
|
| + // Returns an animation that will transition the properties of
|
| + // node defined in 'args' depending how they are defined in
|
| + // 'args.properties'
|
| + //
|
| + // description:
|
| + // dojo.animateProperty is the foundation of most dojo.fx
|
| + // animations. It takes an object of "properties" corresponding to
|
| + // style properties, and animates them in parallel over a set
|
| + // duration.
|
| + //
|
| + // example:
|
| + // A simple animation that changes the width of the specified node.
|
| + // | dojo.animateProperty({
|
| + // | node: "nodeId",
|
| + // | properties: { width: 400 },
|
| + // | }).play();
|
| + // Dojo figures out the start value for the width and converts the
|
| + // integer specified for the width to the more expressive but
|
| + // verbose form `{ width: { end: '400', units: 'px' } }` which you
|
| + // can also specify directly
|
| + //
|
| + // example:
|
| + // Animate width, height, and padding over 2 seconds... the
|
| + // pedantic way:
|
| + // | dojo.animateProperty({ node: node, duration:2000,
|
| + // | properties: {
|
| + // | width: { start: '200', end: '400', unit:"px" },
|
| + // | height: { start:'200', end: '400', unit:"px" },
|
| + // | paddingTop: { start:'5', end:'50', unit:"px" }
|
| + // | }
|
| + // | }).play();
|
| + // Note 'paddingTop' is used over 'padding-top'. Multi-name CSS properties
|
| + // are written using "mixed case", as the hyphen is illegal as an object key.
|
| + //
|
| + // example:
|
| + // Plug in a different easing function and register a callback for
|
| + // when the animation ends. Easing functions accept values between
|
| + // zero and one and return a value on that basis. In this case, an
|
| + // exponential-in curve.
|
| + // | dojo.animateProperty({
|
| + // | node: "nodeId",
|
| + // | // dojo figures out the start value
|
| + // | properties: { width: { end: 400 } },
|
| + // | easing: function(n){
|
| + // | return (n==0) ? 0 : Math.pow(2, 10 * (n - 1));
|
| + // | },
|
| + // | onEnd: function(){
|
| + // | // called when the animation finishes
|
| + // | }
|
| + // | }).play(500); // delay playing half a second
|
| + //
|
| + // example:
|
| + // Like all `dojo._Animation`s, animateProperty returns a handle to the
|
| + // Animation instance, which fires the events common to Dojo FX. Use `dojo.connect`
|
| + // to access these events outside of the Animation definiton:
|
| + // | var anim = dojo.animateProperty({
|
| + // | node:"someId",
|
| + // | properties:{
|
| + // | width:400, height:500
|
| + // | }
|
| + // | });
|
| + // | dojo.connect(anim,"onEnd", function(){
|
| + // |
|
| + // | });
|
| + // | // play the animation now:
|
| + // | anim.play();
|
| +
|
| + args.node = d.byId(args.node);
|
| + if(!args.easing){ args.easing = d._defaultEasing; }
|
| +
|
| + var anim = new d._Animation(args);
|
| + d.connect(anim, "beforeBegin", anim, function(){
|
| + var pm = {};
|
| + for(var p in this.properties){
|
| + // Make shallow copy of properties into pm because we overwrite
|
| + // some values below. In particular if start/end are functions
|
| + // we don't want to overwrite them or the functions won't be
|
| + // called if the animation is reused.
|
| + if(p == "width" || p == "height"){
|
| + this.node.display = "block";
|
| + }
|
| + var prop = this.properties[p];
|
| + prop = pm[p] = d.mixin({}, (d.isObject(prop) ? prop: { end: prop }));
|
| +
|
| + if(d.isFunction(prop.start)){
|
| + prop.start = prop.start();
|
| + }
|
| + if(d.isFunction(prop.end)){
|
| + prop.end = prop.end();
|
| + }
|
| + var isColor = (p.toLowerCase().indexOf("color") >= 0);
|
| + function getStyle(node, p){
|
| + // dojo.style(node, "height") can return "auto" or "" on IE; this is more reliable:
|
| + var v = ({height: node.offsetHeight, width: node.offsetWidth})[p];
|
| + if(v !== undefined){ return v; }
|
| + v = d.style(node, p);
|
| + return (p=="opacity") ? Number(v) : (isColor ? v : parseFloat(v));
|
| + }
|
| + if(!("end" in prop)){
|
| + prop.end = getStyle(this.node, p);
|
| + }else if(!("start" in prop)){
|
| + prop.start = getStyle(this.node, p);
|
| + }
|
| +
|
| + if(isColor){
|
| + prop.start = new d.Color(prop.start);
|
| + prop.end = new d.Color(prop.end);
|
| + }else{
|
| + prop.start = (p == "opacity") ? Number(prop.start) : parseFloat(prop.start);
|
| + }
|
| + }
|
| + this.curve = new PropLine(pm);
|
| + });
|
| + d.connect(anim, "onAnimate", d.hitch(d, "style", anim.node));
|
| + return anim; // dojo._Animation
|
| + }
|
| +
|
| + dojo.anim = function( /*DOMNode|String*/ node,
|
| + /*Object*/ properties,
|
| + /*Integer?*/ duration,
|
| + /*Function?*/ easing,
|
| + /*Function?*/ onEnd,
|
| + /*Integer?*/ delay){
|
| + // summary:
|
| + // A simpler interface to `dojo.animateProperty()`, also returns
|
| + // an instance of `dojo._Animation` but begins the animation
|
| + // immediately, unlike nearly every other Dojo animation API.
|
| + // description:
|
| + // `dojo.anim` is a simpler (but somewhat less powerful) version
|
| + // of `dojo.animateProperty`. It uses defaults for many basic properties
|
| + // and allows for positional parameters to be used in place of the
|
| + // packed "property bag" which is used for other Dojo animation
|
| + // methods.
|
| + //
|
| + // The `dojo._Animation` object returned from `dojo.anim` will be
|
| + // already playing when it is returned from this function, so
|
| + // calling play() on it again is (usually) a no-op.
|
| + // node:
|
| + // a DOM node or the id of a node to animate CSS properties on
|
| + // duration:
|
| + // The number of milliseconds over which the animation
|
| + // should run. Defaults to the global animation default duration
|
| + // (350ms).
|
| + // easing:
|
| + // An easing function over which to calculate acceleration
|
| + // and deceleration of the animation through its duration.
|
| + // A default easing algorithm is provided, but you may
|
| + // plug in any you wish. A large selection of easing algorithms
|
| + // are available in `dojo.fx.easing`.
|
| + // onEnd:
|
| + // A function to be called when the animation finishes
|
| + // running.
|
| + // delay:
|
| + // The number of milliseconds to delay beginning the
|
| + // animation by. The default is 0.
|
| + // example:
|
| + // Fade out a node
|
| + // | dojo.anim("id", { opacity: 0 });
|
| + // example:
|
| + // Fade out a node over a full second
|
| + // | dojo.anim("id", { opacity: 0 }, 1000);
|
| + return d.animateProperty({
|
| + node: node,
|
| + duration: duration||d._Animation.prototype.duration,
|
| + properties: properties,
|
| + easing: easing,
|
| + onEnd: onEnd
|
| + }).play(delay||0);
|
| + }
|
| +})();
|
| +
|
| +}
|
| +
|
| +if(!dojo._hasResource["dojo._base.browser"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
|
| +dojo._hasResource["dojo._base.browser"] = true;
|
| +dojo.provide("dojo._base.browser");
|
| +
|
| +
|
| +
|
| +
|
| +
|
| +
|
| +
|
| +
|
| +
|
| +//Need this to be the last code segment in base, so do not place any
|
| +//dojo.requireIf calls in this file. Otherwise, due to how the build system
|
| +//puts all requireIf dependencies after the current file, the require calls
|
| +//could be called before all of base is defined.
|
| +if(dojo.config.require){
|
| + dojo.forEach(dojo.config.require, "dojo['require'](item);");
|
| +}
|
| +
|
| +}
|
| +
|
| + //INSERT dojo.i18n._preloadLocalizations HERE
|
| +
|
| + if(dojo.config.afterOnLoad && dojo.isBrowser){
|
| + //Dojo is being added to the page after page load, so just trigger
|
| + //the init sequence after a timeout. Using a timeout so the rest of this
|
| + //script gets evaluated properly. This work needs to happen after the
|
| + //dojo.config.require work done in dojo._base.
|
| + window.setTimeout(dojo._fakeLoadInit, 1000);
|
| + }
|
| +
|
| +})();
|
| +
|
|
|
Chromium Code Reviews
Issue 269054:
Importing dromaeo performance tests to src/chrome/test/data.... (Closed)
Base URL: svn://chrome-svn/chrome/trunk/src/