Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojox.dtl.html"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.

dojo._hasResource["dojox.dtl.html"] = true;

dojo.provide("dojox.dtl.html");

dojo.require("dojox.dtl._base");

dojox.dtl.ObjectMap = function(){

	this.contents = [];

}

dojo.extend(dojox.dtl.ObjectMap, {

	get: function(key){

		var contents = this.contents;

		for(var i = 0, content; content = contents[i]; i++){

			if(content[0] === key){

				return content[1];

			}

		}

	},

	put: function(key, value){

		var contents = this.contents;

		for(var i = 0, content; content = contents[i]; i++){

			if(content[0] === key){

				if(arguments.length == 1){

					contents.splice(i, 1);

					return;

				}

				content[1] = value;

				return;

			}

		}

		contents.push([key, value]);

	},

	toString: function(){ return "dojox.dtl.ObjectMap"; }

});

dojox.dtl.html = {

	types: dojo.mixin({change: -11, attr: -12, elem: 1, text: 3}, dojox.dtl.text.types),

	_attributes: {},

	_re: /(^\s+|\s+$)/g,

	_re2: /\b([a-zA-Z]+)="/g,

	_re3: /<!--({({|%).*?(%|})})-->/g,

	_re4: /^function anonymous\(\)\s*{\s*(.*)\s*}$/,

	_trim: function(/*String*/ str){

		return str.replace(this._re, "");

	},

	getTemplate: function(text){

		if(typeof this._commentable == "undefined"){

			// Check to see if the browser can handle comments

			this._commentable = false;

			var div = document.createElement("div");

			div.innerHTML = "<!--Test comment handling, and long comments, using comments whenever possible.-->";

			if(div.childNodes.length && div.childNodes[0].nodeType == 8 && div.childNodes[0].data == "comment"){

				this._commentable = true;

			}

		}

		if(!this._commentable){

			// Strip comments

			text = text.replace(this._re3, "$1");

		}

		var match;

		while(match = this._re2.exec(text)){

			this._attributes[match[1]] = true;

		}

		var div = document.createElement("div");

		div.innerHTML = text;

		var output = { pres: [], posts: []}

		while(div.childNodes.length){

			if(!output.node && div.childNodes[0].nodeType == 1){

				output.node = div.removeChild(div.childNodes[0]);

			}else if(!output.node){

				output.pres.push(div.removeChild(div.childNodes[0]));

			}else{

				output.posts.push(div.removeChild(div.childNodes[0]));

			}

		}

		if(!output.node){

			throw new Error("Template did not provide any content");

		}

		return output;

	},

	tokenize: function(/*Node*/ node, /*Array?*/ tokens, /*Array?*/ preNodes, /*Array?*/ postNodes){

		tokens = tokens || [];

		var first = !tokens.length;

		var types = this.types;

		var children = [];

		for(var i = 0, child; child = node.childNodes[i]; i++){

			children.push(child);

		}

		if(preNodes){

			for(var i = 0, child; child = preNodes[i]; i++){

				this._tokenize(node, child, tokens);

			}

		}

		tokens.push([types.elem, node]);

		tokens.push([types.change, node]);

		for(var key in this._attributes){

			var value = "";

			if(key == "class"){

				value = node.className || value;

			}else if(key == "for"){

				value = node.htmlFor || value;

			}else if(node.getAttribute){

				value = node.getAttribute(key, 2) || value;

				if(key == "href" || key == "src"){

					if(dojo.isIE){

						var hash = location.href.lastIndexOf(location.hash);

						var href = location.href.substring(0, hash).split("/");

						href.pop();

						href = href.join("/") + "/";

						if(value.indexOf(href) == 0){

							value = value.replace(href, "");

						}

						value = value.replace(/%20/g, " ").replace(/%7B/g, "{").replace(/%7D/g, "}").replace(/%25/g, "%");

					}

					if(value.indexOf("{%") != -1 || value.indexOf("{{") != -1){

						node.setAttribute(key, "");

					}

				}

			}

			if(typeof value == "function"){

				value = value.toString().replace(this._re4, "$1");

			}

			if(typeof value == "string" && (value.indexOf("{%") != -1 || value.indexOf("{{") != -1 || (value && dojox.dtl.text.getTag("attr:" + key, true)))){

				tokens.push([types.attr, node, key, value]);

			}

		}

		if(!children.length){

			tokens.push([types.change, node.parentNode, true]);

			if(postNodes){

				for(var i = 0, child; child = postNodes[i]; i++){

					this._tokenize(node, child, tokens);

				}

			}

			return tokens;

		}

		for(var i = 0, child; child = children[i]; i++){

			this._tokenize(node, child, tokens);

		}

		if(node.parentNode && node.parentNode.tagName){

			tokens.push([types.change, node.parentNode, true]);

			node.parentNode.removeChild(node);

		}

		if(postNodes){

			for(var i = 0, child; child = postNodes[i]; i++){

				this._tokenize(node, child, tokens);

			}

		}

		if(first){

			tokens.push([types.change, node, true]);

		}

		return tokens;

	},

	_tokenize: function(parent, child, tokens){

		var types = this.types;

		var data = child.data;

		switch(child.nodeType){

			case 1:

				this.tokenize(child, tokens);

				break;

			case 3:

				if(data.match(/[^\s\n]/)){

					if(data.indexOf("{{") != -1 || data.indexOf("{%") != -1){

						var texts = dojox.dtl.text.tokenize(data);

						for(var j = 0, text; text = texts[j]; j++){

							if(typeof text == "string"){

								tokens.push([types.text, text]);

							}else{

								tokens.push(text);

							}

						}

					}else{

						tokens.push([child.nodeType, child]);

					}

				}

				if(child.parentNode) child.parentNode.removeChild(child);

				break;

			case 8:

				if(data.indexOf("{%") == 0){

					tokens.push([types.tag, this._trim(data.substring(2, data.length - 3))]);

				}

				if(data.indexOf("{{") == 0){

					tokens.push([types.varr, this._trim(data.substring(2, data.length - 3))]);

				}

				if(child.parentNode) child.parentNode.removeChild(child);

				break;

		}

	}

}

