Evénéments DOM : attache, suppression, activation et désactivation

void addEventListener(
    DOMString type, 
    EventListener listener, 
    boolean useCapture
)

el.addEventListener('click', function (e) {
    // Do something on click events
}, false);

void removeEventListener(
    DOMString type,
    EventListener listener, 
    boolean useCapture
)

// référence de l'écouteur.
var listener = function (e) {
    // Do something on click events
};
// Ecoute de l'événement
el.addEventListener('click', listener, false);
// ...
// Plus loin dans le code, on peut supprimer l'écouteur
el.removeEventListener('click', listener, false);

var manager =
{
    handleEvent: function (e) 
    {
        // Do something on DOM events.
    },
    handleClick: function (e) 
    {
        // Do something on click events.
    },
    handleMouseOver: function (e)
    {
        // Do something on mousover events.
    }
};

el.addEventListener('click', manager, false);
el.addEventListener('mouseover', manager, false);

// ou

el.addEventListener('click', manager.handleClick, false);    
el.addEventListener('mouseover', manager.handleMouseOver, false);

// Objet qui regroupe l'ensemble des méthodes 
// d'interaction avec le DOM
rnb.dom = {
    /**
     *  Mise en cache des écouteurs d'événements.
     *  @type Object
     *  @private
     */
    listeners: {},
    
    /**
     *  Attacher un écouteur d'événement à un élément DOM.
     *
     *  @param  {HTMLElement} element Elément sur lequel attacher l'écouteur.
     *  @param  {String} event Type de l'événement.
     *  @param  {Function} listener Ecouteur d'événement.
     *  @param  {Boolean} capture Capture de la phase de rebond.
     *  @return {String} identifiant de l'écouteur d'événement. 
     */
    addEventListener: function (element, event, listener, capture)
    {
        if (!listener.__lid__) {
            listener.__lid__ = rnb.guid('l');
        }
        if (!rnb.dom.listeners[listener.__lid__]) {
            rnb.dom.listeners[listener.__lid__] = {
                enabled: false,
                listener: listener,
                targets: []
            };
        }
        rnb.dom.listeners[listener.__lid__].targets.push({
            element: element, 
            event: event, 
            capture: capture
        });
        rnb.dom.enableEventListener(listener.__lid__);
        
        return listener.__lid__;
    },
    
    /**
     *  Supprimer un écouteur d'événement.
     *
     *  @param {String} id Identifiant de l'écouteur d'événement à supprimer,
     *  retourné par la méthode [#rnb.dom.addEventListener]().
     */
    removeEventListener: function (id)
    {
        rnb.dom.disableEventListener(id);
        rnb.dom.listeners[id].listener = null;
        rnb.dom.listeners[id].targets = null;
        delete rnb.dom.listeners[id];
    },
    
    /**
     *  Activer un écouteur d'événement.
     *
     *  L'activation consiste attacher l'écouteur à l'élément pour écouter
     *  l'émission d'un événement DOM. Elle est effectuée par défaut quand on 
     *  ajoute un écouteur ([#rnb.dom.addEventListener]()). On doit donc appeler 
     *  cette méthode uniquement si l'on a déconnecté l'écouteur auparavant
     *  ([#rnb.dom.disableEventListener]()).
     *
     *  @param {String} id Identifiant de l'écouteur.
     *  @param {Boolean} True si l'écouteur a été connecté, false si l'écouteur
     *  n'existe pas ou est déjà connecté.
     */
    enableEventListener: function (id)
    {
        var o = rnb.dom.listeners[id], i, n, t;
        if (o && !o.enabled) {
            n = o.targets.length;
            for (i = 0; i < n; i++) {
                t = o.targets[i];
                t.element.addEventListener(t.event, o.listener, t.capture);
                o.enabled = true;
            }
            return true;
        }
        return false;
    },
    
    /**
     *  Désactiver un écouteur d'événement.
     *
     *  L'écouteur n'est pas supprimé ; il pourra être réactiver avec la
     *  méthode [#rnb.dom.enableEventListener]().
     *
     *  Pour supprimer complètement un écouteur d'événement, utiliser la méthode
     *  [#rnb.dom.removeEventListener]();
     *
     *  @param {String} id Identifiant de l'écouteur
     *  @return {Boolean} True si l'écouteur à été déconnecté, false si l'écouteur
     *  n'existe pas ou est déjà déconnecté.
     */
    disableEventListener: function (id)
    {
        var o = rnb.dom.listeners[id], i, n, target;
        if (o && o.enabled) {
            n = o.targets.length;
            for (i = 0; i < n; i++) {
                target = o.targets[i];
                target.element.removeEventListener(
                    target.event, 
                    o.listener, 
                    target.capture
                );
            }
            o.enabled = false;
            return true;
        }
        return false;
    },
    
    /**
     *  Un objet possède-t-il un écouteur sur un événement particulier.
     *  La méthode ne peut analyser que les écouteurs attachés avec la méthode 
     *  [#rnb.dom.addEventListener]().
     *
     *  @param {HTMLElement} obj L'objet sur lequel on est à l'écoute.
     *  @param {String} event L'événement devant posséder un écouteur.
     *  @return {boolean} 
     */
    hasEventListener: function (obj, event) 
    {
        var id, o, i, n, target;
        for (id in rnb.dom.listeners) {
            o = rnb.dom.listeners[id];
            if (!o.enabled) {
                continue;
            }
            n = o.targets.length;
            for (i = 0; i < n; i++) {
                target = o.targets[i];
                if (target.element === obj && target.event === event) {
                    return true;
                }
            }
        }
        return false;
    }
};