diff --git a/frameworks/core/components_ng/pattern/flex/flex_layout_algorithm.cpp b/frameworks/core/components_ng/pattern/flex/flex_layout_algorithm.cpp index 28f6bc57b8f042a6b42ecdfd656e5dd7d60829d8..ca7c28e076da56721eedc6a7cd8f57647f0df5d5 100644 --- a/frameworks/core/components_ng/pattern/flex/flex_layout_algorithm.cpp +++ b/frameworks/core/components_ng/pattern/flex/flex_layout_algorithm.cpp @@ -313,7 +313,7 @@ bool FlexLayoutAlgorithm::AddElementIntoLayoutPolicyChildren(LayoutWrapper* layo CHECK_NULL_RETURN(childLayoutProperty, false); auto layoutPolicy = childLayoutProperty->GetLayoutPolicyProperty(); CHECK_NULL_RETURN(layoutPolicy, false); - if (!layoutPolicy.value().isMatch()) { + if (!layoutPolicy.value().IsMatch()) { return false; } layoutPolicyChildren_.emplace_back(child); diff --git a/frameworks/core/components_ng/pattern/relative_container/relative_container_layout_algorithm.cpp b/frameworks/core/components_ng/pattern/relative_container/relative_container_layout_algorithm.cpp index 55b384c60482a384af291e5b803c13e9e8e29ce5..243f073093b856698b33ad8bf6287ecfa77571ce 100644 --- a/frameworks/core/components_ng/pattern/relative_container/relative_container_layout_algorithm.cpp +++ b/frameworks/core/components_ng/pattern/relative_container/relative_container_layout_algorithm.cpp @@ -118,7 +118,7 @@ void RelativeContainerLayoutAlgorithm::Initialize(LayoutWrapper* layoutWrapper) idealSize.SetHeight(std::max(idealSize.Height().value_or(0.0f), layoutConstraint.value().minSize.Height())); } containerSizeWithoutPaddingBorder_ = idealSize.ConvertToSizeT(); - auto layoutPolicy = layoutWrapper->GetLayoutProperty()->GetLayoutPolicyProperty(); + auto layoutPolicy = relativeContainerLayoutProperty->GetLayoutPolicyProperty(); if (layoutPolicy.has_value()) { auto widthLayoutPolicy = layoutPolicy.value().widthLayoutPolicy_; auto heightLayoutPolicy = layoutPolicy.value().heightLayoutPolicy_; @@ -892,7 +892,7 @@ void RelativeContainerLayoutAlgorithm::Measure(LayoutWrapper* layoutWrapper) if (SystemProperties::GetDebugEnabled()) { pattern->SetTopologicalResult(RelativeContainerPattern::TopoListToString(renderList_)); } - + DetermineSelf(layoutWrapper); MeasureChild(layoutWrapper); MeasureChainWeight(layoutWrapper); MeasureSelf(layoutWrapper); @@ -901,6 +901,237 @@ void RelativeContainerLayoutAlgorithm::Measure(LayoutWrapper* layoutWrapper) ResetChildAlignRulesChanged(layoutWrapper); } +void RelativeContainerLayoutAlgorithm::DetermineSelf(LayoutWrapper* layoutWrapper) +{ + auto relativeContainerLayoutProperty = layoutWrapper->GetLayoutProperty(); + CHECK_NULL_VOID(relativeContainerLayoutProperty); + auto layoutPolicy = relativeContainerLayoutProperty->GetLayoutPolicyProperty(); + CHECK_NULL_VOID(layoutPolicy.has_value()); + if (!layoutPolicy.value().IsAdaptive()) { + return; + } + RectF relativeContainerRect(0, 0, 0, 0); + float rCWidth = 0.0f; + float rCHeight = 0.0f; + const auto &layoutConstraint = relativeContainerLayoutProperty->GetLayoutConstraint(); + for (const auto &nodeName : renderList_) { + if (IsBarrier(nodeName)) { + MeasureBarrier(nodeName); + } + auto childConstraint = relativeContainerLayoutProperty->CreateChildConstraint(); + auto it = idNodeMap_.find(nodeName); + if (it == idNodeMap_.end()) { + continue; + } + auto childWrapper = it->second.layoutWrapper; + if (!childWrapper->IsActive()) { + childWrapper->Measure(childConstraint); + continue; + } + auto isWidthRelyOnContainer = IsUnionRelyOnContainer(LineDirection::HORIZONTAL, nodeName); + auto isHeightRelyOnContainer = IsUnionRelyOnContainer(LineDirection::VERTICAL, nodeName); + if (isWidthRelyOnContainer && isHeightRelyOnContainer && layoutPolicy.value().IsAllAdaptive()) { + continue; + } + if (!PreCalcChildSize(layoutWrapper, childWrapper, nodeName, childConstraint)) { + continue; + }; + if (!isWidthRelyOnContainer) { + rCWidth = std::max(rCWidth, + recordOffsetMap_[nodeName].GetX() + childWrapper->GetGeometryNode()->GetMarginFrameSize().Width()); + } + if (!isHeightRelyOnContainer) { + rCHeight = std::max(rCHeight, + recordOffsetMap_[nodeName].GetY() + childWrapper->GetGeometryNode()->GetMarginFrameSize().Height()); + } + RectF tempRect(0, 0, rCWidth, rCHeight); + relativeContainerRect = relativeContainerRect.CombineRectT(tempRect); + ACE_SCOPED_TRACE("relativeContainerRect [%s]", relativeContainerRect.ToString().c_str()); + } + PreCalcContainerSize(layoutWrapper, relativeContainerRect, layoutPolicy.value(), layoutConstraint); +} + +bool RelativeContainerLayoutAlgorithm::PreCalcChildSize(LayoutWrapper* layoutWrapper, + RefPtr childWrapper, const std::string& nodeName, LayoutConstraintF& childConstraint) +{ + auto childLayoutProp = childWrapper->GetLayoutProperty(); + const auto &flexItem = childLayoutProp->GetFlexItemProperty(); + if (!flexItem) { + childWrapper->Measure(childConstraint); + recordOffsetMap_[nodeName] = OffsetF(0.0f, 0.0f); + return true; + } else if (!flexItem->HasAlignRules()) { + childWrapper->Measure(childConstraint); + recordOffsetMap_[nodeName] = OffsetF(0.0f, 0.0f); + return true; + } else { + flexItem->ClearAlignValue(); + auto alignRules = flexItem->GetAlignRulesValue(); + auto frameNode = childWrapper->GetHostNode(); + if (!alignRules.empty() && frameNode && frameNode->GetLayoutProperty()) { + // when child has alignRules and position, the position property do not work. + frameNode->GetLayoutProperty()->SetUsingPosition(false); + } + CalcSizeParam(layoutWrapper, nodeName); + CalcOffsetParam(layoutWrapper, nodeName); + return true; + } + + if (childLayoutProp->GetVisibility() == VisibleType::GONE) { + ACE_SCOPED_TRACE("VisibleType::GONE"); + return false; + } + return true; +} + +void RelativeContainerLayoutAlgorithm::PreCalcContainerSize(LayoutWrapper* layoutWrapper, RectF relativeContainerRect, + LayoutPolicyProperty layoutPolicy, const std::optional& layoutConstraint) +{ + const auto maxSize = layoutConstraint->maxSize; + const auto minSize = layoutConstraint->minSize; + auto widthLayoutPolicy = layoutPolicy.widthLayoutPolicy_.value_or(LayoutCalPolicy::NO_MATCH); + auto heightLayoutPolicy = layoutPolicy.heightLayoutPolicy_.value_or(LayoutCalPolicy::NO_MATCH); + relativeContainerRect = + relativeContainerRect.IntersectRectT(RectF(0.0f, 0.0f, Infinity(), Infinity())); + if (widthLayoutPolicy == LayoutCalPolicy::FIX_AT_IDEAL_SIZE) { + containerSizeWithoutPaddingBorder_.SetWidth(relativeContainerRect.Width()); + layoutWrapper->GetGeometryNode()->SetFrameSize(SizeF(relativeContainerRect.Width() + padding_.Width(), + layoutWrapper->GetGeometryNode()->GetFrameSize().Height())); + } else if (widthLayoutPolicy == LayoutCalPolicy::WRAP_CONTENT) { + relativeContainerRect.Constrain( + RectF(0.0f, 0.0f, maxSize.Width() - padding_.Width(), relativeContainerRect.Height())); + relativeContainerRect.Constrain(RectF(0.0f, 0.0f, minSize.Width(), relativeContainerRect.Height())); + containerSizeWithoutPaddingBorder_.SetWidth(relativeContainerRect.Width()); + layoutWrapper->GetGeometryNode()->SetFrameSize(SizeF(relativeContainerRect.Width() + padding_.Width(), + layoutWrapper->GetGeometryNode()->GetFrameSize().Height())); + } + if (heightLayoutPolicy == LayoutCalPolicy::FIX_AT_IDEAL_SIZE) { + containerSizeWithoutPaddingBorder_.SetHeight(relativeContainerRect.Height()); + layoutWrapper->GetGeometryNode()->SetFrameSize(SizeF(layoutWrapper->GetGeometryNode()->GetFrameSize().Width(), + relativeContainerRect.Height() + padding_.Height())); + } else if (heightLayoutPolicy == LayoutCalPolicy::WRAP_CONTENT) { + containerSizeWithoutPaddingBorder_.SetHeight(relativeContainerRect.Height()); + relativeContainerRect.Constrain( + RectF(0.0f, 0.0f, relativeContainerRect.Width(), maxSize.Height() - padding_.Height())); + relativeContainerRect.Constrain(RectF(0.0f, 0.0f, relativeContainerRect.Width(), minSize.Height())); + layoutWrapper->GetGeometryNode()->SetFrameSize(SizeF(layoutWrapper->GetGeometryNode()->GetFrameSize().Width(), + relativeContainerRect.Height() + padding_.Height())); + } + ResetCalculatedChain(); + ACE_SCOPED_TRACE("PreCalcContainerSize: [%s]", layoutWrapper->GetGeometryNode()->GetFrameSize().ToString().c_str()); +} + +bool RelativeContainerLayoutAlgorithm::MeasureWrapContent( + const std::string& nodeName, LayoutConstraintF& childConstraint) +{ + auto it = idNodeMap_.find(nodeName); + if (it == idNodeMap_.end()) { + ACE_LAYOUT_SCOPED_TRACE("Id %s not in map", nodeName.c_str()); + return false; + } + auto childWrapper = it->second.layoutWrapper; + auto childLayoutProperty = childWrapper->GetLayoutProperty(); + if (childLayoutProperty) { + auto layoutPolicy = childLayoutProperty->GetLayoutPolicyProperty(); + if (layoutPolicy.has_value() && layoutPolicy.value().IsWidthMatch()) { + childConstraint.parentIdealSize.SetWidth(containerSizeWithoutPaddingBorder_.Width()); + } + if (layoutPolicy.has_value() && layoutPolicy.value().IsHeightMatch()) { + childConstraint.parentIdealSize.SetHeight(containerSizeWithoutPaddingBorder_.Height()); + } + } + if (!childWrapper->IsActive()) { + childWrapper->Measure(childConstraint); + return false; + } + if (!childLayoutProperty || !childLayoutProperty->GetFlexItemProperty()) { + childWrapper->Measure(childConstraint); + recordOffsetMap_[nodeName] = OffsetF(0.0f, 0.0f); + return false; + } + const auto &flexItem = childLayoutProperty->GetFlexItemProperty(); + if (!flexItem->HasAlignRules()) { + childWrapper->Measure(childConstraint); + recordOffsetMap_[nodeName] = OffsetF(0.0f, 0.0f); + return false; + } + flexItem->ClearAlignValue(); + auto alignRules = flexItem->GetAlignRulesValue(); + auto frameNode = childWrapper->GetHostNode(); + if (!alignRules.empty() && frameNode && frameNode->GetLayoutProperty()) { + // when child has alignRules and position, the position property do not work. + frameNode->GetLayoutProperty()->SetUsingPosition(false); + } + return true; +} + +void RelativeContainerLayoutAlgorithm::InsertToVerticalReliedOnMap( + const std::string& anchorName, const std::string& nodeName) +{ + auto iter = verticalRelyMap_.find(nodeName); + if (iter == verticalRelyMap_.end()) { + std::set anchorList; + anchorList.insert(anchorName); + verticalRelyMap_[nodeName] = anchorList; + return; + } + iter->second.insert(anchorName); +} + +void RelativeContainerLayoutAlgorithm::InsertToHorizontalReliedOnMap( + const std::string& anchorName, const std::string& nodeName) +{ + auto iter = horizontalRelyMap_.find(nodeName); + if (iter == horizontalRelyMap_.end()) { + std::set anchorList; + anchorList.insert(anchorName); + horizontalRelyMap_[nodeName] = anchorList; + return; + } + iter->second.insert(anchorName); +} + +bool RelativeContainerLayoutAlgorithm::IsUnionRelyOnContainer(LineDirection direction, const std::string& id) +{ + if (direction == LineDirection::HORIZONTAL) { + auto iter = horizontalRelyMap_.find(id); + if (iter == horizontalRelyMap_.end()) { + return false; + } + for (const auto &element : iter->second) { + if (IsAnchorContainer(element) || IsUnionRelyOnContainer(LineDirection::HORIZONTAL, element)) { + return true; + } + } + return false; + } else { + auto iter = verticalRelyMap_.find(id); + if (iter == verticalRelyMap_.end()) { + return false; + } + for (const auto &element : iter->second) { + if (IsAnchorContainer(element) || IsUnionRelyOnContainer(LineDirection::VERTICAL, element)) { + return true; + } + } + return false; + } +} + +void RelativeContainerLayoutAlgorithm::ResetCalculatedChain() +{ + CHECK_NULL_VOID(versionGreatorOrEqualToEleven_); + CHECK_NULL_VOID(!horizontalChains_.empty()); + for (auto &horizontalChain : horizontalChains_) { + horizontalChain.second.remainingSpace = 0.0f; + horizontalChain.second.isCalculated = false; + } + for (auto &verticalChain : verticalChains_) { + verticalChain.second.remainingSpace = 0.0f; + verticalChain.second.isCalculated = false; + } +} + void RelativeContainerLayoutAlgorithm::MeasureChainWeight(LayoutWrapper* layoutWrapper) { CHECK_NULL_VOID(isChainWeightMode_); @@ -921,10 +1152,10 @@ void RelativeContainerLayoutAlgorithm::MeasureChainWeight(LayoutWrapper* layoutW } auto childConstraint = relativeContainerLayoutProperty->CreateChildConstraint(); auto layoutPolicy = childLayoutProperty->GetLayoutPolicyProperty(); - if (layoutPolicy.has_value() && layoutPolicy.value().isWidthMatch()) { + if (layoutPolicy.has_value() && layoutPolicy.value().IsWidthMatch()) { childConstraint.parentIdealSize.SetWidth(containerSizeWithoutPaddingBorder_.Width()); } - if (layoutPolicy.has_value() && layoutPolicy.value().isHeightMatch()) { + if (layoutPolicy.has_value() && layoutPolicy.value().IsHeightMatch()) { childConstraint.parentIdealSize.SetHeight(containerSizeWithoutPaddingBorder_.Height()); } const auto& flexItem = childLayoutProperty->GetFlexItemProperty(); @@ -1022,45 +1253,10 @@ void RelativeContainerLayoutAlgorithm::MeasureChild(LayoutWrapper* layoutWrapper if (IsBarrier(nodeName)) { MeasureBarrier(nodeName); } - auto it = idNodeMap_.find(nodeName); - if (it == idNodeMap_.end()) { - ACE_LAYOUT_SCOPED_TRACE("Id %s not in map", nodeName.c_str()); - continue; - } - auto childWrapper = it->second.layoutWrapper; auto childConstraint = relativeContainerLayoutProperty->CreateChildConstraint(); - auto childLayoutProperty = childWrapper->GetLayoutProperty(); - if (childLayoutProperty) { - auto layoutPolicy = childLayoutProperty->GetLayoutPolicyProperty(); - if (layoutPolicy.has_value() && layoutPolicy.value().isWidthMatch()) { - childConstraint.parentIdealSize.SetWidth(containerSizeWithoutPaddingBorder_.Width()); - } - if (layoutPolicy.has_value() && layoutPolicy.value().isHeightMatch()) { - childConstraint.parentIdealSize.SetHeight(containerSizeWithoutPaddingBorder_.Height()); - } - } - if (!childWrapper->IsActive()) { - childWrapper->Measure(childConstraint); - continue; - } - if (!childLayoutProperty || !childLayoutProperty->GetFlexItemProperty()) { - childWrapper->Measure(childConstraint); - recordOffsetMap_[nodeName] = OffsetF(0.0f, 0.0f); + if (!MeasureWrapContent(nodeName, childConstraint)) { continue; } - const auto& flexItem = childLayoutProperty->GetFlexItemProperty(); - if (!flexItem->HasAlignRules()) { - childWrapper->Measure(childConstraint); - recordOffsetMap_[nodeName] = OffsetF(0.0f, 0.0f); - continue; - } - flexItem->ClearAlignValue(); - auto alignRules = flexItem->GetAlignRulesValue(); - auto frameNode = childWrapper->GetHostNode(); - if (!alignRules.empty() && frameNode && frameNode->GetLayoutProperty()) { - // when child has alignRules and position, the position property do not work. - frameNode->GetLayoutProperty()->SetUsingPosition(false); - } CalcSizeParam(layoutWrapper, nodeName); CalcOffsetParam(layoutWrapper, nodeName); } @@ -1185,12 +1381,16 @@ bool RelativeContainerLayoutAlgorithm::IsAlignRuleInChain(const AlignDirection& IsNodeInHorizontalChain(nodeName, chainName)) { GetDependencyRelationshipInChain(horizontalChains_[chainName].anchorHead.anchor, nodeName); GetDependencyRelationshipInChain(horizontalChains_[chainName].anchorTail.anchor, nodeName); + InsertToHorizontalReliedOnMap(horizontalChains_[chainName].anchorHead.anchor, nodeName); + InsertToHorizontalReliedOnMap(horizontalChains_[chainName].anchorTail.anchor, nodeName); return true; } if ((direction == AlignDirection::TOP || direction == AlignDirection::BOTTOM) && IsNodeInVerticalChain(nodeName, chainName)) { GetDependencyRelationshipInChain(verticalChains_[chainName].anchorHead.anchor, nodeName); GetDependencyRelationshipInChain(verticalChains_[chainName].anchorTail.anchor, nodeName); + InsertToVerticalReliedOnMap(verticalChains_[chainName].anchorHead.anchor, nodeName); + InsertToVerticalReliedOnMap(verticalChains_[chainName].anchorTail.anchor, nodeName); return true; } return false; @@ -1212,8 +1412,8 @@ void RelativeContainerLayoutAlgorithm::GetDependencyRelationship() { for (const auto& mapItem : idNodeMap_) { auto childWrapper = mapItem.second.layoutWrapper; + auto childId = mapItem.second.id; const auto& flexItem = childWrapper->GetLayoutProperty()->GetFlexItemProperty(); - auto childHostNode = childWrapper->GetHostNode(); if (!flexItem || !flexItem->HasAlignRules()) { continue; } @@ -1221,25 +1421,31 @@ void RelativeContainerLayoutAlgorithm::GetDependencyRelationship() if (IsAlignRuleInChain(alignRule.first, mapItem.first)) { continue; } - - if (IsBarrier(alignRule.second.anchor)) { - InsertToReliedOnMap(alignRule.second.anchor, mapItem.second.id); + auto anchor = alignRule.second.anchor; + if (IsBarrier(anchor)) { + InsertToReliedOnMap(anchor, childId); continue; } - - if (IsAnchorContainer(alignRule.second.anchor) || IsGuideline(alignRule.second.anchor)) { + if (IsRelyOnContainer(anchor)) { if (static_cast(alignRule.first) < HORIZONTAL_DIRECTION_RANGE) { isHorizontalRelyOnContainer_ = true; + InsertToHorizontalReliedOnMap(anchor, childId); } else if (static_cast(alignRule.first) < VERTICAL_DIRECTION_RANGE) { isVerticalRelyOnContainer_ = true; + InsertToVerticalReliedOnMap(anchor, childId); } continue; } - auto it = idNodeMap_.find(alignRule.second.anchor); + if (static_cast(alignRule.first) < HORIZONTAL_DIRECTION_RANGE) { + InsertToHorizontalReliedOnMap(anchor, childId); + } else if (static_cast(alignRule.first) < VERTICAL_DIRECTION_RANGE + && static_cast(alignRule.first) >= HORIZONTAL_DIRECTION_RANGE) { + InsertToVerticalReliedOnMap(anchor, childId); + } + auto it = idNodeMap_.find(anchor); if (it == idNodeMap_.end()) { continue; } - if (!AceApplicationInfo::GetInstance().GreatOrEqualTargetAPIVersion(PlatformVersion::VERSION_TWELVE)) { auto anchorChildWrapper = it->second.layoutWrapper; auto anchorChildLayoutProp = anchorChildWrapper->GetLayoutProperty(); @@ -1250,7 +1456,7 @@ void RelativeContainerLayoutAlgorithm::GetDependencyRelationship() } // if a is the anchor of b, then reliedOnMap should place for the first appearance // of key a. Otherwise b will be inserted into the existing value list - InsertToReliedOnMap(alignRule.second.anchor, mapItem.second.id); + InsertToReliedOnMap(anchor, childId); } } GetDependencyRelationshipInBarrier(); @@ -1412,10 +1618,10 @@ void RelativeContainerLayoutAlgorithm::CalcSizeParam(LayoutWrapper* layoutWrappe CHECK_NULL_VOID(relativeContainerLayoutProperty); auto childConstraint = relativeContainerLayoutProperty->CreateChildConstraint(); auto layoutPolicy = childLayoutProperty->GetLayoutPolicyProperty(); - if (layoutPolicy.has_value() && layoutPolicy.value().isWidthMatch()) { + if (layoutPolicy.has_value() && layoutPolicy.value().IsWidthMatch()) { childConstraint.parentIdealSize.SetWidth(containerSizeWithoutPaddingBorder_.Width()); } - if (layoutPolicy.has_value() && layoutPolicy.value().isHeightMatch()) { + if (layoutPolicy.has_value() && layoutPolicy.value().IsHeightMatch()) { childConstraint.parentIdealSize.SetHeight(containerSizeWithoutPaddingBorder_.Height()); } auto alignRules = childWrapper->GetLayoutProperty()->GetFlexItemProperty()->GetAlignRulesValue(); @@ -1827,6 +2033,11 @@ bool RelativeContainerLayoutAlgorithm::IsGuidelineOrBarrier(const std::string& i return IsGuideline(id) || IsBarrier(id); } +bool RelativeContainerLayoutAlgorithm::IsRelyOnContainer(const std::string& id) +{ + return IsAnchorContainer(id) || IsGuideline(id); +} + float RelativeContainerLayoutAlgorithm::GetOriginMarginLeft( TextDirection textDirection, const std::unique_ptr& marginProp) { diff --git a/frameworks/core/components_ng/pattern/relative_container/relative_container_layout_algorithm.h b/frameworks/core/components_ng/pattern/relative_container/relative_container_layout_algorithm.h index 2634ddaf7fd7c0bc960bba84e443404198502cd6..825656676a058f650f82b50354517a8cf716b5a7 100644 --- a/frameworks/core/components_ng/pattern/relative_container/relative_container_layout_algorithm.h +++ b/frameworks/core/components_ng/pattern/relative_container/relative_container_layout_algorithm.h @@ -147,6 +147,17 @@ private: void UpdateSizeWhenChildrenEmpty(LayoutWrapper* layoutWrapper); bool IsAnchorLegal(const std::string& anchorName); void MeasureChild(LayoutWrapper* layoutWrapper); + void DetermineSelf(LayoutWrapper* layoutWrapper); + bool MeasureWrapContent(const std::string& nodeName, LayoutConstraintF& childConstraint); + void InsertToVerticalReliedOnMap(const std::string& anchorName, const std::string& nodeName); + void InsertToHorizontalReliedOnMap(const std::string& anchorName, const std::string& nodeName); + bool IsUnionRelyOnContainer(LineDirection direction, const std::string& id); + void ResetCalculatedChain(); + void PreCalcContainerSize(LayoutWrapper* layoutWrapper, RectF relativeContainerRect, + LayoutPolicyProperty layoutPolicy, const std::optional& layoutConstraint); + bool PreCalcChildSize(LayoutWrapper* layoutWrapper, RefPtr childWrapper, const std::string& nodeName, + LayoutConstraintF& childConstraint); + bool IsRelyOnContainer(const std::string& id); void MeasureChainWeight(LayoutWrapper* layoutWrapper); void InitRemainingSpace(ChainParam& chainParam, LineDirection direction); BarrierDirection BarrierDirectionRtl(BarrierDirection barrierDirection); @@ -160,6 +171,8 @@ private: bool isVerticalRelyOnContainer_ = false; bool isChainWeightMode_ = false; std::list renderList_; + std::unordered_map> horizontalRelyMap_; + std::unordered_map> verticalRelyMap_; std::unordered_map idNodeMap_; std::unordered_map incomingDegreeMap_; std::unordered_map> reliedOnMap_; diff --git a/frameworks/core/components_ng/property/layout_policy_property.h b/frameworks/core/components_ng/property/layout_policy_property.h index 163a3312abb7ca6c5454c1c7dd17bc328afd02dc..2615ddb77957ea348255e9e73876decd3d135c8d 100644 --- a/frameworks/core/components_ng/property/layout_policy_property.h +++ b/frameworks/core/components_ng/property/layout_policy_property.h @@ -57,38 +57,63 @@ struct LayoutPolicyProperty { std::optional widthLayoutPolicy_; std::optional heightLayoutPolicy_; - bool isWidthAdaptive() + bool IsWidthWrap() { - return widthLayoutPolicy_.has_value() && (widthLayoutPolicy_.value() == LayoutCalPolicy::WRAP_CONTENT || - widthLayoutPolicy_.value() == LayoutCalPolicy::FIX_AT_IDEAL_SIZE); + return widthLayoutPolicy_.has_value() && widthLayoutPolicy_.value() == LayoutCalPolicy::WRAP_CONTENT; } - bool isHeightAdaptive() + bool IsHeightWrap() { - return heightLayoutPolicy_.has_value() && - (heightLayoutPolicy_.value() == LayoutCalPolicy::WRAP_CONTENT || - heightLayoutPolicy_.value() == LayoutCalPolicy::FIX_AT_IDEAL_SIZE); + return heightLayoutPolicy_.has_value() && heightLayoutPolicy_.value() == LayoutCalPolicy::WRAP_CONTENT; } - bool isAdaptive() + bool IsWidthFix() { - return isWidthAdaptive() || isHeightAdaptive(); + return widthLayoutPolicy_.has_value() && widthLayoutPolicy_.value() == LayoutCalPolicy::FIX_AT_IDEAL_SIZE; } - bool isWidthMatch() + bool IsHeightFix() + { + return heightLayoutPolicy_.has_value() && heightLayoutPolicy_.value() == LayoutCalPolicy::FIX_AT_IDEAL_SIZE; + } + bool IsWrap() + { + return IsWidthWrap() || IsHeightWrap(); + } + bool IsFix() + { + return IsWidthFix() || IsHeightFix(); + } + bool IsWidthMatch() { return widthLayoutPolicy_.has_value() && widthLayoutPolicy_.value() == LayoutCalPolicy::MATCH_PARENT; } - bool isHeightMatch() + bool IsHeightMatch() { return heightLayoutPolicy_.has_value() && heightLayoutPolicy_.value() == LayoutCalPolicy::MATCH_PARENT; } - bool isMatch() + bool IsMatch() + { + return IsWidthMatch() || IsHeightMatch(); + } + bool IsAllMatch() + { + return IsWidthMatch() && IsHeightMatch(); + } + bool IsWidthAdaptive() + { + return IsWidthWrap() || IsWidthFix(); + } + bool IsHeightAdaptive() + { + return IsHeightWrap() || IsHeightFix(); + } + bool IsAdaptive() { - return isWidthMatch() || isHeightMatch(); + return IsWidthAdaptive() || IsHeightAdaptive(); } - bool isAllMatch() + bool IsAllAdaptive() { - return isWidthMatch() && isHeightMatch(); + return IsWidthAdaptive() && IsHeightAdaptive(); } }; } // namespace OHOS::Ace::NG -#endif // FOUNDATION_ACE_FRAMEWORKS_COMPONENTS_NG_LAYOUT_POLICY_PROPERTY_H +#endif // FOUNDATION_ACE_FRAMEWORKS_COMPONENTS_NG_LAYOUT_POLICY_PROPERTY_H \ No newline at end of file