sproutcore 1.7.1.beta → 1.8.0

data/lib/frameworks/sproutcore/frameworks/desktop/views/list_item.js

@@ -250,6 +250,15 @@ SC.ListItemView = SC.View.extend(SC.InlineEditable, SC.Control,
   */
   validator: null,
 
+  contentKeys: {
+    contentValueKey: 'title',
+    contentCheckboxKey: 'checkbox',
+    contentIconKey:  'icon',
+    contentRightIconKey: 'rightIcon',
+    contentUnreadCountKey: 'count',
+    contentIsBranchKey: 'branch'
+  },
+
   /** @private */
   contentPropertyDidChange: function() {
     //if (this.get('isEditing')) this.discardEditing() ;
@@ -292,7 +301,7 @@ SC.ListItemView = SC.View.extend(SC.InlineEditable, SC.Control,
   },
 
   /** @private
-    Determines if the event occured inside an element with the specified
+    Determines if the event occurred inside an element with the specified
     classname or not.
   */
   _isInsideElementWithClassName: function(className, evt) {
@@ -393,7 +402,7 @@ SC.ListItemView = SC.View.extend(SC.InlineEditable, SC.Control,
       this._removeCheckboxActiveState() ;
       ret = YES ;
 
-    // if mouse as down on disclosure -- handle mosue up.  otherwise pass on
+    // if mouse as down on disclosure -- handle mouse up.  otherwise pass on
     // to parent.
     } else if (this._isMouseDownOnDisclosure) {
       if (this._isInsideDisclosure(evt)) {

data/lib/frameworks/sproutcore/frameworks/desktop/views/menu_item.js

@@ -56,7 +56,7 @@ SC.MenuItemView = SC.View.extend(SC.ContentDisplay,
   acceptsFirstResponder: YES,
 
   /**
-    IE only attribute to block bluring of other controls
+    IE only attribute to block blurring of other controls
 
     @type Boolean
     @default YES
@@ -289,7 +289,7 @@ SC.MenuItemView = SC.View.extend(SC.ContentDisplay,
 
   /**
     This method will check whether the current Menu Item is still
-    selected and then create a submenu accordignly.
+    selected and then create a submenu accordingly.
   */
   showSubMenu: function() {
     var subMenu = this.get('subMenu') ;

data/lib/frameworks/sproutcore/frameworks/desktop/views/menu_scroll.js

@@ -189,7 +189,7 @@ SC.MenuScrollerView = SC.ScrollerView.extend(
   /**
     This function overrides the default function in SC.Scroller.
     SC.MenuScroller and SC.MenuScroll use valueBinding so this function is
-    not neccesary.
+    not necessary.
   */
   _sc_scroller_valueDidChange: function() {}.observes('value'),
   
@@ -258,7 +258,7 @@ SC.MenuScrollerView = SC.ScrollerView.extend(
   _invokeScrollOnMouseOver: function(){
     this._scrollMenu();
     if(this.get('isMouseOver')){
-      this.invokeLater(this._invokeScrollOnMouseOver, 100);
+      this.invokeLater(this._invokeScrollOnMouseOver, 50);
     }
   }
   
@@ -394,7 +394,7 @@ SC.MenuScrollView = SC.ScrollView.extend(
   autohidesHorizontalScroller: NO,
   
   /** 
-    YES if the view shuld maintain a vertical scroller.   This property must 
+    YES if the view should maintain a vertical scroller.   This property must 
     be set when the view is created.
     
     @type Boolean
@@ -647,7 +647,7 @@ SC.MenuScrollView = SC.ScrollView.extend(
   
   /** @private
     Invoked whenever the contentView's frame changes.  This will update the 
-    scroller maxmimum and optionally update the scroller visibility if the
+    scroller maximum and optionally update the scroller visibility if the
     size of the contentView changes.  We don't care about the origin since
     that is tracked separately from the offset values.
   */
@@ -695,7 +695,7 @@ SC.MenuScrollView = SC.ScrollView.extend(
     
     // update the offset for the contentView...
     var contentView = this.get('contentView');
-    if (contentView) contentView.adjust('top', 0-offset) ;
+    if (contentView) contentView.$().css('top', (0-offset) + "px");
     
   }.observes('verticalScrollOffset')
 

data/lib/frameworks/sproutcore/frameworks/desktop/views/popup_button.js

@@ -188,28 +188,34 @@ SC.PopupButtonView = SC.ButtonView.extend(
 
     this._action() ;
 
-    // Store the current timestamp. We register the timestamp at the end of
-    // the runloop so that the menu has been rendered, in case that operation
+    // Store the current timestamp. We register the timestamp after a setTimeout
+    // so that the menu has been rendered, in case that operation
     // takes more than a few hundred milliseconds.
 
     // One mouseUp, we'll use this value to determine how long the mouse was
     // pressed.
-    this.invokeLast(this._recordMouseDownTimestamp);
+    
+    // we need to keep track that we opened it just now in case we get the
+    // mouseUp before render finishes. If it is 0, then we know we have not
+    // waited long enough.
+    this._menuRenderedTimestamp = 0;
+    
+    var self = this;
+    
+    // setTimeout guarantees that all rendering is done. The browser will even
+    // have rendered by this point.
+    setTimeout(function() {
+      SC.run(function(){
+        // a run loop might be overkill here but what if Date.now fails?
+        self._menuRenderedTimestamp = Date.now();
+      });
+    }, 1);
 
     this.becomeFirstResponder();
 
     return YES ;
   },
 
-  /** @private
-    Records the current timestamp. This is invoked at the end of the runloop
-    by mouseDown. We use this value to determine the delay between mouseDown
-    and mouseUp.
-  */
-  _recordMouseDownTimestamp: function() {
-    this._menuRenderedTimestamp = new Date().getTime();
-  },
-
   /** @private
     Because we responded YES to the mouseDown event, we have responsibility
     for handling the corresponding mouseUp event.
@@ -232,6 +238,10 @@ SC.PopupButtonView = SC.ButtonView.extend(
         menu = this.get('instantiatedMenu'),
         touch = SC.platform.touch,
         targetMenuItem;
+    
+    // normalize the previousTimestamp: if it is 0, it might as well be now.
+    // 0 means that we have not even triggered the nearly-immediate saving of timestamp.
+    if (previousTimestamp === 0) previousTimestamp = Date.now();
 
     if (menu) {
       // Get the menu item the user is currently hovering their mouse over

data/lib/frameworks/sproutcore/frameworks/desktop/views/radio.js

@@ -180,7 +180,7 @@ SC.RadioView = SC.View.extend(SC.Control,
   /**
     If items property is a hash, specify which property will function as
     the item width with this itemWidthKey property. This is only used when
-    layoutDirection is set to SC.LAYOUT_HORIONZTAL and can be used to override
+    layoutDirection is set to SC.LAYOUT_HORIZONTAL and can be used to override
     the default value provided by the framework or theme CSS.
     
     @type String
@@ -304,7 +304,7 @@ SC.RadioView = SC.View.extend(SC.Control,
           ariaLabel = item.get ? item.get(ariaLabelKey) : item[ariaLabelKey];
         } else ariaLabel = null;
 
-        // if item is nil, use somedefaults...
+        // if item is nil, use some defaults...
       } else {
         title = value = icon = null;
         isEnabled = NO;
@@ -356,8 +356,11 @@ SC.RadioView = SC.View.extend(SC.Control,
     this._activeRadioButton = index;
     
     if (index !== undefined) {
-      this.get('displayItems')[index].set('isActive', YES);
-      delegate.updateRadioAtIndex(proxy, elem, index);
+      var item = this.get('displayItems')[index];
+      if (item.get('isEnabled')) {
+        item.set('isActive', YES);
+        delegate.updateRadioAtIndex(proxy, elem, index);
+      }
     }
     
     // even if radiobuttons are not set to get firstResponder, allow default 
@@ -387,9 +390,12 @@ SC.RadioView = SC.View.extend(SC.Control,
     this._activeRadioButton = undefined;
     
     if (index !== undefined) {
-      displayItems[index].set('isActive', NO);
-      delegate.updateRadioAtIndex(proxy, elem, index);
-      this.set('value', displayItems[index].value);
+      var item = this.get('displayItems')[index];
+      if (item.get('isEnabled')) {
+        item.set('isActive', NO);
+        delegate.updateRadioAtIndex(proxy, elem, index);
+        this.set('value', item.value);
+      }
     }
     
     evt.allowDefault();

data/lib/frameworks/sproutcore/frameworks/desktop/views/scene.js

@@ -34,7 +34,7 @@ SC.SceneView = SC.ContainerView.extend(
 
   /**
     Array of scene names.  Scenes will slide on and off screen in the order
-    that you specifiy them here.  That is, if you shift from a scene at index
+    that you specify them here.  That is, if you shift from a scene at index
     2 to a scene at index 1, the scenes will animation backwards.  If you
     shift to a scene at index 3, the scenes will animate forwards.
     
@@ -46,7 +46,7 @@ SC.SceneView = SC.ContainerView.extend(
   /**
     The currently showing scene.  Changing this property will cause the 
     scene view to transition to the new scene.  If you set this property to 
-    null, an empty string, or a non-existant scene, then the scene will appear
+    null, an empty string, or a non-existent scene, then the scene will appear
     empty.
     
     @type String

data/lib/frameworks/sproutcore/frameworks/desktop/views/scroll.js

@@ -24,14 +24,14 @@ SC.FAST_SCROLL_DECELERATION = 0.85;
 /** @class
   Implements a complete scroll view.  This class uses a manual implementation
   of scrollers in order to properly support clipping frames.
-  
+
   Important Events:
-  
+
     - contentView frame size changes (to autoshow/hide scrollbar - adjust scrollbar size)
     - horizontalScrollOffset change
     - verticalScrollOffsetChanges
     - scroll wheel events
-  
+
   @extends SC.View
   @since SproutCore 1.0
 */
@@ -47,44 +47,44 @@ SC.ScrollView = SC.View.extend({
 
   // ..........................................................
   // PROPERTIES
-  // 
-  
+  //
+
   /**
     Walk like a duck
-    
+
     @type Boolean
     @default YES
     @readOnly
   */
   isScrollable: YES,
-  
-  /** 
+
+  /**
     The content view you want the scroll view to manage. This will be assigned to the contentView of the clipView also.
-    
+
     @type SC.View
     @default null
   */
   contentView: null,
-  
+
   /**
     The horizontal alignment for non-filling content inside of the ScrollView. Possible values:
-    
+
       - SC.ALIGN_LEFT
       - SC.ALIGN_RIGHT
       - SC.ALIGN_CENTER
-    
+
     @type String
     @default SC.ALIGN_LEFT
   */
   horizontalAlign: SC.ALIGN_LEFT,
-  
+
   /**
     The vertical alignment for non-filling content inside of the ScrollView. Possible values:
-    
+
       - SC.ALIGN_TOP
       - SC.ALIGN_BOTTOM
       - SC.ALIGN_MIDDLE
-    
+
     @type String
     @default SC.ALIGN_TOP
   */
@@ -92,7 +92,7 @@ SC.ScrollView = SC.View.extend({
 
   /**
     The current horizontal scroll offset. Changing this value will update both the contentView and the horizontal scroller, if there is one.
-    
+
     @field
     @type Number
     @default 0
@@ -106,10 +106,10 @@ SC.ScrollView = SC.View.extend({
 
     return this._scroll_horizontalScrollOffset||0;
   }.property().cacheable(),
-  
+
   /**
     The current vertical scroll offset.  Changing this value will update both the contentView and the vertical scroller, if there is one.
-    
+
     @field
     @type Number
     @default 0
@@ -123,7 +123,7 @@ SC.ScrollView = SC.View.extend({
 
     return this._scroll_verticalScrollOffset||0;
   }.property().cacheable(),
-  
+
   /** @private
     Calculates the maximum offset given content and container sizes, and the
     alignment.
@@ -133,7 +133,7 @@ SC.ScrollView = SC.View.extend({
     // simple to calculate the answer. Otherwise, we need to do some fancy-pants
     // alignment logic (read: simple math)
     if (contentSize >= containerSize) return contentSize - containerSize;
-    
+
     // alignment, yeah
     if (align === SC.ALIGN_LEFT || align === SC.ALIGN_TOP) {
       // if we left-align something, and it is smaller than the view, does that not mean
@@ -147,7 +147,7 @@ SC.ScrollView = SC.View.extend({
       return 0 - (containerSize - contentSize);
     }
   },
-  
+
   /** @private
     Calculates the minimum offset given content and container sizes, and the
     alignment.
@@ -156,7 +156,7 @@ SC.ScrollView = SC.View.extend({
     // if the content is larger than the container, we have no need to change the minimum
     // away from the natural 0 position.
     if (contentSize > containerSize) return 0;
-    
+
     // alignment, yeah
     if (align === SC.ALIGN_LEFT || align === SC.ALIGN_TOP) {
       // if we left-align something, and it is smaller than the view, does that not mean
@@ -170,12 +170,12 @@ SC.ScrollView = SC.View.extend({
       return 0 - (containerSize - contentSize);
     }
   },
-  
+
   /**
-    The maximum horizontal scroll offset allowed given the current contentView 
-    size and the size of the scroll view.  If horizontal scrolling is 
+    The maximum horizontal scroll offset allowed given the current contentView
+    size and the size of the scroll view.  If horizontal scrolling is
     disabled, this will always return 0.
-    
+
     @field
     @type Number
     @default 0
@@ -184,27 +184,27 @@ SC.ScrollView = SC.View.extend({
     var view = this.get('contentView') ;
     var contentWidth = view ? view.get('frame').width : 0,
         calculatedWidth = view ? view.get('calculatedWidth') : 0;
-    
+
     // The following code checks if there is a calculatedWidth (collections)
     // to avoid looking at the incorrect value calculated by frame.
     if (calculatedWidth) {
-      contentWidth = view.calculatedWidth; 
+      contentWidth = view.calculatedWidth;
     }
     contentWidth *= this._scale;
-    
+
     var containerWidth = this.get('containerView').get('frame').width ;
-    
+
     // we still must go through minimumScrollOffset even if we can't scroll
     // because we need to adjust for alignment. So, just make sure it won't allow scrolling.
     if (!this.get('canScrollHorizontal')) contentWidth = Math.min(contentWidth, containerWidth);
     return this.maximumScrollOffset(contentWidth, containerWidth, this.get("horizontalAlign"));
   }.property(),
-  
+
   /**
-    The maximum vertical scroll offset allowed given the current contentView 
+    The maximum vertical scroll offset allowed given the current contentView
     size and the size of the scroll view.  If vertical scrolling is disabled,
     this will always return 0 (or whatever alignment dictates).
-    
+
     @field
     @type Number
     @default 0
@@ -213,28 +213,28 @@ SC.ScrollView = SC.View.extend({
     var view = this.get('contentView'),
         contentHeight = (view && view.get('frame')) ? view.get('frame').height : 0,
         calculatedHeight = view ? view.get('calculatedHeight') : 0;
-    
+
     // The following code checks if there is a calculatedWidth (collections)
     // to avoid looking at the incorrect value calculated by frame.
     if(calculatedHeight){
-      contentHeight = calculatedHeight; 
+      contentHeight = calculatedHeight;
     }
     contentHeight *= this._scale;
-    
+
     var containerHeight = this.get('containerView').get('frame').height ;
-    
+
     // we still must go through minimumScrollOffset even if we can't scroll
     // because we need to adjust for alignment. So, just make sure it won't allow scrolling.
     if (!this.get('canScrollVertical')) contentHeight = Math.min(contentHeight, containerHeight);
     return this.maximumScrollOffset(contentHeight, containerHeight, this.get("verticalAlign"));
   }.property(),
-  
-  
+
+
   /**
-    The minimum horizontal scroll offset allowed given the current contentView 
-    size and the size of the scroll view.  If horizontal scrolling is 
+    The minimum horizontal scroll offset allowed given the current contentView
+    size and the size of the scroll view.  If horizontal scrolling is
     disabled, this will always return 0 (or whatever alignment dictates).
-    
+
     @field
     @type Number
     @default 0
@@ -246,23 +246,23 @@ SC.ScrollView = SC.View.extend({
     // The following code checks if there is a calculatedWidth (collections)
     // to avoid looking at the incorrect value calculated by frame.
     if(calculatedWidth){
-      contentWidth = calculatedWidth; 
+      contentWidth = calculatedWidth;
     }
     contentWidth *= this._scale;
-    
+
     var containerWidth = this.get('containerView').get('frame').width ;
-    
+
     // we still must go through minimumScrollOffset even if we can't scroll
     // because we need to adjust for alignment. So, just make sure it won't allow scrolling.
     if (!this.get('canScrollHorizontal')) contentWidth = Math.min(contentWidth, containerWidth);
     return this.minimumScrollOffset(contentWidth, containerWidth, this.get("horizontalAlign"));
   }.property(),
-  
+
   /**
-    The minimum vertical scroll offset allowed given the current contentView 
+    The minimum vertical scroll offset allowed given the current contentView
     size and the size of the scroll view.  If vertical scrolling is disabled,
     this will always return 0 (or whatever alignment dictates).
-    
+
     @field
     @type Number
     @default 0
@@ -271,49 +271,49 @@ SC.ScrollView = SC.View.extend({
     var view = this.get('contentView') ;
     var contentHeight = (view && view.get('frame')) ? view.get('frame').height : 0,
         calculatedHeight = view ? view.get('calculatedHeight') : 0;
-    
+
     // The following code checks if there is a calculatedWidth (collections)
     // to avoid looking at the incorrect value calculated by frame.
     if(calculatedHeight){
-      contentHeight = view.calculatedHeight; 
+      contentHeight = view.calculatedHeight;
     }
     contentHeight *= this._scale;
-    
+
     var containerHeight = this.get('containerView').get('frame').height ;
-    
+
     // we still must go through minimumScrollOffset even if we can't scroll
     // because we need to adjust for alignment. So, just make sure it won't allow scrolling.
     if (!this.get('canScrollVertical')) contentHeight = Math.min(contentHeight, containerHeight);
     return this.minimumScrollOffset(contentHeight, containerHeight, this.get("verticalAlign"));
   }.property(),
-  
-  
-  /** 
+
+
+  /**
     Amount to scroll one vertical line.
-  
+
     Used by the default implementation of scrollDownLine() and scrollUpLine().
-    
+
     @type Number
     @default 20
   */
   verticalLineScroll: 20,
-  
+
   /**
     Amount to scroll one horizontal line.
-  
-    Used by the default implementation of scrollLeftLine() and 
+
+    Used by the default implementation of scrollLeftLine() and
     scrollRightLine().
-    
+
     @type Number
     @default 20
   */
   horizontalLineScroll: 20,
-  
+
   /**
     Amount to scroll one vertical page.
-    
+
     Used by the default implementation of scrollUpPage() and scrollDownPage().
-    
+
     @field
     @type Number
     @default value of frame.height
@@ -322,13 +322,13 @@ SC.ScrollView = SC.View.extend({
   verticalPageScroll: function() {
     return this.get('frame').height;
   }.property('frame'),
-  
+
   /**
     Amount to scroll one horizontal page.
-    
-    Used by the default implementation of scrollLeftPage() and 
+
+    Used by the default implementation of scrollLeftPage() and
     scrollRightPage().
-    
+
     @field
     @type Number
     @default value of frame.width
@@ -337,48 +337,48 @@ SC.ScrollView = SC.View.extend({
   horizontalPageScroll: function() {
     return this.get('frame').width;
   }.property('frame'),
-  
-  
+
+
   // ..........................................................
   // SCROLLERS
-  // 
-  
-  /** 
-    YES if the view should maintain a horizontal scroller.   This property 
+  //
+
+  /**
+    YES if the view should maintain a horizontal scroller.   This property
     must be set when the view is created.
-    
+
     @type Boolean
     @default YES
   */
   hasHorizontalScroller: YES,
-  
+
   /**
-    The horizontal scroller view class. This will be replaced with a view 
-    instance when the ScrollView is created unless hasHorizontalScroller is 
+    The horizontal scroller view class. This will be replaced with a view
+    instance when the ScrollView is created unless hasHorizontalScroller is
     NO.
-    
+
     @type SC.View
     @default SC.ScrollerView
   */
   horizontalScrollerView: SC.ScrollerView,
-  
+
   /**
     The horizontal scroller view for touch. This will be replaced with a view
-    instance when touch is enabled when the ScrollView is created unless 
+    instance when touch is enabled when the ScrollView is created unless
     hasHorizontalScroller is NO.
-    
+
     @type SC.View
     @default SC.TouchScrollerView
   */
   horizontalTouchScrollerView: SC.TouchScrollerView,
-  
+
   /**
-    YES if the horizontal scroller should be visible.  You can change this 
-    property value anytime to show or hide the horizontal scroller.  If you 
-    do not want to use a horizontal scroller at all, you should instead set 
-    hasHorizontalScroller to NO to avoid creating a scroller view in the 
+    YES if the horizontal scroller should be visible.  You can change this
+    property value anytime to show or hide the horizontal scroller.  If you
+    do not want to use a horizontal scroller at all, you should instead set
+    hasHorizontalScroller to NO to avoid creating a scroller view in the
     first place.
-    
+
     @type Boolean
     @default YES
   */
@@ -387,61 +387,61 @@ SC.ScrollView = SC.View.extend({
   /**
     Returns YES if the view both has a horizontal scroller, the scroller is
     visible.
-    
+
     @field
     @type Boolean
     @default YES
   */
   canScrollHorizontal: function() {
-    return !!(this.get('hasHorizontalScroller') && 
-      this.get('horizontalScrollerView') && 
+    return !!(this.get('hasHorizontalScroller') &&
+      this.get('horizontalScrollerView') &&
       this.get('isHorizontalScrollerVisible')) ;
   }.property('isHorizontalScrollerVisible').cacheable(),
-  
+
   /**
     If YES, the horizontal scroller will autohide if the contentView is
-    smaller than the visible area.  You must set hasHorizontalScroller to YES 
+    smaller than the visible area.  You must set hasHorizontalScroller to YES
     for this property to have any effect.
-    
+
     @type Boolean
     @default YES
   */
   autohidesHorizontalScroller: YES,
-  
-  /** 
-    YES if the view shuld maintain a vertical scroller.   This property must 
+
+  /**
+    YES if the view should maintain a vertical scroller.   This property must
     be set when the view is created.
-    
+
     @type Boolean
     @default YES
   */
   hasVerticalScroller: YES,
-  
+
   /**
-    The vertical scroller view class. This will be replaced with a view 
+    The vertical scroller view class. This will be replaced with a view
     instance when the ScrollView is created unless hasVerticalScroller is NO.
-    
+
     @type SC.View
     @default SC.ScrollerView
   */
   verticalScrollerView: SC.ScrollerView,
-  
+
   /**
     The vertical touch scroller view class. This will be replaced with a view
     instance when the ScrollView is created.
-    
+
     @type SC.View
     @default SC.TouchScrollerView
   */
   verticalTouchScrollerView: SC.TouchScrollerView,
-  
+
   /**
-    YES if the vertical scroller should be visible.  You can change this 
-    property value anytime to show or hide the vertical scroller.  If you do 
-    not want to use a vertical scroller at all, you should instead set 
-    hasVerticalScroller to NO to avoid creating a scroller view in the first 
+    YES if the vertical scroller should be visible.  You can change this
+    property value anytime to show or hide the vertical scroller.  If you do
+    not want to use a vertical scroller at all, you should instead set
+    hasVerticalScroller to NO to avoid creating a scroller view in the first
     place.
-    
+
     @type Boolean
     @default YES
   */
@@ -450,43 +450,43 @@ SC.ScrollView = SC.View.extend({
   /**
     Returns YES if the view both has a horizontal scroller, the scroller is
     visible.
-    
+
     @field
     @type Boolean
     @default YES
   */
   canScrollVertical: function() {
-    return !!(this.get('hasVerticalScroller') && 
-      this.get('verticalScrollerView') && 
+    return !!(this.get('hasVerticalScroller') &&
+      this.get('verticalScrollerView') &&
       this.get('isVerticalScrollerVisible')) ;
   }.property('isVerticalScrollerVisible').cacheable(),
 
   /**
     If YES, the vertical scroller will autohide if the contentView is
-    smaller than the visible area.  You must set hasVerticalScroller to YES 
+    smaller than the visible area.  You must set hasVerticalScroller to YES
     for this property to have any effect.
-    
+
     @type Boolean
     @default YES
   */
   autohidesVerticalScroller: YES,
-  
+
   /**
-    Use this property to set the 'bottom' offset of your vertical scroller, 
+    Use this property to set the 'bottom' offset of your vertical scroller,
     to make room for a thumb view or other accessory view. Default is 0.
-    
+
     @type Number
     @default 0
   */
   verticalScrollerBottom: 0,
-  
+
   /**
     Use this to overlay the vertical scroller.
-    
-    This ensures that the container frame will not resize to accomodate the
-    vertical scroller, hence overlaying the scroller on top of 
+
+    This ensures that the container frame will not resize to accommodate the
+    vertical scroller, hence overlaying the scroller on top of
     the container.
-    
+
     @field
     @type Boolean
     @default NO
@@ -495,14 +495,14 @@ SC.ScrollView = SC.View.extend({
     if (SC.platform.touch) return YES;
     return NO;
   }.property().cacheable(),
-  
+
   /**
     Use this to overlay the horizontal scroller.
-    
-    This ensures that the container frame will not resize to accomodate the
-    horizontal scroller, hence overlaying the scroller on top of 
+
+    This ensures that the container frame will not resize to accommodate the
+    horizontal scroller, hence overlaying the scroller on top of
     the container
-    
+
     @field
     @type Boolean
     @default NO
@@ -511,71 +511,71 @@ SC.ScrollView = SC.View.extend({
     if (SC.platform.touch) return YES;
     return NO;
   }.property().cacheable(),
-  
+
   /**
     Use to control the positioning of the vertical scroller.  If you do not
     set 'verticalOverlay' to YES, then the content view will be automatically
     sized to meet the left edge of the vertical scroller, wherever it may be.
     This allows you to easily, for example, have “one pixel higher and one
     pixel lower” scroll bars that blend into their parent views.
-    
+
     If you do set 'verticalOverlay' to YES, then the scroller view will
     “float on top” of the content view.
-    
+
     Example: { top: -1, bottom: -1, right: 0 }
-    
+
     @type Hash
     @default null
   */
   verticalScrollerLayout: null,
-  
+
   /**
     Use to control the positioning of the horizontal scroller.  If you do not
     set 'horizontalOverlay' to YES, then the content view will be
     automatically sized to meet the top edge of the horizontal scroller,
     wherever it may be.
-    
+
     If you do set 'horizontalOverlay' to YES, then the scroller view will
     “float on top” of the content view.
-    
+
     Example: { left: 0, bottom: 0, right: 0 }
-    
+
     @type Hash
     @default null
   */
   horizontalScrollerLayout: null,
-  
+
   // ..........................................................
   // CUSTOM VIEWS
-  // 
-  
+  //
+
   /**
-    The container view that will contain your main content view.  You can 
+    The container view that will contain your main content view.  You can
     replace this property with your own custom subclass if you prefer.
-    
+
     @type SC.ContainerView
     @default SC.ConainerView
   */
   containerView: SC.ContainerView.extend({}),
-  
-  
+
+
   // ..........................................................
   // METHODS
-  // 
-  
+  //
+
   /**
     Scrolls the receiver to the specified x,y coordinate.  This should be the
     offset into the contentView you want to appear at the top-left corner of
     the scroll view.
-    
-    This method will contrain the actual scroll based on whether the view
+
+    This method will contain the actual scroll based on whether the view
     can scroll in the named direction and the maximum distance it can
     scroll.
-    
-    If you only want to scroll in one direction, pass null for the other 
-    direction.  You can also optionally pass a Hash for the first parameter 
+
+    If you only want to scroll in one direction, pass null for the other
+    direction.  You can also optionally pass a Hash for the first parameter
     with x and y coordinates.
-    
+
     @param {Number} x the x scroll location
     @param {Number} y the y scroll location
     @returns {SC.ScrollView} receiver
@@ -585,27 +585,27 @@ SC.ScrollView = SC.View.extend({
     if (y===undefined && SC.typeOf(x) === SC.T_HASH) {
       y = x.y; x = x.x;
     }
-    
+
     if (!SC.none(x)) {
       this.set('horizontalScrollOffset', x) ;
     }
-    
+
     if (!SC.none(y)) {
       this.set('verticalScrollOffset', y) ;
     }
-    
+
     return this ;
   },
-  
+
   /**
-    Scrolls the receiver in the horizontal and vertical directions by the 
-    amount specified, if allowed.  The actual scroll amount will be 
+    Scrolls the receiver in the horizontal and vertical directions by the
+    amount specified, if allowed.  The actual scroll amount will be
     constrained by the current scroll view settings.
-    
-    If you only want to scroll in one direction, pass null or 0 for the other 
-    direction.  You can also optionally pass a Hash for the first parameter 
+
+    If you only want to scroll in one direction, pass null or 0 for the other
+    direction.  You can also optionally pass a Hash for the first parameter
     with x and y coordinates.
-    
+
     @param {Number} x change in the x direction (or hash)
     @param {Number} y change in the y direction
     @returns {SC.ScrollView} receiver
@@ -615,41 +615,41 @@ SC.ScrollView = SC.View.extend({
     if (y===undefined && SC.typeOf(x) === SC.T_HASH) {
       y = x.y; x = x.x;
     }
-    
+
     // if null, undefined, or 0, pass null; otherwise just add current offset
     x = (x) ? this.get('horizontalScrollOffset')+x : null ;
     y = (y) ? this.get('verticalScrollOffset')+y : null ;
     return this.scrollTo(x,y) ;
   },
-  
+
   /**
     Scroll the view to make the view's frame visible.  For this to make sense,
     the view should be a subview of the contentView.  Otherwise the results
     will be undefined.
-    
+
     @param {SC.View} view view to scroll or null to scroll receiver visible
     @returns {Boolean} YES if scroll position was changed
   */
   scrollToVisible: function(view) {
-    
+
     // if no view is passed, do default
-    if (arguments.length === 0) return sc_super(); 
-    
+    if (arguments.length === 0) return sc_super();
+
     var contentView = this.get('contentView') ;
     if (!contentView) return NO; // nothing to do if no contentView.
 
-    // get the frame for the view - should work even for views with static 
+    // get the frame for the view - should work even for views with static
     // layout, assuming it has been added to the screen.
     var vf = view.get('frame');
     if (!vf) return NO; // nothing to do
-    
+
     // convert view's frame to an offset from the contentView origin.  This
     // will become the new scroll offset after some adjustment.
     vf = contentView.convertFrameFromView(vf, view.get('parentView')) ;
-    
+
     return this.scrollToRect(vf);
   },
-  
+
   /**
     Scroll to the supplied rectangle.
     @param {Rect} rect Rectangle to scroll to.
@@ -658,32 +658,32 @@ SC.ScrollView = SC.View.extend({
   scrollToRect: function(rect) {
     // find current visible frame.
     var vo = SC.cloneRect(this.get('containerView').get('frame')) ;
-    
+
     vo.x = this.get('horizontalScrollOffset') ;
     vo.y = this.get('verticalScrollOffset') ;
 
     var origX = vo.x, origY = vo.y;
-    
+
     // if top edge is not visible, shift origin
     vo.y -= Math.max(0, SC.minY(vo) - SC.minY(rect)) ;
     vo.x -= Math.max(0, SC.minX(vo) - SC.minX(rect)) ;
-    
+
     // if bottom edge is not visible, shift origin
     vo.y += Math.max(0, SC.maxY(rect) - SC.maxY(vo)) ;
     vo.x += Math.max(0, SC.maxX(rect) - SC.maxX(vo)) ;
-    
+
     // scroll to that origin.
     if ((origX !== vo.x) || (origY !== vo.y)) {
       this.scrollTo(vo.x, vo.y);
       return YES ;
     } else return NO;
   },
-  
-  
+
+
   /**
     Scrolls the receiver down one or more lines if allowed.  If number of
     lines is not specified, scrolls one line.
-    
+
     @param {Number} lines number of lines
     @returns {SC.ScrollView} receiver
   */
@@ -691,11 +691,11 @@ SC.ScrollView = SC.View.extend({
     if (lines === undefined) lines = 1 ;
     return this.scrollBy(null, this.get('verticalLineScroll')*lines) ;
   },
-  
+
   /**
     Scrolls the receiver up one or more lines if allowed.  If number of
     lines is not specified, scrolls one line.
-    
+
     @param {Number} lines number of lines
     @returns {SC.ScrollView} receiver
   */
@@ -703,11 +703,11 @@ SC.ScrollView = SC.View.extend({
     if (lines === undefined) lines = 1 ;
     return this.scrollBy(null, 0-this.get('verticalLineScroll')*lines) ;
   },
-  
+
   /**
     Scrolls the receiver right one or more lines if allowed.  If number of
     lines is not specified, scrolls one line.
-    
+
     @param {Number} lines number of lines
     @returns {SC.ScrollView} receiver
   */
@@ -715,11 +715,11 @@ SC.ScrollView = SC.View.extend({
     if (lines === undefined) lines = 1 ;
     return this.scrollTo(this.get('horizontalLineScroll')*lines, null) ;
   },
-  
+
   /**
     Scrolls the receiver left one or more lines if allowed.  If number of
     lines is not specified, scrolls one line.
-    
+
     @param {Number} lines number of lines
     @returns {SC.ScrollView} receiver
   */
@@ -727,13 +727,13 @@ SC.ScrollView = SC.View.extend({
     if (lines === undefined) lines = 1 ;
     return this.scrollTo(0-this.get('horizontalLineScroll')*lines, null) ;
   },
-  
+
   /**
     Scrolls the receiver down one or more page if allowed.  If number of
     pages is not specified, scrolls one page.  The page size is determined by
     the verticalPageScroll value.  By default this is the size of the current
     scrollable area.
-    
+
     @param {Number} pages number of lines
     @returns {SC.ScrollView} receiver
   */
@@ -741,13 +741,13 @@ SC.ScrollView = SC.View.extend({
     if (pages === undefined) pages = 1 ;
     return this.scrollBy(null, this.get('verticalPageScroll')*pages) ;
   },
-  
+
   /**
     Scrolls the receiver up one or more page if allowed.  If number of
     pages is not specified, scrolls one page.  The page size is determined by
     the verticalPageScroll value.  By default this is the size of the current
     scrollable area.
-    
+
     @param {Number} pages number of lines
     @returns {SC.ScrollView} receiver
   */
@@ -755,13 +755,13 @@ SC.ScrollView = SC.View.extend({
     if (pages === undefined) pages = 1 ;
     return this.scrollBy(null, 0-(this.get('verticalPageScroll')*pages)) ;
   },
-  
+
   /**
     Scrolls the receiver right one or more page if allowed.  If number of
     pages is not specified, scrolls one page.  The page size is determined by
     the verticalPageScroll value.  By default this is the size of the current
     scrollable area.
-    
+
     @param {Number} pages number of lines
     @returns {SC.ScrollView} receiver
   */
@@ -769,13 +769,13 @@ SC.ScrollView = SC.View.extend({
     if (pages === undefined) pages = 1 ;
     return this.scrollBy(this.get('horizontalPageScroll')*pages, null) ;
   },
-  
+
   /**
     Scrolls the receiver left one or more page if allowed.  If number of
     pages is not specified, scrolls one page.  The page size is determined by
     the verticalPageScroll value.  By default this is the size of the current
     scrollable area.
-    
+
     @param {Number} pages number of lines
     @returns {SC.ScrollView} receiver
   */
@@ -783,12 +783,12 @@ SC.ScrollView = SC.View.extend({
     if (pages === undefined) pages = 1 ;
     return this.scrollBy(0-(this.get('horizontalPageScroll')*pages), null) ;
   },
-  
+
   /** @private
     Adjusts the layout for the various internal views.  This method is called
     once when the scroll view is first configured and then anytime a scroller
     is shown or hidden.  You can call this method yourself as well to retile.
-    
+
     You may also want to override this method to handle layout for any
     additional controls you have added to the view.
   */
@@ -796,26 +796,26 @@ SC.ScrollView = SC.View.extend({
     // get horizontal scroller/determine if we should have a scroller
     var hscroll = this.get('hasHorizontalScroller') ? this.get('horizontalScrollerView') : null ;
     var hasHorizontal = hscroll && this.get('isHorizontalScrollerVisible');
-    
+
     // get vertical scroller/determine if we should have a scroller
     var vscroll = this.get('hasVerticalScroller') ? this.get('verticalScrollerView') : null ;
     var hasVertical = vscroll && this.get('isVerticalScrollerVisible') ;
-    
+
     // get the containerView
     var clip = this.get('containerView') ;
     var clipLayout = { left: 0, top: 0 } ;
     var t, layout, vo, ho, vl, hl;
-    
+
     var ht = ((hasHorizontal) ? hscroll.get('scrollbarThickness') : 0) ;
     var vt = (hasVertical) ?   vscroll.get('scrollbarThickness') : 0 ;
-    
+
     if (hasHorizontal) {
       hl     = this.get('horizontalScrollerLayout');
-      layout = { 
-        left: (hl ? hl.left : 0), 
-        bottom: (hl ? hl.bottom : 0), 
-        right: (hl ? hl.right + vt-1 : vt-1), 
-        height: ht 
+      layout = {
+        left: (hl ? hl.left : 0),
+        bottom: (hl ? hl.bottom : 0),
+        right: (hl ? hl.right + vt-1 : vt-1),
+        height: ht
       };
       hscroll.set('layout', layout) ;
       ho = this.get('horizontalOverlay');
@@ -824,15 +824,15 @@ SC.ScrollView = SC.View.extend({
       clipLayout.bottom = 0 ;
     }
     if (hscroll) hscroll.set('isVisible', hasHorizontal) ;
-    
+
     if (hasVertical) {
       ht     = ht + this.get('verticalScrollerBottom') ;
       vl     = this.get('verticalScrollerLayout');
-      layout = { 
-        top: (vl ? vl.top : 0), 
-        bottom: (vl ? vl.bottom + ht : ht), 
-        right: (vl ? vl.right : 0), 
-        width: vt 
+      layout = {
+        top: (vl ? vl.top : 0),
+        bottom: (vl ? vl.bottom + ht : ht),
+        right: (vl ? vl.right : 0),
+        width: vt
       };
       vscroll.set('layout', layout) ;
       vo = this.get('verticalOverlay');
@@ -844,32 +844,31 @@ SC.ScrollView = SC.View.extend({
 
     clip.adjust(clipLayout) ;
   },
-  
+
   /** @private
     Called whenever a scroller visibility changes.  Calls the tile() method.
   */
   scrollerVisibilityDidChange: function() {
     this.tile();
   }.observes('isVerticalScrollerVisible', 'isHorizontalScrollerVisible'),
-  
+
   // ..........................................................
   // SCROLL WHEEL SUPPORT
-  // 
-  
+  //
+
   /** @private */
   _scroll_wheelDeltaX: 0,
-  
+
   /** @private */
   _scroll_wheelDeltaY: 0,
-  
+
   /** @private */
   mouseWheel: function(evt) {
-    var deltaAdjust = (SC.browser.webkit && SC.browser.version > 533.0) ? 120 : 1;
-    
-    this._scroll_wheelDeltaX += evt.wheelDeltaX / deltaAdjust;
-    this._scroll_wheelDeltaY += evt.wheelDeltaY / deltaAdjust;
+    this._scroll_wheelDeltaX += evt.wheelDeltaX;
+    this._scroll_wheelDeltaY += evt.wheelDeltaY;
+
     this.invokeLater(this._scroll_mouseWheel, 10) ;
-    return this.get('canScrollHorizontal') || this.get('canScrollVertical') ;  
+    return this.get('canScrollHorizontal') || this.get('canScrollVertical') ;
   },
 
   /** @private */
@@ -888,24 +887,24 @@ SC.ScrollView = SC.View.extend({
       this._scroll_wheelDeltaX = 0;
     }
   },
-  
+
   /*..............................................
     SCALING SUPPORT
   */
-  
+
   /**
     Determines whether scaling is allowed.
-    
+
     @type Boolean
     @default NO
   */
   canScale: NO,
-  
+
   /** @private
     The current scale.
   */
   _scale: 1.0,
-  
+
   /**
     @field
     @type Number
@@ -917,39 +916,39 @@ SC.ScrollView = SC.View.extend({
     }
     return this._scale;
   }.property().cacheable(),
-  
+
   /**
     The minimum scale.
-    
+
     @type Number
     @default 0.25
   */
   minimumScale: 0.25,
-  
+
   /**
     The maximum scale.
-    
+
     @type Number
     @default 2.0
   */
   maximumScale: 2.0,
-  
+
   /**
     Whether to automatically determine the scale range based on the size of the content.
-    
+
     @type Boolean
     @default NO
   */
   autoScaleRange: NO,
-  
+
   /** @private */
   _scale_css: "",
-  
+
   /** @private */
   updateScale: function(scale) {
     var contentView = this.get("contentView");
     if (!contentView) return;
-    
+
     if (contentView.isScalable) {
       this.get("contentView").applyScale(scale);
       this._scale_css = "";
@@ -957,55 +956,55 @@ SC.ScrollView = SC.View.extend({
       this._scale_css = "scale3d(" + scale + ", " + scale + ", 1)";
     }
   },
-  
-  
+
+
   // ..........................................................
   // Touch Support
-  // 
-  
+  //
+
   /**
     @type Boolean
     @default YES
     @readOnly
   */
   acceptsMultitouch: YES,
-  
+
   /**
     The scroll deceleration rate.
-    
+
     @type Number
     @default SC.NORMAL_SCROLL_DECELERATION
   */
   decelerationRate: SC.NORMAL_SCROLL_DECELERATION,
-  
+
   /**
     If YES, bouncing will always be enabled in the horizontal direction, even if the content
     is smaller or the same size as the view.
-    
+
     @type Boolean
     @default NO
   */
   alwaysBounceHorizontal: NO,
-  
+
   /**
     If NO, bouncing will not be enabled in the vertical direction when the content is smaller
     or the same size as the scroll view.
-    
+
     @type Boolean
     @default YES
   */
   alwaysBounceVertical: YES,
-  
+
   /**
     Whether to delay touches from passing through to the content.
-    
+
     @type Boolean
     @default YES
   */
   delaysContentTouches: YES,
-  
+
   /** @private
-    If the view supports it, this 
+    If the view supports it, this
   */
   _touchScrollDidChange: function() {
     if (this.get("contentView").touchScrollDidChange) {
@@ -1014,23 +1013,23 @@ SC.ScrollView = SC.View.extend({
         this._scroll_verticalScrollOffset
       );
     }
-    
+
     // tell scrollers
     if (this.verticalScrollerView && this.verticalScrollerView.touchScrollDidChange) {
       this.verticalScrollerView.touchScrollDidChange(this._scroll_verticalScrollOffset);
     }
-    
+
     if (this.horizontalScrollerView && this.horizontalScrollerView.touchScrollDidChange) {
       this.horizontalScrollerView.touchScrollDidChange(this._scroll_horizontalScrollOffset);
     }
   },
-  
+
   /** @private */
   _touchScrollDidStart: function() {
     if (this.get("contentView").touchScrollDidStart) {
       this.get("contentView").touchScrollDidStart(this._scroll_horizontalScrollOffset, this._scroll_verticalScrollOffset);
     }
-    
+
     // tell scrollers
     if (this.verticalScrollerView && this.verticalScrollerView.touchScrollDidStart) {
       this.verticalScrollerView.touchScrollDidStart(this._touch_verticalScrollOffset);
@@ -1039,23 +1038,23 @@ SC.ScrollView = SC.View.extend({
       this.horizontalScrollerView.touchScrollDidStart(this._touch_horizontalScrollOffset);
     }
   },
-  
+
   /** @private */
   _touchScrollDidEnd: function() {
     if (this.get("contentView").touchScrollDidEnd) {
       this.get("contentView").touchScrollDidEnd(this._scroll_horizontalScrollOffset, this._scroll_verticalScrollOffset);
     }
-    
+
     // tell scrollers
     if (this.verticalScrollerView && this.verticalScrollerView.touchScrollDidEnd) {
       this.verticalScrollerView.touchScrollDidEnd(this._touch_verticalScrollOffset);
     }
-    
+
     if (this.horizontalScrollerView && this.horizontalScrollerView.touchScrollDidEnd) {
       this.horizontalScrollerView.touchScrollDidEnd(this._touch_horizontalScrollOffset);
     }
   },
-  
+
   /** @private */
   _applyCSSTransforms: function(layer) {
     var transform = "";
@@ -1063,19 +1062,20 @@ SC.ScrollView = SC.View.extend({
     transform += 'translate3d('+ -this._scroll_horizontalScrollOffset +'px, '+ -Math.round(this._scroll_verticalScrollOffset)+'px,0) ';
     transform += this._scale_css;
     if (layer) {
-      layer.style.webkitTransform = transform;
-      layer.style.webkitTransformOrigin = "top left";
+      var style = layer.style;
+      style.webkitTransform = transform;
+      style.webkitTransformOrigin = "top left";
     }
   },
-  
+
   /** @private */
   captureTouch: function(touch) {
     return YES;
   },
-  
+
   /** @private */
   touchGeneration: 0,
-  
+
   /** @private */
   touchStart: function(touch) {
     var generation = ++this.touchGeneration;
@@ -1093,21 +1093,21 @@ SC.ScrollView = SC.View.extend({
   /** @private */
   beginTouchesInContent: function(gen) {
     if (gen !== this.touchGeneration) return;
-    
+
     var touch = this.touch, itemView;
-        
+
     // NOTE!  On iPad it is possible that the timer set in touchStart() will not have yet fired and that touchEnd() will
-    // come in in the same Run Loop as the one that started with the call to touchStart().  The bad thing that happens is that 
+    // come in in the same Run Loop as the one that started with the call to touchStart().  The bad thing that happens is that
     // even though we cleared this.touch, occasionally if touchEnd() comes in right at the end of the Run Loop and
     // then the timer expires and starts a new Run Loop to call beginTouchesInContent(), that this.touch will STILL exist
     // here.  There's no explanation for it, and it's not 100% reproducible, but what happens is that if we try to capture
     // the touch that has already ended, assignTouch() in RootResponder will check touch.hasEnded and throw an exception.
-    
+
     // Therefore, don't capture a touch if the touch still exists and hasEnded
     if (touch && this.tracking && !this.dragging && !touch.touch.scrollHasEnded && !touch.touch.hasEnded) {
       // try to capture the touch
       touch.touch.captureTouch(this, YES);
-      
+
       if (!touch.touch.touchResponder) {
         // if it DIDN'T WORK!!!!!
         // then we need to take possession again.
@@ -1131,35 +1131,44 @@ SC.ScrollView = SC.View.extend({
   */
   beginTouchTracking: function(touch, starting) {
     var avg = touch.averagedTouchesForView(this, starting);
-    
+
     var verticalScrollOffset = this._scroll_verticalScrollOffset || 0,
         horizontalScrollOffset = this._scroll_horizontalScrollOffset || 0,
         startClipOffsetX = horizontalScrollOffset,
         startClipOffsetY = verticalScrollOffset,
-        needsScrollEnd = NO;
-    
+        needsScrollEnd = NO,
+        contentWidth = 0,
+        contentHeight = 0,
+        viewFrame,
+        view;
+
     if (this.touch && this.touch.timeout) {
       // clear the timeout
       clearTimeout(this.touch.timeout);
       this.touch.timeout = null;
-      
+
       // get the scroll offsets
       startClipOffsetX = this.touch.startClipOffset.x;
       startClipOffsetY = this.touch.startClipOffset.y;
       needsScrollEnd = YES;
     }
-    
+
     // calculate container+content width/height
-    var view = this.get('contentView') ;
-    var contentWidth = view ? view.get('frame').width : 0,
-        contentHeight = view ? view.get('frame').height : 0;
-    
+    view = this.get('contentView') ;
+
+    if(view){
+      viewFrame = view.get('frame');
+      contentWidth = viewFrame.width;
+      contentHeight = viewFrame.height;
+    }
+
     if(view.calculatedWidth && view.calculatedWidth!==0) contentWidth = view.calculatedWidth;
     if (view.calculatedHeight && view.calculatedHeight !==0) contentHeight = view.calculatedHeight;
-    
-    var containerWidth = this.get('containerView').get('frame').width,
-        containerHeight = this.get('containerView').get('frame').height;
-    
+
+    var containerFrame = this.get('containerView').get('frame'),
+        containerWidth = containerFrame.width,
+        containerHeight = containerFrame.height;
+
 
     // calculate position in content
     var globalFrame = this.convertFrameToView(this.get("frame"), null),
@@ -1169,62 +1178,62 @@ SC.ScrollView = SC.View.extend({
     this.touch = {
       startTime: touch.timeStamp,
       notCalculated: YES,
-      
-      enableScrolling: { 
-        x: contentWidth * this._scale > containerWidth || this.get("alwaysBounceHorizontal"), 
-        y: contentHeight * this._scale > containerHeight || this.get("alwaysBounceVertical") 
+
+      enableScrolling: {
+        x: contentWidth * this._scale > containerWidth || this.get("alwaysBounceHorizontal"),
+        y: contentHeight * this._scale > containerHeight || this.get("alwaysBounceVertical")
       },
       scrolling: { x: NO, y: NO },
-      
+
       enableBouncing: SC.platform.bounceOnScroll,
-      
+
       // offsets and velocities
       startClipOffset: { x: startClipOffsetX, y: startClipOffsetY },
       lastScrollOffset: { x: horizontalScrollOffset, y: verticalScrollOffset },
       startTouchOffset: { x: avg.x, y: avg.y },
       scrollVelocity: { x: 0, y: 0 },
-      
+
       startTouchOffsetInContent: { x: positionInContentX, y: positionInContentY },
-      
+
       containerSize: { width: containerWidth, height: containerHeight },
       contentSize: { width: contentWidth, height: contentHeight },
-      
+
       startScale: this._scale,
       startDistance: avg.d,
       canScale: this.get("canScale") && SC.platform.pinchToZoom,
       minimumScale: this.get("minimumScale"),
       maximumScale: this.get("maximumScale"),
-      
+
       globalFrame: globalFrame,
-      
+
       // cache some things
-      layer: this.get("contentView").get('layer'),
+      layer: view.get('layer'), //contentView
 
       // some constants
       resistanceCoefficient: 0.998,
       resistanceAsymptote: 320,
       decelerationFromEdge: 0.05,
       accelerationToEdge: 0.1,
-      
+
       // how much percent of the other drag direction you must drag to start dragging that direction too.
       scrollTolerance: { x: 15, y: 15 },
       scaleTolerance: 5,
       secondaryScrollTolerance: 30,
       scrollLock: 500,
-      
+
       decelerationRate: this.get("decelerationRate"),
 
       // general status
-      lastEventTime: touch.timeStamp,      
-      
+      lastEventTime: touch.timeStamp,
+
       // the touch used
       touch: (starting ? touch : (this.touch ? this.touch.touch : null)),
-      
+
       // needsScrollEnd will cause a scrollDidEnd even if this particular touch does not start a scroll.
       // the reason for this is because we don't want to say we've stopped scrolling just because we got
       // another touch, but simultaneously, we still need to send a touch end eventually.
       // there are two cases in which this will be used:
-      // 
+      //
       //    1. If the touch was sent to content touches (in which case we will not be scrolling)
       //    2. If the touch ends before scrolling starts (no scrolling then, either)
       needsScrollEnd: needsScrollEnd
@@ -1235,33 +1244,33 @@ SC.ScrollView = SC.View.extend({
       this.dragging = NO;
     }
   },
-  
+
   /** @private */
   _adjustForEdgeResistance: function(offset, minOffset, maxOffset, resistanceCoefficient, asymptote) {
     var distanceFromEdge;
-    
+
     // find distance from edge
     if (offset < minOffset) distanceFromEdge = offset - minOffset;
     else if (offset > maxOffset) distanceFromEdge = maxOffset - offset;
     else return offset;
-    
+
     // manipulate logarithmically
     distanceFromEdge = Math.pow(resistanceCoefficient, Math.abs(distanceFromEdge)) * asymptote;
-    
+
     // adjust mathematically
     if (offset < minOffset) distanceFromEdge = distanceFromEdge - asymptote;
     else distanceFromEdge = -distanceFromEdge + asymptote;
-    
+
     // generate final value
     return Math.min(Math.max(minOffset, offset), maxOffset) + distanceFromEdge;
   },
-  
+
   /** @private */
   touchesDragged: function(evt, touches) {
     var avg = evt.averagedTouchesForView(this);
     this.updateTouchScroll(avg.x, avg.y, avg.d, evt.timeStamp);
   },
-  
+
   /** @private */
   updateTouchScroll: function(touchX, touchY, distance, timeStamp) {
     // get some vars
@@ -1272,62 +1281,65 @@ SC.ScrollView = SC.View.extend({
         maxOffsetY,
         offsetX,
         maxOffsetX,
-        minOffsetX, minOffsetY;
-        
+        minOffsetX, minOffsetY,
+        touchScroll = touch.scrolling,
+        hAlign = this.get("horizontalAlign"),
+        vAlign = this.get("verticalAlign");
+
     // calculate new position in content
     var positionInContentX = ((this._scroll_horizontalScrollOffset||0) + touchXInFrame) / this._scale,
         positionInContentY = ((this._scroll_verticalScrollOffset||0) + touchYInFrame) / this._scale;
-    
+
     // calculate deltas
     var deltaX = positionInContentX - touch.startTouchOffsetInContent.x,
         deltaY = positionInContentY - touch.startTouchOffsetInContent.y;
-    
+
     var isDragging = touch.dragging;
-    if (!touch.scrolling.x && Math.abs(deltaX) > touch.scrollTolerance.x && touch.enableScrolling.x) {
+    if (!touchScroll.x && Math.abs(deltaX) > touch.scrollTolerance.x && touch.enableScrolling.x) {
       // say we are scrolling
       isDragging = YES;
-      touch.scrolling.x = YES;
+      touchScroll.x = YES;
       touch.scrollTolerance.y = touch.secondaryScrollTolerance;
-      
+
       // reset position
       touch.startTouchOffset.x = touchX;
       deltaX = 0;
     }
-    if (!touch.scrolling.y && Math.abs(deltaY) > touch.scrollTolerance.y && touch.enableScrolling.y) {
+    if (!touchScroll.y && Math.abs(deltaY) > touch.scrollTolerance.y && touch.enableScrolling.y) {
       // say we are scrolling
       isDragging = YES;
-      touch.scrolling.y = YES;
+      touchScroll.y = YES;
       touch.scrollTolerance.x = touch.secondaryScrollTolerance;
-      
+
       // reset position
       touch.startTouchOffset.y = touchY;
       deltaY = 0;
     }
-    
+
     // handle scroll start
     if (isDragging && !touch.dragging) {
       touch.dragging = YES;
       this.dragging = YES;
       this._touchScrollDidStart();
     }
-    
+
     // calculate new offset
-    if (!touch.scrolling.x && !touch.scrolling.y && !touch.canScale) return;
-    if (touch.scrolling.x && !touch.scrolling.y) {
-      if (deltaX > touch.scrollLock && !touch.scrolling.y) touch.enableScrolling.y = NO;
+    if (!touchScroll.x && !touchScroll.y && !touch.canScale) return;
+    if (touchScroll.x && !touchScroll.y) {
+      if (deltaX > touch.scrollLock && !touchScroll.y) touch.enableScrolling.y = NO;
     }
-    if (touch.scrolling.y && !touch.scrolling.x) {
-      if (deltaY > touch.scrollLock && !touch.scrolling.x) touch.enableScrolling.x = NO;
+    if (touchScroll.y && !touchScroll.x) {
+      if (deltaY > touch.scrollLock && !touchScroll.x) touch.enableScrolling.x = NO;
     }
-    
+
     // handle scaling through pinch gesture
     if (touch.canScale) {
-      
+
       var startDistance = touch.startDistance, dd = distance - startDistance;
       if (Math.abs(dd) > touch.scaleTolerance) {
-        touch.scrolling.y = YES; // if you scale, you can scroll.
-        touch.scrolling.x = YES;
-        
+        touchScroll.y = YES; // if you scale, you can scroll.
+        touchScroll.x = YES;
+
         // we want to say something that was the startDistance away from each other should now be
         // distance away. So, if we are twice as far away as we started...
         var scale = touch.startScale * (distance / Math.max(startDistance, 50));
@@ -1339,28 +1351,28 @@ SC.ScrollView = SC.View.extend({
             newPositionInContentY = positionInContentY * this._scale;
       }
     }
-    
+
     // these do exactly what they sound like. So, this comment is just to
     // block off the code a bit
     // In english, these calculate the minimum X/Y offsets
-    minOffsetX = this.minimumScrollOffset(touch.contentSize.width * this._scale, touch.containerSize.width, this.get("horizontalAlign"));
-    minOffsetY = this.minimumScrollOffset(touch.contentSize.height * this._scale, touch.containerSize.height, this.get("verticalAlign"));
-    
+    minOffsetX = this.minimumScrollOffset(touch.contentSize.width * this._scale, touch.containerSize.width, hAlign);
+    minOffsetY = this.minimumScrollOffset(touch.contentSize.height * this._scale, touch.containerSize.height, vAlign);
+
     // and now, maximum...
-    maxOffsetX = this.maximumScrollOffset(touch.contentSize.width * this._scale, touch.containerSize.width, this.get("horizontalAlign"));
-    maxOffsetY = this.maximumScrollOffset(touch.contentSize.height * this._scale, touch.containerSize.height, this.get("verticalAlign"));
-    
-    
+    maxOffsetX = this.maximumScrollOffset(touch.contentSize.width * this._scale, touch.containerSize.width, hAlign);
+    maxOffsetY = this.maximumScrollOffset(touch.contentSize.height * this._scale, touch.containerSize.height, vAlign);
+
+
     // So, the following is the completely written out algebra:
     // (offsetY + touchYInFrame) / this._scale = touch.startTouchOffsetInContent.y
     // offsetY + touchYInFrame = touch.startTouchOffsetInContent.y * this._scale;
     // offsetY = touch.startTouchOffset * this._scale - touchYInFrame
-    
+
     // and the result applied:
     offsetX = touch.startTouchOffsetInContent.x * this._scale - touchXInFrame;
     offsetY = touch.startTouchOffsetInContent.y * this._scale - touchYInFrame;
-    
-    
+
+
     // we need to adjust for edge resistance, or, if bouncing is disabled, just stop flat.
     if (touch.enableBouncing) {
       offsetX = this._adjustForEdgeResistance(offsetX, minOffsetX, maxOffsetX, touch.resistanceCoefficient, touch.resistanceAsymptote);
@@ -1369,22 +1381,22 @@ SC.ScrollView = SC.View.extend({
       offsetX = Math.max(minOffsetX, Math.min(maxOffsetX, offsetX));
       offsetY = Math.max(minOffsetY, Math.min(maxOffsetY, offsetY));
     }
-    
+
     // and now, _if_ scrolling is enabled, set the new coordinates
-    if (touch.scrolling.x) this._scroll_horizontalScrollOffset = offsetX;
-    if (touch.scrolling.y) this._scroll_verticalScrollOffset = offsetY;
-    
+    if (touchScroll.x) this._scroll_horizontalScrollOffset = offsetX;
+    if (touchScroll.y) this._scroll_verticalScrollOffset = offsetY;
+
     // and apply the CSS transforms.
     this._applyCSSTransforms(touch.layer);
     this._touchScrollDidChange();
-    
-    
+
+
     // now we must prepare for momentum scrolling by calculating the momentum.
     if (timeStamp - touch.lastEventTime >= 1 || touch.notCalculated) {
       touch.notCalculated = NO;
       var horizontalOffset = this._scroll_horizontalScrollOffset;
       var verticalOffset = this._scroll_verticalScrollOffset;
-      
+
       touch.scrollVelocity.x = ((horizontalOffset - touch.lastScrollOffset.x) / Math.max(1, timeStamp - touch.lastEventTime)); // in px per ms
       touch.scrollVelocity.y = ((verticalOffset - touch.lastScrollOffset.y) / Math.max(1, timeStamp - touch.lastEventTime)); // in px per ms
       touch.lastScrollOffset.x = horizontalOffset;
@@ -1397,7 +1409,7 @@ SC.ScrollView = SC.View.extend({
   touchEnd: function(touch) {
     var touchStatus = this.touch,
         avg = touch.averagedTouchesForView(this);
-    
+
     touch.scrollHasEnded = YES;
     if (avg.touchCount > 0) {
       this.beginTouchTracking(touch, NO);
@@ -1412,12 +1424,12 @@ SC.ScrollView = SC.View.extend({
       } else {
         // well. The scrolling stopped. Let us tell everyone if there was a pending one that this non-drag op interrupted.
         if (touchStatus.needsScrollEnd) this._touchScrollDidEnd();
-        
+
         // this part looks weird, but it is actually quite simple.
         // First, we send the touch off for capture+starting again, but telling it to return to us
         // if nothing is found or if it is released.
         touch.captureTouch(this, YES);
-        
+
         // if we went anywhere, did anything, etc., call end()
         if (touch.touchResponder && touch.touchResponder !== this) {
           touch.end();
@@ -1425,26 +1437,26 @@ SC.ScrollView = SC.View.extend({
           // if it was released to us or stayed with us the whole time, or is for some
           // wacky reason empty (in which case it is ours still). If so, and there is a next responder,
           // relay to that.
-          
+
           if (touch.nextTouchResponder) touch.makeTouchResponder(touch.nextTouchResponder);
         } else {
           // in this case, the view that captured it and changed responder should have handled
           // everything for us.
         }
-        
+
         this.touch = null;
       }
-      
+
       this.tracking = NO;
       this.dragging = NO;
     }
   },
-  
+
   /** @private */
   touchCancelled: function(touch) {
     var touchStatus = this.touch,
         avg = touch.averagedTouchesForView(this);
-    
+
     // if we are decelerating, we don't want to stop that. That would be bad. Because there's no point.
     if (!this.touch || !this.touch.timeout) {
       this.beginPropertyChanges();
@@ -1453,11 +1465,11 @@ SC.ScrollView = SC.View.extend({
       this.set("horizontalScrollOffset", this._scroll_horizontalScrollOffset);
       this.endPropertyChanges();
       this.tracking = NO;
-    
+
       if (this.dragging) {
         this._touchScrollDidEnd();
       }
-    
+
       this.dragging = NO;
       this.touch = null;
     }
@@ -1470,16 +1482,16 @@ SC.ScrollView = SC.View.extend({
       x: touch.scrollVelocity.x * 10,
       y: touch.scrollVelocity.y * 10
     };
-    
+
     this.decelerateAnimation();
   },
-  
+
   /** @private
     Does bounce calculations, adjusting velocity.
-    
+
     Bouncing is fun. Functions that handle it should have fun names,
     don'tcha think?
-    
+
     P.S.: should this be named "bouncityBounce" instead?
   */
   bouncyBounce: function(velocity, value, minValue, maxValue, de, ac, additionalAcceleration) {
@@ -1520,24 +1532,28 @@ SC.ScrollView = SC.View.extend({
     // be changed later in this function).
     var touch = this.touch,
         scale = this._scale,
-        minOffsetX = this.minimumScrollOffset(touch.contentSize.width * this._scale, touch.containerSize.width, this.get("horizontalAlign")),
-        minOffsetY = this.minimumScrollOffset(touch.contentSize.height * this._scale, touch.containerSize.height, this.get("verticalAlign")),
-        maxOffsetX = this.maximumScrollOffset(touch.contentSize.width * this._scale, touch.containerSize.width, this.get("horizontalAlign")),
-        maxOffsetY = this.maximumScrollOffset(touch.contentSize.height * this._scale, touch.containerSize.height, this.get("verticalAlign")),
-        
+        touchDim = touch.contentSize,
+        touchContainerDim = touch.containerSize,
+        hAlign = this.get("horizontalAlign"),
+        vAlign = this.get("verticalAlign"),
+        minOffsetX = this.minimumScrollOffset(touchDim.width * this._scale, touchContainerDim.width, hAlign),
+        minOffsetY = this.minimumScrollOffset(touchDim.height * this._scale, touchContainerDim.height, vAlign),
+        maxOffsetX = this.maximumScrollOffset(touchDim.width * this._scale, touchContainerDim.width, hAlign),
+        maxOffsetY = this.maximumScrollOffset(touchDim.height * this._scale, touchContainerDim.height, vAlign),
+
         now = Date.now(),
         t = Math.max(now - touch.lastEventTime, 1),
-        
+
         newX = this._scroll_horizontalScrollOffset + touch.decelerationVelocity.x * (t/10),
         newY = this._scroll_verticalScrollOffset + touch.decelerationVelocity.y * (t/10);
-    
+
     var de = touch.decelerationFromEdge, ac = touch.accelerationToEdge;
-    
+
     // under a few circumstances, we may want to force a valid X/Y position.
     // For instance, if bouncing is disabled, or if position was okay before
     // adjusting scale.
     var forceValidXPosition = !touch.enableBouncing, forceValidYPosition = !touch.enableBouncing;
-    
+
     // determine if position was okay before adjusting scale (which we do, in
     // a lovely, animated way, for the scaled out/in too far bounce-back).
     // if the position was okay, then we are going to make sure that we keep the
@@ -1547,7 +1563,7 @@ SC.ScrollView = SC.View.extend({
     // minimum and maximum scroll offsets)
     if (newX >= minOffsetX && newX <= maxOffsetX) forceValidXPosition = YES;
     if (newY >= minOffsetY && newY <= maxOffsetY) forceValidYPosition = YES;
-    
+
     // We are going to change scale in a moment, but the position should stay the
     // same, if possible (unless it would be more jarring, as described above, in
     // the case of starting with a valid position and ending with an invalid one).
@@ -1559,67 +1575,67 @@ SC.ScrollView = SC.View.extend({
     // bounces back around the center of the screen?
     newX /= this._scale;
     newY /= this._scale;
-    
-    // scale velocity (amount to change) starts out at 0 each time, because 
+
+    // scale velocity (amount to change) starts out at 0 each time, because
     // it is calculated by how far out of bounds it is, rather than by the
     // previous such velocity.
     var sv = 0;
-    
+
     // do said calculation; we'll use the same bouncyBounce method used for everything
     // else, but our adjustor that gives a minimum amount to change by and (which, as we'll
-    // discuss, is to make the stop feel slightly more like a stop), we'll leave at 0 
-    // (scale doesn't really need it as much; if you disagree, at least come up with 
+    // discuss, is to make the stop feel slightly more like a stop), we'll leave at 0
+    // (scale doesn't really need it as much; if you disagree, at least come up with
     // numbers more appropriate for scale than the ones for X/Y)
     sv = this.bouncyBounce(sv, scale, touch.minimumScale, touch.maximumScale, de, ac, 0);
-    
+
     // add the amount to scale. This is linear, rather than multiplicative. If you think
     // it should be multiplicative (or however you say that), come up with a new formula.
     this._scale = scale = scale + sv;
-    
+
     // now we can convert newX/Y back to scale-specific coordinates...
     newX *= this._scale;
     newY *= this._scale;
-    
+
     // It looks very weird if the content started in-bounds, but the scale animation
     // made it not be in bounds; it causes the position to animate snapping back, and,
     // well, it looks very weird. It is more proper to just make sure it stays in a valid
     // position. So, we'll determine the new maximum/minimum offsets, and then, if it was
     // originally a valid position, we'll adjust the new position to a valid position as well.
-    
-    
+
+
     // determine new max offset
-    minOffsetX = this.minimumScrollOffset(touch.contentSize.width * this._scale, touch.containerSize.width, this.get("horizontalAlign"));
-    minOffsetY = this.minimumScrollOffset(touch.contentSize.height * this._scale, touch.containerSize.height, this.get("verticalAlign"));
-    maxOffsetX = this.maximumScrollOffset(touch.contentSize.width * this._scale, touch.containerSize.width, this.get("horizontalAlign"));
-    maxOffsetY = this.maximumScrollOffset(touch.contentSize.height * this._scale, touch.containerSize.height, this.get("verticalAlign"));
-    
+    minOffsetX = this.minimumScrollOffset(touchDim.width * this._scale, touchContainerDim.width, hAlign);
+    minOffsetY = this.minimumScrollOffset(touchDim.height * this._scale, touchContainerDim.height, vAlign);
+    maxOffsetX = this.maximumScrollOffset(touchDim.width * this._scale, touchContainerDim.width, hAlign);
+    maxOffsetY = this.maximumScrollOffset(touchDim.height * this._scale, touchContainerDim.height, vAlign);
+
     // see if scaling messed up the X position (but ignore if 'tweren't right to begin with).
     if (forceValidXPosition && (newX < minOffsetX || newX > maxOffsetX)) {
       // Correct the position
       newX = Math.max(minOffsetX, Math.min(newX, maxOffsetX));
-      
+
       // also, make the velocity be ZERO; it is obviously not needed...
       touch.decelerationVelocity.x = 0;
     }
-    
+
     // now the y
     if (forceValidYPosition && (newY < minOffsetY || newY > maxOffsetY)) {
       // again, correct it...
       newY = Math.max(minOffsetY, Math.min(newY, maxOffsetY));
-      
+
       // also, make the velocity be ZERO; it is obviously not needed...
       touch.decelerationVelocity.y = 0;
     }
-    
-    
+
+
     // now that we are done modifying the position, we may update the actual scroll
     this._scroll_horizontalScrollOffset = newX;
     this._scroll_verticalScrollOffset = newY;
-    
+
     this._applyCSSTransforms(touch.layer); // <- Does what it sounds like.
 
     this._touchScrollDidChange();
-    
+
     // Now we have to adjust the velocities. The velocities are simple x and y numbers that
     // get added to the scroll X/Y positions each frame.
     // The default decay rate is .950 per frame. To achieve some semblance of accuracy, we
@@ -1628,34 +1644,35 @@ SC.ScrollView = SC.View.extend({
     // modify the velocity for the next frame. My mind goes blank when I try to figure out
     // a way to fix this (given that we don't want to change the velocity on the first frame),
     // and as it seems to work great as-is, I'm just leaving it.
-    var decay = touch.decelerationRate;
-    touch.decelerationVelocity.y *= Math.pow(decay, (t / 10));
-    touch.decelerationVelocity.x *= Math.pow(decay, (t / 10));
-    
+    var decay = touch.decelerationRate,
+        decayXtime = Math.pow(decay, (t / 10));
+    touch.decelerationVelocity.y *= decayXtime;
+    touch.decelerationVelocity.x *= decayXtime;
+
     // We have a bouncyBounce method that adjusts the velocity for bounce. That is, if it is
     // out of range and still going, it will slow it down. This step is decelerationFromEdge.
-    // If it is not moving (or has come to a stop from decelerating), but is still out of range, 
+    // If it is not moving (or has come to a stop from decelerating), but is still out of range,
     // it will start it moving back into range (accelerationToEdge)
     // we supply de and ac as these properties.
     // The .3 artificially increases the acceleration by .3; this is actually to make the final
     // stop a bit more abrupt.
     touch.decelerationVelocity.x = this.bouncyBounce(touch.decelerationVelocity.x, newX, minOffsetX, maxOffsetX, de, ac, 0.3);
     touch.decelerationVelocity.y = this.bouncyBounce(touch.decelerationVelocity.y, newY, minOffsetY, maxOffsetY, de, ac, 0.3);
- 
+
     // if we ain't got no velocity... then we must be finished, as there is no where else to go.
     // to determine our velocity, we take the absolue value, and use that; if it is less than .01, we
     // must be done. Note that we check scale's most recent velocity, calculated above using bouncyBounce,
     // as well.
-    var absXVelocity = Math.abs(touch.decelerationVelocity.x);
-    var absYVelocity = Math.abs(touch.decelerationVelocity.y);
+    var absXVelocity = Math.abs(touch.decelerationVelocity.x),
+        absYVelocity = Math.abs(touch.decelerationVelocity.y);
     if (absYVelocity < 0.05 && absXVelocity < 0.05 && Math.abs(sv) < 0.05) {
       // we can reset the timeout, as it will no longer be required, and we don't want to re-cancel it later.
       touch.timeout = null;
       this.touch = null;
-      
+
       // trigger scroll end
       this._touchScrollDidEnd();
-      
+
       // set the scale, vertical, and horizontal offsets to what they technically already are,
       // but don't know they are yet. This will finally update things like, say, the clipping frame.
       this.beginPropertyChanges();
@@ -1663,10 +1680,10 @@ SC.ScrollView = SC.View.extend({
       this.set("verticalScrollOffset", this._scroll_verticalScrollOffset);
       this.set("horizontalScrollOffset", this._scroll_horizontalScrollOffset);
       this.endPropertyChanges();
-      
+
       return;
     }
-    
+
     // We now set up the next round. We are doing this as raw as we possibly can, not touching the
     // run loop at all. This speeds up performance drastically--keep in mind, we're on comparatively
     // slow devices, here. So, we'll just make a closure, saving "this" into "self" and calling
@@ -1676,32 +1693,32 @@ SC.ScrollView = SC.View.extend({
     touch.lastEventTime = Date.now();
     this.touch.timeout = setTimeout(function(){
       SC.run(self.decelerateAnimation(), self);
-    }, 10);
+    }, 30);
   },
-  
+
   // ..........................................................
   // INTERNAL SUPPORT
-  // 
-  
+  //
+
   /** @private
     Instantiate scrollers & container views as needed.  Replace their classes
     in the regular properties.
   */
   createChildViews: function() {
-    var childViews = [] , view; 
-       
-    // create the containerView.  We must always have a container view. 
+    var childViews = [] , view;
+
+    // create the containerView.  We must always have a container view.
     // also, setup the contentView as the child of the containerView...
     if (SC.none(view = this.containerView)) view = SC.ContainerView;
-    
+
     childViews.push(this.containerView = this.createChildView(view, {
       contentView: this.contentView,
       isScrollContainer: YES
     }));
-    
+
     // and replace our own contentView...
     this.contentView = this.containerView.get('contentView');
-    
+
     // create a horizontal scroller view if needed...
     view = SC.platform.touch ? this.get("horizontalTouchScrollerView") : this.get("horizontalScrollerView");
     if (view) {
@@ -1713,7 +1730,7 @@ SC.ScrollView = SC.View.extend({
         childViews.push(view);
       } else this.horizontalScrollerView = null ;
     }
-    
+
     // create a vertical scroller view if needed...
     view = SC.platform.touch ? this.get("verticalTouchScrollerView") : this.get("verticalScrollerView");
     if (view) {
@@ -1725,20 +1742,20 @@ SC.ScrollView = SC.View.extend({
         childViews.push(view);
       } else this.verticalScrollerView = null ;
     }
-    
+
     // set childViews array.
     this.childViews = childViews ;
-    
+
     this.contentViewDidChange() ; // setup initial display...
     this.tile() ; // set up initial tiling
   },
-  
+
   /** @private */
   init: function() {
     sc_super();
-    
+
     // start observing initial content view.  The content view's frame has
-    // already been setup in prepareDisplay so we don't need to call 
+    // already been setup in prepareDisplay so we don't need to call
     // viewFrameDidChange...
     this._scroll_contentView = this.get('contentView') ;
     var contentView = this._scroll_contentView ;
@@ -1751,7 +1768,7 @@ SC.ScrollView = SC.View.extend({
 
     if (this.get('isVisibleInWindow')) this._scsv_registerAutoscroll() ;
   },
-  
+
   /** @private
     Registers/deregisters view with SC.Drag for autoscrolling
   */
@@ -1759,7 +1776,7 @@ SC.ScrollView = SC.View.extend({
     if (this.get('isVisibleInWindow')) SC.Drag.addScrollableView(this);
     else SC.Drag.removeScrollableView(this);
   }.observes('isVisibleInWindow'),
-  
+
   /** @private
     Whenever the contentView is changed, we need to observe the content view's
     frame to be notified whenever it's size changes.
@@ -1771,7 +1788,7 @@ SC.ScrollView = SC.View.extend({
         layerObserver = this.contentViewLayerDidChange;
 
     if (newView !== oldView) {
-      
+
       // stop observing old content view
       if (oldView) {
         oldView.removeObserver('calculatedWidth', this, this.contentViewFrameDidChange);
@@ -1779,7 +1796,7 @@ SC.ScrollView = SC.View.extend({
         oldView.removeObserver('frame', this, frameObserver);
         oldView.removeObserver('layer', this, layerObserver);
       }
-      
+
       // update cache
       this._scroll_contentView = newView;
       if (newView) {
@@ -1788,10 +1805,10 @@ SC.ScrollView = SC.View.extend({
         newView.addObserver('calculatedHeight', this, this.contentViewFrameDidChange);
         newView.addObserver('layer', this, layerObserver);
       }
-      
+
       // replace container
       this.containerView.set('contentView', newView);
-      
+
       this.contentViewFrameDidChange();
     }
   }.observes('contentView'),
@@ -1813,20 +1830,20 @@ SC.ScrollView = SC.View.extend({
 
   /** @private */
   oldMaxHOffset: 0,
-  
+
   /** @private */
   oldMaxVOffset: 0,
 
   /** @private
-    Invoked whenever the contentView's frame changes.  This will update the 
-    scroller maxmimum and optionally update the scroller visibility if the
+    Invoked whenever the contentView's frame changes.  This will update the
+    scroller maximum and optionally update the scroller visibility if the
     size of the contentView changes.  We don't care about the origin since
     that is tracked separately from the offset values.
 
     @param {Boolean} force (optional)  Re-calculate everything even if the contentView’s frame didn’t change size
   */
   contentViewFrameDidChange: function(force) {
-    var view   = this.get('contentView'), 
+    var view   = this.get('contentView'),
         f      = (view) ? view.get('frame') : null,
         scale  = this._scale,
         width  = 0,
@@ -1851,7 +1868,7 @@ SC.ScrollView = SC.View.extend({
     dim       = this.getPath('containerView.frame');
     dimWidth  = dim.width;
     dimHeight = dim.height;
-    
+
     if (this.get('hasHorizontalScroller') && (view = this.get('horizontalScrollerView'))) {
       // decide if it should be visible or not
       if (this.get('autohidesHorizontalScroller')) {
@@ -1860,7 +1877,7 @@ SC.ScrollView = SC.View.extend({
       view.setIfChanged('maximum', width-dimWidth) ;
       view.setIfChanged('proportion', dimWidth/width);
     }
-    
+
     if (this.get('hasVerticalScroller') && (view = this.get('verticalScrollerView'))) {
       // decide if it should be visible or not
       if (this.get('autohidesVerticalScroller')) {
@@ -1869,20 +1886,20 @@ SC.ScrollView = SC.View.extend({
       view.setIfChanged('maximum', height-dimHeight) ;
       view.setIfChanged('proportion', dimHeight/height);
     }
-    
+
     // If there is no vertical scroller and auto hiding is on, make
     // sure we are at the top if not already there
-    if (!this.get('isVerticalScrollerVisible') && (this.get('verticalScrollOffset') !== 0) && 
+    if (!this.get('isVerticalScrollerVisible') && (this.get('verticalScrollOffset') !== 0) &&
        this.get('autohidesVerticalScroller')) {
       this.set('verticalScrollOffset', 0);
     }
-    
+
     // Same thing for horizontal scrolling.
-    if (!this.get('isHorizontalScrollerVisible') && (this.get('horizontalScrollOffset') !== 0) && 
+    if (!this.get('isHorizontalScrollerVisible') && (this.get('horizontalScrollOffset') !== 0) &&
        this.get('autohidesHorizontalScroller')) {
       this.set('horizontalScrollOffset', 0);
     }
-    
+
     // This forces to recalculate the height of the frame when is at the bottom
     // of the scroll and the content dimension are smaller that the previous one
     var mxVOffSet   = this.get('maximumVerticalScrollOffset'),
@@ -1894,10 +1911,14 @@ SC.ScrollView = SC.View.extend({
     if (forceHeight || forceWidth) {
       this.forceDimensionsRecalculation(forceWidth, forceHeight, vOffSet, hOffSet);
     }
+
+    // send change notifications since they don't invalidate automatically
+    this.notifyPropertyChange('maximumVerticalScrollOffset');
+    this.notifyPropertyChange('maximumHorizontalScrollOffset');
   },
 
   /** @private
-    If our frame changes, then we need to re-calculate the visiblility of our
+    If our frame changes, then we need to re-calculate the visibility of our
     scrollers, etc.
   */
   frameDidChange: function() {
@@ -1916,15 +1937,15 @@ SC.ScrollView = SC.View.extend({
   },
 
   /** @private
-    Whenever the horizontal scroll offset changes, update the scrollers and 
+    Whenever the horizontal scroll offset changes, update the scrollers and
     edit the location of the contentView.
   */
   _scroll_horizontalScrollOffsetDidChange: function() {
     this.invokeLast(this.adjustElementScroll);
   }.observes('horizontalScrollOffset'),
-  
+
   /** @private
-    Whenever the vertical scroll offset changes, update the scrollers and 
+    Whenever the vertical scroll offset changes, update the scrollers and
     edit the location of the contentView.
   */
   _scroll_verticalScrollOffsetDidChange: function() {
@@ -1956,7 +1977,7 @@ SC.ScrollView = SC.View.extend({
 
     if (container && !SC.platform.touch) {
       container = container.$()[0];
-      
+
       if (container) {
         if (verticalScrollOffset !== this._verticalScrollOffset) {
           container.scrollTop = verticalScrollOffset;
@@ -1989,8 +2010,8 @@ SC.ScrollView = SC.View.extend({
 
   /** @private */
   _scroll_verticalScrollOffset: 0,
-  
+
   /** @private */
   _scroll_horizontalScrollOffset: 0
-  
+
 });