263 lines
8.6 KiB
JavaScript
263 lines
8.6 KiB
JavaScript
/*
|
|
Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
|
|
Available via Academic Free License >= 2.1 OR the modified BSD license.
|
|
see: http://dojotoolkit.org/license for details
|
|
*/
|
|
|
|
|
|
if(!dojo._hasResource["dojo.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.getObject("io", true, dojo);
|
|
|
|
/*=====
|
|
dojo.declare("dojo.io.script.__ioArgs", dojo.__IoArgs, {
|
|
constructor: function(){
|
|
// 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
|
|
// "jsonp" (response will be a JSONP call returning JSON)
|
|
// or the response is pure JavaScript defined in
|
|
// the body of the script that was attached.
|
|
// callbackParamName: String
|
|
// Deprecated as of Dojo 1.4 in favor of "jsonp", but still supported for
|
|
// legacy code. See notes for jsonp property.
|
|
// jsonp: String
|
|
// The URL parameter name that indicates the JSONP callback string.
|
|
// For instance, when using Yahoo JSONP calls it is normally,
|
|
// jsonp: "callback". For AOL JSONP calls it is normally
|
|
// jsonp: "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).
|
|
// frameDoc: Document
|
|
// The Document object for a child iframe. If this is passed in, the script
|
|
// will be attached to that document. This can be helpful in some comet long-polling
|
|
// scenarios with Firefox and Opera.
|
|
this.callbackParamName = callbackParamName;
|
|
this.jsonp = jsonp;
|
|
this.checkString = checkString;
|
|
this.frameDoc = frameDoc;
|
|
}
|
|
});
|
|
=====*/
|
|
(function(){
|
|
var loadEvent = dojo.isIE ? "onreadystatechange" : "load",
|
|
readyRegExp = /complete|loaded/;
|
|
|
|
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);
|
|
|
|
dojo._ioNotifyStart(dfd);
|
|
|
|
if(this._canAttach(ioArgs)){
|
|
var node = this.attach(ioArgs.id, ioArgs.url, args.frameDoc);
|
|
|
|
//If not a jsonp callback or a polling checkString case, bind
|
|
//to load event on the script tag.
|
|
if(!ioArgs.jsonp && !ioArgs.args.checkString){
|
|
var handle = dojo.connect(node, loadEvent, function(evt){
|
|
if(evt.type == "load" || readyRegExp.test(node.readyState)){
|
|
dojo.disconnect(handle);
|
|
ioArgs.scriptLoaded = evt;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
dojo._ioWatch(dfd, this._validCheck, this._ioCheck, this._resHandle);
|
|
return dfd;
|
|
},
|
|
|
|
attach: function(/*String*/id, /*String*/url, /*Document?*/frameDocument){
|
|
// 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 doc = (frameDocument || dojo.doc);
|
|
var element = doc.createElement("script");
|
|
element.type = "text/javascript";
|
|
element.src = url;
|
|
element.id = id;
|
|
element.charset = "utf-8";
|
|
return doc.getElementsByTagName("head")[0].appendChild(element);
|
|
},
|
|
|
|
remove: function(/*String*/id, /*Document?*/frameDocument){
|
|
//summary: removes the script element with the given id, from the given frameDocument.
|
|
//If no frameDocument is passed, the current document is used.
|
|
dojo.destroy(dojo.byId(id, frameDocument));
|
|
|
|
//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 = dojo._scopeName + "IoScript" + (this._counter++);
|
|
ioArgs.canDelete = false;
|
|
|
|
//Special setup for jsonp case
|
|
ioArgs.jsonp = args.callbackParamName || args.jsonp;
|
|
if(ioArgs.jsonp){
|
|
//Add the jsonp parameter.
|
|
ioArgs.query = ioArgs.query || "";
|
|
if(ioArgs.query.length > 0){
|
|
ioArgs.query += "&";
|
|
}
|
|
ioArgs.query += ioArgs.jsonp
|
|
+ "="
|
|
+ (args.frameDoc ? "parent." : "")
|
|
+ dojo._scopeName + ".io.script.jsonp_" + ioArgs.id + "._jsonpCallback";
|
|
|
|
ioArgs.frameDoc = args.frameDoc;
|
|
|
|
//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._addDeadScript(dfd.ioArgs);
|
|
}
|
|
},
|
|
|
|
_deferredOk: function(/*Deferred*/dfd){
|
|
//summary: okHandler function for dojo._ioSetArgs call.
|
|
|
|
//DO NOT use "this" and expect it to be dojo.io.script.
|
|
var ioArgs = dfd.ioArgs;
|
|
|
|
//Add script to list of things that can be removed.
|
|
if(ioArgs.canDelete){
|
|
dojo.io.script._addDeadScript(ioArgs);
|
|
}
|
|
|
|
//Favor JSONP responses, script load events then lastly ioArgs.
|
|
//The ioArgs are goofy, but cannot return the dfd since that stops
|
|
//the callback chain in Deferred. The return value is not that important
|
|
//in that case, probably a checkString case.
|
|
return ioArgs.json || ioArgs.scriptLoaded || 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, dfd.ioArgs.frameDoc);
|
|
}else{
|
|
dojo.io.script._addDeadScript(dfd.ioArgs);
|
|
}
|
|
}
|
|
console.log("dojo.io.script error", error);
|
|
return error;
|
|
},
|
|
|
|
_deadScripts: [],
|
|
_counter: 1,
|
|
|
|
_addDeadScript: function(/*Object*/ioArgs){
|
|
//summary: sets up an entry in the deadScripts array.
|
|
dojo.io.script._deadScripts.push({id: ioArgs.id, frameDoc: ioArgs.frameDoc});
|
|
//Being extra paranoid about leaks:
|
|
ioArgs.frameDoc = null;
|
|
},
|
|
|
|
_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].id, deadScripts[i].frameDoc);
|
|
deadScripts[i].frameDoc = null;
|
|
}
|
|
dojo.io.script._deadScripts = [];
|
|
}
|
|
|
|
return true;
|
|
},
|
|
|
|
_ioCheck: function(/*Deferred*/dfd){
|
|
//summary: inflight check function to see if IO finished.
|
|
var ioArgs = dfd.ioArgs;
|
|
//Check for finished jsonp
|
|
if(ioArgs.json || (ioArgs.scriptLoaded && !ioArgs.args.checkString)){
|
|
return true;
|
|
}
|
|
|
|
//Check for finished "checkString" case.
|
|
var checkString = 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"));
|
|
}
|
|
},
|
|
|
|
_canAttach: function(/*Object*/ioArgs){
|
|
//summary: A method that can be overridden by other modules
|
|
//to control when the script attachment occurs.
|
|
return true;
|
|
},
|
|
|
|
_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;
|
|
}
|
|
};
|
|
})();
|
|
|
|
}
|