dojo-pkg 1.111.0

data/data/dojo-release-1.1.1-src/dojox/wire/XmlWire.js

@@ -0,0 +1,240 @@
+dojo.provide("dojox.wire.XmlWire");
+
+dojo.require("dojox.data.dom");
+dojo.require("dojox.wire.Wire");
+
+dojo.declare("dojox.wire.XmlWire", dojox.wire.Wire, {
+	//	summary:
+	//		A Wire for XML nodes or values (element, attribute and text)
+	//	description:
+	//		This class accesses XML nodes or value with a simplified XPath
+	//		specified to 'path' property.
+	//		The root object for this class must be an DOM document or element
+	//		node.
+	//		"@name" accesses to an attribute value of an element and "text()"
+	//		accesses to a text value of an element.
+	//		The hierarchy of the elements from the root node can be specified
+	//		with slash-separated list, such as "a/b/@c", which specifies
+	//		the value of an attribute named "c" of an element named "b" as
+	//		a child of another element named "a" of a child of the root node.
+	
+	_wireClass: "dojox.wire.XmlWire",
+	
+	constructor: function(/*Object*/args){
+		//	summary:
+		//		Initialize properties
+		//	description:
+		//		'args' is just mixed in with no further processing.
+		//	args:
+		//		Arguments to initialize properties
+		//		path:
+		//			A simplified XPath to an attribute, a text or elements
+	},
+	_getValue: function(/*Node*/object){
+		//	summary:
+		//		Return an attribute value, a text value or an array of elements
+		//	description:
+		//		This method first uses a root node passed in 'object' argument
+		//		and 'path' property to identify an attribute, a text or
+		//		elements.
+		//		If 'path' starts with a slash (absolute), the first path
+		//		segment is ignored assuming it point to the root node.
+		//		(That is, "/a/b/@c" and "b/@c" against a root node access
+		//		the same attribute value, assuming the root node is an element
+		//		with a tag name, "a".)
+		//	object:
+		//		A root node
+		//	returns:
+		//		A value found, otherwise 'undefined'
+		if(!object || !this.path){
+			return object; //Node
+		}
+
+		var node = object;
+		var path = this.path;
+		if(path.charAt(0) == '/'){ // absolute
+			// skip the first expression (supposed to select the top node)
+			var i = path.indexOf('/', 1);
+			path = path.substring(i + 1);
+		}
+		var list = path.split('/');
+		var last = list.length - 1;
+		for(var i = 0; i < last; i++){
+			node = this._getChildNode(node, list[i]);
+			if(!node){
+				return undefined; //undefined
+			}
+		}
+		var value = this._getNodeValue(node, list[last]);
+		return value; //String||Array
+	},
+
+	_setValue: function(/*Node*/object, /*String*/value){
+		//	summary:
+		//		Set an attribute value or a child text value to an element
+		//	description:
+		//		This method first uses a root node passed in 'object' argument
+		//		and 'path' property to identify an attribute, a text or
+		//		elements.
+		//		If an intermediate element does not exist, it creates
+		//		an element of the tag name in the 'path' segment as a child
+		//		node of the current node.
+		//		Finally, 'value' argument is set to an attribute or a text
+		//		(a child node) of the leaf element.
+		//	object:
+		//		A root node
+		//	value:
+		//		A value to set
+		if(!this.path){
+			return object; //Node
+		}
+
+		var node = object;
+		var doc = this._getDocument(node);
+		var path = this.path;
+		if(path.charAt(0) == '/'){ // absolute
+			var i = path.indexOf('/', 1);
+			if(!node){
+				var name = path.substring(1, i);
+				node = doc.createElement(name);
+				object = node; // to be returned as a new object
+			}
+			// skip the first expression (supposed to select the top node)
+			path = path.substring(i + 1);
+		}else{
+			if(!node){
+				return undefined; //undefined
+			}
+		}
+
+		var list = path.split('/');
+		var last = list.length - 1;
+		for(var i = 0; i < last; i++){
+			var child = this._getChildNode(node, list[i]);
+			if(!child){
+				child = doc.createElement(list[i]);
+				node.appendChild(child);
+			}
+			node = child;
+		}
+		this._setNodeValue(node, list[last], value);
+		return object; //Node
+	},
+
+	_getNodeValue: function(/*Node*/node, /*String*/exp){
+		//	summary:
+		//		Return an attribute value, a text value or an array of elements
+		//	description:
+		//		If 'exp' starts with '@', an attribute value of the specified
+		//		attribute is returned.
+		//		If 'exp' is "text()", a child text value is returned.
+		//		Otherwise, an array of child elements, the tag name of which
+		//		match 'exp', is returned.
+		//	node:
+		//		A node
+		//	exp:
+		//		An expression for attribute, text or elements
+		//	returns:
+		//		A value found, otherwise 'undefined'
+		var value = undefined;
+		if(exp.charAt(0) == '@'){
+			var attribute = exp.substring(1);
+			value = node.getAttribute(attribute);
+		}else if(exp == "text()"){
+			var text = node.firstChild;
+			if(text){
+				value = text.nodeValue;
+			}
+		}else{ // assume elements
+			value = [];
+			for(var i = 0; i < node.childNodes.length; i++){
+				var child = node.childNodes[i];
+				if(child.nodeType === 1 /* ELEMENT_NODE */ && child.nodeName == exp){
+					value.push(child);
+				}
+			}
+		}
+		return value; //String||Array
+	},
+
+	_setNodeValue: function(/*Node*/node, /*String*/exp, /*String*/value){
+		//	summary:
+		//		Set an attribute value or a child text value to an element
+		//	description:
+		//		If 'exp' starts with '@', 'value' is set to the specified
+		//		attribute.
+		//		If 'exp' is "text()", 'value' is set to a child text.
+		//	node:
+		//		A node
+		//	exp:
+		//		An expression for attribute or text
+		//	value:
+		//		A value to set
+		if(exp.charAt(0) == '@'){
+			var attribute = exp.substring(1);
+			if(value){
+				node.setAttribute(attribute, value);
+			}else{
+				node.removeAttribute(attribute);
+			}
+		}else if(exp == "text()"){
+			while(node.firstChild){
+				node.removeChild(node.firstChild);
+			}
+			if(value){
+				var text = this._getDocument(node).createTextNode(value);
+				node.appendChild(text);
+			}
+		}
+		// else not supported
+	},
+
+	_getChildNode: function(/*Node*/node, /*String*/name){
+		//	summary:
+		//		Return a child node
+		//	description:
+		//		A child element of the tag name specified with 'name' is
+		//		returned.
+		//		If 'name' ends with an array index, it is used to pick up
+		//		the corresponding element from multiple child elements.
+		//	node:
+		//		A parent node
+		//	name:
+		//		A tag name	
+		//	returns:
+		//		A child node
+		var index = 1;
+		var i1 = name.indexOf('[');
+		if(i1 >= 0){
+			var i2 = name.indexOf(']');
+			index = name.substring(i1 + 1, i2);
+			name = name.substring(0, i1);
+		}
+		var count = 1;
+		for(var i = 0; i < node.childNodes.length; i++){
+			var child = node.childNodes[i];
+			if(child.nodeType === 1 /* ELEMENT_NODE */ && child.nodeName == name){
+				if(count == index){
+					return child; //Node
+				}
+				count++;
+			}
+		}
+		return null; //null
+	},
+
+	_getDocument: function(/*Node*/node){
+		//	summary:
+		//		Return a DOM document
+		//	description:
+		//		If 'node' is specified, a DOM document of the node is returned.
+		//		Otherwise, a DOM document is created.
+		//	returns:
+		//		A DOM document
+		if(node){
+			return (node.nodeType == 9 /* DOCUMENT_NODE */ ? node : node.ownerDocument); //Document
+		}else{
+			return dojox.data.dom.createDocument(); //Document
+		}
+	}
+});