dojox.dtl.HtmlTemplate = function(/*String|dojo._Url*/ obj){

	// summary: Use this object for HTML templating

	var dd = dojox.dtl;

	var ddh = dd.html;

	if(!obj.node){

		if(typeof obj == "object"){

			obj = dojox.dtl.text.getTemplateString(obj);

		}

		obj = ddh.getTemplate(obj);

	}

	var tokens = ddh.tokenize(obj.node, [], obj.pres, obj.posts);

	var parser = new dd.HtmlParser(tokens);

	this.nodelist = parser.parse();

}

dojo.extend(dojox.dtl.HtmlTemplate, {

	_count: 0,

	_re: /\bdojo:([a-zA-Z0-9_]+)\b/g,

	setClass: function(str){

		this.getRootNode().className = str;

	},

	getRootNode: function(){

		return this.rootNode;

	},

	getBuffer: function(){

		return new dojox.dtl.HtmlBuffer();

	},

	render: function(context, buffer){

		buffer = buffer || this.getBuffer();

		this.rootNode = null;

		var onSetParent = dojo.connect(buffer, "onSetParent", this, function(node){

			if(!this.rootNode){

				this.rootNode = node || true;

			}

		});

		var output = this.nodelist.render(context || new dojox.dtl.Context({}), buffer);

		dojo.disconnect(onSetParent);

		buffer._flushCache();

		return output;

	},

	unrender: function(context, buffer){

		return this.nodelist.unrender(context, buffer);

	},

	toString: function(){ return "dojox.dtl.HtmlTemplate"; }

});

dojox.dtl.HtmlBuffer = function(/*Node*/ parent){

	// summary: Allows the manipulation of DOM

	// description:

	//		Use this to append a child, change the parent, or

	//		change the attribute of the current node.

	this._parent = parent;

	this._cache = [];

}

