mirror of
https://git.tt-rss.org/git/tt-rss.git
synced 2025-12-15 23:35:56 +00:00
upgrade Dojo to 1.6.1
This commit is contained in:
Andrew Dolgov
@@ -1,184 +1,351 @@
|
||||
/*
|
||||
Copyright (c) 2004-2010, The Dojo Foundation All Rights Reserved.
|
||||
Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
|
||||
Available via Academic Free License >= 2.1 OR the modified BSD license.
|
||||
see: http://dojotoolkit.org/license for details
|
||||
*/
|
||||
|
||||
|
||||
if(!dojo._hasResource["dijit._Templated"]){
|
||||
dojo._hasResource["dijit._Templated"]=true;
|
||||
if(!dojo._hasResource["dijit._Templated"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
|
||||
dojo._hasResource["dijit._Templated"] = true;
|
||||
dojo.provide("dijit._Templated");
|
||||
dojo.require("dijit._Widget");
|
||||
dojo.require("dojo.string");
|
||||
dojo.require("dojo.parser");
|
||||
dojo.require("dojo.cache");
|
||||
dojo.declare("dijit._Templated",null,{templateString:null,templatePath:null,widgetsInTemplate:false,_skipNodeCache:false,_earlyTemplatedStartup:false,constructor:function(){
|
||||
this._attachPoints=[];
|
||||
},_stringRepl:function(_1){
|
||||
var _2=this.declaredClass,_3=this;
|
||||
return dojo.string.substitute(_1,this,function(_4,_5){
|
||||
if(_5.charAt(0)=="!"){
|
||||
_4=dojo.getObject(_5.substr(1),false,_3);
|
||||
}
|
||||
if(typeof _4=="undefined"){
|
||||
throw new Error(_2+" template:"+_5);
|
||||
}
|
||||
if(_4==null){
|
||||
return "";
|
||||
}
|
||||
return _5.charAt(0)=="!"?_4:_4.toString().replace(/"/g,""");
|
||||
},this);
|
||||
},buildRendering:function(){
|
||||
var _6=dijit._Templated.getCachedTemplate(this.templatePath,this.templateString,this._skipNodeCache);
|
||||
var _7;
|
||||
if(dojo.isString(_6)){
|
||||
_7=dojo._toDom(this._stringRepl(_6));
|
||||
if(_7.nodeType!=1){
|
||||
throw new Error("Invalid template: "+_6);
|
||||
}
|
||||
}else{
|
||||
_7=_6.cloneNode(true);
|
||||
}
|
||||
this.domNode=_7;
|
||||
this._attachTemplateNodes(_7);
|
||||
if(this.widgetsInTemplate){
|
||||
var _8=dojo.parser,_9,_a;
|
||||
if(_8._query!="[dojoType]"){
|
||||
_9=_8._query;
|
||||
_a=_8._attrName;
|
||||
_8._query="[dojoType]";
|
||||
_8._attrName="dojoType";
|
||||
}
|
||||
var cw=(this._startupWidgets=dojo.parser.parse(_7,{noStart:!this._earlyTemplatedStartup,inherited:{dir:this.dir,lang:this.lang}}));
|
||||
if(_9){
|
||||
_8._query=_9;
|
||||
_8._attrName=_a;
|
||||
}
|
||||
this._supportingWidgets=dijit.findWidgets(_7);
|
||||
this._attachTemplateNodes(cw,function(n,p){
|
||||
return n[p];
|
||||
});
|
||||
}
|
||||
this._fillContent(this.srcNodeRef);
|
||||
},_fillContent:function(_b){
|
||||
var _c=this.containerNode;
|
||||
if(_b&&_c){
|
||||
while(_b.hasChildNodes()){
|
||||
_c.appendChild(_b.firstChild);
|
||||
}
|
||||
}
|
||||
},_attachTemplateNodes:function(_d,_e){
|
||||
_e=_e||function(n,p){
|
||||
return n.getAttribute(p);
|
||||
};
|
||||
var _f=dojo.isArray(_d)?_d:(_d.all||_d.getElementsByTagName("*"));
|
||||
var x=dojo.isArray(_d)?0:-1;
|
||||
for(;x<_f.length;x++){
|
||||
var _10=(x==-1)?_d:_f[x];
|
||||
if(this.widgetsInTemplate&&_e(_10,"dojoType")){
|
||||
continue;
|
||||
}
|
||||
var _11=_e(_10,"dojoAttachPoint");
|
||||
if(_11){
|
||||
var _12,_13=_11.split(/\s*,\s*/);
|
||||
while((_12=_13.shift())){
|
||||
if(dojo.isArray(this[_12])){
|
||||
this[_12].push(_10);
|
||||
}else{
|
||||
this[_12]=_10;
|
||||
}
|
||||
this._attachPoints.push(_12);
|
||||
}
|
||||
}
|
||||
var _14=_e(_10,"dojoAttachEvent");
|
||||
if(_14){
|
||||
var _15,_16=_14.split(/\s*,\s*/);
|
||||
var _17=dojo.trim;
|
||||
while((_15=_16.shift())){
|
||||
if(_15){
|
||||
var _18=null;
|
||||
if(_15.indexOf(":")!=-1){
|
||||
var _19=_15.split(":");
|
||||
_15=_17(_19[0]);
|
||||
_18=_17(_19[1]);
|
||||
}else{
|
||||
_15=_17(_15);
|
||||
}
|
||||
if(!_18){
|
||||
_18=_15;
|
||||
}
|
||||
this.connect(_10,_15,_18);
|
||||
}
|
||||
}
|
||||
}
|
||||
var _1a=_e(_10,"waiRole");
|
||||
if(_1a){
|
||||
dijit.setWaiRole(_10,_1a);
|
||||
}
|
||||
var _1b=_e(_10,"waiState");
|
||||
if(_1b){
|
||||
dojo.forEach(_1b.split(/\s*,\s*/),function(_1c){
|
||||
if(_1c.indexOf("-")!=-1){
|
||||
var _1d=_1c.split("-");
|
||||
dijit.setWaiState(_10,_1d[0],_1d[1]);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
},startup:function(){
|
||||
dojo.forEach(this._startupWidgets,function(w){
|
||||
if(w&&!w._started&&w.startup){
|
||||
w.startup();
|
||||
}
|
||||
});
|
||||
this.inherited(arguments);
|
||||
},destroyRendering:function(){
|
||||
dojo.forEach(this._attachPoints,function(_1e){
|
||||
delete this[_1e];
|
||||
},this);
|
||||
this._attachPoints=[];
|
||||
this.inherited(arguments);
|
||||
}});
|
||||
dijit._Templated._templateCache={};
|
||||
dijit._Templated.getCachedTemplate=function(_1f,_20,_21){
|
||||
var _22=dijit._Templated._templateCache;
|
||||
var key=_20||_1f;
|
||||
var _23=_22[key];
|
||||
if(_23){
|
||||
try{
|
||||
if(!_23.ownerDocument||_23.ownerDocument==dojo.doc){
|
||||
return _23;
|
||||
}
|
||||
}
|
||||
catch(e){
|
||||
}
|
||||
dojo.destroy(_23);
|
||||
}
|
||||
if(!_20){
|
||||
_20=dojo.cache(_1f,{sanitize:true});
|
||||
}
|
||||
_20=dojo.string.trim(_20);
|
||||
if(_21||_20.match(/\$\{([^\}]+)\}/g)){
|
||||
return (_22[key]=_20);
|
||||
}else{
|
||||
var _24=dojo._toDom(_20);
|
||||
if(_24.nodeType!=1){
|
||||
throw new Error("Invalid template: "+_20);
|
||||
}
|
||||
return (_22[key]=_24);
|
||||
}
|
||||
|
||||
|
||||
dojo.declare("dijit._Templated",
|
||||
null,
|
||||
{
|
||||
// summary:
|
||||
// Mixin for widgets that are instantiated from a template
|
||||
|
||||
// templateString: [protected] String
|
||||
// A string that represents the widget template. Pre-empts the
|
||||
// templatePath. In builds that have their strings "interned", the
|
||||
// templatePath is converted to an inline templateString, thereby
|
||||
// preventing a synchronous network call.
|
||||
//
|
||||
// Use in conjunction with dojo.cache() to load from a file.
|
||||
templateString: null,
|
||||
|
||||
// templatePath: [protected deprecated] String
|
||||
// Path to template (HTML file) for this widget relative to dojo.baseUrl.
|
||||
// Deprecated: use templateString with dojo.cache() instead.
|
||||
templatePath: null,
|
||||
|
||||
// widgetsInTemplate: [protected] Boolean
|
||||
// Should we parse the template to find widgets that might be
|
||||
// declared in markup inside it? False by default.
|
||||
widgetsInTemplate: false,
|
||||
|
||||
// skipNodeCache: [protected] Boolean
|
||||
// If using a cached widget template node poses issues for a
|
||||
// particular widget class, it can set this property to ensure
|
||||
// that its template is always re-built from a string
|
||||
_skipNodeCache: false,
|
||||
|
||||
// _earlyTemplatedStartup: Boolean
|
||||
// A fallback to preserve the 1.0 - 1.3 behavior of children in
|
||||
// templates having their startup called before the parent widget
|
||||
// fires postCreate. Defaults to 'false', causing child widgets to
|
||||
// have their .startup() called immediately before a parent widget
|
||||
// .startup(), but always after the parent .postCreate(). Set to
|
||||
// 'true' to re-enable to previous, arguably broken, behavior.
|
||||
_earlyTemplatedStartup: false,
|
||||
|
||||
/*=====
|
||||
// _attachPoints: [private] String[]
|
||||
// List of widget attribute names associated with dojoAttachPoint=... in the
|
||||
// template, ex: ["containerNode", "labelNode"]
|
||||
_attachPoints: [],
|
||||
=====*/
|
||||
|
||||
/*=====
|
||||
// _attachEvents: [private] Handle[]
|
||||
// List of connections associated with dojoAttachEvent=... in the
|
||||
// template
|
||||
_attachEvents: [],
|
||||
=====*/
|
||||
|
||||
constructor: function(){
|
||||
this._attachPoints = [];
|
||||
this._attachEvents = [];
|
||||
},
|
||||
|
||||
_stringRepl: function(tmpl){
|
||||
// summary:
|
||||
// Does substitution of ${foo} type properties in template string
|
||||
// tags:
|
||||
// private
|
||||
var className = this.declaredClass, _this = this;
|
||||
// Cache contains a string because we need to do property replacement
|
||||
// do the property replacement
|
||||
return dojo.string.substitute(tmpl, this, function(value, key){
|
||||
if(key.charAt(0) == '!'){ value = dojo.getObject(key.substr(1), false, _this); }
|
||||
if(typeof value == "undefined"){ throw new Error(className+" template:"+key); } // a debugging aide
|
||||
if(value == null){ return ""; }
|
||||
|
||||
// Substitution keys beginning with ! will skip the transform step,
|
||||
// in case a user wishes to insert unescaped markup, e.g. ${!foo}
|
||||
return key.charAt(0) == "!" ? value :
|
||||
// Safer substitution, see heading "Attribute values" in
|
||||
// http://www.w3.org/TR/REC-html40/appendix/notes.html#h-B.3.2
|
||||
value.toString().replace(/"/g,"""); //TODO: add &? use encodeXML method?
|
||||
}, this);
|
||||
},
|
||||
|
||||
buildRendering: function(){
|
||||
// summary:
|
||||
// Construct the UI for this widget from a template, setting this.domNode.
|
||||
// tags:
|
||||
// protected
|
||||
|
||||
// Lookup cached version of template, and download to cache if it
|
||||
// isn't there already. Returns either a DomNode or a string, depending on
|
||||
// whether or not the template contains ${foo} replacement parameters.
|
||||
var cached = dijit._Templated.getCachedTemplate(this.templatePath, this.templateString, this._skipNodeCache);
|
||||
|
||||
var node;
|
||||
if(dojo.isString(cached)){
|
||||
node = dojo._toDom(this._stringRepl(cached));
|
||||
if(node.nodeType != 1){
|
||||
// Flag common problems such as templates with multiple top level nodes (nodeType == 11)
|
||||
throw new Error("Invalid template: " + cached);
|
||||
}
|
||||
}else{
|
||||
// if it's a node, all we have to do is clone it
|
||||
node = cached.cloneNode(true);
|
||||
}
|
||||
|
||||
this.domNode = node;
|
||||
|
||||
// Call down to _Widget.buildRendering() to get base classes assigned
|
||||
// TODO: change the baseClass assignment to attributeMap
|
||||
this.inherited(arguments);
|
||||
|
||||
// recurse through the node, looking for, and attaching to, our
|
||||
// attachment points and events, which should be defined on the template node.
|
||||
this._attachTemplateNodes(node);
|
||||
|
||||
if(this.widgetsInTemplate){
|
||||
// Store widgets that we need to start at a later point in time
|
||||
var cw = (this._startupWidgets = dojo.parser.parse(node, {
|
||||
noStart: !this._earlyTemplatedStartup,
|
||||
template: true,
|
||||
inherited: {dir: this.dir, lang: this.lang},
|
||||
propsThis: this, // so data-dojo-props of widgets in the template can reference "this" to refer to me
|
||||
scope: "dojo" // even in multi-version mode templates use dojoType/data-dojo-type
|
||||
}));
|
||||
|
||||
this._supportingWidgets = dijit.findWidgets(node);
|
||||
|
||||
this._attachTemplateNodes(cw, function(n,p){
|
||||
return n[p];
|
||||
});
|
||||
}
|
||||
|
||||
this._fillContent(this.srcNodeRef);
|
||||
},
|
||||
|
||||
_fillContent: function(/*DomNode*/ source){
|
||||
// summary:
|
||||
// Relocate source contents to templated container node.
|
||||
// this.containerNode must be able to receive children, or exceptions will be thrown.
|
||||
// tags:
|
||||
// protected
|
||||
var dest = this.containerNode;
|
||||
if(source && dest){
|
||||
while(source.hasChildNodes()){
|
||||
dest.appendChild(source.firstChild);
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
_attachTemplateNodes: function(rootNode, getAttrFunc){
|
||||
// summary:
|
||||
// Iterate through the template and attach functions and nodes accordingly.
|
||||
// Alternately, if rootNode is an array of widgets, then will process dojoAttachPoint
|
||||
// etc. for those widgets.
|
||||
// description:
|
||||
// Map widget properties and functions to the handlers specified in
|
||||
// the dom node and it's descendants. This function iterates over all
|
||||
// nodes and looks for these properties:
|
||||
// * dojoAttachPoint
|
||||
// * dojoAttachEvent
|
||||
// * waiRole
|
||||
// * waiState
|
||||
// rootNode: DomNode|Array[Widgets]
|
||||
// the node to search for properties. All children will be searched.
|
||||
// getAttrFunc: Function?
|
||||
// a function which will be used to obtain property for a given
|
||||
// DomNode/Widget
|
||||
// tags:
|
||||
// private
|
||||
|
||||
getAttrFunc = getAttrFunc || function(n,p){ return n.getAttribute(p); };
|
||||
|
||||
var nodes = dojo.isArray(rootNode) ? rootNode : (rootNode.all || rootNode.getElementsByTagName("*"));
|
||||
var x = dojo.isArray(rootNode) ? 0 : -1;
|
||||
for(; x<nodes.length; x++){
|
||||
var baseNode = (x == -1) ? rootNode : nodes[x];
|
||||
if(this.widgetsInTemplate && (getAttrFunc(baseNode, "dojoType") || getAttrFunc(baseNode, "data-dojo-type"))){
|
||||
continue;
|
||||
}
|
||||
// Process dojoAttachPoint
|
||||
var attachPoint = getAttrFunc(baseNode, "dojoAttachPoint") || getAttrFunc(baseNode, "data-dojo-attach-point");
|
||||
if(attachPoint){
|
||||
var point, points = attachPoint.split(/\s*,\s*/);
|
||||
while((point = points.shift())){
|
||||
if(dojo.isArray(this[point])){
|
||||
this[point].push(baseNode);
|
||||
}else{
|
||||
this[point]=baseNode;
|
||||
}
|
||||
this._attachPoints.push(point);
|
||||
}
|
||||
}
|
||||
|
||||
// Process dojoAttachEvent
|
||||
var attachEvent = getAttrFunc(baseNode, "dojoAttachEvent") || getAttrFunc(baseNode, "data-dojo-attach-event");;
|
||||
if(attachEvent){
|
||||
// NOTE: we want to support attributes that have the form
|
||||
// "domEvent: nativeEvent; ..."
|
||||
var event, events = attachEvent.split(/\s*,\s*/);
|
||||
var trim = dojo.trim;
|
||||
while((event = events.shift())){
|
||||
if(event){
|
||||
var thisFunc = null;
|
||||
if(event.indexOf(":") != -1){
|
||||
// oh, if only JS had tuple assignment
|
||||
var funcNameArr = event.split(":");
|
||||
event = trim(funcNameArr[0]);
|
||||
thisFunc = trim(funcNameArr[1]);
|
||||
}else{
|
||||
event = trim(event);
|
||||
}
|
||||
if(!thisFunc){
|
||||
thisFunc = event;
|
||||
}
|
||||
this._attachEvents.push(this.connect(baseNode, event, thisFunc));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// waiRole, waiState
|
||||
// TODO: remove this in 2.0, templates are now using role=... and aria-XXX=... attributes directicly
|
||||
var role = getAttrFunc(baseNode, "waiRole");
|
||||
if(role){
|
||||
dijit.setWaiRole(baseNode, role);
|
||||
}
|
||||
var values = getAttrFunc(baseNode, "waiState");
|
||||
if(values){
|
||||
dojo.forEach(values.split(/\s*,\s*/), function(stateValue){
|
||||
if(stateValue.indexOf('-') != -1){
|
||||
var pair = stateValue.split('-');
|
||||
dijit.setWaiState(baseNode, pair[0], pair[1]);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
startup: function(){
|
||||
dojo.forEach(this._startupWidgets, function(w){
|
||||
if(w && !w._started && w.startup){
|
||||
w.startup();
|
||||
}
|
||||
});
|
||||
this.inherited(arguments);
|
||||
},
|
||||
|
||||
destroyRendering: function(){
|
||||
// Delete all attach points to prevent IE6 memory leaks.
|
||||
dojo.forEach(this._attachPoints, function(point){
|
||||
delete this[point];
|
||||
}, this);
|
||||
this._attachPoints = [];
|
||||
|
||||
// And same for event handlers
|
||||
dojo.forEach(this._attachEvents, this.disconnect, this);
|
||||
this._attachEvents = [];
|
||||
|
||||
this.inherited(arguments);
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
// key is either templatePath or templateString; object is either string or DOM tree
|
||||
dijit._Templated._templateCache = {};
|
||||
|
||||
dijit._Templated.getCachedTemplate = function(templatePath, templateString, alwaysUseString){
|
||||
// summary:
|
||||
// Static method to get a template based on the templatePath or
|
||||
// templateString key
|
||||
// templatePath: String||dojo.uri.Uri
|
||||
// The URL to get the template from.
|
||||
// templateString: String?
|
||||
// a string to use in lieu of fetching the template from a URL. Takes precedence
|
||||
// over templatePath
|
||||
// returns: Mixed
|
||||
// Either string (if there are ${} variables that need to be replaced) or just
|
||||
// a DOM tree (if the node can be cloned directly)
|
||||
|
||||
// is it already cached?
|
||||
var tmplts = dijit._Templated._templateCache;
|
||||
var key = templateString || templatePath;
|
||||
var cached = tmplts[key];
|
||||
if(cached){
|
||||
try{
|
||||
// if the cached value is an innerHTML string (no ownerDocument) or a DOM tree created within the current document, then use the current cached value
|
||||
if(!cached.ownerDocument || cached.ownerDocument == dojo.doc){
|
||||
// string or node of the same document
|
||||
return cached;
|
||||
}
|
||||
}catch(e){ /* squelch */ } // IE can throw an exception if cached.ownerDocument was reloaded
|
||||
dojo.destroy(cached);
|
||||
}
|
||||
|
||||
// If necessary, load template string from template path
|
||||
if(!templateString){
|
||||
templateString = dojo.cache(templatePath, {sanitize: true});
|
||||
}
|
||||
templateString = dojo.string.trim(templateString);
|
||||
|
||||
if(alwaysUseString || templateString.match(/\$\{([^\}]+)\}/g)){
|
||||
// there are variables in the template so all we can do is cache the string
|
||||
return (tmplts[key] = templateString); //String
|
||||
}else{
|
||||
// there are no variables in the template so we can cache the DOM tree
|
||||
var node = dojo._toDom(templateString);
|
||||
if(node.nodeType != 1){
|
||||
throw new Error("Invalid template: " + templateString);
|
||||
}
|
||||
return (tmplts[key] = node); //Node
|
||||
}
|
||||
};
|
||||
|
||||
if(dojo.isIE){
|
||||
dojo.addOnWindowUnload(function(){
|
||||
var _25=dijit._Templated._templateCache;
|
||||
for(var key in _25){
|
||||
var _26=_25[key];
|
||||
if(typeof _26=="object"){
|
||||
dojo.destroy(_26);
|
||||
}
|
||||
delete _25[key];
|
||||
dojo.addOnWindowUnload(function(){
|
||||
var cache = dijit._Templated._templateCache;
|
||||
for(var key in cache){
|
||||
var value = cache[key];
|
||||
if(typeof value == "object"){ // value is either a string or a DOM node template
|
||||
dojo.destroy(value);
|
||||
}
|
||||
delete cache[key];
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// These arguments can be specified for widgets which are used in templates.
|
||||
// Since any widget can be specified as sub widgets in template, mix it
|
||||
// into the base widget class. (This is a hack, but it's effective.)
|
||||
dojo.extend(dijit._Widget,{
|
||||
dojoAttachEvent: "",
|
||||
dojoAttachPoint: "",
|
||||
waiRole: "",
|
||||
waiState:""
|
||||
});
|
||||
}
|
||||
dojo.extend(dijit._Widget,{dojoAttachEvent:"",dojoAttachPoint:"",waiRole:"",waiState:""});
|
||||
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user