Fix the event listener leak, which has been a serious problem when large numbers of markers etc. are created. Closes #510.

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

lib/OpenLayers/Events.js

@@ -72,7 +72,6 @@ OpenLayers.Event = {
     if (!OpenLayers.Event.observers) return;
     for (var i = 0; i < OpenLayers.Event.observers.length; i++) {
       OpenLayers.Event.stopObserving.apply(this, OpenLayers.Event.observers[i]);
-      OpenLayers.Event.observers[i][0] = null;
     }
     OpenLayers.Event.observers = false;
   },
@@ -98,6 +97,28 @@ OpenLayers.Event = {
         || element.detachEvent))
       name = 'keydown';
 
+    // find entry in this.observers cache array and remove it
+    var observers = OpenLayers.Event.observers;
+    var entry = [element, name, observer, useCapture];
+    for (var i = 0; i < observers.length; i++) {
+        var observer = observers[i];
+
+        //compare all 4 elements of entry with observer
+        var sameEntry = true;        
+        for (var j = 0; j < entry.length; j++) {
+            if (entry[j] != observer[j]) {
+                sameEntry = false;
+                break;
+            }
+        }
+
+        //if we've found it, remove it from the observers array
+        if (sameEntry) {
+            observers.splice(i--, 1);
+            break; 
+        }
+    }
+
     if (element && element.removeEventListener) {
       element.removeEventListener(name, observer, useCapture);
     } else if (element && element.detachEvent) {
@@ -114,8 +135,6 @@ if (window.Event) {
   var Event = OpenLayers.Event;
 }
 
-
-
 /**
  * @class
  */
@@ -143,6 +162,15 @@ OpenLayers.Events.prototype = {
     /** @type Array: list of support application events */
     eventTypes: null,
 
+    /**
+    * @type Function: bound event handler attached to elements
+    * @private
+    */
+    eventHandler: null,
+
+    /** @type Boolean */
+    fallThrough: null,
+
     /**
      * @constructor 
      * 
@@ -160,6 +188,10 @@ OpenLayers.Events.prototype = {
         this.fallThrough = fallThrough;
         this.listeners  = new Object();
 
+        // keep a bound copy of handleBrowserEvent() so that we can
+        // pass the same function to both Event.observe() and .stopObserving()
+        this.eventHandler = this.handleBrowserEvent.bindAsEventListener(this);
+
         // if eventTypes is specified, create a listeners list for each 
         // custom application event.
         if (this.eventTypes != null) 
@@ -172,6 +204,22 @@ OpenLayers.Events.prototype = {
             this.attachToElement(element);
     },
 
+    /**
+     * 
+     */
+    destroy: function () {
+        if (this.element) {
+            this.detachFromElement();
+        }
+        this.element = null;
+
+        this.listeners = null;
+        this.object = null;
+        this.eventTypes = null;
+        this.fallThrough = null;
+        this.eventHandler = null;
+    },
+
     /**
     * @param {HTMLDOMElement} element a DOM element to attach browser events to
     */
@@ -185,12 +233,27 @@ OpenLayers.Events.prototype = {
                 this.listeners[eventType] = new Array();
 
             // use Prototype to register the event cross-browser
-            OpenLayers.Event.observe(element, eventType, 
-                this.handleBrowserEvent.bindAsEventListener(this));
+            OpenLayers.Event.observe(element, eventType, this.eventHandler);
         }
         // disable dragstart in IE so that mousedown/move/up works normally
         OpenLayers.Event.observe(element, "dragstart", OpenLayers.Event.stop);
     },
+    
+    /**
+     * @private
+     */
+    detachFromElement: function () {
+        for (var i = 0; i < this.BROWSER_EVENTS.length; i++) {
+            var eventType = this.BROWSER_EVENTS[i];
+
+            OpenLayers.Event.stopObserving(
+                this.element, eventType, this.eventHandler);
+        }
+
+        // re-enable dragstart in IE
+        OpenLayers.Event.stopObserving(
+            this.element, "dragstart", OpenLayers.Event.stop);
+    },
 
     /**
      * @param {String} type Name of the event to register
@@ -227,9 +290,18 @@ OpenLayers.Events.prototype = {
             }
         }
     },
-    // TODO: get rid of this in 3.0
-    // Decide whether listeners should be called in the order they were
-    // registered or in reverse order.
+
+    /**
+     *   TODO: get rid of this in 3.0 - Decide whether listeners should be 
+     *         called in the order they were registered or in reverse order.
+     * 
+     * @param {String} type Name of the event to register
+     * @param {Object} obj The object to bind the context to for the callback#.
+     *                     If no object is specified, default is the Events's 
+     *                     'object' property.
+     * @param {Function} func The callback function. If no callback is 
+     *                        specified, this function does nothing.
+     */
     registerPriority: function (type, obj, func) {
 
         if (func != null) {