Changeset 11044 in legacy


Ignore:
Timestamp:
Oct 22, 2007 6:11:45 AM (8 years ago)
Author:
alex
Message:

Fixes #4821. Fixes #4378. Now NodeLists are just arrays augmented with extra methods. splice() and slice() are still oddballs, but will be fixed shortly (in the same manner).

Location:
dojo/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • dojo/trunk/_base/NodeList.js

    r10594 r11044  
    33dojo.require("dojo._base.array");
    44
    5 // FIXME: need to provide a location to extend this object!!
    6 // FIXME: need to write explicit tests for NodeList
    7 // FIXME: what do the builtin's that we deferr to do when you concat? What gets
    8 //                      returned? Seems (on FF) to be an Array, not a NodeList!
    9 
    105(function(){
    116
    127        var d = dojo;
     8        var tnl = function(a){
     9                a.constructor = dojo.NodeList;
     10                dojo._mixin(a, dojo.NodeList.prototype);
     11                return a;
     12        }
     13
    1314        dojo.NodeList = function(){
    1415                //      summary:
     
    2122                //              new dojo.NodeList(dojo.byId("foo"));
    2223
     24                var i = [];
     25                // i.prototype = dojo.NodeList.prototype;
    2326                var args = arguments;
    2427
    2528                // make it behave like the Array constructor
    2629                if((args.length == 1)&&(typeof args[0] == "number")){
    27                         this.length = parseInt(args[0]);
     30                        i.length = parseInt(args[0]);
    2831                }else if(args.length){
    29                         d.forEach(args, function(i){ this.push(i); }, this);
     32                        d.forEach(args, function(item){ i.push(item); });
    3033                }
     34                return tnl(i);
    3135        }
    3236
    33         // prototyping subclass for sane browsers
    34         dojo.NodeList.prototype = new Array;
    35 
    36         // now, make sure it's an array subclass on IE:
    37         //
    38         // huge thanks to Dean Edwards and Hedger Wang for a solution to
    39         // subclassing arrays on IE
    40         //              http://dean.edwards.name/weblog/2006/11/hooray/?full
    41         //              http://www.hedgerwow.com/360/dhtml/js-array2.html
    42         // if(!Array.forEach){
    43         // make sure that it has all the JS 1.6 things we need before we subclass
    44         if(d.isIE){
    45 
    46                 var subClassStr = function(className){
    47                         return (
    48                                 // "parent.dojo.debug('setting it up...'); " +
    49                                 "var a2 = parent."+className+"; " +
    50                                 "var ap = Array.prototype; " +
    51                                 "var a2p = a2.prototype; " +
    52                                 "for(var x in a2p){ ap[x] = a2p[x]; } " +
    53                                 "parent."+className+" = Array; "
    54                         );
    55                 }
    56                 var scs = subClassStr("dojo.NodeList");
    57                 // Hedger's excellent invention
    58                 var popup = window.createPopup()
    59                 popup.document.write("<script>"+scs+"</script>");
    60                 // our fix to ensure that we don't hit strange scoping/timing issues
    61                 // insisde of setTimeout() blocks
    62                 popup.show(1, 1, 1, 1);
    63         }
    64 
    65 
    66         dojo.extend(dojo.NodeList,      {
     37        dojo.extend(dojo.NodeList, {
    6738                // http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array#Methods
    68 
    69                 // FIXME: would it be smaller if we set these w/ iteration?
    7039
    7140                // FIXME: handle return values for #3244
     
    7645                //                      slice
    7746                //                      splice
    78                 //                      concat
    7947                //                      join (perhaps w/ innerHTML/outerHTML overload for toString() of items?)
    8048                //                      reduce
    8149                //                      reduceRight
     50
     51                concat: function(){
     52                        var a = dojo._toArray(arguments);
     53                        a.unshift(this);
     54                        return tnl(a.concat.apply([], a));
     55                },
    8256               
    8357                indexOf: function(/*Object*/ value, /*Integer?*/ fromIndex){
     
    291265
    292266                        // FIXME: probably slow
    293                         var ret = new d.NodeList();
     267                        var ret = d.NodeList();
    294268                        this.forEach(function(item){
    295269                                d.query(queryStr, item).forEach(function(subItem){
     
    319293                        var items = this;
    320294                        var _a = arguments;
    321                         var r = new d.NodeList();
     295                        var r = d.NodeList();
    322296                        var rp = function(t){
    323297                                if(typeof t != "undefined"){
     
    428402                        return this._anim("animateProperty", args); // dojo._Animation
    429403                }
    430 
    431404        });
    432405
    433406        // syntactic sugar for DOM events
    434         dojo.forEach([
     407        d.forEach([
    435408                "mouseover", "click", "mouseout", "mousemove", "blur", "mousedown",
    436409                "mouseup", "mousemove", "keydown", "keyup", "keypress", "mouseenter",
     
    465438                }
    466439        );
     440
    467441})();
  • dojo/trunk/tests/_base/NodeList.html

    r10298 r11044  
    6969
    7070                                                        var r = nl.forEach(function(i, idx, arr){
    71                                                                 t.t(arr instanceof dojo.NodeList);
     71                                                                t.t(arr.constructor == dojo.NodeList);
    7272                                                                t.is(2, arr.length);
    7373                                                        });
    74                                                         t.t(r instanceof dojo.NodeList);
     74                                                        t.t(r.constructor == dojo.NodeList);
    7575                                                        t.is(r, nl);
    7676                                                },
     
    130130                                                        // t.is(ret, [0, 1, 2, 3]);
    131131
    132                                                         t.t(ret instanceof dojo.NodeList);
     132                                                        t.t(ret.constructor == dojo.NodeList);
    133133
    134134                                                        // make sure that map() returns a NodeList
     
    186186                                                },
    187187
    188                                                 /*
    189188                                                function concat(t){
    190189                                                        var s = dojo.query("span");
    191190                                                        var d = dojo.query("div");
    192                                                         t.t(s.concat(d) instanceof dojo.NodeList);
     191                                                        console.debug(s.concat(d));
     192                                                        t.is(s.concat(d).constructor, dojo.NodeList);
    193193                                                        t.is((d.length + s.length), s.concat(d).length);
    194                                                         t.t(s.concat([]) instanceof dojo.NodeList);
    195                                                 },
    196                                                 */
     194                                                },
     195
     196                                                function concat2(t){
     197                                                        var s = dojo.query("span");
     198                                                        var d = dojo.query("div");
     199                                                        t.is(s.concat([]).constructor, dojo.NodeList);
     200                                                },
    197201                                               
    198202                                                function place(t){
     
    203207                                                        dojo.body().appendChild(tn);
    204208                                                        var nl = dojo.query("b", tn).place(tn, "first");
    205                                                         t.t(nl instanceof dojo.NodeList);
     209                                                        t.t(nl.constructor == dojo.NodeList);
    206210                                                        t.is(1, nl.length);
    207211                                                        t.is("b", nl[0].nodeName.toLowerCase());
     
    217221                                                        dojo.body().appendChild(tn);
    218222                                                        var nl = dojo.query("span", tn).orphan();
    219                                                         t.t(nl instanceof dojo.NodeList);
     223                                                        t.t(nl.constructor == dojo.NodeList);
    220224
    221225                                                        t.is(2, nl.length);
Note: See TracChangeset for help on using the changeset viewer.