364 lines
8.8 KiB
JavaScript
364 lines
8.8 KiB
JavaScript
/*
|
|
Copyright (c) 2009, Yahoo! Inc. All rights reserved.
|
|
Code licensed under the BSD License:
|
|
http://developer.yahoo.net/yui/license.txt
|
|
version: 3.0.0
|
|
build: 1549
|
|
*/
|
|
YUI.add('event-custom-complex', function(Y) {
|
|
|
|
|
|
/**
|
|
* Adds event facades, preventable default behavior, and bubbling.
|
|
* events.
|
|
* @module event-custom
|
|
* @submodule event-custom-complex
|
|
*/
|
|
|
|
(function() {
|
|
|
|
var FACADE, FACADE_KEYS, CEProto = Y.CustomEvent.prototype;
|
|
|
|
/**
|
|
* Wraps and protects a custom event for use when emitFacade is set to true.
|
|
* Requires the event-custom-complex module
|
|
* @class EventFacade
|
|
* @param e {Event} the custom event
|
|
* @param currentTarget {HTMLElement} the element the listener was attached to
|
|
*/
|
|
|
|
Y.EventFacade = function(e, currentTarget) {
|
|
|
|
e = e || {};
|
|
|
|
/**
|
|
* The arguments passed to fire
|
|
* @property details
|
|
* @type Array
|
|
*/
|
|
this.details = e.details;
|
|
|
|
/**
|
|
* The event type
|
|
* @property type
|
|
* @type string
|
|
*/
|
|
this.type = e.type;
|
|
|
|
//////////////////////////////////////////////////////
|
|
|
|
/**
|
|
* Node reference for the targeted eventtarget
|
|
* @propery target
|
|
* @type Node
|
|
*/
|
|
this.target = e.target;
|
|
|
|
/**
|
|
* Node reference for the element that the listener was attached to.
|
|
* @propery currentTarget
|
|
* @type Node
|
|
*/
|
|
this.currentTarget = currentTarget;
|
|
|
|
/**
|
|
* Node reference to the relatedTarget
|
|
* @propery relatedTarget
|
|
* @type Node
|
|
*/
|
|
this.relatedTarget = e.relatedTarget;
|
|
|
|
/**
|
|
* Stops the propagation to the next bubble target
|
|
* @method stopPropagation
|
|
*/
|
|
this.stopPropagation = function() {
|
|
e.stopPropagation();
|
|
};
|
|
|
|
/**
|
|
* Stops the propagation to the next bubble target and
|
|
* prevents any additional listeners from being exectued
|
|
* on the current target.
|
|
* @method stopImmediatePropagation
|
|
*/
|
|
this.stopImmediatePropagation = function() {
|
|
e.stopImmediatePropagation();
|
|
};
|
|
|
|
/**
|
|
* Prevents the event's default behavior
|
|
* @method preventDefault
|
|
*/
|
|
this.preventDefault = function() {
|
|
e.preventDefault();
|
|
};
|
|
|
|
/**
|
|
* Stops the event propagation and prevents the default
|
|
* event behavior.
|
|
* @method halt
|
|
* @param immediate {boolean} if true additional listeners
|
|
* on the current target will not be executed
|
|
*/
|
|
this.halt = function(immediate) {
|
|
e.halt(immediate);
|
|
};
|
|
|
|
};
|
|
|
|
CEProto.fireComplex = function(args) {
|
|
var es = Y.Env._eventstack, ef, q, queue, ce, ret, events;
|
|
|
|
if (es) {
|
|
// queue this event if the current item in the queue bubbles
|
|
if (this.queuable && this.type != es.next.type) {
|
|
this.log('queue ' + this.type);
|
|
es.queue.push([this, args]);
|
|
return true;
|
|
}
|
|
} else {
|
|
Y.Env._eventstack = {
|
|
// id of the first event in the stack
|
|
id: this.id,
|
|
next: this,
|
|
silent: this.silent,
|
|
stopped: 0,
|
|
prevented: 0,
|
|
queue: []
|
|
};
|
|
es = Y.Env._eventstack;
|
|
}
|
|
|
|
this.stopped = 0;
|
|
this.prevented = 0;
|
|
this.target = this.target || this.host;
|
|
|
|
events = new Y.EventTarget({
|
|
fireOnce: true,
|
|
context: this.host
|
|
});
|
|
|
|
this.events = events;
|
|
|
|
if (this.preventedFn) {
|
|
events.on('prevented', this.preventedFn);
|
|
}
|
|
|
|
if (this.stoppedFn) {
|
|
events.on('stopped', this.stoppedFn);
|
|
}
|
|
|
|
this.currentTarget = this.host || this.currentTarget;
|
|
|
|
this.details = args.slice(); // original arguments in the details
|
|
|
|
// this.log("Firing " + this + ", " + "args: " + args);
|
|
this.log("Firing " + this.type);
|
|
|
|
this._facade = null; // kill facade to eliminate stale properties
|
|
|
|
ef = this._getFacade(args);
|
|
|
|
if (Y.Lang.isObject(args[0])) {
|
|
args[0] = ef;
|
|
} else {
|
|
args.unshift(ef);
|
|
}
|
|
|
|
if (this.hasSubscribers) {
|
|
this._procSubs(Y.merge(this.subscribers), args, ef);
|
|
}
|
|
|
|
// bubble if this is hosted in an event target and propagation has not been stopped
|
|
if (this.bubbles && this.host && this.host.bubble && !this.stopped) {
|
|
es.stopped = 0;
|
|
es.prevented = 0;
|
|
ret = this.host.bubble(this);
|
|
|
|
this.stopped = Math.max(this.stopped, es.stopped);
|
|
this.prevented = Math.max(this.prevented, es.prevented);
|
|
|
|
}
|
|
|
|
// execute the default behavior if not prevented
|
|
if (this.defaultFn && !this.prevented) {
|
|
this.defaultFn.apply(this.host || this, args);
|
|
}
|
|
|
|
// broadcast listeners are fired as discreet events on the
|
|
// YUI instance and potentially the YUI global.
|
|
this._broadcast(args);
|
|
|
|
// process after listeners. If the default behavior was
|
|
// prevented, the after events don't fire.
|
|
if (this.hasAfters && !this.prevented && this.stopped < 2) {
|
|
this._procSubs(Y.merge(this.afters), args, ef);
|
|
}
|
|
|
|
if (es.id === this.id) {
|
|
queue = es.queue;
|
|
|
|
while (queue.length) {
|
|
q = queue.pop();
|
|
ce = q[0];
|
|
es.stopped = 0;
|
|
es.prevented = 0;
|
|
// set up stack to allow the next item to be processed
|
|
es.next = ce;
|
|
ce.fire.apply(ce, q[1]);
|
|
}
|
|
|
|
Y.Env._eventstack = null;
|
|
}
|
|
|
|
return this.stopped ? false : true;
|
|
};
|
|
|
|
CEProto._getFacade = function() {
|
|
|
|
var ef = this._facade, o, o2,
|
|
args = this.details;
|
|
|
|
if (!ef) {
|
|
ef = new Y.EventFacade(this, this.currentTarget);
|
|
}
|
|
|
|
// if the first argument is an object literal, apply the
|
|
// properties to the event facade
|
|
o = args && args[0];
|
|
|
|
if (Y.Lang.isObject(o, true)) {
|
|
|
|
o2 = {};
|
|
|
|
// protect the event facade properties
|
|
Y.mix(o2, ef, true, FACADE_KEYS);
|
|
|
|
// mix the data
|
|
Y.mix(ef, o, true);
|
|
|
|
// restore ef
|
|
Y.mix(ef, o2, true, FACADE_KEYS);
|
|
}
|
|
|
|
// update the details field with the arguments
|
|
// ef.type = this.type;
|
|
ef.details = this.details;
|
|
ef.target = this.target;
|
|
ef.currentTarget = this.currentTarget;
|
|
ef.stopped = 0;
|
|
ef.prevented = 0;
|
|
|
|
this._facade = ef;
|
|
|
|
return this._facade;
|
|
};
|
|
|
|
/**
|
|
* Stop propagation to bubble targets
|
|
* @for CustomEvent
|
|
* @method stopPropagation
|
|
*/
|
|
CEProto.stopPropagation = function() {
|
|
this.stopped = 1;
|
|
Y.Env._eventstack.stopped = 1;
|
|
this.events.fire('stopped', this);
|
|
};
|
|
|
|
/**
|
|
* Stops propagation to bubble targets, and prevents any remaining
|
|
* subscribers on the current target from executing.
|
|
* @method stopImmediatePropagation
|
|
*/
|
|
CEProto.stopImmediatePropagation = function() {
|
|
this.stopped = 2;
|
|
Y.Env._eventstack.stopped = 2;
|
|
this.events.fire('stopped', this);
|
|
};
|
|
|
|
/**
|
|
* Prevents the execution of this event's defaultFn
|
|
* @method preventDefault
|
|
*/
|
|
CEProto.preventDefault = function() {
|
|
if (this.preventable) {
|
|
this.prevented = 1;
|
|
Y.Env._eventstack.prevented = 1;
|
|
this.events.fire('prevented', this);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Stops the event propagation and prevents the default
|
|
* event behavior.
|
|
* @method halt
|
|
* @param immediate {boolean} if true additional listeners
|
|
* on the current target will not be executed
|
|
*/
|
|
CEProto.halt = function(immediate) {
|
|
if (immediate) {
|
|
this.stopImmediatePropagation();
|
|
} else {
|
|
this.stopPropagation();
|
|
}
|
|
this.preventDefault();
|
|
};
|
|
|
|
/**
|
|
* Propagate an event. Requires the event-custom-complex module.
|
|
* @method bubble
|
|
* @param evt {Event.Custom} the custom event to propagate
|
|
* @return {boolean} the aggregated return value from Event.Custom.fire
|
|
* @for EventTarget
|
|
*/
|
|
Y.EventTarget.prototype.bubble = function(evt, args, target) {
|
|
|
|
var targs = this._yuievt.targets, ret = true,
|
|
t, type, ce, i, bc;
|
|
|
|
if (!evt || ((!evt.stopped) && targs)) {
|
|
|
|
for (i in targs) {
|
|
if (targs.hasOwnProperty(i)) {
|
|
t = targs[i];
|
|
type = evt && evt.type;
|
|
ce = t.getEvent(type, true);
|
|
|
|
// if this event was not published on the bubble target,
|
|
// publish it with sensible default properties
|
|
if (!ce) {
|
|
|
|
if (t._yuievt.hasTargets) {
|
|
t.bubble.call(t, evt, args, target);
|
|
}
|
|
|
|
} else {
|
|
ce.target = target || (evt && evt.target) || this;
|
|
ce.currentTarget = t;
|
|
|
|
bc = ce.broadcast;
|
|
ce.broadcast = false;
|
|
ret = ret && ce.fire.apply(ce, args || evt.details);
|
|
ce.broadcast = bc;
|
|
|
|
// stopPropagation() was called
|
|
if (ce.stopped) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
};
|
|
|
|
FACADE = new Y.EventFacade();
|
|
FACADE_KEYS = Y.Object.keys(FACADE);
|
|
|
|
})();
|
|
|
|
|
|
}, '3.0.0' ,{requires:['event-custom-base']});
|