1962:   trigger: function(type, data, elem, donative, extra) {
1963:     // Clone the incoming data, if any
1964:     data = jQuery.makeArray(data || []);
1965: 

1966:     // Handle a global trigger
1967:     if ( !elem ) {
1968:       // Only trigger if we've ever bound an event for it
1969:       if ( this.global[type] )
1970:         jQuery("*").add([window, document]).trigger(type, data);
1971: 

1972:     // Handle triggering a single element
1973:     } else {
1974:       // don't do events on text and comment nodes
1975:       if ( elem.nodeType == 3 || elem.nodeType == 8 )
1976:         return undefined;
1977: 
1978:       var val, ret, fn = jQuery.isFunction( elem[ type ] || null ),
1979:         // Check to see if we need to provide a fake event, or not
1980:         event = !data[0] || !data[0].preventDefault;
1981:       
1982:       // Pass along a fake event
1983:       if ( event )
1984:         data.unshift( this.fix({ type: type, target: elem }) );
1985: 
1986:       // Enforce the right trigger type
1987:       data[0].type = type;
1988: 

1989:       // Trigger the event
1990:       if ( jQuery.isFunction( jQuery.data(elem, "handle") ) )
1991:         val = jQuery.data(elem, "handle").apply( elem, data );
1992: 
1993:       // Handle triggering native .onfoo handlers
1994:       if ( !fn && elem["on"+type] && elem["on"+type].apply( elem, data ) === false )
1995:         val = false;
1996: 

1997:       // Extra functions don't get the custom event object
1998:       if ( event )
1999:         data.shift();
2000: 
2001:       // Handle triggering of extra function
2002:       if ( extra && jQuery.isFunction( extra ) ) {
2003:         // call the extra function and tack the current return value on the end for possible inspection
2004:         ret = extra.apply( elem, val == null ? data : data.concat( val ) );
2005:         // if anything is returned, give it precedence and have it overwrite the previous value
2006:         if (ret !== undefined)
2007:           val = ret;
2008:       }
2009: 

2010:       // Trigger the native events (except for clicks on links)
2011:       if ( fn && donative !== false && val !== false && !(jQuery.nodeName(elem, 'a') && type == "click") ) {
2012:         this.triggered = true;
2013:         try {
2014:           elem[ type ]();
2015:         // prevent IE from throwing an error for some hidden elements
2016:         } catch (e) {}
2017:       }
2018: 
2019:       this.triggered = false;
2020:     }
2021: 

2022:     return val;
2023:   },
2024: 

2025:   handle: function(event) {
2026:     // returned undefined or false
2027:     var val;
2028: 
2029:     // Empty object is for triggered events with no data
2030:     event = jQuery.event.fix( event || window.event || {} ); 
2031: 
2032:     // Namespaced event handlers
2033:     var parts = event.type.split(".");
2034:     event.type = parts[0];
2035: 
2036:     var handlers = jQuery.data(this, "events") && jQuery.data(this, "events")[event.type], args = Array.prototype.slice.call( arguments, 1 );
2037:     args.unshift( event );
2038: 

2039:     for ( var j in handlers ) {
2040:       var handler = handlers[j];
2041:       // Pass in a reference to the handler function itself
2042:       // So that we can later remove it
2043:       args[0].handler = handler;
2044:       args[0].data = handler.data;
2045: 
2046:       // Filter the functions by class
2047:       if ( !parts[1] || handler.type == parts[1] ) {
2048:         var ret = handler.apply( this, args );
2049: 
2050:         if ( val !== false )
2051:           val = ret;
2052: 
2053:         if ( ret === false ) {
2054:           event.preventDefault();
2055:           event.stopPropagation();
2056:         }
2057:       }
2058:     }
2059: 

2060:     // Clean up added properties in IE to prevent memory leak
2061:     if (jQuery.browser.msie)
2062:       event.target = event.preventDefault = event.stopPropagation =
2063:         event.handler = event.data = null;
2064: 
2065:     return val;
2066:   },
2067: 

