Bug Tracker

Ticket #2565: jquery-1.2.3-event-fix.patch

File jquery-1.2.3-event-fix.patch, 8.1 KB (added by diego, 15 years ago)

Patch for the "jquery-1.2.3.js" source file

  • jquery.js

    old new  
    20482048        },
    20492049
    20502050        handle: function(event) {
    2051                 // returned undefined or false
    2052                 var val;
     2051                // val is returned undefined or false
     2052                var j, args, events, handler, handlers, parts, ret, val;
    20532053
    20542054                // Empty object is for triggered events with no data
    20552055                event = jQuery.event.fix( event || window.event || {} );
    20562056
    20572057                // Namespaced event handlers
    2058                 var parts = event.type.split(".");
    2059                 event.type = parts[0];
    2060 
    2061                 var handlers = jQuery.data(this, "events") && jQuery.data(this, "events")[event.type], args = Array.prototype.slice.call( arguments, 1 );
     2058                parts = event.type.split(".");
     2059                if (event.type != parts[0])
     2060                        event.type = parts[0];
     2061
     2062                events = jQuery.data(this, "events");
     2063                handlers = events && events[event.type];
     2064                args = Array.prototype.slice.call( arguments, 1 );
    20622065                args.unshift( event );
    20632066
    2064                 for ( var j in handlers ) {
    2065                         var handler = handlers[j];
     2067                for ( j in handlers ) {
     2068                        handler = handlers[j];
    20662069                        // Pass in a reference to the handler function itself
    20672070                        // So that we can later remove it
    20682071                        args[0].handler = handler;
     
    20702073
    20712074                        // Filter the functions by class
    20722075                        if ( !parts[1] && !event.exclusive || handler.type == parts[1] ) {
    2073                                 var ret = handler.apply( this, args );
     2076                                ret = handler.apply( this, args );
    20742077
    20752078                                if ( val !== false )
    20762079                                        val = ret;
     
    20902091                return val;
    20912092        },
    20922093
    2093         fix: function(event) {
    2094                 // store a copy of the original event object
    2095                 // and clone to set read-only properties
    2096                 var originalEvent = event;
    2097                 event = jQuery.extend({}, originalEvent);
    2098                
    2099                 // add preventDefault and stopPropagation since
    2100                 // they will not work on the clone
    2101                 event.preventDefault = function() {
    2102                         // if preventDefault exists run it on the original event
    2103                         if (originalEvent.preventDefault)
    2104                                 originalEvent.preventDefault();
    2105                         // otherwise set the returnValue property of the original event to false (IE)
    2106                         originalEvent.returnValue = false;
    2107                 };
    2108                 event.stopPropagation = function() {
    2109                         // if stopPropagation exists run it on the original event
    2110                         if (originalEvent.stopPropagation)
    2111                                 originalEvent.stopPropagation();
    2112                         // otherwise set the cancelBubble property of the original event to true (IE)
    2113                         originalEvent.cancelBubble = true;
    2114                 };
    2115                
    2116                 // Fix target property, if necessary
    2117                 if ( !event.target )
    2118                         event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either
    2119                                
    2120                 // check if target is a textnode (safari)
    2121                 if ( event.target.nodeType == 3 )
    2122                         event.target = originalEvent.target.parentNode;
    2123 
    2124                 // Add relatedTarget, if necessary
    2125                 if ( !event.relatedTarget && event.fromElement )
    2126                         event.relatedTarget = event.fromElement == event.target ? event.toElement : event.fromElement;
    2127 
    2128                 // Calculate pageX/Y if missing and clientX/Y available
    2129                 if ( event.pageX == null && event.clientX != null ) {
    2130                         var doc = document.documentElement, body = document.body;
    2131                         event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0);
    2132                         event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0);
    2133                 }
    2134                        
    2135                 // Add which for key events
    2136                 if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) )
    2137                         event.which = event.charCode || event.keyCode;
    2138                
    2139                 // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
    2140                 if ( !event.metaKey && event.ctrlKey )
    2141                         event.metaKey = event.ctrlKey;
    2142 
    2143                 // Add which for click: 1 == left; 2 == middle; 3 == right
    2144                 // Note: button is not normalized, so don't use it
    2145                 if ( !event.which && event.button )
    2146                         event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
    2147                        
    2148                 return event;
    2149         },
    2150        
     2094        // create a new event object to be able to set
     2095        // properties that normally are just read-only
     2096        create: function(e, target, source) {
     2097
     2098                // need to set defult values
     2099                return e.originalEvent ? e : {
     2100
     2101                        type: e.type,
     2102
     2103                        pageX: e.pageX || 0,
     2104                        pageY: e.pageY || 0,
     2105
     2106                        clientX: e.clientX || 0,
     2107                        clientY: e.clientY || 0,
     2108
     2109                        screenX: e.screenX || 0,
     2110                        screenY: e.screenY || 0,
     2111
     2112                        // target is a parameter
     2113                        target: target || window,
     2114
     2115                        altKey: e.altKey || false,
     2116                        button: e.button || false,
     2117                        ctrlKey: e.ctrlKey || false,
     2118                        metaKey: e.metaKey || false,
     2119                        shiftKey: e.shiftKey || false,
     2120
     2121                        details: e.details || null,
     2122                        wheelDelta: e.wheelDelta || 0,
     2123
     2124                        bubbles: e.bubbles || true,
     2125                        cancelable: e.cancelable || true,
     2126
     2127                        eventPhase: e.eventPhase || 0,
     2128                        timeStamp: e.timeStamp || (new Date()).getTime(),
     2129
     2130                        // target and source are parameters
     2131                        relatedTarget: e.relatedTarget || target || null,
     2132                        currentTarget: e.currentTarget || source || null,
     2133
     2134                        view: e.view || window,
     2135
     2136                        relatedNode: e.relatedNode || null,
     2137
     2138                        prevValue: e.prevValue || null,
     2139                        newValue: e.newValue || null,
     2140
     2141                        attrName: e.attrName || '',
     2142                        attrChange: e.attrChange || false,
     2143
     2144                        data: e.data || null,
     2145                        handler: e.handler || null,
     2146                        exclusive: e.exclusive || false,
     2147
     2148                        // reference to the original event
     2149                        originalEvent: e
     2150
     2151                };
     2152
     2153        },
     2154
     2155        fix: function(e, o) {
     2156
     2157                // cache this
     2158                var root = document.documentElement, body = document.body;
     2159
     2160                // optimized using lazy function definition
     2161                // and recreating a new event object template
     2162
     2163                if ( document.createEventObject ) {
     2164
     2165                        jQuery.event.fix = function(e, o) {
     2166
     2167                                var ev = e;
     2168
     2169                                ev.target = ev.target || ev.srcElement || window;
     2170
     2171                                // prevent the execution of the default action
     2172                                ev.preventDefault = ev.preventDefault || function() {
     2173                                        // set the returnValue property of
     2174                                        // the original event to false (IE)
     2175                                        e.returnValue = false;
     2176                                };
     2177
     2178                                // stop the event bubbling up to other elements
     2179                                ev.stopPropagation = ev.stopPropagation || function() {
     2180                                        // set the cancelBubble property of
     2181                                        // the original event to true (IE)
     2182                                        e.cancelBubble = true;
     2183                                };
     2184
     2185                                // check if target is a textnode (safari)
     2186                                if ( ev.target.nodeType == 3 ) {
     2187                                        ev.target = ev.target.parentNode;
     2188                                }
     2189
     2190                                // Add relatedTarget, if necessary
     2191                                ev.relatedTarget = ev.relatedTarget || (ev.fromElement == ev.target ? ev.toElement : ev.fromElement);
     2192
     2193                                // Calculate pageX/Y if missing and clientX/Y available
     2194                                ev.pageX = ev.pageX || (ev.clientX + (root && root.scrollLeft || body && body.scrollLeft || 0) - (root.clientLeft || 0));
     2195                                ev.pageY = ev.pageY || (ev.clientY + (root && root.scrollTop || body && body.scrollTop || 0) - (root.clientTop || 0));
     2196
     2197                                // Add which for key events
     2198                                ev.which = ev.which || ev.charCode || ev.keyCode;
     2199
     2200                                // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
     2201                                ev.metaKey = ev.metaKey || ev.ctrlKey;
     2202
     2203                                // Add which for click: 1 == left; 2 == middle; 3 == right
     2204                                // Note: button is not normalized, so don't use it
     2205                                ev.which = ev.which || (ev.button & 1 ? 1 : ( ev.button & 2 ? 3 : ( ev.button & 4 ? 2 : 0 ) ));
     2206
     2207                                // return the writable cloned event
     2208                                return ev;
     2209                        }
     2210
     2211                } else {
     2212
     2213                        jQuery.event.fix = function(e, o) {
     2214
     2215                                var ev = e;
     2216
     2217                                // is it a custom event
     2218                                if ( !ev.initEvent ) {
     2219
     2220                                        // create a mirror event
     2221                                        ev = jQuery.event.create(e, e.target, o);
     2222
     2223                                        // add preventDefault and stopPropagation since
     2224                                        // they will not work on the clone event object
     2225
     2226                                        // prevent the execution of the default action
     2227                                        ev.preventDefault = ev.preventDefault || function() {
     2228                                                // if preventDefault exists run it on the original event
     2229                                                if (e.preventDefault)
     2230                                                        e.preventDefault();
     2231                                        };
     2232
     2233                                        // stop the event bubbling up to other elements
     2234                                        ev.stopPropagation = ev.stopPropagation || function() {
     2235                                                // if stopPropagation exists run it on the original event
     2236                                                if (e.stopPropagation)
     2237                                                        e.stopPropagation();
     2238                                        };
     2239
     2240                                        // check if target is a textnode
     2241                                        if ( ev.target.nodeType == 3 ) {
     2242                                                ev.target = ev.target.parentNode;
     2243                                        }
     2244
     2245                                }
     2246
     2247                                return ev;
     2248                        }
     2249                }
     2250
     2251                return jQuery.event.fix(e, o);
     2252        },
     2253
    21512254        special: {
    21522255                ready: {
    21532256                        setup: function() {