triggerEvent can now be called with additional arguments for the listeners - this means instead of getting news like 'hey, someone won the lottery' listeners now get news like 'hey, you won the lottery' - in addition, the triggerer gets back the return from the listener, so if a listener wants to say 'dont tell anyone else' the triggerer gets that message - thanks for the reviews (closes #1189)

git-svn-id: http://svn.openlayers.org/trunk/openlayers@5398 dc9f47b5-9b13-0410-9fdd-eb0c1a62fdaf

lib/OpenLayers/Events.js

@@ -586,13 +586,18 @@ OpenLayers.Events = OpenLayers.Class({
 
     /**
      * APIMethod: triggerEvent
-     * Trigger a specified registered event
+     * Trigger a specified registered event.  
      * 
      * Parameters:
      * type - {String} 
      * evt - {Event}
+     * args - {Array} Optional array of arguments to call the listener with.
+     *
+     * Returns:
+     * {Boolean} The last listener return.  If a listener returns false, the
+     *     chain of listeners will stop getting called.
      */
-    triggerEvent: function (type, evt) {
+    triggerEvent: function (type, evt, args) {
 
         // prep evt object with object & div references
         if (evt == null) {
@@ -601,23 +606,25 @@ OpenLayers.Events = OpenLayers.Class({
         evt.object = this.object;
         evt.element = this.element;
         
+        if(!args) {
+            args = [evt];
+        } else {
+            args.unshift(evt);
+        }
+
         // execute all callbacks registered for specified type
         // get a clone of the listeners array to
         // allow for splicing during callbacks
         var listeners = (this.listeners[type]) ?
                             this.listeners[type].slice() : null;
         if ((listeners != null) && (listeners.length > 0)) {
+            var continueChain;
             for (var i = 0; i < listeners.length; i++) {
                 var callback = listeners[i];
-                var continueChain;
+                // bind the context to callback.obj
-                if (callback.obj != null) {
+                continueChain = callback.func.apply(callback.obj, args);
-                    // use the 'call' method to bind the context to callback.obj
-                    continueChain = callback.func.call(callback.obj, evt);
-                } else {
-                    continueChain = callback.func(evt);
-                }
     
-                if ((continueChain != null) && (continueChain == false)) {
+                if ((continueChain != undefined) && (continueChain == false)) {
                     // if callback returns false, execute no more callbacks.
                     break;
                 }
@@ -627,6 +634,7 @@ OpenLayers.Events = OpenLayers.Class({
                 OpenLayers.Event.stop(evt, true);
             }
         }
+        return continueChain;
     },
 
     /**

tests/test_Events.html

@@ -152,7 +152,7 @@
 
     function test_04_Events_triggerEvent(t) {
     
-        t.plan( 6 );
+        t.plan(13);
  
         var mapDiv = OpenLayers.Util.getElement('map');
         var obj = {result: 0};
@@ -200,6 +200,52 @@
         events.triggerEvent("doThingC");
 
         t.eq(a, 5, "if Events has no object set and an event is registered also with no object, triggerEvent() calls it without trying to set the context to null");
+        
+        // trigger events with additional arguments
+        eventTypes = ["something"];
+        events = new OpenLayers.Events(null, null, eventTypes);
+        var instance = {id: Math.random()};
+        var listener = function() {
+            t.eq(this.id, instance.id,
+                 "listener called with proper scope");
+            t.eq(arguments[0].id, evt.id,
+                 "listener called with evt as first arg");
+            t.eq(arguments[1], "arg1",
+                 "listener called with correct extra arg1");
+            t.eq(arguments[2], "arg2",
+                 "listener called with correct extra arg2");
+        };
+        events.register("something", instance, listener);        
+        var evt = {id: Math.random()};
+        events.triggerEvent("something", evt, ["arg1", "arg2", "arg3"]);
+        events.unregister("something", instance, listener);
+        
+        // test return from triggerEvent
+        var listener1 = function() {
+            return "foo";
+        }
+        var listener2 = function() {
+            return false;
+        }
+        var listener3 = function() {
+            t.fail("never call me again!");
+        }
+        events.register("something", instance, listener1);
+        var ret = events.triggerEvent("something", evt);
+        t.eq(ret, "foo", "correct return from single listener");
+        
+        events.register("something", instance, listener2);
+        ret = events.triggerEvent("something", evt);
+        t.eq(ret, false, "correct return for two listeners");
+        
+        events.register("something", instance, listener3);
+        ret = events.triggerEvent("something", evt);
+        t.eq(ret, false, "correct return for three listeners where second cancels");
+        
+        events.unregister("something", instance, listener1);
+        events.unregister("something", instance, listener2);
+        events.unregister("something", instance, listener3);
+        
     }
 
     function test_05_Events_destroy (t) {