| 2150 |
mathias |
1 |
if(!dojo._hasResource["dojox.dtl.tag.logic"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
|
|
|
2 |
dojo._hasResource["dojox.dtl.tag.logic"] = true;
|
|
|
3 |
dojo.provide("dojox.dtl.tag.logic");
|
|
|
4 |
|
|
|
5 |
dojo.require("dojox.dtl._base");
|
|
|
6 |
|
|
|
7 |
dojox.dtl.tag.logic.IfNode = function(bools, trues, falses, type){
|
|
|
8 |
this.bools = bools;
|
|
|
9 |
this.trues = trues;
|
|
|
10 |
this.falses = falses;
|
|
|
11 |
this.type = type;
|
|
|
12 |
}
|
|
|
13 |
dojo.extend(dojox.dtl.tag.logic.IfNode, {
|
|
|
14 |
render: function(context, buffer){
|
|
|
15 |
if(this.type == "or"){
|
|
|
16 |
for(var i = 0, bool; bool = this.bools[i]; i++){
|
|
|
17 |
var ifnot = bool[0];
|
|
|
18 |
var filter = bool[1];
|
|
|
19 |
var value = filter.resolve(context);
|
|
|
20 |
if((value && !ifnot) || (ifnot && !value)){
|
|
|
21 |
if(this.falses){
|
|
|
22 |
buffer = this.falses.unrender(context, buffer);
|
|
|
23 |
}
|
|
|
24 |
return this.trues.render(context, buffer, this);
|
|
|
25 |
}
|
|
|
26 |
buffer = this.trues.unrender(context, buffer);
|
|
|
27 |
if(this.falses) return this.falses.render(context, buffer, this);
|
|
|
28 |
}
|
|
|
29 |
}else{
|
|
|
30 |
for(var i = 0, bool; bool = this.bools[i]; i++){
|
|
|
31 |
var ifnot = bool[0];
|
|
|
32 |
var filter = bool[1];
|
|
|
33 |
var value = filter.resolve(context);
|
|
|
34 |
if(!((value && !ifnot) || (ifnot && !value))){
|
|
|
35 |
if(this.trues){
|
|
|
36 |
buffer = this.trues.unrender(context, buffer);
|
|
|
37 |
}
|
|
|
38 |
return this.falses.render(context, buffer, this);
|
|
|
39 |
}
|
|
|
40 |
buffer = this.falses.unrender(context, buffer);
|
|
|
41 |
if(this.falses) return this.trues.render(context, buffer, this);
|
|
|
42 |
}
|
|
|
43 |
}
|
|
|
44 |
return buffer;
|
|
|
45 |
},
|
|
|
46 |
unrender: function(context, buffer){
|
|
|
47 |
if(this.trues) buffer = this.trues.unrender(context, buffer);
|
|
|
48 |
if(this.falses) buffer = this.falses.unrender(context, buffer);
|
|
|
49 |
return buffer;
|
|
|
50 |
},
|
|
|
51 |
clone: function(buffer){
|
|
|
52 |
var trues = this.trues;
|
|
|
53 |
var falses = this.falses;
|
|
|
54 |
if(trues){
|
|
|
55 |
trues = trues.clone(buffer);
|
|
|
56 |
}
|
|
|
57 |
if(falses){
|
|
|
58 |
falses = falses.clone(buffer);
|
|
|
59 |
}
|
|
|
60 |
return new this.constructor(this.bools, trues, falses, this.type);
|
|
|
61 |
},
|
|
|
62 |
toString: function(){ return "dojox.dtl.tag.logic.IfNode"; }
|
|
|
63 |
});
|
|
|
64 |
|
|
|
65 |
dojox.dtl.tag.logic.ForNode = function(assign, loop, reversed, nodelist){
|
|
|
66 |
this.assign = assign;
|
|
|
67 |
this.loop = loop;
|
|
|
68 |
this.reversed = reversed;
|
|
|
69 |
this.nodelist = nodelist;
|
|
|
70 |
this.pool = [];
|
|
|
71 |
}
|
|
|
72 |
dojo.extend(dojox.dtl.tag.logic.ForNode, {
|
|
|
73 |
render: function(context, buffer){
|
|
|
74 |
var parentloop = {};
|
|
|
75 |
if(context.forloop){
|
|
|
76 |
parentloop = context.forloop;
|
|
|
77 |
}
|
|
|
78 |
var items = dojox.dtl.resolveVariable(this.loop, context);
|
|
|
79 |
context.push();
|
|
|
80 |
for(var i = items.length; i < this.pool.length; i++){
|
|
|
81 |
this.pool[i].unrender(context, buffer);
|
|
|
82 |
}
|
|
|
83 |
if(this.reversed){
|
|
|
84 |
items = items.reversed();
|
|
|
85 |
}
|
|
|
86 |
var j = 0;
|
|
|
87 |
for(var i in items){
|
|
|
88 |
var item = items[i];
|
|
|
89 |
context.forloop = {
|
|
|
90 |
key: i,
|
|
|
91 |
counter0: j,
|
|
|
92 |
counter: j + 1,
|
|
|
93 |
revcounter0: items.length - j - 1,
|
|
|
94 |
revcounter: items.length - j,
|
|
|
95 |
first: j == 0,
|
|
|
96 |
parentloop: parentloop
|
|
|
97 |
};
|
|
|
98 |
context[this.assign] = item;
|
|
|
99 |
if(j + 1 > this.pool.length){
|
|
|
100 |
this.pool.push(this.nodelist.clone(buffer));
|
|
|
101 |
}
|
|
|
102 |
buffer = this.pool[j].render(context, buffer, this);
|
|
|
103 |
++j;
|
|
|
104 |
}
|
|
|
105 |
context.pop();
|
|
|
106 |
return buffer;
|
|
|
107 |
},
|
|
|
108 |
unrender: function(context, buffer){
|
|
|
109 |
for(var i = 0, pool; pool = this.pool[i]; i++){
|
|
|
110 |
buffer = pool.unrender(context, buffer);
|
|
|
111 |
}
|
|
|
112 |
return buffer;
|
|
|
113 |
},
|
|
|
114 |
clone: function(buffer){
|
|
|
115 |
return new this.constructor(this.assign, this.loop, this.reversed, this.nodelist.clone(buffer));
|
|
|
116 |
},
|
|
|
117 |
toString: function(){ return "dojox.dtl.tag.logic.ForNode"; }
|
|
|
118 |
});
|
|
|
119 |
|
|
|
120 |
dojox.dtl.tag.logic.if_ = function(parser, text){
|
|
|
121 |
var parts = text.split(/\s+/g);
|
|
|
122 |
var type;
|
|
|
123 |
var bools = [];
|
|
|
124 |
parts.shift();
|
|
|
125 |
text = parts.join(" ");
|
|
|
126 |
parts = text.split(" and ");
|
|
|
127 |
if(parts.length == 1){
|
|
|
128 |
type = "or";
|
|
|
129 |
parts = text.split(" or ");
|
|
|
130 |
}else{
|
|
|
131 |
type = "and";
|
|
|
132 |
for(var i = 0; i < parts.length; i++){
|
|
|
133 |
if(parts[i] == "or"){
|
|
|
134 |
throw new Error("'if' tags can't mix 'and' and 'or'");
|
|
|
135 |
}
|
|
|
136 |
}
|
|
|
137 |
}
|
|
|
138 |
for(var i = 0, part; part = parts[i]; i++){
|
|
|
139 |
var not = false;
|
|
|
140 |
if(part.indexOf("not ") == 0){
|
|
|
141 |
part = part.substring(4);
|
|
|
142 |
not = true;
|
|
|
143 |
}
|
|
|
144 |
bools.push([not, new dojox.dtl.Filter(part)]);
|
|
|
145 |
}
|
|
|
146 |
var trues = parser.parse(["else", "endif"]);
|
|
|
147 |
var falses = false;
|
|
|
148 |
var token = parser.next();
|
|
|
149 |
if(token.text == "else"){
|
|
|
150 |
var falses = parser.parse(["endif"]);
|
|
|
151 |
parser.next();
|
|
|
152 |
}
|
|
|
153 |
return new dojox.dtl.tag.logic.IfNode(bools, trues, falses, type);
|
|
|
154 |
}
|
|
|
155 |
|
|
|
156 |
dojox.dtl.tag.logic.for_ = function(parser, text){
|
|
|
157 |
var parts = text.split(/\s+/g);
|
|
|
158 |
var reversed = parts.length == 5;
|
|
|
159 |
var nodelist = parser.parse(["endfor"]);
|
|
|
160 |
parser.next();
|
|
|
161 |
return new dojox.dtl.tag.logic.ForNode(parts[1], parts[3], reversed, nodelist);
|
|
|
162 |
}
|
|
|
163 |
|
|
|
164 |
}
|