data/data/dojo-release-1.1.1-src/dojox/wire/_base.js

@@ -0,0 +1,191 @@
+dojo.provide("dojox.wire._base");
+
+dojox.wire._defaultWireClass = "dojox.wire.Wire";
+
+dojox.wire._wireClasses = {
+	"attribute": "dojox.wire.DataWire",
+	"path": "dojox.wire.XmlWire",
+	"children": "dojox.wire.CompositeWire",
+	"columns": "dojox.wire.TableAdapter",
+	"nodes": "dojox.wire.TreeAdapter",
+	"segments": "dojox.wire.TextAdapter"
+};
+
+dojox.wire.register = function(/*Function||String*/wireClass, /*String*/key){
+	//	summary:
+	//		Register a Wire class
+	//	desription:
+	//		The specified Wire class or a class name is registered with
+	//		a key property of arguments to create a Wire
+	//	wireClass:
+	//		A class or full qualified class name
+	//	key:
+	//		A key property of arguments to create a Wire
+	if(!wireClass || !key){
+		return; //undefined
+	}
+	if(dojox.wire._wireClasses[key]){ // key already in use
+		return; //undefined
+	}
+	dojox.wire._wireClasses[key] = wireClass;
+};
+
+dojox.wire._getClass = function(/*String*/name){
+	//	summary:
+	//		Returns a class 
+	//	description:
+	//		The class is loaded by dojo.require() and returned
+	//		by dojo.getObject().
+	//	name:
+	//		A class name
+	//	returns:
+	//		A class
+	dojo["require"](name); // use dojo["require"] instead of dojo.require to avoid a build problem
+	return dojo.getObject(name); //Function
+};
+
+dojox.wire.create = function(/*Object*/args){
+	//	summary:
+	//		Create a Wire from arguments
+	//	description:
+	//		If 'args' specifies 'wireClass', it is used as a class or full
+	//		qualified class name to create a Wire with 'args' as arguments.
+	//		Otherwise, a Wire class is determined by other proeprties of 'args'
+	//		checking if 'args' specifies a key property for a Wire class.
+	//		If no key property found, the default Wire class is used.
+	//	args:
+	//		Arguments to create a Wire
+	//	returns:
+	//		A Wire
+	if(!args){
+		args = {};
+	}
+	var wireClass = args.wireClass;
+	if(wireClass){
+		if(dojo.isString(wireClass)){
+			wireClass = dojox.wire._getClass(wireClass);
+		}
+	}else{
+		for(var key in args){
+			if(!args[key]){
+				continue;
+			}
+			wireClass = dojox.wire._wireClasses[key];
+			if(wireClass){
+				if(dojo.isString(wireClass)){
+					wireClass = dojox.wire._getClass(wireClass);
+					dojox.wire._wireClasses[key] = wireClass;
+				}
+				break;
+			}
+		}
+	}
+	if(!wireClass){
+		if(dojo.isString(dojox.wire._defaultWireClass)){
+			dojox.wire._defaultWireClass = dojox.wire._getClass(dojox.wire._defaultWireClass);
+		}
+		wireClass = dojox.wire._defaultWireClass;
+	}
+	return new wireClass(args); //Object
+};
+
+dojox.wire.isWire = function(/*Object*/wire){
+	//	summary:
+	//		Check if an object is a Wire
+	//	description:
+	//		If the specified object is a Wire, true is returned.
+	//		Otherwise, false is returned.
+	//	wire:
+	//		An object to check
+	//	returns:
+	//		True if the object is a Wire, otherwise false
+	return (wire && wire._wireClass); //Boolean
+};
+
+dojox.wire.transfer = function(/*Wire||Object*/source, /*Wire||Object*/target, /*Object?*/defaultObject, /*Object?*/defaultTargetObject){
+	//	summary:
+	//		Transfer a source value to a target value
+	//	description:
+	//		If 'source' and/or 'target' are not Wires, Wires are created with
+	//		them as arguments.
+	//		A value is got through the source Wire and set through the target
+	//		Wire.
+	//		'defaultObject' is passed to Wires as a default root object.
+	//		If 'defaultTargetObject' is specified, it is passed to the target
+	//		Wire as a default root object, instead of 'defaultObject'.
+	//	source:
+	//		A Wire or arguments to create a Wire for a source value
+	//	target:
+	//		A Wire or arguments to create a Wire for a target value
+	//	defaultObject:
+	//	defaultTargetObject;
+	//		Optional default root objects passed to Wires
+	if(!source || !target){
+		return; //undefined
+	}
+	if(!dojox.wire.isWire(source)){
+		source = dojox.wire.create(source);
+	}
+	if(!dojox.wire.isWire(target)){
+		target = dojox.wire.create(target);
+	}
+
+	var value = source.getValue(defaultObject);
+	target.setValue(value, (defaultTargetObject || defaultObject));
+};
+
+dojox.wire.connect = function(/*Object*/trigger, /*Wire||Object*/source, /*Wire||Object*/target){
+	//	summary:
+	//		Transfer a source value to a target value on a trigger event or
+	//		topic
+	//	description:
+	//		If 'trigger' specifies 'topic', the topic is subscribed to transer
+	//		a value on the topic.
+	//		Otherwise, the event specified to 'event' of 'trigger' is listened
+	//		to transfer a value.
+	//		On the specified event or topic, transfer() is called with
+	//		'source', 'target' and the arguments of the event or topic (as
+	//		default root objects).
+	//	trigger:
+	//		An event or topic to trigger a transfer
+	//	source:
+	//		A Wire or arguments to create a Wire for a source value
+	//	target:
+	//		A Wire or arguments to create a Wire for a target value
+	//	returns:
+	//		A connection handle for disconnect()
+	if(!trigger || !source || !target){
+		return; //undefined
+	}
+
+	var connection = {topic: trigger.topic};
+	if(trigger.topic){
+		connection.handle = dojo.subscribe(trigger.topic, function(){
+			dojox.wire.transfer(source, target, arguments);
+		});
+	}else if(trigger.event){
+		connection.handle = dojo.connect(trigger.scope, trigger.event, function(){
+			dojox.wire.transfer(source, target, arguments);
+		});
+	}
+	return connection; //Object
+};
+
+dojox.wire.disconnect = function(/*Object*/connection){
+	//	summary:
+	//		Remove a connection or subscription for transfer
+	//	description:
+	//		If 'handle' has 'topic', the topic is unsubscribed.
+	//		Otherwise, the listener to an event is removed.
+	//	connection:
+	//		A connection handle returned by connect()
+	if(!connection || !connection.handle){
+		return; //undefined
+	}
+
+	if(connection.topic){
+		dojo.unsubscribe(connection.handle);
+	}else{
+		dojo.disconnect(connection.handle);
+	}
+};

