| New file |
|---|
| 0,0 → 1,203 |
|---|
| 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; |
| } |
| } |
| |
| } |