/* * Copyright [2019] [Doric.Pub] * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ // // Created by pengfei.zhou on 2019/10/23. // #import "DoricLayouts.h" #import #import "UIView+Doric.h" #import "DoricExtensions.h" #import "UIView+Yoga.h" #import #import "Yoga.h" @interface YGLayout () @property(nonatomic, assign, readonly) YGNodeRef node; @end void DoricAddEllipticArcPath(CGMutablePathRef path, CGPoint origin, CGFloat radius, CGFloat startAngle, CGFloat endAngle) { CGAffineTransform t = CGAffineTransformMakeTranslation(origin.x, origin.y); CGPathAddArc(path, &t, 0, 0, radius, startAngle, endAngle, NO); } CGPathRef DoricCreateRoundedRectPath(CGRect bounds, CGFloat leftTop, CGFloat rightTop, CGFloat rightBottom, CGFloat leftBottom) { const CGFloat minX = CGRectGetMinX(bounds); const CGFloat minY = CGRectGetMinY(bounds); const CGFloat maxX = CGRectGetMaxX(bounds); const CGFloat maxY = CGRectGetMaxY(bounds); CGMutablePathRef path = CGPathCreateMutable(); DoricAddEllipticArcPath(path, (CGPoint) { minX + leftTop, minY + leftTop }, leftTop, M_PI, 3 * M_PI_2); DoricAddEllipticArcPath(path, (CGPoint) { maxX - rightTop, minY + rightTop }, rightTop, 3 * M_PI_2, 0); DoricAddEllipticArcPath(path, (CGPoint) { maxX - rightBottom, maxY - rightBottom }, rightBottom, 0, M_PI_2); DoricAddEllipticArcPath(path, (CGPoint) { minX + leftBottom, maxY - leftBottom }, leftBottom, M_PI_2, M_PI); CGPathCloseSubpath(path); return path; } static const void *kLayoutConfig = &kLayoutConfig; @interface DoricShapeLayer : CAShapeLayer @property CGRect viewBounds; @property UIEdgeInsets corners; @end @implementation DoricShapeLayer @end @implementation UIView (DoricLayoutCategory) @dynamic doricLayout; - (void)setDoricLayout:(DoricLayout *)doricLayout { objc_setAssociatedObject(self, kLayoutConfig, doricLayout, OBJC_ASSOCIATION_RETAIN_NONATOMIC); } - (DoricLayout *)doricLayout { DoricLayout *layout = objc_getAssociatedObject(self, kLayoutConfig); if (!layout) { layout = [DoricLayout new]; layout.width = self.width; layout.height = self.height; layout.view = self; self.doricLayout = layout; } return layout; } @end struct DoricSizeAndState { NSUInteger state; CGFloat size; }; typedef struct DoricSizeAndState DoricSizeAndState; DoricMeasureSpec DoricMeasureSpecMake(DoricMeasureSpecMode mode, CGFloat size) { DoricMeasureSpec spec; spec.mode = mode; spec.size = size; return spec; } NSUInteger DORIC_MEASURED_STATE_MASK = 0x11; NSUInteger DORIC_MEASURED_HEIGHT_STATE_SHIFT = 8; NSUInteger DORIC_MEASURED_STATE_TOO_SMALL = 0x01; @interface DoricLayout () /** * width-height * 0xff--ff * */ @property(nonatomic, assign) NSUInteger measuredState; @property(nonatomic, strong) NSMutableDictionary *measuredCache; @end @implementation DoricLayout - (instancetype)init { if (self = [super init]) { _widthSpec = DoricLayoutJust; _heightSpec = DoricLayoutJust; _maxWidth = CGFLOAT_MAX; _maxHeight = CGFLOAT_MAX; _minWidth = -1; _minHeight = -1; _measuredState = 0; _measuredCache = [NSMutableDictionary new]; } return self; } - (void)setMeasuredWidth:(CGFloat)measuredWidth { _measuredWidth = MAX(0, measuredWidth); } - (void)setMeasuredHeight:(CGFloat)measuredHeight { _measuredHeight = MAX(0, measuredHeight); } - (void)apply:(CGSize)frameSize { self.resolved = NO; [self measure:frameSize]; [self setFrame]; self.resolved = YES; } - (void)apply { [self apply:self.view.frame.size]; } - (void)measure:(CGSize)targetSize { [self doMeasure:targetSize]; [self layout]; } - (DoricMeasureSpec)getRootMeasureSpec:(CGFloat)targetSize layoutSpec:(DoricLayoutSpec)spec size:(CGFloat)size { switch (spec) { case DoricLayoutMost: return DoricMeasureSpecMake(DoricMeasureExactly, targetSize); case DoricLayoutFit: if ([self.view.superview isKindOfClass:UIScrollView.class]) { return DoricMeasureSpecMake(DoricMeasureUnspecified, 0); } return DoricMeasureSpecMake(DoricMeasureAtMost, targetSize); default: return DoricMeasureSpecMake(DoricMeasureExactly, size); } } - (void)doMeasure:(CGSize)targetSize { DoricMeasureSpec widthSpec = [self getRootMeasureSpec:targetSize.width layoutSpec:self.widthSpec size:self.width]; DoricMeasureSpec heightSpec = [self getRootMeasureSpec:targetSize.height layoutSpec:self.heightSpec size:self.height]; [self measureWidth:widthSpec height:heightSpec]; } #pragma helper - (CGFloat)takenWidth { return self.measuredWidth + self.marginLeft + self.marginRight; } - (CGFloat)takenHeight { return self.measuredHeight + self.marginTop + self.marginBottom; } - (BOOL)rect:(CGRect)rect1 equalTo:(CGRect)rect2 { return ABS(rect1.origin.x - rect2.origin.x) < 0.00001f && ABS(rect1.origin.y - rect2.origin.y) < 0.00001f && ABS(rect1.size.width - rect2.size.width) < 0.00001f && ABS(rect1.size.height - rect2.size.height) < 0.00001f; } - (NSString *)getLayoutType { switch (self.layoutType) { case DoricVLayout: return @"VLayout"; case DoricHLayout: return @"HLayout"; case DoricStack: return @"Stack"; default: return [NSString stringWithFormat:@"Undefined:%@", self.view.class]; } } - (NSString *)getSpecType:(DoricLayoutSpec)spec { switch (spec) { case DoricLayoutJust: return @"JUST"; case DoricLayoutMost: return @"MOST"; default: return @"FIT"; } } - (NSString *)toString { return [NSString stringWithFormat:@"%@[width:%@,height:%@]", [self getLayoutType], [self getSpecType:self.widthSpec], [self getSpecType:self.heightSpec] ]; } #pragma measure - (DoricMeasureSpec)getChildMeasureSpec:(DoricMeasureSpec)spec padding:(CGFloat)padding childLayoutSpec:(DoricLayoutSpec)childLayoutSpec childSize:(CGFloat)childSize { DoricMeasureSpecMode specMode = spec.mode; CGFloat specSize = spec.size; CGFloat size = MAX(0, specSize - padding); CGFloat resultSize = 0; DoricMeasureSpecMode resultMode = DoricMeasureUnspecified; switch (specMode) { // Parent has imposed an exact size on us case DoricMeasureExactly: if (childLayoutSpec == DoricLayoutJust) { resultSize = childSize; resultMode = DoricMeasureExactly; } else if (childLayoutSpec == DoricLayoutMost) { // Child wants to be our size. So be it. resultSize = size; resultMode = DoricMeasureExactly; } else if (childLayoutSpec == DoricLayoutFit) { // Child wants to determine its own size. It can't be // bigger than us. resultSize = size; resultMode = DoricMeasureAtMost; } break; // Parent has imposed a maximum size on us case DoricMeasureAtMost: if (childLayoutSpec == DoricLayoutJust) { // Child wants a specific size... so be it resultSize = childSize; resultMode = DoricMeasureExactly; } else if (childLayoutSpec == DoricLayoutMost) { // Child wants to be our size, but our size is not fixed. // Constrain child to not be bigger than us. resultSize = size; resultMode = DoricMeasureAtMost; } else if (childLayoutSpec == DoricLayoutFit) { // Child wants to determine its own size. It can't be // bigger than us. resultSize = size; resultMode = DoricMeasureAtMost; } break; // Parent asked to see how big we want to be case DoricMeasureUnspecified: if (childLayoutSpec == DoricLayoutJust) { // Child wants a specific size... let them have it resultSize = childSize; resultMode = DoricMeasureExactly; } else if (childLayoutSpec == DoricLayoutMost) { // Child wants to be our size... find out how big it should // be resultSize = size; resultMode = DoricMeasureUnspecified; } else if (childLayoutSpec == DoricLayoutFit) { // Child wants to determine its own size. It can't be // bigger than us. resultSize = size; resultMode = DoricMeasureUnspecified; } break; } return DoricMeasureSpecMake(resultMode, resultSize); } - (void)measureChild:(DoricLayout *)child widthSpec:(DoricMeasureSpec)widthSpec usedWidth:(CGFloat)usedWidth heightSpec:(DoricMeasureSpec)heightSpec usedHeight:(CGFloat)usedHeight { DoricMeasureSpec childWidthSpec = [self getChildMeasureSpec:widthSpec padding:self.paddingLeft + self.paddingRight + child.marginLeft + child.marginRight + usedWidth childLayoutSpec:child.widthSpec childSize:child.width]; DoricMeasureSpec childHeightSpec = [self getChildMeasureSpec:heightSpec padding:self.paddingTop + self.paddingBottom + child.marginTop + child.marginBottom + usedHeight childLayoutSpec:child.heightSpec childSize:child.height]; [child measureWidth:childWidthSpec height:childHeightSpec]; } - (DoricSizeAndState)resolveSizeAndState:(CGFloat)size spec:(DoricMeasureSpec)measureSpec childMeasuredState:(NSUInteger)state { DoricSizeAndState result; DoricMeasureSpecMode specMode = measureSpec.mode; CGFloat specSize = measureSpec.size; result.state = 0; switch (specMode) { case DoricMeasureAtMost: if (specSize < size) { result.size = specSize; result.state = DORIC_MEASURED_STATE_TOO_SMALL; } else { result.size = size; } break; case DoricMeasureExactly: result.size = specSize; break; case DoricMeasureUnspecified: default: result.size = size; break; } result.state = result.state | (state & DORIC_MEASURED_STATE_MASK); return result; } - (CGFloat)getDefaultSize:(CGFloat)size spec:(DoricMeasureSpec)measureSpec { DoricMeasureSpecMode specMode = measureSpec.mode; CGFloat specSize = measureSpec.size; CGFloat result = size; switch (specMode) { case DoricMeasureUnspecified: result = size; break; case DoricMeasureAtMost: case DoricMeasureExactly: result = specSize; break; } return result; } - (void)forceUniformWidth:(DoricMeasureSpec)heightMeasureSpec { DoricMeasureSpec uniformMeasureSpec = DoricMeasureSpecMake(DoricMeasureExactly, self.measuredWidth); for (__kindof UIView *subview in self.view.subviews) { DoricLayout *childLayout = subview.doricLayout; if (childLayout.disabled) { continue; } if (childLayout.widthSpec == DoricLayoutMost) { // Temporarily force children to reuse their old measured height // FIXME: this may not be right for something like wrapping text? CGFloat oldHeight = childLayout.height; DoricLayoutSpec oldHeightSpec = childLayout.heightSpec; childLayout.height = childLayout.measuredHeight; childLayout.heightSpec = DoricLayoutJust; // Remeasure with new dimensions [self measureChild:childLayout widthSpec:uniformMeasureSpec usedWidth:0 heightSpec:heightMeasureSpec usedHeight:0]; childLayout.height = oldHeight; childLayout.heightSpec = oldHeightSpec; } } } - (void)forceUniformHeight:(DoricMeasureSpec)widthMeasureSpec { // Pretend that the linear layout has an exact size. This is the measured height of // ourselves. The measured height should be the max height of the children, changed // to accommodate the heightMeasureSpec from the parent DoricMeasureSpec uniformMeasureSpec = DoricMeasureSpecMake(DoricMeasureExactly, self.measuredHeight); for (__kindof UIView *subview in self.view.subviews) { DoricLayout *childLayout = subview.doricLayout; if (childLayout.disabled) { continue; } if (childLayout.heightSpec == DoricLayoutMost) { // Temporarily force children to reuse their old measured width // FIXME: this may not be right for something like wrapping text? CGFloat oldWidth = childLayout.width; DoricLayoutSpec oldWidthSpec = childLayout.widthSpec; childLayout.width = childLayout.measuredWidth; childLayout.widthSpec = DoricLayoutJust; // Remeasure with new dimensions [self measureChild:childLayout widthSpec:widthMeasureSpec usedWidth:0 heightSpec:uniformMeasureSpec usedHeight:0]; childLayout.width = oldWidth; childLayout.widthSpec = oldWidthSpec; } } } - (void)measureWidth:(DoricMeasureSpec)widthSpec height:(DoricMeasureSpec)heightSpec { // NSString *measuredKey = [NSString stringWithFormat:@"%@;%@;%@;%@", // @(widthSpec.mode), @(widthSpec.size), // @(heightSpec.mode), @(heightSpec.size)]; // // NSString *cached = self.measuredCache[measuredKey]; // if (cached) { // NSArray *nums = [cached componentsSeparatedByString:@":"]; // if (nums.count == 2) { // self.measuredWidth = nums[0].floatValue; // self.measuredHeight = nums[1].floatValue; // return; // } // } switch (self.layoutType) { case DoricStack: { [self stackMeasureWidth:widthSpec height:heightSpec]; break; } case DoricVLayout: { [self verticalMeasureWidth:widthSpec height:heightSpec]; break; } case DoricHLayout: { [self horizontalMeasureWidth:widthSpec height:heightSpec]; break; } case DoricScroller: { [self scrollerMeasureWidth:widthSpec height:heightSpec]; break; } case DoricFlexLayout: { [self flexMeasureWidth:widthSpec height:heightSpec]; break; } default: { [self undefinedMeasureWidth:widthSpec height:heightSpec]; break; } } if (self.measuredWidth > self.maxWidth || self.measuredHeight > self.measuredHeight) { [self measureWidth:DoricMeasureSpecMake(DoricMeasureAtMost, MIN(self.measuredWidth, self.maxWidth)) height:DoricMeasureSpecMake(DoricMeasureAtMost, MIN(self.measuredHeight, self.maxHeight))]; } // self.measuredCache[measuredKey] = [NSString stringWithFormat:@"%@;%@", // @(self.measuredWidth), // @(self.measuredHeight)]; } - (void)verticalMeasureWidth:(DoricMeasureSpec)widthMeasureSpec height:(DoricMeasureSpec)heightMeasureSpec { CGFloat maxWidth = 0, totalLength = 0; NSUInteger totalWeight = 0; BOOL hadExtraSpace = NO; DoricMeasureSpecMode widthMode = widthMeasureSpec.mode; DoricMeasureSpecMode heightMode = heightMeasureSpec.mode; BOOL skippedMeasure = NO; BOOL matchWidth = NO; BOOL allFillParent = YES; CGFloat weightedMaxWidth = 0; CGFloat alternativeMaxWidth = 0; NSUInteger childState = 0; // See how tall everyone is. Also remember max width. for (__kindof UIView *subview in self.view.subviews) { DoricLayout *childLayout = subview.doricLayout; if (childLayout.disabled) { continue; } hadExtraSpace = YES; totalLength += self.spacing; totalWeight += childLayout.weight; if (heightMode == DoricMeasureExactly && childLayout.heightSpec == DoricLayoutJust && childLayout.height == 0 && childLayout.weight > 0) { // Optimization: don't bother measuring children who are going to use // leftover space. These views will get measured again down below if // there is any leftover space. totalLength = MAX(totalLength, totalLength +childLayout.marginTop + childLayout.marginBottom); skippedMeasure = YES; } else { CGFloat oldHeight = CGFLOAT_MIN; if (childLayout.heightSpec == DoricLayoutJust && childLayout.height == 0 && childLayout.weight > 0) { // heightMode is either UNSPECIFIED or AT_MOST, and this // child wanted to stretch to fill available space. // Translate that to WRAP_CONTENT so that it does not end up // with a height of 0 oldHeight = 0; childLayout.heightSpec = DoricLayoutFit; } // Determine how big this child would like to be. If this or // previous children have given a weight, then we allow it to // use all available space (and we will shrink things later // if needed). [self measureChild:childLayout widthSpec:widthMeasureSpec usedWidth:0 heightSpec:heightMeasureSpec usedHeight:totalWeight == 0 ? totalLength : 0]; if (oldHeight != CGFLOAT_MIN) { childLayout.heightSpec = DoricLayoutJust; childLayout.height = oldHeight; } CGFloat childHeight = childLayout.measuredHeight; totalLength = MAX(totalLength, totalLength + childHeight + childLayout.marginTop + childLayout.marginBottom); } BOOL matchWidthLocally = NO; if (widthMode != DoricMeasureExactly && childLayout.widthSpec == DoricLayoutMost) { // The width of the linear layout will scale, and at least one // child said it wanted to match our width. Set a flag // indicating that we need to remeasure at least that view when // we know our width. matchWidth = YES; matchWidthLocally = YES; } CGFloat margin = childLayout.marginLeft + childLayout.marginRight; CGFloat measuredWidth = childLayout.measuredWidth + margin; maxWidth = MAX(maxWidth, measuredWidth); childState = childState | childLayout.measuredState; allFillParent = allFillParent && childLayout.widthSpec == DoricLayoutMost; if (childLayout.weight > 0) { /* * Widths of weighted Views are bogus if we end up * remeasuring, so keep them separate. */ weightedMaxWidth = MAX(weightedMaxWidth, matchWidthLocally ? margin : measuredWidth); } else { alternativeMaxWidth = MAX(alternativeMaxWidth, matchWidthLocally ? margin : measuredWidth); } } if (hadExtraSpace) { totalLength -= self.spacing; } // Add in our padding totalLength += self.paddingTop + self.paddingBottom; CGFloat heightSize = totalLength; // Check against our minimum height heightSize = MAX(heightSize, self.minHeight); // Reconcile our calculated size with the heightMeasureSpec DoricSizeAndState heightSizeAndState = [self resolveSizeAndState:heightSize spec:heightMeasureSpec childMeasuredState:0]; heightSize = heightSizeAndState.size; // Either expand children with weight to take up available space or // shrink them if they extend beyond our current bounds. If we skipped // measurement on any children, we need to measure them now. CGFloat delta = heightSize - totalLength; if (skippedMeasure || (delta != 0 && totalWeight > 0)) { NSUInteger weightSum = totalWeight; totalLength = 0; for (__kindof UIView *subview in self.view.subviews) { DoricLayout *childLayout = subview.doricLayout; if (childLayout.disabled) { continue; } NSUInteger childExtra = childLayout.weight; if (childExtra > 0) { // Child said it could absorb extra space -- give him his share CGFloat share = childExtra * delta / weightSum; weightSum -= childExtra; delta -= share; DoricMeasureSpec childWidthMeasureSpec = [self getChildMeasureSpec:widthMeasureSpec padding:self.paddingLeft + self.paddingRight + childLayout.marginLeft + childLayout.marginRight childLayoutSpec:childLayout.widthSpec childSize:childLayout.width]; // TODO: Use a field like lp.isMeasured to figure out if this // child has been previously measured if (!(childLayout.heightSpec == DoricLayoutJust && childLayout.height == 0) || heightMode != DoricMeasureExactly) { // child was measured once already above... // base new measurement on stored values CGFloat childHeight = childLayout.measuredHeight + share; if (childHeight < 0) { childHeight = 0; } [childLayout measureWidth:childWidthMeasureSpec height:DoricMeasureSpecMake(DoricMeasureExactly, childHeight)]; } else { // child was skipped in the loop above. // Measure for this first time here [childLayout measureWidth:childWidthMeasureSpec height:DoricMeasureSpecMake(DoricMeasureExactly, share > 0 ? share : 0)]; } // Child may now not fit in vertical dimension. childState = childState | (childLayout.measuredState & (DORIC_MEASURED_STATE_MASK >> DORIC_MEASURED_HEIGHT_STATE_SHIFT)); } CGFloat margin = childLayout.marginLeft + childLayout.marginRight; CGFloat measuredWidth = childLayout.measuredWidth + margin; maxWidth = MAX(maxWidth, measuredWidth); BOOL matchWidthLocally = widthMode != DoricMeasureExactly && childLayout.widthSpec == DoricLayoutMost; alternativeMaxWidth = MAX(alternativeMaxWidth, matchWidthLocally ? margin : measuredWidth); allFillParent = allFillParent && childLayout.widthSpec == DoricLayoutMost; totalLength = MAX(totalLength, totalLength + childLayout.measuredHeight + childLayout.marginTop + childLayout.marginBottom); totalLength += self.spacing; } if (hadExtraSpace) { totalLength -= self.spacing; } totalLength += self.paddingTop + self.paddingBottom; // TODO: Should we recompute the heightMeasureSpec based on the new total length? } else { alternativeMaxWidth = MAX(alternativeMaxWidth, weightedMaxWidth); }; if (!allFillParent && widthMode != DoricMeasureExactly) { maxWidth = alternativeMaxWidth; } maxWidth += self.paddingLeft + self.paddingRight; // Check against our minimum width maxWidth = MAX(maxWidth, self.minWidth); DoricSizeAndState widthSizeAndState = [self resolveSizeAndState:maxWidth spec:widthMeasureSpec childMeasuredState:childState]; self.measuredWidth = widthSizeAndState.size; self.measuredHeight = heightSize; self.measuredState = (widthSizeAndState.state << DORIC_MEASURED_HEIGHT_STATE_SHIFT) | heightSizeAndState.state; if (matchWidth) { [self forceUniformWidth:heightMeasureSpec]; } self.totalLength = totalLength; } - (void)horizontalMeasureWidth:(DoricMeasureSpec)widthMeasureSpec height:(DoricMeasureSpec)heightMeasureSpec { CGFloat maxHeight = 0, totalLength = 0; NSUInteger totalWeight = 0; BOOL hadExtraSpace = NO; DoricMeasureSpecMode widthMode = widthMeasureSpec.mode; DoricMeasureSpecMode heightMode = heightMeasureSpec.mode; BOOL skippedMeasure = NO; BOOL matchHeight = NO; BOOL allFillParent = YES; CGFloat weightedMaxHeight = 0; CGFloat alternativeMaxHeight = 0; BOOL isExactly = widthMode == DoricMeasureExactly; NSUInteger childState = 0; // See how wide everyone is. Also remember max height. for (__kindof UIView *subview in self.view.subviews) { DoricLayout *childLayout = subview.doricLayout; if (childLayout.disabled) { continue; } hadExtraSpace = YES; totalLength += self.spacing; totalWeight += childLayout.weight; if (widthMode == DoricMeasureExactly && childLayout.widthSpec == DoricLayoutJust && childLayout.width == 0 && childLayout.weight > 0) { // Optimization: don't bother measuring children who are going to use // leftover space. These views will get measured again down below if // there is any leftover space. if (isExactly) { totalLength += childLayout.marginLeft + childLayout.marginRight; } else { totalLength = MAX(totalLength, totalLength +childLayout.marginLeft + childLayout.marginRight); } skippedMeasure = YES; } else { CGFloat oldWidth = CGFLOAT_MIN; if (childLayout.widthSpec == DoricLayoutJust && childLayout.width == 0 && childLayout.weight > 0) { // widthMode is either UNSPECIFIED or AT_MOST, and this // child // wanted to stretch to fill available space. Translate that to // WRAP_CONTENT so that it does not end up with a width of 0 oldWidth = 0; childLayout.widthSpec = DoricLayoutFit; } // Determine how big this child would like to be. If this or // previous children have given a weight, then we allow it to // use all available space (and we will shrink things later // if needed). [self measureChild:childLayout widthSpec:widthMeasureSpec usedWidth:totalWeight == 0 ? totalLength : 0 heightSpec:heightMeasureSpec usedHeight:0]; if (oldWidth != CGFLOAT_MIN) { childLayout.widthSpec = DoricLayoutJust; childLayout.width = oldWidth; } CGFloat childWidth = childLayout.measuredWidth; if (isExactly) { totalLength += childWidth + childLayout.marginLeft + childLayout.marginRight; } else { totalLength = MAX(totalLength, totalLength + childWidth + childLayout.marginLeft + childLayout.marginRight); } } BOOL matchHeightLocally = NO; if (heightMode != DoricMeasureExactly && childLayout.heightSpec == DoricLayoutMost) { // The height of the linear layout will scale, and at least one // child said it wanted to match our height. Set a flag indicating that // we need to remeasure at least that view when we know our height. matchHeight = YES; matchHeightLocally = YES; } CGFloat margin = childLayout.marginTop + childLayout.marginBottom; CGFloat childHeight = childLayout.measuredHeight + margin; childState = childState | childLayout.measuredState; maxHeight = MAX(maxHeight, childHeight); allFillParent = allFillParent && childLayout.heightSpec == DoricLayoutMost; if (childLayout.weight > 0) { /* * Heights of weighted Views are bogus if we end up * remeasuring, so keep them separate. */ weightedMaxHeight = MAX(weightedMaxHeight, matchHeightLocally ? margin : childHeight); } else { alternativeMaxHeight = MAX(alternativeMaxHeight, matchHeightLocally ? margin : childHeight); } } if (hadExtraSpace) { totalLength -= self.spacing; } // Add in our padding totalLength += self.paddingLeft + self.paddingRight; CGFloat widthSize = totalLength; // Check against our minimum width widthSize = MAX(widthSize, self.minWidth); // Reconcile our calculated size with the widthMeasureSpec DoricSizeAndState widthSizeAndState = [self resolveSizeAndState:widthSize spec:widthMeasureSpec childMeasuredState:0]; widthSize = widthSizeAndState.size; // Either expand children with weight to take up available space or // shrink them if they extend beyond our current bounds. If we skipped // measurement on any children, we need to measure them now. CGFloat delta = widthSize - totalLength; if (skippedMeasure || (delta != 0 && totalWeight > 0)) { NSUInteger weightSum = totalWeight; totalLength = 0; for (__kindof UIView *subview in self.view.subviews) { DoricLayout *childLayout = subview.doricLayout; if (childLayout.disabled) { continue; } NSUInteger childExtra = childLayout.weight; if (childExtra > 0) { // Child said it could absorb extra space -- give him his share CGFloat share = childExtra * delta / weightSum; weightSum -= childExtra; delta -= share; DoricMeasureSpec childHeightMeasureSpec = [self getChildMeasureSpec:heightMeasureSpec padding:self.paddingTop + self.paddingBottom + childLayout.marginTop + childLayout.marginBottom childLayoutSpec:childLayout.heightSpec childSize:childLayout.height]; // TODO: Use a field like lp.isMeasured to figure out if this // child has been previously measured if (!(childLayout.widthSpec == DoricLayoutJust && childLayout.width == 0) || widthMode != DoricMeasureExactly) { // child was measured once already above ... base new measurement // on stored values CGFloat childWidth = childLayout.measuredWidth + share; if (childWidth < 0) { childWidth = 0; } [childLayout measureWidth:DoricMeasureSpecMake(DoricMeasureExactly, childWidth) height:childHeightMeasureSpec]; } else { // child was skipped in the loop above. Measure for this first time here [childLayout measureWidth:DoricMeasureSpecMake(DoricMeasureExactly, share > 0 ? share : 0) height:childHeightMeasureSpec]; } // Child may now not fit in horizontal dimension. childState = childState | (childLayout.measuredState & DORIC_MEASURED_STATE_MASK); } if (isExactly) { totalLength += childLayout.measuredWidth + childLayout.marginLeft + childLayout.marginRight; } else { totalLength = MAX(totalLength, totalLength + childLayout.measuredWidth + childLayout.marginLeft + childLayout.marginRight); } totalLength += self.spacing; BOOL matchHeightLocally = heightMode != DoricMeasureExactly && childLayout.heightSpec == DoricLayoutMost; CGFloat margin = childLayout.marginTop + childLayout.marginBottom; CGFloat childHeight = childLayout.measuredHeight + margin; maxHeight = MAX(maxHeight, childHeight); alternativeMaxHeight = MAX(alternativeMaxHeight, matchHeightLocally ? margin : childHeight); allFillParent = allFillParent && childLayout.heightSpec == DoricLayoutMost; } if (hadExtraSpace) { totalLength -= self.spacing; } // Add in our padding totalLength += self.paddingLeft + self.paddingRight; // TODO: Should we update widthSize with the new total length? } else { alternativeMaxHeight = MAX(alternativeMaxHeight, weightedMaxHeight); } if (!allFillParent && heightMode != DoricMeasureExactly) { maxHeight = alternativeMaxHeight; } maxHeight += self.paddingTop + self.paddingBottom; // Check against our minimum height maxHeight = MAX(maxHeight, self.minHeight); self.measuredWidth = widthSize; DoricSizeAndState heightSizeAndState = [self resolveSizeAndState:maxHeight spec:heightMeasureSpec childMeasuredState:childState << DORIC_MEASURED_HEIGHT_STATE_SHIFT]; self.measuredHeight = heightSizeAndState.size; self.measuredState = ((widthSizeAndState.state | (childState & DORIC_MEASURED_STATE_MASK)) << DORIC_MEASURED_HEIGHT_STATE_SHIFT) | heightSizeAndState.state; if (matchHeight) { [self forceUniformHeight:widthMeasureSpec]; } self.totalLength = totalLength; } - (void)stackMeasureWidth:(DoricMeasureSpec)widthMeasureSpec height:(DoricMeasureSpec)heightMeasureSpec { CGFloat maxWidth = 0; CGFloat maxHeight = 0; BOOL measureMatchParentChildren = widthMeasureSpec.mode != DoricMeasureExactly || heightMeasureSpec.mode != DoricMeasureExactly; NSMutableArray *matchParentChildren = [NSMutableArray new]; NSUInteger childState = 0; for (__kindof UIView *subview in self.view.subviews) { DoricLayout *childLayout = subview.doricLayout; if (childLayout.disabled) { continue; } [self measureChild:childLayout widthSpec:widthMeasureSpec usedWidth:0 heightSpec:heightMeasureSpec usedHeight:0]; maxWidth = MAX(maxWidth, childLayout.measuredWidth + childLayout.marginLeft + childLayout.marginRight); maxHeight = MAX(maxHeight, childLayout.measuredHeight + childLayout.marginTop + childLayout.marginBottom); childState = childState | childLayout.measuredState; if (measureMatchParentChildren) { if (childLayout.widthSpec == DoricLayoutMost || childLayout.heightSpec == DoricLayoutMost) { [matchParentChildren addObject:childLayout]; } } } // Account for padding too maxWidth += self.paddingLeft + self.paddingRight; maxHeight += self.paddingTop + self.paddingBottom; // Check against our minimum height and width maxWidth = MAX(maxWidth, self.minWidth); maxHeight = MAX(maxHeight, self.minHeight); DoricSizeAndState widthSizeAndState = [self resolveSizeAndState:maxWidth spec:widthMeasureSpec childMeasuredState:childState]; DoricSizeAndState heightSizeAndState = [self resolveSizeAndState:maxHeight spec:heightMeasureSpec childMeasuredState:childState << DORIC_MEASURED_HEIGHT_STATE_SHIFT]; self.measuredWidth = widthSizeAndState.size; self.measuredHeight = heightSizeAndState.size; self.measuredState = (widthSizeAndState.state << DORIC_MEASURED_HEIGHT_STATE_SHIFT) | heightSizeAndState.state; if (matchParentChildren.count > 0) { for (DoricLayout *child in matchParentChildren) { DoricMeasureSpec childWidthMeasureSpec; if (child.widthSpec == DoricLayoutMost) { childWidthMeasureSpec.size = MAX(0, self.measuredWidth - self.paddingLeft - self.paddingRight - child.marginLeft - child.marginRight); childWidthMeasureSpec.mode = DoricMeasureExactly; } else { childWidthMeasureSpec = [self getChildMeasureSpec:widthMeasureSpec padding:self.paddingLeft + self.paddingRight + child.marginLeft + child.marginRight childLayoutSpec:child.widthSpec childSize:child.width]; } DoricMeasureSpec childHeightMeasureSpec; if (child.heightSpec == DoricLayoutMost) { childHeightMeasureSpec.size = MAX(0, self.measuredHeight - self.paddingTop - self.paddingBottom - child.marginTop - child.marginBottom); childHeightMeasureSpec.mode = DoricMeasureExactly; } else { childHeightMeasureSpec = [self getChildMeasureSpec:heightMeasureSpec padding:self.paddingTop + self.paddingBottom + child.marginTop + child.marginBottom childLayoutSpec:child.heightSpec childSize:child.height]; } [child measureWidth:childWidthMeasureSpec height:childHeightMeasureSpec]; } } } - (void)scrollerMeasureWidth:(DoricMeasureSpec)widthMeasureSpec height:(DoricMeasureSpec)heightMeasureSpec { DoricScrollView *scrollView = (DoricScrollView *) self.view; DoricLayout *childLayout = scrollView.contentView.doricLayout; [self measureChild:childLayout widthSpec:widthMeasureSpec usedWidth:0 heightSpec:heightMeasureSpec usedHeight:0]; CGFloat maxWidth, maxHeight; maxWidth = childLayout.measuredWidth + childLayout.marginLeft + childLayout.marginRight; maxHeight = childLayout.measuredHeight + childLayout.marginTop + childLayout.marginBottom; maxWidth += self.paddingLeft + self.paddingRight; maxHeight += self.paddingTop + self.paddingBottom; maxWidth = MAX(maxWidth, self.minWidth); maxHeight = MAX(maxHeight, self.minHeight); DoricSizeAndState widthSizeAndState = [self resolveSizeAndState:maxWidth spec:widthMeasureSpec childMeasuredState:0]; DoricSizeAndState heightSizeAndState = [self resolveSizeAndState:maxHeight spec:heightMeasureSpec childMeasuredState:0]; self.measuredWidth = widthSizeAndState.size; self.measuredHeight = heightSizeAndState.size; if (widthMeasureSpec.mode == DoricMeasureUnspecified && heightMeasureSpec.mode == DoricMeasureUnspecified) { return; } CGFloat width = self.measuredWidth - self.paddingLeft - self.paddingRight; CGFloat height = self.measuredHeight - self.paddingTop - self.paddingBottom; DoricMeasureSpec childWidthMeasureSpec, childHeightMeasureSpec; if (childLayout.widthSpec == DoricLayoutMost) { childWidthMeasureSpec = DoricMeasureSpecMake(DoricMeasureExactly, width); } else { widthMeasureSpec = DoricMeasureSpecMake(DoricMeasureUnspecified, 0); childWidthMeasureSpec = [self getChildMeasureSpec:widthMeasureSpec padding:self.paddingLeft + self.paddingRight childLayoutSpec:childLayout.widthSpec childSize:childLayout.width]; } if (childLayout.heightSpec == DoricLayoutMost) { childHeightMeasureSpec = DoricMeasureSpecMake(DoricMeasureExactly, height); } else { heightMeasureSpec = DoricMeasureSpecMake(DoricMeasureUnspecified, 0); childHeightMeasureSpec = [self getChildMeasureSpec:heightMeasureSpec padding:self.paddingTop + self.paddingBottom childLayoutSpec:childLayout.heightSpec childSize:childLayout.height]; } [childLayout measureWidth:childWidthMeasureSpec height:childHeightMeasureSpec]; } - (void)flexMeasureWidth:(DoricMeasureSpec)widthMeasureSpec height:(DoricMeasureSpec)heightMeasureSpec { for (__kindof UIView *subview in self.view.subviews) { DoricLayout *childDoricLayout = subview.doricLayout; YGLayout *childYGLayout = subview.yoga; DoricMeasureSpec childWidthMeasureSpec; DoricMeasureSpec childHeightMeasureSpec; if (childDoricLayout.widthSpec == DoricLayoutMost) { childWidthMeasureSpec = DoricMeasureSpecMake(DoricMeasureAtMost, self.measuredWidth); } else if (childDoricLayout.widthSpec == DoricLayoutFit) { childWidthMeasureSpec = DoricMeasureSpecMake(DoricMeasureUnspecified, 0); } else { childWidthMeasureSpec = DoricMeasureSpecMake(DoricMeasureExactly, childDoricLayout.width); } if (childDoricLayout.heightSpec == DoricLayoutMost) { childHeightMeasureSpec = DoricMeasureSpecMake(DoricMeasureAtMost, self.measuredHeight); } else if (childDoricLayout.heightSpec == DoricLayoutFit) { childHeightMeasureSpec = DoricMeasureSpecMake(DoricMeasureUnspecified, 0); } else { childHeightMeasureSpec = DoricMeasureSpecMake(DoricMeasureExactly, childDoricLayout.height); } [childDoricLayout measureWidth:childWidthMeasureSpec height:childHeightMeasureSpec]; if (childDoricLayout.layoutType != DoricFlexLayout) { YGUnit widthUnit = YGUnitAuto; YGUnit heightUnit = YGUnitAuto; if (childDoricLayout.flexConfig) { id widthValue = childDoricLayout.flexConfig[@"width"]; if ([widthValue isKindOfClass:NSNumber.class]) { widthUnit = YGUnitPoint; } else if ([widthValue isKindOfClass:NSDictionary.class]) { id type = widthValue[@"type"]; if ([type isKindOfClass:NSNumber.class]) { widthUnit = (YGUnit) [type integerValue]; } } id heightValue = childDoricLayout.flexConfig[@"height"]; if ([heightValue isKindOfClass:NSNumber.class]) { heightUnit = YGUnitPoint; } else if ([heightValue isKindOfClass:NSDictionary.class]) { id type = heightValue[@"type"]; if ([type isKindOfClass:NSNumber.class]) { heightUnit = (YGUnit) [type integerValue]; } } } if (widthUnit == YGUnitAuto) { childYGLayout.width = YGPointValue(childDoricLayout.measuredWidth); } if (heightUnit == YGUnitAuto) { childYGLayout.height = YGPointValue(childDoricLayout.measuredHeight); } } } YGUnit widthUnit = YGUnitAuto; YGUnit heightUnit = YGUnitAuto; if (self.flexConfig) { id widthValue = self.flexConfig[@"width"]; if ([widthValue isKindOfClass:NSNumber.class]) { widthUnit = YGUnitPoint; } else if ([widthValue isKindOfClass:NSDictionary.class]) { id type = widthValue[@"type"]; if ([type isKindOfClass:NSNumber.class]) { widthUnit = (YGUnit) [type integerValue]; } } id heightValue = self.flexConfig[@"height"]; if ([heightValue isKindOfClass:NSNumber.class]) { heightUnit = YGUnitPoint; } else if ([heightValue isKindOfClass:NSDictionary.class]) { id type = heightValue[@"type"]; if ([type isKindOfClass:NSNumber.class]) { heightUnit = (YGUnit) [type integerValue]; } } } if (widthUnit == YGUnitAuto) { self.view.yoga.width = YGValueAuto; } if (heightUnit == YGUnitAuto) { self.view.yoga.height = YGValueAuto; } if (self.view.superview.doricLayout.layoutType != DoricFlexLayout) { if (heightMeasureSpec.mode == DoricMeasureAtMost) { heightMeasureSpec = DoricMeasureSpecMake(DoricMeasureUnspecified, heightMeasureSpec.size); } if (widthMeasureSpec.mode == DoricMeasureAtMost) { widthMeasureSpec = DoricMeasureSpecMake(DoricMeasureUnspecified, widthMeasureSpec.size); } if (heightMeasureSpec.mode == DoricMeasureExactly) { self.view.yoga.height = YGPointValue(heightMeasureSpec.size); } if (widthMeasureSpec.mode == DoricMeasureExactly) { self.view.yoga.width = YGPointValue(widthMeasureSpec.size); } if (heightMeasureSpec.mode == DoricMeasureAtMost) { self.view.yoga.maxHeight = YGPointValue(heightMeasureSpec.size); } if (widthMeasureSpec.mode == DoricMeasureAtMost) { self.view.yoga.maxWidth = YGPointValue(widthMeasureSpec.size); } [self.view.yoga intrinsicSize]; } DoricSizeAndState widthSizeAndState = [self resolveSizeAndState:YGNodeLayoutGetWidth(self.view.yoga.node) spec:widthMeasureSpec childMeasuredState:0]; self.measuredWidth = widthSizeAndState.size; DoricSizeAndState heightSizeAndState = [self resolveSizeAndState:YGNodeLayoutGetHeight(self.view.yoga.node) spec:heightMeasureSpec childMeasuredState:0]; self.measuredHeight = heightSizeAndState.size; } - (void)undefinedMeasureWidth:(DoricMeasureSpec)widthMeasureSpec height:(DoricMeasureSpec)heightMeasureSpec { CGSize targetSize = CGSizeMake(widthMeasureSpec.size - self.paddingLeft - self.paddingRight, heightMeasureSpec.size - self.paddingTop - self.paddingBottom); CGSize measuredSize = [self.view sizeThatFits:targetSize]; CGFloat contentWidth = measuredSize.width; CGFloat contentHeight = measuredSize.height; if ([self.view isKindOfClass:UIImageView.class]) { if (self.widthSpec == DoricLayoutFit && self.heightSpec != DoricLayoutFit && measuredSize.height > 0) { DoricSizeAndState preHeightSizeAndState = [self resolveSizeAndState:contentHeight + self.paddingTop + self.paddingBottom spec:heightMeasureSpec childMeasuredState:0]; contentWidth = measuredSize.width / measuredSize.height * (preHeightSizeAndState.size - self.paddingBottom - self.paddingBottom); self.measuredWidth = contentWidth + self.paddingLeft + self.paddingBottom; self.measuredHeight = preHeightSizeAndState.size; self.measuredState = 0; return; } if (self.heightSpec == DoricLayoutFit && self.widthSpec != DoricLayoutFit && measuredSize.width > 0) { DoricSizeAndState preWidthSizeAndState = [self resolveSizeAndState:contentWidth + self.paddingLeft + self.paddingRight spec:widthMeasureSpec childMeasuredState:0]; contentHeight = measuredSize.height / measuredSize.width * (preWidthSizeAndState.size - self.paddingLeft - self.paddingRight); self.measuredWidth = preWidthSizeAndState.size; self.measuredHeight = contentHeight + self.paddingTop + self.paddingBottom; self.measuredState = 0; return; } } DoricSizeAndState widthSizeAndState = [self resolveSizeAndState:contentWidth + self.paddingLeft + self.paddingRight spec:widthMeasureSpec childMeasuredState:0]; DoricSizeAndState heightSizeAndState = [self resolveSizeAndState:contentHeight + self.paddingTop + self.paddingBottom spec:heightMeasureSpec childMeasuredState:0]; self.measuredWidth = MAX(widthSizeAndState.size, self.minWidth); self.measuredHeight = MAX(heightSizeAndState.size, self.minHeight); self.measuredState = (widthSizeAndState.state << DORIC_MEASURED_HEIGHT_STATE_SHIFT) | heightSizeAndState.state; } #pragma layout - (void)layout { switch (self.layoutType) { case DoricStack: { [self layoutStack]; break; } case DoricVLayout: { [self layoutVLayout]; break; } case DoricHLayout: { [self layoutHLayout]; break; } case DoricScroller: { [self layoutScroller]; break; } case DoricFlexLayout: { [self layoutFlex]; break; } default: { break; } } } #pragma setFrame - (void)setFrame { if (self.layoutType == DoricScroller) { [((DoricScrollView *) self.view).contentView.doricLayout setFrame]; } else if (self.layoutType != DoricUndefined) { [self.view.subviews forEach:^(__kindof UIView *obj) { [obj.doricLayout setFrame]; }]; } CGRect originFrame = CGRectMake(self.measuredX, self.measuredY, self.measuredWidth, self.measuredHeight); if (!CGAffineTransformEqualToTransform(self.view.transform, CGAffineTransformIdentity)) { CGPoint anchor = self.view.layer.anchorPoint; originFrame = CGRectOffset(originFrame, -anchor.x * self.measuredWidth - self.measuredX, -anchor.y * self.measuredHeight - self.measuredY); originFrame = CGRectApplyAffineTransform(originFrame, self.view.transform); originFrame = CGRectOffset(originFrame, anchor.x * self.measuredWidth + self.measuredX, anchor.y * self.measuredHeight + self.measuredY); } BOOL isFrameChange = ![self rect:originFrame equalTo:self.view.frame]; if (isFrameChange) { if (isnan(originFrame.origin.x) || isinf(originFrame.origin.x) || isnan(originFrame.origin.y) || isinf(originFrame.origin.y) || isnan(originFrame.size.width) || isinf(originFrame.size.width) || isnan(originFrame.size.height) || isinf(originFrame.size.height) ) { return; } self.view.frame = originFrame; } if (!UIEdgeInsetsEqualToEdgeInsets(self.corners, UIEdgeInsetsZero)) { if (self.view.layer.mask) { if ([self.view.layer.mask isKindOfClass:[DoricShapeLayer class]]) { DoricShapeLayer *shapeLayer = (DoricShapeLayer *) self.view.layer.mask; if (!UIEdgeInsetsEqualToEdgeInsets(self.corners, shapeLayer.corners) || !CGRectEqualToRect(self.view.bounds, shapeLayer.viewBounds)) { shapeLayer.corners = self.corners; shapeLayer.viewBounds = self.view.bounds; [self configMaskWithLayer:shapeLayer]; } } else if (isFrameChange) { CAShapeLayer *shapeLayer = [CAShapeLayer layer]; [self configMaskWithLayer:shapeLayer]; } } else { DoricShapeLayer *shapeLayer = [DoricShapeLayer layer]; shapeLayer.corners = self.corners; shapeLayer.viewBounds = self.view.bounds; [self configMaskWithLayer:shapeLayer]; } } } - (void)configMaskWithLayer:(CAShapeLayer *)shapeLayer { CGPathRef path = DoricCreateRoundedRectPath(self.view.bounds, self.corners.top, self.corners.left, self.corners.bottom, self.corners.right); shapeLayer.path = path; if ((self.corners.left != self.corners.right || self.corners.left != self.corners.top || self.corners.left != self.corners.bottom) && self.view.layer.borderWidth > CGFLOAT_MIN) { CAShapeLayer *lineLayer = [CAShapeLayer layer]; lineLayer.lineWidth = self.view.layer.borderWidth * 2; lineLayer.strokeColor = self.view.layer.borderColor; lineLayer.path = path; lineLayer.fillColor = nil; [[self.view.layer sublayers] forEach:^(__kindof CALayer *obj) { if ([obj isKindOfClass:CAShapeLayer.class] && ((CAShapeLayer *) obj).lineWidth > CGFLOAT_MIN) { [obj removeFromSuperlayer]; } }]; [self.view.layer addSublayer:lineLayer]; } CGPathRelease(path); self.view.layer.mask = shapeLayer; } - (void)layoutStack { for (__kindof UIView *subview in self.view.subviews) { DoricLayout *layout = subview.doricLayout; if (layout.disabled) { continue; } [layout layout]; DoricGravity gravity = layout.alignment; if ((gravity & DoricGravityLeft) == DoricGravityLeft) { layout.measuredX = self.paddingLeft; } else if ((gravity & DoricGravityRight) == DoricGravityRight) { layout.measuredX = self.measuredWidth - self.paddingRight - layout.measuredWidth; } else if ((gravity & DoricGravityCenterX) == DoricGravityCenterX) { layout.measuredX = self.measuredWidth / 2 - layout.measuredWidth / 2; } else { layout.measuredX = self.paddingLeft; } if ((gravity & DoricGravityTop) == DoricGravityTop) { layout.measuredY = self.paddingTop; } else if ((gravity & DoricGravityBottom) == DoricGravityBottom) { layout.measuredY = self.measuredHeight - self.paddingBottom - layout.measuredHeight; } else if ((gravity & DoricGravityCenterY) == DoricGravityCenterY) { layout.measuredY = self.measuredHeight / 2 - layout.measuredHeight / 2; } else { layout.measuredY = self.paddingTop; } if (!gravity) { gravity = DoricGravityLeft | DoricGravityTop; } if (layout.marginLeft && !((gravity & DoricGravityRight) == DoricGravityRight)) { layout.measuredX += layout.marginLeft; } if (layout.marginRight && !((gravity & DoricGravityLeft) == DoricGravityLeft)) { layout.measuredX -= layout.marginRight; } if (layout.marginTop && !((gravity & DoricGravityBottom) == DoricGravityBottom)) { layout.measuredY += layout.marginTop; } if (layout.marginBottom && !((gravity & DoricGravityTop) == DoricGravityTop)) { layout.measuredY -= layout.marginBottom; } } } - (void)layoutVLayout { CGFloat yStart = self.paddingTop; if ((self.gravity & DoricGravityTop) == DoricGravityTop) { yStart = self.paddingTop; } else if ((self.gravity & DoricGravityBottom) == DoricGravityBottom) { yStart = self.measuredHeight - self.totalLength - self.paddingBottom; } else if ((self.gravity & DoricGravityCenterY) == DoricGravityCenterY) { yStart = (self.measuredHeight - self.totalLength - self.paddingTop - self.paddingBottom) / 2 + self.paddingTop; } for (UIView *child in self.view.subviews) { DoricLayout *layout = child.doricLayout; if (layout.disabled) { continue; } [layout layout]; DoricGravity gravity = layout.alignment | self.gravity; if ((gravity & DoricGravityLeft) == DoricGravityLeft) { layout.measuredX = self.paddingLeft; } else if ((gravity & DoricGravityRight) == DoricGravityRight) { layout.measuredX = self.measuredWidth - self.paddingRight - layout.measuredWidth; } else if ((gravity & DoricGravityCenterX) == DoricGravityCenterX) { layout.measuredX = self.measuredWidth / 2 - layout.measuredWidth / 2; } else { layout.measuredX = self.paddingLeft; } if (!gravity) { gravity = DoricGravityLeft; } if (layout.marginLeft && !((gravity & DoricGravityRight) == DoricGravityRight)) { layout.measuredX += layout.marginLeft; } if (layout.marginRight && !((gravity & DoricGravityLeft) == DoricGravityLeft)) { layout.measuredX -= layout.marginRight; } layout.measuredY = yStart + layout.marginTop; yStart += self.spacing + layout.takenHeight; } } - (void)layoutHLayout { CGFloat xStart = self.paddingLeft; if ((self.gravity & DoricGravityLeft) == DoricGravityLeft) { xStart = self.paddingLeft; } else if ((self.gravity & DoricGravityRight) == DoricGravityRight) { xStart = self.measuredWidth - self.totalLength - self.paddingRight; } else if ((self.gravity & DoricGravityCenterX) == DoricGravityCenterX) { xStart = (self.measuredWidth - self.totalLength - self.paddingLeft - self.paddingRight) / 2 + self.paddingLeft; } for (UIView *child in self.view.subviews) { DoricLayout *layout = child.doricLayout; if (layout.disabled) { continue; } [layout layout]; DoricGravity gravity = layout.alignment | self.gravity; if ((gravity & DoricGravityTop) == DoricGravityTop) { layout.measuredY = self.paddingTop; } else if ((gravity & DoricGravityBottom) == DoricGravityBottom) { layout.measuredY = self.measuredHeight - self.paddingBottom - layout.measuredHeight; } else if ((gravity & DoricGravityCenterY) == DoricGravityCenterY) { layout.measuredY = self.measuredHeight / 2 - layout.measuredHeight / 2; } else { layout.measuredY = self.paddingTop; } if (!gravity) { gravity = DoricGravityTop; } if (layout.marginTop && !((gravity & DoricGravityBottom) == DoricGravityBottom)) { layout.measuredY += layout.marginTop; } if (layout.marginBottom && !((gravity & DoricGravityTop) == DoricGravityTop)) { layout.measuredY -= layout.marginBottom; } layout.measuredX = xStart + layout.marginLeft; xStart += self.spacing + layout.takenWidth; } } - (void)layoutScroller { DoricScrollView *scrollView = (DoricScrollView *) self.view; DoricLayout *layout = scrollView.contentView.doricLayout; if (layout.disabled) { return; } [layout layout]; } - (void)layoutFlex { for (UIView *child in self.view.subviews) { DoricLayout *layout = child.doricLayout; if (layout.disabled) { continue; } layout.measuredX = YGNodeLayoutGetLeft(child.yoga.node); layout.measuredY = YGNodeLayoutGetTop(child.yoga.node); [layout measureWidth:DoricMeasureSpecMake(DoricMeasureExactly, YGNodeLayoutGetWidth(child.yoga.node)) height:DoricMeasureSpecMake(DoricMeasureExactly, YGNodeLayoutGetHeight(child.yoga.node))]; [layout layout]; } } @end @implementation DoricScrollView - (void)setContentView:(UIView *)contentView { if (_contentView) { [_contentView removeFromSuperview]; } _contentView = contentView; [self addSubview:contentView]; } - (void)layoutSubviews { [super layoutSubviews]; self.contentSize = self.contentView.frame.size; } @end