| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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. |
| */ |
| |
| #import "WXComponent+Layout.h" |
| #import "WXComponent_internal.h" |
| #import "WXTransform.h" |
| #import "WXAssert.h" |
| #import "WXSDKInstance_private.h" |
| #import "WXComponent+BoxShadow.h" |
| #import "WXLog.h" |
| #import "WXMonitor.h" |
| #import "WXSDKInstance_performance.h" |
| #import "WXCellComponent.h" |
| |
| bool flexIsUndefined(float value) { |
| return isnan(value); |
| } |
| |
| |
| |
| @implementation WXComponent (Layout) |
| |
| #pragma clang diagnostic ignored "-Wobjc-protocol-method-implementation" |
| |
| #pragma mark Public |
| |
| - (void)setNeedsLayout |
| { |
| _isLayoutDirty = YES; |
| WXComponent *supercomponent = [self supercomponent]; |
| |
| //protet nil ptr |
| if (self.flexCssNode) { |
| self.flexCssNode->markDirty(); |
| }else{ |
| WXLogError(@"flexCssNode is nil"); |
| } |
| |
| if(supercomponent){ |
| [supercomponent setNeedsLayout]; |
| } |
| } |
| |
| - (BOOL)needsLayout |
| { |
| return _isLayoutDirty; |
| } |
| |
| - (CGSize (^)(CGSize))measureBlock |
| { |
| return nil; |
| } |
| |
| - (void)layoutDidFinish |
| { |
| WXAssertMainThread(); |
| } |
| |
| #pragma mark Private |
| |
| - (void)_initCSSNodeWithStyles:(NSDictionary *)styles |
| { |
| _flexCssNode = new WeexCore::WXCoreLayoutNode(); |
| if ([self measureBlock]) { |
| _flexCssNode->setMeasureFunc(flexCssNodeMeasure); |
| } |
| _flexCssNode->setContext((__bridge void *)self); |
| [self _recomputeCSSNodeChildren]; |
| [self _fillCSSNode:styles isUpdate:NO]; |
| |
| if ([self.ref isEqualToString:WX_SDK_ROOT_REF]) { |
| if (flexIsUndefined(_flexCssNode->getStyleHeight()) && self.weexInstance.frame.size.height) { |
| _flexCssNode->setStyleHeight(self.weexInstance.frame.size.height); |
| } |
| |
| if (flexIsUndefined(_flexCssNode->getStyleWidth()) && self.weexInstance.frame.size.width) { |
| _flexCssNode->setStyleWidth(self.weexInstance.frame.size.width,NO); |
| } |
| } |
| } |
| |
| - (void)_updateCSSNodeStyles:(NSDictionary *)styles |
| { |
| [self _fillCSSNode:styles isUpdate:YES]; |
| } |
| |
| -(void)_resetCSSNodeStyles:(NSArray *)styles |
| { |
| [self _resetCSSNode:styles]; |
| } |
| |
| - (void)_recomputeCSSNodeChildren |
| { |
| } |
| |
| - (NSUInteger)_childrenCountForLayout |
| { |
| NSArray *subcomponents = _subcomponents; |
| NSUInteger count = subcomponents.count; |
| for (WXComponent *component in subcomponents) { |
| if (!component->_isNeedJoinLayoutSystem) { |
| count--; |
| } |
| } |
| return (int)(count); |
| } |
| |
| |
| - (void)_frameDidCalculated:(BOOL)isChanged |
| { |
| WXAssertComponentThread(); |
| if (isChanged && [self isKindOfClass:[WXCellComponent class]]) { |
| CGFloat mainScreenWidth = [[UIScreen mainScreen] bounds].size.width; |
| CGFloat mainScreenHeight = [[UIScreen mainScreen] bounds].size.height; |
| if (mainScreenHeight/2 < _calculatedFrame.size.height && mainScreenWidth/2 < _calculatedFrame.size.width) { |
| [self weexInstance].performance.cellExceedNum++; |
| } |
| } |
| |
| if ([self isViewLoaded] && isChanged && [self isViewFrameSyncWithCalculated]) { |
| |
| __weak typeof(self) weakSelf = self; |
| [self.weexInstance.componentManager _addUITask:^{ |
| __strong typeof(weakSelf) strongSelf = weakSelf; |
| |
| if (strongSelf == nil) { |
| return; |
| } |
| |
| // Check again incase that this property is set to NO in another UI task. |
| if (![strongSelf isViewFrameSyncWithCalculated]) { |
| return; |
| } |
| |
| if (strongSelf->_transform && !CATransform3DEqualToTransform(strongSelf.layer.transform, CATransform3DIdentity)) { |
| // From the UIView's frame documentation: |
| // https://developer.apple.com/reference/uikit/uiview#//apple_ref/occ/instp/UIView/frame |
| // Warning : If the transform property is not the identity transform, the value of this property is undefined and therefore should be ignored. |
| // So layer's transform must be reset to CATransform3DIdentity before setFrame, otherwise frame will be incorrect |
| strongSelf.layer.transform = CATransform3DIdentity; |
| } |
| |
| if (!CGRectEqualToRect(strongSelf.view.frame,strongSelf.calculatedFrame)) { |
| strongSelf.view.frame = strongSelf.calculatedFrame; |
| strongSelf->_absolutePosition = CGPointMake(NAN, NAN); |
| [strongSelf configBoxShadow:_boxShadow]; |
| } else { |
| if (![strongSelf equalBoxShadow:_boxShadow withBoxShadow:_lastBoxShadow]) { |
| [strongSelf configBoxShadow:_boxShadow]; |
| } |
| } |
| |
| [self _resetNativeBorderRadius]; |
| |
| if (strongSelf->_transform) { |
| [strongSelf->_transform applyTransformForView:strongSelf.view]; |
| } |
| |
| if (strongSelf->_backgroundImage) { |
| [strongSelf setGradientLayer]; |
| } |
| [strongSelf setNeedsDisplay]; |
| }]; |
| } |
| } |
| |
| - (void)_calculateFrameWithSuperAbsolutePosition:(CGPoint)superAbsolutePosition |
| gatherDirtyComponents:(NSMutableSet<WXComponent *> *)dirtyComponents |
| { |
| WXAssertComponentThread(); |
| |
| if (self.flexCssNode->hasNewLayout()) { |
| self.flexCssNode->setHasNewLayout(false); |
| _isLayoutDirty = NO; |
| CGRect newFrame = CGRectMake( |
| isnan(WXRoundPixelValue(_flexCssNode->getLayoutPositionLeft()))?0:WXRoundPixelValue(_flexCssNode->getLayoutPositionLeft()) |
| ,isnan(WXRoundPixelValue(_flexCssNode->getLayoutPositionTop()))?0:WXRoundPixelValue(_flexCssNode->getLayoutPositionTop()) |
| ,isnan(WXRoundPixelValue(_flexCssNode->getLayoutWidth()))?0:WXRoundPixelValue(_flexCssNode->getLayoutWidth()) |
| ,isnan(WXRoundPixelValue(_flexCssNode->getLayoutHeight()))?0:WXRoundPixelValue(_flexCssNode->getLayoutHeight()) |
| ); |
| BOOL isFrameChanged = NO; |
| |
| if (!CGRectEqualToRect(newFrame, _calculatedFrame)) { |
| |
| isFrameChanged = YES; |
| _calculatedFrame = newFrame; |
| [dirtyComponents addObject:self]; |
| } |
| |
| [self _frameDidCalculated:isFrameChanged]; |
| #ifdef DEBUG |
| WXLogDebug(@"flexLayout -> newFrame ,type:%@,ref:%@, parentRef:%@,size :%@ ,instance:%@",self.type,self.ref,self.supercomponent.ref,NSStringFromCGRect(newFrame),self.weexInstance.instanceId); |
| #endif |
| } |
| |
| NSArray * subcomponents = [_subcomponents copy]; |
| for (WXComponent *subcomponent in subcomponents) { |
| [subcomponent _calculateFrameWithSuperAbsolutePosition:superAbsolutePosition gatherDirtyComponents:dirtyComponents]; |
| } |
| } |
| |
| - (void)_layoutDidFinish |
| { |
| WXAssertMainThread(); |
| |
| if (_positionType == WXPositionTypeSticky) { |
| [self.ancestorScroller adjustSticky]; |
| } |
| [self layoutDidFinish]; |
| } |
| |
| #define WX_STYLE_FLEX_NODE_JUDGE_LEGAL(key) styles[key]&&!isnan([WXConvert WXPixelType:styles[key] scaleFactor:self.weexInstance.pixelScaleFactor]) |
| |
| - (CGFloat)WXPixelType:(id)value |
| { |
| return [WXConvert WXPixelType:value scaleFactor:self.weexInstance.pixelScaleFactor]; |
| } |
| |
| - (void)_fillCSSNode:(NSDictionary *)styles isUpdate:(BOOL)isUpdate |
| { |
| // flex |
| if (styles[@"flex"]) { |
| _flexCssNode->setFlex([WXConvert CGFloat:styles[@"flex"]]); |
| } |
| if (isnan(_flexCssNode->getFlex())) { |
| // to make the default flex value is zero, yoga is nan, maybe this can configured by yoga config |
| _flexCssNode->setFlex(0); |
| } |
| |
| if (styles[@"flexDirection"]) { |
| _flexCssNode->setFlexDirection([self fxFlexDirection:styles[@"flexDirection"]],isUpdate); |
| } |
| if (styles[@"alignItems"]) { |
| _flexCssNode->setAlignItems([self fxAlign:styles[@"alignItems"]]); |
| } |
| if (styles[@"alignSelf"]) { |
| _flexCssNode->setAlignSelf([self fxAlignSelf:styles[@"alignSelf"]]); |
| } |
| if (styles[@"flexWrap"]) { |
| _flexCssNode->setFlexWrap([self fxWrap:styles[@"flexWrap"]]); |
| } |
| if (styles[@"justifyContent"]) { |
| _flexCssNode->setJustifyContent([self fxJustify:styles[@"justifyContent"]]); |
| } |
| |
| // position |
| if (styles[@"position"]) { |
| _flexCssNode->setStylePositionType([self fxPositionType:styles[@"position"]]); |
| } |
| if (styles[@"top"]) { |
| _flexCssNode->setStylePosition(WeexCore::kPositionEdgeTop, |
| [self judgePropValuePropValue:styles[@"top"] defaultValue:NAN]); |
| } |
| if (styles[@"left"]) { |
| _flexCssNode->setStylePosition(WeexCore::kPositionEdgeLeft, |
| [self judgePropValuePropValue:styles[@"left"] defaultValue:NAN]); |
| } |
| if(styles[@"right"]) { |
| _flexCssNode->setStylePosition(WeexCore::kPositionEdgeRight, |
| [self judgePropValuePropValue:styles[@"right"] defaultValue:NAN]); |
| } |
| if (styles[@"bottom"]) { |
| _flexCssNode->setStylePosition(WeexCore::kPositionEdgeBottom, |
| [self judgePropValuePropValue:styles[@"bottom"] defaultValue:NAN]); |
| } |
| |
| // dimension |
| if (styles[@"width"]) { |
| _flexCssNode->setStyleWidth([self judgePropValuePropValue:styles[@"width"] defaultValue:NAN] |
| ,isUpdate); |
| } |
| if (styles[@"height"]) { |
| _flexCssNode->setStyleHeight([self judgePropValuePropValue:styles[@"height"] defaultValue:NAN]); |
| } |
| if (styles[@"minWidth"]) { |
| _flexCssNode->setMinWidth([self judgePropValuePropValue:styles[@"minWidth"] defaultValue:NAN] |
| ,isUpdate); |
| } |
| if (styles[@"minHeight"]) { |
| _flexCssNode->setMinHeight([self judgePropValuePropValue:styles[@"minHeight"] defaultValue:NAN]); |
| } |
| if (styles[@"maxWidth"]) { |
| _flexCssNode->setMaxWidth([self judgePropValuePropValue:styles[@"maxWidth"] defaultValue:NAN] |
| ,isUpdate); |
| } |
| if (styles[@"maxHeight"]) { |
| _flexCssNode->setMaxHeight([self judgePropValuePropValue:styles[@"maxHeight"] defaultValue:NAN]); |
| } |
| |
| // margin |
| if (styles[@"margin"]) { |
| _flexCssNode->setMargin(WeexCore::kMarginALL, |
| [self judgePropValuePropValue:styles[@"margin"] defaultValue:0]); |
| } |
| if (styles[@"marginTop"]) { |
| _flexCssNode->setMargin(WeexCore::kMarginTop, |
| [self judgePropValuePropValue:styles[@"marginTop"] defaultValue:0]); |
| } |
| if (styles[@"marginBottom"]) { |
| _flexCssNode->setMargin(WeexCore::kMarginBottom, |
| [self judgePropValuePropValue:styles[@"marginBottom"] defaultValue:0]); |
| } |
| if (styles[@"marginRight"]) { |
| _flexCssNode->setMargin(WeexCore::kMarginRight, |
| [self judgePropValuePropValue:styles[@"marginRight"] defaultValue:0]); |
| } |
| if (styles[@"marginLeft"]) { |
| _flexCssNode->setMargin(WeexCore::kMarginLeft, |
| [self judgePropValuePropValue:styles[@"marginLeft"] defaultValue:0]); |
| } |
| |
| // border |
| if (styles[@"borderWidth"]) { |
| _flexCssNode->setBorderWidth(WeexCore::kBorderWidthALL, |
| [self judgePropValuePropValue:styles[@"borderWidth"] defaultValue:0]); |
| } |
| if (styles[@"borderTopWidth"]) { |
| _flexCssNode->setBorderWidth(WeexCore::kBorderWidthTop, |
| [self judgePropValuePropValue:styles[@"borderTopWidth"] defaultValue:0]); |
| } |
| |
| if (styles[@"borderLeftWidth"]) { |
| _flexCssNode->setBorderWidth(WeexCore::kBorderWidthLeft, |
| [self judgePropValuePropValue:styles[@"borderLeftWidth"] defaultValue:0]); |
| } |
| |
| if (styles[@"borderBottomWidth"]) { |
| _flexCssNode->setBorderWidth(WeexCore::kBorderWidthBottom, |
| [self judgePropValuePropValue:styles[@"borderBottomWidth"] defaultValue:0]); |
| } |
| if (styles[@"borderRightWidth"]) { |
| _flexCssNode->setBorderWidth(WeexCore::kBorderWidthRight, |
| [self judgePropValuePropValue:styles[@"borderRightWidth"] defaultValue:0]); |
| } |
| |
| // padding |
| if (styles[@"padding"]) { |
| _flexCssNode->setPadding(WeexCore::kPaddingALL, |
| [self judgePropValuePropValue:styles[@"padding"] defaultValue:0]); |
| } |
| if (styles[@"paddingTop"]) { |
| _flexCssNode->setPadding(WeexCore::kPaddingTop, |
| [self judgePropValuePropValue:styles[@"paddingTop"] defaultValue:0]); |
| } |
| if (styles[@"paddingLeft"]) { |
| _flexCssNode->setPadding(WeexCore::kPaddingLeft, |
| [self judgePropValuePropValue:styles[@"paddingLeft"] defaultValue:0]); |
| } |
| if (styles[@"paddingBottom"]) { |
| _flexCssNode->setPadding(WeexCore::kPaddingBottom, |
| [self judgePropValuePropValue:styles[@"paddingBottom"] defaultValue:0]); |
| } |
| if (styles[@"paddingRight"]) { |
| _flexCssNode->setPadding(WeexCore::kPaddingRight, |
| [self judgePropValuePropValue:styles[@"paddingRight"] defaultValue:0]); |
| } |
| |
| [self setNeedsLayout]; |
| } |
| |
| -(CGFloat)judgePropValuePropValue:(NSString *)propValue defaultValue:(CGFloat)defaultValue{ |
| CGFloat convertValue = (CGFloat)[WXConvert WXFlexPixelType:propValue scaleFactor:self.weexInstance.pixelScaleFactor]; |
| if (!isnan(convertValue)) { |
| return convertValue; |
| } |
| return defaultValue; |
| } |
| |
| #define WX_FLEX_STYLE_RESET_CSS_NODE(key, defaultValue)\ |
| do {\ |
| WX_FLEX_STYLE_RESET_CSS_NODE_GIVEN_KEY(key,key,defaultValue)\ |
| } while(0); |
| |
| #define WX_FLEX_STYLE_RESET_CSS_NODE_GIVEN_KEY(judgeKey, propKey, defaultValue)\ |
| do {\ |
| if (styles && [styles containsObject:@#judgeKey]) {\ |
| NSMutableDictionary *resetStyleDic = [[NSMutableDictionary alloc] init];\ |
| [resetStyleDic setValue:defaultValue forKey:@#propKey];\ |
| [self _updateCSSNodeStyles:resetStyleDic];\ |
| [self setNeedsLayout];\ |
| }\ |
| } while(0); |
| |
| #define WX_FLEX_STYLE_RESET_CSS_NODE_GIVEN_DIRECTION_KEY(judgeKey, propTopKey,propLeftKey,propRightKey,propBottomKey, defaultValue)\ |
| do {\ |
| if (styles && [styles containsObject:@#judgeKey]) {\ |
| NSMutableDictionary *resetStyleDic = [[NSMutableDictionary alloc] init];\ |
| [resetStyleDic setValue:defaultValue forKey:@#propTopKey];\ |
| [resetStyleDic setValue:defaultValue forKey:@#propLeftKey];\ |
| [resetStyleDic setValue:defaultValue forKey:@#propRightKey];\ |
| [resetStyleDic setValue:defaultValue forKey:@#propBottomKey];\ |
| [self _updateCSSNodeStyles:resetStyleDic];\ |
| [self setNeedsLayout];\ |
| }\ |
| } while(0); |
| |
| |
| - (void)_resetCSSNode:(NSArray *)styles |
| { |
| if (styles.count<=0) { |
| return; |
| } |
| |
| WX_FLEX_STYLE_RESET_CSS_NODE(flex, @0.0) |
| WX_FLEX_STYLE_RESET_CSS_NODE(flexDirection, @(WeexCore::kFlexDirectionColumn)) |
| WX_FLEX_STYLE_RESET_CSS_NODE(alignItems, @(WeexCore::kAlignItemsStretch)) |
| WX_FLEX_STYLE_RESET_CSS_NODE(alignSelf, @(WeexCore::kAlignSelfAuto)) |
| WX_FLEX_STYLE_RESET_CSS_NODE(flexWrap, @(WeexCore::kNoWrap)) |
| WX_FLEX_STYLE_RESET_CSS_NODE(justifyContent, @(WeexCore::kJustifyFlexStart)) |
| |
| // position |
| WX_FLEX_STYLE_RESET_CSS_NODE(position, @(WeexCore::kRelative)) |
| WX_FLEX_STYLE_RESET_CSS_NODE(top, @(NAN)) |
| WX_FLEX_STYLE_RESET_CSS_NODE(left, @(NAN)) |
| WX_FLEX_STYLE_RESET_CSS_NODE(right, @(NAN)) |
| WX_FLEX_STYLE_RESET_CSS_NODE(bottom, @(NAN)) |
| |
| // dimension |
| WX_FLEX_STYLE_RESET_CSS_NODE(width, @(NAN)) |
| WX_FLEX_STYLE_RESET_CSS_NODE(height, @(NAN)) |
| WX_FLEX_STYLE_RESET_CSS_NODE(minWidth, @(NAN)) |
| WX_FLEX_STYLE_RESET_CSS_NODE(minHeight, @(NAN)) |
| WX_FLEX_STYLE_RESET_CSS_NODE(maxWidth, @(NAN)) |
| WX_FLEX_STYLE_RESET_CSS_NODE(maxHeight, @(NAN)) |
| |
| // margin |
| WX_FLEX_STYLE_RESET_CSS_NODE_GIVEN_DIRECTION_KEY(margin |
| ,marginTop |
| ,marginLeft |
| ,marginRight |
| ,marginBottom |
| , @(0.0)) |
| WX_FLEX_STYLE_RESET_CSS_NODE(marginTop, @(0.0)) |
| WX_FLEX_STYLE_RESET_CSS_NODE(marginLeft, @(0.0)) |
| WX_FLEX_STYLE_RESET_CSS_NODE(marginRight, @(0.0)) |
| WX_FLEX_STYLE_RESET_CSS_NODE(marginBottom, @(0.0)) |
| |
| // border |
| WX_FLEX_STYLE_RESET_CSS_NODE_GIVEN_DIRECTION_KEY(borderWidth |
| , borderTopWidth |
| , borderLeftWidth |
| , borderRightWidth |
| , borderBottomWidth |
| , @(0.0)) |
| WX_FLEX_STYLE_RESET_CSS_NODE(borderTopWidth, @(0.0)) |
| WX_FLEX_STYLE_RESET_CSS_NODE(borderLeftWidth, @(0.0)) |
| WX_FLEX_STYLE_RESET_CSS_NODE(borderRightWidth, @(0.0)) |
| WX_FLEX_STYLE_RESET_CSS_NODE(borderBottomWidth, @(0.0)) |
| |
| // padding |
| WX_FLEX_STYLE_RESET_CSS_NODE_GIVEN_DIRECTION_KEY(padding |
| , paddingTop |
| , paddingLeft |
| , paddingRight |
| , paddingBottom |
| , @(0.0)) |
| WX_FLEX_STYLE_RESET_CSS_NODE(paddingTop, @(0.0)) |
| WX_FLEX_STYLE_RESET_CSS_NODE(paddingLeft, @(0.0)) |
| WX_FLEX_STYLE_RESET_CSS_NODE(paddingRight, @(0.0)) |
| WX_FLEX_STYLE_RESET_CSS_NODE(paddingBottom, @(0.0)) |
| |
| } |
| |
| #pragma mark CSS Node Override |
| |
| static WeexCore::WXCoreSize flexCssNodeMeasure(WeexCore::WXCoreLayoutNode *node, float width, WeexCore::MeasureMode widthMeasureMode,float height, WeexCore::MeasureMode heightMeasureMode){ |
| |
| if (node->getContext() == nullptr) { //为空 |
| return WeexCore::WXCoreSize(); |
| } |
| WXComponent *component = (__bridge WXComponent *)(node->getContext()); |
| |
| if (![component respondsToSelector:@selector(measureBlock)]) { |
| return WeexCore::WXCoreSize(); |
| } |
| |
| CGSize (^measureBlock)(CGSize) = [component measureBlock]; |
| |
| if (!measureBlock) { |
| return WeexCore::WXCoreSize(); |
| } |
| |
| CGSize constrainedSize = CGSizeMake(width, height); |
| CGSize resultSize = measureBlock(constrainedSize); |
| #ifdef DEBUG |
| WXLogDebug(@"flexLayout -> measureblock %@, resultSize:%@", |
| component.type, |
| NSStringFromCGSize(resultSize) |
| ); |
| #endif |
| WeexCore::WXCoreSize size; |
| size.height=(float)resultSize.height; |
| size.width=(float)resultSize.width; |
| return size; |
| } |
| |
| -(WeexCore::WXCorePositionType)fxPositionType:(id)value |
| { |
| if([value isKindOfClass:[NSString class]]){ |
| if ([value isEqualToString:@"absolute"]) { |
| return WeexCore::kAbsolute; |
| } else if ([value isEqualToString:@"relative"]) { |
| return WeexCore::kRelative; |
| } else if ([value isEqualToString:@"fixed"]) { |
| return WeexCore::kFixed; |
| } else if ([value isEqualToString:@"sticky"]) { |
| return WeexCore::kRelative; |
| } |
| } |
| return WeexCore::kRelative; |
| } |
| |
| - (WeexCore::WXCoreFlexDirection)fxFlexDirection:(id)value |
| { |
| if([value isKindOfClass:[NSString class]]){ |
| if ([value isEqualToString:@"column"]) { |
| return WeexCore::kFlexDirectionColumn; |
| } else if ([value isEqualToString:@"column-reverse"]) { |
| return WeexCore::kFlexDirectionColumnReverse; |
| } else if ([value isEqualToString:@"row"]) { |
| return WeexCore::kFlexDirectionRow; |
| } else if ([value isEqualToString:@"row-reverse"]) { |
| return WeexCore::kFlexDirectionRowReverse; |
| } |
| } |
| return WeexCore::kFlexDirectionColumn; |
| } |
| |
| //TODO |
| - (WeexCore::WXCoreAlignItems)fxAlign:(id)value |
| { |
| if([value isKindOfClass:[NSString class]]){ |
| if ([value isEqualToString:@"stretch"]) { |
| return WeexCore::kAlignItemsStretch; |
| } else if ([value isEqualToString:@"flex-start"]) { |
| return WeexCore::kAlignItemsFlexStart; |
| } else if ([value isEqualToString:@"flex-end"]) { |
| return WeexCore::kAlignItemsFlexEnd; |
| } else if ([value isEqualToString:@"center"]) { |
| return WeexCore::kAlignItemsCenter; |
| //return WXCoreFlexLayout::WXCore_AlignItems_Center; |
| } else if ([value isEqualToString:@"auto"]) { |
| // return YGAlignAuto; |
| } else if ([value isEqualToString:@"baseline"]) { |
| // return YGAlignBaseline; |
| } |
| } |
| |
| return WeexCore::kAlignItemsStretch; |
| } |
| |
| - (WeexCore::WXCoreAlignSelf)fxAlignSelf:(id)value |
| { |
| if([value isKindOfClass:[NSString class]]){ |
| if ([value isEqualToString:@"stretch"]) { |
| return WeexCore::kAlignSelfStretch; |
| } else if ([value isEqualToString:@"flex-start"]) { |
| return WeexCore::kAlignSelfFlexStart; |
| } else if ([value isEqualToString:@"flex-end"]) { |
| return WeexCore::kAlignSelfFlexEnd; |
| } else if ([value isEqualToString:@"center"]) { |
| return WeexCore::kAlignSelfCenter; |
| } else if ([value isEqualToString:@"auto"]) { |
| return WeexCore::kAlignSelfAuto; |
| } else if ([value isEqualToString:@"baseline"]) { |
| // return YGAlignBaseline; |
| } |
| } |
| |
| return WeexCore::kAlignSelfStretch; |
| } |
| |
| - (WeexCore::WXCoreFlexWrap)fxWrap:(id)value |
| { |
| if([value isKindOfClass:[NSString class]]) { |
| if ([value isEqualToString:@"nowrap"]) { |
| return WeexCore::kNoWrap; |
| } else if ([value isEqualToString:@"wrap"]) { |
| return WeexCore::kWrap; |
| } else if ([value isEqualToString:@"wrap-reverse"]) { |
| return WeexCore::kWrapReverse; |
| } |
| } |
| return WeexCore::kNoWrap; |
| } |
| |
| - (WeexCore::WXCoreJustifyContent)fxJustify:(id)value |
| { |
| if([value isKindOfClass:[NSString class]]){ |
| if ([value isEqualToString:@"flex-start"]) { |
| return WeexCore::kJustifyFlexStart; |
| } else if ([value isEqualToString:@"center"]) { |
| return WeexCore::kJustifyCenter; |
| } else if ([value isEqualToString:@"flex-end"]) { |
| return WeexCore::kJustifyFlexEnd; |
| } else if ([value isEqualToString:@"space-between"]) { |
| return WeexCore::kJustifySpaceBetween; |
| } else if ([value isEqualToString:@"space-around"]) { |
| return WeexCore::kJustifySpaceAround; |
| } |
| } |
| return WeexCore::kJustifyFlexStart; |
| } |
| |
| |
| - (NSInteger) getActualNodeIndex:(WXComponent*)subcomponent atIndex:(NSInteger) index |
| { |
| NSInteger actualIndex = 0; //实际除去不需要布局的subComponent，此时所在的正确位置 |
| for (WXComponent *child in _subcomponents) { |
| if ([child.ref isEqualToString:subcomponent.ref]) { |
| break; |
| } |
| if (child->_isNeedJoinLayoutSystem) { |
| actualIndex ++; |
| } |
| } |
| return actualIndex; |
| } |
| |
| - (void)_insertChildCssNode:(WXComponent*)subcomponent atIndex:(NSInteger)index |
| { |
| self.flexCssNode->addChildAt(subcomponent.flexCssNode, (uint32_t)index); |
| } |
| |
| - (void)_rmChildCssNode:(WXComponent *)subcomponent |
| { |
| self.flexCssNode->removeChild(subcomponent->_flexCssNode); |
| #ifdef DEBUG |
| WXLogDebug(@"flexLayout -> ref:%@ ,flexCssNode->removeChild ,childRef:%@",self.ref,subcomponent.ref); |
| #endif |
| } |
| |
| |
| + (void) recycleNodeOnComponentThread:(WeexCore::WXCoreLayoutNode * ) garbageNode gabRef:(NSString *)ref { |
| if (nullptr == garbageNode) { |
| #ifdef DEBUG |
| WXLogDebug(@"flexlayout->recycle garbageNode ref:%@ is null ",ref); |
| #endif |
| return; |
| } |
| WXPerformBlockOnComponentThread(^{ |
| #ifdef DEBUG |
| WXLogDebug(@"flexlayout->recycle ref:%@ ,node:%p",ref,garbageNode ); |
| #endif |
| if(nullptr != garbageNode){ |
| delete garbageNode; |
| } |
| }); |
| //domthread |
| } |
| |
| @end |