dojo.extend(dojox.dtl.HtmlBuffer, {

	concat: function(/*DOMNode*/ node){

		if(!this._parent) return this;

		if(node.nodeType){

			var caches = this._getCache(this._parent);

			if(node.parentNode === this._parent){

				// If we reach a node that already existed, fill in the cache for this same parent

				var i = 0;

				for(var i = 0, cache; cache = caches[i]; i++){

					this.onAddNode(node);

					this._parent.insertBefore(cache, node);

				}

				caches.length = 0;

			}

			if(!node.parentNode || !node.parentNode.tagName){

				if(!this._parent.childNodes.length){

					this.onAddNode(node);

					this._parent.appendChild(node);

				}else{

					caches.push(node);

				}

			}

		}

		return this;

	},

	remove: function(obj){

		if(typeof obj == "string"){

			this._parent.removeAttribute(obj);

		}else{

			if(obj.parentNode === this._parent){

				this.onRemoveNode();

				this._parent.removeChild(obj);

			}

		}

		return this;

	},

	setAttribute: function(key, value){

		if(key == "class"){

			this._parent.className = value;

		}else if(key == "for"){

			this._parent.htmlFor = value;

		}else if(this._parent.setAttribute){

			this._parent.setAttribute(key, value);

		}

		return this;

	},

	setParent: function(node, /*Boolean?*/ up){

		if(!this._parent) this._parent = node;

		var caches = this._getCache(this._parent);

		if(caches && caches.length && up){

			for(var i = 0, cache; cache = caches[i]; i++){

				if(cache !== this._parent && (!cache.parentNode || !cache.parentNode.tagName)){

					this.onAddNode(cache);

					this._parent.appendChild(cache);

				}

			}

			caches.length = 0;

		}

		this.onSetParent(node, up);

		this._parent = node;

		return this;

	},

	getParent: function(){

		return this._parent;

	},

	onSetParent: function(){

		// summary: Stub called when setParent is used.

	},

	onAddNode: function(){

		// summary: Stub called when new nodes are added

	},

	onRemoveNode: function(){

		// summary: Stub called when nodes are removed

	},

	_getCache: function(node){

		for(var i = 0, cache; cache = this._cache[i]; i++){

			if(cache[0] === node){

				return cache[1];

			}

		}

		var arr = [];

		this._cache.push([node, arr]);

		return arr;

	},

	_flushCache: function(node){

		for(var i = 0, cache; cache = this._cache[i]; i++){

			if(!cache[1].length){

				this._cache.splice(i--, 1);

			}

		}

	},

	toString: function(){ return "dojox.dtl.HtmlBuffer"; }

});

dojox.dtl.HtmlNode = function(node){

	// summary: Places a node into DOM

	this.contents = node;

}

dojo.extend(dojox.dtl.HtmlNode, {

	render: function(context, buffer){

		return buffer.concat(this.contents);

	},

	unrender: function(context, buffer){

		return buffer.remove(this.contents);

	},

	clone: function(buffer){

		return new dojox.dtl.HtmlNode(this.contents);

	},

	toString: function(){ return "dojox.dtl.HtmlNode"; }

});

dojox.dtl.HtmlNodeList = function(/*Node[]*/ nodes){

	// summary: A list of any HTML-specific node object

	// description:

	//		Any object that's used in the constructor or added

	//		through the push function much implement the

	//		render, unrender, and clone functions.

	this.contents = nodes || [];

}

