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.

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.

This method is also available on SC.Touch objects, and you will usually call it from there.

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 lose focus by clicking on an empty area as it's expected. If you want to block IE from blurring another control set blockIEDeactivate to true on the specific 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.

Handle window focus. Change hasFocus and add sc-focus CSS class (removing sc-blur). Also notify panes.

Before the touchStart event is sent up the usual responder chain, the views along that same responder chain are given the opportunity to capture the touch event, preventing child views (including the target) from hearing about it. This of course proceeds in the opposite direction from a usual event bubbling, starting at the target's first ancestor and proceeding towards the target. This method implements the capture phase.

If no view captures the touch, this method will return NO, and makeTouchResponder is then called for the target, proceeding with standard target-to-pane event bubbling for touchStart.

For an example of captureTouch in action, see SC.ScrollView's touch handling, which by default captures the touch and holds it for 150ms to allow it to determine whether the user is tapping or scrolling.

You will usually not call this method yourself, and if you do, you should call the corresponding convenience method on the touch itself.

Cleans up the additional animation event listeners.

NOTE: requires that SC.RootResponser.responder.animationstartEventName, SC.RootResponser.responder.animationendEventName and SC.RootResponser.responder.animationiterationEventName have been determined.

Cleans up the additional transition event listeners.

NOTE: requires that SC.RootResponser.responder.transitionendEventName has been determined.

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.

Computes the window size from the DOM.

Handle window focus. Change hasFocus and add sc-focus CSS class (removing sc-blur). Also notify panes.

Handle window focus event for IE. Listening to the focus event is not reliable as per every focus event you receive you immediately get a blur event (Only on IE of course ;)

Handle window blur event for IE. Listening to the focus event is not reliable as per every focus event you receive you immediately get a blur event (Only on IE of course ;)

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.

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.

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.

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.

This method attempts to change the responder for a particular touch. The touch's responder is the view which will receive touch events for that touch.

You will usually not call this method directly, instead calling one of the convenience methods on the touch itself. See documentation for SC.Touch for more.

Possible gotchas:

• Because this method must search for a view which implements touchStart (without returning NO), touchStart is called on the new responder before touchCancelled is called on the old one.
• While a touch exposes its current responder at touchResponder and any previous stacked one at nextTouchResponder, their relationship is ad hoc and arbitrary, and so are not chained by nextResponder like in a standard responder chain. To query the touch's current responder stack (or, though it's not recommended, change it), check touch.touchResponders.

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.

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.

On window resize, notifies panes of the change.

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.

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.

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().

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.

Finds the view that appears to be targeted by the passed event. This only works on events with a valid target property.

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.

This method is also available on SC.Touch objects, and you will usually call it from there.