data/data/dojo-release-1.1.1-src/dojox/wire/demos/TableContainer.css

@@ -0,0 +1,30 @@
+.tablecontainer {
+	padding: 3 3 3 3;
+	border-width: 1px;
+	border-style: solid;
+	border-color: #000000;
+	border-collapse: separate;
+}
+
+.tablecontainer th {
+	text-align: left;
+} 
+
+.tablecontainer tr {
+	padding: 3 3 3 3;
+	border-width: 1px;
+	border-style: solid;
+	border-color: #000000;
+}
+
+.tablecontainer tr td {
+	padding: 3 3 3 3;
+	border-width: 1px;
+	border-style: solid;
+	border-color: #000000;
+}
+
+.alternate {
+	background-color: #EEEEEE;
+}
+

data/data/dojo-release-1.1.1-src/dojox/wire/demos/TableContainer.js

@@ -0,0 +1,64 @@
+dojo.provide("dojox.wire.demos.TableContainer");
+
+dojo.require("dojo.parser");
+dojo.require("dijit._Widget");
+dojo.require("dijit._Templated");
+
+dojo.declare("dojox.wire.demos.TableContainer", [ dijit._Widget, dijit._Templated, dijit._Container ], {
+	//	summary:
+	//		Extremely simple 'widget' that is a table generator with an addRow function that takes an array
+	//		as the row to add, where each entry is a cell in the row.  This demo widget is for use with the
+	//		wire demos.
+
+	templateString: "<table class='tablecontainer'><tbody dojoAttachPoint='tableContainer'></tbody></table>",
+	rowCount: 0,
+	headers: "",
+	addRow: function(array){
+		//	summary:
+		//		Function to add in a new row from the elements in the array map to cells in the row.
+		//	array:
+		//		Array of row values to add.
+		try{
+			var row = document.createElement("tr");
+			if((this.rowCount%2) === 0){
+				dojo.addClass(row, "alternate");
+			}
+			this.rowCount++;
+			for(var i in array){
+				var cell = document.createElement("td");
+				var text = document.createTextNode(array[i]);
+				cell.appendChild(text);
+				row.appendChild(cell);
+				
+			}
+			this.tableContainer.appendChild(row);
+		}catch(e){ console.debug(e); }
+	},
+
+	clearTable: function(){
+		//	summary:
+		//		Function to clear all the current rows in the table, except for the header.
+
+		//Always leave the first row, which is the table header.
+		while(this.tableContainer.firstChild.nextSibling){
+			this.tableContainer.removeChild(this.tableContainer.firstChild.nextSibling);
+		}
+		this.rowCount = 0;
+	},
+
+	postCreate: function(){
+		//	summary:
+		//		Widget lifecycle function to handle generation of the header elements in the table.
+		var headers = this.headers.split(",");
+		var tr = document.createElement("tr");
+		for(i in headers){
+			
+			var header = headers[i];
+			var th = document.createElement("th");
+			var text = document.createTextNode(header);
+			th.appendChild(text);
+			tr.appendChild(th);
+		}
+		this.tableContainer.appendChild(tr);
+	}
+});

