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); }
                                                        })
                                );
                        }
                        */
                }
        );

})();

}