sproutcore 1.11.0.rc2 → 1.11.0.rc3

data/lib/frameworks/sproutcore/frameworks/core_foundation/views/view/enabled.js

@@ -124,13 +124,19 @@ SC.View.reopen(
     var handled = true,
       enabledState = this.get('enabledState');
 
+    // If the view itself is disabled, then we can enable it.
     if (enabledState === SC.CoreView.DISABLED) {
-      // If the view itself is disabled, then we can enable it.
+      // Update the enabled state of all children. Top-down, because if a child is disabled on its own it
+      // won't affect its childrens' state and we can bail out early.
       this._callOnChildViews('_parentDidEnableInPane');
       this._gotoEnabledState();
+
+    // If the view is disabled and has a disabled parent, we can enable it, but it will be disabled by the parent.
     } else if (enabledState === SC.CoreView.DISABLED_AND_BY_PARENT) {
       // The view is no longer disabled itself, but still disabled by an ancestor.
       this._gotoDisabledByParentState();
+
+    // If the view is not disabled, we can't enable it.
     } else {
       handled = false;
     }
@@ -145,15 +151,22 @@ SC.View.reopen(
 
     // If the view is not itself disabled, then we can disable it.
     if (enabledState === SC.CoreView.ENABLED) {
+      // Update the disabled state of all children. Top-down, because if a child is disabled on its own it
+      // won't affect its childrens' state and we can bail out early.
+      this._callOnChildViews('_parentDidDisableInPane');
+      this._gotoDisabledState();
+
+      // Ensure that first responder status is given up.
       if (this.get('isFirstResponder')) {
         this.resignFirstResponder();
       }
 
-      this._callOnChildViews('_parentDidDisableInPane');
-      this._gotoDisabledState();
+    // If the view is disabled because of a disabled parent, we can disable the view itself too.
     } else if (enabledState === SC.CoreView.DISABLED_BY_PARENT) {
       // The view is now disabled itself and disabled by an ancestor.
       this._gotoDisabledAndByParentState();
+
+    // If the view is not enabled, we can't disable it.
     } else {
       handled = false;
     }
@@ -266,13 +279,11 @@ SC.View.reopen(
 
   /** @private */
   _gotoDisabledAndByParentState: function () {
-    // Update the state.
     this.set('enabledState', SC.CoreView.DISABLED_AND_BY_PARENT);
   },
 
   /** @private */
   _gotoDisabledByParentState: function () {
-    // Update the state.
     this.set('enabledState', SC.CoreView.DISABLED_BY_PARENT);
   }
 

data/lib/frameworks/sproutcore/frameworks/core_foundation/views/view/layout.js

@@ -286,6 +286,142 @@ SC.View.reopen(
   */
   layout: { top: 0, left: 0, bottom: 0, right: 0 },
 
+  /** @private The explicit layout of the view, computed from the layout using the explicit position. */
+  explicitLayout: function () {
+    var layout = this.get('layout'),
+        explicitPosition = this.get('explicitPosition'),
+        ret;
+
+    if (layout) {
+      ret = SC.clone(layout);
+
+      // Only use the explicit position values.
+      // delete ret.left;
+      delete ret.right;
+      // delete ret.top;
+      delete ret.bottom;
+
+      /*jshint eqnull:true */
+      if (explicitPosition.left != null) { ret.left = explicitPosition.left; }
+      if (explicitPosition.right != null) { ret.right = explicitPosition.right; }
+      if (explicitPosition.top != null) { ret.top = explicitPosition.top; }
+      if (explicitPosition.bottom != null) { ret.bottom = explicitPosition.bottom; }
+      if (explicitPosition.centerX != null) { ret.centerX = explicitPosition.centerX; }
+      if (explicitPosition.centerY != null) { ret.centerY = explicitPosition.centerY; }
+
+      // BORDERS
+      // Apply border first, so that the more specific borderX values will override it next.
+      var border = layout.border;
+      if (border != null) {
+        ret.borderTop = border;
+        ret.borderRight = border;
+        ret.borderBottom = border;
+        ret.borderLeft = border;
+        delete ret.border;
+      }
+
+      if (layout.borderTop != null) {
+        ret.borderTop = layout.borderTop;
+      }
+      if (layout.borderRight != null) {
+        ret.borderRight = layout.borderRight;
+      }
+      if (layout.borderBottom != null) {
+        ret.borderBottom = layout.borderBottom;
+      }
+      if (layout.borderLeft != null) {
+        ret.borderLeft = layout.borderLeft;
+      }
+    }
+
+    return ret;
+  }.property('explicitPosition').cacheable(),
+
+  /** @private The explicit position of the view, computed from the layout property, which may be written in shortform. */
+  explicitPosition: function () {
+    var layout = this.get('layout'),
+      ret;
+
+    if (layout) {
+      ret = {};
+
+      /* jshint eqnull:true */
+      var hasBottom = (layout.bottom != null);
+      var hasRight = (layout.right != null);
+      var hasLeft = (layout.left != null);
+      var hasTop = (layout.top != null);
+      var hasCenterX = (layout.centerX != null);
+      var hasCenterY = (layout.centerY != null);
+      var hasHeight = (layout.height != null); //  || (layout.maxHeight != null)
+      var hasWidth = (layout.width != null); // || (layout.maxWidth != null)
+
+      if (hasLeft) {
+        ret.left = layout.left;
+      } else if (!hasCenterX && !(hasWidth && hasRight)) {
+        ret.left = 0;
+      }
+
+      if (hasRight && !(hasLeft && hasWidth)) {
+        ret.right = layout.right;
+      } else if (!hasCenterX && !hasWidth) {
+        ret.right = 0;
+      }
+
+      //@if(debug)
+      // Debug-only warning when layout isn't valid.
+      // UNUSED: This is too noisy for certain views that adjust their own layouts based on top of the default layout.
+      // if (hasRight && hasLeft && hasWidth) {
+      //   SC.warn("Developer Warning: When setting `width` in the layout, you must only set `left` or `right`, but not both: %@".fmt(this));
+      // }
+      //@endif
+
+      if (hasTop) {
+        ret.top = layout.top;
+      } else if (!hasCenterY && !(hasHeight && hasBottom)) {
+        ret.top = 0;
+      }
+
+      if (hasBottom && !(hasTop && hasHeight)) {
+        ret.bottom = layout.bottom;
+      } else if (!hasCenterY && !hasHeight) {
+        ret.bottom = 0;
+      }
+
+      //@if(debug)
+      // Debug-only warning when layout isn't valid.
+      // UNUSED: This is too noisy for certain views that adjust their own layouts based on top of the default layout.
+      // if (hasBottom && hasTop && hasHeight) {
+      //   SC.warn("Developer Warning: When setting `height` in the layout, you must only set `top` or `bottom`, but not both: %@".fmt(this));
+      // }
+      //@endif
+
+      // CENTERS
+      if (hasCenterX) {
+        ret.centerX = layout.centerX;
+
+        //@if(debug)
+        // Debug-only warning when layout isn't valid.
+        if (!hasWidth) {
+          SC.warn("Developer Warning: When setting `centerX` in the layout, you must also set `width`: %@".fmt(this));
+        }
+        //@endif
+      }
+
+      if (hasCenterY) {
+        ret.centerY = layout.centerY;
+
+        //@if(debug)
+        // Debug-only warning when layout isn't valid.
+        if (!hasHeight) {
+          SC.warn("Developer Warning: When setting `centerY` in the layout, you must also set `height`: %@".fmt(this));
+        }
+        //@endif
+      }
+    }
+
+    return ret;
+  }.property('layout').cacheable(),
+
   /**
     Returns whether the layout is 'fixed' or not.  A fixed layout means a
     fixed left & top position and fixed width & height.  Fixed layouts are
@@ -308,33 +444,18 @@ SC.View.reopen(
     @test in layoutStyle
   */
   isFixedPosition: function () {
-    var layout = this.get('layout'),
-      hasLeft,
-      hasTop,
-      ret;
-
-    // Position is fixed if it has left + top !== SC.LAYOUT_AUTO
-    hasLeft = layout.left !== undefined;
-    if (!hasLeft) {
-      // Check for implied left. If there is a width, then there can't be a right or centerX.
-      hasLeft =  layout.width === undefined || (layout.width !== undefined && layout.right === undefined && layout.centerX === undefined);
-    }
-
-    hasTop = layout.top !== undefined;
-    if (!hasTop) {
-      // Check for implied top. If there is a height, then there can't be a bottom or centerY.
-      hasTop = layout.height === undefined || (layout.height !== undefined && layout.bottom === undefined && layout.centerY === undefined);
-    }
+    var explicitPosition = this.get('explicitPosition'),
+      left = explicitPosition.left,
+      top = explicitPosition.top,
+      hasFixedLeft,
+      hasFixedTop;
 
-    ret = (hasLeft && hasTop && layout.left !== SC.LAYOUT_AUTO && layout.top !== SC.LAYOUT_AUTO);
+    // Position is fixed if it has left + top, but not as percentages and not as SC.LAYOUT_AUTO.
+    hasFixedLeft = left !== undefined && !SC.isPercentage(left) && left !== SC.LAYOUT_AUTO;
+    hasFixedTop = top !== undefined && !SC.isPercentage(top) && top !== SC.LAYOUT_AUTO;
 
-    // The position may appear fixed, but only if none of the values are percentages.
-    if (ret) {
-      ret = (!SC.isPercentage(layout.top) && !SC.isPercentage(layout.left));
-    }
-
-    return ret;
-  }.property('layout').cacheable(),
+    return hasFixedLeft && hasFixedTop;
+  }.property('explicitPosition').cacheable(),
 
   /**
     Returns whether the size is 'fixed' or not.  A fixed size means a fixed
@@ -361,10 +482,10 @@ SC.View.reopen(
   isFixedHeight: function() {
     var layout = this.get('layout');
 
-    // Width is fixed if it has a height and it isn't SC.LAYOUT_AUTO or a percent.
+    // Height is fixed if it has a height and it isn't SC.LAYOUT_AUTO or a percent.
     return (layout.height !== undefined) &&
-      (layout.height !== SC.LAYOUT_AUTO) &&
-      !SC.isPercentage(layout.height);
+      !SC.isPercentage(layout.height) &&
+      (layout.height !== SC.LAYOUT_AUTO);
   }.property('layout').cacheable(),
 
   /**
@@ -381,8 +502,8 @@ SC.View.reopen(
 
     // Width is fixed if it has a width and it isn't SC.LAYOUT_AUTO or a percent.
     return (layout.width !== undefined) &&
-      (layout.width !== SC.LAYOUT_AUTO) &&
-      !SC.isPercentage(layout.width);
+      !SC.isPercentage(layout.width) &&
+      (layout.width !== SC.LAYOUT_AUTO);
   }.property('layout').cacheable(),
 
   /**
@@ -427,7 +548,7 @@ SC.View.reopen(
   },
 
   /** @private */
-  _convertFrameFromViewHelper: function(frame, fromView, targetView) {
+  _convertFrameFromViewHelper: function (frame, fromView, targetView) {
     var myX = frame.x, myY = frame.y, myWidth = frame.width, myHeight = frame.height, view, f;
 
     // first, walk up from the view of the frame, up to the top level
@@ -507,16 +628,18 @@ SC.View.reopen(
   },
 
   /** @private */
-  _effectiveBorderFor: function (layoutName, layout) {
-    return ((layout[layoutName] !== undefined) ? layout[layoutName] : layout.border) || 0;
+  _sc_explicitValueFor: function (givenValue, impliedValue) {
+    return givenValue === undefined ? impliedValue : givenValue;
   },
 
   /** @private */
   _adjustForBorder: function (frame, layout) {
-    var borderTop = this._effectiveBorderFor('borderTop', layout),
-        borderLeft = this._effectiveBorderFor('borderLeft', layout),
-        borderBottom = this._effectiveBorderFor('borderBottom', layout),
-        borderRight = this._effectiveBorderFor('borderRight', layout);
+    /*jshint eqnull:true */
+    var defaultValue = layout.border == null ? 0 : layout.border,
+        borderTop = this._sc_explicitValueFor(layout.borderTop, defaultValue),
+        borderLeft = this._sc_explicitValueFor(layout.borderLeft, defaultValue),
+        borderBottom = this._sc_explicitValueFor(layout.borderBottom, defaultValue),
+        borderRight = this._sc_explicitValueFor(layout.borderRight, defaultValue);
 
     frame.x += borderLeft; // The border on the left pushes the frame to the right
     frame.y += borderTop; // The border on the top pushes the frame down
@@ -527,51 +650,41 @@ SC.View.reopen(
   },
 
   /** @private */
-  _adjustForScale: function (frame, layout, scale, oX, oY) {
-    // Add the original, unscaled height and width.
-    var originalWidth = frame.width;
-    var originalHeight = frame.height;
-
-    // make sure width/height are never < 0
-    if (originalHeight < 0) originalHeight = 0;
-    if (originalWidth < 0) originalWidth = 0;
+  _adjustForScale: function (frame, layout) {
 
-    // GATEKEEP: Scale not supported.
+    // Scale not supported on this platform, ignore the layout values.
     if (!SC.platform.supportsCSSTransforms) {
       frame.scale = 1;
       frame.transformOriginX = frame.transformOriginY = 0.5;
 
-      // Add the original, unscaled height and width.
-      frame.originalWidth = originalWidth;
-      frame.originalHeight = originalHeight;
+    // Use scale.
+    } else {
 
-      return frame;
-    }
+      // Get the scale and transform origins, if not provided. (Note inlining of SC.none for performance)
+      /*jshint eqnull:true*/
+      var scale = layout.scale,
+          oX = layout.transformOriginX,
+          oY = layout.transformOriginY;
 
-    // Get the scale and transform origins, if not provided. (Note inlining of SC.none for performance)
-    /*jshint eqnull:true*/
-    scale = scale == null ? layout.scale : scale;
-    oX = oX == null ? layout.transformOriginX : oX;
-    oY = oY == null ? layout.transformOriginY : oY;
-
-    // Get defaults.
-    if (scale == null) scale = 1;
-    if (oX == null) oX = 0.5;
-    if (oY == null) oY = 0.5;
-
-    // If the scale isn't 1, do some calculations.
-    if (scale !== 1) {
-      frame = SC.scaleRect(frame, scale, oX, oY);
-    }
+      // If the scale is set and isn't 1, do some calculations.
+      if (scale != null && scale !== 1) {
+        // Scale the rect.
+        frame = SC.scaleRect(frame, scale, oX, oY);
 
-    // Regardless, attach the scale numbers for reference.
-    frame.scale = scale;
-    frame.transformOriginX = oX;
-    frame.transformOriginY = oY;
+        // Add the scale and original unscaled height and width.
+        frame.scale = scale;
+      }
 
-    // Add the original, unscaled height and width.
-    frame.originalWidth = originalWidth;
-    frame.originalHeight = originalHeight;
+      // If the origin is set and isn't 0.5, include it.
+      if (oX != null && oX !== 0.5) {
+        frame.transformOriginX = oX;
+      }
+
+      // If the origin is set and isn't 0.5, include it.
+      if (oY != null && oY !== 0.5) {
+        frame.transformOriginY = oY;
+      }
+    }
 
     // Make sure width/height are never < 0.
     if (frame.height < 0) frame.height = 0;
@@ -580,6 +693,7 @@ SC.View.reopen(
     return frame;
   },
 
+  /** */
   computeParentDimensions: function (frame) {
     var parentView = this.get('parentView'),
         parentFrame = (parentView) ? parentView.get('frame') : null,
@@ -609,29 +723,54 @@ SC.View.reopen(
     The frame of the view including the borders and scale
   */
   borderFrame: function () {
-    var layout = this.get('layout'),
-        frame = this.get('frame'),
-        scale = (frame && !SC.none(frame.scale)) ? frame.scale : 1,
-        borderTop = this._effectiveBorderFor('borderTop', layout),
-        scaledBorderTop = borderTop * scale,
-        borderRight = this._effectiveBorderFor('borderRight', layout),
-        scaledBorderRight = borderRight * scale,
-        borderBottom = this._effectiveBorderFor('borderBottom', layout),
-        scaledBorderBottom = borderBottom * scale,
-        borderLeft = this._effectiveBorderFor('borderLeft', layout),
-        scaledBorderLeft = borderLeft * scale;
-
-    return frame ? {
-      x: frame.x - scaledBorderLeft,
-      y: frame.y - scaledBorderTop,
-      width: frame.width + scaledBorderLeft + scaledBorderRight,
-      height: frame.height + scaledBorderTop + scaledBorderBottom,
-      scale: scale,
-      originalWidth: frame.originalWidth + borderLeft + borderRight,
-      originalHeight: frame.originalHeight + borderTop + borderBottom,
-      transformOriginX: frame.transformOriginX,
-      transformOriginY: frame.transformOriginY
-    } : null;
+    var frame = this.get('frame'),
+        ret = null;
+
+    if (frame) {
+      var layout = this.get('layout'),
+        defaultValue = layout.border == null ? 0 : layout.border,
+        borderTop = this._sc_explicitValueFor(layout.borderTop, defaultValue),
+        borderRight = this._sc_explicitValueFor(layout.borderRight, defaultValue),
+        borderBottom = this._sc_explicitValueFor(layout.borderBottom, defaultValue),
+        borderLeft = this._sc_explicitValueFor(layout.borderLeft, defaultValue);
+
+      ret = {
+          x: frame.x,
+          y: frame.y,
+          width: frame.width,
+          height: frame.height
+        };
+
+      var scale = frame.scale;
+      /*jshint eqnull:true*/
+      if (scale != null) {
+        var scaledBorderTop = borderTop * scale,
+            scaledBorderRight = borderRight * scale,
+            scaledBorderBottom = borderBottom * scale,
+            scaledBorderLeft = borderLeft * scale;
+
+        ret.scale = scale;
+        ret.x -= scaledBorderLeft;
+        ret.y -= scaledBorderTop;
+        ret.width += scaledBorderLeft + scaledBorderRight;
+        ret.height += scaledBorderTop + scaledBorderBottom;
+      } else {
+        ret.x -= borderLeft;
+        ret.y -= borderTop;
+        ret.width += borderLeft + borderRight;
+        ret.height += borderTop + borderBottom;
+      }
+
+      if (frame.transformOriginX != null) {
+        ret.transformOriginX = frame.transformOriginX;
+      }
+
+      if (frame.transformOriginY != null) {
+        ret.transformOriginY = frame.transformOriginY;
+      }
+    }
+
+    return ret;
   }.property('frame').cacheable(),
 
   /**
@@ -710,6 +849,9 @@ SC.View.reopen(
   */
   _viewFrameDidChange: function () {
     this.notifyPropertyChange('frame');
+
+    // Notify the children that their clipping frame may have changed. Top-down, because a child's
+    // clippingFrame is dependent on its parent's frame.
     this._callOnChildViews('_sc_view_clippingFrameDidChange');
   },
 
@@ -809,6 +951,7 @@ SC.View.reopen(
     // Optimize notifications depending on if we resized or just moved.
     this._checkForResize();
 
+
     // Notify layoutView/parentView, unless we are transitioning.
     var layoutView = this.get('layoutView');
     if (layoutView) {
@@ -1175,20 +1318,16 @@ SC.View.reopen(
     // Our frame may change once we've been adopted to a parent.
     this._checkForResize();
 
-    // Notify all of our descendents that our parent has changed. They will update their `pane` value for one.
-    this._callOnChildViews('_ancestorDidChangeParent');
+    sc_super();
   },
 
   /** @private Extension: The 'orphaned' event. */
-  _orphaned: function (oldParentView) {
+  _orphaned: function () {
     sc_super();
 
     if (!this.isDestroyed) {
       // Our frame may change once we've been removed from a parent.
       this._checkForResize();
-
-      // Notify all of our descendents that our parent has changed. They will update their `pane` value for one.
-      this._callOnChildViews('_ancestorDidChangeParent');
     }
   },