data/data/dojo-release-1.1.1-src/dojox/wire/demos/WidgetRepeater.js

@@ -0,0 +1,29 @@
+dojo.provide("dojox.wire.demos.WidgetRepeater")
+		
+dojo.require("dojo.parser");
+dojo.require("dijit._Widget");
+dojo.require("dijit._Templated");
+dojo.require("dijit._Container");
+
+dojo.declare("dojox.wire.demos.WidgetRepeater", [ dijit._Widget, dijit._Templated, dijit._Container ], {
+	//	summary:
+	//		Simple widget that does generation of widgets repetatively, based on calls to 
+	//		the createNew function and contains them as child widgets.
+	templateString: "<div class='WidgetRepeater' dojoAttachPoint='repeaterNode'></div>",
+	widget: null,
+	repeater: null,
+	createNew: function(obj){
+		//	summary:
+		//		Function to handle the creation of a new widget and appending it into the widget tree.
+		//	obj:	
+		//		The parameters to pass to the widget.
+		try{
+			if(dojo.isString(this.widget)){
+				dojo.require(this.widget);
+				this.widget = dojo.getObject(this.widget);
+			}
+			this.addChild(new this.widget(obj));
+			this.repeaterNode.appendChild(document.createElement("br"));
+		}catch(e){ console.debug(e); }
+	}
+});

