diff options
Diffstat (limited to 'includes/js/dojox/dtl/tag/loader.js')
-rw-r--r-- | includes/js/dojox/dtl/tag/loader.js | 277 |
1 files changed, 277 insertions, 0 deletions
diff --git a/includes/js/dojox/dtl/tag/loader.js b/includes/js/dojox/dtl/tag/loader.js new file mode 100644 index 0000000..36c81bc --- /dev/null +++ b/includes/js/dojox/dtl/tag/loader.js @@ -0,0 +1,277 @@ +if(!dojo._hasResource["dojox.dtl.tag.loader"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. +dojo._hasResource["dojox.dtl.tag.loader"] = true; +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){ + if(!this.parent){ + this.parent = context.get(this.key, false); + if(!this.parent){ + throw new Error("extends tag used a variable that did not resolve"); + } + if(typeof this.parent == "object"){ + if(this.parent.url){ + if(this.parent.shared){ + this.shared = true; + } + this.parent = this.parent.url.toString(); + }else{ + this.parent = this.parent.toString(); + } + } + if(this.parent && this.parent.indexOf("shared:") == 0){ + this.shared = true; + this.parent = this.parent.substring(7, parent.length); + } + } + var parent = this.parent; + 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(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; + } + }); +})(); + +} |