source: Dev/trunk/src/client/dojox/dtl/contrib/dijit.js @ 529

Last change on this file since 529 was 483, checked in by hendrikvanantwerpen, 11 years ago

Added Dojo 1.9.3 release.
File size: 6.4 KB
Line 
1define([
2        "dojo/_base/lang",
3        "dojo/_base/connect",
4        "dojo/_base/array",
5        "dojo/query",
6        "../_base",
7        "../dom",
8        "dojo/parser",
9        "dojo/_base/sniff"
10], function(lang,connect,array,query,dd,dxdom,parser,has){
11
12        var ddcd = lang.getObject("contrib.dijit", true, dd);
13/*=====
14        ddcd = {
15                // TODO: summary
16        };
17=====*/
18
19        ddcd.AttachNode = lang.extend(function(keys, object){
20                this._keys = keys;
21                this._object = object;
22        },
23        {
24                render: function(context, buffer){
25                        if(!this._rendered){
26                                this._rendered = true;
27                                for(var i = 0, key; key = this._keys[i]; i++){
28                                        context.getThis()[key] = this._object || buffer.getParent();
29                                }
30                        }
31                        return buffer;
32                },
33                unrender: function(context, buffer){
34                        if(this._rendered){
35                                this._rendered = false;
36                                for(var i = 0, key; key = this._keys[i]; i++){
37                                        if(context.getThis()[key] === (this._object || buffer.getParent())){
38                                                delete context.getThis()[key];
39                                        }
40                                }
41                        }
42                        return buffer;
43                },
44                clone: function(buffer){
45                        return new this.constructor(this._keys, this._object);
46                }
47        });
48
49        ddcd.EventNode = lang.extend(function(command, obj){
50                this._command = command;
51
52                var type, events = command.split(/\s*,\s*/);
53                var trim = lang.trim;
54                var types = [];
55                var fns = [];
56                while(type = events.pop()){
57                        if(type){
58                                var fn = null;
59                                if(type.indexOf(":") != -1){
60                                        // oh, if only JS had tuple assignment
61                                        var funcNameArr = type.split(":");
62                                        type = trim(funcNameArr[0]);
63                                        fn = trim(funcNameArr.slice(1).join(":"));
64                                }else{
65                                        type = trim(type);
66                                }
67                                if(!fn){
68                                        fn = type;
69                                }
70                                types.push(type);
71                                fns.push(fn);
72                        }
73                }
74
75                this._types = types;
76                this._fns = fns;
77                this._object = obj;
78                this._rendered = [];
79        },
80        {
81                // _clear: Boolean
82                //              Make sure we kill the actual tags (onclick problems, etc)
83                _clear: false,
84                render: function(context, buffer){
85                        for(var i = 0, type; type = this._types[i]; i++){
86                                if(!this._clear && !this._object){
87                                        buffer.getParent()[type] = null;
88                                }
89                                var fn = this._fns[i];
90                                var args;
91                                if(fn.indexOf(" ") != -1){
92                                        if(this._rendered[i]){
93                                                connect.disconnect(this._rendered[i]);
94                                                this._rendered[i] = false;
95                                        }
96                                        args = array.map(fn.split(" ").slice(1), function(item){
97                                                return new dd._Filter(item).resolve(context);
98                                        });
99                                        fn = fn.split(" ", 2)[0];
100                                }
101                                if(!this._rendered[i]){
102                                        if(!this._object){
103                                                this._rendered[i] = buffer.addEvent(context, type, fn, args);
104                                        }else{
105                                                var resolved = fn;
106                                                if(lang.isArray(args)){
107                                                        resolved = function(e){
108                                                                this[fn].apply(this, [e].concat(args));
109                                                        }
110                                                }
111                                                this._rendered[i] = connect.connect(this._object, type, context.getThis(), fn);
112                                        }
113                                }
114                        }
115                        this._clear = true;
116
117                        return buffer;
118                },
119                unrender: function(context, buffer){
120                        while(this._rendered.length){
121                                connect.disconnect(this._rendered.pop());
122                        }
123                        return buffer;
124                },
125                clone: function(){
126                        return new this.constructor(this._command, this._object);
127                }
128        });
129
130        function cloneNode(n1){
131                var n2 = n1.cloneNode(true);
132                if(has("ie")){
133                        query("script", n2).forEach("item.text = this[index].text;", query("script", n1));
134                }
135                return n2;
136        }
137
138        ddcd.DojoTypeNode = lang.extend(function(node, parsed){
139                this._node = node;
140                this._parsed = parsed;
141
142                var events = node.getAttribute("dojoAttachEvent") || node.getAttribute("data-dojo-attach-event");
143                if(events){
144                        this._events = new ddcd.EventNode(lang.trim(events));
145                }
146                var attach = node.getAttribute("dojoAttachPoint") || node.getAttribute("data-dojo-attach-point");
147                if(attach){
148                        this._attach = new ddcd.AttachNode(lang.trim(attach).split(/\s*,\s*/));
149                }
150
151                if(!parsed){
152                        this._dijit = parser.instantiate([cloneNode(node)])[0];
153                }else{
154                        node = cloneNode(node);
155                        var old = ddcd.widgetsInTemplate;
156                        ddcd.widgetsInTemplate = false;
157                        this._template = new dd.DomTemplate(node);
158                        ddcd.widgetsInTemplate = old;
159                }
160        },
161        {
162                render: function(context, buffer){
163                        if(this._parsed){
164                                var _buffer = new dd.DomBuffer();
165                                this._template.render(context, _buffer);
166                                var root = cloneNode(_buffer.getRootNode());
167                                var div = document.createElement("div");
168                                div.appendChild(root);
169                                var rendered = div.innerHTML;
170                                div.removeChild(root);
171                                if(rendered != this._rendered){
172                                        this._rendered = rendered;
173                                        if(this._dijit){
174                                                this._dijit.destroyRecursive();
175                                        }
176                                        this._dijit = parser.instantiate([root])[0];
177                                }
178                        }
179
180                        var node = this._dijit.domNode;
181
182                        if(this._events){
183                                this._events._object = this._dijit;
184                                this._events.render(context, buffer);
185                        }
186                        if(this._attach){
187                                this._attach._object = this._dijit;
188                                this._attach.render(context, buffer);
189                        }
190
191                        return buffer.concat(node);
192                },
193                unrender: function(context, buffer){
194                        return buffer.remove(this._dijit.domNode);
195                },
196                clone: function(){
197                        return new this.constructor(this._node, this._parsed);
198                }
199        });
200
201        lang.mixin(ddcd, {
202                widgetsInTemplate: true,
203                dojoAttachPoint: function(parser, token){
204                        return new ddcd.AttachNode(token.contents.slice(token.contents.indexOf("data-") !== -1 ? 23 : 16).split(/\s*,\s*/));
205                },
206                dojoAttachEvent: function(parser, token){
207                        return new ddcd.EventNode(token.contents.slice(token.contents.indexOf("data-") !== -1 ? 23 : 16));
208                },
209                dojoType: function(parser, token){
210                        var parsed = false;
211                        if(token.contents.slice(-7) == " parsed"){
212                                parsed = true;
213                        }
214                        var contents = token.contents.indexOf("data-") !== -1 ? token.contents.slice(15)  : token.contents.slice(9);
215                        var dojoType = parsed ? contents.slice(0, -7) : contents.toString();
216
217                        if(ddcd.widgetsInTemplate){
218                                var node = parser.swallowNode();
219                                node.setAttribute("data-dojo-type", dojoType);
220                                return new ddcd.DojoTypeNode(node, parsed);
221                        }
222
223                        return new dd.AttributeNode("data-dojo-type", dojoType);
224                },
225                on: function(parser, token){
226                        // summary:
227                        //              Associates an event type to a function (on the current widget) by name
228                        var parts = token.contents.split();
229                        return new ddcd.EventNode(parts[0] + ":" + parts.slice(1).join(" "));
230                }
231        });
232        ddcd["data-dojo-type"] = ddcd.dojoType;
233        ddcd["data-dojo-attach-point"] = ddcd.dojoAttachPoint;
234        ddcd["data-dojo-attach-event"] = ddcd.dojoAttachEvent;
235       
236
237        dd.register.tags("dojox.dtl.contrib", {
238                "dijit": ["attr:dojoType", "attr:data-dojo-type", "attr:dojoAttachPoint", "attr:data-dojo-attach-point", ["attr:attach", "dojoAttachPoint"], ["attr:attach", "data-dojo-attach-point"], "attr:dojoAttachEvent", "attr:data-dojo-attach-event", [/(attr:)?on(click|key(up))/i, "on"]]
239        });
240
241        return ddcd;
242});
Note: See TracBrowser for help on using the repository browser.