handler.guid = this.guid++;
// Init the element's event structure
- if (!element.events)
- element.events = {};
+ if (!element.$events)
+ element.$events = {};
// Get the current list of functions bound to this event
- var handlers = element.events[type];
+ var handlers = element.$events[type];
// If it hasn't been initialized yet
if (!handlers) {
// Init the event handler queue
- handlers = element.events[type] = {};
+ handlers = element.$events[type] = {};
// Remember an existing handler, if it's already there
if (element["on" + type])
// Detach an event or set of events from an element
remove: function(element, type, handler) {
- if (element.events)
+ if (element.$events)
if ( type && type.type )
- delete element.events[ type.type ][ type.handler.guid ];
- else if (type && element.events[type])
+ delete element.$events[ type.type ][ type.handler.guid ];
+ else if (type && element.$events[type])
if ( handler )
- delete element.events[type][handler.guid];
+ delete element.$events[type][handler.guid];
else
- for ( var i in element.events[type] )
- delete element.events[type][i];
+ for ( var i in element.$events[type] )
+ delete element.$events[type][i];
else
- for ( var j in element.events )
+ for ( var j in element.$events )
this.remove( element, j );
},
- trigger: function(type,data,element) {
+ trigger: function(type, data, element) {
// Clone the incoming data, if any
data = jQuery.makeArray(data || []);
// Handle a global trigger
- if ( !element ) {
- var g = this.global[type];
- if ( g )
- for ( var i = 0, gl = g.length; i < gl; i++ )
- this.trigger( type, data, g[i] );
+ if ( !element )
+ jQuery.each( this.global[type] || [], function(){
+ jQuery.event.trigger( type, data, this );
+ });
// Handle triggering a single element
- } else if ( element["on" + type] ) {
- if ( element[ type ] && element[ type ].constructor == Function )
- element[ type ]();
- else {
+ else {
+ var handler = element["on" + type ], val,
+ fn = jQuery.isFunction( element[ type ] );
+
+ if ( handler ) {
// Pass along a fake event
data.unshift( this.fix({ type: type, target: element }) );
// Trigger the event
- element["on" + type].apply( element, data );
+ if ( (val = handler.apply( element, data )) !== false )
+ this.triggered = true;
}
+
+ if ( fn && val !== false )
+ element[ type ]();
+
+ this.triggered = false;
}
},
handle: function(event) {
- if ( typeof jQuery == "undefined" ) return false;
+ // Handle the second event of a trigger and when
+ // an event is called after a page has unloaded
+ if ( typeof jQuery == "undefined" || jQuery.event.triggered ) return;
// Empty object is for triggered events with no data
event = jQuery.event.fix( event || window.event || {} );
// returned undefined or false
var returnValue;
- var c = this.events[event.type];
+ var c = this.$events[event.type];
var args = [].slice.call( arguments, 1 );
args.unshift( event );
event.target = event.srcElement;
// Calculate pageX/Y if missing and clientX/Y available
- if ( typeof event.pageX == "undefined" && typeof event.clientX != "undefined" ) {
+ if ( event.pageX == undefined && event.clientX != undefined ) {
var e = document.documentElement, b = document.body;
event.pageX = event.clientX + (e.scrollLeft || b.scrollLeft);
event.pageY = event.clientY + (e.scrollTop || b.scrollTop);
* @before <p click="alert('hello')">Hello</p>
* @result alert('hello')
*
+ * @example $("p").click(function(event, a, b) {
+ * // when a normal click fires, a and b are undefined
+ * // for a trigger like below a refers too "foo" and b refers to "bar"
+ * }).trigger("click", ["foo", "bar"]);
+ * @desc Example of how to pass arbitrary to an event
+ *
+ * @before <p click="alert('hello')">Hello</p>
+ * @result alert('hello')
+ *
* @name trigger
* @type jQuery
* @param String type An event type to trigger.
+ * @param Array data (optional) Additional data to pass as arguments (after the event object) to the event handler
* @cat Events
*/
trigger: function( type, data ) {
* and attaching a function to that. By using this method, your bound Function
* will be called the instant the DOM is ready to be read and manipulated,
* which is exactly what 99.99% of all Javascript code needs to run.
+ *
+ * There is one argument passed to the ready event handler: A reference to
+ * the jQuery function. You can name that argument whatever you like, and
+ * can therefore stick with the $ alias without risk of naming collisions.
*
* Please ensure you have no code in your <body> onload event handler,
* otherwise $(document).ready() may not fire.
*
* @example $(document).ready(function(){ Your code here... });
*
+ * @example jQuery(function($) {
+ * // Your code using failsafe $ alias here...
+ * });
+ * @desc Uses both the shortcut for $(document).ready() and the argument
+ * to write failsafe jQuery code using the $ alias, without relying on the
+ * global alias.
+ *
* @name ready
* @type jQuery
* @param Function fn The function to be executed when the DOM is ready.
* @cat Events
+ * @see $.noConflict()
+ * @see $(Function)
*/
ready: function(f) {
// If the DOM is already ready
if ( jQuery.isReady )
// Execute the function immediately
- f.apply( document );
+ f.apply( document, [jQuery] );
// Otherwise, remember the function for later
else {
// Add the function to the wait list
- jQuery.readyList.push( f );
+ jQuery.readyList.push( function() { return f.apply(this, [jQuery]) } );
}
return this;
// If there are functions bound, to execute
if ( jQuery.readyList ) {
// Execute all of them
- for ( var i = 0; i < jQuery.readyList.length; i++ )
- jQuery.readyList[i].apply( document );
+ jQuery.each( jQuery.readyList, function(){
+ this.apply( document );
+ });
// Reset the list of functions
jQuery.readyList = null;