spade 0.0.1

data/sproutcore/frameworks/core_foundation/system/responder.js

@@ -0,0 +1,124 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2010 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+/** @class
+
+  Provides common methods for sending events down a responder chain.
+  Responder chains are used most often to deliver events to user interface
+  elements in your application, but you can also use them to deliver generic
+  events to any part of your application, including controllers.
+
+  @extends SC.Object
+  @since SproutCore 1.0
+*/
+SC.Responder = SC.Object.extend( /** SC.Responder.prototype */ {
+
+  isResponder: YES,
+  
+  /** @property
+    The pane this responder belongs to.  This is used to determine where you 
+    belong to in the responder chain.  Normally you should leave this property
+    set to null.
+  */
+  pane: null,
+  
+  /** @property
+    The app this responder belongs to.  For non-user-interface responder 
+    chains, this is used to determine the context.  Usually this
+    is the property you will want to work with.
+  */
+  responderContext: null,
+  
+  /** @property
+    This is the nextResponder in the responder chain.  If the receiver does 
+    not implement a particular event handler, it will bubble to the next 
+    responder.
+    
+    This can point to an object directly or it can be a string, in which case
+    the path will be resolved from the responderContext root.
+  */
+  nextResponder: null,
+  
+  /** @property 
+    YES if the view is currently first responder.  This property is always 
+    edited by the pane during its makeFirstResponder() method.
+  */
+  isFirstResponder: NO,
+  
+  /** @property
+  
+    YES the responder is somewhere in the responder chain.  This currently
+    only works when used with a ResponderContext.
+    
+    @type {Boolean}
+  */
+  hasFirstResponder: NO,    
+  
+  /** @property
+    Set to YES if your view is willing to accept first responder status.  This is used when calculcating key responder loop.
+  */
+  acceptsFirstResponder: YES,
+  
+  becomingFirstResponder: NO,
+  
+  /** 
+    Call this method on your view or responder to make it become first 
+    responder.
+    
+    @returns {SC.Responder} receiver
+  */
+  becomeFirstResponder: function() {  
+    var pane = this.get('pane') || this.get('responderContext') ||
+              this.pane();
+    if (pane && this.get('acceptsFirstResponder')) {
+      if (pane.get('firstResponder') !== this) pane.makeFirstResponder(this);
+    } 
+    return this ;
+  },
+  
+  /**
+    Call this method on your view or responder to resign your first responder 
+    status. Normally this is not necessary since you will lose first responder 
+    status automatically when another view becomes first responder.
+    
+    @param {Event} the original event that caused this method to be called
+    @returns {SC.Responder} receiver
+  */
+  resignFirstResponder: function(evt) {
+    var pane = this.get('pane') || this.get('responderContext');
+    if (pane && (pane.get('firstResponder') === this)) {
+      pane.makeFirstResponder(null, evt);
+    }
+    return YES;  
+  },
+
+  /**
+    Called just before the responder or any of its subresponder's are about to
+    lose their first responder status.  The passed responder is the responder
+    that is about to lose its status. 
+    
+    Override this method to provide any standard teardown when the first 
+    responder changes.
+    
+    @param {SC.Responder} responder the responder that is about to change
+    @returns {void}
+  */
+  willLoseFirstResponder: function(responder) {},
+  
+  /**
+    Called just after the responder or any of its subresponder's becomes a 
+    first responder.  
+    
+    Override this method to provide any standard setup when the first 
+    responder changes.
+    
+    @param {SC.Responder} responder the responder that changed
+    @returns {void}
+  */
+  didBecomeFirstResponder: function(responder) {}
+
+});

data/sproutcore/frameworks/core_foundation/system/root_responder.js