2068:   fix: function(event) {
2069:     // store a copy of the original event object 
2070:     // and clone to set read-only properties
2071:     var originalEvent = event;
2072:     event = jQuery.extend({}, originalEvent);
2073:     
2074:     // add preventDefault and stopPropagation since 
2075:     // they will not work on the clone
2076:     event.preventDefault = function() {
2077:       // if preventDefault exists run it on the original event
2078:       if (originalEvent.preventDefault)
2079:         originalEvent.preventDefault();
2080:       // otherwise set the returnValue property of the original event to false (IE)
2081:       originalEvent.returnValue = false;
2082:     };
2083:     event.stopPropagation = function() {
2084:       // if stopPropagation exists run it on the original event
2085:       if (originalEvent.stopPropagation)
2086:         originalEvent.stopPropagation();
2087:       // otherwise set the cancelBubble property of the original event to true (IE)
2088:       originalEvent.cancelBubble = true;
2089:     };
2090:     
2091:     // Fix target property, if necessary
2092:     if ( !event.target )
2093:       event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either
2094:         
2095:     // check if target is a textnode (safari)
2096:     if ( event.target.nodeType == 3 )
2097:       event.target = originalEvent.target.parentNode;
2098: 
2099:     // Add relatedTarget, if necessary
2100:     if ( !event.relatedTarget && event.fromElement )
2101:       event.relatedTarget = event.fromElement == event.target ? event.toElement : event.fromElement;
2102: 
2103:     // Calculate pageX/Y if missing and clientX/Y available
2104:     if ( event.pageX == null && event.clientX != null ) {
2105:       var doc = document.documentElement, body = document.body;
2106:       event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0);
2107:       event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0);
2108:     }
2109:       
2110:     // Add which for key events
2111:     if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) )
2112:       event.which = event.charCode || event.keyCode;
2113:     
2114:     // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
2115:     if ( !event.metaKey && event.ctrlKey )
2116:       event.metaKey = event.ctrlKey;
2117: 
2118:     // Add which for click: 1 == left; 2 == middle; 3 == right
2119:     // Note: button is not normalized, so don't use it
2120:     if ( !event.which && event.button )
2121:       event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
2122:       
2123:     return event;
2124:   },
2125:   

2126:   special: {
2127:     ready: {
2128:       setup: function() {
2129:         // Make sure the ready event is setup
2130:         bindReady();
2131:         return;
2132:       },
2133:       
2134:       teardown: function() { return; }
2135:     },
2136:

2137:     mouseenter: {
2138:       setup: function() {
2139:         if ( jQuery.browser.msie ) return false;
2140:         jQuery(this).bind("mouseover", jQuery.event.special.mouseenter.handler);
2141:         return true;
2142:       },
2143:     
2144:       teardown: function() {
2145:         if ( jQuery.browser.msie ) return false;
2146:         jQuery(this).unbind("mouseover", jQuery.event.special.mouseenter.handler);
2147:         return true;
2148:       },
2149:       
2150:       handler: function(event) {
2151:         // If we actually just moused on to a sub-element, ignore it
2152:         if ( withinElement(event, this) ) return true;
2153:         // Execute the right handlers by setting the event type to mouseenter
2154:         arguments[0].type = "mouseenter";
2155:         return jQuery.event.handle.apply(this, arguments);
2156:       }
2157:     },
2158:   

2159:     mouseleave: {
2160:       setup: function() {
2161:         if ( jQuery.browser.msie ) return false;
2162:         jQuery(this).bind("mouseout", jQuery.event.special.mouseleave.handler);
2163:         return true;
2164:       },
2165:     
2166:       teardown: function() {
2167:         if ( jQuery.browser.msie ) return false;
2168:         jQuery(this).unbind("mouseout", jQuery.event.special.mouseleave.handler);
2169:         return true;
2170:       },
2171:       
2172:       handler: function(event) {
2173:         // If we actually just moused on to a sub-element, ignore it
2174:         if ( withinElement(event, this) ) return true;
2175:         // Execute the right handlers by setting the event type to mouseleave
2176:         arguments[0].type = "mouseleave";
2177:         return jQuery.event.handle.apply(this, arguments);
2178:       }
2179:     }
2180:   }
2181: };
2182: