diff options
Diffstat (limited to 'lib/dojo/_base')
53 files changed, 7275 insertions, 13273 deletions
diff --git a/lib/dojo/_base/Color.js b/lib/dojo/_base/Color.js index 4707fa582..ad8e0ab3c 100644 --- a/lib/dojo/_base/Color.js +++ b/lib/dojo/_base/Color.js @@ -4,225 +4,5 @@ see: http://dojotoolkit.org/license for details */ - -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.require("dojo._base.array"); -dojo.require("dojo._base.lang"); - - -(function(){ - - var d = dojo; - - 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 - // and creates a new Color instance to work from. - // - // example: - // Work with a Color instance: - // | var c = new dojo.Color(); - // | c.setColor([0,0,0]); // black - // | var hex = c.toHex(); // #000000 - // - // example: - // Work with a node's color: - // | var color = dojo.style("someNode", "backgroundColor"); - // | var n = new dojo.Color(color); - // | // adjust the color some - // | n.r *= .5; - // | console.log(n.toString()); // rgb(128, 255, 255); - 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], - transparent: d.config.transparentColor || [255,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 - // and sets this color instance to that value. - // - // example: - // | var c = new dojo.Color(); // no color - // | c.setColor("#ededed"); // greyish - 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: - // Ensures the object has correct attributes - // description: - // the default implementation does nothing, include dojo.colors to - // augment it with real checks - return this; // dojo.Color - }, - toRgb: function(){ - // summary: - // Returns 3 component array of rgb values - // example: - // | var c = new dojo.Color("#000000"); - // | console.log(c.toRgb()); // [0,0,0] - var t = this; - return [t.r, t.g, t.b]; // Array - }, - toRgba: function(){ - // summary: - // Returns a 4 component array of rgba values from the color - // represented by this object. - var t = this; - return [t.r, t.g, t.b, t.a]; // Array - }, - toHex: function(){ - // summary: - // Returns a CSS color string in hexadecimal representation - // example: - // | console.log(new dojo.Color([0,0,0]).toHex()); // #000000 - var arr = d.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 - // example: - // | var c = new dojo.Color("#FFF").toCss(); - // | console.log(c); // rgb('255','255','255') - 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 t = obj || new d.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: - // Returns a `dojo.Color` instance from a string of the form - // "rgb(...)" or "rgba(...)". Optionally accepts a `dojo.Color` - // object to update with the parsed value and return instead of - // creating a new object. - // returns: - // A dojo.Color object. If obj is passed, it will be the return value. - 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. Optionally accepts a - // `dojo.Color` object to update with the parsed value. - // - // returns: - // A dojo.Color object. If obj is passed, it will be the return value. - // - // example: - // | var thing = dojo.colorFromHex("#ededed"); // grey, longhand - // - // example: - // | var thing = dojo.colorFromHex("#000"); // black, shorthand - var 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 `dojo.Color` from a 3 or 4 element array, mapping each - // element in sequence to the rgb(a) values of the color. - // example: - // | var myColor = dojo.colorFromArray([237,237,237,0.5]); // grey, 50% alpha - // returns: - // A dojo.Color object. If obj is passed, it will be the return value. - var t = obj || new d.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. Accepts hex, rgb, and rgba - // style color values. - // 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 = d.Color.named[str]; - return a && d.colorFromArray(a, obj) || d.colorFromRgb(str, obj) || d.colorFromHex(str, obj); - }; -})(); - -} +//>>built +define("dojo/_base/Color",["./kernel","./lang","./array","./config"],function(_1,_2,_3,_4){var _5=_1.Color=function(_6){if(_6){this.setColor(_6);}};_5.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],"transparent":_4.transparentColor||[0,0,0,0]};_2.extend(_5,{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(_7){if(_2.isString(_7)){_5.fromString(_7,this);}else{if(_2.isArray(_7)){_5.fromArray(_7,this);}else{this._set(_7.r,_7.g,_7.b,_7.a);if(!(_7 instanceof _5)){this.sanitize();}}}return this;},sanitize:function(){return this;},toRgb:function(){var t=this;return [t.r,t.g,t.b];},toRgba:function(){var t=this;return [t.r,t.g,t.b,t.a];},toHex:function(){var _8=_3.map(["r","g","b"],function(x){var s=this[x].toString(16);return s.length<2?"0"+s:s;},this);return "#"+_8.join("");},toCss:function(_9){var t=this,_a=t.r+", "+t.g+", "+t.b;return (_9?"rgba("+_a+", "+t.a:"rgb("+_a)+")";},toString:function(){return this.toCss(true);}});_5.blendColors=_1.blendColors=function(_b,_c,_d,_e){var t=_e||new _5();_3.forEach(["r","g","b","a"],function(x){t[x]=_b[x]+(_c[x]-_b[x])*_d;if(x!="a"){t[x]=Math.round(t[x]);}});return t.sanitize();};_5.fromRgb=_1.colorFromRgb=function(_f,obj){var m=_f.toLowerCase().match(/^rgba?\(([\s\.,0-9]+)\)/);return m&&_5.fromArray(m[1].split(/\s*,\s*/),obj);};_5.fromHex=_1.colorFromHex=function(_10,obj){var t=obj||new _5(),_11=(_10.length==4)?4:8,_12=(1<<_11)-1;_10=Number("0x"+_10.substr(1));if(isNaN(_10)){return null;}_3.forEach(["b","g","r"],function(x){var c=_10&_12;_10>>=_11;t[x]=_11==4?17*c:c;});t.a=1;return t;};_5.fromArray=_1.colorFromArray=function(a,obj){var t=obj||new _5();t._set(Number(a[0]),Number(a[1]),Number(a[2]),Number(a[3]));if(isNaN(t.a)){t.a=1;}return t.sanitize();};_5.fromString=_1.colorFromString=function(str,obj){var a=_5.named[str];return a&&_5.fromArray(a,obj)||_5.fromRgb(str,obj)||_5.fromHex(str,obj);};return _5;});
\ No newline at end of file diff --git a/lib/dojo/_base/Color.js.uncompressed.js b/lib/dojo/_base/Color.js.uncompressed.js new file mode 100644 index 000000000..ed0918093 --- /dev/null +++ b/lib/dojo/_base/Color.js.uncompressed.js @@ -0,0 +1,220 @@ +define("dojo/_base/Color", ["./kernel", "./lang", "./array", "./config"], function(dojo, lang, ArrayUtil, config){ + + var 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 + // and creates a new Color instance to work from. + // + // example: + // Work with a Color instance: + // | var c = new dojo.Color(); + // | c.setColor([0,0,0]); // black + // | var hex = c.toHex(); // #000000 + // + // example: + // Work with a node's color: + // | var color = dojo.style("someNode", "backgroundColor"); + // | var n = new dojo.Color(color); + // | // adjust the color some + // | n.r *= .5; + // | console.log(n.toString()); // rgb(128, 255, 255); + if(color){ this.setColor(color); } + }; + + /*===== + lang.mixin(dojo.Color,{ + named:{ + // summary: Dictionary list of all CSS named colors, by name. Values are 3-item arrays with corresponding RG and B values. + } + }); + =====*/ + + // FIXME: + // there's got to be a more space-efficient way to encode or discover + // these!! Use hex? + 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], + "transparent": config.transparentColor || [0,0,0,0] + }; + + lang.extend(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 + // and sets this color instance to that value. + // + // example: + // | var c = new dojo.Color(); // no color + // | c.setColor("#ededed"); // greyish + if(lang.isString(color)){ + Color.fromString(color, this); + }else if(lang.isArray(color)){ + Color.fromArray(color, this); + }else{ + this._set(color.r, color.g, color.b, color.a); + if(!(color instanceof Color)){ this.sanitize(); } + } + return this; // dojo.Color + }, + sanitize: function(){ + // summary: + // Ensures the object has correct attributes + // description: + // the default implementation does nothing, include dojo.colors to + // augment it with real checks + return this; // dojo.Color + }, + toRgb: function(){ + // summary: + // Returns 3 component array of rgb values + // example: + // | var c = new dojo.Color("#000000"); + // | console.log(c.toRgb()); // [0,0,0] + var t = this; + return [t.r, t.g, t.b]; // Array + }, + toRgba: function(){ + // summary: + // Returns a 4 component array of rgba values from the color + // represented by this object. + var t = this; + return [t.r, t.g, t.b, t.a]; // Array + }, + toHex: function(){ + // summary: + // Returns a CSS color string in hexadecimal representation + // example: + // | console.log(new dojo.Color([0,0,0]).toHex()); // #000000 + var arr = ArrayUtil.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 + // example: + // | var c = new dojo.Color("#FFF").toCss(); + // | console.log(c); // rgb('255','255','255') + 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 + } + }); + + Color.blendColors = 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 t = obj || new Color(); + ArrayUtil.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 + }; + + Color.fromRgb = dojo.colorFromRgb = function(/*String*/ color, /*dojo.Color?*/ obj){ + // summary: + // Returns a `dojo.Color` instance from a string of the form + // "rgb(...)" or "rgba(...)". Optionally accepts a `dojo.Color` + // object to update with the parsed value and return instead of + // creating a new object. + // returns: + // A dojo.Color object. If obj is passed, it will be the return value. + var m = color.toLowerCase().match(/^rgba?\(([\s\.,0-9]+)\)/); + return m && Color.fromArray(m[1].split(/\s*,\s*/), obj); // dojo.Color + }; + + Color.fromHex = 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. Optionally accepts a + // `dojo.Color` object to update with the parsed value. + // + // returns: + // A dojo.Color object. If obj is passed, it will be the return value. + // + // example: + // | var thing = dojo.colorFromHex("#ededed"); // grey, longhand + // + // example: + // | var thing = dojo.colorFromHex("#000"); // black, shorthand + var t = obj || new Color(), + bits = (color.length == 4) ? 4 : 8, + mask = (1 << bits) - 1; + color = Number("0x" + color.substr(1)); + if(isNaN(color)){ + return null; // dojo.Color + } + ArrayUtil.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 + }; + + Color.fromArray = dojo.colorFromArray = function(/*Array*/ a, /*dojo.Color?*/ obj){ + // summary: + // Builds a `dojo.Color` from a 3 or 4 element array, mapping each + // element in sequence to the rgb(a) values of the color. + // example: + // | var myColor = dojo.colorFromArray([237,237,237,0.5]); // grey, 50% alpha + // returns: + // A dojo.Color object. If obj is passed, it will be the return value. + var t = obj || new 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 + }; + + Color.fromString = dojo.colorFromString = function(/*String*/ str, /*dojo.Color?*/ obj){ + // summary: + // Parses `str` for a color value. Accepts hex, rgb, and rgba + // style color values. + // 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 = Color.named[str]; + return a && Color.fromArray(a, obj) || Color.fromRgb(str, obj) || Color.fromHex(str, obj); // dojo.Color + }; + + return Color; +}); diff --git a/lib/dojo/_base/Deferred.js b/lib/dojo/_base/Deferred.js index c5992c966..13609f687 100644 --- a/lib/dojo/_base/Deferred.js +++ b/lib/dojo/_base/Deferred.js @@ -4,343 +4,5 @@ see: http://dojotoolkit.org/license for details */ - -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.require("dojo._base.lang"); - - -(function(){ - var mutator = function(){}; - var freeze = Object.freeze || function(){}; - // A deferred provides an API for creating and resolving a promise. - dojo.Deferred = function(/*Function?*/canceller){ - // summary: - // Deferreds provide a generic means for encapsulating an asynchronous - // operation and notifying users of the completion and result of the operation. - // description: - // The dojo.Deferred API is based on the concept of promises that provide a - // generic interface into the eventual completion of an asynchronous action. - // The motivation for promises fundamentally is about creating a - // separation of concerns that allows one to achieve the same type of - // call patterns and logical data flow in asynchronous code as can be - // achieved in synchronous code. Promises allows one - // to be able to call a function purely with arguments needed for - // execution, without conflating the call with concerns of whether it is - // sync or async. One shouldn't need to alter a call's arguments if the - // implementation switches from sync to async (or vice versa). By having - // async functions return promises, the concerns of making the call are - // separated from the concerns of asynchronous interaction (which are - // handled by the promise). - // - // The dojo.Deferred is a type of promise that provides methods for fulfilling the - // promise with a successful result or an error. The most important method for - // working with Dojo's promises is the then() method, which follows the - // CommonJS proposed promise API. An example of using a Dojo promise: - // - // | var resultingPromise = someAsyncOperation.then(function(result){ - // | ... handle result ... - // | }, - // | function(error){ - // | ... handle error ... - // | }); - // - // The .then() call returns a new promise that represents the result of the - // execution of the callback. The callbacks will never affect the original promises value. - // - // The dojo.Deferred instances also provide the following functions for backwards compatibility: - // - // * addCallback(handler) - // * addErrback(handler) - // * callback(result) - // * errback(result) - // - // Callbacks are allowed to return promises 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).then(null, 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 synchronous 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).then(null, function(){ - // | promptUserToRecover(); - // | }); - // - // Note that the caller doesn't have to change his code at all to - // handle the asynchronous case. - var result, finished, isError, head, nextListener; - var promise = (this.promise = {}); - - function complete(value){ - if(finished){ - throw new Error("This deferred has already been resolved"); - } - result = value; - finished = true; - notify(); - } - function notify(){ - var mutated; - while(!mutated && nextListener){ - var listener = nextListener; - nextListener = nextListener.next; - if((mutated = (listener.progress == mutator))){ // assignment and check - finished = false; - } - var func = (isError ? listener.error : listener.resolved); - if (func) { - try { - var newResult = func(result); - if (newResult && typeof newResult.then === "function") { - newResult.then(dojo.hitch(listener.deferred, "resolve"), dojo.hitch(listener.deferred, "reject")); - continue; - } - var unchanged = mutated && newResult === undefined; - if(mutated && !unchanged){ - isError = newResult instanceof Error; - } - listener.deferred[unchanged && isError ? "reject" : "resolve"](unchanged ? result : newResult); - } - catch (e) { - listener.deferred.reject(e); - } - }else { - if(isError){ - listener.deferred.reject(result); - }else{ - listener.deferred.resolve(result); - } - } - } - } - // calling resolve will resolve the promise - this.resolve = this.callback = function(value){ - // summary: - // Fulfills the Deferred instance successfully with the provide value - this.fired = 0; - this.results = [value, null]; - complete(value); - }; - - - // calling error will indicate that the promise failed - this.reject = this.errback = function(error){ - // summary: - // Fulfills the Deferred instance as an error with the provided error - isError = true; - this.fired = 1; - complete(error); - this.results = [null, error]; - if(!error || error.log !== false){ - (dojo.config.deferredOnError || function(x){ console.error(x); })(error); - } - }; - // call progress to provide updates on the progress on the completion of the promise - this.progress = function(update){ - // summary - // Send progress events to all listeners - var listener = nextListener; - while(listener){ - var progress = listener.progress; - progress && progress(update); - listener = listener.next; - } - }; - this.addCallbacks = function(/*Function?*/callback, /*Function?*/errback){ - this.then(callback, errback, mutator); - return this; - }; - // provide the implementation of the promise - this.then = promise.then = function(/*Function?*/resolvedCallback, /*Function?*/errorCallback, /*Function?*/progressCallback){ - // summary: - // Adds a fulfilledHandler, errorHandler, and progressHandler to be called for - // completion of a promise. The fulfilledHandler is called when the promise - // is fulfilled. The errorHandler is called when a promise fails. The - // progressHandler is called for progress events. All arguments are optional - // and non-function values are ignored. The progressHandler is not only an - // optional argument, but progress events are purely optional. Promise - // providers are not required to ever create progress events. - // - // This function will return a new promise that is fulfilled when the given - // fulfilledHandler or errorHandler callback is finished. This allows promise - // operations to be chained together. The value returned from the callback - // handler is the fulfillment value for the returned promise. If the callback - // throws an error, the returned promise will be moved to failed state. - // - // example: - // An example of using a CommonJS compliant promise: - // | asyncComputeTheAnswerToEverything(). - // | then(addTwo). - // | then(printResult, onError); - // | >44 - // - var returnDeferred = progressCallback == mutator ? this : new dojo.Deferred(promise.cancel); - var listener = { - resolved: resolvedCallback, - error: errorCallback, - progress: progressCallback, - deferred: returnDeferred - }; - if(nextListener){ - head = head.next = listener; - } - else{ - nextListener = head = listener; - } - if(finished){ - notify(); - } - return returnDeferred.promise; - }; - var deferred = this; - this.cancel = promise.cancel = function () { - // summary: - // Cancels the asynchronous operation - if(!finished){ - var error = canceller && canceller(deferred); - if(!finished){ - if (!(error instanceof Error)) { - error = new Error(error); - } - error.log = false; - deferred.reject(error); - } - } - }; - freeze(promise); - }; - dojo.extend(dojo.Deferred, { - addCallback: function (/*Function*/callback) { - return this.addCallbacks(dojo.hitch.apply(dojo, arguments)); - }, - - addErrback: function (/*Function*/errback) { - return this.addCallbacks(null, dojo.hitch.apply(dojo, arguments)); - }, - - addBoth: function (/*Function*/callback) { - var enclosed = dojo.hitch.apply(dojo, arguments); - return this.addCallbacks(enclosed, enclosed); - }, - fired: -1 - }); -})(); -dojo.when = function(promiseOrValue, /*Function?*/callback, /*Function?*/errback, /*Function?*/progressHandler){ - // summary: - // This provides normalization between normal synchronous values and - // asynchronous promises, so you can interact with them in a common way - // example: - // | function printFirstAndList(items){ - // | dojo.when(findFirst(items), console.log); - // | dojo.when(findLast(items), console.log); - // | } - // | function findFirst(items){ - // | return dojo.when(items, function(items){ - // | return items[0]; - // | }); - // | } - // | function findLast(items){ - // | return dojo.when(items, function(items){ - // | return items[items.length]; - // | }); - // | } - // And now all three of his functions can be used sync or async. - // | printFirstAndLast([1,2,3,4]) will work just as well as - // | printFirstAndLast(dojo.xhrGet(...)); - - if(promiseOrValue && typeof promiseOrValue.then === "function"){ - return promiseOrValue.then(callback, errback, progressHandler); - } - return callback(promiseOrValue); -}; - -} +//>>built +define("dojo/_base/Deferred",["./kernel","./lang"],function(_1,_2){var _3=function(){};var _4=Object.freeze||function(){};_1.Deferred=function(_5){var _6,_7,_8,_9,_a;var _b=(this.promise={});function _c(_d){if(_7){throw new Error("This deferred has already been resolved");}_6=_d;_7=true;_e();};function _e(){var _f;while(!_f&&_a){var _10=_a;_a=_a.next;if((_f=(_10.progress==_3))){_7=false;}var _11=(_8?_10.error:_10.resolved);if(_11){try{var _12=_11(_6);if(_12&&typeof _12.then==="function"){_12.then(_2.hitch(_10.deferred,"resolve"),_2.hitch(_10.deferred,"reject"),_2.hitch(_10.deferred,"progress"));continue;}var _13=_f&&_12===undefined;if(_f&&!_13){_8=_12 instanceof Error;}_10.deferred[_13&&_8?"reject":"resolve"](_13?_6:_12);}catch(e){_10.deferred.reject(e);}}else{if(_8){_10.deferred.reject(_6);}else{_10.deferred.resolve(_6);}}}};this.resolve=this.callback=function(_14){this.fired=0;this.results=[_14,null];_c(_14);};this.reject=this.errback=function(_15){_8=true;this.fired=1;_c(_15);this.results=[null,_15];if(!_15||_15.log!==false){(_1.config.deferredOnError||function(x){console.error(x);})(_15);}};this.progress=function(_16){var _17=_a;while(_17){var _18=_17.progress;_18&&_18(_16);_17=_17.next;}};this.addCallbacks=function(_19,_1a){this.then(_19,_1a,_3);return this;};_b.then=this.then=function(_1b,_1c,_1d){var _1e=_1d==_3?this:new _1.Deferred(_b.cancel);var _1f={resolved:_1b,error:_1c,progress:_1d,deferred:_1e};if(_a){_9=_9.next=_1f;}else{_a=_9=_1f;}if(_7){_e();}return _1e.promise;};var _20=this;_b.cancel=this.cancel=function(){if(!_7){var _21=_5&&_5(_20);if(!_7){if(!(_21 instanceof Error)){_21=new Error(_21);}_21.log=false;_20.reject(_21);}}};_4(_b);};_2.extend(_1.Deferred,{addCallback:function(_22){return this.addCallbacks(_2.hitch.apply(_1,arguments));},addErrback:function(_23){return this.addCallbacks(null,_2.hitch.apply(_1,arguments));},addBoth:function(_24){var _25=_2.hitch.apply(_1,arguments);return this.addCallbacks(_25,_25);},fired:-1});_1.Deferred.when=_1.when=function(_26,_27,_28,_29){if(_26&&typeof _26.then==="function"){return _26.then(_27,_28,_29);}return _27?_27(_26):_26;};return _1.Deferred;});
\ No newline at end of file diff --git a/lib/dojo/_base/Deferred.js.uncompressed.js b/lib/dojo/_base/Deferred.js.uncompressed.js new file mode 100644 index 000000000..6dc39e96c --- /dev/null +++ b/lib/dojo/_base/Deferred.js.uncompressed.js @@ -0,0 +1,366 @@ +define("dojo/_base/Deferred", ["./kernel", "./lang"], function(dojo, lang){ + // module: + // dojo/_base/Deferred + // summary: + // This module defines dojo.Deferred. + + var mutator = function(){}; + var freeze = Object.freeze || function(){}; + // A deferred provides an API for creating and resolving a promise. + dojo.Deferred = function(/*Function?*/ canceller){ + // summary: + // Deferreds provide a generic means for encapsulating an asynchronous + // operation and notifying users of the completion and result of the operation. + // description: + // The dojo.Deferred API is based on the concept of promises that provide a + // generic interface into the eventual completion of an asynchronous action. + // The motivation for promises fundamentally is about creating a + // separation of concerns that allows one to achieve the same type of + // call patterns and logical data flow in asynchronous code as can be + // achieved in synchronous code. Promises allows one + // to be able to call a function purely with arguments needed for + // execution, without conflating the call with concerns of whether it is + // sync or async. One shouldn't need to alter a call's arguments if the + // implementation switches from sync to async (or vice versa). By having + // async functions return promises, the concerns of making the call are + // separated from the concerns of asynchronous interaction (which are + // handled by the promise). + // + // The dojo.Deferred is a type of promise that provides methods for fulfilling the + // promise with a successful result or an error. The most important method for + // working with Dojo's promises is the then() method, which follows the + // CommonJS proposed promise API. An example of using a Dojo promise: + // + // | var resultingPromise = someAsyncOperation.then(function(result){ + // | ... handle result ... + // | }, + // | function(error){ + // | ... handle error ... + // | }); + // + // The .then() call returns a new promise that represents the result of the + // execution of the callback. The callbacks will never affect the original promises value. + // + // The dojo.Deferred instances also provide the following functions for backwards compatibility: + // + // * addCallback(handler) + // * addErrback(handler) + // * callback(result) + // * errback(result) + // + // Callbacks are allowed to return promises 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).then(null, 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 synchronous 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).then(null, function(){ + // | promptUserToRecover(); + // | }); + // + // Note that the caller doesn't have to change his code at all to + // handle the asynchronous case. + + var result, finished, isError, head, nextListener; + var promise = (this.promise = {}); + + function complete(value){ + if(finished){ + throw new Error("This deferred has already been resolved"); + } + result = value; + finished = true; + notify(); + } + function notify(){ + var mutated; + while(!mutated && nextListener){ + var listener = nextListener; + nextListener = nextListener.next; + if((mutated = (listener.progress == mutator))){ // assignment and check + finished = false; + } + var func = (isError ? listener.error : listener.resolved); + if(func){ + try{ + var newResult = func(result); + if (newResult && typeof newResult.then === "function"){ + newResult.then(lang.hitch(listener.deferred, "resolve"), lang.hitch(listener.deferred, "reject"), lang.hitch(listener.deferred, "progress")); + continue; + } + var unchanged = mutated && newResult === undefined; + if(mutated && !unchanged){ + isError = newResult instanceof Error; + } + listener.deferred[unchanged && isError ? "reject" : "resolve"](unchanged ? result : newResult); + }catch(e){ + listener.deferred.reject(e); + } + }else{ + if(isError){ + listener.deferred.reject(result); + }else{ + listener.deferred.resolve(result); + } + } + } + } + // calling resolve will resolve the promise + this.resolve = this.callback = function(value){ + // summary: + // Fulfills the Deferred instance successfully with the provide value + this.fired = 0; + this.results = [value, null]; + complete(value); + }; + + + // calling error will indicate that the promise failed + this.reject = this.errback = function(error){ + // summary: + // Fulfills the Deferred instance as an error with the provided error + isError = true; + this.fired = 1; + complete(error); + this.results = [null, error]; + if(!error || error.log !== false){ + (dojo.config.deferredOnError || function(x){ console.error(x); })(error); + } + }; + // call progress to provide updates on the progress on the completion of the promise + this.progress = function(update){ + // summary: + // Send progress events to all listeners + var listener = nextListener; + while(listener){ + var progress = listener.progress; + progress && progress(update); + listener = listener.next; + } + }; + this.addCallbacks = function(callback, errback){ + // summary: + // Adds callback and error callback for this deferred instance. + // callback: Function? + // The callback attached to this deferred object. + // errback: Function? + // The error callback attached to this deferred object. + // returns: + // Returns this deferred object. + this.then(callback, errback, mutator); + return this; // dojo.Deferred + }; + // provide the implementation of the promise + promise.then = this.then = function(/*Function?*/resolvedCallback, /*Function?*/errorCallback, /*Function?*/progressCallback){ + // summary: + // Adds a fulfilledHandler, errorHandler, and progressHandler to be called for + // completion of a promise. The fulfilledHandler is called when the promise + // is fulfilled. The errorHandler is called when a promise fails. The + // progressHandler is called for progress events. All arguments are optional + // and non-function values are ignored. The progressHandler is not only an + // optional argument, but progress events are purely optional. Promise + // providers are not required to ever create progress events. + // + // This function will return a new promise that is fulfilled when the given + // fulfilledHandler or errorHandler callback is finished. This allows promise + // operations to be chained together. The value returned from the callback + // handler is the fulfillment value for the returned promise. If the callback + // throws an error, the returned promise will be moved to failed state. + // + // returns: + // Returns a new promise that represents the result of the + // execution of the callback. The callbacks will never affect the original promises value. + // example: + // An example of using a CommonJS compliant promise: + // | asyncComputeTheAnswerToEverything(). + // | then(addTwo). + // | then(printResult, onError); + // | >44 + // + var returnDeferred = progressCallback == mutator ? this : new dojo.Deferred(promise.cancel); + var listener = { + resolved: resolvedCallback, + error: errorCallback, + progress: progressCallback, + deferred: returnDeferred + }; + if(nextListener){ + head = head.next = listener; + } + else{ + nextListener = head = listener; + } + if(finished){ + notify(); + } + return returnDeferred.promise; // Promise + }; + var deferred = this; + promise.cancel = this.cancel = function (){ + // summary: + // Cancels the asynchronous operation + if(!finished){ + var error = canceller && canceller(deferred); + if(!finished){ + if (!(error instanceof Error)){ + error = new Error(error); + } + error.log = false; + deferred.reject(error); + } + } + }; + freeze(promise); + }; + lang.extend(dojo.Deferred, { + addCallback: function (/*Function*/ callback){ + // summary: + // Adds successful callback for this deferred instance. + // returns: + // Returns this deferred object. + return this.addCallbacks(lang.hitch.apply(dojo, arguments)); // dojo.Deferred + }, + + addErrback: function (/*Function*/ errback){ + // summary: + // Adds error callback for this deferred instance. + // returns: + // Returns this deferred object. + return this.addCallbacks(null, lang.hitch.apply(dojo, arguments)); // dojo.Deferred + }, + + addBoth: function (/*Function*/ callback){ + // summary: + // Add handler as both successful callback and error callback for this deferred instance. + // returns: + // Returns this deferred object. + var enclosed = lang.hitch.apply(dojo, arguments); + return this.addCallbacks(enclosed, enclosed); // dojo.Deferred + }, + fired: -1 + }); + + dojo.Deferred.when = dojo.when = function(promiseOrValue, /*Function?*/ callback, /*Function?*/ errback, /*Function?*/ progressHandler){ + // summary: + // This provides normalization between normal synchronous values and + // asynchronous promises, so you can interact with them in a common way + // returns: + // Returns a new promise that represents the result of the execution of callback + // when parameter "promiseOrValue" is promise. + // Returns the execution result of callback when parameter "promiseOrValue" is value. + // example: + // | function printFirstAndLast(items){ + // | dojo.when(findFirst(items), console.log); + // | dojo.when(findLast(items), console.log); + // | } + // | function findFirst(items){ + // | return dojo.when(items, function(items){ + // | return items[0]; + // | }); + // | } + // | function findLast(items){ + // | return dojo.when(items, function(items){ + // | return items[items.length - 1]; + // | }); + // | } + // And now all three of his functions can be used sync or async. + // | printFirstAndLast([1,2,3,4]) will work just as well as + // | printFirstAndLast(dojo.xhrGet(...)); + + if(promiseOrValue && typeof promiseOrValue.then === "function"){ + return promiseOrValue.then(callback, errback, progressHandler); + } + return callback ? callback(promiseOrValue) : promiseOrValue; // Promise + }; + + return dojo.Deferred; +}); diff --git a/lib/dojo/_base/NodeList.js b/lib/dojo/_base/NodeList.js index 8cdc1c0f7..4fa6b48a0 100644 --- a/lib/dojo/_base/NodeList.js +++ b/lib/dojo/_base/NodeList.js @@ -4,1010 +4,5 @@ see: http://dojotoolkit.org/license for details */ - -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"); -dojo.require("dojo._base.lang"); -dojo.require("dojo._base.array"); -dojo.require("dojo._base.connect"); -dojo.require("dojo._base.html"); - - -(function(){ - - var d = dojo; - - var ap = Array.prototype, aps = ap.slice, apc = ap.concat; - - var tnl = function(/*Array*/ a, /*dojo.NodeList?*/ parent, /*Function?*/ NodeListCtor){ - // summary: - // decorate an array to make it look like a `dojo.NodeList`. - // a: - // Array of nodes to decorate. - // parent: - // An optional parent NodeList that generated the current - // list of nodes. Used to call _stash() so the parent NodeList - // can be accessed via end() later. - // NodeListCtor: - // An optional constructor function to use for any - // new NodeList calls. This allows a certain chain of - // NodeList calls to use a different object than dojo.NodeList. - if(!a.sort){ - // make sure it's a real array before we pass it on to be wrapped - a = aps.call(a, 0); - } - var ctor = NodeListCtor || this._NodeListCtor || d._NodeListCtor; - a.constructor = ctor; - dojo._mixin(a, ctor.prototype); - a._NodeListCtor = ctor; - return parent ? a._stash(parent) : a; - }; - - var loopBody = function(f, a, o){ - a = [0].concat(aps.call(a, 0)); - o = o || d.global; - return function(node){ - a[0] = node; - return f.apply(o, a); - }; - }; - - // adapters - - var adaptAsForEach = function(f, o){ - // summary: - // adapts a single node function to be used in the forEach-type - // actions. The initial object is returned from the specialized - // function. - // f: Function - // a function to adapt - // o: Object? - // an optional context for f - return function(){ - this.forEach(loopBody(f, arguments, o)); - return this; // Object - }; - }; - - var adaptAsMap = function(f, o){ - // summary: - // adapts a single node function to be used in the map-type - // actions. The return is a new array of values, as via `dojo.map` - // f: Function - // a function to adapt - // o: Object? - // an optional context for f - return function(){ - return this.map(loopBody(f, arguments, o)); - }; - }; - - var adaptAsFilter = function(f, o){ - // summary: - // adapts a single node function to be used in the filter-type actions - // f: Function - // a function to adapt - // o: Object? - // an optional context for f - return function(){ - return this.filter(loopBody(f, arguments, o)); - }; - }; - - var adaptWithCondition = function(f, g, o){ - // summary: - // adapts a single node function to be used in the map-type - // actions, behaves like forEach() or map() depending on arguments - // f: Function - // a function to adapt - // g: Function - // a condition function, if true runs as map(), otherwise runs as forEach() - // o: Object? - // an optional context for f and g - return function(){ - var a = arguments, body = loopBody(f, a, o); - if(g.call(o || d.global, a)){ - return this.map(body); // self - } - this.forEach(body); - return this; // self - }; - }; - - var magicGuard = function(a){ - // summary: - // the guard function for dojo.attr() and dojo.style() - return a.length == 1 && (typeof a[0] == "string"); // inline'd type check - }; - - var orphan = function(node){ - // summary: - // function to orphan nodes - var p = node.parentNode; - if(p){ - p.removeChild(node); - } - }; - // FIXME: should we move orphan() to dojo.html? - - dojo.NodeList = function(){ - // summary: - // dojo.NodeList is an of Array subclass 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. - // description: - // dojo.NodeList instances provide many utilities that reflect - // core Dojo APIs for Array iteration and manipulation, DOM - // manipulation, and event handling. Instead of needing to dig up - // functions in the dojo.* namespace, NodeLists generally make the - // full power of Dojo available for DOM manipulation tasks in a - // simple, chainable way. - // example: - // create a node list from a node - // | new dojo.NodeList(dojo.byId("foo")); - // example: - // get a NodeList from a CSS query and iterate on it - // | var l = dojo.query(".thinger"); - // | l.forEach(function(node, index, nodeList){ - // | console.log(index, node.innerHTML); - // | }); - // example: - // use native and Dojo-provided array methods to manipulate a - // NodeList without needing to use dojo.* functions explicitly: - // | var l = dojo.query(".thinger"); - // | // since NodeLists are real arrays, they have a length - // | // property that is both readable and writable and - // | // push/pop/shift/unshift methods - // | console.log(l.length); - // | l.push(dojo.create("span")); - // | - // | // dojo's normalized array methods work too: - // | console.log( l.indexOf(dojo.byId("foo")) ); - // | // ...including the special "function as string" shorthand - // | console.log( l.every("item.nodeType == 1") ); - // | - // | // NodeLists can be [..] indexed, or you can use the at() - // | // function to get specific items wrapped in a new NodeList: - // | var node = l[3]; // the 4th element - // | var newList = l.at(1, 3); // the 2nd and 4th elements - // example: - // the style functions you expect are all there too: - // | // style() as a getter... - // | var borders = dojo.query(".thinger").style("border"); - // | // ...and as a setter: - // | dojo.query(".thinger").style("border", "1px solid black"); - // | // class manipulation - // | dojo.query("li:nth-child(even)").addClass("even"); - // | // even getting the coordinates of all the items - // | var coords = dojo.query(".thinger").coords(); - // example: - // DOM manipulation functions from the dojo.* namespace area also - // available: - // | // remove all of the elements in the list from their - // | // parents (akin to "deleting" them from the document) - // | dojo.query(".thinger").orphan(); - // | // place all elements in the list at the front of #foo - // | dojo.query(".thinger").place("foo", "first"); - // example: - // Event handling couldn't be easier. `dojo.connect` is mapped in, - // and shortcut handlers are provided for most DOM events: - // | // like dojo.connect(), but with implicit scope - // | dojo.query("li").connect("onclick", console, "log"); - // | - // | // many common event handlers are already available directly: - // | dojo.query("li").onclick(console, "log"); - // | var toggleHovered = dojo.hitch(dojo, "toggleClass", "hovered"); - // | dojo.query("p") - // | .onmouseenter(toggleHovered) - // | .onmouseleave(toggleHovered); - // example: - // chainability is a key advantage of NodeLists: - // | dojo.query(".thinger") - // | .onclick(function(e){ /* ... */ }) - // | .at(1, 3, 8) // get a subset - // | .style("padding", "5px") - // | .forEach(console.log); - - return tnl(Array.apply(null, arguments)); - }; - - //Allow things that new up a NodeList to use a delegated or alternate NodeList implementation. - d._NodeListCtor = d.NodeList; - - var nl = d.NodeList, nlp = nl.prototype; - - // expose adapters and the wrapper as private functions - - nl._wrap = nlp._wrap = tnl; - nl._adaptAsMap = adaptAsMap; - nl._adaptAsForEach = adaptAsForEach; - nl._adaptAsFilter = adaptAsFilter; - nl._adaptWithCondition = adaptWithCondition; - - // mass assignment - - // add array redirectors - d.forEach(["slice", "splice"], function(name){ - var f = ap[name]; - //Use a copy of the this array via this.slice() to allow .end() to work right in the splice case. - // CANNOT apply ._stash()/end() to splice since it currently modifies - // the existing this array -- it would break backward compatibility if we copy the array before - // the splice so that we can use .end(). So only doing the stash option to this._wrap for slice. - nlp[name] = function(){ return this._wrap(f.apply(this, arguments), name == "slice" ? this : null); }; - }); - // concat should be here but some browsers with native NodeList have problems with it - - // add array.js redirectors - d.forEach(["indexOf", "lastIndexOf", "every", "some"], function(name){ - var f = d[name]; - nlp[name] = function(){ return f.apply(d, [this].concat(aps.call(arguments, 0))); }; - }); - - // add conditional methods - d.forEach(["attr", "style"], function(name){ - nlp[name] = adaptWithCondition(d[name], magicGuard); - }); - - // add forEach actions - d.forEach(["connect", "addClass", "removeClass", "replaceClass", "toggleClass", "empty", "removeAttr"], function(name){ - nlp[name] = adaptAsForEach(d[name]); - }); - - dojo.extend(dojo.NodeList, { - _normalize: function(/*String||Element||Object||NodeList*/content, /*DOMNode?*/refNode){ - // summary: - // normalizes data to an array of items to insert. - // description: - // If content is an object, it can have special properties "template" and - // "parse". If "template" is defined, then the template value is run through - // dojo.string.substitute (if dojo.string.substitute has been dojo.required elsewhere), - // or if templateFunc is a function on the content, that function will be used to - // transform the template into a final string to be used for for passing to dojo._toDom. - // If content.parse is true, then it is remembered for later, for when the content - // nodes are inserted into the DOM. At that point, the nodes will be parsed for widgets - // (if dojo.parser has been dojo.required elsewhere). - - //Wanted to just use a DocumentFragment, but for the array/NodeList - //case that meant using cloneNode, but we may not want that. - //Cloning should only happen if the node operations span - //multiple refNodes. Also, need a real array, not a NodeList from the - //DOM since the node movements could change those NodeLists. - - var parse = content.parse === true ? true : false; - - //Do we have an object that needs to be run through a template? - if(typeof content.template == "string"){ - var templateFunc = content.templateFunc || (dojo.string && dojo.string.substitute); - content = templateFunc ? templateFunc(content.template, content) : content; - } - - var type = (typeof content); - if(type == "string" || type == "number"){ - content = dojo._toDom(content, (refNode && refNode.ownerDocument)); - if(content.nodeType == 11){ - //DocumentFragment. It cannot handle cloneNode calls, so pull out the children. - content = dojo._toArray(content.childNodes); - }else{ - content = [content]; - } - }else if(!dojo.isArrayLike(content)){ - content = [content]; - }else if(!dojo.isArray(content)){ - //To get to this point, content is array-like, but - //not an array, which likely means a DOM NodeList. Convert it now. - content = dojo._toArray(content); - } - - //Pass around the parse info - if(parse){ - content._runParse = true; - } - return content; //Array - }, - - _cloneNode: function(/*DOMNode*/ node){ - // summary: - // private utility to clone a node. Not very interesting in the vanilla - // dojo.NodeList case, but delegates could do interesting things like - // clone event handlers if that is derivable from the node. - return node.cloneNode(true); - }, - - _place: function(/*Array*/ary, /*DOMNode*/refNode, /*String*/position, /*Boolean*/useClone){ - // summary: - // private utility to handle placing an array of nodes relative to another node. - // description: - // Allows for cloning the nodes in the array, and for - // optionally parsing widgets, if ary._runParse is true. - - //Avoid a disallowed operation if trying to do an innerHTML on a non-element node. - if(refNode.nodeType != 1 && position == "only"){ - return; - } - var rNode = refNode, tempNode; - - //Always cycle backwards in case the array is really a - //DOM NodeList and the DOM operations take it out of the live collection. - var length = ary.length; - for(var i = length - 1; i >= 0; i--){ - var node = (useClone ? this._cloneNode(ary[i]) : ary[i]); - - //If need widget parsing, use a temp node, instead of waiting after inserting into - //real DOM because we need to start widget parsing at one node up from current node, - //which could cause some already parsed widgets to be parsed again. - if(ary._runParse && dojo.parser && dojo.parser.parse){ - if(!tempNode){ - tempNode = rNode.ownerDocument.createElement("div"); - } - tempNode.appendChild(node); - dojo.parser.parse(tempNode); - node = tempNode.firstChild; - while(tempNode.firstChild){ - tempNode.removeChild(tempNode.firstChild); - } - } - - if(i == length - 1){ - dojo.place(node, rNode, position); - }else{ - rNode.parentNode.insertBefore(node, rNode); - } - rNode = node; - } - }, - - _stash: function(parent){ - // summary: - // private function to hold to a parent NodeList. end() to return the parent NodeList. - // - // example: - // How to make a `dojo.NodeList` method that only returns the third node in - // the dojo.NodeList but allows access to the original NodeList by using this._stash: - // | dojo.extend(dojo.NodeList, { - // | third: function(){ - // | var newNodeList = dojo.NodeList(this[2]); - // | return newNodeList._stash(this); - // | } - // | }); - // | // then see how _stash applies a sub-list, to be .end()'ed out of - // | dojo.query(".foo") - // | .third() - // | .addClass("thirdFoo") - // | .end() - // | // access to the orig .foo list - // | .removeClass("foo") - // | - // - this._parent = parent; - return this; //dojo.NodeList - }, - - end: function(){ - // summary: - // Ends use of the current `dojo.NodeList` by returning the previous dojo.NodeList - // that generated the current dojo.NodeList. - // description: - // Returns the `dojo.NodeList` that generated the current `dojo.NodeList`. If there - // is no parent dojo.NodeList, an empty dojo.NodeList is returned. - // example: - // | dojo.query("a") - // | .filter(".disabled") - // | // operate on the anchors that only have a disabled class - // | .style("color", "grey") - // | .end() - // | // jump back to the list of anchors - // | .style(...) - // - if(this._parent){ - return this._parent; - }else{ - //Just return empty list. - return new this._NodeListCtor(); - } - }, - - // 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 Mozilla's (slice - // documentation)[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. - return this._wrap(a.slice.apply(this, arguments)); - }, - - 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 Mozilla's (splice - // documentation)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:splice] - // For backwards compatibility, calling .end() on the spliced NodeList - // does not return the original NodeList -- splice alters the NodeList in place. - // 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 - return this._wrap(a.splice.apply(this, arguments)); - }, - - indexOf: function(value, fromIndex){ - // summary: - // see dojo.indexOf(). The primary difference is that the acted-on - // array is implicitly this NodeList - // value: Object: - // The value to search for. - // fromIndex: Integer?: - // The location to start searching from. Optional. Defaults to 0. - // description: - // For more details on the behavior of indexOf, see Mozilla's - // (indexOf - // docs)[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 - // Mozilla's (lastIndexOf - // docs)[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 location to start searching from. Optional. Defaults to 0. - // returns: - // Positive Integer or 0 for a match, -1 of not found. - return d.lastIndexOf(this, value, fromIndex); // Integer - }, - - every: function(callback, thisObject){ - // summary: - // see `dojo.every()` and the (Array.every - // docs)[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 - // callback: Function: the callback - // thisObject: Object?: the context - return d.every(this, callback, thisObject); // Boolean - }, - - some: function(callback, thisObject){ - // summary: - // Takes the same structure of arguments and returns as - // `dojo.some()` with the caveat that the passed array is - // implicitly this NodeList. See `dojo.some()` and Mozilla's - // (Array.some - // documentation)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:some]. - // callback: Function: the callback - // thisObject: Object?: the context - return d.some(this, callback, thisObject); // Boolean - }, - =====*/ - - 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 the (Array.concat - // docs)[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 - - //return this._wrap(apc.apply(this, arguments)); - // the line above won't work for the native NodeList :-( - - // implementation notes: - // 1) Native NodeList is not an array, and cannot be used directly - // in concat() --- the latter doesn't recognize it as an array, and - // does not inline it, but append as a single entity. - // 2) On some browsers (e.g., Safari) the "constructor" property is - // read-only and cannot be changed. So we have to test for both - // native NodeList and dojo.NodeList in this property to recognize - // the node list. - - var t = d.isArray(this) ? this : aps.call(this, 0), - m = d.map(arguments, function(a){ - return a && !d.isArray(a) && - (typeof NodeList != "undefined" && a.constructor === NodeList || a.constructor === this._NodeListCtor) ? - aps.call(a, 0) : a; - }); - return this._wrap(apc.apply(t, m), this); // dojo.NodeList - }, - - 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 - return this._wrap(d.map(this, func, obj), this); // dojo.NodeList - }, - - forEach: function(callback, thisObj){ - // summary: - // see `dojo.forEach()`. The primary difference is that the acted-on - // array is implicitly this NodeList. If you want the option to break out - // of the forEach loop, use every() or some() instead. - d.forEach(this, callback, thisObj); - // non-standard return to allow easier chaining - return this; // dojo.NodeList - }, - - /*===== - coords: function(){ - // summary: - // Returns the box objects of all elements in a node list as - // an Array (*not* a NodeList). Acts like `dojo.coords`, though assumes - // the node passed is each node in this list. - - return d.map(this, d.coords); // Array - }, - - position: function(){ - // summary: - // Returns border-box objects (x/y/w/h) of all elements in a node list - // as an Array (*not* a NodeList). Acts like `dojo.position`, though - // assumes the node passed is each node in this list. - - return d.map(this, d.position); // Array - }, - - attr: function(property, value){ - // summary: - // gets or sets the DOM attribute for every element in the - // NodeList. See also `dojo.attr` - // 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 - // example: - // Make all nodes with a particular class focusable: - // | dojo.query(".focusable").attr("tabIndex", -1); - // example: - // Disable a group of buttons: - // | dojo.query("button.group").attr("disabled", true); - // example: - // innerHTML can be assigned or retrieved as well: - // | // get the innerHTML (as an array) for each list item - // | var ih = dojo.query("li.replaceable").attr("innerHTML"); - 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|Array - // A String class name to add, or several space-separated class names, - // or an array of class names. - return; // dojo.NodeList - }, - - removeClass: function(className){ - // summary: - // removes the specified class from every node in the list - // className: String|Array? - // An optional String class name to remove, or several space-separated - // class names, or an array of class names. If omitted, all class names - // will be deleted. - // 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){ - // | console.log("clicked!"); - // | }); - // example: - // attach foo.bar() to every odd div's onmouseover - // | dojo.query("div:nth-child(odd)").connect("onmouseover", foo, "bar"); - }, - - empty: function(){ - // summary: - // clears all content from each node in the list. Effectively - // equivalent to removing all child nodes from every item in - // the list. - return this.forEach("item.innerHTML='';"); // dojo.NodeList - // FIXME: should we be checking for and/or disposing of widgets below these nodes? - }, - =====*/ - - // useful html methods - coords: adaptAsMap(d.coords), - position: adaptAsMap(d.position), - - // FIXME: connectPublisher()? connectRunOnce()? - - /* - destroy: function(){ - // summary: - // destroys every item in the list. - this.forEach(d.destroy); - // FIXME: should we be checking for and/or disposing of widgets below these nodes? - }, - */ - - 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. See: `dojo.place` - // 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" (default) - // | "first" - // | "before" - // | "after" - // | "only" - // | "replace" - // or an offset in the childNodes property - var item = d.query(queryOrNode)[0]; - return this.forEach(function(node){ d.place(node, item, position); }); // dojo.NodeList - }, - - orphan: function(/*String?*/ filter){ - // summary: - // removes elements in this list that match the filter - // from their parents and returns them as a new NodeList. - // filter: - // CSS selector like ".foo" or "div > span" - // returns: - // `dojo.NodeList` containing the orphaned elements - return (filter ? d._filterQueryResult(this, filter) : this).forEach(orphan); // dojo.NodeList - }, - - 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" (default) - // | "first" - // | "before" - // | "after" - // | "only" - // | "replace" - // or an offset in the childNodes property - return d.query(queryOrListOrNode).place(this[0], position)._stash(this); // dojo.NodeList - }, - - // FIXME: do we need this? - query: function(/*String*/ queryStr){ - // summary: - // Returns a new list whose members match the passed query, - // assuming elements of the current NodeList as the root for - // each search. - // example: - // assume a DOM created by this markup: - // | <div id="foo"> - // | <p> - // | bacon is tasty, <span>dontcha think?</span> - // | </p> - // | </div> - // | <div id="bar"> - // | <p>great comedians may not be funny <span>in person</span></p> - // | </div> - // If we are presented with the following definition for a NodeList: - // | var l = new dojo.NodeList(dojo.byId("foo"), dojo.byId("bar")); - // it's possible to find all span elements under paragraphs - // contained by these elements with this sub-query: - // | var spans = l.query("p span"); - - // FIXME: probably slow - if(!queryStr){ return this; } - var ret = this.map(function(node){ - // FIXME: why would we ever get undefined here? - return d.query(queryStr, node).filter(function(subNode){ return subNode !== undefined; }); - }); - return this._wrap(apc.apply([], ret), this); // dojo.NodeList - }, - - filter: function(/*String|Function*/ filter){ - // summary: - // "masks" the built-in javascript filter() method (supported - // in Dojo via `dojo.filter`) to support passing a simple - // string filter in addition to supporting filtering function - // objects. - // filter: - // If a string, a CSS rule like ".thinger" or "div > span". - // example: - // "regular" JS filter syntax as exposed in dojo.filter: - // | dojo.query("*").filter(function(item){ - // | // highlight every paragraph - // | return (item.nodeName == "p"); - // | }).style("backgroundColor", "yellow"); - // example: - // the same filtering using a CSS selector - // | dojo.query("*").filter("p").styles("backgroundColor", "yellow"); - - var a = arguments, items = this, start = 0; - if(typeof filter == "string"){ // inline'd type check - items = d._filterQueryResult(this, a[0]); - if(a.length == 1){ - // if we only got a string query, pass back the filtered results - return items._stash(this); // dojo.NodeList - } - // if we got a callback, run it over the filtered items - start = 1; - } - return this._wrap(d.filter(items, a[start], a[start + 1]), this); // 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||DomNode||Object||dojo.NodeList*/ content, /*String||Integer?*/ position){ - // summary: - // add a node, NodeList 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: - // DOM node, HTML in string format, a NodeList or an Object. If a DOM node or - // NodeList, the content will be cloned if the current NodeList has more than one - // element. Only the DOM nodes are cloned, no event handlers. If it is an Object, - // it should be an object with at "template" String property that has the HTML string - // to insert. If dojo.string has already been dojo.required, then dojo.string.substitute - // will be used on the "template" to generate the final HTML string. Other allowed - // properties on the object are: "parse" if the HTML - // string should be parsed for widgets (dojo.require("dojo.parser") to get that - // option to work), and "templateFunc" if a template function besides dojo.string.substitute - // should be used to transform the "template". - // position: - // can be one of: - // | "last"||"end" (default) - // | "first||"start" - // | "before" - // | "after" - // | "replace" (replaces nodes in this NodeList with new content) - // | "only" (removes other children of the nodes so new content is the only child) - // or an offset in the childNodes property - // example: - // appends content to the end if the position is omitted - // | 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"); - // example: - // add a clone of a DOM node to the end of every element in - // the list, removing it from its existing parent. - // | dojo.query(".note").addContent(dojo.byId("foo")); - // example: - // Append nodes from a templatized string. - // dojo.require("dojo.string"); - // dojo.query(".note").addContent({ - // template: '<b>${id}: </b><span>${name}</span>', - // id: "user332", - // name: "Mr. Anderson" - // }); - // example: - // Append nodes from a templatized string that also has widgets parsed. - // dojo.require("dojo.string"); - // dojo.require("dojo.parser"); - // var notes = dojo.query(".note").addContent({ - // template: '<button dojoType="dijit.form.Button">${text}</button>', - // parse: true, - // text: "Send" - // }); - content = this._normalize(content, this[0]); - for(var i = 0, node; (node = this[i]); i++){ - this._place(content, node, position, i > 0); - } - return this; //dojo.NodeList - }, - - 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. - // example: - // Grabs all buttons in the page and converts them to diji.form.Buttons. - // | var buttons = dojo.query("button").instantiate("dijit.form.Button", {showLabel: true}); - var c = d.isFunction(declaredClass) ? declaredClass : d.getObject(declaredClass); - properties = properties || {}; - return this.forEach(function(node){ - new c(properties, node); - }); // 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. A negative index will start at the end of the - // list and go backwards. - // - // example: - // Shorten the list to the first, second, and third elements - // | dojo.query("a").at(0, 1, 2).forEach(fn); - // - // example: - // Retrieve the first and last elements of a unordered list: - // | dojo.query("ul > li").at(0, -1).forEach(cb); - // - // example: - // Do something for the first element only, but end() out back to - // the original list and continue chaining: - // | dojo.query("a").at(0).onclick(fn).end().forEach(function(n){ - // | console.log(n); // all anchors on the page. - // | }) - // - // returns: - // dojo.NodeList - var t = new this._NodeListCtor(); - d.forEach(arguments, function(i){ - if(i < 0){ i = this.length + i } - if(this[i]){ t.push(this[i]); } - }, this); - return t._stash(this); // dojo.NodeList - } - - }); - - nl.events = [ - // summary: - // list of all DOM events used in NodeList - "blur", "focus", "change", "click", "error", "keydown", "keypress", - "keyup", "load", "mousedown", "mouseenter", "mouseleave", "mousemove", - "mouseout", "mouseover", "mouseup", "submit" - ]; - - // FIXME: pseudo-doc the above automatically generated on-event functions - - // syntactic sugar for DOM events - d.forEach(nl.events, function(evt){ - var _oe = "on" + evt; - nlp[_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 - - console.log(n, evt, _oe); - - // 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){ console.log(e); } - try{ n[_oe](_e); }catch(e){ console.log(e); } - }) - ); - */ - } - ); - -})(); - -} +//>>built +define("dojo/_base/NodeList",["./kernel","../query","./array","./html","../NodeList-dom"],function(_1,_2,_3){var _4=_2.NodeList;var _5=_4.prototype;_5.connect=_4._adaptAsForEach(function(){return _1.connect.apply(this,arguments);});_5.coords=_4._adaptAsMap(_1.coords);_4.events=["blur","focus","change","click","error","keydown","keypress","keyup","load","mousedown","mouseenter","mouseleave","mousemove","mouseout","mouseover","mouseup","submit"];_3.forEach(_4.events,function(_6){var _7="on"+_6;_5[_7]=function(a,b){return this.connect(_7,a,b);};});_1.NodeList=_4;return _1.NodeList;});
\ No newline at end of file diff --git a/lib/dojo/_base/NodeList.js.uncompressed.js b/lib/dojo/_base/NodeList.js.uncompressed.js new file mode 100644 index 000000000..e723fa801 --- /dev/null +++ b/lib/dojo/_base/NodeList.js.uncompressed.js @@ -0,0 +1,100 @@ +define("dojo/_base/NodeList", ["./kernel", "../query", "./array", "./html", "../NodeList-dom"], function(dojo, query, array){ + // module: + // dojo/_base/NodeList + // summary: + // This module defines dojo.NodeList. + +var NodeList = query.NodeList; + + /*===== + dojo.extend(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){ + // | console.log("clicked!"); + // | }); + // example: + // attach foo.bar() to every odd div's onmouseover + // | dojo.query("div:nth-child(odd)").connect("onmouseover", foo, "bar"); + }, + coords: function(){ + // summary: + // Deprecated: Use position() for border-box x/y/w/h + // or marginBox() for margin-box w/h/l/t. + // Returns the box objects of all elements in a node list as + // an Array (*not* a NodeList). Acts like `dojo.coords`, though assumes + // the node passed is each node in this list. + + return dojo.map(this, dojo.coords); // Array + } + }); + + var NodeList = dojo.NodeList; + =====*/ + var nlp = NodeList.prototype; + + // don't bind early to dojo.connect since we no longer explicitly depend on it + nlp.connect = NodeList._adaptAsForEach(function(){ + return dojo.connect.apply(this, arguments); + }); + nlp.coords = NodeList._adaptAsMap(dojo.coords); + + NodeList.events = [ + // summary: + // list of all DOM events used in NodeList + "blur", "focus", "change", "click", "error", "keydown", "keypress", + "keyup", "load", "mousedown", "mouseenter", "mouseleave", "mousemove", + "mouseout", "mouseover", "mouseup", "submit" + ]; + + // FIXME: pseudo-doc the above automatically generated on-event functions + + // syntactic sugar for DOM events + array.forEach(NodeList.events, function(evt){ + var _oe = "on" + evt; + nlp[_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 + + console.log(n, evt, _oe); + + // 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){ console.log(e); } + try{ n[_oe](_e); }catch(e){ console.log(e); } + }) + ); + */ + } + ); + + dojo.NodeList = NodeList; + return dojo.NodeList; +}); diff --git a/lib/dojo/_base/_loader/bootstrap.js b/lib/dojo/_base/_loader/bootstrap.js deleted file mode 100644 index a1f99276a..000000000 --- a/lib/dojo/_base/_loader/bootstrap.js +++ /dev/null @@ -1,505 +0,0 @@ -/* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. - Available via Academic Free License >= 2.1 OR the modified BSD license. - see: http://dojotoolkit.org/license for details -*/ - - -/*===== -// note: -// 'djConfig' does not exist under 'dojo.*' so that it can be set before the -// 'dojo' variable exists. -// note: -// Setting any of these variables *after* the library has loaded does -// nothing at all. - -djConfig = { - // summary: - // Application code can set the global 'djConfig' prior to loading - // the library to override certain global settings for how dojo works. - // - // isDebug: Boolean - // Defaults to `false`. If set to `true`, ensures that Dojo provides - // extended debugging feedback via Firebug. If Firebug is not available - // on your platform, setting `isDebug` to `true` will force Dojo to - // pull in (and display) the version of Firebug Lite which is - // integrated into the Dojo distribution, thereby always providing a - // debugging/logging console when `isDebug` is enabled. Note that - // Firebug's `console.*` methods are ALWAYS defined by Dojo. If - // `isDebug` is false and you are on a platform without Firebug, these - // methods will be defined as no-ops. - isDebug: false, - // debugAtAllCosts: Boolean - // Defaults to `false`. If set to `true`, this triggers an alternate - // mode of the package system in which dependencies are detected and - // only then are resources evaluated in dependency order via - // `<script>` tag inclusion. This may double-request resources and - // cause problems with scripts which expect `dojo.require()` to - // preform synchronously. `debugAtAllCosts` can be an invaluable - // debugging aid, but when using it, ensure that all code which - // depends on Dojo modules is wrapped in `dojo.addOnLoad()` handlers. - // Due to the somewhat unpredictable side-effects of using - // `debugAtAllCosts`, it is strongly recommended that you enable this - // flag as a last resort. `debugAtAllCosts` has no effect when loading - // resources across domains. For usage information, see the - // [Dojo Book](http://dojotoolkit.org/book/book-dojo/part-4-meta-dojo-making-your-dojo-code-run-faster-and-better/debugging-facilities/deb) - debugAtAllCosts: false, - // locale: String - // The locale to assume for loading localized resources in this page, - // specified according to [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt). - // Must be specified entirely in lowercase, e.g. `en-us` and `zh-cn`. - // See the documentation for `dojo.i18n` and `dojo.requireLocalization` - // for details on loading localized resources. If no locale is specified, - // Dojo assumes the locale of the user agent, according to `navigator.userLanguage` - // or `navigator.language` properties. - locale: undefined, - // extraLocale: Array - // No default value. Specifies additional locales whose - // resources should also be loaded alongside the default locale when - // calls to `dojo.requireLocalization()` are processed. - extraLocale: undefined, - // baseUrl: String - // The directory in which `dojo.js` is located. Under normal - // conditions, Dojo auto-detects the correct location from which it - // was loaded. You may need to manually configure `baseUrl` in cases - // where you have renamed `dojo.js` or in which `<base>` tags confuse - // some browsers (e.g. IE 6). The variable `dojo.baseUrl` is assigned - // either the value of `djConfig.baseUrl` if one is provided or the - // auto-detected root if not. Other modules are located relative to - // this path. The path should end in a slash. - baseUrl: undefined, - // modulePaths: Object - // A map of module names to paths relative to `dojo.baseUrl`. The - // key/value pairs correspond directly to the arguments which - // `dojo.registerModulePath` accepts. Specifiying - // `djConfig.modulePaths = { "foo": "../../bar" }` is the equivalent - // of calling `dojo.registerModulePath("foo", "../../bar");`. Multiple - // modules may be configured via `djConfig.modulePaths`. - modulePaths: {}, - // afterOnLoad: Boolean - // Indicates Dojo was added to the page after the page load. In this case - // Dojo will not wait for the page DOMContentLoad/load events and fire - // its dojo.addOnLoad callbacks after making sure all outstanding - // dojo.required modules have loaded. Only works with a built dojo.js, - // it does not work the dojo.js directly from source control. - afterOnLoad: false, - // addOnLoad: Function or Array - // Adds a callback via dojo.addOnLoad. Useful when Dojo is added after - // the page loads and djConfig.afterOnLoad is true. Supports the same - // arguments as dojo.addOnLoad. When using a function reference, use - // `djConfig.addOnLoad = function(){};`. For object with function name use - // `djConfig.addOnLoad = [myObject, "functionName"];` and for object with - // function reference use - // `djConfig.addOnLoad = [myObject, function(){}];` - addOnLoad: null, - // require: Array - // An array of module names to be loaded immediately after dojo.js has been included - // in a page. - require: [], - // defaultDuration: Array - // Default duration, in milliseconds, for wipe and fade animations within dijits. - // Assigned to dijit.defaultDuration. - defaultDuration: 200, - // dojoBlankHtmlUrl: String - // Used by some modules to configure an empty iframe. Used by dojo.io.iframe and - // dojo.back, and dijit popup support in IE where an iframe is needed to make sure native - // controls do not bleed through the popups. Normally this configuration variable - // does not need to be set, except when using cross-domain/CDN Dojo builds. - // Save dojo/resources/blank.html to your domain and set `djConfig.dojoBlankHtmlUrl` - // to the path on your domain your copy of blank.html. - dojoBlankHtmlUrl: undefined, - // ioPublish: Boolean? - // Set this to true to enable publishing of topics for the different phases of - // IO operations. Publishing is done via dojo.publish. See dojo.__IoPublish for a list - // of topics that are published. - ioPublish: false, - // useCustomLogger: Anything? - // If set to a value that evaluates to true such as a string or array and - // isDebug is true and Firebug is not available or running, then it bypasses - // the creation of Firebug Lite allowing you to define your own console object. - useCustomLogger: undefined, - // transparentColor: Array - // Array containing the r, g, b components used as transparent color in dojo.Color; - // if undefined, [255,255,255] (white) will be used. - transparentColor: undefined, - // skipIeDomLoaded: Boolean - // For IE only, skip the DOMContentLoaded hack used. Sometimes it can cause an Operation - // Aborted error if the rest of the page triggers script defers before the DOM is ready. - // If this is config value is set to true, then dojo.addOnLoad callbacks will not be - // triggered until the page load event, which is after images and iframes load. If you - // want to trigger the callbacks sooner, you can put a script block in the bottom of - // your HTML that calls dojo._loadInit();. If you are using multiversion support, change - // "dojo." to the appropriate scope name for dojo. - skipIeDomLoaded: false -} -=====*/ - -(function(){ - // firebug stubs - - if(typeof this["loadFirebugConsole"] == "function"){ - // for Firebug 1.2 - this["loadFirebugConsole"](); - }else{ - this.console = this.console || {}; - - // Be careful to leave 'log' always at the end - var cn = [ - "assert", "count", "debug", "dir", "dirxml", "error", "group", - "groupEnd", "info", "profile", "profileEnd", "time", "timeEnd", - "trace", "warn", "log" - ]; - var i = 0, tn; - while((tn=cn[i++])){ - if(!console[tn]){ - (function(){ - var tcn = tn+""; - console[tcn] = ('log' in console) ? function(){ - var a = Array.apply({}, arguments); - a.unshift(tcn+":"); - console["log"](a.join(" ")); - } : function(){} - console[tcn]._fake = true; - })(); - } - } - } - - //TODOC: HOW TO DOC THIS? - // dojo is the root variable of (almost all) our public symbols -- make sure it is defined. - if(typeof dojo == "undefined"){ - dojo = { - _scopeName: "dojo", - _scopePrefix: "", - _scopePrefixArgs: "", - _scopeSuffix: "", - _scopeMap: {}, - _scopeMapRev: {} - }; - } - - var d = dojo; - - //Need placeholders for dijit and dojox for scoping code. - if(typeof dijit == "undefined"){ - dijit = {_scopeName: "dijit"}; - } - if(typeof dojox == "undefined"){ - dojox = {_scopeName: "dojox"}; - } - - if(!d._scopeArgs){ - d._scopeArgs = [dojo, dijit, dojox]; - } - -/*===== -dojo.global = { - // summary: - // Alias for the global scope - // (e.g. the window object in a browser). - // description: - // Refer to 'dojo.global' rather than referring to window to ensure your - // code runs correctly in contexts other than web browsers (e.g. Rhino on a server). -} -=====*/ - d.global = this; - - d.config =/*===== djConfig = =====*/{ - isDebug: false, - debugAtAllCosts: false - }; - - // FIXME: 2.0, drop djConfig support. Use dojoConfig exclusively for global config. - var cfg = typeof djConfig != "undefined" ? djConfig : - typeof dojoConfig != "undefined" ? dojoConfig : null; - - if(cfg){ - for(var c in cfg){ - d.config[c] = cfg[c]; - } - } - -/*===== - // Override locale setting, if specified - dojo.locale = { - // summary: the locale as defined by Dojo (read-only) - }; -=====*/ - dojo.locale = d.config.locale; - - var rev = "$Rev: 24595 $".match(/\d+/); - -/*===== - dojo.version = function(){ - // summary: - // Version number of the Dojo Toolkit - // major: Integer - // Major version. If total version is "1.2.0beta1", will be 1 - // minor: Integer - // Minor version. If total version is "1.2.0beta1", will be 2 - // patch: Integer - // Patch version. If total version is "1.2.0beta1", will be 0 - // flag: String - // Descriptor flag. If total version is "1.2.0beta1", will be "beta1" - // revision: Number - // The SVN rev from which dojo was pulled - this.major = 0; - this.minor = 0; - this.patch = 0; - this.flag = ""; - this.revision = 0; - } -=====*/ - dojo.version = { - major: 1, minor: 6, patch: 1, flag: "", - revision: rev ? +rev[0] : NaN, - toString: function(){ - with(d.version){ - return major + "." + minor + "." + patch + flag + " (" + revision + ")"; // String - } - } - } - - // Register with the OpenAjax hub - if(typeof OpenAjax != "undefined"){ - OpenAjax.hub.registerLibrary(dojo._scopeName, "http://dojotoolkit.org", d.version.toString()); - } - - var extraNames, extraLen, empty = {}; - for(var i in {toString: 1}){ extraNames = []; break; } - dojo._extraNames = extraNames = extraNames || ["hasOwnProperty", "valueOf", "isPrototypeOf", - "propertyIsEnumerable", "toLocaleString", "toString", "constructor"]; - extraLen = extraNames.length; - - dojo._mixin = function(/*Object*/ target, /*Object*/ source){ - // summary: - // Adds all properties and methods of source to target. This addition - // is "prototype extension safe", so that instances of objects - // will not pass along prototype defaults. - var name, s, i; - for(name in source){ - // the "tobj" condition avoid copying properties in "source" - // inherited from Object.prototype. For example, if target has a custom - // toString() method, don't overwrite it with the toString() method - // that source inherited from Object.prototype - s = source[name]; - if(!(name in target) || (target[name] !== s && (!(name in empty) || empty[name] !== s))){ - target[name] = s; - } - } - // IE doesn't recognize some custom functions in for..in - if(extraLen && source){ - for(i = 0; i < extraLen; ++i){ - name = extraNames[i]; - s = source[name]; - if(!(name in target) || (target[name] !== s && (!(name in empty) || empty[name] !== s))){ - target[name] = s; - } - } - } - return target; // Object - } - - dojo.mixin = function(/*Object*/obj, /*Object...*/props){ - // summary: - // Adds all properties and methods of props to obj and returns the - // (now modified) obj. - // description: - // `dojo.mixin` can mix multiple source objects into a - // destination object which is then returned. Unlike regular - // `for...in` iteration, `dojo.mixin` is also smart about avoiding - // extensions which other toolkits may unwisely add to the root - // object prototype - // obj: - // The object to mix properties into. Also the return value. - // props: - // One or more objects whose values are successively copied into - // obj. If more than one of these objects contain the same value, - // the one specified last in the function call will "win". - // example: - // make a shallow copy of an object - // | var copy = dojo.mixin({}, source); - // example: - // many class constructors often take an object which specifies - // values to be configured on the object. In this case, it is - // often simplest to call `dojo.mixin` on the `this` object: - // | dojo.declare("acme.Base", null, { - // | constructor: function(properties){ - // | // property configuration: - // | dojo.mixin(this, properties); - // | - // | console.log(this.quip); - // | // ... - // | }, - // | quip: "I wasn't born yesterday, you know - I've seen movies.", - // | // ... - // | }); - // | - // | // create an instance of the class and configure it - // | var b = new acme.Base({quip: "That's what it does!" }); - // example: - // copy in properties from multiple objects - // | var flattened = dojo.mixin( - // | { - // | name: "Frylock", - // | braces: true - // | }, - // | { - // | name: "Carl Brutanananadilewski" - // | } - // | ); - // | - // | // will print "Carl Brutanananadilewski" - // | console.log(flattened.name); - // | // will print "true" - // | console.log(flattened.braces); - if(!obj){ obj = {}; } - for(var i=1, l=arguments.length; i<l; i++){ - d._mixin(obj, arguments[i]); - } - return obj; // Object - } - - dojo._getProp = function(/*Array*/parts, /*Boolean*/create, /*Object*/context){ - var obj=context || d.global; - for(var i=0, p; obj && (p=parts[i]); i++){ - if(i == 0 && d._scopeMap[p]){ - p = d._scopeMap[p]; - } - obj = (p in obj ? obj[p] : (create ? obj[p]={} : undefined)); - } - return obj; // mixed - } - - dojo.setObject = function(/*String*/name, /*Object*/value, /*Object?*/context){ - // summary: - // Set a property from a dot-separated string, such as "A.B.C" - // description: - // Useful for longer api chains where you have to test each object in - // the chain, or when you have an object reference in string format. - // Objects are created as needed along `path`. Returns the passed - // value if setting is successful or `undefined` if not. - // name: - // Path to a property, in the form "A.B.C". - // context: - // Optional. Object to use as root of path. Defaults to - // `dojo.global`. - // example: - // set the value of `foo.bar.baz`, regardless of whether - // intermediate objects already exist: - // | dojo.setObject("foo.bar.baz", value); - // example: - // without `dojo.setObject`, we often see code like this: - // | // ensure that intermediate objects are available - // | if(!obj["parent"]){ obj.parent = {}; } - // | if(!obj.parent["child"]){ obj.parent.child= {}; } - // | // now we can safely set the property - // | obj.parent.child.prop = "some value"; - // wheras with `dojo.setObject`, we can shorten that to: - // | dojo.setObject("parent.child.prop", "some value", obj); - var parts=name.split("."), p=parts.pop(), obj=d._getProp(parts, true, context); - return obj && p ? (obj[p]=value) : undefined; // Object - } - - dojo.getObject = function(/*String*/name, /*Boolean?*/create, /*Object?*/context){ - // summary: - // Get a property from a dot-separated string, such as "A.B.C" - // description: - // Useful for longer api chains where you have to test each object in - // the chain, or when you have an object reference in string format. - // name: - // Path to an property, in the form "A.B.C". - // create: - // Optional. Defaults to `false`. If `true`, Objects will be - // created at any point along the 'path' that is undefined. - // context: - // Optional. Object to use as root of path. Defaults to - // 'dojo.global'. Null may be passed. - return d._getProp(name.split("."), create, context); // Object - } - - dojo.exists = function(/*String*/name, /*Object?*/obj){ - // summary: - // determine if an object supports a given method - // description: - // useful for longer api chains where you have to test each object in - // the chain. Useful for object and method detection. - // 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) !== undefined; // Boolean - } - - dojo["eval"] = function(/*String*/ scriptFragment){ - // summary: - // A legacy method created for use exclusively by internal Dojo methods. Do not use - // this method directly, the behavior of this eval will differ from the normal - // browser eval. - // description: - // Placed in a separate function to minimize size of trapped - // exceptions. Calling eval() directly from some other scope may - // complicate tracebacks on some platforms. - // returns: - // The result of the evaluation. Often `undefined` - return d.global.eval ? d.global.eval(scriptFragment) : eval(scriptFragment); // Object - } - - /*===== - dojo.deprecated = function(behaviour, extra, removal){ - // summary: - // Log a debug message to indicate that a behavior has been - // deprecated. - // behaviour: String - // The API or behavior being deprecated. Usually in the form - // of "myApp.someFunction()". - // extra: String? - // Text to append to the message. Often provides advice on a - // new function or facility to achieve the same goal during - // the deprecation period. - // removal: String? - // Text to indicate when in the future the behavior will be - // removed. Usually a version number. - // example: - // | dojo.deprecated("myApp.getTemp()", "use myApp.getLocaleTemp() instead", "1.0"); - } - - dojo.experimental = function(moduleName, extra){ - // summary: Marks code as experimental. - // description: - // This can be used to mark a function, file, or module as - // experimental. Experimental code is not ready to be used, and the - // APIs are subject to change without notice. Experimental code may be - // completed deleted without going through the normal deprecation - // process. - // moduleName: String - // The name of a module, or the name of a module file or a specific - // function - // extra: String? - // some additional message for the user - // example: - // | dojo.experimental("dojo.data.Result"); - // example: - // | dojo.experimental("dojo.weather.toKelvin()", "PENDING approval from NOAA"); - } - =====*/ - - //Real functions declared in dojo._firebug.firebug. - d.deprecated = d.experimental = function(){}; - -})(); -// vim:ai:ts=4:noet diff --git a/lib/dojo/_base/_loader/hostenv_browser.js b/lib/dojo/_base/_loader/hostenv_browser.js deleted file mode 100644 index b31bd77dc..000000000 --- a/lib/dojo/_base/_loader/hostenv_browser.js +++ /dev/null @@ -1,477 +0,0 @@ -/* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. - Available via Academic Free License >= 2.1 OR the modified BSD license. - see: http://dojotoolkit.org/license for details -*/ - - -/*===== -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 KHTML browser. undefined otherwise. Corresponds to major - // detected version. - isKhtml: 0, - // isWebKit: Number | undefined - // Version as a Number if client is a WebKit-derived browser (Konqueror, - // Safari, Chrome, etc.). undefined otherwise. - isWebKit: 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, - // isChrome: Number | undefined - // Version as a Number if client is Chrome browser. undefined otherwise. - isChrome: 0 - // isMac: Boolean - // True if the client runs on Mac -} -=====*/ -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") || scripts[i].getAttribute("data-dojo-config")); - 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, - dav = n.appVersion, - tv = parseFloat(dav); - - if(dua.indexOf("Opera") >= 0){ d.isOpera = tv; } - if(dua.indexOf("AdobeAIR") >= 0){ d.isAIR = 1; } - d.isKhtml = (dav.indexOf("Konqueror") >= 0) ? tv : 0; - d.isWebKit = parseFloat(dua.split("WebKit/")[1]) || undefined; - d.isChrome = parseFloat(dua.split("Chrome/")[1]) || undefined; - d.isMac = dav.indexOf("Macintosh") >= 0; - - // 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 && !dojo.isChrome){ - // try to grab the explicit Safari version first. If we don't get - // one, look for less than 419.3 as the indication that we're on something - // "Safari 2-ish". - d.isSafari = parseFloat(dav.split("Version/")[1]); - if(!d.isSafari || parseFloat(dav.substr(index + 7)) <= 419.3){ - d.isSafari = 2; - } - } - - if(dua.indexOf("Gecko") >= 0 && !d.isKhtml && !d.isWebKit){ d.isMozilla = d.isMoz = tv; } - if(d.isMoz){ - //We really need to get away from this. Consider a sane isGecko approach for the future. - d.isFF = parseFloat(dua.split("Firefox/")[1] || dua.split("Minefield/")[1]) || undefined; - } - if(document.all && !d.isOpera){ - d.isIE = parseFloat(dav.split("MSIE ")[1]) || undefined; - //In cases where the page has an HTTP header or META tag with - //X-UA-Compatible, then it is in emulation mode. - //Make sure isIE reflects the desired version. - //document.documentMode of 5 means quirks mode. - //Only switch the value if documentMode's major version - //is different from isIE's major version. - var mode = document.documentMode; - if(mode && mode != 5 && Math.floor(d.isIE) != mode){ - d.isIE = mode; - } - } - - //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; - } - - d.isQuirks = document.compatMode == "BackCompat"; - - // 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, last_e; - 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, - lp = location.protocol; - return (stat >= 200 && stat < 300) || // Boolean - stat == 304 || // allow any 2XX response code - stat == 1223 || // get it out of the cache - // Internet Explorer mangled the status code - // Internet Explorer mangled the status code OR we're Titanium/browser chrome/chrome extension requesting a local file - (!stat && (lp == "file:" || lp == "chrome:" || lp == "chrome-extension:" || lp == "app:")); - } - - //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) - - // NOTE: must be declared before scope switches ie. this._xhrObj() - var http = d._xhrObj(); - - if(!hasBase && dojo._Url){ - uri = (new dojo._Url(owloc, uri)).toString(); - } - - 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); - 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 - } - - - 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 _a = _w.attachEvent || _w.addEventListener; - evtName = _w.attachEvent ? evtName : evtName.substring(2); - _a(evtName, function(){ - fp.apply(_w, arguments); - }, false); - }; - - - d._windowUnloaders = []; - - d.windowUnloaded = function(){ - // summary: - // signal fired by impending window destruction. You may use - // dojo.addOnWindowUnload() to register a listener for this - // event. NOTE: if you wish to dojo.connect() to this method - // to perform page/application cleanup, be aware that this - // event WILL NOT fire if no handler has been registered with - // dojo.addOnWindowUnload. This behavior started in Dojo 1.3. - // Previous versions always triggered dojo.windowUnloaded. See - // dojo.addOnWindowUnload for more info. - var mll = d._windowUnloaders; - while(mll.length){ - (mll.pop())(); - } - d = null; - }; - - var _onWindowUnloadAttached = 0; - d.addOnWindowUnload = function(/*Object?|Function?*/obj, /*String|Function?*/functionName){ - // summary: - // registers a function to be triggered when window.onunload - // fires. - // description: - // The first time that addOnWindowUnload is called Dojo - // will register a page listener to trigger your unload - // handler with. Note that registering these handlers may - // destory "fastback" page caching in browsers that support - // it. 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 since it fires at the eqivalent of - // the page's "onbeforeunload" event. - // example: - // | dojo.addOnWindowUnload(functionPointer) - // | dojo.addOnWindowUnload(object, "functionName"); - // | dojo.addOnWindowUnload(object, function(){ /* ... */}); - - d._onto(d._windowUnloaders, obj, functionName); - if(!_onWindowUnloadAttached){ - _onWindowUnloadAttached = 1; - _handleNodeEvent("onunload", d.windowUnloaded); - } - }; - - var _onUnloadAttached = 0; - d.addOnUnload = function(/*Object?|Function?*/obj, /*String|Function?*/functionName){ - // summary: - // registers a function to be triggered when the page unloads. - // description: - // The first time that addOnUnload is called Dojo will - // register a page listener to trigger your unload handler - // with. - // - // In a browser enviroment, the functions will be triggered - // during the window.onbeforeunload event. Be careful of doing - // too much work in an unload handler. 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. - // - // Further note that calling dojo.addOnUnload will prevent - // browsers from using a "fast back" cache to make page - // loading via back button instantaneous. - // example: - // | dojo.addOnUnload(functionPointer) - // | dojo.addOnUnload(object, "functionName") - // | dojo.addOnUnload(object, function(){ /* ... */}); - - d._onto(d._unloaders, obj, functionName); - if(!_onUnloadAttached){ - _onUnloadAttached = 1; - _handleNodeEvent("onbeforeunload", dojo.unloaded); - } - }; - - })(); - - //START DOMContentLoaded - dojo._initFired = false; - dojo._loadInit = function(e){ - if(dojo._scrollIntervalId){ - clearInterval(dojo._scrollIntervalId); - dojo._scrollIntervalId = 0; - } - - if(!dojo._initFired){ - dojo._initFired = true; - - //Help out IE to avoid memory leak. - if(!dojo.config.afterOnLoad && window.detachEvent){ - window.detachEvent("onload", dojo._loadInit); - } - - if(dojo._inFlightCount == 0){ - dojo._modulesLoaded(); - } - } - } - - if(!dojo.config.afterOnLoad){ - if(document.addEventListener){ - //Standards. Hooray! Assumption here that if standards based, - //it knows about DOMContentLoaded. It is OK if it does not, the fall through - //to window onload should be good enough. - document.addEventListener("DOMContentLoaded", dojo._loadInit, false); - window.addEventListener("load", dojo._loadInit, false); - }else if(window.attachEvent){ - window.attachEvent("onload", dojo._loadInit); - - //DOMContentLoaded approximation. Diego Perini found this MSDN article - //that indicates doScroll is available after DOM ready, so do a setTimeout - //to check when it is available. - //http://msdn.microsoft.com/en-us/library/ms531426.aspx - if(!dojo.config.skipIeDomLoaded && self === self.top){ - dojo._scrollIntervalId = setInterval(function (){ - try{ - //When dojo is loaded into an iframe in an IE HTML Application - //(HTA), such as in a selenium test, javascript in the iframe - //can't see anything outside of it, so self===self.top is true, - //but the iframe is not the top window and doScroll will be - //available before document.body is set. Test document.body - //before trying the doScroll trick - if(document.body){ - document.documentElement.doScroll("left"); - dojo._loadInit(); - } - }catch (e){} - }, 30); - } - } - } - - if(dojo.isIE){ - try{ - (function(){ - document.namespaces.add("v", "urn:schemas-microsoft-com:vml"); - var vmlElems = ["*", "group", "roundrect", "oval", "shape", "rect", "imagedata", "path", "textpath", "text"], - i = 0, l = 1, s = document.createStyleSheet(); - if(dojo.isIE >= 8){ - i = 1; - l = vmlElems.length; - } - for(; i < l; ++i){ - s.addRule("v\\:" + vmlElems[i], "behavior:url(#default#VML); display:inline-block"); - } - })(); - }catch(e){} - } - //END DOMContentLoaded - - - /* - 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){ - // this breaks the new AMD based module loader. The XDomain won't be necessary - // anyway if you switch to the asynchronous loader - //dojo.config.useXDomain = true; - //dojo.require("dojo._base._loader.loader_xd"); - dojo.require("dojo._base._loader.loader_debug"); - dojo.require("dojo.i18n"); -} - diff --git a/lib/dojo/_base/_loader/hostenv_rhino.js b/lib/dojo/_base/_loader/hostenv_rhino.js deleted file mode 100644 index e3aa78524..000000000 --- a/lib/dojo/_base/_loader/hostenv_rhino.js +++ /dev/null @@ -1,214 +0,0 @@ -/* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. - Available via Academic Free License >= 2.1 OR the modified BSD license. - see: http://dojotoolkit.org/license for details -*/ - - -/* -* Rhino host environment -*/ - -if(dojo.config["baseUrl"]){ - dojo.baseUrl = dojo.config["baseUrl"]; -}else{ - dojo.baseUrl = "./"; -} - -dojo.locale = dojo.locale || String(java.util.Locale.getDefault().toString().replace('_','-').toLowerCase()); -dojo._name = 'rhino'; -dojo.isRhino = true; - -if(typeof print == "function"){ - console.debug = print; -} - -if(!("byId" in dojo)){ - dojo.byId = function(id, doc){ - if(id && (typeof id == "string" || id instanceof String)){ - if(!doc){ doc = document; } - return doc.getElementById(id); - } - return id; // assume it's a node - } -} - -dojo._isLocalUrl = function(/*String*/ uri) { - // summary: - // determines if URI is local or not. - - var local = (new java.io.File(uri)).exists(); - if(!local){ - var stream; - //Try remote URL. Allow this method to throw, - //but still do cleanup. - try{ - // try it as a file first, URL second - stream = (new java.net.URL(uri)).openStream(); - // close the stream so we don't leak resources - stream.close(); - }finally{ - if(stream && stream.close){ - stream.close(); - } - } - } - return local; -} - -// see comments in spidermonkey loadUri -dojo._loadUri = function(uri, cb){ - if(dojo._loadedUrls[uri]){ - return true; // Boolean - } - try{ - var local; - try{ - local = dojo._isLocalUrl(uri); - }catch(e){ - // no debug output; this failure just means the uri was not found. - return false; - } - - dojo._loadedUrls[uri] = true; - //FIXME: Use Rhino 1.6 native readFile/readUrl if available? - if(cb){ - var contents = (local ? readText : readUri)(uri, "UTF-8"); - - // patch up the input to eval until https://bugzilla.mozilla.org/show_bug.cgi?id=471005 is fixed. - if(!eval("'\u200f'").length){ - contents = String(contents).replace(/[\u200E\u200F\u202A-\u202E]/g, function(match){ - return "\\u" + match.charCodeAt(0).toString(16); - }) - } - contents = /^define\(/.test(contents) ? contents : '('+contents+')'; - cb(eval(contents)); - }else{ - load(uri); - } - dojo._loadedUrls.push(uri); - return true; - }catch(e){ - dojo._loadedUrls[uri] = false; - console.debug("rhino load('" + uri + "') failed. Exception: " + e); - return false; - } -} - -dojo.exit = function(exitcode){ - quit(exitcode); -} - -// reading a file from disk in Java is a humiliating experience by any measure. -// Lets avoid that and just get the freaking text -function readText(path, encoding){ - encoding = encoding || "utf-8"; - // NOTE: we intentionally avoid handling exceptions, since the caller will - // want to know - var jf = new java.io.File(path); - var is = new java.io.FileInputStream(jf); - return dj_readInputStream(is, encoding); -} - -function readUri(uri, encoding){ - var conn = (new java.net.URL(uri)).openConnection(); - encoding = encoding || conn.getContentEncoding() || "utf-8"; - var is = conn.getInputStream(); - return dj_readInputStream(is, encoding); -} - -function dj_readInputStream(is, encoding){ - var input = new java.io.BufferedReader(new java.io.InputStreamReader(is, encoding)); - try { - var sb = new java.lang.StringBuffer(); - var line = ""; - while((line = input.readLine()) !== null){ - sb.append(line); - sb.append(java.lang.System.getProperty("line.separator")); - } - return sb.toString(); - } finally { - input.close(); - } -} - -dojo._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. - // 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) - try{ - var local = dojo._isLocalUrl(uri); - var text = (local ? readText : readUri)(uri, "UTF-8"); - if(text !== null){ - //Force JavaScript string. - text += ""; - } - return text; - }catch(e){ - if(fail_ok){ - return null; - }else{ - throw e; - } - } -} - -// summary: -// return the document object associated with the dojo.global -dojo.doc = typeof document != "undefined" ? document : null; - -dojo.body = function(){ - return document.body; -} - -// Supply setTimeout/clearTimeout implementations if they aren't already there -// Note: this assumes that we define both if one is not provided... there might -// be a better way to do this if there is a use case where one is defined but -// not the other -if(typeof setTimeout == "undefined" || typeof clearTimeout == "undefined"){ - dojo._timeouts = []; - clearTimeout = function(idx){ - if(!dojo._timeouts[idx]){ return; } - dojo._timeouts[idx].stop(); - } - - setTimeout = function(func, delay){ - // summary: provides timed callbacks using Java threads - - var def={ - sleepTime:delay, - hasSlept:false, - - run:function(){ - if(!this.hasSlept){ - this.hasSlept=true; - java.lang.Thread.currentThread().sleep(this.sleepTime); - } - try{ - func(); - }catch(e){ - console.debug("Error running setTimeout thread:" + e); - } - } - }; - - var runnable = new java.lang.Runnable(def); - var thread = new java.lang.Thread(runnable); - thread.start(); - return dojo._timeouts.push(thread)-1; - } -} - -//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. -if(dojo.config["modulePaths"]){ - for(var param in dojo.config["modulePaths"]){ - dojo.registerModulePath(param, dojo.config["modulePaths"][param]); - } -} diff --git a/lib/dojo/_base/_loader/loader.js b/lib/dojo/_base/_loader/loader.js deleted file mode 100644 index 73df544fa..000000000 --- a/lib/dojo/_base/_loader/loader.js +++ /dev/null @@ -1,816 +0,0 @@ -/* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. - Available via Academic Free License >= 2.1 OR the modified BSD license. - see: http://dojotoolkit.org/license for details -*/ - - -if(!dojo._hasResource["dojo.foo"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. -dojo._hasResource["dojo.foo"] = true; -/* - * loader.js - A bootstrap module. Runs before the hostenv_*.js file. Contains - * all of the package loading methods. - */ -(function(){ - var d = dojo, currentModule; - - 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 = d._modulePrefixes; - return !!(mp[module] && mp[module].value); // Boolean - }, - - _getModulePrefix: function(/*String*/module){ - // summary: gets the prefix associated with module - var mp = d._modulePrefixes; - if(d._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+:/)) ? "" : d.baseUrl) + relpath; - try{ - currentModule = module; - return !module ? d._loadUri(uri, cb) : d._loadUriAndCheck(uri, module, cb); // Boolean - }catch(e){ - console.error(e); - return false; // Boolean - }finally{ - currentModule = null; - } - } - - 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(d._loadedUrls[uri]){ - return true; // Boolean - } - d._inFlightCount++; // block addOnLoad calls that arrive while we're busy downloading - var contents = d._getText(uri, true); - if(contents){ // not 404, et al - d._loadedUrls[uri] = true; - d._loadedUrls.push(uri); - if(cb){ - //conditional to support script-inject i18n bundle format - contents = /^define\(/.test(contents) ? contents : '('+contents+')'; - }else{ - //Only do the scoping if no callback. If a callback is specified, - //it is most likely the i18n bundle stuff. - contents = d._scopePrefix + contents + d._scopeSuffix; - } - if(!d.isIE){ contents += "\r\n//@ sourceURL=" + uri; } // debugging assist for Firebug - var value = d["eval"](contents); - if(cb){ cb(value); } - } - // Check to see if we need to call _callLoaded() due to an addOnLoad() that arrived while we were busy downloading - if(--d._inFlightCount == 0 && d._postLoad && d._loaders.length){ - // We shouldn't be allowed to get here but Firefox allows an event - // (mouse, keybd, async xhrGet) to interrupt a synchronous xhrGet. - // If the current script block contains multiple require() statements, then after each - // require() returns, inFlightCount == 0, but we want to hold the _callLoaded() until - // all require()s are done since the out-of-sequence addOnLoad() presumably needs them all. - // setTimeout allows the next require() to start (if needed), and then we check this again. - setTimeout(function(){ - // If inFlightCount > 0, then multiple require()s are running sequentially and - // the next require() started after setTimeout() was executed but before we got here. - if(d._inFlightCount == 0){ - d._callLoaded(); - } - }, 0); - } - return !!contents; // Boolean: contents? true : false - } - - // 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 = d._loadUri(uri, cb); - }catch(e){ - console.error("failed loading " + uri + " with error: " + e); - } - return !!(ok && d._loadedModules[moduleName]); // Boolean - } - - dojo.loaded = function(){ - // summary: - // signal fired when initial environment and package loading is - // complete. You should use dojo.addOnLoad() instead of doing a - // direct 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. - d._loadNotifying = true; - d._postLoad = true; - var mll = d._loaders; - - //Clear listeners so new ones can be added - //For other xdomain package loads after the initial load. - d._loaders = []; - - for(var x = 0; x < mll.length; x++){ - mll[x](); - } - - d._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 should use - // dojo.addOnUnload() instead of doing a direct dojo.connect() to this - // method to perform page/application cleanup methods. See - // dojo.addOnUnload for more info. - var mll = d._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.ready = dojo.addOnLoad = function(/*Object*/obj, /*String|Function?*/functionName){ - // summary: - // Registers a function to be triggered after the DOM and dojo.require() calls - // have finished loading. - // - // description: - // Registers a function to be triggered after the DOM has finished - // loading and `dojo.require` modules have loaded. Widgets declared in markup - // have been instantiated if `djConfig.parseOnLoad` is true when this fires. - // - // 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, though including css resouces BEFORE any script elements - // is highly recommended). - // - // example: - // Register an anonymous function to run when everything is ready - // | dojo.addOnLoad(function(){ doStuff(); }); - // - // example: - // Register a function to run when everything is ready by pointer: - // | var init = function(){ doStuff(); } - // | dojo.addOnLoad(init); - // - // example: - // Register a function to run scoped to `object`, either by name or anonymously: - // | dojo.addOnLoad(object, "functionName"); - // | dojo.addOnLoad(object, function(){ doStuff(); }); - - 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._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" || (d.config.useXDomain && d.isOpera)){ - setTimeout( - d.isAIR ? function(){ d.loaded(); } : d._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 && !d._moduleHasPrefix(parentModule)){ - // Support default module directory (sibling of dojo) for top-level modules - syms[0] = "../" + syms[0]; - }else{ - var parentModulePath = d._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: String - // module name to load, using periods for separators, - // e.g. "dojo.date.locale". Module paths are de-referenced by dojo's - // internal mapping of locations to names and are disambiguated by - // longest prefix. See `dojo.registerModulePath()` for details on - // registering new modules. - // - // omitModuleCheck: Boolean? - // if `true`, omitModuleCheck skips the step of ensuring that the - // loaded file actually defines the symbol it is referenced by. - // For example if it called as `dojo.require("a.b.c")` and the - // file located at `a/b/c.js` does not define an object `a.b.c`, - // and exception will be throws whereas no exception is raised - // when called as `dojo.require("a.b.c", true)` - // - // description: - // Modules are loaded via dojo.require by using one of two loaders: the normal loader - // and the xdomain loader. The xdomain loader is used when dojo was built with a - // custom build that specified loader=xdomain and the module lives on a modulePath - // that is a whole URL, with protocol and a domain. The versions of Dojo that are on - // the Google and AOL CDNs use the xdomain loader. - // - // If the module is loaded via the xdomain loader, it is an asynchronous load, since - // the module is added via a dynamically created script tag. This - // means that dojo.require() can return before the module has loaded. However, this - // should only happen in the case where you do dojo.require calls in the top-level - // HTML page, or if you purposely avoid the loader checking for dojo.require - // dependencies in your module by using a syntax like dojo["require"] to load the module. - // - // Sometimes it is useful to not have the loader detect the dojo.require calls in the - // module so that you can dynamically load the modules as a result of an action on the - // page, instead of right at module load time. - // - // Also, for script blocks in an HTML page, the loader does not pre-process them, so - // it does not know to download the modules before the dojo.require calls occur. - // - // So, in those two cases, when you want on-the-fly module loading or for script blocks - // in the HTML page, special care must be taken if the dojo.required code is loaded - // asynchronously. To make sure you can execute code that depends on the dojo.required - // modules, be sure to add the code that depends on the modules in a dojo.addOnLoad() - // callback. dojo.addOnLoad waits for all outstanding modules to finish loading before - // executing. - // - // This type of syntax works with both xdomain and normal loaders, so it is good - // practice to always use this idiom for on-the-fly code loading and in HTML script - // blocks. If at some point you change loaders and where the code is loaded from, - // it will all still work. - // - // More on how dojo.require - // `dojo.require("A.B")` first checks to see if symbol A.B is - // defined. If it is, it is simply returned (nothing to do). - // - // If it is not defined, it will look for `A/B.js` in the script root - // directory. - // - // `dojo.require` throws an exception if it cannot find a file - // to load, or if the symbol `A.B` is not defined after loading. - // - // It returns the object `A.B`, but note the caveats above about on-the-fly loading and - // HTML script blocks when the xdomain loader is loading a module. - // - // `dojo.require()` does nothing about importing symbols into - // the current namespace. It is presumed that the caller will - // take care of that. - // - // example: - // To use dojo.require in conjunction with dojo.ready: - // - // | dojo.require("foo"); - // | dojo.require("bar"); - // | dojo.addOnLoad(function(){ - // | //you can now safely do something with foo and bar - // | }); - // - // example: - // For example, to import all symbols into a local block, you might write: - // - // | with (dojo.require("A.B")) { - // | ... - // | } - // - // And to import just the leaf symbol to a local variable: - // - // | var B = dojo.require("A.B"); - // | ... - // - // returns: - // the required namespace object - omitModuleCheck = d._global_omit_module_check || omitModuleCheck; - - //Check if it is already loaded. - var module = d._loadedModules[moduleName]; - if(module){ - return module; - } - - // convert periods to slashes - var relpath = d._getModuleSymbols(moduleName).join("/") + '.js'; - var modArg = !omitModuleCheck ? moduleName : null; - var ok = d._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 && !d._isXDomain){ - // pass in false so we can give better error - module = d._loadedModules[moduleName]; - if(!module){ - throw new Error("symbol '" + moduleName + "' is not defined after loading '" + relpath + "'"); - } - } - - return module; - } - - dojo.provide = function(/*String*/ resourceName){ - // summary: - // Register a resource with the package system. Works in conjunction with `dojo.require` - // - // 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. - // - // 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. - // - // 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. - // - // resourceName: String - // A dot-sperated string identifying a resource. - // - // example: - // Safely create a `my` object, and make dojo.require("my.CustomModule") work - // | dojo.provide("my.CustomModule"); - - //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 - // - // example: - // | dojo.requireIf(dojo.isBrowser, "my.special.Module"); - - 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. Using "nls" as a - // a bundle name is not supported, since "nls" is the name of the folder - // that holds bundles. Using "nls" as the bundle name will cause problems - // with the custom build. - // - // 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("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$"), - 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, - _a = arguments, - uri = [_a[0]]; - // resolve uri components relative to each other - for(var i = 1; i<_a.length; i++){ - if(!_a[i]){ continue; } - - // Safari doesn't support this.constructor so we have to be explicit - // FIXME: Tracked (and fixed) in Webkit bug 3537. - // http://bugs.webkit.org/show_bug.cgi?id=3537 - var relobj = new d._Url(_a[i]+""), - 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"); - // | console.dir(pngPath); // 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); // dojo._Url - }; - - - -})(); - -} diff --git a/lib/dojo/_base/_loader/loader_debug.js b/lib/dojo/_base/_loader/loader_debug.js deleted file mode 100644 index f2043e4de..000000000 --- a/lib/dojo/_base/_loader/loader_debug.js +++ /dev/null @@ -1,86 +0,0 @@ -/* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. - Available via Academic Free License >= 2.1 OR the modified BSD license. - see: http://dojotoolkit.org/license for details -*/ - - -if(!dojo._hasResource["dojo._base._loader.loader_debug"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. -dojo._hasResource["dojo._base._loader.loader_debug"] = true; -dojo.provide("dojo._base._loader.loader_debug"); - -//Override dojo.provide, so we can trigger the next -//script tag for the next local module. We can only add one -//at a time because there are browsers that execute script tags -//in the order that the code is received, and not in the DOM order. -dojo.nonDebugProvide = dojo.provide; - -dojo.provide = function(resourceName){ - var dbgQueue = dojo["_xdDebugQueue"]; - if(dbgQueue && dbgQueue.length > 0 && resourceName == dbgQueue["currentResourceName"]){ - //Set a timeout so the module can be executed into existence. Normally the - //dojo.provide call in a module is the first line. Don't want to risk attaching - //another script tag until the current one finishes executing. - if(dojo.isAIR){ - window.setTimeout(function(){dojo._xdDebugFileLoaded(resourceName);}, 1); - }else{ - window.setTimeout(dojo._scopeName + "._xdDebugFileLoaded('" + resourceName + "')", 1); - } - } - - return dojo.nonDebugProvide.apply(dojo, arguments); -} - -dojo._xdDebugFileLoaded = function(resourceName){ - - if(!dojo._xdDebugScopeChecked){ - //If using a scoped dojo, we need to expose dojo as a real global - //for the debugAtAllCosts stuff to work. - if(dojo._scopeName != "dojo"){ - window.dojo = window[dojo.config.scopeMap[0][1]]; - window.dijit = window[dojo.config.scopeMap[1][1]]; - window.dojox = window[dojo.config.scopeMap[2][1]]; - } - - dojo._xdDebugScopeChecked = true; - } - - var dbgQueue = dojo._xdDebugQueue; - - if(resourceName && resourceName == dbgQueue.currentResourceName){ - dbgQueue.shift(); - } - - if(dbgQueue.length == 0){ - //Check for more modules that need debug loading. - //dojo._xdWatchInFlight will add more things to the debug - //queue if they just recently loaded but it was not detected - //between the dojo._xdWatchInFlight intervals. - dojo._xdWatchInFlight(); - } - - if(dbgQueue.length == 0){ - dbgQueue.currentResourceName = null; - - //Make sure nothing else is in flight. - //If something is still in flight, then it still - //needs to be added to debug queue after it loads. - for(var param in dojo._xdInFlight){ - if(dojo._xdInFlight[param] === true){ - return; - } - } - - dojo._xdNotifyLoaded(); - }else{ - if(resourceName == dbgQueue.currentResourceName){ - dbgQueue.currentResourceName = dbgQueue[0].resourceName; - var element = document.createElement("script"); - element.type = "text/javascript"; - element.src = dbgQueue[0].resourcePath; - document.getElementsByTagName("head")[0].appendChild(element); - } - } -} - -} diff --git a/lib/dojo/_base/_loader/loader_xd.js b/lib/dojo/_base/_loader/loader_xd.js deleted file mode 100644 index e59f814c0..000000000 --- a/lib/dojo/_base/_loader/loader_xd.js +++ /dev/null @@ -1,727 +0,0 @@ -/* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. - Available via Academic Free License >= 2.1 OR the modified BSD license. - see: http://dojotoolkit.org/license for details -*/ - - -if(!dojo._hasResource["dojo._base._loader.loader_xd"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. -dojo._hasResource["dojo._base._loader.loader_xd"] = true; -//Cross-domain resource loader. -dojo.provide("dojo._base._loader.loader_xd"); - -dojo._xdReset = function(){ - //summary: Internal xd loader function. Resets the xd state. - - //This flag indicates where or not we have crossed into xdomain territory. Once any resource says - //it is cross domain, then the rest of the resources have to be treated as xdomain because we need - //to evaluate resources in order. If there is a xdomain resource followed by a xhr resource, we can't load - //the xhr resource until the one before it finishes loading. The text of the xhr resource will be converted - //to match the format for a xd resource and put in the xd load queue. - dojo._isXDomain = dojo.config.useXDomain || false; - - dojo._xdClearInterval(); - dojo._xdInFlight = {}; - dojo._xdOrderedReqs = []; - dojo._xdDepMap = {}; - dojo._xdContents = []; - dojo._xdDefList = []; -} - -dojo._xdClearInterval = function(){ - //summary: Internal xd loader function. - //Clears the interval timer used to check on the - //status of in-flight xd module resource requests. - if(dojo._xdTimer){ - clearInterval(dojo._xdTimer); - dojo._xdTimer = 0; - } -} - - -//Call reset immediately to set the state. -dojo._xdReset(); - -dojo._xdCreateResource = function(/*String*/contents, /*String*/resourceName, /*String*/resourcePath){ - //summary: Internal xd loader function. Creates an xd module source given an - //non-xd module contents. - - //Remove comments. Not perfect, but good enough for dependency resolution. - var depContents = contents.replace(/(\/\*([\s\S]*?)\*\/|\/\/(.*)$)/mg , ""); - - //Find dependencies. - var deps = []; - var depRegExp = /dojo.(require|requireIf|provide|requireAfterIf|platformRequire|requireLocalization)\s*\(([\w\W]*?)\)/mg; - var match; - while((match = depRegExp.exec(depContents)) != null){ - if(match[1] == "requireLocalization"){ - //Need to load the local bundles asap, since they are not - //part of the list of modules watched for loading. - eval(match[0]); - }else{ - deps.push('"' + match[1] + '", ' + match[2]); - } - } - - //Create resource object and the call to _xdResourceLoaded. - var output = []; - output.push(dojo._scopeName + "._xdResourceLoaded(function(" + dojo._scopePrefixArgs + "){\n"); - - //See if there are any dojo.loadInit calls - var loadInitCalls = dojo._xdExtractLoadInits(contents); - if(loadInitCalls){ - //Adjust fileContents since extractLoadInits removed something. - contents = loadInitCalls[0]; - - //Add any loadInit calls to the top of the xd file. - for(var i = 1; i < loadInitCalls.length; i++){ - output.push(loadInitCalls[i] + ";\n"); - } - } - - output.push("return {"); - - //Add dependencies - if(deps.length > 0){ - output.push("depends: ["); - for(i = 0; i < deps.length; i++){ - if(i > 0){ - output.push(",\n"); - } - output.push("[" + deps[i] + "]"); - } - output.push("],"); - } - - //Add the contents of the file inside a function. - //Pass in scope arguments so we can support multiple versions of the - //same module on a page. - output.push("\ndefineResource: function(" + dojo._scopePrefixArgs + "){"); - - //Don't put in the contents in the debugAtAllCosts case - //since the contents may have syntax errors. Let those - //get pushed up when the script tags are added to the page - //in the debugAtAllCosts case. - if(!dojo.config["debugAtAllCosts"] || resourceName == "dojo._base._loader.loader_debug"){ - output.push(contents); - } - //Add isLocal property so we know if we have to do something different - //in debugAtAllCosts situations. - output.push("\n}, resourceName: '" + resourceName + "', resourcePath: '" + resourcePath + "'};});"); - - return output.join(""); //String -} - -dojo._xdExtractLoadInits = function(/*String*/fileContents){ - //Extracts - var regexp = /dojo.loadInit\s*\(/g; - regexp.lastIndex = 0; - - var parenRe = /[\(\)]/g; - parenRe.lastIndex = 0; - - var results = []; - var matches; - while((matches = regexp.exec(fileContents))){ - //Find end of the call by finding the matching end paren - parenRe.lastIndex = regexp.lastIndex; - var matchCount = 1; - var parenMatch; - while((parenMatch = parenRe.exec(fileContents))){ - if(parenMatch[0] == ")"){ - matchCount -= 1; - }else{ - matchCount += 1; - } - if(matchCount == 0){ - break; - } - } - - if(matchCount != 0){ - throw "unmatched paren around character " + parenRe.lastIndex + " in: " + fileContents; - } - - //Put the master matching string in the results. - var startIndex = regexp.lastIndex - matches[0].length; - results.push(fileContents.substring(startIndex, parenRe.lastIndex)); - - //Remove the matching section. - var remLength = parenRe.lastIndex - startIndex; - fileContents = fileContents.substring(0, startIndex) + fileContents.substring(parenRe.lastIndex, fileContents.length); - - //Move the master regexp past the last matching paren point. - regexp.lastIndex = parenRe.lastIndex - remLength; - - regexp.lastIndex = parenRe.lastIndex; - } - - if(results.length > 0){ - results.unshift(fileContents); - } - - return (results.length ? results : null); -} - -dojo._xdIsXDomainPath = function(/*string*/relpath) { - //summary: Figure out whether the path is local or x-domain - //If there is a colon before the first / then, we have a URL with a protocol. - - var colonIndex = relpath.indexOf(":"); - var slashIndex = relpath.indexOf("/"); - - if(colonIndex > 0 && colonIndex < slashIndex || relpath.indexOf("//") === 0){ - return true; - }else{ - //Is the base script URI-based URL a cross domain URL? - //If so, then the relpath will be evaluated relative to - //baseUrl, and therefore qualify as xdomain. - //Only treat it as xdomain if the page does not have a - //host (file:// url), if the baseUrl does not match the - //current window's domain, or if the baseUrl starts with //. - //If baseUrl starts with // then it probably means that xdomain - //is wanted since it is such a specific path request. This is not completely robust, - //but something more robust would require normalizing the protocol on baseUrl and on the location - //to see if they differ. However, that requires more code, and // as a start path is unusual. - var url = dojo.baseUrl; - colonIndex = url.indexOf(":"); - slashIndex = url.indexOf("/"); - if(url.indexOf("//") === 0 || (colonIndex > 0 && colonIndex < slashIndex && (!location.host || url.indexOf("http://" + location.host) != 0))){ - return true; - } - } - return false; -} - -dojo._loadPath = function(/*String*/relpath, /*String?*/module, /*Function?*/cb){ - //summary: Internal xd loader function. Overrides loadPath() from loader.js. - //xd loading requires slightly different behavior from loadPath(). - - var currentIsXDomain = dojo._xdIsXDomainPath(relpath); - dojo._isXDomain |= currentIsXDomain; - - var uri = ((relpath.charAt(0) == '/' || relpath.match(/^\w+:/)) ? "" : dojo.baseUrl) + relpath; - - try{ - return ((!module || dojo._isXDomain) ? dojo._loadUri(uri, cb, currentIsXDomain, module) : dojo._loadUriAndCheck(uri, module, cb)); //Boolean - }catch(e){ - console.error(e); - return false; //Boolean - } -} - -dojo._xdCharSet = "utf-8"; - -dojo._loadUri = function(/*String*/uri, /*Function?*/cb, /*boolean*/currentIsXDomain, /*String?*/module){ - //summary: Internal xd loader function. Overrides loadUri() from loader.js. - // xd loading requires slightly different behavior from loadPath(). - //description: Wanted to override getText(), but it is used by - // the widget code in too many, synchronous ways right now. - if(dojo._loadedUrls[uri]){ - return 1; //Boolean - } - - //Add the module (resource) to the list of modules. - //Only do this work if we have a modlue name. Otherwise, - //it is a non-xd i18n bundle, which can load immediately and does not - //need to be tracked. Also, don't track dojo.i18n, since it is a prerequisite - //and will be loaded correctly if we load it right away: it has no dependencies. - if(dojo._isXDomain && module && module != "dojo.i18n"){ - dojo._xdOrderedReqs.push(module); - - //Add to waiting resources if it is an xdomain resource. - //Don't add non-xdomain i18n bundles, those get evaled immediately. - if(currentIsXDomain || uri.indexOf("/nls/") == -1){ - dojo._xdInFlight[module] = true; - - //Increment inFlightCount - //This will stop the modulesLoaded from firing all the way. - dojo._inFlightCount++; - } - - //Start timer - if(!dojo._xdTimer){ - if(dojo.isAIR){ - dojo._xdTimer = setInterval(function(){dojo._xdWatchInFlight();}, 100); - }else{ - dojo._xdTimer = setInterval(dojo._scopeName + "._xdWatchInFlight();", 100); - } - } - dojo._xdStartTime = (new Date()).getTime(); - } - - if (currentIsXDomain){ - //Fix name to be a .xd.fileextension name. - var lastIndex = uri.lastIndexOf('.'); - if(lastIndex <= 0){ - lastIndex = uri.length - 1; - } - - var xdUri = uri.substring(0, lastIndex) + ".xd"; - if(lastIndex != uri.length - 1){ - xdUri += uri.substring(lastIndex, uri.length); - } - - if (dojo.isAIR){ - xdUri = xdUri.replace("app:/", "/"); - } - - //Add to script src - var element = document.createElement("script"); - element.type = "text/javascript"; - if(dojo._xdCharSet){ - element.charset = dojo._xdCharSet; - } - element.src = xdUri; - if(!dojo.headElement){ - dojo._headElement = document.getElementsByTagName("head")[0]; - - //Head element may not exist, particularly in html - //html 4 or tag soup cases where the page does not - //have a head tag in it. Use html element, since that will exist. - //Seems to be an issue mostly with Opera 9 and to lesser extent Safari 2 - if(!dojo._headElement){ - dojo._headElement = document.getElementsByTagName("html")[0]; - } - } - dojo._headElement.appendChild(element); - }else{ - var contents = dojo._getText(uri, null, true); - if(contents == null){ return 0; /*boolean*/} - - //If this is not xdomain, or if loading a i18n resource bundle, then send it down - //the normal eval/callback path. - if(dojo._isXDomain - && uri.indexOf("/nls/") == -1 - && module != "dojo.i18n"){ - var res = dojo._xdCreateResource(contents, module, uri); - dojo.eval(res); - }else{ - 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 = dojo._scopePrefix + contents + dojo._scopeSuffix; - } - var value = dojo["eval"](contents+"\r\n//@ sourceURL="+uri); - if(cb){ - cb(value); - } - } - } - - //These steps are done in the non-xd loader version of this function. - //Maintain these steps to fit in with the existing system. - dojo._loadedUrls[uri] = true; - dojo._loadedUrls.push(uri); - return true; //Boolean -} - -dojo._xdResourceLoaded = function(/*Object*/res){ - //summary: Internal xd loader function. Called by an xd module resource when - //it has been loaded via a script tag. - - //Evaluate the function with scopeArgs for multiversion support. - res = res.apply(dojo.global, dojo._scopeArgs); - - //Work through dependencies. - var deps = res.depends; - var requireList = null; - var requireAfterList = null; - var provideList = []; - if(deps && deps.length > 0){ - var dep = null; - var insertHint = 0; - var attachedResource = false; - for(var i = 0; i < deps.length; i++){ - dep = deps[i]; - - //Look for specific dependency indicators. - if (dep[0] == "provide"){ - provideList.push(dep[1]); - }else{ - if(!requireList){ - requireList = []; - } - if(!requireAfterList){ - requireAfterList = []; - } - - var unpackedDeps = dojo._xdUnpackDependency(dep); - if(unpackedDeps.requires){ - requireList = requireList.concat(unpackedDeps.requires); - } - if(unpackedDeps.requiresAfter){ - requireAfterList = requireAfterList.concat(unpackedDeps.requiresAfter); - } - } - - //Call the dependency indicator to allow for the normal dojo setup. - //Only allow for one dot reference, for the i18n._preloadLocalizations calls - //(and maybe future, one-dot things). - var depType = dep[0]; - var objPath = depType.split("."); - if(objPath.length == 2){ - dojo[objPath[0]][objPath[1]].apply(dojo[objPath[0]], dep.slice(1)); - }else{ - dojo[depType].apply(dojo, dep.slice(1)); - } - } - - - //If loading the debugAtAllCosts module, eval it right away since we need - //its functions to properly load the other modules. - if(provideList.length == 1 && provideList[0] == "dojo._base._loader.loader_debug"){ - res.defineResource(dojo); - }else{ - //Save off the resource contents for definition later. - var contentIndex = dojo._xdContents.push({ - content: res.defineResource, - resourceName: res["resourceName"], - resourcePath: res["resourcePath"], - isDefined: false - }) - 1; - - //Add provide/requires to dependency map. - for(i = 0; i < provideList.length; i++){ - dojo._xdDepMap[provideList[i]] = { requires: requireList, requiresAfter: requireAfterList, contentIndex: contentIndex }; - } - } - - //Now update the inflight status for any provided resources in this loaded resource. - //Do this at the very end (in a *separate* for loop) to avoid shutting down the - //inflight timer check too soon. - for(i = 0; i < provideList.length; i++){ - dojo._xdInFlight[provideList[i]] = false; - } - } -} - -dojo._xdLoadFlattenedBundle = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale, /*Object*/bundleData){ - //summary: Internal xd loader function. Used when loading - //a flattened localized bundle via a script tag. - locale = locale || "root"; - var jsLoc = dojo.i18n.normalizeLocale(locale).replace('-', '_'); - var bundleResource = [moduleName, "nls", bundleName].join("."); - var bundle = dojo["provide"](bundleResource); - bundle[jsLoc] = bundleData; - - //Assign the bundle for the original locale(s) we wanted. - var mapName = [moduleName, jsLoc, bundleName].join("."); - var bundleMap = dojo._xdBundleMap[mapName]; - if(bundleMap){ - for(var param in bundleMap){ - bundle[param] = bundleData; - } - } -}; - - -dojo._xdInitExtraLocales = function(){ - // Simulate the extra locale work that dojo.requireLocalization does. - - var extra = dojo.config.extraLocale; - if(extra){ - if(!extra instanceof Array){ - extra = [extra]; - } - - dojo._xdReqLoc = dojo.xdRequireLocalization; - dojo.xdRequireLocalization = function(m, b, locale, fLocales){ - dojo._xdReqLoc(m,b,locale, fLocales); - if(locale){return;} - for(var i=0; i<extra.length; i++){ - dojo._xdReqLoc(m,b,extra[i], fLocales); - } - }; - } -} - -dojo._xdBundleMap = {}; - -dojo.xdRequireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale, /*String*/availableFlatLocales){ - //summary: Internal xd loader function. The xd version of dojo.requireLocalization. - - - //Account for allowing multiple extra locales. Do this here inside the function - //since dojo._xdInitExtraLocales() depends on djConfig being set up, but that only - //happens after hostenv_browser runs. loader_xd has to come before hostenv_browser - //though since hostenv_browser can do a dojo.require for the debug module. - if(dojo._xdInitExtraLocales){ - dojo._xdInitExtraLocales(); - dojo._xdInitExtraLocales = null; - dojo.xdRequireLocalization.apply(dojo, arguments); - return; - } - - var locales = availableFlatLocales.split(","); - - //Find the best-match locale to load. - //Assumes dojo.i18n has already been loaded. This is true for xdomain builds, - //since it is included in dojo.xd.js. - var jsLoc = dojo.i18n.normalizeLocale(locale); - - var bestLocale = ""; - for(var i = 0; i < locales.length; i++){ - //Locale must match from start of string. - if(jsLoc.indexOf(locales[i]) == 0){ - if(locales[i].length > bestLocale.length){ - bestLocale = locales[i]; - } - } - } - - var fixedBestLocale = bestLocale.replace('-', '_'); - //See if the bundle we are going to use is already loaded. - var bundleResource = dojo.getObject([moduleName, "nls", bundleName].join(".")); - if(!bundleResource || !bundleResource[fixedBestLocale]){ - //Need to remember what locale we wanted and which one we actually use. - //Then when we load the one we are actually using, use that bundle for the one - //we originally wanted. - var mapName = [moduleName, (fixedBestLocale||"root"), bundleName].join("."); - var bundleMap = dojo._xdBundleMap[mapName]; - if(!bundleMap){ - bundleMap = dojo._xdBundleMap[mapName] = {}; - } - bundleMap[jsLoc.replace('-', '_')] = true; - - //Do just a normal dojo.require so the resource tracking stuff works as usual. - dojo.require(moduleName + ".nls" + (bestLocale ? "." + bestLocale : "") + "." + bundleName); - } -} - -// Replace dojo.requireLocalization with a wrapper -dojo._xdRealRequireLocalization = dojo.requireLocalization; -dojo.requireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale, /*String*/availableFlatLocales){ - // summary: loads a bundle intelligently based on whether the module is - // local or xd. Overrides the local-case implementation. - - var modulePath = dojo.moduleUrl(moduleName).toString(); - if (dojo._xdIsXDomainPath(modulePath)) { - // call cross-domain loader - return dojo.xdRequireLocalization.apply(dojo, arguments); - } else { - // call local-loader - return dojo._xdRealRequireLocalization.apply(dojo, arguments); - } -} - -//This is a bit brittle: it has to know about the dojo methods that deal with dependencies -//It would be ideal to intercept the actual methods and do something fancy at that point, -//but I have concern about knowing which provide to match to the dependency in that case, -//since scripts can load whenever they want, and trigger new calls to dojo._xdResourceLoaded(). -dojo._xdUnpackDependency = function(/*Array*/dep){ - //summary: Internal xd loader function. Determines what to do with a dependency - //that was listed in an xd version of a module contents. - - //Extract the dependency(ies). - var newDeps = null; - var newAfterDeps = null; - switch(dep[0]){ - case "requireIf": - case "requireAfterIf": - //First arg (dep[1]) is the test. Depedency is dep[2]. - if(dep[1] === true){ - newDeps = [{name: dep[2], content: null}]; - } - break; - case "platformRequire": - var modMap = dep[1]; - var common = modMap["common"]||[]; - newDeps = (modMap[dojo.hostenv.name_]) ? common.concat(modMap[dojo.hostenv.name_]||[]) : common.concat(modMap["default"]||[]); - //Flatten the array of arrays into a one-level deep array. - //Each result could be an array of 3 elements (the 3 arguments to dojo.require). - //We only need the first one. - if(newDeps){ - for(var i = 0; i < newDeps.length; i++){ - if(newDeps[i] instanceof Array){ - newDeps[i] = {name: newDeps[i][0], content: null}; - }else{ - newDeps[i] = {name: newDeps[i], content: null}; - } - } - } - break; - case "require": - //Just worry about dep[1] - newDeps = [{name: dep[1], content: null}]; - break; - case "i18n._preloadLocalizations": - //We can eval these immediately, since they load i18n bundles. - //Since i18n bundles have no dependencies, whenever they are loaded - //in a script tag, they are evaluated immediately, so we do not have to - //treat them has an explicit dependency for the dependency mapping. - //We can call it immediately since dojo.i18n is part of dojo.xd.js. - dojo.i18n._preloadLocalizations.apply(dojo.i18n._preloadLocalizations, dep.slice(1)); - break; - } - - //The requireIf and requireAfterIf needs to be evaluated after the current resource is evaluated. - if(dep[0] == "requireAfterIf" || dep[0] == "requireIf"){ - newAfterDeps = newDeps; - newDeps = null; - } - return {requires: newDeps, requiresAfter: newAfterDeps}; //Object -} - -dojo._xdWalkReqs = function(){ - //summary: Internal xd loader function. - //Walks the requires and evaluates module resource contents in - //the right order. - var reqChain = null; - var req; - for(var i = 0; i < dojo._xdOrderedReqs.length; i++){ - req = dojo._xdOrderedReqs[i]; - if(dojo._xdDepMap[req]){ - reqChain = [req]; - reqChain[req] = true; //Allow for fast lookup of the req in the array - dojo._xdEvalReqs(reqChain); - } - } -} - -dojo._xdEvalReqs = function(/*Array*/reqChain){ - //summary: Internal xd loader function. - //Does a depth first, breadth second search and eval of required modules. - while(reqChain.length > 0){ - var req = reqChain[reqChain.length - 1]; - var res = dojo._xdDepMap[req]; - var i, reqs, nextReq; - if(res){ - //Trace down any requires for this resource. - //START dojo._xdTraceReqs() inlining for small Safari 2.0 call stack - reqs = res.requires; - if(reqs && reqs.length > 0){ - for(i = 0; i < reqs.length; i++){ - nextReq = reqs[i].name; - if(nextReq && !reqChain[nextReq]){ - //New req depedency. Follow it down. - reqChain.push(nextReq); - reqChain[nextReq] = true; - dojo._xdEvalReqs(reqChain); - } - } - } - //END dojo._xdTraceReqs() inlining for small Safari 2.0 call stack - - //Evaluate the resource. - var contents = dojo._xdContents[res.contentIndex]; - if(!contents.isDefined){ - var content = contents.content; - content["resourceName"] = contents["resourceName"]; - content["resourcePath"] = contents["resourcePath"]; - dojo._xdDefList.push(content); - contents.isDefined = true; - } - dojo._xdDepMap[req] = null; - - //Trace down any requireAfters for this resource. - //START dojo._xdTraceReqs() inlining for small Safari 2.0 call stack - reqs = res.requiresAfter; - if(reqs && reqs.length > 0){ - for(i = 0; i < reqs.length; i++){ - nextReq = reqs[i].name; - if(nextReq && !reqChain[nextReq]){ - //New req depedency. Follow it down. - reqChain.push(nextReq); - reqChain[nextReq] = true; - dojo._xdEvalReqs(reqChain); - } - } - } - //END dojo._xdTraceReqs() inlining for small Safari 2.0 call stack - } - - //Done with that require. Remove it and go to the next one. - reqChain.pop(); - } -} - -dojo._xdWatchInFlight = function(){ - //summary: Internal xd loader function. - //Monitors in-flight requests for xd module resources. - - var noLoads = ""; - var waitInterval = (dojo.config.xdWaitSeconds || 15) * 1000; - var expired = (dojo._xdStartTime + waitInterval) < (new Date()).getTime(); - - //If any xdInFlight are true, then still waiting for something to load. - //Come back later. If we timed out, report the things that did not load. - for(var param in dojo._xdInFlight){ - if(dojo._xdInFlight[param] === true){ - if(expired){ - noLoads += param + " "; - }else{ - return; - } - } - } - - //All done. Clean up and notify. - dojo._xdClearInterval(); - - if(expired){ - throw "Could not load cross-domain resources: " + noLoads; - } - - dojo._xdWalkReqs(); - - var defLength = dojo._xdDefList.length; - for(var i= 0; i < defLength; i++){ - var content = dojo._xdDefList[i]; - if(dojo.config["debugAtAllCosts"] && content["resourceName"]){ - if(!dojo["_xdDebugQueue"]){ - dojo._xdDebugQueue = []; - } - dojo._xdDebugQueue.push({resourceName: content.resourceName, resourcePath: content.resourcePath}); - }else{ - //Evaluate the resource to bring it into being. - //Pass in scope args to allow multiple versions of modules in a page. - content.apply(dojo.global, dojo._scopeArgs); - } - } - - //Evaluate any resources that were not evaled before. - //This normally shouldn't happen with proper dojo.provide and dojo.require - //usage, but providing it just in case. Note that these may not be executed - //in the original order that the developer intended. - for(i = 0; i < dojo._xdContents.length; i++){ - var current = dojo._xdContents[i]; - if(current.content && !current.isDefined){ - //Pass in scope args to allow multiple versions of modules in a page. - current.content.apply(dojo.global, dojo._scopeArgs); - } - } - - //Clean up for the next round of xd loading. - dojo._xdReset(); - - if(dojo["_xdDebugQueue"] && dojo._xdDebugQueue.length > 0){ - dojo._xdDebugFileLoaded(); - }else{ - dojo._xdNotifyLoaded(); - } -} - -dojo._xdNotifyLoaded = function(){ - //Clear inflight count so we will finally do finish work. - - //Just having a legitimate status (true or false) for an inflight item - //means that it is still being processed. Do the typeof test - //to avoid bad JavaScript that might tinker with Object.prototype. - for(var prop in dojo._xdInFlight){ - if(typeof dojo._xdInFlight[prop] == "boolean"){ - return; - } - } - - dojo._inFlightCount = 0; - - //Only trigger call loaded if dj_load_init has run. - if(dojo._initFired && !dojo._loadNotifying){ - dojo._callLoaded(); - } -} - -} diff --git a/lib/dojo/_base/array.js b/lib/dojo/_base/array.js index 57cea4229..f25c2ad00 100644 --- a/lib/dojo/_base/array.js +++ b/lib/dojo/_base/array.js @@ -4,260 +4,5 @@ see: http://dojotoolkit.org/license for details */ - -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"); -dojo.require("dojo._base.lang"); - - -(function(){ - var _getParts = function(arr, obj, cb){ - return [ - (typeof arr == "string") ? arr.split("") : arr, - obj || dojo.global, - // FIXME: cache the anonymous functions we create here? - (typeof cb == "string") ? new Function("item", "index", "array", cb) : cb - ]; - }; - - var 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 - }; - - 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: - // This method corresponds to the JavaScript 1.6 Array.indexOf method, with one difference: when - // run over sparse arrays, the Dojo function invokes the callback for every index whereas JavaScript - // 1.6's indexOf skips the holes in the sparse array. - // For details on this method, see: - // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/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: - // This method corresponds to the JavaScript 1.6 Array.lastIndexOf method, with one difference: when - // run over sparse arrays, the Dojo function invokes the callback for every index whereas JavaScript - // 1.6's lastIndexOf skips the holes in the sparse array. - // For details on this method, see: - // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/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. - // If you want to break out of the loop, consider using dojo.every() or dojo.some(). - // forEach does not allow breaking out of the loop over the items in arr. - // 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, with one difference: when - // run over sparse arrays, this implemenation passes the "holes" in the sparse array to - // the callback function with a value of undefined. JavaScript 1.6's forEach skips the holes in the sparse array. - // For more details, see: - // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/forEach - // example: - // | // log out all members of the array: - // | dojo.forEach( - // | [ "thinger", "blah", "howdy", 10 ], - // | function(item){ - // | console.log(item); - // | } - // | ); - // example: - // | // log out the members and their indexes - // | dojo.forEach( - // | [ "thinger", "blah", "howdy", 10 ], - // | function(item, idx, arr){ - // | console.log(item, "at index:", idx); - // | } - // | ); - // example: - // | // use a scoped object member as the callback - // | - // | var obj = { - // | prefix: "logged via obj.callback:", - // | callback: function(item){ - // | console.log(this.prefix, 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); - } - }, - - 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, with one difference: when - // run over sparse arrays, this implemenation passes the "holes" in the sparse array to - // the callback function with a value of undefined. JavaScript 1.6's every skips the holes in the sparse array. - // For more details, see: - // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/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 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, with one difference: when - // run over sparse arrays, this implemenation passes the "holes" in the sparse array to - // the callback function with a value of undefined. JavaScript 1.6's some skips the holes in the sparse array. - // For more details, see: - // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/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 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, with one difference: when - // run over sparse arrays, this implemenation passes the "holes" in the sparse array to - // the callback function with a value of undefined. JavaScript 1.6's map skips the holes in the sparse array. - // For more details, see: - // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/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, with one difference: when - // run over sparse arrays, this implemenation passes the "holes" in the sparse array to - // the callback function with a value of undefined. JavaScript 1.6's filter skips the holes in the sparse array. - // For more details, see: - // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/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 - } - }); -})(); -/* -*/ - -} +//>>built +define("dojo/_base/array",["./kernel","../has","./lang"],function(_1,_2,_3){var _4={},u,_5;function _6(){_4={};};function _7(fn){return _4[fn]=new Function("item","index","array",fn);};function _8(_9){var _a=!_9;return function(a,fn,o){var i=0,l=a&&a.length||0,_b;if(l&&typeof a=="string"){a=a.split("");}if(typeof fn=="string"){fn=_4[fn]||_7(fn);}if(o){for(;i<l;++i){_b=!fn.call(o,a[i],i,a);if(_9^_b){return !_b;}}}else{for(;i<l;++i){_b=!fn(a[i],i,a);if(_9^_b){return !_b;}}}return _a;};};function _c(up){var _d=1,_e=0,_f=0;if(!up){_d=_e=_f=-1;}return function(a,x,_10,_11){if(_11&&_d>0){return _5.lastIndexOf(a,x,_10);}var l=a&&a.length||0,end=up?l+_f:_e,i;if(_10===u){i=up?_e:l+_f;}else{if(_10<0){i=l+_10;if(i<0){i=_e;}}else{i=_10>=l?l+_f:_10;}}if(l&&typeof a=="string"){a=a.split("");}for(;i!=end;i+=_d){if(a[i]==x){return i;}}return -1;};};function _12(a,fn,o){var i=0,l=a&&a.length||0;if(l&&typeof a=="string"){a=a.split("");}if(typeof fn=="string"){fn=_4[fn]||_7(fn);}if(o){for(;i<l;++i){fn.call(o,a[i],i,a);}}else{for(;i<l;++i){fn(a[i],i,a);}}};function map(a,fn,o,Ctr){var i=0,l=a&&a.length||0,out=new (Ctr||Array)(l);if(l&&typeof a=="string"){a=a.split("");}if(typeof fn=="string"){fn=_4[fn]||_7(fn);}if(o){for(;i<l;++i){out[i]=fn.call(o,a[i],i,a);}}else{for(;i<l;++i){out[i]=fn(a[i],i,a);}}return out;};function _13(a,fn,o){var i=0,l=a&&a.length||0,out=[],_14;if(l&&typeof a=="string"){a=a.split("");}if(typeof fn=="string"){fn=_4[fn]||_7(fn);}if(o){for(;i<l;++i){_14=a[i];if(fn.call(o,_14,i,a)){out.push(_14);}}}else{for(;i<l;++i){_14=a[i];if(fn(_14,i,a)){out.push(_14);}}}return out;};_5={every:_8(false),some:_8(true),indexOf:_c(true),lastIndexOf:_c(false),forEach:_12,map:map,filter:_13,clearCache:_6};1&&_3.mixin(_1,_5);return _5;});
\ No newline at end of file diff --git a/lib/dojo/_base/array.js.uncompressed.js b/lib/dojo/_base/array.js.uncompressed.js new file mode 100644 index 000000000..06e733b4b --- /dev/null +++ b/lib/dojo/_base/array.js.uncompressed.js @@ -0,0 +1,343 @@ +define("dojo/_base/array", ["./kernel", "../has", "./lang"], function(dojo, has, lang){ + // module: + // dojo/_base/array + // summary: + // This module defines the Javascript v1.6 array extensions. + + /*===== + dojo.indexOf = function(arr, value, fromIndex, findLast){ + // summary: + // locates the first index of the provided value in the + // passed array. If the value is not found, -1 is returned. + // description: + // This method corresponds to the JavaScript 1.6 Array.indexOf method, with one difference: when + // run over sparse arrays, the Dojo function invokes the callback for every index whereas JavaScript + // 1.6's indexOf skips the holes in the sparse array. + // For details on this method, see: + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/indexOf + // arr: Array + // value: Object + // fromIndex: Integer? + // findLast: Boolean? + // returns: Number + }; + dojo.lastIndexOf = function(arr, value, fromIndex){ + // summary: + // locates the last index of the provided value in the passed + // array. If the value is not found, -1 is returned. + // description: + // This method corresponds to the JavaScript 1.6 Array.lastIndexOf method, with one difference: when + // run over sparse arrays, the Dojo function invokes the callback for every index whereas JavaScript + // 1.6's lastIndexOf skips the holes in the sparse array. + // For details on this method, see: + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/lastIndexOf + // arr: Array, + // value: Object, + // fromIndex: Integer? + // returns: Number + }; + dojo.forEach = function(arr, callback, thisObject){ + // summary: + // for every item in arr, callback is invoked. Return values are ignored. + // If you want to break out of the loop, consider using dojo.every() or dojo.some(). + // forEach does not allow breaking out of the loop over the items in arr. + // 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, with one difference: when + // run over sparse arrays, this implementation passes the "holes" in the sparse array to + // the callback function with a value of undefined. JavaScript 1.6's forEach skips the holes in the sparse array. + // For more details, see: + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/forEach + // example: + // | // log out all members of the array: + // | dojo.forEach( + // | [ "thinger", "blah", "howdy", 10 ], + // | function(item){ + // | console.log(item); + // | } + // | ); + // example: + // | // log out the members and their indexes + // | dojo.forEach( + // | [ "thinger", "blah", "howdy", 10 ], + // | function(item, idx, arr){ + // | console.log(item, "at index:", idx); + // | } + // | ); + // example: + // | // use a scoped object member as the callback + // | + // | var obj = { + // | prefix: "logged via obj.callback:", + // | callback: function(item){ + // | console.log(this.prefix, 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") + // | ); + // arr: Array|String + // callback: Function|String + // thisObject: Object? + }; + dojo.every = function(arr, callback, thisObject){ + // summary: + // Determines whether or not every item in arr satisfies the + // condition implemented by callback. + // arr: Array|String + // the array to iterate on. If a string, operates on individual characters. + // callback: Function|String + // a function is invoked with three arguments: item, index, + // and array and returns true if the condition is met. + // thisObject: Object? + // may be used to scope the call to callback + // returns: Boolean + // description: + // This function corresponds to the JavaScript 1.6 Array.every() method, with one difference: when + // run over sparse arrays, this implementation passes the "holes" in the sparse array to + // the callback function with a value of undefined. JavaScript 1.6's every skips the holes in the sparse array. + // For more details, see: + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/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; }); + }; + dojo.some = function(arr, callback, thisObject){ + // summary: + // Determines whether or not any item in arr satisfies the + // condition implemented by callback. + // arr: Array|String + // the array to iterate over. If a string, operates on individual characters. + // callback: Function|String + // a function is invoked with three arguments: item, index, + // and array and returns true if the condition is met. + // thisObject: Object? + // may be used to scope the call to callback + // returns: Boolean + // description: + // This function corresponds to the JavaScript 1.6 Array.some() method, with one difference: when + // run over sparse arrays, this implementation passes the "holes" in the sparse array to + // the callback function with a value of undefined. JavaScript 1.6's some skips the holes in the sparse array. + // For more details, see: + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/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; }); + }; + dojo.map = function(arr, callback, thisObject){ + // summary: + // applies callback to each element of arr and returns + // an Array with the results + // arr: Array|String + // the array to iterate on. If a string, operates on + // individual characters. + // callback: Function|String + // a function is invoked with three arguments, (item, index, + // array), and returns a value + // thisObject: Object? + // may be used to scope the call to callback + // returns: Array + // description: + // This function corresponds to the JavaScript 1.6 Array.map() method, with one difference: when + // run over sparse arrays, this implementation passes the "holes" in the sparse array to + // the callback function with a value of undefined. JavaScript 1.6's map skips the holes in the sparse array. + // For more details, see: + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map + // example: + // | // returns [2, 3, 4, 5] + // | dojo.map([1, 2, 3, 4], function(item){ return item+1 }); + }; + dojo.filter = function(arr, callback, thisObject){ + // summary: + // Returns a new Array with those items from arr that match the + // condition implemented by callback. + // arr: Array + // the array to iterate over. + // callback: Function|String + // 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: Object? + // may be used to scope the call to callback + // returns: Array + // description: + // This function corresponds to the JavaScript 1.6 Array.filter() method, with one difference: when + // run over sparse arrays, this implementation passes the "holes" in the sparse array to + // the callback function with a value of undefined. JavaScript 1.6's filter skips the holes in the sparse array. + // For more details, see: + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter + // example: + // | // returns [2, 3, 4] + // | dojo.filter([1, 2, 3, 4], function(item){ return item>1; }); + }; + =====*/ + + // our old simple function builder stuff + var cache = {}, u, array; // the export object + + function clearCache(){ + cache = {}; + } + + function buildFn(fn){ + return cache[fn] = new Function("item", "index", "array", fn); // Function + } + // magic snippet: if(typeof fn == "string") fn = cache[fn] || buildFn(fn); + + // every & some + + function everyOrSome(some){ + var every = !some; + return function(a, fn, o){ + var i = 0, l = a && a.length || 0, result; + if(l && typeof a == "string") a = a.split(""); + if(typeof fn == "string") fn = cache[fn] || buildFn(fn); + if(o){ + for(; i < l; ++i){ + result = !fn.call(o, a[i], i, a); + if(some ^ result){ + return !result; + } + } + }else{ + for(; i < l; ++i){ + result = !fn(a[i], i, a); + if(some ^ result){ + return !result; + } + } + } + return every; // Boolean + } + } + // var every = everyOrSome(false), some = everyOrSome(true); + + // indexOf, lastIndexOf + + function index(up){ + var delta = 1, lOver = 0, uOver = 0; + if(!up){ + delta = lOver = uOver = -1; + } + return function(a, x, from, last){ + if(last && delta > 0){ + // TODO: why do we use a non-standard signature? why do we need "last"? + return array.lastIndexOf(a, x, from); + } + var l = a && a.length || 0, end = up ? l + uOver : lOver, i; + if(from === u){ + i = up ? lOver : l + uOver; + }else{ + if(from < 0){ + i = l + from; + if(i < 0){ + i = lOver; + } + }else{ + i = from >= l ? l + uOver : from; + } + } + if(l && typeof a == "string") a = a.split(""); + for(; i != end; i += delta){ + if(a[i] == x){ + return i; // Number + } + } + return -1; // Number + } + } + // var indexOf = index(true), lastIndexOf = index(false); + + function forEach(a, fn, o){ + var i = 0, l = a && a.length || 0; + if(l && typeof a == "string") a = a.split(""); + if(typeof fn == "string") fn = cache[fn] || buildFn(fn); + if(o){ + for(; i < l; ++i){ + fn.call(o, a[i], i, a); + } + }else{ + for(; i < l; ++i){ + fn(a[i], i, a); + } + } + } + + function map(a, fn, o, Ctr){ + // TODO: why do we have a non-standard signature here? do we need "Ctr"? + var i = 0, l = a && a.length || 0, out = new (Ctr || Array)(l); + if(l && typeof a == "string") a = a.split(""); + if(typeof fn == "string") fn = cache[fn] || buildFn(fn); + if(o){ + for(; i < l; ++i){ + out[i] = fn.call(o, a[i], i, a); + } + }else{ + for(; i < l; ++i){ + out[i] = fn(a[i], i, a); + } + } + return out; // Array + } + + function filter(a, fn, o){ + // TODO: do we need "Ctr" here like in map()? + var i = 0, l = a && a.length || 0, out = [], value; + if(l && typeof a == "string") a = a.split(""); + if(typeof fn == "string") fn = cache[fn] || buildFn(fn); + if(o){ + for(; i < l; ++i){ + value = a[i]; + if(fn.call(o, value, i, a)){ + out.push(value); + } + } + }else{ + for(; i < l; ++i){ + value = a[i]; + if(fn(value, i, a)){ + out.push(value); + } + } + } + return out; // Array + } + + array = { + every: everyOrSome(false), + some: everyOrSome(true), + indexOf: index(true), + lastIndexOf: index(false), + forEach: forEach, + map: map, + filter: filter, + clearCache: clearCache + }; + + 1 && lang.mixin(dojo, array); + + /*===== return dojo.array; =====*/ + return array; +}); diff --git a/lib/dojo/_base/browser.js b/lib/dojo/_base/browser.js index 209330f0d..69d57f4cf 100644 --- a/lib/dojo/_base/browser.js +++ b/lib/dojo/_base/browser.js @@ -4,25 +4,5 @@ see: http://dojotoolkit.org/license for details */ - -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"); -dojo.require("dojo._base.window"); -dojo.require("dojo._base.connect"); -dojo.require("dojo._base.event"); -dojo.require("dojo._base.html"); -dojo.require("dojo._base.NodeList"); -dojo.require("dojo._base.query"); -dojo.require("dojo._base.xhr"); -dojo.require("dojo._base.fx"); - - //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/ - dojo.forEach(dojo.config.require, function(i){ - dojo["require"](i); - }); - -} +//>>built +if(require.has){require.has.add("config-selectorEngine","acme");}define("dojo/_base/browser",["../ready","./kernel","./connect","./unload","./window","./event","./html","./NodeList","../query","./xhr","./fx"],function(_1){return _1;});
\ No newline at end of file diff --git a/lib/dojo/_base/browser.js.uncompressed.js b/lib/dojo/_base/browser.js.uncompressed.js new file mode 100644 index 000000000..8f186e2a1 --- /dev/null +++ b/lib/dojo/_base/browser.js.uncompressed.js @@ -0,0 +1,21 @@ +if(require.has){ + require.has.add("config-selectorEngine", "acme"); +} +define("dojo/_base/browser", [ + "../ready", + "./kernel", + "./connect", // until we decide if connect is going back into non-browser environments + "./unload", + "./window", + "./event", + "./html", + "./NodeList", + "../query", + "./xhr", + "./fx"], function(dojo) { + // module: + // dojo/_base/browser + // summary: + // This module causes the browser-only base modules to be loaded. + return dojo; +}); diff --git a/lib/dojo/_base/config.js b/lib/dojo/_base/config.js new file mode 100644 index 000000000..5c70ffd91 --- /dev/null +++ b/lib/dojo/_base/config.js @@ -0,0 +1,8 @@ +/* + Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Available via Academic Free License >= 2.1 OR the modified BSD license. + see: http://dojotoolkit.org/license for details +*/ + +//>>built +define("dojo/_base/config",["../has","require"],function(_1,_2){var _3={};if(1){var _4=_2.rawConfig,p;for(p in _4){_3[p]=_4[p];}}else{var _5=function(_6,_7,_8){for(p in _6){p!="has"&&_1.add(_7+p,_6[p],0,_8);}};_3=1?_2.rawConfig:this.dojoConfig||this.djConfig||{};_5(_3,"config",1);_5(_3.has,"",1);}return _3;});
\ No newline at end of file diff --git a/lib/dojo/_base/config.js.uncompressed.js b/lib/dojo/_base/config.js.uncompressed.js new file mode 100644 index 000000000..290efd10a --- /dev/null +++ b/lib/dojo/_base/config.js.uncompressed.js @@ -0,0 +1,174 @@ +define("dojo/_base/config", ["../has", "require"], function(has, require){ + // module: + // dojo/_base/config + // summary: + // This module defines the user configuration during bootstrap. + // description: + // By defining user configuration as a module value, an entire configuration can be specified in a build, + // thereby eliminating the need for sniffing and or explicitly setting in the global variable dojoConfig. + // Also, when multiple instances of dojo exist in a single application, each will necessarily be located + // at an unique absolute module identifier as given by the package configuration. Implementing configuration + // as a module allows for specifying unique, per-instance configurations. + // example: + // Create a second instance of dojo with a different, instance-uniqe configuration (assume the loader and + // dojo.js are already loaded). + // | // specify a configuration that creates a new instance of dojo at the absolute module identifier "myDojo" + // | require({ + // | packages:[{ + // | name:"myDojo", + // | location:".", //assume baseUrl points to dojo.js + // | }] + // | }); + // | + // | // specify a configuration for the myDojo instance + // | define("myDojo/config", { + // | // normal configuration variables go here, e.g., + // | locale:"fr-ca" + // | }); + // | + // | // load and use the new instance of dojo + // | require(["myDojo"], function(dojo) { + // | // dojo is the new instance of dojo + // | // use as required + // | }); + + var result = {}; + if(1){ + // must be the dojo loader; take a shallow copy of require.rawConfig + var src = require.rawConfig, p; + for(p in src){ + result[p] = src[p]; + } + }else{ + var adviseHas = function(featureSet, prefix, booting){ + for(p in featureSet){ + p!="has" && has.add(prefix + p, featureSet[p], 0, booting); + } + }; + result = 1 ? + // must be a built version of the dojo loader; all config stuffed in require.rawConfig + require.rawConfig : + // a foreign loader + this.dojoConfig || this.djConfig || {}; + adviseHas(result, "config", 1); + adviseHas(result.has, "", 1); + } + return result; + +/*===== +// note: +// 'dojoConfig' 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. + +// FIXME: can we document these on dojo.config object and explain they must be set via djConfig/dojoConfig global prior to loading dojo.js + +dojoConfig = { + // summary: + // Application code can set the global 'dojoConfig' prior to loading + // the library to control 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, + // locale: String + // The locale to assume for loading localized resources in this page, + // specified according to [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt). + // Must be specified entirely in lowercase, e.g. `en-us` and `zh-cn`. + // See the documentation for `dojo.i18n` and `dojo.requireLocalization` + // for details on loading localized resources. If no locale is specified, + // Dojo assumes the locale of the user agent, according to `navigator.userLanguage` + // or `navigator.language` properties. + locale: undefined, + // extraLocale: Array + // No default value. Specifies additional locales whose + // resources should also be loaded alongside the default locale when + // calls to `dojo.requireLocalization()` are processed. + extraLocale: undefined, + // baseUrl: String + // The directory in which `dojo.js` is located. Under normal + // conditions, Dojo auto-detects the correct location from which it + // was loaded. You may need to manually configure `baseUrl` in cases + // where you have renamed `dojo.js` or in which `<base>` tags confuse + // some browsers (e.g. IE 6). The variable `dojo.baseUrl` is assigned + // either the value of `djConfig.baseUrl` if one is provided or the + // auto-detected root if not. Other modules are located relative to + // this path. The path should end in a slash. + baseUrl: undefined, + // modulePaths: Object + // A map of module names to paths relative to `dojo.baseUrl`. The + // key/value pairs correspond directly to the arguments which + // `dojo.registerModulePath` accepts. Specifiying + // `djConfig.modulePaths = { "foo": "../../bar" }` is the equivalent + // of calling `dojo.registerModulePath("foo", "../../bar");`. Multiple + // modules may be configured via `djConfig.modulePaths`. + modulePaths: {}, + // afterOnLoad: Boolean + // Indicates Dojo was added to the page after the page load. In this case + // Dojo will not wait for the page DOMContentLoad/load events and fire + // its dojo.addOnLoad callbacks after making sure all outstanding + // dojo.required modules have loaded. Only works with a built dojo.js, + // it does not work the dojo.js directly from source control. + afterOnLoad: false, + // addOnLoad: Function or Array + // Adds a callback via dojo.addOnLoad. Useful when Dojo is added after + // the page loads and djConfig.afterOnLoad is true. Supports the same + // arguments as dojo.addOnLoad. When using a function reference, use + // `djConfig.addOnLoad = function(){};`. For object with function name use + // `djConfig.addOnLoad = [myObject, "functionName"];` and for object with + // function reference use + // `djConfig.addOnLoad = [myObject, function(){}];` + addOnLoad: null, + // require: Array + // An array of module names to be loaded immediately after dojo.js has been included + // in a page. + require: [], + // defaultDuration: Array + // Default duration, in milliseconds, for wipe and fade animations within dijits. + // Assigned to dijit.defaultDuration. + defaultDuration: 200, + // dojoBlankHtmlUrl: String + // Used by some modules to configure an empty iframe. Used by dojo.io.iframe and + // dojo.back, and dijit popup support in IE where an iframe is needed to make sure native + // controls do not bleed through the popups. Normally this configuration variable + // does not need to be set, except when using cross-domain/CDN Dojo builds. + // Save dojo/resources/blank.html to your domain and set `djConfig.dojoBlankHtmlUrl` + // to the path on your domain your copy of blank.html. + dojoBlankHtmlUrl: undefined, + // ioPublish: Boolean? + // Set this to true to enable publishing of topics for the different phases of + // IO operations. Publishing is done via dojo.publish. See dojo.__IoPublish for a list + // of topics that are published. + ioPublish: false, + // useCustomLogger: Anything? + // If set to a value that evaluates to true such as a string or array and + // isDebug is true and Firebug is not available or running, then it bypasses + // the creation of Firebug Lite allowing you to define your own console object. + useCustomLogger: undefined, + // transparentColor: Array + // Array containing the r, g, b components used as transparent color in dojo.Color; + // if undefined, [255,255,255] (white) will be used. + transparentColor: undefined, + // skipIeDomLoaded: Boolean + // For IE only, skip the DOMContentLoaded hack used. Sometimes it can cause an Operation + // Aborted error if the rest of the page triggers script defers before the DOM is ready. + // If this is config value is set to true, then dojo.addOnLoad callbacks will not be + // triggered until the page load event, which is after images and iframes load. If you + // want to trigger the callbacks sooner, you can put a script block in the bottom of + // your HTML that calls dojo._loadInit();. If you are using multiversion support, change + // "dojo." to the appropriate scope name for dojo. + skipIeDomLoaded: false +} +=====*/ +}); + diff --git a/lib/dojo/_base/_loader/hostenv_ff_ext.js b/lib/dojo/_base/configFirefoxExtension.js index ca47a4c1c..ce30c9153 100644 --- a/lib/dojo/_base/_loader/hostenv_ff_ext.js +++ b/lib/dojo/_base/configFirefoxExtension.js @@ -1,9 +1,4 @@ -/* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. - Available via Academic Free License >= 2.1 OR the modified BSD license. - see: http://dojotoolkit.org/license for details -*/ - +// TODO: this file needs to be converted to the v1.7 loader // a host environment specifically built for Mozilla extensions, but derived // from the browser host environment @@ -18,13 +13,12 @@ if(typeof window != 'undefined'){ // 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. // FIXME: need to probably use a different reference to "document" to get the hosting XUL environment - d.baseUrl = d.config.baseUrl; + dojo.baseUrl = dojo.config.baseUrl; // fill in the rendering support information in dojo.render.* var n = navigator; @@ -32,25 +26,25 @@ if(typeof window != 'undefined'){ var dav = n.appVersion; var tv = parseFloat(dav); - d.isMozilla = d.isMoz = tv; - if(d.isMoz){ - d.isFF = parseFloat(dua.split("Firefox/")[1]) || undefined; + dojo.isMozilla = dojo.isMoz = tv; + if(dojo.isMoz){ + dojo.isFF = parseFloat(dua.split("Firefox/")[1]) || undefined; } // FIXME - d.isQuirks = document.compatMode == "BackCompat"; + dojo.isQuirks = document.compatMode == "BackCompat"; // FIXME // TODO: is the HTML LANG attribute relevant? - d.locale = dojo.config.locale || n.language.toLowerCase(); + dojo.locale = dojo.config.locale || n.language.toLowerCase(); - d._xhrObj = function(){ + dojo._xhrObj = function(){ return new XMLHttpRequest(); - } + }; // monkey-patch _loadUri to handle file://, chrome://, and resource:// url's - var oldLoadUri = d._loadUri; - d._loadUri = function(uri, cb){ + var oldLoadUri = dojo._loadUri; + dojo._loadUri = function(uri, cb){ var handleLocal = ["file:", "chrome:", "resource:"].some(function(prefix){ return String(uri).indexOf(prefix) == 0; }); @@ -59,23 +53,23 @@ if(typeof window != 'undefined'){ // http://developer.mozilla.org/en/mozIJSSubScriptLoader var l = Components.classes["@mozilla.org/moz/jssubscript-loader;1"] .getService(Components.interfaces.mozIJSSubScriptLoader); - var value = l.loadSubScript(uri, d.global) + var value = l.loadSubScript(uri, dojo.global); if(cb){ cb(value); } return true; }else{ // otherwise, call the pre-existing version - return oldLoadUri.apply(d, arguments); + return oldLoadUri.apply(dojo, arguments); } - } + }; // FIXME: PORTME - d._isDocumentOk = function(http){ + dojo._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:") ); - } + (!stat && (location.protocol == "file:" || location.protocol == "chrome:") ); + }; // FIXME: PORTME // var owloc = window.location+""; @@ -83,7 +77,7 @@ if(typeof window != 'undefined'){ // var hasBase = (base && base.length > 0); var hasBase = false; - d._getText = function(/*URI*/ uri, /*Boolean*/ fail_ok){ + dojo._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 @@ -97,15 +91,15 @@ if(typeof window != 'undefined'){ // alert("_getText: " + uri); // NOTE: must be declared before scope switches ie. this._xhrObj() - var http = d._xhrObj(); + var http = dojo._xhrObj(); if(!hasBase && dojo._Url){ uri = (new dojo._Url(uri)).toString(); } - if(d.config.cacheBust){ + if(dojo.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,""); + uri += (uri.indexOf("?") == -1 ? "?" : "&") + String(dojo.config.cacheBust).replace(/\W+/g, ""); } var handleLocal = ["file:", "chrome:", "resource:"].some(function(prefix){ return String(uri).indexOf(prefix) == 0; @@ -115,7 +109,7 @@ if(typeof window != 'undefined'){ // http://forums.mozillazine.org/viewtopic.php?p=921150#921150 var ioService = Components.classes["@mozilla.org/network/io-service;1"] .getService(Components.interfaces.nsIIOService); - var scriptableStream=Components + var scriptableStream = Components .classes["@mozilla.org/scriptableinputstream;1"] .getService(Components.interfaces.nsIScriptableInputStream); @@ -131,37 +125,39 @@ if(typeof window != 'undefined'){ try{ http.send(null); // alert(http); - if(!d._isDocumentOk(http)){ - var err = Error("Unable to load "+uri+" status:"+ http.status); + if(!dojo._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 + if(fail_ok){ + return null; + } // null // rethrow the exception throw e; } return http.responseText; // String } - } - - d._windowUnloaders = []; - + }; + + dojo._windowUnloaders = []; + // FIXME: PORTME - d.windowUnloaded = function(){ + dojo.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 = d._windowUnloaders; + var mll = dojo._windowUnloaders; while(mll.length){ (mll.pop())(); } - } + }; // FIXME: PORTME - d.addOnWindowUnload = function(/*Object?*/obj, /*String|Function?*/functionName){ + dojo.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 @@ -172,9 +168,9 @@ if(typeof window != 'undefined'){ // | dojo.addOnWindowUnload(functionPointer) // | dojo.addOnWindowUnload(object, "functionName") // | dojo.addOnWindowUnload(object, function(){ /* ... */}); - - d._onto(d._windowUnloaders, obj, functionName); - } + + dojo._onto(dojo._windowUnloaders, obj, functionName); + }; // XUL specific APIs var contexts = []; @@ -271,7 +267,7 @@ if(typeof window != 'undefined'){ if(dojo._inFlightCount == 0){ dojo._modulesLoaded(); } - } + }; /* (function(){ @@ -294,7 +290,7 @@ if(typeof window != 'undefined'){ _handleNodeEvent("onunload", function() { dojo.windowUnloaded(); }); })(); */ - + // FIXME: PORTME // this event fires a lot, namely for all plugin XUL overlays and for @@ -302,7 +298,7 @@ if(typeof window != 'undefined'){ // Dojo's to fire once..but we might care if pages navigate. We'll // probably need an extension-specific API if(!dojo.config.afterOnLoad){ - window.addEventListener("DOMContentLoaded",function(e){ + window.addEventListener("DOMContentLoaded", function(e){ dojo._loadInit(e); // console.log("DOM content loaded", e); }, false); @@ -328,11 +324,11 @@ if(dojo.config.isDebug){ console.log = function(m){ var s = Components.classes["@mozilla.org/consoleservice;1"].getService( Components.interfaces.nsIConsoleService - ); + ); s.logStringMessage(m); - } + }; console.debug = function(){ console.log(dojo._toArray(arguments).join(" ")); - } + }; // FIXME: what about the rest of the console.* methods? And is there any way to reach into firebug and log into it directly? } diff --git a/lib/dojo/_base/configNode.js b/lib/dojo/_base/configNode.js new file mode 100644 index 000000000..7cd6f14f9 --- /dev/null +++ b/lib/dojo/_base/configNode.js @@ -0,0 +1,87 @@ +exports.config = function(config){ + // summary: + // This module provides bootstrap configuration for running dojo in node.js + + // any command line arguments with the load flag are pushed into deps + for(var deps = [], args = [], i = 0; i < process.argv.length; i++){ + var arg = (process.argv[i] + "").split("="); + if(arg[0] == "load"){ + deps.push(arg[1]); + }else{ + args.push(arg); + } + } + + var fs = require("fs"); + + // make sure global require exists + //if (typeof global.require=="undefined") { + // global.require= {}; + //} + + // reset the has cache with node-appropriate values; + var hasCache = { + "host-node":1, + "host-browser":0, + "dom":0, + "dojo-has-api":1, + "dojo-xhr-factory":0, + "dojo-inject-api":1, + "dojo-timeout-api":0, + "dojo-trace-api":1, + "dojo-dom-ready-api":0, + "dojo-publish-privates":1, + "dojo-sniff":0, + "dojo-loader":1, + "dojo-test-xd":0, + "dojo-test-sniff":0 + }; + for(var p in hasCache){ + config.hasCache[p] = hasCache[p]; + } + + var vm = require('vm'); + + + // reset some configuration switches with node-appropriate values + var nodeConfig = { + baseUrl: __dirname.match(/(.+)[\/\\]_base$/)[1], + commandLineArgs:args, + deps:deps, + timeout:0, + + // TODO: really get the locale + locale:"en-us", + + loaderPatch: { + log:function(item){ + // define debug for console messages during dev instead of console.log + // (node's heavy async makes console.log confusing sometimes) + var util = require("util"); + util.debug(util.inspect(item)); + }, + + eval: function(__text, __urlHint){ + return vm.runInThisContext(__text, __urlHint); + }, + + injectUrl: function(url, callback){ + try{ + vm.runInThisContext(fs.readFileSync(url, "utf8"), url); + callback(); + }catch(e){ + this.log("failed to load resource (" + url + ")"); + this.log(e); + } + }, + + getText: function(url, sync, onLoad){ + // TODO: implement async and http/https handling + onLoad(fs.readFileSync(url, "utf8")); + } + } + }; + for(p in nodeConfig){ + config[p] = nodeConfig[p]; + } +}; diff --git a/lib/dojo/_base/configRhino.js b/lib/dojo/_base/configRhino.js new file mode 100644 index 000000000..ec6475997 --- /dev/null +++ b/lib/dojo/_base/configRhino.js @@ -0,0 +1,121 @@ +function rhinoDojoConfig(config, baseUrl, rhinoArgs){ + // summary: + // This module provides bootstrap configuration for running dojo in rhino. + + // TODO: v1.6 tries to set dojo.doc and dojo.body in rhino; why? + + // get a minimal console up + var log = function(hint, args){ + print((hint ? hint + ":" : "") + args[0]); + for(var i = 1; i < args.length; i++){ + print(", " + args[i]); + } + }; + // intentionally define console in the global namespace + console= { + log: function(){ log(0, arguments); }, + error: function(){ log("ERROR", arguments); }, + warn: function(){ log("WARN", arguments); } + }; + + // any command line arguments with the load flag are pushed into deps + for(var deps = [], i = 0; i < rhinoArgs.length; i++){ + var arg = (rhinoArgs[i] + "").split("="); + if(arg[0] == "load"){ + deps.push(arg[1]); + } + } + + // provides timed callbacks using Java threads + if(typeof setTimeout == "undefined" || typeof clearTimeout == "undefined"){ + var timeouts = []; + clearTimeout = function(idx){ + if(!timeouts[idx]){ return; } + timeouts[idx].stop(); + }; + + setTimeout = function(func, delay){ + var def = { + sleepTime:delay, + hasSlept:false, + + run:function(){ + if(!this.hasSlept){ + this.hasSlept = true; + java.lang.Thread.currentThread().sleep(this.sleepTime); + } + try{ + func(); + }catch(e){ + console.debug("Error running setTimeout thread:" + e); + } + } + }; + + var runnable = new java.lang.Runnable(def); + var thread = new java.lang.Thread(runnable); + thread.start(); + return timeouts.push(thread) - 1; + }; + } + + var isLocal = function(url){ + return (new java.io.File(url)).exists(); + }; + + // reset the has cache with node-appropriate values; + var hasCache = { + "host-rhino":1, + "host-browser":0, + "dom":0, + "dojo-has-api":1, + "dojo-xhr-factory":0, + "dojo-inject-api":1, + "dojo-timeout-api":0, + "dojo-trace-api":1, + "dojo-loader-catches":1, + "dojo-dom-ready-api":0, + "dojo-publish-privates":1, + "dojo-sniff":0, + "dojo-loader":1, + "dojo-test-xd":0, + "dojo-test-sniff":0 + }; + for(var p in hasCache){ + config.hasCache[p] = hasCache[p]; + } + + // reset some configuration switches with rhino-appropriate values + var rhinoConfig = { + baseUrl:baseUrl, + commandLineArgs:rhinoArgs, + deps:deps, + timeout:0, + locale:String(java.util.Locale.getDefault().toString().replace('_', '-').toLowerCase()), + + loaderPatch:{ + injectUrl: function(url, callback){ + try{ + if(isLocal(url)){ + load(url); + }else{ + require.eval(readUrl(url, "UTF-8")); + } + callback(); + }catch(e){ + console.log("failed to load resource (" + url + ")"); + console.log(e); + } + }, + + getText: function(url, sync, onLoad){ + // TODO: test https://bugzilla.mozilla.org/show_bug.cgi?id=471005; see v1.6 hostenv_rhino + // note: async mode not supported in rhino + onLoad(isLocal(url) ? readFile(url, "UTF-8") : readUrl(url, "UTF-8")); + } + } + }; + for(p in rhinoConfig){ + config[p] = rhinoConfig[p]; + } +} diff --git a/lib/dojo/_base/_loader/hostenv_spidermonkey.js b/lib/dojo/_base/configSpidermonkey.js index a3d2dfc6f..0da0d7102 100644 --- a/lib/dojo/_base/_loader/hostenv_spidermonkey.js +++ b/lib/dojo/_base/configSpidermonkey.js @@ -1,8 +1,4 @@ -/* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. - Available via Academic Free License >= 2.1 OR the modified BSD license. - see: http://dojotoolkit.org/license for details -*/ +// TODO: this file needs to be converted to the v1.7 loader /* @@ -26,7 +22,7 @@ dojo.isSpidermonkey = { dojo.isSpidermonkey = true; dojo.exit = function(exitcode){ quit(exitcode); -} +}; if(typeof print == "function"){ console.debug = print; @@ -46,24 +42,24 @@ dojo._spidermonkeyCurrentFile = function(depth){ // the stack, but that does require that you know how deep your stack is when you are // calling. // - var s = ''; - try{ + var s = ''; + try{ throw Error("whatever"); }catch(e){ s = e.stack; } - // lines are like: bu_getCurrentScriptURI_spidermonkey("ScriptLoader.js")@burst/Runtime.js:101 - var matches = s.match(/[^@]*\.js/gi); - if(!matches){ + // lines are like: bu_getCurrentScriptURI_spidermonkey("ScriptLoader.js")@burst/Runtime.js:101 + var matches = s.match(/[^@]*\.js/gi); + if(!matches){ throw Error("could not parse stack string: '" + s + "'"); } - var fname = (typeof depth != 'undefined' && depth) ? matches[depth + 1] : matches[matches.length - 1]; - if(!fname){ + var fname = (typeof depth != 'undefined' && depth) ? matches[depth + 1] : matches[matches.length - 1]; + if(!fname){ throw Error("could not find file name in stack string '" + s + "'"); } - //print("SpiderMonkeyRuntime got fname '" + fname + "' from stack string '" + s + "'"); - return fname; -} + //print("SpiderMonkeyRuntime got fname '" + fname + "' from stack string '" + s + "'"); + return fname; +}; // print(dojo._spidermonkeyCurrentFile(0)); @@ -72,10 +68,11 @@ dojo._loadUri = function(uri){ // is what we want). // TODO: sigh, load() does not return a useful value. // Perhaps it is returning the value of the last thing evaluated? - var ok = load(uri); + // var ok = + load(uri); // console.log("spidermonkey load(", uri, ") returned ", ok); return 1; -} +}; //Register any module paths set up in djConfig. Need to do this //in the hostenvs since hostenv_browser can read djConfig from a diff --git a/lib/dojo/_base/connect.js b/lib/dojo/_base/connect.js index 7e8006221..6fa7aabc3 100644 --- a/lib/dojo/_base/connect.js +++ b/lib/dojo/_base/connect.js @@ -4,308 +4,5 @@ see: http://dojotoolkit.org/license for details */ - -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"); -dojo.require("dojo._base.lang"); - - -// 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 - r = t && t.apply(this, arguments), - // make local copy of listener array so it is immutable during processing - i, lls = [].concat(ls) - ; - - // invoke listeners after target function - for(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: - // `dojo.connect` is the core event handling and delegation method in - // Dojo. It allows one function to "listen in" on the execution of - // any other, triggering the second whenever the first is called. Many - // listeners may be attached to a function, and source functions may - // be either regular function calls or DOM events. - // - // description: - // Connects listeners to actions, so that after event fires, a - // listener is called with the same arguments passed to the original - // function. - // - // Since `dojo.connect` allows the source of events to be either a - // "regular" JavaScript function or a DOM event, it provides a uniform - // interface for listening to all the types of events that an - // application is likely to deal with though a single, unified - // interface. DOM programmers may want to think of it as - // "addEventListener for everything and anything". - // - // When setting up a connection, the `event` parameter must be a - // string that is the name of the method/event to be listened for. If - // `obj` is null, `dojo.global` is assumed, meaning that connections - // to global methods are supported but also that you may inadvertently - // connect to a global by passing an incorrect object name or invalid - // reference. - // - // `dojo.connect` generally is forgiving. If you pass the name of a - // function or method that does not yet exist on `obj`, connect will - // not fail, but will instead set up a stub method. Similarly, null - // arguments may simply be omitted such that fewer than 4 arguments - // may be required to set up a connection See the examples for details. - // - // 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 omitted - 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 every time 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 -}; - -} +//>>built +define("dojo/_base/connect",["./kernel","../on","../topic","../aspect","./event","../mouse","./sniff","./lang","../keys"],function(_1,on,_2,_3,_4,_5,_6,_7){_6.add("events-keypress-typed",function(){var _8={charCode:0};try{_8=document.createEvent("KeyboardEvent");(_8.initKeyboardEvent||_8.initKeyEvent).call(_8,"keypress",true,true,null,false,false,false,false,9,3);}catch(e){}return _8.charCode==0&&!_6("opera");});function _9(_a,_b,_c,_d,_e){_d=_7.hitch(_c,_d);if(!_a||!(_a.addEventListener||_a.attachEvent)){return _3.after(_a||_1.global,_b,_d,true);}if(typeof _b=="string"&&_b.substring(0,2)=="on"){_b=_b.substring(2);}if(!_a){_a=_1.global;}if(!_e){switch(_b){case "keypress":_b=_f;break;case "mouseenter":_b=_5.enter;break;case "mouseleave":_b=_5.leave;break;}}return on(_a,_b,_d,_e);};var _10={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,229:113};var _11=_6("mac")?"metaKey":"ctrlKey";var _12=function(evt,_13){var _14=_7.mixin({},evt,_13);_15(_14);_14.preventDefault=function(){evt.preventDefault();};_14.stopPropagation=function(){evt.stopPropagation();};return _14;};function _15(evt){evt.keyChar=evt.charCode?String.fromCharCode(evt.charCode):"";evt.charOrCode=evt.keyChar||evt.keyCode;};var _f;if(_6("events-keypress-typed")){var _16=function(e,_17){try{return (e.keyCode=_17);}catch(e){return 0;}};_f=function(_18,_19){var _1a=on(_18,"keydown",function(evt){var k=evt.keyCode;var _1b=(k!=13||(_6("ie")>=9&&!_6("quirks")))&&k!=32&&(k!=27||!_6("ie"))&&(k<48||k>90)&&(k<96||k>111)&&(k<186||k>192)&&(k<219||k>222)&&k!=229;if(_1b||evt.ctrlKey){var c=_1b?0:k;if(evt.ctrlKey){if(k==3||k==13){return _19.call(evt.currentTarget,evt);}else{if(c>95&&c<106){c-=48;}else{if((!evt.shiftKey)&&(c>=65&&c<=90)){c+=32;}else{c=_10[c]||c;}}}}var _1c=_12(evt,{type:"keypress",faux:true,charCode:c});_19.call(evt.currentTarget,_1c);if(_6("ie")){_16(evt,_1c.keyCode);}}});var _1d=on(_18,"keypress",function(evt){var c=evt.charCode;c=c>=32?c:0;evt=_12(evt,{charCode:c,faux:true});return _19.call(this,evt);});return {remove:function(){_1a.remove();_1d.remove();}};};}else{if(_6("opera")){_f=function(_1e,_1f){return on(_1e,"keypress",function(evt){var c=evt.which;if(c==3){c=99;}c=c<32&&!evt.shiftKey?0:c;if(evt.ctrlKey&&!evt.shiftKey&&c>=65&&c<=90){c+=32;}return _1f.call(this,_12(evt,{charCode:c}));});};}else{_f=function(_20,_21){return on(_20,"keypress",function(evt){_15(evt);return _21.call(this,evt);});};}}var _22={_keypress:_f,connect:function(obj,_23,_24,_25,_26){var a=arguments,_27=[],i=0;_27.push(typeof a[0]=="string"?null:a[i++],a[i++]);var a1=a[i+1];_27.push(typeof a1=="string"||typeof a1=="function"?a[i++]:null,a[i++]);for(var l=a.length;i<l;i++){_27.push(a[i]);}return _9.apply(this,_27);},disconnect:function(_28){if(_28){_28.remove();}},subscribe:function(_29,_2a,_2b){return _2.subscribe(_29,_7.hitch(_2a,_2b));},publish:function(_2c,_2d){return _2.publish.apply(_2,[_2c].concat(_2d));},connectPublisher:function(_2e,obj,_2f){var pf=function(){_22.publish(_2e,arguments);};return _2f?_22.connect(obj,_2f,pf):_22.connect(obj,pf);},isCopyKey:function(e){return e[_11];}};_22.unsubscribe=_22.disconnect;1&&_7.mixin(_1,_22);return _22;});
\ No newline at end of file diff --git a/lib/dojo/_base/connect.js.uncompressed.js b/lib/dojo/_base/connect.js.uncompressed.js new file mode 100644 index 000000000..69de83e70 --- /dev/null +++ b/lib/dojo/_base/connect.js.uncompressed.js @@ -0,0 +1,400 @@ +define("dojo/_base/connect", ["./kernel", "../on", "../topic", "../aspect", "./event", "../mouse", "./sniff", "./lang", "../keys"], function(kernel, on, hub, aspect, eventModule, mouse, has, lang){ +// module: +// dojo/_base/connect +// summary: +// This module defines the dojo.connect API. +// This modules also provides keyboard event handling helpers. +// This module exports an extension event for emulating Firefox's keypress handling. +// However, this extension event exists primarily for backwards compatibility and +// is not recommended. WebKit and IE uses an alternate keypress handling (only +// firing for printable characters, to distinguish from keydown events), and most +// consider the WebKit/IE behavior more desirable. +has.add("events-keypress-typed", function(){ // keypresses should only occur a printable character is hit + var testKeyEvent = {charCode: 0}; + try{ + testKeyEvent = document.createEvent("KeyboardEvent"); + (testKeyEvent.initKeyboardEvent || testKeyEvent.initKeyEvent).call(testKeyEvent, "keypress", true, true, null, false, false, false, false, 9, 3); + }catch(e){} + return testKeyEvent.charCode == 0 && !has("opera"); +}); + +function connect_(obj, event, context, method, dontFix){ + method = lang.hitch(context, method); + if(!obj || !(obj.addEventListener || obj.attachEvent)){ + // it is a not a DOM node and we are using the dojo.connect style of treating a + // method like an event, must go right to aspect + return aspect.after(obj || kernel.global, event, method, true); + } + if(typeof event == "string" && event.substring(0, 2) == "on"){ + event = event.substring(2); + } + if(!obj){ + obj = kernel.global; + } + if(!dontFix){ + switch(event){ + // dojo.connect has special handling for these event types + case "keypress": + event = keypress; + break; + case "mouseenter": + event = mouse.enter; + break; + case "mouseleave": + event = mouse.leave; + break; + } + } + return on(obj, event, method, dontFix); +} + +var _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, + 229:113 +}; +var evtCopyKey = has("mac") ? "metaKey" : "ctrlKey"; + + +var _synthesizeEvent = function(evt, props){ + var faux = lang.mixin({}, evt, props); + setKeyChar(faux); + // FIXME: would prefer to use lang.hitch: lang.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; +}; +function setKeyChar(evt){ + evt.keyChar = evt.charCode ? String.fromCharCode(evt.charCode) : ''; + evt.charOrCode = evt.keyChar || evt.keyCode; +} +var keypress; +if(has("events-keypress-typed")){ + // this emulates Firefox's keypress behavior where every keydown can correspond to a keypress + 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; + } + }; + keypress = function(object, listener){ + var keydownSignal = on(object, "keydown", function(evt){ + // 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 || (has("ie") >= 9 && !has("quirks"))) && k!=32 && (k!=27||!has("ie")) && (k<48||k>90) && (k<96||k>111) && (k<186||k>192) && (k<219||k>222) && k!=229; + // 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 listener.call(evt.currentTarget, evt); // 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 = _punctMap[c] || c; // map other problematic CTRL combinations to ASCII + } + } + // simulate a keypress event + var faux = _synthesizeEvent(evt, {type: 'keypress', faux: true, charCode: c}); + listener.call(evt.currentTarget, faux); + if(has("ie")){ + _trySetKeyCode(evt, faux.keyCode); + } + } + }); + var keypressSignal = on(object, "keypress", function(evt){ + var c = evt.charCode; + c = c>=32 ? c : 0; + evt = _synthesizeEvent(evt, {charCode: c, faux: true}); + return listener.call(this, evt); + }); + return { + remove: function(){ + keydownSignal.remove(); + keypressSignal.remove(); + } + }; + }; +}else{ + if(has("opera")){ + keypress = function(object, listener){ + return on(object, "keypress", function(evt){ + 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<32 && !evt.shiftKey ? 0 : c; + if(evt.ctrlKey && !evt.shiftKey && c>=65 && c<=90){ + // lowercase CTRL-[A-Z] keys + c += 32; + } + return listener.call(this, _synthesizeEvent(evt, { charCode: c })); + }); + }; + }else{ + keypress = function(object, listener){ + return on(object, "keypress", function(evt){ + setKeyChar(evt); + return listener.call(this, evt); + }); + }; + } +} + +var connect = { + _keypress:keypress, + + connect:function(obj, event, context, method, dontFix){ + // normalize arguments + var a=arguments, args=[], i=0; + // if a[0] is a String, obj was omitted + args.push(typeof a[0] == "string" ? 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(typeof a1 == "string" || typeof a1 == "function" ? a[i++] : null, a[i++]); + // absorb any additional arguments + for(var l=a.length; i<l; i++){ args.push(a[i]); } + return connect_.apply(this, args); + }, + + disconnect:function(handle){ + if(handle){ + handle.remove(); + } + }, + + subscribe:function(topic, context, method){ + return hub.subscribe(topic, lang.hitch(context, method)); + }, + + publish:function(topic, args){ + return hub.publish.apply(hub, [topic].concat(args)); + }, + + connectPublisher:function(topic, obj, event){ + var pf = function(){ connect.publish(topic, arguments); }; + return event ? connect.connect(obj, event, pf) : connect.connect(obj, pf); //Handle + }, + + isCopyKey: function(e){ + return e[evtCopyKey]; // Boolean + } +}; +connect.unsubscribe = connect.disconnect; + +1 && lang.mixin(kernel, connect); +return connect; + +/*===== +dojo.connect = function(obj, event, context, method, dontFix){ + // summary: + // `dojo.connect` is the core event handling and delegation method in + // Dojo. It allows one function to "listen in" on the execution of + // any other, triggering the second whenever the first is called. Many + // listeners may be attached to a function, and source functions may + // be either regular function calls or DOM events. + // + // description: + // Connects listeners to actions, so that after event fires, a + // listener is called with the same arguments passed to the original + // function. + // + // Since `dojo.connect` allows the source of events to be either a + // "regular" JavaScript function or a DOM event, it provides a uniform + // interface for listening to all the types of events that an + // application is likely to deal with though a single, unified + // interface. DOM programmers may want to think of it as + // "addEventListener for everything and anything". + // + // When setting up a connection, the `event` parameter must be a + // string that is the name of the method/event to be listened for. If + // `obj` is null, `kernel.global` is assumed, meaning that connections + // to global methods are supported but also that you may inadvertently + // connect to a global by passing an incorrect object name or invalid + // reference. + // + // `dojo.connect` generally is forgiving. If you pass the name of a + // function or method that does not yet exist on `obj`, connect will + // not fail, but will instead set up a stub method. Similarly, null + // arguments may simply be omitted such that fewer than 4 arguments + // may be required to set up a connection See the examples for details. + // + // The return value is a handle that is needed to + // remove this connection with `dojo.disconnect`. + // + // obj: Object|null: + // The source object for the event function. + // Defaults to `kernel.global` if null. + // If obj is a DOM node, the connection is delegated + // to the DOM event manager (unless dontFix is true). + // + // event: String: + // String name of the event function in obj. + // I.e. identifies a property `obj[event]`. + // + // context: Object|null + // 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, + // kernel.global is used. + // + // method: String|Function: + // 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: Boolean? + // 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 +} +=====*/ + +/*===== +dojo.disconnect = function(handle){ + // summary: + // Remove a link created by dojo.connect. + // description: + // Removes the connection between event and the method referenced by handle. + // handle: Handle: + // the return value of the dojo.connect call that created the connection. +} +=====*/ + +/*===== +dojo.subscribe = function(topic, context, 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. + // topic: String: + // The topic to which to subscribe. + // context: Object|null: + // Scope in which method will be invoked, or null for default scope. + // method: String|Function: + // 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" ]); +} +=====*/ + +/*===== +dojo.unsubscribe = function(handle){ + // summary: + // Remove a topic listener. + // handle: 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); +} +=====*/ + +/*===== +dojo.publish = function(topic, args){ + // summary: + // Invoke all listener method subscribed to topic. + // topic: String: + // The name of the topic to publish. + // args: Array? + // 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" ]); +} +=====*/ + +/*===== +dojo.connectPublisher = function(topic, obj, event){ + // summary: + // Ensure that every time 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: String: + // The name of the topic to publish. + // obj: Object|null: + // The source object for the event function. Defaults to kernel.global + // if null. + // event: String: + // The name of the event function in obj. + // I.e. identifies a property obj[event]. + // example: + // | dojo.connectPublisher("/ajax/start", dojo, "xhrGet"); +} +=====*/ + +/*===== +dojo.isCopyKey = function(e){ + // summary: + // Checks an event for the copy key (meta on Mac, and ctrl anywhere else) + // e: Event + // Event object to examine +} +=====*/ + +}); + + diff --git a/lib/dojo/_base/declare.js b/lib/dojo/_base/declare.js index 437914870..9247fcc42 100644 --- a/lib/dojo/_base/declare.js +++ b/lib/dojo/_base/declare.js @@ -4,1045 +4,5 @@ see: http://dojotoolkit.org/license for details */ - -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"); -dojo.require("dojo._base.lang"); -dojo.require("dojo._base.array"); - - -(function(){ - var d = dojo, mix = d._mixin, op = Object.prototype, opts = op.toString, - xtor = new Function, counter = 0, cname = "constructor"; - - function err(msg, cls){ throw new Error("declare" + (cls ? " " + cls : "") + ": " + msg); } - - // C3 Method Resolution Order (see http://www.python.org/download/releases/2.3/mro/) - function c3mro(bases, className){ - var result = [], roots = [{cls: 0, refs: []}], nameMap = {}, clsCount = 1, - l = bases.length, i = 0, j, lin, base, top, proto, rec, name, refs; - - // build a list of bases naming them if needed - for(; i < l; ++i){ - base = bases[i]; - if(!base){ - err("mixin #" + i + " is unknown. Did you use dojo.require to pull it in?", className); - }else if(opts.call(base) != "[object Function]"){ - err("mixin #" + i + " is not a callable constructor.", className); - } - lin = base._meta ? base._meta.bases : [base]; - top = 0; - // add bases to the name map - for(j = lin.length - 1; j >= 0; --j){ - proto = lin[j].prototype; - if(!proto.hasOwnProperty("declaredClass")){ - proto.declaredClass = "uniqName_" + (counter++); - } - name = proto.declaredClass; - if(!nameMap.hasOwnProperty(name)){ - nameMap[name] = {count: 0, refs: [], cls: lin[j]}; - ++clsCount; - } - rec = nameMap[name]; - if(top && top !== rec){ - rec.refs.push(top); - ++top.count; - } - top = rec; - } - ++top.count; - roots[0].refs.push(top); - } - - // remove classes without external references recursively - while(roots.length){ - top = roots.pop(); - result.push(top.cls); - --clsCount; - // optimization: follow a single-linked chain - while(refs = top.refs, refs.length == 1){ - top = refs[0]; - if(!top || --top.count){ - // branch or end of chain => do not end to roots - top = 0; - break; - } - result.push(top.cls); - --clsCount; - } - if(top){ - // branch - for(i = 0, l = refs.length; i < l; ++i){ - top = refs[i]; - if(!--top.count){ - roots.push(top); - } - } - } - } - if(clsCount){ - err("can't build consistent linearization", className); - } - - // calculate the superclass offset - base = bases[0]; - result[0] = base ? - base._meta && base === result[result.length - base._meta.bases.length] ? - base._meta.bases.length : 1 : 0; - - return result; - } - - function inherited(args, a, f){ - var name, chains, bases, caller, meta, base, proto, opf, pos, - cache = this._inherited = this._inherited || {}; - - // crack arguments - if(typeof args == "string"){ - name = args; - args = a; - a = f; - } - f = 0; - - caller = args.callee; - name = name || caller.nom; - if(!name){ - err("can't deduce a name to call inherited()", this.declaredClass); - } - - meta = this.constructor._meta; - bases = meta.bases; - - pos = cache.p; - if(name != cname){ - // method - if(cache.c !== caller){ - // cache bust - pos = 0; - base = bases[0]; - meta = base._meta; - if(meta.hidden[name] !== caller){ - // error detection - chains = meta.chains; - if(chains && typeof chains[name] == "string"){ - err("calling chained method with inherited: " + name, this.declaredClass); - } - // find caller - do{ - meta = base._meta; - proto = base.prototype; - if(meta && (proto[name] === caller && proto.hasOwnProperty(name) || meta.hidden[name] === caller)){ - break; - } - }while(base = bases[++pos]); // intentional assignment - pos = base ? pos : -1; - } - } - // find next - base = bases[++pos]; - if(base){ - proto = base.prototype; - if(base._meta && proto.hasOwnProperty(name)){ - f = proto[name]; - }else{ - opf = op[name]; - do{ - proto = base.prototype; - f = proto[name]; - if(f && (base._meta ? proto.hasOwnProperty(name) : f !== opf)){ - break; - } - }while(base = bases[++pos]); // intentional assignment - } - } - f = base && f || op[name]; - }else{ - // constructor - if(cache.c !== caller){ - // cache bust - pos = 0; - meta = bases[0]._meta; - if(meta && meta.ctor !== caller){ - // error detection - chains = meta.chains; - if(!chains || chains.constructor !== "manual"){ - err("calling chained constructor with inherited", this.declaredClass); - } - // find caller - while(base = bases[++pos]){ // intentional assignment - meta = base._meta; - if(meta && meta.ctor === caller){ - break; - } - } - pos = base ? pos : -1; - } - } - // find next - while(base = bases[++pos]){ // intentional assignment - meta = base._meta; - f = meta ? meta.ctor : base; - if(f){ - break; - } - } - f = base && f; - } - - // cache the found super method - cache.c = f; - cache.p = pos; - - // now we have the result - if(f){ - return a === true ? f : f.apply(this, a || args); - } - // intentionally if a super method was not found - } - - function getInherited(name, args){ - if(typeof name == "string"){ - return this.inherited(name, args, true); - } - return this.inherited(name, true); - } - - // emulation of "instanceof" - function isInstanceOf(cls){ - var bases = this.constructor._meta.bases; - for(var i = 0, l = bases.length; i < l; ++i){ - if(bases[i] === cls){ - return true; - } - } - return this instanceof cls; - } - - function mixOwn(target, source){ - var name, i = 0, l = d._extraNames.length; - // add props adding metadata for incoming functions skipping a constructor - for(name in source){ - if(name != cname && source.hasOwnProperty(name)){ - target[name] = source[name]; - } - } - // process unenumerable methods on IE - for(; i < l; ++i){ - name = d._extraNames[i]; - if(name != cname && source.hasOwnProperty(name)){ - target[name] = source[name]; - } - } - } - - // implementation of safe mixin function - function safeMixin(target, source){ - var name, t, i = 0, l = d._extraNames.length; - // add props adding metadata for incoming functions skipping a constructor - for(name in source){ - t = source[name]; - if((t !== op[name] || !(name in op)) && name != cname){ - if(opts.call(t) == "[object Function]"){ - // non-trivial function method => attach its name - t.nom = name; - } - target[name] = t; - } - } - // process unenumerable methods on IE - for(; i < l; ++i){ - name = d._extraNames[i]; - t = source[name]; - if((t !== op[name] || !(name in op)) && name != cname){ - if(opts.call(t) == "[object Function]"){ - // non-trivial function method => attach its name - t.nom = name; - } - target[name] = t; - } - } - return target; - } - - function extend(source){ - safeMixin(this.prototype, source); - return this; - } - - // chained constructor compatible with the legacy dojo.declare() - function chainedConstructor(bases, ctorSpecial){ - return function(){ - var a = arguments, args = a, a0 = a[0], f, i, m, - l = bases.length, preArgs; - - if(!(this instanceof a.callee)){ - // not called via new, so force it - return applyNew(a); - } - - //this._inherited = {}; - // perform the shaman's rituals of the original dojo.declare() - // 1) call two types of the preamble - if(ctorSpecial && (a0 && a0.preamble || this.preamble)){ - // full blown ritual - preArgs = new Array(bases.length); - // prepare parameters - preArgs[0] = a; - for(i = 0;;){ - // process the preamble of the 1st argument - a0 = a[0]; - if(a0){ - f = a0.preamble; - if(f){ - a = f.apply(this, a) || a; - } - } - // process the preamble of this class - f = bases[i].prototype; - f = f.hasOwnProperty("preamble") && f.preamble; - if(f){ - a = f.apply(this, a) || a; - } - // one peculiarity of the preamble: - // it is called if it is not needed, - // e.g., there is no constructor to call - // let's watch for the last constructor - // (see ticket #9795) - if(++i == l){ - break; - } - preArgs[i] = a; - } - } - // 2) call all non-trivial constructors using prepared arguments - for(i = l - 1; i >= 0; --i){ - f = bases[i]; - m = f._meta; - f = m ? m.ctor : f; - if(f){ - f.apply(this, preArgs ? preArgs[i] : a); - } - } - // 3) continue the original ritual: call the postscript - f = this.postscript; - if(f){ - f.apply(this, args); - } - }; - } - - - // chained constructor compatible with the legacy dojo.declare() - function singleConstructor(ctor, ctorSpecial){ - return function(){ - var a = arguments, t = a, a0 = a[0], f; - - if(!(this instanceof a.callee)){ - // not called via new, so force it - return applyNew(a); - } - - //this._inherited = {}; - // perform the shaman's rituals of the original dojo.declare() - // 1) call two types of the preamble - if(ctorSpecial){ - // full blown ritual - if(a0){ - // process the preamble of the 1st argument - f = a0.preamble; - if(f){ - t = f.apply(this, t) || t; - } - } - f = this.preamble; - if(f){ - // process the preamble of this class - f.apply(this, t); - // one peculiarity of the preamble: - // it is called even if it is not needed, - // e.g., there is no constructor to call - // let's watch for the last constructor - // (see ticket #9795) - } - } - // 2) call a constructor - if(ctor){ - ctor.apply(this, a); - } - // 3) continue the original ritual: call the postscript - f = this.postscript; - if(f){ - f.apply(this, a); - } - }; - } - - // plain vanilla constructor (can use inherited() to call its base constructor) - function simpleConstructor(bases){ - return function(){ - var a = arguments, i = 0, f, m; - - if(!(this instanceof a.callee)){ - // not called via new, so force it - return applyNew(a); - } - - //this._inherited = {}; - // perform the shaman's rituals of the original dojo.declare() - // 1) do not call the preamble - // 2) call the top constructor (it can use this.inherited()) - for(; f = bases[i]; ++i){ // intentional assignment - m = f._meta; - f = m ? m.ctor : f; - if(f){ - f.apply(this, a); - break; - } - } - // 3) call the postscript - f = this.postscript; - if(f){ - f.apply(this, a); - } - }; - } - - function chain(name, bases, reversed){ - return function(){ - var b, m, f, i = 0, step = 1; - if(reversed){ - i = bases.length - 1; - step = -1; - } - for(; b = bases[i]; i += step){ // intentional assignment - m = b._meta; - f = (m ? m.hidden : b.prototype)[name]; - if(f){ - f.apply(this, arguments); - } - } - }; - } - - // forceNew(ctor) - // return a new object that inherits from ctor.prototype but - // without actually running ctor on the object. - function forceNew(ctor){ - // create object with correct prototype using a do-nothing - // constructor - xtor.prototype = ctor.prototype; - var t = new xtor; - xtor.prototype = null; // clean up - return t; - } - - // applyNew(args) - // just like 'new ctor()' except that the constructor and its arguments come - // from args, which must be an array or an arguments object - function applyNew(args){ - // create an object with ctor's prototype but without - // calling ctor on it. - var ctor = args.callee, t = forceNew(ctor); - // execute the real constructor on the new object - ctor.apply(t, args); - return t; - } - - d.declare = function(className, superclass, props){ - // crack parameters - if(typeof className != "string"){ - props = superclass; - superclass = className; - className = ""; - } - props = props || {}; - - var proto, i, t, ctor, name, bases, chains, mixins = 1, parents = superclass; - - // build a prototype - if(opts.call(superclass) == "[object Array]"){ - // C3 MRO - bases = c3mro(superclass, className); - t = bases[0]; - mixins = bases.length - t; - superclass = bases[mixins]; - }else{ - bases = [0]; - if(superclass){ - if(opts.call(superclass) == "[object Function]"){ - t = superclass._meta; - bases = bases.concat(t ? t.bases : superclass); - }else{ - err("base class is not a callable constructor.", className); - } - }else if(superclass !== null){ - err("unknown base class. Did you use dojo.require to pull it in?", className); - } - } - if(superclass){ - for(i = mixins - 1;; --i){ - proto = forceNew(superclass); - if(!i){ - // stop if nothing to add (the last base) - break; - } - // mix in properties - t = bases[i]; - (t._meta ? mixOwn : mix)(proto, t.prototype); - // chain in new constructor - ctor = new Function; - ctor.superclass = superclass; - ctor.prototype = proto; - superclass = proto.constructor = ctor; - } - }else{ - proto = {}; - } - // add all properties - safeMixin(proto, props); - // add constructor - t = props.constructor; - if(t !== op.constructor){ - t.nom = cname; - proto.constructor = t; - } - - // collect chains and flags - for(i = mixins - 1; i; --i){ // intentional assignment - t = bases[i]._meta; - if(t && t.chains){ - chains = mix(chains || {}, t.chains); - } - } - if(proto["-chains-"]){ - chains = mix(chains || {}, proto["-chains-"]); - } - - // build ctor - t = !chains || !chains.hasOwnProperty(cname); - bases[0] = ctor = (chains && chains.constructor === "manual") ? simpleConstructor(bases) : - (bases.length == 1 ? singleConstructor(props.constructor, t) : chainedConstructor(bases, t)); - - // add meta information to the constructor - ctor._meta = {bases: bases, hidden: props, chains: chains, - parents: parents, ctor: props.constructor}; - ctor.superclass = superclass && superclass.prototype; - ctor.extend = extend; - ctor.prototype = proto; - proto.constructor = ctor; - - // add "standard" methods to the prototype - proto.getInherited = getInherited; - proto.inherited = inherited; - proto.isInstanceOf = isInstanceOf; - - // add name if specified - if(className){ - proto.declaredClass = className; - d.setObject(className, ctor); - } - - // build chains and add them to the prototype - if(chains){ - for(name in chains){ - if(proto[name] && typeof chains[name] == "string" && name != cname){ - t = proto[name] = chain(name, bases, chains[name] === "after"); - t.nom = name; - } - } - } - // chained methods do not return values - // no need to chain "invisible" functions - - return ctor; // Function - }; - - d.safeMixin = safeMixin; - - /*===== - dojo.declare = function(className, superclass, props){ - // summary: - // Create a feature-rich constructor from compact notation. - // className: String?: - // The optional name of the constructor (loosely, a "class") - // stored in the "declaredClass" property in the created prototype. - // It will be used as a global name for a created constructor. - // superclass: Function|Function[]: - // May be null, a Function, or an Array of Functions. This argument - // specifies a list of bases (the left-most one is the most deepest - // base). - // props: Object: - // An object whose properties are copied to the created prototype. - // Add an instance-initialization function by making it a property - // named "constructor". - // returns: - // New constructor function. - // description: - // Create a constructor using a compact notation for inheritance and - // prototype extension. - // - // Mixin ancestors provide a type of multiple inheritance. - // Prototypes of mixin ancestors are copied to the new class: - // changes to mixin prototypes will not affect classes to which - // they have been mixed in. - // - // Ancestors can be compound classes created by this version of - // dojo.declare. In complex cases all base classes are going to be - // linearized according to C3 MRO algorithm - // (see http://www.python.org/download/releases/2.3/mro/ for more - // details). - // - // "className" is cached in "declaredClass" property of the new class, - // if it was supplied. The immediate super class will be cached in - // "superclass" property of the new class. - // - // Methods in "props" will be copied and modified: "nom" property - // (the declared name of the method) will be added to all copied - // functions to help identify them for the internal machinery. Be - // very careful, while reusing methods: if you use the same - // function under different names, it can produce errors in some - // cases. - // - // It is possible to use constructors created "manually" (without - // dojo.declare) as bases. They will be called as usual during the - // creation of an instance, their methods will be chained, and even - // called by "this.inherited()". - // - // Special property "-chains-" governs how to chain methods. It is - // a dictionary, which uses method names as keys, and hint strings - // as values. If a hint string is "after", this method will be - // called after methods of its base classes. If a hint string is - // "before", this method will be called before methods of its base - // classes. - // - // If "constructor" is not mentioned in "-chains-" property, it will - // be chained using the legacy mode: using "after" chaining, - // calling preamble() method before each constructor, if available, - // and calling postscript() after all constructors were executed. - // If the hint is "after", it is chained as a regular method, but - // postscript() will be called after the chain of constructors. - // "constructor" cannot be chained "before", but it allows - // a special hint string: "manual", which means that constructors - // are not going to be chained in any way, and programmer will call - // them manually using this.inherited(). In the latter case - // postscript() will be called after the construction. - // - // All chaining hints are "inherited" from base classes and - // potentially can be overridden. Be very careful when overriding - // hints! Make sure that all chained methods can work in a proposed - // manner of chaining. - // - // Once a method was chained, it is impossible to unchain it. The - // only exception is "constructor". You don't need to define a - // method in order to supply a chaining hint. - // - // If a method is chained, it cannot use this.inherited() because - // all other methods in the hierarchy will be called automatically. - // - // Usually constructors and initializers of any kind are chained - // using "after" and destructors of any kind are chained as - // "before". Note that chaining assumes that chained methods do not - // return any value: any returned value will be discarded. - // - // example: - // | dojo.declare("my.classes.bar", my.classes.foo, { - // | // properties to be added to the class prototype - // | someValue: 2, - // | // initialization function - // | constructor: function(){ - // | this.myComplicatedObject = new ReallyComplicatedObject(); - // | }, - // | // other functions - // | someMethod: function(){ - // | doStuff(); - // | } - // | }); - // - // example: - // | var MyBase = dojo.declare(null, { - // | // constructor, properties, and methods go here - // | // ... - // | }); - // | var MyClass1 = dojo.declare(MyBase, { - // | // constructor, properties, and methods go here - // | // ... - // | }); - // | var MyClass2 = dojo.declare(MyBase, { - // | // constructor, properties, and methods go here - // | // ... - // | }); - // | var MyDiamond = dojo.declare([MyClass1, MyClass2], { - // | // constructor, properties, and methods go here - // | // ... - // | }); - // - // example: - // | var F = function(){ console.log("raw constructor"); }; - // | F.prototype.method = function(){ - // | console.log("raw method"); - // | }; - // | var A = dojo.declare(F, { - // | constructor: function(){ - // | console.log("A.constructor"); - // | }, - // | method: function(){ - // | console.log("before calling F.method..."); - // | this.inherited(arguments); - // | console.log("...back in A"); - // | } - // | }); - // | new A().method(); - // | // will print: - // | // raw constructor - // | // A.constructor - // | // before calling F.method... - // | // raw method - // | // ...back in A - // - // example: - // | var A = dojo.declare(null, { - // | "-chains-": { - // | destroy: "before" - // | } - // | }); - // | var B = dojo.declare(A, { - // | constructor: function(){ - // | console.log("B.constructor"); - // | }, - // | destroy: function(){ - // | console.log("B.destroy"); - // | } - // | }); - // | var C = dojo.declare(B, { - // | constructor: function(){ - // | console.log("C.constructor"); - // | }, - // | destroy: function(){ - // | console.log("C.destroy"); - // | } - // | }); - // | new C().destroy(); - // | // prints: - // | // B.constructor - // | // C.constructor - // | // C.destroy - // | // B.destroy - // - // example: - // | var A = dojo.declare(null, { - // | "-chains-": { - // | constructor: "manual" - // | } - // | }); - // | var B = dojo.declare(A, { - // | constructor: function(){ - // | // ... - // | // call the base constructor with new parameters - // | this.inherited(arguments, [1, 2, 3]); - // | // ... - // | } - // | }); - // - // example: - // | var A = dojo.declare(null, { - // | "-chains-": { - // | m1: "before" - // | }, - // | m1: function(){ - // | console.log("A.m1"); - // | }, - // | m2: function(){ - // | console.log("A.m2"); - // | } - // | }); - // | var B = dojo.declare(A, { - // | "-chains-": { - // | m2: "after" - // | }, - // | m1: function(){ - // | console.log("B.m1"); - // | }, - // | m2: function(){ - // | console.log("B.m2"); - // | } - // | }); - // | var x = new B(); - // | x.m1(); - // | // prints: - // | // B.m1 - // | // A.m1 - // | x.m2(); - // | // prints: - // | // A.m2 - // | // B.m2 - return new Function(); // Function - }; - =====*/ - - /*===== - dojo.safeMixin = function(target, source){ - // summary: - // Mix in properties skipping a constructor and decorating functions - // like it is done by dojo.declare. - // target: Object - // Target object to accept new properties. - // source: Object - // Source object for new properties. - // description: - // This function is used to mix in properties like dojo._mixin does, - // but it skips a constructor property and decorates functions like - // dojo.declare does. - // - // It is meant to be used with classes and objects produced with - // dojo.declare. Functions mixed in with dojo.safeMixin can use - // this.inherited() like normal methods. - // - // This function is used to implement extend() method of a constructor - // produced with dojo.declare(). - // - // example: - // | var A = dojo.declare(null, { - // | m1: function(){ - // | console.log("A.m1"); - // | }, - // | m2: function(){ - // | console.log("A.m2"); - // | } - // | }); - // | var B = dojo.declare(A, { - // | m1: function(){ - // | this.inherited(arguments); - // | console.log("B.m1"); - // | } - // | }); - // | B.extend({ - // | m2: function(){ - // | this.inherited(arguments); - // | console.log("B.m2"); - // | } - // | }); - // | var x = new B(); - // | dojo.safeMixin(x, { - // | m1: function(){ - // | this.inherited(arguments); - // | console.log("X.m1"); - // | }, - // | m2: function(){ - // | this.inherited(arguments); - // | console.log("X.m2"); - // | } - // | }); - // | x.m2(); - // | // prints: - // | // A.m1 - // | // B.m1 - // | // X.m1 - }; - =====*/ - - /*===== - Object.inherited = function(name, args, newArgs){ - // summary: - // Calls a super method. - // name: String? - // The optional method name. Should be the same as the caller's - // name. Usually "name" is specified in complex dynamic cases, when - // the calling method was dynamically added, undecorated by - // dojo.declare, and it cannot be determined. - // args: Arguments - // The caller supply this argument, which should be the original - // "arguments". - // newArgs: Object? - // If "true", the found function will be returned without - // executing it. - // If Array, it will be used to call a super method. Otherwise - // "args" will be used. - // returns: - // Whatever is returned by a super method, or a super method itself, - // if "true" was specified as newArgs. - // description: - // This method is used inside method of classes produced with - // dojo.declare to call a super method (next in the chain). It is - // used for manually controlled chaining. Consider using the regular - // chaining, because it is faster. Use "this.inherited()" only in - // complex cases. - // - // This method cannot me called from automatically chained - // constructors including the case of a special (legacy) - // constructor chaining. It cannot be called from chained methods. - // - // If "this.inherited()" cannot find the next-in-chain method, it - // does nothing and returns "undefined". The last method in chain - // can be a default method implemented in Object, which will be - // called last. - // - // If "name" is specified, it is assumed that the method that - // received "args" is the parent method for this call. It is looked - // up in the chain list and if it is found the next-in-chain method - // is called. If it is not found, the first-in-chain method is - // called. - // - // If "name" is not specified, it will be derived from the calling - // method (using a methoid property "nom"). - // - // example: - // | var B = dojo.declare(A, { - // | method1: function(a, b, c){ - // | this.inherited(arguments); - // | }, - // | method2: function(a, b){ - // | return this.inherited(arguments, [a + b]); - // | } - // | }); - // | // next method is not in the chain list because it is added - // | // manually after the class was created. - // | B.prototype.method3 = function(){ - // | console.log("This is a dynamically-added method."); - // | this.inherited("method3", arguments); - // | }; - // example: - // | var B = dojo.declare(A, { - // | method: function(a, b){ - // | var super = this.inherited(arguments, true); - // | // ... - // | if(!super){ - // | console.log("there is no super method"); - // | return 0; - // | } - // | return super.apply(this, arguments); - // | } - // | }); - return {}; // Object - } - =====*/ - - /*===== - Object.getInherited = function(name, args){ - // summary: - // Returns a super method. - // name: String? - // The optional method name. Should be the same as the caller's - // name. Usually "name" is specified in complex dynamic cases, when - // the calling method was dynamically added, undecorated by - // dojo.declare, and it cannot be determined. - // args: Arguments - // The caller supply this argument, which should be the original - // "arguments". - // returns: - // Returns a super method (Function) or "undefined". - // description: - // This method is a convenience method for "this.inherited()". - // It uses the same algorithm but instead of executing a super - // method, it returns it, or "undefined" if not found. - // - // example: - // | var B = dojo.declare(A, { - // | method: function(a, b){ - // | var super = this.getInherited(arguments); - // | // ... - // | if(!super){ - // | console.log("there is no super method"); - // | return 0; - // | } - // | return super.apply(this, arguments); - // | } - // | }); - return {}; // Object - } - =====*/ - - /*===== - Object.isInstanceOf = function(cls){ - // summary: - // Checks the inheritance chain to see if it is inherited from this - // class. - // cls: Function - // Class constructor. - // returns: - // "true", if this object is inherited from this class, "false" - // otherwise. - // description: - // This method is used with instances of classes produced with - // dojo.declare to determine of they support a certain interface or - // not. It models "instanceof" operator. - // - // example: - // | var A = dojo.declare(null, { - // | // constructor, properties, and methods go here - // | // ... - // | }); - // | var B = dojo.declare(null, { - // | // constructor, properties, and methods go here - // | // ... - // | }); - // | var C = dojo.declare([A, B], { - // | // constructor, properties, and methods go here - // | // ... - // | }); - // | var D = dojo.declare(A, { - // | // constructor, properties, and methods go here - // | // ... - // | }); - // | - // | var a = new A(), b = new B(), c = new C(), d = new D(); - // | - // | console.log(a.isInstanceOf(A)); // true - // | console.log(b.isInstanceOf(A)); // false - // | console.log(c.isInstanceOf(A)); // true - // | console.log(d.isInstanceOf(A)); // true - // | - // | console.log(a.isInstanceOf(B)); // false - // | console.log(b.isInstanceOf(B)); // true - // | console.log(c.isInstanceOf(B)); // true - // | console.log(d.isInstanceOf(B)); // false - // | - // | console.log(a.isInstanceOf(C)); // false - // | console.log(b.isInstanceOf(C)); // false - // | console.log(c.isInstanceOf(C)); // true - // | console.log(d.isInstanceOf(C)); // false - // | - // | console.log(a.isInstanceOf(D)); // false - // | console.log(b.isInstanceOf(D)); // false - // | console.log(c.isInstanceOf(D)); // false - // | console.log(d.isInstanceOf(D)); // true - return {}; // Object - } - =====*/ - - /*===== - Object.extend = function(source){ - // summary: - // Adds all properties and methods of source to constructor's - // prototype, making them available to all instances created with - // constructor. This method is specific to constructors created with - // dojo.declare. - // source: Object - // Source object which properties are going to be copied to the - // constructor's prototype. - // description: - // Adds source properties to the constructor's prototype. It can - // override existing properties. - // - // This method is similar to dojo.extend function, but it is specific - // to constructors produced by dojo.declare. It is implemented - // using dojo.safeMixin, and it skips a constructor property, - // and properly decorates copied functions. - // - // example: - // | var A = dojo.declare(null, { - // | m1: function(){}, - // | s1: "Popokatepetl" - // | }); - // | A.extend({ - // | m1: function(){}, - // | m2: function(){}, - // | f1: true, - // | d1: 42 - // | }); - }; - =====*/ -})(); - -} +//>>built +define("dojo/_base/declare",["./kernel","../has","./lang"],function(_1,_2,_3){var _4=_3.mixin,op=Object.prototype,_5=op.toString,_6=new Function,_7=0,_8="constructor";function _9(_a,_b){throw new Error("declare"+(_b?" "+_b:"")+": "+_a);};function _c(_d,_e){var _f=[],_10=[{cls:0,refs:[]}],_11={},_12=1,l=_d.length,i=0,j,lin,_13,top,_14,rec,_15,_16;for(;i<l;++i){_13=_d[i];if(!_13){_9("mixin #"+i+" is unknown. Did you use dojo.require to pull it in?",_e);}else{if(_5.call(_13)!="[object Function]"){_9("mixin #"+i+" is not a callable constructor.",_e);}}lin=_13._meta?_13._meta.bases:[_13];top=0;for(j=lin.length-1;j>=0;--j){_14=lin[j].prototype;if(!_14.hasOwnProperty("declaredClass")){_14.declaredClass="uniqName_"+(_7++);}_15=_14.declaredClass;if(!_11.hasOwnProperty(_15)){_11[_15]={count:0,refs:[],cls:lin[j]};++_12;}rec=_11[_15];if(top&&top!==rec){rec.refs.push(top);++top.count;}top=rec;}++top.count;_10[0].refs.push(top);}while(_10.length){top=_10.pop();_f.push(top.cls);--_12;while(_16=top.refs,_16.length==1){top=_16[0];if(!top||--top.count){top=0;break;}_f.push(top.cls);--_12;}if(top){for(i=0,l=_16.length;i<l;++i){top=_16[i];if(!--top.count){_10.push(top);}}}}if(_12){_9("can't build consistent linearization",_e);}_13=_d[0];_f[0]=_13?_13._meta&&_13===_f[_f.length-_13._meta.bases.length]?_13._meta.bases.length:1:0;return _f;};function _17(_18,a,f){var _19,_1a,_1b,_1c,_1d,_1e,_1f,opf,pos,_20=this._inherited=this._inherited||{};if(typeof _18=="string"){_19=_18;_18=a;a=f;}f=0;_1c=_18.callee;_19=_19||_1c.nom;if(!_19){_9("can't deduce a name to call inherited()",this.declaredClass);}_1d=this.constructor._meta;_1b=_1d.bases;pos=_20.p;if(_19!=_8){if(_20.c!==_1c){pos=0;_1e=_1b[0];_1d=_1e._meta;if(_1d.hidden[_19]!==_1c){_1a=_1d.chains;if(_1a&&typeof _1a[_19]=="string"){_9("calling chained method with inherited: "+_19,this.declaredClass);}do{_1d=_1e._meta;_1f=_1e.prototype;if(_1d&&(_1f[_19]===_1c&&_1f.hasOwnProperty(_19)||_1d.hidden[_19]===_1c)){break;}}while(_1e=_1b[++pos]);pos=_1e?pos:-1;}}_1e=_1b[++pos];if(_1e){_1f=_1e.prototype;if(_1e._meta&&_1f.hasOwnProperty(_19)){f=_1f[_19];}else{opf=op[_19];do{_1f=_1e.prototype;f=_1f[_19];if(f&&(_1e._meta?_1f.hasOwnProperty(_19):f!==opf)){break;}}while(_1e=_1b[++pos]);}}f=_1e&&f||op[_19];}else{if(_20.c!==_1c){pos=0;_1d=_1b[0]._meta;if(_1d&&_1d.ctor!==_1c){_1a=_1d.chains;if(!_1a||_1a.constructor!=="manual"){_9("calling chained constructor with inherited",this.declaredClass);}while(_1e=_1b[++pos]){_1d=_1e._meta;if(_1d&&_1d.ctor===_1c){break;}}pos=_1e?pos:-1;}}while(_1e=_1b[++pos]){_1d=_1e._meta;f=_1d?_1d.ctor:_1e;if(f){break;}}f=_1e&&f;}_20.c=f;_20.p=pos;if(f){return a===true?f:f.apply(this,a||_18);}};function _21(_22,_23){if(typeof _22=="string"){return this.__inherited(_22,_23,true);}return this.__inherited(_22,true);};function _24(_25,a1,a2){var f=this.getInherited(_25,a1);if(f){return f.apply(this,a2||a1||_25);}};var _26=_1.config.isDebug?_24:_17;function _27(cls){var _28=this.constructor._meta.bases;for(var i=0,l=_28.length;i<l;++i){if(_28[i]===cls){return true;}}return this instanceof cls;};function _29(_2a,_2b){for(var _2c in _2b){if(_2c!=_8&&_2b.hasOwnProperty(_2c)){_2a[_2c]=_2b[_2c];}}if(_2("bug-for-in-skips-shadowed")){for(var _2d=_3._extraNames,i=_2d.length;i;){_2c=_2d[--i];if(_2c!=_8&&_2b.hasOwnProperty(_2c)){_2a[_2c]=_2b[_2c];}}}};function _2e(_2f,_30){var _31,t;for(_31 in _30){t=_30[_31];if((t!==op[_31]||!(_31 in op))&&_31!=_8){if(_5.call(t)=="[object Function]"){t.nom=_31;}_2f[_31]=t;}}if(_2("bug-for-in-skips-shadowed")){for(var _32=_3._extraNames,i=_32.length;i;){_31=_32[--i];t=_30[_31];if((t!==op[_31]||!(_31 in op))&&_31!=_8){if(_5.call(t)=="[object Function]"){t.nom=_31;}_2f[_31]=t;}}}return _2f;};function _33(_34){_35.safeMixin(this.prototype,_34);return this;};function _36(_37,_38){return function(){var a=arguments,_39=a,a0=a[0],f,i,m,l=_37.length,_3a;if(!(this instanceof a.callee)){return _3b(a);}if(_38&&(a0&&a0.preamble||this.preamble)){_3a=new Array(_37.length);_3a[0]=a;for(i=0;;){a0=a[0];if(a0){f=a0.preamble;if(f){a=f.apply(this,a)||a;}}f=_37[i].prototype;f=f.hasOwnProperty("preamble")&&f.preamble;if(f){a=f.apply(this,a)||a;}if(++i==l){break;}_3a[i]=a;}}for(i=l-1;i>=0;--i){f=_37[i];m=f._meta;f=m?m.ctor:f;if(f){f.apply(this,_3a?_3a[i]:a);}}f=this.postscript;if(f){f.apply(this,_39);}};};function _3c(_3d,_3e){return function(){var a=arguments,t=a,a0=a[0],f;if(!(this instanceof a.callee)){return _3b(a);}if(_3e){if(a0){f=a0.preamble;if(f){t=f.apply(this,t)||t;}}f=this.preamble;if(f){f.apply(this,t);}}if(_3d){_3d.apply(this,a);}f=this.postscript;if(f){f.apply(this,a);}};};function _3f(_40){return function(){var a=arguments,i=0,f,m;if(!(this instanceof a.callee)){return _3b(a);}for(;f=_40[i];++i){m=f._meta;f=m?m.ctor:f;if(f){f.apply(this,a);break;}}f=this.postscript;if(f){f.apply(this,a);}};};function _41(_42,_43,_44){return function(){var b,m,f,i=0,_45=1;if(_44){i=_43.length-1;_45=-1;}for(;b=_43[i];i+=_45){m=b._meta;f=(m?m.hidden:b.prototype)[_42];if(f){f.apply(this,arguments);}}};};function _46(_47){_6.prototype=_47.prototype;var t=new _6;_6.prototype=null;return t;};function _3b(_48){var _49=_48.callee,t=_46(_49);_49.apply(t,_48);return t;};function _35(_4a,_4b,_4c){if(typeof _4a!="string"){_4c=_4b;_4b=_4a;_4a="";}_4c=_4c||{};var _4d,i,t,_4e,_4f,_50,_51,_52=1,_53=_4b;if(_5.call(_4b)=="[object Array]"){_50=_c(_4b,_4a);t=_50[0];_52=_50.length-t;_4b=_50[_52];}else{_50=[0];if(_4b){if(_5.call(_4b)=="[object Function]"){t=_4b._meta;_50=_50.concat(t?t.bases:_4b);}else{_9("base class is not a callable constructor.",_4a);}}else{if(_4b!==null){_9("unknown base class. Did you use dojo.require to pull it in?",_4a);}}}if(_4b){for(i=_52-1;;--i){_4d=_46(_4b);if(!i){break;}t=_50[i];(t._meta?_29:_4)(_4d,t.prototype);_4e=new Function;_4e.superclass=_4b;_4e.prototype=_4d;_4b=_4d.constructor=_4e;}}else{_4d={};}_35.safeMixin(_4d,_4c);t=_4c.constructor;if(t!==op.constructor){t.nom=_8;_4d.constructor=t;}for(i=_52-1;i;--i){t=_50[i]._meta;if(t&&t.chains){_51=_4(_51||{},t.chains);}}if(_4d["-chains-"]){_51=_4(_51||{},_4d["-chains-"]);}t=!_51||!_51.hasOwnProperty(_8);_50[0]=_4e=(_51&&_51.constructor==="manual")?_3f(_50):(_50.length==1?_3c(_4c.constructor,t):_36(_50,t));_4e._meta={bases:_50,hidden:_4c,chains:_51,parents:_53,ctor:_4c.constructor};_4e.superclass=_4b&&_4b.prototype;_4e.extend=_33;_4e.prototype=_4d;_4d.constructor=_4e;_4d.getInherited=_21;_4d.isInstanceOf=_27;_4d.inherited=_26;_4d.__inherited=_17;if(_4a){_4d.declaredClass=_4a;_3.setObject(_4a,_4e);}if(_51){for(_4f in _51){if(_4d[_4f]&&typeof _51[_4f]=="string"&&_4f!=_8){t=_4d[_4f]=_41(_4f,_50,_51[_4f]==="after");t.nom=_4f;}}}return _4e;};_1.safeMixin=_35.safeMixin=_2e;_1.declare=_35;return _35;});
\ No newline at end of file diff --git a/lib/dojo/_base/declare.js.uncompressed.js b/lib/dojo/_base/declare.js.uncompressed.js new file mode 100644 index 000000000..838bf1c81 --- /dev/null +++ b/lib/dojo/_base/declare.js.uncompressed.js @@ -0,0 +1,1050 @@ +define("dojo/_base/declare", ["./kernel", "../has", "./lang"], function(dojo, has, lang){ + // module: + // dojo/_base/declare + // summary: + // This module defines dojo.declare. + + var mix = lang.mixin, op = Object.prototype, opts = op.toString, + xtor = new Function, counter = 0, cname = "constructor"; + + function err(msg, cls){ throw new Error("declare" + (cls ? " " + cls : "") + ": " + msg); } + + // C3 Method Resolution Order (see http://www.python.org/download/releases/2.3/mro/) + function c3mro(bases, className){ + var result = [], roots = [{cls: 0, refs: []}], nameMap = {}, clsCount = 1, + l = bases.length, i = 0, j, lin, base, top, proto, rec, name, refs; + + // build a list of bases naming them if needed + for(; i < l; ++i){ + base = bases[i]; + if(!base){ + err("mixin #" + i + " is unknown. Did you use dojo.require to pull it in?", className); + }else if(opts.call(base) != "[object Function]"){ + err("mixin #" + i + " is not a callable constructor.", className); + } + lin = base._meta ? base._meta.bases : [base]; + top = 0; + // add bases to the name map + for(j = lin.length - 1; j >= 0; --j){ + proto = lin[j].prototype; + if(!proto.hasOwnProperty("declaredClass")){ + proto.declaredClass = "uniqName_" + (counter++); + } + name = proto.declaredClass; + if(!nameMap.hasOwnProperty(name)){ + nameMap[name] = {count: 0, refs: [], cls: lin[j]}; + ++clsCount; + } + rec = nameMap[name]; + if(top && top !== rec){ + rec.refs.push(top); + ++top.count; + } + top = rec; + } + ++top.count; + roots[0].refs.push(top); + } + + // remove classes without external references recursively + while(roots.length){ + top = roots.pop(); + result.push(top.cls); + --clsCount; + // optimization: follow a single-linked chain + while(refs = top.refs, refs.length == 1){ + top = refs[0]; + if(!top || --top.count){ + // branch or end of chain => do not end to roots + top = 0; + break; + } + result.push(top.cls); + --clsCount; + } + if(top){ + // branch + for(i = 0, l = refs.length; i < l; ++i){ + top = refs[i]; + if(!--top.count){ + roots.push(top); + } + } + } + } + if(clsCount){ + err("can't build consistent linearization", className); + } + + // calculate the superclass offset + base = bases[0]; + result[0] = base ? + base._meta && base === result[result.length - base._meta.bases.length] ? + base._meta.bases.length : 1 : 0; + + return result; + } + + function inherited(args, a, f){ + var name, chains, bases, caller, meta, base, proto, opf, pos, + cache = this._inherited = this._inherited || {}; + + // crack arguments + if(typeof args == "string"){ + name = args; + args = a; + a = f; + } + f = 0; + + caller = args.callee; + name = name || caller.nom; + if(!name){ + err("can't deduce a name to call inherited()", this.declaredClass); + } + + meta = this.constructor._meta; + bases = meta.bases; + + pos = cache.p; + if(name != cname){ + // method + if(cache.c !== caller){ + // cache bust + pos = 0; + base = bases[0]; + meta = base._meta; + if(meta.hidden[name] !== caller){ + // error detection + chains = meta.chains; + if(chains && typeof chains[name] == "string"){ + err("calling chained method with inherited: " + name, this.declaredClass); + } + // find caller + do{ + meta = base._meta; + proto = base.prototype; + if(meta && (proto[name] === caller && proto.hasOwnProperty(name) || meta.hidden[name] === caller)){ + break; + } + }while(base = bases[++pos]); // intentional assignment + pos = base ? pos : -1; + } + } + // find next + base = bases[++pos]; + if(base){ + proto = base.prototype; + if(base._meta && proto.hasOwnProperty(name)){ + f = proto[name]; + }else{ + opf = op[name]; + do{ + proto = base.prototype; + f = proto[name]; + if(f && (base._meta ? proto.hasOwnProperty(name) : f !== opf)){ + break; + } + }while(base = bases[++pos]); // intentional assignment + } + } + f = base && f || op[name]; + }else{ + // constructor + if(cache.c !== caller){ + // cache bust + pos = 0; + meta = bases[0]._meta; + if(meta && meta.ctor !== caller){ + // error detection + chains = meta.chains; + if(!chains || chains.constructor !== "manual"){ + err("calling chained constructor with inherited", this.declaredClass); + } + // find caller + while(base = bases[++pos]){ // intentional assignment + meta = base._meta; + if(meta && meta.ctor === caller){ + break; + } + } + pos = base ? pos : -1; + } + } + // find next + while(base = bases[++pos]){ // intentional assignment + meta = base._meta; + f = meta ? meta.ctor : base; + if(f){ + break; + } + } + f = base && f; + } + + // cache the found super method + cache.c = f; + cache.p = pos; + + // now we have the result + if(f){ + return a === true ? f : f.apply(this, a || args); + } + // intentionally no return if a super method was not found + } + + function getInherited(name, args){ + if(typeof name == "string"){ + return this.__inherited(name, args, true); + } + return this.__inherited(name, true); + } + + function inherited__debug(args, a1, a2){ + var f = this.getInherited(args, a1); + if(f){ return f.apply(this, a2 || a1 || args); } + // intentionally no return if a super method was not found + } + + var inheritedImpl = dojo.config.isDebug ? inherited__debug : inherited; + + // emulation of "instanceof" + function isInstanceOf(cls){ + var bases = this.constructor._meta.bases; + for(var i = 0, l = bases.length; i < l; ++i){ + if(bases[i] === cls){ + return true; + } + } + return this instanceof cls; + } + + function mixOwn(target, source){ + // add props adding metadata for incoming functions skipping a constructor + for(var name in source){ + if(name != cname && source.hasOwnProperty(name)){ + target[name] = source[name]; + } + } + if(has("bug-for-in-skips-shadowed")){ + for(var extraNames= lang._extraNames, i= extraNames.length; i;){ + name = extraNames[--i]; + if(name != cname && source.hasOwnProperty(name)){ + target[name] = source[name]; + } + } + } + } + + // implementation of safe mixin function + function safeMixin(target, source){ + var name, t; + // add props adding metadata for incoming functions skipping a constructor + for(name in source){ + t = source[name]; + if((t !== op[name] || !(name in op)) && name != cname){ + if(opts.call(t) == "[object Function]"){ + // non-trivial function method => attach its name + t.nom = name; + } + target[name] = t; + } + } + if(has("bug-for-in-skips-shadowed")){ + for(var extraNames= lang._extraNames, i= extraNames.length; i;){ + name = extraNames[--i]; + t = source[name]; + if((t !== op[name] || !(name in op)) && name != cname){ + if(opts.call(t) == "[object Function]"){ + // non-trivial function method => attach its name + t.nom = name; + } + target[name] = t; + } + } + } + return target; + } + + function extend(source){ + declare.safeMixin(this.prototype, source); + return this; + } + + // chained constructor compatible with the legacy dojo.declare() + function chainedConstructor(bases, ctorSpecial){ + return function(){ + var a = arguments, args = a, a0 = a[0], f, i, m, + l = bases.length, preArgs; + + if(!(this instanceof a.callee)){ + // not called via new, so force it + return applyNew(a); + } + + //this._inherited = {}; + // perform the shaman's rituals of the original dojo.declare() + // 1) call two types of the preamble + if(ctorSpecial && (a0 && a0.preamble || this.preamble)){ + // full blown ritual + preArgs = new Array(bases.length); + // prepare parameters + preArgs[0] = a; + for(i = 0;;){ + // process the preamble of the 1st argument + a0 = a[0]; + if(a0){ + f = a0.preamble; + if(f){ + a = f.apply(this, a) || a; + } + } + // process the preamble of this class + f = bases[i].prototype; + f = f.hasOwnProperty("preamble") && f.preamble; + if(f){ + a = f.apply(this, a) || a; + } + // one peculiarity of the preamble: + // it is called if it is not needed, + // e.g., there is no constructor to call + // let's watch for the last constructor + // (see ticket #9795) + if(++i == l){ + break; + } + preArgs[i] = a; + } + } + // 2) call all non-trivial constructors using prepared arguments + for(i = l - 1; i >= 0; --i){ + f = bases[i]; + m = f._meta; + f = m ? m.ctor : f; + if(f){ + f.apply(this, preArgs ? preArgs[i] : a); + } + } + // 3) continue the original ritual: call the postscript + f = this.postscript; + if(f){ + f.apply(this, args); + } + }; + } + + + // chained constructor compatible with the legacy dojo.declare() + function singleConstructor(ctor, ctorSpecial){ + return function(){ + var a = arguments, t = a, a0 = a[0], f; + + if(!(this instanceof a.callee)){ + // not called via new, so force it + return applyNew(a); + } + + //this._inherited = {}; + // perform the shaman's rituals of the original dojo.declare() + // 1) call two types of the preamble + if(ctorSpecial){ + // full blown ritual + if(a0){ + // process the preamble of the 1st argument + f = a0.preamble; + if(f){ + t = f.apply(this, t) || t; + } + } + f = this.preamble; + if(f){ + // process the preamble of this class + f.apply(this, t); + // one peculiarity of the preamble: + // it is called even if it is not needed, + // e.g., there is no constructor to call + // let's watch for the last constructor + // (see ticket #9795) + } + } + // 2) call a constructor + if(ctor){ + ctor.apply(this, a); + } + // 3) continue the original ritual: call the postscript + f = this.postscript; + if(f){ + f.apply(this, a); + } + }; + } + + // plain vanilla constructor (can use inherited() to call its base constructor) + function simpleConstructor(bases){ + return function(){ + var a = arguments, i = 0, f, m; + + if(!(this instanceof a.callee)){ + // not called via new, so force it + return applyNew(a); + } + + //this._inherited = {}; + // perform the shaman's rituals of the original dojo.declare() + // 1) do not call the preamble + // 2) call the top constructor (it can use this.inherited()) + for(; f = bases[i]; ++i){ // intentional assignment + m = f._meta; + f = m ? m.ctor : f; + if(f){ + f.apply(this, a); + break; + } + } + // 3) call the postscript + f = this.postscript; + if(f){ + f.apply(this, a); + } + }; + } + + function chain(name, bases, reversed){ + return function(){ + var b, m, f, i = 0, step = 1; + if(reversed){ + i = bases.length - 1; + step = -1; + } + for(; b = bases[i]; i += step){ // intentional assignment + m = b._meta; + f = (m ? m.hidden : b.prototype)[name]; + if(f){ + f.apply(this, arguments); + } + } + }; + } + + // forceNew(ctor) + // return a new object that inherits from ctor.prototype but + // without actually running ctor on the object. + function forceNew(ctor){ + // create object with correct prototype using a do-nothing + // constructor + xtor.prototype = ctor.prototype; + var t = new xtor; + xtor.prototype = null; // clean up + return t; + } + + // applyNew(args) + // just like 'new ctor()' except that the constructor and its arguments come + // from args, which must be an array or an arguments object + function applyNew(args){ + // create an object with ctor's prototype but without + // calling ctor on it. + var ctor = args.callee, t = forceNew(ctor); + // execute the real constructor on the new object + ctor.apply(t, args); + return t; + } + + function declare(className, superclass, props){ + // crack parameters + if(typeof className != "string"){ + props = superclass; + superclass = className; + className = ""; + } + props = props || {}; + + var proto, i, t, ctor, name, bases, chains, mixins = 1, parents = superclass; + + // build a prototype + if(opts.call(superclass) == "[object Array]"){ + // C3 MRO + bases = c3mro(superclass, className); + t = bases[0]; + mixins = bases.length - t; + superclass = bases[mixins]; + }else{ + bases = [0]; + if(superclass){ + if(opts.call(superclass) == "[object Function]"){ + t = superclass._meta; + bases = bases.concat(t ? t.bases : superclass); + }else{ + err("base class is not a callable constructor.", className); + } + }else if(superclass !== null){ + err("unknown base class. Did you use dojo.require to pull it in?", className); + } + } + if(superclass){ + for(i = mixins - 1;; --i){ + proto = forceNew(superclass); + if(!i){ + // stop if nothing to add (the last base) + break; + } + // mix in properties + t = bases[i]; + (t._meta ? mixOwn : mix)(proto, t.prototype); + // chain in new constructor + ctor = new Function; + ctor.superclass = superclass; + ctor.prototype = proto; + superclass = proto.constructor = ctor; + } + }else{ + proto = {}; + } + // add all properties + declare.safeMixin(proto, props); + // add constructor + t = props.constructor; + if(t !== op.constructor){ + t.nom = cname; + proto.constructor = t; + } + + // collect chains and flags + for(i = mixins - 1; i; --i){ // intentional assignment + t = bases[i]._meta; + if(t && t.chains){ + chains = mix(chains || {}, t.chains); + } + } + if(proto["-chains-"]){ + chains = mix(chains || {}, proto["-chains-"]); + } + + // build ctor + t = !chains || !chains.hasOwnProperty(cname); + bases[0] = ctor = (chains && chains.constructor === "manual") ? simpleConstructor(bases) : + (bases.length == 1 ? singleConstructor(props.constructor, t) : chainedConstructor(bases, t)); + + // add meta information to the constructor + ctor._meta = {bases: bases, hidden: props, chains: chains, + parents: parents, ctor: props.constructor}; + ctor.superclass = superclass && superclass.prototype; + ctor.extend = extend; + ctor.prototype = proto; + proto.constructor = ctor; + + // add "standard" methods to the prototype + proto.getInherited = getInherited; + proto.isInstanceOf = isInstanceOf; + proto.inherited = inheritedImpl; + proto.__inherited = inherited; + + // add name if specified + if(className){ + proto.declaredClass = className; + lang.setObject(className, ctor); + } + + // build chains and add them to the prototype + if(chains){ + for(name in chains){ + if(proto[name] && typeof chains[name] == "string" && name != cname){ + t = proto[name] = chain(name, bases, chains[name] === "after"); + t.nom = name; + } + } + } + // chained methods do not return values + // no need to chain "invisible" functions + + return ctor; // Function + } + + /*===== + dojo.declare = function(className, superclass, props){ + // summary: + // Create a feature-rich constructor from compact notation. + // className: String?: + // The optional name of the constructor (loosely, a "class") + // stored in the "declaredClass" property in the created prototype. + // It will be used as a global name for a created constructor. + // superclass: Function|Function[]: + // May be null, a Function, or an Array of Functions. This argument + // specifies a list of bases (the left-most one is the most deepest + // base). + // props: Object: + // An object whose properties are copied to the created prototype. + // Add an instance-initialization function by making it a property + // named "constructor". + // returns: + // New constructor function. + // description: + // Create a constructor using a compact notation for inheritance and + // prototype extension. + // + // Mixin ancestors provide a type of multiple inheritance. + // Prototypes of mixin ancestors are copied to the new class: + // changes to mixin prototypes will not affect classes to which + // they have been mixed in. + // + // Ancestors can be compound classes created by this version of + // dojo.declare. In complex cases all base classes are going to be + // linearized according to C3 MRO algorithm + // (see http://www.python.org/download/releases/2.3/mro/ for more + // details). + // + // "className" is cached in "declaredClass" property of the new class, + // if it was supplied. The immediate super class will be cached in + // "superclass" property of the new class. + // + // Methods in "props" will be copied and modified: "nom" property + // (the declared name of the method) will be added to all copied + // functions to help identify them for the internal machinery. Be + // very careful, while reusing methods: if you use the same + // function under different names, it can produce errors in some + // cases. + // + // It is possible to use constructors created "manually" (without + // dojo.declare) as bases. They will be called as usual during the + // creation of an instance, their methods will be chained, and even + // called by "this.inherited()". + // + // Special property "-chains-" governs how to chain methods. It is + // a dictionary, which uses method names as keys, and hint strings + // as values. If a hint string is "after", this method will be + // called after methods of its base classes. If a hint string is + // "before", this method will be called before methods of its base + // classes. + // + // If "constructor" is not mentioned in "-chains-" property, it will + // be chained using the legacy mode: using "after" chaining, + // calling preamble() method before each constructor, if available, + // and calling postscript() after all constructors were executed. + // If the hint is "after", it is chained as a regular method, but + // postscript() will be called after the chain of constructors. + // "constructor" cannot be chained "before", but it allows + // a special hint string: "manual", which means that constructors + // are not going to be chained in any way, and programmer will call + // them manually using this.inherited(). In the latter case + // postscript() will be called after the construction. + // + // All chaining hints are "inherited" from base classes and + // potentially can be overridden. Be very careful when overriding + // hints! Make sure that all chained methods can work in a proposed + // manner of chaining. + // + // Once a method was chained, it is impossible to unchain it. The + // only exception is "constructor". You don't need to define a + // method in order to supply a chaining hint. + // + // If a method is chained, it cannot use this.inherited() because + // all other methods in the hierarchy will be called automatically. + // + // Usually constructors and initializers of any kind are chained + // using "after" and destructors of any kind are chained as + // "before". Note that chaining assumes that chained methods do not + // return any value: any returned value will be discarded. + // + // example: + // | dojo.declare("my.classes.bar", my.classes.foo, { + // | // properties to be added to the class prototype + // | someValue: 2, + // | // initialization function + // | constructor: function(){ + // | this.myComplicatedObject = new ReallyComplicatedObject(); + // | }, + // | // other functions + // | someMethod: function(){ + // | doStuff(); + // | } + // | }); + // + // example: + // | var MyBase = dojo.declare(null, { + // | // constructor, properties, and methods go here + // | // ... + // | }); + // | var MyClass1 = dojo.declare(MyBase, { + // | // constructor, properties, and methods go here + // | // ... + // | }); + // | var MyClass2 = dojo.declare(MyBase, { + // | // constructor, properties, and methods go here + // | // ... + // | }); + // | var MyDiamond = dojo.declare([MyClass1, MyClass2], { + // | // constructor, properties, and methods go here + // | // ... + // | }); + // + // example: + // | var F = function(){ console.log("raw constructor"); }; + // | F.prototype.method = function(){ + // | console.log("raw method"); + // | }; + // | var A = dojo.declare(F, { + // | constructor: function(){ + // | console.log("A.constructor"); + // | }, + // | method: function(){ + // | console.log("before calling F.method..."); + // | this.inherited(arguments); + // | console.log("...back in A"); + // | } + // | }); + // | new A().method(); + // | // will print: + // | // raw constructor + // | // A.constructor + // | // before calling F.method... + // | // raw method + // | // ...back in A + // + // example: + // | var A = dojo.declare(null, { + // | "-chains-": { + // | destroy: "before" + // | } + // | }); + // | var B = dojo.declare(A, { + // | constructor: function(){ + // | console.log("B.constructor"); + // | }, + // | destroy: function(){ + // | console.log("B.destroy"); + // | } + // | }); + // | var C = dojo.declare(B, { + // | constructor: function(){ + // | console.log("C.constructor"); + // | }, + // | destroy: function(){ + // | console.log("C.destroy"); + // | } + // | }); + // | new C().destroy(); + // | // prints: + // | // B.constructor + // | // C.constructor + // | // C.destroy + // | // B.destroy + // + // example: + // | var A = dojo.declare(null, { + // | "-chains-": { + // | constructor: "manual" + // | } + // | }); + // | var B = dojo.declare(A, { + // | constructor: function(){ + // | // ... + // | // call the base constructor with new parameters + // | this.inherited(arguments, [1, 2, 3]); + // | // ... + // | } + // | }); + // + // example: + // | var A = dojo.declare(null, { + // | "-chains-": { + // | m1: "before" + // | }, + // | m1: function(){ + // | console.log("A.m1"); + // | }, + // | m2: function(){ + // | console.log("A.m2"); + // | } + // | }); + // | var B = dojo.declare(A, { + // | "-chains-": { + // | m2: "after" + // | }, + // | m1: function(){ + // | console.log("B.m1"); + // | }, + // | m2: function(){ + // | console.log("B.m2"); + // | } + // | }); + // | var x = new B(); + // | x.m1(); + // | // prints: + // | // B.m1 + // | // A.m1 + // | x.m2(); + // | // prints: + // | // A.m2 + // | // B.m2 + return new Function(); // Function + }; + =====*/ + + /*===== + dojo.safeMixin = function(target, source){ + // summary: + // Mix in properties skipping a constructor and decorating functions + // like it is done by dojo.declare. + // target: Object + // Target object to accept new properties. + // source: Object + // Source object for new properties. + // description: + // This function is used to mix in properties like lang.mixin does, + // but it skips a constructor property and decorates functions like + // dojo.declare does. + // + // It is meant to be used with classes and objects produced with + // dojo.declare. Functions mixed in with dojo.safeMixin can use + // this.inherited() like normal methods. + // + // This function is used to implement extend() method of a constructor + // produced with dojo.declare(). + // + // example: + // | var A = dojo.declare(null, { + // | m1: function(){ + // | console.log("A.m1"); + // | }, + // | m2: function(){ + // | console.log("A.m2"); + // | } + // | }); + // | var B = dojo.declare(A, { + // | m1: function(){ + // | this.inherited(arguments); + // | console.log("B.m1"); + // | } + // | }); + // | B.extend({ + // | m2: function(){ + // | this.inherited(arguments); + // | console.log("B.m2"); + // | } + // | }); + // | var x = new B(); + // | dojo.safeMixin(x, { + // | m1: function(){ + // | this.inherited(arguments); + // | console.log("X.m1"); + // | }, + // | m2: function(){ + // | this.inherited(arguments); + // | console.log("X.m2"); + // | } + // | }); + // | x.m2(); + // | // prints: + // | // A.m1 + // | // B.m1 + // | // X.m1 + }; + =====*/ + + /*===== + Object.inherited = function(name, args, newArgs){ + // summary: + // Calls a super method. + // name: String? + // The optional method name. Should be the same as the caller's + // name. Usually "name" is specified in complex dynamic cases, when + // the calling method was dynamically added, undecorated by + // dojo.declare, and it cannot be determined. + // args: Arguments + // The caller supply this argument, which should be the original + // "arguments". + // newArgs: Object? + // If "true", the found function will be returned without + // executing it. + // If Array, it will be used to call a super method. Otherwise + // "args" will be used. + // returns: + // Whatever is returned by a super method, or a super method itself, + // if "true" was specified as newArgs. + // description: + // This method is used inside method of classes produced with + // dojo.declare to call a super method (next in the chain). It is + // used for manually controlled chaining. Consider using the regular + // chaining, because it is faster. Use "this.inherited()" only in + // complex cases. + // + // This method cannot me called from automatically chained + // constructors including the case of a special (legacy) + // constructor chaining. It cannot be called from chained methods. + // + // If "this.inherited()" cannot find the next-in-chain method, it + // does nothing and returns "undefined". The last method in chain + // can be a default method implemented in Object, which will be + // called last. + // + // If "name" is specified, it is assumed that the method that + // received "args" is the parent method for this call. It is looked + // up in the chain list and if it is found the next-in-chain method + // is called. If it is not found, the first-in-chain method is + // called. + // + // If "name" is not specified, it will be derived from the calling + // method (using a methoid property "nom"). + // + // example: + // | var B = dojo.declare(A, { + // | method1: function(a, b, c){ + // | this.inherited(arguments); + // | }, + // | method2: function(a, b){ + // | return this.inherited(arguments, [a + b]); + // | } + // | }); + // | // next method is not in the chain list because it is added + // | // manually after the class was created. + // | B.prototype.method3 = function(){ + // | console.log("This is a dynamically-added method."); + // | this.inherited("method3", arguments); + // | }; + // example: + // | var B = dojo.declare(A, { + // | method: function(a, b){ + // | var super = this.inherited(arguments, true); + // | // ... + // | if(!super){ + // | console.log("there is no super method"); + // | return 0; + // | } + // | return super.apply(this, arguments); + // | } + // | }); + return {}; // Object + } + =====*/ + + /*===== + Object.getInherited = function(name, args){ + // summary: + // Returns a super method. + // name: String? + // The optional method name. Should be the same as the caller's + // name. Usually "name" is specified in complex dynamic cases, when + // the calling method was dynamically added, undecorated by + // dojo.declare, and it cannot be determined. + // args: Arguments + // The caller supply this argument, which should be the original + // "arguments". + // returns: + // Returns a super method (Function) or "undefined". + // description: + // This method is a convenience method for "this.inherited()". + // It uses the same algorithm but instead of executing a super + // method, it returns it, or "undefined" if not found. + // + // example: + // | var B = dojo.declare(A, { + // | method: function(a, b){ + // | var super = this.getInherited(arguments); + // | // ... + // | if(!super){ + // | console.log("there is no super method"); + // | return 0; + // | } + // | return super.apply(this, arguments); + // | } + // | }); + return {}; // Object + } + =====*/ + + /*===== + Object.isInstanceOf = function(cls){ + // summary: + // Checks the inheritance chain to see if it is inherited from this + // class. + // cls: Function + // Class constructor. + // returns: + // "true", if this object is inherited from this class, "false" + // otherwise. + // description: + // This method is used with instances of classes produced with + // dojo.declare to determine of they support a certain interface or + // not. It models "instanceof" operator. + // + // example: + // | var A = dojo.declare(null, { + // | // constructor, properties, and methods go here + // | // ... + // | }); + // | var B = dojo.declare(null, { + // | // constructor, properties, and methods go here + // | // ... + // | }); + // | var C = dojo.declare([A, B], { + // | // constructor, properties, and methods go here + // | // ... + // | }); + // | var D = dojo.declare(A, { + // | // constructor, properties, and methods go here + // | // ... + // | }); + // | + // | var a = new A(), b = new B(), c = new C(), d = new D(); + // | + // | console.log(a.isInstanceOf(A)); // true + // | console.log(b.isInstanceOf(A)); // false + // | console.log(c.isInstanceOf(A)); // true + // | console.log(d.isInstanceOf(A)); // true + // | + // | console.log(a.isInstanceOf(B)); // false + // | console.log(b.isInstanceOf(B)); // true + // | console.log(c.isInstanceOf(B)); // true + // | console.log(d.isInstanceOf(B)); // false + // | + // | console.log(a.isInstanceOf(C)); // false + // | console.log(b.isInstanceOf(C)); // false + // | console.log(c.isInstanceOf(C)); // true + // | console.log(d.isInstanceOf(C)); // false + // | + // | console.log(a.isInstanceOf(D)); // false + // | console.log(b.isInstanceOf(D)); // false + // | console.log(c.isInstanceOf(D)); // false + // | console.log(d.isInstanceOf(D)); // true + return {}; // Object + } + =====*/ + + /*===== + Object.extend = function(source){ + // summary: + // Adds all properties and methods of source to constructor's + // prototype, making them available to all instances created with + // constructor. This method is specific to constructors created with + // dojo.declare. + // source: Object + // Source object which properties are going to be copied to the + // constructor's prototype. + // description: + // Adds source properties to the constructor's prototype. It can + // override existing properties. + // + // This method is similar to dojo.extend function, but it is specific + // to constructors produced by dojo.declare. It is implemented + // using dojo.safeMixin, and it skips a constructor property, + // and properly decorates copied functions. + // + // example: + // | var A = dojo.declare(null, { + // | m1: function(){}, + // | s1: "Popokatepetl" + // | }); + // | A.extend({ + // | m1: function(){}, + // | m2: function(){}, + // | f1: true, + // | d1: 42 + // | }); + }; + =====*/ + + dojo.safeMixin = declare.safeMixin = safeMixin; + dojo.declare = declare; + + return declare; +}); diff --git a/lib/dojo/_base/event.js b/lib/dojo/_base/event.js index 65239bf50..522202d7b 100644 --- a/lib/dojo/_base/event.js +++ b/lib/dojo/_base/event.js @@ -4,646 +4,5 @@ see: http://dojotoolkit.org/license for details */ - -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"); -dojo.require("dojo._base.connect"); - - -// 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); - if( - !dojo.isIE && - (name == "mouseenter" || name == "mouseleave") - ){ - var ofp = fp; - name = (name == "mouseenter") ? "mouseover" : "mouseout"; - fp = function(e){ - 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 >= 32 ? 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 ? (dontFix ? 2 : 1) : 0, 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, - META: dojo.isSafari ? 91 : 224, // the apple key on macs - 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, - // virtual key mapping - copyKey: dojo.isMac && !dojo.isAIR ? (dojo.isSafari ? 91 : 224 ) : 17 - }; - - var evtCopyKey = dojo.isMac ? "metaKey" : "ctrlKey"; - - dojo.isCopyKey = function(e){ - // summary: - // Checks an event for the copy key (meta on Mac, and ctrl anywhere else) - // e: Event - // Event object to examine - return e[evtCopyKey]; // Boolean - }; - - // Public: decoding mouse buttons from events - -/*===== - dojo.mouseButtons = { - // LEFT: Number - // Numeric value of the left mouse button for the platform. - LEFT: 0, - // MIDDLE: Number - // Numeric value of the middle mouse button for the platform. - MIDDLE: 1, - // RIGHT: Number - // Numeric value of the right mouse button for the platform. - RIGHT: 2, - - isButton: function(e, button){ - // summary: - // Checks an event object for a pressed button - // e: Event - // Event object to examine - // button: Number - // The button value (example: dojo.mouseButton.LEFT) - return e.button == button; // Boolean - }, - isLeft: function(e){ - // summary: - // Checks an event object for the pressed left button - // e: Event - // Event object to examine - return e.button == 0; // Boolean - }, - isMiddle: function(e){ - // summary: - // Checks an event object for the pressed middle button - // e: Event - // Event object to examine - return e.button == 1; // Boolean - }, - isRight: function(e){ - // summary: - // Checks an event object for the pressed right button - // e: Event - // Event object to examine - return e.button == 2; // Boolean - } - }; -=====*/ - - if(dojo.isIE < 9 || (dojo.isIE && dojo.isQuirks)){ - dojo.mouseButtons = { - LEFT: 1, - MIDDLE: 4, - RIGHT: 2, - // helper functions - isButton: function(e, button){ return e.button & button; }, - isLeft: function(e){ return e.button & 1; }, - isMiddle: function(e){ return e.button & 4; }, - isRight: function(e){ return e.button & 2; } - }; - }else{ - dojo.mouseButtons = { - LEFT: 0, - MIDDLE: 1, - RIGHT: 2, - // helper functions - isButton: function(e, button){ return e.button == button; }, - isLeft: function(e){ return e.button == 0; }, - isMiddle: function(e){ return e.button == 1; }, - isRight: function(e){ return e.button == 2; } - }; - } - - // 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; - } - if (dojo.isIE < 9 || dojo.isQuirks) { - 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 || (dojo.isIE >= 9 && !dojo.isQuirks)) && 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); - if(dojo.isIE < 9 || (dojo.isIE && dojo.isQuirks)){ - 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 = (dojo.isIE < 9 || dojo.isQuirks) ? function(evt){ - evt = evt || window.event; - del._stopPropagation.call(evt); - del._preventDefault.call(evt); - } : dojo.stopEvent; - } - - 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; - } - }); - } - - // Webkit event normalization - if(dojo.isWebKit){ - 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<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){ - var f = h[lls[i]]; - if(!(i in ap) && f){ - f.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)); }; - }; -} - -} +//>>built +define("dojo/_base/event",["./kernel","../on","../has","../dom-geometry"],function(_1,on,_2,_3){if(on._fixEvent){var _4=on._fixEvent;on._fixEvent=function(_5,se){_5=_4(_5,se);if(_5){_3.normalizeEvent(_5);}return _5;};}_1.fixEvent=function(_6,_7){if(on._fixEvent){return on._fixEvent(_6,_7);}return _6;};_1.stopEvent=function(_8){if(_2("dom-addeventlistener")||(_8&&_8.preventDefault)){_8.preventDefault();_8.stopPropagation();}else{_8=_8||window.event;_8.cancelBubble=true;on._preventDefault.call(_8);}};return {fix:_1.fixEvent,stop:_1.stopEvent};});
\ No newline at end of file diff --git a/lib/dojo/_base/event.js.uncompressed.js b/lib/dojo/_base/event.js.uncompressed.js new file mode 100644 index 000000000..34b9ce8e6 --- /dev/null +++ b/lib/dojo/_base/event.js.uncompressed.js @@ -0,0 +1,51 @@ +define("dojo/_base/event", ["./kernel", "../on", "../has", "../dom-geometry"], function(dojo, on, has, dom){ + // module: + // dojo/_base/event + // summary: + // This module defines dojo DOM event API. + if(on._fixEvent){ + var fixEvent = on._fixEvent; + on._fixEvent = function(evt, se){ + // add some additional normalization for back-compat, this isn't in on.js because it is somewhat more expensive + evt = fixEvent(evt, se); + if(evt){ + dom.normalizeEvent(evt); + } + return evt; + }; + } + 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" + if(on._fixEvent){ + return on._fixEvent(evt, sender); + } + return evt; // Event + }; + + 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. + if(has("dom-addeventlistener") || (evt && evt.preventDefault)){ + evt.preventDefault(); + evt.stopPropagation(); + }else{ + evt = evt || window.event; + evt.cancelBubble = true; + on._preventDefault.call(evt); + } + }; + + return { + fix: dojo.fixEvent, + stop: dojo.stopEvent + }; +}); diff --git a/lib/dojo/_base/fx.js b/lib/dojo/_base/fx.js index 860e0e18b..0ac96bc69 100644 --- a/lib/dojo/_base/fx.js +++ b/lib/dojo/_base/fx.js @@ -4,667 +4,5 @@ see: http://dojotoolkit.org/license for details */ - -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"); -dojo.require("dojo._base.Color"); -dojo.require("dojo._base.connect"); -dojo.require("dojo._base.lang"); -dojo.require("dojo._base.html"); - - -/* - Animation loosely package based on Dan Pupius' work, contributed under CLA: - http://pupius.co.uk/js/Toolkit.Drawing.js -*/ -(function(){ - var d = dojo; - var _mixin = d._mixin; - - 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; - }; - - dojo._Line.prototype.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 - }; - - dojo.Animation = function(args){ - // summary: - // A generic animation class that fires callbacks into its handlers - // object at various states. - // description: - // 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. - // args: Object - // The 'magic argument', mixing all the properties into this - // animation instance. - - _mixin(this, args); - if(d.isArray(this.curve)){ - this.curve = new d._Line(this.curve[0], this.curve[1]); - } - - }; - - // Alias to drop come 2.0: - d._Animation = d.Animation; - - d.extend(dojo.Animation, { - // 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: 1000/rate = fps) - rate: 20 /* 50 fps */, - - /*===== - // delay: Integer? - // The time in milliseconds to wait before starting animation after it - // has been .play()'ed - delay: null, - - // 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, - - _getStep: function(){ - var _p = this._percent, - _e = this.easing - ; - return _e ? _e(_p) : _p; - }, - _fire: function(/*Event*/ evt, /*Array?*/ args){ - // summary: - // Convenience function. Fire event "evt" and pass it the - // arguments specified in "args". - // description: - // Convenience function. Fire event "evt" and pass it the - // arguments specified in "args". - // Fires the callback in the scope of the `dojo.Animation` - // instance. - // evt: - // The event to fire. - // args: - // The arguments to pass to the event. - var a = args||[]; - if(this[evt]){ - if(d.config.debugAtAllCosts){ - this[evt].apply(this, a); - }else{ - try{ - this[evt].apply(this, a); - }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. - // returns: dojo.Animation - // The instance to allow chaining. - - var _t = this; - if(_t._delayTimer){ _t._clearTimer(); } - if(gotoStart){ - _t._stopTimer(); - _t._active = _t._paused = false; - _t._percent = 0; - }else if(_t._active && !_t._paused){ - return _t; - } - - _t._fire("beforeBegin", [_t.node]); - - var de = delay || _t.delay, - _p = dojo.hitch(_t, "_play", gotoStart); - - if(de > 0){ - _t._delayTimer = setTimeout(_p, de); - return _t; - } - _p(); - return _t; - }, - - _play: function(gotoStart){ - var _t = this; - if(_t._delayTimer){ _t._clearTimer(); } - _t._startTime = new Date().valueOf(); - if(_t._paused){ - _t._startTime -= _t.duration * _t._percent; - } - - _t._active = true; - _t._paused = false; - var value = _t.curve.getValue(_t._getStep()); - 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. - var _t = this; - if(_t._delayTimer){ _t._clearTimer(); } - _t._stopTimer(); - if(!_t._active){ return _t; /*dojo.Animation*/ } - _t._paused = true; - _t._fire("onPause", [_t.curve.getValue(_t._getStep())]); - return _t; // 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. - var _t = this; - _t._stopTimer(); - _t._active = _t._paused = true; - _t._percent = percent; - if(andPlay){ _t.play(); } - return _t; // dojo.Animation - }, - - stop: function(/*boolean?*/ gotoEnd){ - // summary: Stops a running animation. - // gotoEnd: If true, the animation will end. - var _t = this; - if(_t._delayTimer){ _t._clearTimer(); } - if(!_t._timer){ return _t; /* dojo.Animation */ } - _t._stopTimer(); - if(gotoEnd){ - _t._percent = 1; - } - _t._fire("onStop", [_t.curve.getValue(_t._getStep())]); - _t._active = _t._paused = false; - return _t; // 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.duration); - - 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.node]); - !_t.repeat && _t._stopTimer(); - } - } - return _t; // dojo.Animation - }, - - _clearTimer: function(){ - // summary: Clear the play delay timer - clearTimeout(this._delayTimer); - delete this._delayTimer; - } - - }); - - // the local timer, stubbed into all Animation instances - var ctr = 0, - timer = null, - runner = { - run: function(){} - }; - - d.extend(d.Animation, { - - _startTimer: function(){ - if(!this._timer){ - this._timer = d.connect(runner, "run", this, "_cycle"); - ctr++; - } - if(!timer){ - timer = setInterval(d.hitch(runner, "run"), this.rate); - } - }, - - _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 = _mixin({ properties: {} }, args), - props = (fArgs.properties.opacity = {}); - - props.start = !("start" in fArgs) ? - function(){ - return +d.style(fArgs.node, "opacity")||0; - } : 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(_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(_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(); - } - } - }; - - PropLine.prototype.getValue = function(r){ - var ret = {}; - for(var p in this._properties){ - var prop = this._properties[p], - 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" : 0); - } - } - 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 'units' 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. Defaults to 'px' if ommitted. - // - // example: - // Animate width, height, and padding over 2 seconds... the - // pedantic way: - // | dojo.animateProperty({ node: node, duration:2000, - // | properties: { - // | width: { start: '200', end: '400', units:"px" }, - // | height: { start:'200', end: '400', units:"px" }, - // | paddingTop: { start:'5', end:'50', units:"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(node){ - // | // called when the animation finishes. The animation - // | // target is passed to this function - // | } - // | }).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(){ - // | console.log("animation ended"); - // | }); - // | // play the animation now: - // | anim.play(); - // - // example: - // Each property can be a function whose return value is substituted along. - // Additionally, each measurement (eg: start, end) can be a function. The node - // reference is passed direcly to callbacks. - // | dojo.animateProperty({ - // | node:"mine", - // | properties:{ - // | height:function(node){ - // | // shrink this node by 50% - // | return dojo.position(node).h / 2 - // | }, - // | width:{ - // | start:function(node){ return 100; }, - // | end:function(node){ return 200; } - // | } - // | } - // | }).play(); - // - - var n = 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]; - if(d.isFunction(prop)){ - prop = prop(n); - } - prop = pm[p] = _mixin({}, (d.isObject(prop) ? prop: { end: prop })); - - if(d.isFunction(prop.start)){ - prop.start = prop.start(n); - } - if(d.isFunction(prop.end)){ - prop.end = prop.end(n); - } - 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") ? +v : (isColor ? v : parseFloat(v)); - } - if(!("end" in prop)){ - prop.end = getStyle(n, p); - }else if(!("start" in prop)){ - prop.start = getStyle(n, p); - } - - if(isColor){ - prop.start = new d.Color(prop.start); - prop.end = new d.Color(prop.end); - }else{ - prop.start = (p == "opacity") ? +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({ // dojo.Animation - node: node, - duration: duration || d.Animation.prototype.duration, - properties: properties, - easing: easing, - onEnd: onEnd - }).play(delay || 0); - }; -})(); - -} +//>>built +define("dojo/_base/fx",["./kernel","./lang","../Evented","./Color","./connect","./sniff","../dom","../dom-style"],function(_1,_2,_3,_4,_5,_6,_7,_8){var _9=_2.mixin;_1._Line=function(_a,_b){this.start=_a;this.end=_b;};_1._Line.prototype.getValue=function(n){return ((this.end-this.start)*n)+this.start;};_1.Animation=function(_c){_9(this,_c);if(_2.isArray(this.curve)){this.curve=new _1._Line(this.curve[0],this.curve[1]);}};_1.Animation.prototype=new _3();_1._Animation=_1.Animation;_2.extend(_1.Animation,{duration:350,repeat:0,rate:20,_percent:0,_startRepeatCount:0,_getStep:function(){var _d=this._percent,_e=this.easing;return _e?_e(_d):_d;},_fire:function(_f,_10){var a=_10||[];if(this[_f]){if(_1.config.debugAtAllCosts){this[_f].apply(this,a);}else{try{this[_f].apply(this,a);}catch(e){console.error("exception in animation handler for:",_f);console.error(e);}}}return this;},play:function(_11,_12){var _13=this;if(_13._delayTimer){_13._clearTimer();}if(_12){_13._stopTimer();_13._active=_13._paused=false;_13._percent=0;}else{if(_13._active&&!_13._paused){return _13;}}_13._fire("beforeBegin",[_13.node]);var de=_11||_13.delay,_14=_2.hitch(_13,"_play",_12);if(de>0){_13._delayTimer=setTimeout(_14,de);return _13;}_14();return _13;},_play:function(_15){var _16=this;if(_16._delayTimer){_16._clearTimer();}_16._startTime=new Date().valueOf();if(_16._paused){_16._startTime-=_16.duration*_16._percent;}_16._active=true;_16._paused=false;var _17=_16.curve.getValue(_16._getStep());if(!_16._percent){if(!_16._startRepeatCount){_16._startRepeatCount=_16.repeat;}_16._fire("onBegin",[_17]);}_16._fire("onPlay",[_17]);_16._cycle();return _16;},pause:function(){var _18=this;if(_18._delayTimer){_18._clearTimer();}_18._stopTimer();if(!_18._active){return _18;}_18._paused=true;_18._fire("onPause",[_18.curve.getValue(_18._getStep())]);return _18;},gotoPercent:function(_19,_1a){var _1b=this;_1b._stopTimer();_1b._active=_1b._paused=true;_1b._percent=_19;if(_1a){_1b.play();}return _1b;},stop:function(_1c){var _1d=this;if(_1d._delayTimer){_1d._clearTimer();}if(!_1d._timer){return _1d;}_1d._stopTimer();if(_1c){_1d._percent=1;}_1d._fire("onStop",[_1d.curve.getValue(_1d._getStep())]);_1d._active=_1d._paused=false;return _1d;},status:function(){if(this._active){return this._paused?"paused":"playing";}return "stopped";},_cycle:function(){var _1e=this;if(_1e._active){var _1f=new Date().valueOf();var _20=(_1f-_1e._startTime)/(_1e.duration);if(_20>=1){_20=1;}_1e._percent=_20;if(_1e.easing){_20=_1e.easing(_20);}_1e._fire("onAnimate",[_1e.curve.getValue(_20)]);if(_1e._percent<1){_1e._startTimer();}else{_1e._active=false;if(_1e.repeat>0){_1e.repeat--;_1e.play(null,true);}else{if(_1e.repeat==-1){_1e.play(null,true);}else{if(_1e._startRepeatCount){_1e.repeat=_1e._startRepeatCount;_1e._startRepeatCount=0;}}}_1e._percent=0;_1e._fire("onEnd",[_1e.node]);!_1e.repeat&&_1e._stopTimer();}}return _1e;},_clearTimer:function(){clearTimeout(this._delayTimer);delete this._delayTimer;}});var ctr=0,_21=null,_22={run:function(){}};_2.extend(_1.Animation,{_startTimer:function(){if(!this._timer){this._timer=_5.connect(_22,"run",this,"_cycle");ctr++;}if(!_21){_21=setInterval(_2.hitch(_22,"run"),this.rate);}},_stopTimer:function(){if(this._timer){_5.disconnect(this._timer);this._timer=null;ctr--;}if(ctr<=0){clearInterval(_21);_21=null;ctr=0;}}});var _23=_6("ie")?function(_24){var ns=_24.style;if(!ns.width.length&&_8.get(_24,"width")=="auto"){ns.width="auto";}}:function(){};_1._fade=function(_25){_25.node=_7.byId(_25.node);var _26=_9({properties:{}},_25),_27=(_26.properties.opacity={});_27.start=!("start" in _26)?function(){return +_8.get(_26.node,"opacity")||0;}:_26.start;_27.end=_26.end;var _28=_1.animateProperty(_26);_5.connect(_28,"beforeBegin",_2.partial(_23,_26.node));return _28;};_1.fadeIn=function(_29){return _1._fade(_9({end:1},_29));};_1.fadeOut=function(_2a){return _1._fade(_9({end:0},_2a));};_1._defaultEasing=function(n){return 0.5+((Math.sin((n+1.5)*Math.PI))/2);};var _2b=function(_2c){this._properties=_2c;for(var p in _2c){var _2d=_2c[p];if(_2d.start instanceof _4){_2d.tempColor=new _4();}}};_2b.prototype.getValue=function(r){var ret={};for(var p in this._properties){var _2e=this._properties[p],_2f=_2e.start;if(_2f instanceof _4){ret[p]=_4.blendColors(_2f,_2e.end,r,_2e.tempColor).toCss();}else{if(!_2.isArray(_2f)){ret[p]=((_2e.end-_2f)*r)+_2f+(p!="opacity"?_2e.units||"px":0);}}}return ret;};_1.animateProperty=function(_30){var n=_30.node=_7.byId(_30.node);if(!_30.easing){_30.easing=_1._defaultEasing;}var _31=new _1.Animation(_30);_5.connect(_31,"beforeBegin",_31,function(){var pm={};for(var p in this.properties){if(p=="width"||p=="height"){this.node.display="block";}var _32=this.properties[p];if(_2.isFunction(_32)){_32=_32(n);}_32=pm[p]=_9({},(_2.isObject(_32)?_32:{end:_32}));if(_2.isFunction(_32.start)){_32.start=_32.start(n);}if(_2.isFunction(_32.end)){_32.end=_32.end(n);}var _33=(p.toLowerCase().indexOf("color")>=0);function _34(_35,p){var v={height:_35.offsetHeight,width:_35.offsetWidth}[p];if(v!==undefined){return v;}v=_8.get(_35,p);return (p=="opacity")?+v:(_33?v:parseFloat(v));};if(!("end" in _32)){_32.end=_34(n,p);}else{if(!("start" in _32)){_32.start=_34(n,p);}}if(_33){_32.start=new _4(_32.start);_32.end=new _4(_32.end);}else{_32.start=(p=="opacity")?+_32.start:parseFloat(_32.start);}}this.curve=new _2b(pm);});_5.connect(_31,"onAnimate",_2.hitch(_8,"set",_31.node));return _31;};_1.anim=function(_36,_37,_38,_39,_3a,_3b){return _1.animateProperty({node:_36,duration:_38||_1.Animation.prototype.duration,properties:_37,easing:_39,onEnd:_3a}).play(_3b||0);};return {_Line:_1._Line,Animation:_1.Animation,_fade:_1._fade,fadeIn:_1.fadeIn,fadeOut:_1.fadeOut,_defaultEasing:_1._defaultEasing,animateProperty:_1.animateProperty,anim:_1.anim};});
\ No newline at end of file diff --git a/lib/dojo/_base/fx.js.uncompressed.js b/lib/dojo/_base/fx.js.uncompressed.js new file mode 100644 index 000000000..cf52b0de1 --- /dev/null +++ b/lib/dojo/_base/fx.js.uncompressed.js @@ -0,0 +1,666 @@ +define("dojo/_base/fx", ["./kernel", "./lang", "../Evented", "./Color", "./connect", "./sniff", "../dom", "../dom-style"], function(dojo, lang, Evented, Color, connect, has, dom, style){ + // module: + // dojo/_base/fx + // summary: + // This module defines the base dojo.fx implementation. + // notes: + // Animation loosely package based on Dan Pupius' work, contributed under CLA; see + // http://pupius.co.uk/js/Toolkit.Drawing.js + + var _mixin = lang.mixin; + + 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; + }; + + dojo._Line.prototype.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 + }; + + dojo.Animation = function(args){ + // summary: + // A generic animation class that fires callbacks into its handlers + // object at various states. + // description: + // 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. + // args: Object + // The 'magic argument', mixing all the properties into this + // animation instance. + + _mixin(this, args); + if(lang.isArray(this.curve)){ + this.curve = new dojo._Line(this.curve[0], this.curve[1]); + } + + }; + dojo.Animation.prototype = new Evented(); + // Alias to drop come 2.0: + dojo._Animation = dojo.Animation; + + lang.extend(dojo.Animation, { + // 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: 1000/rate = fps) + rate: 20 /* 50 fps */, + + /*===== + // delay: Integer? + // The time in milliseconds to wait before starting animation after it + // has been .play()'ed + delay: null, + + // 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, + + _getStep: function(){ + var _p = this._percent, + _e = this.easing + ; + return _e ? _e(_p) : _p; + }, + _fire: function(/*Event*/ evt, /*Array?*/ args){ + // summary: + // Convenience function. Fire event "evt" and pass it the + // arguments specified in "args". + // description: + // Convenience function. Fire event "evt" and pass it the + // arguments specified in "args". + // Fires the callback in the scope of the `dojo.Animation` + // instance. + // evt: + // The event to fire. + // args: + // The arguments to pass to the event. + var a = args||[]; + if(this[evt]){ + if(dojo.config.debugAtAllCosts){ + this[evt].apply(this, a); + }else{ + try{ + this[evt].apply(this, a); + }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. + // returns: dojo.Animation + // The instance to allow chaining. + + var _t = this; + if(_t._delayTimer){ _t._clearTimer(); } + if(gotoStart){ + _t._stopTimer(); + _t._active = _t._paused = false; + _t._percent = 0; + }else if(_t._active && !_t._paused){ + return _t; + } + + _t._fire("beforeBegin", [_t.node]); + + var de = delay || _t.delay, + _p = lang.hitch(_t, "_play", gotoStart); + + if(de > 0){ + _t._delayTimer = setTimeout(_p, de); + return _t; + } + _p(); + return _t; // dojo.Animation + }, + + _play: function(gotoStart){ + var _t = this; + if(_t._delayTimer){ _t._clearTimer(); } + _t._startTime = new Date().valueOf(); + if(_t._paused){ + _t._startTime -= _t.duration * _t._percent; + } + + _t._active = true; + _t._paused = false; + var value = _t.curve.getValue(_t._getStep()); + 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. + var _t = this; + if(_t._delayTimer){ _t._clearTimer(); } + _t._stopTimer(); + if(!_t._active){ return _t; /*dojo.Animation*/ } + _t._paused = true; + _t._fire("onPause", [_t.curve.getValue(_t._getStep())]); + return _t; // 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. + var _t = this; + _t._stopTimer(); + _t._active = _t._paused = true; + _t._percent = percent; + if(andPlay){ _t.play(); } + return _t; // dojo.Animation + }, + + stop: function(/*boolean?*/ gotoEnd){ + // summary: Stops a running animation. + // gotoEnd: If true, the animation will end. + var _t = this; + if(_t._delayTimer){ _t._clearTimer(); } + if(!_t._timer){ return _t; /* dojo.Animation */ } + _t._stopTimer(); + if(gotoEnd){ + _t._percent = 1; + } + _t._fire("onStop", [_t.curve.getValue(_t._getStep())]); + _t._active = _t._paused = false; + return _t; // 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.duration); + + 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.node]); + !_t.repeat && _t._stopTimer(); + } + } + return _t; // dojo.Animation + }, + + _clearTimer: function(){ + // summary: Clear the play delay timer + clearTimeout(this._delayTimer); + delete this._delayTimer; + } + + }); + + // the local timer, stubbed into all Animation instances + var ctr = 0, + timer = null, + runner = { + run: function(){} + }; + + lang.extend(dojo.Animation, { + + _startTimer: function(){ + if(!this._timer){ + this._timer = connect.connect(runner, "run", this, "_cycle"); + ctr++; + } + if(!timer){ + timer = setInterval(lang.hitch(runner, "run"), this.rate); + } + }, + + _stopTimer: function(){ + if(this._timer){ + connect.disconnect(this._timer); + this._timer = null; + ctr--; + } + if(ctr <= 0){ + clearInterval(timer); + timer = null; + ctr = 0; + } + } + + }); + + var _makeFadeable = + has("ie") ? 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 && style.get(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 = dom.byId(args.node); + var fArgs = _mixin({ properties: {} }, args), + props = (fArgs.properties.opacity = {}); + + props.start = !("start" in fArgs) ? + function(){ + return +style.get(fArgs.node, "opacity")||0; + } : fArgs.start; + props.end = fArgs.end; + + var anim = dojo.animateProperty(fArgs); + connect.connect(anim, "beforeBegin", lang.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 dojo._fade(_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 dojo._fade(_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); // Decimal + }; + + 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 Color){ + // create a reusable temp color object to keep intermediate results + prop.tempColor = new Color(); + } + } + }; + + PropLine.prototype.getValue = function(r){ + var ret = {}; + for(var p in this._properties){ + var prop = this._properties[p], + start = prop.start; + if(start instanceof Color){ + ret[p] = Color.blendColors(start, prop.end, r, prop.tempColor).toCss(); + }else if(!lang.isArray(start)){ + ret[p] = ((prop.end - start) * r) + start + (p != "opacity" ? prop.units || "px" : 0); + } + } + 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 'units' 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. Defaults to 'px' if ommitted. + // + // example: + // Animate width, height, and padding over 2 seconds... the + // pedantic way: + // | dojo.animateProperty({ node: node, duration:2000, + // | properties: { + // | width: { start: '200', end: '400', units:"px" }, + // | height: { start:'200', end: '400', units:"px" }, + // | paddingTop: { start:'5', end:'50', units:"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(node){ + // | // called when the animation finishes. The animation + // | // target is passed to this function + // | } + // | }).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(){ + // | console.log("animation ended"); + // | }); + // | // play the animation now: + // | anim.play(); + // + // example: + // Each property can be a function whose return value is substituted along. + // Additionally, each measurement (eg: start, end) can be a function. The node + // reference is passed direcly to callbacks. + // | dojo.animateProperty({ + // | node:"mine", + // | properties:{ + // | height:function(node){ + // | // shrink this node by 50% + // | return dojo.position(node).h / 2 + // | }, + // | width:{ + // | start:function(node){ return 100; }, + // | end:function(node){ return 200; } + // | } + // | } + // | }).play(); + // + + var n = args.node = dom.byId(args.node); + if(!args.easing){ args.easing = dojo._defaultEasing; } + + var anim = new dojo.Animation(args); + connect.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]; + if(lang.isFunction(prop)){ + prop = prop(n); + } + prop = pm[p] = _mixin({}, (lang.isObject(prop) ? prop: { end: prop })); + + if(lang.isFunction(prop.start)){ + prop.start = prop.start(n); + } + if(lang.isFunction(prop.end)){ + prop.end = prop.end(n); + } + 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 = style.get(node, p); + return (p == "opacity") ? +v : (isColor ? v : parseFloat(v)); + } + if(!("end" in prop)){ + prop.end = getStyle(n, p); + }else if(!("start" in prop)){ + prop.start = getStyle(n, p); + } + + if(isColor){ + prop.start = new Color(prop.start); + prop.end = new Color(prop.end); + }else{ + prop.start = (p == "opacity") ? +prop.start : parseFloat(prop.start); + } + } + this.curve = new PropLine(pm); + }); + connect.connect(anim, "onAnimate", lang.hitch(style, "set", 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 dojo.animateProperty({ // dojo.Animation + node: node, + duration: duration || dojo.Animation.prototype.duration, + properties: properties, + easing: easing, + onEnd: onEnd + }).play(delay || 0); + }; + + return { + _Line: dojo._Line, + Animation: dojo.Animation, + _fade: dojo._fade, + fadeIn: dojo.fadeIn, + fadeOut: dojo.fadeOut, + _defaultEasing: dojo._defaultEasing, + animateProperty: dojo.animateProperty, + anim: dojo.anim + }; +}); diff --git a/lib/dojo/_base/html.js b/lib/dojo/_base/html.js index 8661b2b12..89f6a5192 100644 --- a/lib/dojo/_base/html.js +++ b/lib/dojo/_base/html.js @@ -4,1833 +4,5 @@ see: http://dojotoolkit.org/license for details */ - -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"); -dojo.require("dojo._base.lang"); - - -// FIXME: need to add unit tests for all the semi-public methods - -try{ - document.execCommand("BackgroundImageCache", false, true); -}catch(e){ - // sane browsers don't have cache "issues" -} - -// ============================= -// DOM Functions -// ============================= - -/*===== -dojo.byId = function(id, doc){ - // summary: - // Returns DOM node with matching `id` attribute or `null` - // if not found. If `id` is a DomNode, this function is a no-op. - // - // id: String|DOMNode - // A string to match an HTML id attribute or a reference to a DOM Node - // - // doc: Document? - // Document to work in. Defaults to the current value of - // dojo.doc. Can be used to retrieve - // node references from other documents. - // - // example: - // Look up a node by ID: - // | var n = dojo.byId("foo"); - // - // example: - // Check if a node exists, and use it. - // | var n = dojo.byId("bar"); - // | if(n){ doStuff() ... } - // - // example: - // Allow string or DomNode references to be passed to a custom function: - // | var foo = function(nodeOrId){ - // | nodeOrId = dojo.byId(nodeOrId); - // | // ... more stuff - // | } -=====*/ - -if(dojo.isIE){ - dojo.byId = function(id, doc){ - if(typeof id != "string"){ - return id; - } - var _d = doc || dojo.doc, 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 || te.id == id)){ - return te; - }else{ - var eles = _d.all[id]; - if(!eles || eles.nodeName){ - eles = [eles]; - } - // if more than 1, choose first with the correct id - var i=0; - while((te=eles[i++])){ - if((te.attributes && te.attributes.id && te.attributes.id.value == id) - || te.id == id){ - return te; - } - } - } - }; -}else{ - dojo.byId = function(id, doc){ - // inline'd type check. - // be sure to return null per documentation, to match IE branch. - return ((typeof id == "string") ? (doc || dojo.doc).getElementById(id) : id) || null; // DomNode - }; -} -/*===== -}; -=====*/ - -(function(){ - var d = dojo; - var byId = d.byId; - - var _destroyContainer = null, - _destroyDoc; - d.addOnWindowUnload(function(){ - _destroyContainer = null; //prevent IE leak - }); - -/*===== - dojo._destroyElement = function(node){ - // summary: - // Existing alias for `dojo.destroy`. Deprecated, will be removed - // in 2.0 - } -=====*/ - dojo._destroyElement = dojo.destroy = function(/*String|DomNode*/node){ - // summary: - // Removes a node from its parent, clobbering it and all of its - // children. - // - // description: - // Removes a node from its parent, clobbering it and all of its - // children. Function only works with DomNodes, and returns nothing. - // - // node: - // A String ID or DomNode reference of the element to be destroyed - // - // example: - // Destroy a node byId: - // | dojo.destroy("someId"); - // - // example: - // Destroy all nodes in a list by reference: - // | dojo.query(".someNode").forEach(dojo.destroy); - - node = byId(node); - try{ - var doc = node.ownerDocument; - // cannot use _destroyContainer.ownerDocument since this can throw an exception on IE - if(!_destroyContainer || _destroyDoc != doc){ - _destroyContainer = doc.createElement("div"); - _destroyDoc = doc; - } - _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: string id or node reference to test - // ancestor: string id or node reference of potential parent to test against - // - // example: - // Test is node id="bar" is a descendant of node id="foo" - // | if(dojo.isDescendant("bar", "foo")){ ... } - try{ - node = byId(node); - ancestor = 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: - // state to put the node in. false indicates unselectable, true - // allows selection. - // example: - // Make the node id="bar" unselectable - // | dojo.setSelectable("bar"); - // example: - // Make the node id="bar" selectable - // | dojo.setSelectable("bar", true); - node = byId(node); - if(d.isMozilla){ - node.style.MozUserSelect = selectable ? "" : "none"; - }else if(d.isKhtml || d.isWebKit){ - 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(/*DomNode*/node, /*DomNode*/ref){ - var parent = ref.parentNode; - if(parent){ - parent.insertBefore(node, ref); - } - }; - - var _insertAfter = function(/*DomNode*/node, /*DomNode*/ref){ - // summary: - // Try to insert node after ref - var parent = ref.parentNode; - if(parent){ - if(parent.lastChild == ref){ - parent.appendChild(node); - }else{ - parent.insertBefore(node, ref.nextSibling); - } - } - }; - - dojo.place = function(node, refNode, position){ - // summary: - // Attempt to insert node into the DOM, choosing from various positioning options. - // Returns the first argument resolved to a DOM node. - // - // node: String|DomNode - // id or node reference, or HTML fragment starting with "<" to place relative to refNode - // - // refNode: String|DomNode - // id or node reference to use as basis for placement - // - // position: String|Number? - // string noting the position of node relative to refNode or a - // number indicating the location in the childNodes collection of refNode. - // Accepted string values are: - // | * before - // | * after - // | * replace - // | * only - // | * first - // | * last - // "first" and "last" indicate positions as children of refNode, "replace" replaces refNode, - // "only" replaces all children. position defaults to "last" if not specified - // - // returns: DomNode - // Returned values is the first argument resolved to a DOM node. - // - // .place() is also a method of `dojo.NodeList`, allowing `dojo.query` node lookups. - // - // example: - // Place a node by string id as the last child of another node by string id: - // | dojo.place("someNode", "anotherNode"); - // - // example: - // Place a node by string id before another node by string id - // | dojo.place("someNode", "anotherNode", "before"); - // - // example: - // Create a Node, and place it in the body element (last child): - // | dojo.place("<div></div>", dojo.body()); - // - // example: - // Put a new LI as the first child of a list by id: - // | dojo.place("<li></li>", "someUl", "first"); - - refNode = byId(refNode); - if(typeof node == "string"){ // inline'd type check - node = /^\s*</.test(node) ? d._toDom(node, refNode.ownerDocument) : byId(node); - } - if(typeof position == "number"){ // inline'd type check - var cn = refNode.childNodes; - if(!cn.length || cn.length <= position){ - refNode.appendChild(node); - }else{ - _insertBefore(node, cn[position < 0 ? 0 : position]); - } - }else{ - switch(position){ - case "before": - _insertBefore(node, refNode); - break; - case "after": - _insertAfter(node, refNode); - break; - case "replace": - refNode.parentNode.replaceChild(node, refNode); - break; - case "only": - d.empty(refNode); - refNode.appendChild(node); - break; - case "first": - if(refNode.firstChild){ - _insertBefore(node, refNode.firstChild); - break; - } - // else fallthrough... - default: // aka: last - refNode.appendChild(node); - } - } - return node; // DomNode - }; - - // 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*/){ - // client code may have to adjust if compatMode varies across iframes - d.boxModel = document.compatMode == "BackCompat" ? "border-box" : "content-box"; - } - - // ============================= - // Style Functions - // ============================= - - // getComputedStyle drives most of the style code. - // Wherever possible, reuse the returned object. - // - // API functions below that need to access computed styles accept an - // optional computedStyle parameter. - // If this parameter is omitted, the functions will call getComputedStyle themselves. - // This way, calling code can access computedStyle once, and then pass the reference to - // multiple API functions. - -/*===== - dojo.getComputedStyle = function(node){ - // summary: - // Returns a "computed style" object. - // - // description: - // Gets a "computed style" object which can be used to gather - // information about the current state of the rendered node. - // - // Note that this may behave differently on different browsers. - // Values may have different formats and value encodings across - // browsers. - // - // Note also that this method is expensive. Wherever possible, - // reuse the returned object. - // - // Use the dojo.style() method for more consistent (pixelized) - // return values. - // - // node: DOMNode - // A reference to a DOM node. Does NOT support taking an - // ID string for speed reasons. - // example: - // | dojo.getComputedStyle(dojo.byId('foo')).borderWidth; - // - // example: - // Reusing the returned object, avoiding multiple lookups: - // | var cs = dojo.getComputedStyle(dojo.byId("someNode")); - // | var w = cs.width, h = cs.height; - return; // CSS2Properties - } -=====*/ - - // Although we normally eschew argument validation at this - // level, here we test argument 'node' for (duck)type, - // by testing nodeType, ecause 'document' is the 'parentNode' of 'body' - // it is frequently sent to this function even - // though it is not Element. - var gcs; - if(d.isWebKit){ - gcs = function(/*DomNode*/node){ - var s; - if(node.nodeType == 1){ - var dv = node.ownerDocument.defaultView; - s = dv.getComputedStyle(node, null); - if(!s && node.style){ - node.style.display = ""; - s = dv.getComputedStyle(node, null); - } - } - return s || {}; - }; - }else if(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.nodeType == 1 ? - node.ownerDocument.defaultView.getComputedStyle(node, null) : {}; - }; - } - dojo.getComputedStyle = gcs; - - if(!d.isIE){ - d._toPixelValue = function(element, value){ - // style values can be floats, client code may want - // to round for integer pixels. - return parseFloat(value) || 0; - }; - }else{ - d._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 < 9 ? 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 < 9 ? function(/*DomNode*/node, /*Number*/opacity){ - var ov = opacity * 100, opaque = opacity == 1; - node.style.zoom = opaque ? "" : 1; - - if(!af(node)){ - if(opaque){ - return opacity; - } - node.style.filter += " progid:" + astr + "(Opacity=" + ov + ")"; - }else{ - af(node, 1).Opacity = ov; - } - - // on IE7 Alpha(Filter opacity=100) makes text look fuzzy so disable it altogether (bug #2661), - //but still update the opacity value so we can get a correct reading if it is read later. - af(node, 1).Enabled = !opaque; - - if(node.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", - _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. - // description: - // Getting the style value uses the computed style for the node, so the value - // will be a calculated value, not just the immediate node.style value. - // Also when getting values, use specific style names, - // like "borderBottomWidth" instead of "border" since compound values like - // "border" are not necessarily reflected as expected. - // If you want to get node dimensions, use `dojo.marginBox()`, - // `dojo.contentBox()` or `dojo.position()`. - // node: - // 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. When setting a pixel value, - // be sure to include "px" in the value. For instance, top: "200px". - // Otherwise, in some cases, some browsers will not apply the style. - // example: - // Passing 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": "300px" - // | }); - // - // 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 = 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 && typeof style != "string"){ // inline'd type check - 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. - // description: - // Returns an object with `w`, `h`, `l`, `t` properties: - // | 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. - // description: - // * 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. - // description: - // * 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.isWebKit && (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 || (d.isIE > 7 && !d.isQuirks)){ - // On Opera and IE 8, offsetLeft/Top includes the parent's border - if(p){ - 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._getMarginSize = function(/*DomNode*/node, /*Object*/computedStyle){ - // summary: - // returns an object that encodes the width and height of - // the node's margin box - node = byId(node); - var me = d._getMarginExtents(node, computedStyle || gcs(node)); - - var size = node.getBoundingClientRect(); - return { - w: (size.right - size.left) + me.w, - h: (size.bottom - size.top) + 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: - // left offset from parent. - // t: - // top offset from parent. - // w: - // width in current box model. - // h: - // width in current box model. - // u: - // unit measure to use for other measures. Defaults to "px". - u = u || "px"; - var s = node.style; - if(!isNaN(l)){ s.left = l + u; } - if(!isNaN(t)){ s.top = t + u; } - if(w >= 0){ s.width = w + u; } - if(h >= 0){ s.height = h + u; } - }; - - 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" || d._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. - bb = d._usesBorderBox(node), - pb = bb ? _nilExtents : d._getPadBorderExtents(node, s) - ; - if(d.isWebKit){ - // 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(d._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: - // Getter/setter for the margin-box of node. - // 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. - // example: - // Retrieve the marginbox of a passed node - // | var box = dojo.marginBox("someNodeId"); - // | console.dir(box); - // - // example: - // Set a node's marginbox to the size of another node - // | var box = dojo.marginBox("someNodeId"); - // | dojo.marginBox("someOtherNode", box); - - var n = 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. - // While the getter will return top and left values, the - // setter only accepts setting the width and height. - // 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, but only w (width) and h (height) are supported. - // All properties are optional if passed. - var n = 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 n = d.global; - return "pageXOffset" in n - ? { x:n.pageXOffset, y:n.pageYOffset } - : (n = d.isQuirks? d.doc.body : d.doc.documentElement, { x:d._fixIeBiDiScrollLeft(n.scrollLeft || 0), y:n.scrollTop || 0 }); - }; - - dojo._isBodyLtr = function(){ - return "_bodyLtr" in d? d._bodyLtr : - d._bodyLtr = (d.body().dir || d.doc.documentElement.dir || "ltr").toLowerCase() == "ltr"; // Boolean - }; - - dojo._getIeDocumentElementOffset = function(){ - // summary: - // returns the offset in x and y from the document body to the - // visual edge of the page - // description: - // The following values in IE contain an offset: - // | event.clientX - // | event.clientY - // | node.getBoundingClientRect().left - // | node.getBoundingClientRect().top - // But other position related values do not contain this offset, - // such as node.offsetLeft, node.offsetTop, node.style.left and - // node.style.top. The offset is always (2, 2) in LTR direction. - // When the body is in RTL direction, the offset counts the width - // of left scroll bar's width. This function computes the actual - // offset. - - //NOTE: assumes we're being called in an IE browser - - var de = d.doc.documentElement; // only deal with HTML element here, _abs handles body/quirks - - if(d.isIE < 8){ - var r = de.getBoundingClientRect(); // works well for IE6+ - //console.debug('rect left,top = ' + r.left+','+r.top + ', html client left/top = ' + de.clientLeft+','+de.clientTop + ', rtl = ' + (!d._isBodyLtr()) + ', quirks = ' + d.isQuirks); - var l = r.left, - t = r.top; - if(d.isIE < 7){ - l += de.clientLeft; // scrollbar size in strict/RTL, or, - t += de.clientTop; // HTML border size in strict - } - return { - x: l < 0? 0 : l, // FRAME element border size can lead to inaccurate negative values - y: t < 0? 0 : t - }; - }else{ - return { - x: 0, - y: 0 - }; - } - - }; - - 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 ie = d.isIE; - if(ie && !d._isBodyLtr()){ - var qk = d.isQuirks, - de = qk ? d.doc.body : d.doc.documentElement; - if(ie == 6 && !qk && d.global.frameElement && de.scrollHeight > de.clientHeight){ - scrollLeft += de.clientLeft; // workaround ie6+strict+rtl+iframe+vertical-scrollbar bug where clientWidth is too small by clientLeft pixels - } - return (ie < 8 || qk) ? (scrollLeft + de.clientWidth - de.scrollWidth) : -scrollLeft; // Integer - } - return scrollLeft; // Integer - }; - - // FIXME: need a setter for coords or a moveTo!! - dojo._abs = dojo.position = function(/*DomNode*/node, /*Boolean?*/includeScroll){ - // summary: - // Gets the position and size of the passed element relative to - // the viewport (if includeScroll==false), or relative to the - // document root (if includeScroll==true). - // - // description: - // Returns an object of the form: - // { x: 100, y: 300, w: 20, h: 15 } - // If includeScroll==true, the x and y values will include any - // document offsets that may affect the position relative to the - // viewport. - // Uses the border-box model (inclusive of border and padding but - // not margin). Does not act as a setter. - - node = byId(node); - var db = d.body(), - dh = db.parentNode, - ret = node.getBoundingClientRect(); - ret = { x: ret.left, y: ret.top, w: ret.right - ret.left, h: ret.bottom - ret.top }; - if(d.isIE){ - // On IE there's a 2px offset that we need to adjust for, see _getIeDocumentElementOffset() - var offset = d._getIeDocumentElementOffset(); - - // fixes the position in IE, quirks mode - ret.x -= offset.x + (d.isQuirks ? db.clientLeft+db.offsetLeft : 0); - ret.y -= offset.y + (d.isQuirks ? db.clientTop+db.offsetTop : 0); - }else if(d.isFF == 3){ - // In FF3 you have to subtract the document element margins. - // Fixed in FF3.5 though. - var cs = gcs(dh); - ret.x -= px(dh, cs.marginLeft) + px(dh, cs.borderLeftWidth); - ret.y -= px(dh, cs.marginTop) + px(dh, cs.borderTopWidth); - } - // account for document scrolling - if(includeScroll){ - var scroll = d._docScroll(); - ret.x += scroll.x; - ret.y += scroll.y; - } - - return ret; // Object - }; - - dojo.coords = function(/*DomNode|String*/node, /*Boolean?*/includeScroll){ - // summary: - // Deprecated: Use position() for border-box x/y/w/h - // or marginBox() for margin-box w/h/l/t. - // Returns an object representing a node's size and position. - // - // description: - // Returns an object that measures margin-box (w)idth/(h)eight - // and absolute position x/y of the border-box. Also returned - // is computed (l)eft and (t)op values in pixels from the - // node's offsetParent as returned from marginBox(). - // 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.position(). - var n = byId(node), s = gcs(n), mb = d._getMarginBox(n, s); - var abs = d.position(n, includeScroll); - mb.x = abs.x; - mb.y = abs.y; - return mb; - }; - - // ============================= - // Element attribute Functions - // ============================= - - // dojo.attr() should conform to http://www.w3.org/TR/DOM-Level-2-Core/ - - var _propNames = { - // properties renamed to avoid clashes with reserved words - "class": "className", - "for": "htmlFor", - // properties written as camelCase - tabindex: "tabIndex", - readonly: "readOnly", - colspan: "colSpan", - frameborder: "frameBorder", - rowspan: "rowSpan", - valuetype: "valueType" - }, - _attrNames = { - // original attribute names - classname: "class", - htmlfor: "for", - // for IE - tabindex: "tabIndex", - readonly: "readOnly" - }, - _forcePropNames = { - innerHTML: 1, - className: 1, - htmlFor: d.isIE, - value: 1 - }; - - var _fixAttrName = function(/*String*/ name){ - return _attrNames[name.toLowerCase()] || name; - }; - - var _hasAttr = function(node, name){ - var attr = node.getAttributeNode && node.getAttributeNode(name); - return attr && attr.specified; // Boolean - }; - - // There is a difference in the presence of certain properties and their default values - // between browsers. For example, on IE "disabled" is present on all elements, - // but it is value is "false"; "tabIndex" of <div> returns 0 by default on IE, yet other browsers - // can return -1. - - 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 - var lc = name.toLowerCase(); - return _forcePropNames[_propNames[lc] || name] || _hasAttr(byId(node), _attrNames[lc] || name); // Boolean - }; - - var _evtHdlrMap = {}, _ctr = 0, - _attrId = dojo._scopeName + "attrid", - // the next dictionary lists elements with read-only innerHTML on IE - _roInnerHtml = {col: 1, colgroup: 1, - // frameset: 1, head: 1, html: 1, style: 1, - table: 1, tbody: 1, tfoot: 1, thead: 1, tr: 1, title: 1}; - - 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 argument 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 used as a setter, the DOM node - // - // 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" }); - // | } - // | }); - // - // example: - // Style is s special case: Only set with an object hash of styles - // | dojo.attr("someNode",{ - // | id:"bar", - // | style:{ - // | width:"200px", height:"100px", color:"#000" - // | } - // | }); - // - // example: - // Again, only set style as an object hash of styles: - // | var obj = { color:"#fff", backgroundColor:"#000" }; - // | dojo.attr("someNode", "style", obj); - // | - // | // though shorter to use `dojo.style()` in this case: - // | dojo.style("someNode", obj); - - node = byId(node); - var args = arguments.length, prop; - if(args == 2 && typeof name != "string"){ // inline'd type check - // the object form of setter: the 2nd argument is a dictionary - for(var x in name){ - d.attr(node, x, name[x]); - } - return node; // DomNode - } - var lc = name.toLowerCase(), - propName = _propNames[lc] || name, - forceProp = _forcePropNames[propName], - attrName = _attrNames[lc] || name; - if(args == 3){ - // setter - do{ - if(propName == "style" && typeof value != "string"){ // inline'd type check - // special case: setting a style - d.style(node, value); - break; - } - if(propName == "innerHTML"){ - // special case: assigning HTML - if(d.isIE && node.tagName.toLowerCase() in _roInnerHtml){ - d.empty(node); - node.appendChild(d._toDom(value, node.ownerDocument)); - }else{ - node[propName] = value; - } - break; - } - if(d.isFunction(value)){ - // special case: assigning an event handler - // 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][propName]; - if(h){ - d.disconnect(h); - }else{ - try{ - delete node[propName]; - }catch(e){} - } - // ensure that event objects are normalized, etc. - _evtHdlrMap[attrId][propName] = d.connect(node, propName, value); - break; - } - if(forceProp || typeof value == "boolean"){ - // special case: forcing assignment to the property - // special case: setting boolean to a property instead of attribute - node[propName] = value; - break; - } - // node's attribute - node.setAttribute(attrName, value); - }while(false); - return node; // DomNode - } - // getter - // should we access this attribute via a property or - // via getAttribute()? - value = node[propName]; - if(forceProp && typeof value != "undefined"){ - // node's property - return value; // Anything - } - if(propName != "href" && (typeof value == "boolean" || d.isFunction(value))){ - // node's property - return value; // Anything - } - // node's attribute - // we need _hasAttr() here to guard against IE returning a default value - return _hasAttr(node, attrName) ? node.getAttribute(attrName) : null; // Anything - }; - - 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 - byId(node).removeAttribute(_fixAttrName(name)); - }; - - dojo.getNodeProp = function(/*DomNode|String*/ node, /*String*/ name){ - // summary: - // Returns an effective value of a property or an attribute. - // node: - // id or reference to the element to remove the attribute from - // name: - // the name of the attribute - node = byId(node); - var lc = name.toLowerCase(), - propName = _propNames[lc] || name; - if((propName in node) && propName != "href"){ - // node's property - return node[propName]; // Anything - } - // node's attribute - var attrName = _attrNames[lc] || name; - return _hasAttr(node, attrName) ? node.getAttribute(attrName) : null; // Anything - }; - - dojo.create = function(tag, attrs, refNode, pos){ - // summary: - // Create an element, allowing for optional attribute decoration - // and placement. - // - // description: - // A DOM Element creation function. A shorthand method for creating a node or - // a fragment, and allowing for a convenient optional attribute setting step, - // as well as an optional DOM placement reference. - //| - // Attributes are set by passing the optional object through `dojo.attr`. - // See `dojo.attr` for noted caveats and nuances, and API if applicable. - //| - // Placement is done via `dojo.place`, assuming the new node to be the action - // node, passing along the optional reference node and position. - // - // tag: String|DomNode - // A string of the element to create (eg: "div", "a", "p", "li", "script", "br"), - // or an existing DOM node to process. - // - // attrs: Object - // An object-hash of attributes to set on the newly created node. - // Can be null, if you don't want to set any attributes/styles. - // See: `dojo.attr` for a description of available attributes. - // - // refNode: String?|DomNode? - // Optional reference node. Used by `dojo.place` to place the newly created - // node somewhere in the dom relative to refNode. Can be a DomNode reference - // or String ID of a node. - // - // pos: String? - // Optional positional reference. Defaults to "last" by way of `dojo.place`, - // though can be set to "first","after","before","last", "replace" or "only" - // to further control the placement of the new node relative to the refNode. - // 'refNode' is required if a 'pos' is specified. - // - // returns: DomNode - // - // example: - // Create a DIV: - // | var n = dojo.create("div"); - // - // example: - // Create a DIV with content: - // | var n = dojo.create("div", { innerHTML:"<p>hi</p>" }); - // - // example: - // Place a new DIV in the BODY, with no attributes set - // | var n = dojo.create("div", null, dojo.body()); - // - // example: - // Create an UL, and populate it with LI's. Place the list as the first-child of a - // node with id="someId": - // | var ul = dojo.create("ul", null, "someId", "first"); - // | var items = ["one", "two", "three", "four"]; - // | dojo.forEach(items, function(data){ - // | dojo.create("li", { innerHTML: data }, ul); - // | }); - // - // example: - // Create an anchor, with an href. Place in BODY: - // | dojo.create("a", { href:"foo.html", title:"Goto FOO!" }, dojo.body()); - // - // example: - // Create a `dojo.NodeList()` from a new element (for syntatic sugar): - // | dojo.query(dojo.create('div')) - // | .addClass("newDiv") - // | .onclick(function(e){ console.log('clicked', e.target) }) - // | .place("#someNode"); // redundant, but cleaner. - - var doc = d.doc; - if(refNode){ - refNode = byId(refNode); - doc = refNode.ownerDocument; - } - if(typeof tag == "string"){ // inline'd type check - tag = doc.createElement(tag); - } - if(attrs){ d.attr(tag, attrs); } - if(refNode){ d.place(tag, refNode, pos); } - return tag; // DomNode - }; - - /*===== - dojo.empty = function(node){ - // summary: - // safely removes all children of the node. - // node: DOMNode|String - // a reference to a DOM node or an id. - // example: - // Destroy node's children byId: - // | dojo.empty("someId"); - // - // example: - // Destroy all nodes' children in a list by reference: - // | dojo.query(".someNode").forEach(dojo.empty); - } - =====*/ - - d.empty = - d.isIE ? function(node){ - node = byId(node); - for(var c; c = node.lastChild;){ // intentional assignment - d.destroy(c); - } - } : - function(node){ - byId(node).innerHTML = ""; - }; - - /*===== - dojo._toDom = function(frag, doc){ - // summary: - // instantiates an HTML fragment returning the corresponding DOM. - // frag: String - // the HTML fragment - // doc: DocumentNode? - // optional document to use when creating DOM nodes, defaults to - // dojo.doc if not specified. - // returns: DocumentFragment - // - // example: - // Create a table row: - // | var tr = dojo._toDom("<tr><td>First!</td></tr>"); - } - =====*/ - - // support stuff for dojo._toDom - var tagWrap = { - option: ["select"], - tbody: ["table"], - thead: ["table"], - tfoot: ["table"], - tr: ["table", "tbody"], - td: ["table", "tbody", "tr"], - th: ["table", "thead", "tr"], - legend: ["fieldset"], - caption: ["table"], - colgroup: ["table"], - col: ["table", "colgroup"], - li: ["ul"] - }, - reTag = /<\s*([\w\:]+)/, - masterNode = {}, masterNum = 0, - masterName = "__" + d._scopeName + "ToDomId"; - - // generate start/end tag strings to use - // for the injection for each special tag wrap case. - for(var param in tagWrap){ - if(tagWrap.hasOwnProperty(param)){ - var tw = tagWrap[param]; - tw.pre = param == "option" ? '<select multiple="multiple">' : "<" + tw.join("><") + ">"; - tw.post = "</" + tw.reverse().join("></") + ">"; - // the last line is destructive: it reverses the array, - // but we don't care at this point - } - } - - d._toDom = function(frag, doc){ - // summary: - // converts HTML string into DOM nodes. - - doc = doc || d.doc; - var masterId = doc[masterName]; - if(!masterId){ - doc[masterName] = masterId = ++masterNum + ""; - masterNode[masterId] = doc.createElement("div"); - } - - // make sure the frag is a string. - frag += ""; - - // find the starting tag, and get node wrapper - var match = frag.match(reTag), - tag = match ? match[1].toLowerCase() : "", - master = masterNode[masterId], - wrap, i, fc, df; - if(match && tagWrap[tag]){ - wrap = tagWrap[tag]; - master.innerHTML = wrap.pre + frag + wrap.post; - for(i = wrap.length; i; --i){ - master = master.firstChild; - } - }else{ - master.innerHTML = frag; - } - - // one node shortcut => return the node itself - if(master.childNodes.length == 1){ - return master.removeChild(master.firstChild); // DOMNode - } - - // return multiple nodes as a document fragment - df = doc.createDocumentFragment(); - while(fc = master.firstChild){ // intentional assignment - df.appendChild(fc); - } - return df; // DOMNode - }; - - // ============================= - // (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. - // - // node: - // String ID or DomNode reference to check the class for. - // - // classStr: - // A string class name to look for. - // - // example: - // Do something if a node with id="someNode" has class="aSillyClassName" present - // | if(dojo.hasClass("someNode","aSillyClassName")){ ... } - - return ((" "+ byId(node)[_className] +" ").indexOf(" " + classStr + " ") >= 0); // Boolean - }; - - var spaces = /\s+/, a1 = [""], - fakeNode = {}, - str2array = function(s){ - if(typeof s == "string" || s instanceof String){ - if(s.indexOf(" ") < 0){ - a1[0] = s; - return a1; - }else{ - return s.split(spaces); - } - } - // assumed to be an array - return s || ""; - }; - - dojo.addClass = function(/*DomNode|String*/node, /*String|Array*/classStr){ - // summary: - // Adds the specified classes to the end of the class list on the - // passed node. Will not re-apply duplicate classes. - // - // node: - // String ID or DomNode reference to add a class string too - // - // classStr: - // A String class name to add, or several space-separated class names, - // or an array of class names. - // - // example: - // Add a class to some node: - // | dojo.addClass("someNode", "anewClass"); - // - // example: - // Add two classes at once: - // | dojo.addClass("someNode", "firstClass secondClass"); - // - // example: - // Add two classes at once (using array): - // | dojo.addClass("someNode", ["firstClass", "secondClass"]); - // - // example: - // Available in `dojo.NodeList` for multiple additions - // | dojo.query("ul > li").addClass("firstLevel"); - - node = byId(node); - classStr = str2array(classStr); - var cls = node[_className], oldLen; - cls = cls ? " " + cls + " " : " "; - oldLen = cls.length; - for(var i = 0, len = classStr.length, c; i < len; ++i){ - c = classStr[i]; - if(c && cls.indexOf(" " + c + " ") < 0){ - cls += c + " "; - } - } - if(oldLen < cls.length){ - node[_className] = cls.substr(1, cls.length - 2); - } - }; - - dojo.removeClass = function(/*DomNode|String*/node, /*String|Array?*/classStr){ - // summary: - // Removes the specified classes from node. No `dojo.hasClass` - // check is required. - // - // node: - // String ID or DomNode reference to remove the class from. - // - // classStr: - // An optional String class name to remove, or several space-separated - // class names, or an array of class names. If omitted, all class names - // will be deleted. - // - // example: - // Remove a class from some node: - // | dojo.removeClass("someNode", "firstClass"); - // - // example: - // Remove two classes from some node: - // | dojo.removeClass("someNode", "firstClass secondClass"); - // - // example: - // Remove two classes from some node (using array): - // | dojo.removeClass("someNode", ["firstClass", "secondClass"]); - // - // example: - // Remove all classes from some node: - // | dojo.removeClass("someNode"); - // - // example: - // Available in `dojo.NodeList()` for multiple removal - // | dojo.query(".foo").removeClass("foo"); - - node = byId(node); - var cls; - if(classStr !== undefined){ - classStr = str2array(classStr); - cls = " " + node[_className] + " "; - for(var i = 0, len = classStr.length; i < len; ++i){ - cls = cls.replace(" " + classStr[i] + " ", " "); - } - cls = d.trim(cls); - }else{ - cls = ""; - } - if(node[_className] != cls){ node[_className] = cls; } - }; - - dojo.replaceClass = function(/*DomNode|String*/node, /*String|Array*/addClassStr, /*String|Array?*/removeClassStr){ - // summary: - // Replaces one or more classes on a node if not present. - // Operates more quickly than calling dojo.removeClass and dojo.addClass - // node: - // String ID or DomNode reference to remove the class from. - // addClassStr: - // A String class name to add, or several space-separated class names, - // or an array of class names. - // removeClassStr: - // A String class name to remove, or several space-separated class names, - // or an array of class names. - // - // example: - // | dojo.replaceClass("someNode", "add1 add2", "remove1 remove2"); - // - // example: - // Replace all classes with addMe - // | dojo.replaceClass("someNode", "addMe"); - // - // example: - // Available in `dojo.NodeList()` for multiple toggles - // | dojo.query(".findMe").replaceClass("addMe", "removeMe"); - - node = byId(node); - fakeNode.className = node.className; - dojo.removeClass(fakeNode, removeClassStr); - dojo.addClass(fakeNode, addClassStr); - if(node.className !== fakeNode.className){ - node.className = fakeNode.className; - } - }; - - dojo.toggleClass = function(/*DomNode|String*/node, /*String|Array*/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. - // - // example: - // | dojo.toggleClass("someNode", "hovered"); - // - // example: - // Forcefully add a class - // | dojo.toggleClass("someNode", "hovered", true); - // - // example: - // Available in `dojo.NodeList()` for multiple toggles - // | dojo.query(".toggleMe").toggleClass("toggleMe"); - - if(condition === undefined){ - condition = !d.hasClass(node, classStr); - } - d[condition ? "addClass" : "removeClass"](node, classStr); - }; - -})(); - -} +//>>built +define("dojo/_base/html",["./kernel","../dom","../dom-style","../dom-attr","../dom-prop","../dom-class","../dom-construct","../dom-geometry"],function(_1,_2,_3,_4,_5,_6,_7,_8){_1.byId=_2.byId;_1.isDescendant=_2.isDescendant;_1.setSelectable=_2.setSelectable;_1.getAttr=_4.get;_1.setAttr=_4.set;_1.hasAttr=_4.has;_1.removeAttr=_4.remove;_1.getNodeProp=_4.getNodeProp;_1.attr=function(_9,_a,_b){if(arguments.length==2){return _4[typeof _a=="string"?"get":"set"](_9,_a);}return _4.set(_9,_a,_b);};_1.hasClass=_6.contains;_1.addClass=_6.add;_1.removeClass=_6.remove;_1.toggleClass=_6.toggle;_1.replaceClass=_6.replace;_1._toDom=_1.toDom=_7.toDom;_1.place=_7.place;_1.create=_7.create;_1.empty=function(_c){_7.empty(_c);};_1._destroyElement=_1.destroy=function(_d){_7.destroy(_d);};_1._getPadExtents=_1.getPadExtents=_8.getPadExtents;_1._getBorderExtents=_1.getBorderExtents=_8.getBorderExtents;_1._getPadBorderExtents=_1.getPadBorderExtents=_8.getPadBorderExtents;_1._getMarginExtents=_1.getMarginExtents=_8.getMarginExtents;_1._getMarginSize=_1.getMarginSize=_8.getMarginSize;_1._getMarginBox=_1.getMarginBox=_8.getMarginBox;_1.setMarginBox=_8.setMarginBox;_1._getContentBox=_1.getContentBox=_8.getContentBox;_1.setContentSize=_8.setContentSize;_1._isBodyLtr=_1.isBodyLtr=_8.isBodyLtr;_1._docScroll=_1.docScroll=_8.docScroll;_1._getIeDocumentElementOffset=_1.getIeDocumentElementOffset=_8.getIeDocumentElementOffset;_1._fixIeBiDiScrollLeft=_1.fixIeBiDiScrollLeft=_8.fixIeBiDiScrollLeft;_1.position=_8.position;_1.marginBox=function marginBox(_e,_f){return _f?_8.setMarginBox(_e,_f):_8.getMarginBox(_e);};_1.contentBox=function contentBox(_10,box){return box?_8.setContentSize(_10,box):_8.getContentBox(_10);};_1.coords=function(_11,_12){_1.deprecated("dojo.coords()","Use dojo.position() or dojo.marginBox().");_11=_2.byId(_11);var s=_3.getComputedStyle(_11),mb=_8.getMarginBox(_11,s);var abs=_8.position(_11,_12);mb.x=abs.x;mb.y=abs.y;return mb;};_1.getProp=_5.get;_1.setProp=_5.set;_1.prop=function(_13,_14,_15){if(arguments.length==2){return _5[typeof _14=="string"?"get":"set"](_13,_14);}return _5.set(_13,_14,_15);};_1.getStyle=_3.get;_1.setStyle=_3.set;_1.getComputedStyle=_3.getComputedStyle;_1.__toPixelValue=_1.toPixelValue=_3.toPixelValue;_1.style=function(_16,_17,_18){switch(arguments.length){case 1:return _3.get(_16);case 2:return _3[typeof _17=="string"?"get":"set"](_16,_17);}return _3.set(_16,_17,_18);};return _1;});
\ No newline at end of file diff --git a/lib/dojo/_base/html.js.uncompressed.js b/lib/dojo/_base/html.js.uncompressed.js new file mode 100644 index 000000000..63e3bee46 --- /dev/null +++ b/lib/dojo/_base/html.js.uncompressed.js @@ -0,0 +1,389 @@ +define("dojo/_base/html", ["./kernel", "../dom", "../dom-style", "../dom-attr", "../dom-prop", "../dom-class", "../dom-construct", "../dom-geometry"], function(dojo, dom, style, attr, prop, cls, ctr, geom){ + // module: + // dojo/dom + // summary: + // This module is a stub for the core dojo DOM API. + + // mix-in dom + dojo.byId = dom.byId; + dojo.isDescendant = dom.isDescendant; + dojo.setSelectable = dom.setSelectable; + + // mix-in dom-attr + dojo.getAttr = attr.get; + dojo.setAttr = attr.set; + dojo.hasAttr = attr.has; + dojo.removeAttr = attr.remove; + dojo.getNodeProp = attr.getNodeProp; + + dojo.attr = function(node, name, 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 argument is a + // string, acts as a getter. + // + // If a third argument is passed, or if the second argument 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: DOMNode|String + // id or reference to the element to get or set the attribute on + // name: String|Object + // the name of the attribute to get or set. + // value: String? + // 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 used as a setter, the DOM node + // + // 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" }); + // | } + // | }); + // + // example: + // Style is s special case: Only set with an object hash of styles + // | dojo.attr("someNode",{ + // | id:"bar", + // | style:{ + // | width:"200px", height:"100px", color:"#000" + // | } + // | }); + // + // example: + // Again, only set style as an object hash of styles: + // | var obj = { color:"#fff", backgroundColor:"#000" }; + // | dojo.attr("someNode", "style", obj); + // | + // | // though shorter to use `dojo.style()` in this case: + // | dojo.style("someNode", obj); + + if(arguments.length == 2){ + return attr[typeof name == "string" ? "get" : "set"](node, name); + } + return attr.set(node, name, value); + }; + + // mix-in dom-class + dojo.hasClass = cls.contains; + dojo.addClass = cls.add; + dojo.removeClass = cls.remove; + dojo.toggleClass = cls.toggle; + dojo.replaceClass = cls.replace; + + // mix-in dom-construct + dojo._toDom = dojo.toDom = ctr.toDom; + dojo.place = ctr.place; + dojo.create = ctr.create; + dojo.empty = function(node){ ctr.empty(node); }; + dojo._destroyElement = dojo.destroy = function(node){ ctr.destroy(node); }; + + // mix-in dom-geometry + dojo._getPadExtents = dojo.getPadExtents = geom.getPadExtents; + dojo._getBorderExtents = dojo.getBorderExtents = geom.getBorderExtents; + dojo._getPadBorderExtents = dojo.getPadBorderExtents = geom.getPadBorderExtents; + dojo._getMarginExtents = dojo.getMarginExtents = geom.getMarginExtents; + dojo._getMarginSize = dojo.getMarginSize = geom.getMarginSize; + dojo._getMarginBox = dojo.getMarginBox = geom.getMarginBox; + dojo.setMarginBox = geom.setMarginBox; + dojo._getContentBox = dojo.getContentBox = geom.getContentBox; + dojo.setContentSize = geom.setContentSize; + dojo._isBodyLtr = dojo.isBodyLtr = geom.isBodyLtr; + dojo._docScroll = dojo.docScroll = geom.docScroll; + dojo._getIeDocumentElementOffset = dojo.getIeDocumentElementOffset = geom.getIeDocumentElementOffset; + dojo._fixIeBiDiScrollLeft = dojo.fixIeBiDiScrollLeft = geom.fixIeBiDiScrollLeft; + dojo.position = geom.position; + + dojo.marginBox = function marginBox(/*DomNode|String*/node, /*Object?*/box){ + // summary: + // Getter/setter for the margin-box of node. + // description: + // Getter/setter for the margin-box of node. + // 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. + // example: + // Retrieve the margin box of a passed node + // | var box = dojo.marginBox("someNodeId"); + // | console.dir(box); + // + // example: + // Set a node's margin box to the size of another node + // | var box = dojo.marginBox("someNodeId"); + // | dojo.marginBox("someOtherNode", box); + return box ? geom.setMarginBox(node, box) : geom.getMarginBox(node); // Object + }; + + dojo.contentBox = function contentBox(/*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. + // While the getter will return top and left values, the + // setter only accepts setting the width and height. + // 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, but only w (width) and h (height) are supported. + // All properties are optional if passed. + return box ? geom.setContentSize(node, box) : geom.getContentBox(node); // Object + }; + + dojo.coords = function(/*DomNode|String*/node, /*Boolean?*/includeScroll){ + // summary: + // Deprecated: Use position() for border-box x/y/w/h + // or marginBox() for margin-box w/h/l/t. + // Returns an object representing a node's size and position. + // + // description: + // Returns an object that measures margin-box (w)idth/(h)eight + // and absolute position x/y of the border-box. Also returned + // is computed (l)eft and (t)op values in pixels from the + // node's offsetParent as returned from marginBox(). + // 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.position(). + dojo.deprecated("dojo.coords()", "Use dojo.position() or dojo.marginBox()."); + node = dom.byId(node); + var s = style.getComputedStyle(node), mb = geom.getMarginBox(node, s); + var abs = geom.position(node, includeScroll); + mb.x = abs.x; + mb.y = abs.y; + return mb; // Object + }; + + // mix-in dom-prop + dojo.getProp = prop.get; + dojo.setProp = prop.set; + + dojo.prop = function(/*DomNode|String*/node, /*String|Object*/name, /*String?*/value){ + // summary: + // Gets or sets a property on an HTML element. + // description: + // Handles normalized getting and setting of properties on DOM + // Nodes. If 2 arguments are passed, and a the second argument is a + // string, acts as a getter. + // + // If a third argument is passed, or if the second argument 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 property on + // name: + // the name of the property to get or set. + // value: + // The value to set for the property + // returns: + // when used as a getter, the value of the requested property + // or null if that attribute does not have a specified or + // default value; + // + // when used as a setter, the DOM node + // + // example: + // | // get the current value of the "foo" property on a node + // | dojo.prop(dojo.byId("nodeId"), "foo"); + // | // or we can just pass the id: + // | dojo.prop("nodeId", "foo"); + // + // example: + // | // use prop() to set the tab index + // | dojo.prop("nodeId", "tabIndex", 3); + // | + // + // example: + // Set multiple values at once, including event handlers: + // | dojo.prop("formId", { + // | "foo": "bar", + // | "tabIndex": -1, + // | "method": "POST", + // | "onsubmit": function(e){ + // | // stop submitting the form. Note that the IE behavior + // | // of returning true or false will have no effect here + // | // since our handler is connect()ed to the built-in + // | // onsubmit behavior and so we need to use + // | // dojo.stopEvent() to ensure that the submission + // | // doesn't proceed. + // | dojo.stopEvent(e); + // | + // | // submit the form with Ajax + // | dojo.xhrPost({ form: "formId" }); + // | } + // | }); + // + // example: + // Style is s special case: Only set with an object hash of styles + // | dojo.prop("someNode",{ + // | id:"bar", + // | style:{ + // | width:"200px", height:"100px", color:"#000" + // | } + // | }); + // + // example: + // Again, only set style as an object hash of styles: + // | var obj = { color:"#fff", backgroundColor:"#000" }; + // | dojo.prop("someNode", "style", obj); + // | + // | // though shorter to use `dojo.style()` in this case: + // | dojo.style("someNode", obj); + + if(arguments.length == 2){ + return prop[typeof name == "string" ? "get" : "set"](node, name); + } + // setter + return prop.set(node, name, value); + }; + + // mix-in dom-style + dojo.getStyle = style.get; + dojo.setStyle = style.set; + dojo.getComputedStyle = style.getComputedStyle; + dojo.__toPixelValue = dojo.toPixelValue = style.toPixelValue; + + dojo.style = function(node, name, 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. + // description: + // Getting the style value uses the computed style for the node, so the value + // will be a calculated value, not just the immediate node.style value. + // Also when getting values, use specific style names, + // like "borderBottomWidth" instead of "border" since compound values like + // "border" are not necessarily reflected as expected. + // If you want to get node dimensions, use `dojo.marginBox()`, + // `dojo.contentBox()` or `dojo.position()`. + // node: DOMNode|String + // id or reference to node to get/set style for + // name: String?|Object? + // the style property to set in DOM-accessor format + // ("borderWidth", not "border-width") or an object with key/value + // pairs suitable for setting each property. + // value: String? + // If passed, sets value on the node for style, handling + // cross-browser concerns. When setting a pixel value, + // be sure to include "px" in the value. For instance, top: "200px". + // Otherwise, in some cases, some browsers will not apply the style. + // returns: + // when used as a getter, return the computed style of the node if passing in an ID or node, + // or return the normalized, computed value for the property when passing in a node and a style property + // 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": "300px" + // | }); + // + // 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" + // | }); + + switch(arguments.length){ + case 1: + return style.get(node); + case 2: + return style[typeof name == "string" ? "get" : "set"](node, name); + } + // setter + return style.set(node, name, value); + }; + + return dojo; +}); diff --git a/lib/dojo/_base/json.js b/lib/dojo/_base/json.js index 4267c225e..b644339f7 100644 --- a/lib/dojo/_base/json.js +++ b/lib/dojo/_base/json.js @@ -4,152 +4,5 @@ see: http://dojotoolkit.org/license for details */ - -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. - // description: - // Throws for invalid JSON strings, but it does not use a strict JSON parser. It - // delegates to eval(). The content passed to this method must therefore come - // from a trusted source. - // 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. - // example: - // simple serialization of a trivial object - // | var jsonStr = dojo.toJson({ howdy: "stranger!", isStrange: true }); - // | doh.is('{"howdy":"stranger!","isStrange":true}', jsonStr); - // example: - // a custom serializer for an objects of a particular class: - // | dojo.declare("Furby", null, { - // | furbies: "are strange", - // | furbyCount: 10, - // | __json__: function(){ - // | }, - // | }); - - 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){ - // console.log(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 -}; - -} +//>>built +define("dojo/_base/json",["./kernel","../json"],function(_1,_2){_1.fromJson=function(js){return eval("("+js+")");};_1._escapeString=_2.stringify;_1.toJsonIndentStr="\t";_1.toJson=function(it,_3){return _2.stringify(it,function(_4,_5){if(_5){var tf=_5.__json__||_5.json;if(typeof tf=="function"){return tf.call(_5);}}return _5;},_3&&_1.toJsonIndentStr);};return _1;});
\ No newline at end of file diff --git a/lib/dojo/_base/json.js.uncompressed.js b/lib/dojo/_base/json.js.uncompressed.js new file mode 100644 index 000000000..b70d4ebb8 --- /dev/null +++ b/lib/dojo/_base/json.js.uncompressed.js @@ -0,0 +1,85 @@ +define("dojo/_base/json", ["./kernel", "../json"], function(dojo, json){ + // module: + // dojo/_base/json + // summary: + // This module defines the dojo JSON API. + +dojo.fromJson = function(/*String*/ js){ + // summary: + // Parses a JavaScript expression and returns a JavaScript value. + // description: + // Throws for invalid JavaScript expressions. It does not use a strict JSON parser. It + // always delegates to eval(). The content passed to this method must therefore come + // from a trusted source. + // It is recommend that you use dojo/json's parse function for an + // implementation uses the (faster) native JSON parse when available. + // js: + // a string literal of a JavaScript expression, for instance: + // `'{ "foo": [ "bar", 1, { "baz": "thud" } ] }'` + + return eval("(" + js + ")"); // Object +}; + +/*===== +dojo._escapeString = function(){ + // summary: + // Adds escape sequences for non-visual characters, double quote and + // backslash and surrounds with double quotes to form a valid string + // literal. +}; +=====*/ +dojo._escapeString = json.stringify; // just delegate to json.stringify + +dojo.toJsonIndentStr = "\t"; +dojo.toJson = function(/*Object*/ it, /*Boolean?*/ prettyPrint){ + // 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 is recommend that you use dojo/json's stringify function for an lighter + // and faster implementation that matches the native JSON API and uses the + // native JSON serializer when available. + // 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. + // Note that in 1.6, toJson would serialize undefined, but this no longer supported + // since it is not supported by native JSON serializer. + // 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(). + // Note that if native JSON support is available, it will be used for serialization, + // and native implementations vary on the exact spacing used in pretty printing. + // returns: + // A JSON string serialization of the passed-in object. + // example: + // simple serialization of a trivial object + // | var jsonStr = dojo.toJson({ howdy: "stranger!", isStrange: true }); + // | doh.is('{"howdy":"stranger!","isStrange":true}', jsonStr); + // example: + // a custom serializer for an objects of a particular class: + // | dojo.declare("Furby", null, { + // | furbies: "are strange", + // | furbyCount: 10, + // | __json__: function(){ + // | }, + // | }); + + // use dojo/json + return json.stringify(it, function(key, value){ + if(value){ + var tf = value.__json__||value.json; + if(typeof tf == "function"){ + return tf.call(value); + } + } + return value; + }, prettyPrint && dojo.toJsonIndentStr); // String +}; + +return dojo; +}); diff --git a/lib/dojo/_base/kernel.js b/lib/dojo/_base/kernel.js new file mode 100644 index 000000000..f574dadd2 --- /dev/null +++ b/lib/dojo/_base/kernel.js @@ -0,0 +1,8 @@ +/* + Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Available via Academic Free License >= 2.1 OR the modified BSD license. + see: http://dojotoolkit.org/license for details +*/ + +//>>built +define("dojo/_base/kernel",["../has","./config","require","module"],function(_1,_2,_3,_4){var i,p,_5={},_6={},_7={config:_2,global:this,dijit:_5,dojox:_6};var _8={dojo:["dojo",_7],dijit:["dijit",_5],dojox:["dojox",_6]},_9=(_3.packs&&_3.packs[_4.id.match(/[^\/]+/)[0]].packageMap)||{},_a;for(p in _9){if(_8[p]){_8[p][0]=_9[p];}else{_8[p]=[_9[p],{}];}}for(p in _8){_a=_8[p];_a[1]._scopeName=_a[0];if(!_2.noGlobals){this[_a[0]]=_a[1];}}_7.scopeMap=_8;_7.baseUrl=_7.config.baseUrl=_3.baseUrl;_7.isAsync=!1||_3.async;_7.locale=_2.locale;var _b="$Rev: 28982 $".match(/\d+/);_7.version={major:1,minor:7,patch:3,flag:"",revision:_b?+_b[0]:NaN,toString:function(){var v=_7.version;return v.major+"."+v.minor+"."+v.patch+v.flag+" ("+v.revision+")";}};true||_1.add("extend-dojo",1);_7.eval=function(_c){};(Function("d","d.eval = function(){return d.global.eval ? d.global.eval(arguments[0]) : eval(arguments[0]);}"))(_7);if(0){_7.exit=function(_d){quit(_d);};}else{_7.exit=function(){};}true||_1.add("dojo-guarantee-console",1);if(1){typeof console!="undefined"||(console={});var cn=["assert","count","debug","dir","dirxml","error","group","groupEnd","info","profile","profileEnd","time","timeEnd","trace","warn","log"];var tn;i=0;while((tn=cn[i++])){if(!console[tn]){(function(){var _e=tn+"";console[_e]=("log" in console)?function(){var a=Array.apply({},arguments);a.unshift(_e+":");console["log"](a.join(" "));}:function(){};console[_e]._fake=true;})();}}}_1.add("dojo-debug-messages",!!_2.isDebug);if(_1("dojo-debug-messages")){_7.deprecated=function(_f,_10,_11){var _12="DEPRECATED: "+_f;if(_10){_12+=" "+_10;}if(_11){_12+=" -- will be removed in version: "+_11;}console.warn(_12);};_7.experimental=function(_13,_14){var _15="EXPERIMENTAL: "+_13+" -- APIs subject to change without notice.";if(_14){_15+=" "+_14;}console.warn(_15);};}else{_7.deprecated=_7.experimental=function(){};}true||_1.add("dojo-modulePaths",1);if(1){if(_2.modulePaths){_7.deprecated("dojo.modulePaths","use paths configuration");var _16={};for(p in _2.modulePaths){_16[p.replace(/\./g,"/")]=_2.modulePaths[p];}_3({paths:_16});}}true||_1.add("dojo-moduleUrl",1);if(1){_7.moduleUrl=function(_17,url){_7.deprecated("dojo.moduleUrl()","use require.toUrl","2.0");var _18=null;if(_17){_18=_3.toUrl(_17.replace(/\./g,"/")+(url?("/"+url):"")+"/*.*").replace(/\/\*\.\*/,"")+(url?"":"/");}return _18;};}_7._hasResource={};return _7;});
\ No newline at end of file diff --git a/lib/dojo/_base/kernel.js.uncompressed.js b/lib/dojo/_base/kernel.js.uncompressed.js new file mode 100644 index 000000000..30465dbb1 --- /dev/null +++ b/lib/dojo/_base/kernel.js.uncompressed.js @@ -0,0 +1,302 @@ +define("dojo/_base/kernel", ["../has", "./config", "require", "module"], function(has, config, require, module){ + // module: + // dojo/_base/kernel + // summary: + // This module is the foundational module of the dojo boot sequence; it defines the dojo object. + var + // loop variables for this module + i, p, + + // create dojo, dijit, and dojox + // FIXME: in 2.0 remove dijit, dojox being created by dojo + dijit = {}, + dojox = {}, + dojo = { + // notice dojo takes ownership of the value of the config module + config:config, + global:this, + dijit:dijit, + dojox:dojox + }; + + + // Configure the scope map. For a 100% AMD application, the scope map is not needed other than to provide + // a _scopeName property for the dojo, dijit, and dojox root object so those packages can create + // unique names in the global space. + // + // Built, legacy modules use the scope map to allow those modules to be expressed as if dojo, dijit, and dojox, + // where global when in fact they are either global under different names or not global at all. In v1.6-, the + // config variable "scopeMap" was used to map names as used within a module to global names. This has been + // subsumed by the dojo packageMap configuration variable which relocates packages to different names. See + // http://livedocs.dojotoolkit.org/developer/design/loader#legacy-cross-domain-mode for details. + // + // The following computations contort the packageMap for this dojo instance into a scopeMap. + var scopeMap = + // a map from a name used in a legacy module to the (global variable name, object addressed by that name) + // always map dojo, dijit, and dojox + { + dojo:["dojo", dojo], + dijit:["dijit", dijit], + dojox:["dojox", dojox] + }, + + packageMap = + // the package map for this dojo instance; note, a foreign loader or no pacakgeMap results in the above default config + (require.packs && require.packs[module.id.match(/[^\/]+/)[0]].packageMap) || {}, + + item; + + // process all mapped top-level names for this instance of dojo + for(p in packageMap){ + if(scopeMap[p]){ + // mapped dojo, dijit, or dojox + scopeMap[p][0] = packageMap[p]; + }else{ + // some other top-level name + scopeMap[p] = [packageMap[p], {}]; + } + } + + // publish those names to _scopeName and, optionally, the global namespace + for(p in scopeMap){ + item = scopeMap[p]; + item[1]._scopeName = item[0]; + if(!config.noGlobals){ + this[item[0]] = item[1]; + } + } + dojo.scopeMap = scopeMap; + + // FIXME: dojo.baseUrl and dojo.config.baseUrl should be deprecated + dojo.baseUrl = dojo.config.baseUrl = require.baseUrl; + dojo.isAsync = !1 || require.async; + dojo.locale = config.locale; + + /*===== + dojo.version = function(){ + // summary: + // Version number of the Dojo Toolkit + // major: Integer + // Major version. If total version is "1.2.0beta1", will be 1 + // minor: Integer + // Minor version. If total version is "1.2.0beta1", will be 2 + // patch: Integer + // Patch version. If total version is "1.2.0beta1", will be 0 + // flag: String + // Descriptor flag. If total version is "1.2.0beta1", will be "beta1" + // revision: Number + // The SVN rev from which dojo was pulled + this.major = 0; + this.minor = 0; + this.patch = 0; + this.flag = ""; + this.revision = 0; + } + =====*/ + var rev = "$Rev: 28982 $".match(/\d+/); + dojo.version = { + major: 1, minor: 7, patch: 3, flag: "", + revision: rev ? +rev[0] : NaN, + toString: function(){ + var v = dojo.version; + return v.major + "." + v.minor + "." + v.patch + v.flag + " (" + v.revision + ")"; // String + } + }; + + + // If 1 is truthy, then as a dojo module is defined it should push it's definitions + // into the dojo object, and conversely. In 2.0, it will likely be unusual to augment another object + // as a result of defining a module. This has feature gives a way to force 2.0 behavior as the code + // is migrated. Absent specific advice otherwise, set extend-dojo to truthy. + true || has.add("extend-dojo", 1); + + + dojo.eval = function(scriptText){ + // summary: + // A legacy method created for use exclusively by internal Dojo methods. Do not use this method + // directly unless you understand its possibly-different implications on the platforms your are targeting. + // description: + // Makes an attempt to evaluate scriptText in the global scope. The function works correctly for browsers + // that support indirect eval. + // + // As usual, IE does not. On IE, the only way to implement global eval is to + // use execScript. Unfortunately, execScript does not return a value and breaks some current usages of dojo.eval. + // This implementation uses the technique of executing eval in the scope of a function that is a single scope + // frame below the global scope; thereby coming close to the global scope. Note carefully that + // + // dojo.eval("var pi = 3.14;"); + // + // will define global pi in non-IE environments, but define pi only in a temporary local scope for IE. If you want + // to define a global variable using dojo.eval, write something like + // + // dojo.eval("window.pi = 3.14;") + // scriptText: + // The text to evaluation. + // returns: + // The result of the evaluation. Often `undefined` + }; + + (Function("d", "d.eval = function(){return d.global.eval ? d.global.eval(arguments[0]) : eval(arguments[0]);}"))(dojo); + + + if(0){ + dojo.exit = function(exitcode){ + quit(exitcode); + }; + } else{ + dojo.exit = function(){ + }; + } + + true || has.add("dojo-guarantee-console", + // ensure that console.log, console.warn, etc. are defined + 1 + ); + if(1){ + typeof console != "undefined" || (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 tn; + i = 0; + while((tn = cn[i++])){ + if(!console[tn]){ + (function(){ + var tcn = tn + ""; + console[tcn] = ('log' in console) ? function(){ + var a = Array.apply({}, arguments); + a.unshift(tcn + ":"); + console["log"](a.join(" ")); + } : function(){}; + console[tcn]._fake = true; + })(); + } + } + } + + has.add("dojo-debug-messages", + // include dojo.deprecated/dojo.experimental implementations + !!config.isDebug + ); + if(has("dojo-debug-messages")){ + dojo.deprecated = function(/*String*/ behaviour, /*String?*/ extra, /*String?*/ 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"); + + var message = "DEPRECATED: " + behaviour; + if(extra){ message += " " + extra; } + if(removal){ message += " -- will be removed in version: " + removal; } + console.warn(message); + }; + + dojo.experimental = function(/* String */ moduleName, /* String? */ 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"); + + var message = "EXPERIMENTAL: " + moduleName + " -- APIs subject to change without notice."; + if(extra){ message += " " + extra; } + console.warn(message); + }; + }else{ + dojo.deprecated = dojo.experimental = function(){}; + } + + true || has.add("dojo-modulePaths", + // consume dojo.modulePaths processing + 1 + ); + if(1){ + // notice that modulePaths won't be applied to any require's before the dojo/_base/kernel factory is run; + // this is the v1.6- behavior. + if(config.modulePaths){ + dojo.deprecated("dojo.modulePaths", "use paths configuration"); + var paths = {}; + for(p in config.modulePaths){ + paths[p.replace(/\./g, "/")] = config.modulePaths[p]; + } + require({paths:paths}); + } + } + + true || has.add("dojo-moduleUrl", + // include dojo.moduleUrl + 1 + ); + if(1){ + dojo.moduleUrl = function(/*String*/module, /*String?*/url){ + // summary: + // Returns a URL relative to a module. + // example: + // | var pngPath = dojo.moduleUrl("acme","images/small.png"); + // | console.dir(pngPath); // list the object properties + // | // create an image and set it's source to pngPath's value: + // | var img = document.createElement("img"); + // | img.src = pngPath; + // | // 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"); + + dojo.deprecated("dojo.moduleUrl()", "use require.toUrl", "2.0"); + + // require.toUrl requires a filetype; therefore, just append the suffix "/*.*" to guarantee a filetype, then + // remove the suffix from the result. This way clients can request a url w/out a filetype. This should be + // rare, but it maintains backcompat for the v1.x line (note: dojo.moduleUrl will be removed in v2.0). + // Notice * is an illegal filename so it won't conflict with any real path map that may exist the paths config. + var result = null; + if(module){ + result = require.toUrl(module.replace(/\./g, "/") + (url ? ("/" + url) : "") + "/*.*").replace(/\/\*\.\*/, "") + (url ? "" : "/"); + } + return result; + }; + } + + dojo._hasResource = {}; // for backward compatibility with layers built with 1.6 tooling + + return dojo; +}); diff --git a/lib/dojo/_base/lang.js b/lib/dojo/_base/lang.js index 9061de01e..bc88c7cde 100644 --- a/lib/dojo/_base/lang.js +++ b/lib/dojo/_base/lang.js @@ -4,394 +4,5 @@ see: http://dojotoolkit.org/license for details */ - -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"); - - -(function(){ - var d = dojo, opts = Object.prototype.toString; - - // Crockford (ish) functions - - dojo.isString = function(/*anything*/ it){ - // summary: - // Return true if it is a String - return (typeof it == "string" || it instanceof String); // Boolean - }; - - dojo.isArray = function(/*anything*/ it){ - // summary: - // Return true if it is an Array. - // Does not work on Arrays created in other windows. - return it && (it instanceof Array || typeof it == "array"); // Boolean - }; - - dojo.isFunction = function(/*anything*/ it){ - // summary: - // Return true if it is a Function - return opts.call(it) === "[object Function]"; - }; - - 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" || d.isArray(it) || d.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 quacks like a duck, return `true` - 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 && !d.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++){ - d._mixin(constructor.prototype, arguments[i]); - } - return constructor; // Object - }; - - dojo._hitchArgs = function(scope, method /*,...*/){ - var pre = d._toArray(arguments, 2); - var named = d.isString(method); - return function(){ - // arrayify arguments - var args = d._toArray(arguments); - // locate our method - var f = named ? (scope||d.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 - // example: - // Expansion on the default positional arguments passed along from - // hitch. Passed args are mixed first, additional args after. - // | var foo = { bar: function(a, b, c){ console.log(a, b, c); } }; - // | var fn = dojo.hitch(foo, "bar", 1, 2); - // | fn(3); // logs "1, 2, 3" - // example: - // | var foo = { bar: 2 }; - // | dojo.hitch(foo, function(){ this.bar = 10; })(); - // execute an anonymous function in scope of foo - - if(arguments.length > 2){ - return d._hitchArgs.apply(d, arguments); // Function - } - if(!method){ - method = scope; - scope = null; - } - if(d.isString(method)){ - scope = scope || d.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(); - TMP.prototype = null; - if(props){ - d._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. - } - =====*/ - - 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 = - d.isIE ? function(obj){ - return ((obj.item) ? slow : efficient).apply(this, arguments); - } : - efficient; - - 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 d.hitch.apply(d, arr.concat(d._toArray(arguments))); // Function - }; - - var extraNames = d._extraNames, extraLen = extraNames.length, empty = {}; - - dojo.clone = function(/*anything*/ o){ - // summary: - // Clones objects (including DOM nodes) and all children. - // Warning: do not clone cyclic structures. - if(!o || typeof o != "object" || d.isFunction(o)){ - // null, undefined, any non-object, or function - return o; // anything - } - if(o.nodeType && "cloneNode" in o){ - // DOM Node - return o.cloneNode(true); // Node - } - if(o instanceof Date){ - // Date - return new Date(o.getTime()); // Date - } - if(o instanceof RegExp){ - // RegExp - return new RegExp(o); // RegExp - } - var r, i, l, s, name; - if(d.isArray(o)){ - // array - r = []; - for(i = 0, l = o.length; i < l; ++i){ - if(i in o){ - r.push(d.clone(o[i])); - } - } -// we don't clone functions for performance reasons -// }else if(d.isFunction(o)){ -// // function -// r = function(){ return o.apply(this, arguments); }; - }else{ - // generic objects - r = o.constructor ? new o.constructor() : {}; - } - for(name in o){ - // the "tobj" condition avoid copying properties in "source" - // inherited from Object.prototype. For example, if target has a custom - // toString() method, don't overwrite it with the toString() method - // that source inherited from Object.prototype - s = o[name]; - if(!(name in r) || (r[name] !== s && (!(name in empty) || empty[name] !== s))){ - r[name] = d.clone(s); - } - } - // IE doesn't recognize some custom functions in for..in - if(extraLen){ - for(i = 0; i < extraLen; ++i){ - name = extraNames[i]; - s = o[name]; - if(!(name in r) || (r[name] !== s && (!(name in empty) || empty[name] !== s))){ - r[name] = s; // functions only, we don't clone them - } - } - } - return r; // Object - }; - - /*===== - dojo.trim = function(str){ - // summary: - // Trims whitespace from both sides of the string - // str: String - // String to be trimmed - // returns: String - // Returns the trimmed string - // description: - // This version of trim() was 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) - // Uses String.prototype.trim instead, if available. - // The fastest but longest version of this function is located at - // dojo.string.trim() - return ""; // String - } - =====*/ - - dojo.trim = String.prototype.trim ? - function(str){ return str.trim(); } : - function(str){ return str.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); }; - - /*===== - dojo.replace = function(tmpl, map, pattern){ - // summary: - // Performs parameterized substitutions on a string. Throws an - // exception if any parameter is unmatched. - // tmpl: String - // String to be used as a template. - // map: Object|Function - // If an object, it is used as a dictionary to look up substitutions. - // If a function, it is called for every substitution with following - // parameters: a whole match, a name, an offset, and the whole template - // string (see https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Objects/String/replace - // for more details). - // pattern: RegEx? - // Optional regular expression objects that overrides the default pattern. - // Must be global and match one item. The default is: /\{([^\}]+)\}/g, - // which matches patterns like that: "{xxx}", where "xxx" is any sequence - // of characters, which doesn't include "}". - // returns: String - // Returns the substituted string. - // example: - // | // uses a dictionary for substitutions: - // | dojo.replace("Hello, {name.first} {name.last} AKA {nick}!", - // | { - // | nick: "Bob", - // | name: { - // | first: "Robert", - // | middle: "X", - // | last: "Cringely" - // | } - // | }); - // | // returns: Hello, Robert Cringely AKA Bob! - // example: - // | // uses an array for substitutions: - // | dojo.replace("Hello, {0} {2}!", - // | ["Robert", "X", "Cringely"]); - // | // returns: Hello, Robert Cringely! - // example: - // | // uses a function for substitutions: - // | function sum(a){ - // | var t = 0; - // | dojo.forEach(a, function(x){ t += x; }); - // | return t; - // | } - // | dojo.replace( - // | "{count} payments averaging {avg} USD per payment.", - // | dojo.hitch( - // | { payments: [11, 16, 12] }, - // | function(_, key){ - // | switch(key){ - // | case "count": return this.payments.length; - // | case "min": return Math.min.apply(Math, this.payments); - // | case "max": return Math.max.apply(Math, this.payments); - // | case "sum": return sum(this.payments); - // | case "avg": return sum(this.payments) / this.payments.length; - // | } - // | } - // | ) - // | ); - // | // prints: 3 payments averaging 13 USD per payment. - // example: - // | // uses an alternative PHP-like pattern for substitutions: - // | dojo.replace("Hello, ${0} ${2}!", - // | ["Robert", "X", "Cringely"], /\$\{([^\}]+)\}/g); - // | // returns: Hello, Robert Cringely! - return ""; // String - } - =====*/ - - var _pattern = /\{([^\}]+)\}/g; - dojo.replace = function(tmpl, map, pattern){ - return tmpl.replace(pattern || _pattern, d.isFunction(map) ? - map : function(_, k){ return d.getObject(k, false, map); }); - }; -})(); - -} +//>>built +define("dojo/_base/lang",["./kernel","../has","./sniff"],function(_1,_2){_2.add("bug-for-in-skips-shadowed",function(){for(var i in {toString:1}){return 0;}return 1;});var _3=_2("bug-for-in-skips-shadowed")?"hasOwnProperty.valueOf.isPrototypeOf.propertyIsEnumerable.toLocaleString.toString.constructor".split("."):[],_4=_3.length,_5=function(_6,_7,_8){var _9,s,i,_a={};for(_9 in _7){s=_7[_9];if(!(_9 in _6)||(_6[_9]!==s&&(!(_9 in _a)||_a[_9]!==s))){_6[_9]=_8?_8(s):s;}}if(_2("bug-for-in-skips-shadowed")){if(_7){for(i=0;i<_4;++i){_9=_3[i];s=_7[_9];if(!(_9 in _6)||(_6[_9]!==s&&(!(_9 in _a)||_a[_9]!==s))){_6[_9]=_8?_8(s):s;}}}}return _6;},_b=function(_c,_d){if(!_c){_c={};}for(var i=1,l=arguments.length;i<l;i++){_e._mixin(_c,arguments[i]);}return _c;},_f=function(_10,_11,_12){var p,i=0,_13=_1.global;if(!_12){if(!_10.length){return _13;}else{p=_10[i++];try{_12=_1.scopeMap[p]&&_1.scopeMap[p][1];}catch(e){}_12=_12||(p in _13?_13[p]:(_11?_13[p]={}:undefined));}}while(_12&&(p=_10[i++])){_12=(p in _12?_12[p]:(_11?_12[p]={}:undefined));}return _12;},_14=function(_15,_16,_17){var _18=_15.split("."),p=_18.pop(),obj=_f(_18,true,_17);return obj&&p?(obj[p]=_16):undefined;},_19=function(_1a,_1b,_1c){return _f(_1a.split("."),_1b,_1c);},_1d=function(_1e,obj){return _e.getObject(_1e,false,obj)!==undefined;},_1f=Object.prototype.toString,_20=function(it){return (typeof it=="string"||it instanceof String);},_21=function(it){return it&&(it instanceof Array||typeof it=="array");},_22=function(it){return _1f.call(it)==="[object Function]";},_23=function(it){return it!==undefined&&(it===null||typeof it=="object"||_e.isArray(it)||_e.isFunction(it));},_24=function(it){return it&&it!==undefined&&!_e.isString(it)&&!_e.isFunction(it)&&!(it.tagName&&it.tagName.toLowerCase()=="form")&&(_e.isArray(it)||isFinite(it.length));},_25=function(it){return it&&!_e.isFunction(it)&&/\{\s*\[native code\]\s*\}/.test(String(it));},_26=function(_27,_28){for(var i=1,l=arguments.length;i<l;i++){_e._mixin(_27.prototype,arguments[i]);}return _27;},_29=function(_2a,_2b){var pre=_2c(arguments,2);var _2d=_e.isString(_2b);return function(){var _2e=_2c(arguments);var f=_2d?(_2a||_1.global)[_2b]:_2b;return f&&f.apply(_2a||this,pre.concat(_2e));};},_2f=function(_30,_31){if(arguments.length>2){return _e._hitchArgs.apply(_1,arguments);}if(!_31){_31=_30;_30=null;}if(_e.isString(_31)){_30=_30||_1.global;if(!_30[_31]){throw (["dojo.hitch: scope[\"",_31,"\"] is null (scope=\"",_30,"\")"].join(""));}return function(){return _30[_31].apply(_30,arguments||[]);};}return !_30?_31:function(){return _31.apply(_30,arguments||[]);};},_32=(function(){function TMP(){};return function(obj,_33){TMP.prototype=obj;var tmp=new TMP();TMP.prototype=null;if(_33){_e._mixin(tmp,_33);}return tmp;};})(),_34=function(obj,_35,_36){return (_36||[]).concat(Array.prototype.slice.call(obj,_35||0));},_2c=_2("ie")?(function(){function _37(obj,_38,_39){var arr=_39||[];for(var x=_38||0;x<obj.length;x++){arr.push(obj[x]);}return arr;};return function(obj){return ((obj.item)?_37:_34).apply(this,arguments);};})():_34,_3a=function(_3b){var arr=[null];return _e.hitch.apply(_1,arr.concat(_e._toArray(arguments)));},_3c=function(src){if(!src||typeof src!="object"||_e.isFunction(src)){return src;}if(src.nodeType&&"cloneNode" in src){return src.cloneNode(true);}if(src instanceof Date){return new Date(src.getTime());}if(src instanceof RegExp){return new RegExp(src);}var r,i,l;if(_e.isArray(src)){r=[];for(i=0,l=src.length;i<l;++i){if(i in src){r.push(_3c(src[i]));}}}else{r=src.constructor?new src.constructor():{};}return _e._mixin(r,src,_3c);},_3d=String.prototype.trim?function(str){return str.trim();}:function(str){return str.replace(/^\s\s*/,"").replace(/\s\s*$/,"");},_3e=/\{([^\}]+)\}/g,_3f=function(_40,map,_41){return _40.replace(_41||_3e,_e.isFunction(map)?map:function(_42,k){return _19(k,false,map);});},_e={_extraNames:_3,_mixin:_5,mixin:_b,setObject:_14,getObject:_19,exists:_1d,isString:_20,isArray:_21,isFunction:_22,isObject:_23,isArrayLike:_24,isAlien:_25,extend:_26,_hitchArgs:_29,hitch:_2f,delegate:_32,_toArray:_2c,partial:_3a,clone:_3c,trim:_3d,replace:_3f};1&&_b(_1,_e);return _e;});
\ No newline at end of file diff --git a/lib/dojo/_base/lang.js.uncompressed.js b/lib/dojo/_base/lang.js.uncompressed.js new file mode 100644 index 000000000..503606040 --- /dev/null +++ b/lib/dojo/_base/lang.js.uncompressed.js @@ -0,0 +1,707 @@ +define("dojo/_base/lang", ["./kernel", "../has", "./sniff"], function(dojo, has){ + // module: + // dojo/_base/lang + // summary: + // This module defines Javascript language extensions. + + has.add("bug-for-in-skips-shadowed", function(){ + // if true, the for-in interator skips object properties that exist in Object's prototype (IE 6 - ?) + for(var i in {toString: 1}){ + return 0; + } + return 1; + }); + + var _extraNames = + has("bug-for-in-skips-shadowed") ? + "hasOwnProperty.valueOf.isPrototypeOf.propertyIsEnumerable.toLocaleString.toString.constructor".split(".") : [], + + _extraLen = _extraNames.length, + + _mixin = function(dest, source, copyFunc){ + var name, s, i, empty = {}; + for(name in source){ + // the (!(name in empty) || empty[name] !== s) condition avoids copying properties in "source" + // inherited from Object.prototype. For example, if dest has a custom toString() method, + // don't overwrite it with the toString() method that source inherited from Object.prototype + s = source[name]; + if(!(name in dest) || (dest[name] !== s && (!(name in empty) || empty[name] !== s))){ + dest[name] = copyFunc ? copyFunc(s) : s; + } + } + + if(has("bug-for-in-skips-shadowed")){ + if(source){ + for(i = 0; i < _extraLen; ++i){ + name = _extraNames[i]; + s = source[name]; + if(!(name in dest) || (dest[name] !== s && (!(name in empty) || empty[name] !== s))){ + dest[name] = copyFunc ? copyFunc(s) : s; + } + } + } + } + + return dest; // Object + }, + + mixin = function(dest, sources){ + if(!dest){ dest = {}; } + for(var i = 1, l = arguments.length; i < l; i++){ + lang._mixin(dest, arguments[i]); + } + return dest; // Object + }, + + getProp = function(/*Array*/parts, /*Boolean*/create, /*Object*/context){ + var p, i = 0, dojoGlobal = dojo.global; + if(!context){ + if(!parts.length){ + return dojoGlobal; + }else{ + p = parts[i++]; + try{ + context = dojo.scopeMap[p] && dojo.scopeMap[p][1]; + }catch(e){} + context = context || (p in dojoGlobal ? dojoGlobal[p] : (create ? dojoGlobal[p] = {} : undefined)); + } + } + while(context && (p = parts[i++])){ + context = (p in context ? context[p] : (create ? context[p] = {} : undefined)); + } + return context; // mixed + }, + + setObject = function(name, value, context){ + var parts = name.split("."), p = parts.pop(), obj = getProp(parts, true, context); + return obj && p ? (obj[p] = value) : undefined; // Object + }, + + getObject = function(name, create, context){ + return getProp(name.split("."), create, context); // Object + }, + + exists = function(name, obj){ + return lang.getObject(name, false, obj) !== undefined; // Boolean + }, + + opts = Object.prototype.toString, + + // Crockford (ish) functions + + isString = function(it){ + return (typeof it == "string" || it instanceof String); // Boolean + }, + + isArray = function(it){ + return it && (it instanceof Array || typeof it == "array"); // Boolean + }, + + isFunction = function(it){ + return opts.call(it) === "[object Function]"; + }, + + isObject = function(it){ + return it !== undefined && + (it === null || typeof it == "object" || lang.isArray(it) || lang.isFunction(it)); // Boolean + }, + + isArrayLike = function(it){ + return it && it !== undefined && // Boolean + // keep out built-in constructors (Number, String, ...) which have length + // properties + !lang.isString(it) && !lang.isFunction(it) && + !(it.tagName && it.tagName.toLowerCase() == 'form') && + (lang.isArray(it) || isFinite(it.length)); + }, + + isAlien = function(it){ + return it && !lang.isFunction(it) && /\{\s*\[native code\]\s*\}/.test(String(it)); // Boolean + }, + + extend = function(constructor, props){ + for(var i=1, l=arguments.length; i<l; i++){ + lang._mixin(constructor.prototype, arguments[i]); + } + return constructor; // Object + }, + + _hitchArgs = function(scope, method){ + var pre = _toArray(arguments, 2); + var named = lang.isString(method); + return function(){ + // arrayify arguments + var args = _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 + }, + + hitch = function(scope, method){ + if(arguments.length > 2){ + return lang._hitchArgs.apply(dojo, arguments); // Function + } + if(!method){ + method = scope; + scope = null; + } + if(lang.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 + }, + + delegate = (function(){ + // boodman/crockford delegation w/ cornford optimization + function TMP(){} + return function(obj, props){ + TMP.prototype = obj; + var tmp = new TMP(); + TMP.prototype = null; + if(props){ + lang._mixin(tmp, props); + } + return tmp; // Object + }; + })(), + + efficient = function(obj, offset, startWith){ + return (startWith||[]).concat(Array.prototype.slice.call(obj, offset||0)); + }, + + _toArray = + has("ie") ? + (function(){ + function slow(obj, offset, startWith){ + var arr = startWith||[]; + for(var x = offset || 0; x < obj.length; x++){ + arr.push(obj[x]); + } + return arr; + } + return function(obj){ + return ((obj.item) ? slow : efficient).apply(this, arguments); + }; + })() : efficient, + + partial = function(/*Function|String*/method /*, ...*/){ + var arr = [ null ]; + return lang.hitch.apply(dojo, arr.concat(lang._toArray(arguments))); // Function + }, + + clone = function(/*anything*/ src){ + if(!src || typeof src != "object" || lang.isFunction(src)){ + // null, undefined, any non-object, or function + return src; // anything + } + if(src.nodeType && "cloneNode" in src){ + // DOM Node + return src.cloneNode(true); // Node + } + if(src instanceof Date){ + // Date + return new Date(src.getTime()); // Date + } + if(src instanceof RegExp){ + // RegExp + return new RegExp(src); // RegExp + } + var r, i, l; + if(lang.isArray(src)){ + // array + r = []; + for(i = 0, l = src.length; i < l; ++i){ + if(i in src){ + r.push(clone(src[i])); + } + } + // we don't clone functions for performance reasons + // }else if(d.isFunction(src)){ + // // function + // r = function(){ return src.apply(this, arguments); }; + }else{ + // generic objects + r = src.constructor ? new src.constructor() : {}; + } + return lang._mixin(r, src, clone); + }, + + + trim = String.prototype.trim ? + function(str){ return str.trim(); } : + function(str){ return str.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); }, + + + _pattern = /\{([^\}]+)\}/g, + + replace = function(tmpl, map, pattern){ + return tmpl.replace(pattern || _pattern, lang.isFunction(map) ? + map : function(_, k){ return getObject(k, false, map); }); + }, + + lang = { + _extraNames:_extraNames, + _mixin:_mixin, + mixin:mixin, + setObject:setObject, + getObject:getObject, + exists:exists, + isString:isString, + isArray:isArray, + isFunction:isFunction, + isObject:isObject, + isArrayLike:isArrayLike, + isAlien:isAlien, + extend:extend, + _hitchArgs:_hitchArgs, + hitch:hitch, + delegate:delegate, + _toArray:_toArray, + partial:partial, + clone:clone, + trim:trim, + replace:replace + }; + + 1 && mixin(dojo, lang); + return lang; + + /*===== + dojo._extraNames + // summary: + // Array of strings. Lists property names that must be explicitly processed during for-in interation + // in environments that have has("bug-for-in-skips-shadowed") true. + =====*/ + + /*===== + dojo._mixin = function(dest, source, copyFunc){ + // summary: + // Copies/adds all properties of source to dest; returns dest. + // dest: Object: + // The object to which to copy/add all properties contained in source. + // source: Object: + // The object from which to draw all properties to copy into dest. + // copyFunc: Function?: + // The process used to copy/add a property in source; defaults to the Javascript assignment operator. + // returns: + // dest, as modified + // description: + // All properties, including functions (sometimes termed "methods"), excluding any non-standard extensions + // found in Object.prototype, are copied/added to dest. Copying/adding each particular property is + // delegated to copyFunc (if any); copyFunc defaults to the Javascript assignment operator if not provided. + // Notice that by default, _mixin executes a so-called "shallow copy" and aggregate types are copied/added by reference. + } + =====*/ + + /*===== + dojo.mixin = function(dest, sources){ + // summary: + // Copies/adds all properties of one or more sources to dest; returns dest. + // dest: Object + // The object to which to copy/add all properties contained in source. If dest is falsy, then + // a new object is manufactured before copying/adding properties begins. + // sources: Object... + // One of more objects from which to draw all properties to copy into dest. sources are processed + // left-to-right and if more than one of these objects contain the same property name, the right-most + // value "wins". + // returns: Object + // dest, as modified + // description: + // All properties, including functions (sometimes termed "methods"), excluding any non-standard extensions + // found in Object.prototype, are copied/added from sources to dest. sources are processed left to right. + // The Javascript assignment operator is used to copy/add each property; therefore, by default, mixin + // executes a so-called "shallow copy" and aggregate types are copied/added by reference. + // example: + // make a shallow copy of an object + // | var copy = lang.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 `lang.mixin` on the `this` object: + // | dojo.declare("acme.Base", null, { + // | constructor: function(properties){ + // | // property configuration: + // | lang.mixin(this, properties); + // | + // | console.log(this.quip); + // | // ... + // | }, + // | quip: "I wasn't born yesterday, you know - I've seen movies.", + // | // ... + // | }); + // | + // | // create an instance of the class and configure it + // | var b = new acme.Base({quip: "That's what it does!" }); + // example: + // copy in properties from multiple objects + // | var flattened = lang.mixin( + // | { + // | name: "Frylock", + // | braces: true + // | }, + // | { + // | name: "Carl Brutanananadilewski" + // | } + // | ); + // | + // | // will print "Carl Brutanananadilewski" + // | console.log(flattened.name); + // | // will print "true" + // | console.log(flattened.braces); + } + =====*/ + + /*===== + dojo.setObject = function(name, value, 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: String + // Path to a property, in the form "A.B.C". + // value: anything + // value or object to place at location given by name + // context: Object? + // 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: + // | lang.setObject("foo.bar.baz", value); + // example: + // without `lang.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"; + // whereas with `lang.setObject`, we can shorten that to: + // | lang.setObject("parent.child.prop", "some value", obj); + } + =====*/ + + /*===== + dojo.getObject = function(name, create, 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: String + // Path to an property, in the form "A.B.C". + // create: Boolean? + // Optional. Defaults to `false`. If `true`, Objects will be + // created at any point along the 'path' that is undefined. + // context: Object? + // Optional. Object to use as root of path. Defaults to + // 'dojo.global'. Null may be passed. + } + =====*/ + + /*===== + dojo.exists = function(name, obj){ + // summary: + // determine if an object supports a given method + // description: + // useful for longer api chains where you have to test each object in + // the chain. Useful for object and method detection. + // name: String + // Path to an object, in the form "A.B.C". + // obj: Object? + // 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 + // | lang.exists("foo.bar"); // true + // | lang.exists("foo.bar.baz"); // false + // | + // | // search from a particular scope + // | lang.exists("bar", foo); // true + // | lang.exists("bar.baz", foo); // false + } + =====*/ + + /*===== + dojo.isString = function(it){ + // summary: + // Return true if it is a String + // it: anything + // Item to test. + } + =====*/ + + /*===== + dojo.isArray = function(it){ + // summary: + // Return true if it is an Array. + // Does not work on Arrays created in other windows. + // it: anything + // Item to test. + } + =====*/ + + /*===== + dojo.isFunction = function(it){ + // summary: + // Return true if it is a Function + // it: anything + // Item to test. + } + =====*/ + + /*===== + dojo.isObject = function(it){ + // summary: + // Returns true if it is a JavaScript object (or an Array, a Function + // or null) + // it: anything + // Item to test. + } + =====*/ + + /*===== + dojo.isArrayLike = function(it){ + // summary: + // similar to dojo.isArray() but more permissive + // it: anything + // Item to test. + // returns: + // If it walks like a duck and quacks like a duck, return `true` + // 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(). + } + =====*/ + + /*===== + dojo.isAlien = function(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 + } + =====*/ + + /*===== + dojo.extend = function(constructor, props){ + // summary: + // Adds all properties and methods of props to constructor's + // prototype, making them available to all instances created with + // constructor. + // constructor: Object + // Target constructor to extend. + // props: Object... + // One or more objects to mix into constructor.prototype + } + =====*/ + + /*===== + dojo.hitch = function(scope, 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: Object + // The scope to use when method executes. If method is a string, + // scope is also the object containing method. + // method: Function|String... + // 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 + // example: + // Expansion on the default positional arguments passed along from + // hitch. Passed args are mixed first, additional args after. + // | var foo = { bar: function(a, b, c){ console.log(a, b, c); } }; + // | var fn = dojo.hitch(foo, "bar", 1, 2); + // | fn(3); // logs "1, 2, 3" + // example: + // | var foo = { bar: 2 }; + // | dojo.hitch(foo, function(){ this.bar = 10; })(); + // execute an anonymous function in scope of foo + } + =====*/ + + /*===== + 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: Object + // The object to delegate to for properties not found directly on the + // return object or in props. + // props: Object... + // 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.partial = function(method){ + // summary: + // similar to hitch() except that the scope object is left to be + // whatever the execution context eventually becomes. + // method: Function|String + // description: + // Calling dojo.partial is the functional equivalent of calling: + // | dojo.hitch(null, funcName, ...); + } + =====*/ + + /*===== + dojo.trim = function(str){ + // summary: + // Trims whitespace from both sides of the string + // str: String + // String to be trimmed + // returns: String + // Returns the trimmed string + // description: + // This version of trim() was 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) + // Uses String.prototype.trim instead, if available. + // The fastest but longest version of this function is located at + // dojo.string.trim() + } + =====*/ + + /*===== + dojo.clone = function(src){ + // summary: + // Clones objects (including DOM nodes) and all children. + // Warning: do not clone cyclic structures. + // src: + // The object to clone + } + =====*/ + + /*===== + 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. + } + =====*/ + + /*===== + dojo.replace = function(tmpl, map, pattern){ + // summary: + // Performs parameterized substitutions on a string. Throws an + // exception if any parameter is unmatched. + // tmpl: String + // String to be used as a template. + // map: Object|Function + // If an object, it is used as a dictionary to look up substitutions. + // If a function, it is called for every substitution with following + // parameters: a whole match, a name, an offset, and the whole template + // string (see https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Objects/String/replace + // for more details). + // pattern: RegEx? + // Optional regular expression objects that overrides the default pattern. + // Must be global and match one item. The default is: /\{([^\}]+)\}/g, + // which matches patterns like that: "{xxx}", where "xxx" is any sequence + // of characters, which doesn't include "}". + // returns: String + // Returns the substituted string. + // example: + // | // uses a dictionary for substitutions: + // | dojo.replace("Hello, {name.first} {name.last} AKA {nick}!", + // | { + // | nick: "Bob", + // | name: { + // | first: "Robert", + // | middle: "X", + // | last: "Cringely" + // | } + // | }); + // | // returns: Hello, Robert Cringely AKA Bob! + // example: + // | // uses an array for substitutions: + // | dojo.replace("Hello, {0} {2}!", + // | ["Robert", "X", "Cringely"]); + // | // returns: Hello, Robert Cringely! + // example: + // | // uses a function for substitutions: + // | function sum(a){ + // | var t = 0; + // | dojo.forEach(a, function(x){ t += x; }); + // | return t; + // | } + // | dojo.replace( + // | "{count} payments averaging {avg} USD per payment.", + // | dojo.hitch( + // | { payments: [11, 16, 12] }, + // | function(_, key){ + // | switch(key){ + // | case "count": return this.payments.length; + // | case "min": return Math.min.apply(Math, this.payments); + // | case "max": return Math.max.apply(Math, this.payments); + // | case "sum": return sum(this.payments); + // | case "avg": return sum(this.payments) / this.payments.length; + // | } + // | } + // | ) + // | ); + // | // prints: 3 payments averaging 13 USD per payment. + // example: + // | // uses an alternative PHP-like pattern for substitutions: + // | dojo.replace("Hello, ${0} ${2}!", + // | ["Robert", "X", "Cringely"], /\$\{([^\}]+)\}/g); + // | // returns: Hello, Robert Cringely! + return ""; // String + } + =====*/ +}); + diff --git a/lib/dojo/_base/loader.js b/lib/dojo/_base/loader.js new file mode 100644 index 000000000..fd9b8f3df --- /dev/null +++ b/lib/dojo/_base/loader.js @@ -0,0 +1,8 @@ +/* + Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Available via Academic Free License >= 2.1 OR the modified BSD license. + see: http://dojotoolkit.org/license for details +*/ + +//>>built +define("dojo/_base/loader",["./kernel","../has","require","module","./json","./lang","./array"],function(_1,_2,_3,_4,_5,_6,_7){if(!1){console.error("cannot load the Dojo v1.x loader with a foreign loader");return 0;}var _8=function(id){return {src:_4.id,id:id};},_9=function(_a){return _a.replace(/\./g,"/");},_b=/\/\/>>built/,_c=[],_d=[],_e=function(_f,_10,_11){_c.push(_11);_7.forEach(_f.split(","),function(mid){var _12=_13(mid,_10.module);_d.push(_12);_14(_12);});_15();},_16,_17=function(m){_16[m.mid]=1;for(var t,_18,_19=m.deps||[],i=0;i<_19.length;i++){_18=_19[i];if(!(t=_16[_18.mid])){if(t===0||!_17(_18)){_16[m.mid]=0;return false;}}}return true;},_15=function(){var _1a,mid;_16={};for(mid in _1b){_1a=_1b[mid];if(_1a.executed||_1a.noReqPluginCheck){_16[mid]=1;}else{if(_1a.noReqPluginCheck!==0){_1a.noReqPluginCheck=/loadInit\!/.test(mid)||/require\!/.test(mid)?1:0;}if(_1a.noReqPluginCheck){_16[mid]=1;}else{if(_1a.injected!==_1c){_16[mid]=0;}}}}for(var t,i=0,end=_d.length;i<end;i++){_1a=_d[i];if(!(t=_16[_1a.mid])){if(t===0||!_17(_1a)){return;}}}_1d.holdIdle();var _1e=_c;_c=[];_7.forEach(_1e,function(cb){cb(1);});_1d.releaseIdle();},_1f=function(mid,_20,_21){_20([mid],function(_22){_20(_22.names,function(){for(var _23="",_24=[],i=0;i<arguments.length;i++){_23+="var "+_22.names[i]+"= arguments["+i+"]; ";_24.push(arguments[i]);}eval(_23);var _25=_20.module,_26=[],_27={},_28=[],p,_29={provide:function(_2a){_2a=_9(_2a);var _2b=_13(_2a,_25);if(_2b!==_25){_53(_2b);}},require:function(_2c,_2d){_2c=_9(_2c);_2d&&(_13(_2c,_25).result=_4e);_28.push(_2c);},requireLocalization:function(_2e,_2f,_30){_26.length||(_26=["dojo/i18n"]);_30=(_30||_1.locale).toLowerCase();_2e=_9(_2e)+"/nls/"+(/root/i.test(_30)?"":_30+"/")+_9(_2f);if(_13(_2e,_25).isXd){_26.push("dojo/i18n!"+_2e);}},loadInit:function(f){f();}};try{for(p in _29){_27[p]=_1[p];_1[p]=_29[p];}_22.def.apply(null,_24);}catch(e){_54("error",[_8("failedDojoLoadInit"),e]);}finally{for(p in _29){_1[p]=_27[p];}}_28.length&&_26.push("dojo/require!"+_28.join(","));_c.push(_21);_7.forEach(_28,function(mid){var _31=_13(mid,_20.module);_d.push(_31);_14(_31);});_15();});});},_32=function(_33,_34,_35){var _36=/\(|\)/g,_37=1,_38;_36.lastIndex=_34;while((_38=_36.exec(_33))){if(_38[0]==")"){_37-=1;}else{_37+=1;}if(_37==0){break;}}if(_37!=0){throw "unmatched paren around character "+_36.lastIndex+" in: "+_33;}return [_1.trim(_33.substring(_35,_36.lastIndex))+";\n",_36.lastIndex];},_39=/(\/\*([\s\S]*?)\*\/|\/\/(.*)$)/mg,_3a=/(^|\s)dojo\.(loadInit|require|provide|requireLocalization|requireIf|requireAfterIf|platformRequire)\s*\(/mg,_3b=/(^|\s)(require|define)\s*\(/m,_3c=function(_3d,_3e){var _3f,_40,_41,_42,_43=[],_44=[],_45=[];_3e=_3e||_3d.replace(_39,function(_46){_3a.lastIndex=_3b.lastIndex=0;return (_3a.test(_46)||_3b.test(_46))?"":_46;});while((_3f=_3a.exec(_3e))){_40=_3a.lastIndex;_41=_40-_3f[0].length;_42=_32(_3e,_40,_41);if(_3f[2]=="loadInit"){_43.push(_42[0]);}else{_44.push(_42[0]);}_3a.lastIndex=_42[1];}_45=_43.concat(_44);if(_45.length||!_3b.test(_3e)){return [_3d.replace(/(^|\s)dojo\.loadInit\s*\(/g,"\n0 && dojo.loadInit("),_45.join(""),_45];}else{return 0;}},_47=function(_48,_49){var _4a,id,_4b=[],_4c=[];if(_b.test(_49)||!(_4a=_3c(_49))){return 0;}id=_48.mid+"-*loadInit";for(var p in _13("dojo",_48).result.scopeMap){_4b.push(p);_4c.push("\""+p+"\"");}return "// xdomain rewrite of "+_48.path+"\n"+"define('"+id+"',{\n"+"\tnames:"+_1.toJson(_4b)+",\n"+"\tdef:function("+_4b.join(",")+"){"+_4a[1]+"}"+"});\n\n"+"define("+_1.toJson(_4b.concat(["dojo/loadInit!"+id]))+", function("+_4b.join(",")+"){\n"+_4a[0]+"});";},_1d=_3.initSyncLoader(_e,_15,_47),_4d=_1d.sync,xd=_1d.xd,_1c=_1d.arrived,_4e=_1d.nonmodule,_4f=_1d.executing,_50=_1d.executed,_51=_1d.syncExecStack,_1b=_1d.modules,_52=_1d.execQ,_13=_1d.getModule,_14=_1d.injectModule,_53=_1d.setArrived,_54=_1d.signal,_55=_1d.finishExec,_56=_1d.execModule,_57=_1d.getLegacyMode;_1.provide=function(mid){var _58=_51[0],_59=_6.mixin(_13(_9(mid),_3.module),{executed:_4f,result:_6.getObject(mid,true)});_53(_59);if(_58){(_58.provides||(_58.provides=[])).push(function(){_59.result=_6.getObject(mid);delete _59.provides;_59.executed!==_50&&_55(_59);});}return _59.result;};_2.add("config-publishRequireResult",1,0,0);_1.require=function(_5a,_5b){function _5c(mid,_5d){var _5e=_13(_9(mid),_3.module);if(_51.length&&_51[0].finish){_51[0].finish.push(mid);return undefined;}if(_5e.executed){return _5e.result;}_5d&&(_5e.result=_4e);var _5f=_57();_14(_5e);_5f=_57();if(_5e.executed!==_50&&_5e.injected===_1c){_1d.holdIdle();_56(_5e);_1d.releaseIdle();}if(_5e.executed){return _5e.result;}if(_5f==_4d){if(_5e.cjs){_52.unshift(_5e);}else{_51.length&&(_51[0].finish=[mid]);}}else{_52.push(_5e);}return undefined;};var _60=_5c(_5a,_5b);if(_2("config-publishRequireResult")&&!_6.exists(_5a)&&_60!==undefined){_6.setObject(_5a,_60);}return _60;};_1.loadInit=function(f){f();};_1.registerModulePath=function(_61,_62){var _63={};_63[_61.replace(/\./g,"/")]=_62;_3({paths:_63});};_1.platformRequire=function(_64){var _65=(_64.common||[]).concat(_64[_1._name]||_64["default"]||[]),_66;while(_65.length){if(_6.isArray(_66=_65.shift())){_1.require.apply(_1,_66);}else{_1.require(_66);}}};_1.requireIf=_1.requireAfterIf=function(_67,_68,_69){if(_67){_1.require(_68,_69);}};_1.requireLocalization=function(_6a,_6b,_6c){_3(["../i18n"],function(_6d){_6d.getLocalization(_6a,_6b,_6c);});};return {extractLegacyApiApplications:_3c,require:_1d.dojoRequirePlugin,loadInit:_1f};});
\ No newline at end of file diff --git a/lib/dojo/_base/loader.js.uncompressed.js b/lib/dojo/_base/loader.js.uncompressed.js new file mode 100644 index 000000000..0bc2cc5b3 --- /dev/null +++ b/lib/dojo/_base/loader.js.uncompressed.js @@ -0,0 +1,718 @@ +define("dojo/_base/loader", ["./kernel", "../has", "require", "module", "./json", "./lang", "./array"], function(dojo, has, require, thisModule, json, lang, array) { + // module: + // dojo/_base/lader + // summary: + // This module defines the v1.x synchronous loader API. + + // signal the loader in sync mode... + //>>pure-amd + + if (!1){ + console.error("cannot load the Dojo v1.x loader with a foreign loader"); + return 0; + } + + var makeErrorToken = function(id){ + return {src:thisModule.id, id:id}; + }, + + slashName = function(name){ + return name.replace(/\./g, "/"); + }, + + buildDetectRe = /\/\/>>built/, + + dojoRequireCallbacks = [], + dojoRequireModuleStack = [], + + dojoRequirePlugin = function(mid, require, loaded){ + dojoRequireCallbacks.push(loaded); + array.forEach(mid.split(","), function(mid){ + var module = getModule(mid, require.module); + dojoRequireModuleStack.push(module); + injectModule(module); + }); + checkDojoRequirePlugin(); + }, + + // checkDojoRequirePlugin inspects all of the modules demanded by a dojo/require!<module-list> dependency + // to see if they have arrived. The loader does not release *any* of these modules to be instantiated + // until *all* of these modules are on board, thereby preventing the evaluation of a module with dojo.require's + // that reference modules that are not available. + // + // The algorithm works by traversing the dependency graphs (remember, there can be cycles so they are not trees) + // of each module in the dojoRequireModuleStack array (which contains the list of modules demanded by dojo/require!). + // The moment a single module is discovered that is missing, the algorithm gives up and indicates that not all + // modules are on board. dojo/loadInit! and dojo/require! are ignored because there dependencies are inserted + // directly in dojoRequireModuleStack. For example, if "your/module" module depends on "dojo/require!my/module", then + // *both* "dojo/require!my/module" and "my/module" will be in dojoRequireModuleStack. Obviously, if "my/module" + // is on board, then "dojo/require!my/module" is also satisfied, so the algorithm doesn't check for "dojo/require!my/module". + // + // Note: inserting a dojo/require!<some-module-list> dependency in the dojoRequireModuleStack achieves nothing + // with the current algorithm; however, having such modules present makes it possible to optimize the algorithm + // + // Note: prior versions of this algorithm had an optimization that signaled loaded on dojo/require! dependencies + // individually (rather than waiting for them all to be resolved). The implementation proved problematic with cycles + // and plugins. However, it is possible to reattach that strategy in the future. + + // a set from module-id to {undefined | 1 | 0}, where... + // undefined => the module has not been inspected + // 0 => the module or at least one of its dependencies has not arrived + // 1 => the module is a loadInit! or require! plugin resource, or is currently being traversed (therefore, assume + // OK until proven otherwise), or has been completely traversed and all dependencies have arrived + touched, + + traverse = function(m){ + touched[m.mid] = 1; + for(var t, module, deps = m.deps || [], i= 0; i<deps.length; i++){ + module = deps[i]; + if(!(t = touched[module.mid])){ + if(t===0 || !traverse(module)){ + touched[m.mid] = 0; + return false; + } + } + } + return true; + }, + + checkDojoRequirePlugin = function(){ + // initialize the touched hash with easy-to-compute values that help short circuit recursive algorithm; + // recall loadInit/require plugin modules are dependencies of modules in dojoRequireModuleStack... + // which would cause a circular dependency chain that would never be resolved if checked here + // notice all dependencies of any particular loadInit/require plugin module will already + // be checked since those are pushed into dojoRequireModuleStack explicitly by the + // plugin...so if a particular loadInitPlugin module's dependencies are not really + // on board, that *will* be detected elsewhere in the traversal. + var module, mid; + touched = {}; + for(mid in modules){ + module = modules[mid]; + // this could be improved by remembering the result of the regex tests + if(module.executed || module.noReqPluginCheck){ + touched[mid] = 1; + }else{ + if(module.noReqPluginCheck!==0){ + // tag the module as either a loadInit or require plugin or not for future reference + module.noReqPluginCheck = /loadInit\!/.test(mid) || /require\!/.test(mid) ? 1 : 0; + } + if(module.noReqPluginCheck){ + touched[mid] = 1; + }else if(module.injected!==arrived){ + // not executed, has not arrived, and is not a loadInit or require plugin resource + touched[mid] = 0; + }// else, leave undefined and we'll traverse the dependencies + } + } + + for(var t, i = 0, end = dojoRequireModuleStack.length; i<end; i++){ + module = dojoRequireModuleStack[i]; + if(!(t = touched[module.mid])){ + if(t===0 || !traverse(module)){ + return; + } + } + } + loaderVars.holdIdle(); + var oldCallbacks = dojoRequireCallbacks; + dojoRequireCallbacks = []; + array.forEach(oldCallbacks, function(cb){cb(1);}); + loaderVars.releaseIdle(); + }, + + dojoLoadInitPlugin = function(mid, require, loaded){ + // mid names a module that defines a "dojo load init" bundle, an object with two properties: + // + // * names: a vector of module ids that give top-level names to define in the lexical scope of def + // * def: a function that contains some some legacy loader API applications + // + // The point of def is to possibly cause some modules to be loaded (but not executed) by dojo/require! where the module + // ids are possibly-determined at runtime. For example, here is dojox.gfx from v1.6 expressed as an AMD module using the dojo/loadInit + // and dojo/require plugins. + // + // // dojox/gfx: + // + // define("*loadInit_12, { + // names:["dojo", "dijit", "dojox"], + // def: function(){ + // dojo.loadInit(function(){ + // var gfx = lang.getObject("dojox.gfx", true); + // + // // + // // code required to set gfx properties ommitted... + // // + // + // // now use the calculations to include the runtime-dependent module + // dojo.require("dojox.gfx." + gfx.renderer); + // }); + // } + // }); + // + // define(["dojo", "dojo/loadInit!" + id].concat("dojo/require!dojox/gfx/matric,dojox/gfx/_base"), function(dojo){ + // // when this AMD factory function is executed, the following modules are guaranteed downloaded but not executed: + // // "dojox.gfx." + gfx.renderer + // // dojox.gfx.matrix + // // dojox.gfx._base + // dojo.provide("dojo.gfx"); + // dojo.require("dojox.gfx.matrix"); + // dojo.require("dojox.gfx._base"); + // dojo.require("dojox.gfx." + gfx.renderer); + // return lang.getObject("dojo.gfx"); + // }); + // })(); + // + // The idea is to run the legacy loader API with global variables shadowed, which allows these variables to + // be relocated. For example, dojox and dojo could be relocated to different names by giving a packageMap and the code above will + // execute properly (because the plugin below resolves the load init bundle.names module with respect to the module that demanded + // the plugin resource). + // + // Note that the relocation is specified in the runtime configuration; relocated names need not be set at build-time. + // + // Warning: this is not the best way to express dojox.gfx as and AMD module. In fact, the module has been properly converted in + // v1.7. However, this technique allows the builder to convert legacy modules into AMD modules and guarantee the codepath is the + // same in the converted AMD module. + require([mid], function(bundle){ + // notice how names is resolved with respect to the module that demanded the plugin resource + require(bundle.names, function(){ + // bring the bundle names into scope + for(var scopeText = "", args= [], i = 0; i<arguments.length; i++){ + scopeText+= "var " + bundle.names[i] + "= arguments[" + i + "]; "; + args.push(arguments[i]); + } + eval(scopeText); + + var callingModule = require.module, + deps = [], + hold = {}, + requireList = [], + p, + syncLoaderApi = { + provide:function(moduleName){ + // mark modules that arrive consequent to multiple provides in this module as arrived since they can't be injected + moduleName = slashName(moduleName); + var providedModule = getModule(moduleName, callingModule); + if(providedModule!==callingModule){ + setArrived(providedModule); + } + }, + require:function(moduleName, omitModuleCheck){ + moduleName = slashName(moduleName); + omitModuleCheck && (getModule(moduleName, callingModule).result = nonmodule); + requireList.push(moduleName); + }, + requireLocalization:function(moduleName, bundleName, locale){ + // since we're going to need dojo/i8n, add it to deps if not already there + deps.length || (deps = ["dojo/i18n"]); + + // figure out if the bundle is xdomain; if so, add it to the depsSet + locale = (locale || dojo.locale).toLowerCase(); + moduleName = slashName(moduleName) + "/nls/" + (/root/i.test(locale) ? "" : locale + "/") + slashName(bundleName); + if(getModule(moduleName, callingModule).isXd){ + deps.push("dojo/i18n!" + moduleName); + }// else the bundle will be loaded synchronously when the module is evaluated + }, + loadInit:function(f){ + f(); + } + }; + + // hijack the correct dojo and apply bundle.def + try{ + for(p in syncLoaderApi){ + hold[p] = dojo[p]; + dojo[p] = syncLoaderApi[p]; + } + bundle.def.apply(null, args); + }catch(e){ + signal("error", [makeErrorToken("failedDojoLoadInit"), e]); + }finally{ + for(p in syncLoaderApi){ + dojo[p] = hold[p]; + } + } + + // requireList is the list of modules that need to be downloaded but not executed before the callingModule can be executed + requireList.length && deps.push("dojo/require!" + requireList.join(",")); + + dojoRequireCallbacks.push(loaded); + array.forEach(requireList, function(mid){ + var module = getModule(mid, require.module); + dojoRequireModuleStack.push(module); + injectModule(module); + }); + checkDojoRequirePlugin(); + }); + }); + }, + + extractApplication = function( + text, // the text to search + startSearch, // the position in text to start looking for the closing paren + startApplication // the position in text where the function application expression starts + ){ + // find end of the call by finding the matching end paren + // Warning: as usual, this will fail in the presense of unmatched right parans contained in strings, regexs, or unremoved comments + var parenRe = /\(|\)/g, + matchCount = 1, + match; + parenRe.lastIndex = startSearch; + while((match = parenRe.exec(text))){ + if(match[0] == ")"){ + matchCount -= 1; + }else{ + matchCount += 1; + } + if(matchCount == 0){ + break; + } + } + + if(matchCount != 0){ + throw "unmatched paren around character " + parenRe.lastIndex + " in: " + text; + } + + //Put the master matching string in the results. + return [dojo.trim(text.substring(startApplication, parenRe.lastIndex))+";\n", parenRe.lastIndex]; + }, + + // the following regex is taken from 1.6. It is a very poor technique to remove comments and + // will fail in some cases; for example, consider the code... + // + // var message = "Category-1 */* Category-2"; + // + // The regex that follows will see a /* comment and trash the code accordingly. In fact, there are all + // kinds of cases like this with strings and regexs that will cause this design to fail miserably. + // + // Alternative regex designs exist that will result in less-likely failures, but will still fail in many cases. + // The only solution guaranteed 100% correct is to parse the code and that seems overkill for this + // backcompat/unbuilt-xdomain layer. In the end, since it's been this way for a while, we won't change it. + // See the opening paragraphs of Chapter 7 or ECME-262 which describes the lexical abiguity further. + removeCommentRe = /(\/\*([\s\S]*?)\*\/|\/\/(.*)$)/mg, + + syncLoaderApiRe = /(^|\s)dojo\.(loadInit|require|provide|requireLocalization|requireIf|requireAfterIf|platformRequire)\s*\(/mg, + + amdLoaderApiRe = /(^|\s)(require|define)\s*\(/m, + + extractLegacyApiApplications = function(text, noCommentText){ + // scan the noCommentText for any legacy loader API applications. Copy such applications into result (this is + // used by the builder). Move dojo.loadInit applications to loadInitApplications string. Copy all other applications + // to otherApplications string. If no applications were found, return 0, signalling an AMD module. Otherwise, return + // loadInitApplications + otherApplications. Fixup text by replacing + // + // dojo.loadInit(// etc... + // + // with + // + // \n 0 && dojo.loadInit(// etc... + // + // Which results in the dojo.loadInit from *not* being applied. This design goes a long way towards protecting the + // code from an over-agressive removeCommentRe. However... + // + // WARNING: the removeCommentRe will cause an error if a detected comment removes all or part of a legacy-loader application + // that is not in a comment. + + var match, startSearch, startApplication, application, + loadInitApplications = [], + otherApplications = [], + allApplications = []; + + // noCommentText may be provided by a build app with comments extracted by a better method than regex (hopefully) + noCommentText = noCommentText || text.replace(removeCommentRe, function(match){ + // remove iff the detected comment has text that looks like a sync loader API application; this helps by + // removing as little as possible, minimizing the changes the janky regex will kill the module + syncLoaderApiRe.lastIndex = amdLoaderApiRe.lastIndex = 0; + return (syncLoaderApiRe.test(match) || amdLoaderApiRe.test(match)) ? "" : match; + }); + + // find and extract all dojo.loadInit applications + while((match = syncLoaderApiRe.exec(noCommentText))){ + startSearch = syncLoaderApiRe.lastIndex; + startApplication = startSearch - match[0].length; + application = extractApplication(noCommentText, startSearch, startApplication); + if(match[2]=="loadInit"){ + loadInitApplications.push(application[0]); + }else{ + otherApplications.push(application[0]); + } + syncLoaderApiRe.lastIndex = application[1]; + } + allApplications = loadInitApplications.concat(otherApplications); + if(allApplications.length || !amdLoaderApiRe.test(noCommentText)){ + // either there were some legacy loader API applications or there were no AMD API applications + return [text.replace(/(^|\s)dojo\.loadInit\s*\(/g, "\n0 && dojo.loadInit("), allApplications.join(""), allApplications]; + }else{ + // legacy loader API *was not* detected and AMD API *was* detected; therefore, assume it's an AMD module + return 0; + } + }, + + transformToAmd = function(module, text){ + // This is roughly the equivalent of dojo._xdCreateResource in 1.6-; however, it expresses a v1.6- dojo + // module in terms of AMD define instead of creating the dojo proprietary xdomain module expression. + // The module could have originated from several sources: + // + // * amd require() a module, e.g., require(["my/module"]) + // * amd require() a nonmodule, e.g., require(["my/resource.js"') + // * amd define() deps vector (always a module) + // * dojo.require() a module, e.g. dojo.require("my.module") + // * dojo.require() a nonmodule, e.g., dojo.require("my.module", true) + // * dojo.requireIf/requireAfterIf/platformRequire a module + // + // The module is scanned for legacy loader API applications; if none are found, then assume the module is an + // AMD module and return 0. Otherwise, a synthetic dojo/loadInit plugin resource is created and the module text + // is rewritten as an AMD module with the single dependency of this synthetic resource. When the dojo/loadInit + // plugin loaded the synthetic resource, it will cause all dojo.loadInit's to be executed, find all dojo.require's + // (either directly consequent to dojo.require or indirectly consequent to dojo.require[After]If or + // dojo.platformRequire, and finally cause loading of all dojo.required modules with the dojo/require plugin. Thus, + // when the dojo/loadInit plugin reports it has been loaded, all modules required by the given module are guaranteed + // loaded (but not executed). This then allows the module to execute it's code path without interupts, thereby + // following the synchronous code path. + + var extractResult, id, names = [], namesAsStrings = []; + if(buildDetectRe.test(text) || !(extractResult = extractLegacyApiApplications(text))){ + // buildDetectRe.test(text) => a built module, always AMD + // extractResult==0 => no sync API + return 0; + } + + // manufacture a synthetic module id that can never be a real mdule id (just like require does) + id = module.mid + "-*loadInit"; + + // construct the dojo/loadInit names vector which causes any relocated names to be defined as lexical variables under their not-relocated name + // the dojo/loadInit plugin assumes the first name in names is "dojo" + + for(var p in getModule("dojo", module).result.scopeMap){ + names.push(p); + namesAsStrings.push('"' + p + '"'); + } + + // rewrite the module as a synthetic dojo/loadInit plugin resource + the module expressed as an AMD module that depends on this synthetic resource + return "// xdomain rewrite of " + module.path + "\n" + + "define('" + id + "',{\n" + + "\tnames:" + dojo.toJson(names) + ",\n" + + "\tdef:function(" + names.join(",") + "){" + extractResult[1] + "}" + + "});\n\n" + + "define(" + dojo.toJson(names.concat(["dojo/loadInit!"+id])) + ", function(" + names.join(",") + "){\n" + extractResult[0] + "});"; + }, + + loaderVars = require.initSyncLoader(dojoRequirePlugin, checkDojoRequirePlugin, transformToAmd), + + sync = + loaderVars.sync, + + xd = + loaderVars.xd, + + arrived = + loaderVars.arrived, + + nonmodule = + loaderVars.nonmodule, + + executing = + loaderVars.executing, + + executed = + loaderVars.executed, + + syncExecStack = + loaderVars.syncExecStack, + + modules = + loaderVars.modules, + + execQ = + loaderVars.execQ, + + getModule = + loaderVars.getModule, + + injectModule = + loaderVars.injectModule, + + setArrived = + loaderVars.setArrived, + + signal = + loaderVars.signal, + + finishExec = + loaderVars.finishExec, + + execModule = + loaderVars.execModule, + + getLegacyMode = + loaderVars.getLegacyMode; + + dojo.provide = function(mid){ + var executingModule = syncExecStack[0], + module = lang.mixin(getModule(slashName(mid), require.module), { + executed:executing, + result:lang.getObject(mid, true) + }); + setArrived(module); + if(executingModule){ + (executingModule.provides || (executingModule.provides = [])).push(function(){ + module.result = lang.getObject(mid); + delete module.provides; + module.executed!==executed && finishExec(module); + }); + }// else dojo.provide called not consequent to loading; therefore, give up trying to publish module value to loader namespace + return module.result; + }; + + has.add("config-publishRequireResult", 1, 0, 0); + + dojo.require = function(moduleName, omitModuleCheck) { + // summary: + // loads a Javascript module from the appropriate URI + // + // moduleName: String + // module name to load, using periods for separators, + // e.g. "dojo.date.locale". Module paths are de-referenced by dojo's + // internal mapping of locations to names and are disambiguated by + // longest prefix. See `dojo.registerModulePath()` for details on + // registering new modules. + // + // omitModuleCheck: Boolean? + // if `true`, omitModuleCheck skips the step of ensuring that the + // loaded file actually defines the symbol it is referenced by. + // For example if it called as `dojo.require("a.b.c")` and the + // file located at `a/b/c.js` does not define an object `a.b.c`, + // and exception will be throws whereas no exception is raised + // when called as `dojo.require("a.b.c", true)` + // + // description: + // Modules are loaded via dojo.require by using one of two loaders: the normal loader + // and the xdomain loader. The xdomain loader is used when dojo was built with a + // custom build that specified loader=xdomain and the module lives on a modulePath + // that is a whole URL, with protocol and a domain. The versions of Dojo that are on + // the Google and AOL CDNs use the xdomain loader. + // + // If the module is loaded via the xdomain loader, it is an asynchronous load, since + // the module is added via a dynamically created script tag. This + // means that dojo.require() can return before the module has loaded. However, this + // should only happen in the case where you do dojo.require calls in the top-level + // HTML page, or if you purposely avoid the loader checking for dojo.require + // dependencies in your module by using a syntax like dojo["require"] to load the module. + // + // Sometimes it is useful to not have the loader detect the dojo.require calls in the + // module so that you can dynamically load the modules as a result of an action on the + // page, instead of right at module load time. + // + // Also, for script blocks in an HTML page, the loader does not pre-process them, so + // it does not know to download the modules before the dojo.require calls occur. + // + // So, in those two cases, when you want on-the-fly module loading or for script blocks + // in the HTML page, special care must be taken if the dojo.required code is loaded + // asynchronously. To make sure you can execute code that depends on the dojo.required + // modules, be sure to add the code that depends on the modules in a dojo.addOnLoad() + // callback. dojo.addOnLoad waits for all outstanding modules to finish loading before + // executing. + // + // This type of syntax works with both xdomain and normal loaders, so it is good + // practice to always use this idiom for on-the-fly code loading and in HTML script + // blocks. If at some point you change loaders and where the code is loaded from, + // it will all still work. + // + // More on how dojo.require + // `dojo.require("A.B")` first checks to see if symbol A.B is + // defined. If it is, it is simply returned (nothing to do). + // + // If it is not defined, it will look for `A/B.js` in the script root + // directory. + // + // `dojo.require` throws an exception if it cannot find a file + // to load, or if the symbol `A.B` is not defined after loading. + // + // It returns the object `A.B`, but note the caveats above about on-the-fly loading and + // HTML script blocks when the xdomain loader is loading a module. + // + // `dojo.require()` does nothing about importing symbols into + // the current namespace. It is presumed that the caller will + // take care of that. + // + // example: + // To use dojo.require in conjunction with dojo.ready: + // + // | dojo.require("foo"); + // | dojo.require("bar"); + // | dojo.addOnLoad(function(){ + // | //you can now safely do something with foo and bar + // | }); + // + // example: + // For example, to import all symbols into a local block, you might write: + // + // | with (dojo.require("A.B")) { + // | ... + // | } + // + // And to import just the leaf symbol to a local variable: + // + // | var B = dojo.require("A.B"); + // | ... + // + // returns: + // the required namespace object + function doRequire(mid, omitModuleCheck){ + var module = getModule(slashName(mid), require.module); + if(syncExecStack.length && syncExecStack[0].finish){ + // switched to async loading in the middle of evaluating a legacy module; stop + // applying dojo.require so the remaining dojo.requires are applied in order + syncExecStack[0].finish.push(mid); + return undefined; + } + + // recall module.executed has values {0, executing, executed}; therefore, truthy indicates executing or executed + if(module.executed){ + return module.result; + } + omitModuleCheck && (module.result = nonmodule); + + var currentMode = getLegacyMode(); + + // recall, in sync mode to inject is to *eval* the module text + // if the module is a legacy module, this is the same as executing + // but if the module is an AMD module, this means defining, not executing + injectModule(module); + // the inject may have changed the mode + currentMode = getLegacyMode(); + + // in sync mode to dojo.require is to execute + if(module.executed!==executed && module.injected===arrived){ + // the module was already here before injectModule was called probably finishing up a xdomain + // load, but maybe a module given to the loader directly rather than having the loader retrieve it + loaderVars.holdIdle(); + execModule(module); + loaderVars.releaseIdle(); + } + if(module.executed){ + return module.result; + } + + if(currentMode==sync){ + // the only way to get here is in sync mode and dojo.required a module that + // * was loaded async in the injectModule application a few lines up + // * was an AMD module that had deps that are being loaded async and therefore couldn't execute + if(module.cjs){ + // the module was an AMD module; unshift, not push, which causes the current traversal to be reattempted from the top + execQ.unshift(module); + }else{ + // the module was a legacy module + syncExecStack.length && (syncExecStack[0].finish= [mid]); + } + }else{ + // the loader wasn't in sync mode on entry; probably async mode; therefore, no expectation of getting + // the module value synchronously; make sure it gets executed though + execQ.push(module); + } + return undefined; + } + + var result = doRequire(moduleName, omitModuleCheck); + if(has("config-publishRequireResult") && !lang.exists(moduleName) && result!==undefined){ + lang.setObject(moduleName, result); + } + return result; + }; + + dojo.loadInit = function(f) { + f(); + }; + + dojo.registerModulePath = function(/*String*/moduleName, /*String*/prefix){ + // summary: + // Maps a module name to a path + // description: + // An unregistered module is given the default path of ../[module], + // relative to Dojo root. For example, module acme is mapped to + // ../acme. If you want to use a different module name, use + // dojo.registerModulePath. + // example: + // If your dojo.js is located at this location in the web root: + // | /myapp/js/dojo/dojo/dojo.js + // and your modules are located at: + // | /myapp/js/foo/bar.js + // | /myapp/js/foo/baz.js + // | /myapp/js/foo/thud/xyzzy.js + // Your application can tell Dojo to locate the "foo" namespace by calling: + // | dojo.registerModulePath("foo", "../../foo"); + // At which point you can then use dojo.require() to load the + // modules (assuming they provide() the same things which are + // required). The full code might be: + // | <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> + + var paths = {}; + paths[moduleName.replace(/\./g, "/")] = prefix; + require({paths:paths}); + }; + + dojo.platformRequire = function(/*Object*/modMap){ + // summary: + // require one or more modules based on which host environment + // Dojo is currently operating in + // description: + // This method takes a "map" of arrays which one can use to + // optionally load dojo modules. The map is indexed by the + // possible dojo.name_ values, with two additional values: + // "default" and "common". The items in the "default" array will + // be loaded if none of the other items have been choosen based on + // dojo.name_, set by your host environment. The items in the + // "common" array will *always* be loaded, regardless of which + // list is chosen. + // example: + // | dojo.platformRequire({ + // | browser: [ + // | "foo.sample", // simple module + // | "foo.test", + // | ["foo.bar.baz", true] // skip object check in _loadModule (dojo.require) + // | ], + // | default: [ "foo.sample._base" ], + // | common: [ "important.module.common" ] + // | }); + + var result = (modMap.common || []).concat(modMap[dojo._name] || modMap["default"] || []), + temp; + while(result.length){ + if(lang.isArray(temp = result.shift())){ + dojo.require.apply(dojo, temp); + }else{ + dojo.require(temp); + } + } + }; + + dojo.requireIf = dojo.requireAfterIf = function(/*Boolean*/ condition, /*String*/ moduleName, /*Boolean?*/omitModuleCheck){ + // summary: + // If the condition is true then call `dojo.require()` for the specified + // resource + // + // example: + // | dojo.requireIf(dojo.isBrowser, "my.special.Module"); + + if(condition){ + dojo.require(moduleName, omitModuleCheck); + } + }; + + dojo.requireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale){ + require(["../i18n"], function(i18n){ + i18n.getLocalization(moduleName, bundleName, locale); + }); + }; + + return { + extractLegacyApiApplications:extractLegacyApiApplications, + require:loaderVars.dojoRequirePlugin, + loadInit:dojoLoadInitPlugin + }; +}); diff --git a/lib/dojo/_base/query-sizzle.js b/lib/dojo/_base/query-sizzle.js deleted file mode 100644 index aad4e824d..000000000 --- a/lib/dojo/_base/query-sizzle.js +++ /dev/null @@ -1,877 +0,0 @@ -/* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. - Available via Academic Free License >= 2.1 OR the modified BSD license. - see: http://dojotoolkit.org/license for details -*/ - - -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; -/*! - * Sizzle CSS Selector Engine - v0.9 - * Copyright 2009, John Resig - * Redistributed with the Dojo Toolkit under the terms of the New BSD license. - * More information: http://sizzlejs.com/ - * - * This version from github, dated 1/23/2009, commit: e374a73bbffc12ec3b5f252e7f76e593c508dfa5 - * Modified for dojo loader, and to fit into dojo namespace. This was done by passing - * dojo object to anonymous function, then assigning Sizzle to dojo.Sizzle instead of window.Sizzle. - * Then an alias for dojo.query and dojo._filterQueryResult(). dojo.psuedos is not mapped. - * Finally, dojo.provide/require added. - */ - -var startDojoMappings= function(dojo) { - //Start Dojo mappings. - dojo.query = function(/*String*/ query, /*String|DOMNode?*/ root, /*Function?*/listCtor){ - listCtor = listCtor || dojo.NodeList; - - if(!query){ - return new listCtor(); - } - - if(query.constructor == listCtor){ - return query; - } - if(!dojo.isString(query)){ - return new listCtor(query); // dojo.NodeList - } - if(dojo.isString(root)){ - root = dojo.byId(root); - if(!root){ return new listCtor(); } - } - - return dojo.Sizzle(query, root, new listCtor()); - }; - - dojo._filterQueryResult = function(nodeList, simpleFilter){ - return dojo.Sizzle.filter(simpleFilter, nodeList); - }; -}; - -//Main Sizzle code follows... -//ns argument, added for dojo, used at the end of the file. -var defineSizzle= function(ns){ - -var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|[^[\]]+)+\]|\\.|[^ >+~,(\[]+)+|[>+~])(\s*,\s*)?/g, - done = 0, - toString = Object.prototype.toString; - -var Sizzle = function(selector, context, results, seed) { - results = results || []; - context = context || document; - - if ( context.nodeType !== 1 && context.nodeType !== 9 ) - return []; - - if ( !selector || typeof selector !== "string" ) { - return results; - } - - var parts = [], m, set, checkSet, check, mode, extra, prune = true; - - // Reset the position of the chunker regexp (start from head) - chunker.lastIndex = 0; - - while ( (m = chunker.exec(selector)) !== null ) { - parts.push( m[1] ); - - if ( m[2] ) { - extra = RegExp.rightContext; - break; - } - } - - if ( parts.length > 1 && Expr.match.POS.exec( selector ) ) { - if ( parts.length === 2 && Expr.relative[ parts[0] ] ) { - var later = "", match; - - // Position selectors must be done after the filter - while ( (match = Expr.match.POS.exec( selector )) ) { - later += match[0]; - selector = selector.replace( Expr.match.POS, "" ); - } - - set = Sizzle.filter( later, Sizzle( selector, context ) ); - } else { - set = Expr.relative[ parts[0] ] ? - [ context ] : - Sizzle( parts.shift(), context ); - - while ( parts.length ) { - var tmpSet = []; - - selector = parts.shift(); - if ( Expr.relative[ selector ] ) - selector += parts.shift(); - - for ( var i = 0, l = set.length; i < l; i++ ) { - Sizzle( selector, set[i], tmpSet ); - } - - set = tmpSet; - } - } - } else { - var ret = seed ? - { expr: parts.pop(), set: makeArray(seed) } : - Sizzle.find( parts.pop(), parts.length === 1 && context.parentNode ? context.parentNode : context ); - set = Sizzle.filter( ret.expr, ret.set ); - - if ( parts.length > 0 ) { - checkSet = makeArray(set); - } else { - prune = false; - } - - while ( parts.length ) { - var cur = parts.pop(), pop = cur; - - if ( !Expr.relative[ cur ] ) { - cur = ""; - } else { - pop = parts.pop(); - } - - if ( pop == null ) { - pop = context; - } - - Expr.relative[ cur ]( checkSet, pop ); - } - } - - if ( !checkSet ) { - checkSet = set; - } - - if ( !checkSet ) { - throw "Syntax error, unrecognized expression: " + (cur || selector); - } - - if ( toString.call(checkSet) === "[object Array]" ) { - if ( !prune ) { - results.push.apply( results, checkSet ); - } else if ( context.nodeType === 1 ) { - for ( var i = 0; checkSet[i] != null; i++ ) { - if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && contains(context, checkSet[i])) ) { - results.push( set[i] ); - } - } - } else { - for ( var i = 0; checkSet[i] != null; i++ ) { - if ( checkSet[i] && checkSet[i].nodeType === 1 ) { - results.push( set[i] ); - } - } - } - } else { - makeArray( checkSet, results ); - } - - if ( extra ) { - Sizzle( extra, context, results, seed ); - } - - return results; -}; - -Sizzle.matches = function(expr, set){ - return Sizzle(expr, null, null, set); -}; - -Sizzle.find = function(expr, context){ - var set, match; - - if ( !expr ) { - return []; - } - - for ( var i = 0, l = Expr.order.length; i < l; i++ ) { - var type = Expr.order[i], match; - - if ( (match = Expr.match[ type ].exec( expr )) ) { - var left = RegExp.leftContext; - - if ( left.substr( left.length - 1 ) !== "\\" ) { - match[1] = (match[1] || "").replace(/\\/g, ""); - set = Expr.find[ type ]( match, context ); - if ( set != null ) { - expr = expr.replace( Expr.match[ type ], "" ); - break; - } - } - } - } - - if ( !set ) { - set = context.getElementsByTagName("*"); - } - - return {set: set, expr: expr}; -}; - -Sizzle.filter = function(expr, set, inplace, not){ - var old = expr, result = [], curLoop = set, match, anyFound; - - while ( expr && set.length ) { - for ( var type in Expr.filter ) { - if ( (match = Expr.match[ type ].exec( expr )) != null ) { - var filter = Expr.filter[ type ], goodArray = null, goodPos = 0, found, item; - anyFound = false; - - if ( curLoop == result ) { - result = []; - } - - if ( Expr.preFilter[ type ] ) { - match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not ); - - if ( !match ) { - anyFound = found = true; - } else if ( match[0] === true ) { - goodArray = []; - var last = null, elem; - for ( var i = 0; (elem = curLoop[i]) !== undefined; i++ ) { - if ( elem && last !== elem ) { - goodArray.push( elem ); - last = elem; - } - } - } - } - - if ( match ) { - for ( var i = 0; (item = curLoop[i]) !== undefined; i++ ) { - if ( item ) { - if ( goodArray && item != goodArray[goodPos] ) { - goodPos++; - } - - found = filter( item, match, goodPos, goodArray ); - var pass = not ^ !!found; - - if ( inplace && found != null ) { - if ( pass ) { - anyFound = true; - } else { - curLoop[i] = false; - } - } else if ( pass ) { - result.push( item ); - anyFound = true; - } - } - } - } - - if ( found !== undefined ) { - if ( !inplace ) { - curLoop = result; - } - - expr = expr.replace( Expr.match[ type ], "" ); - - if ( !anyFound ) { - return []; - } - - break; - } - } - } - - expr = expr.replace(/\s*,\s*/, ""); - - // Improper expression - if ( expr == old ) { - if ( anyFound == null ) { - throw "Syntax error, unrecognized expression: " + expr; - } else { - break; - } - } - - old = expr; - } - - return curLoop; -}; - -var Expr = Sizzle.selectors = { - order: [ "ID", "NAME", "TAG" ], - match: { - ID: /#((?:[\w\u0128-\uFFFF_-]|\\.)+)/, - CLASS: /\.((?:[\w\u0128-\uFFFF_-]|\\.)+)/, - NAME: /\[name=['"]*((?:[\w\u0128-\uFFFF_-]|\\.)+)['"]*\]/, - ATTR: /\[((?:[\w\u0128-\uFFFF_-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\]/, - TAG: /^((?:[\w\u0128-\uFFFF\*_-]|\\.)+)/, - CHILD: /:(only|nth|last|first)-child\(?(even|odd|[\dn+-]*)\)?/, - POS: /:(nth|eq|gt|lt|first|last|even|odd)\(?(\d*)\)?(?:[^-]|$)/, - PSEUDO: /:((?:[\w\u0128-\uFFFF_-]|\\.)+)(?:\((['"]*)((?:\([^\)]+\)|[^\2\(\)]*)+)\2\))?/ - }, - attrMap: { - "class": "className", - "for": "htmlFor" - }, - relative: { - "+": function(checkSet, part){ - for ( var i = 0, l = checkSet.length; i < l; i++ ) { - var elem = checkSet[i]; - if ( elem ) { - var cur = elem.previousSibling; - while ( cur && cur.nodeType !== 1 ) { - cur = cur.previousSibling; - } - checkSet[i] = typeof part === "string" ? - cur || false : - cur === part; - } - } - - if ( typeof part === "string" ) { - Sizzle.filter( part, checkSet, true ); - } - }, - ">": function(checkSet, part){ - if ( typeof part === "string" && !/\W/.test(part) ) { - part = part.toUpperCase(); - - for ( var i = 0, l = checkSet.length; i < l; i++ ) { - var elem = checkSet[i]; - if ( elem ) { - var parent = elem.parentNode; - checkSet[i] = parent.nodeName === part ? parent : false; - } - } - } else { - for ( var i = 0, l = checkSet.length; i < l; i++ ) { - var elem = checkSet[i]; - if ( elem ) { - checkSet[i] = typeof part === "string" ? - elem.parentNode : - elem.parentNode === part; - } - } - - if ( typeof part === "string" ) { - Sizzle.filter( part, checkSet, true ); - } - } - }, - "": function(checkSet, part){ - var doneName = "done" + (done++), checkFn = dirCheck; - - if ( !part.match(/\W/) ) { - var nodeCheck = part = part.toUpperCase(); - checkFn = dirNodeCheck; - } - - checkFn("parentNode", part, doneName, checkSet, nodeCheck); - }, - "~": function(checkSet, part){ - var doneName = "done" + (done++), checkFn = dirCheck; - - if ( typeof part === "string" && !part.match(/\W/) ) { - var nodeCheck = part = part.toUpperCase(); - checkFn = dirNodeCheck; - } - - checkFn("previousSibling", part, doneName, checkSet, nodeCheck); - } - }, - find: { - ID: function(match, context){ - if ( context.getElementById ) { - var m = context.getElementById(match[1]); - return m ? [m] : []; - } - }, - NAME: function(match, context){ - return context.getElementsByName ? context.getElementsByName(match[1]) : null; - }, - TAG: function(match, context){ - return context.getElementsByTagName(match[1]); - } - }, - preFilter: { - CLASS: function(match, curLoop, inplace, result, not){ - match = " " + match[1].replace(/\\/g, "") + " "; - - for ( var i = 0; curLoop[i]; i++ ) { - if ( not ^ (" " + curLoop[i].className + " ").indexOf(match) >= 0 ) { - if ( !inplace ) - result.push( curLoop[i] ); - } else if ( inplace ) { - curLoop[i] = false; - } - } - - return false; - }, - ID: function(match){ - return match[1]; - }, - TAG: function(match){ - return match[1].toUpperCase(); - }, - CHILD: function(match){ - if ( match[1] == "nth" ) { - // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6' - var test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec( - match[2] == "even" && "2n" || match[2] == "odd" && "2n+1" || - !/\D/.test( match[2] ) && "0n+" + match[2] || match[2]); - - // calculate the numbers (first)n+(last) including if they are negative - match[2] = (test[1] + (test[2] || 1)) - 0; - match[3] = test[3] - 0; - } - - // TODO: Move to normal caching system - match[0] = "done" + (done++); - - return match; - }, - ATTR: function(match){ - var name = match[1]; - - if ( Expr.attrMap[name] ) { - match[1] = Expr.attrMap[name]; - } - - if ( match[2] === "~=" ) { - match[4] = " " + match[4] + " "; - } - - return match; - }, - PSEUDO: function(match, curLoop, inplace, result, not){ - if ( match[1] === "not" ) { - // If we're dealing with a complex expression, or a simple one - if ( match[3].match(chunker).length > 1 ) { - match[3] = Sizzle(match[3], null, null, curLoop); - } else { - var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not); - if ( !inplace ) { - result.push.apply( result, ret ); - } - return false; - } - } - - return match; - }, - POS: function(match){ - match.unshift( true ); - return match; - } - }, - filters: { - enabled: function(elem){ - return elem.disabled === false && elem.type !== "hidden"; - }, - disabled: function(elem){ - return elem.disabled === true; - }, - checked: function(elem){ - return elem.checked === true; - }, - selected: function(elem){ - // Accessing this property makes selected-by-default - // options in Safari work properly - elem.parentNode.selectedIndex; - return elem.selected === true; - }, - parent: function(elem){ - return !!elem.firstChild; - }, - empty: function(elem){ - return !elem.firstChild; - }, - has: function(elem, i, match){ - return !!Sizzle( match[3], elem ).length; - }, - header: function(elem){ - return /h\d/i.test( elem.nodeName ); - }, - text: function(elem){ - return "text" === elem.type; - }, - radio: function(elem){ - return "radio" === elem.type; - }, - checkbox: function(elem){ - return "checkbox" === elem.type; - }, - file: function(elem){ - return "file" === elem.type; - }, - password: function(elem){ - return "password" === elem.type; - }, - submit: function(elem){ - return "submit" === elem.type; - }, - image: function(elem){ - return "image" === elem.type; - }, - reset: function(elem){ - return "reset" === elem.type; - }, - button: function(elem){ - return "button" === elem.type || elem.nodeName.toUpperCase() === "BUTTON"; - }, - input: function(elem){ - return /input|select|textarea|button/i.test(elem.nodeName); - } - }, - setFilters: { - first: function(elem, i){ - return i === 0; - }, - last: function(elem, i, match, array){ - return i === array.length - 1; - }, - even: function(elem, i){ - return i % 2 === 0; - }, - odd: function(elem, i){ - return i % 2 === 1; - }, - lt: function(elem, i, match){ - return i < match[3] - 0; - }, - gt: function(elem, i, match){ - return i > match[3] - 0; - }, - nth: function(elem, i, match){ - return match[3] - 0 == i; - }, - eq: function(elem, i, match){ - return match[3] - 0 == i; - } - }, - filter: { - CHILD: function(elem, match){ - var type = match[1], parent = elem.parentNode; - - var doneName = match[0]; - - if ( parent && !parent[ doneName ] ) { - var count = 1; - - for ( var node = parent.firstChild; node; node = node.nextSibling ) { - if ( node.nodeType == 1 ) { - node.nodeIndex = count++; - } - } - - parent[ doneName ] = count - 1; - } - - if ( type == "first" ) { - return elem.nodeIndex == 1; - } else if ( type == "last" ) { - return elem.nodeIndex == parent[ doneName ]; - } else if ( type == "only" ) { - return parent[ doneName ] == 1; - } else if ( type == "nth" ) { - var add = false, first = match[2], last = match[3]; - - if ( first == 1 && last == 0 ) { - return true; - } - - if ( first == 0 ) { - if ( elem.nodeIndex == last ) { - add = true; - } - } else if ( (elem.nodeIndex - last) % first == 0 && (elem.nodeIndex - last) / first >= 0 ) { - add = true; - } - - return add; - } - }, - PSEUDO: function(elem, match, i, array){ - var name = match[1], filter = Expr.filters[ name ]; - - if ( filter ) { - return filter( elem, i, match, array ); - } else if ( name === "contains" ) { - return (elem.textContent || elem.innerText || "").indexOf(match[3]) >= 0; - } else if ( name === "not" ) { - var not = match[3]; - - for ( var i = 0, l = not.length; i < l; i++ ) { - if ( not[i] === elem ) { - return false; - } - } - - return true; - } - }, - ID: function(elem, match){ - return elem.nodeType === 1 && elem.getAttribute("id") === match; - }, - TAG: function(elem, match){ - return (match === "*" && elem.nodeType === 1) || elem.nodeName === match; - }, - CLASS: function(elem, match){ - return match.test( elem.className ); - }, - ATTR: function(elem, match){ - var result = elem[ match[1] ] || elem.getAttribute( match[1] ), value = result + "", type = match[2], check = match[4]; - return result == null ? - false : - type === "=" ? - value === check : - type === "*=" ? - value.indexOf(check) >= 0 : - type === "~=" ? - (" " + value + " ").indexOf(check) >= 0 : - !match[4] ? - result : - type === "!=" ? - value != check : - type === "^=" ? - value.indexOf(check) === 0 : - type === "$=" ? - value.substr(value.length - check.length) === check : - type === "|=" ? - value === check || value.substr(0, check.length + 1) === check + "-" : - false; - }, - POS: function(elem, match, i, array){ - var name = match[2], filter = Expr.setFilters[ name ]; - - if ( filter ) { - return filter( elem, i, match, array ); - } - } - } -}; - -for ( var type in Expr.match ) { - Expr.match[ type ] = RegExp( Expr.match[ type ].source + /(?![^\[]*\])(?![^\(]*\))/.source ); -} - -var makeArray = function(array, results) { - array = Array.prototype.slice.call( array ); - - if ( results ) { - results.push.apply( results, array ); - return results; - } - - return array; -}; - -// Perform a simple check to determine if the browser is capable of -// converting a NodeList to an array using builtin methods. -try { - Array.prototype.slice.call( document.documentElement.childNodes ); - -// Provide a fallback method if it does not work -} catch(e){ - makeArray = function(array, results) { - var ret = results || []; - - if ( toString.call(array) === "[object Array]" ) { - Array.prototype.push.apply( ret, array ); - } else { - if ( typeof array.length === "number" ) { - for ( var i = 0, l = array.length; i < l; i++ ) { - ret.push( array[i] ); - } - } else { - for ( var i = 0; array[i]; i++ ) { - ret.push( array[i] ); - } - } - } - - return ret; - }; -} - -// Check to see if the browser returns elements by name when -// querying by getElementById (and provide a workaround) -(function(){ - // We're going to inject a fake input element with a specified name - var form = document.createElement("form"), - id = "script" + (new Date).getTime(); - form.innerHTML = "<input name='" + id + "'/>"; - - // Inject it into the root element, check its status, and remove it quickly - var root = document.documentElement; - root.insertBefore( form, root.firstChild ); - - // The workaround has to do additional checks after a getElementById - // Which slows things down for other browsers (hence the branching) - if ( !!document.getElementById( id ) ) { - Expr.find.ID = function(match, context){ - if ( context.getElementById ) { - var m = context.getElementById(match[1]); - return m ? m.id === match[1] || m.getAttributeNode && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : []; - } - }; - - Expr.filter.ID = function(elem, match){ - var node = elem.getAttributeNode && elem.getAttributeNode("id"); - return elem.nodeType === 1 && node && node.nodeValue === match; - }; - } - - root.removeChild( form ); -})(); - -// Check to see if the browser returns only elements -// when doing getElementsByTagName("*") -(function(){ - // Create a fake element - var div = document.createElement("div"); - div.appendChild( document.createComment("") ); - - // Make sure no comments are found - if ( div.getElementsByTagName("*").length > 0 ) { - Expr.find.TAG = function(match, context){ - var results = context.getElementsByTagName(match[1]); - - // Filter out possible comments - if ( match[1] === "*" ) { - var tmp = []; - - for ( var i = 0; results[i]; i++ ) { - if ( results[i].nodeType === 1 ) { - tmp.push( results[i] ); - } - } - - results = tmp; - } - - return results; - }; - } -})(); - -if ( document.querySelectorAll ) (function(){ - var oldSizzle = Sizzle; - - Sizzle = function(query, context, extra, seed){ - context = context || document; - - if ( !seed && context.nodeType === 9 ) { - try { - return makeArray( context.querySelectorAll(query), extra ); - } catch(e){} - } - - return oldSizzle(query, context, extra, seed); - }; - - Sizzle.find = oldSizzle.find; - Sizzle.filter = oldSizzle.filter; - Sizzle.selectors = oldSizzle.selectors; - Sizzle.matches = oldSizzle.matches; -})(); - -if ( document.documentElement.getElementsByClassName ) { - Expr.order.splice(1, 0, "CLASS"); - Expr.find.CLASS = function(match, context) { - return context.getElementsByClassName(match[1]); - }; -} - -function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck ) { - for ( var i = 0, l = checkSet.length; i < l; i++ ) { - var elem = checkSet[i]; - if ( elem ) { - elem = elem[dir]; - var match = false; - - while ( elem && elem.nodeType ) { - var done = elem[doneName]; - if ( done ) { - match = checkSet[ done ]; - break; - } - - if ( elem.nodeType === 1 ) - elem[doneName] = i; - - if ( elem.nodeName === cur ) { - match = elem; - break; - } - - elem = elem[dir]; - } - - checkSet[i] = match; - } - } -} - -function dirCheck( dir, cur, doneName, checkSet, nodeCheck ) { - for ( var i = 0, l = checkSet.length; i < l; i++ ) { - var elem = checkSet[i]; - if ( elem ) { - elem = elem[dir]; - var match = false; - - while ( elem && elem.nodeType ) { - if ( elem[doneName] ) { - match = checkSet[ elem[doneName] ]; - break; - } - - if ( elem.nodeType === 1 ) { - elem[doneName] = i; - - if ( typeof cur !== "string" ) { - if ( elem === cur ) { - match = true; - break; - } - - } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) { - match = elem; - break; - } - } - - elem = elem[dir]; - } - - checkSet[i] = match; - } - } -} - -var contains = document.compareDocumentPosition ? function(a, b){ - return a.compareDocumentPosition(b) & 16; -} : function(a, b){ - return a !== b && (a.contains ? a.contains(b) : true); -}; - -// EXPOSE - -ns.Sizzle = Sizzle; - -}; - -if (this["dojo"]) { - var defined= 0; - if (!defined) { - // must be in a built version that stripped out the define above - dojo.provide("dojo._base.query"); - dojo.require("dojo._base.NodeList"); - defineSizzle(dojo); - } // else must be in a source version (or a build that likes define) -} else { - defineSizzle(window); -} - -} diff --git a/lib/dojo/_base/query.js b/lib/dojo/_base/query.js index 59411952f..f6ee04bc8 100644 --- a/lib/dojo/_base/query.js +++ b/lib/dojo/_base/query.js @@ -4,1598 +4,5 @@ see: http://dojotoolkit.org/license for details */ - -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; -(function(){ - -/* - 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) - - native (FF3.1+, Safari 3.1+, IE 8+) - 3.) tokenize and convert to executable "query dispatcher" - - this is where the lion's share of the complexity in the - system lies. In the DOM version, the query dispatcher is - assembled as a chain of "yes/no" test functions pertaining to - a section of a simple query statement (".blah:nth-child(odd)" - but not "div div", which is 2 simple statements). Individual - statement dispatchers are cached (to prevent re-definition) - as are entire dispatch chains (to make re-execution of the - same query fast) - 4.) the resulting query dispatcher is called in the passed scope - (by default the top-level document) - - for DOM queries, this results in a recursive, top-down - evaluation of nodes based on each simple query section - - for native implementations, this may mean working around spec - bugs. So be it. - 5.) matched nodes are pruned to ensure they are unique (if necessary) -*/ - -var defineQuery= function(d){ - // define everything in a closure for compressability reasons. "d" is an - // alias to "dojo" (or the toolkit alias object, e.g., "acme"). - - //////////////////////////////////////////////////////////////////////// - // Toolkit aliases - //////////////////////////////////////////////////////////////////////// - - // if you are extracting dojo.query for use in your own system, you will - // need to provide these methods and properties. No other porting should be - // necessary, save for configuring the system to use a class other than - // dojo.NodeList as the return instance instantiator - var trim = d.trim; - var each = d.forEach; - // d.isIE; // float - // d.isSafari; // float - // d.isOpera; // float - // d.isWebKit; // float - // d.doc ; // document element - var qlc = (d._NodeListCtor = d.NodeList); - - var getDoc = function(){ return d.doc; }; - // NOTE(alex): the spec is idiotic. CSS queries should ALWAYS be case-sensitive, but nooooooo - var cssCaseBug = ((d.isWebKit||d.isMozilla) && ((getDoc().compatMode) == "BackCompat")); - - //////////////////////////////////////////////////////////////////////// - // Global utilities - //////////////////////////////////////////////////////////////////////// - - - // on browsers that support the "children" collection we can avoid a lot of - // iteration on chaff (non-element) nodes. - // why. - var childNodesName = !!getDoc().firstChild["children"] ? "children" : "childNodes"; - - var specials = ">~+"; - - // global thunk to determine whether we should treat the current query as - // case sensitive or not. This switch is flipped by the query evaluator - // based on the document passed as the context to search. - var caseSensitive = false; - - // how high? - var yesman = function(){ return true; }; - - //////////////////////////////////////////////////////////////////////// - // Tokenizer - //////////////////////////////////////////////////////////////////////// - - var getQueryParts = function(query){ - // summary: - // state machine for query tokenization - // description: - // instead of using a brittle and slow regex-based CSS parser, - // dojo.query implements an AST-style query representation. This - // representation is only generated once per query. For example, - // the same query run multiple times or under different root nodes - // does not re-parse the selector expression but instead uses the - // cached data structure. The state machine implemented here - // terminates on the last " " (space) character and returns an - // ordered array of query component structures (or "parts"). Each - // part represents an operator or a simple CSS filtering - // expression. The structure for parts is documented in the code - // below. - - - // NOTE: - // this code is designed to run fast and compress well. Sacrifices - // to readability and maintainability have been made. Your best - // bet when hacking the tokenizer is to put The Donnas on *really* - // loud (may we recommend their "Spend The Night" release?) and - // just assume you're gonna make mistakes. Keep the unit tests - // open and run them frequently. Knowing is half the battle ;-) - if(specials.indexOf(query.slice(-1)) >= 0){ - // if we end with a ">", "+", or "~", that means we're implicitly - // searching all children, so make it explicit - query += " * " - }else{ - // if you have not provided a terminator, one will be provided for - // you... - query += " "; - } - - var ts = function(/*Integer*/ s, /*Integer*/ e){ - // trim and slice. - - // take an index to start a string slice from and an end position - // and return a trimmed copy of that sub-string - return trim(query.slice(s, e)); - } - - // the overall data graph of the full query, as represented by queryPart objects - var queryParts = []; - - - // state keeping vars - var inBrackets = -1, inParens = -1, inMatchFor = -1, - inPseudo = -1, inClass = -1, inId = -1, inTag = -1, - lc = "", cc = "", pStart; - - // iteration vars - var x = 0, // index in the query - ql = query.length, - currentPart = null, // data structure representing the entire clause - _cp = null; // the current pseudo or attr matcher - - // several temporary variables are assigned to this structure during a - // potential sub-expression match: - // attr: - // a string representing the current full attribute match in a - // bracket expression - // type: - // if there's an operator in a bracket expression, this is - // used to keep track of it - // value: - // the internals of parenthetical expression for a pseudo. for - // :nth-child(2n+1), value might be "2n+1" - - var endTag = function(){ - // called when the tokenizer hits the end of a particular tag name. - // Re-sets state variables for tag matching and sets up the matcher - // to handle the next type of token (tag or operator). - if(inTag >= 0){ - var tv = (inTag == x) ? null : ts(inTag, x); // .toLowerCase(); - currentPart[ (specials.indexOf(tv) < 0) ? "tag" : "oper" ] = tv; - inTag = -1; - } - } - - var endId = function(){ - // called when the tokenizer might be at the end of an ID portion of a match - if(inId >= 0){ - currentPart.id = ts(inId, x).replace(/\\/g, ""); - inId = -1; - } - } - - var endClass = function(){ - // called when the tokenizer might be at the end of a class name - // match. CSS allows for multiple classes, so we augment the - // current item with another class in its list - if(inClass >= 0){ - currentPart.classes.push(ts(inClass+1, x).replace(/\\/g, "")); - inClass = -1; - } - } - - var endAll = function(){ - // at the end of a simple fragment, so wall off the matches - endId(); endTag(); endClass(); - } - - var endPart = function(){ - endAll(); - if(inPseudo >= 0){ - currentPart.pseudos.push({ name: ts(inPseudo+1, x) }); - } - // hint to the selector engine to tell it whether or not it - // needs to do any iteration. Many simple selectors don't, and - // we can avoid significant construction-time work by advising - // the system to skip them - currentPart.loops = ( - currentPart.pseudos.length || - currentPart.attrs.length || - currentPart.classes.length ); - - currentPart.oquery = currentPart.query = ts(pStart, x); // save the full expression as a string - - - // otag/tag are hints to suggest to the system whether or not - // it's an operator or a tag. We save a copy of otag since the - // tag name is cast to upper-case in regular HTML matches. The - // system has a global switch to figure out if the current - // expression needs to be case sensitive or not and it will use - // otag or tag accordingly - currentPart.otag = currentPart.tag = (currentPart["oper"]) ? null : (currentPart.tag || "*"); - - if(currentPart.tag){ - // if we're in a case-insensitive HTML doc, we likely want - // the toUpperCase when matching on element.tagName. If we - // do it here, we can skip the string op per node - // comparison - currentPart.tag = currentPart.tag.toUpperCase(); - } - - // add the part to the list - if(queryParts.length && (queryParts[queryParts.length-1].oper)){ - // operators are always infix, so we remove them from the - // list and attach them to the next match. The evaluator is - // responsible for sorting out how to handle them. - currentPart.infixOper = queryParts.pop(); - currentPart.query = currentPart.infixOper.query + " " + currentPart.query; - /* - console.debug( "swapping out the infix", - currentPart.infixOper, - "and attaching it to", - currentPart); - */ - } - queryParts.push(currentPart); - - currentPart = null; - } - - // iterate over the query, character by character, building up a - // list of query part objects - for(; lc=cc, cc=query.charAt(x), x < ql; x++){ - // cc: the current character in the match - // lc: the last character (if any) - - // someone is trying to escape something, so don't try to match any - // fragments. We assume we're inside a literal. - if(lc == "\\"){ continue; } - if(!currentPart){ // a part was just ended or none has yet been created - // NOTE: I hate all this alloc, but it's shorter than writing tons of if's - pStart = x; - // rules describe full CSS sub-expressions, like: - // #someId - // .className:first-child - // but not: - // thinger > div.howdy[type=thinger] - // the indidual components of the previous query would be - // split into 3 parts that would be represented a structure - // like: - // [ - // { - // query: "thinger", - // tag: "thinger", - // }, - // { - // query: "div.howdy[type=thinger]", - // classes: ["howdy"], - // infixOper: { - // query: ">", - // oper: ">", - // } - // }, - // ] - currentPart = { - query: null, // the full text of the part's rule - pseudos: [], // CSS supports multiple pseud-class matches in a single rule - attrs: [], // CSS supports multi-attribute match, so we need an array - classes: [], // class matches may be additive, e.g.: .thinger.blah.howdy - tag: null, // only one tag... - oper: null, // ...or operator per component. Note that these wind up being exclusive. - id: null, // the id component of a rule - getTag: function(){ - return (caseSensitive) ? this.otag : this.tag; - } - }; - - // if we don't have a part, we assume we're going to start at - // the beginning of a match, which should be a tag name. This - // might fault a little later on, but we detect that and this - // iteration will still be fine. - inTag = x; - } - - if(inBrackets >= 0){ - // look for a the close first - if(cc == "]"){ // if we're in a [...] clause and we end, do assignment - if(!_cp.attr){ - // no attribute match was previously begun, so we - // assume this is an attribute existence match in the - // form of [someAttributeName] - _cp.attr = ts(inBrackets+1, x); - }else{ - // we had an attribute already, so we know that we're - // matching some sort of value, as in [attrName=howdy] - _cp.matchFor = ts((inMatchFor||inBrackets+1), x); - } - var cmf = _cp.matchFor; - if(cmf){ - // try to strip quotes from the matchFor value. We want - // [attrName=howdy] to match the same - // as [attrName = 'howdy' ] - if( (cmf.charAt(0) == '"') || (cmf.charAt(0) == "'") ){ - _cp.matchFor = cmf.slice(1, -1); - } - } - // end the attribute by adding it to the list of attributes. - currentPart.attrs.push(_cp); - _cp = null; // necessary? - inBrackets = inMatchFor = -1; - }else if(cc == "="){ - // if the last char was an operator prefix, make sure we - // record it along with the "=" operator. - var addToCc = ("|~^$*".indexOf(lc) >=0 ) ? lc : ""; - _cp.type = addToCc+cc; - _cp.attr = ts(inBrackets+1, x-addToCc.length); - inMatchFor = x+1; - } - // now look for other clause parts - }else if(inParens >= 0){ - // if we're in a parenthetical expression, we need to figure - // out if it's attached to a pseudo-selector rule like - // :nth-child(1) - if(cc == ")"){ - if(inPseudo >= 0){ - _cp.value = ts(inParens+1, x); - } - inPseudo = inParens = -1; - } - }else if(cc == "#"){ - // start of an ID match - endAll(); - inId = x+1; - }else if(cc == "."){ - // start of a class match - endAll(); - inClass = x; - }else if(cc == ":"){ - // start of a pseudo-selector match - endAll(); - inPseudo = x; - }else if(cc == "["){ - // start of an attribute match. - endAll(); - inBrackets = x; - // provide a new structure for the attribute match to fill-in - _cp = { - /*===== - attr: null, type: null, matchFor: null - =====*/ - }; - }else if(cc == "("){ - // we really only care if we've entered a parenthetical - // expression if we're already inside a pseudo-selector match - if(inPseudo >= 0){ - // provide a new structure for the pseudo match to fill-in - _cp = { - name: ts(inPseudo+1, x), - value: null - } - currentPart.pseudos.push(_cp); - } - inParens = x; - }else if( - (cc == " ") && - // if it's a space char and the last char is too, consume the - // current one without doing more work - (lc != cc) - ){ - endPart(); - } - } - return queryParts; - }; - - - //////////////////////////////////////////////////////////////////////// - // DOM query infrastructure - //////////////////////////////////////////////////////////////////////// - - var agree = function(first, second){ - // the basic building block of the yes/no chaining system. agree(f1, - // f2) generates a new function which returns the boolean results of - // both of the passed functions to a single logical-anded result. If - // either are not passed, the other is used exclusively. - if(!first){ return second; } - if(!second){ return first; } - - return function(){ - return first.apply(window, arguments) && second.apply(window, arguments); - } - }; - - var getArr = function(i, arr){ - // helps us avoid array alloc when we don't need it - var r = arr||[]; // FIXME: should this be 'new d._NodeListCtor()' ? - if(i){ r.push(i); } - return r; - }; - - var _isElement = function(n){ return (1 == n.nodeType); }; - - // FIXME: need to coalesce _getAttr with defaultGetter - var blank = ""; - var _getAttr = function(elem, attr){ - if(!elem){ return blank; } - if(attr == "class"){ - return elem.className || blank; - } - if(attr == "for"){ - return elem.htmlFor || blank; - } - if(attr == "style"){ - return elem.style.cssText || blank; - } - return (caseSensitive ? elem.getAttribute(attr) : elem.getAttribute(attr, 2)) || blank; - }; - - var attrs = { - "*=": function(attr, value){ - return function(elem){ - // E[foo*="bar"] - // an E element whose "foo" attribute value contains - // the substring "bar" - return (_getAttr(elem, attr).indexOf(value)>=0); - } - }, - "^=": function(attr, value){ - // E[foo^="bar"] - // an E element whose "foo" attribute value begins exactly - // with the string "bar" - return function(elem){ - return (_getAttr(elem, attr).indexOf(value)==0); - } - }, - "$=": function(attr, value){ - // E[foo$="bar"] - // an E element whose "foo" attribute value ends exactly - // with the string "bar" - 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 = " "+_getAttr(elem, attr); - return ( - (ea == value) || - (ea.indexOf(valueDash)==0) - ); - } - }, - "=": function(attr, value){ - return function(elem){ - return (_getAttr(elem, attr) == value); - } - } - }; - - // avoid testing for node type if we can. Defining this in the negative - // here to avoid negation in the fast path. - var _noNES = (typeof getDoc().firstChild.nextElementSibling == "undefined"); - var _ns = !_noNES ? "nextElementSibling" : "nextSibling"; - var _ps = !_noNES ? "previousElementSibling" : "previousSibling"; - var _simpleNodeTest = (_noNES ? _isElement : yesman); - - var _lookLeft = function(node){ - // look left - while(node = node[_ps]){ - if(_simpleNodeTest(node)){ return false; } - } - return true; - }; - - var _lookRight = function(node){ - // look right - while(node = node[_ns]){ - if(_simpleNodeTest(node)){ return false; } - } - return true; - }; - - var getNodeIndex = function(node){ - var root = node.parentNode; - var i = 0, - tret = root[childNodesName], - ci = (node["_i"]||-1), - cl = (root["_l"]||-1); - - if(!tret){ return -1; } - var l = tret.length; - - // we calculate the parent length as a cheap way to invalidate the - // cache. It's not 100% accurate, but it's much more honest than what - // other libraries do - if( cl == l && ci >= 0 && cl >= 0 ){ - // if it's legit, tag and release - return ci; - } - - // else re-key things - root["_l"] = l; - ci = -1; - for(var te = root["firstElementChild"]||root["firstChild"]; te; te = te[_ns]){ - if(_simpleNodeTest(te)){ - te["_i"] = ++i; - if(node === te){ - // NOTE: - // shortcutting the return at this step in indexing works - // very well for benchmarking but we avoid it here since - // it leads to potential O(n^2) behavior in sequential - // getNodexIndex operations on a previously un-indexed - // parent. We may revisit this at a later time, but for - // now we just want to get the right answer more often - // than not. - ci = i; - } - } - } - return ci; - }; - - var isEven = function(elem){ - return !((getNodeIndex(elem)) % 2); - }; - - var isOdd = function(elem){ - return ((getNodeIndex(elem)) % 2); - }; - - var pseudos = { - "checked": function(name, condition){ - return function(elem){ - return !!("checked" in elem ? elem.checked : elem.selected); - } - }, - "first-child": function(){ return _lookLeft; }, - "last-child": function(){ return _lookRight; }, - "only-child": function(name, condition){ - return function(node){ - if(!_lookLeft(node)){ return false; } - if(!_lookRight(node)){ return false; } - return true; - }; - }, - "empty": function(name, condition){ - return function(elem){ - // DomQuery and jQuery get this wrong, oddly enough. - // The CSS 3 selectors spec is pretty explicit about it, too. - var cn = elem.childNodes; - var cnl = elem.childNodes.length; - // if(!cnl){ return true; } - for(var x=cnl-1; x >= 0; x--){ - var nt = cn[x].nodeType; - if((nt === 1)||(nt == 3)){ return false; } - } - return true; - } - }, - "contains": function(name, condition){ - var cz = condition.charAt(0); - if( cz == '"' || cz == "'" ){ //remove quote - condition = condition.slice(1, -1); - } - return function(elem){ - return (elem.innerHTML.indexOf(condition) >= 0); - } - }, - "not": function(name, condition){ - var p = getQueryParts(condition)[0]; - var ignores = { el: 1 }; - if(p.tag != "*"){ - ignores.tag = 1; - } - if(!p.classes.length){ - ignores.classes = 1; - } - var ntf = getSimpleFilterFunc(p, ignores); - return function(elem){ - return (!ntf(elem)); - } - }, - "nth-child": function(name, condition){ - var pi = parseInt; - // avoid re-defining function objects if we can - if(condition == "odd"){ - return isOdd; - }else if(condition == "even"){ - return isEven; - } - // FIXME: can we shorten this? - if(condition.indexOf("n") != -1){ - var tparts = condition.split("n", 2); - var pred = tparts[0] ? ((tparts[0] == '-') ? -1 : pi(tparts[0])) : 1; - var idx = tparts[1] ? pi(tparts[1]) : 0; - var lb = 0, ub = -1; - if(pred > 0){ - if(idx < 0){ - idx = (idx % pred) && (pred + (idx % pred)); - }else if(idx>0){ - if(idx >= pred){ - lb = idx - idx % pred; - } - idx = idx % pred; - } - }else if(pred<0){ - pred *= -1; - // idx has to be greater than 0 when pred is negative; - // shall we throw an error here? - if(idx > 0){ - ub = idx; - idx = idx % pred; - } - } - if(pred > 0){ - return function(elem){ - var i = getNodeIndex(elem); - return (i>=lb) && (ub<0 || i<=ub) && ((i % pred) == idx); - } - }else{ - condition = idx; - } - } - var ncount = pi(condition); - return function(elem){ - return (getNodeIndex(elem) == ncount); - } - } - }; - - var defaultGetter = (d.isIE < 9 || (dojo.isIE && dojo.isQuirks)) ? function(cond){ - var clc = cond.toLowerCase(); - if(clc == "class"){ cond = "className"; } - return function(elem){ - return (caseSensitive ? elem.getAttribute(cond) : elem[cond]||elem[clc]); - } - } : function(cond){ - return function(elem){ - return (elem && elem.getAttribute && elem.hasAttribute(cond)); - } - }; - - var getSimpleFilterFunc = function(query, ignores){ - // generates a node tester function based on the passed query part. The - // query part is one of the structures generated by the query parser - // when it creates the query AST. The "ignores" object specifies which - // (if any) tests to skip, allowing the system to avoid duplicating - // work where it may have already been taken into account by other - // factors such as how the nodes to test were fetched in the first - // place - if(!query){ return yesman; } - ignores = ignores||{}; - - var ff = null; - - if(!("el" in ignores)){ - ff = agree(ff, _isElement); - } - - if(!("tag" in ignores)){ - if(query.tag != "*"){ - ff = agree(ff, function(elem){ - return (elem && (elem.tagName == query.getTag())); - }); - } - } - - if(!("classes" in ignores)){ - each(query.classes, function(cname, idx, arr){ - // get the class name - /* - var isWildcard = cname.charAt(cname.length-1) == "*"; - if(isWildcard){ - cname = cname.substr(0, cname.length-1); - } - // I dislike the regex thing, even if memoized in a cache, but it's VERY short - var re = new RegExp("(?:^|\\s)" + cname + (isWildcard ? ".*" : "") + "(?:\\s|$)"); - */ - var re = new RegExp("(?:^|\\s)" + cname + "(?:\\s|$)"); - ff = agree(ff, function(elem){ - return re.test(elem.className); - }); - ff.count = idx; - }); - } - - if(!("pseudos" in ignores)){ - each(query.pseudos, function(pseudo){ - var pn = pseudo.name; - if(pseudos[pn]){ - ff = agree(ff, pseudos[pn](pn, pseudo.value)); - } - }); - } - - if(!("attrs" in ignores)){ - each(query.attrs, function(attr){ - var matcher; - var a = attr.attr; - // type, attr, matchFor - if(attr.type && attrs[attr.type]){ - matcher = attrs[attr.type](a, attr.matchFor); - }else if(a.length){ - matcher = defaultGetter(a); - } - if(matcher){ - ff = agree(ff, matcher); - } - }); - } - - if(!("id" in ignores)){ - if(query.id){ - ff = agree(ff, function(elem){ - return (!!elem && (elem.id == query.id)); - }); - } - } - - if(!ff){ - if(!("default" in ignores)){ - ff = yesman; - } - } - return ff; - }; - - var _nextSibling = function(filterFunc){ - return function(node, ret, bag){ - while(node = node[_ns]){ - if(_noNES && (!_isElement(node))){ continue; } - if( - (!bag || _isUnique(node, bag)) && - filterFunc(node) - ){ - ret.push(node); - } - break; - } - return ret; - } - }; - - var _nextSiblings = function(filterFunc){ - return function(root, ret, bag){ - var te = root[_ns]; - while(te){ - if(_simpleNodeTest(te)){ - if(bag && !_isUnique(te, bag)){ - break; - } - if(filterFunc(te)){ - ret.push(te); - } - } - te = te[_ns]; - } - return ret; - } - }; - - // get an array of child *elements*, skipping text and comment nodes - var _childElements = function(filterFunc){ - filterFunc = filterFunc||yesman; - return function(root, ret, bag){ - // get an array of child elements, skipping text and comment nodes - var te, x = 0, tret = root[childNodesName]; - while(te = tret[x++]){ - if( - _simpleNodeTest(te) && - (!bag || _isUnique(te, bag)) && - (filterFunc(te, x)) - ){ - ret.push(te); - } - } - return ret; - }; - }; - - /* - // thanks, Dean! - var itemIsAfterRoot = d.isIE ? function(item, root){ - return (item.sourceIndex > root.sourceIndex); - } : function(item, root){ - return (item.compareDocumentPosition(root) == 2); - }; - */ - - // test to see if node is below root - var _isDescendant = function(node, root){ - var pn = node.parentNode; - while(pn){ - if(pn == root){ - break; - } - pn = pn.parentNode; - } - return !!pn; - }; - - var _getElementsFuncCache = {}; - - var getElementsFunc = function(query){ - var retFunc = _getElementsFuncCache[query.query]; - // if we've got a cached dispatcher, just use that - if(retFunc){ return retFunc; } - // else, generate a new on - - // NOTE: - // this function returns a function that searches for nodes and - // filters them. The search may be specialized by infix operators - // (">", "~", or "+") else it will default to searching all - // descendants (the " " selector). Once a group of children is - // found, a test function is applied to weed out the ones we - // don't want. Many common cases can be fast-pathed. We spend a - // lot of cycles to create a dispatcher that doesn't do more work - // than necessary at any point since, unlike this function, the - // dispatchers will be called every time. The logic of generating - // efficient dispatchers looks like this in pseudo code: - // - // # if it's a purely descendant query (no ">", "+", or "~" modifiers) - // if infixOperator == " ": - // if only(id): - // return def(root): - // return d.byId(id, root); - // - // elif id: - // return def(root): - // return filter(d.byId(id, root)); - // - // elif cssClass && getElementsByClassName: - // return def(root): - // return filter(root.getElementsByClassName(cssClass)); - // - // elif only(tag): - // return def(root): - // return root.getElementsByTagName(tagName); - // - // else: - // # search by tag name, then filter - // return def(root): - // return filter(root.getElementsByTagName(tagName||"*")); - // - // elif infixOperator == ">": - // # search direct children - // return def(root): - // return filter(root.children); - // - // elif infixOperator == "+": - // # search next sibling - // return def(root): - // return filter(root.nextElementSibling); - // - // elif infixOperator == "~": - // # search rightward siblings - // return def(root): - // return filter(nextSiblings(root)); - - var io = query.infixOper; - var oper = (io ? io.oper : ""); - // the default filter func which tests for all conditions in the query - // part. This is potentially inefficient, so some optimized paths may - // re-define it to test fewer things. - var filterFunc = getSimpleFilterFunc(query, { el: 1 }); - var qt = query.tag; - var wildcardTag = ("*" == qt); - var ecs = getDoc()["getElementsByClassName"]; - - if(!oper){ - // if there's no infix operator, then it's a descendant query. ID - // and "elements by class name" variants can be accelerated so we - // call them out explicitly: - if(query.id){ - // testing shows that the overhead of yesman() is acceptable - // and can save us some bytes vs. re-defining the function - // everywhere. - filterFunc = (!query.loops && wildcardTag) ? - yesman : - getSimpleFilterFunc(query, { el: 1, id: 1 }); - - retFunc = function(root, arr){ - var te = d.byId(query.id, (root.ownerDocument||root)); - if(!te || !filterFunc(te)){ return; } - if(9 == root.nodeType){ // if root's a doc, we just return directly - return getArr(te, arr); - }else{ // otherwise check ancestry - if(_isDescendant(te, root)){ - return getArr(te, arr); - } - } - } - }else if( - ecs && - // isAlien check. Workaround for Prototype.js being totally evil/dumb. - /\{\s*\[native code\]\s*\}/.test(String(ecs)) && - query.classes.length && - !cssCaseBug - ){ - // it's a class-based query and we've got a fast way to run it. - - // ignore class and ID filters since we will have handled both - filterFunc = getSimpleFilterFunc(query, { el: 1, classes: 1, id: 1 }); - var classesString = query.classes.join(" "); - retFunc = function(root, arr, bag){ - var ret = getArr(0, arr), te, x=0; - var tret = root.getElementsByClassName(classesString); - while((te = tret[x++])){ - if(filterFunc(te, root) && _isUnique(te, bag)){ - ret.push(te); - } - } - return ret; - }; - - }else if(!wildcardTag && !query.loops){ - // it's tag only. Fast-path it. - retFunc = function(root, arr, bag){ - var ret = getArr(0, arr), te, x=0; - var tret = root.getElementsByTagName(query.getTag()); - while((te = tret[x++])){ - if(_isUnique(te, bag)){ - ret.push(te); - } - } - return ret; - }; - }else{ - // the common case: - // a descendant selector without a fast path. By now it's got - // to have a tag selector, even if it's just "*" so we query - // by that and filter - filterFunc = getSimpleFilterFunc(query, { el: 1, tag: 1, id: 1 }); - retFunc = function(root, arr, bag){ - var ret = getArr(0, arr), te, x=0; - // we use getTag() to avoid case sensitivity issues - var tret = root.getElementsByTagName(query.getTag()); - while((te = tret[x++])){ - if(filterFunc(te, root) && _isUnique(te, bag)){ - ret.push(te); - } - } - return ret; - }; - } - }else{ - // the query is scoped in some way. Instead of querying by tag we - // use some other collection to find candidate nodes - var skipFilters = { el: 1 }; - if(wildcardTag){ - skipFilters.tag = 1; - } - filterFunc = getSimpleFilterFunc(query, skipFilters); - if("+" == oper){ - retFunc = _nextSibling(filterFunc); - }else if("~" == oper){ - retFunc = _nextSiblings(filterFunc); - }else if(">" == oper){ - retFunc = _childElements(filterFunc); - } - } - // cache it and return - return _getElementsFuncCache[query.query] = retFunc; - }; - - var filterDown = function(root, queryParts){ - // NOTE: - // this is the guts of the DOM query system. It takes a list of - // parsed query parts and a root and finds children which match - // the selector represented by the parts - var candidates = getArr(root), qp, x, te, qpl = queryParts.length, bag, ret; - - for(var i = 0; i < qpl; i++){ - ret = []; - qp = queryParts[i]; - x = candidates.length - 1; - if(x > 0){ - // if we have more than one root at this level, provide a new - // hash to use for checking group membership but tell the - // system not to post-filter us since we will already have been - // gauranteed to be unique - bag = {}; - ret.nozip = true; - } - var gef = getElementsFunc(qp); - for(var j = 0; (te = candidates[j]); j++){ - // for every root, get the elements that match the descendant - // selector, adding them to the "ret" array and filtering them - // via membership in this level's bag. If there are more query - // parts, then this level's return will be used as the next - // level's candidates - gef(te, ret, bag); - } - if(!ret.length){ break; } - candidates = ret; - } - return ret; - }; - - //////////////////////////////////////////////////////////////////////// - // the query runner - //////////////////////////////////////////////////////////////////////// - - // these are the primary caches for full-query results. The query - // dispatcher functions are generated then stored here for hash lookup in - // the future - var _queryFuncCacheDOM = {}, - _queryFuncCacheQSA = {}; - - // this is the second level of spliting, from full-length queries (e.g., - // "div.foo .bar") into simple query expressions (e.g., ["div.foo", - // ".bar"]) - var getStepQueryFunc = function(query){ - var qparts = getQueryParts(trim(query)); - - // if it's trivial, avoid iteration and zipping costs - if(qparts.length == 1){ - // we optimize this case here to prevent dispatch further down the - // chain, potentially slowing things down. We could more elegantly - // handle this in filterDown(), but it's slower for simple things - // that need to be fast (e.g., "#someId"). - var tef = getElementsFunc(qparts[0]); - return function(root){ - var r = tef(root, new qlc()); - if(r){ r.nozip = true; } - return r; - } - } - - // otherwise, break it up and return a runner that iterates over the parts recursively - return function(root){ - return filterDown(root, qparts); - } - }; - - // NOTES: - // * we can't trust QSA for anything but document-rooted queries, so - // caching is split into DOM query evaluators and QSA query evaluators - // * caching query results is dirty and leak-prone (or, at a minimum, - // prone to unbounded growth). Other toolkits may go this route, but - // they totally destroy their own ability to manage their memory - // footprint. If we implement it, it should only ever be with a fixed - // total element reference # limit and an LRU-style algorithm since JS - // has no weakref support. Caching compiled query evaluators is also - // potentially problematic, but even on large documents the size of the - // query evaluators is often < 100 function objects per evaluator (and - // LRU can be applied if it's ever shown to be an issue). - // * since IE's QSA support is currently only for HTML documents and even - // then only in IE 8's "standards mode", we have to detect our dispatch - // route at query time and keep 2 separate caches. Ugg. - - // we need to determine if we think we can run a given query via - // querySelectorAll or if we'll need to fall back on DOM queries to get - // there. We need a lot of information about the environment and the query - // to make the determiniation (e.g. does it support QSA, does the query in - // question work in the native QSA impl, etc.). - var nua = navigator.userAgent; - // some versions of Safari provided QSA, but it was buggy and crash-prone. - // We need te detect the right "internal" webkit version to make this work. - var wk = "WebKit/"; - var is525 = ( - d.isWebKit && - (nua.indexOf(wk) > 0) && - (parseFloat(nua.split(wk)[1]) > 528) - ); - - // IE QSA queries may incorrectly include comment nodes, so we throw the - // zipping function into "remove" comments mode instead of the normal "skip - // it" which every other QSA-clued browser enjoys - var noZip = d.isIE ? "commentStrip" : "nozip"; - - var qsa = "querySelectorAll"; - var qsaAvail = ( - !!getDoc()[qsa] && - // see #5832 - (!d.isSafari || (d.isSafari > 3.1) || is525 ) - ); - - //Don't bother with n+3 type of matches, IE complains if we modify those. - var infixSpaceRe = /n\+\d|([^ ])?([>~+])([^ =])?/g; - var infixSpaceFunc = function(match, pre, ch, post) { - return ch ? (pre ? pre + " " : "") + ch + (post ? " " + post : "") : /*n+3*/ match; - }; - - var getQueryFunc = function(query, forceDOM){ - //Normalize query. The CSS3 selectors spec allows for omitting spaces around - //infix operators, >, ~ and + - //Do the work here since detection for spaces is used as a simple "not use QSA" - //test below. - query = query.replace(infixSpaceRe, infixSpaceFunc); - - if(qsaAvail){ - // if we've got a cached variant and we think we can do it, run it! - var qsaCached = _queryFuncCacheQSA[query]; - if(qsaCached && !forceDOM){ return qsaCached; } - } - - // else if we've got a DOM cached variant, assume that we already know - // all we need to and use it - var domCached = _queryFuncCacheDOM[query]; - if(domCached){ return domCached; } - - // TODO: - // today we're caching DOM and QSA branches separately so we - // recalc useQSA every time. If we had a way to tag root+query - // efficiently, we'd be in good shape to do a global cache. - - var qcz = query.charAt(0); - var nospace = (-1 == query.indexOf(" ")); - - // byId searches are wicked fast compared to QSA, even when filtering - // is required - if( (query.indexOf("#") >= 0) && (nospace) ){ - forceDOM = true; - } - - var useQSA = ( - qsaAvail && (!forceDOM) && - // as per CSS 3, we can't currently start w/ combinator: - // http://www.w3.org/TR/css3-selectors/#w3cselgrammar - (specials.indexOf(qcz) == -1) && - // IE's QSA impl sucks on pseudos - (!d.isIE || (query.indexOf(":") == -1)) && - - (!(cssCaseBug && (query.indexOf(".") >= 0))) && - - // FIXME: - // need to tighten up browser rules on ":contains" and "|=" to - // figure out which aren't good - // Latest webkit (around 531.21.8) does not seem to do well with :checked on option - // elements, even though according to spec, selected options should - // match :checked. So go nonQSA for it: - // http://bugs.dojotoolkit.org/ticket/5179 - (query.indexOf(":contains") == -1) && (query.indexOf(":checked") == -1) && - (query.indexOf("|=") == -1) // some browsers don't grok it - ); - - // TODO: - // if we've got a descendant query (e.g., "> .thinger" instead of - // just ".thinger") in a QSA-able doc, but are passed a child as a - // root, it should be possible to give the item a synthetic ID and - // trivially rewrite the query to the form "#synid > .thinger" to - // use the QSA branch - - - if(useQSA){ - var tq = (specials.indexOf(query.charAt(query.length-1)) >= 0) ? - (query + " *") : query; - return _queryFuncCacheQSA[query] = function(root){ - try{ - // the QSA system contains an egregious spec bug which - // limits us, effectively, to only running QSA queries over - // entire documents. See: - // http://ejohn.org/blog/thoughts-on-queryselectorall/ - // despite this, we can also handle QSA runs on simple - // selectors, but we don't want detection to be expensive - // so we're just checking for the presence of a space char - // right now. Not elegant, but it's cheaper than running - // the query parser when we might not need to - if(!((9 == root.nodeType) || nospace)){ throw ""; } - var r = root[qsa](tq); - // skip expensive duplication checks and just wrap in a NodeList - r[noZip] = true; - return r; - }catch(e){ - // else run the DOM branch on this query, ensuring that we - // default that way in the future - return getQueryFunc(query, true)(root); - } - } - }else{ - // DOM branch - var parts = query.split(/\s*,\s*/); - return _queryFuncCacheDOM[query] = ((parts.length < 2) ? - // if not a compound query (e.g., ".foo, .bar"), cache and return a dispatcher - getStepQueryFunc(query) : - // if it *is* a complex query, break it up into its - // constituent parts and return a dispatcher that will - // merge the parts when run - function(root){ - var pindex = 0, // avoid array alloc for every invocation - ret = [], - tp; - while((tp = parts[pindex++])){ - ret = ret.concat(getStepQueryFunc(tp)(root)); - } - return ret; - } - ); - } - }; - - var _zipIdx = 0; - - // NOTE: - // this function is Moo inspired, but our own impl to deal correctly - // with XML in IE - var _nodeUID = d.isIE ? function(node){ - if(caseSensitive){ - // XML docs don't have uniqueID on their nodes - return (node.getAttribute("_uid") || node.setAttribute("_uid", ++_zipIdx) || _zipIdx); - - }else{ - return node.uniqueID; - } - } : - function(node){ - return (node._uid || (node._uid = ++_zipIdx)); - }; - - // determine if a node in is unique in a "bag". In this case we don't want - // to flatten a list of unique items, but rather just tell if the item in - // question is already in the bag. Normally we'd just use hash lookup to do - // this for us but IE's DOM is busted so we can't really count on that. On - // the upside, it gives us a built in unique ID function. - var _isUnique = function(node, bag){ - if(!bag){ return 1; } - var id = _nodeUID(node); - if(!bag[id]){ return bag[id] = 1; } - return 0; - }; - - // attempt to efficiently determine if an item in a list is a dupe, - // returning a list of "uniques", hopefully in doucment order - var _zipIdxName = "_zipIdx"; - var _zip = function(arr){ - if(arr && arr.nozip){ - return (qlc._wrap) ? qlc._wrap(arr) : arr; - } - // var ret = new d._NodeListCtor(); - var ret = new qlc(); - if(!arr || !arr.length){ return ret; } - if(arr[0]){ - ret.push(arr[0]); - } - if(arr.length < 2){ return ret; } - - _zipIdx++; - - // we have to fork here for IE and XML docs because we can't set - // expandos on their nodes (apparently). *sigh* - if(d.isIE && caseSensitive){ - var szidx = _zipIdx+""; - arr[0].setAttribute(_zipIdxName, szidx); - for(var x = 1, te; te = arr[x]; x++){ - if(arr[x].getAttribute(_zipIdxName) != szidx){ - ret.push(te); - } - te.setAttribute(_zipIdxName, szidx); - } - }else if(d.isIE && arr.commentStrip){ - try{ - for(var x = 1, te; te = arr[x]; x++){ - if(_isElement(te)){ - ret.push(te); - } - } - }catch(e){ /* squelch */ } - }else{ - if(arr[0]){ arr[0][_zipIdxName] = _zipIdx; } - for(var x = 1, te; te = arr[x]; x++){ - if(arr[x][_zipIdxName] != _zipIdx){ - ret.push(te); - } - te[_zipIdxName] = _zipIdx; - } - } - return ret; - }; - - // the main executor - 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 preceded-by sibling selector - // * `+`, the immediately preceded-by sibling selector - // * attribute queries: - // | * `[foo]` attribute presence selector - // | * `[foo='bar']` attribute value exact match - // | * `[foo~='bar']` attribute value list item match - // | * `[foo^='bar']` attribute start match - // | * `[foo$='bar']` attribute end match - // | * `[foo*='bar']` attribute substring match - // * `:first-child`, `:last-child`, and `:only-child` positional selectors - // * `:empty` content emtpy selector - // * `:checked` pseudo selector - // * `:nth-child(n)`, `:nth-child(2n+1)` style positional calculations - // * `:nth-child(even)`, `:nth-child(odd)` positional selectors - // * `:not(...)` negation pseudo selectors - // - // Any legal combination of these selectors will work with - // `dojo.query()`, including compound selectors ("," delimited). - // Very complex and useful searches can be constructed with this - // palette of selectors and when combined with functions for - // manipulation presented by dojo.NodeList, many types of DOM - // manipulation operations become very straightforward. - // - // Unsupported Selectors: - // ---------------------- - // - // While dojo.query handles many CSS3 selectors, some fall outside of - // what's reasonable for a programmatic node querying engine to - // handle. Currently unsupported selectors include: - // - // * namespace-differentiated selectors of any form - // * all `::` pseduo-element selectors - // * certain pseduo-selectors which don't get a lot of day-to-day use: - // | * `:root`, `:lang()`, `:target`, `:focus` - // * all visual and state selectors: - // | * `:root`, `:active`, `:hover`, `:visisted`, `:link`, - // `:enabled`, `:disabled` - // * `:*-of-type` pseudo selectors - // - // dojo.query and XML Documents: - // ----------------------------- - // - // `dojo.query` (as of dojo 1.2) supports searching XML documents - // in a case-sensitive manner. If an HTML document is served with - // a doctype that forces case-sensitivity (e.g., XHTML 1.1 - // Strict), dojo.query() will detect this and "do the right - // thing". Case sensitivity is dependent upon the document being - // searched and not the query used. It is therefore possible to - // use case-sensitive queries on strict sub-documents (iframes, - // etc.) or XML documents while still assuming case-insensitivity - // for a host/root document. - // - // Non-selector Queries: - // --------------------- - // - // If something other than a String is passed for the query, - // `dojo.query` will return a new `dojo.NodeList` instance - // constructed from that parameter alone and all further - // processing will stop. This means that if you have a reference - // to a node or NodeList, you can quickly construct a new NodeList - // from the original by calling `dojo.query(node)` or - // `dojo.query(list)`. - // - // query: - // The CSS3 expression to match against. For details on the syntax of - // CSS3 selectors, see <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"); - // | } - // | }); - // | }); - - //Set list constructor to desired value. This can change - //between calls, so always re-assign here. - qlc = d._NodeListCtor; - - if(!query){ - return new qlc(); - } - - if(query.constructor == qlc){ - return query; - } - if(typeof query != "string"){ // inline'd type check - return new qlc(query); // dojo.NodeList - } - if(typeof root == "string"){ // inline'd type check - root = d.byId(root); - if(!root){ return new qlc(); } - } - - root = root||getDoc(); - var od = root.ownerDocument||root.documentElement; - - // throw the big case sensitivity switch - - // NOTE: - // Opera in XHTML mode doesn't detect case-sensitivity correctly - // and it's not clear that there's any way to test for it - caseSensitive = (root.contentType && root.contentType=="application/xml") || - (d.isOpera && (root.doctype || od.toString() == "[object XMLDocument]")) || - (!!od) && - (d.isIE ? od.xml : (root.xmlVersion||od.xmlVersion)); - - // NOTE: - // adding "true" as the 2nd argument to getQueryFunc is useful for - // testing the DOM branch without worrying about the - // behavior/performance of the QSA branch. - var r = getQueryFunc(query)(root); - - // FIXME: - // need to investigate this branch WRT #8074 and #8075 - if(r && r.nozip && !qlc._wrap){ - return r; - } - return _zip(r); // dojo.NodeList - } - - // FIXME: need to add infrastructure for post-filtering pseudos, ala :last - d.query.pseudos = pseudos; - - // function for filtering a NodeList based on a selector, optimized for simple selectors - d._filterQueryResult = function(/*NodeList*/ nodeList, /*String*/ filter, /*String|DOMNode?*/ root){ - var tmpNodeList = new d._NodeListCtor(), - parts = getQueryParts(filter), - filterFunc = - (parts.length == 1 && !/[^\w#\.]/.test(filter)) ? - getSimpleFilterFunc(parts[0]) : - function(node) { - return dojo.query(filter, root).indexOf(node) != -1; - }; - for(var x = 0, te; te = nodeList[x]; x++){ - if(filterFunc(te)){ tmpNodeList.push(te); } - } - return tmpNodeList; - } -};//end defineQuery - -var defineAcme= function(){ - // a self-sufficient query impl - acme = { - trim: function(/*String*/ str){ - // summary: - // trims whitespaces from both sides of the string - str = str.replace(/^\s+/, ''); - for(var i = str.length - 1; i >= 0; i--){ - if(/\S/.test(str.charAt(i))){ - str = str.substring(0, i + 1); - break; - } - } - return str; // String - }, - forEach: function(/*String*/ arr, /*Function*/ callback, /*Object?*/ thisObject){ - // summary: - // an iterator function that passes items, indexes, - // and the array to a callback - if(!arr || !arr.length){ return; } - for(var i=0,l=arr.length; i<l; ++i){ - callback.call(thisObject||window, arr[i], i, arr); - } - }, - byId: function(id, doc){ - // summary: - // a function that return an element by ID, but also - // accepts nodes safely - if(typeof id == "string"){ - return (doc||document).getElementById(id); // DomNode - }else{ - return id; // DomNode - } - }, - // the default document to search - doc: document, - // the constructor for node list objects returned from query() - NodeList: Array - }; - - // define acme.isIE, acme.isSafari, acme.isOpera, etc. - var n = navigator; - var dua = n.userAgent; - var dav = n.appVersion; - var tv = parseFloat(dav); - acme.isOpera = (dua.indexOf("Opera") >= 0) ? tv: undefined; - acme.isKhtml = (dav.indexOf("Konqueror") >= 0) ? tv : undefined; - acme.isWebKit = parseFloat(dua.split("WebKit/")[1]) || undefined; - acme.isChrome = parseFloat(dua.split("Chrome/")[1]) || undefined; - var index = Math.max(dav.indexOf("WebKit"), dav.indexOf("Safari"), 0); - if(index && !acme.isChrome){ - acme.isSafari = parseFloat(dav.split("Version/")[1]); - if(!acme.isSafari || parseFloat(dav.substr(index + 7)) <= 419.3){ - acme.isSafari = 2; - } - } - if(document.all && !acme.isOpera){ - acme.isIE = parseFloat(dav.split("MSIE ")[1]) || undefined; - } - - Array._wrap = function(arr){ return arr; }; - return acme; -}; - - //prefers queryPortability, then acme, then dojo - if(this["dojo"]){ - dojo.provide("dojo._base.query"); - dojo.require("dojo._base.NodeList"); - dojo.require("dojo._base.lang"); - defineQuery(this["queryPortability"]||this["acme"]||dojo); - }else{ - defineQuery(this["queryPortability"]||this["acme"]||defineAcme()); - } - -})(); - -/* -*/ - -} +//>>built +define("dojo/_base/query",["./kernel","../query","./NodeList"],function(_1){return _1.query;});
\ No newline at end of file diff --git a/lib/dojo/_base/query.js.uncompressed.js b/lib/dojo/_base/query.js.uncompressed.js new file mode 100644 index 000000000..a1b161b0b --- /dev/null +++ b/lib/dojo/_base/query.js.uncompressed.js @@ -0,0 +1,3 @@ +define("dojo/_base/query", ["./kernel", "../query", "./NodeList"], function(dojo){ + return dojo.query; +}); diff --git a/lib/dojo/_base/sniff.js b/lib/dojo/_base/sniff.js new file mode 100644 index 000000000..5849b99e9 --- /dev/null +++ b/lib/dojo/_base/sniff.js @@ -0,0 +1,8 @@ +/* + Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Available via Academic Free License >= 2.1 OR the modified BSD license. + see: http://dojotoolkit.org/license for details +*/ + +//>>built +define("dojo/_base/sniff",["./kernel","../has"],function(_1,_2){if(!1){return _2;}_1.isBrowser=true,_1._name="browser";var _3=_2.add,n=navigator,_4=n.userAgent,_5=n.appVersion,tv=parseFloat(_5),_6,_7,_8,_9,_a,_b,_c,_d,_e,_f,_10,_11,_12,_13,_14;if(_4.indexOf("AdobeAIR")>=0){_7=1;}_8=(_5.indexOf("Konqueror")>=0)?tv:0;_9=parseFloat(_4.split("WebKit/")[1])||undefined;_a=parseFloat(_4.split("Chrome/")[1])||undefined;_b=_5.indexOf("Macintosh")>=0;_12=/iPhone|iPod|iPad/.test(_4);_13=parseFloat(_4.split("Android ")[1])||undefined;_14=typeof opera!="undefined"&&opera.wiiremote;var _15=Math.max(_5.indexOf("WebKit"),_5.indexOf("Safari"),0);if(_15&&!_a){_c=parseFloat(_5.split("Version/")[1]);if(!_c||parseFloat(_5.substr(_15+7))<=419.3){_c=2;}}if(!_2("dojo-webkit")){if(_4.indexOf("Opera")>=0){_6=tv;if(_6>=9.8){_6=parseFloat(_4.split("Version/")[1])||tv;}}if(_4.indexOf("Gecko")>=0&&!_8&&!_9){_d=_e=tv;}if(_e){_10=parseFloat(_4.split("Firefox/")[1]||_4.split("Minefield/")[1])||undefined;}if(document.all&&!_6){_f=parseFloat(_5.split("MSIE ")[1])||undefined;var _16=document.documentMode;if(_16&&_16!=5&&Math.floor(_f)!=_16){_f=_16;}}}_11=document.compatMode=="BackCompat";_3("opera",_1.isOpera=_6);_3("air",_1.isAIR=_7);_3("khtml",_1.isKhtml=_8);_3("webkit",_1.isWebKit=_9);_3("chrome",_1.isChrome=_a);_3("mac",_1.isMac=_b);_3("safari",_1.isSafari=_c);_3("mozilla",_1.isMozilla=_1.isMoz=_d);_3("ie",_1.isIE=_f);_3("ff",_1.isFF=_10);_3("quirks",_1.isQuirks=_11);_3("ios",_1.isIos=_12);_3("android",_1.isAndroid=_13);_1.locale=_1.locale||(_f?n.userLanguage:n.language).toLowerCase();return _2;});
\ No newline at end of file diff --git a/lib/dojo/_base/sniff.js.uncompressed.js b/lib/dojo/_base/sniff.js.uncompressed.js new file mode 100644 index 000000000..c7e4b428a --- /dev/null +++ b/lib/dojo/_base/sniff.js.uncompressed.js @@ -0,0 +1,187 @@ +define("dojo/_base/sniff", ["./kernel", "../has"], function(dojo, has){ + // module: + // dojo/sniff + // summary: + // This module populates the dojo browser version sniffing properties. + + if(!1){ + return has; + } + + dojo.isBrowser = true, + dojo._name = "browser"; + + var hasAdd = has.add, + n = navigator, + dua = n.userAgent, + dav = n.appVersion, + tv = parseFloat(dav), + isOpera, + isAIR, + isKhtml, + isWebKit, + isChrome, + isMac, + isSafari, + isMozilla , + isMoz, + isIE, + isFF, + isQuirks, + isIos, + isAndroid, + isWii; + + /*===== + 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.mixin(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 KHTML browser. undefined otherwise. Corresponds to major + // detected version. + isKhtml: 0, + // isWebKit: Number | undefined + // Version as a Number if client is a WebKit-derived browser (Konqueror, + // Safari, Chrome, etc.). undefined otherwise. + isWebKit: 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, + // isChrome: Number | undefined + // Version as a Number if client is Chrome browser. undefined otherwise. + isChrome: 0, + // isMac: Boolean + // True if the client runs on Mac + isMac: 0, + // isIos: Boolean + // True if client is iPhone, iPod, or iPad + isIos: 0, + // isAndroid: Number | undefined + // Version as a Number if client is android browser. undefined otherwise. + isAndroid: 0, + // isWii: Boolean + // True if client is Wii + isWii: 0 + }); + =====*/ + + // fill in the rendering support information in dojo.render.* + if(dua.indexOf("AdobeAIR") >= 0){ isAIR = 1; } + isKhtml = (dav.indexOf("Konqueror") >= 0) ? tv : 0; + isWebKit = parseFloat(dua.split("WebKit/")[1]) || undefined; + isChrome = parseFloat(dua.split("Chrome/")[1]) || undefined; + isMac = dav.indexOf("Macintosh") >= 0; + isIos = /iPhone|iPod|iPad/.test(dua); + isAndroid = parseFloat(dua.split("Android ")[1]) || undefined; + isWii = typeof opera != "undefined" && opera.wiiremote; + + // 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 && !isChrome){ + // try to grab the explicit Safari version first. If we don't get + // one, look for less than 419.3 as the indication that we're on something + // "Safari 2-ish". + isSafari = parseFloat(dav.split("Version/")[1]); + if(!isSafari || parseFloat(dav.substr(index + 7)) <= 419.3){ + isSafari = 2; + } + } + + if (!has("dojo-webkit")) { + if(dua.indexOf("Opera") >= 0){ + isOpera = tv; + // see http://dev.opera.com/articles/view/opera-ua-string-changes and http://www.useragentstring.com/pages/Opera/ + // 9.8 has both styles; <9.8, 9.9 only old style + if(isOpera >= 9.8){ + isOpera = parseFloat(dua.split("Version/")[1]) || tv; + } + } + + if(dua.indexOf("Gecko") >= 0 && !isKhtml && !isWebKit){ + isMozilla = isMoz = tv; + } + if(isMoz){ + //We really need to get away from this. Consider a sane isGecko approach for the future. + isFF = parseFloat(dua.split("Firefox/")[1] || dua.split("Minefield/")[1]) || undefined; + } + if(document.all && !isOpera){ + isIE = parseFloat(dav.split("MSIE ")[1]) || undefined; + //In cases where the page has an HTTP header or META tag with + //X-UA-Compatible, then it is in emulation mode. + //Make sure isIE reflects the desired version. + //document.documentMode of 5 means quirks mode. + //Only switch the value if documentMode's major version + //is different from isIE's major version. + var mode = document.documentMode; + if(mode && mode != 5 && Math.floor(isIE) != mode){ + isIE = mode; + } + } + } + + isQuirks = document.compatMode == "BackCompat"; + + hasAdd("opera", dojo.isOpera = isOpera); + hasAdd("air", dojo.isAIR = isAIR); + hasAdd("khtml", dojo.isKhtml = isKhtml); + hasAdd("webkit", dojo.isWebKit = isWebKit); + hasAdd("chrome", dojo.isChrome = isChrome); + hasAdd("mac", dojo.isMac = isMac ); + hasAdd("safari", dojo.isSafari = isSafari); + hasAdd("mozilla", dojo.isMozilla = dojo.isMoz = isMozilla ); + hasAdd("ie", dojo.isIE = isIE ); + hasAdd("ff", dojo.isFF = isFF); + hasAdd("quirks", dojo.isQuirks = isQuirks); + hasAdd("ios", dojo.isIos = isIos); + hasAdd("android", dojo.isAndroid = isAndroid); + + dojo.locale = dojo.locale || (isIE ? n.userLanguage : n.language).toLowerCase(); + + return has; +}); diff --git a/lib/dojo/_base/unload.js b/lib/dojo/_base/unload.js new file mode 100644 index 000000000..8e099ae14 --- /dev/null +++ b/lib/dojo/_base/unload.js @@ -0,0 +1,8 @@ +/* + Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Available via Academic Free License >= 2.1 OR the modified BSD license. + see: http://dojotoolkit.org/license for details +*/ + +//>>built +define("dojo/_base/unload",["./kernel","./connect"],function(_1,_2){var _3=window;_1.addOnWindowUnload=function(_4,_5){if(!_1.windowUnloaded){_2.connect(_3,"unload",(_1.windowUnloaded=function(){}));}_2.connect(_3,"unload",_4,_5);};_1.addOnUnload=function(_6,_7){_2.connect(_3,"beforeunload",_6,_7);};return {addOnWindowUnload:_1.addOnWindowUnload,addOnUnload:_1.addOnUnload};});
\ No newline at end of file diff --git a/lib/dojo/_base/unload.js.uncompressed.js b/lib/dojo/_base/unload.js.uncompressed.js new file mode 100644 index 000000000..e811d929d --- /dev/null +++ b/lib/dojo/_base/unload.js.uncompressed.js @@ -0,0 +1,81 @@ +define("dojo/_base/unload", ["./kernel", "./connect"], function(dojo, connect) { + // module: + // dojo/unload + // summary: + // This module contains the document and window unload detection API. + + var win = window; + + /*===== + dojo.windowUnloaded = function(){ + // summary: + // signal fired by impending window destruction. You may use + // dojo.addOnWindowUnload() to register a listener for this + // event. NOTE: if you wish to dojo.connect() to this method + // to perform page/application cleanup, be aware that this + // event WILL NOT fire if no handler has been registered with + // dojo.addOnWindowUnload. This behavior started in Dojo 1.3. + // Previous versions always triggered dojo.windowUnloaded. See + // dojo.addOnWindowUnload for more info. + }; + =====*/ + + dojo.addOnWindowUnload = function(/*Object?|Function?*/obj, /*String|Function?*/functionName){ + // summary: + // registers a function to be triggered when window.onunload + // fires. + // description: + // The first time that addOnWindowUnload is called Dojo + // will register a page listener to trigger your unload + // handler with. Note that registering these handlers may + // destory "fastback" page caching in browsers that support + // it. 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 since it fires at the eqivalent of + // the page's "onbeforeunload" event. + // example: + // | dojo.addOnWindowUnload(functionPointer) + // | dojo.addOnWindowUnload(object, "functionName"); + // | dojo.addOnWindowUnload(object, function(){ /* ... */}); + + if (!dojo.windowUnloaded) { + connect.connect(win, "unload", (dojo.windowUnloaded= function(){})); + } + connect.connect(win, "unload", obj, functionName); + }; + + dojo.addOnUnload = function(/*Object?|Function?*/obj, /*String|Function?*/functionName){ + // summary: + // registers a function to be triggered when the page unloads. + // description: + // The first time that addOnUnload is called Dojo will + // register a page listener to trigger your unload handler + // with. + // + // In a browser enviroment, the functions will be triggered + // during the window.onbeforeunload event. Be careful of doing + // too much work in an unload handler. 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. + // + // Further note that calling dojo.addOnUnload will prevent + // browsers from using a "fast back" cache to make page + // loading via back button instantaneous. + // example: + // | dojo.addOnUnload(functionPointer) + // | dojo.addOnUnload(object, "functionName") + // | dojo.addOnUnload(object, function(){ /* ... */}); + + connect.connect(win, "beforeunload", obj, functionName); + }; + + return { + addOnWindowUnload: dojo.addOnWindowUnload, + addOnUnload: dojo.addOnUnload + }; +}); diff --git a/lib/dojo/_base/url.js b/lib/dojo/_base/url.js new file mode 100644 index 000000000..41bae092c --- /dev/null +++ b/lib/dojo/_base/url.js @@ -0,0 +1,8 @@ +/* + Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Available via Academic Free License >= 2.1 OR the modified BSD license. + see: http://dojotoolkit.org/license for details +*/ + +//>>built +define("dojo/_base/url",["./kernel"],function(_1){var _2=new RegExp("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$"),_3=new RegExp("^((([^\\[:]+):)?([^@]+)@)?(\\[([^\\]]+)\\]|([^\\[:]*))(:([0-9]+))?$"),_4=function(){var n=null,_5=arguments,_6=[_5[0]];for(var i=1;i<_5.length;i++){if(!_5[i]){continue;}var _7=new _4(_5[i]+""),_8=new _4(_6[0]+"");if(_7.path==""&&!_7.scheme&&!_7.authority&&!_7.query){if(_7.fragment!=n){_8.fragment=_7.fragment;}_7=_8;}else{if(!_7.scheme){_7.scheme=_8.scheme;if(!_7.authority){_7.authority=_8.authority;if(_7.path.charAt(0)!="/"){var _9=_8.path.substring(0,_8.path.lastIndexOf("/")+1)+_7.path;var _a=_9.split("/");for(var j=0;j<_a.length;j++){if(_a[j]=="."){if(j==_a.length-1){_a[j]="";}else{_a.splice(j,1);j--;}}else{if(j>0&&!(j==1&&_a[0]=="")&&_a[j]==".."&&_a[j-1]!=".."){if(j==(_a.length-1)){_a.splice(j,1);_a[j-1]="";}else{_a.splice(j-1,2);j-=2;}}}}_7.path=_a.join("/");}}}}_6=[];if(_7.scheme){_6.push(_7.scheme,":");}if(_7.authority){_6.push("//",_7.authority);}_6.push(_7.path);if(_7.query){_6.push("?",_7.query);}if(_7.fragment){_6.push("#",_7.fragment);}}this.uri=_6.join("");var r=this.uri.match(_2);this.scheme=r[2]||(r[1]?"":n);this.authority=r[4]||(r[3]?"":n);this.path=r[5];this.query=r[7]||(r[6]?"":n);this.fragment=r[9]||(r[8]?"":n);if(this.authority!=n){r=this.authority.match(_3);this.user=r[3]||n;this.password=r[4]||n;this.host=r[6]||r[7];this.port=r[9]||n;}};_4.prototype.toString=function(){return this.uri;};return _1._Url=_4;});
\ No newline at end of file diff --git a/lib/dojo/_base/url.js.uncompressed.js b/lib/dojo/_base/url.js.uncompressed.js new file mode 100644 index 000000000..73f447b54 --- /dev/null +++ b/lib/dojo/_base/url.js.uncompressed.js @@ -0,0 +1,111 @@ +define("dojo/_base/url", ["./kernel"], function(dojo) { + // module: + // dojo/url + // summary: + // This module contains dojo._Url + + var + ore = new RegExp("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$"), + ire = new RegExp("^((([^\\[:]+):)?([^@]+)@)?(\\[([^\\]]+)\\]|([^\\[:]*))(:([0-9]+))?$"), + _Url = function(){ + var n = null, + _a = arguments, + uri = [_a[0]]; + // resolve uri components relative to each other + for(var i = 1; i<_a.length; i++){ + if(!_a[i]){ continue; } + + // Safari doesn't support this.constructor so we have to be explicit + // FIXME: Tracked (and fixed) in Webkit bug 3537. + // http://bugs.webkit.org/show_bug.cgi?id=3537 + var relobj = new _Url(_a[i]+""), + uriobj = new _Url(uri[0]+""); + + if( + relobj.path == "" && + !relobj.scheme && + !relobj.authority && + !relobj.query + ){ + if(relobj.fragment != n){ + uriobj.fragment = relobj.fragment; + } + relobj = uriobj; + }else if(!relobj.scheme){ + relobj.scheme = uriobj.scheme; + + if(!relobj.authority){ + relobj.authority = uriobj.authority; + + if(relobj.path.charAt(0) != "/"){ + var path = uriobj.path.substring(0, + uriobj.path.lastIndexOf("/") + 1) + relobj.path; + + var segs = path.split("/"); + for(var j = 0; j < segs.length; j++){ + if(segs[j] == "."){ + // flatten "./" references + if(j == segs.length - 1){ + segs[j] = ""; + }else{ + segs.splice(j, 1); + j--; + } + }else if(j > 0 && !(j == 1 && segs[0] == "") && + segs[j] == ".." && segs[j-1] != ".."){ + // flatten "../" references + if(j == (segs.length - 1)){ + segs.splice(j, 1); + segs[j - 1] = ""; + }else{ + segs.splice(j - 1, 2); + j -= 2; + } + } + } + relobj.path = segs.join("/"); + } + } + } + + uri = []; + if(relobj.scheme){ + uri.push(relobj.scheme, ":"); + } + if(relobj.authority){ + uri.push("//", relobj.authority); + } + uri.push(relobj.path); + if(relobj.query){ + uri.push("?", relobj.query); + } + if(relobj.fragment){ + uri.push("#", relobj.fragment); + } + } + + this.uri = uri.join(""); + + // break the uri into its main components + var r = this.uri.match(ore); + + this.scheme = r[2] || (r[1] ? "" : n); + this.authority = r[4] || (r[3] ? "" : n); + this.path = r[5]; // can never be undefined + this.query = r[7] || (r[6] ? "" : n); + this.fragment = r[9] || (r[8] ? "" : n); + + if(this.authority != n){ + // server based naming authority + r = this.authority.match(ire); + + this.user = r[3] || n; + this.password = r[4] || n; + this.host = r[6] || r[7]; // ipv6 || ipv4 + this.port = r[9] || n; + } + }; + _Url.prototype.toString = function(){ return this.uri; }; + + return dojo._Url = _Url; +}); diff --git a/lib/dojo/_base/window.js b/lib/dojo/_base/window.js index 143bad610..7082cb077 100644 --- a/lib/dojo/_base/window.js +++ b/lib/dojo/_base/window.js @@ -4,105 +4,5 @@ see: http://dojotoolkit.org/license for details */ - -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.withGlobal = function( /*Object*/globalObject, - /*Function*/callback, - /*Object?*/thisObject, - /*Array?*/cbArguments){ - // summary: - // Invoke callback with globalObject as dojo.global and - // globalObject.document as dojo.doc. - // description: - // Invoke callback with globalObject as dojo.global and - // globalObject.document as dojo.doc. If provided, globalObject - // will be executed in the context of object thisObject - // When callback() returns or throws an error, the dojo.global - // and dojo.doc will be restored to its previous state. - - var oldGlob = dojo.global; - try{ - dojo.global = globalObject; - return dojo.withDoc.call(null, globalObject.document, callback, thisObject, cbArguments); - }finally{ - dojo.global = oldGlob; - } -}; - -dojo.withDoc = function( /*DocumentElement*/documentObject, - /*Function*/callback, - /*Object?*/thisObject, - /*Array?*/cbArguments){ - // summary: - // Invoke callback with documentObject as dojo.doc. - // description: - // Invoke callback with documentObject as dojo.doc. If provided, - // callback will be executed in the context of object thisObject - // When callback() returns or throws an error, the dojo.doc will - // be restored to its previous state. - - var oldDoc = dojo.doc, - oldLtr = dojo._bodyLtr, - oldQ = dojo.isQuirks; - - try{ - dojo.doc = documentObject; - delete dojo._bodyLtr; // uncache - dojo.isQuirks = dojo.doc.compatMode == "BackCompat"; // no need to check for QuirksMode which was Opera 7 only - - if(thisObject && typeof callback == "string"){ - callback = thisObject[callback]; - } - - return callback.apply(thisObject, cbArguments || []); - }finally{ - dojo.doc = oldDoc; - delete dojo._bodyLtr; // in case it was undefined originally, and set to true/false by the alternate document - if(oldLtr !== undefined){ dojo._bodyLtr = oldLtr; } - dojo.isQuirks = oldQ; - } -}; - -} +//>>built +define("dojo/_base/window",["./kernel","../has","./sniff"],function(_1,_2){_1.doc=this["document"]||null;_1.body=function(){return _1.doc.body||_1.doc.getElementsByTagName("body")[0];};_1.setContext=function(_3,_4){_1.global=_5.global=_3;_1.doc=_5.doc=_4;};_1.withGlobal=function(_6,_7,_8,_9){var _a=_1.global;try{_1.global=_5.global=_6;return _1.withDoc.call(null,_6.document,_7,_8,_9);}finally{_1.global=_5.global=_a;}};_1.withDoc=function(_b,_c,_d,_e){var _f=_1.doc,_10=_1.isQuirks,_11=_1.isIE,_12,_13,_14;try{_1.doc=_5.doc=_b;_1.isQuirks=_2.add("quirks",_1.doc.compatMode=="BackCompat",true,true);if(_2("ie")){if((_14=_b.parentWindow)&&_14.navigator){_12=parseFloat(_14.navigator.appVersion.split("MSIE ")[1])||undefined;_13=_b.documentMode;if(_13&&_13!=5&&Math.floor(_12)!=_13){_12=_13;}_1.isIE=_2.add("ie",_12,true,true);}}if(_d&&typeof _c=="string"){_c=_d[_c];}return _c.apply(_d,_e||[]);}finally{_1.doc=_5.doc=_f;_1.isQuirks=_2.add("quirks",_10,true,true);_1.isIE=_2.add("ie",_11,true,true);}};var _5={global:_1.global,doc:_1.doc,body:_1.body,setContext:_1.setContext,withGlobal:_1.withGlobal,withDoc:_1.withDoc};return _5;});
\ No newline at end of file diff --git a/lib/dojo/_base/window.js.uncompressed.js b/lib/dojo/_base/window.js.uncompressed.js new file mode 100644 index 000000000..0c9f236b6 --- /dev/null +++ b/lib/dojo/_base/window.js.uncompressed.js @@ -0,0 +1,126 @@ +define("dojo/_base/window", ["./kernel", "../has", "./sniff"], function(dojo, has){ + // module: + // dojo/window + // summary: + // This module provides an API to save/set/restore the global/document scope. + +/*===== +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 = this["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 = ret.global = globalObject; + dojo.doc = ret.doc = globalDocument; +}; + +dojo.withGlobal = function( /*Object*/globalObject, + /*Function*/callback, + /*Object?*/thisObject, + /*Array?*/cbArguments){ + // summary: + // Invoke callback with globalObject as dojo.global and + // globalObject.document as dojo.doc. + // description: + // Invoke callback with globalObject as dojo.global and + // globalObject.document as dojo.doc. If provided, globalObject + // will be executed in the context of object thisObject + // When callback() returns or throws an error, the dojo.global + // and dojo.doc will be restored to its previous state. + + var oldGlob = dojo.global; + try{ + dojo.global = ret.global = globalObject; + return dojo.withDoc.call(null, globalObject.document, callback, thisObject, cbArguments); + }finally{ + dojo.global = ret.global = oldGlob; + } +}; + +dojo.withDoc = function( /*DocumentElement*/documentObject, + /*Function*/callback, + /*Object?*/thisObject, + /*Array?*/cbArguments){ + // summary: + // Invoke callback with documentObject as dojo.doc. + // description: + // Invoke callback with documentObject as dojo.doc. If provided, + // callback will be executed in the context of object thisObject + // When callback() returns or throws an error, the dojo.doc will + // be restored to its previous state. + + var oldDoc = dojo.doc, + oldQ = dojo.isQuirks, + oldIE = dojo.isIE, isIE, mode, pwin; + + try{ + dojo.doc = ret.doc = documentObject; + // update dojo.isQuirks and the value of the has feature "quirks" + dojo.isQuirks = has.add("quirks", dojo.doc.compatMode == "BackCompat", true, true); // no need to check for QuirksMode which was Opera 7 only + + if(has("ie")){ + if((pwin = documentObject.parentWindow) && pwin.navigator){ + // re-run IE detection logic and update dojo.isIE / has("ie") + // (the only time parentWindow/navigator wouldn't exist is if we were not + // passed an actual legitimate document object) + isIE = parseFloat(pwin.navigator.appVersion.split("MSIE ")[1]) || undefined; + mode = documentObject.documentMode; + if(mode && mode != 5 && Math.floor(isIE) != mode){ + isIE = mode; + } + dojo.isIE = has.add("ie", isIE, true, true); + } + } + + if(thisObject && typeof callback == "string"){ + callback = thisObject[callback]; + } + + return callback.apply(thisObject, cbArguments || []); + }finally{ + dojo.doc = ret.doc = oldDoc; + dojo.isQuirks = has.add("quirks", oldQ, true, true); + dojo.isIE = has.add("ie", oldIE, true, true); + } +}; + +var ret = { + global: dojo.global, + doc: dojo.doc, + body: dojo.body, + setContext: dojo.setContext, + withGlobal: dojo.withGlobal, + withDoc: dojo.withDoc +}; + +return ret; + +}); diff --git a/lib/dojo/_base/xhr.js b/lib/dojo/_base/xhr.js index 58f1fdb62..ee38dbd4f 100644 --- a/lib/dojo/_base/xhr.js +++ b/lib/dojo/_base/xhr.js @@ -4,939 +4,5 @@ see: http://dojotoolkit.org/license for details */ - -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"); -dojo.require("dojo._base.Deferred"); -dojo.require("dojo._base.json"); -dojo.require("dojo._base.lang"); -dojo.require("dojo._base.query"); - - -(function(){ - var _d = dojo, cfg = _d.config; - - 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. - - //Skip it if there is no value - if(value === null){ - return; - } - - var val = obj[name]; - if(typeof val == "string"){ // inline'd type check - obj[name] = [val, value]; - }else if(_d.isArray(val)){ - val.push(value); - }else{ - obj[name] = value; - } - } - - dojo.fieldToObject = function(/*DOMNode||String*/ inputNode){ - // summary: - // Serialize a form field to a JavaScript object. - // - // description: - // Returns the value encoded in a form field as - // as a string or an array of strings. Disabled form elements - // and unchecked radio and checkboxes are skipped. Multi-select - // elements are returned as an array of string values. - var ret = null; - var item = _d.byId(inputNode); - if(item){ - var _in = item.name; - var type = (item.type||"").toLowerCase(); - if(_in && type && !item.disabled){ - if(type == "radio" || type == "checkbox"){ - if(item.checked){ ret = item.value; } - }else if(item.multiple){ - ret = []; - _d.query("option", item).forEach(function(opt){ - if(opt.selected){ - ret.push(opt.value); - } - }); - }else{ - ret = item.value; - } - } - } - return ret; // Object - }; - - dojo.formToObject = function(/*DOMNode||String*/ formNode){ - // summary: - // Serialize a form node to a JavaScript object. - // description: - // 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. - // - // example: - // 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){ - setValue(ret, _in, _d.fieldToObject(item)); - 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: - // Create 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: - // Create an object representing a de-serialized query section of a - // URL. Query keys with multiple values are returned in an array. - // - // example: - // 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(typeof ret[name] == "string"){ // inline'd type check - ret[name] = [ret[name]]; - } - - if(_d.isArray(ret[name])){ - ret[name].push(val); - }else{ - ret[name] = val; - } - } - }); - return ret; // Object - }; - - // 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; - - // MOW: remove dojo._contentHandlers alias in 2.0 - var handlers = _d._contentHandlers = dojo.contentHandlers = { - // summary: - // A map of availble XHR transport handle types. Name matches the - // `handleAs` attribute passed to XHR calls. - // - // description: - // A map of availble XHR transport handle types. Name matches the - // `handleAs` attribute passed to XHR calls. Each contentHandler is - // called, passing the xhr object for manipulation. The return value - // from the contentHandler will be passed to the `load` or `handle` - // functions defined in the original xhr call. - // - // example: - // Creating a custom content-handler: - // | dojo.contentHandlers.makeCaps = function(xhr){ - // | return xhr.responseText.toUpperCase(); - // | } - // | // and later: - // | dojo.xhrGet({ - // | url:"foo.txt", - // | handleAs:"makeCaps", - // | load: function(data){ /* data is a toUpper version of foo.txt */ } - // | }); - - text: function(xhr){ - // summary: A contentHandler which simply returns the plaintext response data - return xhr.responseText; - }, - json: function(xhr){ - // summary: A contentHandler which returns a JavaScript object created from the response data - return _d.fromJson(xhr.responseText || null); - }, - "json-comment-filtered": function(xhr){ - // summary: A contentHandler which expects comment-filtered JSON. - // description: - // A contentHandler which expects comment-filtered JSON. - // 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. - // - // Will throw a notice suggesting to use application/json mimetype, as - // json-commenting can introduce security issues. To decrease the chances of hijacking, - // use the standard `json` contentHandler, and prefix your "JSON" with: {}&& - // - // use djConfig.useCommentedJson = true to turn off the notice - 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){ - // summary: A contentHandler which evaluates the response data, expecting it to be valid JavaScript - - // FIXME: try Moz and IE specific eval variants? - return _d.eval(xhr.responseText); - }, - xml: function(xhr){ - // summary: A contentHandler returning an XML Document parsed from the response data - var result = xhr.responseXML; - if(_d.isIE && (!result || !result.documentElement)){ - //WARNING: this branch used by the xml handling in dojo.io.iframe, - //so be sure to test dojo.io.iframe if making changes below. - var ms = function(n){ return "MSXML" + n + ".DOMDocument"; }; - var dp = ["Microsoft.XMLDOM", ms(6), ms(4), ms(3), ms(2)]; - _d.some(dp, function(p){ - try{ - var dom = new ActiveXObject(p); - dom.async = false; - dom.loadXML(xhr.responseText); - result = dom; - }catch(e){ return false; } - return true; - }); - } - return result; // DOMDocument - }, - "json-comment-optional": function(xhr){ - // summary: A contentHandler which checks the presence of comment-filtered JSON and - // alternates between the `json` and `json-comment-filtered` contentHandlers. - if(xhr.responseText && /^[^{\[]*\/\*/.test(xhr.responseText)){ - 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). - // rawBody: String? - // Sets the raw body for an HTTP request. If this is used, then the content - // property is ignored. This is mostly useful for HTTP methods that have - // a body to their requests, like PUT or POST. This property can be used instead - // of postData and putData for dojo.rawXhrPost and dojo.rawXhrPut respectively. - // ioPublish: Boolean? - // Set this explicitly to false to prevent publishing of topics related to - // IO operations. Otherwise, if djConfig.ioPublish is set to true, topics - // will be published via dojo.publish for different phases of an IO operation. - // See dojo.__IoPublish for a list of topics that are published. - // load: Function? - // This function will be - // called on a successful HTTP response code. - // error: Function? - // 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.debugAtAllCosts 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? - // 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.ioPublish = ioPublish; - this.load = function(response, ioArgs){ - // ioArgs: dojo.__IoCallbackArgs - // Provides additional information about the request. - // response: Object - // The response in the format as defined with handleAs. - } - this.error = function(response, ioArgs){ - // ioArgs: dojo.__IoCallbackArgs - // Provides additional information about the request. - // response: Object - // The response in the format as defined with handleAs. - } - this.handle = function(loadOrError, response, ioArgs){ - // loadOrError: String - // Provides a string that tells you whether this function - // was called because of success (load) or failure (error). - // response: Object - // The response in the format as defined with handleAs. - // ioArgs: dojo.__IoCallbackArgs - // Provides additional information about the request. - } - } - =====*/ - - /*===== - 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.__IoPublish = function(){ - // summary: - // This is a list of IO topics that can be published - // if djConfig.ioPublish is set to true. IO topics can be - // published for any Input/Output, network operation. So, - // dojo.xhr, dojo.io.script and dojo.io.iframe can all - // trigger these topics to be published. - // start: String - // "/dojo/io/start" is sent when there are no outstanding IO - // requests, and a new IO request is started. No arguments - // are passed with this topic. - // send: String - // "/dojo/io/send" is sent whenever a new IO request is started. - // It passes the dojo.Deferred for the request with the topic. - // load: String - // "/dojo/io/load" is sent whenever an IO request has loaded - // successfully. It passes the response and the dojo.Deferred - // for the request with the topic. - // error: String - // "/dojo/io/error" is sent whenever an IO request has errored. - // It passes the error and the dojo.Deferred - // for the request with the topic. - // done: String - // "/dojo/io/done" is sent whenever an IO request has completed, - // either by loading or by erroring. It passes the error and - // the dojo.Deferred for the request with the topic. - // stop: String - // "/dojo/io/stop" is sent when all outstanding IO requests have - // finished. No arguments are passed with this topic. - this.start = "/dojo/io/start"; - this.send = "/dojo/io/send"; - this.load = "/dojo/io/load"; - this.error = "/dojo/io/error"; - this.done = "/dojo/io/done"; - this.stop = "/dojo/io/stop"; - } - =====*/ - - - 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); - }); - } - - //Plug in topic publishing, if dojo.publish is loaded. - if(cfg.ioPublish && _d.publish && ioArgs.args.ioPublish !== false){ - d.addCallbacks( - function(res){ - _d.publish("/dojo/io/load", [d, res]); - return res; - }, - function(res){ - _d.publish("/dojo/io/error", [d, res]); - return res; - } - ); - d.addBoth(function(res){ - _d.publish("/dojo/io/done", [d, res]); - return res; - }); - } - - 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 = handlers[dfd.ioArgs.handleAs](dfd.ioArgs.xhr); - return ret === undefined ? null : ret; - }; - var _deferError = function(/*Error*/error, /*Deferred*/dfd){ - // summary: errHandler function for dojo._ioSetArgs call. - - if(!dfd.ioArgs.args.failOk){ - console.error(error); - } - 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 = []; - - - //Use a separate count for knowing if we are starting/stopping io calls. - //Cannot use _inFlight.length since it can change at a different time than - //when we want to do this kind of test. We only want to decrement the count - //after a callback/errback has finished, since the callback/errback should be - //considered as part of finishing a request. - var _pubCount = 0; - var _checkPubCount = function(dfd){ - if(_pubCount <= 0){ - _pubCount = 0; - if(cfg.ioPublish && _d.publish && (!dfd || dfd && dfd.ioArgs.args.ioPublish !== false)){ - _d.publish("/dojo/io/stop"); - } - } - }; - - 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); - _pubCount -= 1; - }else if(tif.ioCheck(dfd)){ - _inFlight.splice(i--, 1); - tif.resHandle(dfd); - _pubCount -= 1; - }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(); - _pubCount -= 1; - } - } - }; - if(dojo.config.debugAtAllCosts){ - func.call(this); - }else{ - try{ - func.call(this); - }catch(e){ - dfd.errback(e); - } - } - } - } - - _checkPubCount(dfd); - - 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._ioNotifyStart = function(/*Deferred*/dfd){ - // summary: - // If dojo.publish is available, publish topics - // about the start of a request queue and/or the - // the beginning of request. - // description: - // Used by IO transports. An IO transport should - // call this method before making the network connection. - if(cfg.ioPublish && _d.publish && dfd.ioArgs.args.ioPublish !== false){ - if(!_pubCount){ - _d.publish("/dojo/io/start"); - } - _pubCount += 1; - _d.publish("/dojo/io/send", [dfd]); - } - }; - - _d._ioWatch = function(dfd, validCheck, ioCheck, resHandle){ - // summary: - // Watches the io request represented by dfd to see if it completes. - // dfd: Deferred - // The Deferred object to watch. - // validCheck: Function - // Function used to check if the IO request is still valid. Gets the dfd - // object as its only argument. - // ioCheck: Function - // Function used to check if basic IO call worked. Gets the dfd - // object as its only argument. - // resHandle: Function - // Function used to process response. Gets the dfd - // object as its only argument. - var args = dfd.ioArgs.args; - if(args.timeout){ - dfd.startTime = (new Date()).getTime(); - } - - _inFlight.push({dfd: dfd, validCheck: validCheck, ioCheck: ioCheck, resHandle: resHandle}); - if(!_inFlightIntvl){ - _inFlightIntvl = setInterval(_watchInFlight, 50); - } - // handle sync requests - //A weakness: async calls in flight - //could have their handlers called as part of the - //_watchInFlight call, before the sync's callbacks - // are called. - if(args.sync){ - _watchInFlight(); - } - }; - - 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. See `dojo.contentHandlers` - // 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. - // failOk: Boolean? - // false is default. Indicates whether a request should be - // allowed to fail (and therefore no console error message in - // the event of a failure) - this.handleAs = handleAs; - this.sync = sync; - this.headers = headers; - this.failOk = failOk; - } - }); - =====*/ - - 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); - var ioArgs = dfd.ioArgs; - - //Pass the args to _xhrObj, to allow alternate XHR calls based specific calls, like - //the one used for iframe proxies. - var xhr = ioArgs.xhr = _d._xhrObj(ioArgs.args); - //If XHR factory fails, cancel the deferred. - if(!xhr){ - dfd.cancel(); - return dfd; - } - - //Allow for specifying the HTTP body completely. - if("postData" in args){ - ioArgs.query = args.postData; - }else if("putData" in args){ - ioArgs.query = args.putData; - }else if("rawBody" in args){ - ioArgs.query = args.rawBody; - }else if((arguments.length > 2 && !hasBody) || "POST|PUT".indexOf(method.toUpperCase()) == -1){ - //Check for hasBody being passed. If no hasBody, - //then only append query string if not a POST or PUT request. - _d._ioAddQueryToUrl(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" - 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 if(args.headers[hdr]){ - //Only add header if it has a value. This allows for instnace, skipping - //insertion of X-Requested-With by specifying empty value. - xhr.setRequestHeader(hdr, args.headers[hdr]); - } - } - } - // FIXME: is this appropriate for all content types? - xhr.setRequestHeader("Content-Type", args.contentType || _defaultContentType); - if(!args.headers || !("X-Requested-With" in args.headers)){ - xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest"); - } - // FIXME: set other headers here! - _d._ioNotifyStart(dfd); - if(dojo.config.debugAtAllCosts){ - xhr.send(ioArgs.query); - }else{ - try{ - xhr.send(ioArgs.query); - }catch(e){ - 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"); - } - */ -})(); - -} +//>>built +define("dojo/_base/xhr",["./kernel","./sniff","require","../io-query","../dom","../dom-form","./Deferred","./json","./lang","./array","../on"],function(_1,_2,_3,_4,_5,_6,_7,_8,_9,_a,on){_2.add("native-xhr",function(){return typeof XMLHttpRequest!=="undefined";});if(1&&_3.getXhr){_1._xhrObj=_3.getXhr;}else{if(_2("native-xhr")){_1._xhrObj=function(){try{return new XMLHttpRequest();}catch(e){throw new Error("XMLHTTP not available: "+e);}};}else{for(var _b=["Msxml2.XMLHTTP","Microsoft.XMLHTTP","Msxml2.XMLHTTP.4.0"],_c,i=0;i<3;){try{_c=_b[i++];if(new ActiveXObject(_c)){break;}}catch(e){}}_1._xhrObj=function(){return new ActiveXObject(_c);};}}var _d=_1.config;_1.objectToQuery=_4.objectToQuery;_1.queryToObject=_4.queryToObject;_1.fieldToObject=_6.fieldToObject;_1.formToObject=_6.toObject;_1.formToQuery=_6.toQuery;_1.formToJson=_6.toJson;_1._blockAsync=false;var _e=_1._contentHandlers=_1.contentHandlers={"text":function(_f){return _f.responseText;},"json":function(xhr){return _8.fromJson(xhr.responseText||null);},"json-comment-filtered":function(xhr){if(!_1.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 _10=xhr.responseText;var _11=_10.indexOf("/*");var _12=_10.lastIndexOf("*/");if(_11==-1||_12==-1){throw new Error("JSON was not comment filtered");}return _8.fromJson(_10.substring(_11+2,_12));},"javascript":function(xhr){return _1.eval(xhr.responseText);},"xml":function(xhr){var _13=xhr.responseXML;if(_2("ie")){if((!_13||!_13.documentElement)){var ms=function(n){return "MSXML"+n+".DOMDocument";};var dp=["Microsoft.XMLDOM",ms(6),ms(4),ms(3),ms(2)];_a.some(dp,function(p){try{var dom=new ActiveXObject(p);dom.async=false;dom.loadXML(xhr.responseText);_13=dom;}catch(e){return false;}return true;});}}return _13;},"json-comment-optional":function(xhr){if(xhr.responseText&&/^[^{\[]*\/\*/.test(xhr.responseText)){return _e["json-comment-filtered"](xhr);}else{return _e["json"](xhr);}}};_1._ioSetArgs=function(_14,_15,_16,_17){var _18={args:_14,url:_14.url};var _19=null;if(_14.form){var _1a=_5.byId(_14.form);var _1b=_1a.getAttributeNode("action");_18.url=_18.url||(_1b?_1b.value:null);_19=_6.toObject(_1a);}var _1c=[{}];if(_19){_1c.push(_19);}if(_14.content){_1c.push(_14.content);}if(_14.preventCache){_1c.push({"dojo.preventCache":new Date().valueOf()});}_18.query=_4.objectToQuery(_9.mixin.apply(null,_1c));_18.handleAs=_14.handleAs||"text";var d=new _7(_15);d.addCallbacks(_16,function(_1d){return _17(_1d,d);});var ld=_14.load;if(ld&&_9.isFunction(ld)){d.addCallback(function(_1e){return ld.call(_14,_1e,_18);});}var err=_14.error;if(err&&_9.isFunction(err)){d.addErrback(function(_1f){return err.call(_14,_1f,_18);});}var _20=_14.handle;if(_20&&_9.isFunction(_20)){d.addBoth(function(_21){return _20.call(_14,_21,_18);});}if(_d.ioPublish&&_1.publish&&_18.args.ioPublish!==false){d.addCallbacks(function(res){_1.publish("/dojo/io/load",[d,res]);return res;},function(res){_1.publish("/dojo/io/error",[d,res]);return res;});d.addBoth(function(res){_1.publish("/dojo/io/done",[d,res]);return res;});}d.ioArgs=_18;return d;};var _22=function(dfd){dfd.canceled=true;var xhr=dfd.ioArgs.xhr;var _23=typeof xhr.abort;if(_23=="function"||_23=="object"||_23=="unknown"){xhr.abort();}var err=dfd.ioArgs.error;if(!err){err=new Error("xhr cancelled");err.dojoType="cancel";}return err;};var _24=function(dfd){var ret=_e[dfd.ioArgs.handleAs](dfd.ioArgs.xhr);return ret===undefined?null:ret;};var _25=function(_26,dfd){if(!dfd.ioArgs.args.failOk){console.error(_26);}return _26;};var _27=null;var _28=[];var _29=0;var _2a=function(dfd){if(_29<=0){_29=0;if(_d.ioPublish&&_1.publish&&(!dfd||dfd&&dfd.ioArgs.args.ioPublish!==false)){_1.publish("/dojo/io/stop");}}};var _2b=function(){var now=(new Date()).getTime();if(!_1._blockAsync){for(var i=0,tif;i<_28.length&&(tif=_28[i]);i++){var dfd=tif.dfd;var _2c=function(){if(!dfd||dfd.canceled||!tif.validCheck(dfd)){_28.splice(i--,1);_29-=1;}else{if(tif.ioCheck(dfd)){_28.splice(i--,1);tif.resHandle(dfd);_29-=1;}else{if(dfd.startTime){if(dfd.startTime+(dfd.ioArgs.args.timeout||0)<now){_28.splice(i--,1);var err=new Error("timeout exceeded");err.dojoType="timeout";dfd.errback(err);dfd.cancel();_29-=1;}}}}};if(_1.config.debugAtAllCosts){_2c.call(this);}else{try{_2c.call(this);}catch(e){dfd.errback(e);}}}}_2a(dfd);if(!_28.length){clearInterval(_27);_27=null;}};_1._ioCancelAll=function(){try{_a.forEach(_28,function(i){try{i.dfd.cancel();}catch(e){}});}catch(e){}};if(_2("ie")){on(window,"unload",_1._ioCancelAll);}_1._ioNotifyStart=function(dfd){if(_d.ioPublish&&_1.publish&&dfd.ioArgs.args.ioPublish!==false){if(!_29){_1.publish("/dojo/io/start");}_29+=1;_1.publish("/dojo/io/send",[dfd]);}};_1._ioWatch=function(dfd,_2d,_2e,_2f){var _30=dfd.ioArgs.args;if(_30.timeout){dfd.startTime=(new Date()).getTime();}_28.push({dfd:dfd,validCheck:_2d,ioCheck:_2e,resHandle:_2f});if(!_27){_27=setInterval(_2b,50);}if(_30.sync){_2b();}};var _31="application/x-www-form-urlencoded";var _32=function(dfd){return dfd.ioArgs.xhr.readyState;};var _33=function(dfd){return 4==dfd.ioArgs.xhr.readyState;};var _34=function(dfd){var xhr=dfd.ioArgs.xhr;if(_1._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;err.xhr=xhr;dfd.errback(err);}};_1._ioAddQueryToUrl=function(_35){if(_35.query.length){_35.url+=(_35.url.indexOf("?")==-1?"?":"&")+_35.query;_35.query=null;}};_1.xhr=function(_36,_37,_38){var dfd=_1._ioSetArgs(_37,_22,_24,_25);var _39=dfd.ioArgs;var xhr=_39.xhr=_1._xhrObj(_39.args);if(!xhr){dfd.cancel();return dfd;}if("postData" in _37){_39.query=_37.postData;}else{if("putData" in _37){_39.query=_37.putData;}else{if("rawBody" in _37){_39.query=_37.rawBody;}else{if((arguments.length>2&&!_38)||"POST|PUT".indexOf(_36.toUpperCase())==-1){_1._ioAddQueryToUrl(_39);}}}}xhr.open(_36,_39.url,_37.sync!==true,_37.user||undefined,_37.password||undefined);if(_37.headers){for(var hdr in _37.headers){if(hdr.toLowerCase()==="content-type"&&!_37.contentType){_37.contentType=_37.headers[hdr];}else{if(_37.headers[hdr]){xhr.setRequestHeader(hdr,_37.headers[hdr]);}}}}if(_37.contentType!==false){xhr.setRequestHeader("Content-Type",_37.contentType||_31);}if(!_37.headers||!("X-Requested-With" in _37.headers)){xhr.setRequestHeader("X-Requested-With","XMLHttpRequest");}_1._ioNotifyStart(dfd);if(_1.config.debugAtAllCosts){xhr.send(_39.query);}else{try{xhr.send(_39.query);}catch(e){_39.error=e;dfd.cancel();}}_1._ioWatch(dfd,_32,_33,_34);xhr=null;return dfd;};_1.xhrGet=function(_3a){return _1.xhr("GET",_3a);};_1.rawXhrPost=_1.xhrPost=function(_3b){return _1.xhr("POST",_3b,true);};_1.rawXhrPut=_1.xhrPut=function(_3c){return _1.xhr("PUT",_3c,true);};_1.xhrDelete=function(_3d){return _1.xhr("DELETE",_3d);};_1._isDocumentOk=function(_3e){var _3f=_3e.status||0;_3f=(_3f>=200&&_3f<300)||_3f==304||_3f==1223||!_3f;return _3f;};_1._getText=function(url){var _40;_1.xhrGet({url:url,sync:true,load:function(_41){_40=_41;}});return _40;};_9.mixin(_1.xhr,{_xhrObj:_1._xhrObj,fieldToObject:_6.fieldToObject,formToObject:_6.toObject,objectToQuery:_4.objectToQuery,formToQuery:_6.toQuery,formToJson:_6.toJson,queryToObject:_4.queryToObject,contentHandlers:_e,_ioSetArgs:_1._ioSetArgs,_ioCancelAll:_1._ioCancelAll,_ioNotifyStart:_1._ioNotifyStart,_ioWatch:_1._ioWatch,_ioAddQueryToUrl:_1._ioAddQueryToUrl,_isDocumentOk:_1._isDocumentOk,_getText:_1._getText,get:_1.xhrGet,post:_1.xhrPost,put:_1.xhrPut,del:_1.xhrDelete});return _1.xhr;});
\ No newline at end of file diff --git a/lib/dojo/_base/xhr.js.uncompressed.js b/lib/dojo/_base/xhr.js.uncompressed.js new file mode 100644 index 000000000..94f5c78b1 --- /dev/null +++ b/lib/dojo/_base/xhr.js.uncompressed.js @@ -0,0 +1,830 @@ +define("dojo/_base/xhr", [ + "./kernel", "./sniff", "require", "../io-query", "../dom", "../dom-form", "./Deferred", "./json", "./lang", "./array", "../on" +], function(dojo, has, require, ioq, dom, domForm, deferred, json, lang, array, on){ + // module: + // dojo/_base.xhr + // summary: + // This modules defines the dojo.xhr* API. + + has.add("native-xhr", function() { + // if true, the environment has a native XHR implementation + return typeof XMLHttpRequest !== 'undefined'; + }); + + if(1 && require.getXhr){ + dojo._xhrObj = require.getXhr; + }else if (has("native-xhr")){ + dojo._xhrObj = function(){ + // summary: + // does the work of portably generating a new XMLHTTPRequest object. + try{ + return new XMLHttpRequest(); + }catch(e){ + throw new Error("XMLHTTP not available: "+e); + } + }; + }else{ + // PROGIDs are in order of decreasing likelihood; this will change in time. + for(var XMLHTTP_PROGIDS = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'], progid, i = 0; i < 3;){ + try{ + progid = XMLHTTP_PROGIDS[i++]; + if (new ActiveXObject(progid)) { + // this progid works; therefore, use it from now on + break; + } + }catch(e){ + // squelch; we're just trying to find a good ActiveX PROGID + // if they all fail, then progid ends up as the last attempt and that will signal the error + // the first time the client actually tries to exec an xhr + } + } + dojo._xhrObj= function() { + return new ActiveXObject(progid); + }; + } + + var cfg = dojo.config; + + // mix in io-query and dom-form + dojo.objectToQuery = ioq.objectToQuery; + dojo.queryToObject = ioq.queryToObject; + dojo.fieldToObject = domForm.fieldToObject; + dojo.formToObject = domForm.toObject; + dojo.formToQuery = domForm.toQuery; + dojo.formToJson = domForm.toJson; + + // 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; + + // MOW: remove dojo._contentHandlers alias in 2.0 + var handlers = dojo._contentHandlers = dojo.contentHandlers = { + // summary: + // A map of availble XHR transport handle types. Name matches the + // `handleAs` attribute passed to XHR calls. + // + // description: + // A map of availble XHR transport handle types. Name matches the + // `handleAs` attribute passed to XHR calls. Each contentHandler is + // called, passing the xhr object for manipulation. The return value + // from the contentHandler will be passed to the `load` or `handle` + // functions defined in the original xhr call. + // + // example: + // Creating a custom content-handler: + // | dojo.contentHandlers.makeCaps = function(xhr){ + // | return xhr.responseText.toUpperCase(); + // | } + // | // and later: + // | dojo.xhrGet({ + // | url:"foo.txt", + // | handleAs:"makeCaps", + // | load: function(data){ /* data is a toUpper version of foo.txt */ } + // | }); + + "text": function(xhr){ + // summary: A contentHandler which simply returns the plaintext response data + return xhr.responseText; + }, + "json": function(xhr){ + // summary: A contentHandler which returns a JavaScript object created from the response data + return json.fromJson(xhr.responseText || null); + }, + "json-comment-filtered": function(xhr){ + // summary: A contentHandler which expects comment-filtered JSON. + // description: + // A contentHandler which expects comment-filtered JSON. + // 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. + // + // Will throw a notice suggesting to use application/json mimetype, as + // json-commenting can introduce security issues. To decrease the chances of hijacking, + // use the standard `json` contentHandler, and prefix your "JSON" with: {}&& + // + // use djConfig.useCommentedJson = true to turn off the notice + 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 json.fromJson(value.substring(cStartIdx+2, cEndIdx)); + }, + "javascript": function(xhr){ + // summary: A contentHandler which evaluates the response data, expecting it to be valid JavaScript + + // FIXME: try Moz and IE specific eval variants? + return dojo.eval(xhr.responseText); + }, + "xml": function(xhr){ + // summary: A contentHandler returning an XML Document parsed from the response data + var result = xhr.responseXML; + + if(has("ie")){ + if((!result || !result.documentElement)){ + //WARNING: this branch used by the xml handling in dojo.io.iframe, + //so be sure to test dojo.io.iframe if making changes below. + var ms = function(n){ return "MSXML" + n + ".DOMDocument"; }; + var dp = ["Microsoft.XMLDOM", ms(6), ms(4), ms(3), ms(2)]; + array.some(dp, function(p){ + try{ + var dom = new ActiveXObject(p); + dom.async = false; + dom.loadXML(xhr.responseText); + result = dom; + }catch(e){ return false; } + return true; + }); + } + } + return result; // DOMDocument + }, + "json-comment-optional": function(xhr){ + // summary: A contentHandler which checks the presence of comment-filtered JSON and + // alternates between the `json` and `json-comment-filtered` contentHandlers. + if(xhr.responseText && /^[^{\[]*\/\*/.test(xhr.responseText)){ + 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). + // rawBody: String? + // Sets the raw body for an HTTP request. If this is used, then the content + // property is ignored. This is mostly useful for HTTP methods that have + // a body to their requests, like PUT or POST. This property can be used instead + // of postData and putData for dojo.rawXhrPost and dojo.rawXhrPut respectively. + // ioPublish: Boolean? + // Set this explicitly to false to prevent publishing of topics related to + // IO operations. Otherwise, if djConfig.ioPublish is set to true, topics + // will be published via dojo.publish for different phases of an IO operation. + // See dojo.__IoPublish for a list of topics that are published. + // load: Function? + // This function will be + // called on a successful HTTP response code. + // error: Function? + // 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.debugAtAllCosts 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? + // 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.ioPublish = ioPublish; + this.load = function(response, ioArgs){ + // ioArgs: dojo.__IoCallbackArgs + // Provides additional information about the request. + // response: Object + // The response in the format as defined with handleAs. + } + this.error = function(response, ioArgs){ + // ioArgs: dojo.__IoCallbackArgs + // Provides additional information about the request. + // response: Object + // The response in the format as defined with handleAs. + } + this.handle = function(loadOrError, response, ioArgs){ + // loadOrError: String + // Provides a string that tells you whether this function + // was called because of success (load) or failure (error). + // response: Object + // The response in the format as defined with handleAs. + // ioArgs: dojo.__IoCallbackArgs + // Provides additional information about the request. + } + } + =====*/ + + /*===== + 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.__IoPublish = function(){ + // summary: + // This is a list of IO topics that can be published + // if djConfig.ioPublish is set to true. IO topics can be + // published for any Input/Output, network operation. So, + // dojo.xhr, dojo.io.script and dojo.io.iframe can all + // trigger these topics to be published. + // start: String + // "/dojo/io/start" is sent when there are no outstanding IO + // requests, and a new IO request is started. No arguments + // are passed with this topic. + // send: String + // "/dojo/io/send" is sent whenever a new IO request is started. + // It passes the dojo.Deferred for the request with the topic. + // load: String + // "/dojo/io/load" is sent whenever an IO request has loaded + // successfully. It passes the response and the dojo.Deferred + // for the request with the topic. + // error: String + // "/dojo/io/error" is sent whenever an IO request has errored. + // It passes the error and the dojo.Deferred + // for the request with the topic. + // done: String + // "/dojo/io/done" is sent whenever an IO request has completed, + // either by loading or by erroring. It passes the error and + // the dojo.Deferred for the request with the topic. + // stop: String + // "/dojo/io/stop" is sent when all outstanding IO requests have + // finished. No arguments are passed with this topic. + this.start = "/dojo/io/start"; + this.send = "/dojo/io/send"; + this.load = "/dojo/io/load"; + this.error = "/dojo/io/error"; + this.done = "/dojo/io/done"; + this.stop = "/dojo/io/stop"; + } + =====*/ + + + 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 = dom.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 = domForm.toObject(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 = ioq.objectToQuery(lang.mixin.apply(null, miArgs)); + + // .. and the real work of getting the deferred in order, etc. + ioArgs.handleAs = args.handleAs || "text"; + var d = new 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 && lang.isFunction(ld)){ + d.addCallback(function(value){ + return ld.call(args, value, ioArgs); + }); + } + var err = args.error; + if(err && lang.isFunction(err)){ + d.addErrback(function(value){ + return err.call(args, value, ioArgs); + }); + } + var handle = args.handle; + if(handle && lang.isFunction(handle)){ + d.addBoth(function(value){ + return handle.call(args, value, ioArgs); + }); + } + + //Plug in topic publishing, if dojo.publish is loaded. + if(cfg.ioPublish && dojo.publish && ioArgs.args.ioPublish !== false){ + d.addCallbacks( + function(res){ + dojo.publish("/dojo/io/load", [d, res]); + return res; + }, + function(res){ + dojo.publish("/dojo/io/error", [d, res]); + return res; + } + ); + d.addBoth(function(res){ + dojo.publish("/dojo/io/done", [d, res]); + return res; + }); + } + + 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 = handlers[dfd.ioArgs.handleAs](dfd.ioArgs.xhr); + return ret === undefined ? null : ret; + }; + var _deferError = function(/*Error*/error, /*Deferred*/dfd){ + // summary: errHandler function for dojo._ioSetArgs call. + + if(!dfd.ioArgs.args.failOk){ + console.error(error); + } + 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 = []; + + + //Use a separate count for knowing if we are starting/stopping io calls. + //Cannot use _inFlight.length since it can change at a different time than + //when we want to do this kind of test. We only want to decrement the count + //after a callback/errback has finished, since the callback/errback should be + //considered as part of finishing a request. + var _pubCount = 0; + var _checkPubCount = function(dfd){ + if(_pubCount <= 0){ + _pubCount = 0; + if(cfg.ioPublish && dojo.publish && (!dfd || dfd && dfd.ioArgs.args.ioPublish !== false)){ + dojo.publish("/dojo/io/stop"); + } + } + }; + + 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(!dojo._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); + _pubCount -= 1; + }else if(tif.ioCheck(dfd)){ + _inFlight.splice(i--, 1); + tif.resHandle(dfd); + _pubCount -= 1; + }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(); + _pubCount -= 1; + } + } + }; + if(dojo.config.debugAtAllCosts){ + func.call(this); + }else{ + try{ + func.call(this); + }catch(e){ + dfd.errback(e); + } + } + } + } + + _checkPubCount(dfd); + + if(!_inFlight.length){ + clearInterval(_inFlightIntvl); + _inFlightIntvl = null; + } + }; + + dojo._ioCancelAll = function(){ + //summary: Cancels all pending IO requests, regardless of IO type + //(xhr, script, iframe). + try{ + array.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(has("ie")){ + on(window, "unload", dojo._ioCancelAll); + } + + dojo._ioNotifyStart = function(/*Deferred*/dfd){ + // summary: + // If dojo.publish is available, publish topics + // about the start of a request queue and/or the + // the beginning of request. + // description: + // Used by IO transports. An IO transport should + // call this method before making the network connection. + if(cfg.ioPublish && dojo.publish && dfd.ioArgs.args.ioPublish !== false){ + if(!_pubCount){ + dojo.publish("/dojo/io/start"); + } + _pubCount += 1; + dojo.publish("/dojo/io/send", [dfd]); + } + }; + + dojo._ioWatch = function(dfd, validCheck, ioCheck, resHandle){ + // summary: + // Watches the io request represented by dfd to see if it completes. + // dfd: Deferred + // The Deferred object to watch. + // validCheck: Function + // Function used to check if the IO request is still valid. Gets the dfd + // object as its only argument. + // ioCheck: Function + // Function used to check if basic IO call worked. Gets the dfd + // object as its only argument. + // resHandle: Function + // Function used to process response. Gets the dfd + // object as its only argument. + var args = dfd.ioArgs.args; + if(args.timeout){ + dfd.startTime = (new Date()).getTime(); + } + + _inFlight.push({dfd: dfd, validCheck: validCheck, ioCheck: ioCheck, resHandle: resHandle}); + if(!_inFlightIntvl){ + _inFlightIntvl = setInterval(_watchInFlight, 50); + } + // handle sync requests + //A weakness: async calls in flight + //could have their handlers called as part of the + //_watchInFlight call, before the sync's callbacks + // are called. + if(args.sync){ + _watchInFlight(); + } + }; + + 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(dojo._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; + err.xhr = xhr; + 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. See `dojo.contentHandlers` + // 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. + // failOk: Boolean? + // false is default. Indicates whether a request should be + // allowed to fail (and therefore no console error message in + // the event of a failure) + // contentType: String|Boolean + // "application/x-www-form-urlencoded" is default. Set to false to + // prevent a Content-Type header from being sent, or to a string + // to send a different Content-Type. + this.handleAs = handleAs; + this.sync = sync; + this.headers = headers; + this.failOk = failOk; + } + }); + =====*/ + + 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 = dojo._ioSetArgs(args, _deferredCancel, _deferredOk, _deferError); + var ioArgs = dfd.ioArgs; + + //Pass the args to _xhrObj, to allow alternate XHR calls based specific calls, like + //the one used for iframe proxies. + var xhr = ioArgs.xhr = dojo._xhrObj(ioArgs.args); + //If XHR factory fails, cancel the deferred. + if(!xhr){ + dfd.cancel(); + return dfd; + } + + //Allow for specifying the HTTP body completely. + if("postData" in args){ + ioArgs.query = args.postData; + }else if("putData" in args){ + ioArgs.query = args.putData; + }else if("rawBody" in args){ + ioArgs.query = args.rawBody; + }else if((arguments.length > 2 && !hasBody) || "POST|PUT".indexOf(method.toUpperCase()) == -1){ + //Check for hasBody being passed. If no hasBody, + //then only append query string if not a POST or PUT request. + dojo._ioAddQueryToUrl(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" + 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 if(args.headers[hdr]){ + //Only add header if it has a value. This allows for instnace, skipping + //insertion of X-Requested-With by specifying empty value. + xhr.setRequestHeader(hdr, args.headers[hdr]); + } + } + } + // FIXME: is this appropriate for all content types? + if(args.contentType !== false){ + xhr.setRequestHeader("Content-Type", args.contentType || _defaultContentType); + } + if(!args.headers || !("X-Requested-With" in args.headers)){ + xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest"); + } + // FIXME: set other headers here! + dojo._ioNotifyStart(dfd); + if(dojo.config.debugAtAllCosts){ + xhr.send(ioArgs.query); + }else{ + try{ + xhr.send(ioArgs.query); + }catch(e){ + ioArgs.error = e; + dfd.cancel(); + } + } + dojo._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 dojo.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 dojo.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 dojo.xhr("PUT", args, true); // dojo.Deferred + }; + + dojo.xhrDelete = function(/*dojo.__XhrArgs*/ args){ + // summary: + // Sends an HTTP DELETE request to the server. + return dojo.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"); + } + */ + + dojo._isDocumentOk = function(http){ + var stat = http.status || 0; + stat = + (stat >= 200 && stat < 300) || // allow any 2XX response code + stat == 304 || // or, get it out of the cache + stat == 1223 || // or, Internet Explorer mangled the status code + !stat; // or, we're Titanium/browser chrome/chrome extension requesting a local file + return stat; // Boolean + }; + + dojo._getText = function(url){ + var result; + dojo.xhrGet({url:url, sync:true, load:function(text){ + result = text; + }}); + return result; + }; + + // Add aliases for static functions to dojo.xhr since dojo.xhr is what's returned from this module + lang.mixin(dojo.xhr, { + _xhrObj: dojo._xhrObj, + fieldToObject: domForm.fieldToObject, + formToObject: domForm.toObject, + objectToQuery: ioq.objectToQuery, + formToQuery: domForm.toQuery, + formToJson: domForm.toJson, + queryToObject: ioq.queryToObject, + contentHandlers: handlers, + _ioSetArgs: dojo._ioSetArgs, + _ioCancelAll: dojo._ioCancelAll, + _ioNotifyStart: dojo._ioNotifyStart, + _ioWatch: dojo._ioWatch, + _ioAddQueryToUrl: dojo._ioAddQueryToUrl, + _isDocumentOk: dojo._isDocumentOk, + _getText: dojo._getText, + get: dojo.xhrGet, + post: dojo.xhrPost, + put: dojo.xhrPut, + del: dojo.xhrDelete // because "delete" is a reserved word + }); + + return dojo.xhr; +}); |