event-debug.js revision 4fcbec6145d16637205990699912fb90f6a3807c
/**
* The YUI event system
* @module event
*/
/**
* Subscribes to the yui:load event, which fires when a Y.use operation
* is complete.
* @method ready
* @param f {Function} the function to execute
* @param c Optional execution context
* @param args* 0..n Additional arguments to append
* to the signature provided when the event fires.
* @return {YUI} the YUI instance
*/
// Y.ready = function(f, c) {
// var a = arguments, m = (a.length > 1) ? Y.bind.apply(Y, a) : f;
// Y.on("yui:load", m);
// return this;
// };
/**
* Attach an event listener, either to a DOM object
* or to an Event.Target.
* @param type {string} the event type
* @param f {Function} the function to execute
* @param o the Event.Target or element to attach to
* @param context Optional execution context
* @param args* 0..n additional arguments to append
* to the signature provided when the event fires.
* @method on
* @for YUI
* @return {Event.Handle} a handle object for
* unsubscribing to this event.
*/
switch (cat[0]) {
default:
}
} else {
}
};
/**
* Detach an event listener (either a custom event or a
* DOM event
* @method detach
* @param type the type of event, or a Event.Handle to
* for the subscription. If the Event.Handle is passed
* in, the other parameters are not used.
* @param f {Function} the subscribed function
* @param o the object or element the listener is subscribed
* to.
* @method detach
* @return {YUI} the YUI instance
*/
switch (cat[0]) {
default:
}
} else {
}
};
/**
* Executes the callback before a DOM event, custom event
* or method. If the first argument is a function, it
* is assumed the target is a method.
*
* For DOM and custom events:
* type, callback, context, 1-n arguments
*
* For methods:
* callback, object (method host), methodName, context, 1-n arguments
*
* @method before
* @return unsubscribe handle
*/
// method override
// callback, object, sMethod
}
return Y;
};
/**
* Executes the callback after a DOM event, custom event
* or method. If the first argument is a function, it
* is assumed the target is a method.
*
* @TODO add event
*
* For DOM and custom events:
* type, callback, context, 1-n arguments
*
* For methods:
* callback, object (method host), methodName, context, 1-n arguments
*
* @method after
* @return unsubscribe handle
*/
}
return Y;
};
}, "3.0.0", {
use: [
"aop",
"event-custom",
"event-target",
"event-ready",
"event-dom",
"event-facade"
]
});
/*
* Method displacement
* @submodule event-aop
* @module event
*/
var BEFORE = 0,
AFTER = 1;
/**
* Allows for the insertion of methods that are executed before or after
* a specified method
* @class Do
* @static
*/
Y.Do = {
/**
* Cache of objects touched by the utility
* @property objs
* @static
*/
objs: {},
/**
* Execute the supplied method before the specified function
* @method before
* @param fn {Function} the function to execute
* @param obj the object hosting the method to displace
* @param sFn {string} the name of the method to displace
* @param c The execution context for fn
* @return {string} handle for the subscription
* @static
*/
var f = fn;
if (c) {
}
},
/**
* Execute the supplied method after the specified function
* @method after
* @param fn {Function} the function to execute
* @param obj the object hosting the method to displace
* @param sFn {string} the name of the method to displace
* @param c The execution context for fn
* @return {string} handle for the subscription
* @static
*/
var f = fn;
if (c) {
}
},
/**
* Execute the supplied method after the specified function
* @method _inject
* @param when {string} before or after
* @param fn {Function} the function to execute
* @param obj the object hosting the method to displace
* @param sFn {string} the name of the method to displace
* @param c The execution context for fn
* @return {string} handle for the subscription
* @private
* @static
*/
// object id
// create a map entry for the obj if it doesn't exist
}
if (! o[sFn]) {
// create a map entry for the method if it doesn't exist
// re-route the method to our wrapper
function() {
};
}
// subscriber id
// register the callback
return sid;
},
/**
* Detach a before or after subscription
* @method detach
* @param sid {string} the subscription handle
*/
},
}
};
//////////////////////////////////////////////////////////////////////////
/**
* Wrapper for a displaced method with aop enabled
* @class Do.Method
* @constructor
* @param obj The object to operate on
* @param sFn The name of the method to displace
*/
this.methodName = sFn;
// this.before = [];
// this.after = [];
this.before = {};
this.after = {};
};
/**
* Register a aop subscriber
* @method register
* @param sid {string} the subscriber id
* @param fn {Function} the function to execute
* @param when {string} when to execute the function
*/
if (when) {
// this.after.push(fn);
} else {
// this.before.push(fn);
}
};
/**
* Execute the wrapped method
* @method exec
*/
// for (i=0; i<this.before.length; ++i) {
for (i in bf) {
if (bf.hasOwnProperty(i)) {
// Stop processing if an Error is returned
// this.logger.debug("Error before " + this.methodName +
// ": " ret.msg);
// Check for altered arguments
// this.logger.debug("Params altered before " +
// this.methodName + ": " ret.msg);
}
}
}
// execute method
// execute after methods.
// for (i=0; i<this.after.length; ++i) {
for (i in af) {
if (af.hasOwnProperty(i)) {
// Stop processing if an Error is returned
// this.logger.debug("Error after " + this.methodName +
// ": " ret.msg);
// Check for a new return value
// this.logger.debug("Return altered after " +
// this.methodName + ": " newRet.msg);
}
}
}
return ret;
};
//////////////////////////////////////////////////////////////////////////
/**
* Return an Error object when you want to terminate the execution
* of all subsequent method calls
* @class Do.Error
*/
};
/**
* Return an AlterArgs object when you want to change the arguments that
* were passed into the function. An example would be a service that scrubs
* out illegal characters prior to executing the core business logic.
* @class Do.AlterArgs
*/
};
/**
* Return an AlterReturn object when you want to change the result returned
* from the core method to the caller
* @class Do.AlterReturn
*/
};
//////////////////////////////////////////////////////////////////////////
// Y["Event"] && Y.Event.addListener(window, "unload", Y.Do._unload, Y.Do);
}, "3.0.0");
/*
* YUI Custom Events
* @submodule event-custom
* @module event
*/
var onsubscribeType = "_event:onsub",
AFTER = 'after',
CONFIGS = [
'broadcast',
'bubbles',
'context',
'configured',
'currentTarget',
'defaultFn',
'details',
'emitFacade',
'fireOnce',
'host',
'preventable',
'preventedFn',
'queuable',
'silent',
'stoppedFn',
'target',
'type'
];
/**
* Return value from all subscribe operations
* @class Event.Handle
* @constructor
* @param evt {Event.Custom} the custom event
* @param sub {Event.Subscriber} the subscriber
*/
return null;
}
/**
* The custom event
* @type Event.Custom
*/
/**
* The subscriber object
* @type Event.Subscriber
*/
};
Y.EventHandle.prototype = {
/**
* Detaches this subscriber
* @method detach
*/
detach: function() {
}
};
/**
* The Event.Custom class lets you define events for your application
* that can be subscribed to by one or more independent component.
*
* @param {String} type The type of event, which is passed to the callback
* when the event fires
* @param {Object} context The context the event will fire from. "this" will
* refer to this object in the callback. Default value:
* the window object. The listener can override this.
* @param {boolean} silent pass true to prevent the event from writing to
* the debug system
* @class Event.Custom
* @constructor
*/
Y.CustomEvent = function(type, o) {
// if (arguments.length > 2) {
// this.log('CustomEvent context and silent are now in the config', 'warn', 'Event');
// }
o = o || {};
/**
* The type of event, returned to subscribers when the event fires
* @property type
* @type string
*/
/**
* The context the the event will fire from by default. Defaults to the YUI
* instance.
* @property context
* @type object
*/
this.context = Y;
/**
* If 0, this event does not broadcast. If 1, the YUI instance is notified
* every time this event fires. If 2, the YUI instance and the YUI global
* (if event is enabled on the global) are notified every time this event
* fires.
* @property broadcast
* @type int
*/
this.broadcast = 0;
/**
* By default all custom events are logged in the debug build, set silent
* to true to disable debug outpu for this event.
* @property silent
* @type boolean
*/
// this.queuable = !(this.logSystem);
this.queuable = false;
/**
* The subscribers to this event
* @property subscribers
* @type Event.Subscriber{}
*/
this.subscribers = {};
/**
* The publisher has configured this event
* @property configured
* @type boolean
* @default true
*/
this.configured = true;
/**
* 'After' subscribers
* @property afters
* @type Event.Subscriber{}
*/
this.afters = {};
/**
* This event has fired if true
*
* @property fired
* @type boolean
* @default false;
*/
this.fired = false;
/**
* This event should only fire one time if true, and if
* it has fired, any new subscribers should be notified
* immediately.
*
* @property fireOnce
* @type boolean
* @default false;
*/
this.fireOnce = false;
/**
* Flag for stopPropagation that is modified during fire()
* 1 means to stop propagation to bubble targets. 2 means
* to also stop additional subscribers on this target.
* @property stopped
* @type int
*/
this.stopped = 0;
/**
* Flag for preventDefault that is modified during fire().
* if it is not 0, the default behavior for this event
* @property prevented
* @type int
*/
this.prevented = 0;
/**
* Specifies the host for this custom event. This is used
* to enable event bubbling
* @property host
* @type Event.Target
*/
this.host = null;
/**
* The default function to execute after event listeners
* have fire, but only if the default action was not
* prevented.
* @property defaultFn
* @type Function
*/
this.defaultFn = null;
/**
* The function to execute if a subscriber calls
* stopPropagation or stopImmediatePropagation
* @property stoppedFn
* @type Function
*/
this.stoppedFn = null;
/**
* The function to execute if a subscriber calls
* preventDefault
* @property preventedFn
* @type Function
*/
this.preventedFn = null;
/**
* Specifies whether or not this event's default function
* can be cancelled by a subscriber by executing preventDefault()
* on the event facade
* @property preventable
* @type boolean
* @default true
*/
this.preventable = true;
/**
* Specifies whether or not a subscriber can stop the event propagation
* via stopPropagation(), stopImmediatePropagation(), or halt()
* @property bubbles
* @type boolean
* @default true
*/
this.bubbles = true;
this.emitFacade = false;
this.applyConfig(o, true);
// Only add subscribe events for events that are not generated by
// Event.Custom
if (type !== onsubscribeType) {
/**
* Custom events provide a custom event that fires whenever there is
* a new subscriber to the event. This provides an opportunity to
* handle the case where there is a non-repeating event that has
* already fired has a new subscriber.
*
* @event subscribeEvent
* @type Y.Event.Custom
* @param {Function} fn The function to execute
* @param {Object} obj An object to be passed along when the event
* fires
* @param {boolean|Object} override If true, the obj passed in becomes
* the execution context of the listener.
* if an object, that object becomes the
* the execution context.
*/
context: this,
silent: true
});
}
};
Y.CustomEvent.prototype = {
_YUI_EVENT: true,
/**
* Apply configuration properties. Only applies the CONFIG whitelist
* @method applyConfig
* @param o hash of properties to apply
* @param force {boolean} if true, properties that exist on the event
* will be overwritten.
*/
applyConfig: function(o, force) {
if (o) {
}
},
if (!fn) {
}
var se = this.subscribeEvent;
if (se) {
}
this._notify(s);
}
} else {
this.subscribers[s.id] = s;
}
return new Y.EventHandle(this, s);
},
/**
* Listen for this event
* @method subscribe
* @param {Function} fn The function to execute
* @param {Object} obj An object to be passed along when the event fires
* @param args* 1..n params to provide to the listener
* @return {Event.Handle} unsubscribe handle
*/
},
/**
* Listen for this event after the normal subscribers have been notified and
* the default behavior has been applied. If a normal subscriber prevents the
* default behavior, it also prevents after listeners from firing.
* @method after
* @param {Function} fn The function to execute
* @param {Object} obj An object to be passed along when the event fires
* @param args* 1..n params to provide to the listener
* @return {Event.Handle} unsubscribe handle
*/
},
/**
* Unsubscribes subscribers.
* @method unsubscribe
* @param {Function} fn The subscribed function to remove, if not supplied
* all will be removed
* @param {Object} obj The custom object passed to subscribe. This is
* optional, but if supplied will be used to
* disambiguate multiple listeners that are the same
* (e.g., you subscribe many object using a function
* that lives on the prototype)
* @return {boolean} True if the subscriber was found and detached.
*/
// if arg[0] typeof unsubscribe handle
}
if (!fn) {
return this.unsubscribeAll();
}
for (var i in subs) {
if (subs.hasOwnProperty(i)) {
var s = subs[i];
this._delete(s);
found = true;
}
}
}
return found;
},
_getFacade: function(args) {
if (!ef) {
}
// if the first argument is an object literal, apply the
// properties to the event facade
}
// update the details field with the arguments
return this._facade;
},
/**
* Notify a single subscriber
* @method _notify
* @param s {Event.Subscriber} the subscriber
* @param args {Array} the arguments array to apply to the listener
* @private
*/
var ret;
// emit an Event.Facade if this is that sort of event
// if (this.emitFacade && (!args[0] || !args[0]._yuifacade)) {
if (this.emitFacade) {
// @TODO object literal support to fire makes it possible for
// config info to be passed if we wish.
if (!ef) {
}
}
return false;
}
return true;
},
/**
* Logger abstraction to centralize the application of the silent flag
* @method log
* @param msg {string} message to log
* @param cat {string} log category
*/
// if (!s && !this.silent) {
if (!this.silent) {
}
},
/**
* Notifies the subscribers. The callback functions will be executed
* from the context specified when the event was created, and with the
* following parameters:
* <ul>
* <li>The type of event</li>
* <li>All of the arguments fire() was executed with as an array</li>
* <li>The custom object (if any) that was passed into the subscribe()
* method</li>
* </ul>
* @method fire
* @param {Object*} arguments an arbitrary set of parameters to pass to
* the handler.
* @return {boolean} false if one of the subscribers returned false,
* true otherwise
*/
fire: function() {
if (es) {
// var b = this.bubbles, h = this.host;
// if (b && h) {
// b = (h._yuievt.targets.length);
// }
// es.silent = (es.silent || this.silent);
// queue this event if the current item in the queue bubbles
// if (b && this.queuable && this.type != es.next.type) {
return true;
}
} else {
Y.Env._eventstack = {
// id of the first event in the stack
next: this,
stopped: 0,
prevented: 0,
queue: []
};
}
var ret = true;
} else {
// var subs = this.subscribers.slice(), len=subs.length,
this.stopped = 0;
this.prevented = 0;
this.fired = true;
// this.log("Firing " + this + ", " + "args: " + args);
var hasSub = false;
for (i in subs) {
if (subs.hasOwnProperty(i)) {
if (!hasSub) {
hasSub = true;
}
// stopImmediatePropagation
if (this.stopped == 2) {
break;
}
s = subs[i];
if (s && s.fn) {
if (false === ret) {
this.stopped = 2;
}
}
}
}
// bubble if this is hosted in an event target and propagation has not been stopped
// @TODO check if we need to worry about defaultFn order
}
// execute the default behavior if not prevented
// @TODO need context
}
// process after listeners. If the default behavior was
// prevented, the after events don't fire.
for (i in subs) {
if (subs.hasOwnProperty(i)) {
if (!hasSub) {
hasSub = true;
}
// stopImmediatePropagation
if (this.stopped == 2) {
break;
}
s = subs[i];
if (s && s.fn) {
if (false === ret) {
this.stopped = 2;
}
}
}
}
}
}
// console.log('clearing stack: ' + es.id + ', ' + this);
// reset propragation properties while processing the rest of the queue
// process queued events
// q[0] = the event, q[1] = arguments to fire
// Y.log('firing queued event ' + ce.type + ', from ' + this);
// set up stack to allow the next item to be processed
}
Y.Env._eventstack = null;
}
return (ret !== false);
},
/**
* Removes all listeners
* @method unsubscribeAll
* @return {int} The number of listeners unsubscribed
*/
unsubscribeAll: function() {
var subs = this.subscribers, i;
for (i in subs) {
if (subs.hasOwnProperty(i)) {
}
}
this.subscribers={};
return i;
},
/**
* @method _delete
* @param subscriber object
* @private
*/
_delete: function(s) {
if (s) {
delete s.fn;
delete s.obj;
delete this.subscribers[s.id];
}
},
/**
* @method toString
*/
toString: function() {
// return "{ CE '" + this.type + "' " + "id: " + this.id +
// ", host: " + (this.host && Y.stamp(this.host) + " }");
return this.type;
},
/**
* Stop propagation to bubble targets
* @method stopPropagation
*/
stopPropagation: function() {
this.stopped = 1;
if (this.stoppedFn) {
}
},
/**
* Stops propagation to bubble targets, and prevents any remaining
* subscribers on the current target from executing.
* @method stopImmediatePropagation
*/
stopImmediatePropagation: function() {
this.stopped = 2;
if (this.stoppedFn) {
}
},
/**
* Prevents the execution of this event's defaultFn
* @method preventDefault
*/
preventDefault: function() {
if (this.preventable) {
this.prevented = 1;
}
if (this.preventedFn) {
}
}
};
/////////////////////////////////////////////////////////////////////
/**
* Stores the subscriber information to be used when the event fires.
* @param {Function} fn The wrapped function to execute
* @param {Object} obj An object to be passed along when the event fires
* @param {Array} args subscribe() additional arguments
*
* @class Event.Subscriber
* @constructor
*/
/**
* The callback that will be execute when the event fires
* This is wrapped by Y.bind if obj was supplied.
* @property fn
* @type Function
*/
/**
* An optional custom object that will passed to the callback when
* the event fires
* @property obj
* @type Object
*/
/**
* Unique subscriber id
* @property id
* @type String
*/
/**
* Optional additional arguments supplied to subscribe(). If present,
* these will be appended to the arguments supplied to fire()
* @property args
* @type Array
*/
// this.args = args;
var m = fn;
if (obj) {
}
/**
* }
* fn bound to obj with additional arguments applied via Y.bind
* @property wrappedFn
* @type Function
*/
this.wrappedFn = m;
};
Y.Subscriber.prototype = {
/**
* Executes the subscriber.
* @method notify
* @param defaultContext The execution context if not overridden
* by the subscriber
* @param args {Array} Arguments array for the subscriber
*/
try {
} catch(e) {
}
return ret;
},
/**
* Returns true if the fn and obj match this objects properties.
* Used by the unsubscribe method to match the right subscriber.
*
* @method contains
* @param {Function} fn the function to execute
* @param {Object} obj an object to be passed along when the event fires
* @return {boolean} true if the supplied arguments match this
* subscriber's signature.
*/
if (obj) {
} else {
}
},
/**
* @method toString
*/
toString: function() {
return "Subscriber " + this.id;
}
};
}, "3.0.0");
/*
* Configures an object to be able to be targeted for events, and to publish events
* @submodule event-target
* @module event
*/
var SILENT = { 'yui:log': true };
/**
* Event.Target is designed to be used with Y.augment to wrap
* Event.Custom in an interface that allows events to be subscribed to
* and fired by name. This makes it possible for implementing code to
* subscribe to an event that either has not been created yet, or will
* not be created at all.
*
* @Class Event.Target
*/
Y.EventTarget = function(opts) {
// console.log('Event.Target constructor executed: ' + this._yuid);
this._yuievt = {
events: {},
targets: {},
config: o,
defaults: {
context: this,
host: this,
emitFacade: o.emitFacade || false,
}
};
};
var ET = Y.EventTarget;
/**
* Subscribe to a custom event hosted by this object
* @method subscribe
* @param type {string} The type of the event
* @param fn {Function} The callback
* @param context The execution context
* @param args* 1..n params to supply to the callback
*/
configured: false
}),
a = Y.Array(arguments, 1, true);
},
/**
* Unsubscribes one or more listeners the from the specified event
* @method unsubscribe
* @param type {string|Object} Either the handle to the subscriber or the
* type of event. If the type
* is not specified, it will attempt to remove
* the listener from all hosted events.
* @param fn {Function} The subscribed function to unsubscribe, if not
* supplied, all subscribers will be removed.
* @param context {Object} The custom object passed to subscribe. This is
* optional, but if supplied will be used to
* disambiguate multiple listeners that are the same
* (e.g., you subscribe many object using a function
* that lives on the prototype)
* @return {boolean} true if the subscriber was found and detached.
*/
// If this is an event handle, use it to detach
}
if (type) {
if (ce) {
}
} else {
var ret = true;
for (var i in evts) {
}
}
return ret;
}
return false;
},
/**
* Removes all listeners from the specified event. If the event type
* is not specified, all listeners from all hosted custom events will
* be removed.
* @method unsubscribeAll
* @param type {string} The type, or name of the event
*/
unsubscribeAll: function(type) {
return this.unsubscribe(type);
},
/**
* Creates a new custom event of the specified type. If a custom event
* by that name already exists, it will not be re-created. In either
* case the custom event is returned.
*
* @method publish
*
* @param type {string} the type, or name of the event
* @param opts {object} optional config params. Valid properties are:
*
* <ul>
* <li>
* 'broadcast': whether or not the YUI instance and YUI global are notified when the event is fired (false)
* </li>
* <li>
* 'bubbles': whether or not this event bubbles (true)
* </li>
* <li>
* 'context': the default execution context for the listeners (this)
* </li>
* <li>
* 'defaultFn': the default function to execute when this event fires if preventDefault was not called
* </li>
* <li>
* 'emitFacade': whether or not this event emits a facade (false)
* </li>
* <li>
* 'fireOnce': if an event is configured to fire once, new subscribers after
* the fire will be notified immediately.
* </li>
* <li>
* 'preventable': whether or not preventDefault() has an effect (true)
* </li>
* <li>
* 'preventedFn': a function that is executed when preventDefault is called
* </li>
* <li>
* 'queuable': whether or not this event can be queued during bubbling (false)
* </li>
* <li>
* 'silent': if silent is true, debug messages are not provided for this event.
* </li>
* <li>
* 'stoppedFn': a function that is executed when stopPropagation is called
* </li>
* <li>
* 'type': the event type (valid option if not provided as the first parameter to publish)
* </li>
* </ul>
*
* @return {Event.Custom} the custom event
*
*/
// This event could have been published
ce.configured = true;
} else {
var o = opts || {};
// apply defaults
if (o.onSubscribeCallback) {
}
}
},
/**
* Registers another Event.Target as a bubble target. Bubble order
* is determined by the order registered. Multiple targets can
* be specified.
* @method addTarget
* @param o {Event.Target} the target to add
*/
addTarget: function(o) {
this._yuievt.hasTargets = true;
},
/**
* Removes a bubble target
* @method removeTarget
* @param o {Event.Target} the target to remove
*/
removeTarget: function(o) {
},
/**
* Fire a custom event by name. The callback functions will be executed
* from the context specified when the event was created, and with the
* following parameters.
*
* If the custom event object hasn't been created, then the event hasn't
* been published and it has no subscribers. For performance sake, we
* immediate exit in this case. This means the event won't bubble, so
* if the intention is that a bubble target be notified, the event must
* be published on this object first.
*
* @method fire
* @param type {String|Object} The type of the event, or an object that contains
* a 'type' property.
* @param arguments {Object*} an arbitrary set of parameters to pass to
* the handler.
* @return {boolean} the return value from Event.Custom.fire
*
*/
// this event has not been published or subscribed to
if (!ce) {
// if this object has bubble targets, we need to publish the
// event in order for it to bubble.
if (this._yuievt.hasTargets) {
configured: false
});
}
// otherwise there is nothing to be done
return true;
}
// Provide this object's subscribers the object they are listening to.
// ce.currentTarget = this;
// This this the target unless target is current not null
// (set in bubble()).
// ce.target = ce.target || this;
// clear target for next fire()
return ret;
},
/**
* Returns the custom event of the provided type has been created, a
* falsy value otherwise
* @method getEvent
* @param type {string} the type, or name of the event
* @return {Event.Target} the custom event or a falsy value
*/
return (e && e[type]);
},
/**
* Propagate an event
* @method bubble
* @param evt {Event.Custom} the custom event to propagate
* @return {boolean} the aggregated return value from Event.Custom.fire
*/
// Y.log('Bubbling ' + evt.type);
for (var i in targs) {
if (targs.hasOwnProperty(i)) {
// if this event was not published on the bubble target,
// publish it with sensible default properties
if (!ce) {
// publish the event on the bubble target using this event
// for its configuration
ce.configured = false;
// set the host and context appropriately
// clear handlers if specified on this event
ce.preventedFn = null;
}
ce.currentTarget = t;
// ce.target = evt.target;
// stopPropagation() was called
break;
}
}
}
}
return ret;
},
/**
* Subscribe to a custom event hosted by this object. The
* supplied callback will execute after any listeners add
* via the subscribe method, and after the default function,
* if configured for the event, has executed.
* @method after
* @param type {string} The type of the event
* @param fn {Function} The callback
* @param context The execution context
* @param args* 1..n params to supply to the callback
*/
configured: false
}),
a = Y.Array(arguments, 1, true);
}
};
// make Y an event target
bubbles: false
});
}, "3.0.0");
/*
* DOMReady
* @submodule event-ready
* @module event
*/
if (Y === YUI) {
return;
}
// Fire the content ready custom event
// E.DOMReadyEvent.fire();
if (D.removeEventListener) {
}
}
};
// create custom event
/////////////////////////////////////////////////////////////
// DOMReady
// Internet Explorer: use the readyState of a defered script.
// This isolates what appears to be a safe moment to manipulate
// the DOM prior to when the document's readyState suggests
// it is safe to do so.
var n = D.createElement('p');
try {
// throws an error if doc is not ready
n.doScroll('left');
n = null;
} catch (ex) {
n = null;
}
}, POLL_INTERVAL);
// The document's readyState in Safari currently will
var rs=D.readyState;
}
}, POLL_INTERVAL);
// FireFox and Opera: These browsers provide a event for this
// moment. The latest WebKit releases now support this event.
} else {
}
/////////////////////////////////////////////////////////////
}
Y.publish('event:ready', {
fireOnce: true
});
var yready = function() {
Y.fire('event:ready');
};
yready();
} else {
}
}, "3.0.0");
/*
* The YUI DOM event system
* @submodule event-dom
* @module event
*/
/*
* The Event Utility provides utilities for managing DOM Events and tools
* for building event systems
*
* @module event
* @title Event Utility
*/
/**
* The event utility provides functions to add and remove event listeners,
* event cleansing. It also tries to automatically remove listeners it
* registers during the unload event.
*
* @class Event
* @static
*/
Y.Event = function() {
/**
* True after the onload event has fired
* @property loadComplete
* @type boolean
* @static
* @private
*/
var loadComplete = false;
/**
* The number of times to poll after window.onload. This number is
* increased if additional late-bound handlers are requested after
* the page load.
* @property _retryCount
* @static
* @private
*/
var _retryCount = 0;
/**
* onAvailable listeners
* @property _avail
* @static
* @private
*/
var _avail = [];
/**
* Custom event wrappers for DOM events. Key is
* 'event:' + Element uid stamp + event type
* @property _wrappers
* @type Y.Event.Custom
* @static
* @private
*/
var _wrappers = {};
/**
* Custom event wrapper map DOM events. Key is
* Element uid stamp. Each item is a hash of custom event
* wrappers as provided in the _wrappers collection. This
* provides the infrastructure for getListeners.
* @property _el_events
* @static
* @private
*/
var _el_events = {};
return {
/**
* The number of times we should look for elements that are not
* in the DOM at the time the event is requested after the document
* has been loaded. The default is 2000@amp;20 ms, so it will poll
* for 40 seconds or until all outstanding handlers are bound
* (whichever comes first).
* @property POLL_RETRYS
* @type int
* @static
* @final
*/
POLL_RETRYS: 2000,
/**
* The poll interval in milliseconds
* @property POLL_INTERVAL
* @type int
* @static
* @final
*/
POLL_INTERVAL: 20,
/**
* addListener/removeListener can throw errors in unexpected scenarios.
* These errors are suppressed, the method returns false, and this property
* is set
* @property lastError
* @static
* @type Error
*/
lastError: null,
/**
* poll handle
* @property _interval
* @static
* @private
*/
_interval: null,
/**
* document readystate poll handle
* @property _dri
* @static
* @private
*/
_dri: null,
/**
* True when the document is initially usable
* @property DOMReady
* @type boolean
* @static
*/
DOMReady: false,
/**
* @method startInterval
* @static
* @private
*/
startInterval: function() {
if (!this._interval) {
var self = this;
}
},
/**
* Executes the supplied callback when the item with the supplied
* id is found. This is meant to be used to execute behavior as
* soon as possible as the page loads. If you use this after the
* initial page load it will poll for a fixed time for the element.
* The number of times it will poll and the frequency are
* configurable. By default it will poll for 10 seconds.
*
* <p>The callback is executed with a single parameter:
* the custom object parameter, if provided.</p>
*
* @method onAvailable
*
* @param {string||string[]} id the id of the element, or an array
* of ids to look for.
* @param {function} fn what to execute when the element is found.
* @param {object} p_obj an optional object to be passed back as
* a parameter to fn.
* @param {boolean|object} p_override If set to true, fn will execute
* in the context of p_obj, if set to an object it
* will execute in the context of that object
* @param checkContent {boolean} check child node readiness (onContentReady)
* @static
*/
// @TODO fix arguments
// var a = (Y.Lang.isString(id)) ? [id] : id;
var a = Y.Array(id);
checkReady: checkContent });
}
_retryCount = this.POLL_RETRYS;
this.startInterval();
},
/**
* Works the same way as onAvailable, but additionally checks the
* state of sibling elements to determine if the content of the
* available element is safe to modify.
*
* <p>The callback is executed with a single parameter:
* the custom object parameter, if provided.</p>
*
* @method onContentReady
*
* @param {string} id the id of the element to look for.
* @param {function} fn what to execute when the element is ready.
* @param {object} p_obj an optional object to be passed back as
* a parameter to fn.
* @param {boolean|object} p_override If set to true, fn will execute
* in the context of p_obj. If an object, fn will
* exectute in the context of that object
*
* @static
*/
// @TODO fix arguments
},
/**
* Executes the supplied callback when the DOM is first usable. This
* will execute immediately if called after the DOMReady event has
* fired. @todo the DOMContentReady event does not fire when the
* script is dynamically injected into the page. This means the
* DOMReady custom event will never fire in FireFox or Opera when the
* library is injected. It _will_ fire in Safari, and the IE
* implementation would allow for us to fire it if the defered script
* is not available. We want this to behave the same in all browsers.
* Is there a way to identify when the script has been injected
* instead of included inline? Is there a way to know whether the
* window onload event has fired without having had a listener attached
* to it when it did so?
*
* <p>The callback is a Event.Custom, so the signature is:</p>
* <p>type <string>, args <array>, customobject <object></p>
* <p>For DOMReady events, there are no fire argments, so the
* signature is:</p>
* <p>"DOMReady", [], obj</p>
*
*
* @method onDOMReady
*
* @param {function} fn what to execute when the element is found.
* @optional context execution context
* @optional args 1..n arguments to send to the listener
*
* @static
*/
onDOMReady: function(fn) {
// var ev = Y.Event.DOMReadyEvent;
// ev.subscribe.apply(ev, arguments);
var a = Y.Array(arguments, 0, true);
a.unshift('event:ready');
},
/**
* Appends an event handler
*
* @method addListener
*
* @param {String|HTMLElement|Array|NodeList} el An id, an element
* listener to.
* @param {String} type The type of event to append
* @param {Function} fn The method the event invokes
* @param {Object} obj An arbitrary object that will be
* passed as a parameter to the handler
* @param {Boolean|object} args 1..n ar
* @return {Boolean} True if the action was successful or defered,
* false if one or more of the elements
* could not have the listener attached,
* or if the operation throws an exception.
* @static
*/
// Y.log('addListener: ' + Y.Lang.dump(Y.Array(arguments, 0, true), 1));
// throw new TypeError(type + " addListener call failed, callback undefined");
return false;
}
// The el argument can be an array of elements or element ids.
if (this._isValidCollection(el)) {
// Y.log('collection: ' + el);
// Y.log('collection: ' + el.item(0) + ', ' + el.item(1));
// handles.push(this.addListener(el[i], type, fn, obj, override));
// var node = el.item(k);
// Y.log('collection stuff: ' + node);
var b = a.slice();
b.unshift(v);
h = E.addListener.apply(E, b);
};
return handles;
// If the el argument is a string, we assume it is
// actually the id of the element. If the page is loaded
// we convert el to the actual element, otherwise we
// defer attaching the event until onload event fires
// check to see if we need to delay hooking up the event
// until after the page loads.
if (size) {
if (size > 1) {
} else {
}
} else {
//
// defer adding the event until the element is available
this.onAvailable(el, function() {
// Y.Event.addListener(el, type, fn, obj, override);
});
return true;
}
}
// Element should be an html element or an array if we get
// here.
if (!el) {
// Y.log("unable to attach event " + type);
return false;
}
// the custom event key is the uid for the element + type
if (!cewrapper) {
// create CE wrapper
silent: true,
// host: this,
bubbles: false
});
// cache the dom event details in the custom event
// for later removeListener calls
};
// var capture = (Y.lang.isObject(obj) && obj.capture);
// attach a listener that fires the custom event
}
// from type, fn, etc to fn, obj, override
a = Y.Array(arguments, 2, true);
// a = a.shift();
// if (override) {
// if (override === true) {
// context = obj;
// } else {
// context = override;
// }
// }
a[1] = context;
// set context to element if not specified
},
/**
* Removes an event listener
*
* @method removeListener
*
* @param {String|HTMLElement|Array|NodeList} el An id, an element
* the listener from.
* @param {String} type the type of event to remove.
* @param {Function} fn the method the event invokes. If fn is
* undefined, then all event handlers for the type of event are * removed.
* @return {boolean} true if the unbind was successful, false * otherwise.
* @static
*/
}
// The el argument can be a string
if (typeof el == "string") {
// The el argument can be an array of elements or element ids.
} else if ( this._isValidCollection(el)) {
var ok = true;
}
return ok;
}
// Y.log("Error, function is not valid " + fn);
//return false;
}
if (ce) {
}
},
/**
* Finds the event in the window object, the caller's arguments, or
* in the arguments of another method in the callstack. This is
* executed automatically for events registered through the event
* manager, so the implementer should not normally need to execute
* this function at all.
* @method getEvent
* @param {Event} e the event parameter from the handler
* @param {HTMLElement} boundEl the element the listener is attached to
* @return {Event} the event
* @static
*/
if (!ev) {
while (c) {
break;
}
c = c.caller;
}
}
// Y.log('wrapper for facade: ' + 'event:' + Y.stamp(boundEl) + e.type);
},
/**
* Generates an unique ID for the element if it does not already
* have one.
* @method generateId
* @param el the element to create the id for
* @return {string} the resulting id of the element
* @static
*/
generateId: function(el) {
if (!id) {
}
return id;
},
/**
* We want to be able to use getElementsByTagName as a collection
* to attach a group of events to. Unfortunately, different
* browsers return different types of collections. This function
* tests to determine if the object is array-like. It will also
* fail if the object is an array, but is empty.
* @method _isValidCollection
* @param o the object to test
* @return {boolean} true if the object is array-like and populated
* @static
* @private
*/
_isValidCollection: function(o) {
try {
return ( o && // o is something
typeof o !== "string" && // o is not a string
!o.tagName && // o is not an HTML element
!o.alert && // o is not a window
} catch(ex) {
return false;
}
},
/*
* Custom event the fires when the dom is initially usable
* @event DOMReadyEvent
*/
// DOMReadyEvent: new Y.CustomEvent("event:ready", this),
// DOMReadyEvent: Y.publish("event:ready", this, {
// fireOnce: true
// }),
/**
* hook up any deferred listeners
* @method _load
* @static
* @private
*/
_load: function(e) {
if (!loadComplete) {
loadComplete = true;
var E = Y.Event;
// Just in case DOMReady did not go off for some reason
// E._ready();
// Available elements may not have been detected before the
// window load event fires. Try to find them now so that the
// the user is more likely to get the onAvailable notifications
// before the window load notification
E._tryPreloadAttach();
}
},
/**
* Polling function that runs before the onload event fires,
* attempting to attach to DOM Nodes as soon as they are
* available
* @method _tryPreloadAttach
* @static
* @private
*/
_tryPreloadAttach: function() {
if (this.locked) {
return;
}
// Hold off if DOMReady has not fired and check current
// readyState to protect against the IE operation aborted
// issue.
if (!this.DOMReady) {
this.startInterval();
return;
}
}
this.locked = true;
// Y.log.debug("tryPreloadAttach");
// keep trying until after the page is loaded. We need to
// check the page load state prior to trying to bind the
// elements so that we can be certain all elements have been
// tested appropriately
var tryAgain = !loadComplete;
if (!tryAgain) {
}
// onAvailable
var notAvail = [];
} else {
}
}
};
// onAvailable
if (el) {
_avail[i] = null;
} else {
}
}
}
// onContentReady
if (el) {
// The element is available, but not necessarily ready
// @todo should we test parentNode.nextSibling?
_avail[i] = null;
}
} else {
}
}
}
if (tryAgain) {
// we may need to strip the nulled out items here
this.startInterval();
} else {
clearInterval(this._interval);
this._interval = null;
}
this.locked = false;
return;
},
/**
* Removes all listeners attached to the given element via addListener.
* Optionally, the node's children can also be purged.
* Optionally, you can specify a specific type of event to remove.
* @method purgeElement
* @param {HTMLElement} el the element to purge
* @param {boolean} recurse recursively purge this element's children
* as well. Use with caution.
* @param {string} type optional type of listener to purge. If
* left out, all listeners will be removed
* @static
*/
if (lis) {
lis[i].unsubscribeAll();
}
}
}
}
},
/**
* Returns all listeners attached to the given element via addListener.
* Optionally, you can specify a specific type of event to return.
* @method getListeners
* @param el {HTMLElement|string} the element or element id to inspect
* @param type {string} optional type of listener to return. If
* left out, all listeners will be returned
* @return {Y.Custom.Event} the custom event wrapper for the DOM event(s)
* @static
*/
if (key) {
}
} else {
for (var i in evts) {
}
}
},
/**
* Removes all listeners registered by pe.event. Called
* automatically during the unload event.
* @method _unload
* @static
* @private
*/
_unload: function(e) {
var E = Y.Event, i, w;
for (i in _wrappers) {
w = _wrappers[i];
w.unsubscribeAll();
delete _wrappers[i];
}
},
/**
* Adds a DOM event directly without the caching, cleanup, context adj, etc
*
* @method nativeAdd
* @param {HTMLElement} el the element to bind the handler to
* @param {string} type the type of event handler
* @param {function} fn the callback to invoke
* @param {boolen} capture capture or bubble phase
* @static
* @private
*/
if (el.addEventListener) {
} else if (el.attachEvent) {
}
// else {
// Y.log('DOM evt error');
// }
},
/**
* Basic remove listener
*
* @method nativeRemove
* @param {HTMLElement} el the element to bind the handler to
* @param {string} type the type of event handler
* @param {function} fn the callback to invoke
* @param {boolen} capture capture or bubble phase
* @static
* @private
*/
if (el.removeEventListener) {
} else if (el.detachEvent) {
}
}
};
}();
var E = Y.Event;
// Process onAvailable/onContentReady items when when the DOM is ready in IE
}
E.Custom = Y.CustomEvent;
E.Subscriber = Y.Subscriber;
E.Target = Y.EventTarget;
/**
* Y.Event.on is an alias for addListener
* @method on
* @see addListener
* @static
*/
var a = Y.Array(arguments, 0, true),
return E.addListener.apply(E, a);
};
};
E._tryPreloadAttach();
}, "3.0.0");
/*
* A wrapper for DOM events and Custom Events
* @submodule event-facade
* @module event
*/
var whitelist = {
"altKey" : 1,
// "button" : 1, // we supply
// "bubbles" : 1, // needed?
// "cancelable" : 1, // needed?
// "charCode" : 1, // we supply
"cancelBubble" : 1,
// "currentTarget" : 1, // we supply
"ctrlKey" : 1,
"clientX" : 1, // needed?
"clientY" : 1, // needed?
"detail" : 1, // not fully implemented
// "fromElement" : 1,
"keyCode" : 1,
// "height" : 1, // needed?
// "initEvent" : 1, // need the init events?
// "initMouseEvent" : 1,
// "initUIEvent" : 1,
// "layerX" : 1, // needed?
// "layerY" : 1, // needed?
"metaKey" : 1,
// "modifiers" : 1, // needed?
// "offsetX" : 1, // needed?
// "offsetY" : 1, // needed?
// "preventDefault" : 1, // we supply
// "reason" : 1, // IE proprietary
// "relatedTarget" : 1,
// "returnValue" : 1, // needed?
"shiftKey" : 1,
// "srcUrn" : 1, // IE proprietary
// "srcElement" : 1,
// "srcFilter" : 1, IE proprietary
// "stopPropagation" : 1, // we supply
// "target" : 1,
// "timeStamp" : 1, // needed?
// "toElement" : 1,
"type" : 1,
// "view" : 1,
// "which" : 1, // we supply
// "width" : 1, // needed?
"x" : 1,
"y" : 1
};
/**
* webkit key remapping required for Safari < 3.1
* @property webkitKeymap
* @private
*/
webkitKeymap = {
63232: 38, // up
63233: 40, // down
63234: 37, // left
63235: 39, // right
63276: 33, // page up
63277: 34, // page down
25: 9 // SHIFT-TAB (Safari provides a different key code in
// this case, even though the shiftKey modifier is set)
},
/**
* Returns a wrapped node. Intended to be used on event targets,
* so it will return the node's parent if the target is a text
* node
* @method resolve
* @private
*/
resolve = function(n) {
if (!n) {
return null;
}
try {
n = n.parentNode;
}
} catch(ex) { }
};
// provide a single event with browser abstractions resolved
//
// include all properties for both browers?
// include only DOM2 spec properties?
// provide browser-specific facade?
/**
* Wraps a DOM event, properties requiring browser abstraction are
* fixed here. Provids a security layer when required.
* @class Event.Facade
* @param ev {Event} the DOM event
* @param currentTarget {HTMLElement} the element the listener was attached to
* @param wrapper {Event.Custom} the custom event wrapper for this DOM event
*/
// @TODO the document should be the target's owner document
// copy all primitives ... this is slow in FF
// for (var i in e) {
for (var i in whitelist) {
// if (!Y.Lang.isObject(e[i])) {
if (whitelist.hasOwnProperty(i)) {
this[i] = e[i];
}
}
//////////////////////////////////////////////////////
if (!x && 0 !== x) {
x = e.clientX || 0;
y = e.clientY || 0;
}
}
this._yuifacade = true;
/**
* The X location of the event on the page (including scroll)
* @property pageX
* @type int
*/
this.pageX = x;
/**
* The Y location of the event on the page (including scroll)
* @property pageY
* @type int
*/
this.pageY = y;
//////////////////////////////////////////////////////
/**
* The keyCode for key events. Uses charCode if keyCode is not available
* @property keyCode
* @type int
*/
c = webkitKeymap[c];
}
/**
* The keyCode for key events. Uses charCode if keyCode is not available
* @property keyCode
* @type int
*/
this.keyCode = c;
/**
* The charCode for key events. Same as keyCode
* @property charCode
* @type int
*/
this.charCode = c;
//////////////////////////////////////////////////////
/**
* The button that was pushed.
* @property button
* @type int
*/
/**
* The button that was pushed. Same as button.
* @property which
* @type int
*/
/**
* The event details. Currently supported for Custom
* Events only, where it contains the arguments that
* were passed to fire().
* @property details
* @type Array
*/
//////////////////////////////////////////////////////
/**
* Timestamp for the event
* @property time
* @type Date
*/
//////////////////////////////////////////////////////
/**
* Node reference for the targeted element
* @propery target
* @type Node
*/
/**
* Node reference for the element that the listener was attached to.
* @propery currentTarget
* @type Node
*/
var t = e.relatedTarget;
if (!t) {
if (e.type == "mouseout") {
t = e.toElement;
} else if (e.type == "mouseover") {
t = e.fromElement;
}
}
/**
* Node reference to the relatedTarget
* @propery relatedTarget
* @type Node
*/
//////////////////////////////////////////////////////
// methods
/**
* Stops the propagation to the next bubble target
* @method stopPropagation
*/
this.stopPropagation = function() {
if (e.stopPropagation) {
e.stopPropagation();
} else {
e.cancelBubble = true;
}
if (wrapper) {
}
};
/**
* 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() {
if (e.stopImmediatePropagation) {
} else {
this.stopPropagation();
}
if (wrapper) {
}
};
/**
* Prevents the event's default behavior
* @method preventDefault
*/
this.preventDefault = function() {
if (e.preventDefault) {
e.preventDefault();
} else {
e.returnValue = false;
}
if (wrapper) {
}
};
/**
* 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
*/
if (immediate) {
this.stopImmediatePropagation();
} else {
this.stopPropagation();
}
this.preventDefault();
};
};
}, "3.0.0");