You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tapestry.apache.org by jk...@apache.org on 2006/06/10 15:59:38 UTC
svn commit: r413300 [7/16] - in /tapestry/tapestry4/trunk/framework/src/js:
dojo/ dojo/src/ dojo/src/animation/ dojo/src/collections/ dojo/src/compat/
dojo/src/crypto/ dojo/src/data/ dojo/src/data/format/
dojo/src/data/provider/ dojo/src/debug/ dojo/sr...
Added: tapestry/tapestry4/trunk/framework/src/js/dojo/src/io/BrowserIO.js
URL: http://svn.apache.org/viewvc/tapestry/tapestry4/trunk/framework/src/js/dojo/src/io/BrowserIO.js?rev=413300&view=auto
==============================================================================
--- tapestry/tapestry4/trunk/framework/src/js/dojo/src/io/BrowserIO.js (added)
+++ tapestry/tapestry4/trunk/framework/src/js/dojo/src/io/BrowserIO.js Sat Jun 10 06:59:28 2006
@@ -0,0 +1,557 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.io.BrowserIO");
+
+dojo.require("dojo.io");
+dojo.require("dojo.lang.array");
+dojo.require("dojo.lang.func");
+dojo.require("dojo.string.extras");
+dojo.require("dojo.dom");
+dojo.require("dojo.undo.browser");
+
+dojo.io.checkChildrenForFile = function(node){
+ var hasFile = false;
+ var inputs = node.getElementsByTagName("input");
+ dojo.lang.forEach(inputs, function(input){
+ if(hasFile){ return; }
+ if(input.getAttribute("type")=="file"){
+ hasFile = true;
+ }
+ });
+ return hasFile;
+}
+
+dojo.io.formHasFile = function(formNode){
+ return dojo.io.checkChildrenForFile(formNode);
+}
+
+dojo.io.updateNode = function(node, urlOrArgs){
+ node = dojo.byId(node);
+ var args = urlOrArgs;
+ if(dojo.lang.isString(urlOrArgs)){
+ args = { url: urlOrArgs };
+ }
+ args.mimetype = "text/html";
+ args.load = function(t, d, e){
+ while(node.firstChild){
+ if(dojo["event"]){
+ try{
+ dojo.event.browser.clean(node.firstChild);
+ }catch(e){}
+ }
+ node.removeChild(node.firstChild);
+ }
+ node.innerHTML = d;
+ };
+ dojo.io.bind(args);
+}
+
+dojo.io.formFilter = function(node) {
+ var type = (node.type||"").toLowerCase();
+ return !node.disabled && node.name
+ && !dojo.lang.inArray(type, ["file", "submit", "image", "reset", "button"]);
+}
+
+// TODO: Move to htmlUtils
+dojo.io.encodeForm = function(formNode, encoding, formFilter){
+ if((!formNode)||(!formNode.tagName)||(!formNode.tagName.toLowerCase() == "form")){
+ dojo.raise("Attempted to encode a non-form element.");
+ }
+ if(!formFilter) { formFilter = dojo.io.formFilter; }
+ var enc = /utf/i.test(encoding||"") ? encodeURIComponent : dojo.string.encodeAscii;
+ var values = [];
+
+ for(var i = 0; i < formNode.elements.length; i++){
+ var elm = formNode.elements[i];
+ if(!elm || elm.tagName.toLowerCase() == "fieldset" || !formFilter(elm)) { continue; }
+ var name = enc(elm.name);
+ var type = elm.type.toLowerCase();
+
+ if(type == "select-multiple"){
+ for(var j = 0; j < elm.options.length; j++){
+ if(elm.options[j].selected) {
+ values.push(name + "=" + enc(elm.options[j].value));
+ }
+ }
+ }else if(dojo.lang.inArray(type, ["radio", "checkbox"])){
+ if(elm.checked){
+ values.push(name + "=" + enc(elm.value));
+ }
+ }else{
+ values.push(name + "=" + enc(elm.value));
+ }
+ }
+
+ // now collect input type="image", which doesn't show up in the elements array
+ var inputs = formNode.getElementsByTagName("input");
+ for(var i = 0; i < inputs.length; i++) {
+ var input = inputs[i];
+ if(input.type.toLowerCase() == "image" && input.form == formNode
+ && formFilter(input)) {
+ var name = enc(input.name);
+ values.push(name + "=" + enc(input.value));
+ values.push(name + ".x=0");
+ values.push(name + ".y=0");
+ }
+ }
+ return values.join("&") + "&";
+}
+
+dojo.io.FormBind = function(args) {
+ this.bindArgs = {};
+
+ if(args && args.formNode) {
+ this.init(args);
+ } else if(args) {
+ this.init({formNode: args});
+ }
+}
+dojo.lang.extend(dojo.io.FormBind, {
+ form: null,
+
+ bindArgs: null,
+
+ clickedButton: null,
+
+ init: function(args) {
+ var form = dojo.byId(args.formNode);
+
+ if(!form || !form.tagName || form.tagName.toLowerCase() != "form") {
+ throw new Error("FormBind: Couldn't apply, invalid form");
+ } else if(this.form == form) {
+ return;
+ } else if(this.form) {
+ throw new Error("FormBind: Already applied to a form");
+ }
+
+ dojo.lang.mixin(this.bindArgs, args);
+ this.form = form;
+
+ this.connect(form, "onsubmit", "submit");
+
+ for(var i = 0; i < form.elements.length; i++) {
+ var node = form.elements[i];
+ if(node && node.type && dojo.lang.inArray(node.type.toLowerCase(), ["submit", "button"])) {
+ this.connect(node, "onclick", "click");
+ }
+ }
+
+ var inputs = form.getElementsByTagName("input");
+ for(var i = 0; i < inputs.length; i++) {
+ var input = inputs[i];
+ if(input.type.toLowerCase() == "image" && input.form == form) {
+ this.connect(input, "onclick", "click");
+ }
+ }
+ },
+
+ onSubmit: function(form) {
+ return true;
+ },
+
+ submit: function(e) {
+ e.preventDefault();
+ if(this.onSubmit(this.form)) {
+ dojo.io.bind(dojo.lang.mixin(this.bindArgs, {
+ formFilter: dojo.lang.hitch(this, "formFilter")
+ }));
+ }
+ },
+
+ click: function(e) {
+ var node = e.currentTarget;
+ if(node.disabled) { return; }
+ this.clickedButton = node;
+ },
+
+ formFilter: function(node) {
+ var type = (node.type||"").toLowerCase();
+ var accept = false;
+ if(node.disabled || !node.name) {
+ accept = false;
+ } else if(dojo.lang.inArray(type, ["submit", "button", "image"])) {
+ if(!this.clickedButton) { this.clickedButton = node; }
+ accept = node == this.clickedButton;
+ } else {
+ accept = !dojo.lang.inArray(type, ["file", "submit", "reset", "button"]);
+ }
+ return accept;
+ },
+
+ // in case you don't have dojo.event.* pulled in
+ connect: function(srcObj, srcFcn, targetFcn) {
+ if(dojo.evalObjPath("dojo.event.connect")) {
+ dojo.event.connect(srcObj, srcFcn, this, targetFcn);
+ } else {
+ var fcn = dojo.lang.hitch(this, targetFcn);
+ srcObj[srcFcn] = function(e) {
+ if(!e) { e = window.event; }
+ if(!e.currentTarget) { e.currentTarget = e.srcElement; }
+ if(!e.preventDefault) { e.preventDefault = function() { window.event.returnValue = false; } }
+ fcn(e);
+ }
+ }
+ }
+});
+
+dojo.io.XMLHTTPTransport = new function(){
+ var _this = this;
+
+ var _cache = {}; // FIXME: make this public? do we even need to?
+ this.useCache = false; // if this is true, we'll cache unless kwArgs.useCache = false
+ this.preventCache = false; // if this is true, we'll always force GET requests to cache
+
+ // FIXME: Should this even be a function? or do we just hard code it in the next 2 functions?
+ function getCacheKey(url, query, method) {
+ return url + "|" + query + "|" + method.toLowerCase();
+ }
+
+ function addToCache(url, query, method, http) {
+ _cache[getCacheKey(url, query, method)] = http;
+ }
+
+ function getFromCache(url, query, method) {
+ return _cache[getCacheKey(url, query, method)];
+ }
+
+ this.clearCache = function() {
+ _cache = {};
+ }
+
+ // moved successful load stuff here
+ function doLoad(kwArgs, http, url, query, useCache) {
+ if( ((http.status>=200)&&(http.status<300))|| // allow any 2XX response code
+ (http.status==304)|| // get it out of the cache
+ (location.protocol=="file:" && (http.status==0 || http.status==undefined))||
+ (location.protocol=="chrome:" && (http.status==0 || http.status==undefined))
+ ){
+ var ret;
+ if(kwArgs.method.toLowerCase() == "head"){
+ var headers = http.getAllResponseHeaders();
+ ret = {};
+ ret.toString = function(){ return headers; }
+ var values = headers.split(/[\r\n]+/g);
+ for(var i = 0; i < values.length; i++) {
+ var pair = values[i].match(/^([^:]+)\s*:\s*(.+)$/i);
+ if(pair) {
+ ret[pair[1]] = pair[2];
+ }
+ }
+ }else if(kwArgs.mimetype == "text/javascript"){
+ try{
+ ret = dj_eval(http.responseText);
+ }catch(e){
+ dojo.debug(e);
+ dojo.debug(http.responseText);
+ ret = null;
+ }
+ }else if(kwArgs.mimetype == "text/json"){
+ try{
+ ret = dj_eval("("+http.responseText+")");
+ }catch(e){
+ dojo.debug(e);
+ dojo.debug(http.responseText);
+ ret = false;
+ }
+ }else if((kwArgs.mimetype == "application/xml")||
+ (kwArgs.mimetype == "text/xml")){
+ ret = http.responseXML;
+ if(!ret || typeof ret == "string" || !http.getResponseHeader("Content-Type")) {
+ ret = dojo.dom.createDocumentFromText(http.responseText);
+ }
+ }else{
+ ret = http.responseText;
+ }
+
+ if(useCache){ // only cache successful responses
+ addToCache(url, query, kwArgs.method, http);
+ }
+ kwArgs[(typeof kwArgs.load == "function") ? "load" : "handle"]("load", ret, http, kwArgs);
+ }else{
+ var errObj = new dojo.io.Error("XMLHttpTransport Error: "+http.status+" "+http.statusText);
+ kwArgs[(typeof kwArgs.error == "function") ? "error" : "handle"]("error", errObj, http, kwArgs);
+ }
+ }
+
+ // set headers (note: Content-Type will get overriden if kwArgs.contentType is set)
+ function setHeaders(http, kwArgs){
+ if(kwArgs["headers"]) {
+ for(var header in kwArgs["headers"]) {
+ if(header.toLowerCase() == "content-type" && !kwArgs["contentType"]) {
+ kwArgs["contentType"] = kwArgs["headers"][header];
+ } else {
+ http.setRequestHeader(header, kwArgs["headers"][header]);
+ }
+ }
+ }
+ }
+
+ this.inFlight = [];
+ this.inFlightTimer = null;
+
+ this.startWatchingInFlight = function(){
+ if(!this.inFlightTimer){
+ this.inFlightTimer = setInterval("dojo.io.XMLHTTPTransport.watchInFlight();", 10);
+ }
+ }
+
+ this.watchInFlight = function(){
+ var now = null;
+ for(var x=this.inFlight.length-1; x>=0; x--){
+ var tif = this.inFlight[x];
+ if(!tif){ this.inFlight.splice(x, 1); continue; }
+ if(4==tif.http.readyState){
+ // remove it so we can clean refs
+ this.inFlight.splice(x, 1);
+ doLoad(tif.req, tif.http, tif.url, tif.query, tif.useCache);
+ }else if (tif.startTime){
+ //See if this is a timeout case.
+ if(!now){
+ now = (new Date()).getTime();
+ }
+ if(tif.startTime + (tif.req.timeoutSeconds * 1000) < now){
+ //Stop the request.
+ if(typeof tif.http.abort == "function"){
+ tif.http.abort();
+ }
+
+ // remove it so we can clean refs
+ this.inFlight.splice(x, 1);
+ tif.req[(typeof tif.req.timeout == "function") ? "timeout" : "handle"]("timeout", null, tif.http, tif.req);
+ }
+ }
+ }
+
+ if(this.inFlight.length == 0){
+ clearInterval(this.inFlightTimer);
+ this.inFlightTimer = null;
+ }
+ }
+
+ var hasXmlHttp = dojo.hostenv.getXmlhttpObject() ? true : false;
+ this.canHandle = function(kwArgs){
+ // canHandle just tells dojo.io.bind() if this is a good transport to
+ // use for the particular type of request.
+
+ // FIXME: we need to determine when form values need to be
+ // multi-part mime encoded and avoid using this transport for those
+ // requests.
+ return hasXmlHttp
+ && dojo.lang.inArray((kwArgs["mimetype"].toLowerCase()||""), ["text/plain", "text/html", "application/xml", "text/xml", "text/javascript", "text/json"])
+ && !( kwArgs["formNode"] && dojo.io.formHasFile(kwArgs["formNode"]) );
+ }
+
+ this.multipartBoundary = "45309FFF-BD65-4d50-99C9-36986896A96F"; // unique guid as a boundary value for multipart posts
+
+ this.bind = function(kwArgs){
+ if(!kwArgs["url"]){
+ // are we performing a history action?
+ if( !kwArgs["formNode"]
+ && (kwArgs["backButton"] || kwArgs["back"] || kwArgs["changeUrl"] || kwArgs["watchForURL"])
+ && (!djConfig.preventBackButtonFix)) {
+ dojo.deprecated("Using dojo.io.XMLHTTPTransport.bind() to add to browser history without doing an IO request",
+ "Use dojo.undo.browser.addToHistory() instead.", "0.4");
+ dojo.undo.browser.addToHistory(kwArgs);
+ return true;
+ }
+ }
+
+ // build this first for cache purposes
+ var url = kwArgs.url;
+ var query = "";
+ if(kwArgs["formNode"]){
+ var ta = kwArgs.formNode.getAttribute("action");
+ if((ta)&&(!kwArgs["url"])){ url = ta; }
+ var tp = kwArgs.formNode.getAttribute("method");
+ if((tp)&&(!kwArgs["method"])){ kwArgs.method = tp; }
+ query += dojo.io.encodeForm(kwArgs.formNode, kwArgs.encoding, kwArgs["formFilter"]);
+ }
+
+ if(url.indexOf("#") > -1) {
+ dojo.debug("Warning: dojo.io.bind: stripping hash values from url:", url);
+ url = url.split("#")[0];
+ }
+
+ if(kwArgs["file"]){
+ // force post for file transfer
+ kwArgs.method = "post";
+ }
+
+ if(!kwArgs["method"]){
+ kwArgs.method = "get";
+ }
+
+ // guess the multipart value
+ if(kwArgs.method.toLowerCase() == "get"){
+ // GET cannot use multipart
+ kwArgs.multipart = false;
+ }else{
+ if(kwArgs["file"]){
+ // enforce multipart when sending files
+ kwArgs.multipart = true;
+ }else if(!kwArgs["multipart"]){
+ // default
+ kwArgs.multipart = false;
+ }
+ }
+
+ if(kwArgs["backButton"] || kwArgs["back"] || kwArgs["changeUrl"]){
+ dojo.undo.browser.addToHistory(kwArgs);
+ }
+
+ var content = kwArgs["content"] || {};
+
+ if(kwArgs.sendTransport) {
+ content["dojo.transport"] = "xmlhttp";
+ }
+
+ do { // break-block
+ if(kwArgs.postContent){
+ query = kwArgs.postContent;
+ break;
+ }
+
+ if(content) {
+ query += dojo.io.argsFromMap(content, kwArgs.encoding);
+ }
+
+ if(kwArgs.method.toLowerCase() == "get" || !kwArgs.multipart){
+ break;
+ }
+
+ var t = [];
+ if(query.length){
+ var q = query.split("&");
+ for(var i = 0; i < q.length; ++i){
+ if(q[i].length){
+ var p = q[i].split("=");
+ t.push( "--" + this.multipartBoundary,
+ "Content-Disposition: form-data; name=\"" + p[0] + "\"",
+ "",
+ p[1]);
+ }
+ }
+ }
+
+ if(kwArgs.file){
+ if(dojo.lang.isArray(kwArgs.file)){
+ for(var i = 0; i < kwArgs.file.length; ++i){
+ var o = kwArgs.file[i];
+ t.push( "--" + this.multipartBoundary,
+ "Content-Disposition: form-data; name=\"" + o.name + "\"; filename=\"" + ("fileName" in o ? o.fileName : o.name) + "\"",
+ "Content-Type: " + ("contentType" in o ? o.contentType : "application/octet-stream"),
+ "",
+ o.content);
+ }
+ }else{
+ var o = kwArgs.file;
+ t.push( "--" + this.multipartBoundary,
+ "Content-Disposition: form-data; name=\"" + o.name + "\"; filename=\"" + ("fileName" in o ? o.fileName : o.name) + "\"",
+ "Content-Type: " + ("contentType" in o ? o.contentType : "application/octet-stream"),
+ "",
+ o.content);
+ }
+ }
+
+ if(t.length){
+ t.push("--"+this.multipartBoundary+"--", "");
+ query = t.join("\r\n");
+ }
+ }while(false);
+
+ // kwArgs.Connection = "close";
+
+ var async = kwArgs["sync"] ? false : true;
+
+ var preventCache = kwArgs["preventCache"] ||
+ (this.preventCache == true && kwArgs["preventCache"] != false);
+ var useCache = kwArgs["useCache"] == true ||
+ (this.useCache == true && kwArgs["useCache"] != false );
+
+ // preventCache is browser-level (add query string junk), useCache
+ // is for the local cache. If we say preventCache, then don't attempt
+ // to look in the cache, but if useCache is true, we still want to cache
+ // the response
+ if(!preventCache && useCache){
+ var cachedHttp = getFromCache(url, query, kwArgs.method);
+ if(cachedHttp){
+ doLoad(kwArgs, cachedHttp, url, query, false);
+ return;
+ }
+ }
+
+ // much of this is from getText, but reproduced here because we need
+ // more flexibility
+ var http = dojo.hostenv.getXmlhttpObject(kwArgs);
+ var received = false;
+
+ // build a handler function that calls back to the handler obj
+ if(async){
+ var startTime =
+ // FIXME: setting up this callback handler leaks on IE!!!
+ this.inFlight.push({
+ "req": kwArgs,
+ "http": http,
+ "url": url,
+ "query": query,
+ "useCache": useCache,
+ "startTime": kwArgs.timeoutSeconds ? (new Date()).getTime() : 0
+ });
+ this.startWatchingInFlight();
+ }
+
+ if(kwArgs.method.toLowerCase() == "post"){
+ // FIXME: need to hack in more flexible Content-Type setting here!
+ http.open("POST", url, async);
+ setHeaders(http, kwArgs);
+ http.setRequestHeader("Content-Type", kwArgs.multipart ? ("multipart/form-data; boundary=" + this.multipartBoundary) :
+ (kwArgs.contentType || "application/x-www-form-urlencoded"));
+ try{
+ http.send(query);
+ }catch(e){
+ if(typeof http.abort == "function"){
+ http.abort();
+ }
+ doLoad(kwArgs, {status: 404}, url, query, useCache);
+ }
+ }else{
+ var tmpUrl = url;
+ if(query != "") {
+ tmpUrl += (tmpUrl.indexOf("?") > -1 ? "&" : "?") + query;
+ }
+ if(preventCache) {
+ tmpUrl += (dojo.string.endsWithAny(tmpUrl, "?", "&")
+ ? "" : (tmpUrl.indexOf("?") > -1 ? "&" : "?")) + "dojo.preventCache=" + new Date().valueOf();
+ }
+ http.open(kwArgs.method.toUpperCase(), tmpUrl, async);
+ setHeaders(http, kwArgs);
+ try {
+ http.send(null);
+ }catch(e) {
+ if(typeof http.abort == "function"){
+ http.abort();
+ }
+ doLoad(kwArgs, {status: 404}, url, query, useCache);
+ }
+ }
+
+ if( !async ) {
+ doLoad(kwArgs, http, url, query, useCache);
+ }
+
+ kwArgs.abort = function(){
+ return http.abort();
+ }
+
+ return;
+ }
+ dojo.io.transports.addTransport("XMLHTTPTransport");
+}
Propchange: tapestry/tapestry4/trunk/framework/src/js/dojo/src/io/BrowserIO.js
------------------------------------------------------------------------------
svn:eol-style = native
Added: tapestry/tapestry4/trunk/framework/src/js/dojo/src/io/IframeIO.js
URL: http://svn.apache.org/viewvc/tapestry/tapestry4/trunk/framework/src/js/dojo/src/io/IframeIO.js?rev=413300&view=auto
==============================================================================
--- tapestry/tapestry4/trunk/framework/src/js/dojo/src/io/IframeIO.js (added)
+++ tapestry/tapestry4/trunk/framework/src/js/dojo/src/io/IframeIO.js Sat Jun 10 06:59:28 2006
@@ -0,0 +1,253 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.io.IframeIO");
+dojo.require("dojo.io.BrowserIO");
+dojo.require("dojo.uri.*");
+
+// FIXME: is it possible to use the Google htmlfile hack to prevent the
+// background click with this transport?
+
+dojo.io.createIFrame = function(fname, onloadstr){
+ if(window[fname]){ return window[fname]; }
+ if(window.frames[fname]){ return window.frames[fname]; }
+ var r = dojo.render.html;
+ var cframe = null;
+ var turi = dojo.uri.dojoUri("iframe_history.html?noInit=true");
+ var ifrstr = ((r.ie)&&(dojo.render.os.win)) ? "<iframe name='"+fname+"' src='"+turi+"' onload='"+onloadstr+"'>" : "iframe";
+ cframe = document.createElement(ifrstr);
+ with(cframe){
+ name = fname;
+ setAttribute("name", fname);
+ id = fname;
+ }
+ (document.body||document.getElementsByTagName("body")[0]).appendChild(cframe);
+ window[fname] = cframe;
+ with(cframe.style){
+ position = "absolute";
+ left = top = "0px";
+ height = width = "1px";
+ visibility = "hidden";
+ /*
+ if(djConfig.isDebug){
+ position = "relative";
+ height = "300px";
+ width = "600px";
+ visibility = "visible";
+ }
+ */
+ }
+
+ if(!r.ie){
+ dojo.io.setIFrameSrc(cframe, turi, true);
+ cframe.onload = new Function(onloadstr);
+ }
+ return cframe;
+}
+
+// thanks burstlib!
+dojo.io.iframeContentWindow = function(iframe_el) {
+ var win = iframe_el.contentWindow || // IE
+ dojo.io.iframeContentDocument(iframe_el).defaultView || // Moz, opera
+ // Moz. TODO: is this available when defaultView isn't?
+ dojo.io.iframeContentDocument(iframe_el).__parent__ ||
+ (iframe_el.name && document.frames[iframe_el.name]) || null;
+ return win;
+}
+
+dojo.io.iframeContentDocument = function(iframe_el){
+ var doc = iframe_el.contentDocument || // W3
+ (
+ (iframe_el.contentWindow)&&(iframe_el.contentWindow.document)
+ ) || // IE
+ (
+ (iframe_el.name)&&(document.frames[iframe_el.name])&&
+ (document.frames[iframe_el.name].document)
+ ) || null;
+ return doc;
+}
+
+dojo.io.IframeTransport = new function(){
+ var _this = this;
+ this.currentRequest = null;
+ this.requestQueue = [];
+ this.iframeName = "dojoIoIframe";
+
+ this.fireNextRequest = function(){
+ if((this.currentRequest)||(this.requestQueue.length == 0)){ return; }
+ // dojo.debug("fireNextRequest");
+ var cr = this.currentRequest = this.requestQueue.shift();
+ cr._contentToClean = [];
+ var fn = cr["formNode"];
+ var content = cr["content"] || {};
+ if(cr.sendTransport) {
+ content["dojo.transport"] = "iframe";
+ }
+ 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.render.html.ie){
+ tn = document.createElement("<input type='hidden' name='"+x+"' value='"+content[x]+"'>");
+ fn.appendChild(tn);
+ }else{
+ tn = document.createElement("input");
+ fn.appendChild(tn);
+ tn.type = "hidden";
+ tn.name = x;
+ tn.value = content[x];
+ }
+ cr._contentToClean.push(x);
+ }else{
+ fn[x].value = content[x];
+ }
+ }
+ }
+ if(cr["url"]){
+ cr._originalAction = fn.getAttribute("action");
+ fn.setAttribute("action", cr.url);
+ }
+ if(!fn.getAttribute("method")){
+ fn.setAttribute("method", (cr["method"]) ? cr["method"] : "post");
+ }
+ cr._originalTarget = fn.getAttribute("target");
+ 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 query = dojo.io.argsFromMap(this.currentRequest.content);
+ var tmpUrl = (cr.url.indexOf("?") > -1 ? "&" : "?") + query;
+ dojo.io.setIFrameSrc(this.iframe, tmpUrl, true);
+ }
+ }
+
+ this.canHandle = function(kwArgs){
+ return (
+ (
+ // FIXME: can we really handle text/plain and
+ // text/javascript requests?
+ dojo.lang.inArray(kwArgs["mimetype"],
+ [ "text/plain", "text/html",
+ "text/javascript", "text/json"])
+ )&&(
+ // make sur we really only get used in file upload cases
+ (kwArgs["formNode"])&&(dojo.io.checkChildrenForFile(kwArgs["formNode"]))
+ )&&(
+ dojo.lang.inArray(kwArgs["method"].toLowerCase(), ["post", "get"])
+ )&&(
+ // never handle a sync request
+ ! ((kwArgs["sync"])&&(kwArgs["sync"] == true))
+ )
+ );
+ }
+
+ this.bind = function(kwArgs){
+ if(!this["iframe"]){ this.setUpIframe(); }
+ this.requestQueue.push(kwArgs);
+ this.fireNextRequest();
+ return;
+ }
+
+ this.setUpIframe = function(){
+
+ // NOTE: IE 5.0 and earlier Mozilla's don't support an onload event for
+ // iframes. OTOH, we don't care.
+ this.iframe = dojo.io.createIFrame(this.iframeName, "dojo.io.IframeTransport.iframeOnload();");
+ }
+
+ this.iframeOnload = function(){
+ if(!_this.currentRequest){
+ _this.fireNextRequest();
+ return;
+ }
+
+ var req = _this.currentRequest;
+
+ // remove all the hidden content inputs
+ var toClean = req._contentToClean;
+ for(var i = 0; i < toClean.length; i++) {
+ var key = toClean[i];
+ if(dojo.render.html.safari){
+ //In Safari (at least 2.0.3), can't use formNode[key] syntax to find the node,
+ //for nodes that were dynamically added.
+ var fNode = req.formNode;
+ for(var j = 0; j < fNode.childNodes.length; j++){
+ var chNode = fNode.childNodes[j];
+ if(chNode.name == key){
+ var pNode = chNode.parentNode;
+ pNode.removeChild(chNode);
+ break;
+ }
+ }
+ }else{
+ var input = req.formNode[key];
+ req.formNode.removeChild(input);
+ req.formNode[key] = null;
+ }
+ }
+
+ // restore original action + target
+ if(req["_originalAction"]){
+ req.formNode.setAttribute("action", req._originalAction);
+ }
+ req.formNode.setAttribute("target", req._originalTarget);
+ req.formNode.target = req._originalTarget;
+
+ var ifd = dojo.io.iframeContentDocument(_this.iframe);
+ // handle successful returns
+ // FIXME: how do we determine success for iframes? Is there an equiv of
+ // the "status" property?
+ var value;
+ var success = false;
+
+ try{
+ var cmt = req.mimetype;
+ if((cmt == "text/javascript")||(cmt == "text/json")){
+ // FIXME: not sure what to do here? try to pull some evalulable
+ // text from a textarea or cdata section?
+ // how should we set up the contract for that?
+ var js = ifd.getElementsByTagName("textarea")[0].value;
+ if(cmt == "text/json") { js = "(" + js + ")"; }
+ value = dj_eval(js);
+ }else if(cmt == "text/html"){
+ value = ifd;
+ }else{ // text/plain
+ value = ifd.getElementsByTagName("textarea")[0].value;
+ }
+ success = true;
+ }catch(e){
+ // looks like we didn't get what we wanted!
+ var errObj = new dojo.io.Error("IframeTransport Error");
+ if(dojo.lang.isFunction(req["error"])){
+ req.error("error", errObj, req);
+ }
+ }
+
+ // don't want to mix load function errors with processing errors, thus
+ // a separate try..catch
+ try {
+ if(success && dojo.lang.isFunction(req["load"])){
+ req.load("load", value, req);
+ }
+ } catch(e) {
+ throw e;
+ } finally {
+ _this.currentRequest = null;
+ _this.fireNextRequest();
+ }
+ }
+
+ dojo.io.transports.addTransport("IframeTransport");
+}
Propchange: tapestry/tapestry4/trunk/framework/src/js/dojo/src/io/IframeIO.js
------------------------------------------------------------------------------
svn:eol-style = native
Added: tapestry/tapestry4/trunk/framework/src/js/dojo/src/io/RepubsubIO.js
URL: http://svn.apache.org/viewvc/tapestry/tapestry4/trunk/framework/src/js/dojo/src/io/RepubsubIO.js?rev=413300&view=auto
==============================================================================
--- tapestry/tapestry4/trunk/framework/src/js/dojo/src/io/RepubsubIO.js (added)
+++ tapestry/tapestry4/trunk/framework/src/js/dojo/src/io/RepubsubIO.js Sat Jun 10 06:59:28 2006
@@ -0,0 +1,517 @@
+// Copyright (c) 2004 Friendster Inc., Licensed under the Academic Free
+// License version 2.0 or later
+
+dojo.require("dojo.event.Event");
+dojo.require("dojo.event.BrowserEvent");
+dojo.require("dojo.io.BrowserIO");
+
+dojo.provide("dojo.io.RepubsubIO");
+dojo.provide("dojo.io.repubsub");
+dojo.provide("dojo.io.repubsubTransport");
+
+dojo.io.repubsubTranport = new function(){
+ var rps = dojo.io.repubsub;
+ this.canHandle = function(kwArgs){
+ if((kwArgs["mimetype"] == "text/javascript")&&(kwArgs["method"] == "repubsub")){
+ return true;
+ }
+ return false;
+ }
+
+ this.bind = function(kwArgs){
+ if(!rps.isInitialized){
+ // open up our tunnel, queue up requests anyway
+ rps.init();
+ }
+ // FIXME: we need to turn this into a topic subscription
+ // var tgtURL = kwArgs.url+"?"+dojo.io.argsFromMap(kwArgs.content);
+ // sampleTransport.sendRequest(tgtURL, hdlrFunc);
+
+ // a normal "bind()" call in a request-response transport layer is
+ // something that (usually) encodes most of it's payload with the
+ // request. Multi-event systems like repubsub are a bit more complex,
+ // and repubsub in particular distinguishes the publish and subscribe
+ // portions of thep rocess with different method calls to handle each.
+ // Therefore, a "bind" in the sense of repubsub must first determine if
+ // we have an open subscription to a channel provided by the server,
+ // and then "publish" the request payload if there is any. We therefore
+ // must take care not to incorrectly or too agressively register or
+ // file event handlers which are provided with the kwArgs method.
+
+ // NOTE: we ONLY pay attention to those event handlers that are
+ // registered with the bind request that subscribes to the channel. If
+ // event handlers are provided with subsequent requests, we might in
+ // the future support some additive or replacement syntax, but for now
+ // they get dropped on the floor.
+
+ // NOTE: in this case, url MUST be the "topic" to which we
+ // subscribe/publish for this channel
+ if(!rps.topics[kwArgs.url]){
+ kwArgs.rpsLoad = function(evt){
+ kwArgs.load("load", evt);
+ }
+ rps.subscribe(kwArgs.url, kwArgs, "rpsLoad");
+ }
+
+ if(kwArgs["content"]){
+ // what we wanted to send
+ var cEvt = dojo.io.repubsubEvent.initFromProperties(kwArgs.content);
+ rps.publish(kwArgs.url, cEvt);
+ }
+ }
+
+ dojo.io.transports.addTransport("repubsubTranport");
+}
+
+dojo.io.repubsub = new function(){
+ this.initDoc = "init.html";
+ this.isInitialized = false;
+ this.subscriptionBacklog = [];
+ this.debug = true;
+ this.rcvNodeName = null;
+ this.sndNodeName = null;
+ this.rcvNode = null;
+ this.sndNode = null;
+ this.canRcv = false;
+ this.canSnd = false;
+ this.canLog = false;
+ this.sndTimer = null;
+ this.windowRef = window;
+ this.backlog = [];
+ this.tunnelInitCount = 0;
+ this.tunnelFrameKey = "tunnel_frame";
+ this.serverBaseURL = location.protocol+"//"+location.host+location.pathname;
+ this.logBacklog = [];
+ this.getRandStr = function(){
+ return Math.random().toString().substring(2, 10);
+ }
+ this.userid = "guest";
+ this.tunnelID = this.getRandStr();
+ this.attachPathList = [];
+ this.topics = []; // list of topics we have listeners to
+
+ // actually, now that I think about it a little bit more, it would sure be
+ // useful to parse out the <script> src attributes. We're looking for
+ // something with a "do_method=lib", since that's what would have included
+ // us in the first place (in the common case).
+ this.parseGetStr = function(){
+ var baseUrl = document.location.toString();
+ var params = baseUrl.split("?", 2);
+ if(params.length > 1){
+ var paramStr = params[1];
+ var pairs = paramStr.split("&");
+ var opts = [];
+ for(var x in pairs){
+ var sp = pairs[x].split("=");
+ // FIXME: is this eval dangerous?
+ try{
+ opts[sp[0]]=eval(sp[1]);
+ }catch(e){
+ opts[sp[0]]=sp[1];
+ }
+ }
+ return opts;
+ }else{
+ return [];
+ }
+ }
+
+ // parse URL params and use them as default vals
+ var getOpts = this.parseGetStr();
+ for(var x in getOpts){
+ // FIXME: should I be checking for undefined here before setting? Does
+ // that buy me anything?
+ this[x] = getOpts[x];
+ }
+
+ if(!this["tunnelURI"]){
+ this.tunnelURI = [ "/who/", escape(this.userid), "/s/",
+ this.getRandStr(), "/kn_journal"].join("");
+ // this.tunnelURI = this.absoluteTopicURI(this.tunnelURI);
+ }
+
+ /*
+ if (self.kn_tunnelID) kn.tunnelID = self.kn_tunnelID; // the server says
+ if (kn._argv.kn_tunnelID) kn.tunnelID = kn._argv.kn_tunnelID; // the url says
+ */
+
+ // check the options object if it exists and use its properties as an
+ // over-ride
+ if(window["repubsubOpts"]||window["rpsOpts"]){
+ var optObj = window["repubsubOpts"]||window["rpsOpts"];
+ for(var x in optObj){
+ this[x] = optObj[x]; // copy the option object properties
+ }
+ }
+
+ // things that get called directly from our iframe to inform us of events
+ this.tunnelCloseCallback = function(){
+ // when we get this callback, we should immediately attempt to re-start
+ // our tunnel connection
+ dojo.io.setIFrameSrc(this.rcvNode, this.initDoc+"?callback=repubsub.rcvNodeReady&domain="+document.domain);
+ }
+
+ this.receiveEventFromTunnel = function(evt, srcWindow){
+ // we should never be getting events from windows we didn't create
+ // NOTE: events sourced from the local window are also supported for
+ // debugging purposes
+
+ // any event object MUST have a an "elements" property
+ if(!evt["elements"]){
+ this.log("bailing! event received without elements!", "error");
+ return;
+ }
+
+ // if the event passes some minimal sanity tests, we need to attempt to
+ // dispatch it!
+
+ // first, it seems we have to munge the event object a bit
+ var e = {};
+ for(var i=0; i<evt.elements.length; i++){
+ var ee = evt.elements[i];
+ e[ee.name||ee.nameU] = (ee.value||ee.valueU);
+ // FIXME: need to enable this only in some extreme debugging mode!
+ this.log("[event]: "+(ee.name||ee.nameU)+": "+e[ee.name||ee.nameU]);
+ }
+
+ // NOTE: the previous version of this library put a bunch of code here
+ // to manage state that tried to make sure that we never, ever, lost
+ // any info about an event. If we unload RIGHT HERE, I don't think it's
+ // going to make a huge difference one way or another. Time will tell.
+
+ // and with THAT out of the way, dispatch it!
+ this.dispatch(e);
+
+ // TODO: remove the script block that created the event obj to save
+ // memory, etc.
+ }
+
+ this.widenDomain = function(domainStr){
+ // the purpose of this is to set the most liberal domain policy
+ // available
+ var cd = domainStr||document.domain;
+ if(cd.indexOf(".")==-1){ return; } // probably file:/// or localhost
+ var dps = cd.split(".");
+ if(dps.length<=2){ return; } // probably file:/// or an RFC 1918 address
+ dps = dps.slice(dps.length-2);
+ document.domain = dps.join(".");
+ }
+
+ // FIXME: parseCookie and setCookie should be methods that are more broadly
+ // available. Perhaps in htmlUtils?
+
+ this.parseCookie = function(){
+ var cs = document.cookie;
+ var keypairs = cs.split(";");
+ for(var x=0; x<keypairs.length; x++){
+ keypairs[x] = keypairs[x].split("=");
+ if(x!=keypairs.length-1){ cs+=";"; }
+ }
+ return keypairs;
+ }
+
+ this.setCookie = function(keypairs, clobber){
+ // NOTE: we want to only ever set session cookies, so never provide an
+ // expires date
+ if((clobber)&&(clobber==true)){ document.cookie = ""; }
+ var cs = "";
+ for(var x=0; x<keypairs.length; x++){
+ cs += keypairs[x][0]+"="+keypairs[x][1];
+ if(x!=keypairs.length-1){ cs+=";"; }
+ }
+ document.cookie = cs;
+ }
+
+ // FIXME: need to replace w/ dojo.log.*
+ this.log = function(str, lvl){
+ if(!this.debug){ return; } // we of course only care if we're in debug mode
+ while(this.logBacklog.length>0){
+ if(!this.canLog){ break; }
+ var blo = this.logBacklog.shift();
+ this.writeLog("["+blo[0]+"]: "+blo[1], blo[2]);
+ }
+ this.writeLog(str, lvl);
+ }
+
+ this.writeLog = function(str, lvl){
+ dojo.debug(((new Date()).toLocaleTimeString())+": "+str);
+ }
+
+ this.init = function(){
+ this.widenDomain();
+ // this.findPeers();
+ this.openTunnel();
+ this.isInitialized = true;
+ // FIXME: this seems like entirely the wrong place to replay the backlog
+ while(this.subscriptionBacklog.length){
+ this.subscribe.apply(this, this.subscriptionBacklog.shift());
+ }
+ }
+
+ this.clobber = function(){
+ if(this.rcvNode){
+ this.setCookie( [
+ [this.tunnelFrameKey,"closed"],
+ ["path","/"]
+ ], false
+ );
+ }
+ }
+
+ this.openTunnel = function(){
+ // We create two iframes here:
+
+ // one for getting data
+ this.rcvNodeName = "rcvIFrame_"+this.getRandStr();
+ // set cookie that can be used to find the receiving iframe
+ this.setCookie( [
+ [this.tunnelFrameKey,this.rcvNodeName],
+ ["path","/"]
+ ], false
+ );
+
+ this.rcvNode = dojo.io.createIFrame(this.rcvNodeName);
+ // FIXME: set the src attribute here to the initialization URL
+ dojo.io.setIFrameSrc(this.rcvNode, this.initDoc+"?callback=repubsub.rcvNodeReady&domain="+document.domain);
+
+ // the other for posting data in reply
+
+ this.sndNodeName = "sndIFrame_"+this.getRandStr();
+ this.sndNode = dojo.io.createIFrame(this.sndNodeName);
+ // FIXME: set the src attribute here to the initialization URL
+ dojo.io.setIFrameSrc(this.sndNode, this.initDoc+"?callback=repubsub.sndNodeReady&domain="+document.domain);
+
+ }
+
+ this.rcvNodeReady = function(){
+ // FIXME: why is this sequence number needed? Why isn't the UID gen
+ // function enough?
+ var statusURI = [this.tunnelURI, '/kn_status/', this.getRandStr(), '_',
+ String(this.tunnelInitCount++)].join("");
+ // (kn._seqNum++); // FIXME: !!!!
+ // this.canRcv = true;
+ this.log("rcvNodeReady");
+ // FIXME: initialize receiver and request the base topic
+ // dojo.io.setIFrameSrc(this.rcvNode, this.serverBaseURL+"/kn?do_method=blank");
+ var initURIArr = [ this.serverBaseURL, "/kn?kn_from=", escape(this.tunnelURI),
+ "&kn_id=", escape(this.tunnelID), "&kn_status_from=",
+ escape(statusURI)];
+ // FIXME: does the above really need a kn_response_flush? won't the
+ // server already know? If not, what good is it anyway?
+ dojo.io.setIFrameSrc(this.rcvNode, initURIArr.join(""));
+
+ // setup a status path listener, but don't tell the server about it,
+ // since it already knows we're itnerested in our own tunnel status
+ this.subscribe(statusURI, this, "statusListener", true);
+
+ this.log(initURIArr.join(""));
+ }
+
+ this.sndNodeReady = function(){
+ this.canSnd = true;
+ this.log("sndNodeReady");
+ this.log(this.backlog.length);
+ // FIXME: handle any pent-up send commands
+ if(this.backlog.length > 0){
+ this.dequeueEvent();
+ }
+ }
+
+ this.statusListener = function(evt){
+ this.log("status listener called");
+ this.log(evt.status, "info");
+ }
+
+ // this handles local event propigation
+ this.dispatch = function(evt){
+ // figure out what topic it came from
+ if(evt["to"]||evt["kn_routed_from"]){
+ var rf = evt["to"]||evt["kn_routed_from"];
+ // split off the base server URL
+ var topic = rf.split(this.serverBaseURL, 2)[1];
+ if(!topic){
+ // FIXME: how do we recover when we don't get a sane "from"? Do
+ // we try to route to it anyway?
+ topic = rf;
+ }
+ this.log("[topic] "+topic);
+ if(topic.length>3){
+ if(topic.slice(0, 3)=="/kn"){
+ topic = topic.slice(3);
+ }
+ }
+ if(this.attachPathList[topic]){
+ this.attachPathList[topic](evt);
+ }
+ }
+ }
+
+ this.subscribe = function( topic /* kn_from in the old terminilogy */,
+ toObj, toFunc, dontTellServer){
+ if(!this.isInitialized){
+ this.subscriptionBacklog.push([topic, toObj, toFunc, dontTellServer]);
+ return;
+ }
+ if(!this.attachPathList[topic]){
+ this.attachPathList[topic] = function(){ return true; }
+ this.log("subscribing to: "+topic);
+ this.topics.push(topic);
+ }
+ var revt = new dojo.io.repubsubEvent(this.tunnelURI, topic, "route");
+ var rstr = [this.serverBaseURL+"/kn", revt.toGetString()].join("");
+ dojo.event.kwConnect({
+ once: true,
+ srcObj: this.attachPathList,
+ srcFunc: topic,
+ adviceObj: toObj,
+ adviceFunc: toFunc
+ });
+ // NOTE: the above is a local mapping, if we're not the leader, we
+ // should connect our mapping to the topic handler of the peer
+ // leader, this ensures that not matter what happens to the
+ // leader, we don't really loose our heads if/when the leader
+ // goes away.
+ if(!this.rcvNode){ /* this should be an error! */ }
+ if(dontTellServer){
+ return;
+ }
+ this.log("sending subscription to: "+topic);
+ // create a subscription event object and give it all the props we need
+ // to updates on the specified topic
+
+ // FIXME: we should only enqueue if this is our first subscription!
+ this.sendTopicSubToServer(topic, rstr);
+ }
+
+ this.sendTopicSubToServer = function(topic, str){
+ if(!this.attachPathList[topic]["subscriptions"]){
+ this.enqueueEventStr(str);
+ this.attachPathList[topic].subscriptions = 0;
+ }
+ this.attachPathList[topic].subscriptions++;
+ }
+
+ this.unSubscribe = function(topic, toObj, toFunc){
+ // first, locally disconnect
+ dojo.event.kwDisconnect({
+ srcObj: this.attachPathList,
+ srcFunc: topic,
+ adviceObj: toObj,
+ adviceFunc: toFunc
+ });
+
+ // FIXME: figure out if there are any remaining listeners to the topic,
+ // and if not, inform the server of our desire not to be
+ // notified of updates to the topic
+ }
+
+ // the "publish" method is really a misnomer, since it really means "take
+ // this event and send it to the server". Note that the "dispatch" method
+ // handles local event promigulation, and therefore we emulate both sides
+ // of a real event router without having to swallow all of the complexity.
+ this.publish = function(topic, event){
+ var evt = dojo.io.repubsubEvent.initFromProperties(event);
+ // FIXME: need to make sure we have from and to set correctly
+ // before we serialize and send off to the great blue
+ // younder.
+ evt.to = topic;
+ // evt.from = this.tunnelURI;
+
+ var evtURLParts = [];
+ evtURLParts.push(this.serverBaseURL+"/kn");
+
+ // serialize the event to a string and then post it to the correct
+ // topic
+ evtURLParts.push(evt.toGetString());
+ this.enqueueEventStr(evtURLParts.join(""));
+ }
+
+ this.enqueueEventStr = function(evtStr){
+ this.log("enqueueEventStr");
+ this.backlog.push(evtStr);
+ this.dequeueEvent();
+ }
+
+ this.dequeueEvent = function(force){
+ this.log("dequeueEvent");
+ if(this.backlog.length <= 0){ return; }
+ if((this.canSnd)||(force)){
+ dojo.io.setIFrameSrc(this.sndNode, this.backlog.shift()+"&callback=repubsub.sndNodeReady");
+ this.canSnd = false;
+ }else{
+ this.log("sndNode not available yet!", "debug");
+ }
+ }
+}
+
+dojo.io.repubsubEvent = function(to, from, method, id, routeURI, payload, dispname, uid){
+ this.to = to;
+ this.from = from;
+ this.method = method||"route";
+ this.id = id||repubsub.getRandStr();
+ this.uri = routeURI;
+ this.displayname = dispname||repubsub.displayname;
+ this.userid = uid||repubsub.userid;
+ this.payload = payload||"";
+ this.flushChars = 4096;
+
+ this.initFromProperties = function(evt){
+ if(evt.constructor = dojo.io.repubsubEvent){
+ for(var x in evt){
+ this[x] = evt[x];
+ }
+ }else{
+ // we want to copy all the properties of the evt object, and transform
+ // those that are "stock" properties of dojo.io.repubsubEvent. All others should
+ // be copied as-is
+ for(var x in evt){
+ if(typeof this.forwardPropertiesMap[x] == "string"){
+ this[this.forwardPropertiesMap[x]] = evt[x];
+ }else{
+ this[x] = evt[x];
+ }
+ }
+ }
+ }
+
+ this.toGetString = function(noQmark){
+ var qs = [ ((noQmark) ? "" : "?") ];
+ for(var x=0; x<this.properties.length; x++){
+ var tp = this.properties[x];
+ if(this[tp[0]]){
+ qs.push(tp[1]+"="+encodeURIComponent(String(this[tp[0]])));
+ }
+ // FIXME: we need to be able to serialize non-stock properties!!!
+ }
+ return qs.join("&");
+ }
+
+}
+
+dojo.io.repubsubEvent.prototype.properties = [["from", "kn_from"], ["to", "kn_to"],
+ ["method", "do_method"], ["id", "kn_id"],
+ ["uri", "kn_uri"],
+ ["displayname", "kn_displayname"],
+ ["userid", "kn_userid"],
+ ["payload", "kn_payload"],
+ ["flushChars", "kn_response_flush"],
+ ["responseFormat", "kn_response_format"] ];
+
+// maps properties from their old names to their new names...
+dojo.io.repubsubEvent.prototype.forwardPropertiesMap = {};
+// ...and vice versa...
+dojo.io.repubsubEvent.prototype.reversePropertiesMap = {};
+
+// and we then populate them both from the properties list
+for(var x=0; x<dojo.io.repubsubEvent.prototype.properties.length; x++){
+ var tp = dojo.io.repubsubEvent.prototype.properties[x];
+ dojo.io.repubsubEvent.prototype.reversePropertiesMap[tp[0]] = tp[1];
+ dojo.io.repubsubEvent.prototype.forwardPropertiesMap[tp[1]] = tp[0];
+}
+// static version of initFromProperties, creates new event and object and
+// returns it after init
+dojo.io.repubsubEvent.initFromProperties = function(evt){
+ var eventObj = new dojo.io.repubsubEvent();
+ eventObj.initFromProperties(evt);
+ return eventObj;
+}
Propchange: tapestry/tapestry4/trunk/framework/src/js/dojo/src/io/RepubsubIO.js
------------------------------------------------------------------------------
svn:eol-style = native
Added: tapestry/tapestry4/trunk/framework/src/js/dojo/src/io/RhinoIO.js
URL: http://svn.apache.org/viewvc/tapestry/tapestry4/trunk/framework/src/js/dojo/src/io/RhinoIO.js?rev=413300&view=auto
==============================================================================
--- tapestry/tapestry4/trunk/framework/src/js/dojo/src/io/RhinoIO.js (added)
+++ tapestry/tapestry4/trunk/framework/src/js/dojo/src/io/RhinoIO.js Sat Jun 10 06:59:28 2006
@@ -0,0 +1,22 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.io.RhinoIO");
+
+// TODO: this doesn't execute
+/*dojo.io.SyncHTTPRequest = function(){
+ dojo.io.SyncRequest.call(this);
+
+ this.send = function(URI){
+ }
+}
+
+dojo.inherits(dojo.io.SyncHTTPRequest, dojo.io.SyncRequest);
+*/
Propchange: tapestry/tapestry4/trunk/framework/src/js/dojo/src/io/RhinoIO.js
------------------------------------------------------------------------------
svn:eol-style = native
Added: tapestry/tapestry4/trunk/framework/src/js/dojo/src/io/cookie.js
URL: http://svn.apache.org/viewvc/tapestry/tapestry4/trunk/framework/src/js/dojo/src/io/cookie.js?rev=413300&view=auto
==============================================================================
--- tapestry/tapestry4/trunk/framework/src/js/dojo/src/io/cookie.js (added)
+++ tapestry/tapestry4/trunk/framework/src/js/dojo/src/io/cookie.js Sat Jun 10 06:59:28 2006
@@ -0,0 +1,108 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.io.cookie");
+
+dojo.io.cookie.setCookie = function(name, value, days, path, domain, secure) {
+ var expires = -1;
+ if(typeof days == "number" && days >= 0) {
+ var d = new Date();
+ d.setTime(d.getTime()+(days*24*60*60*1000));
+ expires = d.toGMTString();
+ }
+ value = escape(value);
+ document.cookie = name + "=" + value + ";"
+ + (expires != -1 ? " expires=" + expires + ";" : "")
+ + (path ? "path=" + path : "")
+ + (domain ? "; domain=" + domain : "")
+ + (secure ? "; secure" : "");
+}
+
+dojo.io.cookie.set = dojo.io.cookie.setCookie;
+
+dojo.io.cookie.getCookie = function(name) {
+ // FIXME: Which cookie should we return?
+ // If there are cookies set for different sub domains in the current
+ // scope there could be more than one cookie with the same name.
+ // I think taking the last one in the list takes the one from the
+ // deepest subdomain, which is what we're doing here.
+ var idx = document.cookie.lastIndexOf(name+'=');
+ if(idx == -1) { return null; }
+ var value = document.cookie.substring(idx+name.length+1);
+ var end = value.indexOf(';');
+ if(end == -1) { end = value.length; }
+ value = value.substring(0, end);
+ value = unescape(value);
+ return value;
+}
+
+dojo.io.cookie.get = dojo.io.cookie.getCookie;
+
+dojo.io.cookie.deleteCookie = function(name) {
+ dojo.io.cookie.setCookie(name, "-", 0);
+}
+
+dojo.io.cookie.setObjectCookie = function(name, obj, days, path, domain, secure, clearCurrent) {
+ if(arguments.length == 5) { // for backwards compat
+ clearCurrent = domain;
+ domain = null;
+ secure = null;
+ }
+ var pairs = [], cookie, value = "";
+ if(!clearCurrent) { cookie = dojo.io.cookie.getObjectCookie(name); }
+ if(days >= 0) {
+ if(!cookie) { cookie = {}; }
+ for(var prop in obj) {
+ if(prop == null) {
+ delete cookie[prop];
+ } else if(typeof obj[prop] == "string" || typeof obj[prop] == "number") {
+ cookie[prop] = obj[prop];
+ }
+ }
+ prop = null;
+ for(var prop in cookie) {
+ pairs.push(escape(prop) + "=" + escape(cookie[prop]));
+ }
+ value = pairs.join("&");
+ }
+ dojo.io.cookie.setCookie(name, value, days, path, domain, secure);
+}
+
+dojo.io.cookie.getObjectCookie = function(name) {
+ var values = null, cookie = dojo.io.cookie.getCookie(name);
+ if(cookie) {
+ values = {};
+ var pairs = cookie.split("&");
+ for(var i = 0; i < pairs.length; i++) {
+ var pair = pairs[i].split("=");
+ var value = pair[1];
+ if( isNaN(value) ) { value = unescape(pair[1]); }
+ values[ unescape(pair[0]) ] = value;
+ }
+ }
+ return values;
+}
+
+dojo.io.cookie.isSupported = function() {
+ if(typeof navigator.cookieEnabled != "boolean") {
+ dojo.io.cookie.setCookie("__TestingYourBrowserForCookieSupport__",
+ "CookiesAllowed", 90, null);
+ var cookieVal = dojo.io.cookie.getCookie("__TestingYourBrowserForCookieSupport__");
+ navigator.cookieEnabled = (cookieVal == "CookiesAllowed");
+ if(navigator.cookieEnabled) {
+ // FIXME: should we leave this around?
+ this.deleteCookie("__TestingYourBrowserForCookieSupport__");
+ }
+ }
+ return navigator.cookieEnabled;
+}
+
+// need to leave this in for backwards-compat from 0.1 for when it gets pulled in by dojo.io.*
+if(!dojo.io.cookies) { dojo.io.cookies = dojo.io.cookie; }
Propchange: tapestry/tapestry4/trunk/framework/src/js/dojo/src/io/cookie.js
------------------------------------------------------------------------------
svn:eol-style = native
Added: tapestry/tapestry4/trunk/framework/src/js/dojo/src/json.js
URL: http://svn.apache.org/viewvc/tapestry/tapestry4/trunk/framework/src/js/dojo/src/json.js?rev=413300&view=auto
==============================================================================
--- tapestry/tapestry4/trunk/framework/src/js/dojo/src/json.js (added)
+++ tapestry/tapestry4/trunk/framework/src/js/dojo/src/json.js Sat Jun 10 06:59:28 2006
@@ -0,0 +1,135 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.json");
+dojo.require("dojo.lang.func");
+dojo.require("dojo.string.extras");
+dojo.require("dojo.AdapterRegistry");
+
+dojo.json = {
+ jsonRegistry: new dojo.AdapterRegistry(),
+
+ register: function(name, check, wrap, /*optional*/ override){
+ /***
+
+ Register a JSON serialization function. JSON serialization
+ functions should take one argument and return an object
+ suitable for JSON serialization:
+
+ - string
+ - number
+ - boolean
+ - undefined
+ - object
+ - null
+ - Array-like (length property that is a number)
+ - Objects with a "json" method will have this method called
+ - Any other object will be used as {key:value, ...} pairs
+
+ If override is given, it is used as the highest priority
+ JSON serialization, otherwise it will be used as the lowest.
+ ***/
+
+ dojo.json.jsonRegistry.register(name, check, wrap, override);
+ },
+
+ evalJson: function(/* jsonString */ json){
+ // FIXME: should this accept mozilla's optional second arg?
+ try {
+ return eval("(" + json + ")");
+ }catch(e){
+ dojo.debug(e);
+ return json;
+ }
+ },
+
+ evalJSON: function (json) {
+ dojo.deprecated("dojo.json.evalJSON", "use dojo.json.evalJson", "0.4");
+ return this.evalJson(json);
+ },
+
+ serialize: function(o){
+ /***
+ Create a JSON serialization of an object, note that this doesn't
+ check for infinite recursion, so don't do that!
+ ***/
+
+ var objtype = typeof(o);
+ if(objtype == "undefined"){
+ return "undefined";
+ }else if((objtype == "number")||(objtype == "boolean")){
+ return o + "";
+ }else if(o === null){
+ return "null";
+ }
+ if (objtype == "string") { return dojo.string.escapeString(o); }
+ // recurse
+ var me = arguments.callee;
+ // short-circuit for objects that support "json" serialization
+ // if they return "self" then just pass-through...
+ var newObj;
+ if(typeof(o.__json__) == "function"){
+ newObj = o.__json__();
+ if(o !== newObj){
+ return me(newObj);
+ }
+ }
+ if(typeof(o.json) == "function"){
+ newObj = o.json();
+ if (o !== newObj) {
+ return me(newObj);
+ }
+ }
+ // array
+ if(objtype != "function" && typeof(o.length) == "number"){
+ var res = [];
+ for(var i = 0; i < o.length; i++){
+ var val = me(o[i]);
+ if(typeof(val) != "string"){
+ val = "undefined";
+ }
+ res.push(val);
+ }
+ return "[" + res.join(",") + "]";
+ }
+ // look in the registry
+ try {
+ window.o = o;
+ newObj = dojo.json.jsonRegistry.match(o);
+ return me(newObj);
+ }catch(e){
+ // dojo.debug(e);
+ }
+ // it's a function with no adapter, bad
+ if(objtype == "function"){
+ return null;
+ }
+ // generic object code path
+ res = [];
+ for (var k in o){
+ var useKey;
+ if (typeof(k) == "number"){
+ useKey = '"' + k + '"';
+ }else if (typeof(k) == "string"){
+ useKey = dojo.string.escapeString(k);
+ }else{
+ // skip non-string or number keys
+ continue;
+ }
+ val = me(o[k]);
+ if(typeof(val) != "string"){
+ // skip non-serializable values
+ continue;
+ }
+ res.push(useKey + ":" + val);
+ }
+ return "{" + res.join(",") + "}";
+ }
+};
Propchange: tapestry/tapestry4/trunk/framework/src/js/dojo/src/json.js
------------------------------------------------------------------------------
svn:eol-style = native
Added: tapestry/tapestry4/trunk/framework/src/js/dojo/src/lang/__package__.js
URL: http://svn.apache.org/viewvc/tapestry/tapestry4/trunk/framework/src/js/dojo/src/lang/__package__.js?rev=413300&view=auto
==============================================================================
--- tapestry/tapestry4/trunk/framework/src/js/dojo/src/lang/__package__.js (added)
+++ tapestry/tapestry4/trunk/framework/src/js/dojo/src/lang/__package__.js Sat Jun 10 06:59:28 2006
@@ -0,0 +1,24 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.kwCompoundRequire({
+ common: [
+ "dojo.lang",
+ "dojo.lang.common",
+ "dojo.lang.assert",
+ "dojo.lang.array",
+ "dojo.lang.type",
+ "dojo.lang.func",
+ "dojo.lang.extras",
+ "dojo.lang.repr",
+ "dojo.lang.declare"
+ ]
+});
+dojo.provide("dojo.lang.*");
Propchange: tapestry/tapestry4/trunk/framework/src/js/dojo/src/lang/__package__.js
------------------------------------------------------------------------------
svn:eol-style = native
Added: tapestry/tapestry4/trunk/framework/src/js/dojo/src/lfx/extras.js
URL: http://svn.apache.org/viewvc/tapestry/tapestry4/trunk/framework/src/js/dojo/src/lfx/extras.js?rev=413300&view=auto
==============================================================================
--- tapestry/tapestry4/trunk/framework/src/js/dojo/src/lfx/extras.js (added)
+++ tapestry/tapestry4/trunk/framework/src/js/dojo/src/lfx/extras.js Sat Jun 10 06:59:28 2006
@@ -0,0 +1,119 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.lfx.extras");
+
+dojo.require("dojo.lfx.html");
+dojo.require("dojo.lfx.Animation");
+
+dojo.lfx.html.fadeWipeIn = function(nodes, duration, easing, callback){
+ nodes = dojo.lfx.html._byId(nodes);
+ var anim = dojo.lfx.combine(
+ dojo.lfx.wipeIn(nodes, duration, easing),
+ dojo.lfx.fadeIn(nodes, duration, easing));
+
+ if(callback){
+ dojo.event.connect(anim, "onEnd", function(){
+ callback(nodes, anim);
+ });
+ }
+
+ return anim;
+}
+
+dojo.lfx.html.fadeWipeOut = function(nodes, duration, easing, callback){
+ nodes = dojo.lfx.html._byId(nodes);
+ var anim = dojo.lfx.combine(
+ dojo.lfx.wipeOut(nodes, duration, easing),
+ dojo.lfx.fadeOut(nodes, duration, easing));
+
+ if(callback){
+ dojo.event.connect(anim, "onEnd", function(){
+ callback(nodes, anim);
+ });
+ }
+
+ return anim;
+}
+
+dojo.lfx.html.scale = function(nodes, percentage, scaleContent, fromCenter, duration, easing, callback){
+ nodes = dojo.lfx.html._byId(nodes);
+ var anims = [];
+
+ dojo.lang.forEach(nodes, function(node){
+ var origWidth = dojo.style.getOuterWidth(node);
+ var origHeight = dojo.style.getOuterHeight(node);
+
+ var actualPct = percentage/100.0;
+ var props = [
+ { property: "width",
+ start: origWidth,
+ end: origWidth * actualPct
+ },
+ { property: "height",
+ start: origHeight,
+ end: origHeight * actualPct
+ }];
+
+ if(scaleContent){
+ var fontSize = dojo.style.getStyle(node, 'font-size');
+ var fontSizeType = null;
+ if(!fontSize){
+ fontSize = parseFloat('100%');
+ fontSizeType = '%';
+ }else{
+ dojo.lang.some(['em','px','%'], function(item, index, arr){
+ if(fontSize.indexOf(item)>0){
+ fontSize = parseFloat(fontSize);
+ fontSizeType = item;
+ return true;
+ }
+ });
+ }
+ props.push({
+ property: "font-size",
+ start: fontSize,
+ end: fontSize * actualPct,
+ units: fontSizeType });
+ }
+
+ if(fromCenter){
+ var positioning = dojo.style.getStyle(node, "position");
+ var originalTop = node.offsetTop;
+ var originalLeft = node.offsetLeft;
+ var endTop = ((origHeight * actualPct) - origHeight)/2;
+ var endLeft = ((origWidth * actualPct) - origWidth)/2;
+ props.push({
+ property: "top",
+ start: originalTop,
+ end: (positioning == "absolute" ? originalTop - endTop : (-1*endTop))
+ });
+ props.push({
+ property: "left",
+ start: originalLeft,
+ end: (positioning == "absolute" ? originalLeft - endLeft : (-1*endLeft))
+ });
+ }
+
+ var anim = dojo.lfx.propertyAnimation(node, props, duration, easing);
+ if(callback){
+ dojo.event.connect(anim, "onEnd", function(){
+ callback(node, anim);
+ });
+ }
+
+ anims.push(anim);
+ });
+
+ if(nodes.length > 1){ return dojo.lfx.combine(anims); }
+ else{ return anims[0]; }
+}
+
+dojo.lang.mixin(dojo.lfx, dojo.lfx.html);
Propchange: tapestry/tapestry4/trunk/framework/src/js/dojo/src/lfx/extras.js
------------------------------------------------------------------------------
svn:eol-style = native
Added: tapestry/tapestry4/trunk/framework/src/js/dojo/src/loader.js
URL: http://svn.apache.org/viewvc/tapestry/tapestry4/trunk/framework/src/js/dojo/src/loader.js?rev=413300&view=auto
==============================================================================
--- tapestry/tapestry4/trunk/framework/src/js/dojo/src/loader.js (added)
+++ tapestry/tapestry4/trunk/framework/src/js/dojo/src/loader.js Sat Jun 10 06:59:28 2006
@@ -0,0 +1,450 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+/*
+ * loader.js - runs before the hostenv_*.js file. Contains all of the package loading methods.
+ */
+
+//A semi-colon is at the start of the line because after doing a build, this function definition
+//get compressed onto the same line as the last line in bootstrap1.js. That list line is just a
+//curly bracket, and the browser complains about that syntax. The semicolon fixes it. Putting it
+//here instead of at the end of bootstrap1.js, since it is more of an issue for this file, (using
+//the closure), and bootstrap1.js could change in the future.
+;(function(){
+ //Additional properties for dojo.hostenv
+ var _addHostEnv = {
+ pkgFileName: "__package__",
+
+ // for recursion protection
+ loading_modules_: {},
+ loaded_modules_: {},
+ addedToLoadingCount: [],
+ removedFromLoadingCount: [],
+
+ inFlightCount: 0,
+
+ // FIXME: it should be possible to pull module prefixes in from djConfig
+ modulePrefixes_: {
+ dojo: {name: "dojo", value: "src"}
+ },
+
+
+ setModulePrefix: function(module, prefix){
+ this.modulePrefixes_[module] = {name: module, value: prefix};
+ },
+
+ getModulePrefix: function(module){
+ var mp = this.modulePrefixes_;
+ if((mp[module])&&(mp[module]["name"])){
+ return mp[module].value;
+ }
+ return module;
+ },
+
+ getTextStack: [],
+ loadUriStack: [],
+ loadedUris: [],
+
+ //WARNING: This variable is referenced by packages outside of bootstrap: FloatingPane.js and undo/browser.js
+ post_load_: false,
+
+ //Egad! Lots of test files push on this directly instead of using dojo.addOnLoad.
+ modulesLoadedListeners: [],
+ unloadListeners: [],
+ loadNotifying: false
+ };
+
+ //Add all of these properties to dojo.hostenv
+ for(var param in _addHostEnv){
+ dojo.hostenv[param] = _addHostEnv[param];
+ }
+})();
+
+/**
+ * Loads and interprets the script located at relpath, which is relative to the
+ * script root directory. If the script is found but its interpretation causes
+ * a runtime exception, that exception is not caught by us, so the caller will
+ * see it. We return a true value if and only if the script is found.
+ *
+ * For now, we do not have an implementation of a true search path. We
+ * consider only the single base script uri, as returned by getBaseScriptUri().
+ *
+ * @param relpath A relative path to a script (no leading '/', and typically
+ * ending in '.js').
+ * @param module A module whose existance to check for after loading a path.
+ * Can be used to determine success or failure of the load.
+ * @param cb a function to pass the result of evaluating the script (optional)
+ */
+dojo.hostenv.loadPath = function(relpath, module /*optional*/, cb /*optional*/){
+ var uri;
+ if((relpath.charAt(0) == '/')||(relpath.match(/^\w+:/))){
+ // dojo.raise("relpath '" + relpath + "'; must be relative");
+ uri = relpath;
+ }else{
+ uri = this.getBaseScriptUri() + relpath;
+ }
+ if(djConfig.cacheBust && dojo.render.html.capable){
+ uri += "?" + String(djConfig.cacheBust).replace(/\W+/g,"");
+ }
+ try{
+ return ((!module) ? this.loadUri(uri, cb) : this.loadUriAndCheck(uri, module, cb));
+ }catch(e){
+ dojo.debug(e);
+ return false;
+ }
+}
+
+/**
+ * Reads the contents of the URI, and evaluates the contents.
+ * Returns true if it succeeded. Returns false if the URI reading failed.
+ * Throws if the evaluation throws.
+ * The result of the eval is not available to the caller TODO: now it is; was this a deliberate restriction?
+ *
+ * @param uri a uri which points at the script to be loaded
+ * @param cb a function to process the result of evaluating the script as an expression (optional)
+ */
+dojo.hostenv.loadUri = function(uri, cb /*optional*/){
+ if(this.loadedUris[uri]){
+ return 1;
+ }
+ var contents = this.getText(uri, null, true);
+ if(contents == null){ return 0; }
+ this.loadedUris[uri] = true;
+ if(cb){ contents = '('+contents+')'; }
+ var value = dj_eval(contents);
+ if(cb){
+ cb(value);
+ }
+ return 1;
+}
+
+// FIXME: probably need to add logging to this method
+dojo.hostenv.loadUriAndCheck = function(uri, module, cb){
+ var ok = true;
+ try{
+ ok = this.loadUri(uri, cb);
+ }catch(e){
+ dojo.debug("failed loading ", uri, " with error: ", e);
+ }
+ return ((ok)&&(this.findModule(module, false))) ? true : false;
+}
+
+dojo.loaded = function(){ }
+dojo.unloaded = function(){ }
+
+dojo.hostenv.loaded = function(){
+ this.loadNotifying = true;
+ this.post_load_ = true;
+ var mll = this.modulesLoadedListeners;
+ for(var x=0; x<mll.length; x++){
+ mll[x]();
+ }
+
+ //Clear listeners so new ones can be added
+ //For other xdomain package loads after the initial load.
+ this.modulesLoadedListeners = [];
+ this.loadNotifying = false;
+
+ dojo.loaded();
+}
+
+dojo.hostenv.unloaded = function(){
+ var mll = this.unloadListeners;
+ while(mll.length){
+ (mll.pop())();
+ }
+ dojo.unloaded();
+}
+
+/*
+Call styles:
+ dojo.addOnLoad(functionPointer)
+ dojo.addOnLoad(object, "functionName")
+*/
+dojo.addOnLoad = function(obj, fcnName) {
+ var dh = dojo.hostenv;
+ if(arguments.length == 1) {
+ dh.modulesLoadedListeners.push(obj);
+ } else if(arguments.length > 1) {
+ dh.modulesLoadedListeners.push(function() {
+ obj[fcnName]();
+ });
+ }
+
+ //Added for xdomain loading. dojo.addOnLoad is used to
+ //indicate callbacks after doing some dojo.require() statements.
+ //In the xdomain case, if all the requires are loaded (after initial
+ //page load), then immediately call any listeners.
+ if(dh.post_load_ && dh.inFlightCount == 0 && !dh.loadNotifying){
+ dh.callLoaded();
+ }
+}
+
+dojo.addOnUnload = function(obj, fcnName){
+ var dh = dojo.hostenv;
+ if(arguments.length == 1){
+ dh.unloadListeners.push(obj);
+ } else if(arguments.length > 1) {
+ dh.unloadListeners.push(function() {
+ obj[fcnName]();
+ });
+ }
+}
+
+dojo.hostenv.modulesLoaded = function(){
+ if(this.post_load_){ return; }
+ if((this.loadUriStack.length==0)&&(this.getTextStack.length==0)){
+ if(this.inFlightCount > 0){
+ dojo.debug("files still in flight!");
+ return;
+ }
+ dojo.hostenv.callLoaded();
+ }
+}
+
+dojo.hostenv.callLoaded = function(){
+ if(typeof setTimeout == "object"){
+ setTimeout("dojo.hostenv.loaded();", 0);
+ }else{
+ dojo.hostenv.loaded();
+ }
+}
+
+dojo.hostenv.getModuleSymbols = function(modulename) {
+ var syms = modulename.split(".");
+ for(var i = syms.length - 1; i > 0; i--){
+ var parentModule = syms.slice(0, i).join(".");
+ var parentModulePath = this.getModulePrefix(parentModule);
+ if(parentModulePath != parentModule){
+ syms.splice(0, i, parentModulePath);
+ break;
+ }
+ }
+ return syms;
+}
+
+/**
+* loadModule("A.B") first checks to see if symbol A.B is defined.
+* If it is, it is simply returned (nothing to do).
+*
+* If it is not defined, it will look for "A/B.js" in the script root directory,
+* followed by "A.js".
+*
+* It throws if it cannot find a file to load, or if the symbol A.B is not
+* defined after loading.
+*
+* It returns the object A.B.
+*
+* This does nothing about importing symbols into the current package.
+* It is presumed that the caller will take care of that. For example, to import
+* all symbols:
+*
+* with (dojo.hostenv.loadModule("A.B")) {
+* ...
+* }
+*
+* And to import just the leaf symbol:
+*
+* var B = dojo.hostenv.loadModule("A.B");
+* ...
+*
+* dj_load is an alias for dojo.hostenv.loadModule
+*/
+dojo.hostenv._global_omit_module_check = false;
+dojo.hostenv.loadModule = function(modulename, exact_only, omit_module_check){
+ if(!modulename){ return; }
+ omit_module_check = this._global_omit_module_check || omit_module_check;
+ var module = this.findModule(modulename, false);
+ if(module){
+ return module;
+ }
+
+ // protect against infinite recursion from mutual dependencies
+ if(dj_undef(modulename, this.loading_modules_)){
+ this.addedToLoadingCount.push(modulename);
+ }
+ this.loading_modules_[modulename] = 1;
+
+ // convert periods to slashes
+ var relpath = modulename.replace(/\./g, '/') + '.js';
+
+ var syms = this.getModuleSymbols(modulename);
+ var startedRelative = ((syms[0].charAt(0) != '/')&&(!syms[0].match(/^\w+:/)));
+ var last = syms[syms.length - 1];
+ // figure out if we're looking for a full package, if so, we want to do
+ // things slightly diffrently
+ var nsyms = modulename.split(".");
+ if(last=="*"){
+ modulename = (nsyms.slice(0, -1)).join('.');
+
+ while(syms.length){
+ syms.pop();
+ syms.push(this.pkgFileName);
+ relpath = syms.join("/") + '.js';
+ if(startedRelative && (relpath.charAt(0)=="/")){
+ relpath = relpath.slice(1);
+ }
+ ok = this.loadPath(relpath, ((!omit_module_check) ? modulename : null));
+ if(ok){ break; }
+ syms.pop();
+ }
+ }else{
+ relpath = syms.join("/") + '.js';
+ modulename = nsyms.join('.');
+ var ok = this.loadPath(relpath, ((!omit_module_check) ? modulename : null));
+ if((!ok)&&(!exact_only)){
+ syms.pop();
+ while(syms.length){
+ relpath = syms.join('/') + '.js';
+ ok = this.loadPath(relpath, ((!omit_module_check) ? modulename : null));
+ if(ok){ break; }
+ syms.pop();
+ relpath = syms.join('/') + '/'+this.pkgFileName+'.js';
+ if(startedRelative && (relpath.charAt(0)=="/")){
+ relpath = relpath.slice(1);
+ }
+ ok = this.loadPath(relpath, ((!omit_module_check) ? modulename : null));
+ if(ok){ break; }
+ }
+ }
+
+ if((!ok)&&(!omit_module_check)){
+ dojo.raise("Could not load '" + modulename + "'; last tried '" + relpath + "'");
+ }
+ }
+
+ // check that the symbol was defined
+ //Don't bother if we're doing xdomain (asynchronous) loading.
+ if(!omit_module_check && !this["isXDomain"]){
+ // pass in false so we can give better error
+ module = this.findModule(modulename, false);
+ if(!module){
+ dojo.raise("symbol '" + modulename + "' is not defined after loading '" + relpath + "'");
+ }
+ }
+
+ return module;
+}
+
+/**
+* startPackage("A.B") follows the path, and at each level creates a new empty
+* object or uses what already exists. It returns the result.
+*/
+dojo.hostenv.startPackage = function(packname){
+ var modref = dojo.evalObjPath((packname.split(".").slice(0, -1)).join('.'));
+ this.loaded_modules_[(new String(packname)).toLowerCase()] = modref;
+
+ var syms = packname.split(/\./);
+ if(syms[syms.length-1]=="*"){
+ syms.pop();
+ }
+ return dojo.evalObjPath(syms.join("."), true);
+}
+
+/**
+ * findModule("A.B") returns the object A.B if it exists, otherwise null.
+ * @param modulename A string like 'A.B'.
+ * @param must_exist Optional, defualt false. throw instead of returning null
+ * if the module does not currently exist.
+ */
+dojo.hostenv.findModule = function(modulename, must_exist){
+ // check cache
+ /*
+ if(!dj_undef(modulename, this.modules_)){
+ return this.modules_[modulename];
+ }
+ */
+
+ var lmn = (new String(modulename)).toLowerCase();
+
+ if(this.loaded_modules_[lmn]){
+ return this.loaded_modules_[lmn];
+ }
+
+ // see if symbol is defined anyway
+ var module = dojo.evalObjPath(modulename);
+ if((modulename)&&(typeof module != 'undefined')&&(module)){
+ this.loaded_modules_[lmn] = module;
+ return module;
+ }
+
+ if(must_exist){
+ dojo.raise("no loaded module named '" + modulename + "'");
+ }
+ return null;
+}
+
+//Start of old bootstrap2:
+
+/*
+ * This method taks a "map" of arrays which one can use to optionally load dojo
+ * modules. The map is indexed by the possible dojo.hostenv.name_ values, with
+ * two additional values: "default" and "common". The items in the "default"
+ * array will be loaded if none of the other items have been choosen based on
+ * the hostenv.name_ item. The items in the "common" array will _always_ be
+ * loaded, regardless of which list is chosen. Here's how it's normally
+ * called:
+ *
+ * dojo.kwCompoundRequire({
+ * browser: [
+ * ["foo.bar.baz", true, true], // an example that passes multiple args to loadModule()
+ * "foo.sample.*",
+ * "foo.test,
+ * ],
+ * default: [ "foo.sample.*" ],
+ * common: [ "really.important.module.*" ]
+ * });
+ */
+dojo.kwCompoundRequire = function(modMap){
+ var common = modMap["common"]||[];
+ var result = (modMap[dojo.hostenv.name_]) ? common.concat(modMap[dojo.hostenv.name_]||[]) : common.concat(modMap["default"]||[]);
+
+ for(var x=0; x<result.length; x++){
+ var curr = result[x];
+ if(curr.constructor == Array){
+ dojo.hostenv.loadModule.apply(dojo.hostenv, curr);
+ }else{
+ dojo.hostenv.loadModule(curr);
+ }
+ }
+}
+
+dojo.require = function(){
+ dojo.hostenv.loadModule.apply(dojo.hostenv, arguments);
+}
+
+dojo.requireIf = function(){
+ if((arguments[0] === true)||(arguments[0]=="common")||(arguments[0] && dojo.render[arguments[0]].capable)){
+ var args = [];
+ for (var i = 1; i < arguments.length; i++) { args.push(arguments[i]); }
+ dojo.require.apply(dojo, args);
+ }
+}
+
+dojo.requireAfterIf = dojo.requireIf;
+
+dojo.provide = function(){
+ return dojo.hostenv.startPackage.apply(dojo.hostenv, arguments);
+}
+
+dojo.setModulePrefix = function(module, prefix){
+ return dojo.hostenv.setModulePrefix(module, prefix);
+}
+
+// determine if an object supports a given method
+// useful for longer api chains where you have to test each object in the chain
+dojo.exists = function(obj, name){
+ var p = name.split(".");
+ for(var i = 0; i < p.length; i++){
+ if(!(obj[p[i]])) return false;
+ obj = obj[p[i]];
+ }
+ return true;
+}
Propchange: tapestry/tapestry4/trunk/framework/src/js/dojo/src/loader.js
------------------------------------------------------------------------------
svn:eol-style = native
Added: tapestry/tapestry4/trunk/framework/src/js/dojo/src/loader_xd.js
URL: http://svn.apache.org/viewvc/tapestry/tapestry4/trunk/framework/src/js/dojo/src/loader_xd.js?rev=413300&view=auto
==============================================================================
--- tapestry/tapestry4/trunk/framework/src/js/dojo/src/loader_xd.js (added)
+++ tapestry/tapestry4/trunk/framework/src/js/dojo/src/loader_xd.js Sat Jun 10 06:59:28 2006
@@ -0,0 +1,414 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+//Cross-domain package loader.
+
+//FIXME: How will xd loading work with debugAtAllCosts? Any bad interactions?
+//FIXME: widgets won't work fully (HTML/CSS) and also because of the requireIf() thing.
+
+dojo.hostenv.resetXd = function(){
+ //This flag indicates where or not we have crossed into xdomain territory. Once any package says
+ //it is cross domain, then the rest of the packages have to be treated as xdomain because we need
+ //to evaluate packages in order. If there is a xdomain package followed by a xhr package, we can't load
+ //the xhr package until the one before it finishes loading. The text of the xhr package will be converted
+ //to match the format for a xd package and put in the xd load queue.
+ //You can force all packages to be treated as xd by setting the djConfig.forceXDomain.
+ this.isXDomain = djConfig.forceXDomain || false;
+
+ this.xdTimer = 0;
+ this.xdInFlight = {};
+ this.xdOrderedReqs = [];
+ this.xdDepMap = {};
+ this.xdContents = [];
+}
+
+//Call reset immediately to set the state.
+dojo.hostenv.resetXd();
+
+dojo.hostenv.createXdPackage = function(contents){
+ //Find dependencies.
+ var deps = [];
+ var depRegExp = /dojo.(require|requireIf|requireAll|provide|requireAfterIf|requireAfter|kwCompoundRequire|conditionalRequire|hostenv\.conditionalLoadModule|.hostenv\.loadModule|hostenv\.moduleLoaded)\(([\w\W]*?)\)/mg;
+ var match;
+ while((match = depRegExp.exec(contents)) != null){
+ deps.push("\"" + match[1] + "\", " + match[2]);
+ }
+
+ //Create package object and the call to packageLoaded.
+ var output = [];
+ output.push("dojo.hostenv.packageLoaded({\n");
+
+ //Add dependencies
+ if(deps.length > 0){
+ output.push("depends: [");
+ for(var i = 0; i < deps.length; i++){
+ if(i > 0){
+ output.push(",\n");
+ }
+ output.push("[" + deps[i] + "]");
+ }
+ output.push("],");
+ }
+
+ //Add the contents of the file inside a function.
+ //Pass in dojo as an argument to the function to help with
+ //allowing multiple versions of dojo in a page.
+ output.push("\ndefinePackage: function(dojo){");
+ output.push(contents);
+ output.push("\n}});");
+
+ return output.join("");
+}
+
+dojo.hostenv.loadPath = function(relpath, module /*optional*/, cb /*optional*/){
+ //Only do getBaseScriptUri if path does not start with a URL with a protocol.
+ //If there is a colon before the first / then, we have a URL with a protocol.
+ var colonIndex = relpath.indexOf(":");
+ var slashIndex = relpath.indexOf("/");
+ var uri;
+ var currentIsXDomain = false;
+ if(colonIndex > 0 && colonIndex < slashIndex){
+ uri = relpath;
+ this.isXDomain = currentIsXDomain = true;
+ }else{
+ uri = this.getBaseScriptUri() + relpath;
+
+ //Is ithe base script URI-based URL a cross domain URL?
+ colonIndex = uri.indexOf(":");
+ slashIndex = uri.indexOf("/");
+ if(colonIndex > 0 && colonIndex < slashIndex && (!location.host || uri.indexOf("http://" + location.host) != 0)){
+ this.isXDomain = currentIsXDomain = true;
+ }
+ }
+
+ if(djConfig.cacheBust && dojo.render.html.capable) { uri += "?" + String(djConfig.cacheBust).replace(/\W+/g,""); }
+ try{
+ return ((!module || this.isXDomain) ? this.loadUri(uri, cb, currentIsXDomain, module) : this.loadUriAndCheck(uri, module, cb));
+ }catch(e){
+ dojo.debug(e);
+ return false;
+ }
+}
+
+//Overriding loadUri for now. Wanted to override getText(), but it is used by
+//the widget code in too many, synchronous ways right now. This means the xd stuff
+//is not suitable for widgets yet.
+dojo.hostenv.loadUri = function(uri, cb, currentIsXDomain, module){
+ if(this.loadedUris[uri]){
+ return 1;
+ }
+
+ //Add the module (package) to the list of modules.
+ if(this.isXDomain){
+ //Curious: is this array going to get whacked with multiple access since scripts
+ //load asynchronously and may be accessing the array at the same time?
+ //JS is single-threaded supposedly, so it should be ok. And we don't need
+ //a precise ordering.
+ this.xdOrderedReqs.push(module);
+
+ //Add to waiting packages.
+ //If this is a __package__.js file, then this must be
+ //a package.* request (since xdomain can only work with the first
+ //path in a package search list. However, .* module names are not
+ //passed to this function, so do an adjustment here.
+ if(uri.indexOf("__package__") != -1){
+ module += ".*";
+ }
+
+ this.xdInFlight[module] = true;
+
+ //Increment inFlightCount
+ //This will stop the modulesLoaded from firing all the way.
+ this.inFlightCount++;
+
+ //Start timer
+ if(!this.xdTimer){
+ this.xdTimer = setInterval("dojo.hostenv.watchInFlightXDomain();", 100);
+ }
+ this.xdStartTime = (new Date()).getTime();
+ }
+
+ if (currentIsXDomain){
+ //Fix name to be a .xd.fileextension name.
+ var lastIndex = uri.lastIndexOf('.');
+ if(lastIndex <= 0){
+ lastIndex = uri.length - 1;
+ }
+
+ var xdUri = uri.substring(0, lastIndex) + ".xd";
+ if(lastIndex != uri.length - 1){
+ xdUri += uri.substring(lastIndex, uri.length);
+ }
+
+ //Add to script src
+ var element = document.createElement("script");
+ element.type = "text/javascript";
+ element.src = xdUri;
+ if(!this.headElement){
+ this.headElement = document.getElementsByTagName("head")[0];
+ }
+ this.headElement.appendChild(element);
+ }else{
+ var contents = this.getText(uri, null, true);
+ if(contents == null){ return 0; }
+
+ if(this.isXDomain){
+ var pkg = this.createXdPackage(contents);
+ dj_eval(pkg);
+ }else{
+ if(cb){ contents = '('+contents+')'; }
+ var value = dj_eval(contents);
+ if(cb){
+ cb(value);
+ }
+ }
+ }
+
+ //These steps are done in the non-xd loader version of this function.
+ //Maintain these steps to fit in with the existing system.
+ this.loadedUris[uri] = true;
+ return 1;
+}
+
+dojo.hostenv.packageLoaded = function(pkg){
+ var deps = pkg.depends;
+ var requireList = null;
+ var requireAfterList = null;
+ var provideList = [];
+ if(deps && deps.length > 0){
+ var dep = null;
+ var insertHint = 0;
+ var attachedPackage = false;
+ for(var i = 0; i < deps.length; i++){
+ dep = deps[i];
+
+ //Look for specific dependency indicators.
+ if (dep[0] == "provide" || dep[0] == "hostenv.moduleLoaded"){
+ provideList.push(dep[1]);
+ }else{
+ if(!requireList){
+ requireList = [];
+ }
+ if(!requireAfterList){
+ requireAfterList = [];
+ }
+
+ var unpackedDeps = this.unpackXdDependency(dep);
+ if(unpackedDeps.requires){
+ requireList = requireList.concat(unpackedDeps.requires);
+ }
+ if(unpackedDeps.requiresAfter){
+ requireAfterList = requireAfterList.concat(unpackedDeps.requiresAfter);
+ }
+ }
+
+ //Call the dependency indicator to allow for the normal dojo setup.
+ //Only allow for one dot reference, for the hostenv.* type calls.
+ var depType = dep[0];
+ var objPath = depType.split(".");
+ if(objPath.length == 2){
+ dojo[objPath[0]][objPath[1]].apply(dojo[objPath[0]], dep.slice(1));
+ }else{
+ dojo[depType].apply(dojo, dep.slice(1));
+ }
+ }
+
+ //Save off the package contents for definition later.
+ var contentIndex = this.xdContents.push({content: pkg.definePackage, isDefined: false}) - 1;
+
+ //Add provide/requires to dependency map.
+ for(var i = 0; i < provideList.length; i++){
+ this.xdDepMap[provideList[i]] = { requires: requireList, requiresAfter: requireAfterList, contentIndex: contentIndex };
+ }
+
+ //Now update the inflight status for any provided packages in this loaded package.
+ //Do this at the very end (in a *separate* for loop) to avoid shutting down the
+ //inflight timer check too soon.
+ for(var i = 0; i < provideList.length; i++){
+ this.xdInFlight[provideList[i]] = false;
+ }
+ }
+}
+
+//This is a bit brittle: it has to know about the dojo methods that deal with dependencies
+//It would be ideal to intercept the actual methods and do something fancy at that point,
+//but I have concern about knowing which provide to match to the dependency in that case,
+//since scripts can load whenever they want, and trigger new calls to dojo.hostenv.packageLoaded().
+dojo.hostenv.unpackXdDependency = function(dep){
+ //Extract the dependency(ies).
+ var newDeps = null;
+ var newAfterDeps = null;
+ switch(dep[0]){
+ case "requireIf":
+ case "requireAfterIf":
+ case "conditionalRequire":
+ //First arg (dep[1]) is the test. Depedency is dep[2].
+ if((dep[1] === true)||(dep[1]=="common")||(dep[1] && dojo.render[dep[1]].capable)){
+ newDeps = [{name: dep[2], content: null}];
+ }
+ break;
+ case "requireAll":
+ //the arguments are an array, each element a call to require.
+ //Get rid of first item, which is "requireAll".
+ dep.shift();
+ newDeps = dep;
+ dojo.hostenv.flattenRequireArray(newDeps);
+ break;
+ case "kwCompoundRequire":
+ case "hostenv.conditionalLoadModule":
+ var modMap = dep[1];
+ var common = modMap["common"]||[];
+ var newDeps = (modMap[dojo.hostenv.name_]) ? common.concat(modMap[dojo.hostenv.name_]||[]) : common.concat(modMap["default"]||[]);
+ dojo.hostenv.flattenRequireArray(newDeps);
+ break;
+ case "require":
+ case "requireAfter":
+ case "hostenv.loadModule":
+ //Just worry about dep[1]
+ newDeps = [{name: dep[1], content: null}];
+ break;
+ }
+
+ //The requireAfterIf or requireAfter needs to be evaluated after the current package is evaluated.
+ if(dep[0] == "requireAfterIf"){
+ newAfterDeps = newDeps;
+ newDeps = null;
+ }
+ return {requires: newDeps, requiresAfter: newAfterDeps};
+}
+
+//Walks the requires and evaluates package contents in
+//the right order.
+dojo.hostenv.xdWalkReqs = function(){
+ var reqChain = null;
+ var req;
+ for(var i = 0; i < this.xdOrderedReqs.length; i++){
+ req = this.xdOrderedReqs[i];
+ if(this.xdDepMap[req]){
+ reqChain = [req];
+ reqChain[req] = true; //Allow for fast lookup of the req in the array
+ this.xdEvalReqs(reqChain);
+ }
+ }
+}
+
+//Trace down any requires.
+dojo.hostenv.xdTraceReqs = function(reqs, reqChain){
+ if(reqs && reqs.length > 0){
+ var nextReq;
+ for(var i = 0; i < reqs.length; i++){
+ nextReq = reqs[i].name;
+ if(nextReq && !reqChain[nextReq]){
+ //New req depedency. Follow it down.
+ reqChain.push(nextReq);
+ reqChain[nextReq] = true;
+ this.xdEvalReqs(reqChain);
+ }
+ }
+ }
+}
+
+//Do a depth first, breadth second search and eval or reqs.
+dojo.hostenv.xdEvalReqs = function(reqChain){
+ if(reqChain.length > 0){
+ var req = reqChain[reqChain.length - 1];
+ var pkg = this.xdDepMap[req];
+ if(pkg){
+ //Trace down any requires for this package.
+ this.xdTraceReqs(pkg.requires, reqChain);
+
+ //Evaluate the package.
+ var contents = this.xdContents[pkg.contentIndex];
+ if(!contents.isDefined){
+ //Evaluate the package to bring it into being.
+ //Pass dojo in so that later, to support multiple versions of dojo
+ //in a page, we can pass which version of dojo to use.
+ contents.content(dojo);
+ contents.isDefined = true;
+ }
+ this.xdDepMap[req] = null;
+
+ //Trace down any requireAfters for this package..
+ this.xdTraceReqs(pkg.requiresAfter, reqChain);
+ }
+
+ //Done with that require. Remove it and go to the next one.
+ reqChain.pop();
+ this.xdEvalReqs(reqChain);
+ }
+}
+
+dojo.hostenv.clearXdInterval = function(){
+ clearInterval(this.xdTimer);
+ this.xdTimer = 0;
+}
+
+dojo.hostenv.watchInFlightXDomain = function(){
+ //Make sure we haven't waited timed out.
+ var waitInterval = (djConfig.xdWaitSeconds || 30) * 1000;
+
+ if(this.xdStartTime + waitInterval < (new Date()).getTime()){
+ this.clearXdInterval();
+ var noLoads = "";
+ for(var param in this.xdInFlight){
+ if(this.xdInFlight[param]){
+ noLoads += param + " ";
+ }
+ }
+ dojo.raise("Could not load cross-domain packages: " + noLoads);
+ }
+
+ //If any are true, then still waiting.
+ //Come back later.
+ for(var param in this.xdInFlight){
+ if(this.xdInFlight[param]){
+ return;
+ }
+ }
+
+ //All done loading. Clean up and notify that we are loaded.
+ this.clearXdInterval();
+
+ this.xdWalkReqs();
+
+ //Evaluate any packages that were not evaled before.
+ //This normally shouldn't happen with proper dojo.provide and dojo.require
+ //usage, but providing it just in case. Note that these may not be executed
+ //in the original order that the developer intended.
+ //Pass dojo in so that later, to support multiple versions of dojo
+ //in a page, we can pass which version of dojo to use.
+ for(var i = 0; i < this.xdContents.length; i++){
+ var current = this.xdContents[i];
+ if(current.content && !current.isDefined){
+ current.content(dojo);
+ }
+ }
+
+ //Clean up for the next round of xd loading.
+ this.resetXd();
+
+ //Clear inflight count so we will finally do finish work.
+ this.inFlightCount = 0;
+ this.callLoaded();
+}
+
+dojo.hostenv.flattenRequireArray = function(target){
+ //Each result could be an array of 3 elements (the 3 arguments to dojo.require).
+ //We only need the first one.
+ if(target){
+ for(var i = 0; i < target.length; i++){
+ if(target[i] instanceof Array){
+ target[i] = {name: target[i][0], content: null};
+ }else{
+ target[i] = {name: target[i], content: null};
+ }
+ }
+ }
+}
Propchange: tapestry/tapestry4/trunk/framework/src/js/dojo/src/loader_xd.js
------------------------------------------------------------------------------
svn:eol-style = native