Subversion Repositories Applications.papyrus

Compare Revisions

Ignore whitespace Rev 2149 → Rev 2150

/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, '&lt;$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
})
 
}