ThePain/Swiftgram
1
0
Fork 0
mirror of https://github.com/Swiftgram/Telegram-iOS.git synced 2026-03-22 15:15:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove Auto size type.

Browse Source
This commit is contained in:
Huy Nguyen
2015-06-25 07:23:01 +07:00
parent 65aa677afc
commit 93564899fd
7 changed files with 41 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
AsyncDisplayKit/Layout/ASDimension.h
View File

@@ -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

48
AsyncDisplayKit/Layout/ASDimension.mm
View File

@@ -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));
}

2
AsyncDisplayKit/Layout/ASStackLayoutNode.h
View File

@@ -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;

1
AsyncDisplayKit/Layout/ASStackLayoutNode.mm
View File

@@ -84,6 +84,7 @@
ASStackLayoutNodeChild *c = [super new];
if (c && initializer) {
ASMutableStackLayoutNodeChild *mutableChild = [[ASMutableStackLayoutNodeChild alloc] init];
mutableChild.flexBasis = ASRelativeDimensionUnconstrained;
initializer(mutableChild);
c = [mutableChild copy];
}

2
AsyncDisplayKit/Layout/ASStaticLayoutNode.h
View File

@@ -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;

6
AsyncDisplayKit/Layout/ASStaticLayoutNode.mm
View File

@@ -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];

8
AsyncDisplayKit/Private/ASStackUnpositionedLayout.mm
View File

@@ -292,7 +292,11 @@ static std::vector<ASStackUnpositionedItem> 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<ASStackUnpositionedItem> 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)
};