dojo-pkg 1.111.0

data/data/dojo-release-1.1.1-src/dijit/_Templated.js

@@ -0,0 +1,325 @@
+dojo.provide("dijit._Templated");
+
+dojo.require("dijit._Widget");
+dojo.require("dojo.string");
+dojo.require("dojo.parser");
+
+dojo.declare("dijit._Templated",
+	null,
+	{
+		//	summary:
+		//		Mixin for widgets that are instantiated from a template
+		// 
+		// templateNode: DomNode
+		//		a node that represents the widget template. Pre-empts both templateString and templatePath.
+		templateNode: null,
+
+		// templateString: 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.
+		templateString: null,
+
+		// templatePath: String
+		//	Path to template (HTML file) for this widget relative to dojo.baseUrl
+		templatePath: null,
+
+		// widgetsInTemplate: Boolean
+		//		should we parse the template to find widgets that might be
+		//		declared in markup inside it? false by default.
+		widgetsInTemplate: false,
+
+		// containerNode: DomNode
+		//		holds child elements. "containerNode" is generally set via a
+		//		dojoAttachPoint assignment and it designates where children of
+		//		the src dom node will be placed
+		containerNode: null,
+
+		// skipNodeCache: 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,
+
+		_stringRepl: function(tmpl){
+			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 = _this[key.substr(1)]; }
+				if(typeof value == "undefined"){ throw new Error(className+" template:"+key); } // a debugging aide
+				if(!value){ 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 &amp? use encodeXML method?
+			}, this);
+		},
+
+		// method over-ride
+		buildRendering: function(){
+			// summary:
+			//		Construct the UI for this widget from a template, setting this.domNode.
+
+			// 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 = dijit._Templated._createNodesFromText(this._stringRepl(cached))[0];
+			}else{
+				// if it's a node, all we have to do is clone it
+				node = cached.cloneNode(true);
+			}
+
+			// recurse through the node, looking for, and attaching to, our
+			// attachment points which should be defined on the template node.
+			this._attachTemplateNodes(node);
+
+			var source = this.srcNodeRef;
+			if(source && source.parentNode){
+				source.parentNode.replaceChild(node, source);
+			}
+
+			this.domNode = node;
+			if(this.widgetsInTemplate){
+				var cw = this._supportingWidgets  = dojo.parser.parse(node);
+				this._attachTemplateNodes(cw, function(n,p){
+					return n[p];
+				});
+			}
+
+			this._fillContent(source);
+		},
+
+		_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
+			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.	
+			// 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
+
+			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')){
+					continue;
+				}
+				// Process dojoAttachPoint
+				var attachPoint = getAttrFunc(baseNode, "dojoAttachPoint");
+				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;
+						}
+					}
+				}
+
+				// Process dojoAttachEvent
+				var attachEvent = getAttrFunc(baseNode, "dojoAttachEvent");
+				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.connect(baseNode, event, thisFunc);
+						}
+					}
+				}
+
+				// waiRole, waiState
+				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]);
+						}
+					});
+				}
+
+			}
+		}
+	}
+);
+
+// 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
+	//		The URL to get the template from. dojo.uri.Uri is often passed as well.
+	// 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){
+		return cached;
+	}
+
+	// If necessary, load template string from template path
+	if(!templateString){
+		templateString = dijit._Templated._sanitizeTemplateString(dojo._getText(templatePath));
+	}
+
+	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
+		return (tmplts[key] = dijit._Templated._createNodesFromText(templateString)[0]); //Node
+	}
+};
+
+dijit._Templated._sanitizeTemplateString = function(/*String*/tString){
+	// summary: 
+	//		Strips <?xml ...?> declarations so that external SVG and XML
+	// 		documents can be added to a document without worry. Also, if the string
+	//		is an HTML document, only the part inside the body tag is returned.
+	if(tString){
+		tString = tString.replace(/^\s*<\?xml(\s)+version=[\'\"](\d)*.(\d)*[\'\"](\s)*\?>/im, "");
+		var matches = tString.match(/<body[^>]*>\s*([\s\S]+)\s*<\/body>/im);
+		if(matches){
+			tString = matches[1];
+		}
+	}else{
+		tString = "";
+	}
+	return tString; //String
+};
+
+
+if(dojo.isIE){
+	dojo.addOnUnload(function(){
+		var cache = dijit._Templated._templateCache;
+		for(var key in cache){
+			var value = cache[key];
+			if(!isNaN(value.nodeType)){ // isNode equivalent
+				dojo._destroyElement(value);
+			}
+			delete cache[key];
+		}
+	});
+}
+
+(function(){
+	var tagMap = {
+		cell: {re: /^<t[dh][\s\r\n>]/i, pre: "<table><tbody><tr>", post: "</tr></tbody></table>"},
+		row: {re: /^<tr[\s\r\n>]/i, pre: "<table><tbody>", post: "</tbody></table>"},
+		section: {re: /^<(thead|tbody|tfoot)[\s\r\n>]/i, pre: "<table>", post: "</table>"}
+	};
+
+	// dummy container node used temporarily to hold nodes being created
+	var tn;
+
+	dijit._Templated._createNodesFromText = function(/*String*/text){
+		// summary:
+		//	Attempts to create a set of nodes based on the structure of the passed text.
+
+		if(!tn){
+			tn = dojo.doc.createElement("div");
+			tn.style.display="none";
+			dojo.body().appendChild(tn);
+		}
+		var tableType = "none";
+		var rtext = text.replace(/^\s+/, "");
+		for(var type in tagMap){
+			var map = tagMap[type];
+			if(map.re.test(rtext)){
+				tableType = type;
+				text = map.pre + text + map.post;
+				break;
+			}
+		}
+
+		tn.innerHTML = text;
+		if(tn.normalize){
+			tn.normalize();
+		}
+
+		var tag = { cell: "tr", row: "tbody", section: "table" }[tableType];
+		var _parent = (typeof tag != "undefined") ?
+						tn.getElementsByTagName(tag)[0] :
+						tn;
+
+		var nodes = [];
+		while(_parent.firstChild){
+			nodes.push(_parent.removeChild(_parent.firstChild));
+		}
+		tn.innerHTML="";
+		return nodes;	//	Array
+	}
+})();
+
+// 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:""
+})

