sproutcore 1.11.0.rc1 → 1.11.0.rc2

data/lib/frameworks/sproutcore/frameworks/core_foundation/mixins/delegate_support.js

@@ -71,12 +71,16 @@ SC.DelegateSupport = {
 
     @param {Object} delegate a delegate object.  May be null.
     @param {String} methodName a method name
-    @param {Object...} args (OPTIONAL) any additional arguments
+    @param {Object...} [args...] any additional arguments
 
     @returns {Object} value returned by delegate
   */
-  invokeDelegateMethod: function(delegate, methodName, args) {
-    args = SC.A(arguments); args = args.slice(2, args.length) ;
+  invokeDelegateMethod: function(delegate, methodName) {
+    // Fast arguments access.
+    // Accessing `arguments.length` is just a Number and doesn't materialize the `arguments` object, which is costly.
+    var args = new Array(arguments.length - 2); //  SC.A(arguments).slice(2)
+    for (var i = 0, len = args.length; i < len; i++) { args[i] = arguments[i + 2]; }
+
     if (!delegate || !delegate[methodName]) delegate = this ;
 
     var method = delegate[methodName];

data/lib/frameworks/sproutcore/frameworks/core_foundation/mixins/responder_context.js

@@ -25,11 +25,8 @@ sc_require('system/responder');
 */
 SC.ResponderContext = {
 
-  // ..........................................................
-  // PROPERTIES
-  //
-
-  isResponderContext: YES,
+  //@if(debug)
+  /* BEGIN DEBUG ONLY PROPERTIES AND METHODS */
 
   /** @property
 
@@ -38,6 +35,15 @@ SC.ResponderContext = {
   */
   trace: NO,
 
+  /* END DEBUG ONLY PROPERTIES AND METHODS */
+  //@endif
+
+  // ..........................................................
+  // PROPERTIES
+  //
+
+  isResponderContext: YES,
+
   /** @property
     The default responder.  Set this to point to a responder object that can
     respond to events when no other view in the hierarchy handles them.
@@ -90,6 +96,7 @@ SC.ResponderContext = {
     return responder._scrc_name || responder.toString(); // try again
   },
 
+  /** @private */
   _findResponderNamesFor: function(responder, level, path) {
     var key, value;
 
@@ -122,21 +129,27 @@ SC.ResponderContext = {
   makeFirstResponder: function(responder, evt) {
     var current = this.get('firstResponder'),
         last    = this.get('nextResponder'),
+        //@if(debug)
         trace   = this.get('trace'),
+        //@endif
         common ;
 
     if (this._locked) {
+      //@if(debug)
       if (trace) {
         SC.Logger.log('%@: AFTER ACTION: makeFirstResponder => %@'.fmt(this, this.responderNameFor(responder)));
       }
+      //@endif
 
       this._pendingResponder = responder;
       return ;
     }
 
+    //@if(debug)
     if (trace) {
       SC.Logger.log('%@: makeFirstResponder => %@'.fmt(this, this.responderNameFor(responder)));
     }
+    //@endif
 
     if (responder) responder.set("becomingFirstResponder", YES);
 
@@ -167,7 +180,7 @@ SC.ResponderContext = {
     if (responder) responder.set('isFirstResponder', YES);
 
     this._notifyDidBecomeFirstResponder(responder, responder, common);
-    
+
     // now, tell everyone the good news!
     this.endPropertyChanges();
 
@@ -220,20 +233,25 @@ SC.ResponderContext = {
 
     @param {String} action name of action
     @param {Object} sender object sending the action
-    @param {Object} context optional additional context info
+    @param {Object} [context] additional context info
     @returns {SC.Responder} the responder that handled it or null
   */
   sendAction: function(action, sender, context) {
     var working = this.get('firstResponder'),
         last    = this.get('nextResponder'),
+        //@if(debug)
         trace   = this.get('trace'),
+        //@endif
         handled = NO,
         responder;
 
     this._locked = YES;
+
+    //@if(debug)
     if (trace) {
       SC.Logger.log("%@: begin action '%@' (%@, %@)".fmt(this, action, sender, context));
     }
+    //@endif
 
     if (!handled && !working && this.tryToPerform) {
       handled = this.tryToPerform(action, sender, context);
@@ -249,10 +267,12 @@ SC.ResponderContext = {
       }
     }
 
+    //@if(debug)
     if (trace) {
       if (!handled) SC.Logger.log("%@:  action '%@' NOT HANDLED".fmt(this,action));
       else SC.Logger.log("%@: action '%@' handled by %@".fmt(this, action, this.responderNameFor(working)));
     }
+    //@endif
 
     this._locked = NO ;
 

data/lib/frameworks/sproutcore/frameworks/core_foundation/system/browser.js

@@ -83,48 +83,6 @@ SC.mixin(SC.browser,
     return 0;
   },
 
-  /**
-    @deprecated Since 1.7. Use SC.browser.compare(version, otherVersion) instead.
-
-    Pass any number of arguments, and this will check them against the browser
-    version split on ".".  If any of them are not equal, return the inequality.
-    If as many arguments as were passed in are equal, return 0.  If something
-    is NaN, return 0.
-  */
-
-  // Deprecation Note:
-  //
-  // This function forces the comparison against the value of
-  // SC.browser.version, but the old value of SC.browser.version would
-  // occasionally be the browser's version or the layout engine's version,
-  // which could cause unexpected results.  As well, there was no way to
-  // compare the actual browser version or OS version.
-  compareVersion: function () {
-    //@if(debug)
-    SC.warn('Developer Warning: SC.browser.compareVersion() has been deprecated.  Please ' +
-        'use SC.browser.compare() instead.  Example: ' +
-        'SC.browser.compareVersion(16,0,912) < 0 becomes ' +
-        'SC.browser.compare(SC.browser.engineVersion, \'16.0.912\').');
-    //@endif
-
-    if (this._versionSplit === undefined) {
-      var coerce = function (part) {
-        return Number(part.match(/^[0-9]+/));
-      };
-      this._versionSplit = SC.A(this.version.split('.')).map(coerce);
-    }
-
-    var tests = SC.A(arguments).map(Number);
-    for (var i = 0; i < tests.length; i++) {
-      var check = this._versionSplit[i] - tests[i];
-      if (isNaN(check)) return 0;
-      if (check !== 0) return check;
-    }
-
-    return 0;
-  },
-
-
   /**
     This simple method allows you to more safely use experimental properties and
     methods in current and future browsers.
@@ -180,19 +138,6 @@ SC.mixin(SC.browser,
     @returns {string} The name of the property or method on the target or SC.UNSUPPORTED if no method found.
   */
   experimentalNameFor: function (target, standardName, testValue) {
-    var cachedNames = this._cachedNames,
-      targetGuid = SC.guidFor(target);
-
-    // Fast path & cache initialization.
-    if (!cachedNames) {
-      cachedNames = this._cachedNames = {};
-      cachedNames[targetGuid] = {};
-    } else if (!cachedNames[targetGuid]) {
-      cachedNames[targetGuid] = {};
-    } else if (cachedNames[targetGuid][standardName]) {
-      return cachedNames[targetGuid][standardName];
-    }
-
     // Test the property name.
     var ret = standardName;
 
@@ -220,9 +165,6 @@ SC.mixin(SC.browser,
       }
     }
 
-    // Cache the experimental property name (even SC.UNSUPPORTED) for quick repeat access.
-    cachedNames[targetGuid][standardName] = ret;
-
     return ret;
   },
 
@@ -262,13 +204,28 @@ SC.mixin(SC.browser,
     @returns {string} Future-proof style name for use in the current browser or SC.UNSUPPORTED if no style support found.
   */
   experimentalStyleNameFor: function (standardStyleName, testValue) {
-    // Test the style name.
-    var el = this._testEl;
+    var cachedNames = this._sc_experimentalStyleNames,
+        ret;
+
+    // Fast path & cache initialization.
+    if (!cachedNames) {
+      cachedNames = this._sc_experimentalStyleNames = {};
+    }
+
+    if (cachedNames[standardStyleName]) {
+      ret = cachedNames[standardStyleName];
+    } else {
+      // Test the style name.
+      var el = this._testEl;
 
-    // Create a test element and cache it for repeated use.
-    if (!el) { el = this._testEl = document.createElement("div"); }
+      // Create a test element and cache it for repeated use.
+      if (!el) { el = this._testEl = document.createElement("div"); }
 
-    return this.experimentalNameFor(el.style, standardStyleName, testValue);
+      // Cache the experimental style name (even SC.UNSUPPORTED) for quick repeat access.
+      ret = cachedNames[standardStyleName] = this.experimentalNameFor(el.style, standardStyleName, testValue);
+    }
+
+    return ret;
   },
 
   /**

data/lib/frameworks/sproutcore/frameworks/core_foundation/system/color.js

@@ -144,7 +144,7 @@
       if (SC.Color.supportsARGB) {
         var gradient = "progid:DXImageTransform.Microsoft.gradient";
         css = ("-ms-filter:" + gradient + "(startColorstr=%@1,endColorstr=%@1);" +
-               "filter:" + gradient + "(startColorstr=%@1,endColorstr=%@1)" + 
+               "filter:" + gradient + "(startColorstr=%@1,endColorstr=%@1)" +
                "zoom: 1").fmt(color);
       } else {
         css = "background-color:" + color;
@@ -482,7 +482,7 @@ SC.Color = SC.Object.extend(
    */
   cssText: function (key, value) {
     // Getter.
-    if (value === undefined) { 
+    if (value === undefined) {
       // FAST PATH: Error.
       if (this.get('isError')) return this.get('errorValue');
 
@@ -641,16 +641,22 @@ SC.Color.mixin(
 
   /** @private Overrides create to support creation with {a, r, g, b} hash. */
   create: function() {
-    var args = SC.A(arguments),
-        len = args.length,
-        vals = {},
+    var vals = {},
         hasVals = NO,
         keys = ['a', 'r', 'g', 'b'],
+        args, len,
         hash, i, k, key;
+
+
+    // Fast arguments access.
+    // Accessing `arguments.length` is just a Number and doesn't materialize the `arguments` object, which is costly.
+    args = new Array(arguments.length); // SC.A(arguments)
+    len = args.length;
+
     // Loop through all arguments. If any of them contain numeric a, r, g or b arguments,
     // clone the hash and move the value from (e.g.) a to _a.
     for (i = 0; i < len; i++) {
-      hash = args[i];
+      hash = arguments[i];
       if (SC.typeOf(hash.a) === SC.T_NUMBER
         || SC.typeOf(hash.r) === SC.T_NUMBER
         || SC.typeOf(hash.g) === SC.T_NUMBER
@@ -665,8 +671,11 @@ SC.Color.mixin(
             delete hash[key];
           }
         }
+      } else {
+        args[i] = hash;
       }
     }
+
     if (hasVals) args.push(vals);
     return SC.Object.create.apply(this, args);
   },
@@ -921,7 +930,7 @@ SC.Color.mixin(
 
   // ..........................................................
   // Regular expressions for accepted color types
-  // 
+  //
   PARSE_RGBA: /^rgba\(\s*([\d]+%?)\s*,\s*([\d]+%?)\s*,\s*([\d]+%?)\s*,\s*([.\d]+)\s*\)$/,
   PARSE_RGB : /^rgb\(\s*([\d]+%?)\s*,\s*([\d]+%?)\s*,\s*([\d]+%?)\s*\)$/,
   PARSE_HSLA: /^hsla\(\s*(-?[\d]+)\s*\s*,\s*([\d]+)%\s*,\s*([\d]+)%\s*,\s*([.\d]+)\s*\)$/,

data/lib/frameworks/sproutcore/frameworks/core_foundation/system/event.js

@@ -28,90 +28,10 @@ sc_require('system/core_query') ;
   @since SproutCore 1.0
 */
 SC.Event = function(originalEvent) {
-  var idx, len;
-  // copy properties from original event, if passed in.
-  if (originalEvent) {
-    this.originalEvent = originalEvent ;
-    var props = SC.Event._props, key;
-    len = props.length;
-    idx = len;
-    while(--idx >= 0) {
-      key = props[idx] ;
-      this[key] = originalEvent[key] ;
-    }
-  }
-
-  // Fix timeStamp
-  this.timeStamp = this.timeStamp || Date.now();
-
-  // Fix target property, if necessary
-  // Fixes #1925 where srcElement might not be defined either
-  if (!this.target) this.target = this.srcElement || document;
-
-  // check if target is a textnode (safari)
-  if (this.target.nodeType === 3 ) this.target = this.target.parentNode;
-
-  // Add relatedTarget, if necessary
-  if (!this.relatedTarget && this.fromElement) {
-    this.relatedTarget = (this.fromElement === this.target) ? this.toElement : this.fromElement;
-  }
-
-  // Calculate pageX/Y if missing and clientX/Y available
-  if (SC.none(this.pageX) && !SC.none(this.clientX)) {
-    var doc = document.documentElement, body = document.body;
-    this.pageX = this.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0);
-    this.pageY = this.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0);
-  }
-
-  // Add which for key events
-  if (!this.which && ((this.charCode || originalEvent.charCode === 0) ? this.charCode : this.keyCode)) {
-    this.which = this.charCode || this.keyCode;
-  }
-
-  // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
-  if (!this.metaKey && this.ctrlKey) this.metaKey = this.ctrlKey;
-
-  // Add which for click: 1 == left; 2 == middle; 3 == right
-  // Note: button is not normalized, so don't use it
-  if (!this.which && this.button) {
-    this.which = ((this.button & 1) ? 1 : ((this.button & 2) ? 3 : ( (this.button & 4) ? 2 : 0 ) ));
-  }
-
-  // Normalize wheel delta values for mousewheel events
-  if (this.type === 'mousewheel' || this.type === 'DOMMouseScroll' || this.type === 'MozMousePixelScroll') {
-    var deltaMultiplier = SC.Event.MOUSE_WHEEL_MULTIPLIER;
-
-    // normalize wheelDelta, wheelDeltaX, & wheelDeltaY for Safari
-    if (SC.browser.isWebkit && originalEvent.wheelDelta !== undefined) {
-      this.wheelDelta = 0-(originalEvent.wheelDeltaY || originalEvent.wheelDeltaX);
-      this.wheelDeltaY = 0-(originalEvent.wheelDeltaY||0);
-      this.wheelDeltaX = 0-(originalEvent.wheelDeltaX||0);
-
-    // normalize wheelDelta for Firefox (all Mozilla browsers)
-    // note that we multiple the delta on FF to make it's acceleration more
-    // natural.
-    } else if (!SC.none(originalEvent.detail) && SC.browser.isMozilla) {
-      if (originalEvent.axis && (originalEvent.axis === originalEvent.HORIZONTAL_AXIS)) {
-        this.wheelDeltaX = originalEvent.detail;
-        this.wheelDeltaY = this.wheelDelta = 0;
-      } else {
-        this.wheelDeltaY = this.wheelDelta = originalEvent.detail ;
-        this.wheelDeltaX = 0 ;
-      }
-
-    // handle all other legacy browser
-    } else {
-      this.wheelDelta = this.wheelDeltaY = SC.browser.isIE || SC.browser.isOpera ? 0-originalEvent.wheelDelta : originalEvent.wheelDelta ;
-      this.wheelDeltaX = 0 ;
-    }
-
-    this.wheelDelta *= deltaMultiplier;
-    this.wheelDeltaX *= deltaMultiplier;
-    this.wheelDeltaY *= deltaMultiplier;
-  }
+  this._sc_updateNormalizedEvent(originalEvent);
 
   return this;
-} ;
+};
 
 SC.mixin(SC.Event, /** @scope SC.Event */ {
 
@@ -187,7 +107,7 @@ SC.mixin(SC.Event, /** @scope SC.Event */ {
     named element.  You can optionally pass an additional context object which
     will be included on the event in the event.data property.
 
-    When your handler function is called the, the function's "this" property
+    When your handler function is called, the function's "this" property
     will point to the element the event occurred on.
 
     The click handler for this method must have a method signature like:
@@ -260,21 +180,24 @@ SC.mixin(SC.Event, /** @scope SC.Event */ {
 
     // if target is a function, treat it as the method, with optional context
     if (SC.typeOf(target) === SC.T_FUNCTION) {
-      context = method; method = target; target = null;
+      context = method;
+      method = target;
+      target = null;
 
     // handle case where passed method is a key on the target.
     } else if (target && SC.typeOf(method) === SC.T_STRING) {
-      method = target[method] ;
+      method = target[method];
     }
 
     // Get the handlers queue for this element/eventType.  If the queue does
     // not exist yet, create it and also setup the shared listener for this
     // eventType.
-    var events = SC.data(elem, "sc_events") || SC.data(elem, "sc_events", {}) ,
+    var events = SC.data(elem, "sc_events") || SC.data(elem, "sc_events", {}),
         handlers = events[eventType];
+
     if (!handlers) {
-      handlers = events[eventType] = {} ;
-      this._addEventListener(elem, eventType, useCapture) ;
+      handlers = events[eventType] = {};
+      this._addEventListener(elem, eventType, useCapture);
     }
 
     // Build the handler array and add to queue
@@ -420,7 +343,8 @@ SC.mixin(SC.Event, /** @scope SC.Event */ {
       timeStamp: Date.now(),
       bubbles: (this.NO_BUBBLE.indexOf(eventType)<0),
       cancelled: NO,
-      normalized: YES
+      normalized: YES,
+      simulated: true
     });
     if (attrs) SC.mixin(ret, attrs) ;
     return ret ;
@@ -445,18 +369,18 @@ SC.mixin(SC.Event, /** @scope SC.Event */ {
 
     @param elem {Element} the target element
     @param eventType {String} the event type
-    @param args {Array} optional argument or arguments to pass to handler.
+    @param event {SC.Event} [event] pre-normalized event to pass to handler
     @param donative ??
     @returns {Boolean} Return value of trigger or undefined if not fired
   */
-  trigger: function(elem, eventType, args, donative) {
+  trigger: function(elem, eventType, event, donative) {
 
     // if a CQ object is passed in, either call add on each item in the
     // matched set, or simply get the first element and use that.
     if (elem && elem.isCoreQuery) {
       if (elem.length > 0) {
         elem.forEach(function(e) {
-          this.trigger(e, eventType, args, donative);
+          this.trigger(e, eventType, event, donative);
         }, this);
         return this;
       } else elem = elem[0];
@@ -466,25 +390,23 @@ SC.mixin(SC.Event, /** @scope SC.Event */ {
     // don't do events on text and comment nodes
     if ( elem.nodeType === 3 || elem.nodeType === 8 ) return undefined;
 
-    // Normalize to an array
-    args = SC.A(args) ;
+    // Backwards-compatibility. Normalize from an Array.
+    if (SC.typeOf(event) === SC.T_ARRAY) { event = event[0]; }
 
     var ret, fn = SC.typeOf(elem[eventType] || null) === SC.T_FUNCTION ,
-        event, current, onfoo, isClick;
+        current, onfoo, isClick;
 
     // Get the event to pass, creating a fake one if necessary
-    event = args[0];
     if (!event || !event.preventDefault) {
-      event = this.simulateEvent(elem, eventType) ;
-      args.unshift(event) ;
+      event = this.simulateEvent(elem, eventType);
     }
 
-    event.type = eventType ;
+    event.type = eventType;
 
     // Trigger the event - bubble if enabled
     current = elem;
     do {
-      ret = SC.Event.handle.apply(current, args);
+      ret = SC.Event.handle.call(current, event);
       current = (current===document) ? null : (current.parentNode || document);
     } while(!ret && event.bubbles && current);
     current = null ;
@@ -492,7 +414,7 @@ SC.mixin(SC.Event, /** @scope SC.Event */ {
     // Handle triggering native .onfoo handlers
     onfoo = elem["on" + eventType] ;
     isClick = SC.$.nodeName(elem, 'a') && eventType === 'click';
-    if ((!fn || isClick) && onfoo && onfoo.apply(elem, args) === NO) ret = NO;
+    if ((!fn || isClick) && onfoo && onfoo.call(elem, event) === NO) ret = NO;
 
     // Trigger the native events (except for clicks on links)
     if (fn && donative !== NO && ret !== NO && !isClick) {
@@ -520,50 +442,55 @@ SC.mixin(SC.Event, /** @scope SC.Event */ {
     Note that like other parts of this library, the handle function does not
     support namespaces.
 
-    @param event {Event} the event to handle
+    @param event {DOMEvent} the event to handle
     @returns {Boolean}
   */
-  handle: function(event) {
+  handle: function (event) {
 
     // ignore events triggered after window is unloaded or if double-called
     // from within a trigger.
-    if ((typeof SC === "undefined") || SC.Event.triggered) return YES ;
-
-    // returned undefined or NO
-    var val, ret, handlers, args, key, handler, method, target;
+    if ((typeof SC === "undefined") || SC.Event.triggered) return true;
 
-    // normalize event across browsers.  The new event will actually wrap the
-    // real event with a normalized API.
-    args = SC.A(arguments);
-    args[0] = event = SC.Event.normalizeEvent(event || window.event);
+    // returned undefined or false
+    var val, ret, handlers, method, target;
 
     // get the handlers for this event type
     handlers = (SC.data(this, "sc_events") || {})[event.type];
-    if (!handlers) return NO ; // nothing to do
-
-    // invoke all handlers
-    for (key in handlers ) {
-      handler = handlers[key];
-      // handler = [target, method, context]
-      method = handler[1];
-
-      // Pass in a reference to the handler function itself
-      // So that we can later remove it
-      event.handler = method;
-      event.data = event.context = handler[2];
-
-      target = handler[0] || this;
-      ret = method.apply( target, args );
-
-      if (val !== NO) val = ret;
-
-      // if method returned NO, do not continue.  Stop propagation and
-      // return default.  Note that we test explicitly for NO since
-      // if the handler returns no specific value, we do not want to stop.
-      if ( ret === NO ) {
-        event.preventDefault();
-        event.stopPropagation();
+
+    // no handlers for the event
+    if (!handlers) {
+      val = false; // nothing to do
+
+    } else {
+      // normalize event across browsers.  The new event will actually wrap the real event with a normalized API.
+      event = SC.Event.normalizeEvent(event || window.event);
+
+      // invoke all handlers
+      for (var key in handlers) {
+        var handler = handlers[key];
+
+        method = handler[1];
+
+        // Pass in a reference to the handler function itself so that we can remove it later.
+        event.handler = method;
+        event.data = event.context = handler[2];
+
+        target = handler[0] || this;
+        ret = method.call(target, event);
+
+        if (val !== false) val = ret;
+
+        // if method returned NO, do not continue.  Stop propagation and
+        // return default.  Note that we test explicitly for NO since
+        // if the handler returns no specific value, we do not want to stop.
+        if ( ret === false ) {
+          event.preventDefault();
+          event.stopPropagation();
+        }
       }
+
+      // Clean up the cached normalized SC.Event so that it's not holding onto extra memory.
+      if (event.originalEvent && !event.originalEvent.simulated) { event._sc_clearNormalizedEvent(); }
     }
 
     return val;
@@ -619,12 +546,13 @@ SC.mixin(SC.Event, /** @scope SC.Event */ {
         return YES;
       },
 
-      handler: function(event) {
+      handler: function (event) {
         // If we actually just moused on to a sub-element, ignore it
         if ( SC.Event._withinElement(event, this) ) return YES;
         // Execute the right handlers by setting the event type to mouseenter
         event.type = "mouseenter";
-        return SC.Event.handle.apply(this, arguments);
+
+        return SC.Event.handle.call(this, event);
       }
     },
 
@@ -643,12 +571,12 @@ SC.mixin(SC.Event, /** @scope SC.Event */ {
         return YES;
       },
 
-      handler: function(event) {
+      handler: function (event) {
         // If we actually just moused on to a sub-element, ignore it
         if ( SC.Event._withinElement(event, this) ) return YES;
         // Execute the right handlers by setting the event type to mouseleave
         event.type = "mouseleave";
-        return SC.Event.handle.apply(this, arguments);
+        return SC.Event.handle.call(this, event);
       }
     }
   },
@@ -693,16 +621,17 @@ SC.mixin(SC.Event, /** @scope SC.Event */ {
     @param eventType {String} the event type
   */
   _addEventListener: function(elem, eventType, useCapture) {
-    var listener, special = this.special[eventType] ;
+    var listener,
+        special = this.special[eventType] ;
 
 		if (!useCapture) {
-			useCapture = NO;
+			useCapture = false;
 		}
 
     // Check for a special event handler
     // Only use addEventListener/attachEvent if the special
-    // events handler returns NO
-    if ( !special || special.setup.call(elem)===NO) {
+    // events handler returns false
+    if ( !special || special.setup.call(elem) === false) {
 
       // Save element in cache.  This must be removed later to avoid
       // memory leaks.
@@ -711,9 +640,9 @@ SC.mixin(SC.Event, /** @scope SC.Event */ {
 
       // Either retrieve the previously cached listener or cache a new one.
       listener = SC.data(elem, "listener") || SC.data(elem, "listener",
-       function() {
-         return SC.Event.handle.apply(SC.Event._elements[guid], arguments);
-      }) ;
+        function handle_event (event) {
+          return SC.Event.handle.call(SC.Event._elements[guid], event);
+        });
 
       // Bind the global event handler to the element
       if (elem.addEventListener) {
@@ -723,13 +652,9 @@ SC.mixin(SC.Event, /** @scope SC.Event */ {
         // there is currently a hack in request , but it needs to fixed here.
         elem.attachEvent("on" + eventType, listener);
       }
-      //
-      // else {
-      //         elem.onreadystatechange = listener;
-      //       }
     }
 
-    elem = special = listener = null ; // avoid memory leak
+    elem = special = listener = null; // avoid memory leak
   },
 
   /** @private
@@ -764,24 +689,51 @@ SC.mixin(SC.Event, /** @scope SC.Event */ {
 
   _elements: {},
 
+  _sc_normalizedEvents: null,
+
   // implement preventDefault() in a cross platform way
 
   /** @private Take an incoming event and convert it to a normalized event. */
-  normalizeEvent: function(event) {
-    if (event === window.event) {
-      // IE can't do event.normalized on an Event object
-      return SC.Event.create(event) ;
+  normalizeEvent: function (event) {
+    var ret;
+
+    // Create the cache the first time.
+    if (!this._sc_normalizedEvents) { this._sc_normalizedEvents = {}; }
+    ret = this._sc_normalizedEvents[event.type];
+
+    // Create a new normalized SC.Event.
+    if (!ret) {
+      if (event === window.event) {
+        // IE can't do event.normalized on an Event object
+        ret = SC.Event.create(event) ;
+      } else {
+        ret = event.normalized ? event : SC.Event.create(event) ;
+      }
+
+    // When passed an SC.Event, don't re-normalize it.
+    // TODO: This is hacky nonsense left over from a whole pile of bad decisions in SC.Event—
+    } else if (event.normalized) {
+      ret = event;
+
+    // Update the cached normalized SC.Event with the new DOM event.
     } else {
-      return event.normalized ? event : SC.Event.create(event) ;
+      ret._sc_updateNormalizedEvent(event);
     }
+
+    // Cache the normalized event object for this type of event. This allows us to avoid recreating
+    // SC.Event objects constantly for noisy events such as 'mousemove' or 'mousewheel'.
+    this._sc_normalizedEvents[event.type] = ret;
+
+    return ret;
   },
 
   _global: {},
 
   /** @private properties to copy from native event onto the event */
-  _props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode metaKey newValue originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target timeStamp toElement type view which touches targetTouches changedTouches animationName elapsedTime dataTransfer".split(" ")
+  // TODO: Remove this needless copy.
+  _props: ['altKey', 'attrChange', 'attrName', 'bubbles', 'button', 'cancelable', 'charCode', 'clientX', 'clientY', 'ctrlKey', 'currentTarget', 'data', 'detail', 'fromElement', 'handler', 'keyCode', 'metaKey', 'newValue', 'originalTarget', 'pageX', 'pageY', 'prevValue', 'relatedNode', 'relatedTarget', 'screenX', 'screenY', 'shiftKey', 'srcElement', 'target', 'timeStamp', 'toElement', 'type', 'view', 'which', 'touches', 'targetTouches', 'changedTouches', 'animationName', 'elapsedTime', 'dataTransfer']
 
-}) ;
+});
 
 SC.Event.prototype = {
 
@@ -792,7 +744,175 @@ SC.Event.prototype = {
 
     @type Boolean
   */
-  hasCustomEventHandling: NO,
+  hasCustomEventHandling: false,
+
+  /** @private Clear out the originalEvent from the SC.Event instance. */
+  _sc_clearNormalizedEvent: function () {
+    // Remove the original event.
+    this.originalEvent = null;
+
+    // Reset the custom event handling and normalized flag.
+    this.hasCustomEventHandling = false;
+    this.normalized = false;
+
+    // Remove non-primitive properties copied over from the original event. While these will
+    // be overwritten, it's best to quickly null them out to avoid any issues.
+    var props = SC.Event._props,
+      idx;
+
+    idx = props.length;
+    while(--idx >= 0) {
+      var key = props[idx];
+      this[key] = null;
+    }
+
+    // Remove the custom properties associated with the previous original event. While these will
+    // be overwritten, it's best to quickly null them out to avoid any issues.
+    this.timeStamp = null;
+    this.target = null;
+    this.relatedTarget = null;
+    this.pageX = null;
+    this.pageY = null;
+    this.which = null;
+    this.metaKey = null;
+    this.wheelDelta = null;
+    this.wheelDeltaY = null;
+    this.wheelDeltaX = null;
+  },
+
+  /** @private Update the SC.Event instance with the new originalEvent. */
+  _sc_updateNormalizedEvent: function (originalEvent) {
+    var idx, len;
+
+    // Flag.
+    this.normalized = true;
+
+    // copy properties from original event, if passed in.
+    if (originalEvent) {
+      this.originalEvent = originalEvent ;
+      var props = SC.Event._props,
+        key;
+
+      len = props.length;
+      idx = len;
+      while(--idx >= 0) {
+        key = props[idx] ;
+        this[key] = originalEvent[key] ;
+      }
+    }
+
+    // Fix timeStamp
+    this.timeStamp = this.timeStamp || Date.now();
+
+    // Fix target property, if necessary
+    // Fixes #1925 where srcElement might not be defined either
+    if (!this.target) this.target = this.srcElement || document;
+
+    // check if target is a textnode (safari)
+    if (this.target.nodeType === 3 ) this.target = this.target.parentNode;
+
+    // Add relatedTarget, if necessary
+    if (!this.relatedTarget && this.fromElement) {
+      this.relatedTarget = (this.fromElement === this.target) ? this.toElement : this.fromElement;
+    }
+
+    // Calculate pageX/Y if missing and clientX/Y available
+    if (SC.none(this.pageX) && !SC.none(this.clientX)) {
+      var doc = document.documentElement, body = document.body;
+      this.pageX = this.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0);
+      this.pageY = this.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0);
+    }
+
+    // Add which for key events
+    if (!this.which && ((this.charCode || originalEvent.charCode === 0) ? this.charCode : this.keyCode)) {
+      this.which = this.charCode || this.keyCode;
+    }
+
+    // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
+    if (!this.metaKey && this.ctrlKey) this.metaKey = this.ctrlKey;
+
+    // Add which for click: 1 == left; 2 == middle; 3 == right
+    // Note: button is not normalized, so don't use it
+    if (!this.which && this.button) {
+      this.which = ((this.button & 1) ? 1 : ((this.button & 2) ? 3 : ( (this.button & 4) ? 2 : 0 ) ));
+    }
+
+    // Normalize wheel delta values for mousewheel events.
+    /*
+      Taken from https://developer.mozilla.org/en-US/docs/Web/Events/mousewheel
+      IE and Opera (Presto) only support wheelDelta attribute and do not support horizontal scroll.
+
+      The wheelDeltaX attribute value indicates the wheelDelta attribute value along the horizontal axis. When a user operates the device for scrolling to right, the value is negative. Otherwise, i.e., if it's to left, the value is positive.
+
+      The wheelDeltaY attribute value indicates the wheelDelta attribute value along the vertical axis. The sign of the value is the same as the wheelDelta attribute value.
+
+      IE
+
+      The value is the same as the delta value of WM_MOUSEWHEEL or WM_MOUSEHWHEEL. It means that if the mouse wheel doesn't support high resolution scroll, the value is 120 per notch. The value isn't changed even if the scroll amount of system settings is page scroll.
+
+      ## Chrome
+
+      On Windows, the value is the same as the delta value of WM_MOUSEWHEEL or WM_MOUSEHWHEEL. And also, the value isn't changed even if the scroll amount of system settings is page scroll, i.e., the value is the same as IE on Windows.
+
+      On Linux, the value is 120 or -120 per native wheel event. This makes the same behavior as IE and Chrome for Windows.
+
+      On Mac, the value is complicated. The value is changed if the device that causes the native wheel event supports continuous scroll.
+
+      If the device supports continuous scroll (e.g., trackpad of MacBook or mouse wheel which can be turned smoothly), the value is computed from accelerated scroll amount. In this case, the value is the same as Safari.
+
+      If the device does not support continuous scroll (typically, old mouse wheel which cannot be turned smoothly), the value is computed from non-accelerated scroll amount (120 per notch). In this case, the value is different from Safari.
+
+      This difference makes a serious issue for web application developers. That is, web developers cannot know if mousewheel event is caused by which device.
+
+      See WebInputEventFactory::mouseWheelEvent of the Chromium's source code for the detail.
+
+      ## Safari
+
+      The value is always computed from accelerated scroll amount. This is really different from other browsers except Chrome with continuous scroll supported device.
+
+      Note: tested with the Windows package, the earliest available version was Safari 3.0 from 2007. It could be that earlier versions (on Mac) support the properties too.
+
+      ## Opera (Presto)
+
+      The value is always the detail attribute value ✕ 40.
+
+      On Windows, since the detail attribute value is computed from actual scroll amount, the value is different from other browsers except the scroll amount per notch is 3 lines in system settings or a page.
+
+      On Linux, the value is 80 or -80 per native wheel event. This is different from other browsers.
+
+      On Mac, the detail attribute value is computed from accelerated scroll amout of native event. The value is usually much bigger than Safari's or Chrome's value.
+    */
+    if (this.type === 'mousewheel' || this.type === 'DOMMouseScroll' || this.type === 'MozMousePixelScroll') {
+      var deltaMultiplier = SC.Event.MOUSE_WHEEL_MULTIPLIER;
+
+      // normalize wheelDelta, wheelDeltaX, & wheelDeltaY for Safari
+      if (SC.browser.isWebkit && originalEvent.wheelDelta !== undefined) {
+        this.wheelDelta = 0 - (originalEvent.wheelDeltaY || originalEvent.wheelDeltaX);
+        this.wheelDeltaY = 0 - (originalEvent.wheelDeltaY || 0);
+        this.wheelDeltaX = 0 - (originalEvent.wheelDeltaX || 0);
+
+      // normalize wheelDelta for Firefox (all Mozilla browsers)
+      // note that we multiple the delta on FF to make it's acceleration more natural.
+      } else if (!SC.none(originalEvent.detail) && SC.browser.isMozilla) {
+        if (originalEvent.axis && (originalEvent.axis === originalEvent.HORIZONTAL_AXIS)) {
+          this.wheelDeltaX = originalEvent.detail;
+          this.wheelDelta = this.wheelDeltaY = 0;
+        } else {
+          this.wheelDelta = this.wheelDeltaY = originalEvent.detail;
+          this.wheelDeltaX = 0;
+        }
+
+      // handle all other legacy browser
+      } else {
+        this.wheelDelta = this.wheelDeltaY = SC.browser.isIE || SC.browser.isOpera ? 0 - originalEvent.wheelDelta : originalEvent.wheelDelta;
+        this.wheelDeltaX = 0;
+      }
+
+      this.wheelDelta *= deltaMultiplier;
+      this.wheelDeltaX *= deltaMultiplier;
+      this.wheelDeltaY *= deltaMultiplier;
+    }
+  },
 
   /**
     Returns the touches owned by the supplied view.