@@ -0,0 +1,2173 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2010 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+sc_require('system/ready');
+sc_require('system/platform');
+
+/** Set to NO to leave the backspace key under the control of the browser.*/
+SC.CAPTURE_BACKSPACE_KEY = NO ;
+
+/** @class
+
+  The RootResponder captures events coming from a web browser and routes them
+  to the correct view in the view hierarchy.  Usually you do not work with a
+  RootResponder directly.  Instead you will work with Pane objects, which
+  register themselves with the RootResponder as needed to receive events.
+
+  h1. RootResponder and Platforms
+
+  RootResponder contains core functionality common among the different web
+  platforms. You will likely be working with a subclass of RootResponder that
+  implements functionality unique to that platform.
+
+  The correct instance of RootResponder is detected at runtime and loaded
+  transparently.
+
+  h1. Event Types
+
+  RootResponders can route four types of events:
+
+  - Direct events, such as mouse and touch events.  These are routed to the
+    nearest view managing the target DOM elment. RootResponder also handles
+    multitouch events so that they are delegated to the correct views.
+  - Keyboard events. These are sent to the keyPane, which will then send the
+    event to the current firstResponder and up the responder chain.
+  - Resize events. When the viewport resizes, these events will be sent to all
+    panes.
+  - Keyboard shortcuts. Shortcuts are sent to the keyPane first, which
+    will go down its view hierarchy. Then they go to the mainPane, which will
+    go down its view hierarchy.
+  - Actions. Actions are generic messages that your application can send in
+    response to user action or other events. You can either specify an
+    explicit target, or allow the action to traverse the hierarchy until a
+    view is found that handles it.
+*/
+SC.RootResponder = SC.Object.extend({
+
+  /**
+    Contains a list of all panes currently visible on screen.  Everytime a
+    pane attaches or detaches, it will update itself in this array.
+  */
+  panes: null,
+
+  init: function() {
+    sc_super();
+    this.panes = SC.Set.create();
+
+    if (SC.platform.supportsCSSTransitions) {
+      this[SC.platform.cssPrefix+'TransitionEnd'] = this.transitionEnd;
+    }
+  },
+
+  // .......................................................
+  // MAIN PANE
+  //
+
+  /** @property
+    The main pane.  This pane receives shortcuts and actions if the
+    focusedPane does not respond to them.  There can be only one main pane.
+    You can swap main panes by calling makeMainPane() here.
+
+    Usually you will not need to edit the main pane directly.  Instead, you
+    should use a MainPane subclass, which will automatically make itself main
+    when you append it to the document.
+  */
+  mainPane: null,
+
+  /**
+    Swaps the main pane.  If the current main pane is also the key pane, then
+    the new main pane will also be made key view automatically.  In addition
+    to simply updating the mainPane property, this method will also notify the
+    panes themselves that they will lose/gain their mainView status.
+
+    Note that this method does not actually change the Pane's place in the
+    document body.  That will be handled by the Pane itself.
+
+    @param {SC.Pane} pane
+    @returns {SC.RootResponder} receiver
+  */
+  makeMainPane: function(pane) {
+    var currentMain = this.get('mainPane') ;
+    if (currentMain === pane) return this ; // nothing to do
+
+    this.beginPropertyChanges() ;
+
+    // change key focus if needed.
+    if (this.get('keyPane') === currentMain) this.makeKeyPane(pane) ;
+
+    // change setting
+    this.set('mainPane', pane) ;
+
+    // notify panes.  This will allow them to remove themselves.
+    if (currentMain) currentMain.blurMainTo(pane) ;
+    if (pane) pane.focusMainFrom(currentMain) ;
+
+    this.endPropertyChanges() ;
+    return this ;
+  },
+
+  // ..........................................................
+  // MENU PANE
+  //
+
+  /**
+    The current menu pane. This pane receives keyboard events before all other
+    panes, but tends to be transient, as it is only set when a pane is open.
+
+    @type SC.MenuPane
+  */
+  menuPane: null,
+
+  /**
+    Sets a pane as the menu pane. All key events will be directed to this
+    pane, but the current key pane will not lose focus.
+
+    Usually you would not call this method directly, but allow instances of
+    SC.MenuPane to manage the menu pane for you. If your pane does need to
+    become menu pane, you should relinquish control by calling this method
+    with a null parameter. Otherwise, key events will always be delivered to
+    that pane.
+
+    @param {SC.MenuPane} pane
+    @returns {SC.RootResponder} receiver
+  */
+  makeMenuPane: function(pane) {
+    // Does the specified pane accept being the menu pane?  If not, there's
+    // nothing to do.
+    if (pane  &&  !pane.get('acceptsMenuPane')) {
+      return this;
+    } else {
+      var currentMenu = this.get('menuPane');
+      if (currentMenu === pane) return this; // nothing to do
+
+      this.set('menuPane', pane);
+    }
+
+    return this;
+  },
+
+  // .......................................................
+  // KEY PANE
+  //
+
+  /**
+    The current key pane. This pane receives keyboard events, shortcuts, and
+    actions first, unless a menu is open. This pane is usually the highest
+    ordered pane or the mainPane.
+
+    @type SC.Pane
+  */
+  keyPane: null,
+
+  /** @property
+    A stack of the previous key panes.
+
+    *IMPORTANT: Property is not observable*
+  */
+  previousKeyPanes: [],
+
+  /**
+    Makes the passed pane the new key pane.  If you pass null or if the pane
+    does not accept key focus, then key focus will transfer to the previous
+    key pane (if it is still attached), and so on down the stack.  This will
+    notify both the old pane and the new root View that key focus has changed.
+
+    @param {SC.Pane} pane
+    @returns {SC.RootResponder} receiver
+  */
+  makeKeyPane: function(pane) {
+    // Was a pane specified?
+    var newKeyPane, previousKeyPane, previousKeyPanes ;
+
+    if (pane) {
+      // Does the specified pane accept being the key pane?  If not, there's
+      // nothing to do.
+      if (!pane.get('acceptsKeyPane')) {
+        return this ;
+      }
+      else {
+        // It does accept key pane status?  Then push the current keyPane to
+        // the top of the stack and make the specified pane the new keyPane.
+        // First, though, do a sanity-check to make sure it's not already the
+        // key pane, in which case we have nothing to do.
+        previousKeyPane = this.get('keyPane') ;
+        if (previousKeyPane === pane) {
+          return this ;
+        }
+        else {
+          if (previousKeyPane) {
+            previousKeyPanes = this.get('previousKeyPanes') ;
+            previousKeyPanes.push(previousKeyPane) ;
+          }
+
+          newKeyPane = pane ;
+        }
+      }
+    }
+    else {
+      // No pane was specified?  Then pop the previous key pane off the top of
+      // the stack and make it the new key pane, assuming that it's still
+      // attached and accepts key pane (its value for acceptsKeyPane might
+      // have changed in the meantime).  Otherwise, we'll keep going up the
+      // stack.
+      previousKeyPane = this.get('keyPane') ;
+      previousKeyPanes = this.get('previousKeyPanes') ;
+
+      newKeyPane = null ;
+      while (previousKeyPanes.length > 0) {
+        var candidate = previousKeyPanes.pop();
+        if (candidate.get('isPaneAttached')  &&  candidate.get('acceptsKeyPane')) {
+          newKeyPane = candidate ;
+          break ;
+        }
+      }
+    }
+
+
+    // If we found an appropriate candidate, make it the new key pane.
+    // Otherwise, make the main pane the key pane (if it accepts it).
+    if (!newKeyPane) {
+      var mainPane = this.get('mainPane') ;
+      if (mainPane && mainPane.get('acceptsKeyPane')) newKeyPane = mainPane ;
+    }
+
+    // now notify old and new key views of change after edit
+    if (previousKeyPane) previousKeyPane.willLoseKeyPaneTo(newKeyPane) ;
+    if (newKeyPane) newKeyPane.willBecomeKeyPaneFrom(previousKeyPane) ;
+
+    this.set('keyPane', newKeyPane) ;
+
+    if (newKeyPane) newKeyPane.didBecomeKeyPaneFrom(previousKeyPane) ;
+    if (previousKeyPane) previousKeyPane.didLoseKeyPaneTo(newKeyPane) ;
+
+    return this ;
+  },
+
+  // ..........................................................
+  // VIEWPORT STATE
+  //
+
+  /**
+    The last known window size.
+    @type Rect
+    @isReadOnly
+  */
+  currentWindowSize: null,
+
+  /**
+    Computes the window size from the DOM.
+
+    @returns Rect
+  */
+    computeWindowSize: function() {
+      var size, bod, docElement;
+      if(!this._bod || !this._docElement){
+        bod = document.body;
+        docElement = document.documentElement;
+        this._bod=bod;
+        this._docElement=docElement;
+      }else{
+        bod = this._bod;
+        docElement = this._docElement;
+      }
+      if (window.innerHeight) {
+        size = {
+          width: window.innerWidth,
+          height: window.innerHeight
+        } ;
+      } else if (docElement && docElement.clientHeight) {
+        size = {
+          width: docElement.clientWidth,
+          height: docElement.clientHeight
+        };
+      } else if (bod) {
+        size = {
+          width: bod.clientWidth,
+          height: bod.clientHeight
+        } ;
+      }
+      return size;
+    },
+
+  /**
+    On window resize, notifies panes of the change.
+
+    @returns {Boolean}
+  */
+  resize: function() {
+    this._resize();
+    //this.invokeLater(this._resize, 10);
+    return YES; //always allow normal processing to continue.
+  },
+
+  _resize: function() {
+    // calculate new window size...
+    var newSize = this.computeWindowSize(), oldSize = this.get('currentWindowSize');
+    this.set('currentWindowSize', newSize); // update size
+
+    if (!SC.rectsEqual(newSize, oldSize)) {
+      //Notify orientation change. This is faster than waiting for the orientation
+      //change event.
+      SC.device.windowSizeDidChange(newSize);
+
+      // notify panes
+      if (this.panes) {
+        SC.run(function() {
+          this.panes.invoke('windowSizeDidChange', oldSize, newSize) ;
+        }, this);
+      }
+    }
+  },
+
+  /**
+    Indicates whether or not the window currently has focus.  If you need
+    to do something based on whether or not the window is in focus, you can
+    setup a binding or observer to this property.  Note that the SproutCore
+    automatically adds an sc-focus or sc-blur CSS class to the body tag as
+    appropriate.  If you only care about changing the appearance of your
+    controls, you should use those classes in your CSS rules instead.
+  */
+  hasFocus: NO,
+
+  /**
+    Handle window focus.  Change hasFocus and add sc-focus CSS class
+    (removing sc-blur).  Also notify panes.
+  */
+  focus: function() {
+    if (!this.get('hasFocus')) {
+      SC.$('body').addClass('sc-focus').removeClass('sc-blur');
+
+      SC.run(function() {
+        this.set('hasFocus', YES);
+      }, this);
+    }
+    return YES ; // allow default
+  },
+
+  /**
+    Handle window focus event for IE. Listening to the focus event is not
+    reliable as per every focus event you receive you inmediately get a blur
+    event (Only on IE of course ;)
+  */
+  focusin: function() {
+    this.focus();
+  },
+
+  /**
+    Handle window blur event for IE. Listening to the focus event is not
+    reliable as per every focus event you receive you inmediately get a blur
+    event (Only on IE of course ;)
+  */
+  focusout: function() {
+    this.blur();
+  },
+
+
+  /**
+    Handle window focus.  Change hasFocus and add sc-focus CSS class (removing
+    sc-blur).  Also notify panes.
+  */
+  blur: function() {
+    if (this.get('hasFocus')) {
+      SC.$('body').addClass('sc-blur').removeClass('sc-focus');
+
+      SC.run(function() {
+        this.set('hasFocus', NO);
+      }, this);
+    }
+    return YES ; // allow default
+  },
+
+  dragDidStart: function(drag) {
+    this._mouseDownView = drag ;
+    this._drag = drag ;
+  },
+
+  // .......................................................
+  // ACTIONS
+  //
+
+  /**
+    Set this to a delegate object that can respond to actions as they are sent
+    down the responder chain.
+
+    @type SC.Object
+  */
+  defaultResponder: null,
+
+  /**
+    Route an action message to the appropriate responder.  This method will
+    walk the responder chain, attempting to find a responder that implements
+    the action name you pass to this method.  Set 'target' to null to search
+    the responder chain.
+
+    IMPORTANT: This method's API and implementation will likely change
+    significantly after SproutCore 1.0 to match the version found in
+    SC.ResponderContext.
+
+    You generally should not call or override this method in your own
+    applications.
+
+    @param {String} action The action to perform - this is a method name.
+    @param {SC.Responder} target object to set method to (can be null)
+    @param {Object} sender The sender of the action
+    @param {SC.Pane} pane optional pane to start search with
+    @param {Object} context optional. only passed to ResponderContexts
+    @returns {Boolean} YES if action was performed, NO otherwise
+    @test in targetForAction
+  */
+  sendAction: function( action, target, sender, pane, context, firstResponder) {
+    target = this.targetForAction(action, target, sender, pane, firstResponder) ;
+
+    // HACK: If the target is a ResponderContext, forward the action.
+    if (target && target.isResponderContext) {
+      return !!target.sendAction(action, sender, context, firstResponder);
+    } else return target && target.tryToPerform(action, sender);
+  },
+
+  _responderFor: function(target, methodName, firstResponder) {
+    var defaultResponder = target ? target.get('defaultResponder') : null;
+
+    if (target) {
+      target = firstResponder || target.get('firstResponder') || target;
+      do {
+        if (target.respondsTo(methodName)) return target ;
+      } while ((target = target.get('nextResponder'))) ;
+    }
+
+    // HACK: Eventually we need to normalize the sendAction() method between
+    // this and the ResponderContext, but for the moment just look for a
+    // ResponderContext as the defaultResponder and return it if present.
+    if (typeof defaultResponder === SC.T_STRING) {
+      defaultResponder = SC.objectForPropertyPath(defaultResponder);
+    }
+
+    if (!defaultResponder) return null;
+    else if (defaultResponder.isResponderContext) return defaultResponder;
+    else if (defaultResponder.respondsTo(methodName)) return defaultResponder;
+    else return null;
+  },
+
+  /**
+    Attempts to determine the initial target for a given action/target/sender
+    tuple.  This is the method used by sendAction() to try to determine the
+    correct target starting point for an action before trickling up the
+    responder chain.
+
+    You send actions for user interface events and for menu actions.
+
+    This method returns an object if a starting target was found or null if no
+    object could be found that responds to the target action.
+
+    Passing an explicit target or pane constrains the target lookup to just
+    them; the defaultResponder and other panes are *not* searched.
+
+    @param {Object|String} target or null if no target is specified
+    @param {String} method name for target
+    @param {Object} sender optional sender
+    @param {SC.Pane} optional pane
+    @param {firstResponder} a first responder to use
+    @returns {Object} target object or null if none found
+  */
+  targetForAction: function(methodName, target, sender, pane, firstResponder) {
+
+    // 1. no action, no target...
+    if (!methodName || (SC.typeOf(methodName) !== SC.T_STRING)) {
+      return null ;
+    }
+
+    // 2. an explicit target was passed...
+    if (target) {
+      if (SC.typeOf(target) === SC.T_STRING) {
+        target =  SC.objectForPropertyPath(target) ||
+                  SC.objectForPropertyPath(target, sender);
+      }
+
+      if (target && !target.isResponderContext) {
+        if (target.respondsTo && !target.respondsTo(methodName)) {
+          target = null ;
+        } else if (SC.typeOf(target[methodName]) !== SC.T_FUNCTION) {
+          target = null ;
+        }
+      }
+
+      return target ;
+    }
+
+    // 3. an explicit pane was passed...
+    if (pane) {
+      target = this._responderFor(pane, methodName, firstResponder);
+      if (target) return target;
+    }
+
+    // 4. no target or pane passed... try to find target in the active panes
+    // and the defaultResponder
+    var keyPane = this.get('keyPane'), mainPane = this.get('mainPane') ;
+
+    // ...check key and main panes first
+    if (keyPane && (keyPane !== pane)) {
+      target = this._responderFor(keyPane, methodName) ;
+    }
+    if (!target && mainPane && (mainPane !== keyPane)) {
+      target = this._responderFor(mainPane, methodName) ;
+    }
+
+    // ...still no target? check the defaultResponder...
+    if (!target && (target = this.get('defaultResponder'))) {
+      if (SC.typeOf(target) === SC.T_STRING) {
+        target = SC.objectForPropertyPath(target) ;
+        if (target) this.set('defaultResponder', target) ; // cache if found
+      }
+      if (target && !target.isResponderContext) {
+        if (target.respondsTo && !target.respondsTo(methodName)) {
+          target = null ;
+        } else if (SC.typeOf(target[methodName]) !== SC.T_FUNCTION) {
+          target = null ;
+        }
+      }
+    }
+
+    return target ;
+  },
+
+  /**
+    Finds the view that appears to be targeted by the passed event.  This only
+    works on events with a valid target property.
+
+    @param {SC.Event} evt
+    @returns {SC.View} view instance or null
+  */
+  targetViewForEvent: function(evt) {
+    return evt.target ? SC.$(evt.target).view()[0] : null ;
+  },
+
+  /**
+    Attempts to send an event down the responder chain.  This method will
+    invoke the sendEvent() method on either the keyPane or on the pane owning
+    the target view you pass in.  It will also automatically begin and end
+    a new run loop.
+
+    If you want to trap additional events, you should use this method to
+    send the event down the responder chain.
+
+    @param {String} action
+    @param {SC.Event} evt
+    @param {Object} target
+    @returns {Object} object that handled the event or null if not handled
+  */
+  sendEvent: function(action, evt, target) {
+    var pane, ret ;
+
+    SC.run(function() {
+      // get the target pane
+      if (target) pane = target.get('pane') ;
+      else pane = this.get('menuPane') || this.get('keyPane') || this.get('mainPane') ;
+
+      // if we found a valid pane, send the event to it
+      ret = (pane) ? pane.sendEvent(action, evt, target) : null ;
+    }, this);
+
+    return ret ;
+  },
+
+  // .......................................................
+  // EVENT LISTENER SETUP
+  //
+
+  /**
+    Default method to add an event listener for the named event.  If you simply
+    need to add listeners for a type of event, you can use this method as
+    shorthand.  Pass an array of event types to listen for and the element to
+    listen in.  A listener will only be added if a handler is actually installed
+    on the RootResponder (or receiver) of the same name.
+
+    @param {Array} keyNames
+    @param {Element} target
+    @param {Object} receiver - optional if you don't want 'this'
+    @param {Boolean} useCapture
+    @returns {SC.RootResponder} receiver
+  */
+  listenFor: function(keyNames, target, receiver, useCapture) {
+    receiver = receiver ? receiver : this;
+    keyNames.forEach( function(keyName) {
+      var method = receiver[keyName] ;
+      if (method) SC.Event.add(target, keyName, receiver, method, null, useCapture) ;
+    },this) ;
+    target = null ;
+    return receiver ;
+  },
+
+  /**
+    Called when the document is ready to begin handling events.  Setup event
+    listeners in this method that you are interested in observing for your
+    particular platform.  Be sure to call sc_super().
+
+    @returns {void}
+  */
+  setup: function() {
+    // handle touch events
+    this.listenFor('touchstart touchmove touchend touchcancel'.w(), document);
+
+    // handle basic events
+    this.listenFor('keydown keyup beforedeactivate mousedown mouseup click dblclick mousemove selectstart contextmenu'.w(), document)
+        .listenFor('resize'.w(), window);
+
+    if(SC.browser.msie) this.listenFor('focusin focusout'.w(), document);
+    else this.listenFor('focus blur'.w(), window);
+
+    // handle animation events
+    this.listenFor('webkitAnimationStart webkitAnimationIteration webkitAnimationEnd'.w(), document);
+
+    // CSS Transitions
+    if (SC.platform.supportsCSSTransitions) {
+      this.listenFor(['transitionEnd', SC.platform.cssPrefix+'TransitionEnd'], document);
+    }
+
+    // handle special case for keypress- you can't use normal listener to block the backspace key on Mozilla
+    if (this.keypress) {
+      if (SC.CAPTURE_BACKSPACE_KEY && SC.browser.mozilla) {
+        var responder = this ;
+        document.onkeypress = function(e) {
+          e = SC.Event.normalizeEvent(e);
+          return responder.keypress.call(responder, e);
+        };
+
+        // SC.Event.add(window, 'unload', this, function() { document.onkeypress = null; }); // be sure to cleanup memory leaks
+
+      // Otherwise, just add a normal event handler.
+      } else SC.Event.add(document, 'keypress', this, this.keypress);
+    }
+
+    // handle these two events specially in IE
+    'drag selectstart'.w().forEach(function(keyName) {
+      var method = this[keyName] ;
+      if (method) {
+        if (SC.browser.msie) {
+          var responder = this ;
+          document.body['on' + keyName] = function(e) {
+            // return method.call(responder, SC.Event.normalizeEvent(e));
+            return method.call(responder, SC.Event.normalizeEvent(event || window.event)); // this is IE :(
+          };
+
+          // be sure to cleanup memory leaks
+           SC.Event.add(window, 'unload', this, function() {
+            document.body['on' + keyName] = null;
+          });
+
+        } else {
+          SC.Event.add(document, keyName, this, method);
+        }
+      }
+    }, this);
+
+    var mousewheel = 'mousewheel';
+
+    // Firefox emits different mousewheel events than other browsers
+    if (SC.browser.mozilla) {
+      // For Firefox <3.5, subscribe to DOMMouseScroll events
+      if (SC.browser.compareVersion(1,9,1) < 0) {
+        mousewheel = 'DOMMouseScroll';
+
+      // For Firefox 3.5 and greater, we can listen for MozMousePixelScroll,
+      // which supports pixel-precision scrolling devices, like MacBook
+      // trackpads.
+      } else {
+        mousewheel = 'MozMousePixelScroll';
+      }
+    }
+    SC.Event.add(document, mousewheel, this, this.mousewheel);
+
+    // If the browser is identifying itself as a touch-enabled browser, but
+    // touch events are not present, assume this is a desktop browser doing
+    // user agent spoofing and simulate touch events automatically.
+    if (SC.browser && SC.platform && SC.browser.mobileSafari && !SC.platform.touch) {
+      SC.platform.simulateTouchEvents();
+    }
+
+    // do some initial set
+    this.set('currentWindowSize', this.computeWindowSize()) ;
+    this.focus(); // assume the window is focused when you load.
+
+    if (SC.browser.mobileSafari) {
+      // Monkey patch RunLoop if we're in MobileSafari
+      var f = SC.RunLoop.prototype.endRunLoop, patch;
+
+      patch = function() {
+        // Call original endRunLoop implementation.
+        if (f) f.apply(this, arguments);
+
+        // This is a workaround for a bug in MobileSafari.
+        // Specifically, if the target of a touchstart event is removed from the DOM,
+        // you will not receive future touchmove or touchend events. What we do is, at the
+        // end of every runloop, check to see if the target of any touches has been removed
+        // from the DOM. If so, we re-append it to the DOM and hide it. We then mark the target
+        // as having been moved, and it is de-allocated in the corresponding touchend event.
+        var touches = SC.RootResponder.responder._touches, touch, elem, target, textNode, view, found = NO;
+        if (touches) {
+          // Iterate through the touches we're currently tracking
+          for (touch in touches) {
+            if (touches[touch]._rescuedElement) continue; // only do once
+
+            target = elem = touches[touch].target;
+
+            // Travel up the hierarchy looking for the document body
+            while (elem && (elem = elem.parentNode) && !found) {
+              found = (elem === document.body);
+            }
+
+            // If we aren't part of the body, move the element back
+            // but make sure we hide it from display.
+            if (!found && target) {
+
+              // Actually clone this node and replace it in the original
+              // layer if needed
+              if (target.parentNode && target.cloneNode) {
+                var clone = target.cloneNode(true);
+                target.parentNode.replaceChild(clone, target);
+                target.swapNode = clone; // save for restore later
+              }
+
+              // Create a holding pen if needed for these views...
+              var pen = SC.touchHoldingPen;
+              if (!pen) {
+                pen = SC.touchHoldingPen = document.createElement('div');
+                pen.style.display = 'none';
+                document.body.appendChild(pen);
+              }
+
+              // move element back into document...
+              pen.appendChild(target);
+
+              // // In MobileSafari, our target can sometimes
+              // // be a text node, so make sure we handle that case.
+              // textNode = (target.nodeType === 3);
+              //
+              // if (textNode && target.parentElement) {
+              //   // Hide the text node's parent element if it has one
+              //   target = target.parentElement;
+              //   target.style.display = 'none';
+              // } else if (textNode) {
+              //   // We have a text node with no containing element,
+              //   // so just erase its text content.
+              //   target.nodeValue = '';
+              // } else {
+              //   // Standard Element, just toggle its display off.
+              //   target.style.display = 'none';
+              // }
+              //
+              // // Now move the captured and hidden element back to the DOM.
+              // document.body.appendChild(target);
+
+              // ...and save the element to be garbage collected on
+              // touchEnd.
+              touches[touch]._rescuedElement = target;
+            }
+          }
+        }
+      };
+      SC.RunLoop.prototype.endRunLoop = patch;
+    }
+  },
+
+  // ................................................................................
+  // TOUCH SUPPORT
+  //
+  /*
+    This touch support is written to meet the following specifications. They are actually
+    simple, but I decided to write out in great detail all of the rules so there would
+    be no confusion.
+
+    There are three events: touchStart, touchEnd, touchDragged. touchStart and End are called
+    individually for each touch. touchDragged events are sent to whatever view owns the touch
+    event
+  */
+
+  /**
+    @private
+    A map from views to internal touch entries.
+
+    Note: the touch entries themselves also reference the views.
+  */
+  _touchedViews: {},
+
+  /**
+    @private
+    A map from internal touch ids to the touch entries themselves.
+
+    The touch entry ids currently come from the touch event's identifier.
+  */
+  _touches: {},
+
+  /**
+    Returns the touches that are registered to the specified view or responder; undefined if none.
+
+    When views receive a touch event, they have the option to subscribe to it.
+    They are then mapped to touch events and vice-versa. This returns touches mapped to the view.
+  */
+  touchesForView: function(view) {
+    if (this._touchedViews[SC.guidFor(view)]) {
+      return this._touchedViews[SC.guidFor(view)].touches;
+    }
+  },
+
+  /**
+    Computes a hash with x, y, and d (distance) properties, containing the average position
+    of all touches, and the average distance of all touches from that average.
+
+    This is useful for implementing scaling.
+  */
+  averagedTouchesForView: function(view, added) {
+    var t = this.touchesForView(view),
+
+    // cache per view to avoid gc
+    averaged = view._scrr_averagedTouches || (view._scrr_averagedTouches = {});
+
+    if ((!t || t.length === 0) && !added) {
+      averaged.x = 0;
+      averaged.y = 0;
+      averaged.d = 0;
+      averaged.touchCount = 0;
+
+    } else {
+      // make array of touches using cached array
+      var touches = this._averagedTouches_touches || (this._averagedTouches_touches = []);
+      touches.length = 0;
+
+      // copy touches into array
+      if (t) {
+        var i, len = t.length;
+        for(i = 0; i < len; i++) {
+          touches.push(t[i]);
+        }
+      }
+
+      // add added if needed
+      if (added) touches.push(added);
+
+      // prepare variables for looping
+      var idx, touch,
+          ax = 0, ay = 0, dx, dy, ad = 0;
+      len = touches.length;
+
+      // first, add
+      for (idx = 0; idx < len; idx++) {
+        touch = touches[idx];
+        ax += touch.pageX; ay += touch.pageY;
+      }
+
+      // now, average
+      ax /= len;
+      ay /= len;
+
+      // distance
+      for (idx = 0; idx < len; idx++) {
+        touch = touches[idx];
+
+        // get distance from average
+        dx = Math.abs(touch.pageX - ax);
+        dy = Math.abs(touch.pageY - ay);
+
+        // Pythagoras was clever...
+        ad += Math.pow(dx * dx + dy * dy, 0.5);
+      }
+
+      // average
+      ad /= len;
+
+      averaged.x = ax;
+      averaged.y = ay;
+      averaged.d = ad;
+      averaged.touchCount = len;
+    }
+
+    return averaged;
+  },
+
+  assignTouch: function(touch, view) {
+    // sanity-check
+    if (touch.hasEnded) throw "Attemt to assign a touch that is already finished.";
+
+    // unassign from old view if necessary
+    if (touch.view === view) return;
+    if (touch.view) {
+      this.unassignTouch(touch);
+    }
+
+    // create view entry if needed
+    if (!this._touchedViews[SC.guidFor(view)]) {
+      this._touchedViews[SC.guidFor(view)] = {
+        view: view,
+        touches: SC.CoreSet.create([]),
+        touchCount: 0
+      };
+      view.set("hasTouch", YES);
+    }
+
+    // add touch
+    touch.view = view;
+    this._touchedViews[SC.guidFor(view)].touches.add(touch);
+    this._touchedViews[SC.guidFor(view)].touchCount++;
+  },
+
+  unassignTouch: function(touch) {
+    // find view entry
+    var view, viewEntry;
+
+    // get view
+    if (!touch.view) return; // touch.view should===touch.touchResponder eventually :)
+    view = touch.view;
+
+    // get view entry
+    viewEntry = this._touchedViews[SC.guidFor(view)];
+    viewEntry.touches.remove(touch);
+    viewEntry.touchCount--;
+
+    // remove view entry if needed
+    if (viewEntry.touchCount < 1) {
+      view.set("hasTouch", NO);
+      viewEntry.view = null;
+      delete this._touchedViews[SC.guidFor(view)];
+    }
+
+    // clear view
+    touch.view = undefined;
+  },
+
+  _flushQueuedTouchResponder: function(){
+    if (this._queuedTouchResponder) {
+      var queued = this._queuedTouchResponder;
+      this._queuedTouchResponder = null;
+      this.makeTouchResponder.apply(this, queued);
+    }
+  },
+
+  /**
+    The touch responder for any given touch is the view which will receive touch events
+    for that touch. Quite simple.
+
+    makeTouchResponder takes a potential responder as an argument, and, by calling touchStart on each
+    nextResponder, finds the actual responder. As a side-effect of how it does this, touchStart is called
+    on the new responder before touchCancelled is called on the old one (touchStart has to accept the touch
+    before it can be considered cancelled).
+
+    You usually don't have to think about this at all. However, if you don't want your view to,
+    for instance, prevent scrolling in a ScrollView, you need to make sure to transfer control
+    back to the previous responder:
+
+    if (Math.abs(touch.pageY - touch.startY) > this.MAX_SWIPE) touch.restoreLastTouchResponder();
+
+    You don't call makeTouchResponder on RootResponder directly. Instead, it gets called for you
+    when you return YES to captureTouch or touchStart.
+
+    You do, however, use a form of makeTouchResponder to return to a previous touch responder. Consider
+    a button view inside a ScrollView: if the touch moves too much, the button should give control back
+    to the scroll view.
+
+    if (Math.abs(touch.pageX - touch.startX) > 4) {
+      if (touch.nextTouchResponder) touch.makeTouchResponder(touch.nextTouchResponder);
+    }
+
+    This will give control back to the containing view. Maybe you only want to do it if it is a ScrollView?
+
+    if (Math.abs(touch.pageX - touch.startX) > 4 && touch.nextTouchResponder && touch.nextTouchResponder.isScrollable)
+      touch.makeTouchResponder(touch.nextTouchResponder);
+
+    Possible gotcha: while you can do touch.nextTouchResponder, the responders are not chained in a linked list like
+    normal responders, because each touch has its own responder stack. To navigate through the stack (or, though
+    it is not recommended, change it), use touch.touchResponders (the raw stack array).
+
+    makeTouchResponder is called with an event object. However, it usually triggers custom touchStart/touchCancelled
+    events on the views. The event object is passed so that functions such as stopPropagation may be called.
+  */
+  makeTouchResponder: function(touch, responder, shouldStack, upViewChain) {
+
+    // In certain cases (SC.Gesture being one), we have to call makeTouchResponder
+    // from inside makeTouchResponder so we queue it up here.
+    if (this._isMakingTouchResponder) {
+      this._queuedTouchResponder = [touch, responder, shouldStack, upViewChain];
+      return;
+    }
+    this._isMakingTouchResponder = YES;
+
+
+    var stack = touch.touchResponders, touchesForView;
+
+    // find the actual responder (if any, I suppose)
+    // note that the pane's sendEvent function is slightly clever:
+    // if the target is already touch responder, it will just return it without calling touchStart
+    // we must do the same.
+    if (touch.touchResponder === responder) {
+      this._isMakingTouchResponder = NO;
+      this._flushQueuedTouchResponder();
+      return;
+    }
+
+    // send touchStart
+    // get the target pane
+    var pane;
+    if (responder) pane = responder.get('pane') ;
+    else pane = this.get('keyPane') || this.get('mainPane') ;
+
+    // if the responder is not already in the stack...
+
+    if (stack.indexOf(responder) < 0) {
+      // if we need to go up the view chain, do so
+      if (upViewChain) {
+        // if we found a valid pane, send the event to it
+        try {
+          responder = (pane) ? pane.sendEvent("touchStart", touch, responder) : null ;
+        } catch (e) {
+          SC.Logger.error("Error in touchStart: " + e);
+          responder = null;
+        }
+      } else {
+
+        if ((responder.get ? responder.get("acceptsMultitouch") : responder.acceptsMultitouch) || !responder.hasTouch) {
+          if (!responder.touchStart(touch)) responder = null;
+        } else {
+          // do nothing; the responder is the responder, and may stay the responder, and all will be fine
+        }
+      }
+    }
+
+    // if the item is in the stack, we will go to it (whether shouldStack is true or not)
+    // as it is already stacked
+    if (!shouldStack || (stack.indexOf(responder) > -1 && stack[stack.length - 1] !== responder)) {
+      // first, we should unassign the touch. Note that we only do this IF WE ARE removing
+      // the current touch responder. Otherwise we cause all sorts of headaches; why? Because,
+      // if we are not (suppose, for instance, that it is stacked), then the touch does not
+      // get passed back to the touch responder-- even while it continues to get events because
+      // the touchResponder is still set!
+      this.unassignTouch(touch);
+
+      // pop all other items
+      var idx = stack.length - 1, last = stack[idx];
+      while (last && last !== responder) {
+        // unassign the touch
+        touchesForView = this.touchesForView(last); // won't even exist if there are no touches
+
+        // send touchCancelled (or, don't, if the view doesn't accept multitouch and it is not the last touch)
+        if ((last.get ? last.get("acceptsMultitouch") : last.acceptsMultitouch) || !touchesForView) {
+          if (last.touchCancelled) last.touchCancelled(touch);
+        }
+
+        // go to next (if < 0, it will be undefined, so lovely)
+        idx--;
+        last = stack[idx];
+
+        // update responders (for consistency)
+        stack.pop();
+
+        touch.touchResponder = stack[idx];
+        touch.nextTouchResponder = stack[idx - 1];
+      }
+
+    }
+
+    // now that we've popped off, we can push on
+    if (responder) {
+      this.assignTouch(touch, responder);
+
+      // keep in mind, it could be one we popped off _to_ above...
+      if (responder !== touch.touchResponder) {
+        stack.push(responder);
+
+        // update responder helpers
+        touch.touchResponder = responder;
+        touch.nextTouchResponder = stack[stack.length - 2];
+      }
+    }
+
+
+    this._isMakingTouchResponder = NO;
+    this._flushQueuedTouchResponder();
+
+  },
+
+  /**
+    captureTouch is used to find the view to handle a touch. It starts at the starting point and works down
+    to the touch's target, looking for a view which captures the touch. If no view is found, it uses the target
+    view.
+
+    Then, it triggers a touchStart event starting at whatever the found view was; this propagates up the view chain
+    until a view responds YES. This view becomes the touch's owner.
+
+    You usually do not call captureTouch, and if you do call it, you'd call it on the touch itself:
+    touch.captureTouch(startingPoint, shouldStack)
+
+    If shouldStack is YES, the previous responder will be kept so that it may be returned to later.
+  */
+  captureTouch: function(touch, startingPoint, shouldStack) {
+    if (!startingPoint) startingPoint = this;
+
+    var target = touch.targetView, view = target,
+        chain = [], idx, len;
+
+    if (SC.LOG_TOUCH_EVENTS) {
+      SC.Logger.info('  -- Received one touch on %@'.fmt(target.toString()));
+    }
+    // work up the chain until we get the root
+    while (view && (view !== startingPoint)) {
+      chain.unshift(view);
+      view = view.get('nextResponder');
+    }
+
+    // work down the chain
+    for (len = chain.length, idx = 0; idx < len; idx++) {
+      view = chain[idx];
+      if (SC.LOG_TOUCH_EVENTS) SC.Logger.info('  -- Checking %@ for captureTouch response…'.fmt(view.toString()));
+
+      // see if it captured the touch
+      if (view.tryToPerform('captureTouch', touch)) {
+        if (SC.LOG_TOUCH_EVENTS) SC.Logger.info('   -- Making %@ touch responder because it returns YES to captureTouch'.fmt(view.toString()));
+
+        // if so, make it the touch's responder
+        this.makeTouchResponder(touch, view, shouldStack, YES); // triggers touchStart/Cancel/etc. event.
+        return; // and that's all we need
+      }
+    }
+
+    if (SC.LOG_TOUCH_EVENTS) SC.Logger.info("   -- Didn't find a view that returned YES to captureTouch, so we're calling touchStart");
+    // if we did not capture the touch (obviously we didn't)
+    // we need to figure out what view _will_
+    // Thankfully, makeTouchResponder does exactly that: starts at the view it is supplied and keeps calling startTouch
+    this.makeTouchResponder(touch, target, shouldStack, YES);
+  },
+
+  /** @private
+    Artificially calls endTouch for any touch which is no longer present. This is necessary because
+    _sometimes_, WebKit ends up not sending endtouch.
+  */
+  endMissingTouches: function(presentTouches) {
+    var idx, len = presentTouches.length, map = {}, end = [];
+
+    // make a map of what touches _are_ present
+    for (idx = 0; idx < len; idx++) {
+      map[presentTouches[idx].identifier] = YES;
+    }
+
+    // check if any of the touches we have recorded are NOT present
+    for (idx in this._touches) {
+      var id = this._touches[idx].identifier;
+      if (!map[id]) end.push(this._touches[idx]);
+    }
+
+    // end said touches
+    for (idx = 0, len = end.length; idx < len; idx++) {
+      this.endTouch(end[idx]);
+      this.finishTouch(end[idx]);
+    }
+  },
+
+  _touchCount: 0,
+  /** @private
+    Ends a specific touch (for a bit, at least). This does not "finish" a touch; it merely calls
+    touchEnd, touchCancelled, etc. A re-dispatch (through recapture or makeTouchResponder) will terminate
+    the process; it would have to be restarted separately, through touch.end().
+  */
+  endTouch: function(touchEntry, action, evt) {
+    if (!action) { action = "touchEnd"; }
+
+    var responderIdx, responders, responder, originalResponder;
+
+    // unassign
+    this.unassignTouch(touchEntry);
+
+    // call end for all items in chain
+    if (touchEntry.touchResponder) {
+      originalResponder = touchEntry.touchResponder;
+
+      responders = touchEntry.touchResponders;
+      responderIdx = responders.length - 1;
+      responder = responders[responderIdx];
+      while (responder) {
+        if (responder[action]) { responder[action](touchEntry, evt); }
+
+        // check to see if the responder changed, and stop immediately if so.
+        if (touchEntry.touchResponder !== originalResponder) { break; }
+
+        // next
+        responderIdx--;
+        responder = responders[responderIdx];
+        action = "touchCancelled"; // any further ones receive cancelled
+      }
+    }
+  },
+
+  /**
+    @private
+    "Finishes" a touch. That is, it eradicates it from our touch entries and removes all responder, etc. properties.
+  */
+  finishTouch: function(touch) {
+    var elem;
+
+    // ensure the touch is indeed unassigned.
+    this.unassignTouch(touch);
+
+    // If we rescued this touch's initial element, we should remove it
+    // from the DOM and garbage collect now. See setup() for an
+    // explanation of this bug/workaround.
+    if (elem = touch._rescuedElement) {
+      if (elem.swapNode && elem.swapNode.parentNode) {
+        elem.swapNode.parentNode.replaceChild(elem, elem.swapNode);
+      } else if (elem.parentNode === SC.touchHoldingPen) {
+        SC.touchHoldingPen.removeChild(elem);
+      }
+      delete touch._rescuedElement;
+      elem.swapNode = null;
+      elem = null;
+    }
+
+
+    // clear responders (just to be thorough)
+    touch.touchResponders = null;
+    touch.touchResponder = null;
+    touch.nextTouchResponder = null;
+    touch.hasEnded = YES;
+
+    // and remove from our set
+    if (this._touches[touch.identifier]) delete this._touches[touch.identifier];
+  },
+
+  /** @private
+    Called when the user touches their finger to the screen. This method
+    dispatches the touchstart event to the appropriate view.
+
+    We may receive a touchstart event for each touch, or we may receive a
+    single touchstart event with multiple touches, so we may have to dispatch
+    events to multiple views.
+
+    @param {Event} evt the event
+    @returns {Boolean}
+  */
+  touchstart: function(evt) {
+    var hidingTouchIntercept = NO;
+
+    SC.run(function() {
+      // sometimes WebKit is a bit... iffy:
+      this.endMissingTouches(evt.touches);
+
+      // as you were...
+      // loop through changed touches, calling touchStart, etc.
+      var idx, touches = evt.changedTouches, len = touches.length,
+          target, view, touch, touchEntry;
+
+      // prepare event for touch mapping.
+      evt.touchContext = this;
+
+      // Loop through each touch we received in this event
+      for (idx = 0; idx < len; idx++) {
+        touch = touches[idx];
+
+        // Create an SC.Touch instance for every touch.
+        touchEntry = SC.Touch.create(touch, this);
+
+        // skip the touch if there was no target
+        if (!touchEntry.targetView) continue;
+
+        // account for hidden touch intercept (passing through touches, etc.)
+        if (touchEntry.hidesTouchIntercept) hidingTouchIntercept = YES;
+
+        // set timestamp
+        touchEntry.timeStamp = evt.timeStamp;
+
+        // Store the SC.Touch object. We use the identifier property (provided
+        // by the browser) to disambiguate between touches. These will be used
+        // later to determine if the touches have changed.
+        this._touches[touch.identifier] = touchEntry;
+
+        // set the event (so default action, etc. can be stopped)
+        touchEntry.event = evt; // will be unset momentarily
+
+        // send out event thing: creates a chain, goes up it, then down it,
+        // with startTouch and cancelTouch. in this case, only startTouch, as
+        // there are no existing touch responders. We send the touchEntry
+        // because it is cached (we add the helpers only once)
+        this.captureTouch(touchEntry, this);
+
+        // Unset the reference to the original event so we can garbage collect.
+        touchEntry.event = null;
+      }
+    }, this);
+
+
+    // hack for text fields
+    if (hidingTouchIntercept) {
+      return YES;
+    }
+
+    return evt.hasCustomEventHandling;
+  },
+
+  /**
+    @private
+    used to keep track of when a specific type of touch event was last handled, to see if it needs to be re-handled
+  */
+  touchmove: function(evt) {
+    SC.run(function() {
+      // pretty much all we gotta do is update touches, and figure out which views need updating.
+      var touches = evt.changedTouches, touch, touchEntry,
+          idx, len = touches.length, view, changedTouches, viewTouches, firstTouch,
+          changedViews = {}, loc, guid, hidingTouchIntercept = NO;
+
+      if (this._drag) {
+        touch = SC.Touch.create(evt.changedTouches[0], this);
+        this._drag.tryToPerform('mouseDragged', touch);
+      }
+
+      // figure out what views had touches changed, and update our internal touch objects
+      for (idx = 0; idx < len; idx++) {
+        touch = touches[idx];
+
+        // get our touch
+        touchEntry = this._touches[touch.identifier];
+
+        // we may have no touch entry; this can happen if somehow the touch came to a non-SC area.
+        if (!touchEntry) {
+          continue;
+        }
+
+        if (touchEntry.hidesTouchIntercept) hidingTouchIntercept = YES;
+
+        // update touch
+        touchEntry.pageX = touch.pageX;
+        touchEntry.pageY = touch.pageY;
+        touchEntry.clientX = touch.clientX;
+        touchEntry.clientY = touch.clientY;
+        touchEntry.screenX = touch.screenX;
+        touchEntry.screenY = touch.screenY;
+        touchEntry.timeStamp = evt.timeStamp;
+        touchEntry.event = evt;
+
+        // if the touch entry has a view
+        if (touchEntry.touchResponder) {
+          view = touchEntry.touchResponder;
+
+          guid = SC.guidFor(view);
+          // create a view entry
+          if (!changedViews[guid]) changedViews[guid] = { "view": view, "touches": [] };
+
+          // add touch
+          changedViews[guid].touches.push(touchEntry);
+        }
+      }
+
+      // HACK: DISABLE OTHER TOUCH DRAGS WHILE MESSING WITH TEXT FIELDS
+      if (hidingTouchIntercept) {
+        evt.allowDefault();
+        return YES;
+      }
+
+      // loop through changed views and send events
+      for (idx in changedViews) {
+        // get info
+        view = changedViews[idx].view;
+        changedTouches = changedViews[idx].touches;
+
+        // prepare event; note that views often won't use this method anyway (they'll call touchesForView instead)
+        evt.viewChangedTouches = changedTouches;
+
+        // the first VIEW touch should be the touch info sent
+        viewTouches = this.touchesForView(view);
+        firstTouch = viewTouches.firstObject();
+        evt.pageX = firstTouch.pageX;
+        evt.pageY = firstTouch.pageY;
+        evt.clientX = firstTouch.clientX;
+        evt.clientY = firstTouch.clientY;
+        evt.screenX = firstTouch.screenX;
+        evt.screenY = firstTouch.screenY;
+        evt.touchContext = this; // so it can call touchesForView
+
+        // and go
+        view.tryToPerform("touchesDragged", evt, viewTouches);
+      }
+
+      // clear references to event
+      touches = evt.changedTouches;
+      len = touches.length;
+      for (idx = 0; idx < len; idx++) {
+        touch = touches[idx];
+        touchEntry = this._touches[touch.identifier];
+        if (touchEntry) touchEntry.event = null;
+      }
+    }, this);
+
+    return evt.hasCustomEventHandling;
+  },
+
+  touchend: function(evt) {
+    var hidesTouchIntercept = NO;
+
+    SC.run(function() {
+      var touches = evt.changedTouches, touch, touchEntry,
+          idx, len = touches.length,
+          view, elem,
+          action = evt.isCancel ? "touchCancelled" : "touchEnd", a,
+          responderIdx, responders, responder;
+
+      for (idx = 0; idx < len; idx++) {
+        //get touch+entry
+        touch = touches[idx];
+        touch.type = 'touchend';
+        touchEntry = this._touches[touch.identifier];
+
+        // check if there is an entry
+        if (!touchEntry) continue;
+
+        // continue work
+        touchEntry.timeStamp = evt.timeStamp;
+        touchEntry.pageX = touch.pageX;
+        touchEntry.pageY = touch.pageY;
+        touchEntry.clientX = touch.clientX;
+        touchEntry.clientY = touch.clientY;
+        touchEntry.screenX = touch.screenX;
+        touchEntry.screenY = touch.screenY;
+        touchEntry.type = 'touchend';
+        touchEntry.event = evt;
+
+        if (SC.LOG_TOUCH_EVENTS) SC.Logger.info('-- Received touch end');
+        if (touchEntry.hidesTouchIntercept) {
+          touchEntry.unhideTouchIntercept();
+          hidesTouchIntercept = YES;
+        }
+
+        if (this._drag) {
+          this._drag.tryToPerform('mouseUp', touch) ;
+          this._drag = null ;
+        }
+
+        // unassign
+        this.endTouch(touchEntry, action, evt);
+        this.finishTouch(touchEntry);
+      }
+    }, this);
+
+
+    // for text fields
+    if (hidesTouchIntercept) {
+      return YES;
+    }
+
+    return evt.hasCustomEventHandling;
+  },
+
+  /** @private
+    Handle touch cancel event.  Works just like cancelling a touch for any other reason.
+    touchend handles it as a special case (sending cancel instead of end if needed).
+  */
+  touchcancel: function(evt) {
+    evt.isCancel = YES;
+    this.touchend(evt);
+  },
+
+  // ..........................................................
+  // KEYBOARD HANDLING
+  //
+
+
+  /**
+    Invoked on a keyDown event that is not handled by any actual value.  This
+    will get the key equivalent string and then walk down the keyPane, then
+    the focusedPane, then the mainPane, looking for someone to handle it.
+    Note that this will walk DOWN the view hierarchy, not up it like most.
+
+    @returns {Object} Object that handled evet or null
+  */
+  attemptKeyEquivalent: function(evt) {
+    var ret = null ;
+
+    // keystring is a method name representing the keys pressed (i.e
+    // 'alt_shift_escape')
+    var keystring = evt.commandCodes()[0];
+
+    // couldn't build a keystring for this key event, nothing to do
+    if (!keystring) return NO;
+
+    var menuPane = this.get('menuPane'),
+        keyPane  = this.get('keyPane'),
+        mainPane = this.get('mainPane');
+
+    if (menuPane) {
+      ret = menuPane.performKeyEquivalent(keystring, evt) ;
+      if (ret) return ret;
+    }
+
+    // Try the keyPane.  If it's modal, then try the equivalent there but on
+    // nobody else.
+    if (keyPane) {
+      ret = keyPane.performKeyEquivalent(keystring, evt) ;
+      if (ret || keyPane.get('isModal')) return ret ;
+    }
+
+    // if not, then try the main pane
+    if (!ret && mainPane && (mainPane!==keyPane)) {
+      ret = mainPane.performKeyEquivalent(keystring, evt);
+      if (ret || mainPane.get('isModal')) return ret ;
+    }
+
+    return ret ;
+  },
+
+  _lastModifiers: null,
+
+  /** @private
+    Modifier key changes are notified with a keydown event in most browsers.
+    We turn this into a flagsChanged keyboard event.  Normally this does not
+    stop the normal browser behavior.
+  */
+  _handleModifierChanges: function(evt) {
+    // if the modifier keys have changed, then notify the first responder.
+    var m;
+    m = this._lastModifiers = (this._lastModifiers || { alt: false, ctrl: false, shift: false });
+
+    var changed = false;
+    if (evt.altKey !== m.alt) { m.alt = evt.altKey; changed=true; }
+    if (evt.ctrlKey !== m.ctrl) { m.ctrl = evt.ctrlKey; changed=true; }
+    if (evt.shiftKey !== m.shift) { m.shift = evt.shiftKey; changed=true;}
+    evt.modifiers = m; // save on event
+
+    return (changed) ? (this.sendEvent('flagsChanged', evt) ? evt.hasCustomEventHandling : YES) : YES ;
+  },
+
+  /** @private
+    Determines if the keyDown event is a nonprintable or function key. These
+    kinds of events are processed as keyboard shortcuts.  If no shortcut
+    handles the event, then it will be sent as a regular keyDown event.
+  */
+  _isFunctionOrNonPrintableKey: function(evt) {
+    return !!(evt.altKey || evt.ctrlKey || evt.metaKey || ((evt.charCode !== evt.which) && SC.FUNCTION_KEYS[evt.which]));
+  },
+
+  /** @private
+    Determines if the event simply reflects a modifier key change.  These
+    events may generate a flagsChanged event, but are otherwise ignored.
+  */
+  _isModifierKey: function(evt) {
+    return !!SC.MODIFIER_KEYS[evt.charCode];
+  },
+
+  /** @private
+    The keydown event occurs whenever the physically depressed key changes.
+    This event is used to deliver the flagsChanged event and to with function
+    keys and keyboard shortcuts.
+
+    All actions that might cause an actual insertion of text are handled in
+    the keypress event.
+  */
+  keydown: function(evt) {
+    if (SC.none(evt)) return YES;
+    var keyCode = evt.keyCode;
+    if(SC.browser.mozilla && evt.keyCode===9){
+      this.keydownCounter=1;
+    }
+    // Fix for IME input (japanese, mandarin).
+    // If the KeyCode is 229 wait for the keyup and
+    // trigger a keyDown if it is is enter onKeyup.
+    if (keyCode===229){
+      this._IMEInputON = YES;
+      return this.sendEvent('keyDown', evt);
+    }
+
+    // If user presses the escape key while we are in the middle of a
+    // drag operation, cancel the drag operation and handle the event.
+    if (keyCode === 27 && this._drag) {
+      this._drag.cancelDrag();
+      this._drag = null;
+      this._mouseDownView = null;
+      return YES;
+    }
+
+    // Firefox does NOT handle delete here...
+    if (SC.browser.mozilla && (evt.which === 8)) return true ;
+
+    // modifier keys are handled separately by the 'flagsChanged' event
+    // send event for modifier key changes, but only stop processing if this
+    // is only a modifier change
+    var ret = this._handleModifierChanges(evt),
+        target = evt.target || evt.srcElement,
+        forceBlock = (evt.which === 8) && !SC.allowsBackspaceToPreviousPage && (target === document.body);
+
+    if (this._isModifierKey(evt)) return (forceBlock ? NO : ret);
+
+    // if this is a function or non-printable key, try to use this as a key
+    // equivalent.  Otherwise, send as a keyDown event so that the focused
+    // responder can do something useful with the event.
+    ret = YES ;
+    if (this._isFunctionOrNonPrintableKey(evt)) {
+      // otherwise, send as keyDown event.  If no one was interested in this
+      // keyDown event (probably the case), just let the browser do its own
+      // processing.
+
+      // Arrow keys are handled in keypress for firefox
+      if (keyCode>=37 && keyCode<=40 && SC.browser.mozilla) return YES;
+
+
+      ret = this.sendEvent('keyDown', evt) ;
+
+      // attempt key equivalent if key not handled
+      if (!ret) {
+        ret = !this.attemptKeyEquivalent(evt) ;
+      } else {
+        ret = evt.hasCustomEventHandling ;
+        if (ret) forceBlock = NO ; // code asked explicitly to let delete go
+      }
+    }
+
+    return forceBlock ? NO : ret ;
+  },
+
+  /** @private
+    The keypress event occurs after the user has typed something useful that
+    the browser would like to insert.  Unlike keydown, the input codes here
+    have been processed to reflect that actual text you might want to insert.
+
+    Normally ignore any function or non-printable key events.  Otherwise, just
+    trigger a keyDown.
+  */
+  keypress: function(evt) {
+    var ret,
+        keyCode   = evt.keyCode,
+        isFirefox = !!SC.browser.mozilla;
+
+    if(SC.browser.mozilla && evt.keyCode===9){
+      this.keydownCounter++;
+      if(this.keydownCounter==2) return YES;
+    }
+    // delete is handled in keydown() for most browsers
+    if (isFirefox && (evt.which === 8)) {
+      //get the keycode and set it for which.
+      evt.which = keyCode;
+      ret = this.sendEvent('keyDown', evt);
+      return ret ? (SC.allowsBackspaceToPreviousPage || evt.hasCustomEventHandling) : YES ;
+
+    // normal processing.  send keyDown for printable keys...
+    //there is a special case for arrow key repeating of events in FF.
+    } else {
+      var isFirefoxArrowKeys = (keyCode >= 37 && keyCode <= 40 && isFirefox),
+          charCode           = evt.charCode;
+      if ((charCode !== undefined && charCode === 0 && evt.keyCode!==9) && !isFirefoxArrowKeys) return YES;
+      if (isFirefoxArrowKeys) evt.which = keyCode;
+      return this.sendEvent('keyDown', evt) ? evt.hasCustomEventHandling:YES;
+    }
+  },
+
+  keyup: function(evt) {
+    // to end the simulation of keypress in firefox set the _ffevt to null
+    if(this._ffevt) this._ffevt=null;
+    // modifier keys are handled separately by the 'flagsChanged' event
+    // send event for modifier key changes, but only stop processing if this is only a modifier change
+    var ret = this._handleModifierChanges(evt);
+    if (this._isModifierKey(evt)) return ret;
+    // Fix for IME input (japanese, mandarin).
+    // If the KeyCode is 229 wait for the keyup and
+    // trigger a keyDown if it is is enter onKeyup.
+    if (this._IMEInputON && evt.keyCode===13){
+      evt.isIMEInput = YES;
+      this.sendEvent('keyDown', evt);
+      this._IMEInputON = NO;
+    }
+    return this.sendEvent('keyUp', evt) ? evt.hasCustomEventHandling:YES;
+  },
+
+  /**
+    IE's default behavior to blur textfields and other controls can only be
+    blocked by returning NO to this event. However we don't want to block
+    its default behavior otherwise textfields won't loose focus by clicking on
+    an empty area as it's expected. If you want to block IE from bluring another
+    control set blockIEDeactivate to true on the especific view in which you
+    want to avoid this. Think of an autocomplete menu, you want to click on
+    the menu but don't loose focus.
+  */
+  beforedeactivate: function(evt) {
+    var toElement = evt.toElement;
+    if (toElement && toElement.tagName && toElement.tagName!=="IFRAME") {
+      var view = SC.$(toElement).view()[0];
+      //The following line is neccesary to allow/block text selection for IE,
+      // in combination with the selectstart event.
+      if (view && view.get('blocksIEDeactivate')) return NO;
+    }
+    return YES;
+  },
+
+  // ..........................................................
+  // MOUSE HANDLING
+  //
+
+  mousedown: function(evt) {
+    if (SC.platform.touch) {
+      evt.allowDefault();
+      return YES;
+    }
+
+    if(!SC.browser.msie) window.focus();
+
+    // First, save the click count. The click count resets if the mouse down
+    // event occurs more than 250 ms later than the mouse up event or more
+    // than 8 pixels away from the mouse down event.
+    this._clickCount += 1 ;
+    if (!this._lastMouseUpAt || ((Date.now()-this._lastMouseUpAt) > 250)) {
+      this._clickCount = 1 ;
+    } else {
+      var deltaX = this._lastMouseDownX - evt.clientX,
+          deltaY = this._lastMouseDownY - evt.clientY,
+          distance = Math.sqrt(deltaX*deltaX + deltaY*deltaY) ;
+      if (distance > 8.0) this._clickCount = 1 ;
+    }
+    evt.clickCount = this._clickCount ;
+
+    this._lastMouseDownX = evt.clientX ;
+    this._lastMouseDownY = evt.clientY ;
+
+    var fr, view = this.targetViewForEvent(evt) ;
+
+    // InlineTextField needs to loose firstResponder whenever you click outside
+    // the view. This is a special case as textfields are not supposed to loose
+    // focus unless you click on a list, another textfield or an special
+    // view/control.
+
+    if(view) fr=view.getPath('pane.firstResponder');
+
+    if(fr && fr.kindOf(SC.InlineTextFieldView) && fr!==view){
+      fr.resignFirstResponder();
+    }
+
+    view = this._mouseDownView = this.sendEvent('mouseDown', evt, view) ;
+    if (view && view.respondsTo('mouseDragged')) this._mouseCanDrag = YES ;
+
+    // Determine if any views took responsibility for the
+    // event. If so, save that information so we can prevent
+    // the next click event we receive from propagating to the browser.
+    var ret = view ? evt.hasCustomEventHandling : YES;
+    this._lastMouseDownCustomHandling = ret;
+
+    return ret;
+  },
+
+  /**
+    mouseUp only gets delivered to the view that handled the mouseDown evt.
+    we also handle click and double click notifications through here to
+    ensure consistant delivery.  Note that if mouseDownView is not
+    implemented, then no mouseUp event will be sent, but a click will be
+    sent.
+  */
+  mouseup: function(evt) {
+    if (SC.platform.touch) {
+      evt.allowDefault();
+      return YES;
+    }
+
+    if (this._drag) {
+      this._drag.tryToPerform('mouseUp', evt) ;
+      this._drag = null ;
+    }
+
+    var handler = null, view = this._mouseDownView,
+        targetView = this.targetViewForEvent(evt);
+
+    // record click count.
+    evt.clickCount = this._clickCount ;
+
+    // attempt the mouseup call only if there's a target.
+    // don't want a mouseup going to anyone unless they handled the mousedown...
+    if (view) {
+      handler = this.sendEvent('mouseUp', evt, view) ;
+
+      // try doubleClick
+      if (!handler && (this._clickCount === 2)) {
+        handler = this.sendEvent('doubleClick', evt, view) ;
+      }
+
+      // try single click
+      if (!handler) {
+        handler = this.sendEvent('click', evt, view) ;
+      }
+    }
+
+    // try whoever's under the mouse if we haven't handle the mouse up yet
+    if (!handler) {
+
+      // try doubleClick
+      if (this._clickCount === 2) {
+        handler = this.sendEvent('doubleClick', evt, targetView);
+      }
+
+      // try singleClick
+      if (!handler) {
+        handler = this.sendEvent('click', evt, targetView) ;
+      }
+    }
+
+    // cleanup
+    this._mouseCanDrag = NO; this._mouseDownView = null ;
+
+    // Save timestamp of mouseup at last possible moment.
+    // (This is used to calculate double click events)
+    this._lastMouseUpAt = Date.now() ;
+
+    // Determine if any views took responsibility for the
+    // event. If so, save that information so we can prevent
+    // the next click event we receive from propagating to the browser.
+    var ret = handler ? evt.hasCustomEventHandling : YES;
+    this._lastMouseUpCustomHandling = ret;
+
+    return ret;
+  },
+
+  /**
+    Certain browsers ignore us overriding mouseup and mousedown events and
+    still allow default behavior (such as navigating away when the user clicks
+    on a link). To block default behavior, we store whether or not the last
+    mouseup or mousedown events resulted in us calling preventDefault() or
+    stopPropagation(), in which case we make the same calls on the click event.
+
+    @param {Event} evt the click event
+    @returns {Boolean} whether the event should be propagated to the browser
+  */
+  click: function(evt) {
+    if (!this._lastMouseUpCustomHandling || !this._lastMouseDownCustomHandling) {
+      evt.preventDefault();
+      evt.stopPropagation();
+      return NO;
+    }
+
+    return YES;
+  },
+
+  dblclick: function(evt){
+    if (SC.browser.isIE) {
+      this._clickCount = 2;
+      // this._onmouseup(evt);
+      this.mouseup(evt);
+    }
+  },
+
+  mousewheel: function(evt) {
+    var view = this.targetViewForEvent(evt) ,
+        handler = this.sendEvent('mouseWheel', evt, view) ;
+
+    return (handler) ? evt.hasCustomEventHandling : YES ;
+  },
+
+  _lastHovered: null,
+
+  /**
+   This will send mouseEntered, mouseExited, mousedDragged and mouseMoved
+   to the views you hover over.  To receive these events, you must implement
+   the method. If any subviews implement them and return true, then you won't
+   receive any notices.
+
+   If there is a target mouseDown view, then mouse moved events will also
+   trigger calls to mouseDragged.
+  */
+  mousemove: function(evt) {
+    if (SC.platform.touch) {
+      evt.allowDefault();
+      return YES;
+    }
+
+    if (SC.browser.msie) {
+      if (this._lastMoveX === evt.clientX && this._lastMoveY === evt.clientY) return;
+    }
+
+    // We'll record the last positions in all browsers, in case a special pane
+    // or some such UI absolutely needs this information.
+    this._lastMoveX = evt.clientX;
+    this._lastMoveY = evt.clientY;
+
+    SC.run(function() {
+       // make sure the view gets focus no matter what.  FF is inconsistant
+       // about this.
+      // this.focus();
+       // only do mouse[Moved|Entered|Exited|Dragged] if not in a drag session
+       // drags send their own events, e.g. drag[Moved|Entered|Exited]
+       if (this._drag) {
+         //IE triggers mousemove at the same time as mousedown
+         if(SC.browser.msie){
+           if (this._lastMouseDownX !== evt.clientX || this._lastMouseDownY !== evt.clientY) {
+             this._drag.tryToPerform('mouseDragged', evt);
+           }
+         }
+         else {
+           this._drag.tryToPerform('mouseDragged', evt);
+         }
+       } else {
+         var lh = this._lastHovered || [] , nh = [] , exited, loc, len,
+             view = this.targetViewForEvent(evt) ;
+
+         // first collect all the responding view starting with the
+         // target view from the given mouse move event
+         while (view && (view !== this)) {
+           nh.push(view);
+           view = view.get('nextResponder');
+         }
+
+         // next exit views that are no longer part of the
+         // responding chain
+         for (loc=0, len=lh.length; loc < len; loc++) {
+           view = lh[loc] ;
+           exited = view.respondsTo('mouseExited');
+           if (exited && nh.indexOf(view) === -1) {
+             view.tryToPerform('mouseExited', evt);
+           }
+         }
+
+         // finally, either perform mouse moved or mouse entered depending on
+         // whether a responding view was or was not part of the last
+         // hovered views
+         for (loc=0, len=nh.length; loc < len; loc++) {
+           view = nh[loc];
+           if (lh.indexOf(view) !== -1) {
+             view.tryToPerform('mouseMoved', evt);
+           } else {
+             view.tryToPerform('mouseEntered', evt);
+           }
+         }
+
+         // Keep track of the view that were last hovered
+         this._lastHovered = nh;
+
+         // also, if a mouseDownView exists, call the mouseDragged action, if
+         // it exists.
+         if (this._mouseDownView) {
+           if(SC.browser.msie){
+             if (this._lastMouseDownX !== evt.clientX && this._lastMouseDownY !== evt.clientY) {
+               this._mouseDownView.tryToPerform('mouseDragged', evt);
+             }
+           }
+           else {
+             this._mouseDownView.tryToPerform('mouseDragged', evt);
+           }
+         }
+       }
+    }, this);
+  },
+
+  // these methods are used to prevent unnecessary text-selection in IE,
+  // there could be some more work to improve this behavior and make it
+  // a bit more useful; right now it's just to prevent bugs when dragging
+  // and dropping.
+
+  _mouseCanDrag: YES,
+
+  selectstart: function(evt) {
+    var targetView = this.targetViewForEvent(evt),
+        result = this.sendEvent('selectStart', evt, targetView);
+
+    // If the target view implements mouseDragged, then we want to ignore the
+    // 'selectstart' event.
+    if (targetView && targetView.respondsTo('mouseDragged')) {
+      return (result !==null ? YES: NO) && !this._mouseCanDrag;
+    }
+    else {
+      return (result !==null ? YES: NO);
+    }
+  },
+
+  drag: function() { return false; },
+
+  contextmenu: function(evt) {
+    var view = this.targetViewForEvent(evt) ;
+    return this.sendEvent('contextMenu', evt, view);
+  },
+
+  // ..........................................................
+  // ANIMATION HANDLING
+  //
+  webkitAnimationStart: function(evt) {
+    try {
+      var view = this.targetViewForEvent(evt) ;
+      this.sendEvent('animationDidStart', evt, view) ;
+    } catch (e) {
+      SC.Logger.warn('Exception during animationDidStart: %@'.fmt(e)) ;
+      throw e;
+    }
+
+    return view ? evt.hasCustomEventHandling : YES;
+  },
+
+  webkitAnimationIteration: function(evt) {
+    try {
+      var view = this.targetViewForEvent(evt) ;
+      this.sendEvent('animationDidIterate', evt, view) ;
+    } catch (e) {
+      SC.Logger.warn('Exception during animationDidIterate: %@'.fmt(e)) ;
+      throw e;
+    }
+
+    return view ? evt.hasCustomEventHandling : YES;
+  },
+
+  webkitAnimationEnd: function(evt) {
+    try {
+      var view = this.targetViewForEvent(evt) ;
+      this.sendEvent('animationDidEnd', evt, view) ;
+    } catch (e) {
+      SC.Logger.warn('Exception during animationDidEnd: %@'.fmt(e)) ;
+      throw e;
+    }
+
+    return view ? evt.hasCustomEventHandling : YES;
+  },
+
+  transitionEnd: function(evt){
+    try {
+      var view = this.targetViewForEvent(evt) ;
+      this.sendEvent('transitionDidEnd', evt, view) ;
+    } catch (e) {
+      SC.Logger.warn('Exception during transitionDidEnd: %@'.fmt(e)) ;
+      throw e;
+    }
+
+    return view ? evt.hasCustomEventHandling : YES;
+  }
+
+});
+
+/**
+  @class SC.Touch
+  Represents a touch.
+
+  Views receive touchStart and touchEnd.
+*/
+SC.Touch = function(touch, touchContext) {
+  // get the raw target view (we'll refine later)
+  this.touchContext = touchContext;
+  this.identifier = touch.identifier; // for now, our internal id is WebKit's id.
+
+  var target = touch.target, targetView;
+  if (target && SC.$(target).hasClass("touch-intercept")) {
+    touch.target.style.webkitTransform = "translate3d(0px,-5000px,0px)";
+    target = document.elementFromPoint(touch.pageX, touch.pageY);
+    if (target) targetView = SC.$(target).view()[0];
+
+    this.hidesTouchIntercept = NO;
+    if (target.tagName === "INPUT") {
+      this.hidesTouchIntercept = touch.target;
+    } else {
+      touch.target.style.webkitTransform = "translate3d(0px,0px,0px)";
+    }
+  } else {
+    targetView = touch.target ? SC.$(touch.target).view()[0] : null;
+  }
+  this.targetView = targetView;
+  this.target = target;
+  this.hasEnded = NO;
+  this.type = touch.type;
+  this.clickCount = 1;
+
+  this.view = undefined;
+  this.touchResponder = this.nextTouchResponder = undefined;
+  this.touchResponders = [];
+
+  this.startX = this.pageX = touch.pageX;
+  this.startY = this.pageY = touch.pageY;
+  this.clientX = touch.clientX;
+  this.clientY = touch.clientY;
+  this.screenX = touch.screenX;
+  this.screenY = touch.screenY;
+};
+
+SC.Touch.prototype = {
+  /**@scope SC.Touch.prototype*/
+
+  unhideTouchIntercept: function() {
+    var intercept = this.hidesTouchIntercept;
+    if (intercept) {
+      setTimeout(function() { intercept.style.webkitTransform = "translate3d(0px,0px,0px)"; }, 500);
+    }
+  },
+
+  /**
+    Indicates that you want to allow the normal default behavior.  Sets
+    the hasCustomEventHandling property to YES but does not cancel the event.
+  */
+  allowDefault: function() {
+    if (this.event) this.event.hasCustomEventHandling = YES ;
+  },
+
+  /**
+    If the touch is associated with an event, prevents default action on the event.
+  */
+  preventDefault: function() {
+    if (this.event) this.event.preventDefault();
+  },
+
+  stopPropagation: function() {
+    if (this.event) this.event.stopPropagation();
+  },
+
+  stop: function() {
+    if (this.event) this.event.stop();
+  },
+
+  /**
+    Removes from and calls touchEnd on the touch responder.
+  */
+  end: function() {
+    this.touchContext.endTouch(this);
+  },
+
+  /**
+    Changes the touch responder for the touch. If shouldStack === YES,
+    the current responder will be saved so that the next responder may
+    return to it.
+  */
+  makeTouchResponder: function(responder, shouldStack, upViewChain) {
+    this.touchContext.makeTouchResponder(this, responder, shouldStack, upViewChain);
+  },
+
+
+  /**
+    Captures, or recaptures, the touch. This works from the touch's raw target view
+    up to the startingPoint, and finds either a view that returns YES to captureTouch() or
+    touchStart().
+  */
+  captureTouch: function(startingPoint, shouldStack) {
+    this.touchContext.captureTouch(this, startingPoint, shouldStack);
+  },
+
+  /**
+    Returns all touches for a specified view. Put as a convenience on the touch itself; this method
+    is also available on the event.
+  */
+  touchesForView: function(view) {
+    return this.touchContext.touchesForView(view);
+  },
+
+  /**
+    Same as touchesForView, but sounds better for responders.
+  */
+  touchesForResponder: function(responder) {
+    return this.touchContext.touchesForView(responder);
+  },
+
+  /**
+    Returns average data--x, y, and d (distance)--for the touches owned by the supplied view.
+
+    addSelf adds this touch to the set being considered. This is useful from touchStart. If
+    you use it from anywhere else, it will make this touch be used twice--so use caution.
+  */
+  averagedTouchesForView: function(view, addSelf) {
+    return this.touchContext.averagedTouchesForView(view, (addSelf ? this : null));
+  }
+};
+
+SC.mixin(SC.Touch, {
+  create: function(touch, touchContext) {
+    return new SC.Touch(touch, touchContext);
+  }
+});
+
+/*
+  Invoked when the document is ready, but before main is called.  Creates
+  an instance and sets up event listeners as needed.
+*/
+SC.ready(SC.RootResponder, SC.RootResponder.ready = function() {
+  var r;
+  r = SC.RootResponder.responder = SC.RootResponder.create() ;
+  r.setup() ;
+});