From f0cfe83e3725f9a3928da97a6e3085e79cb25309 Mon Sep 17 00:00:00 2001 From: Andrew Dolgov Date: Mon, 18 Mar 2013 10:26:24 +0400 Subject: upgrade dojo to 1.8.3 (refs #570) --- lib/dojo/_base/Color.js | 2 +- lib/dojo/_base/Color.js.uncompressed.js | 214 ++++++ lib/dojo/_base/Deferred.js | 4 +- lib/dojo/_base/Deferred.js.uncompressed.js | 349 ++++++++++ lib/dojo/_base/NodeList.js | 4 +- lib/dojo/_base/NodeList.js.uncompressed.js | 110 +++ lib/dojo/_base/array.js | 4 +- lib/dojo/_base/array.js.uncompressed.js | 343 +++++++++ lib/dojo/_base/browser.js | 2 +- lib/dojo/_base/browser.js.uncompressed.js | 28 + lib/dojo/_base/config.js | 2 +- lib/dojo/_base/config.js.uncompressed.js | 187 +++++ lib/dojo/_base/configFirefoxExtension.js | 28 +- lib/dojo/_base/configNode.js | 10 +- lib/dojo/_base/configRhino.js | 2 +- lib/dojo/_base/configSpidermonkey.js | 14 +- lib/dojo/_base/connect.js | 4 +- lib/dojo/_base/connect.js.uncompressed.js | 374 ++++++++++ lib/dojo/_base/declare.js | 4 +- lib/dojo/_base/declare.js.uncompressed.js | 1045 ++++++++++++++++++++++++++++ lib/dojo/_base/event.js | 4 +- lib/dojo/_base/event.js.uncompressed.js | 59 ++ lib/dojo/_base/fx.js | 4 +- lib/dojo/_base/fx.js.uncompressed.js | 670 ++++++++++++++++++ lib/dojo/_base/html.js | 2 +- lib/dojo/_base/html.js.uncompressed.js | 392 +++++++++++ lib/dojo/_base/json.js | 2 +- lib/dojo/_base/json.js.uncompressed.js | 91 +++ lib/dojo/_base/kernel.js | 4 +- lib/dojo/_base/kernel.js.uncompressed.js | 299 ++++++++ lib/dojo/_base/lang.js | 4 +- lib/dojo/_base/lang.js.uncompressed.js | 605 ++++++++++++++++ lib/dojo/_base/loader.js | 4 +- lib/dojo/_base/loader.js.uncompressed.js | 776 +++++++++++++++++++++ lib/dojo/_base/query.js | 4 +- lib/dojo/_base/query.js.uncompressed.js | 13 + lib/dojo/_base/sniff.js | 4 +- lib/dojo/_base/sniff.js.uncompressed.js | 96 +++ lib/dojo/_base/unload.js | 4 +- lib/dojo/_base/unload.js.uncompressed.js | 82 +++ lib/dojo/_base/url.js | 2 +- lib/dojo/_base/url.js.uncompressed.js | 109 +++ lib/dojo/_base/window.js | 4 +- lib/dojo/_base/window.js.uncompressed.js | 134 ++++ lib/dojo/_base/xhr.js | 4 +- lib/dojo/_base/xhr.js.uncompressed.js | 710 +++++++++++++++++++ 46 files changed, 6748 insertions(+), 64 deletions(-) create mode 100644 lib/dojo/_base/Color.js.uncompressed.js create mode 100644 lib/dojo/_base/Deferred.js.uncompressed.js create mode 100644 lib/dojo/_base/NodeList.js.uncompressed.js create mode 100644 lib/dojo/_base/array.js.uncompressed.js create mode 100644 lib/dojo/_base/browser.js.uncompressed.js create mode 100644 lib/dojo/_base/config.js.uncompressed.js create mode 100644 lib/dojo/_base/connect.js.uncompressed.js create mode 100644 lib/dojo/_base/declare.js.uncompressed.js create mode 100644 lib/dojo/_base/event.js.uncompressed.js create mode 100644 lib/dojo/_base/fx.js.uncompressed.js create mode 100644 lib/dojo/_base/html.js.uncompressed.js create mode 100644 lib/dojo/_base/json.js.uncompressed.js create mode 100644 lib/dojo/_base/kernel.js.uncompressed.js create mode 100644 lib/dojo/_base/lang.js.uncompressed.js create mode 100644 lib/dojo/_base/loader.js.uncompressed.js create mode 100644 lib/dojo/_base/query.js.uncompressed.js create mode 100644 lib/dojo/_base/sniff.js.uncompressed.js create mode 100644 lib/dojo/_base/unload.js.uncompressed.js create mode 100644 lib/dojo/_base/url.js.uncompressed.js create mode 100644 lib/dojo/_base/window.js.uncompressed.js create mode 100644 lib/dojo/_base/xhr.js.uncompressed.js (limited to 'lib/dojo/_base') diff --git a/lib/dojo/_base/Color.js b/lib/dojo/_base/Color.js index ad8e0ab3c..ce245ad8e 100644 --- a/lib/dojo/_base/Color.js +++ b/lib/dojo/_base/Color.js @@ -1,5 +1,5 @@ /* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Copyright (c) 2004-2012, 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 */ diff --git a/lib/dojo/_base/Color.js.uncompressed.js b/lib/dojo/_base/Color.js.uncompressed.js new file mode 100644 index 000000000..dba93b8f4 --- /dev/null +++ b/lib/dojo/_base/Color.js.uncompressed.js @@ -0,0 +1,214 @@ +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 `Color` object + // and creates a new Color instance to work from. + // + // example: + // Work with a Color instance: + // | var c = new 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 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? + Color.named = { + // summary: + // Dictionary list of all CSS named colors, by name. Values are 3-item arrays with corresponding RG and B values. + "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 `Color` object + // and sets this color instance to that value. + // + // example: + // | var c = new 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; // 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; // Color + }, + toRgb: function(){ + // summary: + // Returns 3 component array of rgb values + // example: + // | var c = new 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 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 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( + /*Color*/ start, + /*Color*/ end, + /*Number*/ weight, + /*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 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(); // Color + }; + + Color.fromRgb = dojo.colorFromRgb = function(/*String*/ color, /*Color?*/ obj){ + // summary: + // Returns a `Color` instance from a string of the form + // "rgb(...)" or "rgba(...)". Optionally accepts a `Color` + // object to update with the parsed value and return instead of + // creating a new object. + // returns: + // A 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); // Color + }; + + Color.fromHex = dojo.colorFromHex = function(/*String*/ color, /*Color?*/ obj){ + // summary: + // Converts a hex string with a '#' prefix to a color object. + // Supports 12-bit #rgb shorthand. Optionally accepts a + // `Color` object to update with the parsed value. + // + // returns: + // A 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; // 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; // Color + }; + + Color.fromArray = dojo.colorFromArray = function(/*Array*/ a, /*Color?*/ obj){ + // summary: + // Builds a `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 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(); // Color + }; + + Color.fromString = dojo.colorFromString = function(/*String*/ str, /*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 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); // Color + }; + + return Color; +}); diff --git a/lib/dojo/_base/Deferred.js b/lib/dojo/_base/Deferred.js index 13609f687..a356c8c15 100644 --- a/lib/dojo/_base/Deferred.js +++ b/lib/dojo/_base/Deferred.js @@ -1,8 +1,8 @@ /* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Copyright (c) 2004-2012, 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/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 +define("dojo/_base/Deferred",["./kernel","../Deferred","../promise/Promise","../errors/CancelError","../has","./lang","../when"],function(_1,_2,_3,_4,_5,_6,_7){var _8=function(){};var _9=Object.freeze||function(){};var _a=_1.Deferred=function(_b){var _c,_d,_e,_f,_10;var _11=(this.promise=new _3());function _12(_13){if(_d){throw new Error("This deferred has already been resolved");}_c=_13;_d=true;_14();};function _14(){var _15;while(!_15&&_10){var _16=_10;_10=_10.next;if((_15=(_16.progress==_8))){_d=false;}var _17=(_e?_16.error:_16.resolved);if(_5("config-useDeferredInstrumentation")){if(_e&&_2.instrumentRejected){_2.instrumentRejected(_c,!!_17);}}if(_17){try{var _18=_17(_c);if(_18&&typeof _18.then==="function"){_18.then(_6.hitch(_16.deferred,"resolve"),_6.hitch(_16.deferred,"reject"),_6.hitch(_16.deferred,"progress"));continue;}var _19=_15&&_18===undefined;if(_15&&!_19){_e=_18 instanceof Error;}_16.deferred[_19&&_e?"reject":"resolve"](_19?_c:_18);}catch(e){_16.deferred.reject(e);}}else{if(_e){_16.deferred.reject(_c);}else{_16.deferred.resolve(_c);}}}};this.resolve=this.callback=function(_1a){this.fired=0;this.results=[_1a,null];_12(_1a);};this.reject=this.errback=function(_1b){_e=true;this.fired=1;if(_5("config-useDeferredInstrumentation")){if(_2.instrumentRejected){_2.instrumentRejected(_1b,!!_10);}}_12(_1b);this.results=[null,_1b];};this.progress=function(_1c){var _1d=_10;while(_1d){var _1e=_1d.progress;_1e&&_1e(_1c);_1d=_1d.next;}};this.addCallbacks=function(_1f,_20){this.then(_1f,_20,_8);return this;};_11.then=this.then=function(_21,_22,_23){var _24=_23==_8?this:new _a(_11.cancel);var _25={resolved:_21,error:_22,progress:_23,deferred:_24};if(_10){_f=_f.next=_25;}else{_10=_f=_25;}if(_d){_14();}return _24.promise;};var _26=this;_11.cancel=this.cancel=function(){if(!_d){var _27=_b&&_b(_26);if(!_d){if(!(_27 instanceof Error)){_27=new _4(_27);}_27.log=false;_26.reject(_27);}}};_9(_11);};_6.extend(_a,{addCallback:function(_28){return this.addCallbacks(_6.hitch.apply(_1,arguments));},addErrback:function(_29){return this.addCallbacks(null,_6.hitch.apply(_1,arguments));},addBoth:function(_2a){var _2b=_6.hitch.apply(_1,arguments);return this.addCallbacks(_2b,_2b);},fired:-1});_a.when=_1.when=_7;return _a;}); \ 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..7c2cedacc --- /dev/null +++ b/lib/dojo/_base/Deferred.js.uncompressed.js @@ -0,0 +1,349 @@ +define("dojo/_base/Deferred", [ + "./kernel", + "../Deferred", + "../promise/Promise", + "../errors/CancelError", + "../has", + "./lang", + "../when" +], function(dojo, NewDeferred, Promise, CancelError, has, lang, when){ + // module: + // dojo/_base/Deferred + + var mutator = function(){}; + var freeze = Object.freeze || function(){}; + // A deferred provides an API for creating and resolving a promise. + var Deferred = dojo.Deferred = function(/*Function?*/ canceller){ + // summary: + // Deprecated. This module defines the legacy dojo/_base/Deferred API. + // New code should use dojo/Deferred instead. + // description: + // The 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 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 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 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 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 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 = new 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(has("config-useDeferredInstrumentation")){ + if(isError && NewDeferred.instrumentRejected){ + NewDeferred.instrumentRejected(result, !!func); + } + } + 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; + if(has("config-useDeferredInstrumentation")){ + if(NewDeferred.instrumentRejected){ + NewDeferred.instrumentRejected(error, !!nextListener); + } + } + complete(error); + this.results = [null, 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; // 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 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 CancelError(error); + } + error.log = false; + deferred.reject(error); + } + } + }; + freeze(promise); + }; + lang.extend(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)); // 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)); // 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); // Deferred + }, + fired: -1 + }); + + Deferred.when = dojo.when = when; + + return Deferred; +}); diff --git a/lib/dojo/_base/NodeList.js b/lib/dojo/_base/NodeList.js index 4fa6b48a0..c1d1397ae 100644 --- a/lib/dojo/_base/NodeList.js +++ b/lib/dojo/_base/NodeList.js @@ -1,8 +1,8 @@ /* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Copyright (c) 2004-2012, 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/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 +define("dojo/_base/NodeList",["./kernel","../query","./array","./html","../NodeList-dom"],function(_1,_2,_3){var _4=_2.NodeList,_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 _4;}); \ 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..f9e9070f1 --- /dev/null +++ b/lib/dojo/_base/NodeList.js.uncompressed.js @@ -0,0 +1,110 @@ +define("dojo/_base/NodeList", ["./kernel", "../query", "./array", "./html", "../NodeList-dom"], function(dojo, query, array){ + // module: + // dojo/_base/NodeList + + /*===== + return { + // summary: + // This module extends dojo/NodeList with the legacy connect(), coords(), + // blur(), focus(), change(), click(), error(), keydown(), keypress(), + // keyup(), load(), mousedown(), mouseenter(), mouseleave(), mousemove(), + // mouseout(), mouseover(), mouseup(), and submit() methods. + }; + =====*/ + + var NodeList = query.NodeList, + nlp = NodeList.prototype; + + nlp.connect = NodeList._adaptAsForEach(function(){ + // don't bind early to dojo.connect since we no longer explicitly depend on it + return dojo.connect.apply(this, arguments); + }); + /*===== + nlp.connect = function(methodName, objOrFunc, funcName){ + // summary: + // Attach event handlers to every item of the NodeList. Uses dojo.connect() + // so event properties are normalized. + // + // Application must manually require() "dojo/_base/connect" before using this method. + // 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 + // | query("div:nth-child(odd)").connect("onclick", function(e){ + // | console.log("clicked!"); + // | }); + // example: + // attach foo.bar() to every odd div's onmouseover + // | query("div:nth-child(odd)").connect("onmouseover", foo, "bar"); + + return null; // NodeList + }; + =====*/ + + nlp.coords = NodeList._adaptAsMap(dojo.coords); + /*===== + nlp.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 `domGeom.coords`, though assumes + // the node passed is each node in this list. + + return []; // Array + }; + =====*/ + + 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 NodeList; +}); diff --git a/lib/dojo/_base/array.js b/lib/dojo/_base/array.js index f25c2ad00..dfa3b096a 100644 --- a/lib/dojo/_base/array.js +++ b/lib/dojo/_base/array.js @@ -1,8 +1,8 @@ /* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Copyright (c) 2004-2012, 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/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(;i0){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(;i0){return _10.lastIndexOf(a,x,_e);}var l=a&&a.length||0,end=up?l+_d:_c,i;if(_e===u){i=up?_c:l+_d;}else{if(_e<0){i=l+_e;if(i<0){i=_c;}}else{i=_e>=l?l+_d:_e;}}if(l&&typeof a=="string"){a=a.split("");}for(;i!=end;i+=_b){if(a[i]==x){return i;}}return -1;};};var _10={every:_6(false),some:_6(true),indexOf:_a(true),lastIndexOf:_a(false),forEach:function(arr,_11,_12){var i=0,l=arr&&arr.length||0;if(l&&typeof arr=="string"){arr=arr.split("");}if(typeof _11=="string"){_11=_4[_11]||_5(_11);}if(_12){for(;i 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 array = { + // summary: + // The Javascript v1.6 array extensions. + + every: everyOrSome(false), + /*===== + 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 + // | array.every([1, 2, 3, 4], function(item){ return item>1; }); + // example: + // | // returns true + // | array.every([1, 2, 3, 4], function(item){ return item>0; }); + }, + =====*/ + + some: everyOrSome(true), + /*===== + 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 + // | array.some([1, 2, 3, 4], function(item){ return item>1; }); + // example: + // | // is false + // | array.some([1, 2, 3, 4], function(item){ return item<1; }); + }, + =====*/ + + indexOf: index(true), + /*===== + 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 + }, + =====*/ + + lastIndexOf: index(false), + /*===== + 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 + }, + =====*/ + + 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 array.every() or array.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: + // | array.forEach( + // | [ "thinger", "blah", "howdy", 10 ], + // | function(item){ + // | console.log(item); + // | } + // | ); + // example: + // | // log out the members and their indexes + // | array.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 + // | array.forEach( + // | [ "thinger", "blah", "howdy", 10 ], + // | obj.callback, + // | obj + // | ); + // | + // | // alternately, we can accomplish the same thing with lang.hitch() + // | array.forEach( + // | [ "thinger", "blah", "howdy", 10 ], + // | lang.hitch(obj, "callback") + // | ); + // arr: Array|String + // callback: Function|String + // thisObject: Object? + + var i = 0, l = arr && arr.length || 0; + if(l && typeof arr == "string") arr = arr.split(""); + if(typeof callback == "string") callback = cache[callback] || buildFn(callback); + if(thisObject){ + for(; i < l; ++i){ + callback.call(thisObject, arr[i], i, arr); + } + }else{ + for(; i < l; ++i){ + callback(arr[i], i, arr); + } + } + }, + + map: function(arr, callback, thisObject, Ctr){ + // 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] + // | array.map([1, 2, 3, 4], function(item){ return item+1 }); + + // TODO: why do we have a non-standard signature here? do we need "Ctr"? + var i = 0, l = arr && arr.length || 0, out = new (Ctr || Array)(l); + if(l && typeof arr == "string") arr = arr.split(""); + if(typeof callback == "string") callback = cache[callback] || buildFn(callback); + if(thisObject){ + for(; i < l; ++i){ + out[i] = callback.call(thisObject, arr[i], i, arr); + } + }else{ + for(; i < l; ++i){ + out[i] = callback(arr[i], i, arr); + } + } + return out; // Array + }, + + 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] + // | array.filter([1, 2, 3, 4], function(item){ return item>1; }); + + // TODO: do we need "Ctr" here like in map()? + var i = 0, l = arr && arr.length || 0, out = [], value; + if(l && typeof arr == "string") arr = arr.split(""); + if(typeof callback == "string") callback = cache[callback] || buildFn(callback); + if(thisObject){ + for(; i < l; ++i){ + value = arr[i]; + if(callback.call(thisObject, value, i, arr)){ + out.push(value); + } + } + }else{ + for(; i < l; ++i){ + value = arr[i]; + if(callback(value, i, arr)){ + out.push(value); + } + } + } + return out; // Array + }, + + clearCache: function(){ + cache = {}; + } + }; + + + 1 && lang.mixin(dojo, array); + + return array; +}); diff --git a/lib/dojo/_base/browser.js b/lib/dojo/_base/browser.js index 69d57f4cf..4df4dc7ba 100644 --- a/lib/dojo/_base/browser.js +++ b/lib/dojo/_base/browser.js @@ -1,5 +1,5 @@ /* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Copyright (c) 2004-2012, 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 */ diff --git a/lib/dojo/_base/browser.js.uncompressed.js b/lib/dojo/_base/browser.js.uncompressed.js new file mode 100644 index 000000000..4c607fd3b --- /dev/null +++ b/lib/dojo/_base/browser.js.uncompressed.js @@ -0,0 +1,28 @@ +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 + + /*===== + return { + // 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 index 5c70ffd91..a637258c8 100644 --- a/lib/dojo/_base/config.js +++ b/lib/dojo/_base/config.js @@ -1,5 +1,5 @@ /* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Copyright (c) 2004-2012, 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 */ diff --git a/lib/dojo/_base/config.js.uncompressed.js b/lib/dojo/_base/config.js.uncompressed.js new file mode 100644 index 000000000..bbb564afd --- /dev/null +++ b/lib/dojo/_base/config.js.uncompressed.js @@ -0,0 +1,187 @@ +define("dojo/_base/config", ["../has", "require"], function(has, require){ + // module: + // dojo/_base/config + +/*===== +return { + // 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-unique 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 + // | }); + + // 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 `` 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: [deprecated] 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. Specifying + // `djConfig.modulePaths = { "foo": "../../bar" }` is the equivalent + // of calling `dojo.registerModulePath("foo", "../../bar");`. Multiple + // modules may be configured via `djConfig.modulePaths`. + modulePaths: {}, + + // addOnLoad: Function|Array + // Adds a callback via dojo/ready. Useful when Dojo is added after + // the page loads and djConfig.afterOnLoad is true. Supports the same + // arguments as dojo/ready. 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, + + // parseOnLoad: Boolean + // Run the parser after the page is loaded + parseOnLoad: false, + + // require: String[] + // An array of module names to be loaded immediately after dojo.js has been included + // in a page. + require: [], + + // defaultDuration: Number + // 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/topic.publish(). See dojo/main.__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, + + // deps: Function|Array + // Defines dependencies to be used before the loader has been loaded. + // When provided, they cause the loader to execute require(deps, callback) + // once it has finished loading. Should be used with callback. + deps: undefined, + + // callback: Function|Array + // Defines a callback to be used when dependencies are defined before + // the loader has been loaded. When provided, they cause the loader to + // execute require(deps, callback) once it has finished loading. + // Should be used with deps. + callback: undefined, + + // deferredInstrumentation: Boolean + // Whether deferred instrumentation should be loaded or included + // in builds. + deferredInstrumentation: true, + + // useDeferredInstrumentation: Boolean|String + // Whether the deferred instrumentation should be used. + // + // * `"report-rejections"`: report each rejection as it occurs. + // * `true` or `1` or `"report-unhandled-rejections"`: wait 1 second + // in an attempt to detect unhandled rejections. + useDeferredInstrumentation: "report-unhandled-rejections" +}; +=====*/ + + 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; +}); + diff --git a/lib/dojo/_base/configFirefoxExtension.js b/lib/dojo/_base/configFirefoxExtension.js index ce30c9153..4115c6172 100644 --- a/lib/dojo/_base/configFirefoxExtension.js +++ b/lib/dojo/_base/configFirefoxExtension.js @@ -78,14 +78,16 @@ if(typeof window != 'undefined'){ var hasBase = false; dojo._getText = function(/*URI*/ uri, /*Boolean*/ fail_ok){ - // summary: Read the contents of the specified uri and return those contents. + // 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 + // returns: + // The response text. null is returned when there is a // failure and failure is okay (an exception otherwise) // alert("_getText: " + uri); @@ -178,12 +180,12 @@ if(typeof window != 'undefined'){ dojo._defaultContext = [ window, document ]; dojo.pushContext = function(/*Object|String?*/g, /*MDocumentElement?*/d){ - // summary: + // summary: // causes subsequent calls to Dojo methods to assume the // passed object and, optionally, document as the default // scopes to use. A 2-element array of the previous global and // document are returned. - // description: + // description: // dojo.pushContext treats contexts as a stack. The // auto-detected contexts which are initially provided using // dojo.setContext() require authors to keep state in order to @@ -199,10 +201,10 @@ if(typeof window != 'undefined'){ // the context to push. This means that iframes can be given // an ID and code can be executed in the scope of the iframe's // document in subsequent calls easily. - // g: + // g: // The global context. If a string, the id of the frame to // search for a context and document. - // d: + // d: // The document element to execute subsequent code with. var old = [dojo.global, dojo.doc]; contexts.push(old); @@ -224,7 +226,7 @@ if(typeof window != 'undefined'){ }; dojo.popContext = function(){ - // summary: + // summary: // If the context stack contains elements, ensure that // subsequent code executes in the *previous* context to the // current context. The current context set ([global, @@ -286,17 +288,17 @@ if(typeof window != 'undefined'){ }; // FIXME: PORT // FIXME: dojo.unloaded requires dojo scope, so using anon function wrapper. - _handleNodeEvent("onbeforeunload", function() { dojo.unloaded(); }); - _handleNodeEvent("onunload", function() { dojo.windowUnloaded(); }); + _handleNodeEvent("onbeforeunload", function(){ dojo.unloaded(); }); + _handleNodeEvent("onunload", function(){ dojo.windowUnloaded(); }); })(); */ // FIXME: PORTME - // this event fires a lot, namely for all plugin XUL overlays and for - // all iframes (in addition to window navigations). We only want - // Dojo's to fire once..but we might care if pages navigate. We'll - // probably need an extension-specific API + // this event fires a lot, namely for all plugin XUL overlays and for + // all iframes (in addition to window navigations). We only want + // 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){ dojo._loadInit(e); diff --git a/lib/dojo/_base/configNode.js b/lib/dojo/_base/configNode.js index 7cd6f14f9..1866795c1 100644 --- a/lib/dojo/_base/configNode.js +++ b/lib/dojo/_base/configNode.js @@ -1,5 +1,5 @@ exports.config = function(config){ - // summary: + // summary: // This module provides bootstrap configuration for running dojo in node.js // any command line arguments with the load flag are pushed into deps @@ -15,7 +15,7 @@ exports.config = function(config){ var fs = require("fs"); // make sure global require exists - //if (typeof global.require=="undefined") { + //if (typeof global.require=="undefined"){ // global.require= {}; //} @@ -40,12 +40,12 @@ exports.config = function(config){ config.hasCache[p] = hasCache[p]; } - var vm = require('vm'); - + var vm = require('vm'), + path = require('path'); // reset some configuration switches with node-appropriate values var nodeConfig = { - baseUrl: __dirname.match(/(.+)[\/\\]_base$/)[1], + baseUrl: path.dirname(process.argv[1]), commandLineArgs:args, deps:deps, timeout:0, diff --git a/lib/dojo/_base/configRhino.js b/lib/dojo/_base/configRhino.js index ec6475997..2cbbf8887 100644 --- a/lib/dojo/_base/configRhino.js +++ b/lib/dojo/_base/configRhino.js @@ -1,5 +1,5 @@ function rhinoDojoConfig(config, baseUrl, rhinoArgs){ - // summary: + // 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? diff --git a/lib/dojo/_base/configSpidermonkey.js b/lib/dojo/_base/configSpidermonkey.js index 0da0d7102..af16fda3b 100644 --- a/lib/dojo/_base/configSpidermonkey.js +++ b/lib/dojo/_base/configSpidermonkey.js @@ -1,9 +1,9 @@ // TODO: this file needs to be converted to the v1.7 loader - -/* - * SpiderMonkey host environment - */ +// module: +// configSpidermonkey +// summary: +// SpiderMonkey host environment if(dojo.config["baseUrl"]){ dojo.baseUrl = dojo.config["baseUrl"]; @@ -13,11 +13,7 @@ if(dojo.config["baseUrl"]){ dojo._name = 'spidermonkey'; -/*===== -dojo.isSpidermonkey = { - // summary: Detect spidermonkey -}; -=====*/ + dojo.isSpidermonkey = true; dojo.exit = function(exitcode){ diff --git a/lib/dojo/_base/connect.js b/lib/dojo/_base/connect.js index 6fa7aabc3..5775c63c8 100644 --- a/lib/dojo/_base/connect.js +++ b/lib/dojo/_base/connect.js @@ -1,8 +1,8 @@ /* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Copyright (c) 2004-2012, 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/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;i90)&&(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;i90) && (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 = { + // 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. + + _keypress:keypress, + + connect:function(obj, event, context, method, dontFix){ + // summary: + // `dojo.connect` is a deprecated 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? + // 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 + + // 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= 2.1 OR the modified BSD license. see: http://dojotoolkit.org/license for details */ //>>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=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=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 +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=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=0;--i){f=_39[i];m=f._meta;f=m?m.ctor:f;if(f){f.apply(this,_3c?_3c[i]:a);}}f=this.postscript;if(f){f.apply(this,_3b);}};};function _3e(_3f,_40){return function(){var a=arguments,t=a,a0=a[0],f;if(!(this instanceof a.callee)){return _3d(a);}if(_40){if(a0){f=a0.preamble;if(f){t=f.apply(this,t)||t;}}f=this.preamble;if(f){f.apply(this,t);}}if(_3f){_3f.apply(this,a);}f=this.postscript;if(f){f.apply(this,a);}};};function _41(_42){return function(){var a=arguments,i=0,f,m;if(!(this instanceof a.callee)){return _3d(a);}for(;f=_42[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 _43(_44,_45,_46){return function(){var b,m,f,i=0,_47=1;if(_46){i=_45.length-1;_47=-1;}for(;b=_45[i];i+=_47){m=b._meta;f=(m?m.hidden:b.prototype)[_44];if(f){f.apply(this,arguments);}}};};function _48(_49){_6.prototype=_49.prototype;var t=new _6;_6.prototype=null;return t;};function _3d(_4a){var _4b=_4a.callee,t=_48(_4b);_4b.apply(t,_4a);return t;};function _35(_4c,_4d,_4e){if(typeof _4c!="string"){_4e=_4d;_4d=_4c;_4c="";}_4e=_4e||{};var _4f,i,t,_50,_51,_52,_53,_54=1,_55=_4d;if(_5.call(_4d)=="[object Array]"){_52=_c(_4d,_4c);t=_52[0];_54=_52.length-t;_4d=_52[_54];}else{_52=[0];if(_4d){if(_5.call(_4d)=="[object Function]"){t=_4d._meta;_52=_52.concat(t?t.bases:_4d);}else{_9("base class is not a callable constructor.",_4c);}}else{if(_4d!==null){_9("unknown base class. Did you use dojo.require to pull it in?",_4c);}}}if(_4d){for(i=_54-1;;--i){_4f=_48(_4d);if(!i){break;}t=_52[i];(t._meta?_29:_4)(_4f,t.prototype);_50=new Function;_50.superclass=_4d;_50.prototype=_4f;_4d=_4f.constructor=_50;}}else{_4f={};}_35.safeMixin(_4f,_4e);t=_4e.constructor;if(t!==op.constructor){t.nom=_8;_4f.constructor=t;}for(i=_54-1;i;--i){t=_52[i]._meta;if(t&&t.chains){_53=_4(_53||{},t.chains);}}if(_4f["-chains-"]){_53=_4(_53||{},_4f["-chains-"]);}t=!_53||!_53.hasOwnProperty(_8);_52[0]=_50=(_53&&_53.constructor==="manual")?_41(_52):(_52.length==1?_3e(_4e.constructor,t):_38(_52,t));_50._meta={bases:_52,hidden:_4e,chains:_53,parents:_55,ctor:_4e.constructor};_50.superclass=_4d&&_4d.prototype;_50.extend=_33;_50.createSubclass=_36;_50.prototype=_4f;_4f.constructor=_50;_4f.getInherited=_21;_4f.isInstanceOf=_27;_4f.inherited=_26;_4f.__inherited=_17;if(_4c){_4f.declaredClass=_4c;_3.setObject(_4c,_50);}if(_53){for(_51 in _53){if(_4f[_51]&&typeof _53[_51]=="string"&&_51!=_8){t=_4f[_51]=_43(_51,_52,_53[_51]==="after");t.nom=_51;}}}return _50;};_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..cb25e2873 --- /dev/null +++ b/lib/dojo/_base/declare.js.uncompressed.js @@ -0,0 +1,1045 @@ +define("dojo/_base/declare", ["./kernel", "../has", "./lang"], function(dojo, has, lang){ + // module: + // dojo/_base/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){ + // summary: + // Mix in properties skipping a constructor and decorating functions + // like it is done by 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 + // declare() does. + // + // It is meant to be used with classes and objects produced with + // 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 declare(). + // + // example: + // | var A = declare(null, { + // | m1: function(){ + // | console.log("A.m1"); + // | }, + // | m2: function(){ + // | console.log("A.m2"); + // | } + // | }); + // | var B = 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 + + 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; + } + + function createSubclass(mixins){ + return declare([this].concat(mixins)); + } + + // chained constructor compatible with the legacy 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 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 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 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 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){ + // 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: dojo/_base/declare.__DeclareCreatedObject + // 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 + // 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 + // 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: + // | 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 = declare(null, { + // | // constructor, properties, and methods go here + // | // ... + // | }); + // | var MyClass1 = declare(MyBase, { + // | // constructor, properties, and methods go here + // | // ... + // | }); + // | var MyClass2 = declare(MyBase, { + // | // constructor, properties, and methods go here + // | // ... + // | }); + // | var MyDiamond = 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 = 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 = declare(null, { + // | "-chains-": { + // | destroy: "before" + // | } + // | }); + // | var B = declare(A, { + // | constructor: function(){ + // | console.log("B.constructor"); + // | }, + // | destroy: function(){ + // | console.log("B.destroy"); + // | } + // | }); + // | var C = 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 = declare(null, { + // | "-chains-": { + // | constructor: "manual" + // | } + // | }); + // | var B = declare(A, { + // | constructor: function(){ + // | // ... + // | // call the base constructor with new parameters + // | this.inherited(arguments, [1, 2, 3]); + // | // ... + // | } + // | }); + // + // example: + // | var A = declare(null, { + // | "-chains-": { + // | m1: "before" + // | }, + // | m1: function(){ + // | console.log("A.m1"); + // | }, + // | m2: function(){ + // | console.log("A.m2"); + // | } + // | }); + // | var B = 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 + + // 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.createSubclass = createSubclass; + 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 + } + + /*===== + declare.__DeclareCreatedObject = { + // summary: + // dojo/_base/declare() returns a constructor `C`. `new C()` returns an Object with the following + // methods, in addition to the methods and properties specified via the arguments passed to declare(). + + 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 + // 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 + // 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 = 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 = 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 + }, + + 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 + // 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 = 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 + }, + + 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 + // declare() to determine of they support a certain interface or + // not. It models "instanceof" operator. + // + // example: + // | var A = declare(null, { + // | // constructor, properties, and methods go here + // | // ... + // | }); + // | var B = declare(null, { + // | // constructor, properties, and methods go here + // | // ... + // | }); + // | var C = declare([A, B], { + // | // constructor, properties, and methods go here + // | // ... + // | }); + // | var D = 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 + }, + + 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 + // 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 declare(). It is implemented + // using dojo.safeMixin, and it skips a constructor property, + // and properly decorates copied functions. + // + // example: + // | var A = declare(null, { + // | m1: function(){}, + // | s1: "Popokatepetl" + // | }); + // | A.extend({ + // | m1: function(){}, + // | m2: function(){}, + // | f1: true, + // | d1: 42 + // | }); + } + }; + =====*/ + + // For back-compat, remove for 2.0 + 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 522202d7b..40fb87d88 100644 --- a/lib/dojo/_base/event.js +++ b/lib/dojo/_base/event.js @@ -1,8 +1,8 @@ /* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Copyright (c) 2004-2012, 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/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 +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;};}var _6={fix:function(_7,_8){if(on._fixEvent){return on._fixEvent(_7,_8);}return _7;},stop:function(_9){if(_2("dom-addeventlistener")||(_9&&_9.preventDefault)){_9.preventDefault();_9.stopPropagation();}else{_9=_9||window.event;_9.cancelBubble=true;on._preventDefault.call(_9);}}};if(1){_1.fixEvent=_6.fix;_1.stopEvent=_6.stop;}return _6;}); \ 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..8a0597f49 --- /dev/null +++ b/lib/dojo/_base/event.js.uncompressed.js @@ -0,0 +1,59 @@ +define("dojo/_base/event", ["./kernel", "../on", "../has", "../dom-geometry"], function(dojo, on, has, dom){ + // module: + // dojo/_base/event + + 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; + }; + } + + var ret = { + // summary: + // This module defines dojo DOM event API. Usually you should use dojo/on, and evt.stopPropagation() + + // evt.preventDefault(), rather than this module. + + fix: 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 + }, + + stop: 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); + } + } + }; + + if( 1 ){ + dojo.fixEvent = ret.fix; + dojo.stopEvent = ret.stop; + } + + return ret; +}); diff --git a/lib/dojo/_base/fx.js b/lib/dojo/_base/fx.js index 0ac96bc69..5e88baa8d 100644 --- a/lib/dojo/_base/fx.js +++ b/lib/dojo/_base/fx.js @@ -1,8 +1,8 @@ /* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Copyright (c) 2004-2012, 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/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 +define("dojo/_base/fx",["./kernel","./config","./lang","../Evented","./Color","./connect","./sniff","../dom","../dom-style"],function(_1,_2,_3,_4,_5,_6,_7,_8,_9){var _a=_3.mixin;var _b={};var _c=_b._Line=function(_d,_e){this.start=_d;this.end=_e;};_c.prototype.getValue=function(n){return ((this.end-this.start)*n)+this.start;};var _f=_b.Animation=function(_10){_a(this,_10);if(_3.isArray(this.curve)){this.curve=new _c(this.curve[0],this.curve[1]);}};_f.prototype=new _4();_3.extend(_f,{duration:350,repeat:0,rate:20,_percent:0,_startRepeatCount:0,_getStep:function(){var _11=this._percent,_12=this.easing;return _12?_12(_11):_11;},_fire:function(evt,_13){var a=_13||[];if(this[evt]){if(_2.debugAtAllCosts){this[evt].apply(this,a);}else{try{this[evt].apply(this,a);}catch(e){console.error("exception in animation handler for:",evt);console.error(e);}}}return this;},play:function(_14,_15){var _16=this;if(_16._delayTimer){_16._clearTimer();}if(_15){_16._stopTimer();_16._active=_16._paused=false;_16._percent=0;}else{if(_16._active&&!_16._paused){return _16;}}_16._fire("beforeBegin",[_16.node]);var de=_14||_16.delay,_17=_3.hitch(_16,"_play",_15);if(de>0){_16._delayTimer=setTimeout(_17,de);return _16;}_17();return _16;},_play:function(_18){var _19=this;if(_19._delayTimer){_19._clearTimer();}_19._startTime=new Date().valueOf();if(_19._paused){_19._startTime-=_19.duration*_19._percent;}_19._active=true;_19._paused=false;var _1a=_19.curve.getValue(_19._getStep());if(!_19._percent){if(!_19._startRepeatCount){_19._startRepeatCount=_19.repeat;}_19._fire("onBegin",[_1a]);}_19._fire("onPlay",[_1a]);_19._cycle();return _19;},pause:function(){var _1b=this;if(_1b._delayTimer){_1b._clearTimer();}_1b._stopTimer();if(!_1b._active){return _1b;}_1b._paused=true;_1b._fire("onPause",[_1b.curve.getValue(_1b._getStep())]);return _1b;},gotoPercent:function(_1c,_1d){var _1e=this;_1e._stopTimer();_1e._active=_1e._paused=true;_1e._percent=_1c;if(_1d){_1e.play();}return _1e;},stop:function(_1f){var _20=this;if(_20._delayTimer){_20._clearTimer();}if(!_20._timer){return _20;}_20._stopTimer();if(_1f){_20._percent=1;}_20._fire("onStop",[_20.curve.getValue(_20._getStep())]);_20._active=_20._paused=false;return _20;},status:function(){if(this._active){return this._paused?"paused":"playing";}return "stopped";},_cycle:function(){var _21=this;if(_21._active){var _22=new Date().valueOf();var _23=_21.duration===0?1:(_22-_21._startTime)/(_21.duration);if(_23>=1){_23=1;}_21._percent=_23;if(_21.easing){_23=_21.easing(_23);}_21._fire("onAnimate",[_21.curve.getValue(_23)]);if(_21._percent<1){_21._startTimer();}else{_21._active=false;if(_21.repeat>0){_21.repeat--;_21.play(null,true);}else{if(_21.repeat==-1){_21.play(null,true);}else{if(_21._startRepeatCount){_21.repeat=_21._startRepeatCount;_21._startRepeatCount=0;}}}_21._percent=0;_21._fire("onEnd",[_21.node]);!_21.repeat&&_21._stopTimer();}}return _21;},_clearTimer:function(){clearTimeout(this._delayTimer);delete this._delayTimer;}});var ctr=0,_24=null,_25={run:function(){}};_3.extend(_f,{_startTimer:function(){if(!this._timer){this._timer=_6.connect(_25,"run",this,"_cycle");ctr++;}if(!_24){_24=setInterval(_3.hitch(_25,"run"),this.rate);}},_stopTimer:function(){if(this._timer){_6.disconnect(this._timer);this._timer=null;ctr--;}if(ctr<=0){clearInterval(_24);_24=null;ctr=0;}}});var _26=_7("ie")?function(_27){var ns=_27.style;if(!ns.width.length&&_9.get(_27,"width")=="auto"){ns.width="auto";}}:function(){};_b._fade=function(_28){_28.node=_8.byId(_28.node);var _29=_a({properties:{}},_28),_2a=(_29.properties.opacity={});_2a.start=!("start" in _29)?function(){return +_9.get(_29.node,"opacity")||0;}:_29.start;_2a.end=_29.end;var _2b=_b.animateProperty(_29);_6.connect(_2b,"beforeBegin",_3.partial(_26,_29.node));return _2b;};_b.fadeIn=function(_2c){return _b._fade(_a({end:1},_2c));};_b.fadeOut=function(_2d){return _b._fade(_a({end:0},_2d));};_b._defaultEasing=function(n){return 0.5+((Math.sin((n+1.5)*Math.PI))/2);};var _2e=function(_2f){this._properties=_2f;for(var p in _2f){var _30=_2f[p];if(_30.start instanceof _5){_30.tempColor=new _5();}}};_2e.prototype.getValue=function(r){var ret={};for(var p in this._properties){var _31=this._properties[p],_32=_31.start;if(_32 instanceof _5){ret[p]=_5.blendColors(_32,_31.end,r,_31.tempColor).toCss();}else{if(!_3.isArray(_32)){ret[p]=((_31.end-_32)*r)+_32+(p!="opacity"?_31.units||"px":0);}}}return ret;};_b.animateProperty=function(_33){var n=_33.node=_8.byId(_33.node);if(!_33.easing){_33.easing=_1._defaultEasing;}var _34=new _f(_33);_6.connect(_34,"beforeBegin",_34,function(){var pm={};for(var p in this.properties){if(p=="width"||p=="height"){this.node.display="block";}var _35=this.properties[p];if(_3.isFunction(_35)){_35=_35(n);}_35=pm[p]=_a({},(_3.isObject(_35)?_35:{end:_35}));if(_3.isFunction(_35.start)){_35.start=_35.start(n);}if(_3.isFunction(_35.end)){_35.end=_35.end(n);}var _36=(p.toLowerCase().indexOf("color")>=0);function _37(_38,p){var v={height:_38.offsetHeight,width:_38.offsetWidth}[p];if(v!==undefined){return v;}v=_9.get(_38,p);return (p=="opacity")?+v:(_36?v:parseFloat(v));};if(!("end" in _35)){_35.end=_37(n,p);}else{if(!("start" in _35)){_35.start=_37(n,p);}}if(_36){_35.start=new _5(_35.start);_35.end=new _5(_35.end);}else{_35.start=(p=="opacity")?+_35.start:parseFloat(_35.start);}}this.curve=new _2e(pm);});_6.connect(_34,"onAnimate",_3.hitch(_9,"set",_34.node));return _34;};_b.anim=function(_39,_3a,_3b,_3c,_3d,_3e){return _b.animateProperty({node:_39,duration:_3b||_f.prototype.duration,properties:_3a,easing:_3c,onEnd:_3d}).play(_3e||0);};if(1){_a(_1,_b);_1._Animation=_f;}return _b;}); \ 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..b3568bfc5 --- /dev/null +++ b/lib/dojo/_base/fx.js.uncompressed.js @@ -0,0 +1,670 @@ +define("dojo/_base/fx", ["./kernel", "./config", /*===== "./declare", =====*/ "./lang", "../Evented", "./Color", "./connect", "./sniff", "../dom", "../dom-style"], + function(dojo, config, /*===== declare, =====*/ lang, Evented, Color, connect, has, dom, style){ + // module: + // dojo/_base/fx + // 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; + + // Module export + var basefx = { + // summary: + // This module defines the base dojo/_base/fx implementation. + }; + + var _Line = basefx._Line = function(/*int*/ start, /*int*/ end){ + // summary: + // 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; + }; + + _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 + }; + + var Animation = basefx.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 `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 _Line(this.curve[0], this.curve[1]); + } + + }; + Animation.prototype = new Evented(); + + lang.extend(Animation, { + // duration: Integer + // The time in milliseconds the animation will take to run + duration: 350, + + /*===== + // curve: _Line|Array + // A two element array of start and end values, or a `_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 _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 Animation begins playing (synchronous) + beforeBegin: null, + + // onBegin: Event? + // Synthetic event fired as a Animation begins playing (useful?) + onBegin: null, + + // onAnimate: Event? + // Synthetic event fired at each interval of the Animation + onAnimate: null, + + // onEnd: Event? + // Synthetic event fired after the final frame of the Animation + onEnd: null, + + // onPlay: Event? + // Synthetic event fired any time the Animation is play()'ed + onPlay: null, + + // onPause: Event? + // Synthetic event fired when the Animation is paused + onPause: null, + + // onStop: Event + // Synthetic event fires when the 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 this Animation + // instance. + // evt: + // The event to fire. + // args: + // The arguments to pass to the event. + var a = args||[]; + if(this[evt]){ + if(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; // 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: 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; // 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; // Animation + }, + + pause: function(){ + // summary: + // Pauses a running animation. + var _t = this; + if(_t._delayTimer){ _t._clearTimer(); } + _t._stopTimer(); + if(!_t._active){ return _t; /*Animation*/ } + _t._paused = true; + _t._fire("onPause", [_t.curve.getValue(_t._getStep())]); + return _t; // 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; // 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; /* Animation */ } + _t._stopTimer(); + if(gotoEnd){ + _t._percent = 1; + } + _t._fire("onStop", [_t.curve.getValue(_t._getStep())]); + _t._active = _t._paused = false; + return _t; // 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(); + // Allow durations of 0 (instant) by setting step to 1 - see #13798 + var step = _t.duration === 0 ? 1 : (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; // 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(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(){}; + + basefx._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 = basefx.animateProperty(fArgs); + connect.connect(anim, "beforeBegin", lang.partial(_makeFadeable, fArgs.node)); + + return anim; // Animation + }; + + /*===== + var __FadeArgs = declare(null, { + // node: DOMNode|String + // The node referenced in the animation + // duration: Integer? + // Duration of the animation in milliseconds. + // easing: Function? + // An easing function. + }); + =====*/ + + basefx.fadeIn = function(/*__FadeArgs*/ args){ + // summary: + // Returns an animation that will fade node defined in 'args' from + // its current opacity to fully opaque. + return basefx._fade(_mixin({ end: 1 }, args)); // Animation + }; + + basefx.fadeOut = function(/*__FadeArgs*/ args){ + // summary: + // Returns an animation that will fade node defined in 'args' + // from its current opacity to fully transparent. + return basefx._fade(_mixin({ end: 0 }, args)); // Animation + }; + + basefx._defaultEasing = function(/*Decimal?*/ n){ + // summary: + // The default easing function for 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; + }; + + /*===== + var __AnimArgs = declare(__FadeArgs, { + // properties: Object? + // A hash map of style properties to Objects describing the transition, + // such as the properties of _Line with an additional 'units' property + properties: {} + + //TODOC: add event callbacks + }); + =====*/ + + basefx.animateProperty = function(/*__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: + // Foundation of most `dojo/_base/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. + // | basefx.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 omitted. + // + // example: + // Animate width, height, and padding over 2 seconds... the + // pedantic way: + // | basefx.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. + // | basefx.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 `Animation`s, animateProperty returns a handle to the + // Animation instance, which fires the events common to Dojo FX. Use `aspect.after` + // to access these events outside of the Animation definition: + // | var anim = basefx.animateProperty({ + // | node:"someId", + // | properties:{ + // | width:400, height:500 + // | } + // | }); + // | aspect.after(anim, "onEnd", function(){ + // | console.log("animation ended"); + // | }, true); + // | // 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 directly to callbacks. + // | basefx.animateProperty({ + // | node:"mine", + // | properties:{ + // | height:function(node){ + // | // shrink this node by 50% + // | return domGeom.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 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){ + // domStyle.get(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; // Animation + }; + + basefx.anim = function( /*DOMNode|String*/ node, + /*Object*/ properties, + /*Integer?*/ duration, + /*Function?*/ easing, + /*Function?*/ onEnd, + /*Integer?*/ delay){ + // summary: + // A simpler interface to `animateProperty()`, also returns + // an instance of `Animation` but begins the animation + // immediately, unlike nearly every other Dojo animation API. + // description: + // Simpler (but somewhat less powerful) version + // of `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 `Animation` object returned will be already playing, 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 + // | basefx.anim("id", { opacity: 0 }); + // example: + // Fade out a node over a full second + // | basefx.anim("id", { opacity: 0 }, 1000); + return basefx.animateProperty({ // Animation + node: node, + duration: duration || Animation.prototype.duration, + properties: properties, + easing: easing, + onEnd: onEnd + }).play(delay || 0); + }; + + + if( 1 ){ + _mixin(dojo, basefx); + // Alias to drop come 2.0: + dojo._Animation = Animation; + } + + return basefx; +}); diff --git a/lib/dojo/_base/html.js b/lib/dojo/_base/html.js index 89f6a5192..32f4d5b0d 100644 --- a/lib/dojo/_base/html.js +++ b/lib/dojo/_base/html.js @@ -1,5 +1,5 @@ /* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Copyright (c) 2004-2012, 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 */ diff --git a/lib/dojo/_base/html.js.uncompressed.js b/lib/dojo/_base/html.js.uncompressed.js new file mode 100644 index 000000000..f439d0d54 --- /dev/null +++ b/lib/dojo/_base/html.js.uncompressed.js @@ -0,0 +1,392 @@ +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 + + /*===== + return { + // 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 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 b644339f7..1caf6a1a1 100644 --- a/lib/dojo/_base/json.js +++ b/lib/dojo/_base/json.js @@ -1,5 +1,5 @@ /* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Copyright (c) 2004-2012, 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 */ diff --git a/lib/dojo/_base/json.js.uncompressed.js b/lib/dojo/_base/json.js.uncompressed.js new file mode 100644 index 000000000..525c04880 --- /dev/null +++ b/lib/dojo/_base/json.js.uncompressed.js @@ -0,0 +1,91 @@ +define("dojo/_base/json", ["./kernel", "../json"], function(dojo, json){ + +// module: +// dojo/_base/json + +/*===== +return { + // 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 index f574dadd2..412775cad 100644 --- a/lib/dojo/_base/kernel.js +++ b/lib/dojo/_base/kernel.js @@ -1,8 +1,8 @@ /* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Copyright (c) 2004-2012, 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 +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.map&&_3.map[_4.id.match(/[^\/]+/)[0]]),_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: 30226 $".match(/\d+/);_7.version={major:1,minor:8,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+")";}};1||_1.add("extend-dojo",1);(Function("d","d.eval = function(){return d.global.eval ? d.global.eval(arguments[0]) : eval(arguments[0]);}"))(_7);if(0){_7.exit=function(_c){quit(_c);};}else{_7.exit=function(){};}1||_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 _d=tn+"";console[_d]=("log" in console)?function(){var a=Array.apply({},arguments);a.unshift(_d+":");console["log"](a.join(" "));}:function(){};console[_d]._fake=true;})();}}}_1.add("dojo-debug-messages",!!_2.isDebug);_7.deprecated=_7.experimental=function(){};if(_1("dojo-debug-messages")){_7.deprecated=function(_e,_f,_10){var _11="DEPRECATED: "+_e;if(_f){_11+=" "+_f;}if(_10){_11+=" -- will be removed in version: "+_10;}console.warn(_11);};_7.experimental=function(_12,_13){var _14="EXPERIMENTAL: "+_12+" -- APIs subject to change without notice.";if(_13){_14+=" "+_13;}console.warn(_14);};}1||_1.add("dojo-modulePaths",1);if(1){if(_2.modulePaths){_7.deprecated("dojo.modulePaths","use paths configuration");var _15={};for(p in _2.modulePaths){_15[p.replace(/\./g,"/")]=_2.modulePaths[p];}_3({paths:_15});}}1||_1.add("dojo-moduleUrl",1);if(1){_7.moduleUrl=function(_16,url){_7.deprecated("dojo.moduleUrl()","use require.toUrl","2.0");var _17=null;if(_16){_17=_3.toUrl(_16.replace(/\./g,"/")+(url?("/"+url):"")+"/*.*").replace(/\/\*\.\*/,"")+(url?"":"/");}return _17;};}_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..44b2f9b28 --- /dev/null +++ b/lib/dojo/_base/kernel.js.uncompressed.js @@ -0,0 +1,299 @@ +define("dojo/_base/kernel", ["../has", "./config", "require", "module"], function(has, config, require, module){ + // module: + // dojo/_base/kernel + + // 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 = { + // summary: + // This module is the foundational module of the dojo boot sequence; it defines the dojo object. + + // 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 AMD map configuration variable which can relocate packages to different names. For backcompat, + // only the "*" mapping is supported. 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.map && require.map[module.id.match(/[^\/]+/)[0]]), + + 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; + + /*===== dojo.__docParserConfigureScopeMap(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; + + var rev = "$Rev: 30226 $".match(/\d+/); + dojo.version = { + // summary: + // Version number of the Dojo Toolkit + // description: + // Hash about the version, including + // + // - major: Integer: Major version. If total version is "1.2.0beta1", will be 1 + // - minor: Integer: Minor version. If total version is "1.2.0beta1", will be 2 + // - patch: Integer: Patch version. If total version is "1.2.0beta1", will be 0 + // - flag: String: Descriptor flag. If total version is "1.2.0beta1", will be "beta1" + // - revision: Number: The SVN rev from which dojo was pulled + + major: 1, minor: 8, 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. + 1 || has.add("extend-dojo", 1); + + + (Function("d", "d.eval = function(){return d.global.eval ? d.global.eval(arguments[0]) : eval(arguments[0]);}"))(dojo); + /*===== + 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` + }; + =====*/ + + + if( 0 ){ + dojo.exit = function(exitcode){ + quit(exitcode); + }; + }else{ + dojo.exit = function(){ + }; + } + + 1 || 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 + ); + dojo.deprecated = dojo.experimental = function(){}; + 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); + }; + } + + 1 || 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}); + } + } + + 1 || 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 bc88c7cde..2439bd0ba 100644 --- a/lib/dojo/_base/lang.js +++ b/lib/dojo/_base/lang.js @@ -1,8 +1,8 @@ /* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Copyright (c) 2004-2012, 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/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;i2){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;x2){return _10._hitchArgs.apply(_1,arguments);}if(!_27){_27=_26;_26=null;}if(_10.isString(_27)){_26=_26||_1.global;if(!_26[_27]){throw (["lang.hitch: scope[\"",_27,"\"] is null (scope=\"",_26,"\")"].join(""));}return function(){return _26[_27].apply(_26,arguments||[]);};}return !_26?_27:function(){return _27.apply(_26,arguments||[]);};},delegate:(function(){function TMP(){};return function(obj,_28){TMP.prototype=obj;var tmp=new TMP();TMP.prototype=null;if(_28){_10._mixin(tmp,_28);}return tmp;};})(),_toArray:_2("ie")?(function(){function _29(obj,_2a,_2b){var arr=_2b||[];for(var x=_2a||0;x 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(['lang.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 + }; + })(), + /*===== + 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 implementation 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 = lang.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 + }, + =====*/ + + _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, + /*===== + _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. + }, + =====*/ + + 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 lang.partial is the functional equivalent of calling: + // | lang.hitch(null, funcName, ...); + // method: + // The function to "wrap" + var arr = [ null ]; + return lang.hitch.apply(dojo, arr.concat(lang._toArray(arguments))); // Function + }, + + clone: function(/*anything*/ src){ + // summary: + // Clones objects (including DOM nodes) and all children. + // Warning: do not clone cyclic structures. + // src: + // The object to clone + 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(lang.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, lang.clone); + }, + + + trim: String.prototype.trim ? + function(str){ return str.trim(); } : + function(str){ return str.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); }, + /*===== + 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 + // lang.string.trim() + }, + =====*/ + + 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: + // | lang.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: + // | lang.replace("Hello, {0} {2}!", + // | ["Robert", "X", "Cringely"]); + // | // returns: Hello, Robert Cringely! + // example: + // | // uses a function for substitutions: + // | function sum(a){ + // | var t = 0; + // | arrayforEach(a, function(x){ t += x; }); + // | return t; + // | } + // | lang.replace( + // | "{count} payments averaging {avg} USD per payment.", + // | lang.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: + // | lang.replace("Hello, ${0} ${2}!", + // | ["Robert", "X", "Cringely"], /\$\{([^\}]+)\}/g); + // | // returns: Hello, Robert Cringely! + + return tmpl.replace(pattern || _pattern, lang.isFunction(map) ? + map : function(_, k){ return lang.getObject(k, false, map); }); + } + }; + + 1 && lang.mixin(dojo, lang); + + return lang; +}); + diff --git a/lib/dojo/_base/loader.js b/lib/dojo/_base/loader.js index fd9b8f3df..8dfd16dec 100644 --- a/lib/dojo/_base/loader.js +++ b/lib/dojo/_base/loader.js @@ -1,8 +1,8 @@ /* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Copyright (c) 2004-2012, 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>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();},_15=(1?function(){var _16,mid;for(mid in _17){_16=_17[mid];if(_16.noReqPluginCheck===undefined){_16.noReqPluginCheck=/loadInit\!/.test(mid)||/require\!/.test(mid)?1:0;}if(!_16.executed&&!_16.noReqPluginCheck&&_16.injected==_18){return;}}_19(function(){var _1a=_c;_c=[];_7.forEach(_1a,function(cb){cb(1);});});}:(function(){var _1b,_1c=function(m){_1b[m.mid]=1;for(var t,_1d,_1e=m.deps||[],i=0;i<_1e.length;i++){_1d=_1e[i];if(!(t=_1b[_1d.mid])){if(t===0||!_1c(_1d)){_1b[m.mid]=0;return false;}}}return true;};return function(){var _1f,mid;_1b={};for(mid in _17){_1f=_17[mid];if(_1f.executed||_1f.noReqPluginCheck){_1b[mid]=1;}else{if(_1f.noReqPluginCheck!==0){_1f.noReqPluginCheck=/loadInit\!/.test(mid)||/require\!/.test(mid)?1:0;}if(_1f.noReqPluginCheck){_1b[mid]=1;}else{if(_1f.injected!==_51){_1b[mid]=0;}}}}for(var t,i=0,end=_d.length;i>pure-amd + + if (! 1 ){ + console.error("cannot load the Dojo v1.x loader with a foreign loader"); + return 0; + } + + 1 || has.add("dojo-fast-sync-require", 1); + + + 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 = ( 1 ? + // This version of checkDojoRequirePlugin makes the observation that all dojoRequireCallbacks can be released + // when all *non-dojo/require!, dojo/loadInit!* modules are either executed, not requested, or arrived. This is + // the case since there are no more modules the loader is waiting for, therefore, dojo/require! must have + // everything it needs on board. + // + // The potential weakness of this algorithm is that dojo/require will not execute callbacks until *all* dependency + // trees are ready. It is possible that some trees may be ready earlier than others, and this extra wait is non-optimal. + // Still, for big projects, this seems better than the original algorithm below that proved slow in some cases. + // Note, however, the original algorithm had the potential to execute partial trees, but that potential was never enabled. + // There are also other optimization available with the original algorithm that have not been explored. + function(){ + var module, mid; + for(mid in modules){ + module = modules[mid]; + if(module.noReqPluginCheck===undefined){ + // 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.executed && !module.noReqPluginCheck && module.injected==requested){ + return; + } + } + + guardCheckComplete(function(){ + var oldCallbacks = dojoRequireCallbacks; + dojoRequireCallbacks = []; + array.forEach(oldCallbacks, function(cb){cb(1);}); + }); + } : (function(){ + // Note: this is the original checkDojoRequirePlugin that is much slower than the algorithm above. However, we know it + // works, so we leave it here in case the algorithm above fails in some corner case. + // + // checkDojoRequirePlugin inspects all of the modules demanded by a dojo/require! 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! 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 + + var touched, + traverse = function(m){ + touched[m.mid] = 1; + for(var t, module, deps = m.deps || [], i= 0; i a built module, always AMD + // extractResult==0 => no sync API + return 0; + } + + // manufacture a synthetic module id that can never be a real mdule id (just like require does) + id = module.mid + "-*loadInit"; + + // construct the dojo/loadInit names vector which causes any relocated names to be defined as lexical variables under their not-relocated name + // the dojo/loadInit plugin assumes the first name in names is "dojo" + + for(var p in getModule("dojo", module).result.scopeMap){ + names.push(p); + namesAsStrings.push('"' + p + '"'); + } + + // rewrite the module as a synthetic dojo/loadInit plugin resource + the module expressed as an AMD module that depends on this synthetic resource + // don't have to map dojo/init since that will occur when the dependency is resolved + return "// xdomain rewrite of " + module.mid + "\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, + + requested = + loaderVars.requested, + + 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, + + guardCheckComplete = + loaderVars.guardCheckComplete; + + // there is exactly one dojoRequirePlugin among possibly-many dojo/_base/loader's (owing to mapping) + dojoRequirePlugin = loaderVars.dojoRequirePlugin; + + 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); + + // rcg...why here and in two lines?? + 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.guardCheckComplete(function(){ + execModule(module); + }); + } + if(module.executed){ + return module.result; + } + + if(currentMode==sync){ + // the only way to get here is in sync mode and dojo.required a module that + // * was loaded async in the injectModule application a few lines up + // * was an AMD module that had deps that are being loaded async and therefore couldn't execute + if(module.cjs){ + // the module was an AMD module; unshift, not push, which causes the current traversal to be reattempted from the top + execQ.unshift(module); + }else{ + // the module was a legacy module + syncExecStack.length && (syncExecStack[0].finish= [mid]); + } + }else{ + // the loader wasn't in sync mode on entry; probably async mode; therefore, no expectation of getting + // the module value synchronously; make sure it gets executed though + execQ.push(module); + } + + return undefined; + } + + var result = doRequire(moduleName, omitModuleCheck); + if(has("config-publishRequireResult") && !lang.exists(moduleName) && result!==undefined){ + lang.setObject(moduleName, result); + } + return result; + }; + + dojo.loadInit = function(f) { + f(); + }; + + dojo.registerModulePath = function(/*String*/moduleName, /*String*/prefix){ + // summary: + // Maps a module name to a path + // description: + // An unregistered module is given the default path of ../[module], + // relative to Dojo root. For example, module acme is mapped to + // ../acme. If you want to use a different module name, use + // dojo.registerModulePath. + // example: + // If your dojo.js is located at this location in the web root: + // | /myapp/js/dojo/dojo/dojo.js + // and your modules are located at: + // | /myapp/js/foo/bar.js + // | /myapp/js/foo/baz.js + // | /myapp/js/foo/thud/xyzzy.js + // Your application can tell Dojo to locate the "foo" namespace by calling: + // | dojo.registerModulePath("foo", "../../foo"); + // At which point you can then use dojo.require() to load the + // modules (assuming they provide() the same things which are + // required). The full code might be: + // | + // | + + var paths = {}; + paths[moduleName.replace(/\./g, "/")] = prefix; + require({paths:paths}); + }; + + dojo.platformRequire = function(/*Object*/modMap){ + // summary: + // require one or more modules based on which host environment + // Dojo is currently operating in + // description: + // This method takes a "map" of arrays which one can use to + // optionally load dojo modules. The map is indexed by the + // possible dojo.name_ values, with two additional values: + // "default" and "common". The items in the "default" array will + // be loaded if none of the other items have been choosen based on + // dojo.name_, set by your host environment. The items in the + // "common" array will *always* be loaded, regardless of which + // list is chosen. + // example: + // | dojo.platformRequire({ + // | browser: [ + // | "foo.sample", // simple module + // | "foo.test", + // | ["foo.bar.baz", true] // skip object check in _loadModule (dojo.require) + // | ], + // | default: [ "foo.sample._base" ], + // | common: [ "important.module.common" ] + // | }); + + var result = (modMap.common || []).concat(modMap[dojo._name] || modMap["default"] || []), + temp; + while(result.length){ + if(lang.isArray(temp = result.shift())){ + dojo.require.apply(dojo, temp); + }else{ + dojo.require(temp); + } + } + }; + + dojo.requireIf = dojo.requireAfterIf = function(/*Boolean*/ condition, /*String*/ moduleName, /*Boolean?*/omitModuleCheck){ + // summary: + // If the condition is true then call `dojo.require()` for the specified + // resource + // + // example: + // | dojo.requireIf(dojo.isBrowser, "my.special.Module"); + + if(condition){ + dojo.require(moduleName, omitModuleCheck); + } + }; + + dojo.requireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale){ + require(["../i18n"], function(i18n){ + i18n.getLocalization(moduleName, bundleName, locale); + }); + }; + + return { + // summary: + // This module defines the v1.x synchronous loader API. + + extractLegacyApiApplications:extractLegacyApiApplications, + require:dojoRequirePlugin, + loadInit:dojoLoadInitPlugin + }; +}); diff --git a/lib/dojo/_base/query.js b/lib/dojo/_base/query.js index f6ee04bc8..36128a011 100644 --- a/lib/dojo/_base/query.js +++ b/lib/dojo/_base/query.js @@ -1,8 +1,8 @@ /* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Copyright (c) 2004-2012, 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/query",["./kernel","../query","./NodeList"],function(_1){return _1.query;}); \ No newline at end of file +define("dojo/_base/query",["../query","./NodeList"],function(_1){return _1;}); \ 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..d354bbc6c --- /dev/null +++ b/lib/dojo/_base/query.js.uncompressed.js @@ -0,0 +1,13 @@ +define("dojo/_base/query", ["../query", "./NodeList"], function(query){ + // module: + // dojo/_base/query + + /*===== + return { + // summary: + // Deprecated. Use dojo/query instead. + }; + =====*/ + + return query; +}); diff --git a/lib/dojo/_base/sniff.js b/lib/dojo/_base/sniff.js index 5849b99e9..34eb8180c 100644 --- a/lib/dojo/_base/sniff.js +++ b/lib/dojo/_base/sniff.js @@ -1,8 +1,8 @@ /* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Copyright (c) 2004-2012, 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 +define("dojo/_base/sniff",["./kernel","./lang","../sniff"],function(_1,_2,_3){if(!1){return _3;}_1._name="browser";_2.mixin(_1,{isBrowser:true,isFF:_3("ff"),isIE:_3("ie"),isKhtml:_3("khtml"),isWebKit:_3("webkit"),isMozilla:_3("mozilla"),isMoz:_3("mozilla"),isOpera:_3("opera"),isSafari:_3("safari"),isChrome:_3("chrome"),isMac:_3("mac"),isIos:_3("ios"),isAndroid:_3("android"),isWii:_3("wii"),isQuirks:_3("quirks"),isAir:_3("air")});_1.locale=_1.locale||(_3("ie")?navigator.userLanguage:navigator.language).toLowerCase();return _3;}); \ 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..eeb0b8560 --- /dev/null +++ b/lib/dojo/_base/sniff.js.uncompressed.js @@ -0,0 +1,96 @@ +define("dojo/_base/sniff", ["./kernel", "./lang", "../sniff"], function(dojo, lang, has){ + // module: + // dojo/_base/sniff + + /*===== + return { + // summary: + // Deprecated. New code should use dojo/sniff. + // This module populates the dojo browser version sniffing properties like dojo.isIE. + }; + =====*/ + + if(! 1 ){ + return has; + } + + // no idea what this is for, or if it's used + dojo._name = "browser"; + + lang.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: has("ff"), + + // 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: has("ie"), + + // isKhtml: Number|undefined + // Version as a Number if client is a KHTML browser. undefined otherwise. Corresponds to major + // detected version. + isKhtml: has("khtml"), + + // isWebKit: Number|undefined + // Version as a Number if client is a WebKit-derived browser (Konqueror, + // Safari, Chrome, etc.). undefined otherwise. + isWebKit: has("webkit"), + + // isMozilla: Number|undefined + // Version as a Number if client is a Mozilla-based browser (Firefox, + // SeaMonkey). undefined otherwise. Corresponds to major detected version. + isMozilla: has("mozilla"), + // isMoz: Number|undefined + // Version as a Number if client is a Mozilla-based browser (Firefox, + // SeaMonkey). undefined otherwise. Corresponds to major detected version. + isMoz: has("mozilla"), + + // isOpera: Number|undefined + // Version as a Number if client is Opera. undefined otherwise. Corresponds to + // major detected version. + isOpera: has("opera"), + + // isSafari: Number|undefined + // Version as a Number if client is Safari or iPhone. undefined otherwise. + isSafari: has("safari"), + + // isChrome: Number|undefined + // Version as a Number if client is Chrome browser. undefined otherwise. + isChrome: has("chrome"), + + // isMac: Boolean + // True if the client runs on Mac + isMac: has("mac"), + + // isIos: Boolean + // True if client is iPhone, iPod, or iPad + isIos: has("ios"), + + // isAndroid: Number|undefined + // Version as a Number if client is android browser. undefined otherwise. + isAndroid: has("android"), + + // isWii: Boolean + // True if client is Wii + isWii: has("wii"), + + // isQuirks: Boolean + // Page is in quirks mode. + isQuirks: has("quirks"), + + // isAir: Boolean + // True if client is Adobe Air + isAir: has("air") + }); + + + dojo.locale = dojo.locale || (has("ie") ? navigator.userLanguage : navigator.language).toLowerCase(); + + return has; +}); diff --git a/lib/dojo/_base/unload.js b/lib/dojo/_base/unload.js index 8e099ae14..218bbb972 100644 --- a/lib/dojo/_base/unload.js +++ b/lib/dojo/_base/unload.js @@ -1,8 +1,8 @@ /* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Copyright (c) 2004-2012, 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 +define("dojo/_base/unload",["./kernel","./lang","../on"],function(_1,_2,on){var _3=window;var _4={addOnWindowUnload:function(_5,_6){if(!_1.windowUnloaded){on(_3,"unload",(_1.windowUnloaded=function(){}));}on(_3,"unload",_2.hitch(_5,_6));},addOnUnload:function(_7,_8){on(_3,"beforeunload",_2.hitch(_7,_8));}};_1.addOnWindowUnload=_4.addOnWindowUnload;_1.addOnUnload=_4.addOnUnload;return _4;}); \ 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..1ceae7d29 --- /dev/null +++ b/lib/dojo/_base/unload.js.uncompressed.js @@ -0,0 +1,82 @@ +define("dojo/_base/unload", ["./kernel", "./lang", "../on"], function(dojo, lang, on){ + +// module: +// dojo/unload + +var win = window; + +var unload = { + // summary: + // This module contains the document and window unload detection API. + + 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 + // destroy "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 + // addOnUnload() if you need to modify the DOM or do + // heavy JavaScript work since it fires at the equivalent of + // the page's "onbeforeunload" event. + // example: + // | unload.addOnWindowUnload(functionPointer) + // | unload.addOnWindowUnload(object, "functionName"); + // | unload.addOnWindowUnload(object, function(){ /* ... */}); + + if (!dojo.windowUnloaded){ + on(win, "unload", (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 + // addOnWindowUnload(). This behavior started in Dojo 1.3. + // Previous versions always triggered windowUnloaded(). See + // addOnWindowUnload for more info. + })); + } + on(win, "unload", lang.hitch(obj, functionName)); + }, + + 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 environment, 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(){ /* ... */}); + + on(win, "beforeunload", lang.hitch(obj, functionName)); + } +}; + +dojo.addOnWindowUnload = unload.addOnWindowUnload; +dojo.addOnUnload = unload.addOnUnload; + +return unload; + +}); diff --git a/lib/dojo/_base/url.js b/lib/dojo/_base/url.js index 41bae092c..82ba41d80 100644 --- a/lib/dojo/_base/url.js +++ b/lib/dojo/_base/url.js @@ -1,5 +1,5 @@ /* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Copyright (c) 2004-2012, 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 */ diff --git a/lib/dojo/_base/url.js.uncompressed.js b/lib/dojo/_base/url.js.uncompressed.js new file mode 100644 index 000000000..c83e1a2e3 --- /dev/null +++ b/lib/dojo/_base/url.js.uncompressed.js @@ -0,0 +1,109 @@ +define("dojo/_base/url", ["./kernel"], function(dojo){ + // module: + // 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 7082cb077..1049aec2e 100644 --- a/lib/dojo/_base/window.js +++ b/lib/dojo/_base/window.js @@ -1,8 +1,8 @@ /* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Copyright (c) 2004-2012, 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/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 +define("dojo/_base/window",["./kernel","./lang","../sniff"],function(_1,_2,_3){var _4={global:_1.global,doc:this["document"]||null,body:function(_5){_5=_5||_1.doc;return _5.body||_5.getElementsByTagName("body")[0];},setContext:function(_6,_7){_1.global=_4.global=_6;_1.doc=_4.doc=_7;},withGlobal:function(_8,_9,_a,_b){var _c=_1.global;try{_1.global=_4.global=_8;return _4.withDoc.call(null,_8.document,_9,_a,_b);}finally{_1.global=_4.global=_c;}},withDoc:function(_d,_e,_f,_10){var _11=_4.doc,_12=_3("quirks"),_13=_3("ie"),_14,_15,_16;try{_1.doc=_4.doc=_d;_1.isQuirks=_3.add("quirks",_1.doc.compatMode=="BackCompat",true,true);if(_3("ie")){if((_16=_d.parentWindow)&&_16.navigator){_14=parseFloat(_16.navigator.appVersion.split("MSIE ")[1])||undefined;_15=_d.documentMode;if(_15&&_15!=5&&Math.floor(_14)!=_15){_14=_15;}_1.isIE=_3.add("ie",_14,true,true);}}if(_f&&typeof _e=="string"){_e=_f[_e];}return _e.apply(_f,_10||[]);}finally{_1.doc=_4.doc=_11;_1.isQuirks=_3.add("quirks",_12,true,true);_1.isIE=_3.add("ie",_13,true,true);}}};1&&_2.mixin(_1,_4);return _4;}); \ 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..3d23c3a97 --- /dev/null +++ b/lib/dojo/_base/window.js.uncompressed.js @@ -0,0 +1,134 @@ +define("dojo/_base/window", ["./kernel", "./lang", "../sniff"], function(dojo, lang, has){ +// module: +// dojo/_base/window + +var ret = { + // summary: + // API to save/set/restore the global/document scope. + + global: dojo.global, + /*===== + global: { + // summary: + // Alias for the current window. 'global' can be modified + // for temporary context shifting. See also withGlobal(). + // description: + // Use this rather than referring to 'window' to ensure your code runs + // correctly in managed contexts. + }, + =====*/ + + doc: this["document"] || null, + /*===== + doc: { + // summary: + // Alias for the current document. 'doc' can be modified + // for temporary context shifting. See also withDoc(). + // description: + // Use this rather than referring to 'window.document' to ensure your code runs + // correctly in managed contexts. + // example: + // | n.appendChild(dojo.doc.createElement('div')); + }, + =====*/ + + body: function(/*Document?*/ doc){ + // summary: + // Return the body element of the specified document or of dojo/_base/window::doc. + // example: + // | win.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(). + doc = doc || dojo.doc; + return doc.body || doc.getElementsByTagName("body")[0]; // Node + }, + + 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; + }, + + 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 ret.withDoc.call(null, globalObject.document, callback, thisObject, cbArguments); + }finally{ + dojo.global = ret.global = oldGlob; + } + }, + + withDoc: function( /*DocumentElement*/ documentObject, + /*Function*/ callback, + /*Object?*/ thisObject, + /*Array?*/ cbArguments){ + // summary: + // Invoke callback with documentObject as dojo/_base/window::doc. + // description: + // Invoke callback with documentObject as dojo/_base/window::doc. If provided, + // callback will be executed in the context of object thisObject + // When callback() returns or throws an error, the dojo/_base/window::doc will + // be restored to its previous state. + + var oldDoc = ret.doc, + oldQ = has("quirks"), + oldIE = has("ie"), isIE, mode, pwin; + + try{ + dojo.doc = ret.doc = documentObject; + // update dojo.isQuirks and the value of the has feature "quirks". + // remove setting dojo.isQuirks and dojo.isIE for 2.0 + 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); + } + } +}; + + 1 && lang.mixin(dojo, ret); + +return ret; + +}); diff --git a/lib/dojo/_base/xhr.js b/lib/dojo/_base/xhr.js index ee38dbd4f..48ef42474 100644 --- a/lib/dojo/_base/xhr.js +++ b/lib/dojo/_base/xhr.js @@ -1,8 +1,8 @@ /* - Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. + Copyright (c) 2004-2012, 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/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)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 +define("dojo/_base/xhr",["./kernel","./sniff","require","../io-query","../dom","../dom-form","./Deferred","./config","./json","./lang","./array","../on","../aspect","../request/watch","../request/xhr","../request/util"],function(_1,_2,_3,_4,_5,_6,_7,_8,_9,_a,_b,on,_c,_d,_e,_f){_1._xhrObj=_e._create;var cfg=_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 _10=_1._contentHandlers=_1.contentHandlers={"text":function(xhr){return xhr.responseText;},"json":function(xhr){return _9.fromJson(xhr.responseText||null);},"json-comment-filtered":function(xhr){if(!_8.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 _11=xhr.responseText;var _12=_11.indexOf("/*");var _13=_11.lastIndexOf("*/");if(_12==-1||_13==-1){throw new Error("JSON was not comment filtered");}return _9.fromJson(_11.substring(_12+2,_13));},"javascript":function(xhr){return _1.eval(xhr.responseText);},"xml":function(xhr){var _14=xhr.responseXML;if(_2("ie")){if((!_14||!_14.documentElement)){var ms=function(n){return "MSXML"+n+".DOMDocument";};var dp=["Microsoft.XMLDOM",ms(6),ms(4),ms(3),ms(2)];_b.some(dp,function(p){try{var dom=new ActiveXObject(p);dom.async=false;dom.loadXML(xhr.responseText);_14=dom;}catch(e){return false;}return true;});}}return _14;},"json-comment-optional":function(xhr){if(xhr.responseText&&/^[^{\[]*\/\*/.test(xhr.responseText)){return _10["json-comment-filtered"](xhr);}else{return _10["json"](xhr);}}};_1._ioSetArgs=function(_15,_16,_17,_18){var _19={args:_15,url:_15.url};var _1a=null;if(_15.form){var _1b=_5.byId(_15.form);var _1c=_1b.getAttributeNode("action");_19.url=_19.url||(_1c?_1c.value:null);_1a=_6.toObject(_1b);}var _1d=[{}];if(_1a){_1d.push(_1a);}if(_15.content){_1d.push(_15.content);}if(_15.preventCache){_1d.push({"dojo.preventCache":new Date().valueOf()});}_19.query=_4.objectToQuery(_a.mixin.apply(null,_1d));_19.handleAs=_15.handleAs||"text";var d=new _7(function(dfd){dfd.canceled=true;_16&&_16(dfd);var err=dfd.ioArgs.error;if(!err){err=new Error("request cancelled");err.dojoType="cancel";dfd.ioArgs.error=err;}return err;});d.addCallback(_17);var ld=_15.load;if(ld&&_a.isFunction(ld)){d.addCallback(function(_1e){return ld.call(_15,_1e,_19);});}var err=_15.error;if(err&&_a.isFunction(err)){d.addErrback(function(_1f){return err.call(_15,_1f,_19);});}var _20=_15.handle;if(_20&&_a.isFunction(_20)){d.addBoth(function(_21){return _20.call(_15,_21,_19);});}d.addErrback(function(_22){return _18(_22,d);});if(cfg.ioPublish&&_1.publish&&_19.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=_19;return d;};var _23=function(dfd){var ret=_10[dfd.ioArgs.handleAs](dfd.ioArgs.xhr);return ret===undefined?null:ret;};var _24=function(_25,dfd){if(!dfd.ioArgs.args.failOk){console.error(_25);}return _25;};var _26=function(dfd){if(_27<=0){_27=0;if(cfg.ioPublish&&_1.publish&&(!dfd||dfd&&dfd.ioArgs.args.ioPublish!==false)){_1.publish("/dojo/io/stop");}}};var _27=0;_c.after(_d,"_onAction",function(){_27-=1;});_c.after(_d,"_onInFlight",_26);_1._ioCancelAll=_d.cancelAll;_1._ioNotifyStart=function(dfd){if(cfg.ioPublish&&_1.publish&&dfd.ioArgs.args.ioPublish!==false){if(!_27){_1.publish("/dojo/io/start");}_27+=1;_1.publish("/dojo/io/send",[dfd]);}};_1._ioWatch=function(dfd,_28,_29,_2a){var _2b=dfd.ioArgs.options=dfd.ioArgs.args;_a.mixin(dfd,{response:dfd.ioArgs,isValid:function(_2c){return _28(dfd);},isReady:function(_2d){return _29(dfd);},handleResponse:function(_2e){return _2a(dfd);}});_d(dfd);_26(dfd);};var _2f="application/x-www-form-urlencoded";_1._ioAddQueryToUrl=function(_30){if(_30.query.length){_30.url+=(_30.url.indexOf("?")==-1?"?":"&")+_30.query;_30.query=null;}};_1.xhr=function(_31,_32,_33){var _34;var dfd=_1._ioSetArgs(_32,function(dfd){_34&&_34.cancel();},_23,_24);var _35=dfd.ioArgs;if("postData" in _32){_35.query=_32.postData;}else{if("putData" in _32){_35.query=_32.putData;}else{if("rawBody" in _32){_35.query=_32.rawBody;}else{if((arguments.length>2&&!_33)||"POST|PUT".indexOf(_31.toUpperCase())===-1){_1._ioAddQueryToUrl(_35);}}}}var _36={method:_31,handleAs:"text",timeout:_32.timeout,withCredentials:_32.withCredentials,ioArgs:_35};if(typeof _32.headers!=="undefined"){_36.headers=_32.headers;}if(typeof _32.contentType!=="undefined"){if(!_36.headers){_36.headers={};}_36.headers["Content-Type"]=_32.contentType;}if(typeof _35.query!=="undefined"){_36.data=_35.query;}if(typeof _32.sync!=="undefined"){_36.sync=_32.sync;}_1._ioNotifyStart(dfd);try{_34=_e(_35.url,_36,true);}catch(e){dfd.cancel();return dfd;}dfd.ioArgs.xhr=_34.response.xhr;_34.then(function(){dfd.resolve(dfd);}).otherwise(function(_37){_35.error=_37;if(_37.response){_37.status=_37.response.status;_37.responseText=_37.response.text;_37.xhr=_37.response.xhr;}dfd.reject(_37);});return dfd;};_1.xhrGet=function(_38){return _1.xhr("GET",_38);};_1.rawXhrPost=_1.xhrPost=function(_39){return _1.xhr("POST",_39,true);};_1.rawXhrPut=_1.xhrPut=function(_3a){return _1.xhr("PUT",_3a,true);};_1.xhrDelete=function(_3b){return _1.xhr("DELETE",_3b);};_1._isDocumentOk=function(x){return _f.checkStatus(x.status);};_1._getText=function(url){var _3c;_1.xhrGet({url:url,sync:true,load:function(_3d){_3c=_3d;}});return _3c;};_a.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:_10,_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..ee78af504 --- /dev/null +++ b/lib/dojo/_base/xhr.js.uncompressed.js @@ -0,0 +1,710 @@ +define("dojo/_base/xhr", [ + "./kernel", + "./sniff", + "require", + "../io-query", + /*===== "./declare", =====*/ + "../dom", + "../dom-form", + "./Deferred", + "./config", + "./json", + "./lang", + "./array", + "../on", + "../aspect", + "../request/watch", + "../request/xhr", + "../request/util" +], function(dojo, has, require, ioq, /*===== declare, =====*/ dom, domForm, Deferred, config, json, lang, array, on, aspect, watch, _xhr, util){ + // module: + // dojo/_base/xhr + + /*===== + dojo._xhrObj = function(){ + // summary: + // does the work of portably generating a new XMLHTTPRequest object. + }; + =====*/ + dojo._xhrObj = _xhr._create; + + 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 available XHR transport handle types. Name matches the + // `handleAs` attribute passed to XHR calls. + // description: + // A map of available 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: + // | xhr.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(!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); + } + } + }; + + /*===== + + // kwargs function parameter definitions. Assigning to dojo namespace rather than making them local variables + // because they are used by dojo/io modules too + + dojo.__IoArgs = declare(null, { + // 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/_base/xhr.rawXhrPost and dojo/_base/xhr.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/topic.publish() for different phases of an IO operation. + // See dojo/main.__IoPublish for a list of topics that are published. + + load: function(response, ioArgs){ + // summary: + // This function will be + // called on a successful HTTP response code. + // ioArgs: dojo/main.__IoCallbackArgs + // Provides additional information about the request. + // response: Object + // The response in the format as defined with handleAs. + }, + + error: function(response, ioArgs){ + // summary: + // 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. + // ioArgs: dojo/main.__IoCallbackArgs + // Provides additional information about the request. + // response: Object + // The response in the format as defined with handleAs. + }, + + handle: function(loadOrError, response, ioArgs){ + // summary: + // This function will + // be called at the end of every request, whether or not an error occurs. + // 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/main.__IoCallbackArgs + // Provides additional information about the request. + } + }); + + dojo.__IoCallbackArgs = declare(null, { + // 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. + }); + + dojo.__IoPublish = declare(null, { + // 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. + }); + =====*/ + + + dojo._ioSetArgs = function(/*dojo/main.__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 requested. + 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(function(dfd){ + dfd.canceled = true; + canceller && canceller(dfd); + + var err = dfd.ioArgs.error; + if(!err){ + err = new Error("request cancelled"); + err.dojoType="cancel"; + dfd.ioArgs.error = err; + } + return err; + }); + d.addCallback(okHandler); + + //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); + }); + } + + // Attach error handler last (not including topic publishing) + // to catch any errors that may have been generated from load + // or handle functions. + d.addErrback(function(error){ + return errHandler(error, d); + }); + + //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 + // analogous in the Deferred + return d; + }; + + 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; + }; + + //Use a separate count for knowing if we are starting/stopping io calls. + 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 _pubCount = 0; + aspect.after(watch, "_onAction", function(){ + _pubCount -= 1; + }); + aspect.after(watch, "_onInFlight", _checkPubCount); + + dojo._ioCancelAll = watch.cancelAll; + /*===== + dojo._ioCancelAll = function(){ + // summary: + // Cancels all pending IO requests, regardless of IO type + // (xhr, script, iframe). + }; + =====*/ + + 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. + // + // 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.options = dfd.ioArgs.args; + lang.mixin(dfd, { + response: dfd.ioArgs, + isValid: function(response){ + return validCheck(dfd); + }, + isReady: function(response){ + return ioCheck(dfd); + }, + handleResponse: function(response){ + return resHandle(dfd); + } + }); + watch(dfd); + + _checkPubCount(dfd); + }; + + var _defaultContentType = "application/x-www-form-urlencoded"; + + 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.__XhrArgs = declare(dojo.__IoArgs, { + // 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/_base/xhr.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. + }); + =====*/ + + dojo.xhr = function(/*String*/ method, /*dojo.__XhrArgs*/ args, /*Boolean?*/ hasBody){ + // summary: + // Deprecated. Use dojo/request instead. + // 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. + + var rDfd; + //Make the Deferred object for this xhr request. + var dfd = dojo._ioSetArgs(args, function(dfd){ + rDfd && rDfd.cancel(); + }, _deferredOk, _deferError); + var ioArgs = dfd.ioArgs; + + //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); + } + + var options = { + method: method, + handleAs: "text", + timeout: args.timeout, + withCredentials: args.withCredentials, + ioArgs: ioArgs + }; + + if(typeof args.headers !== 'undefined'){ + options.headers = args.headers; + } + if(typeof args.contentType !== 'undefined'){ + if(!options.headers){ + options.headers = {}; + } + options.headers['Content-Type'] = args.contentType; + } + if(typeof ioArgs.query !== 'undefined'){ + options.data = ioArgs.query; + } + if(typeof args.sync !== 'undefined'){ + options.sync = args.sync; + } + + dojo._ioNotifyStart(dfd); + try{ + rDfd = _xhr(ioArgs.url, options, true); + }catch(e){ + // If XHR creation fails, dojo/request/xhr throws + // When this happens, cancel the deferred + dfd.cancel(); + return dfd; + } + + // sync ioArgs + dfd.ioArgs.xhr = rDfd.response.xhr; + + rDfd.then(function(){ + dfd.resolve(dfd); + }).otherwise(function(error){ + ioArgs.error = error; + if(error.response){ + error.status = error.response.status; + error.responseText = error.response.text; + error.xhr = error.response.xhr; + } + dfd.reject(error); + }); + return dfd; // dojo/_base/Deferred + }; + + dojo.xhrGet = function(/*dojo.__XhrArgs*/ args){ + // summary: + // Sends an HTTP GET request to the server. + return dojo.xhr("GET", args); // dojo/_base/Deferred + }; + + dojo.rawXhrPost = dojo.xhrPost = function(/*dojo.__XhrArgs*/ args){ + // summary: + // Sends an HTTP POST request to the server. In addition 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/_base/Deferred + }; + + dojo.rawXhrPut = dojo.xhrPut = function(/*dojo.__XhrArgs*/ args){ + // summary: + // Sends an HTTP PUT request to the server. In addition 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/_base/Deferred + }; + + dojo.xhrDelete = function(/*dojo.__XhrArgs*/ args){ + // summary: + // Sends an HTTP DELETE request to the server. + return dojo.xhr("DELETE", args); // dojo/_base/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(x){ + return util.checkStatus(x.status); + }; + + 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; +}); -- cgit v1.2.3