git.pond.sub.org Git - eow/blob - static/dojo-release-1.1.1/dojox/dtl/contrib/dijit.js

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