295 lines
9.7 KiB
Objective-C
295 lines
9.7 KiB
Objective-C
/**
|
|
* Copyright (c) 2014-present, Facebook, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This source code is licensed under the BSD-style license found in the
|
|
* LICENSE file in the root directory of this source tree. An additional grant
|
|
* of patent rights can be found in the PATENTS file in the same directory.
|
|
*/
|
|
|
|
#import <UIKit/UIKit.h>
|
|
#import <YogaKit/UIView+YogaKit.h>
|
|
#import <YogaKit/YKLayout.h>
|
|
#import <YogaKit/yoga.h>
|
|
|
|
#define YK_STYLE_PROPERTY_IMPL(objc_type, c_type, lowercased_name, capitalized_name) \
|
|
- (objc_type)lowercased_name \
|
|
{ \
|
|
return (objc_type)YGNodeStyleGet##capitalized_name(_node); \
|
|
} \
|
|
\
|
|
- (void)set##capitalized_name:(objc_type)lowercased_name \
|
|
{ \
|
|
YGNodeStyleSet##capitalized_name(_node, (c_type)lowercased_name); \
|
|
}
|
|
|
|
#define _YK_STYLE_EDGE_PROPERTY_IMPL(lowercased_name, capitalized_name, edge) \
|
|
- (CGFloat)lowercased_name##edge \
|
|
{ \
|
|
return YGNodeStyleGet##capitalized_name(_node, YGEdge##edge); \
|
|
} \
|
|
\
|
|
- (void)set##capitalized_name##edge:(CGFloat)lowercased_name##edge \
|
|
{ \
|
|
YGNodeStyleSet##capitalized_name(_node, YGEdge##edge, lowercased_name##edge); \
|
|
}
|
|
|
|
#define YK_STYLE_EDGE_PROPERTY_IMPL(lowercased_name, capitalized_name) \
|
|
_YK_STYLE_EDGE_PROPERTY_IMPL(lowercased_name, capitalized_name, Left) \
|
|
_YK_STYLE_EDGE_PROPERTY_IMPL(lowercased_name, capitalized_name, Top) \
|
|
_YK_STYLE_EDGE_PROPERTY_IMPL(lowercased_name, capitalized_name, Right) \
|
|
_YK_STYLE_EDGE_PROPERTY_IMPL(lowercased_name, capitalized_name, Bottom) \
|
|
_YK_STYLE_EDGE_PROPERTY_IMPL(lowercased_name, capitalized_name, Start) \
|
|
_YK_STYLE_EDGE_PROPERTY_IMPL(lowercased_name, capitalized_name, End) \
|
|
_YK_STYLE_EDGE_PROPERTY_IMPL(lowercased_name, capitalized_name, Horizontal) \
|
|
_YK_STYLE_EDGE_PROPERTY_IMPL(lowercased_name, capitalized_name, Vertical) \
|
|
_YK_STYLE_EDGE_PROPERTY_IMPL(lowercased_name, capitalized_name, All)
|
|
|
|
@interface YKLayout ()
|
|
@property (nonatomic, weak, readonly) UIView* view;
|
|
@property (nonatomic, assign, readonly) YGNodeRef node;
|
|
@end
|
|
|
|
@implementation YKLayout
|
|
|
|
@synthesize isEnabled=_isEnabled;
|
|
@synthesize isIncluded=_isIncluded;
|
|
|
|
+ (void)initialize
|
|
{
|
|
YGSetExperimentalFeatureEnabled(YGExperimentalFeatureWebFlexBasis, true);
|
|
}
|
|
|
|
- (instancetype)initWithView:(UIView*)view
|
|
{
|
|
if ([super init]) {
|
|
_view = view;
|
|
_node = YGNodeNew();
|
|
YGNodeSetContext(_node, (__bridge void *) view);
|
|
_isEnabled = NO;
|
|
_isIncluded = YES;
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
- (void)dealloc
|
|
{
|
|
YGNodeFree(_node);
|
|
}
|
|
|
|
- (NSUInteger)numberOfChildren
|
|
{
|
|
return YGNodeGetChildCount(_node);
|
|
}
|
|
|
|
YK_STYLE_PROPERTY_IMPL(YKDirection, YGDirection, direction, Direction)
|
|
YK_STYLE_PROPERTY_IMPL(YKFlexDirection, YGFlexDirection, flexDirection, FlexDirection)
|
|
YK_STYLE_PROPERTY_IMPL(YKJustify, YGJustify, justifyContent, JustifyContent)
|
|
YK_STYLE_PROPERTY_IMPL(YKAlign, YGAlign, alignContent, AlignContent)
|
|
YK_STYLE_PROPERTY_IMPL(YKAlign, YGAlign, alignItems, AlignItems)
|
|
YK_STYLE_PROPERTY_IMPL(YKAlign, YGAlign, alignSelf, AlignSelf)
|
|
YK_STYLE_PROPERTY_IMPL(YKPositionType, YGPositionType, positionType, PositionType)
|
|
YK_STYLE_PROPERTY_IMPL(YKWrap, YGWrap, flexWrap, FlexWrap)
|
|
YK_STYLE_PROPERTY_IMPL(CGFloat, CGFloat, flexGrow, FlexGrow)
|
|
YK_STYLE_PROPERTY_IMPL(CGFloat, CGFloat, flexShrink, FlexShrink)
|
|
YK_STYLE_PROPERTY_IMPL(CGFloat, CGFloat, flexBasis, FlexBasis)
|
|
YK_STYLE_EDGE_PROPERTY_IMPL(position, Position)
|
|
YK_STYLE_EDGE_PROPERTY_IMPL(margin, Margin)
|
|
YK_STYLE_EDGE_PROPERTY_IMPL(padding, Padding)
|
|
YK_STYLE_PROPERTY_IMPL(CGFloat, CGFloat, width, Width)
|
|
YK_STYLE_PROPERTY_IMPL(CGFloat, CGFloat, height, Height)
|
|
YK_STYLE_PROPERTY_IMPL(CGFloat, CGFloat, minWidth, MinWidth)
|
|
YK_STYLE_PROPERTY_IMPL(CGFloat, CGFloat, minHeight, MinHeight)
|
|
YK_STYLE_PROPERTY_IMPL(CGFloat, CGFloat, maxWidth, MaxWidth)
|
|
YK_STYLE_PROPERTY_IMPL(CGFloat, CGFloat, maxHeight, MaxHeight)
|
|
YK_STYLE_PROPERTY_IMPL(CGFloat, CGFloat, aspectRatio, AspectRatio)
|
|
|
|
#pragma mark - Layout and Sizing
|
|
|
|
- (YKDirection)resolvedDirection
|
|
{
|
|
return (YKDirection)YGNodeLayoutGetDirection(_node);
|
|
}
|
|
|
|
- (void)apply
|
|
{
|
|
[self calculateLayoutWithSize:self.view.bounds.size];
|
|
YKApplyLayoutToViewHierarchy(self);
|
|
}
|
|
|
|
- (CGSize)intrinsicSize
|
|
{
|
|
const CGSize constrainedSize = {
|
|
.width = YGUndefined,
|
|
.height = YGUndefined,
|
|
};
|
|
return [self calculateLayoutWithSize:constrainedSize];
|
|
}
|
|
|
|
#pragma mark - Private
|
|
|
|
- (CGSize)calculateLayoutWithSize:(CGSize)size
|
|
{
|
|
NSAssert([NSThread isMainThread], @"YG Layout calculation must be done on main.");
|
|
NSAssert([self isEnabled], @"YG Layout is not enabled for this view.");
|
|
|
|
YKAttachNodesFromViewHierachy(self);
|
|
|
|
const YGNodeRef node = _node;
|
|
YGNodeCalculateLayout(
|
|
node,
|
|
size.width,
|
|
size.height,
|
|
YGNodeStyleGetDirection(node));
|
|
|
|
return (CGSize) {
|
|
.width = YGNodeLayoutGetWidth(node),
|
|
.height = YGNodeLayoutGetHeight(node),
|
|
};
|
|
}
|
|
|
|
static YGSize YKMeasureView(
|
|
YGNodeRef node,
|
|
float width,
|
|
YGMeasureMode widthMode,
|
|
float height,
|
|
YGMeasureMode heightMode)
|
|
{
|
|
const CGFloat constrainedWidth = (widthMode == YGMeasureModeUndefined) ? CGFLOAT_MAX : width;
|
|
const CGFloat constrainedHeight = (heightMode == YGMeasureModeUndefined) ? CGFLOAT_MAX: height;
|
|
|
|
UIView *view = (__bridge UIView*) YGNodeGetContext(node);
|
|
const CGSize sizeThatFits = [view sizeThatFits:(CGSize) {
|
|
.width = constrainedWidth,
|
|
.height = constrainedHeight,
|
|
}];
|
|
|
|
return (YGSize) {
|
|
.width = YKSanitizeMeasurement(constrainedWidth, sizeThatFits.width, widthMode),
|
|
.height = YKSanitizeMeasurement(constrainedHeight, sizeThatFits.height, heightMode),
|
|
};
|
|
}
|
|
|
|
static CGFloat YKSanitizeMeasurement(
|
|
CGFloat constrainedSize,
|
|
CGFloat measuredSize,
|
|
YGMeasureMode measureMode)
|
|
{
|
|
CGFloat result;
|
|
if (measureMode == YGMeasureModeExactly) {
|
|
result = constrainedSize;
|
|
} else if (measureMode == YGMeasureModeAtMost) {
|
|
result = MIN(constrainedSize, measuredSize);
|
|
} else {
|
|
result = measuredSize;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static void YKAttachNodesFromViewHierachy(YKLayout *layout) {
|
|
YGNodeRef node = layout.node;
|
|
UIView *view = layout.view;
|
|
|
|
// Only leaf nodes should have a measure function
|
|
if (![layout isEnabled] || view.subviews.count == 0) {
|
|
YGNodeSetMeasureFunc(node, YKMeasureView);
|
|
YKRemoveAllChildren(node);
|
|
} else {
|
|
YGNodeSetMeasureFunc(node, NULL);
|
|
|
|
// Create a list of all the subviews that we are going to use for layout.
|
|
NSMutableArray<UIView *> *subviewsToInclude = [[NSMutableArray alloc] initWithCapacity:view.subviews.count];
|
|
for (UIView *subview in view.subviews) {
|
|
if (subview.layout.isIncluded) {
|
|
[subviewsToInclude addObject:subview];
|
|
}
|
|
}
|
|
|
|
BOOL shouldReconstructChildList = NO;
|
|
if (YGNodeGetChildCount(node) != subviewsToInclude.count) {
|
|
shouldReconstructChildList = YES;
|
|
} else {
|
|
for (int i = 0; i < subviewsToInclude.count; i++) {
|
|
if (YGNodeGetChild(node, i) != subviewsToInclude[i].layout.node) {
|
|
shouldReconstructChildList = YES;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (shouldReconstructChildList) {
|
|
YKRemoveAllChildren(node);
|
|
|
|
for (int i = 0 ; i < subviewsToInclude.count; i++) {
|
|
UIView *const subview = subviewsToInclude[i];
|
|
YGNodeInsertChild(node, subview.layout.node, i);
|
|
YKAttachNodesFromViewHierachy(subview.layout);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void YKRemoveAllChildren(const YGNodeRef node)
|
|
{
|
|
if (node == NULL) {
|
|
return;
|
|
}
|
|
|
|
while (YGNodeGetChildCount(node) > 0) {
|
|
YGNodeRemoveChild(node, YGNodeGetChild(node, YGNodeGetChildCount(node) - 1));
|
|
}
|
|
}
|
|
|
|
static CGFloat YKRoundPixelValue(CGFloat value)
|
|
{
|
|
static CGFloat scale;
|
|
static dispatch_once_t onceToken;
|
|
dispatch_once(&onceToken, ^(){
|
|
scale = [UIScreen mainScreen].scale;
|
|
});
|
|
|
|
return round(value * scale) / scale;
|
|
}
|
|
|
|
static void YKApplyLayoutToViewHierarchy(YKLayout *layout) {
|
|
NSCAssert([NSThread isMainThread], @"Framesetting should only be done on the main thread.");
|
|
|
|
if (!layout.isIncluded) {
|
|
return;
|
|
}
|
|
|
|
YGNodeRef node = layout.node;
|
|
const CGPoint topLeft = {
|
|
YGNodeLayoutGetLeft(node),
|
|
YGNodeLayoutGetTop(node),
|
|
};
|
|
|
|
const CGPoint bottomRight = {
|
|
topLeft.x + YGNodeLayoutGetWidth(node),
|
|
topLeft.y + YGNodeLayoutGetHeight(node),
|
|
};
|
|
|
|
UIView *view = layout.view;
|
|
view.frame = (CGRect) {
|
|
.origin = {
|
|
.x = YKRoundPixelValue(topLeft.x),
|
|
.y = YKRoundPixelValue(topLeft.y),
|
|
},
|
|
.size = {
|
|
.width = YKRoundPixelValue(bottomRight.x) - YKRoundPixelValue(topLeft.x),
|
|
.height = YKRoundPixelValue(bottomRight.y) - YKRoundPixelValue(topLeft.y),
|
|
},
|
|
};
|
|
|
|
const BOOL isLeaf = !layout.isEnabled || view.subviews.count == 0;
|
|
if (!isLeaf) {
|
|
for (NSUInteger i = 0; i < view.subviews.count; i++) {
|
|
YKApplyLayoutToViewHierarchy(view.subviews[i].layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
@end
|