diff --git a/lib/OpenLayers/Events.js b/lib/OpenLayers/Events.js
index 4214a95c20..0844fe1c1a 100644
--- a/lib/OpenLayers/Events.js
+++ b/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} 
+     * 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) {
@@ -600,6 +605,12 @@ 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
@@ -607,17 +618,13 @@ OpenLayers.Events = OpenLayers.Class({
         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;
-                if (callback.obj != null) {
-                    // use the 'call' method to bind the context to callback.obj
-                    continueChain = callback.func.call(callback.obj, evt);
-                } else {
-                    continueChain = callback.func(evt);
-                }
+                // bind the context to callback.obj
+                continueChain = callback.func.apply(callback.obj, args);
     
-                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;
     },
 
     /**
diff --git a/tests/test_Events.html b/tests/test_Events.html
index 57cb5c50f1..750df5270f 100644
--- a/tests/test_Events.html
+++ b/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};
@@ -199,7 +199,53 @@
         events.register( "doThingC", null, func );
         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");        
+        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) {