/trunk/api/js/dojo1.0/dojox/dtl/tag/loader.js |
---|
New file |
0,0 → 1,146 |
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"); |
dojox.dtl.tag.loader.BlockNode = function(name, nodelist){ |
this.name = name; |
this.nodelist = nodelist; // Can be overridden |
} |
dojo.extend(dojox.dtl.tag.loader.BlockNode, { |
render: function(context, buffer){ |
if(this.override){ |
buffer = this.override.render(context, buffer, this); |
this.rendered = this.override; |
}else{ |
buffer = this.nodelist.render(context, buffer, this); |
this.rendered = this.nodelist; |
} |
this.override = null; |
return buffer; |
}, |
unrender: function(context, buffer){ |
return this.rendered.unrender(context, 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"; } |
}); |
dojox.dtl.tag.loader.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); |
} |
dojox.dtl.tag.loader.ExtendsNode = function(getTemplate, nodelist, shared, parent, key){ |
this.getTemplate = getTemplate; |
this.nodelist = nodelist; |
this.shared = shared; |
this.parent = parent; |
this.key = key; |
} |
dojo.extend(dojox.dtl.tag.loader.ExtendsNode, { |
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 st = dojox.dtl; |
var stbl = dojox.dtl.tag.loader; |
var parent = this.getParent(context); |
var isChild = parent.nodelist[0] instanceof this.constructor; |
var parentBlocks = {}; |
for(var i = 0, node; node = parent.nodelist.contents[i]; i++){ |
if(node instanceof stbl.BlockNode){ |
parentBlocks[node.name] = node; |
} |
} |
for(var i = 0, node; node = this.nodelist.contents[i]; i++){ |
if(node instanceof stbl.BlockNode){ |
var block = parentBlocks[node.name]; |
if(!block){ |
if(isChild){ |
parent.nodelist[0].nodelist.append(node); |
} |
}else{ |
if(this.shared){ |
block.setOverride(node.nodelist); |
}else{ |
block.nodelist = node.nodelist; |
} |
} |
} |
} |
this.rendered = parent; |
return parent.render(context, buffer, this); |
}, |
unrender: function(context, buffer){ |
return this.rendered.unrender(context, buffer, this); |
}, |
toString: function(){ return "dojox.dtl.block.ExtendsNode"; } |
}); |
dojox.dtl.tag.loader.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); |
} |
} |
/trunk/api/js/dojo1.0/dojox/dtl/tag/loop.js |
---|
New file |
0,0 → 1,89 |
if(!dojo._hasResource["dojox.dtl.tag.loop"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. |
dojo._hasResource["dojox.dtl.tag.loop"] = true; |
dojo.provide("dojox.dtl.tag.loop"); |
dojo.require("dojox.dtl._base"); |
dojox.dtl.tag.loop.CycleNode = function(cyclevars, name, VarNode){ |
this._cyclevars = cyclevars; |
this._counter = -1 |
this._name = name; |
this._map = {}; |
this._VarNode = VarNode; |
} |
dojo.extend(dojox.dtl.tag.loop.CycleNode, { |
render: function(context, buffer){ |
if(context.forloop && !context.forloop.counter0){ |
this._counter = -1; |
} |
++this._counter; |
var value = this._cyclevars[this._counter % this._cyclevars.length]; |
if(this._name){ |
context[this._name] = value; |
} |
if(!this._map[value]){ |
this._map[value] = {}; |
} |
var node = this._map[value][this._counter] = new this._VarNode(value); |
return node.render(context, buffer, this); |
}, |
unrender: function(context, buffer){ |
return buffer; |
}, |
clone: function(){ |
return new this.constructor(this._cyclevars, this._name); |
}, |
_onEnd: function(){ |
this._counter = -1; |
}, |
toString: function(){ return "dojox.dtl.tag.loop.CycleNode"; } |
}); |
dojox.dtl.tag.loop.cycle = function(parser, text){ |
// summary: Cycle among the given strings each time this tag is encountered |
var args = text.split(" "); |
if(args.length < 2){ |
throw new Error("'cycle' tag requires at least two arguments"); |
} |
if(args[1].indexOf(",") != -1){ |
var vars = args[1].split(","); |
args = [args[0]]; |
for(var i = 0; i < vars.length; i++){ |
args.push('"' + vars[i] + '"'); |
} |
} |
if(args.length == 2){ |
var name = args[args.length - 1]; |
if(!parser._namedCycleNodes){ |
throw new Error("No named cycles in template: '" + name + "' is not defined"); |
} |
if(!parser._namedCycleNodes[name]){ |
throw new Error("Named cycle '" + name + "' does not exist"); |
} |
return parser._namedCycleNodes[name]; |
} |
if(args.length > 4 && args[args.length - 2] == "as"){ |
var name = args[args.length - 1]; |
var node = new dojox.dtl.tag.loop.CycleNode(args.slice(1, args.length - 2), name, parser.getVarNode()); |
if(!parser._namedCycleNodes){ |
parser._namedCycleNodes = {}; |
} |
parser._namedCycleNodes[name] = node; |
}else{ |
node = new dojox.dtl.tag.loop.CycleNode(args.slice(1), null, parser.getVarNode()); |
} |
return node; |
} |
} |
/trunk/api/js/dojo1.0/dojox/dtl/tag/misc.js |
---|
New file |
0,0 → 1,76 |
if(!dojo._hasResource["dojox.dtl.tag.misc"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. |
dojo._hasResource["dojox.dtl.tag.misc"] = true; |
dojo.provide("dojox.dtl.tag.misc"); |
dojo.require("dojox.dtl._base"); |
dojox.dtl.tag.misc.commentNode = new function(){ |
this.render = this.unrender = function(context, buffer){ return buffer; }; |
this.clone = function(){ return this; }; |
this.toString = function(){ return "dojox.dtl.tag.misc.CommentNode"; }; |
} |
dojox.dtl.tag.misc.DebugNode = function(TextNode){ |
this._TextNode = TextNode; |
} |
dojo.extend(dojox.dtl.tag.misc.DebugNode, { |
render: function(context, buffer){ |
var keys = context.getKeys(); |
var debug = ""; |
for(var i = 0, key; key = keys[i]; i++){ |
console.debug("DEBUG", key, ":", context[key]); |
debug += key + ": " + dojo.toJson(context[key]) + "\n\n"; |
} |
return new this._TextNode(debug).render(context, buffer, this); |
}, |
unrender: function(context, buffer){ |
return buffer; |
}, |
clone: function(buffer){ |
return new this.constructor(this._TextNode); |
}, |
toString: function(){ return "dojox.dtl.tag.misc.DebugNode"; } |
}); |
dojox.dtl.tag.misc.FilterNode = function(varnode, nodelist){ |
this._varnode = varnode; |
this._nodelist = nodelist; |
} |
dojo.extend(dojox.dtl.tag.misc.FilterNode, { |
render: function(context, buffer){ |
// Doing this in HTML requires a different buffer with a fake root node |
var output = this._nodelist.render(context, new dojox.string.Builder()); |
context.update({ "var": output.toString() }); |
var filtered = this._varnode.render(context, buffer); |
context.pop(); |
return buffer; |
}, |
unrender: function(context, buffer){ |
return buffer; |
}, |
clone: function(buffer){ |
return new this.constructor(this._expression, this._nodelist.clone(buffer)); |
} |
}); |
dojox.dtl.tag.misc.comment = function(parser, text){ |
// summary: Ignore everything between {% comment %} and {% endcomment %} |
parser.skipPast("endcomment"); |
return dojox.dtl.tag.misc.commentNode; |
} |
dojox.dtl.tag.misc.debug = function(parser, text){ |
// summary: Output the current context, maybe add more stuff later. |
return new dojox.dtl.tag.misc.DebugNode(parser.getTextNode()); |
} |
dojox.dtl.tag.misc.filter = function(parser, text){ |
// summary: Filter the contents of the blog through variable filters. |
var parts = text.split(" ", 2); |
var varnode = new (parser.getVarNode())("var|" + parts[1]); |
var nodelist = parser.parse(["endfilter"]); |
parser.next(); |
return new dojox.dtl.tag.misc.FilterNode(varnode, nodelist); |
} |
} |
/trunk/api/js/dojo1.0/dojox/dtl/tag/logic.js |
---|
New file |
0,0 → 1,164 |
if(!dojo._hasResource["dojox.dtl.tag.logic"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. |
dojo._hasResource["dojox.dtl.tag.logic"] = true; |
dojo.provide("dojox.dtl.tag.logic"); |
dojo.require("dojox.dtl._base"); |
dojox.dtl.tag.logic.IfNode = function(bools, trues, falses, type){ |
this.bools = bools; |
this.trues = trues; |
this.falses = falses; |
this.type = type; |
} |
dojo.extend(dojox.dtl.tag.logic.IfNode, { |
render: function(context, buffer){ |
if(this.type == "or"){ |
for(var i = 0, bool; bool = this.bools[i]; i++){ |
var ifnot = bool[0]; |
var filter = bool[1]; |
var value = filter.resolve(context); |
if((value && !ifnot) || (ifnot && !value)){ |
if(this.falses){ |
buffer = this.falses.unrender(context, buffer); |
} |
return this.trues.render(context, buffer, this); |
} |
buffer = this.trues.unrender(context, buffer); |
if(this.falses) return this.falses.render(context, buffer, this); |
} |
}else{ |
for(var i = 0, bool; bool = this.bools[i]; i++){ |
var ifnot = bool[0]; |
var filter = bool[1]; |
var value = filter.resolve(context); |
if(!((value && !ifnot) || (ifnot && !value))){ |
if(this.trues){ |
buffer = this.trues.unrender(context, buffer); |
} |
return this.falses.render(context, buffer, this); |
} |
buffer = this.falses.unrender(context, buffer); |
if(this.falses) return this.trues.render(context, buffer, this); |
} |
} |
return buffer; |
}, |
unrender: function(context, buffer){ |
if(this.trues) buffer = this.trues.unrender(context, buffer); |
if(this.falses) buffer = this.falses.unrender(context, buffer); |
return buffer; |
}, |
clone: function(buffer){ |
var trues = this.trues; |
var falses = this.falses; |
if(trues){ |
trues = trues.clone(buffer); |
} |
if(falses){ |
falses = falses.clone(buffer); |
} |
return new this.constructor(this.bools, trues, falses, this.type); |
}, |
toString: function(){ return "dojox.dtl.tag.logic.IfNode"; } |
}); |
dojox.dtl.tag.logic.ForNode = function(assign, loop, reversed, nodelist){ |
this.assign = assign; |
this.loop = loop; |
this.reversed = reversed; |
this.nodelist = nodelist; |
this.pool = []; |
} |
dojo.extend(dojox.dtl.tag.logic.ForNode, { |
render: function(context, buffer){ |
var parentloop = {}; |
if(context.forloop){ |
parentloop = context.forloop; |
} |
var items = dojox.dtl.resolveVariable(this.loop, context); |
context.push(); |
for(var i = items.length; i < this.pool.length; i++){ |
this.pool[i].unrender(context, buffer); |
} |
if(this.reversed){ |
items = items.reversed(); |
} |
var j = 0; |
for(var i in items){ |
var item = items[i]; |
context.forloop = { |
key: i, |
counter0: j, |
counter: j + 1, |
revcounter0: items.length - j - 1, |
revcounter: items.length - j, |
first: j == 0, |
parentloop: parentloop |
}; |
context[this.assign] = item; |
if(j + 1 > this.pool.length){ |
this.pool.push(this.nodelist.clone(buffer)); |
} |
buffer = this.pool[j].render(context, buffer, this); |
++j; |
} |
context.pop(); |
return buffer; |
}, |
unrender: function(context, buffer){ |
for(var i = 0, pool; pool = this.pool[i]; i++){ |
buffer = pool.unrender(context, buffer); |
} |
return buffer; |
}, |
clone: function(buffer){ |
return new this.constructor(this.assign, this.loop, this.reversed, this.nodelist.clone(buffer)); |
}, |
toString: function(){ return "dojox.dtl.tag.logic.ForNode"; } |
}); |
dojox.dtl.tag.logic.if_ = function(parser, text){ |
var parts = text.split(/\s+/g); |
var type; |
var bools = []; |
parts.shift(); |
text = parts.join(" "); |
parts = text.split(" and "); |
if(parts.length == 1){ |
type = "or"; |
parts = text.split(" or "); |
}else{ |
type = "and"; |
for(var i = 0; i < parts.length; i++){ |
if(parts[i] == "or"){ |
throw new Error("'if' tags can't mix 'and' and 'or'"); |
} |
} |
} |
for(var i = 0, part; part = parts[i]; i++){ |
var not = false; |
if(part.indexOf("not ") == 0){ |
part = part.substring(4); |
not = true; |
} |
bools.push([not, new dojox.dtl.Filter(part)]); |
} |
var trues = parser.parse(["else", "endif"]); |
var falses = false; |
var token = parser.next(); |
if(token.text == "else"){ |
var falses = parser.parse(["endif"]); |
parser.next(); |
} |
return new dojox.dtl.tag.logic.IfNode(bools, trues, falses, type); |
} |
dojox.dtl.tag.logic.for_ = function(parser, text){ |
var parts = text.split(/\s+/g); |
var reversed = parts.length == 5; |
var nodelist = parser.parse(["endfor"]); |
parser.next(); |
return new dojox.dtl.tag.logic.ForNode(parts[1], parts[3], reversed, nodelist); |
} |
} |
/trunk/api/js/dojo1.0/dojox/dtl/tag/event.js |
---|
New file |
0,0 → 1,42 |
if(!dojo._hasResource["dojox.dtl.tag.event"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. |
dojo._hasResource["dojox.dtl.tag.event"] = true; |
dojo.provide("dojox.dtl.tag.event"); |
dojo.require("dojox.dtl._base"); |
dojox.dtl.tag.event.EventNode = function(type, fn){ |
this._type = type; |
this.contents = fn; |
} |
dojo.extend(dojox.dtl.tag.event.EventNode, { |
render: function(context, buffer){ |
if(!this._clear){ |
buffer.getParent()[this._type] = null; |
this._clear = true; |
} |
if(this.contents && !this._rendered){ |
if(!context.getThis()) throw new Error("You must use Context.setObject(instance)"); |
this._rendered = dojo.connect(buffer.getParent(), this._type, context.getThis(), this.contents); |
} |
return buffer; |
}, |
unrender: function(context, buffer){ |
if(this._rendered){ |
dojo.disconnect(this._rendered); |
this._rendered = false; |
} |
return buffer; |
}, |
clone: function(){ |
return new dojox.dtl.tag.event.EventNode(this._type, this.contents); |
}, |
toString: function(){ return "dojox.dtl.tag.event." + this._type; } |
}); |
dojox.dtl.tag.event.on = function(parser, text){ |
// summary: Associates an event type to a function (on the current widget) by name |
var parts = text.split(" "); |
return new dojox.dtl.tag.event.EventNode(parts[0], parts[1]); |
} |
} |
/trunk/api/js/dojo1.0/dojox/dtl/tag/html.js |
---|
New file |
0,0 → 1,136 |
if(!dojo._hasResource["dojox.dtl.tag.html"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. |
dojo._hasResource["dojox.dtl.tag.html"] = true; |
dojo.provide("dojox.dtl.tag.html"); |
dojo.require("dojox.dtl._base"); |
dojox.dtl.tag.html.HtmlNode = function(name){ |
this.contents = new dojox.dtl.Filter(name); |
this._div = document.createElement("div"); |
this._lasts = []; |
} |
dojo.extend(dojox.dtl.tag.html.HtmlNode, { |
render: function(context, buffer){ |
var text = this.contents.resolve(context); |
text = text.replace(/<(\/?script)/ig, '<$1').replace(/\bon[a-z]+\s*=/ig, ''); |
if(this._rendered && this._last != text){ |
buffer = this.unrender(context, buffer); |
} |
this._last = text; |
// This can get reset in the above tag |
if(!this._rendered){ |
this._rendered = true; |
var div = this._div; |
div.innerHTML = text; |
var children = div.childNodes; |
while(children.length){ |
var removed = div.removeChild(children[0]); |
this._lasts.push(removed); |
buffer = buffer.concat(removed); |
} |
} |
return buffer; |
}, |
unrender: function(context, buffer){ |
if(this._rendered){ |
this._rendered = false; |
this._last = ""; |
for(var i = 0, node; node = this._lasts[i++];){ |
buffer = buffer.remove(node); |
dojo._destroyElement(node); |
} |
this._lasts = []; |
} |
return buffer; |
}, |
clone: function(buffer){ |
return new dojox.dtl.tag.html.HtmlNode(this.contents.contents); |
}, |
toString: function(){ return "dojox.dtl.tag.html.HtmlNode"; } |
}); |
dojox.dtl.tag.html.StyleNode = function(styles){ |
this.contents = {}; |
this._styles = styles; |
for(var key in styles){ |
this.contents[key] = new dojox.dtl.Template(styles[key]); |
} |
} |
dojo.extend(dojox.dtl.tag.html.StyleNode, { |
render: function(context, buffer){ |
for(var key in this.contents){ |
dojo.style(buffer.getParent(), key, this.contents[key].render(context)); |
} |
return buffer; |
}, |
unrender: function(context, buffer){ |
return buffer; |
}, |
clone: function(buffer){ |
return new dojox.dtl.tag.html.HtmlNode(this._styles); |
}, |
toString: function(){ return "dojox.dtl.tag.html.StyleNode"; } |
}); |
dojox.dtl.tag.html.AttachNode = function(key){ |
this.contents = key; |
} |
dojo.extend(dojox.dtl.tag.html.AttachNode, { |
render: function(context, buffer){ |
if(!this._rendered){ |
this._rendered = true; |
context.getThis()[this.contents] = buffer.getParent(); |
} |
return buffer; |
}, |
unrender: function(context, buffer){ |
if(this._rendered){ |
this._rendered = false; |
if(context.getThis()[this.contents] === buffer.getParent()){ |
delete context.getThis()[this.contents]; |
} |
} |
return buffer; |
}, |
clone: function(buffer){ |
return new dojox.dtl.tag.html.HtmlNode(this._styles); |
}, |
toString: function(){ return "dojox.dtl.tag.html.AttachNode"; } |
}); |
dojox.dtl.tag.html.html = function(parser, text){ |
var parts = text.split(" ", 2); |
return new dojox.dtl.tag.html.HtmlNode(parts[1]); |
} |
dojox.dtl.tag.html.tstyle = function(parser, text){ |
var styles = {}; |
text = text.replace(dojox.dtl.tag.html.tstyle._re, ""); |
var rules = text.split(dojox.dtl.tag.html.tstyle._re1); |
for(var i = 0, rule; rule = rules[i]; i++){ |
var parts = rule.split(dojox.dtl.tag.html.tstyle._re2); |
var key = parts[0]; |
var value = parts[1]; |
if(value.indexOf("{{") == 0){ |
styles[key] = value; |
} |
} |
return new dojox.dtl.tag.html.StyleNode(styles); |
} |
dojo.mixin(dojox.dtl.tag.html.tstyle, { |
_re: /^tstyle\s+/, |
_re1: /\s*;\s*/g, |
_re2: /\s*:\s*/g |
}); |
dojox.dtl.tag.html.attach = function(parser, text){ |
var parts = text.split(dojox.dtl.tag.html.attach._re); |
return new dojox.dtl.tag.html.AttachNode(parts[1]); |
} |
dojo.mixin(dojox.dtl.tag.html.attach, { |
_re: /\s+/g |
}) |
} |