Source: events/event.js

  1. /**
  2.  * @fileOverview Requirejs module containing the antie.events.Event abstract base class.
  3.  * @author Chris Warren <chris.warren@bbc.co.uk>
  4.  * @version 1.0.0
  5.  */
  7. /**
  8.  * @preserve Copyright (c) 2013-present British Broadcasting Corporation. All rights reserved.
  9.  * @license See https://github.com/fmtvp/tal/blob/master/LICENSE for full licence
  10.  */
  13. define(
  14.     'antie/events/event',
  15.     [
  16.         'antie/class',
  17.         'antie/runtimecontext'
  18.     ],
  19.     function(Class, RuntimeContext) {
  20.         'use strict';
  22.         var eventCount = 0;
  23.         var eventListeners = {};
  25.         /**
  26.          * Abstract base class for events.
  27.          * @abstract
  28.          * @extends antie.Class
  29.          * @name antie.events.Event
  30.          * @class
  31.          * @param {String} type The event type (e.g. <code>keydown</code>, <code>databound</code>).
  32.          */
  33.         var Event = Class.extend(/** @lends antie.events.Event.prototype */ {
  34.             /**
  35.              * @constructor
  36.              * @ignore
  37.              */
  38.             init: function init (type) {
  39.                 this.type = type;
  40.                 this._propagationStopped = false;
  41.                 this._defaultPrevented = false;
  42.                 eventCount++;
  43.             },
  44.             /**
  45.              * Stop propagation of the event through the widget tree.
  46.              */
  47.             stopPropagation: function stopPropagation () {
  48.                 this._propagationStopped = true;
  49.                 eventCount--;
  50.                 if (!eventCount) {
  51.                     this.fireEvent('emptyStack');
  52.                 }
  53.             },
  54.             /**
  55.              * Check to see if the propagation of this event has been stopped.
  56.              * @returns Boolean true if the event has been stopped, otherwise Boolean false.
  57.              */
  58.             isPropagationStopped: function isPropagationStopped () {
  59.                 return this._propagationStopped;
  60.             },
  61.             /**
  62.              * Prevent any default handler being called for this event.
  63.              */
  64.             preventDefault: function preventDefault () {
  65.                 this._defaultPrevented = true;
  66.             },
  67.             /**
  68.              * Check to see if the default handler has been prevented.
  69.              * @returns Boolean true if the default handler has been prevented.
  70.              */
  71.             isDefaultPrevented: function isDefaultPrevented () {
  72.                 return this._defaultPrevented;
  73.             },
  74.             /**
  75.              * Add an event listener function to the event stack. Used for 'meta-events'.
  76.              * @memberOf antie.events.Event
  77.              * @static
  78.              * @param {String} ev The event type to listen for (e.g. <code>emptyStack</code>)
  79.              * @param {Function} func The handler to be called when the event is fired.
  80.              */
  81.             addEventListener: function addEventListener (ev, func) {
  82.                 var listeners = eventListeners[ev];
  83.                 if (typeof listeners === 'undefined') {
  84.                     listeners = [];
  85.                     eventListeners[ev] = listeners;
  86.                 }
  87.                 if (!~listeners.indexOf(func)) {
  88.                     listeners.push(func);
  89.                 }
  90.             },
  91.             /**
  92.              * Removes an event listener function to the event stack. Used for 'meta-events'.
  93.              * @memberOf antie.events.Event
  94.              * @static
  95.              * @param {String} ev The event type that the listener is to be removed from (e.g. <code>emptyStack</code>)
  96.              * @param {Function} func The handler to be removed.
  97.              */
  98.             removeEventListener: function removeEventListener (ev, func) {
  99.                 var listeners = eventListeners[ev],
  100.                     listener;
  102.                 if (!listeners) {
  103.                     RuntimeContext.getDevice().getLogger().error('Attempting to remove non-existent event listener');
  104.                     return false;
  105.                 }
  107.                 listener = listeners.indexOf(func);
  108.                 if (~listener) {
  109.                     listeners.splice(listener, 1);
  110.                 }
  111.             },
  112.             /**
  113.              * Fires an event on the event stack.
  114.              * Note: this does not bubble or propagate the event, the concept is meaningless in the context
  115.              * of the event stack.
  116.              * @memberOf antie.events.Event
  117.              * @static
  118.              * @param {String} ev The event to fire (e.g. <code>emptyStack</code>).
  119.              * @see antie.events.Event
  120.              */
  121.             fireEvent: function fireEvent (ev) {
  122.                 var listeners = eventListeners[ev];
  123.                 if(listeners) {
  124.                     for(var func in listeners) {
  125.                         if(listeners.hasOwnProperty(func)) {
  126.                             listeners[func]();
  127.                         }
  128.                     }
  129.                 }
  130.             }
  131.         });
  133.         return Event;
  134.     }
  135. );