dojo_src 1.4.102 → 1.5.0

data/dojo/dojo/LICENSE

@@ -13,7 +13,7 @@ The text of the AFL and BSD licenses is reproduced below.
 The "New" BSD License:
 **********************
 
-Copyright (c) 2005-2009, The Dojo Foundation
+Copyright (c) 2005-2010, The Dojo Foundation
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

data/dojo/dojo/NodeList-fx.js

@@ -10,59 +10,114 @@ dojo["NodeList-fx"] = {
 dojo.extend(dojo.NodeList, {
 	_anim: function(obj, method, args){
 		args = args||{};
-		return dojo.fx.combine(
+		var a = dojo.fx.combine(
 			this.map(function(item){
 				var tmpArgs = { node: item };
 				dojo.mixin(tmpArgs, args);
 				return obj[method](tmpArgs);
 			})
-		); // dojo.Animation
+		); 
+		return args.auto ? a.play() && this : a; // dojo.Animation|dojo.NodeList
 	},
 
 	wipeIn: function(args){
 		//	summary:
-		//		wipe in all elements of this NodeList. Returns an instance of dojo.Animation
+		//		wipe in all elements of this NodeList via `dojo.fx.wipeIn`
+		//
+		//	args: Object?
+		//		Additional dojo.Animation arguments to mix into this set with the addition of 
+		//		an `auto` parameter.
+		//
+		//	returns: dojo.Animation|dojo.NodeList
+		//		A special args member `auto` can be passed to automatically play the animation.
+		//		If args.auto is present, the original dojo.NodeList will be returned for further
+		//		chaining. Otherwise the dojo.Animation instance is returned and must be .play()'ed
+		//
 		//	example:
 		//		Fade in all tables with class "blah":
 		//		|	dojo.query("table.blah").wipeIn().play();
-		return this._anim(dojo.fx, "wipeIn", args); // dojo.Animation
+		//
+		//	example:
+		//		Utilizing `auto` to get the NodeList back:
+		//		|	dojo.query(".titles").wipeIn({ auto:true }).onclick(someFunction);
+		//
+		return this._anim(dojo.fx, "wipeIn", args); // dojo.Animation|dojo.NodeList
 	},
 
 	wipeOut: function(args){
 		//	summary:
-		//		wipe out all elements of this NodeList. Returns an instance of dojo.Animation
+		//		wipe out all elements of this NodeList via `dojo.fx.wipeOut`
+		//
+		//	args: Object?
+		//		Additional dojo.Animation arguments to mix into this set with the addition of 
+		//		an `auto` parameter.
+		//
+		//	returns: dojo.Animation|dojo.NodeList
+		//		A special args member `auto` can be passed to automatically play the animation.
+		//		If args.auto is present, the original dojo.NodeList will be returned for further
+		//		chaining. Otherwise the dojo.Animation instance is returned and must be .play()'ed
+		//
 		//	example:
 		//		Wipe out all tables with class "blah":
 		//		|	dojo.query("table.blah").wipeOut().play();
-		return this._anim(dojo.fx, "wipeOut", args); // dojo.Animation
+		return this._anim(dojo.fx, "wipeOut", args); // dojo.Animation|dojo.NodeList
 	},
 
 	slideTo: function(args){
 		//	summary:
-		//		slide all elements of the node list to the specified place.
-		//		Returns an instance of dojo.Animation
+		//		slide all elements of the node list to the specified place via `dojo.fx.slideTo`
+		//
+		//	args: Object?
+		//		Additional dojo.Animation arguments to mix into this set with the addition of 
+		//		an `auto` parameter.
+		//
+		//	returns: dojo.Animation|dojo.NodeList
+		//		A special args member `auto` can be passed to automatically play the animation.
+		//		If args.auto is present, the original dojo.NodeList will be returned for further
+		//		chaining. Otherwise the dojo.Animation instance is returned and must be .play()'ed
+		//
 		//	example:
 		//		|	Move all tables with class "blah" to 300/300:
 		//		|	dojo.query("table.blah").slideTo({
 		//		|		left: 40,
 		//		|		top: 50
 		//		|	}).play();
-		return this._anim(dojo.fx, "slideTo", args); // dojo.Animation
+		return this._anim(dojo.fx, "slideTo", args); // dojo.Animation|dojo.NodeList
 	},
 
 
 	fadeIn: function(args){
 		//	summary:
-		//		fade in all elements of this NodeList. Returns an instance of dojo.Animation
+		//		fade in all elements of this NodeList via `dojo.fadeIn`
+		//
+		//	args: Object?
+		//		Additional dojo.Animation arguments to mix into this set with the addition of 
+		//		an `auto` parameter.
+		//
+		//	returns: dojo.Animation|dojo.NodeList
+		//		A special args member `auto` can be passed to automatically play the animation.
+		//		If args.auto is present, the original dojo.NodeList will be returned for further
+		//		chaining. Otherwise the dojo.Animation instance is returned and must be .play()'ed
+		//
 		//	example:
 		//		Fade in all tables with class "blah":
 		//		|	dojo.query("table.blah").fadeIn().play();
-		return this._anim(dojo, "fadeIn", args); // dojo.Animation
+		return this._anim(dojo, "fadeIn", args); // dojo.Animation|dojo.NodeList
 	},
 
 	fadeOut: function(args){
 		//	summary:
-		//		fade out all elements of this NodeList. Returns an instance of dojo.Animation
+		//		fade out all elements of this NodeList via `dojo.fadeOut`
+		//
+		//	args: Object?
+		//		Additional dojo.Animation arguments to mix into this set with the addition of 
+		//		an `auto` parameter.
+		//
+		//	returns: dojo.Animation|dojo.NodeList
+		//		A special args member `auto` can be passed to automatically play the animation.
+		//		If args.auto is present, the original dojo.NodeList will be returned for further
+		//		chaining. Otherwise the dojo.Animation instance is returned and must be .play()'ed
+		//
 		//	example:
 		//		Fade out all elements with class "zork":
 		//		|	dojo.query(".zork").fadeOut().play();
@@ -71,13 +126,23 @@ dojo.extend(dojo.NodeList, {
 		//		|	var fo = dojo.query(".zork").fadeOut();
 		//		|	dojo.connect(fo, "onEnd", function(){ /*...*/ });
 		//		|	fo.play();
-		return this._anim(dojo, "fadeOut", args); // dojo.Animation
+		//	example:
+		//		Using `auto`:
+		//		|	dojo.query("li").fadeOut({ auto:true }).filter(filterFn).forEach(doit);
+		//
+		return this._anim(dojo, "fadeOut", args); // dojo.Animation|dojo.NodeList
 	},
 
 	animateProperty: function(args){
 		//	summary:
-		//		see dojo.animateProperty(). Animate all elements of this
-		//		NodeList across the properties specified.
+		//		Animate all elements of this NodeList across the properties specified.
+		//		syntax identical to `dojo.animateProperty`
+		//
+		// returns: dojo.Animation|dojo.NodeList
+		//		A special args member `auto` can be passed to automatically play the animation.
+		//		If args.auto is present, the original dojo.NodeList will be returned for further
+		//		chaining. Otherwise the dojo.Animation instance is returned and must be .play()'ed
+		//
 		//	example:
 		//	|	dojo.query(".zork").animateProperty({
 		//	|		duration: 500,
@@ -86,10 +151,18 @@ dojo.extend(dojo.NodeList, {
 		//	|			left:		{ end: 300 } 
 		//	|		} 
 		//	|	}).play();
-		return this._anim(dojo, "animateProperty", args); // dojo.Animation
+		//
+		//	example:
+		//	|	dojo.query(".grue").animateProperty({ 
+		//	|		auto:true,
+		//	|		properties: {
+		//	|			height:240
+		//	|		}
+		//	|	}).onclick(handler);
+		return this._anim(dojo, "animateProperty", args); // dojo.Animation|dojo.NodeList
 	},
 
-	anim: function(	/*Object*/ 			properties, 
+	anim: function( /*Object*/			properties, 
 					/*Integer?*/		duration, 
 					/*Function?*/		easing, 
 					/*Function?*/		onEnd,
@@ -99,7 +172,8 @@ dojo.extend(dojo.NodeList, {
 		//		The returned animation object will already be playing when it
 		//		is returned. See the docs for `dojo.anim` for full details.
 		//	properties: Object
-		//		the properties to animate
+		//		the properties to animate. does NOT support the `auto` parameter like other 
+		//		NodeList-fx methods. 
 		//	duration: Integer?
 		//		Optional. The time to run the animations for
 		//	easing: Function?

data/dojo/dojo/Stateful.js

@@ -0,0 +1,123 @@
+dojo.provide("dojo.Stateful");
+
+dojo.declare("dojo.Stateful", null, {
+	// summary:
+	//		Base class for objects that provide named properties with optional getter/setter
+	//		control and the ability to watch for property changes
+	// example:
+	//	|	var obj = new dojo.Stateful();
+	//	|	obj.watch("foo", function(){
+	//	|		console.log("foo changed to " + this.get("foo"));
+	//	|	});
+	//	|	obj.set("foo","bar");
+	postscript: function(mixin){
+		if(mixin){
+			dojo.mixin(this, mixin);
+		}
+	},
+	
+	get: function(/*String*/name){
+		// summary:
+		//		Get a property on a Stateful instance.
+		//	name:
+		//		The property to get.
+		// description:
+		//		Get a named property on a Stateful object. The property may
+		//		potentially be retrieved via a getter method in subclasses. In the base class
+		// 		this just retrieves the object's property. 
+		// 		For example:
+		//	|	stateful = new dojo.Stateful({foo: 3});
+		//	|	stateful.get("foo") // returns 3
+		//	|	stateful.foo // returns 3
+		
+		return this[name];
+	},
+	set: function(/*String*/name, /*Object*/value){
+		// summary:
+		//		Set a property on a Stateful instance
+		//	name:
+		//		The property to set. 
+		//	value:
+		//		The value to set in the property.
+		// description:
+		//		Sets named properties on a stateful object and notifies any watchers of 
+		// 		the property. A programmatic setter may be defined in subclasses.
+		// 		For example:
+		//	|	stateful = new dojo.Stateful();
+		//	|	stateful.watch(function(name, oldValue, value){
+		//	|		// this will be called on the set below
+		//	|	}
+		//	|	stateful.set(foo, 5);
+		//
+		//	set() may also be called with a hash of name/value pairs, ex:
+		//	|	myObj.set({
+		//	|		foo: "Howdy",
+		//	|		bar: 3
+		//	|	})
+		//	This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
+		if(typeof name === "object"){
+			for(var x in name){
+				this.set(x, name[x]); 
+			}
+			return this;
+		}
+		var oldValue = this[name];
+		this[name] = value;
+		if(this._watchCallbacks){
+			this._watchCallbacks(name, oldValue, value);
+		}
+		return this;
+	},
+	watch: function(/*String?*/name, /*Function*/callback){
+		// summary:
+		//		Watches a property for changes
+		//	name:
+		//		Indicates the property to watch. This is optional (the callback may be the 
+		// 		only parameter), and if omitted, all the properties will be watched
+		// returns:
+		//		An object handle for the watch. The unwatch method of this object 
+		// 		can be used to discontinue watching this property:
+		//		|	var watchHandle = obj.watch("foo", callback);
+		//		|	watchHandle.unwatch(); // callback won't be called now
+		//	callback:
+		//		The function to execute when the property changes. This will be called after
+		//		the property has been changed. The callback will be called with the |this|
+		//		set to the instance, the first argument as the name of the property, the 
+		// 		second argument as the old value and the third argument as the new value.
+		
+		var callbacks = this._watchCallbacks;
+		if(!callbacks){
+			var self = this;
+			callbacks = this._watchCallbacks = function(name, oldValue, value, ignoreCatchall){
+				var notify = function(propertyCallbacks){
+					for(var i = 0, l = propertyCallbacks && propertyCallbacks.length; i < l; i++){
+						try{
+							propertyCallbacks[i].call(self, name, oldValue, value);
+						}catch(e){
+							console.error(e);
+						}
+					}
+				};
+				notify(callbacks[name]);
+				if(!ignoreCatchall){
+					notify(callbacks["*"]); // the catch-all
+				}
+			}; // we use a function instead of an object so it will be ignored by JSON conversion
+		}
+		if(!callback && typeof name === "function"){
+			callback = name;
+			name = "*";
+		}
+		var propertyCallbacks = callbacks[name];
+		if(typeof propertyCallbacks !== "object"){
+			propertyCallbacks = callbacks[name] = [];
+		}
+		propertyCallbacks.push(callback);
+		return {
+			unwatch: function(){
+				propertyCallbacks.splice(dojo.indexOf(propertyCallbacks, callback), 1);
+			}
+		};
+	}
+	
+});

data/dojo/dojo/_base.js

@@ -1,9 +1,9 @@
 dojo.provide("dojo._base");
 dojo.require("dojo._base.lang");
+dojo.require("dojo._base.array");
 dojo.require("dojo._base.declare");
 dojo.require("dojo._base.connect");
 dojo.require("dojo._base.Deferred");
 dojo.require("dojo._base.json");
-dojo.require("dojo._base.array");
 dojo.require("dojo._base.Color");
 dojo.requireIf(dojo.isBrowser, "dojo._base.browser");

data/dojo/dojo/_base/Deferred.js

@@ -1,115 +1,52 @@
 dojo.provide("dojo._base.Deferred");
 dojo.require("dojo._base.lang");
 
-dojo.Deferred = function(/*Function?*/ canceller){
+(function(){
+	var mutator = function(){};		
+	var freeze = Object.freeze || function(){};
+	// A deferred provides an API for creating and resolving a promise.
+	dojo.Deferred = function(/*Function?*/canceller){
 	// summary:
-	//		Encapsulates a sequence of callbacks in response to a value that
-	//		may not yet be available.  This is modeled after the Deferred class
-	//		from Twisted <http://twistedmatrix.com>.
+	//		Deferreds provide a generic means for encapsulating an asynchronous
+	// 		operation and notifying users of the completion and result of the operation. 
 	// description:
-	//		JavaScript has no threads, and even if it did, threads are hard.
-	//		Deferreds are a way of abstracting non-blocking events, such as the
-	//		final response to an XMLHttpRequest. Deferreds create a promise to
-	//		return a response a some point in the future and an easy way to
-	//		register your interest in receiving that response.
+	//		The dojo.Deferred API is based on the concept of promises that provide a
+	//		generic interface into the eventual completion of an asynchronous action.
+	//		The motivation for promises fundamentally is about creating a 
+	//		separation of concerns that allows one to achieve the same type of 
+	//		call patterns and logical data flow in asynchronous code as can be 
+	//		achieved in synchronous code. Promises allows one 
+	//		to be able to call a function purely with arguments needed for 
+	//		execution, without conflating the call with concerns of whether it is 
+	//		sync or async. One shouldn't need to alter a call's arguments if the 
+	//		implementation switches from sync to async (or vice versa). By having 
+	//		async functions return promises, the concerns of making the call are 
+	//		separated from the concerns of asynchronous interaction (which are 
+	//		handled by the promise).
+	// 
+	//  	The dojo.Deferred is a type of promise that provides methods for fulfilling the 
+	// 		promise with a successful result or an error. The most important method for 
+	// 		working with Dojo's promises is the then() method, which follows the 
+	// 		CommonJS proposed promise API. An example of using a Dojo promise:
+	//		
+	//		| 	var resultingPromise = someAsyncOperation.then(function(result){
+	//		|		... handle result ...
+	//		|	},
+	//		|	function(error){
+	//		|		... handle error ...
+	//		|	});
+	//	
+	//		The .then() call returns a new promise that represents the result of the 
+	// 		execution of the callback. The callbacks will never affect the original promises value.
 	//
-	//		The most important methods for Deffered users are:
+	//		The dojo.Deferred instances also provide the following functions for backwards compatibility:
 	//
 	//			* addCallback(handler)
 	//			* addErrback(handler)
 	//			* callback(result)
 	//			* errback(result)
 	//
-	//		In general, when a function returns a Deferred, users then "fill
-	//		in" the second half of the contract by registering callbacks and
-	//		error handlers. You may register as many callback and errback
-	//		handlers as you like and they will be executed in the order
-	//		registered when a result is provided. Usually this result is
-	//		provided as the result of an asynchronous operation. The code
-	//		"managing" the Deferred (the code that made the promise to provide
-	//		an answer later) will use the callback() and errback() methods to
-	//		communicate with registered listeners about the result of the
-	//		operation. At this time, all registered result handlers are called
-	//		*with the most recent result value*.
-	//
-	//		Deferred callback handlers are treated as a chain, and each item in
-	//		the chain is required to return a value that will be fed into
-	//		successive handlers. The most minimal callback may be registered
-	//		like this:
-	//
-	//		|	var d = new dojo.Deferred();
-	//		|	d.addCallback(function(result){ return result; });
-	//
-	//		Perhaps the most common mistake when first using Deferreds is to
-	//		forget to return a value (in most cases, the value you were
-	//		passed).
-	//
-	//		The sequence of callbacks is internally represented as a list of
-	//		2-tuples containing the callback/errback pair.  For example, the
-	//		following call sequence:
-	//		
-	//		|	var d = new dojo.Deferred();
-	//		|	d.addCallback(myCallback);
-	//		|	d.addErrback(myErrback);
-	//		|	d.addBoth(myBoth);
-	//		|	d.addCallbacks(myCallback, myErrback);
-	//
-	//		is translated into a Deferred with the following internal
-	//		representation:
-	//
-	//		|	[
-	//		|		[myCallback, null],
-	//		|		[null, myErrback],
-	//		|		[myBoth, myBoth],
-	//		|		[myCallback, myErrback]
-	//		|	]
-	//
-	//		The Deferred also keeps track of its current status (fired).  Its
-	//		status may be one of three things:
-	//
-	//			* -1: no value yet (initial condition)
-	//			* 0: success
-	//			* 1: error
-	//	
-	//		A Deferred will be in the error state if one of the following three
-	//		conditions are met:
-	//
-	//			1. The result given to callback or errback is "instanceof" Error
-	//			2. The previous callback or errback raised an exception while
-	//			   executing
-	//			3. The previous callback or errback returned a value
-	//			   "instanceof" Error
-	//
-	//		Otherwise, the Deferred will be in the success state. The state of
-	//		the Deferred determines the next element in the callback sequence
-	//		to run.
-	//
-	//		When a callback or errback occurs with the example deferred chain,
-	//		something equivalent to the following will happen (imagine
-	//		that exceptions are caught and returned):
-	//
-	//		|	// d.callback(result) or d.errback(result)
-	//		|	if(!(result instanceof Error)){
-	//		|		result = myCallback(result);
-	//		|	}
-	//		|	if(result instanceof Error){
-	//		|		result = myErrback(result);
-	//		|	}
-	//		|	result = myBoth(result);
-	//		|	if(result instanceof Error){
-	//		|		result = myErrback(result);
-	//		|	}else{
-	//		|		result = myCallback(result);
-	//		|	}
-	//
-	//		The result is then stored away in case another step is added to the
-	//		callback sequence.	Since the Deferred already has a value
-	//		available, any new callbacks added will be called immediately.
-	//
-	//		There are two other "advanced" details about this implementation
-	//		that are useful:
-	//
-	//		Callbacks are allowed to return Deferred instances themselves, so
+	//		Callbacks are allowed to return promisesthemselves, so
 	//		you can build complicated sequences of events with ease.
 	//
 	//		The creator of the Deferred may specify a canceller.  The canceller
@@ -176,7 +113,7 @@ dojo.Deferred = function(/*Function?*/ canceller){
 	//		|	}
 	//
 	//		|	// using Deferred style
-	//		|	renderLotsOfData(someDataObj).addErrback(function(){
+	//		|	renderLotsOfData(someDataObj).then(null, function(){
 	//		|		promptUserToRecover();
 	//		|	});
 	//		|	// NOTE: addErrback and addCallback both return the Deferred
@@ -204,218 +141,191 @@ dojo.Deferred = function(/*Function?*/ canceller){
 	//		|	}
 	//
 	//		|	// using Deferred style
-	//		|	renderLotsOfData(someDataObj).addErrback(function(){
+	//		|	renderLotsOfData(someDataObj).then(null, function(){
 	//		|		promptUserToRecover();
 	//		|	});
 	//
 	//		Note that the caller doesn't have to change his code at all to
 	//		handle the asynchronous case.
-
-	this.chain = [];
-	this.id = this._nextId();
-	this.fired = -1;
-	this.paused = 0;
-	this.results = [null, null];
-	this.canceller = canceller;
-	this.silentlyCancelled = false;
-	this.isFiring = false;
-};
-
-dojo.extend(dojo.Deferred, {
-	/*
-	makeCalled: function(){
-		// summary:
-		//		returns a new, empty deferred, which is already in the called
-		//		state. Calling callback() or errback() on this deferred will
-		//		yeild an error and adding new handlers to it will result in
-		//		them being called immediately.
-		var deferred = new dojo.Deferred();
-		deferred.callback();
-		return deferred;
-	},
-
-	toString: function(){
-		var state;
-		if(this.fired == -1){
-			state = 'unfired';
-		}else{
-			state = this.fired ? 'success' : 'error';
-		}
-		return 'Deferred(' + this.id + ', ' + state + ')';
-	},
-	*/
-
-	_nextId: (function(){
-		var n = 1;
-		return function(){ return n++; };
-	})(),
-
-	cancel: function(){
-		// summary:	
-		//		Cancels a Deferred that has not yet received a value, or is
-		//		waiting on another Deferred as its value.
-		// description:
-		//		If a canceller is defined, the canceller is called. If the
-		//		canceller did not return an error, or there was no canceller,
-		//		then the errback chain is started.
-		var err;
-		if(this.fired == -1){
-			if(this.canceller){
-				err = this.canceller(this);
-			}else{
-				this.silentlyCancelled = true;
-			}
-			if(this.fired == -1){
-				if(!(err instanceof Error)){
-					var res = err;
-					var msg = "Deferred Cancelled";
-					if(err && err.toString){
-						msg += ": " + err.toString();
-					}
-					err = new Error(msg);
-					err.dojoType = "cancel";
-					err.cancelResult = res;
-				}
-				this.errback(err);
-			}
-		}else if(	(this.fired == 0) &&
-					(this.results[0] instanceof dojo.Deferred)
-		){
-			this.results[0].cancel();
-		}
-	},
-			
-
-	_resback: function(res){
-		// summary:
-		//		The private primitive that means either callback or errback
-		this.fired = ((res instanceof Error) ? 1 : 0);
-		this.results[this.fired] = res;
-		this._fire();
-	},
-
-	_check: function(){
-		if(this.fired != -1){
-			if(!this.silentlyCancelled){
-				throw new Error("already called!");
-			}
-			this.silentlyCancelled = false;
-			return;
-		}
-	},
-
-	callback: function(res){
-		//	summary:	
-		//		Begin the callback sequence with a non-error value.
+		var result, finished, isError, head, nextListener;
+		var promise = this.promise = {};
 		
-		/*
-		callback or errback should only be called once on a given
-		Deferred.
-		*/
-		this._check();
-		this._resback(res);
-	},
-
-	errback: function(/*Error*/res){
-		//	summary: 
-		//		Begin the callback sequence with an error result.
-		this._check();
-		if(!(res instanceof Error)){
-			res = new Error(res);
-		}
-		this._resback(res);
-	},
-
-	addBoth: function(/*Function|Object*/cb, /*String?*/cbfn){
-		//	summary:
-		//		Add the same function as both a callback and an errback as the
-		//		next element on the callback sequence.This is useful for code
-		//		that you want to guarantee to run, e.g. a finalizer.
-		var enclosed = dojo.hitch.apply(dojo, arguments);
-		return this.addCallbacks(enclosed, enclosed); // dojo.Deferred
-	},
-
-	addCallback: function(/*Function|Object*/cb, /*String?*/cbfn /*...*/){
-		//	summary: 
-		//		Add a single callback to the end of the callback sequence.
-		return this.addCallbacks(dojo.hitch.apply(dojo, arguments)); // dojo.Deferred
-	},
-
-	addErrback: function(cb, cbfn){
-		//	summary: 
-		//		Add a single callback to the end of the callback sequence.
-		return this.addCallbacks(null, dojo.hitch.apply(dojo, arguments)); // dojo.Deferred
-	},
-
-	addCallbacks: function(cb, eb){
-		// summary: 
-		//		Add separate callback and errback to the end of the callback
-		//		sequence.
-		this.chain.push([cb, eb])
-		if(this.fired >= 0 && !this.isFiring){
-			this._fire();
+		function complete(value){
+			if(finished){
+				throw new Error("This deferred has already been resolved");				
+			}
+			result = value;
+			finished = true;
+			notify();
 		}
-		return this; // dojo.Deferred
-	},
-
-	_fire: function(){
-		// summary: 
-		//		Used internally to exhaust the callback sequence when a result
-		//		is available.
-		this.isFiring = true;
-		var chain = this.chain;
-		var fired = this.fired;
-		var res = this.results[fired];
-		var self = this;
-		var cb = null;
-		while(
-			(chain.length > 0) &&
-			(this.paused == 0)
-		){
-			// Array
-			var f = chain.shift()[fired];
-			if(!f){ continue; }
-			var func = function(){
-				var ret = f(res);
-				//If no response, then use previous response.
-				if(typeof ret != "undefined"){
-					res = ret;
+		function notify(){
+			var mutated;
+			while(!mutated && nextListener){
+				var listener = nextListener;
+				nextListener = nextListener.next;
+				if(mutated = (listener.progress == mutator)){ // assignment and check
+					finished = false;
 				}
-				fired = ((res instanceof Error) ? 1 : 0);
-				if(res instanceof dojo.Deferred){
-					cb = function(res){
-						self._resback(res);
-						// inlined from _pause()
-						self.paused--;
-						if(
-							(self.paused == 0) && 
-							(self.fired >= 0)
-						){
-							self._fire();
+				var func = (isError ? listener.error : listener.resolved);
+				if (func) {
+					try {
+						var newResult = func(result);
+						if (newResult && typeof newResult.then === "function") {
+							newResult.then(dojo.hitch(listener.deferred, "resolve"), dojo.hitch(listener.deferred, "reject"));
+							continue;
 						}
+						var unchanged = mutated && newResult === undefined;
+						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);
 					}
-					// inlined from _unpause
-					this.paused++;
 				}
-			};
-			if(dojo.config.debugAtAllCosts){
-				func.call(this);
-			}else{
-				try{
-					func.call(this);
-				}catch(err){
-					fired = 1;
-					res = err;
+			}	
+		}
+		// calling resolve will resolve the promise
+		this.resolve = this.callback = function(value){
+			// summary:
+			//		Fulfills the Deferred instance successfully with the provide value
+			this.fired = 0;
+			this.results = [value, null];
+			complete(value);
+		};
+		
+		
+		// calling error will indicate that the promise failed
+		this.reject = this.errback = function(error){
+			// summary:
+			//		Fulfills the Deferred instance as an error with the provided error 
+			isError = true;
+			this.fired = 1;
+			complete(error);
+			this.results = [null, error];
+			if(!error || error.log !== false){
+				(dojo.config.deferredOnError || function(x){ console.error(x); })(error);
+			}
+		};
+		// call progress to provide updates on the progress on the completion of the promise
+		this.progress = function(update){
+			// summary
+			//		Send progress events to all listeners
+			var listener = nextListener;
+			while(listener){
+				var progress = listener.progress;
+				progress && progress(update);
+				listener = listener.next;	
+			}
+		};
+		this.addCallbacks = function(/*Function?*/callback, /*Function?*/errback){
+			this.then(callback, errback, mutator);
+			return this;
+		};
+		// provide the implementation of the promise
+		this.then = promise.then = function(/*Function?*/resolvedCallback, /*Function?*/errorCallback, /*Function?*/progressCallback){
+			// summary
+			// 		Adds a fulfilledHandler, errorHandler, and progressHandler to be called for 
+			// 		completion of a promise. The fulfilledHandler is called when the promise 
+			// 		is fulfilled. The errorHandler is called when a promise fails. The 
+			// 		progressHandler is called for progress events. All arguments are optional 
+			// 		and non-function values are ignored. The progressHandler is not only an 
+			// 		optional argument, but progress events are purely optional. Promise 
+			// 		providers are not required to ever create progress events.
+			// 
+			// 		This function will return a new promise that is fulfilled when the given 
+			// 		fulfilledHandler or errorHandler callback is finished. This allows promise 
+			// 		operations to be chained together. The value returned from the callback 
+			// 		handler is the fulfillment value for the returned promise. If the callback 
+			// 		throws an error, the returned promise will be moved to failed state.
+			//	
+			// example:
+			// 		An example of using a CommonJS compliant promise:
+  			//		|	asyncComputeTheAnswerToEverything().
+			//		|		then(addTwo).
+			//		|		then(printResult, onError);
+  			//		|	>44 
+			// 		
+			var returnDeferred = progressCallback == mutator ? this : new dojo.Deferred(promise.cancel);
+			var listener = {
+				resolved: resolvedCallback, 
+				error: errorCallback, 
+				progress: progressCallback, 
+				deferred: returnDeferred
+			}; 
+			if(nextListener){
+				head = head.next = listener;
+			}
+			else{
+				nextListener = head = listener;
+			}
+			if(finished){
+				notify();
+			}
+			return returnDeferred.promise;
+		};
+		var deferred = this;
+		this.cancel = promise.cancel = function () {
+			// summary:
+			//		Cancels the asynchronous operation
+			if(!finished){
+				var error = canceller && canceller(deferred);
+				if(!finished){
+					if (!(error instanceof Error)) {
+						error = new Error(error);
+					}
+					error.log = false;
+					deferred.reject(error);
 				}
 			}
 		}
-		this.fired = fired;
-		this.results[fired] = res;
-		this.isFiring = false;
-		if((cb)&&(this.paused)){
-			// this is for "tail recursion" in case the dependent
-			// deferred is already fired
-			res.addBoth(cb);
-		}
+		freeze(promise);
+	};
+	dojo.extend(dojo.Deferred, {
+		addCallback: function (/*Function*/callback) {
+			return this.addCallbacks(dojo.hitch.apply(dojo, arguments));
+		},
+	
+		addErrback: function (/*Function*/errback) {
+			return this.addCallbacks(null, dojo.hitch.apply(dojo, arguments));
+		},
+	
+		addBoth: function (/*Function*/callback) {
+			var enclosed = dojo.hitch.apply(dojo, arguments);
+			return this.addCallbacks(enclosed, enclosed);
+		},
+		fired: -1
+	});
+})();
+dojo.when = function(promiseOrValue, /*Function?*/callback, /*Function?*/errback, /*Function?*/progressHandler){
+	// summary:
+	//		This provides normalization between normal synchronous values and 
+	//		asynchronous promises, so you can interact with them in a common way
+	//	example:
+	//		|	function printFirstAndList(items){
+	//		|		dojo.when(findFirst(items), console.log);
+	//		|		dojo.when(findLast(items), console.log);
+	//		|	}
+	//		|	function findFirst(items){
+	//		|		return dojo.when(items, function(items){
+	//		|			return items[0];
+	//		|		});
+	//		|	}
+	//		|	function findLast(items){
+	//		|		return dojo.when(items, function(items){
+	//		|			return items[items.length];
+	//		|		});
+	//		|	}
+	//		And now all three of his functions can be used sync or async.
+	//		|	printFirstAndLast([1,2,3,4]) will work just as well as
+	//		|	printFirstAndLast(dojo.xhrGet(...));
+	
+	if(promiseOrValue && typeof promiseOrValue.then === "function"){
+		return promiseOrValue.then(callback, errback, progressHandler);
 	}
-});
+	return callback(promiseOrValue);
+};