data/data/dojo-release-1.1.1-src/dojox/wire/demos/markup/countries.json

@@ -0,0 +1,43 @@
+{ identifier: 'name',
+   items: [
+	 { name:'Africa', type:'continent',
+		 children:[{_reference:'Egypt'}, {_reference:'Kenya'}, {_reference:'Sudan'}] },
+	 { name:'Egypt', type:'country' },
+	 { name:'Kenya', type:'country',
+		 children:[{_reference:'Nairobi'}, {_reference:'Mombasa'}] },
+	 { name:'Nairobi', type:'city' },
+	 { name:'Mombasa', type:'city' },
+	 { name:'Sudan', type:'country',
+		 children:{_reference:'Khartoum'} },
+	 { name:'Khartoum', type:'city' },
+	 { name:'Asia', type:'continent',
+		 children:[{_reference:'China'}, {_reference:'India'}, {_reference:'Russia'}, {_reference:'Mongolia'}] },
+	 { name:'China', type:'country' },
+	 { name:'India', type:'country' },
+	 { name:'Russia', type:'country' },
+	 { name:'Mongolia', type:'country' },
+	 { name:'Australia', type:'continent', population:'21 million',
+		 children:{_reference:'Commonwealth of Australia'}},
+	 { name:'Commonwealth of Australia', type:'country', population:'21 million'},
+	 { name:'Europe', type:'continent',
+		 children:[{_reference:'Germany'}, {_reference:'France'}, {_reference:'Spain'}, {_reference:'Italy'}] },
+	 { name:'Germany', type:'country' },
+	 { name:'France', type:'country' },
+	 { name:'Spain', type:'country' },
+	 { name:'Italy', type:'country' },
+	 { name:'North America', type:'continent',
+		 children:[{_reference:'Mexico'}, {_reference:'Canada'}, {_reference:'United States of America'}] },
+	 { name:'Mexico', type:'country',  population:'108 million', area:'1,972,550 sq km',
+		 children:[{_reference:'Mexico City'}, {_reference:'Guadalajara'}] },
+	 { name:'Mexico City', type:'city', population:'19 million', timezone:'-6 UTC'},
+	 { name:'Guadalajara', type:'city', population:'4 million', timezone:'-6 UTC' },
+	 { name:'Canada', type:'country',  population:'33 million', area:'9,984,670 sq km',
+		 children:[{_reference:'Ottawa'}, {_reference:'Toronto'}] },
+	 { name:'Ottawa', type:'city', population:'0.9 million', timezone:'-5 UTC'},
+	 { name:'Toronto', type:'city', population:'2.5 million', timezone:'-5 UTC' },
+	 { name:'United States of America', type:'country' },
+	 { name:'South America', type:'continent',
+		 children:[{_reference:'Brazil'}, {_reference:'Argentina'}] },
+	 { name:'Brazil', type:'country', population:'186 million' },
+	 { name:'Argentina', type:'country', population:'40 million' }
+]}