data/data/dojo-release-1.1.1-src/dijit/_TimePicker.js

@@ -0,0 +1,245 @@
+dojo.provide("dijit._TimePicker");
+
+dojo.require("dijit.form._FormWidget");
+dojo.require("dojo.date.locale");
+
+/*=====
+dojo.declare(
+	"dijit._TimePicker.__Constraints",
+	[dojo.date.locale.__FormatOptions],
+	{
+		// clickableIncrement: String
+		//		see dijit._TimePicker.clickableIncrement
+		clickableIncrement: "T00:15:00",
+
+		// visibleIncrement: String
+		//		see dijit._TimePicker.visibleIncrement
+		visibleIncrement: "T01:00:00",
+
+		// visibleRange: String
+		//		see dijit._TimePicker.visibleRange
+		visibleRange: "T05:00:00"
+	}
+);
+=====*/
+
+dojo.declare("dijit._TimePicker",
+	[dijit._Widget, dijit._Templated],
+	{
+		//	summary:
+		//		A graphical time picker.
+		//		This widget is used internally by other widgets and is not accessible
+		//		as a standalone widget.
+
+		templatePath: dojo.moduleUrl("dijit.form", "templates/TimePicker.html"),
+		baseClass: "dijitTimePicker",
+
+		// clickableIncrement: String
+		//		ISO-8601 string representing the amount by which
+		//		every clickable element in the time picker increases.
+		//		Set in local time, without a time zone.
+		//		Example: `T00:15:00` creates 15 minute increments
+		//		Must divide dijit._TimePicker.visibleIncrement evenly
+		clickableIncrement: "T00:15:00",
+
+		// visibleIncrement: String
+		//		ISO-8601 string representing the amount by which
+		//		every element with a visible time in the time picker increases.
+		//		Set in local time, without a time zone.
+		//		Example: `T01:00:00` creates text in every 1 hour increment
+		visibleIncrement: "T01:00:00",
+
+		// visibleRange: String
+		//		ISO-8601 string representing the range of this TimePicker.
+		//		The TimePicker will only display times in this range.
+		//		Example: `T05:00:00` displays 5 hours of options
+		visibleRange: "T05:00:00",
+
+		// value: String
+		//		Date to display.
+		//		Defaults to current time and date.
+		//		Can be a Date object or an ISO-8601 string.
+		//		If you specify the GMT time zone (`-01:00`),
+		//		the time will be converted to the local time in the local time zone.
+		//		Otherwise, the time is considered to be in the local time zone.
+		//		If you specify the date and isDate is true, the date is used.
+		//		Example: if your local time zone is `GMT -05:00`,
+		//		`T10:00:00` becomes `T10:00:00-05:00` (considered to be local time),
+		//		`T10:00:00-01:00` becomes `T06:00:00-05:00` (4 hour difference),
+		//		`T10:00:00Z` becomes `T05:00:00-05:00` (5 hour difference between Zulu and local time)
+		//		`yyyy-mm-ddThh:mm:ss` is the format to set the date and time
+		//		Example: `2007-06-01T09:00:00`
+		value: new Date(),
+
+		_visibleIncrement:2,
+		_clickableIncrement:1,
+		_totalIncrements:10,
+
+		// constraints: dijit._TimePicker.__Constraints 
+		constraints:{},
+
+		serialize: dojo.date.stamp.toISOString,
+
+//TODOC: what is priority?
+		setValue:function(/*Date*/ date, /*Boolean*/ priority){
+			// summary:
+			//	Set the value of the TimePicker
+			//	Redraws the TimePicker around the new date
+
+			//dijit._TimePicker.superclass.setValue.apply(this, arguments);
+			this.value=date;
+			this._showText();
+		},
+
+		isDisabledDate: function(/*Date*/dateObject, /*String?*/locale){
+			// summary:
+			//	May be overridden to disable certain dates in the TimePicker e.g. `isDisabledDate=dojo.date.locale.isWeekend`
+			return false; // Boolean
+		},
+
+		_showText:function(){
+			this.timeMenu.innerHTML = "";
+			var fromIso = dojo.date.stamp.fromISOString;
+			this._clickableIncrementDate=fromIso(this.clickableIncrement);
+			this._visibleIncrementDate=fromIso(this.visibleIncrement);
+			this._visibleRangeDate=fromIso(this.visibleRange);
+			// get the value of the increments and the range in seconds (since 00:00:00) to find out how many divs to create
+			var sinceMidnight = function(/*Date*/ date){
+				return date.getHours() * 60 * 60 + date.getMinutes() * 60 + date.getSeconds();
+			};
+
+			var clickableIncrementSeconds = sinceMidnight(this._clickableIncrementDate);
+			var visibleIncrementSeconds = sinceMidnight(this._visibleIncrementDate);
+			var visibleRangeSeconds = sinceMidnight(this._visibleRangeDate);
+
+			// round reference date to previous visible increment
+			var time = this.value.getTime();
+			this._refDate = new Date(time - time % (visibleIncrementSeconds*1000));
+			this._refDate.setFullYear(1970,0,1); // match parse defaults
+
+			// assume clickable increment is the smallest unit
+			this._clickableIncrement = 1;
+			// divide the visible range by the clickable increment to get the number of divs to create
+			// example: 10:00:00/00:15:00 -> display 40 divs
+			this._totalIncrements = visibleRangeSeconds / clickableIncrementSeconds;
+			// divide the visible increments by the clickable increments to get how often to display the time inline
+			// example: 01:00:00/00:15:00 -> display the time every 4 divs
+			this._visibleIncrement = visibleIncrementSeconds / clickableIncrementSeconds;
+			for(var i = -(this._totalIncrements >> 1); i < (this._totalIncrements >> 1); i += this._clickableIncrement){
+				this.timeMenu.appendChild(this._createOption(i));
+			}
+			
+			// TODO:
+			// I commented this out because it
+			// causes problems for a TimeTextBox in a Dialog, or as the editor of an InlineEditBox,
+			// because the timeMenu node isn't visible yet. -- Bill (Bug #????)
+			// dijit.focus(this.timeMenu);
+		},
+
+		postCreate:function(){
+			// instantiate constraints
+			if(this.constraints===dijit._TimePicker.prototype.constraints){
+				this.constraints={};
+			}
+
+			// brings in visibleRange, increments, etc.
+			dojo.mixin(this, this.constraints);
+
+			// dojo.date.locale needs the lang in the constraints as locale
+			if(!this.constraints.locale){
+				this.constraints.locale=this.lang;
+			}
+
+			// assign typematic mouse listeners to the arrow buttons
+			this.connect(this.timeMenu, dojo.isIE ? "onmousewheel" : 'DOMMouseScroll', "_mouseWheeled");
+			var typematic = dijit.typematic.addMouseListener;
+			typematic(this.upArrow,this,this._onArrowUp, 0.8, 500);
+			typematic(this.downArrow,this,this._onArrowDown, 0.8, 500);
+			//dijit.typematic.addListener(this.upArrow,this.timeMenu, {keyCode:dojo.keys.UP_ARROW,ctrlKey:false,altKey:false,shiftKey:false}, this, "_onArrowUp", 0.8, 500);
+			//dijit.typematic.addListener(this.downArrow, this.timeMenu, {keyCode:dojo.keys.DOWN_ARROW,ctrlKey:false,altKey:false,shiftKey:false}, this, "_onArrowDown", 0.8,500);
+
+			this.inherited(arguments);
+			this.setValue(this.value);
+		},
+
+		_createOption:function(/*Number*/ index){
+			// summary: creates a clickable time option
+			var div = dojo.doc.createElement("div");
+			var date = (div.date = new Date(this._refDate));
+			div.index = index;
+			var incrementDate = this._clickableIncrementDate;
+			date.setHours(date.getHours() + incrementDate.getHours() * index,
+				date.getMinutes() + incrementDate.getMinutes() * index,
+				date.getSeconds() + incrementDate.getSeconds() * index);
+
+			var innerDiv = dojo.doc.createElement('div');
+			dojo.addClass(div,this.baseClass+"Item");
+			dojo.addClass(innerDiv,this.baseClass+"ItemInner");
+			innerDiv.innerHTML = dojo.date.locale.format(date, this.constraints);				
+			div.appendChild(innerDiv);
+
+			if(index%this._visibleIncrement<1 && index%this._visibleIncrement>-1){
+				dojo.addClass(div, this.baseClass+"Marker");
+			}else if(!(index%this._clickableIncrement)){
+				dojo.addClass(div, this.baseClass+"Tick");
+			}
+						
+			if(this.isDisabledDate(date)){
+				// set disabled
+				dojo.addClass(div, this.baseClass+"ItemDisabled");
+			}
+			if(!dojo.date.compare(this.value, date, this.constraints.selector)){
+				div.selected = true;
+				dojo.addClass(div, this.baseClass+"ItemSelected");
+			}
+			return div;
+		},
+
+		_onOptionSelected:function(/*Object*/ tgt){
+			var tdate = tgt.target.date || tgt.target.parentNode.date;			
+			if(!tdate || this.isDisabledDate(tdate)){ return; }
+			this.setValue(tdate);
+			this.onValueSelected(tdate);
+		},
+
+		onValueSelected:function(value){
+		},
+
+		onmouseover:function(/*Event*/ e){
+			var tgr = (e.target.parentNode === this.timeMenu) ? e.target : e.target.parentNode;			
+			this._highlighted_option=tgr;
+			dojo.addClass(tgr, this.baseClass+"ItemHover");
+		},
+
+		onmouseout:function(/*Event*/ e){
+			var tgr = (e.target.parentNode === this.timeMenu) ? e.target : e.target.parentNode;
+			if(this._highlighted_option===tgr){			
+				dojo.removeClass(tgr, this.baseClass+"ItemHover");
+			}
+		},
+
+		_mouseWheeled:function(/*Event*/e){
+			// summary: handle the mouse wheel listener
+			dojo.stopEvent(e);
+			// we're not _measuring_ the scroll amount, just direction
+			var scrollAmount = (dojo.isIE ? e.wheelDelta : -e.detail);
+			this[(scrollAmount>0 ? "_onArrowUp" : "_onArrowDown")](); // yes, we're making a new dom node every time you mousewheel, or click
+		},
+
+		_onArrowUp:function(){
+			// summary: remove the bottom time and add one to the top
+			var index = this.timeMenu.childNodes[0].index - 1;
+			var div = this._createOption(index);
+			this.timeMenu.removeChild(this.timeMenu.childNodes[this.timeMenu.childNodes.length - 1]);
+			this.timeMenu.insertBefore(div, this.timeMenu.childNodes[0]);
+		},
+
+		_onArrowDown:function(){
+			// summary: remove the top time and add one to the bottom
+			var index = this.timeMenu.childNodes[this.timeMenu.childNodes.length - 1].index + 1;
+			var div = this._createOption(index);
+			this.timeMenu.removeChild(this.timeMenu.childNodes[0]);
+			this.timeMenu.appendChild(div);
+		}
+	}
+);