Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojo.io.script"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.

dojo._hasResource["dojo.io.script"] = true;

dojo.provide("dojo.io.script");

/*=====

dojo.io.script.__ioArgs = function(kwArgs){

	//	summary:

	//		All the properties described in the dojo.__ioArgs type, apply to this

	//		type as well, EXCEPT "handleAs". It is not applicable to

	//		dojo.io.script.get() calls, since it is implied by the usage of

	//		"callbackParamName" (response will be a JSONP call returning JSON)

	//		or "checkString" (response is pure JavaScript defined in

	//		the body of the script that was attached). The following additional

	//		properties are allowed for dojo.io.script.get():

	//	callbackParamName: String

	//		The URL parameter name that indicates the JSONP callback string.

	//		For instance, when using Yahoo JSONP calls it is normally,

	//		callbackParamName: "callback". For AOL JSONP calls it is normally

	//		callbackParamName: "c".

	//	checkString: String

	//		A string of JavaScript that when evaluated like so:

	//		"typeof(" + checkString + ") != 'undefined'"

	//		being true means that the script fetched has been loaded.

	//		Do not use this if doing a JSONP type of call (use callbackParamName instead).

}

=====*/

dojo.io.script = {

	get: function(/*dojo.io.script.__ioArgs*/args){

		//	summary:

		//		sends a get request using a dynamically created script tag.

		var dfd = this._makeScriptDeferred(args);

		var ioArgs = dfd.ioArgs;

		dojo._ioAddQueryToUrl(ioArgs);

		this.attach(ioArgs.id, ioArgs.url);

		dojo._ioWatch(dfd, this._validCheck, this._ioCheck, this._resHandle);

		return dfd;

	},

	attach: function(/*String*/id, /*String*/url){

		//	summary:

		//		creates a new <script> tag pointing to the specified URL and

		//		adds it to the document.

		//	description:

		//		Attaches the script element to the DOM.  Use this method if you

		//		just want to attach a script to the DOM and do not care when or

		//		if it loads.

		var element = dojo.doc.createElement("script");

		element.type = "text/javascript";

		element.src = url;

		element.id = id;

		dojo.doc.getElementsByTagName("head")[0].appendChild(element);

	},

	remove: function(/*String*/id){

		//summary: removes the script element with the given id.

		dojo._destroyElement(dojo.byId(id));

		//Remove the jsonp callback on dojo.io.script, if it exists.

		if(this["jsonp_" + id]){

			delete this["jsonp_" + id];

		}

	},

	_makeScriptDeferred: function(/*Object*/args){

		//summary:

		//		sets up a Deferred object for an IO request.

		var dfd = dojo._ioSetArgs(args, this._deferredCancel, this._deferredOk, this._deferredError);

		var ioArgs = dfd.ioArgs;

		ioArgs.id = "dojoIoScript" + (this._counter++);

		ioArgs.canDelete = false;

		//Special setup for jsonp case

		if(args.callbackParamName){

			//Add the jsonp parameter.

			ioArgs.query = ioArgs.query || "";

			if(ioArgs.query.length > 0){

				ioArgs.query += "&";

			}

			ioArgs.query += args.callbackParamName + "=dojo.io.script.jsonp_" + ioArgs.id + "._jsonpCallback";

			//Setup the Deferred to have the jsonp callback.

			ioArgs.canDelete = true;

			dfd._jsonpCallback = this._jsonpCallback;

			this["jsonp_" + ioArgs.id] = dfd;

		}

		return dfd; // dojo.Deferred

	},

	_deferredCancel: function(/*Deferred*/dfd){

		//summary: canceller function for dojo._ioSetArgs call.

		//DO NOT use "this" and expect it to be dojo.io.script.

		dfd.canceled = true;

		if(dfd.ioArgs.canDelete){

			dojo.io.script._deadScripts.push(dfd.ioArgs.id);

		}

	},

	_deferredOk: function(/*Deferred*/dfd){

		//summary: okHandler function for dojo._ioSetArgs call.

		//DO NOT use "this" and expect it to be dojo.io.script.

		//Add script to list of things that can be removed.

		if(dfd.ioArgs.canDelete){

			dojo.io.script._deadScripts.push(dfd.ioArgs.id);

		}

		if(dfd.ioArgs.json){

			//Make sure to *not* remove the json property from the

			//Deferred, so that the Deferred can still function correctly

			//after the response is received.

			return dfd.ioArgs.json;

		}else{

			//FIXME: cannot return the dfd here, otherwise that stops

			//the callback chain in Deferred. So return the ioArgs instead.

			//This doesn't feel right.

			return dfd.ioArgs;

		}

	},

	_deferredError: function(/*Error*/error, /*Deferred*/dfd){

		//summary: errHandler function for dojo._ioSetArgs call.

		if(dfd.ioArgs.canDelete){

			//DO NOT use "this" and expect it to be dojo.io.script.

			if(error.dojoType == "timeout"){

				//For timeouts, remove the script element immediately to

				//avoid a response from it coming back later and causing trouble.

				dojo.io.script.remove(dfd.ioArgs.id);

			}else{

				dojo.io.script._deadScripts.push(dfd.ioArgs.id);

			}

		}

		console.debug("dojo.io.script error", error);

		return error;

	},

	_deadScripts: [],

	_counter: 1,

	_validCheck: function(/*Deferred*/dfd){

		//summary: inflight check function to see if dfd is still valid.

		//Do script cleanup here. We wait for one inflight pass

		//to make sure we don't get any weird things by trying to remove a script

		//tag that is part of the call chain (IE 6 has been known to

		//crash in that case).

		var _self = dojo.io.script;

		var deadScripts = _self._deadScripts;

		if(deadScripts && deadScripts.length > 0){

			for(var i = 0; i < deadScripts.length; i++){

				//Remove the script tag

				_self.remove(deadScripts[i]);

			}

			dojo.io.script._deadScripts = [];

		}

		return true;

	},

	_ioCheck: function(/*Deferred*/dfd){

		//summary: inflight check function to see if IO finished.

		//Check for finished jsonp

		if(dfd.ioArgs.json){

			return true;

		}

		//Check for finished "checkString" case.

		var checkString = dfd.ioArgs.args.checkString;

		if(checkString && eval("typeof(" + checkString + ") != 'undefined'")){

			return true;

		}

		return false;

	},

	_resHandle: function(/*Deferred*/dfd){

		//summary: inflight function to handle a completed response.

		if(dojo.io.script._ioCheck(dfd)){

			dfd.callback(dfd);

		}else{

			//This path should never happen since the only way we can get

			//to _resHandle is if _ioCheck is true.

			dfd.errback(new Error("inconceivable dojo.io.script._resHandle error"));

		}

	},

	_jsonpCallback: function(/*JSON Object*/json){

		//summary:

		//		generic handler for jsonp callback. A pointer to this function

		//		is used for all jsonp callbacks.  NOTE: the "this" in this

		//		function will be the Deferred object that represents the script

		//		request.

		this.ioArgs.json = json;

	}

}

}