You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1014 lines
37 KiB
JavaScript
1014 lines
37 KiB
JavaScript
/*
|
|
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["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");
|
|
dojo.require("dojo._base.connect");
|
|
dojo.require("dojo._base.html");
|
|
|
|
|
|
(function(){
|
|
|
|
var d = dojo;
|
|
|
|
var ap = Array.prototype, aps = ap.slice, apc = ap.concat;
|
|
|
|
var tnl = function(/*Array*/ a, /*dojo.NodeList?*/ parent, /*Function?*/ NodeListCtor){
|
|
// summary:
|
|
// decorate an array to make it look like a `dojo.NodeList`.
|
|
// a:
|
|
// Array of nodes to decorate.
|
|
// parent:
|
|
// An optional parent NodeList that generated the current
|
|
// list of nodes. Used to call _stash() so the parent NodeList
|
|
// can be accessed via end() later.
|
|
// NodeListCtor:
|
|
// An optional constructor function to use for any
|
|
// new NodeList calls. This allows a certain chain of
|
|
// NodeList calls to use a different object than dojo.NodeList.
|
|
if(!a.sort){
|
|
// make sure it's a real array before we pass it on to be wrapped
|
|
a = aps.call(a, 0);
|
|
}
|
|
var ctor = NodeListCtor || this._NodeListCtor || d._NodeListCtor;
|
|
a.constructor = ctor;
|
|
dojo._mixin(a, ctor.prototype);
|
|
a._NodeListCtor = ctor;
|
|
return parent ? a._stash(parent) : a;
|
|
};
|
|
|
|
var loopBody = function(f, a, o){
|
|
a = [0].concat(aps.call(a, 0));
|
|
o = o || d.global;
|
|
return function(node){
|
|
a[0] = node;
|
|
return f.apply(o, a);
|
|
};
|
|
};
|
|
|
|
// adapters
|
|
|
|
var adaptAsForEach = function(f, o){
|
|
// summary:
|
|
// adapts a single node function to be used in the forEach-type
|
|
// actions. The initial object is returned from the specialized
|
|
// function.
|
|
// f: Function
|
|
// a function to adapt
|
|
// o: Object?
|
|
// an optional context for f
|
|
return function(){
|
|
this.forEach(loopBody(f, arguments, o));
|
|
return this; // Object
|
|
};
|
|
};
|
|
|
|
var adaptAsMap = function(f, o){
|
|
// summary:
|
|
// adapts a single node function to be used in the map-type
|
|
// actions. The return is a new array of values, as via `dojo.map`
|
|
// f: Function
|
|
// a function to adapt
|
|
// o: Object?
|
|
// an optional context for f
|
|
return function(){
|
|
return this.map(loopBody(f, arguments, o));
|
|
};
|
|
};
|
|
|
|
var adaptAsFilter = function(f, o){
|
|
// summary:
|
|
// adapts a single node function to be used in the filter-type actions
|
|
// f: Function
|
|
// a function to adapt
|
|
// o: Object?
|
|
// an optional context for f
|
|
return function(){
|
|
return this.filter(loopBody(f, arguments, o));
|
|
};
|
|
};
|
|
|
|
var adaptWithCondition = function(f, g, o){
|
|
// summary:
|
|
// adapts a single node function to be used in the map-type
|
|
// actions, behaves like forEach() or map() depending on arguments
|
|
// f: Function
|
|
// a function to adapt
|
|
// g: Function
|
|
// a condition function, if true runs as map(), otherwise runs as forEach()
|
|
// o: Object?
|
|
// an optional context for f and g
|
|
return function(){
|
|
var a = arguments, body = loopBody(f, a, o);
|
|
if(g.call(o || d.global, a)){
|
|
return this.map(body); // self
|
|
}
|
|
this.forEach(body);
|
|
return this; // self
|
|
};
|
|
};
|
|
|
|
var magicGuard = function(a){
|
|
// summary:
|
|
// the guard function for dojo.attr() and dojo.style()
|
|
return a.length == 1 && (typeof a[0] == "string"); // inline'd type check
|
|
};
|
|
|
|
var orphan = function(node){
|
|
// summary:
|
|
// function to orphan nodes
|
|
var p = node.parentNode;
|
|
if(p){
|
|
p.removeChild(node);
|
|
}
|
|
};
|
|
// FIXME: should we move orphan() to dojo.html?
|
|
|
|
dojo.NodeList = function(){
|
|
// summary:
|
|
// dojo.NodeList is an of Array subclass 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.
|
|
// description:
|
|
// dojo.NodeList instances provide many utilities that reflect
|
|
// core Dojo APIs for Array iteration and manipulation, DOM
|
|
// manipulation, and event handling. Instead of needing to dig up
|
|
// functions in the dojo.* namespace, NodeLists generally make the
|
|
// full power of Dojo available for DOM manipulation tasks in a
|
|
// simple, chainable way.
|
|
// example:
|
|
// create a node list from a node
|
|
// | new dojo.NodeList(dojo.byId("foo"));
|
|
// example:
|
|
// get a NodeList from a CSS query and iterate on it
|
|
// | var l = dojo.query(".thinger");
|
|
// | l.forEach(function(node, index, nodeList){
|
|
// | console.log(index, node.innerHTML);
|
|
// | });
|
|
// example:
|
|
// use native and Dojo-provided array methods to manipulate a
|
|
// NodeList without needing to use dojo.* functions explicitly:
|
|
// | var l = dojo.query(".thinger");
|
|
// | // since NodeLists are real arrays, they have a length
|
|
// | // property that is both readable and writable and
|
|
// | // push/pop/shift/unshift methods
|
|
// | console.log(l.length);
|
|
// | l.push(dojo.create("span"));
|
|
// |
|
|
// | // dojo's normalized array methods work too:
|
|
// | console.log( l.indexOf(dojo.byId("foo")) );
|
|
// | // ...including the special "function as string" shorthand
|
|
// | console.log( l.every("item.nodeType == 1") );
|
|
// |
|
|
// | // NodeLists can be [..] indexed, or you can use the at()
|
|
// | // function to get specific items wrapped in a new NodeList:
|
|
// | var node = l[3]; // the 4th element
|
|
// | var newList = l.at(1, 3); // the 2nd and 4th elements
|
|
// example:
|
|
// the style functions you expect are all there too:
|
|
// | // style() as a getter...
|
|
// | var borders = dojo.query(".thinger").style("border");
|
|
// | // ...and as a setter:
|
|
// | dojo.query(".thinger").style("border", "1px solid black");
|
|
// | // class manipulation
|
|
// | dojo.query("li:nth-child(even)").addClass("even");
|
|
// | // even getting the coordinates of all the items
|
|
// | var coords = dojo.query(".thinger").coords();
|
|
// example:
|
|
// DOM manipulation functions from the dojo.* namespace area also
|
|
// available:
|
|
// | // remove all of the elements in the list from their
|
|
// | // parents (akin to "deleting" them from the document)
|
|
// | dojo.query(".thinger").orphan();
|
|
// | // place all elements in the list at the front of #foo
|
|
// | dojo.query(".thinger").place("foo", "first");
|
|
// example:
|
|
// Event handling couldn't be easier. `dojo.connect` is mapped in,
|
|
// and shortcut handlers are provided for most DOM events:
|
|
// | // like dojo.connect(), but with implicit scope
|
|
// | dojo.query("li").connect("onclick", console, "log");
|
|
// |
|
|
// | // many common event handlers are already available directly:
|
|
// | dojo.query("li").onclick(console, "log");
|
|
// | var toggleHovered = dojo.hitch(dojo, "toggleClass", "hovered");
|
|
// | dojo.query("p")
|
|
// | .onmouseenter(toggleHovered)
|
|
// | .onmouseleave(toggleHovered);
|
|
// example:
|
|
// chainability is a key advantage of NodeLists:
|
|
// | dojo.query(".thinger")
|
|
// | .onclick(function(e){ /* ... */ })
|
|
// | .at(1, 3, 8) // get a subset
|
|
// | .style("padding", "5px")
|
|
// | .forEach(console.log);
|
|
|
|
return tnl(Array.apply(null, arguments));
|
|
};
|
|
|
|
//Allow things that new up a NodeList to use a delegated or alternate NodeList implementation.
|
|
d._NodeListCtor = d.NodeList;
|
|
|
|
var nl = d.NodeList, nlp = nl.prototype;
|
|
|
|
// expose adapters and the wrapper as private functions
|
|
|
|
nl._wrap = nlp._wrap = tnl;
|
|
nl._adaptAsMap = adaptAsMap;
|
|
nl._adaptAsForEach = adaptAsForEach;
|
|
nl._adaptAsFilter = adaptAsFilter;
|
|
nl._adaptWithCondition = adaptWithCondition;
|
|
|
|
// mass assignment
|
|
|
|
// add array redirectors
|
|
d.forEach(["slice", "splice"], function(name){
|
|
var f = ap[name];
|
|
//Use a copy of the this array via this.slice() to allow .end() to work right in the splice case.
|
|
// CANNOT apply ._stash()/end() to splice since it currently modifies
|
|
// the existing this array -- it would break backward compatibility if we copy the array before
|
|
// the splice so that we can use .end(). So only doing the stash option to this._wrap for slice.
|
|
nlp[name] = function(){ return this._wrap(f.apply(this, arguments), name == "slice" ? this : null); };
|
|
});
|
|
// concat should be here but some browsers with native NodeList have problems with it
|
|
|
|
// add array.js redirectors
|
|
d.forEach(["indexOf", "lastIndexOf", "every", "some"], function(name){
|
|
var f = d[name];
|
|
nlp[name] = function(){ return f.apply(d, [this].concat(aps.call(arguments, 0))); };
|
|
});
|
|
|
|
// add conditional methods
|
|
d.forEach(["attr", "style"], function(name){
|
|
nlp[name] = adaptWithCondition(d[name], magicGuard);
|
|
});
|
|
|
|
// add forEach actions
|
|
d.forEach(["connect", "addClass", "removeClass", "replaceClass", "toggleClass", "empty", "removeAttr"], function(name){
|
|
nlp[name] = adaptAsForEach(d[name]);
|
|
});
|
|
|
|
dojo.extend(dojo.NodeList, {
|
|
_normalize: function(/*String||Element||Object||NodeList*/content, /*DOMNode?*/refNode){
|
|
// summary:
|
|
// normalizes data to an array of items to insert.
|
|
// description:
|
|
// If content is an object, it can have special properties "template" and
|
|
// "parse". If "template" is defined, then the template value is run through
|
|
// dojo.string.substitute (if dojo.string.substitute has been dojo.required elsewhere),
|
|
// or if templateFunc is a function on the content, that function will be used to
|
|
// transform the template into a final string to be used for for passing to dojo._toDom.
|
|
// If content.parse is true, then it is remembered for later, for when the content
|
|
// nodes are inserted into the DOM. At that point, the nodes will be parsed for widgets
|
|
// (if dojo.parser has been dojo.required elsewhere).
|
|
|
|
//Wanted to just use a DocumentFragment, but for the array/NodeList
|
|
//case that meant using cloneNode, but we may not want that.
|
|
//Cloning should only happen if the node operations span
|
|
//multiple refNodes. Also, need a real array, not a NodeList from the
|
|
//DOM since the node movements could change those NodeLists.
|
|
|
|
var parse = content.parse === true ? true : false;
|
|
|
|
//Do we have an object that needs to be run through a template?
|
|
if(typeof content.template == "string"){
|
|
var templateFunc = content.templateFunc || (dojo.string && dojo.string.substitute);
|
|
content = templateFunc ? templateFunc(content.template, content) : content;
|
|
}
|
|
|
|
var type = (typeof content);
|
|
if(type == "string" || type == "number"){
|
|
content = dojo._toDom(content, (refNode && refNode.ownerDocument));
|
|
if(content.nodeType == 11){
|
|
//DocumentFragment. It cannot handle cloneNode calls, so pull out the children.
|
|
content = dojo._toArray(content.childNodes);
|
|
}else{
|
|
content = [content];
|
|
}
|
|
}else if(!dojo.isArrayLike(content)){
|
|
content = [content];
|
|
}else if(!dojo.isArray(content)){
|
|
//To get to this point, content is array-like, but
|
|
//not an array, which likely means a DOM NodeList. Convert it now.
|
|
content = dojo._toArray(content);
|
|
}
|
|
|
|
//Pass around the parse info
|
|
if(parse){
|
|
content._runParse = true;
|
|
}
|
|
return content; //Array
|
|
},
|
|
|
|
_cloneNode: function(/*DOMNode*/ node){
|
|
// summary:
|
|
// private utility to clone a node. Not very interesting in the vanilla
|
|
// dojo.NodeList case, but delegates could do interesting things like
|
|
// clone event handlers if that is derivable from the node.
|
|
return node.cloneNode(true);
|
|
},
|
|
|
|
_place: function(/*Array*/ary, /*DOMNode*/refNode, /*String*/position, /*Boolean*/useClone){
|
|
// summary:
|
|
// private utility to handle placing an array of nodes relative to another node.
|
|
// description:
|
|
// Allows for cloning the nodes in the array, and for
|
|
// optionally parsing widgets, if ary._runParse is true.
|
|
|
|
//Avoid a disallowed operation if trying to do an innerHTML on a non-element node.
|
|
if(refNode.nodeType != 1 && position == "only"){
|
|
return;
|
|
}
|
|
var rNode = refNode, tempNode;
|
|
|
|
//Always cycle backwards in case the array is really a
|
|
//DOM NodeList and the DOM operations take it out of the live collection.
|
|
var length = ary.length;
|
|
for(var i = length - 1; i >= 0; i--){
|
|
var node = (useClone ? this._cloneNode(ary[i]) : ary[i]);
|
|
|
|
//If need widget parsing, use a temp node, instead of waiting after inserting into
|
|
//real DOM because we need to start widget parsing at one node up from current node,
|
|
//which could cause some already parsed widgets to be parsed again.
|
|
if(ary._runParse && dojo.parser && dojo.parser.parse){
|
|
if(!tempNode){
|
|
tempNode = rNode.ownerDocument.createElement("div");
|
|
}
|
|
tempNode.appendChild(node);
|
|
dojo.parser.parse(tempNode);
|
|
node = tempNode.firstChild;
|
|
while(tempNode.firstChild){
|
|
tempNode.removeChild(tempNode.firstChild);
|
|
}
|
|
}
|
|
|
|
if(i == length - 1){
|
|
dojo.place(node, rNode, position);
|
|
}else{
|
|
rNode.parentNode.insertBefore(node, rNode);
|
|
}
|
|
rNode = node;
|
|
}
|
|
},
|
|
|
|
_stash: function(parent){
|
|
// summary:
|
|
// private function to hold to a parent NodeList. end() to return the parent NodeList.
|
|
//
|
|
// example:
|
|
// How to make a `dojo.NodeList` method that only returns the third node in
|
|
// the dojo.NodeList but allows access to the original NodeList by using this._stash:
|
|
// | dojo.extend(dojo.NodeList, {
|
|
// | third: function(){
|
|
// | var newNodeList = dojo.NodeList(this[2]);
|
|
// | return newNodeList._stash(this);
|
|
// | }
|
|
// | });
|
|
// | // then see how _stash applies a sub-list, to be .end()'ed out of
|
|
// | dojo.query(".foo")
|
|
// | .third()
|
|
// | .addClass("thirdFoo")
|
|
// | .end()
|
|
// | // access to the orig .foo list
|
|
// | .removeClass("foo")
|
|
// |
|
|
//
|
|
this._parent = parent;
|
|
return this; //dojo.NodeList
|
|
},
|
|
|
|
end: function(){
|
|
// summary:
|
|
// Ends use of the current `dojo.NodeList` by returning the previous dojo.NodeList
|
|
// that generated the current dojo.NodeList.
|
|
// description:
|
|
// Returns the `dojo.NodeList` that generated the current `dojo.NodeList`. If there
|
|
// is no parent dojo.NodeList, an empty dojo.NodeList is returned.
|
|
// example:
|
|
// | dojo.query("a")
|
|
// | .filter(".disabled")
|
|
// | // operate on the anchors that only have a disabled class
|
|
// | .style("color", "grey")
|
|
// | .end()
|
|
// | // jump back to the list of anchors
|
|
// | .style(...)
|
|
//
|
|
if(this._parent){
|
|
return this._parent;
|
|
}else{
|
|
//Just return empty list.
|
|
return new this._NodeListCtor();
|
|
}
|
|
},
|
|
|
|
// 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 Mozilla's (slice
|
|
// documentation)[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.
|
|
return this._wrap(a.slice.apply(this, arguments));
|
|
},
|
|
|
|
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 Mozilla's (splice
|
|
// documentation)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:splice]
|
|
// For backwards compatibility, calling .end() on the spliced NodeList
|
|
// does not return the original NodeList -- splice alters the NodeList in place.
|
|
// 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
|
|
return this._wrap(a.splice.apply(this, arguments));
|
|
},
|
|
|
|
indexOf: function(value, fromIndex){
|
|
// summary:
|
|
// see dojo.indexOf(). The primary difference is that the acted-on
|
|
// array is implicitly this NodeList
|
|
// value: Object:
|
|
// The value to search for.
|
|
// fromIndex: Integer?:
|
|
// The location to start searching from. Optional. Defaults to 0.
|
|
// description:
|
|
// For more details on the behavior of indexOf, see Mozilla's
|
|
// (indexOf
|
|
// docs)[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
|
|
// Mozilla's (lastIndexOf
|
|
// docs)[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 location to start searching from. Optional. Defaults to 0.
|
|
// returns:
|
|
// Positive Integer or 0 for a match, -1 of not found.
|
|
return d.lastIndexOf(this, value, fromIndex); // Integer
|
|
},
|
|
|
|
every: function(callback, thisObject){
|
|
// summary:
|
|
// see `dojo.every()` and the (Array.every
|
|
// docs)[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
|
|
// callback: Function: the callback
|
|
// thisObject: Object?: the context
|
|
return d.every(this, callback, thisObject); // Boolean
|
|
},
|
|
|
|
some: function(callback, thisObject){
|
|
// summary:
|
|
// Takes the same structure of arguments and returns as
|
|
// `dojo.some()` with the caveat that the passed array is
|
|
// implicitly this NodeList. See `dojo.some()` and Mozilla's
|
|
// (Array.some
|
|
// documentation)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:some].
|
|
// callback: Function: the callback
|
|
// thisObject: Object?: the context
|
|
return d.some(this, callback, thisObject); // Boolean
|
|
},
|
|
=====*/
|
|
|
|
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 the (Array.concat
|
|
// docs)[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
|
|
|
|
//return this._wrap(apc.apply(this, arguments));
|
|
// the line above won't work for the native NodeList :-(
|
|
|
|
// implementation notes:
|
|
// 1) Native NodeList is not an array, and cannot be used directly
|
|
// in concat() --- the latter doesn't recognize it as an array, and
|
|
// does not inline it, but append as a single entity.
|
|
// 2) On some browsers (e.g., Safari) the "constructor" property is
|
|
// read-only and cannot be changed. So we have to test for both
|
|
// native NodeList and dojo.NodeList in this property to recognize
|
|
// the node list.
|
|
|
|
var t = d.isArray(this) ? this : aps.call(this, 0),
|
|
m = d.map(arguments, function(a){
|
|
return a && !d.isArray(a) &&
|
|
(typeof NodeList != "undefined" && a.constructor === NodeList || a.constructor === this._NodeListCtor) ?
|
|
aps.call(a, 0) : a;
|
|
});
|
|
return this._wrap(apc.apply(t, m), this); // dojo.NodeList
|
|
},
|
|
|
|
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
|
|
return this._wrap(d.map(this, func, obj), this); // dojo.NodeList
|
|
},
|
|
|
|
forEach: function(callback, thisObj){
|
|
// summary:
|
|
// see `dojo.forEach()`. The primary difference is that the acted-on
|
|
// array is implicitly this NodeList. If you want the option to break out
|
|
// of the forEach loop, use every() or some() instead.
|
|
d.forEach(this, callback, thisObj);
|
|
// non-standard return to allow easier chaining
|
|
return this; // dojo.NodeList
|
|
},
|
|
|
|
/*=====
|
|
coords: function(){
|
|
// summary:
|
|
// Returns the box objects of all elements in a node list as
|
|
// an Array (*not* a NodeList). Acts like `dojo.coords`, though assumes
|
|
// the node passed is each node in this list.
|
|
|
|
return d.map(this, d.coords); // Array
|
|
},
|
|
|
|
position: function(){
|
|
// summary:
|
|
// Returns border-box objects (x/y/w/h) of all elements in a node list
|
|
// as an Array (*not* a NodeList). Acts like `dojo.position`, though
|
|
// assumes the node passed is each node in this list.
|
|
|
|
return d.map(this, d.position); // Array
|
|
},
|
|
|
|
attr: function(property, value){
|
|
// summary:
|
|
// gets or sets the DOM attribute for every element in the
|
|
// NodeList. See also `dojo.attr`
|
|
// property: String
|
|
// the attribute to get/set
|
|
// value: String?
|
|
// optional. The value to set the property to
|
|
// returns:
|
|
// if no value is passed, the result is an array of attribute values
|
|
// If a value is passed, the return is this NodeList
|
|
// example:
|
|
// Make all nodes with a particular class focusable:
|
|
// | dojo.query(".focusable").attr("tabIndex", -1);
|
|
// example:
|
|
// Disable a group of buttons:
|
|
// | dojo.query("button.group").attr("disabled", true);
|
|
// example:
|
|
// innerHTML can be assigned or retrieved as well:
|
|
// | // get the innerHTML (as an array) for each list item
|
|
// | var ih = dojo.query("li.replaceable").attr("innerHTML");
|
|
return; // dojo.NodeList
|
|
return; // Array
|
|
},
|
|
|
|
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
|
|
// returns:
|
|
// if no value is passed, the result is an array of strings.
|
|
// If a value is passed, the return is this NodeList
|
|
return; // dojo.NodeList
|
|
return; // Array
|
|
},
|
|
|
|
addClass: function(className){
|
|
// summary:
|
|
// adds the specified class to every node in the list
|
|
// className: String|Array
|
|
// A String class name to add, or several space-separated class names,
|
|
// or an array of class names.
|
|
return; // dojo.NodeList
|
|
},
|
|
|
|
removeClass: function(className){
|
|
// summary:
|
|
// removes the specified class from every node in the list
|
|
// className: String|Array?
|
|
// An optional String class name to remove, or several space-separated
|
|
// class names, or an array of class names. If omitted, all class names
|
|
// will be deleted.
|
|
// returns:
|
|
// dojo.NodeList, this list
|
|
return; // dojo.NodeList
|
|
},
|
|
|
|
toggleClass: function(className, condition){
|
|
// summary:
|
|
// Adds a class to node if not present, or removes if present.
|
|
// Pass a boolean condition if you want to explicitly add or remove.
|
|
// condition: Boolean?
|
|
// If passed, true means to add the class, false means to remove.
|
|
// className: String
|
|
// the CSS class to add
|
|
return; // dojo.NodeList
|
|
},
|
|
|
|
connect: function(methodName, objOrFunc, funcName){
|
|
// summary:
|
|
// attach event handlers to every item of the NodeList. Uses dojo.connect()
|
|
// so event properties are normalized
|
|
// methodName: String
|
|
// the name of the method to attach to. For DOM events, this should be
|
|
// the lower-case name of the event
|
|
// objOrFunc: Object|Function|String
|
|
// 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: String?
|
|
// 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("div:nth-child(odd)").connect("onclick", function(e){
|
|
// | console.log("clicked!");
|
|
// | });
|
|
// example:
|
|
// attach foo.bar() to every odd div's onmouseover
|
|
// | dojo.query("div:nth-child(odd)").connect("onmouseover", foo, "bar");
|
|
},
|
|
|
|
empty: function(){
|
|
// summary:
|
|
// clears all content from each node in the list. Effectively
|
|
// equivalent to removing all child nodes from every item in
|
|
// the list.
|
|
return this.forEach("item.innerHTML='';"); // dojo.NodeList
|
|
// FIXME: should we be checking for and/or disposing of widgets below these nodes?
|
|
},
|
|
=====*/
|
|
|
|
// useful html methods
|
|
coords: adaptAsMap(d.coords),
|
|
position: adaptAsMap(d.position),
|
|
|
|
// FIXME: connectPublisher()? connectRunOnce()?
|
|
|
|
/*
|
|
destroy: function(){
|
|
// summary:
|
|
// destroys every item in the list.
|
|
this.forEach(d.destroy);
|
|
// FIXME: should we be checking for and/or disposing of widgets below these nodes?
|
|
},
|
|
*/
|
|
|
|
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. See: `dojo.place`
|
|
// 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" (default)
|
|
// | "first"
|
|
// | "before"
|
|
// | "after"
|
|
// | "only"
|
|
// | "replace"
|
|
// or an offset in the childNodes property
|
|
var item = d.query(queryOrNode)[0];
|
|
return this.forEach(function(node){ d.place(node, item, position); }); // dojo.NodeList
|
|
},
|
|
|
|
orphan: function(/*String?*/ filter){
|
|
// summary:
|
|
// removes elements in this list that match the filter
|
|
// from their parents and returns them as a new NodeList.
|
|
// filter:
|
|
// CSS selector like ".foo" or "div > span"
|
|
// returns:
|
|
// `dojo.NodeList` containing the orphaned elements
|
|
return (filter ? d._filterQueryResult(this, filter) : this).forEach(orphan); // 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:
|
|
// can be one of:
|
|
// | "last" (default)
|
|
// | "first"
|
|
// | "before"
|
|
// | "after"
|
|
// | "only"
|
|
// | "replace"
|
|
// or an offset in the childNodes property
|
|
return d.query(queryOrListOrNode).place(this[0], position)._stash(this); // dojo.NodeList
|
|
},
|
|
|
|
// FIXME: do we need this?
|
|
query: function(/*String*/ queryStr){
|
|
// summary:
|
|
// Returns a new list whose members match the passed query,
|
|
// assuming elements of the current NodeList as the root for
|
|
// each search.
|
|
// example:
|
|
// assume a DOM created by this markup:
|
|
// | <div id="foo">
|
|
// | <p>
|
|
// | bacon is tasty, <span>dontcha think?</span>
|
|
// | </p>
|
|
// | </div>
|
|
// | <div id="bar">
|
|
// | <p>great comedians may not be funny <span>in person</span></p>
|
|
// | </div>
|
|
// If we are presented with the following definition for a NodeList:
|
|
// | var l = new dojo.NodeList(dojo.byId("foo"), dojo.byId("bar"));
|
|
// it's possible to find all span elements under paragraphs
|
|
// contained by these elements with this sub-query:
|
|
// | var spans = l.query("p span");
|
|
|
|
// FIXME: probably slow
|
|
if(!queryStr){ return this; }
|
|
var ret = this.map(function(node){
|
|
// FIXME: why would we ever get undefined here?
|
|
return d.query(queryStr, node).filter(function(subNode){ return subNode !== undefined; });
|
|
});
|
|
return this._wrap(apc.apply([], ret), this); // dojo.NodeList
|
|
},
|
|
|
|
filter: function(/*String|Function*/ filter){
|
|
// summary:
|
|
// "masks" the built-in javascript filter() method (supported
|
|
// in Dojo via `dojo.filter`) to support passing a simple
|
|
// string filter in addition to supporting filtering function
|
|
// objects.
|
|
// filter:
|
|
// If a string, a CSS rule like ".thinger" or "div > span".
|
|
// example:
|
|
// "regular" JS filter syntax as exposed in dojo.filter:
|
|
// | dojo.query("*").filter(function(item){
|
|
// | // highlight every paragraph
|
|
// | return (item.nodeName == "p");
|
|
// | }).style("backgroundColor", "yellow");
|
|
// example:
|
|
// the same filtering using a CSS selector
|
|
// | dojo.query("*").filter("p").styles("backgroundColor", "yellow");
|
|
|
|
var a = arguments, items = this, start = 0;
|
|
if(typeof filter == "string"){ // inline'd type check
|
|
items = d._filterQueryResult(this, a[0]);
|
|
if(a.length == 1){
|
|
// if we only got a string query, pass back the filtered results
|
|
return items._stash(this); // dojo.NodeList
|
|
}
|
|
// if we got a callback, run it over the filtered items
|
|
start = 1;
|
|
}
|
|
return this._wrap(d.filter(items, a[start], a[start + 1]), this); // 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||DomNode||Object||dojo.NodeList*/ content, /*String||Integer?*/ position){
|
|
// summary:
|
|
// add a node, NodeList or some HTML as a string to every item in the
|
|
// list. Returns the original list.
|
|
// description:
|
|
// a copy of the HTML content is added to each item in the
|
|
// list, with an optional position argument. If no position
|
|
// argument is provided, the content is appended to the end of
|
|
// each item.
|
|
// content:
|
|
// DOM node, HTML in string format, a NodeList or an Object. If a DOM node or
|
|
// NodeList, the content will be cloned if the current NodeList has more than one
|
|
// element. Only the DOM nodes are cloned, no event handlers. If it is an Object,
|
|
// it should be an object with at "template" String property that has the HTML string
|
|
// to insert. If dojo.string has already been dojo.required, then dojo.string.substitute
|
|
// will be used on the "template" to generate the final HTML string. Other allowed
|
|
// properties on the object are: "parse" if the HTML
|
|
// string should be parsed for widgets (dojo.require("dojo.parser") to get that
|
|
// option to work), and "templateFunc" if a template function besides dojo.string.substitute
|
|
// should be used to transform the "template".
|
|
// position:
|
|
// can be one of:
|
|
// | "last"||"end" (default)
|
|
// | "first||"start"
|
|
// | "before"
|
|
// | "after"
|
|
// | "replace" (replaces nodes in this NodeList with new content)
|
|
// | "only" (removes other children of the nodes so new content is the only child)
|
|
// or an offset in the childNodes property
|
|
// example:
|
|
// appends content to the end if the position is omitted
|
|
// | dojo.query("h3 > p").addContent("hey there!");
|
|
// example:
|
|
// add something to the front of each element that has a
|
|
// "thinger" property:
|
|
// | dojo.query("[thinger]").addContent("...", "first");
|
|
// example:
|
|
// adds a header before each element of the list
|
|
// | dojo.query(".note").addContent("<h4>NOTE:</h4>", "before");
|
|
// example:
|
|
// add a clone of a DOM node to the end of every element in
|
|
// the list, removing it from its existing parent.
|
|
// | dojo.query(".note").addContent(dojo.byId("foo"));
|
|
// example:
|
|
// Append nodes from a templatized string.
|
|
// dojo.require("dojo.string");
|
|
// dojo.query(".note").addContent({
|
|
// template: '<b>${id}: </b><span>${name}</span>',
|
|
// id: "user332",
|
|
// name: "Mr. Anderson"
|
|
// });
|
|
// example:
|
|
// Append nodes from a templatized string that also has widgets parsed.
|
|
// dojo.require("dojo.string");
|
|
// dojo.require("dojo.parser");
|
|
// var notes = dojo.query(".note").addContent({
|
|
// template: '<button dojoType="dijit.form.Button">${text}</button>',
|
|
// parse: true,
|
|
// text: "Send"
|
|
// });
|
|
content = this._normalize(content, this[0]);
|
|
for(var i = 0, node; (node = this[i]); i++){
|
|
this._place(content, node, position, i > 0);
|
|
}
|
|
return this; //dojo.NodeList
|
|
},
|
|
|
|
instantiate: function(/*String|Object*/ declaredClass, /*Object?*/ properties){
|
|
// summary:
|
|
// Create a new instance of a specified class, using the
|
|
// specified properties and each node in the nodeList as a
|
|
// srcNodeRef.
|
|
// example:
|
|
// Grabs all buttons in the page and converts them to diji.form.Buttons.
|
|
// | var buttons = dojo.query("button").instantiate("dijit.form.Button", {showLabel: true});
|
|
var c = d.isFunction(declaredClass) ? declaredClass : d.getObject(declaredClass);
|
|
properties = properties || {};
|
|
return this.forEach(function(node){
|
|
new c(properties, node);
|
|
}); // dojo.NodeList
|
|
},
|
|
|
|
at: function(/*===== index =====*/){
|
|
// summary:
|
|
// Returns a new NodeList comprised of items in this NodeList
|
|
// at the given index or indices.
|
|
//
|
|
// index: Integer...
|
|
// One or more 0-based indices of items in the current
|
|
// NodeList. A negative index will start at the end of the
|
|
// list and go backwards.
|
|
//
|
|
// example:
|
|
// Shorten the list to the first, second, and third elements
|
|
// | dojo.query("a").at(0, 1, 2).forEach(fn);
|
|
//
|
|
// example:
|
|
// Retrieve the first and last elements of a unordered list:
|
|
// | dojo.query("ul > li").at(0, -1).forEach(cb);
|
|
//
|
|
// example:
|
|
// Do something for the first element only, but end() out back to
|
|
// the original list and continue chaining:
|
|
// | dojo.query("a").at(0).onclick(fn).end().forEach(function(n){
|
|
// | console.log(n); // all anchors on the page.
|
|
// | })
|
|
//
|
|
// returns:
|
|
// dojo.NodeList
|
|
var t = new this._NodeListCtor();
|
|
d.forEach(arguments, function(i){
|
|
if(i < 0){ i = this.length + i }
|
|
if(this[i]){ t.push(this[i]); }
|
|
}, this);
|
|
return t._stash(this); // dojo.NodeList
|
|
}
|
|
|
|
});
|
|
|
|
nl.events = [
|
|
// summary:
|
|
// list of all DOM events used in NodeList
|
|
"blur", "focus", "change", "click", "error", "keydown", "keypress",
|
|
"keyup", "load", "mousedown", "mouseenter", "mouseleave", "mousemove",
|
|
"mouseout", "mouseover", "mouseup", "submit"
|
|
];
|
|
|
|
// FIXME: pseudo-doc the above automatically generated on-event functions
|
|
|
|
// syntactic sugar for DOM events
|
|
d.forEach(nl.events, function(evt){
|
|
var _oe = "on" + evt;
|
|
nlp[_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.log(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.log(e); }
|
|
try{ n[_oe](_e); }catch(e){ console.log(e); }
|
|
})
|
|
);
|
|
*/
|
|
}
|
|
);
|
|
|
|
})();
|
|
|
|
}
|