/* Copyright (c) 2006-2007 MetaCarta, Inc., published under the BSD license. * See http://svn.openlayers.org/trunk/openlayers/release-license.txt  * for the full text of the license. *//** * @requires OpenLayers/Util.js * * Namespace: OpenLayers.Event * Utility functions for event handling. */OpenLayers.Event = {    /**      * Property: observers      * {Object} A hashtable cache of the event observers. Keyed by     * element._eventCacheID      */    observers: false,        /**      * Constant: KEY_BACKSPACE      * {int}      */    KEY_BACKSPACE: 8,    /**      * Constant: KEY_TAB      * {int}      */    KEY_TAB: 9,    /**      * Constant: KEY_RETURN      * {int}      */    KEY_RETURN: 13,    /**      * Constant: KEY_ESC      * {int}      */    KEY_ESC: 27,    /**      * Constant: KEY_LEFT      * {int}      */    KEY_LEFT: 37,    /**      * Constant: KEY_UP      * {int}      */    KEY_UP: 38,    /**      * Constant: KEY_RIGHT      * {int}      */    KEY_RIGHT: 39,    /**      * Constant: KEY_DOWN      * {int}      */    KEY_DOWN: 40,    /**      * Constant: KEY_DELETE      * {int}      */    KEY_DELETE: 46,    /**     * Method: element     * Cross browser event element detection.     *      * Parameters:     * event - {Event}      *      * Returns:     * {DOMElement} The element that caused the event      */    element: function(event) {        return event.target || event.srcElement;    },    /**     * Method: isLeftClick     * Determine whether event was caused by a left click.      *     * Parameters:     * event - {Event}      *      * Returns:     * {Boolean}     */    isLeftClick: function(event) {        return (((event.which) && (event.which == 1)) ||                ((event.button) && (event.button == 1)));    },    /**     * Method: stop     * Stops an event from propagating.      *     * Parameters:      * event - {Event}      * allowDefault - {Boolean} If true, we stop the event chain but      *                               still allow the default browser      *                               behaviour (text selection, radio-button      *                               clicking, etc)     *                               Default false     */    stop: function(event, allowDefault) {                if (!allowDefault) {             if (event.preventDefault) {                event.preventDefault();            } else {                event.returnValue = false;            }        }                        if (event.stopPropagation) {            event.stopPropagation();        } else {            event.cancelBubble = true;        }    },    /**      * Method: findElement     *      * Parameters:     * event - {Event}      * tagName - {String}      *      * Returns:     * {DOMElement} The first node with the given tagName, starting from the     * node the event was triggered on and traversing the DOM upwards     */    findElement: function(event, tagName) {        var element = OpenLayers.Event.element(event);        while (element.parentNode && (!element.tagName ||              (element.tagName.toUpperCase() != tagName.toUpperCase())))            element = element.parentNode;        return element;    },    /**      * Method: observe     *      * Parameters:     * elementParam - {DOMElement || String}      * name - {String}      * observer - {function}      * useCapture - {Boolean}      */    observe: function(elementParam, name, observer, useCapture) {        var element = OpenLayers.Util.getElement(elementParam);        useCapture = useCapture || false;        if (name == 'keypress' &&           (navigator.appVersion.match(/Konqueror|Safari|KHTML/)           || element.attachEvent)) {            name = 'keydown';        }        //if observers cache has not yet been created, create it        if (!this.observers) {            this.observers = {};        }        //if not already assigned, make a new unique cache ID        if (!element._eventCacheID) {            var idPrefix = "eventCacheID_";            if (element.id) {                idPrefix = element.id + "_" + idPrefix;            }            element._eventCacheID = OpenLayers.Util.createUniqueID(idPrefix);        }        var cacheID = element._eventCacheID;        //if there is not yet a hash entry for this element, add one        if (!this.observers[cacheID]) {            this.observers[cacheID] = [];        }        //add a new observer to this element's list        this.observers[cacheID].push({            'element': element,            'name': name,            'observer': observer,            'useCapture': useCapture        });        //add the actual browser event listener        if (element.addEventListener) {            element.addEventListener(name, observer, useCapture);        } else if (element.attachEvent) {            element.attachEvent('on' + name, observer);        }    },    /**      * Method: stopObservingElement     * Given the id of an element to stop observing, cycle through the      *   element's cached observers, calling stopObserving on each one,      *   skipping those entries which can no longer be removed.     *      * parameters:     * elementParam - {DOMElement || String}      */    stopObservingElement: function(elementParam) {        var element = OpenLayers.Util.getElement(elementParam);        var cacheID = element._eventCacheID;        this._removeElementObservers(OpenLayers.Event.observers[cacheID]);    },    /**     * Method: _removeElementObservers     *     * Parameters:     * elementObservers - {Array(Object)} Array of (element, name,      *                                         observer, usecapture) objects,      *                                         taken directly from hashtable     */    _removeElementObservers: function(elementObservers) {        if (elementObservers) {            for(var i = elementObservers.length-1; i >= 0; i--) {                var entry = elementObservers[i];                var args = new Array(entry.element,                                     entry.name,                                     entry.observer,                                     entry.useCapture);                var removed = OpenLayers.Event.stopObserving.apply(this, args);            }        }    },    /**     * Method: stopObserving     *      * Parameters:     * elementParam - {DOMElement || String}      * name - {String}      * observer - {function}      * useCapture - {Boolean}      *       * Returns:     * {Boolean} Whether or not the event observer was removed     */    stopObserving: function(elementParam, name, observer, useCapture) {        useCapture = useCapture || false;            var element = OpenLayers.Util.getElement(elementParam);        var cacheID = element._eventCacheID;        if (name == 'keypress') {            if ( navigator.appVersion.match(/Konqueror|Safari|KHTML/) ||                  element.detachEvent) {              name = 'keydown';            }        }        // find element's entry in this.observers cache and remove it        var foundEntry = false;        var elementObservers = OpenLayers.Event.observers[cacheID];        if (elementObservers) {                // find the specific event type in the element's list            var i=0;            while(!foundEntry && i < elementObservers.length) {                var cacheEntry = elementObservers[i];                    if ((cacheEntry.name == name) &&                    (cacheEntry.observer == observer) &&                    (cacheEntry.useCapture == useCapture)) {                        elementObservers.splice(i, 1);                    if (elementObservers.length == 0) {                        delete OpenLayers.Event.observers[cacheID];                    }                    foundEntry = true;                    break;                 }                i++;                       }        }            //actually remove the event listener from browser        if (element.removeEventListener) {            element.removeEventListener(name, observer, useCapture);        } else if (element && element.detachEvent) {            element.detachEvent('on' + name, observer);        }        return foundEntry;    },        /**      * Method: unloadCache     * Cycle through all the element entries in the events cache and call     *   stopObservingElement on each.      */    unloadCache: function() {        if (OpenLayers.Event.observers) {            for (var cacheID in OpenLayers.Event.observers) {                var elementObservers = OpenLayers.Event.observers[cacheID];                OpenLayers.Event._removeElementObservers.apply(this,                                                            [elementObservers]);            }            OpenLayers.Event.observers = false;        }    },    CLASS_NAME: "OpenLayers.Event"};/* prevent memory leaks in IE */OpenLayers.Event.observe(window, 'unload', OpenLayers.Event.unloadCache, false);// FIXME: Remove this in 3.0. In 3.0, Event.stop will no longer be provided// by OpenLayers.if (window.Event) {    OpenLayers.Util.applyDefaults(window.Event, OpenLayers.Event);} else {    var Event = OpenLayers.Event;}/** * Class: OpenLayers.Events */