- Author:
- David Nickerson <nickerso@users.sourceforge.net>
- Date:
- 2009-07-07 17:11:57+12:00
- Desc:
- update for modified HH graphs in tutorial description
- Permanent Source URI:
- https://models.physiomeproject.org/workspace/a1/rawfile/98909b01e6b21653a5e1cd28865dd259c586d490/dojo-presentation/js/dojo/dojox/dtl/tag/loader.js
dojo.provide("dojox.dtl.tag.loader");
dojo.require("dojox.dtl._base");
(function(){
var dd = dojox.dtl;
var ddtl = dd.tag.loader;
ddtl.BlockNode = dojo.extend(function(name, nodelist){
this.name = name;
this.nodelist = nodelist; // Can be overridden
},
{
render: function(context, buffer){
var name = this.name;
var nodelist = this.nodelist;
if(buffer.blocks){
var block = buffer.blocks[name];
if(block){
nodelist = block.nodelist;
block.used = true;
}
}
this.rendered = nodelist;
return nodelist.render(context, buffer, this);
},
unrender: function(context, buffer){
return this.rendered.unrender(context, buffer);
},
clone: function(buffer){
return new this.constructor(this.name, this.nodelist.clone(buffer));
},
setOverride: function(nodelist){
// summary: In a shared parent, we override, not overwrite
if(!this.override){
this.override = nodelist;
}
},
toString: function(){ return "dojox.dtl.tag.loader.BlockNode"; }
});
ddtl.ExtendsNode = dojo.extend(function(getTemplate, nodelist, shared, parent, key){
this.getTemplate = getTemplate;
this.nodelist = nodelist;
this.shared = shared;
this.parent = parent;
this.key = key;
},
{
parents: {},
getParent: function(context){
var parent = this.parent;
if(!parent){
var string;
parent = this.parent = context.get(this.key, false);
if(!parent){
throw new Error("extends tag used a variable that did not resolve");
}
if(typeof parent == "object"){
var url = parent.url || parent.templatePath;
if(parent.shared){
this.shared = true;
}
if(url){
parent = this.parent = url.toString();
}else if(parent.templateString){
string = parent.templateString;
parent = this.parent = " ";
}else{
parent = this.parent = this.parent.toString();
}
}
if(parent && parent.indexOf("shared:") == 0){
this.shared = true;
parent = this.parent = parent.substring(7, parent.length);
}
}
if(!parent){
throw new Error("Invalid template name in 'extends' tag.");
}
if(parent.render){
return parent;
}
if(this.parents[parent]){
return this.parents[parent];
}
this.parent = this.getTemplate(string || dojox.dtl.text.getTemplateString(parent));
if(this.shared){
this.parents[parent] = this.parent;
}
return this.parent;
},
render: function(context, buffer){
var parent = this.getParent(context);
buffer.blocks = buffer.blocks || {};
// The parent won't always be in the default parent's nodelist
for(var i = 0, node; node = this.nodelist.contents[i]; i++){
if(node instanceof dojox.dtl.tag.loader.BlockNode){
buffer.blocks[node.name] = {
shared: this.shared,
nodelist: node.nodelist,
used: false
}
}
}
this.rendered = parent;
buffer = parent.nodelist.render(context, buffer, this);
var rerender = false;
for(var name in buffer.blocks){
var block = buffer.blocks[name];
if(!block.used){
rerender = true;
parent.nodelist[0].nodelist.append(block.nodelist);
}
}
if(rerender){
buffer = parent.nodelist.render(context, buffer, this);
}
return buffer;
},
unrender: function(context, buffer){
return this.rendered.unrender(context, buffer, this);
},
toString: function(){ return "dojox.dtl.block.ExtendsNode"; }
});
ddtl.IncludeNode = dojo.extend(function(path, constant, getTemplate, TextNode, parsed){
this._path = path;
this.constant = constant;
this.path = (constant) ? path : new dd._Filter(path);
this.getTemplate = getTemplate;
this.TextNode = TextNode;
this.parsed = (arguments.length == 5) ? parsed : true;
},
{
_cache: [{}, {}],
render: function(context, buffer){
var location = ((this.constant) ? this.path : this.path.resolve(context)).toString();
var parsed = Number(this.parsed);
var dirty = false;
if(location != this.last){
dirty = true;
if(this.last){
buffer = this.unrender(context, buffer);
}
this.last = location;
}
var cache = this._cache[parsed];
if(parsed){
if(!cache[location]){
cache[location] = dd.text._resolveTemplateArg(location, true);
}
if(dirty){
var template = this.getTemplate(cache[location]);
this.rendered = template.nodelist;
}
return this.rendered.render(context, buffer, this);
}else{
if(this.TextNode == dd._TextNode){
if(dirty){
this.rendered = new this.TextNode("");
this.rendered.set(dd.text._resolveTemplateArg(location, true));
}
return this.rendered.render(context, buffer);
}else{
if(!cache[location]){
var nodelist = [];
var div = document.createElement("div");
div.innerHTML = dd.text._resolveTemplateArg(location, true);
var children = div.childNodes;
while(children.length){
var removed = div.removeChild(children[0]);
nodelist.push(removed);
}
cache[location] = nodelist;
}
if(dirty){
this.nodelist = [];
var exists = true;
for(var i = 0, child; child = cache[location][i]; i++){
this.nodelist.push(child.cloneNode(true));
}
}
for(var i = 0, node; node = this.nodelist[i]; i++){
buffer = buffer.concat(node);
}
}
}
return buffer;
},
unrender: function(context, buffer){
if(this.rendered){
buffer = this.rendered.unrender(context, buffer);
}
if(this.nodelist){
for(var i = 0, node; node = this.nodelist[i]; i++){
buffer = buffer.remove(node);
}
}
return buffer;
},
clone: function(buffer){
return new this.constructor(this._path, this.constant, this.getTemplate, this.TextNode, this.parsed);
}
});
dojo.mixin(ddtl, {
block: function(parser, text){
var parts = text.split(" ");
var name = parts[1];
parser._blocks = parser._blocks || {};
parser._blocks[name] = parser._blocks[name] || [];
parser._blocks[name].push(name);
var nodelist = parser.parse(["endblock", "endblock " + name]);
parser.next();
return new dojox.dtl.tag.loader.BlockNode(name, nodelist);
},
extends_: function(parser, text){
var parts = text.split(" ");
var shared = false;
var parent = null;
var key = null;
if(parts[1].charAt(0) == '"' || parts[1].charAt(0) == "'"){
parent = parts[1].substring(1, parts[1].length - 1);
}else{
key = parts[1];
}
if(parent && parent.indexOf("shared:") == 0){
shared = true;
parent = parent.substring(7, parent.length);
}
var nodelist = parser.parse();
return new dojox.dtl.tag.loader.ExtendsNode(parser.getTemplate, nodelist, shared, parent, key);
},
include: function(parser, token){
var parts = dd.text.pySplit(token);
if(parts.length != 2){
throw new Error(parts[0] + " tag takes one argument: the name of the template to be included");
}
var path = parts[1];
var constant = false;
if((path.charAt(0) == '"' || path.slice(-1) == "'") && path.charAt(0) == path.slice(-1)){
path = path.slice(1, -1);
constant = true;
}
return new ddtl.IncludeNode(path, constant, parser.getTemplate, parser.getTextNodeConstructor());
},
ssi: function(parser, token){
// We're going to treat things a little differently here.
// First of all, this tag is *not* portable, so I'm not
// concerned about it being a "drop in" replacement.
// Instead, we'll just replicate the include tag, but with that
// optional "parsed" parameter.
var parts = dd.text.pySplit(token);
var parsed = false;
if(parts.length == 3){
parsed = (parts.pop() == "parsed");
if(!parsed){
throw new Error("Second (optional) argument to ssi tag must be 'parsed'");
}
}
var node = ddtl.include(parser, parts.join(" "));
node.parsed = parsed;
return node;
}
});
})();