1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
if(!dojo._hasResource["dojo.behavior"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojo.behavior"] = true;
dojo.provide("dojo.behavior");
dojo.behavior = new function(){
function arrIn(obj, name){
if(!obj[name]){ obj[name] = []; }
return obj[name];
}
var _inc = 0;
function forIn(obj, scope, func){
var tmpObj = {};
for(var x in obj){
if(typeof tmpObj[x] == "undefined"){
if(!func){
scope(obj[x], x);
}else{
func.call(scope, obj[x], x);
}
}
}
}
// FIXME: need a better test so we don't exclude nightly Safari's!
this._behaviors = {};
this.add = function(behaviorObj){
// summary:
// add the specified behavior to the list of behaviors which will
// be applied the next time apply() is called. Calls to add() for
// an already existing behavior do not replace the previous rules,
// but are instead additive. New nodes which match the rule will
// have all add()-ed behaviors applied to them when matched.
//
// description:
// behavior objects are specified in the following format(s):
//
// {
// "#id": {
// "found": function(element){
// // ...
// },
//
// "onblah": {targetObj: foo, targetFunc: "bar"},
//
// "onblarg": "/foo/bar/baz/blarg",
//
// "onevent": function(evt){
// },
//
// "onotherevent: function(evt){
// // ...
// }
// },
//
// "#id2": {
// // ...
// },
//
// "#id3": function(element){
// // ...
// },
//
// // publish the match on a topic
// "#id4": "/found/topic/name",
//
// // match all direct descendants
// "#id4 > *": function(element){
// // ...
// },
//
// // match the first child node that's an element
// "#id4 > :first-child": { ... },
//
// // match the last child node that's an element
// "#id4 > :last-child": { ... },
//
// // all elements of type tagname
// "tagname": {
// // ...
// },
//
// "tagname1 tagname2 tagname3": {
// // ...
// },
//
// ".classname": {
// // ...
// },
//
// "tagname.classname": {
// // ...
// },
// }
//
// The "found" method is a generalized handler that's called as soon
// as the node matches the selector. Rules for values that follow also
// apply to the "found" key.
//
// The "on*" handlers are attached with dojo.connect().
//
// If the value corresponding to the ID key is a function and not a
// list, it's treated as though it was the value of "found".
var tmpObj = {};
forIn(behaviorObj, this, function(behavior, name){
var tBehavior = arrIn(this._behaviors, name);
if(typeof tBehavior["id"] != "number"){
tBehavior.id = _inc++;
}
var cversion = [];
tBehavior.push(cversion);
if((dojo.isString(behavior))||(dojo.isFunction(behavior))){
behavior = { found: behavior };
}
forIn(behavior, function(rule, ruleName){
arrIn(cversion, ruleName).push(rule);
});
});
}
var _applyToNode = function(node, action, ruleSetName){
if(dojo.isString(action)){
if(ruleSetName == "found"){
dojo.publish(action, [ node ]);
}else{
dojo.connect(node, ruleSetName, function(){
dojo.publish(action, arguments);
});
}
}else if(dojo.isFunction(action)){
if(ruleSetName == "found"){
action(node);
}else{
dojo.connect(node, ruleSetName, action);
}
}
}
this.apply = function(){
// summary:
// applies all currently registered behaviors to the document,
// taking care to ensure that only incremental updates are made
// since the last time add() or apply() were called. If new
// matching nodes have been added, all rules in a behavior will be
// applied to that node. For previously matched nodes, only
// behaviors which have been added since the last call to apply()
// will be added to the nodes.
forIn(this._behaviors, function(tBehavior, id){
dojo.query(id).forEach(
function(elem){
var runFrom = 0;
var bid = "_dj_behavior_"+tBehavior.id;
if(typeof elem[bid] == "number"){
runFrom = elem[bid];
// console.debug(bid, runFrom);
if(runFrom == (tBehavior.length)){
return;
}
}
// run through the versions, applying newer rules at each step
for(var x=runFrom, tver; tver = tBehavior[x]; x++){
// console.debug(tver);
forIn(tver, function(ruleSet, ruleSetName){
if(dojo.isArray(ruleSet)){
dojo.forEach(ruleSet, function(action){
_applyToNode(elem, action, ruleSetName);
});
}
});
}
// ensure that re-application only adds new rules to the node
elem[bid] = tBehavior.length;
}
);
});
}
}
dojo.addOnLoad(dojo.behavior, "apply");
}
|
