Changeset 8235

Timestamp:

04/21/07 18:25:14 (19 months ago)

Author:

alex

Message:

committing Scott's new keyboard handling work + tests. Refs #2641. Still needs more unit tests.

Location:

dojo/trunk

Files:

• tests/_base/connect.js (modified) (4 diffs)
• _base/connect.js (modified) (3 diffs)
• _base/event.js (modified) (12 diffs)
• _base/lang.js (modified) (1 diff)

dojo/trunk/tests/_base/connect.js

@@ -1 +1 @@
 dojo.provide("tests._base.connect");
 
-hub = function() {
-}
-
-bad = function() {
+hub = function(){
+}
+
+failures = 0;
+bad = function(){
         failures++;
-        //logMe('BAD - I should have been disconnected');
-}
-
-good = function() {
-        //logMe("good - I'm supposed to be here");
-}
-
-markAndSweepTest = function(iterations) {
-        //console.group('markAndSweepTest(' + iterations + ');');
+}
+
+good = function(){
+}
+
+// make 'iterations' connections to hub
+// roughly half of which will be to 'good' and 
+// half to 'bad'
+// all connections to 'bad' are disconnected
+// test can then be performed on the values
+// 'failures' and 'successes'
+markAndSweepTest = function(iterations){
         var marked = [];
         // connections
-        //var t = new Date().getTime();
-        for (var i=0;i<iterations;i++) {
-                if (Math.random() < 0.5) {
-                        marked.push(dojo.connect(null, 'hub', null, bad));
-                } else {
-                        dojo.connect(null, 'hub', null, 'good');
-                }
-        }
-        //t = new Date().getTime() - t;
-        //logMe('made ' + i + ' connections with ' + marked.length + ' marked for disconnection in ' + t + 'ms.');
-        // Randomizing markers (takes a long time if the count is too high)
-        if (i < Math.pow(10, 4)) {
-                //var t = new Date().getTime();
+        for(var i=0; i<iterations; i++){
+                if(Math.random() < 0.5){
+                        marked.push(dojo.connect('hub', bad));
+                }else{
+                        dojo.connect('hub', good);
+                }
+        }
+        // Randomize markers (only if the count isn't very high)
+        if(i < Math.pow(10, 4)){
                 var rm = [ ];
-                while (marked.length) {
+                while(marked.length){
                         var m = Math.floor(Math.random() * marked.length);
                         rm.push(marked[m]);
@@ -37 +37 @@
                 }
                 marked = rm;                            
-                //t = new Date().getTime() - t;
-                //logMe('randomized markers in ' + t + 'ms.');
         } 
-        //else logMe('skipping marker randomization due to large set.');
-        // disconnections
-        //var t = new Date().getTime();
-        for (var m=0; m<marked.length; m++) {
-                dojo.disconnect(null, 'hub', marked[m]);
-        }
-        //t = new Date().getTime() - t;
-        //logMe('performed disconnects in ' + t + 'ms.');
+        for(var m=0; m<marked.length; m++){
+                dojo.disconnect('hub', marked[m]);
+        }
         // test
         failures = 0;
-        //var t = new Date().getTime();
         hub();
-        //t = new Date().getTime() - t;
-        //logMe('invoked hub in ' + t + 'ms with ' + failures + ' failed disconnects over ' + i + ' iterations.');
-        // done
-        //console.groupEnd();
+        // return number of disconnected functions that fired (should be 0)
+        return failures;
+}
+
+markAndSweepSubscribersTest = function(iterations){
+        var topic = "hubbins";
+        var marked = [];
+        // connections
+        for(var i=0; i<iterations; i++){
+                if(Math.random() < 0.5){
+                        marked.push(dojo.subscribe(topic, bad));
+                }else{
+                        dojo.subscribe(topic, good);
+                }
+        }
+        // Randomize markers (only if the count isn't very high)
+        if(i < Math.pow(10, 4)){
+                var rm = [ ];
+                while(marked.length){
+                        var m = Math.floor(Math.random() * marked.length);
+                        rm.push(marked[m]);
+                        marked.splice(m, 1);
+                }
+                marked = rm;                            
+        } 
+        for(var m=0; m<marked.length; m++){
+                dojo.unsubscribe(topic, marked[m]);
+        }
+        // test
+        failures = 0;
+        dojo.publish(topic);
+        // return number of unsubscribed functions that fired (should be 0)
         return failures;
 }
@@ -62 +82 @@
         [
                 function smokeTest(t){
-                        var ok = false, foo = { foo: function(){} };
+                        // foo sets ok to false
+                        var ok, foo = { foo: function(){ok=false} };
+                        // connected function sets ok to true
                         dojo.connect(foo, "foo", null, function(){ok=true});
                         foo.foo();
-                        t.is(ok, true);
-                },
-                function smokeTest2(t){
-                        var ok = false, foo = { foo: function(){}, ok: function(){ok=true} };
-                        dojo.connect(foo, "foo", foo, "ok");
-                        foo.foo();
-                        t.is(ok, true);
-                },
-                function simpleTest(t) {
+                        t.is(true, ok);
+                },
+                function basicTest(t) {
                         var out = '';
                         var obj = {
@@ -120 +136 @@
                         t.is(markAndSweepTest(1000), 0);
                 },
-                function hubConnectDisconnect10000(t){
-                        t.is(markAndSweepTest(10000), 0);
+                function args4Test(t){
+                        // standard 4 args test
+                        var ok, obj = { foo: function(){ok=false;}, bar: function(){ok=true} };
+                        dojo.connect(obj, "foo", obj, "bar");
+                        obj.foo();
+                        t.is(true, ok);
+                },
+                function args3Test(t){
+                        // make some globals
+                        var ok;
+                        dojo.global["gFoo"] = function(){ok=false;};
+                        dojo.global["gOk"] = function(){ok=true;};
+                        // 3 arg shorthand for globals (a)
+                        var link = dojo.connect("gFoo", null, "gOk");
+                        gFoo();
+                        dojo.disconnect("gFoo", link);
+                        t.is(true, ok);
+                        // 3 arg shorthand for globals (b)
+                        link = dojo.connect(null, "gFoo", "gOk");
+                        gFoo();
+                        dojo.disconnect("gFoo", link);
+                        t.is(true, ok);
+                        // verify disconnections 
+                        gFoo();
+                        t.is(false, ok);
+                },
+                function args2Test(t){
+                        // make some globals
+                        var ok;
+                        dojo.global["gFoo"] = function(){ok=false;};
+                        dojo.global["gOk"] = function(){ok=true;};
+                        // 2 arg shorthand for globals 
+                        var link = dojo.connect("gFoo", "gOk");
+                        gFoo();
+                        dojo.disconnect("gFoo", link);
+                        console.log('argsTest2a: ', (ok ? "ok" : "not ok"));
+                        // 2 arg shorthand for globals, alternate scoping 
+                        link = dojo.connect("gFoo", gOk);
+                        gFoo();
+                        dojo.disconnect("gFoo", link);
+                        console.log('argsTest2b: ', (ok ? "ok" : "not ok"));
+                },
+                function scopeTest1(t){
+                        var foo = { ok: true, foo: function(){this.ok=false;} };
+                        var bar = { ok: false, bar: function(){this.ok=true} };
+                        // link foo.foo to bar.bar with natural scope
+                        var link = dojo.connect(foo, "foo", bar, "bar");
+                        foo.foo();
+                        t.is(false, foo.ok);
+                        t.is(true, bar.ok);
+                },              
+                function scopeTest2(t){
+                        var foo = { ok: true, foo: function(){this.ok=false;} };
+                        var bar = { ok: false, bar: function(){this.ok=true} };
+                        // link foo.foo to bar.bar such that scope is always 'foo'
+                        var link = dojo.connect(foo, "foo", bar.bar);
+                        foo.foo();
+                        t.is(true, foo.ok);
+                        t.is(false, bar.ok);
+                },
+                function publishSubscribe1000(t){
+                        t.is(markAndSweepSubscribersTest(1000), 0);
                 }
         ]

dojo/trunk/_base/connect.js

@@ -2 +2 @@
 dojo.require("dojo._base.lang");
 
-// this file courtesy of the TurboAjax group, licensed under a Dojo CLA
+// this file courtesy of the TurboAjax Group, licensed under a Dojo CLA
 
 // FIXME: needs in-code docs in the worst way!!
 
+// low-level delegation machinery
 dojo._listener = {
-        // low-level delegation machinery
-        dispatchers: [ ],
-        dispatcher: function(source, method, f) {
-                var op = Object.prototype;
-                var d = function(){
-                        var c=arguments.callee, list=c.listeners;
-                        for (var i in list) {
-                                !(i in op)&&(list[i].apply(this, arguments));
+        // create a dispatcher function
+        dispatcher: function(f){
+                // return a dispatcher function
+                return function(){
+                        // iterate over our listeners
+                        var ls = arguments.callee.listeners;
+                        for(var i in ls){
+                                // properties that are really listeners will not be in "a"
+                                if(!(i in Array.prototype)){
+                                        // invoke the listener with our current scope
+                                        ls[i].apply(this, arguments);
+                                }
                         }
                 }
-                d.clean = function() {
-                        source[method] = null 
-                }
-                d.listeners = (f ? [f] : []);
-                source[method] = d;
-                dojo._listener.dispatchers.push(d);
-                return d;
         },
+        // add a listener to an object
         add: function(/*Object*/ source, /*String*/ method, /*Function*/ listener){
                 // Whenever 'method' is invoked, 'listener' will have the same scope.
-                // Supporting a context object for the listener here leads to 
-                // unwarranted complexity. 
-                //
-                // This is an issue for providing 'once' functionality here
+                // Trying to supporting a context object for the listener led to 
+                // complexity. 
+                // Non trivial to provide 'once' functionality here
                 // because listener could be the result of a dojo.hitch call,
-                // in which case two references to the same function would not
+                // in which case two references to the same hitch target would not
                 // be equivalent. 
                 source = source || dojo.global;
                 // The source method is either null, a dispatcher, or some other function
-                var d = source[method];
+                var f = source[method];
                 // Ensure a dispatcher
-                if (!d||!d.listeners) {
-                        d = dojo._listener.dispatcher(source, method, d);
+                if(!f||!f.listeners){
+                        var d = dojo._listener.dispatcher(f);
+                        // dispatcher holds a list of handlers
+                        d.listeners = (f ? [f] : []);
+                        // put back in source                   
+                        f = source[method] = d;
                 }
-                // The contract is that a 'handle' is returned that is suitable for 
-                // identifying this listener. 
+                // The contract is that a handle is returned that can 
+                // identify this listener for disconnect. 
                 //
-                // The type of 'handle' is private. Here is it implemented as Integer. 
-                // DOM event code has this same contract but 'handle' is Function 
+                // The type of the handle is private. Here is it implemented as Integer. 
+                // DOM event code has this same contract but handle is Function 
                 // in non-IE browsers.
                 //
                 // Could implement 'before' with a flag and unshift.
-                return d.listeners.push(listener) - 1; /*Handle*/
+                return f.listeners.push(listener) ; /*Handle*/
         },
+        // remove a listener from an object
         remove: function(/*Object*/ source, /*String*/ method, /*Handle*/ handle){
                 var f = (source||dojo.global)[method];
-                if(f && f.listeners && handle){ delete f.listeners[handle]; }
-        },
-        clean: function(){
-                for (var i=0, d; (d=this.dispatchers[i]); i++){ d.clean(); }
-                this.dispatchers = [];
+                // remember that handle is the index+1 (0 is not a valid handle)
+                if(f && f.listeners && handle--){       
+                        delete f.listeners[handle]; 
+                }
         }
 };
+
 // arbitrary method delegation (knows nothing about DOM)
 
@@ -66 +69 @@
                                                 /*Object|null*/ context, 
                                                 /*String|Function*/ method){
-        // support for 3 argument invocation depends on hitch
-        return dojo._listener.add(obj, event, dojo.hitch(context, method)); /*Handle*/
+        // summary:
+        //              Create a link that calls one function when another executes. 
+        // description:
+        //              Connects method to event, so that after event fires, method
+        //              does too. Connect as many methods to event as needed.
+        //
+        //              event must be a string. If obj is null, dojo.global is used.
+        //
+        //              null arguments may simply be omitted.
+        //
+        //              obj[event] can resolve to a function or undefined (null). 
+        //              If obj[event] is null, it is assigned a function.
+        //
+        //              The return value is a handle that is needed to 
+        //              remove this connection with dojo.disconnect.
+        // obj: 
+        //              The source object for the event function. 
+        //              Defaults to dojo.global if null.
+        // event:
+        //              String name of the event function in obj. 
+        //              I.e. identifies a property obj[event].
+        // context: 
+        //              The object that method will receive as "this".
+        //
+        //              If context is null and method is a function, then method
+        //              inherits the context of event.
+        //      
+        //              If method is a string then context must be the source 
+        //              object object for method (context[method]). If context is null,
+        //              dojo.global is used.
+        // method:
+        //              A function reference, or name of a function in context. 
+        //              The function identified by method fires after event does. 
+        //              method receives the same arguments as the event.
+        //              See context argument comments for information on method's scope.
+        // usage:
+        //              // when obj.onchange(), do ui.update()
+        //              dojo.connect(obj, "onchange", ui, "update");
+        //              dojo.connect(obj, "onchange", ui, ui.update); // same
+        //
+        //              // using return value for disconnect
+        //              var link = dojo.connect(obj, "onchange", ui, "update");
+        //              ...
+        //              dojo.disconnect(obj, "onchange", link);
+        //
+        //              // when onglobalevent executes, watcher.handler is invoked
+        //              dojo.connect(null, "onglobalevent", watcher, "handler");
+        //
+        //              // when ob.onCustomEvent executes, customEventHandler is invoked
+        //              dojo.connect(ob, "onCustomEvent", null, "customEventHandler");
+        //              dojo.connect(ob, "onCustomEvent", "customEventHandler"); // same
+        //
+        //              // when ob.onCustomEvent executes, customEventHandler is invoked
+        //              // with the same scope (this)
+        //              dojo.connect(ob, "onCustomEvent", null, customEventHandler);
+        //              dojo.connect(ob, "onCustomEvent", customEventHandler); // same
+        //
+        //              // when globalEvent executes, globalHandler is invoked
+        //              // with the same scope (this)
+        //              dojo.connect(null, "globalEvent", null, globalHandler);
+        //              dojo.connect("globalEvent", globalHandler); // same
+
+        // support for omitting context argument depends on hitch
+        if(dojo.isString(obj)){
+                return dojo._listener.add(null, obj, dojo.hitch(event, context)); /*Handle*/
+        }else{
+                return dojo._listener.add(obj, event, dojo.hitch(context, method)); /*Handle*/
+        }
 }
 
-dojo.disconnect = function(     /*Object|null*/ obj,
-                                                        /*String*/ event, 
-                                                        /*Handle*/ handle){
-        dojo._listener.remove(obj, event, handle);
+dojo.disconnect = function(/*Object|null*/ obj, /*String*/ event, /*Handle*/ handle){
+        // summary:
+        //              Remove a link created by dojo.connect.
+        // description:
+        //              Removes the connection between event and the method referenced by handle.
+        // obj: 
+        //              The source object for the event function. 
+        //              Defaults to dojo.global if null. May be omitted.
+        // event:
+        //              String name of the event function in obj. 
+        //              I.e. identifies a property obj[event].
+        // handle:
+        //              the return value of the dojo.connect call that created the connection.
+        if(dojo.isString(obj)){
+                dojo._listener.remove(null, obj, event);
+        }else{
+                dojo._listener.remove(obj, event, handle);
+        }
 }
 
@@ -79 +162 @@
 
 dojo._topics = {};
-dojo.subscribe = function(      /*String*/ topic, 
-                                                        /*Object|null*/ context, 
-                                                        /*String|Function*/ method){
+
+dojo.subscribe = function(/*String*/ topic, /*Object|null*/ context, /*String|Function*/ method){
         // support for 3 argument invocation depends on hitch
         return dojo._listener.add(dojo._topics, topic, dojo.hitch(context, method)); /*Handle*/
 }
+
 dojo.unsubscribe = function(/*String*/ topic, /*Handle*/ handle){
         dojo._listener.remove(dojo._topics, topic, handle);
 }
+
 dojo.publish = function(/*String*/ topic, /*Array*/ args){
         // Note that args is an array. This is more efficient vs variable length argument list.

dojo/trunk/_base/event.js

@@ -2 +2 @@
 dojo.require("dojo._base.connect");
 
-// this file courtesy of the TurboAjax group, licensed under a Dojo CLA
+// this file courtesy of the TurboAjax Group, licensed under a Dojo CLA
 
 (function(){
@@ -10 +10 @@
                 addListener: function(/*DOMNode*/node, /*String*/event, /*Function*/fp){
                         if(!node){ return; } 
-                        event = de.normalizeEventName(event);
-                        fp = (!de._fixCallback ? fp : de._fixCallback(fp));
-                        if(node.addEventListener){ 
-                                node.addEventListener(event.slice(2), fp, false);
-                                return fp; /*Handle*/
-                        }else{
-                                return dojo._listener.add(node, event, fp); /*Handle*/
-                        }
+                        event = de._normalizeEventName(event)
+                        node.addEventListener(event, de._fixCallback(event, fp), false);
+                        return fp; /*Handle*/
                 },
                 removeListener: function(/*DOMNode*/node, /*String*/event, /*Handle*/handle){
@@ -28 +23 @@
                         // fp:
                         //              the function to register
-                        event = de.normalizeEventName(event);
-                        if(node.removeEventListener){
-                                node.removeEventListener(event.slice(2), handle, false);
-                        }else{
-                                dojo.listener.remove(node, event, handle);
+                        node.removeEventListener(de._normalizeEventName(event), handle, false);
+                },
+                _normalizeEventName: function(/*String*/name){
+                        // Generally, name should be lower case, unless it is special
+                        // somehow (e.g. a Mozilla event)
+
+                        // Remove 'on'
+                        return (name.slice(0,2)=="on" ? name.slice(2) : name);
+                },
+                _fixCallback: function(/*String*/name, fp){
+                        //return function(e){ return fp(de._fixEvent(e, this)); };      
+                        return (name!="keypress" ? fp : function(e){ return fp(de._fixEvent(e, this)); });      
+                },
+                _fixEvent: function(evt, sender){
+                        // fixCallback only attaches us to keypress, but we switch on
+                        // evt.type because we might be called from dojo.fixEvent
+                        switch(evt.type){
+                                case "keypress":
+                                        de._fixKey(evt);
+                                        break;
                         }
+                        return evt;
                 },
-                normalizeEventName: function(/*String*/eventName){
-                        // Generally, eventName should be lower case, unless it is special somehow (e.g. a Mozilla event)
-                        if(eventName.slice(0,2)!="on"){ eventName = "on"+eventName; }
-                        if(eventName=="onkey"){ eventName = (dojo.isIE ? "onkeydown" : "onkeypress");   }
-                        return eventName;
-                },
-                // hosts can override to fix events as needed
-                _fixCallback: null,
-                // public fixEvent
-                fixEvent: function(/*Event*/evt, /*DOMNode*/sender){
-                        // summary:
-                        //              normalizes properties on the event object including event
-                        //              bubbling methods, keystroke normalization, and x/y positions
-                        // evt: native event object
-                        // sender: node to treat as "currentTarget"
-                        var f = de._fixEvent;
-                        return (f ? f(evt, sender) : evt);
-                },
-                stopEvent: function(/*Event*/evt){
-                        // summary:
-                        //              prevents propagation and clobbers the default action of the
-                        //              passed event
-                        // evt: Optional for IE. The native event object.
-                        evt.preventDefault();
-                        evt.stopPropagation();
+                _fixKey: function(evt, charCode){
+                        var c = (arguments.length > 1 ? charCode : evt.charCode);
+                        evt.keyChar = (c ? String.fromCharCode(c) : '');
                 }
         };
+        // FIXME: do we need this for debugging???
+        // dojo.event = de;
 
         // DOM events
-        dojo.addListener = function(node, event, context, method) {
+        dojo.addListener = function(node, event, context, method){
                 return de.addListener(node, event, dojo.hitch(context, method)); // Handle
         }
 
-        dojo.removeListener = function(node, event, handle) {
+        dojo.removeListener = function(node, event, handle){
                 de.removeListener(node, event, handle);
         }
 
-        // prefer these remain public, but could be confusing in top level docs
-
-        // dojo.addConnection = dojo.connect; 
-        // dojo.removeConnection = dojo.disconnect;
+        dojo.fixEvent = function(/*Event*/evt, /*DOMNode*/sender){
+                // summary:
+                //              normalizes properties on the event object including event
+                //              bubbling methods, keystroke normalization, and x/y positions
+                // evt: native event object
+                // sender: node to treat as "currentTarget"
+                return de._fixEvent(evt, sender);
+                //return (de._fixEvent ? de._fixEvent(evt, sender) : evt);
+        }
+
+        dojo.stopEvent = function(/*Event*/evt){
+                // summary:
+                //              prevents propagation and clobbers the default action of the
+                //              passed event
+                // evt: Optional for IE. The native event object.
+                evt.preventDefault();
+                evt.stopPropagation();
+        }
+
+        // =============================================
+        // FIXME: I want to eliminate these and their
+        //        IE<7 bretheren below
+        dojo.cleanEvents = function(){
+                // self cleaning, except on IE
+                
+                // FIXME: why public?
+        }
+        dojo.cleanNodeEvents = function(inNode){
+                // self cleaning, except on IE
+                
+                // FIXME: why public?
+        }
+        // =============================================
+
+        // cache raw implementations