Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojo._base.NodeList"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.

dojo._hasResource["dojo._base.NodeList"] = true;

dojo.provide("dojo._base.NodeList");

dojo.require("dojo._base.lang");

dojo.require("dojo._base.array");

(function(){

	var d = dojo;

	var tnl = function(arr){

		arr.constructor = dojo.NodeList;

		dojo._mixin(arr, dojo.NodeList.prototype);

		return arr;

	}

	dojo.NodeList = function(){

		//	summary:

		//		dojo.NodeList is as subclass of Array which adds syntactic

		//		sugar for chaining, common iteration operations, animation,

		//		and node manipulation. NodeLists are most often returned as

		//		the result of dojo.query() calls.

		//	example:

		//		create a node list from a node

		//		|	new dojo.NodeList(dojo.byId("foo"));

		return tnl(Array.apply(null, arguments));

	}

	dojo.NodeList._wrap = tnl;

	dojo.extend(dojo.NodeList, {

		// http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array#Methods

		// FIXME: handle return values for #3244

		//		http://trac.dojotoolkit.org/ticket/3244

		// FIXME:

		//		need to wrap or implement:

		//			join (perhaps w/ innerHTML/outerHTML overload for toString() of items?)

		//			reduce

		//			reduceRight

		slice: function(/*===== begin, end =====*/){

			// summary:

			//		Returns a new NodeList, maintaining this one in place

			// description:

			//		This method behaves exactly like the Array.slice method

			//		with the caveat that it returns a dojo.NodeList and not a

			//		raw Array. For more details, see:

			//			http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:slice

			// begin: Integer

			//		Can be a positive or negative integer, with positive

			//		integers noting the offset to begin at, and negative

			//		integers denoting an offset from the end (i.e., to the left

			//		of the end)

			// end: Integer?

			//		Optional parameter to describe what position relative to

			//		the NodeList's zero index to end the slice at. Like begin,

			//		can be positive or negative.

			var a = dojo._toArray(arguments);

			return tnl(a.slice.apply(this, a));

		},

		splice: function(/*===== index, howmany, item =====*/){

			// summary:

			//		Returns a new NodeList, manipulating this NodeList based on

			//		the arguments passed, potentially splicing in new elements

			//		at an offset, optionally deleting elements

			// description:

			//		This method behaves exactly like the Array.splice method

			//		with the caveat that it returns a dojo.NodeList and not a

			//		raw Array. For more details, see:

			//			http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:splice

			// index: Integer

			//		begin can be a positive or negative integer, with positive

			//		integers noting the offset to begin at, and negative

			//		integers denoting an offset from the end (i.e., to the left

			//		of the end)

			// howmany: Integer?

			//		Optional parameter to describe what position relative to

			//		the NodeList's zero index to end the slice at. Like begin,

			//		can be positive or negative.

			// item: Object...?

			//		Any number of optional parameters may be passed in to be

			//		spliced into the NodeList

			// returns:

			//		dojo.NodeList

			var a = dojo._toArray(arguments);

			return tnl(a.splice.apply(this, a));

		},

		concat: function(/*===== item =====*/){

			// summary:

			//		Returns a new NodeList comprised of items in this NodeList

			//		as well as items passed in as parameters

			// description:

			//		This method behaves exactly like the Array.concat method

			//		with the caveat that it returns a dojo.NodeList and not a

			//		raw Array. For more details, see:

			//			http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:concat

			// item: Object...?

			//		Any number of optional parameters may be passed in to be

			//		spliced into the NodeList

			// returns:

			//		dojo.NodeList

			var a = dojo._toArray(arguments, 0, [this]);

			return tnl(a.concat.apply([], a));

		},

		indexOf: function(/*Object*/ value, /*Integer?*/ fromIndex){

			//	summary:

			//		see dojo.indexOf(). The primary difference is that the acted-on

			//		array is implicitly this NodeList

			// value:

			//		The value to search for.

			// fromIndex:

			//		The loction to start searching from. Optional. Defaults to 0.

			//	description:

			//		For more details on the behavior of indexOf, see:

			//			http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:indexOf

			//	returns:

			//		Positive Integer or 0 for a match, -1 of not found.

			return d.indexOf(this, value, fromIndex); // Integer

		},

		lastIndexOf: function(/*===== value, fromIndex =====*/){

			// summary:

			//		see dojo.lastIndexOf(). The primary difference is that the

			//		acted-on array is implicitly this NodeList

			//	description:

			//		For more details on the behavior of lastIndexOf, see:

			//			http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:lastIndexOf

			// value: Object

			//		The value to search for.

			// fromIndex: Integer?

			//		The loction to start searching from. Optional. Defaults to 0.

			// returns:

			//		Positive Integer or 0 for a match, -1 of not found.

			return d.lastIndexOf.apply(d, d._toArray(arguments, 0, [this])); // Integer

		},

		every: function(/*Function*/callback, /*Object?*/thisObject){

			//	summary:

			//		see dojo.every() and:

			//			http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:every

			//		Takes the same structure of arguments and returns as

			//		dojo.every() with the caveat that the passed array is

			//		implicitly this NodeList

			return d.every(this, callback, thisObject); // Boolean

		},

		some: function(/*Function*/callback, /*Object?*/thisObject){

			//	summary:

			//		see dojo.some() and:

			//			http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:some

			//		Takes the same structure of arguments and returns as

			//		dojo.some() with the caveat that the passed array is

			//		implicitly this NodeList

			return d.some(this, callback, thisObject); // Boolean

		},

		map: function(/*Function*/ func, /*Function?*/ obj){

			//	summary:

			//		see dojo.map(). The primary difference is that the acted-on

			//		array is implicitly this NodeList and the return is a

			//		dojo.NodeList (a subclass of Array)

			return d.map(this, func, obj, d.NodeList); // dojo.NodeList

		},

		forEach: function(callback, thisObj){

			//	summary:

			//		see dojo.forEach(). The primary difference is that the acted-on

			//		array is implicitly this NodeList

			d.forEach(this, callback, thisObj);

			return this; // dojo.NodeList non-standard return to allow easier chaining

		},

		// custom methods

		coords: function(){

			//	summary:

			// 		Returns the box objects all elements in a node list as

			// 		an Array (*not* a NodeList)

			return d.map(this, d.coords);

		},

		style: function(/*===== property, value =====*/){

			//	summary:

			//		gets or sets the CSS property for every element in the NodeList

			//	property: String

			//		the CSS property to get/set, in JavaScript notation

			//		("lineHieght" instead of "line-height")

			//	value: String?

			//		optional. The value to set the property to

			//	return:

			//		if no value is passed, the result is an array of strings.

			//		If a value is passed, the return is this NodeList

			var aa = d._toArray(arguments, 0, [null]);

			var s = this.map(function(i){

				aa[0] = i;

				return d.style.apply(d, aa);

			});

			return (arguments.length > 1) ? this : s; // String||dojo.NodeList

		},

		styles: function(/*===== property, value =====*/){

			//	summary:

			//		Deprecated. Use NodeList.style instead. Will be removed in

			//		Dojo 1.1. Gets or sets the CSS property for every element

			//		in the NodeList

			//	property: String

			//		the CSS property to get/set, in JavaScript notation

			//		("lineHieght" instead of "line-height")

			//	value: String?

			//		optional. The value to set the property to

			//	return:

			//		if no value is passed, the result is an array of strings.

			//		If a value is passed, the return is this NodeList

			d.deprecated("NodeList.styles", "use NodeList.style instead", "1.1");

			return this.style.apply(this, arguments);

		},

		addClass: function(/*String*/ className){

			// summary:

			//		adds the specified class to every node in the list

			//

			this.forEach(function(i){ d.addClass(i, className); });

			return this;

		},

		removeClass: function(/*String*/ className){

			this.forEach(function(i){ d.removeClass(i, className); });

			return this;

		},

		// FIXME: toggleClass()? connectPublisher()? connectRunOnce()?

		place: function(/*String||Node*/ queryOrNode, /*String*/ position){

			//	summary:

			//		places elements of this node list relative to the first element matched

			//		by queryOrNode. Returns the original NodeList.

			//	queryOrNode:

			//		may be a string representing any valid CSS3 selector or a DOM node.

			//		In the selector case, only the first matching element will be used

			//		for relative positioning.

			//	position:

			//		can be one of:

			//			"last"||"end" (default)

			//			"first||"start"

			//			"before"

			//			"after"

			// 		or an offset in the childNodes property

			var item = d.query(queryOrNode)[0];

			position = position||"last";

			for(var x=0; x<this.length; x++){

				d.place(this[x], item, position);

			}

			return this; // dojo.NodeList

		},

		connect: function(/*String*/ methodName, /*Object||Function||String*/ objOrFunc, /*String?*/ funcName){

			//	summary:

			//		attach event handlers to every item of the NodeList. Uses dojo.connect()

			//		so event properties are normalized

			//	methodName:

			//		the name of the method to attach to. For DOM events, this should be

			//		the lower-case name of the event

			//	objOrFunc:

			//		if 2 arguments are passed (methodName, objOrFunc), objOrFunc should

			//		reference a function or be the name of the function in the global

			//		namespace to attach. If 3 arguments are provided

			//		(methodName, objOrFunc, funcName), objOrFunc must be the scope to

			//		locate the bound function in

			//	funcName:

			//		optional. A string naming the function in objOrFunc to bind to the

			//		event. May also be a function reference.

			//	example:

			//		add an onclick handler to every button on the page

			//		|	dojo.query("onclick", function(e){

			//		|		console.debug("clicked!");

			//		|	});

			// example:

			//		attach foo.bar() to every odd div's onmouseover

			//		|	dojo.query("div:nth-child(odd)").onclick("onmouseover", foo, "bar");

			this.forEach(function(item){

				d.connect(item, methodName, objOrFunc, funcName);

			});

			return this; // dojo.NodeList

		},

		orphan: function(/*String?*/ simpleFilter){

			//	summary:

			//		removes elements in this list that match the simple

			//		filter from their parents and returns them as a new

			//		NodeList.

			//	simpleFilter: single-expression CSS filter

			//	return: a dojo.NodeList of all of the elements orpahned

			var orphans = (simpleFilter) ? d._filterQueryResult(this, simpleFilter) : this;

			orphans.forEach(function(item){

				if(item["parentNode"]){

					item.parentNode.removeChild(item);

				}

			});

			return orphans; // dojo.NodeList

		},

		adopt: function(/*String||Array||DomNode*/ queryOrListOrNode, /*String?*/ position){

			//	summary:

			//		places any/all elements in queryOrListOrNode at a

			//		position relative to the first element in this list.

			//		Returns a dojo.NodeList of the adopted elements.

			//	queryOrListOrNode:

			//		a DOM node or a query string or a query result.

			//		Represents the nodes to be adopted relative to the

			//		first element of this NodeList.

			//	position:

			//		optional. One of:

			//			"last"||"end" (default)

			//			"first||"start"

			//			"before"

			//			"after"

			// 		or an offset in the childNodes property

			var item = this[0];

			return d.query(queryOrListOrNode).forEach(function(ai){ d.place(ai, item, (position||"last")); }); // dojo.NodeList

		},

		// FIXME: do we need this?

		query: function(/*String*/ queryStr){

			//	summary:

			//		Returns a new, flattened NodeList. Elements of the new list

			//		satisfy the passed query but use elements of the

			//		current NodeList as query roots.

			queryStr = queryStr||"";

			// FIXME: probably slow

			var ret = d.NodeList();

			this.forEach(function(item){

				d.query(queryStr, item).forEach(function(subItem){

					if(typeof subItem != "undefined"){

						ret.push(subItem);

					}

				});

			});

			return ret; // dojo.NodeList

		},

		filter: function(/*String*/ simpleQuery){

			//	summary:

			// 		"masks" the built-in javascript filter() method to support

			//		passing a simple string filter in addition to supporting

			//		filtering function objects.

			//	example:

			//		"regular" JS filter syntax as exposed in dojo.filter:

			//		|	dojo.query("*").filter(function(item){

			//		|		// highlight every paragraph

			//		|		return (item.nodeName == "p");

			//		|	}).styles("backgroundColor", "yellow");

			// example:

			//		the same filtering using a CSS selector

			//		|	dojo.query("*").filter("p").styles("backgroundColor", "yellow");

			var items = this;

			var _a = arguments;

			var r = d.NodeList();

			var rp = function(t){

				if(typeof t != "undefined"){

					r.push(t);

				}

			}

			if(d.isString(simpleQuery)){

				items = d._filterQueryResult(this, _a[0]);

				if(_a.length == 1){

					// if we only got a string query, pass back the filtered results

					return items; // dojo.NodeList

				}

				// if we got a callback, run it over the filtered items

				d.forEach(d.filter(items, _a[1], _a[2]), rp);

				return r; // dojo.NodeList

			}

			// handle the (callback, [thisObject]) case

			d.forEach(d.filter(items, _a[0], _a[1]), rp);

			return r; // dojo.NodeList

		},

		/*

		// FIXME: should this be "copyTo" and include parenting info?

		clone: function(){

			// summary:

			//		creates node clones of each element of this list

			//		and returns a new list containing the clones

		},

		*/

		addContent: function(/*String*/ content, /*String||Integer?*/ position){

			//	summary:

			//		add a node or some HTML as a string to every item in the list.

			//		Returns the original list.

			//	content:

			//		the HTML in string format to add at position to every item

			//	position:

			//		One of:

			//			"last"||"end" (default)

			//			"first||"start"

			//			"before"

			//			"after"

			//		or an integer offset in the childNodes property

			var ta = d.doc.createElement("span");

			if(d.isString(content)){

				ta.innerHTML = content;

			}else{

				ta.appendChild(content);

			}

			var ct = ((position == "first")||(position == "after")) ? "lastChild" : "firstChild";

			this.forEach(function(item){

				var tn = ta.cloneNode(true);

				while(tn[ct]){

					d.place(tn[ct], item, position);

				}

			});

			return this; // dojo.NodeList

		}

	});

	// syntactic sugar for DOM events

	d.forEach([

		"blur", "click", "keydown", "keypress", "keyup", "mousedown", "mouseenter",

		"mouseleave", "mousemove", "mouseout", "mouseover", "mouseup"

		], function(evt){

			var _oe = "on"+evt;

			dojo.NodeList.prototype[_oe] = function(a, b){

				return this.connect(_oe, a, b);

			}

				// FIXME: should these events trigger publishes?

				/*

				return (a ? this.connect(_oe, a, b) :

							this.forEach(function(n){

								// FIXME:

								//		listeners get buried by

								//		addEventListener and can't be dug back

								//		out to be triggered externally.

								// see:

								//		http://developer.mozilla.org/en/docs/DOM:element

								console.debug(n, evt, _oe);

								// FIXME: need synthetic event support!

								var _e = { target: n, faux: true, type: evt };

								// dojo._event_listener._synthesizeEvent({}, { target: n, faux: true, type: evt });

								try{ n[evt](_e); }catch(e){ console.debug(e); }

								try{ n[_oe](_e); }catch(e){ console.debug(e); }

							})

				);

			}

			*/

		}

	);

})();

}