diff options
Diffstat (limited to 'includes/js/dojo/io/iframe.js')
| -rw-r--r-- | includes/js/dojo/io/iframe.js | 358 |
1 files changed, 358 insertions, 0 deletions
diff --git a/includes/js/dojo/io/iframe.js b/includes/js/dojo/io/iframe.js new file mode 100644 index 0000000..a3003ba --- /dev/null +++ b/includes/js/dojo/io/iframe.js @@ -0,0 +1,358 @@ +if(!dojo._hasResource["dojo.io.iframe"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. +dojo._hasResource["dojo.io.iframe"] = true; +dojo.provide("dojo.io.iframe"); + +dojo.io.iframe = { + 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 cframe = null; + var turi = uri; + if(!turi){ + if(dojo.config["useXDomain"] && !dojo.config["dojoBlankHtmlUrl"]){ + console.debug("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"]||dojo.moduleUrl("dojo", "resources/blank.html")); + } + var ifrstr = dojo.isIE ? '<iframe name="'+fname+'" src="'+turi+'" onload="'+onloadstr+'">' : 'iframe'; + cframe = dojo.doc.createElement(ifrstr); + with(cframe){ + name = fname; + setAttribute("name", fname); + id = fname; + } + dojo.body().appendChild(cframe); + window[fname] = cframe; + + with(cframe.style){ + if(dojo.isSafari < 3){ + //We can't change the src in Safari 2.0.3 if absolute position. Bizarro. + position = "absolute"; + } + left = top = "1px"; + height = width = "1px"; + visibility = "hidden"; + } + + if(!dojo.isIE){ + this.setSrc(cframe, turi, true); + cframe.onload = new Function(onloadstr); + } + + 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.isSafari){ + iframe.location = src; + }else{ + frames[iframe.name].location = src; + } + }else{ + // Fun with DOM 0 incompatibilities! + var idoc; + if(dojo.isIE || dojo.isSafari > 2){ + idoc = iframe.contentWindow.document; + }else if(dojo.isSafari){ + idoc = iframe.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; + return; + }else{ + idoc.location.replace(src); + } + } + }catch(e){ + console.debug("dojo.io.iframe.setSrc: ", e); + } + }, + + doc: function(/*DOMNode*/iframeNode){ + //summary: Returns the document object associated with the iframe DOM Node argument. + var doc = iframeNode.contentDocument || // W3 + ( + ( + (iframeNode.name) && (iframeNode.document) && + (document.getElementsByTagName("iframe")[iframeNode.name].contentWindow) && + (document.getElementsByTagName("iframe")[iframeNode.name].contentWindow.document) + ) + ) || // IE + ( + (iframeNode.name)&&(document.frames[iframeNode.name])&& + (document.frames[iframeNode.name].document) + ) || null; + return doc; + }, + + /*===== + dojo.io.iframe.__ioArgs = function(kwArgs){ + // 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, javascript, + // json. IMPORTANT: For all values EXCEPT html, 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 + // or any other XML type is NOT supported by this transport. + // 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(). + } + =====*/ + + 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"){ + 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; } + var dfd = this._currentDfd = this._dfdQueue.shift(); + 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 + for(var x in content){ + if(!fn[x]){ + var tn; + if(dojo.isIE){ + tn = dojo.doc.createElement("<input type='hidden' name='"+x+"'>"); + }else{ + tn = dojo.doc.createElement("input"); + tn.type = "hidden"; + tn.name = x; + } + tn.value = content[x]; + fn.appendChild(tn); + ioArgs._contentToClean.push(x); + }else{ + fn[x].value = content[x]; + } + } + } + //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; + 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; + 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]; + if(dojo.isSafari < 3){ + //In Safari (at least 2.0.3), can't use form[key] syntax to find the node, + //for nodes that were dynamically added. + for(var j = 0; j < fNode.childNodes.length; j++){ + var chNode = fNode.childNodes[j]; + if(chNode.name == key){ + dojo._destroyElement(chNode); + break; + } + } + }else{ + dojo._destroyElement(fNode[key]); + fNode[key] = null; + } + } + + // 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; + } +} + +} |