sproutcore 1.11.0.rc2 → 1.11.0.rc3

data/lib/frameworks/sproutcore/frameworks/desktop/panes/picker.js

@@ -225,6 +225,14 @@ SC.PICKER_MENU_POINTER = 'menu-pointer';
 
   Positioning: SC.POSITION_BOTTOM (3) > SC.POSITION_RIGHT (0) > SC.POSITION_LEFT (1) > SC.POSITION_TOP (2). Fallback to SC.POSITION_BOTTOM (3).
 
+  ### Transition-In Special Handling
+
+  This view has special behavior when used with SC.View's `transitionIn` plugin support. If the
+  plugin defines `layoutProperties` of either `scale` or `rotate`, then the picker will adjust its
+  transform origin X & Y position to appear to scale or rotate out of the anchor. The result is a
+  very nice effect that picker panes appear to pop out of their anchors. To see it in effect,
+  simply set the `transitionIn` property of the pane to one of `SC.View.SCALE_IN` or `SC.View.POP_IN`.
+
   @extends SC.PalettePane
   @since SproutCore 1.0
 */
@@ -538,10 +546,11 @@ SC.PickerPane = SC.PalettePane.extend(
 
   /* @private If the pane changes size, reposition as necessary. */
   viewDidResize: function () {
-    this.positionPane(true);
-
     // Don't forget to call the superclass method.
     sc_super();
+
+    // Re-position.
+    this.positionPane(true);
   },
 
   /**
@@ -624,22 +633,79 @@ SC.PickerPane = SC.PalettePane.extend(
       // frames, add those properties.
       anchor.halfWidth = parseInt(anchor.width * 0.5, 0);
       anchor.halfHeight = parseInt(anchor.height * 0.5, 0);
-      frame.halfWidth = parseInt(frame.originalWidth * 0.5, 0);
-      frame.halfHeight = parseInt(frame.originalHeight * 0.5, 0);
+
+      // Don't pollute the borderFrame rect.
+      frame = SC.cloneRect(frame);
+      frame.halfWidth = parseInt(frame.width * 0.5, 0);
+      frame.halfHeight = parseInt(frame.height * 0.5, 0);
 
       frame = this.fitPositionToScreen(origin, frame, anchor);
+
       adjustHash = {
         left: frame.x,
-        top: frame.y,
-        width: frame.width,
-        height: frame.height
+        top: frame.y
       };
 
+      /*
+        Special case behavior for transitions that include scale or rotate: notably SC.View.SCALE_IN and SC.View.POP_IN.
+
+        We make an assumption that the picker should always scale out of the anchor, so we set the
+        transform origin accordingly.
+      */
+      var transitionIn = this.get('transitionIn');
+      if (transitionIn && (transitionIn.layoutProperties.indexOf('scale') >= 0 || transitionIn.layoutProperties.indexOf('rotate') >= 0)) {
+        var transformOriginX, transformOriginY;
+
+        switch (preferType) {
+        // If the picker uses a pointer, set the origin to the pointer.
+        case SC.PICKER_POINTER:
+        case SC.PICKER_MENU_POINTER:
+          switch (this.get('pointerPos')) {
+          case 'perfectTop':
+            transformOriginX = (frame.halfWidth + this.get('pointerPosX')) / frame.width;
+            transformOriginY = 1;
+            break;
+          case 'perfectRight':
+            transformOriginX = 0;
+            transformOriginY = (frame.halfHeight + this.get('pointerPosY')) / frame.height;
+            break;
+          case 'perfectBottom':
+            transformOriginX = (frame.halfWidth + this.get('pointerPosX')) / frame.width;
+            transformOriginY = 0;
+            break;
+          case 'perfectLeft':
+            transformOriginX = 1;
+            transformOriginY = (frame.halfHeight + this.get('pointerPosY')) / frame.height;
+            break;
+          }
+          break;
+
+        // If the picker doesn't use a pointer, set the origin to the correct corner.
+        case SC.PICKER_MENU:
+        case SC.PICKER_FIXED:
+          if (frame.x >= anchor.x) {
+            transformOriginX = 0;
+          } else {
+            transformOriginX = 1;
+          }
+          if (frame.y >= anchor.y) {
+            transformOriginY = 0;
+          } else {
+            transformOriginY = 1;
+          }
+
+          break;
+        }
+
+        adjustHash.transformOriginX = transformOriginX;
+        adjustHash.transformOriginY = transformOriginY;
+      }
+
       // Adjust.
       this.adjust(adjustHash);
-    }
+
     // if no anchor view has been set for some reason, just center.
