| /** |
| * 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. |
| */ |
| #include "layout.h" |
| #include <tuple> |
| |
| using namespace WeexCore; |
| |
| namespace WeexCore { |
| |
| /** |
| * Entry function to calculate layout |
| */ |
| void WXCoreLayoutNode::calculateLayout(const std::pair<float,float> &renderPageSize) { |
| BFCs.clear(); |
| initFormatingContext(BFCs); |
| auto bfcDimension = calculateBFCDimension(renderPageSize); |
| if (std::get<0>(bfcDimension) || isDirty()) { |
| mChildrenFrozen.assign(getChildCount(kNonBFC), false); |
| measure(std::get<1>(bfcDimension), std::get<2>(bfcDimension), true); |
| checkSizeConstraints(this, false); |
| } |
| layout(mCssStyle->mMargin.getMargin(kMarginLeft), |
| mCssStyle->mMargin.getMargin(kMarginTop), |
| mCssStyle->mMargin.getMargin(kMarginLeft) + getLayoutWidth(), |
| mCssStyle->mMargin.getMargin(kMarginTop) + getLayoutHeight(), |
| false, &renderPageSize); |
| for (Index i = 0; i < getChildCount(kBFC); ++i) { |
| WXCoreLayoutNode *child = getChildAt(kBFC, i); |
| child->calculateLayout(renderPageSize); |
| } |
| } |
| |
| void WXCoreLayoutNode::initFormatingContext(std::vector<WXCoreLayoutNode *> &BFCs) { |
| NonBFCs.clear(); |
| for(auto it = ChildListIterBegin(); it != ChildListIterEnd(); it++) { |
| WXCoreLayoutNode* child = *it; |
| if (child != nullptr) { |
| if (isBFC(child)) { |
| BFCs.push_back(child); |
| } else { |
| NonBFCs.push_back(child); |
| child->initFormatingContext(BFCs); |
| } |
| } |
| } |
| reset(); |
| } |
| |
| std::tuple<bool, float, float> WXCoreLayoutNode::calculateBFCDimension(const std::pair<float,float>& renderPageSize) { |
| bool sizeChanged = false; |
| float width = mCssStyle->mStyleWidth, height = mCssStyle->mStyleHeight; |
| std::pair<bool,float> ret; |
| if (isBFC(this)) { |
| ret = calculateBFCWidth(width, renderPageSize.first); |
| sizeChanged |=ret.first; |
| width = ret.second; |
| |
| ret = calculateBFCHeight(height,renderPageSize.second); |
| sizeChanged |=ret.first; |
| height = ret.second; |
| } |
| return std::make_tuple(sizeChanged, width, height); |
| } |
| |
| std::pair<bool,float> WXCoreLayoutNode::calculateBFCWidth(float width, const float renderPageWidth){ |
| bool sizeChanged = false; |
| if (isnan(width) && |
| mParent != nullptr && |
| !isnan(mCssStyle->mStylePosition.getPosition(kPositionEdgeLeft)) && |
| !isnan(mCssStyle->mStylePosition.getPosition(kPositionEdgeRight))) { |
| float containingBlockWidth = NAN; |
| switch (mCssStyle->mPositionType) { |
| case kAbsolute: |
| containingBlockWidth = mParent->mLayoutResult->mLayoutSize.width; |
| break; |
| case kFixed: |
| if (!isnan(renderPageWidth)) { |
| containingBlockWidth = renderPageWidth; |
| } |
| break; |
| } |
| if (!isnan(containingBlockWidth)) { |
| width = containingBlockWidth - |
| mCssStyle->mStylePosition.getPosition(kPositionEdgeLeft) - |
| mCssStyle->mStylePosition.getPosition(kPositionEdgeRight); |
| if (!isnan(mCssStyle->mMargin.getMargin(kMarginLeft))) { |
| width -= mCssStyle->mMargin.getMargin(kMarginLeft); |
| } |
| if (!isnan(mCssStyle->mMargin.getMargin(kMarginRight))) { |
| width -= mCssStyle->mMargin.getMargin(kMarginRight); |
| } |
| setWidthMeasureMode(kExactly); |
| sizeChanged = true; |
| } |
| } |
| return std::make_pair(sizeChanged, width); |
| } |
| |
| |
| std::pair<bool,float> WXCoreLayoutNode::calculateBFCHeight(float height, const float renderPageHeight){ |
| bool sizeChanged = false; |
| if (isnan(mCssStyle->mStyleHeight) && |
| mParent != nullptr && |
| !isnan(mCssStyle->mStylePosition.getPosition(kPositionEdgeTop)) && |
| !isnan(mCssStyle->mStylePosition.getPosition(kPositionEdgeBottom))) { |
| float containingBlockHeight = NAN; |
| switch (mCssStyle->mPositionType) { |
| case kAbsolute: |
| containingBlockHeight = mParent->mLayoutResult->mLayoutSize.height; |
| break; |
| case kFixed: |
| if (!isnan(renderPageHeight)) { |
| containingBlockHeight = renderPageHeight; |
| } |
| break; |
| } |
| if (!isnan(containingBlockHeight)) { |
| height = containingBlockHeight - |
| mCssStyle->mStylePosition.getPosition(kPositionEdgeTop) - |
| mCssStyle->mStylePosition.getPosition(kPositionEdgeBottom); |
| if (!isnan(mCssStyle->mMargin.getMargin(kMarginTop))) { |
| height -= mCssStyle->mMargin.getMargin(kMarginTop); |
| } |
| if (!isnan(mCssStyle->mMargin.getMargin(kMarginBottom))) { |
| height -= mCssStyle->mMargin.getMargin(kMarginBottom); |
| } |
| setHeightMeasureMode(kExactly); |
| sizeChanged = true; |
| } |
| } |
| return std::make_pair(sizeChanged, height); |
| } |
| |
| void WXCoreLayoutNode::measure(const float width, const float height, const bool hypotheticalMeasurment){ |
| if(hypotheticalMeasurment){ |
| //Only BFC will enter this case. |
| hypotheticalMeasure(width, height); |
| } |
| |
| if(getChildCount(kNonBFC) > 0){ |
| if((isMainAxisHorizontal(this) && widthDirty) || (!isMainAxisHorizontal(this) && heightDirty)){ |
| measureInternalNode(width, height, false, false); |
| } |
| determineMainSize(width, height); |
| determineCrossSize(width, height, true); |
| measureInternalNode(width, height, true, false); |
| determineCrossSize(width, height, false); |
| } |
| else { |
| if (widthDirty || heightDirty) { |
| measureLeafNode(width, height, hypotheticalMeasurment, false); |
| } |
| } |
| clearDirty(); |
| } |
| |
| void WXCoreLayoutNode::hypotheticalMeasure(const float width, const float height, const bool stretch){ |
| if (getChildCount(kNonBFC) > 0) { |
| measureInternalNode(width, height, true, true); |
| } else { |
| measureLeafNode(width, height, true, stretch); |
| } |
| |
| widthDirty = false; |
| heightDirty = false; |
| mLayoutResult->mLayoutSize.hypotheticalWidth = mLayoutResult->mLayoutSize.width; |
| mLayoutResult->mLayoutSize.hypotheticalHeight = mLayoutResult->mLayoutSize.height; |
| } |
| |
| void WXCoreLayoutNode::measureLeafNode(float width, float height, const bool hypothetical, const bool stretch) { |
| if ((measureFunc != nullptr) && |
| (widthMeasureMode == kUnspecified |
| || heightMeasureMode == kUnspecified)) { |
| float constrainsWidth = width; |
| if(isnan(width)){ |
| if(!isnan(mCssStyle->mMaxWidth)){ |
| constrainsWidth = mCssStyle->mMaxWidth; |
| } |
| } |
| |
| if((!isnan(width)&&widthMeasureMode == kExactly) || |
| (isnan(width) && !isnan(mCssStyle->mMaxWidth))) { |
| constrainsWidth -= sumPaddingBorderAlongAxis(this, true); |
| } |
| WXCoreSize dimension = measureFunc(this, constrainsWidth, |
| (stretch && !isnan(width)) ? kExactly:widthMeasureMode, |
| height, heightMeasureMode); |
| if (widthMeasureMode == kUnspecified) { |
| float actualWidth = dimension.width + sumPaddingBorderAlongAxis(this, true); |
| if (isnan(width)) { |
| width = actualWidth; |
| } else if (!stretch) { |
| width = std::min(width, actualWidth); |
| } |
| } |
| if (heightMeasureMode == kUnspecified) { |
| float actualHeight = dimension.height + sumPaddingBorderAlongAxis(this, false); |
| if (isnan(height)) { |
| height = actualHeight; |
| } else if (!stretch) { |
| height = std::min(height, actualHeight); |
| } |
| } |
| } else { |
| width = widthMeasureMode == kUnspecified ? sumPaddingBorderAlongAxis(this, true) |
| : width; |
| height = heightMeasureMode == kUnspecified ? sumPaddingBorderAlongAxis(this, false) |
| : height; |
| } |
| setMeasuredDimension(width, height); |
| } |
| |
| |
| /** |
| * Determine the main size by expanding the individual flexGrow attribute. |
| */ |
| void WXCoreLayoutNode::determineMainSize(const float width, const float height) { |
| bool horizontal = isMainAxisHorizontal(this); |
| if((horizontal && widthMeasureMode == kExactly) || (!horizontal && heightMeasureMode == kExactly)) { |
| //The measureMode along main axis is exactly |
| float maxMainSize = horizontal ? width: height; |
| maxMainSize -= sumPaddingBorderAlongAxis(this, isMainAxisHorizontal(this)); |
| Index childIndex = 0; |
| for (WXCoreFlexLine *flexLine : mFlexLines) { |
| childIndex = expandItemsInFlexLine(flexLine, maxMainSize, childIndex); |
| } |
| } |
| } |
| |
| |
| /** |
| * @param flexDirection the flex direction attribute |
| * @param width stylewidth by this node |
| * @param height styleheight by this node |
| * @param paddingAlongCrossAxis the padding value for this node along the cross axis |
| */ |
| void WXCoreLayoutNode::determineCrossSize(const float width, const float height, const bool stretch) { |
| if (mFlexLines.size() == 1 && isCrossExactly()) { |
| bool horizontal = isMainAxisHorizontal(this); |
| float size = mFlexLines[0]->mCrossSize; |
| float paddingAlongCrossAxis = sumPaddingBorderAlongAxis(this, !horizontal); |
| if (horizontal) { |
| if (heightMeasureMode == kExactly) { |
| size = height - paddingAlongCrossAxis; |
| } |
| } else { |
| if (widthMeasureMode == kExactly) { |
| size = width - paddingAlongCrossAxis; |
| } |
| } |
| mFlexLines[0]->mCrossSize = size; |
| } |
| if (stretch) { |
| stretchViewCrossSize(); |
| } |
| } |
| |
| |
| void WXCoreLayoutNode::measureInternalNode(const float width, const float height, const bool needMeasure, |
| const bool hypotheticalMeasurment) { |
| for (WXCoreFlexLine *flexLine : mFlexLines) { |
| if(flexLine!= nullptr) { |
| delete flexLine; |
| } |
| flexLine = nullptr; |
| } |
| mFlexLines.clear(); |
| Index childCount = getChildCount(kNonBFC); |
| WXCoreFlexLine *flexLine = new WXCoreFlexLine(); |
| |
| for (Index i = 0; i < childCount; i++) { |
| WXCoreLayoutNode *child = getChildAt(kNonBFC, i); |
| if (child->mCssStyle->mAlignSelf == kAlignSelfStretch) { |
| flexLine->mIndicesAlignSelfStretch.push_back(i); |
| } |
| measureChild(child, flexLine->mMainSize, width, height, needMeasure, hypotheticalMeasurment); |
| checkSizeConstraints(child, hypotheticalMeasurment); |
| |
| if (isWrapRequired(width, height, flexLine->mMainSize, |
| calcItemSizeAlongAxis(child, isMainAxisHorizontal(this)))) { |
| if (flexLine->mItemCount > 0) { |
| mFlexLines.push_back(flexLine); |
| } |
| flexLine = new WXCoreFlexLine(); |
| flexLine->mItemCount = 1; |
| } else { |
| flexLine->mItemCount++; |
| } |
| updateCurrentFlexline(childCount, flexLine, i, child, hypotheticalMeasurment || (!hypotheticalMeasurment && !needMeasure)); |
| } |
| setMeasuredDimensionForFlex(width, widthMeasureMode, height, heightMeasureMode); |
| } |
| |
| void WXCoreLayoutNode::updateCurrentFlexline(const Index childCount, WXCoreFlexLine* const flexLine, const Index i, |
| const WXCoreLayoutNode* const child, const bool useHypotheticalSize){ |
| flexLine->mMainSize += calcItemSizeAlongAxis(child, isMainAxisHorizontal(this), useHypotheticalSize); |
| sumFlexGrow(child, flexLine, i); |
| flexLine->mCrossSize = |
| std::max(flexLine->mCrossSize, calcItemSizeAlongAxis(child, !isMainAxisHorizontal(this), useHypotheticalSize)); |
| if (i == childCount - 1 && flexLine->mItemCount != 0) { |
| mFlexLines.push_back(flexLine); |
| } |
| } |
| |
| void WXCoreLayoutNode::measureChild(WXCoreLayoutNode* const child, const float currentMainSize, |
| const float parentWidth, const float parentHeight, |
| const bool needMeasure, const bool hypotheticalMeasurment) { |
| if (needMeasure && child->isDirty()) { |
| if (hypotheticalMeasurment) { |
| float childWidth = child->mCssStyle->mStyleWidth; |
| float childHeight = child->mCssStyle->mStyleHeight; |
| bool stretch = !isMainAxisHorizontal(this) && |
| child->measureFunc != nullptr && |
| widthMeasureMode == kExactly && |
| isSingleFlexLine(parentHeight) && |
| ((child->mCssStyle->mAlignSelf == kAlignSelfStretch) || |
| (mCssStyle->mAlignItems == kAlignItemsStretch |
| && child->mCssStyle->mAlignSelf == kAlignSelfAuto)); |
| |
| adjustChildSize(child, currentMainSize, parentWidth, |
| parentHeight, childWidth, childHeight); |
| child->hypotheticalMeasure(childWidth, childHeight, stretch); |
| } else { |
| if(isSingleFlexLine(isMainAxisHorizontal(this) ? parentWidth : parentHeight) |
| && !isMainAxisHorizontal(this) && child->widthMeasureMode == kUnspecified){ |
| child->setLayoutWidth(parentWidth - sumPaddingBorderAlongAxis(this, true) |
| -child->mCssStyle->sumMarginOfDirection(true)); |
| if(child->heightMeasureMode == kUnspecified && child->widthDirty) { |
| child->mLayoutResult->mLayoutSize.height = NAN; |
| } |
| } |
| child->measure(child->mLayoutResult->mLayoutSize.width, |
| child->mLayoutResult->mLayoutSize.height, hypotheticalMeasurment); |
| } |
| } |
| } |
| |
| void WXCoreLayoutNode::adjustChildSize(const WXCoreLayoutNode *child, |
| const float currentMainSize, |
| const float parentWidth, |
| const float parentHeight, |
| float &childWidth, |
| float &childHeight) const { |
| if(child->measureFunc == nullptr) { |
| if(!isnan(childWidth)){ |
| childWidth = std::max(childWidth, child->sumPaddingBorderAlongAxis(child, true)); |
| } |
| if(!isnan(childHeight)){ |
| childHeight = std::max(childHeight, child->sumPaddingBorderAlongAxis(child, false)); |
| } |
| } |
| |
| if (isSingleFlexLine(isMainAxisHorizontal(this) ? parentWidth : parentHeight)) { |
| if (isMainAxisHorizontal(this)) { |
| if (!isnan(parentHeight) && isnan(child->mCssStyle->mStyleHeight) |
| && child->mCssStyle->mAlignSelf == kAlignSelfAuto |
| && mCssStyle->mAlignItems == kAlignItemsStretch) { |
| childHeight = parentHeight - sumPaddingBorderAlongAxis(this, false) - |
| child->mCssStyle->sumMarginOfDirection(false); |
| } |
| } else { |
| if (!isnan(parentWidth) && isnan(child->mCssStyle->mStyleWidth)) { |
| childWidth = parentWidth - sumPaddingBorderAlongAxis(this, true) - |
| child->mCssStyle->sumMarginOfDirection(true); |
| } |
| } |
| } |
| } |
| |
| void WXCoreLayoutNode::checkSizeConstraints(WXCoreLayoutNode* const node, const bool hypotheticalMeasurment) { |
| bool widthRemeasure = false, heightRemeasure = false; |
| float nodeWidth,nodeHeight; |
| nodeWidth = node->mLayoutResult->mLayoutSize.width; |
| nodeHeight = node->mLayoutResult->mLayoutSize.height; |
| |
| if (!isnan(node->mCssStyle->mMinWidth) && |
| nodeWidth < node->mCssStyle->mMinWidth) { |
| widthRemeasure = true; |
| nodeWidth = node->mCssStyle->mMinWidth; |
| } else if (!isnan(node->mCssStyle->mMaxWidth) |
| && nodeWidth > node->mCssStyle->mMaxWidth) { |
| widthRemeasure = true; |
| nodeWidth = node->mCssStyle->mMaxWidth; |
| } |
| |
| if (!isnan(node->mCssStyle->mMinHeight) && |
| nodeHeight < node->mCssStyle->mMinHeight) { |
| heightRemeasure = true; |
| nodeHeight = node->mCssStyle->mMinHeight; |
| } else if (!isnan(node->mCssStyle->mMaxHeight) && |
| nodeHeight > node->mCssStyle->mMaxHeight) { |
| heightRemeasure = true; |
| nodeHeight = node->mCssStyle->mMaxHeight; |
| } |
| |
| node->setWidthMeasureMode(widthRemeasure ? kExactly : node->widthMeasureMode); |
| node->setHeightMeasureMode(heightRemeasure ? kExactly : node->heightMeasureMode); |
| |
| if (hypotheticalMeasurment) { |
| if (widthRemeasure) { |
| node->setLayoutWidth(nodeWidth); |
| node->mLayoutResult->mLayoutSize.hypotheticalWidth = nodeWidth; |
| } |
| if (heightRemeasure) { |
| node->setLayoutHeight(nodeHeight); |
| node->mLayoutResult->mLayoutSize.hypotheticalHeight = nodeHeight; |
| } |
| } else { |
| if (widthRemeasure || heightRemeasure) { |
| node->measure(nodeWidth, nodeHeight, hypotheticalMeasurment); |
| } |
| } |
| } |
| |
| Index WXCoreLayoutNode::expandItemsInFlexLine(WXCoreFlexLine* const flexLine, |
| const float maxMainSize, |
| const Index startIndex) { |
| Index childIndex = startIndex; |
| if (flexLine->mTotalFlexGrow <= 0) { |
| childIndex += flexLine->mItemCount; |
| } else { |
| bool needsReexpand = false; |
| const float unitSpace = (maxMainSize - flexLine->mMainSize + flexLine->mTotalFlexibleSize) / |
| (flexLine->mTotalFlexGrow > 1 ? flexLine->mTotalFlexGrow : 1); |
| float sizeBeforeExpand = flexLine->mMainSize; |
| flexLine->mMainSize = 0; |
| |
| for (Index i = 0; i < flexLine->mItemCount; i++) { |
| WXCoreLayoutNode *child = getChildAt(kNonBFC, childIndex); |
| if (!mChildrenFrozen[childIndex]) { |
| float childSizeAlongMainAxis = unitSpace * child->mCssStyle->mFlexGrow; |
| std::pair<bool, float> limitSize = limitChildMainSize(flexLine, child, |
| childSizeAlongMainAxis, childIndex); |
| needsReexpand = limitSize.first; |
| adjustChildSize(child, limitSize.second); |
| } |
| flexLine->mMainSize += calcItemSizeAlongAxis(child, isMainAxisHorizontal(this)); |
| childIndex++; |
| } |
| |
| if (needsReexpand && sizeBeforeExpand != flexLine->mMainSize) { |
| // Re-invoke the method with the same startIndex to distribute the positive free space |
| // that wasn't fully distributed (because of maximum/minimum length constraint) |
| expandItemsInFlexLine(flexLine, maxMainSize, startIndex); |
| } |
| } |
| return childIndex; |
| } |
| |
| void WXCoreLayoutNode::adjustChildSize(WXCoreLayoutNode* const child, const float childMainSize) { |
| if (isMainAxisHorizontal(this)) { |
| child->setWidthMeasureMode(kExactly); |
| child->setLayoutWidth(childMainSize); |
| } else { |
| child->setHeightMeasureMode(kExactly); |
| child->setLayoutHeight(childMainSize); |
| } |
| } |
| |
| void WXCoreLayoutNode::stretchViewCrossSize(){ |
| if (mCssStyle->mAlignItems == kAlignItemsStretch) { |
| Index viewIndex = 0; |
| for (Index i = 0; i< mFlexLines.size(); i++ ) { |
| WXCoreFlexLine *flexLine = mFlexLines.at(i); |
| for (Index j = 0; j < flexLine->mItemCount; j++, viewIndex++) { |
| WXCoreLayoutNode* child = getChildAt(kNonBFC, viewIndex); |
| if (child->mCssStyle->mAlignSelf == kAlignSelfAuto || |
| child->mCssStyle->mAlignSelf == kAlignSelfStretch) { |
| stretchViewCrossSize(child, flexLine->mCrossSize); |
| } |
| } |
| } |
| } else { |
| for (WXCoreFlexLine *flexLine : mFlexLines) { |
| for (auto index : flexLine->mIndicesAlignSelfStretch) { |
| stretchViewCrossSize(getChildAt(kNonBFC, index), flexLine->mCrossSize); |
| } |
| } |
| } |
| } |
| |
| void WXCoreLayoutNode::stretchViewCrossSize(WXCoreLayoutNode* const child, float crossSize){ |
| if (isMainAxisHorizontal(this)) { |
| if (child->heightMeasureMode != kExactly) { |
| crossSize -= |
| child->mCssStyle->mMargin.getMargin(kMarginTop) + |
| child->mCssStyle->mMargin.getMargin(kMarginBottom); |
| child->setHeightMeasureMode(kExactly); |
| child->setLayoutHeight(std::max(0.f, crossSize)); |
| } |
| } else { |
| if (child->widthMeasureMode != kExactly) { |
| crossSize -= |
| child->mCssStyle->mMargin.getMargin(kMarginLeft) + |
| child->mCssStyle->mMargin.getMargin(kMarginRight); |
| child->setWidthMeasureMode(kExactly); |
| child->setLayoutWidth(std::max(0.f, crossSize)); |
| } |
| } |
| } |
| |
| void WXCoreLayoutNode::setFrame(const float l, const float t, const float r, const float b) { |
| if (mLayoutResult->mLayoutPosition.getPosition(kPositionEdgeLeft) != l |
| || mLayoutResult->mLayoutPosition.getPosition(kPositionEdgeTop) != t |
| || mLayoutResult->mLayoutPosition.getPosition(kPositionEdgeRight) != r |
| || mLayoutResult->mLayoutPosition.getPosition(kPositionEdgeBottom) != b) { |
| setHasNewLayout(true); |
| setFrame(&mLayoutResult->mLayoutPosition, l, t, r, b); |
| } |
| } |
| |
| void WXCoreLayoutNode::setFrame(WXCorePosition* position,const float l, const float t, const float r, const float b){ |
| position->setPosition(kPositionEdgeLeft, l); |
| position->setPosition(kPositionEdgeTop, t); |
| position->setPosition(kPositionEdgeRight, r); |
| position->setPosition(kPositionEdgeBottom, b); |
| } |
| |
| void WXCoreLayoutNode::layout(float left, float top, float right, float bottom, const bool absoluteFlexItem, const std::pair<float,float>* const renderPageSize) { |
| if(absoluteFlexItem) { |
| absoultePositon = new WXCorePosition(); |
| setFrame(absoultePositon, left, top, right, bottom); |
| } |
| else{ |
| switch (mCssStyle->mPositionType) { |
| case kFixed: |
| case kAbsolute: |
| calcAbsoluteOffset(left, top, right, bottom, renderPageSize); |
| break; |
| default: |
| case kRelative: |
| calcRelativeOffset(left, top, right, bottom); |
| break; |
| } |
| setFrame(left, top, right, bottom); |
| onLayout(left, top, right, bottom); |
| } |
| } |
| |
| void WXCoreLayoutNode::calcRelativeOffset(float &left, float &top, float &right, float &bottom) const { |
| if (!isnan(mCssStyle->mStylePosition.getPosition(kPositionEdgeLeft))) { |
| left += mCssStyle->mStylePosition.getPosition(kPositionEdgeLeft); |
| right += mCssStyle->mStylePosition.getPosition(kPositionEdgeLeft); |
| } else if (!isnan(mCssStyle->mStylePosition.getPosition(kPositionEdgeRight))) { |
| left -= mCssStyle->mStylePosition.getPosition(kPositionEdgeRight); |
| right -= mCssStyle->mStylePosition.getPosition(kPositionEdgeRight); |
| } |
| |
| if (!isnan(mCssStyle->mStylePosition.getPosition(kPositionEdgeTop))) { |
| top += mCssStyle->mStylePosition.getPosition(kPositionEdgeTop); |
| bottom += mCssStyle->mStylePosition.getPosition(kPositionEdgeTop); |
| } else if (!isnan(mCssStyle->mStylePosition.getPosition(kPositionEdgeBottom))) { |
| top -= mCssStyle->mStylePosition.getPosition(kPositionEdgeBottom); |
| bottom -= mCssStyle->mStylePosition.getPosition(kPositionEdgeBottom); |
| } |
| } |
| |
| void WXCoreLayoutNode::calcAbsoluteOffset(float &left, float &top, float &right, float &bottom, const std::pair<float,float>* const renderPageSize){ |
| WXCorePadding parentPadding; |
| WXCoreBorderWidth parentBorder; |
| WXCoreSize parentSize; |
| if (mCssStyle->mPositionType == kAbsolute && mParent != nullptr) { |
| parentPadding = mParent->mCssStyle->mPadding; |
| parentBorder = mParent->mCssStyle->mBorderWidth; |
| parentSize = mParent->mLayoutResult->mLayoutSize; |
| positionAbsoluteFlexItem(left, top, right, bottom); |
| } else if(mCssStyle->mPositionType == kFixed && renderPageSize!= nullptr){ |
| parentSize.width = renderPageSize->first; |
| parentSize.height = renderPageSize->second; |
| } |
| updateLeftRightForAbsolute(left, right, parentPadding, parentBorder, parentSize); |
| updateTopBottomForAbsolute(top, bottom, parentPadding, parentBorder, parentSize); |
| } |
| |
| void WXCoreLayoutNode::positionAbsoluteFlexItem(float &left, float &top, float &right, float &bottom){ |
| if ((isnan(getStylePositionLeft()) && isnan(getStylePositionRight())) || |
| (isnan(getStylePositionTop()) && isnan(getStylePositionBottom()))) { |
| WXCoreFlexLine tempLine; |
| mParent->updateFlexLineForAbsoluteItem(this, &tempLine); |
| mParent->onLayout(mParent->getLayoutPositionLeft(), |
| mParent->getLayoutPositionTop(), |
| mParent->getLayoutPositionRight(), |
| mParent->getLayoutPositionBottom(), |
| this, &tempLine); |
| if(absoultePositon != nullptr) { |
| if (isnan(getStylePositionLeft()) && isnan(getStylePositionRight())) { |
| left = absoultePositon->getPosition(kPositionEdgeLeft); |
| right = absoultePositon->getPosition(kPositionEdgeRight); |
| } |
| if (isnan(getStylePositionTop()) && isnan(getStylePositionBottom())) { |
| top = absoultePositon->getPosition(kPositionEdgeTop); |
| bottom = absoultePositon->getPosition(kPositionEdgeBottom); |
| } |
| delete absoultePositon; |
| absoultePositon = nullptr; |
| } |
| } |
| } |
| |
| void WXCoreLayoutNode::updateFlexLineForAbsoluteItem(WXCoreLayoutNode *const absoluteFlexItem, WXCoreFlexLine *const flexLine){ |
| flexLine->mMainSize = isMainAxisHorizontal(this) ? |
| absoluteFlexItem->getLayoutWidth() + absoluteFlexItem->getMarginLeft() |
| + absoluteFlexItem->getMarginRight() : |
| absoluteFlexItem->getLayoutHeight() + absoluteFlexItem->getMarginTop() |
| + absoluteFlexItem->getMarginBottom(); |
| flexLine->mCrossSize = isMainAxisHorizontal(this) ? |
| absoluteFlexItem->getLayoutHeight() + absoluteFlexItem->getMarginTop() |
| + absoluteFlexItem->getMarginBottom() : |
| absoluteFlexItem->getLayoutWidth() + absoluteFlexItem->getMarginLeft() |
| + absoluteFlexItem->getMarginRight(); |
| flexLine->mItemCount = 1; |
| } |
| |
| void WXCoreLayoutNode::onLayout(const float left, const float top, const float right, const float bottom, |
| WXCoreLayoutNode *const absoulteItem, WXCoreFlexLine *const flexLine) { |
| switch (mCssStyle->mFlexDirection) { |
| case kFlexDirectionRow: |
| layoutHorizontal(false, left, top, right, bottom, absoulteItem, flexLine); |
| break; |
| case kFlexDirectionRowReverse: |
| layoutHorizontal(true, left, top, right, bottom, absoulteItem, flexLine); |
| break; |
| case kFlexDirectionColumnReverse: |
| layoutVertical(mCssStyle->mFlexWrap == kWrapReverse, true, left, top, right, bottom, absoulteItem, flexLine); |
| break; |
| case kFlexDirectionColumn: |
| default: |
| layoutVertical(mCssStyle->mFlexWrap == kWrapReverse, false, left, top, right, bottom, absoulteItem, flexLine); |
| break; |
| } |
| } |
| |
| /** |
| * Sub method for {@link WXCoreLayoutNode #onLayout(int, int, int, int)} when the |
| * {@link #mFlexDirection} is either {@link WXCoreFlexDirection #WXCore_Flex_Direction_Row} or |
| * {@link WXCoreFlexDirection #WXCore_Flex_Direction_Row_REVERSE}. |
| * |
| * @param isRtl {@code true} if the horizontal layout direction is mStyleRight to mStyleLeft, {@code |
| * false} otherwise. |
| * @param left the mStyleLeft position of this View |
| * @param top the mStyleTop position of this View |
| * @param right the mStyleRight position of this View |
| * @param bottom the mStyleBottom position of this View |
| */ |
| void WXCoreLayoutNode::layoutHorizontal(const bool isRtl, |
| const float left, const float top, |
| const float right, const float bottom, |
| WXCoreLayoutNode *const absoulteItem, |
| WXCoreFlexLine *const flexLine) { |
| Index currentViewIndex = 0; |
| float height = bottom - top; |
| float width = right - left; |
| |
| // childBottom is used if the mFlexWrap is FLEX_WRAP_WRAP_REVERSE otherwise |
| // childTop is used to align the vertical position of the children views. |
| float childBottom = height - getPaddingBottom() - getBorderWidthBottom(); |
| float childTop = getPaddingTop() + getBorderWidthTop(); |
| |
| // Used only for RTL layout |
| // Use float to reduce the round error that may happen in when justifyContent == |
| // SPACE_BETWEEN or SPACE_AROUND |
| float childLeft, childRight; |
| const std::vector<WXCoreFlexLine*> &lines = (flexLine == nullptr? mFlexLines: std::vector<WXCoreFlexLine*>{flexLine}); |
| |
| for (WXCoreFlexLine *flexLine: lines) { |
| float spaceBetweenItem = 0.f; |
| layoutFlexlineHorizontal(width, flexLine, childLeft, childRight, spaceBetweenItem); |
| spaceBetweenItem = std::max(spaceBetweenItem, 0.f); |
| |
| if(absoulteItem == nullptr) { |
| for (Index j = 0; j < flexLine->mItemCount; j++) { |
| WXCoreLayoutNode *child = getChildAt(kNonBFC, currentViewIndex); |
| if (child == nullptr) { |
| continue; |
| } |
| layoutSingleChildHorizontal(isRtl, false, childBottom, childTop, |
| flexLine, child, childLeft, childRight); |
| childLeft += child->mLayoutResult->mLayoutSize.width + spaceBetweenItem + child->getMarginRight(); |
| childRight -= child->mLayoutResult->mLayoutSize.width + spaceBetweenItem + child->getMarginLeft(); |
| currentViewIndex++; |
| } |
| childTop += flexLine->mCrossSize; |
| childBottom -= flexLine->mCrossSize; |
| } |
| else{ |
| layoutSingleChildHorizontal(isRtl, true, childBottom, childTop, |
| flexLine, absoulteItem, childLeft, childRight); |
| } |
| } |
| } |
| |
| void WXCoreLayoutNode::layoutFlexlineHorizontal(const float width, |
| const WXCoreFlexLine *const flexLine, |
| float &childLeft, |
| float &childRight, |
| float &spaceBetweenItem) const { |
| Index visibleCount, visibleItem; |
| float denominator; |
| switch (mCssStyle->mJustifyContent) { |
| case kJustifyFlexEnd: |
| childLeft = width - flexLine->mMainSize - getPaddingRight() - getBorderWidthRight(); |
| childRight = width - getPaddingLeft() - getBorderWidthLeft(); |
| break; |
| case kJustifyCenter: |
| childLeft = (width - flexLine->mMainSize - mCssStyle->sumPaddingBorderOfEdge(kRight) |
| + mCssStyle->sumPaddingBorderOfEdge(kLeft)) / 2; |
| childRight = childLeft + flexLine->mMainSize; |
| break; |
| case kJustifySpaceAround: |
| visibleCount = flexLine->mItemCount; |
| if (visibleCount != 0) { |
| spaceBetweenItem = |
| (width - flexLine->mMainSize - sumPaddingBorderAlongAxis(this, true)) / visibleCount; |
| } |
| childLeft = getPaddingLeft() + getBorderWidthLeft() + spaceBetweenItem / 2.f; |
| childRight = width - getPaddingRight() - getBorderWidthRight() - spaceBetweenItem / 2.f; |
| break; |
| case kJustifySpaceBetween: |
| childLeft = getPaddingLeft() + getBorderWidthLeft(); |
| visibleItem = flexLine->mItemCount; |
| denominator = visibleItem != 1 ? visibleItem - 1 : 1.f; |
| spaceBetweenItem = |
| (width - flexLine->mMainSize - sumPaddingBorderAlongAxis(this, true)) / denominator; |
| childRight = width - getPaddingRight() - getBorderWidthRight(); |
| break; |
| case kJustifyFlexStart: |
| default: |
| childLeft = getPaddingLeft() + getBorderWidthLeft(); |
| childRight = width - getPaddingRight() - getBorderWidthRight(); |
| break; |
| } |
| } |
| |
| void WXCoreLayoutNode::layoutSingleChildHorizontal(const bool isRtl, const bool absoulteItem, |
| float childBottom, float childTop, |
| WXCoreFlexLine *const flexLine, |
| WXCoreLayoutNode *const child, |
| float &childLeft, float &childRight) { |
| childLeft += child->getMarginLeft(); |
| childRight -= child->getMarginRight(); |
| if (mCssStyle->mFlexWrap == kWrapReverse) { |
| if (isRtl) { |
| layoutSingleChildHorizontal(child, |
| flexLine, |
| mCssStyle->mFlexWrap, |
| mCssStyle->mAlignItems, |
| childRight - child->mLayoutResult->mLayoutSize.width, |
| childBottom - child->mLayoutResult->mLayoutSize.height, |
| childRight, |
| childBottom, |
| absoulteItem); |
| } else { |
| layoutSingleChildHorizontal(child, |
| flexLine, |
| mCssStyle->mFlexWrap, |
| mCssStyle->mAlignItems, |
| childLeft, |
| childBottom - child->mLayoutResult->mLayoutSize.height, |
| childLeft + child->mLayoutResult->mLayoutSize.width, |
| childBottom, |
| absoulteItem); |
| } |
| } else { |
| if (isRtl) { |
| layoutSingleChildHorizontal(child, flexLine, mCssStyle->mFlexWrap, mCssStyle->mAlignItems, |
| childRight - child->mLayoutResult->mLayoutSize.width, childTop, |
| childRight, childTop + child->mLayoutResult->mLayoutSize.height, |
| absoulteItem); |
| } else { |
| layoutSingleChildHorizontal(child, flexLine, mCssStyle->mFlexWrap, mCssStyle->mAlignItems, |
| childLeft, childTop, |
| childLeft + child->mLayoutResult->mLayoutSize.width, |
| childTop + child->mLayoutResult->mLayoutSize.height, |
| absoulteItem); |
| } |
| } |
| } |
| |
| /** |
| * Place a single View when the layout direction is horizontal ({@link #mFlexDirection} is |
| * either {@link WXCoreFlexDirection #WXCore_Flex_Direction_Row} or |
| * {@link WXCoreFlexDirection #WXCore_Flex_Direction_Row_REVERSE}). |
| * |
| * @param node the View to be placed |
| * @param flexLine the {@link WXCoreFlexLine} where the View belongs to |
| * @param flexWrap the flex wrap attribute of this BasicLayoutNode |
| * @param alignItems the align items attribute of this BasicLayoutNode |
| * @param left the mStyleLeft position of the View, which the View's margin is already taken |
| * into account |
| * @param top the mStyleTop position of the flex line where the View belongs to. The actual |
| * View's mStyleTop position is shifted depending on the flexWrap and alignItems |
| * attributes |
| * @param right the mStyleRight position of the View, which the View's margin is already taken |
| * into account |
| * @param bottom the mStyleBottom position of the flex line where the View belongs to. The actual |
| * View's mStyleBottom position is shifted depending on the flexWrap and alignItems |
| * attributes |
| */ |
| void WXCoreLayoutNode::layoutSingleChildHorizontal(WXCoreLayoutNode *const node, WXCoreFlexLine* const flexLine, |
| const WXCoreFlexWrap flexWrap, WXCoreAlignItems alignItems, |
| const float left, const float top, const float right, const float bottom, const bool absoluteFlexItem) { |
| if (node->mCssStyle->mAlignSelf != kAlignSelfAuto) { |
| // Expecting the values for alignItems and alignSelf match except for ALIGN_SELF_AUTO. |
| // Assigning the alignSelf value as alignItems should work. |
| alignItems = static_cast<WXCoreAlignItems>(node->mCssStyle->mAlignSelf); |
| } |
| |
| float crossSize = flexLine->mCrossSize; |
| |
| switch (alignItems) { |
| case kAlignItemsFlexStart: |
| case kAlignItemsStretch: |
| if (flexWrap != kWrapReverse) { |
| node->layout(left, top + node->getMarginTop(), right, bottom + node->getMarginTop(), absoluteFlexItem); |
| } else { |
| node->layout(left, top - node->getMarginBottom(), right, bottom - node->getMarginBottom(), absoluteFlexItem); |
| } |
| break; |
| case kAlignItemsFlexEnd: |
| if (flexWrap != kWrapReverse) { |
| node->layout(left, |
| top + crossSize - node->mLayoutResult->mLayoutSize.height - node->getMarginBottom(), |
| right, top + crossSize - node->getMarginBottom(), absoluteFlexItem); |
| } else { |
| // If the flexWrap == FLEX_WRAP_WRAP_REVERSE, the direction of the |
| // flexEnd is flipped (from mStyleTop to mStyleBottom). |
| node->layout(left, top - crossSize + node->mLayoutResult->mLayoutSize.height + node->getMarginTop(), |
| right, bottom - crossSize + node->mLayoutResult->mLayoutSize.height + node->getMarginTop(), absoluteFlexItem); |
| } |
| break; |
| case kAlignItemsCenter: |
| float topFromCrossAxis = (crossSize - node->mLayoutResult->mLayoutSize.height |
| + node->getMarginTop() - node->getMarginBottom()) / 2; |
| if (flexWrap != kWrapReverse) { |
| node->layout(left, top + topFromCrossAxis, |
| right, top + topFromCrossAxis + node->mLayoutResult->mLayoutSize.height, absoluteFlexItem); |
| } else { |
| node->layout(left, top - topFromCrossAxis, |
| right, top - topFromCrossAxis + node->mLayoutResult->mLayoutSize.height, absoluteFlexItem); |
| } |
| break; |
| } |
| } |
| |
| /** |
| * Sub method for {@link WXCoreLayoutNode #onLayout(int, int, int, int)} when the |
| * {@link #mFlexDirection} is either {@link WXCoreFlexDirection #WXCore_Flex_Direction_Column} or |
| * {@link WXCoreFlexDirection #WXCore_Flex_Direction_Column_Reverse}. |
| * |
| * @param isRtl {@code true} if the horizontal layout direction is mStyleRight to mStyleLeft, |
| * {@code false} |
| * otherwise |
| * @param fromBottomToTop {@code true} if the layout direction is mStyleBottom to mStyleTop, {@code false} |
| * otherwise |
| * @param left the mStyleLeft position of this View |
| * @param top the mStyleTop position of this View |
| * @param right the mStyleRight position of this View |
| * @param bottom the mStyleBottom position of this View |
| */ |
| void |
| WXCoreLayoutNode::layoutVertical(const bool isRtl, |
| const bool fromBottomToTop, |
| const float left, const float top, |
| const float right, const float bottom, |
| WXCoreLayoutNode *const absoulteItem, |
| WXCoreFlexLine *const flexLine) { |
| float childLeft = getPaddingLeft() + getBorderWidthLeft(); |
| Index currentViewIndex = 0; |
| float width = right - left; |
| float height = bottom - top; |
| |
| // childRight is used if the mFlexWrap is FLEX_WRAP_WRAP_REVERSE otherwise |
| // childLeft is used to align the horizontal position of the children views. |
| float childRight = width - getPaddingRight() - getBorderWidthRight(); |
| |
| // Use float to reduce the round error that may happen in when justifyContent == |
| // SPACE_BETWEEN or SPACE_AROUND |
| float childTop, childBottom; |
| const std::vector<WXCoreFlexLine*> &lines = (flexLine == nullptr? mFlexLines: std::vector<WXCoreFlexLine*>{flexLine}); |
| |
| for (WXCoreFlexLine *flexLine : lines) { |
| float spaceBetweenItem = 0.f; |
| layoutFlexlineVertical(height, flexLine, childTop, childBottom, spaceBetweenItem); |
| spaceBetweenItem = std::max(spaceBetweenItem, 0.f); |
| if(absoulteItem == nullptr) { |
| for (Index j = 0; j < flexLine->mItemCount; j++) { |
| WXCoreLayoutNode *child = getChildAt(kNonBFC, currentViewIndex); |
| if (child == nullptr) { |
| continue; |
| } |
| layoutSingleChildVertical(isRtl, fromBottomToTop, false, |
| childLeft, childRight, flexLine, |
| child, childTop, childBottom); |
| childTop += child->mLayoutResult->mLayoutSize.height + spaceBetweenItem + child->getMarginBottom(); |
| childBottom -= child->mLayoutResult->mLayoutSize.height + spaceBetweenItem + child->getMarginTop(); |
| currentViewIndex++; |
| } |
| childLeft += flexLine->mCrossSize; |
| childRight -= flexLine->mCrossSize; |
| } |
| else{ |
| layoutSingleChildVertical(isRtl, fromBottomToTop, true, |
| childLeft, childRight, flexLine, |
| absoulteItem, childTop, childBottom); |
| } |
| } |
| } |
| |
| void WXCoreLayoutNode::layoutFlexlineVertical(const float height, |
| const WXCoreFlexLine *const flexLine, |
| float &childTop, |
| float &childBottom, |
| float &spaceBetweenItem) const { |
| Index visibleCount, visibleItem; |
| float denominator; |
| switch (mCssStyle->mJustifyContent) { |
| case kJustifyFlexEnd: |
| childTop = height - flexLine->mMainSize - getPaddingBottom() - getBorderWidthBottom(); |
| childBottom = height - getPaddingTop() - getBorderWidthTop(); |
| break; |
| case kJustifyCenter: |
| childTop = (height - flexLine->mMainSize - mCssStyle->sumPaddingBorderOfEdge(kBottom) |
| + mCssStyle->sumPaddingBorderOfEdge(kTop)) / 2; |
| childBottom = childTop + flexLine->mMainSize; |
| break; |
| case kJustifySpaceAround: |
| visibleCount = flexLine->mItemCount; |
| if (visibleCount != 0) { |
| spaceBetweenItem = (height - flexLine->mMainSize - sumPaddingBorderAlongAxis(this, false)) |
| / visibleCount; |
| } |
| childTop = getPaddingTop() + getBorderWidthTop() + spaceBetweenItem / 2; |
| childBottom = height - getPaddingBottom() - getBorderWidthBottom() - spaceBetweenItem / 2; |
| break; |
| case kJustifySpaceBetween: |
| childTop = getPaddingTop() + getBorderWidthTop(); |
| visibleItem = flexLine->mItemCount; |
| denominator = visibleItem != 1 ? visibleItem - 1 : 1.f; |
| spaceBetweenItem = |
| (height - flexLine->mMainSize - sumPaddingBorderAlongAxis(this, false)) / denominator; |
| childBottom = height - getPaddingBottom() - getBorderWidthBottom(); |
| break; |
| case kJustifyFlexStart: |
| default: |
| childTop = getPaddingTop() + getBorderWidthTop(); |
| childBottom = height - getPaddingBottom() - getBorderWidthBottom(); |
| break; |
| } |
| } |
| |
| void WXCoreLayoutNode::layoutSingleChildVertical(const bool isRtl, const bool fromBottomToTop, |
| const bool absoluteFlexItem, |
| const float childLeft, const float childRight, |
| WXCoreFlexLine *const flexLine, |
| WXCoreLayoutNode *const child, |
| float &childTop, float &childBottom) { |
| childTop += child->getMarginTop(); |
| childBottom -= child->getMarginBottom(); |
| if (isRtl) { |
| if (fromBottomToTop) { |
| layoutSingleChildVertical(child, flexLine, true, |
| mCssStyle->mAlignItems, |
| childRight - child->mLayoutResult->mLayoutSize.width, |
| childBottom - child->mLayoutResult->mLayoutSize.height, |
| childRight, childBottom, absoluteFlexItem); |
| } else { |
| layoutSingleChildVertical(child, flexLine, true, mCssStyle->mAlignItems, |
| childRight - child->mLayoutResult->mLayoutSize.width, childTop, |
| childRight, childTop + child->mLayoutResult->mLayoutSize.height, |
| absoluteFlexItem); |
| } |
| } else { |
| if (fromBottomToTop) { |
| layoutSingleChildVertical(child, flexLine, false, mCssStyle->mAlignItems, |
| childLeft, childBottom - child->mLayoutResult->mLayoutSize.height, |
| childLeft + child->mLayoutResult->mLayoutSize.width, childBottom, |
| absoluteFlexItem); |
| } else { |
| layoutSingleChildVertical(child, flexLine, false, mCssStyle->mAlignItems, |
| childLeft, childTop, |
| childLeft + child->mLayoutResult->mLayoutSize.width, |
| childTop + child->mLayoutResult->mLayoutSize.height, |
| absoluteFlexItem); |
| } |
| } |
| } |
| |
| /** |
| * Place a single View when the layout direction is vertical ({@link #mFlexDirection} is |
| * either {@link WXCoreFlexDirection #WXCore_Flex_Direction_Column} or |
| * {@link WXCoreFlexDirection #WXCore_Flex_Direction_Column_Reverse}). |
| * |
| * @param node the View to be placed |
| * @param flexLine the {@link FlexLine} where the View belongs to |
| * @param isRtl {@code true} if the layout direction is mStyleRight to mStyleLeft, {@code false} |
| * otherwise |
| * @param alignItems the align items attribute of this BasicLayoutNode |
| * @param left the mStyleLeft position of the flex line where the View belongs to. The actual |
| * View's mStyleLeft position is shifted depending on the isRtl and alignItems |
| * attributes |
| * @param top the mStyleTop position of the View, which the View's margin is already taken |
| * into account |
| * @param right the mStyleRight position of the flex line where the View belongs to. The actual |
| * View's mStyleRight position is shifted depending on the isRtl and alignItems |
| * attributes |
| * @param bottom the mStyleBottom position of the View, which the View's margin is already taken |
| * into account |
| */ |
| void WXCoreLayoutNode::layoutSingleChildVertical(WXCoreLayoutNode* const node, WXCoreFlexLine* const flexLine, const bool isRtl, |
| WXCoreAlignItems alignItems, const float left, const float top, const float right, |
| const float bottom, const bool absoluteFlexItem) { |
| if (node->mCssStyle->mAlignSelf != kAlignSelfAuto) { |
| // Expecting the values for alignItems and alignSelf match except for ALIGN_SELF_AUTO. |
| // Assigning the alignSelf value as alignItems should work. |
| alignItems = static_cast<WXCoreAlignItems>(node->mCssStyle->mAlignSelf); |
| } |
| |
| float crossSize = flexLine->mCrossSize; |
| |
| switch (alignItems) { |
| case kAlignItemsFlexStart: |
| case kAlignItemsStretch: |
| if (!isRtl) { |
| node->layout(left + node->getMarginLeft(), top, right + node->getMarginLeft(), bottom, absoluteFlexItem); |
| } else { |
| node->layout(left - node->getMarginRight(), top, right - node->getMarginRight(), bottom, absoluteFlexItem); |
| } |
| break; |
| case kAlignItemsFlexEnd: |
| if (!isRtl) { |
| node->layout(left + crossSize - node->mLayoutResult->mLayoutSize.width - node->getMarginRight(), |
| top, right + crossSize - node->mLayoutResult->mLayoutSize.width - node->getMarginRight(), |
| bottom, absoluteFlexItem); |
| } else { |
| // If the flexWrap == FLEX_WRAP_WRAP_REVERSE, the direction of the |
| // flexEnd is flipped (from mStyleLeft to mStyleRight). |
| node->layout(left - crossSize + node->mLayoutResult->mLayoutSize.width + node->getMarginLeft(), top, |
| right - crossSize + node->mLayoutResult->mLayoutSize.width + node->getMarginLeft(), |
| bottom, absoluteFlexItem); |
| } |
| break; |
| case kAlignItemsCenter: |
| float leftFromCrossAxis = (crossSize - node->mLayoutResult->mLayoutSize.width |
| + node->getMarginLeft() |
| - node->getMarginRight()) / 2.f; |
| if (!isRtl) { |
| node->layout(left + leftFromCrossAxis, top, right + leftFromCrossAxis, bottom, absoluteFlexItem); |
| } else { |
| node->layout(left - leftFromCrossAxis, top, right - leftFromCrossAxis, bottom, absoluteFlexItem); |
| } |
| break; |
| } |
| } |
| } |
| |
| |
