sproutcore 1.0.1049.pre.2 → 1.4.0.rc

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

@@ -15,9 +15,11 @@ sc_require('views/separator') ;
   @extends SC.ButtonView
   @since SproutCore 1.0
 */
-SC.MenuItemView = SC.View.extend( SC.ContentDisplay,
+SC.MenuItemView = SC.View.extend(SC.ContentDisplay,
 /** @scope SC.MenuItemView.prototype */{
 
+  displayProperties: ['title', 'isEnabled', 'isSeparator'],
+
   classNames: ['sc-menu-item'],
 
   escapeHTML: YES,
@@ -37,11 +39,9 @@ SC.MenuItemView = SC.View.extend( SC.ContentDisplay,
   blocksIEDeactivate: YES,
 
   /**
-    IE only attribute to block bluring of other controls
-
-    @type Boolean
+    Disable context menu.
   */
-  blocksIEDeactivate: YES,
+  isContextMenuEnabled: NO,
 
   // ..........................................................
   // KEY PROPERTIES

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

@@ -52,15 +52,97 @@ SC.PopupButtonView = SC.ButtonView.extend(
     @default null
   */
   menu: null,
+  
+  /**
+    If YES and the menu is a class, this will cause a task that will instantiate the menu
+    to be added to SC.backgroundTaskQueue.
+  */
+  shouldLoadInBackground: NO,
 
   // ..........................................................
   // INTERNAL SUPPORT
   //
+  
+  /**
+    @private
+    If necessary, adds the loading of the menu to the background task queue.
+  */
+  init: function() {
+    sc_super();
+    this._setupMenu();
+    if (this.get('shouldLoadInBackground')) {
+      SC.backgroundTaskQueue.push(SC.PopupButtonMenuLoader.create({ popupButton: this }));
+    }
+  },
+  
+  /**
+    @private
+    Sets up binding on the menu, removing any old ones if necessary.
+  */
+  _setupMenu: function() {
+    var menu = this.get('instantiatedMenu');
+    
+    // clear existing bindings
+    if (this.isActiveBinding) this.isActiveBinding.disconnect();
+    this.isActiveBinding = null;
+    
+    // if there is a menu
+    if (menu && !menu.isClass) {
+      this.isActiveBinding = this.bind('isActive', menu, 'isVisibleInWindow');
+    }
+  },
+  
+  /**
+    Setup the bindings for menu...
+  */
+  _popup_menuDidChange: function() {
+    this._setupMenu();
+  }.observes('menu'),
 
   /** @private
-    Binds the button's selection state to the menu's visibility.
+    isActive is NO, but when the menu is instantiated, it is bound to the menu's isVisibleInWindow property.
   */
-  isActiveBinding: '*menu.isVisibleInWindow',
+  isActive: NO,
+  
+  /**
+    @private
+    Instantiates the menu if it is not already instantiated.
+  */
+  _instantiateMenu: function() {
+    // get menu
+    var menu = this.get('menu');
+    
+    // if it is already instantiated or does not exist, we cannot do anything
+    if (!menu.isClass || !menu) return;
+    
+    // create
+    this.menu = menu.create();
+    
+    // setup
+    this._setupMenu();
+  },
+  
+  acceptsFirstResponder: YES,
+  
+  /**
+    The guaranteed-instantiated menu.
+  */
+  instantiatedMenu: function() {
+    // get the menu
+    var menu = this.get('menu');
+    
+    // if it is a class, we need to instantiate it
+    if (menu && menu.isClass) {
+      // do so
+      this._instantiateMenu();
+      
+      // get the new version of the local
+      menu = this.get('menu');
+    }
+    
+    // return
+    return menu;
+  }.property('menu').cacheable(),
 
   /** @private
     Displays the menu.
@@ -69,7 +151,7 @@ SC.PopupButtonView = SC.ButtonView.extend(
   */
   action: function(evt)
   {
-    var menu = this.get('menu') ;
+    var menu = this.get('instantiatedMenu') ;
 
     if (!menu) {
       //@ if (debug)
@@ -105,6 +187,8 @@ SC.PopupButtonView = SC.ButtonView.extend(
     // pressed.
     this.invokeLast(this._recordMouseDownTimestamp);
 
+    this.becomeFirstResponder();
+
     return YES ;
   },
 
@@ -136,7 +220,7 @@ SC.PopupButtonView = SC.ButtonView.extend(
   mouseUp: function(evt) {
     var timestamp = new Date().getTime(),
         previousTimestamp = this._menuRenderedTimestamp,
-        menu = this.get('menu'),
+        menu = this.get('instantiatedMenu'),
         touch = SC.platform.touch,
         targetMenuItem;
 
@@ -189,7 +273,7 @@ SC.PopupButtonView = SC.ButtonView.extend(
   performKeyEquivalent: function( charCode, evt )
   {
     if (!this.get('isEnabled')) return NO ;
-    var menu = this.get('menu') ;
+    var menu = this.get('instantiatedMenu') ;
     return (!!menu && menu.performKeyEquivalent(charCode, evt)) ;
   },
 
@@ -200,3 +284,15 @@ SC.PopupButtonView = SC.ButtonView.extend(
   }.property('isEnabled')
 
 });
+
+/**
+  @private
+  Handles lazy instantiation of popup button menu.
+*/
+SC.PopupButtonMenuLoader = SC.Task.extend({
+  popupButton: null,
+  run: function() {
+    if (this.popupButton) this.popupButton._instantiateMenu();
+  }
+});
+

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

@@ -294,9 +294,14 @@ SC.ScrollView = SC.View.extend(SC.Border, {
     
     @property {SC.View}
   */
-  horizontalScrollerView: function() {
-    return SC.ScrollerView;
-  }.property().cacheable(),
+  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 
+    hasHorizontalScroller is NO.
+  */
+  horizontalTouchScrollerView: SC.TouchScrollerView,
   
   /**
     YES if the horizontal scroller should be visible.  You can change this 
@@ -342,9 +347,13 @@ SC.ScrollView = SC.View.extend(SC.Border, {
     
     @property {SC.View}
   */
-  verticalScrollerView: function() {
-    return SC.ScrollerView;
-  }.property().cacheable(),
+  verticalScrollerView: SC.ScrollerView,
+  
+  /**
+    The vertical touch scroller view class. This will be replaced with a view
+    instance when the ScrollView is created.
+  */
+  verticalTouchScrollerView: SC.TouchScrollerView,
   
   /**
     YES if the vertical scroller should be visible.  You can change this 
@@ -689,17 +698,13 @@ SC.ScrollView = SC.View.extend(SC.Border, {
     additional controls you have added to the view.
   */
   tile: function() {
-    
-    // for now just hide scroll bars on touch platforms
-    var isTouch = SC.platform.touch;
-    
     // get horizontal scroller/determine if we should have a scroller
     var hscroll = this.get('hasHorizontalScroller') ? this.get('horizontalScrollerView') : null ;
-    var hasHorizontal = hscroll && !isTouch && this.get('isHorizontalScrollerVisible');
+    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 && !isTouch && this.get('isVerticalScrollerVisible') ;
+    var hasVertical = vscroll && this.get('isVerticalScrollerVisible') ;
     
     // get the containerView
     var clip = this.get('containerView') ;
@@ -919,10 +924,8 @@ SC.ScrollView = SC.View.extend(SC.Border, {
     this.updateScale(this._scale);
     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";
-    }
+    layer.style.webkitTransform = transform;
+    layer.style.webkitTransformOrigin = "top left";
   },
   
   captureTouch: function(touch) {
@@ -945,11 +948,22 @@ SC.ScrollView = SC.View.extend(SC.Border, {
 
   beginTouchesInContent: function(gen) {
     if (gen !== this.touchGeneration) return;
+    
     var touch = this.touch, itemView;
     if (touch && this.tracking && !this.dragging && !touch.touch.scrollHasEnded) {
       // try to capture the touch
       touch.touch.captureTouch(this, YES);
-      if (!touch.touch.touchResponder) touch.touch.makeTouchResponder(this);
+      
+      if (!touch.touch.touchResponder) {
+        // if it DIDN'T WORK!!!!!
+        // then we need to take possession again.
+        touch.touch.makeTouchResponder(this);
+      } else {
+        // Otherwise, it did work, and if we had a pending scroll end, we must do it now
+        if (touch.needsScrollEnd) {
+          this._touchScrollDidEnd();
+        }
+      }
     }
   },
 
@@ -967,7 +981,8 @@ SC.ScrollView = SC.View.extend(SC.Border, {
     var verticalScrollOffset = this._scroll_verticalScrollOffset || 0,
         horizontalScrollOffset = this._scroll_horizontalScrollOffset || 0,
         startClipOffsetX = horizontalScrollOffset,
-        startClipOffsetY = verticalScrollOffset;
+        startClipOffsetY = verticalScrollOffset,
+        needsScrollEnd = NO;
     
     if (this.touch && this.touch.timeout) {
       // clear the timeout
@@ -977,6 +992,7 @@ SC.ScrollView = SC.View.extend(SC.Border, {
       // get the scroll offsets
       startClipOffsetX = this.touch.startClipOffset.x;
       startClipOffsetY = this.touch.startClipOffset.y;
+      needsScrollEnd = YES;
     }
     
     // calculate container+content width/height
@@ -995,19 +1011,16 @@ SC.ScrollView = SC.View.extend(SC.Border, {
     var globalFrame = this.convertFrameToView(this.get("frame"), null),
         positionInContentX = (horizontalScrollOffset + (avg.x - globalFrame.x)) / this._scale,
         positionInContentY = (verticalScrollOffset + (avg.y - globalFrame.y)) / this._scale;
-
+    
     this.touch = {
       startTime: touch.timeStamp,
       notCalculated: YES,
       
       enableScrolling: { 
         x: contentWidth * this._scale > containerWidth || this.get("alwaysBounceHorizontal"), 
-        y: contentHeight * this._scale > containerHeight || this.get("alwaysBounceVertical") 
-      },
+        y: contentHeight * this._scale > containerHeight || this.get("alwaysBounceVertical") }, // TODO: get from class properties
       scrolling: { x: NO, y: NO },
       
-      enableBouncing: SC.platform.bounceOnScroll,
-      
       // offsets and velocities
       startClipOffset: { x: startClipOffsetX, y: startClipOffsetY },
       lastScrollOffset: { x: horizontalScrollOffset, y: verticalScrollOffset },
@@ -1021,7 +1034,7 @@ SC.ScrollView = SC.View.extend(SC.Border, {
       
       startScale: this._scale,
       startDistance: avg.d,
-      canScale: this.get("canScale") && SC.platform.pinchToZoom,
+      canScale: this.get("canScale"),
       minimumScale: this.get("minimumScale"),
       maximumScale: this.get("maximumScale"),
       
@@ -1048,7 +1061,16 @@ SC.ScrollView = SC.View.extend(SC.Border, {
       lastEventTime: touch.timeStamp,      
       
       // the touch used
-      touch: (starting ? touch : (this.touch ? this.touch.touch : null))
+      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
     };
 
     if (!this.tracking) {
@@ -1138,7 +1160,7 @@ SC.ScrollView = SC.View.extend(SC.Border, {
       if (deltaY > touch.scrollLock && !touch.scrolling.x) touch.enableScrolling.x = NO;
     }
     
-    // handle scaling through pinch gesture
+    // handle scaling
     if (touch.canScale) {
       
       var startDistance = touch.startDistance, dd = distance - startDistance;
@@ -1158,46 +1180,30 @@ SC.ScrollView = SC.View.extend(SC.Border, {
       }
     }
     
-    // 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"));
     
-    // 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"));
     
-    
-    // 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);
-      offsetY = this._adjustForEdgeResistance(offsetY, minOffsetY, maxOffsetY, touch.resistanceCoefficient, touch.resistanceAsymptote);
-    } else {
-      offsetX = Math.max(minOffsetX, Math.min(maxOffsetX, offsetX));
-      offsetY = Math.max(minOffsetY, Math.min(maxOffsetY, offsetY));
-    }
+    // update immediately, without consulting anyone else.
+    offsetX = this._adjustForEdgeResistance(offsetX, minOffsetX, maxOffsetX, touch.resistanceCoefficient, touch.resistanceAsymptote);
+    offsetY = this._adjustForEdgeResistance(offsetY, minOffsetY, maxOffsetY, touch.resistanceCoefficient, touch.resistanceAsymptote);
     
-    // 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;
     
-    // 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;
@@ -1227,6 +1233,9 @@ SC.ScrollView = SC.View.extend(SC.Border, {
 
         this.startDecelerationAnimation();
       } 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.
@@ -1235,17 +1244,18 @@ SC.ScrollView = SC.View.extend(SC.Border, {
         // if we went anywhere, did anything, etc., call end()
         if (touch.touchResponder && touch.touchResponder !== this) {
           touch.end();
-        }
-        
-        // now check 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.touchResponder || touch.touchResponder === this) {
+        } else if (!touch.touchResponder || touch.touchResponder === this) {
+          // 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;
@@ -1254,19 +1264,25 @@ SC.ScrollView = SC.View.extend(SC.Border, {
   },
   
   touchCancelled: function(touch) {
-    this.beginPropertyChanges();
-    this.set("scale", this._scale);
-    this.set("verticalScrollOffset", this._scroll_verticalScrollOffset);
-    this.set("horizontalScrollOffset", this._scroll_horizontalScrollOffset);
-    this.endPropertyChanges();
-    this.tracking = NO;
-    
-    if (this.dragging) {
-      this._touchScrollDidEnd();
-    }
+    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();
+      this.set("scale", this._scale);
+      this.set("verticalScrollOffset", this._scroll_verticalScrollOffset);
+      this.set("horizontalScrollOffset", this._scroll_horizontalScrollOffset);
+      this.endPropertyChanges();
+      this.tracking = NO;
     
-    this.dragging = NO;
-    this.touch = null;
+      if (this.dragging) {
+        this._touchScrollDidEnd();
+      }
+    
+      this.dragging = NO;
+      this.touch = null;
+    }
   },
 
   startDecelerationAnimation: function(evt) {
@@ -1338,11 +1354,6 @@ SC.ScrollView = SC.View.extend(SC.Border, {
     
     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
@@ -1350,8 +1361,8 @@ SC.ScrollView = SC.View.extend(SC.Border, {
     //
     // Position OKness, here, referring to if the position is valid (within
     // minimum and maximum scroll offsets)
-    if (newX >= minOffsetX && newX <= maxOffsetX) forceValidXPosition = YES;
-    if (newY >= minOffsetY && newY <= maxOffsetY) forceValidYPosition = YES;
+    var validXPosition = newX >= minOffsetX && newX <= maxOffsetX;
+    var validYPosition = newY >= minOffsetY && newY <= maxOffsetY;
     
     // 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
@@ -1399,21 +1410,15 @@ SC.ScrollView = SC.View.extend(SC.Border, {
     maxOffsetY = this.maximumScrollOffset(touch.contentSize.height * this._scale, touch.containerSize.height, this.get("verticalAlign"));
     
     // see if scaling messed up the X position (but ignore if 'tweren't right to begin with).
-    if (forceValidXPosition && (newX < minOffsetX || newX > maxOffsetX)) {
+    if (validXPosition && (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)) {
+    if (validYPosition && (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;
     }
     
     
@@ -1488,9 +1493,7 @@ SC.ScrollView = SC.View.extend(SC.Border, {
     var self = this;
     touch.lastEventTime = Date.now();
     this.touch.timeout = setTimeout(function(){
-      SC.RunLoop.begin();
       self.decelerateAnimation();
-      SC.RunLoop.end();
     }, 10);
   },
   
@@ -1518,7 +1521,7 @@ SC.ScrollView = SC.View.extend(SC.Border, {
     this.contentView = this.containerView.get('contentView');
     
     // create a horizontal scroller view if needed...
-    view = this.get("horizontalScrollerView");
+    view = SC.platform.touch ? this.get("horizontalTouchScrollerView") : this.get("horizontalScrollerView");
     if (view) {
       if (this.get('hasHorizontalScroller')) {
         view = this.horizontalScrollerView = this.createChildView(view, {
@@ -1530,7 +1533,7 @@ SC.ScrollView = SC.View.extend(SC.Border, {
     }
     
     // create a vertical scroller view if needed...
-    view = this.get("verticalScrollerView");
+    view = SC.platform.touch ? this.get("verticalTouchScrollerView") : this.get("verticalScrollerView");
     if (view) {
       if (this.get('hasVerticalScroller')) {
         view = this.verticalScrollerView = this.createChildView(view, {
@@ -1641,7 +1644,7 @@ SC.ScrollView = SC.View.extend(SC.Border, {
     this._scroll_contentWidth  = width;
     this._scroll_contentHeight = height;
 
-    dim       = this.get('frame');
+    dim       = this.getPath('containerView.frame');
     dimWidth  = dim.width;
     dimHeight = dim.height;
     
@@ -1659,7 +1662,6 @@ SC.ScrollView = SC.View.extend(SC.Border, {
       if (this.get('autohidesVerticalScroller')) {
         this.set('isVerticalScrollerVisible', height > dimHeight);
       }
-      height -= this.get('verticalScrollerBottom') ;
       view.setIfChanged('maximum', height-dimHeight) ;
       view.setIfChanged('proportion', dimHeight/height);
     }