You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
131 lines
3.5 KiB
131 lines
3.5 KiB
// Copyright 2005 The Closure Library Authors. All Rights Reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS-IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
/**
|
|
* @fileoverview Listener object.
|
|
* @see ../demos/events.html
|
|
*/
|
|
|
|
goog.provide('goog.events.Listener');
|
|
|
|
goog.require('goog.events.ListenableKey');
|
|
|
|
|
|
|
|
/**
|
|
* Simple class that stores information about a listener
|
|
* @param {!Function} listener Callback function.
|
|
* @param {Function} proxy Wrapper for the listener that patches the event.
|
|
* @param {EventTarget|goog.events.Listenable} src Source object for
|
|
* the event.
|
|
* @param {string} type Event type.
|
|
* @param {boolean} capture Whether in capture or bubble phase.
|
|
* @param {Object=} opt_handler Object in whose context to execute the callback.
|
|
* @implements {goog.events.ListenableKey}
|
|
* @constructor
|
|
*/
|
|
goog.events.Listener = function(
|
|
listener, proxy, src, type, capture, opt_handler) {
|
|
if (goog.events.Listener.ENABLE_MONITORING) {
|
|
this.creationStack = new Error().stack;
|
|
}
|
|
|
|
/**
|
|
* Callback function.
|
|
* @type {Function}
|
|
*/
|
|
this.listener = listener;
|
|
|
|
/**
|
|
* A wrapper over the original listener. This is used solely to
|
|
* handle native browser events (it is used to simulate the capture
|
|
* phase and to patch the event object).
|
|
* @type {Function}
|
|
*/
|
|
this.proxy = proxy;
|
|
|
|
/**
|
|
* Object or node that callback is listening to
|
|
* @type {EventTarget|goog.events.Listenable}
|
|
*/
|
|
this.src = src;
|
|
|
|
/**
|
|
* The event type.
|
|
* @const {string}
|
|
*/
|
|
this.type = type;
|
|
|
|
/**
|
|
* Whether the listener is being called in the capture or bubble phase
|
|
* @const {boolean}
|
|
*/
|
|
this.capture = !!capture;
|
|
|
|
/**
|
|
* Optional object whose context to execute the listener in
|
|
* @type {Object|undefined}
|
|
*/
|
|
this.handler = opt_handler;
|
|
|
|
/**
|
|
* The key of the listener.
|
|
* @const {number}
|
|
* @override
|
|
*/
|
|
this.key = goog.events.ListenableKey.reserveKey();
|
|
|
|
/**
|
|
* Whether to remove the listener after it has been called.
|
|
* @type {boolean}
|
|
*/
|
|
this.callOnce = false;
|
|
|
|
/**
|
|
* Whether the listener has been removed.
|
|
* @type {boolean}
|
|
*/
|
|
this.removed = false;
|
|
};
|
|
|
|
|
|
/**
|
|
* @define {boolean} Whether to enable the monitoring of the
|
|
* goog.events.Listener instances. Switching on the monitoring is only
|
|
* recommended for debugging because it has a significant impact on
|
|
* performance and memory usage. If switched off, the monitoring code
|
|
* compiles down to 0 bytes.
|
|
*/
|
|
goog.define('goog.events.Listener.ENABLE_MONITORING', false);
|
|
|
|
|
|
/**
|
|
* If monitoring the goog.events.Listener instances is enabled, stores the
|
|
* creation stack trace of the Disposable instance.
|
|
* @type {string}
|
|
*/
|
|
goog.events.Listener.prototype.creationStack;
|
|
|
|
|
|
/**
|
|
* Marks this listener as removed. This also remove references held by
|
|
* this listener object (such as listener and event source).
|
|
*/
|
|
goog.events.Listener.prototype.markAsRemoved = function() {
|
|
this.removed = true;
|
|
this.listener = null;
|
|
this.proxy = null;
|
|
this.src = null;
|
|
this.handler = null;
|
|
};
|
|
|