Bug Tracker

Ticket #2565: event-fix.patch

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

Patch for the "event.js" source file

  • event.js

    old new  
    236236        },
    237237
    238238        handle: function(event) {
    239                 // returned undefined or false
    240                 var val;
     239                // val is returned undefined or false
     240                var j, args, events, handler, handlers, parts, ret, val;
    241241
    242242                // Empty object is for triggered events with no data
    243243                event = jQuery.event.fix( event || window.event || {} );
    244244
    245245                // Namespaced event handlers
    246                 var parts = event.type.split(".");
    247                 event.type = parts[0];
    248 
    249                 var handlers = jQuery.data(this, "events") && jQuery.data(this, "events")[event.type], args = Array.prototype.slice.call( arguments, 1 );
     246                parts = event.type.split(".");
     247                if (event.type != parts[0])
     248                        event.type = parts[0];
     249
     250                events = jQuery.data(this, "events");
     251                handlers = events && events[event.type];
     252                args = Array.prototype.slice.call( arguments, 1 );
    250253                args.unshift( event );
    251254
    252                 for ( var j in handlers ) {
    253                         var handler = handlers[j];
     255                for ( j in handlers ) {
     256                        handler = handlers[j];
    254257                        // Pass in a reference to the handler function itself
    255258                        // So that we can later remove it
    256259                        args[0].handler = handler;
     
    258261
    259262                        // Filter the functions by class
    260263                        if ( !parts[1] && !event.exclusive || handler.type == parts[1] ) {
    261                                 var ret = handler.apply( this, args );
     264                                ret = handler.apply( this, args );
    262265
    263266                                if ( val !== false )
    264267                                        val = ret;
     
    278278                return val;
    279279        },
    280280
    281         fix: function(event) {
    282                 // store a copy of the original event object
    283                 // and clone to set read-only properties
    284                 var originalEvent = event;
    285                 event = jQuery.extend({}, originalEvent);
    286                
    287                 // add preventDefault and stopPropagation since
    288                 // they will not work on the clone
    289                 event.preventDefault = function() {
    290                         // if preventDefault exists run it on the original event
    291                         if (originalEvent.preventDefault)
    292                                 originalEvent.preventDefault();
    293                         // otherwise set the returnValue property of the original event to false (IE)
    294                         originalEvent.returnValue = false;
    295                 };
    296                 event.stopPropagation = function() {
    297                         // if stopPropagation exists run it on the original event
    298                         if (originalEvent.stopPropagation)
    299                                 originalEvent.stopPropagation();
    300                         // otherwise set the cancelBubble property of the original event to true (IE)
    301                         originalEvent.cancelBubble = true;
    302                 };
    303                
    304                 // Fix target property, if necessary
    305                 if ( !event.target )
    306                         event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either
    307                                
    308                 // check if target is a textnode (safari)
    309                 if ( event.target.nodeType == 3 )
    310                         event.target = originalEvent.target.parentNode;
    311 
    312                 // Add relatedTarget, if necessary
    313                 if ( !event.relatedTarget && event.fromElement )
    314                         event.relatedTarget = event.fromElement == event.target ? event.toElement : event.fromElement;
    315 
    316                 // Calculate pageX/Y if missing and clientX/Y available
    317                 if ( event.pageX == null && event.clientX != null ) {
    318                         var doc = document.documentElement, body = document.body;
    319                         event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0);
    320                         event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0);
    321                 }
    322                        
    323                 // Add which for key events
    324                 if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) )
    325                         event.which = event.charCode || event.keyCode;
    326                
    327                 // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
    328                 if ( !event.metaKey && event.ctrlKey )
    329                         event.metaKey = event.ctrlKey;
    330 
    331                 // Add which for click: 1 == left; 2 == middle; 3 == right
    332                 // Note: button is not normalized, so don't use it
    333                 if ( !event.which && event.button )
    334                         event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
    335                        
    336                 return event;
    337         },
    338        
     281        // create a new event object to be able to set
     282        // properties that normally are just read-only
     283        create: function(e, target, source) {
     284
     285                // need to set defult values
     286                return e.originalEvent ? e : {
     287
     288                        type: e.type,
     289
     290                        pageX: e.pageX || 0,
     291                        pageY: e.pageY || 0,
     292
     293                        clientX: e.clientX || 0,
     294                        clientY: e.clientY || 0,
     295
     296                        screenX: e.screenX || 0,
     297                        screenY: e.screenY || 0,
     298
     299                        // target is a parameter
     300                        target: target || window,
     301
     302                        altKey: e.altKey || false,
     303                        button: e.button || false,
     304                        ctrlKey: e.ctrlKey || false,
     305                        metaKey: e.metaKey || false,
     306                        shiftKey: e.shiftKey || false,
     307
     308                        details: e.details || null,
     309                        wheelDelta: e.wheelDelta || 0,
     310
     311                        bubbles: e.bubbles || true,
     312                        cancelable: e.cancelable || true,
     313
     314                        eventPhase: e.eventPhase || 0,
     315                        timeStamp: e.timeStamp || (new Date()).getTime(),
     316
     317                        // target and source are parameters
     318                        relatedTarget: e.relatedTarget || target || null,
     319                        currentTarget: e.currentTarget || source || null,
     320
     321                        view: e.view || window,
     322
     323                        relatedNode: e.relatedNode || null,
     324
     325                        prevValue: e.prevValue || null,
     326                        newValue: e.newValue || null,
     327
     328                        attrName: e.attrName || '',
     329                        attrChange: e.attrChange || false,
     330
     331                        data: e.data || null,
     332                        handler: e.handler || null,
     333                        exclusive: e.exclusive || false,
     334
     335                        // reference to the original event
     336                        originalEvent: e
     337
     338                };
     339
     340        },
     341
     342        fix: function(e, o) {
     343
     344                // cache this
     345                var root = document.documentElement, body = document.body;
     346
     347                // optimized using lazy function definition
     348                // and recreating a new event object template
     349
     350                if ( document.createEventObject ) {
     351
     352                        jQuery.event.fix = function(e, o) {
     353
     354                                var ev = e;
     355
     356                                ev.target = ev.target || ev.srcElement || window;
     357
     358                                // prevent the execution of the default action
     359                                ev.preventDefault = ev.preventDefault || function() {
     360                                        // set the returnValue property of
     361                                        // the original event to false (IE)
     362                                        e.returnValue = false;
     363                                };
     364
     365                                // stop the event bubbling up to other elements
     366                                ev.stopPropagation = ev.stopPropagation || function() {
     367                                        // set the cancelBubble property of
     368                                        // the original event to true (IE)
     369                                        e.cancelBubble = true;
     370                                };
     371
     372                                // check if target is a textnode (safari)
     373                                if ( ev.target.nodeType == 3 ) {
     374                                        ev.target = ev.target.parentNode;
     375                                }
     376
     377                                // Add relatedTarget, if necessary
     378                                ev.relatedTarget = ev.relatedTarget || (ev.fromElement == ev.target ? ev.toElement : ev.fromElement);
     379
     380                                // Calculate pageX/Y if missing and clientX/Y available
     381                                ev.pageX = ev.pageX || (ev.clientX + (root && root.scrollLeft || body && body.scrollLeft || 0) - (root.clientLeft || 0));
     382                                ev.pageY = ev.pageY || (ev.clientY + (root && root.scrollTop || body && body.scrollTop || 0) - (root.clientTop || 0));
     383
     384                                // Add which for key events
     385                                ev.which = ev.which || ev.charCode || ev.keyCode;
     386
     387                                // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
     388                                ev.metaKey = ev.metaKey || ev.ctrlKey;
     389
     390                                // Add which for click: 1 == left; 2 == middle; 3 == right
     391                                // Note: button is not normalized, so don't use it
     392                                ev.which = ev.which || (ev.button & 1 ? 1 : ( ev.button & 2 ? 3 : ( ev.button & 4 ? 2 : 0 ) ));
     393
     394                                // return the writable cloned event
     395                                return ev;
     396                        }
     397
     398                } else {
     399
     400                        jQuery.event.fix = function(e, o) {
     401
     402                                var ev = e;
     403
     404                                // is it a custom event
     405                                if ( !ev.initEvent ) {
     406
     407                                        // create a mirror event
     408                                        ev = jQuery.event.create(e, e.target, o);
     409
     410                                        // add preventDefault and stopPropagation since
     411                                        // they will not work on the clone event object
     412
     413                                        // prevent the execution of the default action
     414                                        ev.preventDefault = ev.preventDefault || function() {
     415                                                // if preventDefault exists run it on the original event
     416                                                if (e.preventDefault)
     417                                                        e.preventDefault();
     418                                        };
     419
     420                                        // stop the event bubbling up to other elements
     421                                        ev.stopPropagation = ev.stopPropagation || function() {
     422                                                // if stopPropagation exists run it on the original event
     423                                                if (e.stopPropagation)
     424                                                        e.stopPropagation();
     425                                        };
     426
     427                                        // check if target is a textnode
     428                                        if ( ev.target.nodeType == 3 ) {
     429                                                ev.target = ev.target.parentNode;
     430                                        }
     431
     432                                }
     433
     434                                return ev;
     435                        }
     436                }
     437
     438                return jQuery.event.fix(e, o);
     439        },
     440
    339441        special: {
    340442                ready: {
    341443                        setup: function() {