OpenLayers.Event

{Boolean}

{Boolean} Should the .xy property automatically be created for browser mouse events?  In general, this should be false.  If it is true, then mouse events will automatically generate a ‘.xy’ property on the event object that is passed.  (Prior to OpenLayers 2.7, this was true by default.)  Otherwise, you can call the getMousePosition on the relevant events handler on the object available via the ‘evt.object’ property of the evt object.  So, for most events, you can call: function named(evt) { this.xy = this.object.events.getMousePosition(evt) }

This option typically defaults to false for performance reasons

when creating an events object whose primary purpose is to manage relatively positioned mouse events within a div, it may make sense to set it to true.

This option is also used to control whether the events object caches offsets.  If this is false, it will not: the reason for this is that it is only expected to be called many times if the includeXY property is set to true.  If you set this to true, you are expected to clear the offset cache manually (using this.clearMouseCache()) if: the border of the element changes the location of the element in the page changes

{Object} Event extensions registered with this instance.  Keys are event types, values are {OpenLayers.Events.*} extension instances or {Boolean} for events that an instantiated extension provides in addition to the one it was created for.

Extensions create an event in addition to browser events, which usually fires when a sequence of browser events is completed.  Extensions are automatically instantiated when a listener is registered for an event provided by an extension.

Extensions are created in the OpenLayers.Events namespace using OpenLayers.Class, and named after the event they provide.  The constructor receives the target OpenLayers.Events instance as argument.  Extensions that need to capture browser events before they propagate can register their listeners events using register, with {extension: true} as 4th argument.

If an extension creates more than one event, an alias for each event type should be created and reference the same class.  The constructor should set a reference in the target’s extensions registry to itself.

Below is a minimal extension that provides the “foostart” and “fooend” event types, which replace the native “click” event type if clicked on an element with the css class “foo”:

OpenLayers.Events.foostart = OpenLayers.Class({
    initialize: function(target) {
        this.target = target;
        this.target.register("click", this, this.doStuff, {extension: true});
        // only required if extension provides more than one event type
        this.target.extensions["foostart"] = true;
        this.target.extensions["fooend"] = true;
    },
    destroy: function() {
        var target = this.target;
        target.unregister("click", this, this.doStuff);
        delete this.target;
        // only required if extension provides more than one event type
        delete target.extensions["foostart"];
        delete target.extensions["fooend"];
    },
    doStuff: function(evt) {
        var propagate = true;
        if (OpenLayers.Event.element(evt).className === "foo") {
            propagate = false;
            var target = this.target;
            target.triggerEvent("foostart");
            window.setTimeout(function() {
                target.triggerEvent("fooend");
            }, 1000);
        }
        return propagate;
    }
});
// only required if extension provides more than one event type
OpenLayers.Events.fooend = OpenLayers.Events.foostart;