From 93564899fdbe6d0c941f727d08f40db45236e352 Mon Sep 17 00:00:00 2001 From: Huy Nguyen Date: Thu, 25 Jun 2015 07:23:01 +0700 Subject: [PATCH] Remove Auto size type. --- AsyncDisplayKit/Layout/ASDimension.h | 50 +++++-------------- AsyncDisplayKit/Layout/ASDimension.mm | 48 ++++++------------ AsyncDisplayKit/Layout/ASStackLayoutNode.h | 2 +- AsyncDisplayKit/Layout/ASStackLayoutNode.mm | 1 + AsyncDisplayKit/Layout/ASStaticLayoutNode.h | 2 +- AsyncDisplayKit/Layout/ASStaticLayoutNode.mm | 6 ++- .../Private/ASStackUnpositionedLayout.mm | 8 ++- 7 files changed, 41 insertions(+), 76 deletions(-) diff --git a/AsyncDisplayKit/Layout/ASDimension.h b/AsyncDisplayKit/Layout/ASDimension.h index f1f9d96720..294b633e8d 100644 --- a/AsyncDisplayKit/Layout/ASDimension.h +++ b/AsyncDisplayKit/Layout/ASDimension.h @@ -13,20 +13,17 @@ /** A dimension relative to constraints to be provided in the future. - A RelativeDimension can be one of three types: - - "Auto" - This indicated "I have no opinion" and may be resolved in whatever way makes most sense given - the circumstances. This is the default type. - - "Points" - Just a number. It will always resolve to exactly this amount. + A RelativeDimension can be one of two types: + "Points" - Just a number. It will always resolve to exactly this amount. This is the default type. + "Percent" - Multiplied to a provided parent amount to resolve a final amount. */ typedef NS_ENUM(NSInteger, ASRelativeDimensionType) { - ASRelativeDimensionTypeAuto, ASRelativeDimensionTypePoints, ASRelativeDimensionTypePercent, }; + typedef struct { ASRelativeDimensionType type; CGFloat value; @@ -52,17 +49,9 @@ typedef struct { ASRelativeSize max; } ASRelativeSizeRange; -/** type = Auto; value = 0 */ -extern ASRelativeDimension const ASRelativeDimensionAuto; +extern ASRelativeDimension const ASRelativeDimensionUnconstrained; -/** min = {0,0}; max = {INFINITY, INFINITY} */ -extern ASSizeRange const ASSizeRangeUnconstrained; - -/** width = Auto; height = Auto */ -extern ASRelativeSize const ASRelativeSizeAuto; - -/** min = {Auto, Auto}; max = {Auto, Auto} */ -extern ASRelativeSizeRange const ASRelativeSizeRangeAuto; +extern ASRelativeSizeRange const ASRelativeSizeRangeUnconstrained; ASDISPLAYNODE_EXTERN_C_BEGIN @@ -80,7 +69,7 @@ extern BOOL ASRelativeDimensionEqualToDimension(ASRelativeDimension lhs, ASRelat extern NSString *NSStringFromASRelativeDimension(ASRelativeDimension dimension); -extern CGFloat ASRelativeDimensionResolve(ASRelativeDimension dimension, CGFloat autoSize, CGFloat parent); +extern CGFloat ASRelativeDimensionResolve(ASRelativeDimension dimension, CGFloat parent); #pragma mark - #pragma mark ASSizeRange @@ -108,8 +97,8 @@ extern ASRelativeSize ASRelativeSizeMake(ASRelativeDimension width, ASRelativeDi /** Convenience constructor to provide size in Points. */ extern ASRelativeSize ASRelativeSizeMakeWithCGSize(CGSize size); -/** Resolve this relative size relative to a parent size and an auto size. */ -extern CGSize ASRelativeSizeResolveSize(ASRelativeSize relativeSize, CGSize parentSize, CGSize autoSize); +/** Resolve this relative size relative to a parent size. */ +extern CGSize ASRelativeSizeResolveSize(ASRelativeSize relativeSize, CGSize parentSize); extern BOOL ASRelativeSizeEqualToSize(ASRelativeSize lhs, ASRelativeSize rhs); @@ -128,25 +117,12 @@ extern ASRelativeSizeRange ASRelativeSizeRangeMakeWithExactCGSize(CGSize exact); extern ASRelativeSizeRange ASRelativeSizeRangeMakeWithExactRelativeDimensions(ASRelativeDimension exactWidth, ASRelativeDimension exactHeight); +extern BOOL ASRelativeSizeRangeEqualToRelativeSizeRange(ASRelativeSizeRange lhs, ASRelativeSizeRange rhs); + /** - Provided a parent size and values to use in place of Auto, compute final dimensions for this RelativeSizeRange - to arrive at a SizeRange. + Provided a parent size, compute final dimensions for this RelativeSizeRange to arrive at a SizeRange. */ extern ASSizeRange ASRelativeSizeRangeResolveSizeRange(ASRelativeSizeRange relativeSizeRange, - CGSize parentSize, - ASSizeRange autoSizeRange); - -/** - Provided a parent size and a default autoSizeRange, compute final dimensions for this RelativeSizeRange - to arrive at a SizeRange. As an example: - - CGSize parent = {200, 120}; - RelativeSizeRange rel = {Percent(0.5), Percent(2/3)} - ASRelativeSizeRangeResolve(rel, parent); // {{100, 60}, {100, 60}} - - The default autoSizeRange is *everything*, meaning ASSizeRangeUnconstrained. - */ -extern ASSizeRange ASRelativeSizeRangeResolveSizeRangeWithDefaultAutoSizeRange(ASRelativeSizeRange relativeSizeRange, - CGSize parentSize); + CGSize parentSize); ASDISPLAYNODE_EXTERN_C_END diff --git a/AsyncDisplayKit/Layout/ASDimension.mm b/AsyncDisplayKit/Layout/ASDimension.mm index 3438b1d06e..9d8c178a5a 100644 --- a/AsyncDisplayKit/Layout/ASDimension.mm +++ b/AsyncDisplayKit/Layout/ASDimension.mm @@ -12,17 +12,15 @@ #import "ASAssert.h" -ASRelativeDimension const ASRelativeDimensionAuto = {ASRelativeDimensionTypeAuto, 0}; -ASSizeRange const ASSizeRangeUnconstrained = {{0,0}, {INFINITY, INFINITY}}; -ASRelativeSize const ASRelativeSizeAuto = {ASRelativeDimensionAuto, ASRelativeDimensionAuto}; -ASRelativeSizeRange const ASRelativeSizeRangeAuto = {ASRelativeSizeAuto, ASRelativeSizeAuto}; +ASRelativeDimension const ASRelativeDimensionUnconstrained = {}; + +ASRelativeSizeRange const ASRelativeSizeRangeUnconstrained = {}; #pragma mark ASRelativeDimension ASRelativeDimension ASRelativeDimensionMake(ASRelativeDimensionType type, CGFloat value) { if (type == ASRelativeDimensionTypePoints) { ASDisplayNodeCAssertPositiveReal(@"Points", value); } - if (type == ASRelativeDimensionTypeAuto) { ASDisplayNodeCAssertTrue(value == 0); } ASRelativeDimension dimension; dimension.type = type; dimension.value = value; return dimension; } @@ -43,24 +41,12 @@ ASRelativeDimension ASRelativeDimensionCopy(ASRelativeDimension aDimension) BOOL ASRelativeDimensionEqualToDimension(ASRelativeDimension lhs, ASRelativeDimension rhs) { - // Implementation assumes that "auto" assigns '0' to value. - if (lhs.type != rhs.type) { - return false; - } - switch (lhs.type) { - case ASRelativeDimensionTypeAuto: - return true; - case ASRelativeDimensionTypePoints: - case ASRelativeDimensionTypePercent: - return lhs.value == rhs.value; - } + return lhs.type == rhs.type && lhs.value == rhs.value; } NSString *NSStringFromASRelativeDimension(ASRelativeDimension dimension) { switch (dimension.type) { - case ASRelativeDimensionTypeAuto: - return @"Auto"; case ASRelativeDimensionTypePoints: return [NSString stringWithFormat:@"%.0fpt", dimension.value]; case ASRelativeDimensionTypePercent: @@ -68,11 +54,9 @@ NSString *NSStringFromASRelativeDimension(ASRelativeDimension dimension) } } -CGFloat ASRelativeDimensionResolve(ASRelativeDimension dimension, CGFloat autoSize, CGFloat parent) +CGFloat ASRelativeDimensionResolve(ASRelativeDimension dimension, CGFloat parent) { switch (dimension.type) { - case ASRelativeDimensionTypeAuto: - return autoSize; case ASRelativeDimensionTypePoints: return dimension.value; case ASRelativeDimensionTypePercent: @@ -160,16 +144,16 @@ ASRelativeSize ASRelativeSizeMakeWithCGSize(CGSize size) ASRelativeDimensionMakeWithPoints(size.height)); } -CGSize ASRelativeSizeResolveSize(ASRelativeSize relativeSize, CGSize parentSize, CGSize autoSize) +CGSize ASRelativeSizeResolveSize(ASRelativeSize relativeSize, CGSize parentSize) { - return CGSizeMake(ASRelativeDimensionResolve(relativeSize.width, autoSize.width, parentSize.width), - ASRelativeDimensionResolve(relativeSize.height, autoSize.height, parentSize.height)); + return CGSizeMake(ASRelativeDimensionResolve(relativeSize.width, parentSize.width), + ASRelativeDimensionResolve(relativeSize.height, parentSize.height)); } BOOL ASRelativeSizeEqualToSize(ASRelativeSize lhs, ASRelativeSize rhs) { return ASRelativeDimensionEqualToDimension(lhs.width, rhs.width) - && ASRelativeDimensionEqualToDimension(lhs.height, rhs.height); + && ASRelativeDimensionEqualToDimension(lhs.height, rhs.height); } NSString *NSStringFromASRelativeSize(ASRelativeSize size) @@ -203,16 +187,14 @@ ASRelativeSizeRange ASRelativeSizeRangeMakeWithExactRelativeDimensions(ASRelativ return ASRelativeSizeRangeMakeWithExactRelativeSize(ASRelativeSizeMake(exactWidth, exactHeight)); } -ASSizeRange ASRelativeSizeRangeResolveSizeRange(ASRelativeSizeRange relativeSizeRange, - CGSize parentSize, - ASSizeRange autoSizeRange) +BOOL ASRelativeSizeRangeEqualToRelativeSizeRange(ASRelativeSizeRange lhs, ASRelativeSizeRange rhs) { - return ASSizeRangeMake(ASRelativeSizeResolveSize(relativeSizeRange.min, parentSize, autoSizeRange.min), - ASRelativeSizeResolveSize(relativeSizeRange.max, parentSize, autoSizeRange.max)); + return ASRelativeSizeEqualToSize(lhs.min, rhs.min) && ASRelativeSizeEqualToSize(lhs.max, rhs.max); } -ASSizeRange ASRelativeSizeRangeResolveSizeRangeWithDefaultAutoSizeRange(ASRelativeSizeRange relativeSizeRange, - CGSize parentSize) +ASSizeRange ASRelativeSizeRangeResolveSizeRange(ASRelativeSizeRange relativeSizeRange, + CGSize parentSize) { - return ASRelativeSizeRangeResolveSizeRange(relativeSizeRange, parentSize, ASSizeRangeUnconstrained); + return ASSizeRangeMake(ASRelativeSizeResolveSize(relativeSizeRange.min, parentSize), + ASRelativeSizeResolveSize(relativeSizeRange.max, parentSize)); } diff --git a/AsyncDisplayKit/Layout/ASStackLayoutNode.h b/AsyncDisplayKit/Layout/ASStackLayoutNode.h index d86399ccde..79a7170aa1 100644 --- a/AsyncDisplayKit/Layout/ASStackLayoutNode.h +++ b/AsyncDisplayKit/Layout/ASStackLayoutNode.h @@ -82,7 +82,7 @@ typedef struct { @property (nonatomic, readonly) BOOL flexGrow; /** If the sum of childrens' stack dimensions is greater than the maximum size, should this node shrink? */ @property (nonatomic, readonly) BOOL flexShrink; -/** Specifies the initial size in the stack dimension for the child. */ +/** Specifies the initial size in the stack dimension for the child. Default to ASRelativeDimensionUnconstrained. */ @property (nonatomic, readonly) ASRelativeDimension flexBasis; /** Orientation of the child along cross axis, overriding alignItems */ @property (nonatomic, readonly) ASStackLayoutAlignSelf alignSelf; diff --git a/AsyncDisplayKit/Layout/ASStackLayoutNode.mm b/AsyncDisplayKit/Layout/ASStackLayoutNode.mm index ae55c0af70..bdd8d735b9 100644 --- a/AsyncDisplayKit/Layout/ASStackLayoutNode.mm +++ b/AsyncDisplayKit/Layout/ASStackLayoutNode.mm @@ -84,6 +84,7 @@ ASStackLayoutNodeChild *c = [super new]; if (c && initializer) { ASMutableStackLayoutNodeChild *mutableChild = [[ASMutableStackLayoutNodeChild alloc] init]; + mutableChild.flexBasis = ASRelativeDimensionUnconstrained; initializer(mutableChild); c = [mutableChild copy]; } diff --git a/AsyncDisplayKit/Layout/ASStaticLayoutNode.h b/AsyncDisplayKit/Layout/ASStaticLayoutNode.h index 2485d97941..cee1387688 100644 --- a/AsyncDisplayKit/Layout/ASStaticLayoutNode.h +++ b/AsyncDisplayKit/Layout/ASStaticLayoutNode.h @@ -24,7 +24,7 @@ + (instancetype)newWithPosition:(CGPoint)position node:(ASLayoutNode *)node size:(ASRelativeSizeRange)size; /** - Convenience with default size is Auto in both dimensions, which sets the child's min size to zero + Convenience with default size is Unconstrained in both dimensions, which sets the child's min size to zero and max size to the maximum available space it can consume without overflowing the node's bounds. */ + (instancetype)newWithPosition:(CGPoint)position node:(ASLayoutNode *)node; diff --git a/AsyncDisplayKit/Layout/ASStaticLayoutNode.mm b/AsyncDisplayKit/Layout/ASStaticLayoutNode.mm index e5ceff15d4..bfd1d52da8 100644 --- a/AsyncDisplayKit/Layout/ASStaticLayoutNode.mm +++ b/AsyncDisplayKit/Layout/ASStaticLayoutNode.mm @@ -29,7 +29,7 @@ + (instancetype)newWithPosition:(CGPoint)position node:(ASLayoutNode *)node { - return [self newWithPosition:position node:node size:{}]; + return [self newWithPosition:position node:node size:ASRelativeSizeRangeUnconstrained]; } @end @@ -66,7 +66,9 @@ constrainedSize.max.width - child.position.x, constrainedSize.max.height - child.position.y }; - ASSizeRange childConstraint = ASRelativeSizeRangeResolveSizeRange(child.size, size, {{0,0}, autoMaxSize}); + ASSizeRange childConstraint = ASRelativeSizeRangeEqualToRelativeSizeRange(ASRelativeSizeRangeUnconstrained, child.size) + ? ASSizeRangeMake({0, 0}, autoMaxSize) + : ASRelativeSizeRangeResolveSizeRange(child.size, size); ASLayoutChild *layoutChild = [ASLayoutChild newWithPosition:child.position layout:[child.node calculateLayoutThatFits:childConstraint]]; [layoutChildren addObject:layoutChild]; diff --git a/AsyncDisplayKit/Private/ASStackUnpositionedLayout.mm b/AsyncDisplayKit/Private/ASStackUnpositionedLayout.mm index 189de696ac..913f49a28f 100644 --- a/AsyncDisplayKit/Private/ASStackUnpositionedLayout.mm +++ b/AsyncDisplayKit/Private/ASStackUnpositionedLayout.mm @@ -292,7 +292,11 @@ static std::vector layoutChildrenAlongUnconstrainedStac { const CGFloat minCrossDimension = crossDimension(style.direction, sizeRange.min); const CGFloat maxCrossDimension = crossDimension(style.direction, sizeRange.max); + return AS::map(children, [&](ASStackLayoutNodeChild *child) -> ASStackUnpositionedItem { + const BOOL isUnconstrainedFlexBasis = ASRelativeDimensionEqualToDimension(ASRelativeDimensionUnconstrained, child.flexBasis); + const CGFloat exactStackDimension = ASRelativeDimensionResolve(child.flexBasis, stackDimension(style.direction, size)); + if (useOptimizedFlexing && isFlexibleInBothDirections(child)) { return { child, [ASLayout newWithNode:child.node size:{0, 0}] }; } else { @@ -300,8 +304,8 @@ static std::vector layoutChildrenAlongUnconstrainedStac child, crossChildLayout(child, style, - ASRelativeDimensionResolve(child.flexBasis, 0, stackDimension(style.direction, size)), - ASRelativeDimensionResolve(child.flexBasis, INFINITY, stackDimension(style.direction, size)), + isUnconstrainedFlexBasis ? 0 : exactStackDimension, + isUnconstrainedFlexBasis ? INFINITY : exactStackDimension, minCrossDimension, maxCrossDimension) };