dojo.extend(dojox.dtl.HtmlNodeList, {

	parents: new dojox.dtl.ObjectMap(),

	push: function(node){

		this.contents.push(node);

	},

	unshift: function(node){

		this.contents.unshift(node);

	},

	render: function(context, buffer, /*Node*/ instance){

		if(instance){

			var parent = buffer.getParent();

		}

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

			buffer = this.contents[i].render(context, buffer);

			if(!buffer) throw new Error("Template node render functions must return their buffer");

		}

		if(parent){

			buffer.setParent(parent, true);

		}

		return buffer;

	},

	unrender: function(context, buffer){

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

			buffer = this.contents[i].unrender(context, buffer);

			if(!buffer) throw new Error("Template node render functions must return their buffer");

		}

		return buffer;

	},

	clone: function(buffer){

		// summary:

		//		Used to create an identical copy of a NodeList, useful for things like the for tag.

		var dd = dojox.dtl;

		var ddh = dd.html;

		var parent = buffer.getParent();

		var contents = this.contents;

		var nodelist = new dd.HtmlNodeList();

		var cloned = [];

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

			var clone = contents[i].clone(buffer);

			if(clone instanceof dd.ChangeNode || clone instanceof dd.HtmlNode){

				var item = this.parents.get(clone.contents);

				if(item){

					clone.contents = item;

				}else if(parent !== clone.contents && clone instanceof dd.HtmlNode){

					var node = clone.contents;

					clone.contents = clone.contents.cloneNode(false);

					cloned.push(node);

					this.parents.put(node, clone.contents);

				}

			}

			nodelist.push(clone);

		}

		for(var i = 0, clone; clone = cloned[i]; i++){

			this.parents.put(clone);

		}

		return nodelist;

	},

	toString: function(){ return "dojox.dtl.HtmlNodeList"; }

});

dojox.dtl.HtmlVarNode = function(str){

	// summary: A node to be processed as a variable

	// description:

	//		Will render an object that supports the render function

	// 		and the getRootNode function

	this.contents = new dojox.dtl.Filter(str);

	this._lists = {};

}

dojo.extend(dojox.dtl.HtmlVarNode, {

	render: function(context, buffer){

		this._rendered = true;

		var dd = dojox.dtl;

		var ddh = dd.html;

		var str = this.contents.resolve(context);

		if(str && str.render && str.getRootNode){

			var root = this._curr = str.getRootNode();

			var lists = this._lists;

			var list = lists[root];

			if(!list){

				list = lists[root] = new dd.HtmlNodeList();

				list.push(new dd.ChangeNode(buffer.getParent()));

				list.push(new dd.HtmlNode(root));

				list.push(str);

				list.push(new dd.ChangeNode(buffer.getParent(), true));

			}

			return list.render(context, buffer);

		}else{

			if(!this._txt) this._txt = document.createTextNode(str);

			if(this._txt.data != str) this._txt.data = str;

			return buffer.concat(this._txt);

		}

		return buffer;

	},

	unrender: function(context, buffer){

		if(this._rendered){

			this._rendered = false;

			if(this._curr){

				return this._lists[this._curr].unrender(context, buffer);

			}else if(this._txt){

				return buffer.remove(this._txt);

			}

		}

		return buffer;

	},

	clone: function(){

		return new dojox.dtl.HtmlVarNode(this.contents.contents);

	},

	toString: function(){ return "dojox.dtl.HtmlVarNode"; }

});

dojox.dtl.ChangeNode = function(node, /*Boolean?*/ up){

	// summary: Changes the parent during render/unrender

	this.contents = node;

	this._up = up;

}

dojo.extend(dojox.dtl.ChangeNode, {

	render: function(context, buffer){

		return buffer.setParent(this.contents, this._up);

	},

	unrender: function(context, buffer){

		return buffer.setParent(this.contents);

	},

	clone: function(buffer){

		return new dojox.dtl.ChangeNode(this.contents, this._up);

	},

	toString: function(){ return "dojox.dtl.ChangeNode"; }

});

dojox.dtl.AttributeNode = function(key, value){

	// summary: Works on attributes

	this._key = key;

	this._value = value;

	this._tpl = new dojox.dtl.Template(value);

	this.contents = "";

}

dojo.extend(dojox.dtl.AttributeNode, {

	render: function(context, buffer){

		var key = this._key;

		var value = this._tpl.render(context);

		if(this._rendered){

			if(value != this.contents){

				this.contents = value;

				return buffer.setAttribute(key, value);

			}

		}else{

			this._rendered = true;

			this.contents = value;

			return buffer.setAttribute(key, value);

		}

		return buffer;

	},

	unrender: function(context, buffer){

		if(this._rendered){

			this._rendered = false;

			this.contents = "";

			return buffer.remove(this.contents);

		}

		return buffer;

	},

	clone: function(){

		return new dojox.dtl.AttributeNode(this._key, this._value);

	},

	toString: function(){ return "dojox.dtl.AttributeNode"; }

});

