event-debug.js revision 873d065534cc0dc422a278a6c6651f4663d99b7c
/**
* Custom event engine, DOM event listener abstraction layer, synthetic DOM
* events.
* @module event
*/
(function() {
D = C.doc,
if (!GLOBAL_ENV._ready) {
GLOBAL_ENV.windowLoaded = false;
var _ready = function(e) {
GLOBAL_ENV._ready();
};
GLOBAL_ENV._ready = function() {
if (!GLOBAL_ENV.DOMReady) {
GLOBAL_ENV.DOMReady=true;
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.
try {
// throws an error if doc is not ready
GLOBAL_ENV._dri = null;
_ready();
} catch (ex) {
}
}, POLL_INTERVAL);
// FireFox and Opera: These browsers provide a event for this
// moment. The latest WebKit releases now support this event.
} else {
}
/////////////////////////////////////////////////////////////
}
})();
(function() {
/**
* Custom event engine, DOM event listener abstraction layer, synthetic DOM
* events.
* @module event
*/
CAPTURE = "capture_",
Y.Env.eventAdaptors = {
/**
* Adds a DOM focus listener. Uses the focusin event in IE,
* and the capture phase otherwise so that
* the event propagates properly.
* @for YUI
* @event focus
*/
focus: {
on: function() {
},
detach: function() {
}
},
/**
* Adds a DOM focus listener. Uses the focusout event in IE,
* and the capture phase otherwise so that
* the event propagates properly.
* @for YUI
* @event blur
*/
blur: {
on: function() {
},
detach: function() {
}
},
/**
* Executes the callback as soon as the specified element
* is detected in the DOM.
* @for YUI
* @event available
*/
available: {
}
},
/**
* Executes the callback as soon as the specified element
* is detected in the DOM with a nextSibling property
* (indicating that the element's children are available)
* @for YUI
* @event contentready
*/
contentready: {
}
},
/**
* Add a key listener. The listener will only be notified if the
* keystroke detected meets the supplied specification. The
* spec consists of the key event type, followed by a colon,
* followed by zero or more comma separated key codes, followed
* by zero or more modifiers delimited by a plus sign. Ex:
* press:12,65+shift+ctrl
* @event key
* @param fn {string} the function to execute
* @param id {string} the element(s) to bind
* @param spec {string} the keyCode and modifier specification
* @param o optional context object
* @param args 0..n additional arguments that should be provided
* to the listener.
*/
key: {
}
// parse spec ([key event type]:[criteria])
// key event type: 'down', 'up', or 'press'
// list of key codes optionally followed by modifiers
// the name of the custom event that will be created for the spec
a = Y.Array(arguments, 0, true);
// subscribe spec validator to the DOM event
// Y.log('keylistener: ' + e.keyCode);
// pass this section if any supplied keyCode
// is found
// Y.log('passed: ' + crit);
passed = true;
} else {
failed = true;
// Y.log('failed: ' + crit);
}
// only check modifier if no keyCode was specified
// or the keyCode check was successful. pass only
// if every modifier passes
// Y.log(crit + ": " + passed);
}
}
// fire spec custom event if spec if met
if (passed) {
}
}, id);
// subscribe supplied listener to custom event for spec validator
// remove element and spec.
a[0] = ename;
}
}
};
/**
* 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.
*/
} else {
} 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
*/
} else {
} 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, this is an alias for Y.on.
*
* 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
*/
} else {
}
};
/**
* 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.
*
* 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 {Event.Handle} unsubscribe handle
*/
} else {
}
};
})();
(function() {
/**
* Custom event engine, DOM event listener abstraction layer, synthetic DOM
* events.
* @module event
*/
/**
* Allows for the insertion of methods that are executed before or after
* a specified method
* @class Do
* @static
*/
var BEFORE = 0,
AFTER = 1;
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
*/
// Y.log('Do before: ' + sFn, 'info', 'event');
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
},
/**
* Detach a before or after subscription
* @method detach
* @param handle {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);
}
};
/**
* Unregister a aop subscriber
* @method delete
* @param sid {string} the subscriber id
* @param fn {Function} the function to execute
* @param when {string} when to execute the function
*/
// Y.log('Y.Do._delete: ' + sid, 'info', 'Event');
};
/**
* Execute the wrapped method
* @method exec
*/
prevented = false;
// execute before
for (i in bf) {
if (bf.hasOwnProperty(i)) {
if (ret) {
switch (ret.constructor) {
break;
prevented = true;
break;
default:
}
}
}
}
// execute method
if (!prevented) {
}
// execute after methods.
for (i in af) {
if (af.hasOwnProperty(i)) {
// Stop processing if a Halt object is returned
// Check for a new return value
}
}
}
return ret;
};
//////////////////////////////////////////////////////////////////////////
/**
* 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
*/
};
/**
* Return a Halt object when you want to terminate the execution
* of all subsequent subscribers as well as the wrapped method
* if it has not exectued yet.
* @class Do.Halt
*/
};
/**
* Return a Prevent object when you want to prevent the wrapped function
* from executing, but want the remaining listeners to execute
* @class Do.Halt
*/
};
/**
* Return an Error object when you want to terminate the execution
* of all subsequent method calls.
* @class Do.Error
* @deprecated
*/
//////////////////////////////////////////////////////////////////////////
// Y["Event"] && Y.Event.addListener(window, "unload", Y.Do._unload, Y.Do);
})();
/**
* Custom event engine, DOM event listener abstraction layer, synthetic DOM
* events.
* @module event
*/
/**
* Return value from all subscribe operations
* @class Event.Handle
* @constructor
* @param evt {Event.Custom} the custom event
* @param sub {Event.Subscriber} the subscriber
*/
var onsubscribeType = "_event:onsub",
AFTER = 'after',
CONFIGS = [
'broadcast',
'bubbles',
'context',
'configured',
'currentTarget',
'defaultFn',
'details',
'emitFacade',
'fireOnce',
'host',
'preventable',
'preventedFn',
'queuable',
'silent',
'stoppedFn',
'target',
'type'
],
YUI3_SIGNATURE = 9;
/**
* The custom event
* @type Event.Custom
*/
/**
* The subscriber object
* @type Event.Subscriber
*/
};
Y.EventHandle.prototype = {
/**
* Detaches this subscriber
* @method detach
*/
detach: function() {
if (this.evt) {
// Y.log('EventHandle.detach: ' + this.sub, 'info', 'Event');
}
}
};
/**
* 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 o configuration object
* @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;
/**
* Supports multiple options for listener signatures in order to
* port YUI 2 apps.
* @property signature
* @type int
* @default 9
*/
this.signature = YUI3_SIGNATURE;
/**
* If set to true, the custom event will deliver an Event.Facade object
* that is similar to a DOM event object.
* @property emitFacade
* @type boolean
* @default false
*/
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 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);
// setTimeout(Y.bind(this._notify, this, s), 0);
}
} 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} context Specifies the value of the
* 'this' keyword in the listener.
* @param args* 0..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} context Specifies the value of the
* 'this' keyword in the listener.
* @param args* 0..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} context The context object passed to subscribe.
* @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
*/
// 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) {
}
}
// the listener was bound to.
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;
var ef = null;
if (this.emitFacade) {
// this.fire({
// foo: 1
// bar: 2
// }
// this.fire({
// bar: 2
// } // foo is still 1 unless we create a new facade
this._facade = null;
}
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() {
for (i in subs) {
if (subs.hasOwnProperty(i)) {
l++;
}
}
this.subscribers={};
return l;
},
/**
* @method _delete
* @param subscriber object
* @private
*/
_delete: function(s) {
if (s) {
delete s.fn;
delete s.context;
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} context The value of the keyword 'this' in the listener
* @param {Array} args* 0..n additional arguments to supply the listener
*
* @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
*/
/**
* Optional 'this' keyword for the listener
* @property context
* @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;
/**
* }
* fn bound to obj with additional arguments applied via Y.bind
* @property wrappedFn
* @type Function
*/
if (context) {
/*
var a = (args) ? Y.Array(args) : [];
a.unshift(fn, context);
// a.unshift(fn);
m = Y.bind.apply(Y, a);
*/
}
};
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
* @param ce {Event.Custom} The custom event that sent the notification
*/
f = function() {
case 0:
break;
case 1:
break;
default:
}
};
// Ease debugging by only catching errors if we will not re-throw
// them.
f.call(this);
} else {
try {
f.call(this);
} 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} context optional 'this' keyword for the listener
* @return {boolean} true if the supplied arguments match this
* subscriber's signature.
*/
if (context) {
} else {
}
},
/**
* @method toString
*/
toString: function() {
return "Subscriber " + this.id;
}
};
/**
* Custom event engine, DOM event listener abstraction layer, synthetic DOM
* events.
* @module event
*/
/**
* 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
*/
var SILENT = { 'yui:log': true },
L = Y.Lang;
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* 0..n params to supply to the callback
*/
ret = {};
if (v) {
f = v.fn || f;
c = v.context || c;
}
args[0] = k;
args[1] = f;
args[2] = c;
}, this);
return ret;
}
// this.publish(type, {
// 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) {
if (evts.hasOwnProperty(i)) {
}
}
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
*
*/
var ret = {};
}, this);
return ret;
}
//if (ce && !ce.configured) {
if (ce) {
// ce.log("publish applying config to published event: '"+type+"' exists", 'info', '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) {
// ce = this.publish(t, {
// 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.Custom} the custom event or null
*/
},
/**
* 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* 0..n params to supply to the callback
*/
if (L.isFunction(type)) {
} else {
// this.publish(type, {
// configured: false
// }),
a = Y.Array(arguments, 1, true);
}
},
if (L.isFunction(type)) {
} else {
}
}
};
// make Y an event target
bubbles: false
});
/**
* Custom event engine, DOM event listener abstraction layer, synthetic DOM
* events.
* @module event
*/
// if (Y !== YUI) {
// return;
// }
/**
* 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>
*
*
* @event domready
* @for YUI
*
* @param {function} fn what to execute when the element is found.
* @optional context execution context
* @optional args 0..n arguments to send to the listener
*
*/
domready: {
},
/**
* Use domready event instead. @see domready
* @event event:ready
* @for YUI
* @deprecated use 'domready' instead
*/
'event:ready': {
on: function() {
},
detach: function() {
}
}
});
Y.publish('domready', {
fireOnce: true
});
var yready = function() {
Y.fire('domready');
};
if (GLOBAL_ENV.DOMReady) {
// Y.log('DOMReady already fired', 'info', 'event');
yready();
} else {
// Y.log('setting up before listener', 'info', 'event');
}
/**
* Custom event engine, DOM event listener abstraction layer, synthetic DOM
* events.
* @module event
*/
/**
* 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
*/
if (el.addEventListener) {
} else if (el.attachEvent) {
}
},
if (el.removeEventListener) {
} else if (el.detachEvent) {
}
},
onLoad = function() {
},
onUnload = function() {
},
EVENT_READY = 'domready',
COMPAT_ARG = '~yui|2|compat~',
CAPTURE = "capture_";
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 = {};
var _windowLoadKey = null;
/**
* 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() {
var E = Y.Event;
if (!E._interval) {
}
},
/**
* 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
* @deprecated Use Y.on("available")
*/
// @TODO fix arguments
var a = Y.Array(id);
// Y.log('onAvailable registered for: ' + id);
id: a[i],
});
}
_retryCount = this.POLL_RETRYS;
// We want the first test to be immediate, but async
return new Y.EventHandle(); // @TODO by id needs a defered handle
},
/**
* 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
* @deprecated Use Y.on("contentready")
*/
// @TODO fix arguments
},
/**
* Appends an event handler
*
* @method attach
*
* @param {String} type The type of event to append
* @param {Function} fn The method the event invokes
* @param {String|HTMLElement|Array|NodeList} el An id, an element
* listener to.
* @param {Object} obj An arbitrary object that will be
* passed as a parameter to the handler
* @param {Boolean|object} args 0..n arguments to pass to the callback
* @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('attach: ' + Y.Lang.dump(Y.Array(arguments, 0, true), 1));
// Y.log('attach:');
// Y.log(Y.Array(arguments, 0, true), 1);
// var a=Y.Array(arguments, 1, true), override=a[3], E=Y.Event, aa=Y.Array(arguments, 0, true);
capture = true;
}
compat = true;
trimmedArgs.pop();
}
// throw new TypeError(type + " attach 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));
var handles=[], i, l;
args[2] = v;
});
// 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.
// Node collection
// if (oEl && oEl.size && oEl.size() > 0) {
//
// Y.log('node?: ' + (oEl instanceof Y.Node));
/*
if (oEl) {
el = oEl;
*/
if (size > 1) {
// Y.log('more than one: ' + size + ', ' + type);
// args[0] = oEl;
} else {
// Y.log('just one: ' + size + ', ' + type);
// el = oEl;
}
// HTMLElement
// } else if (compat && oEl) {
} else if (oEl) {
// Y.log('no size: ' + oEl + ', ' + type);
// Not found = defer adding the event until the element is available
} else {
// Y.log(el + ' not found');
return this.onAvailable(el, function() {
// Y.log('lazy attach: ' + args);
}, E, true, false, compat);
}
}
// Element should be an html element or an array if we get here.
if (!el) {
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
};
// window load happens once
// if the load is complete, fire immediately.
// all subscribers, including the current one
// will be notified.
}
}
// var capture = (Y.lang.isObject(obj) && obj.capture);
// attach a listener that fires the custom event
// Y.log("Attaching listener: " + [el, type, cewrapper.fn, capture]);
}
// switched from obj to trimmedArgs[2] to deal with appened compat param
// set the context as the second arg to subscribe
// remove the 'obj' param
// set context to the Node if not specified
},
/**
* Removes an event listener. Supports the signature the event was bound
* with, but the preferred way to remove listeners is using the handle
* that is returned when using Y.on
*
* @method detach
*
* @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
*/
compat = true;
// args.pop();
}
}
// 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;
// ok = ( this.detach(el[i], type, fn) && ok );
}
return ok;
}
}
if (ce) {
} else {
return false;
}
},
/**
* 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} el the element the listener was attached to
* @return {Event} the event
* @static
*/
},
/**
* 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 {
// Y.log('node? ' + (o instanceof Y.Node) + ', ' + ((o.size) ? o.size() : ' no size'));
// if (o instanceof Y.Node) {
// o.tagName ="adsf";
// }
return ( o && // o is something
typeof o !== "string" && // o is not a string
// o.length && // o is indexed
!o.tagName && // o is not an HTML element
!o.alert && // o is not a window
} catch(ex) {
return false;
}
},
/**
* hook up any deferred listeners
* @method _load
* @static
* @private
*/
_load: function(e) {
if (!loadComplete) {
// Y.log('Load Complete', 'info', 'event');
loadComplete = true;
// Just in case DOMReady did not go off for some reason
// E._ready();
if (Y.fire) {
Y.fire(EVENT_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
Y.Event._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.
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 = [];
if (ov === true) {
} else {
}
} else {
}
} else {
}
};
// onAvailable
if (el) {
// Y.log('avail: ' + el);
_avail[i] = null;
} else {
// Y.log('NOT avail: ' + el);
}
}
}
// 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 (!evts) {
return null;
}
if (key) {
}
} else {
});
}
},
/**
* Removes all listeners registered by pe.event. Called
* automatically during the unload event.
* @method _unload
* @static
* @private
*/
_unload: function(e) {
var E = Y.Event;
v.unsubscribeAll();
delete _wrappers[k];
});
},
/**
* 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
*/
/**
* 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
*/
};
}();
// Y.Event = Event;
// Process onAvailable/onContentReady items when when the DOM is ready in IE
}
/**
* Custom event engine, DOM event listener abstraction layer, synthetic DOM
* events.
* @module event
*/
/**
* 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 constants? LEFTBUTTON, MIDDLEBUTTON, RIGHTBUTTON, keys
*/
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?
// @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();
};
};
(function() {
/**
* Custom event engine, DOM event listener abstraction layer, synthetic DOM
* events.
* @module event
*/
//shortcuts
var L = Y.Lang,
array = Y.Array,
isFunction = L.isFunction,
//mouse events supported
mouseEvents = [
/**
* Simulates a click on a particular element.
* @param {HTMLElement} target The element to click on.
* @param {Object} options Additional event options (use DOM standard names).
* @method click
* @static
* @for Event
*/
"click",
/**
* Simulates a double click on a particular element.
* @param {HTMLElement} target The element to double click on.
* @param {Object} options Additional event options (use DOM standard names).
* @method dblclick
* @static
*/
"dblclick",
/**
* Simulates a mouseover event on a particular element. Use "relatedTarget"
* on the options object to specify where the mouse moved from.
* Quirks: Firefox less than 2.0 doesn't set relatedTarget properly, so
* fromElement is assigned in its place. IE doesn't allow fromElement to be
* be assigned, so relatedTarget is assigned in its place. Both of these
* concessions allow YAHOO.util.Event.getRelatedTarget() to work correctly
* in both browsers.
* @param {HTMLElement} target The element to act on.
* @param {Object} options Additional event options (use DOM standard names).
* @method mouseover
* @static
*/
"mouseover",
/**
* Simulates a mouseout event on a particular element. Use "relatedTarget"
* on the options object to specify where the mouse moved to.
* Quirks: Firefox less than 2.0 doesn't set relatedTarget properly, so
* toElement is assigned in its place. IE doesn't allow toElement to be
* be assigned, so relatedTarget is assigned in its place. Both of these
* concessions allow YAHOO.util.Event.getRelatedTarget() to work correctly
* in both browsers.
* @param {HTMLElement} target The element to act on.
* @param {Object} options Additional event options (use DOM standard names).
* @method mouseout
* @static
*/
"mouseout",
/**
* Simulates a mousedown on a particular element.
* @param {HTMLElement} target The element to act on.
* @param {Object} options Additional event options (use DOM standard names).
* @method mousedown
* @static
*/
"mousedown",
/**
* Simulates a mouseup on a particular element.
* @param {HTMLElement} target The element to act on.
* @param {Object} options Additional event options (use DOM standard names).
* @method mouseup
* @static
*/
"mouseup",
/**
* Simulates a mousemove on a particular element.
* @param {HTMLElement} target The element to act on.
* @param {Object} options Additional event options (use DOM standard names).
* @method mousemove
* @static
*/
"mousemove"
],
//key events supported
keyEvents = [
/**
* Simulates a keydown event on a particular element.
* @param {HTMLElement} target The element to act on.
* @param {Object} options Additional event options (use DOM standard names).
* @method keydown
* @static
*/
"keydown",
/**
* Simulates a keyup event on a particular element.
* @param {HTMLElement} target The element to act on.
* @param {Object} options Additional event options (use DOM standard names).
* @method keyup
* @static
*/
"keyup",
/**
* Simulates a keypress on a particular element.
* @param {HTMLElement} target The element to act on.
* @param {Object} options Additional event options (use DOM standard names).
* @method keypress
* @static
*/
"keypress"
];
/**
* Note: Intentionally not for YUIDoc generation.
* Simulates a key event using the given event information to populate
* the generated event object. This method does browser-equalizing
* calculations to account for differences in the DOM and IE event models
* as well as different browser quirks. Note: keydown causes Safari 2.x to
* crash.
* @method simulateKeyEvent
* @private
* @static
* @param {HTMLElement} target The target of the given event.
* @param {String} type The type of event to fire. This can be any one of
* the following: keyup, keydown, and keypress.
* @param {Boolean} bubbles (Optional) Indicates if the event can be
* bubbled up. DOM Level 3 specifies that all key events bubble by
* default. The default is true.
* @param {Boolean} cancelable (Optional) Indicates if the event can be
* canceled using preventDefault(). DOM Level 3 specifies that all
* key events can be cancelled. The default
* is true.
* @param {Window} view (Optional) The view containing the target. This is
* typically the window object. The default is window.
* @param {Boolean} ctrlKey (Optional) Indicates if one of the CTRL keys
* is pressed while the event is firing. The default is false.
* @param {Boolean} altKey (Optional) Indicates if one of the ALT keys
* is pressed while the event is firing. The default is false.
* @param {Boolean} shiftKey (Optional) Indicates if one of the SHIFT keys
* is pressed while the event is firing. The default is false.
* @param {Boolean} metaKey (Optional) Indicates if one of the META keys
* is pressed while the event is firing. The default is false.
* @param {int} keyCode (Optional) The code for the key that is in use.
* The default is 0.
* @param {int} charCode (Optional) The Unicode code for the character
* associated with the key being used. The default is 0.
*/
view /*:Window*/,
{
//check target
if (!target){
Y.fail("simulateKeyEvent(): Invalid target.");
}
//check event type
switch(type){
case "textevent": //DOM Level 3
type = "keypress";
/*falls through*/
case "keyup":
case "keydown":
case "keypress":
break;
default:
}
} else {
Y.fail("simulateKeyEvent(): Event type must be a string.");
}
//setup default values
bubbles = true; //all key events bubble
}
if (!isBoolean(cancelable)){
cancelable = true; //all key events can be cancelled
}
}
ctrlKey = false;
}
altKey = false;
}
shiftKey = false;
}
metaKey = false;
}
keyCode = 0;
}
charCode = 0;
}
//try to create a mouse event
var customEvent /*:MouseEvent*/ = null;
//check for DOM-compliant browsers first
try {
//try to create key event
/*
* Interesting problem: Firefox implemented a non-standard
* version of initKeyEvent() based on DOM Level 2 specs.
* Key event was removed from DOM Level 2 and re-introduced
* in DOM Level 3 with a different interface. Firefox is the
* only browser with any implementation of Key Events, so for
* now, assume it's Firefox if the above line doesn't error.
*/
//TODO: Decipher between Firefox's implementation and a correct one.
} catch (ex /*:Error*/){
/*
* If it got here, that means key events aren't officially supported.
* set keyCode, charCode, or other properties if you use a
* UIEvent, so we first must try to create a generic event. The
* fun part is that this will throw an error on Safari 2.x. The
* end result is that we need another try...catch statement just to
* deal with this mess.
*/
try {
//try to create generic event - will fail in Safari 2.x
} catch (uierror /*:Error*/){
//the above failed, so create a UIEvent for Safari 2.x
} finally {
//initialize
}
}
//fire the event
//create an IE event object
//assign available properties
/*
* IE doesn't support charCode explicitly. CharCode should
* take precedence over any keyCode value for accurate
* representation.
*/
//fire the event
} else {
Y.fail("simulateKeyEvent(): No event simulation framework present.");
}
}
/*
* Note: Intentionally not for YUIDoc generation.
* Simulates a mouse event using the given event information to populate
* the generated event object. This method does browser-equalizing
* calculations to account for differences in the DOM and IE event models
* as well as different browser quirks.
* @method simulateMouseEvent
* @private
* @static
* @param {HTMLElement} target The target of the given event.
* @param {String} type The type of event to fire. This can be any one of
* the following: click, dblclick, mousedown, mouseup, mouseout,
* mouseover, and mousemove.
* @param {Boolean} bubbles (Optional) Indicates if the event can be
* bubbled up. DOM Level 2 specifies that all mouse events bubble by
* default. The default is true.
* @param {Boolean} cancelable (Optional) Indicates if the event can be
* canceled using preventDefault(). DOM Level 2 specifies that all
* mouse events except mousemove can be cancelled. The default
* is true for all events except mousemove, for which the default
* is false.
* @param {Window} view (Optional) The view containing the target. This is
* typically the window object. The default is window.
* @param {int} detail (Optional) The number of times the mouse button has
* been used. The default value is 1.
* @param {int} screenX (Optional) The x-coordinate on the screen at which
* point the event occured. The default is 0.
* @param {int} screenY (Optional) The y-coordinate on the screen at which
* point the event occured. The default is 0.
* @param {int} clientX (Optional) The x-coordinate on the client at which
* point the event occured. The default is 0.
* @param {int} clientY (Optional) The y-coordinate on the client at which
* point the event occured. The default is 0.
* @param {Boolean} ctrlKey (Optional) Indicates if one of the CTRL keys
* is pressed while the event is firing. The default is false.
* @param {Boolean} altKey (Optional) Indicates if one of the ALT keys
* is pressed while the event is firing. The default is false.
* @param {Boolean} shiftKey (Optional) Indicates if one of the SHIFT keys
* is pressed while the event is firing. The default is false.
* @param {Boolean} metaKey (Optional) Indicates if one of the META keys
* is pressed while the event is firing. The default is false.
* @param {int} button (Optional) The button being pressed while the event
* is executing. The value should be 0 for the primary mouse button
* (typically the left button), 1 for the terciary mouse button
* (typically the middle button), and 2 for the secondary mouse button
* (typically the right button). The default is 0.
* @param {HTMLElement} relatedTarget (Optional) For mouseout events,
* this is the element that the mouse has moved to. For mouseover
* events, this is the element that the mouse has moved from. This
* argument is ignored for all other events. The default is null.
*/
{
//check target
if (!target){
Y.fail("simulateMouseEvent(): Invalid target.");
}
//check event type
//make sure it's a supported mouse event
}
} else {
Y.fail("simulateMouseEvent(): Event type must be a string.");
}
//setup default values
bubbles = true; //all mouse events bubble
}
if (!isBoolean(cancelable)){
}
}
}
screenX = 0;
}
screenY = 0;
}
clientX = 0;
}
clientY = 0;
}
ctrlKey = false;
}
altKey = false;
}
shiftKey = false;
}
metaKey = false;
}
button = 0;
}
//try to create a mouse event
var customEvent /*:MouseEvent*/ = null;
//check for DOM-compliant browsers first
//Safari 2.x (WebKit 418) still doesn't implement initMouseEvent()
if (customEvent.initMouseEvent){
} else { //Safari
//the closest thing available in Safari 2.x is UIEvents
}
/*
* Check to see if relatedTarget has been assigned. Firefox
* versions less than 2.0 don't allow it to be assigned via
* initMouseEvent() and the property is readonly after event
* creation, so in order to keep YAHOO.util.getRelatedTarget()
* working, assign to the IE proprietary toElement property
* for mouseout event and fromElement property for mouseover
* event.
*/
if (type == "mouseout"){
} else if (type == "mouseover"){
}
}
//fire the event
//create an IE event object
//assign available properties
//fix button property for IE's wacky implementation
switch(button){
case 0:
break;
case 1:
break;
case 2:
//leave as is
break;
default:
}
/*
* Have to use relatedTarget because IE won't allow assignment
* to toElement or fromElement on generic events. This keeps
* YAHOO.util.customEvent.getRelatedTarget() functional.
*/
//fire the event
} else {
Y.fail("simulateMouseEvent(): No event simulation framework present.");
}
}
//add mouse event methods
};
});
//add key event methods
};
});
/**
* Simulates the event with the given name on a target.
* @param {HTMLElement} target The DOM element that's the target of the event.
* @param {String} type The type of event to simulate (i.e., "click").
* @param {Object} options (Optional) Extra options to copy onto the event object.
* @return {void}
* @method simulate
* @static
*/
}
};
/*
* TODO: focus(), blur(), submit()
*/
})();
}, '@VERSION@' );