diff options
Diffstat (limited to 'lib/dojo/io/iframe.js.uncompressed.js')
| -rw-r--r-- | lib/dojo/io/iframe.js.uncompressed.js | 376 |
1 files changed, 376 insertions, 0 deletions
diff --git a/lib/dojo/io/iframe.js.uncompressed.js b/lib/dojo/io/iframe.js.uncompressed.js new file mode 100644 index 000000000..9ac948278 --- /dev/null +++ b/lib/dojo/io/iframe.js.uncompressed.js @@ -0,0 +1,376 @@ +define("dojo/io/iframe", ["../main", "require"], function(dojo, require) { + // module: + // dojo/io/iframe + // summary: + // TODOC + +dojo.getObject("io", true, dojo); + +/*===== +dojo.declare("dojo.io.iframe.__ioArgs", dojo.__IoArgs, { + constructor: function(){ + // summary: + // All the properties described in the dojo.__ioArgs type, apply + // to this type. The following additional properties are allowed + // for dojo.io.iframe.send(): + // method: String? + // The HTTP method to use. "GET" or "POST" are the only supported + // values. It will try to read the value from the form node's + // method, then try this argument. If neither one exists, then it + // defaults to POST. + // handleAs: String? + // Specifies what format the result data should be given to the + // load/handle callback. Valid values are: text, html, xml, json, + // javascript. IMPORTANT: For all values EXCEPT html and xml, The + // server response should be an HTML file with a textarea element. + // The response data should be inside the textarea element. Using an + // HTML document the only reliable, cross-browser way this + // transport can know when the response has loaded. For the html + // handleAs value, just return a normal HTML document. NOTE: xml + // is now supported with this transport (as of 1.1+); a known issue + // is if the XML document in question is malformed, Internet Explorer + // will throw an uncatchable error. + // content: Object? + // If "form" is one of the other args properties, then the content + // object properties become hidden form form elements. For + // instance, a content object of {name1 : "value1"} is converted + // to a hidden form element with a name of "name1" and a value of + // "value1". If there is not a "form" property, then the content + // object is converted into a name=value&name=value string, by + // using dojo.objectToQuery(). + this.method = method; + this.handleAs = handleAs; + this.content = content; + } +}); +=====*/ + +dojo.io.iframe = { + // summary: + // Sends an Ajax I/O call using and Iframe (for instance, to upload files) + + create: function(/*String*/fname, /*String*/onloadstr, /*String?*/uri){ + // summary: + // Creates a hidden iframe in the page. Used mostly for IO + // transports. You do not need to call this to start a + // dojo.io.iframe request. Just call send(). + // fname: String + // The name of the iframe. Used for the name attribute on the + // iframe. + // onloadstr: String + // A string of JavaScript that will be executed when the content + // in the iframe loads. + // uri: String + // The value of the src attribute on the iframe element. If a + // value is not given, then dojo/resources/blank.html will be + // used. + if(window[fname]){ return window[fname]; } + if(window.frames[fname]){ return window.frames[fname]; } + var turi = uri; + if(!turi){ + if(dojo.config["useXDomain"] && !dojo.config["dojoBlankHtmlUrl"]){ + console.warn("dojo.io.iframe.create: When using cross-domain Dojo builds," + + " please save dojo/resources/blank.html to your domain and set djConfig.dojoBlankHtmlUrl" + + " to the path on your domain to blank.html"); + } + turi = (dojo.config["dojoBlankHtmlUrl"]||require.toUrl("../resources/blank.html")); + } + var cframe = dojo.place( + '<iframe id="'+fname+'" name="'+fname+'" src="'+turi+'" onload="'+onloadstr+ + '" style="position: absolute; left: 1px; top: 1px; height: 1px; width: 1px; visibility: hidden">', + dojo.body()); + + window[fname] = cframe; + + return cframe; + }, + + setSrc: function(/*DOMNode*/iframe, /*String*/src, /*Boolean*/replace){ + //summary: + // Sets the URL that is loaded in an IFrame. The replace parameter + // indicates whether location.replace() should be used when + // changing the location of the iframe. + try{ + if(!replace){ + if(dojo.isWebKit){ + iframe.location = src; + }else{ + frames[iframe.name].location = src; + } + }else{ + // Fun with DOM 0 incompatibilities! + var idoc; + if(dojo.isIE || dojo.isWebKit){ + idoc = iframe.contentWindow.document; + }else{ // if(d.isMozilla){ + idoc = iframe.contentWindow; + } + + //For Safari (at least 2.0.3) and Opera, if the iframe + //has just been created but it doesn't have content + //yet, then iframe.document may be null. In that case, + //use iframe.location and return. + if(!idoc){ + iframe.location = src; + }else{ + idoc.location.replace(src); + } + } + }catch(e){ + console.log("dojo.io.iframe.setSrc: ", e); + } + }, + + doc: function(/*DOMNode*/iframeNode){ + //summary: Returns the document object associated with the iframe DOM Node argument. + return iframeNode.contentDocument || // W3 + ( + ( + (iframeNode.name) && (iframeNode.document) && + (dojo.doc.getElementsByTagName("iframe")[iframeNode.name].contentWindow) && + (dojo.doc.getElementsByTagName("iframe")[iframeNode.name].contentWindow.document) + ) + ) || // IE + ( + (iframeNode.name)&&(dojo.doc.frames[iframeNode.name])&& + (dojo.doc.frames[iframeNode.name].document) + ) || null; + }, + + send: function(/*dojo.io.iframe.__ioArgs*/args){ + //summary: + // Function that sends the request to the server. + // This transport can only process one send() request at a time, so if send() is called + //multiple times, it will queue up the calls and only process one at a time. + if(!this["_frame"]){ + this._frame = this.create(this._iframeName, dojo._scopeName + ".io.iframe._iframeOnload();"); + } + + //Set up the deferred. + var dfd = dojo._ioSetArgs( + args, + function(/*Deferred*/dfd){ + //summary: canceller function for dojo._ioSetArgs call. + dfd.canceled = true; + dfd.ioArgs._callNext(); + }, + function(/*Deferred*/dfd){ + //summary: okHandler function for dojo._ioSetArgs call. + var value = null; + try{ + var ioArgs = dfd.ioArgs; + var dii = dojo.io.iframe; + var ifd = dii.doc(dii._frame); + var handleAs = ioArgs.handleAs; + + //Assign correct value based on handleAs value. + value = ifd; //html + if(handleAs != "html"){ + if(handleAs == "xml"){ + // FF, Saf 3+ and Opera all seem to be fine with ifd being xml. We have to + // do it manually for IE6-8. Refs #6334. + if(dojo.isIE < 9 || (dojo.isIE && dojo.isQuirks)){ + dojo.query("a", dii._frame.contentWindow.document.documentElement).orphan(); + var xmlText=(dii._frame.contentWindow.document).documentElement.innerText; + xmlText=xmlText.replace(/>\s+</g, "><"); + xmlText=dojo.trim(xmlText); + //Reusing some code in base dojo for handling XML content. Simpler and keeps + //Core from duplicating the effort needed to locate the XML Parser on IE. + var fauxXhr = { responseText: xmlText }; + value = dojo._contentHandlers["xml"](fauxXhr); // DOMDocument + } + }else{ + value = ifd.getElementsByTagName("textarea")[0].value; //text + if(handleAs == "json"){ + value = dojo.fromJson(value); //json + }else if(handleAs == "javascript"){ + value = dojo.eval(value); //javascript + } + } + } + }catch(e){ + value = e; + }finally{ + ioArgs._callNext(); + } + return value; + }, + function(/*Error*/error, /*Deferred*/dfd){ + //summary: errHandler function for dojo._ioSetArgs call. + dfd.ioArgs._hasError = true; + dfd.ioArgs._callNext(); + return error; + } + ); + + //Set up a function that will fire the next iframe request. Make sure it only + //happens once per deferred. + dfd.ioArgs._callNext = function(){ + if(!this["_calledNext"]){ + this._calledNext = true; + dojo.io.iframe._currentDfd = null; + dojo.io.iframe._fireNextRequest(); + } + }; + + this._dfdQueue.push(dfd); + this._fireNextRequest(); + + //Add it the IO watch queue, to get things like timeout support. + dojo._ioWatch( + dfd, + function(/*Deferred*/dfd){ + //validCheck + return !dfd.ioArgs["_hasError"]; + }, + function(dfd){ + //ioCheck + return (!!dfd.ioArgs["_finished"]); + }, + function(dfd){ + //resHandle + if(dfd.ioArgs._finished){ + dfd.callback(dfd); + }else{ + dfd.errback(new Error("Invalid dojo.io.iframe request state")); + } + } + ); + + return dfd; + }, + + _currentDfd: null, + _dfdQueue: [], + _iframeName: dojo._scopeName + "IoIframe", + + _fireNextRequest: function(){ + //summary: Internal method used to fire the next request in the bind queue. + try{ + if((this._currentDfd)||(this._dfdQueue.length == 0)){ return; } + //Find next deferred, skip the canceled ones. + do{ + var dfd = this._currentDfd = this._dfdQueue.shift(); + } while(dfd && dfd.canceled && this._dfdQueue.length); + + //If no more dfds, cancel. + if(!dfd || dfd.canceled){ + this._currentDfd = null; + return; + } + + var ioArgs = dfd.ioArgs; + var args = ioArgs.args; + + ioArgs._contentToClean = []; + var fn = dojo.byId(args["form"]); + var content = args["content"] || {}; + if(fn){ + if(content){ + // if we have things in content, we need to add them to the form + // before submission + var pHandler = function(name, value) { + dojo.create("input", {type: "hidden", name: name, value: value}, fn); + ioArgs._contentToClean.push(name); + }; + for(var x in content){ + var val = content[x]; + if(dojo.isArray(val) && val.length > 1){ + var i; + for (i = 0; i < val.length; i++) { + pHandler(x,val[i]); + } + }else{ + if(!fn[x]){ + pHandler(x,val); + }else{ + fn[x].value = val; + } + } + } + } + //IE requires going through getAttributeNode instead of just getAttribute in some form cases, + //so use it for all. See #2844 + var actnNode = fn.getAttributeNode("action"); + var mthdNode = fn.getAttributeNode("method"); + var trgtNode = fn.getAttributeNode("target"); + if(args["url"]){ + ioArgs._originalAction = actnNode ? actnNode.value : null; + if(actnNode){ + actnNode.value = args.url; + }else{ + fn.setAttribute("action",args.url); + } + } + if(!mthdNode || !mthdNode.value){ + if(mthdNode){ + mthdNode.value= (args["method"]) ? args["method"] : "post"; + }else{ + fn.setAttribute("method", (args["method"]) ? args["method"] : "post"); + } + } + ioArgs._originalTarget = trgtNode ? trgtNode.value: null; + if(trgtNode){ + trgtNode.value = this._iframeName; + }else{ + fn.setAttribute("target", this._iframeName); + } + fn.target = this._iframeName; + dojo._ioNotifyStart(dfd); + fn.submit(); + }else{ + // otherwise we post a GET string by changing URL location for the + // iframe + var tmpUrl = args.url + (args.url.indexOf("?") > -1 ? "&" : "?") + ioArgs.query; + dojo._ioNotifyStart(dfd); + this.setSrc(this._frame, tmpUrl, true); + } + }catch(e){ + dfd.errback(e); + } + }, + + _iframeOnload: function(){ + var dfd = this._currentDfd; + if(!dfd){ + this._fireNextRequest(); + return; + } + + var ioArgs = dfd.ioArgs; + var args = ioArgs.args; + var fNode = dojo.byId(args.form); + + if(fNode){ + // remove all the hidden content inputs + var toClean = ioArgs._contentToClean; + for(var i = 0; i < toClean.length; i++) { + var key = toClean[i]; + //Need to cycle over all nodes since we may have added + //an array value which means that more than one node could + //have the same .name value. + for(var j = 0; j < fNode.childNodes.length; j++){ + var chNode = fNode.childNodes[j]; + if(chNode.name == key){ + dojo.destroy(chNode); + break; + } + } + } + + // restore original action + target + if(ioArgs["_originalAction"]){ + fNode.setAttribute("action", ioArgs._originalAction); + } + if(ioArgs["_originalTarget"]){ + fNode.setAttribute("target", ioArgs._originalTarget); + fNode.target = ioArgs._originalTarget; + } + } + + ioArgs._finished = true; + } +}; + +return dojo.io.iframe; +}); |