dojox.dtl.HtmlTextNode = function(str){

	// summary: Adds a straight text node without any processing

	this.contents = document.createTextNode(str);

}

dojo.extend(dojox.dtl.HtmlTextNode, {

	render: function(context, buffer){

		return buffer.concat(this.contents);

	},

	unrender: function(context, buffer){

		return buffer.remove(this.contents);

	},

	clone: function(){

		return new dojox.dtl.HtmlTextNode(this.contents.data);

	},

	toString: function(){ return "dojox.dtl.HtmlTextNode"; }

});

dojox.dtl.HtmlParser = function(tokens){

	// summary: Turn a simple array into a set of objects

	// description:

	//	This is also used by all tags to move through

	//	the list of nodes.

	this.contents = tokens;

}

dojo.extend(dojox.dtl.HtmlParser, {

	parse: function(/*Array?*/ stop_at){

		var dd = dojox.dtl;

		var ddh = dd.html;

		var types = ddh.types;

		var terminators = {};

		var tokens = this.contents;

		if(!stop_at){

			stop_at = [];

		}

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

			terminators[stop_at[i]] = true;

		}

		var nodelist = new dd.HtmlNodeList();

		while(tokens.length){

			var token = tokens.shift();

			var type = token[0];

			var value = token[1];

			if(type == types.change){

				nodelist.push(new dd.ChangeNode(value, token[2]));

			}else if(type == types.attr){

				var fn = dojox.dtl.text.getTag("attr:" + token[2], true);

				if(fn){

					nodelist.push(fn(null, token[2] + " " + token[3]));

				}else{

					nodelist.push(new dd.AttributeNode(token[2], token[3]));

				}

			}else if(type == types.elem){

				var fn = dojox.dtl.text.getTag("node:" + value.tagName.toLowerCase(), true);

				if(fn){

					// TODO: We need to move this to tokenization so that it's before the

					// 				node and the parser can be passed here instead of null

					nodelist.push(fn(null, value, value.tagName.toLowerCase()));

				}

				nodelist.push(new dd.HtmlNode(value));

			}else if(type == types.varr){

				nodelist.push(new dd.HtmlVarNode(value));

			}else if(type == types.text){

				nodelist.push(new dd.HtmlTextNode(value.data || value));

			}else if(type == types.tag){

				if(terminators[value]){

					tokens.unshift(token);

					return nodelist;

				}

				var cmd = value.split(/\s+/g);

				if(cmd.length){

					cmd = cmd[0];

					var fn = dojox.dtl.text.getTag(cmd);

					if(typeof fn != "function"){

						throw new Error("Function not found for ", cmd);

					}

					var tpl = fn(this, value);

					if(tpl){

						nodelist.push(tpl);

					}

				}

			}

		}

		if(stop_at.length){

			throw new Error("Could not find closing tag(s): " + stop_at.toString());

		}

		return nodelist;

	},

	next: function(){

		// summary: Used by tags to discover what token was found

		var token = this.contents.shift();

		return {type: token[0], text: token[1]};

	},

	skipPast: function(endtag){

		return dojox.dtl.Parser.prototype.skipPast.call(this, endtag);

	},

	getVarNode: function(){

		return dojox.dtl.HtmlVarNode;

	},

	getTextNode: function(){

		return dojox.dtl.HtmlTextNode;

	},

	getTemplate: function(/*String*/ loc){

		return new dojox.dtl.HtmlTemplate(dojox.dtl.html.getTemplate(loc));

	},

	toString: function(){ return "dojox.dtl.HtmlParser"; }

});

dojox.dtl.register.tag("dojox.dtl.tag.event", "dojox.dtl.tag.event", [[/(attr:)?on(click|key(up))/i, "on"]]);

dojox.dtl.register.tag("dojox.dtl.tag.html", "dojox.dtl.tag.html", ["html", "attr:attach", "attr:tstyle"]);

}