Subversion Repositories Applications.papyrus

/*

	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.widget.html.loader");

dojo.require("dojo.widget.HtmlWidget");

dojo.require("dojo.io.*");

dojo.require("dojo.lang.common");

dojo.require("dojo.lang.extras");

dojo.require("dojo.experimental");

dojo.experimental("dojo.widget.html.loader");

dojo.widget.html.loader = new (function () {

	this.toString = function () {

		return "dojo.widget.html.loader";

	};

	var _loader = this;

	dojo.addOnLoad(function () {

		dojo.experimental(_loader.toString());

		var undo = dojo.evalObjPath("dojo.undo.browser");

		if (djConfig["preventBackButtonFix"] && undo && !undo.initialState) {

			undo.setInitialState(new trackerObj);

		}

	});

	var logger = {};

	var trackerObj = function (id, data) {

		this.id = id;

		this.data = data;

	};

	trackerObj.prototype.handle = function (type) {

		if (typeof dojo == "undefined") {

			return;

		}

		var wg = dojo.widget.byId(this.id);

		if (wg) {

			wg.setContent(this.data, true);

		}

	};

	this._log = function (widget, data) {

		if (widget.trackHistory) {

			if (!logger[widget.widgetId]) {

				logger[widget.widgetId] = {childrenIds:[], stack:[data]};

			}

			var children = logger[widget.widgetId].childrenIds;

			while (children && children.length) {

				delete logger[children.pop()];

			}

			for (var child in widget.children) {

				logger[widget.widgetId].childrenIds = child.widgetId;

			}

			dojo.undo.browser.addToHistory(new trackerObj(widget.widgetId, dojo.lang.shallowCopy(data, true)));

		}

	};

	var undef = dojo.lang.isUndefined;

	var isFunc = dojo.lang.isFunction;

	function handleDefaults(e, handler, useAlert) {

		if (!handler) {

			handler = "onContentError";

		}

		if (dojo.lang.isString(e)) {

			e = {_text:e};

		}

		if (!e._text) {

			e._text = e.toString();

		}

		e.toString = function () {

			return this._text;

		};

		if (typeof e.returnValue != "boolean") {

			e.returnValue = true;

		}

		if (typeof e.preventDefault != "function") {

			e.preventDefault = function () {

				this.returnValue = false;

			};

		}

		this[handler](e);

		if (e.returnValue) {

			if (useAlert) {

				alert(e.toString());

			} else {

				this.loader.callOnUnLoad.call(this, false);

				this.onSetContent(e.toString());

			}

		}

	}

	function downloader(bindArgs) {

		for (var x in this.bindArgs) {

			bindArgs[x] = (undef(bindArgs[x]) ? this.bindArgs[x] : undefined);

		}

		var cache = this.cacheContent;

		if (undef(bindArgs.useCache)) {

			bindArgs.useCache = cache;

		}

		if (undef(bindArgs.preventCache)) {

			bindArgs.preventCache = !cache;

		}

		if (undef(bindArgs.mimetype)) {

			bindArgs.mimetype = "text/html";

		}

		this.loader.bindObj = dojo.io.bind(bindArgs);

	}

	function stackRunner(st) {

		var err = "", func = null;

		var scope = this.scriptScope || dojo.global();

		while (st.length) {

			func = st.shift();

			try {

				func.call(scope);

			}

			catch (e) {

				err += "\n" + func + " failed: " + e;

			}

		}

		if (err.length) {

			var name = (st == this.loader.addOnLoads) ? "addOnLoad" : "addOnUnLoad";

			handleDefaults.call(this, name + " failure\n " + err, "onExecError", true);

		}

	}

	function stackPusher(st, obj, func) {

		if (typeof func == "undefined") {

			st.push(obj);

		} else {

			st.push(function () {

				obj[func]();

			});

		}

	}

	function refreshed() {

		this.onResized();

		this.onLoad();

		this.isLoaded = true;

	}

	function asyncParse(data) {

		if (this.executeScripts) {

			this.onExecScript.call(this, data.scripts);

		}

		if (this.parseContent) {

			this.onContentParse.call(this);

		}

		refreshed.call(this);

	}

	function runHandler() {

		if (dojo.lang.isFunction(this.handler)) {

			this.handler(this, this.containerNode || this.domNode);

			refreshed.call(this);

			return false;

		}

		return true;

	}

	this.htmlContentBasicFix = function (s, url) {

		var titles = [], styles = [];

		var regex = /<title[^>]*>([\s\S]*?)<\/title>/i;

		var match, attr;

		while (match = regex.exec(s)) {

			titles.push(match[1]);

			s = s.substring(0, match.index) + s.substr(match.index + match[0].length);

		}

		regex = /(?:<(style)[^>]*>([\s\S]*?)<\/style>|<link ([^>]*rel=['"]?stylesheet['"]?[^>]*)>)/i;

		while (match = regex.exec(s)) {

			if (match[1] && match[1].toLowerCase() == "style") {

				styles.push(dojo.html.fixPathsInCssText(match[2], url));

			} else {

				if (attr = match[3].match(/href=(['"]?)([^'">]*)\1/i)) {

					styles.push({path:attr[2]});

				}

			}

			s = s.substring(0, match.index) + s.substr(match.index + match[0].length);

		}

		return {"s":s, "titles":titles, "styles":styles};

	};

	this.htmlContentAdjustPaths = function (s, url) {

		var tag = "", str = "", tagFix = "", path = "";

		var attr = [], origPath = "", fix = "";

		var regexFindTag = /<[a-z][a-z0-9]*[^>]*\s(?:(?:src|href|style)=[^>])+[^>]*>/i;

		var regexFindAttr = /\s(src|href|style)=(['"]?)([\w()\[\]\/.,\\'"-:;#=&?\s@]+?)\2/i;

		var regexProtocols = /^(?:[#]|(?:(?:https?|ftps?|file|javascript|mailto|news):))/;

		while (tag = regexFindTag.exec(s)) {

			str += s.substring(0, tag.index);

			s = s.substring((tag.index + tag[0].length), s.length);

			tag = tag[0];

			tagFix = "";

			while (attr = regexFindAttr.exec(tag)) {

				path = "";

				origPath = attr[3];

				switch (attr[1].toLowerCase()) {

				  case "src":

				  case "href":

					if (regexProtocols.exec(origPath)) {

						path = origPath;

					} else {

						path = (new dojo.uri.Uri(url, origPath).toString());

					}

					break;

				  case "style":

					path = dojo.html.fixPathsInCssText(origPath, url);

					break;

				  default:

					path = origPath;

				}

				fix = " " + attr[1] + "=" + attr[2] + path + attr[2];

				tagFix += tag.substring(0, attr.index) + fix;

				tag = tag.substring((attr.index + attr[0].length), tag.length);

			}

			str += tagFix + tag;

		}

		return str + s;

	};

	this.htmlContentScripts = function (s, collectScripts) {

		var scripts = [], requires = [], match = [];

		var attr = "", tmp = null, tag = "", sc = "", str = "";

		var regex = /<script([^>]*)>([\s\S]*?)<\/script>/i;

		var regexSrc = /src=(['"]?)([^"']*)\1/i;

		var regexDojoJs = /.*(\bdojo\b\.js(?:\.uncompressed\.js)?)$/;

		var regexInvalid = /(?:var )?\bdjConfig\b(?:[\s]*=[\s]*\{[^}]+\}|\.[\w]*[\s]*=[\s]*[^;\n]*)?;?|dojo\.hostenv\.writeIncludes\(\s*\);?/g;

		var regexRequires = /dojo\.(?:(?:require(?:After)?(?:If)?)|(?:widget\.(?:manager\.)?registerWidgetPackage)|(?:(?:hostenv\.)?setModulePrefix)|defineNamespace)\((['"]).*?\1\)\s*;?/;

		while (match = regex.exec(s)) {

			if (this.executeScripts && match[1]) {

				if (attr = regexSrc.exec(match[1])) {

					if (regexDojoJs.exec(attr[2])) {

						dojo.debug("Security note! inhibit:" + attr[2] + " from  beeing loaded again.");

					} else {

						scripts.push({path:attr[2]});

					}

				}

			}

			if (match[2]) {

				sc = match[2].replace(regexInvalid, "");

				if (!sc) {

					continue;

				}

				while (tmp = regexRequires.exec(sc)) {

					requires.push(tmp[0]);

					sc = sc.substring(0, tmp.index) + sc.substr(tmp.index + tmp[0].length);

				}

				if (collectScripts) {

					scripts.push(sc);

				}

			}

			s = s.substr(0, match.index) + s.substr(match.index + match[0].length);

		}

		if (collectScripts) {

			var regex = /(<[a-zA-Z][a-zA-Z0-9]*\s[^>]*\S=(['"])[^>]*[^\.\]])scriptScope([^>]*>)/;

			str = "";

			while (tag = regex.exec(s)) {

				tmp = ((tag[2] == "'") ? "\"" : "'");

				str += s.substring(0, tag.index);

				s = s.substr(tag.index).replace(regex, "$1dojo.widget.byId(" + tmp + this.widgetId + tmp + ").scriptScope$3");

			}

			s = str + s;

		}

		return {"s":s, "requires":requires, "scripts":scripts};

	};

	this.splitAndFixPaths = function (args) {

		if (!args.url) {

			args.url = "./";

		}

		url = new dojo.uri.Uri(location, args.url).toString();

		var ret = {"xml":"", "styles":[], "titles":[], "requires":[], "scripts":[], "url":url};

		if (args.content) {

			var tmp = null, content = args.content;

			if (args.adjustPaths) {

				content = _loader.htmlContentAdjustPaths.call(this, content, url);

			}

			tmp = _loader.htmlContentBasicFix.call(this, content, url);

			content = tmp.s;

			ret.styles = tmp.styles;

			ret.titles = tmp.titles;

			if (args.collectRequires || args.collectScripts) {

				tmp = _loader.htmlContentScripts.call(this, content, args.collectScripts);

				content = tmp.s;

				ret.requires = tmp.requires;

				ret.scripts = tmp.scripts;

			}

			var match = [];

			if (args.bodyExtract) {

				match = content.match(/<body[^>]*>\s*([\s\S]+)\s*<\/body>/im);

				if (match) {

					content = match[1];

				}

			}

			ret.xml = content;

		}

		return ret;

	};

	this.hookUp = function (args) {

		var widget = args.widget;

		if (dojo.lang.isString(widget)) {

			if (args.mixin) {

				dojo.raise(this.toString() + ", cant use mixin when widget is a string");

			}

			widget = dojo.evalObjPath(widget);

		}

		if (!widget || !(widget instanceof dojo.widget.HtmlWidget)) {

			dojo.raise(this.toString() + " Widget isn't defined or isn't a HtmlWidget instance");

		}

		if (widget.loader && widget.setUrl) {

			return;

		}

		var widgetProto = (args.mixin) ? widget : widget.constructor.prototype;

		widget.loader = {isLoaded:false, styleNodes:[], addOnLoads:[], addOnUnLoads:[], callOnUnLoad:(function (canCall) {

			return function (after) {

				this.abort();

				if (canCall) {

					this.onUnLoad();

				}

				canCall = after;

			};

		})(false), bindObj:null, unHook:(function (w, wg) {

			var oldProps = {isContainer:w.isContainer, adjustPats:w.adjustPaths, href:w.href, extractContent:w.extractContent, parseContent:w.parseContent, cacheContent:w.cacheContent, bindArgs:w.bindArgs, preload:w.preload, refreshOnShow:w.refreshOnShow, handler:w.handler, trackHistory:w.trackHistory, executeScripts:w.executeScripts, scriptScope:w.scriptScope, postCreate:w.postCreate, show:w.show, refresh:w.refresh, loadContents:w.loadContents, abort:w.abort, destroy:w.destroy, onLoad:w.onLoad, onUnLoad:w.onUnLoad, addOnLoad:w.addOnLoad, addOnUnLoad:w.addOnUnLoad, onDownloadStart:w.onDownloadStart, onDownloadEnd:w.onDownloadEnd, onDownloadError:w.onDownloadError, onContentError:w.onContentError, onExecError:w.onExecError, onSetContent:w.onSetContent, setUrl:w.setUrl, setContent:w.setContent, onContentParse:w.onContentParse, onExecScript:w.onExecScript, setHandler:w.setHandler};

			return function () {

				if (wg.abort) {

					wg.abort();

				}

				if ((w != wg) && (dojo.widget.byType(wg.widgetType).length > 1)) {

					return;

				}

				for (var x in oldProps) {

					if (oldProps[x] === undefined) {

						delete w[x];

						continue;

					}

					w[x] = oldProps[x];

				}

				delete wg._loader_defined;

				delete wg.loader;

			};

		})(widgetProto, widget)};

		if (widgetProto._loader_defined || widget._loader_defined) {

			return;

		}

		dojo.mixin(widgetProto, {isContainer:true, adjustPaths:undef(widgetProto.adjustPaths) ? true : widgetProto.adjustPaths, href:undef(widgetProto.href) ? "" : widgetProto.href, extractContent:undef(widgetProto.extractContent) ? true : widgetProto.extractContent, parseContent:undef(widgetProto.parseContent) ? true : widgetProto.parseContent, cacheContent:undef(widgetProto.cacheContent) ? true : widgetProto.cacheContent, bindArgs:undef(widgetProto.bindArgs) ? {} : widgetProto.bindArgs, preload:undef(widgetProto.preload) ? false : widgetProto.preload, refreshOnShow:undef(widgetProto.refreshOnShow) ? false : widgetProto.refreshOnShow, handler:undef(widgetProto.handler) ? "" : widgetProto.handler, executeScripts:undef(widgetProto.executeScripts) ? false : widgetProto.executeScripts, trackHistory:undef(widgetProto.tracHistory) ? false : widgetProto.trackHistory, scriptScope:null});

		widgetProto.postCreate = (function (postCreate) {

			return function () {

				if (widgetProto.constructor.superclass.postCreate != postCreate) {

					postCreate.apply(this, arguments);

				} else {

					widgetProto.constructor.superclass.postCreate.apply(this, arguments);

				}

				if (this.handler !== "") {

					this.setHandler(this.handler);

				}

				if (this.isShowing() || this.preload) {

					this.loadContents();

					if (!this.href) {

						_loader._log(this, (this.domNode || this.containerNode).innerHTML);

					}

				}

			};

		})(widgetProto.postCreate);

		widgetProto.show = (function (show) {

			return function () {

				if (this.refreshOnShow) {

					this.refresh();

				} else {

					this.loadContents();

				}

				if ((widgetProto.constructor.superclass.show == show) || !isFunc(show)) {

					widgetProto.constructor.superclass.show.apply(this, arguments);

				} else {

					show.apply(this, arguments);

				}

			};

		})(widgetProto.show);

		widgetProto.destroy = (function (destroy) {

			return function (destroy) {

				this.onUnLoad();

				this.abort();

				this.loader.unHook();

				if ((widgetProto.constructor.superclass.destroy != destroy) && isFunc(destroy)) {

					destroy.apply(this, arguments);

				} else {

					widgetProto.constructor.superclass.destroy.apply(this, arguments);

				}

			};

		})(widgetProto.destroy);

		if (!widgetProto.refresh) {

			widgetProto.refresh = function () {

				this.loader.isLoaded = false;

				this.loadContents();

			};

		}

		if (!widgetProto.loadContents) {

			widgetProto.loadContents = function () {

				if (this.loader.isLoaded) {

					return;

				}

				if (isFunc(this.handler)) {

					runHandler.call(this);

				} else {

					if (this.href !== "") {

						handleDefaults.call(this, "Loading...", "onDownloadStart");

						var self = this, url = this.href;

						downloader.call(this, {url:url, load:function (type, data, xhr) {

							self.onDownloadEnd.call(self, url, data);

						}, error:function (type, err, xhr) {

							var e = {responseText:xhr.responseText, status:xhr.status, statusText:xhr.statusText, responseHeaders:(xhr.getAllResponseHeaders) ? xhr.getAllResponseHeaders() : [], _text:"Error loading '" + url + "' (" + xhr.status + " " + xhr.statusText + ")"};

							handleDefaults.call(self, e, "onDownloadError");

							self.onLoad();

						}});

					}

				}

			};

		}

		if (!widgetProto.abort) {

			widgetProto.abort = function () {

				if (!this.loader || !this.loader.bindObj || !this.loader.bindObj.abort) {

					return;

				}

				this.loader.bindObj.abort();

				this.loader.bindObj = null;

			};

		}

		if (!widgetProto.onLoad) {

			widgetProto.onLoad = function () {

				stackRunner.call(this, this.loader.addOnLoads);

				this.loader.isLoaded = true;

			};

		}

		if (!widgetProto.onUnLoad) {

			widgetProto.onUnLoad = function () {

				stackRunner.call(this, this.loader.addOnUnLoads);

				delete this.scriptScope;

			};

		}

		if (!widgetProto.addOnLoad) {

			widgetProto.addOnLoad = function (obj, func) {

				stackPusher.call(this, this.loader.addOnLoads, obj, func);

			};

		}

		if (!widgetProto.addOnUnLoad) {

			widgetProto.addOnUnLoad = function (obj, func) {

				stackPusher.call(this, this.loader.addOnUnLoads, obj, func);

			};

		}

		if (!widgetProto.onExecError) {

			widgetProto.onExecError = function () {

			};

		}

		if (!widgetProto.onContentError) {

			widgetProto.onContentError = function () {

			};

		}

		if (!widgetProto.onDownloadError) {

			widgetProto.onDownloadError = function () {

			};

		}

		if (!widgetProto.onDownloadStart) {

			widgetProto.onDownloadStart = function (onDownloadStart) {

			};

		}

		if (!widgetProto.onDownloadEnd) {

			widgetProto.onDownloadEnd = function (url, data) {

				var args = {content:data, url:url, adjustPaths:this.adjustPaths, collectScripts:this.executeScripts, collectRequires:this.parseContent, bodyExtract:this.extractContent};

				data = _loader.splitAndFixPaths.call(this, args);

				this.setContent(data);

			};

		}

		if (!widgetProto.onSetContent) {

			widgetProto.onSetContent = function (cont) {

				this.destroyChildren();

				var styleNodes = this.loader.styleNodes;

				while (styleNodes.length) {

					var st = styleNodes.pop();

					if (st && st.parentNode) {

						st.parentNode.removeChild(st);

					}

				}

				var node = this.containerNode || this.domNode;

				while (node.firstChild) {

					try {

						dojo.event.browser.clean(node.firstChild);

					}

					catch (e) {

					}

					node.removeChild(node.firstChild);

				}

				try {

					if (typeof cont != "string") {

						node.appendChild(cont);

					} else {

						try {

							node.innerHTML = cont;

						}

						catch (e) {

							var tmp;

							(tmp = dojo.doc().createElement("div")).innerHTML = cont;

							while (tmp.firstChild) {

								node.appendChild(tmp.removeChild(tmp.firstChild));

							}

						}

					}

				}

				catch (e) {

					e._text = "Could'nt load content: " + e;

					var useAlert = (this.loader._onSetContent_err == e._text);

					this.loader._onSetContent_err = e._text;

					handleDefaults.call(this, e, "onContentError", useAlert);

				}

			};

		}

		if (!widgetProto.setUrl) {

			widgetProto.setUrl = function (url) {

				this.href = url;

				this.loader.isLoaded = false;

				if (this.preload || this.isShowing()) {

					this.loadContents();

				}

			};

		}

		if (!widgetProto.setContent) {

			widgetProto.setContent = function (data, dontLog) {

				this.loader.callOnUnLoad.call(this, true);

				if (!data || dojo.html.isNode(data)) {

					this.onSetContent(data);

					refreshed.call(this);

				} else {

					if (typeof data.xml != "string") {

						this.href = "";

						var args = {content:data, url:this.href, adjustPaths:this.adjustPaths, collectScripts:this.executeScripts, collectRequires:this.parseContent, bodyExtract:this.extractContent};

						data = _loader.splitAndFixPaths.call(this, args);

					} else {

						if (data.url != "./") {

							this.url = data.url;

						}

					}

					this.onSetContent(data.xml);

					for (var i = 0, styles = data.styles; i < styles.length; i++) {

						if (styles[i].path) {

							this.loader.styleNodes.push(dojo.html.insertCssFile(styles[i].path));

						} else {

							this.loader.styleNodes.push(dojo.html.insertCssText(styles[i]));

						}

					}

					if (this.parseContent) {

						for (var i = 0, requires = data.requires; i < requires.length; i++) {

							try {

								eval(requires[i]);

							}

							catch (e) {

								e._text = "dojo.widget.html.loader.hookUp: error in package loading calls, " + (e.description || e);

								handleDefaults.call(this, e, "onContentError", true);

							}

						}

					}

					if (dojo.hostenv.isXDomain && data.requires.length) {

						dojo.addOnLoad(function () {

							asyncParse.call(this, data);

							if (!dontLog) {

								_loader._log(this, data);

							}

						});

						dontLog = true;

					} else {

						asyncParse.call(this, data);

					}

				}

				if (!dontLog) {

				}

			};

		}

		if (!widgetProto.onContentParse) {

			widgetProto.onContentParse = function () {

				var node = this.containerNode || this.domNode;

				var parser = new dojo.xml.Parse();

				var frag = parser.parseElement(node, null, true);

				dojo.widget.getParser().createSubComponents(frag, this);

			};

		}

		if (!widgetProto.onExecScript) {

			widgetProto.onExecScript = function (scripts) {

				var self = this, tmp = "", code = "";

				for (var i = 0; i < scripts.length; i++) {

					if (scripts[i].path) {

						var url = scripts[i].path;

						downloader.call(this, {"url":url, "load":function (type, scriptStr) {

							(function () {

								tmp = scriptStr;

								scripts[i] = scriptStr;

							}).call(self);

						}, "error":function (type, error) {

							error._text = type + " downloading remote script";

							handleDefaults.call(self, error, "onExecError", true);

						}, "mimetype":"text/plain", "sync":true});

						code += tmp;

					} else {

						code += scripts[i];

					}

				}

				try {

					delete this.scriptScope;

					this.scriptScope = new (new Function("_container_", code + "; return this;"))(self);

				}

				catch (e) {

					e._text = "Error running scripts from content:\n" + (e.description || e.toString());

					handleDefaults.call(this, e, "onExecError", true);

				}

			};

		}

		if (!widgetProto.setHandler) {

			widgetProto.setHandler = function (handler) {

				var fcn = dojo.lang.isFunction(handler) ? handler : window[handler];

				if (!isFunc(fcn)) {

					handleDefaults.call(this, "Unable to set handler, '" + handler + "' not a function.", "onExecError", true);

					return;

				}

				this.handler = function () {

					return fcn.apply(this, arguments);

				};

			};

		}

		widgetProto._loader_defined = true;

	};

})();