-    else {
+    } else {
       this.adjust({
         centerX: 0,
         centerY: 0
@@ -886,10 +952,10 @@ SC.PickerPane = SC.PalettePane.extend(
       [anchorFrame.x + anchorFrame.width + offset[0], anchorFrame.y + anchorFrame.halfHeight - frame.halfHeight],
 
       // Top left [x, y] if positioned evenly to the left of the anchor
-      [anchorFrame.x - frame.originalWidth + offset[1], anchorFrame.y + anchorFrame.halfHeight - frame.halfHeight],
+      [anchorFrame.x - frame.width + offset[1], anchorFrame.y + anchorFrame.halfHeight - frame.halfHeight],
 
       // Top left [x, y] if positioned evenly above the anchor
-      [anchorFrame.x + anchorFrame.halfWidth - frame.halfWidth, anchorFrame.y - frame.originalHeight + offset[2]],
+      [anchorFrame.x + anchorFrame.halfWidth - frame.halfWidth, anchorFrame.y - frame.height + offset[2]],
 
       // Top left [x, y] if positioned evenly below the anchor
       [anchorFrame.x + anchorFrame.halfWidth - frame.halfWidth, anchorFrame.y + anchorFrame.height + offset[3]]
@@ -1038,8 +1104,7 @@ SC.PickerPane = SC.PalettePane.extend(
 
     }
 
-    // If no arrangement was found to fit, then use the fall back preferred
-    // type.
+    // If no arrangement was found to fit, then use the fall back preferred type.
     if (i === pointerLen) {
       if (matrix[4] === -1) {
         frame.x = anchorFrame.x + anchorFrame.halfWidth;
@@ -1216,7 +1281,7 @@ SC.PickerPane = SC.PalettePane.extend(
   },
 
   remove: function () {
-    if (this.get('isVisibleInWindow') && this.get('isPaneAttached')) {
+    if (this.get('isVisibleInWindow')) {
       this._withdrawOverflowRequest();
     }
     this._removeScrollObservers();
@@ -1334,6 +1399,7 @@ SC.PickerPane = SC.PalettePane.extend(
     this._anchorHTMLElement = null;
     return sc_super();
   }
+
 });
 
 

data/lib/frameworks/sproutcore/frameworks/desktop/panes/sheet.js

@@ -36,8 +36,8 @@ SC.SheetPane = SC.PanelPane.extend(
 
     /**
      @type {Array}
-     @default {['sc-sheet']}
-     @see {SC.View#classNames}
+     @default ['sc-sheet']
+     @see SC.View#classNames
      */
     classNames: ['sc-sheet'],
 

data/lib/frameworks/sproutcore/frameworks/desktop/protocols/{drag_data_source.js → drag_data_source_protocol.js}

@@ -5,16 +5,22 @@
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
-sc_require('system/drag') ;
+sc_require('system/drag');
 
-/**
-  @namespace
+/** @namespace
+  The `SC.DragDataSourceProtocol` protocol defines the properties and methods that you may implement
+  in your drag source objects in order to access additional functionality of SproutCore's drag
+  support.
 
-  This protocol implements a dynamic data source for a drag operation. You can
-  return a set of allowed data types and then the method will be used to 
-  actually get data in that format when requested.
+  This protocol implements a dynamic data source for a drag operation. You should use it to return a
+  set of allowed data types and then the method will be used to actually get data in that format
+  when requested.
+
+  *Note: Do not mix `SC.DragDataSourceProtocol` into your classes. As a protocol, it exists only for
+  reference sake. You only need define any of the properties or methods listed below in order to use
+  this protocol.*
 */
-SC.DragDataSource = {
+SC.DragDataSourceProtocol = {
 
   /**
     Implement this property as an array of data types you want to support
@@ -28,11 +34,11 @@ SC.DragDataSource = {
   /**
     Implement this method to return the data in the format passed.  Return
     null if the requested data type cannot be generated.
-    
+
     @param {SC.Drag} drag The Drag instance managing this drag.
-    @param {Object} dataType The proposed dataType to return.  This will 
+    @param {Object} dataType The proposed dataType to return.  This will
       always be one of the data types declared in dragDataTypes.
-    
+
     @returns The data object for the specified type
   */
   dragDataForType: function(drag, dataType) {

data/lib/frameworks/sproutcore/frameworks/desktop/protocols/{drag_source.js → drag_source_protocol.js}

@@ -7,62 +7,64 @@
 
 sc_require('system/drag') ;
 
-/**
-  @namespace
+/** @namespace
+  The `SC.DragSourceProtocol` protocol defines the properties and methods that you may implement in
+  your drag source objects in order to access additional functionality of SproutCore's drag support.
 
-  If you implement the SC.DragSource protocol on your drag's source, it will
-  receive a series of callbacks throughout the course of the drag, and be consulted
-  about what operations to allow on a particular candidate drop target. All methods
-  are optional.
+  If you implement the `SC.DragSourceProtocol` protocol on your drag's source, it will receive a
+  series of callbacks throughout the course of the drag, and be consulted about what operations to
+  allow on a particular candidate drop target. Note that when you initiate a drag you must also
+  provide an object implementing `SC.DragDataSourceProtocol`, which includes some *required*
+  methods. A single object may serve as both the drag's source and its data source.
 
-  (Note that when you initiate a drag you must also provide an object implementing
-  SC.DragDataSource, which includes some required methods. A single object may
-  serve as both the drag's source and its data source.)
+  *Note: Do not mix `SC.DragSourceProtocol` into your classes. As a protocol, it exists only for
+  reference sake. You only need define any of the properties or methods listed below in order to use
+  this protocol.*
 */
-SC.DragSource = {
+SC.DragSourceProtocol = {
 
   /**
     Return a bitwise OR'd mask of the drag operations allowed on the
     specified target.  If you don't care about the target, just return a
     constant value. If a drag's source does not implement this method,
     it will assume that any drag operation (SC.DRAG_ANY) is allowed.
-    
+
     @param {SC.Drag} drag The SC.Drag instance managing this drag.
     @param {SC.View} dropTarget The proposed target of the drop.
   */
   dragSourceOperationMaskFor: function(drag, dropTarget) {
     return SC.DRAG_ANY;
   },
-  
+
   /**
     If this property is set to `NO` or is not implemented, then the user may
-    modify the drag operation by changing the modifier keys they have 
+    modify the drag operation by changing the modifier keys they have
     pressed.
-    
+
     @type Boolean
     @default NO
   */
   ignoreModifierKeysWhileDragging: NO,
-    
+
   /**
     This method is called when the drag begins. You can use this to do any
-    visual highlighting to indicate that the receiver is the source of the 
+    visual highlighting to indicate that the receiver is the source of the
     drag.
-    
+
     @param {SC.Drag} drag The Drag instance managing this drag.
-    @param {Point} loc The point in *window* coordinates where the drag 
-      began.  You can use convertOffsetFromView() to convert this to local 
+    @param {Point} loc The point in *window* coordinates where the drag
+      began.  You can use convertOffsetFromView() to convert this to local
       coordinates.
   */
   dragDidBegin: function(drag, loc) {},
-  
+
   /**
     This method is called whenever the drag image is moved.  This is
     similar to the `dragUpdated()` method called on drop targets.
-    
+
     @param {SC.Drag} drag The Drag instance managing this drag.
-    @param {Point} loc  The point in *window* coordinates where the drag 
-      mouse is.  You can use convertOffsetFromView() to convert this to local 
+    @param {Point} loc  The point in *window* coordinates where the drag
+      mouse is.  You can use convertOffsetFromView() to convert this to local
       coordinates.
   */
   dragDidMove: function(drag, loc) {},
@@ -90,11 +92,11 @@ SC.DragSource = {
     @param {DragOp} op Provided for consistency. Always SC.DRAG_NONE.
   */
   dragDidCancel: function(drag, loc, op) {},
-  
+
   /**
     This method is called when the drag ended, regardless of whether it succeeded
     or not. You can use this to do any cleanup.
-    
+
     @param {SC.Drag} drag The drag instance managing the drag.
     @param {Point} loc The point in WINDOW coordinates where the drag
       ended.
@@ -108,7 +110,7 @@ SC.DragSource = {
     to YES, then the drag's ghost view will slide back to its initial location.
     dragDidEnd is called immediately upon mouseUp; dragSlideBackDidEnd is called
     after the slide-back animation completes.
-    
+
     @param {SC.Drag} drag The drag instance managing the drag.
   */
   dragSlideBackDidEnd: function(drag) {}

data/lib/frameworks/sproutcore/frameworks/desktop/protocols/{drop_target.js → drop_target_protocol.js}

@@ -7,17 +7,12 @@
 
 sc_require('system/drag');
 
-/**
-  @namespace
-  
-  Implement the DropTarget protocol in your view to be able to accept drop events. You 
-  should define the methods below as needed to handle accepting of events.
-  
-  See the method descriptions for more information on what you need to implement.
-  
-  The general call sequence for all drop targets is (in pseudo-Ragel, regex
-  format):
-  
+/** @namespace
+  The `SC.DropTargetProtocol` protocol defines the properties and methods that you may implement
+  in your views in order to act as a drop target for a drag.
+
+  The general call sequence for all drop targets is (in pseudo-Ragel, regex format):
+
       dragStarted
       (
         computeDragOperations+
@@ -30,159 +25,162 @@ sc_require('system/drag');
         )*
       )*
       dragEnded
-  
-  Thus, every drop target will have its dragStarted and dragEnded methods called 
-  once during every drag session. computeDragOperations, if called at all, may be 
-  called more than once before the dragEntered method is called. Once dragEntered 
-  is called, you are at guaranteed that both dragUpdated and dragExited will be 
-  called at some point, followed by either dragEnded or additional 
-  computeDragOperation calls.
+
+  Thus, every drop target will have its `dragStarted` and `dragEnded` methods called once during
+  every drag session. `computeDragOperations`, if called at all, may be called more than once before
+  the `dragEntered` method is called. Once `dragEntered` is called, you are guaranteed that both
+  `dragUpdated` and `dragExited` will be called at some point, followed by either `dragEnded` or
+  additional `computeDragOperation` calls.
+
+  *Note: Do not mix `SC.DropTargetProtocol` into your classes. As a protocol, it exists only for
+  reference sake. You only need define any of the properties or methods listed below in order to use
+  this protocol.*
 */
-SC.DropTarget = {
-  
+SC.DropTargetProtocol = {
+
   /**
     Must be true when your view is instantiated.
-    
+
     Drop targets must be specially registered in order to receive drop
     events.  SproutCore knows to register your view when this property
     is true on view creation.
-    
+
     @type Boolean
     @default YES
     @constant
-  */  
+  */
   isDropTarget: YES,
 
   /**
     Called when the drag is started, regardless of where or not your drop
     target is current. You can use this to highlight your drop target
     as "eligible".
-    
+
     The default implementation does nothing.
-    
+
     @param {SC.Drag} drag The current drag object.
-    @param {SC.Event} evt The most recent mouse move event.  Use to get location 
+    @param {SC.Event} evt The most recent mouse move event.  Use to get location
   */
   dragStarted: function(drag, evt) {},
-  
+
   /**
     Called when the drag first enters the droppable area, if it returns a
     drag operations other than `SC.DRAG_NONE`.
-    
+
     The default implementation does nothing.
-    
+
     @param drag {SC.Drag} The current drag object.
     @param evt {SC.Event} The most recent mouse move event.  Use to get location
   */
   dragEntered: function(drag, evt) {},
-  
+
   /**
     Called periodically when a drag is over your droppable area.
-    
-    Override this method this to update various elements of the drag state, 
-    including the location of ghost view.  You should  use this method to 
+
+    Override this method this to update various elements of the drag state,
+    including the location of ghost view.  You should  use this method to
     implement snapping.
-    
+
     This method will be called periodically, even if the user is not moving
     the drag.  If you perform expensive operations, be sure to check the
     mouseLocation property of the drag to determine if you actually need to
     update anything before doing your expensive work.
-    
+
     The default implementation does nothing.
-    
+
     @param {SC.Drag} drag The current drag object.
     @param {SC.Event} evt The most recent mouse move event. Use to get location
   */
   dragUpdated: function(drag, evt) {},
-  
+
   /**
     Called when the user exits your droppable area or the drag ends
     and you were the last targeted droppable area.
-    
-    Override this method to perform any clean up on your UI such as hiding 
+
+    Override this method to perform any clean up on your UI such as hiding
     a special highlight state or removing insertion points.
-    
+
     The default implementation does nothing.
-    
+
     @param {SC.Drag} drag The current drag object
     @param {SC.Event}   evt  The most recent mouse move event. Use to get location.
   */
   dragExited: function(drag, evt) {},
-  
+
   /**
-    Called on all drop targets when the drag ends.  
-    
-    For example, the user might have dragged the view off the screen and let 
-    go or they might have hit escape.  Override this method to perform any 
+    Called on all drop targets when the drag ends.
+
+    For example, the user might have dragged the view off the screen and let
+    go or they might have hit escape.  Override this method to perform any
     final cleanup.  This will be called instead of dragExited.
-    
+
     The default implementation does nothing.
-    
+
     @param {SC.Drag} drag The current drag object
     @param {SC.Event}   evt  The most recent mouse move event. Use to get location.
   */
   dragEnded: function(drag, evt) {},
-  
+
   /**
     Called when the drag needs to determine which drag operations are
     valid in a given area.
-    
-    Override this method to return an OR'd mask of the allowed drag 
-    operations.  If the user drags over a droppable area within another 
-    droppable area, the drag will latch onto the deepest view that returns one 
+
+    Override this method to return an OR'd mask of the allowed drag
+    operations.  If the user drags over a droppable area within another
+    droppable area, the drag will latch onto the deepest view that returns one
     or more available operations.
-    
+
     The default implementation returns `SC.DRAG_NONE`
-    
+
     @param {SC.Drag} drag The current drag object
-    @param {SC.Event} evt The most recent mouse move event.  Use to get 
-      location 
+    @param {SC.Event} evt The most recent mouse move event.  Use to get
+      location
     @param {DragOp} op The proposed drag operation. A drag constant
-    
-    @returns {DragOps} A mask of all the drag operations allowed or 
+
+    @returns {DragOps} A mask of all the drag operations allowed or
       SC.DRAG_NONE
   */
   computeDragOperations: function(drag, evt, op) {
     return SC.DRAG_NONE;
   },
-  
+
   /**
     Called when the user releases the mouse.
-    
-    This method gives your drop target one last opportunity to choose to 
+
+    This method gives your drop target one last opportunity to choose to
     accept the proposed drop operation.  You might use this method to
     perform fine-grained checks on the drop location, for example.
     Return true to accept the drop operation.
-    
+
     The default implementation returns `YES`.
-    
+
     @param {SC.Drag} drag The drag instance managing this drag
     @param {DragOp} op The proposed drag operation. A drag constant
-    
+
     @return {Boolean} YES if operation is OK, NO to cancel.
-  */  
+  */
   acceptDragOperation: function(drag, op) {
     return YES;
   },
-  
+
   /**
     Called to actually perform the drag operation.
-    
+
     Override this method to actually perform the drag operation.  This method
-    is only called if you returned `YES` in `acceptDragOperation()`. 
-    
-    Return the operation that was actually performed or `SC.DRAG_NONE` if the 
+    is only called if you returned `YES` in `acceptDragOperation()`.
+
+    Return the operation that was actually performed or `SC.DRAG_NONE` if the
     operation was aborted.
-    
+
     The default implementation returns `SC.DRAG_NONE`
-    
+
     @param {SC.Drag} drag The drag instance managing this drag
     @param {DragOp} op The proposed drag operation. A drag constant.
-    
+
     @return {DragOp} Drag Operation actually performed
   */
   performDragOperation: function(drag, op) {
     return SC.DRAG_NONE;
   }
-  
+
 };