DaddyFrosty/yoga
1
0
Fork 0
Code Issues 96 Pull Requests 31 Actions Packages Projects Releases 33 Wiki Activity

Rename ambiguous getLeading/Trailing... functions in Node.cpp (#1424)

Browse Source 
Summary:
X-link: https://github.com/facebook/react-native/pull/41018

Pull Request resolved: https://github.com/facebook/yoga/pull/1424

See D50344874

Reviewed By: NickGerleman

Differential Revision: D50344874

fbshipit-source-id: 32fc35df674eb854c682a5e387c031a94c1c4f68
This commit is contained in:
Joe Vilches
2023-10-17 20:30:16 -07:00
committed by Facebook GitHub Bot
parent bab6b43683
commit e17005960f
4 changed files with 126 additions and 124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
yoga/algorithm/BoundAxis.h
View File

@@ -21,8 +21,8 @@ inline float paddingAndBorderForAxis(
const yoga::Node* const node, const yoga::Node* const node,
const FlexDirection axis, const FlexDirection axis,
const float widthSize) { const float widthSize) {
return node->getLeadingPaddingAndBorder(axis, widthSize) + return node->getFlexStartPaddingAndBorder(axis, widthSize) +
node->getTrailingPaddingAndBorder(axis, widthSize); node->getFlexEndPaddingAndBorder(axis, widthSize);
} }
inline FloatOptional boundAxisWithinMinAndMax( inline FloatOptional boundAxisWithinMinAndMax(

152
yoga/algorithm/CalculateLayout.cpp
View File

@@ -343,13 +343,13 @@ static void layoutAbsoluteChild(
} else { } else {
// If the child doesn't have a specified width, compute the width based on // If the child doesn't have a specified width, compute the width based on
// the left/right offsets if they're defined. // the left/right offsets if they're defined.
if (child->isLeadingPositionDefined(FlexDirection::Row) && if (child->isFlexStartPositionDefined(FlexDirection::Row) &&
child->isTrailingPosDefined(FlexDirection::Row)) { child->isFlexEndPositionDefined(FlexDirection::Row)) {
childWidth = node->getLayout().measuredDimension(Dimension::Width) - childWidth = node->getLayout().measuredDimension(Dimension::Width) -
(node->getLeadingBorder(FlexDirection::Row) + (node->getFlexStartBorder(FlexDirection::Row) +
node->getTrailingBorder(FlexDirection::Row)) - node->getFlexEndBorder(FlexDirection::Row)) -
(child->getLeadingPosition(FlexDirection::Row, width) + (child->getFlexStartPosition(FlexDirection::Row, width) +
child->getTrailingPosition(FlexDirection::Row, width)); child->getFlexEndPosition(FlexDirection::Row, width));
childWidth = childWidth =
boundAxis(child, FlexDirection::Row, childWidth, width, width); boundAxis(child, FlexDirection::Row, childWidth, width, width);
} }
@@ -363,13 +363,13 @@ static void layoutAbsoluteChild(
} else { } else {
// If the child doesn't have a specified height, compute the height based on // If the child doesn't have a specified height, compute the height based on
// the top/bottom offsets if they're defined. // the top/bottom offsets if they're defined.
if (child->isLeadingPositionDefined(FlexDirection::Column) && if (child->isFlexStartPositionDefined(FlexDirection::Column) &&
child->isTrailingPosDefined(FlexDirection::Column)) { child->isFlexEndPositionDefined(FlexDirection::Column)) {
childHeight = node->getLayout().measuredDimension(Dimension::Height) - childHeight = node->getLayout().measuredDimension(Dimension::Height) -
(node->getLeadingBorder(FlexDirection::Column) + (node->getFlexStartBorder(FlexDirection::Column) +
node->getTrailingBorder(FlexDirection::Column)) - node->getFlexEndBorder(FlexDirection::Column)) -
(child->getLeadingPosition(FlexDirection::Column, height) + (child->getFlexStartPosition(FlexDirection::Column, height) +
child->getTrailingPosition(FlexDirection::Column, height)); child->getFlexEndPosition(FlexDirection::Column, height));
childHeight = childHeight =
boundAxis(child, FlexDirection::Column, childHeight, height, width); boundAxis(child, FlexDirection::Column, childHeight, height, width);
} }
@@ -446,19 +446,18 @@ static void layoutAbsoluteChild(
depth, depth,
generationCount); generationCount);
if (child->isTrailingPosDefined(mainAxis) && if (child->isFlexEndPositionDefined(mainAxis) &&
!child->isLeadingPositionDefined(mainAxis)) { !child->isFlexStartPositionDefined(mainAxis)) {
child->setLayoutPosition( child->setLayoutPosition(
node->getLayout().measuredDimension(dimension(mainAxis)) - node->getLayout().measuredDimension(dimension(mainAxis)) -
child->getLayout().measuredDimension(dimension(mainAxis)) - child->getLayout().measuredDimension(dimension(mainAxis)) -
node->getTrailingBorder(mainAxis) - node->getFlexEndBorder(mainAxis) -
child->getTrailingMargin( child->getInlineEndMargin(
mainAxis, direction, isMainAxisRow ? width : height) - mainAxis, direction, isMainAxisRow ? width : height) -
child->getTrailingPosition( child->getFlexEndPosition(mainAxis, isMainAxisRow ? width : height),
mainAxis, isMainAxisRow ? width : height),
flexStartEdge(mainAxis)); flexStartEdge(mainAxis));
} else if ( } else if (
!child->isLeadingPositionDefined(mainAxis) && !child->isFlexStartPositionDefined(mainAxis) &&
node->getStyle().justifyContent() == Justify::Center) { node->getStyle().justifyContent() == Justify::Center) {
child->setLayoutPosition( child->setLayoutPosition(
(node->getLayout().measuredDimension(dimension(mainAxis)) - (node->getLayout().measuredDimension(dimension(mainAxis)) -
@@ -466,7 +465,7 @@ static void layoutAbsoluteChild(
2.0f, 2.0f,
flexStartEdge(mainAxis)); flexStartEdge(mainAxis));
} else if ( } else if (
!child->isLeadingPositionDefined(mainAxis) && !child->isFlexStartPositionDefined(mainAxis) &&
node->getStyle().justifyContent() == Justify::FlexEnd) { node->getStyle().justifyContent() == Justify::FlexEnd) {
child->setLayoutPosition( child->setLayoutPosition(
(node->getLayout().measuredDimension(dimension(mainAxis)) - (node->getLayout().measuredDimension(dimension(mainAxis)) -
@@ -475,33 +474,33 @@ static void layoutAbsoluteChild(
} else if ( } else if (
node->getConfig()->isExperimentalFeatureEnabled( node->getConfig()->isExperimentalFeatureEnabled(
ExperimentalFeature::AbsolutePercentageAgainstPaddingEdge) && ExperimentalFeature::AbsolutePercentageAgainstPaddingEdge) &&
child->isLeadingPositionDefined(mainAxis)) { child->isFlexStartPositionDefined(mainAxis)) {
child->setLayoutPosition( child->setLayoutPosition(
child->getLeadingPosition( child->getFlexStartPosition(
mainAxis, mainAxis,
node->getLayout().measuredDimension(dimension(mainAxis))) + node->getLayout().measuredDimension(dimension(mainAxis))) +
node->getLeadingBorder(mainAxis) + node->getFlexStartBorder(mainAxis) +
child->getLeadingMargin( child->getInlineStartMargin(
mainAxis, mainAxis,
direction, direction,
node->getLayout().measuredDimension(dimension(mainAxis))), node->getLayout().measuredDimension(dimension(mainAxis))),
flexStartEdge(mainAxis)); flexStartEdge(mainAxis));
} }
if (child->isTrailingPosDefined(crossAxis) && if (child->isFlexEndPositionDefined(crossAxis) &&
!child->isLeadingPositionDefined(crossAxis)) { !child->isFlexStartPositionDefined(crossAxis)) {
child->setLayoutPosition( child->setLayoutPosition(
node->getLayout().measuredDimension(dimension(crossAxis)) - node->getLayout().measuredDimension(dimension(crossAxis)) -
child->getLayout().measuredDimension(dimension(crossAxis)) - child->getLayout().measuredDimension(dimension(crossAxis)) -
node->getTrailingBorder(crossAxis) - node->getFlexEndBorder(crossAxis) -
child->getTrailingMargin( child->getInlineEndMargin(
crossAxis, direction, isMainAxisRow ? height : width) - crossAxis, direction, isMainAxisRow ? height : width) -
child->getTrailingPosition( child->getFlexEndPosition(
crossAxis, isMainAxisRow ? height : width), crossAxis, isMainAxisRow ? height : width),
flexStartEdge(crossAxis)); flexStartEdge(crossAxis));
} else if ( } else if (
!child->isLeadingPositionDefined(crossAxis) && !child->isFlexStartPositionDefined(crossAxis) &&
resolveChildAlignment(node, child) == Align::Center) { resolveChildAlignment(node, child) == Align::Center) {
child->setLayoutPosition( child->setLayoutPosition(
(node->getLayout().measuredDimension(dimension(crossAxis)) - (node->getLayout().measuredDimension(dimension(crossAxis)) -
@@ -509,7 +508,7 @@ static void layoutAbsoluteChild(
2.0f, 2.0f,
flexStartEdge(crossAxis)); flexStartEdge(crossAxis));
} else if ( } else if (
!child->isLeadingPositionDefined(crossAxis) && !child->isFlexStartPositionDefined(crossAxis) &&
((resolveChildAlignment(node, child) == Align::FlexEnd) ^ ((resolveChildAlignment(node, child) == Align::FlexEnd) ^
(node->getStyle().flexWrap() == Wrap::WrapReverse))) { (node->getStyle().flexWrap() == Wrap::WrapReverse))) {
child->setLayoutPosition( child->setLayoutPosition(
@@ -519,13 +518,13 @@ static void layoutAbsoluteChild(
} else if ( } else if (
node->getConfig()->isExperimentalFeatureEnabled( node->getConfig()->isExperimentalFeatureEnabled(
ExperimentalFeature::AbsolutePercentageAgainstPaddingEdge) && ExperimentalFeature::AbsolutePercentageAgainstPaddingEdge) &&
child->isLeadingPositionDefined(crossAxis)) { child->isFlexStartPositionDefined(crossAxis)) {
child->setLayoutPosition( child->setLayoutPosition(
child->getLeadingPosition( child->getFlexStartPosition(
crossAxis, crossAxis,
node->getLayout().measuredDimension(dimension(crossAxis))) + node->getLayout().measuredDimension(dimension(crossAxis))) +
node->getLeadingBorder(crossAxis) + node->getFlexStartBorder(crossAxis) +
child->getLeadingMargin( child->getInlineStartMargin(
crossAxis, crossAxis,
direction, direction,
node->getLayout().measuredDimension(dimension(crossAxis))), node->getLayout().measuredDimension(dimension(crossAxis))),
@@ -946,7 +945,8 @@ static float distributeFreeSpaceSecondPass(
measureModeCrossDim == MeasureMode::Exactly && measureModeCrossDim == MeasureMode::Exactly &&
!(isNodeFlexWrap && mainAxisOverflows) && !(isNodeFlexWrap && mainAxisOverflows) &&
resolveChildAlignment(node, currentLineChild) == Align::Stretch && resolveChildAlignment(node, currentLineChild) == Align::Stretch &&
currentLineChild->marginLeadingValue(crossAxis).unit != YGUnitAuto && currentLineChild->getFlexStartMarginValue(crossAxis).unit !=
YGUnitAuto &&
currentLineChild->marginTrailingValue(crossAxis).unit != YGUnitAuto) { currentLineChild->marginTrailingValue(crossAxis).unit != YGUnitAuto) {
childCrossSize = availableInnerCrossDim; childCrossSize = availableInnerCrossDim;
childCrossMeasureMode = MeasureMode::Exactly; childCrossMeasureMode = MeasureMode::Exactly;
@@ -992,7 +992,8 @@ static float distributeFreeSpaceSecondPass(
!styleDefinesDimension( !styleDefinesDimension(
currentLineChild, crossAxis, availableInnerCrossDim) && currentLineChild, crossAxis, availableInnerCrossDim) &&
resolveChildAlignment(node, currentLineChild) == Align::Stretch && resolveChildAlignment(node, currentLineChild) == Align::Stretch &&
currentLineChild->marginLeadingValue(crossAxis).unit != YGUnitAuto && currentLineChild->getFlexStartMarginValue(crossAxis).unit !=
YGUnitAuto &&
currentLineChild->marginTrailingValue(crossAxis).unit != YGUnitAuto; currentLineChild->marginTrailingValue(crossAxis).unit != YGUnitAuto;
const float childWidth = isMainAxisRow ? childMainSize : childCrossSize; const float childWidth = isMainAxisRow ? childMainSize : childCrossSize;
@@ -1199,9 +1200,9 @@ static void justifyMainAxis(
const bool performLayout) { const bool performLayout) {
const auto& style = node->getStyle(); const auto& style = node->getStyle();
const float leadingPaddingAndBorderMain = const float leadingPaddingAndBorderMain =
node->getLeadingPaddingAndBorder(mainAxis, ownerWidth); node->getFlexStartPaddingAndBorder(mainAxis, ownerWidth);
const float trailingPaddingAndBorderMain = const float trailingPaddingAndBorderMain =
node->getTrailingPaddingAndBorder(mainAxis, ownerWidth); node->getFlexEndPaddingAndBorder(mainAxis, ownerWidth);
const float gap = node->getGapForAxis(mainAxis); const float gap = node->getGapForAxis(mainAxis);
// If we are using "at most" rules in the main axis, make sure that // If we are using "at most" rules in the main axis, make sure that
// remainingFreeSpace is 0 when min main dimension is not given // remainingFreeSpace is 0 when min main dimension is not given
@@ -1236,7 +1237,7 @@ static void justifyMainAxis(
for (size_t i = startOfLineIndex; i < flexLine.endOfLineIndex; i++) { for (size_t i = startOfLineIndex; i < flexLine.endOfLineIndex; i++) {
auto child = node->getChild(i); auto child = node->getChild(i);
if (child->getStyle().positionType() != PositionType::Absolute) { if (child->getStyle().positionType() != PositionType::Absolute) {
if (child->marginLeadingValue(mainAxis).unit == YGUnitAuto) { if (child->getFlexStartMarginValue(mainAxis).unit == YGUnitAuto) {
numberOfAutoMarginsOnCurrentLine++; numberOfAutoMarginsOnCurrentLine++;
} }
if (child->marginTrailingValue(mainAxis).unit == YGUnitAuto) { if (child->marginTrailingValue(mainAxis).unit == YGUnitAuto) {
@@ -1298,15 +1299,15 @@ static void justifyMainAxis(
continue; continue;
} }
if (childStyle.positionType() == PositionType::Absolute && if (childStyle.positionType() == PositionType::Absolute &&
child->isLeadingPositionDefined(mainAxis)) { child->isFlexStartPositionDefined(mainAxis)) {
if (performLayout) { if (performLayout) {
// In case the child is position absolute and has left/top being // In case the child is position absolute and has left/top being
// defined, we override the position to whatever the user said (and // defined, we override the position to whatever the user said (and
// margin/border). // margin/border).
child->setLayoutPosition( child->setLayoutPosition(
child->getLeadingPosition(mainAxis, availableInnerMainDim) + child->getFlexStartPosition(mainAxis, availableInnerMainDim) +
node->getLeadingBorder(mainAxis) + node->getFlexStartBorder(mainAxis) +
child->getLeadingMargin( child->getInlineStartMargin(
mainAxis, direction, availableInnerWidth), mainAxis, direction, availableInnerWidth),
flexStartEdge(mainAxis)); flexStartEdge(mainAxis));
} }
@@ -1315,7 +1316,7 @@ static void justifyMainAxis(
// We need to do that only for relative elements. Absolute elements do not // We need to do that only for relative elements. Absolute elements do not
// take part in that phase. // take part in that phase.
if (childStyle.positionType() != PositionType::Absolute) { if (childStyle.positionType() != PositionType::Absolute) {
if (child->marginLeadingValue(mainAxis).unit == YGUnitAuto) { if (child->getFlexStartMarginValue(mainAxis).unit == YGUnitAuto) {
flexLine.layout.mainDim += flexLine.layout.remainingFreeSpace / flexLine.layout.mainDim += flexLine.layout.remainingFreeSpace /
static_cast<float>(numberOfAutoMarginsOnCurrentLine); static_cast<float>(numberOfAutoMarginsOnCurrentLine);
} }
@@ -1355,7 +1356,7 @@ static void justifyMainAxis(
// If the child is baseline aligned then the cross dimension is // If the child is baseline aligned then the cross dimension is
// calculated by adding maxAscent and maxDescent from the baseline. // calculated by adding maxAscent and maxDescent from the baseline.
const float ascent = calculateBaseline(child) + const float ascent = calculateBaseline(child) +
child->getLeadingMargin( child->getInlineStartMargin(
FlexDirection::Column, direction, availableInnerWidth); FlexDirection::Column, direction, availableInnerWidth);
const float descent = const float descent =
child->getLayout().measuredDimension(Dimension::Height) + child->getLayout().measuredDimension(Dimension::Height) +
@@ -1379,7 +1380,7 @@ static void justifyMainAxis(
} else if (performLayout) { } else if (performLayout) {
child->setLayoutPosition( child->setLayoutPosition(
childLayout.position[flexStartEdge(mainAxis)] + childLayout.position[flexStartEdge(mainAxis)] +
node->getLeadingBorder(mainAxis) + leadingMainDim, node->getFlexStartBorder(mainAxis) + leadingMainDim,
flexStartEdge(mainAxis)); flexStartEdge(mainAxis));
} }
} }
@@ -1502,35 +1503,36 @@ static void calculateLayoutImpl(
const YGEdge endEdge = direction == Direction::LTR ? YGEdgeRight : YGEdgeLeft; const YGEdge endEdge = direction == Direction::LTR ? YGEdgeRight : YGEdgeLeft;
const float marginRowLeading = const float marginRowLeading =
node->getLeadingMargin(flexRowDirection, direction, ownerWidth); node->getInlineStartMargin(flexRowDirection, direction, ownerWidth);
node->setLayoutMargin(marginRowLeading, startEdge); node->setLayoutMargin(marginRowLeading, startEdge);
const float marginRowTrailing = const float marginRowTrailing =
node->getTrailingMargin(flexRowDirection, direction, ownerWidth); node->getInlineEndMargin(flexRowDirection, direction, ownerWidth);
node->setLayoutMargin(marginRowTrailing, endEdge); node->setLayoutMargin(marginRowTrailing, endEdge);
const float marginColumnLeading = const float marginColumnLeading =
node->getLeadingMargin(flexColumnDirection, direction, ownerWidth); node->getInlineStartMargin(flexColumnDirection, direction, ownerWidth);
node->setLayoutMargin(marginColumnLeading, YGEdgeTop); node->setLayoutMargin(marginColumnLeading, YGEdgeTop);
const float marginColumnTrailing = const float marginColumnTrailing =
node->getTrailingMargin(flexColumnDirection, direction, ownerWidth); node->getInlineEndMargin(flexColumnDirection, direction, ownerWidth);
node->setLayoutMargin(marginColumnTrailing, YGEdgeBottom); node->setLayoutMargin(marginColumnTrailing, YGEdgeBottom);
const float marginAxisRow = marginRowLeading + marginRowTrailing; const float marginAxisRow = marginRowLeading + marginRowTrailing;
const float marginAxisColumn = marginColumnLeading + marginColumnTrailing; const float marginAxisColumn = marginColumnLeading + marginColumnTrailing;
node->setLayoutBorder(node->getLeadingBorder(flexRowDirection), startEdge); node->setLayoutBorder(node->getFlexStartBorder(flexRowDirection), startEdge);
node->setLayoutBorder(node->getTrailingBorder(flexRowDirection), endEdge); node->setLayoutBorder(node->getFlexEndBorder(flexRowDirection), endEdge);
node->setLayoutBorder(node->getLeadingBorder(flexColumnDirection), YGEdgeTop);
node->setLayoutBorder( node->setLayoutBorder(
node->getTrailingBorder(flexColumnDirection), YGEdgeBottom); node->getFlexStartBorder(flexColumnDirection), YGEdgeTop);
node->setLayoutBorder(
node->getFlexEndBorder(flexColumnDirection), YGEdgeBottom);
node->setLayoutPadding( node->setLayoutPadding(
node->getLeadingPadding(flexRowDirection, ownerWidth), startEdge); node->getFlexStartPadding(flexRowDirection, ownerWidth), startEdge);
node->setLayoutPadding( node->setLayoutPadding(
node->getTrailingPadding(flexRowDirection, ownerWidth), endEdge); node->getFlexEndPadding(flexRowDirection, ownerWidth), endEdge);
node->setLayoutPadding( node->setLayoutPadding(
node->getLeadingPadding(flexColumnDirection, ownerWidth), YGEdgeTop); node->getFlexStartPadding(flexColumnDirection, ownerWidth), YGEdgeTop);
node->setLayoutPadding( node->setLayoutPadding(
node->getTrailingPadding(flexColumnDirection, ownerWidth), YGEdgeBottom); node->getFlexEndPadding(flexColumnDirection, ownerWidth), YGEdgeBottom);
if (node->hasMeasureFunc()) { if (node->hasMeasureFunc()) {
measureNodeWithMeasureFunc( measureNodeWithMeasureFunc(
@@ -1592,9 +1594,9 @@ static void calculateLayoutImpl(
const float paddingAndBorderAxisMain = const float paddingAndBorderAxisMain =
paddingAndBorderForAxis(node, mainAxis, ownerWidth); paddingAndBorderForAxis(node, mainAxis, ownerWidth);
const float leadingPaddingAndBorderCross = const float leadingPaddingAndBorderCross =
node->getLeadingPaddingAndBorder(crossAxis, ownerWidth); node->getFlexStartPaddingAndBorder(crossAxis, ownerWidth);
const float trailingPaddingAndBorderCross = const float trailingPaddingAndBorderCross =
node->getTrailingPaddingAndBorder(crossAxis, ownerWidth); node->getFlexEndPaddingAndBorder(crossAxis, ownerWidth);
const float paddingAndBorderAxisCross = const float paddingAndBorderAxisCross =
leadingPaddingAndBorderCross + trailingPaddingAndBorderCross; leadingPaddingAndBorderCross + trailingPaddingAndBorderCross;
@@ -1849,12 +1851,12 @@ static void calculateLayoutImpl(
// top/left/bottom/right set, override all the previously computed // top/left/bottom/right set, override all the previously computed
// positions to set it correctly. // positions to set it correctly.
const bool isChildLeadingPosDefined = const bool isChildLeadingPosDefined =
child->isLeadingPositionDefined(crossAxis); child->isFlexStartPositionDefined(crossAxis);
if (isChildLeadingPosDefined) { if (isChildLeadingPosDefined) {
child->setLayoutPosition( child->setLayoutPosition(
child->getLeadingPosition(crossAxis, availableInnerCrossDim) + child->getFlexStartPosition(crossAxis, availableInnerCrossDim) +
node->getLeadingBorder(crossAxis) + node->getFlexStartBorder(crossAxis) +
child->getLeadingMargin( child->getInlineStartMargin(
crossAxis, direction, availableInnerWidth), crossAxis, direction, availableInnerWidth),
flexStartEdge(crossAxis)); flexStartEdge(crossAxis));
} }
@@ -1864,8 +1866,8 @@ static void calculateLayoutImpl(
yoga::isUndefined( yoga::isUndefined(
child->getLayout().position[flexStartEdge(crossAxis)])) { child->getLayout().position[flexStartEdge(crossAxis)])) {
child->setLayoutPosition( child->setLayoutPosition(
node->getLeadingBorder(crossAxis) + node->getFlexStartBorder(crossAxis) +
child->getLeadingMargin( child->getInlineStartMargin(
crossAxis, direction, availableInnerWidth), crossAxis, direction, availableInnerWidth),
flexStartEdge(crossAxis)); flexStartEdge(crossAxis));
} }
@@ -1881,7 +1883,7 @@ static void calculateLayoutImpl(
// time, this time forcing the cross-axis size to be the computed // time, this time forcing the cross-axis size to be the computed
// cross size for the current line. // cross size for the current line.
if (alignItem == Align::Stretch && if (alignItem == Align::Stretch &&
child->marginLeadingValue(crossAxis).unit != YGUnitAuto && child->getFlexStartMarginValue(crossAxis).unit != YGUnitAuto &&
child->marginTrailingValue(crossAxis).unit != YGUnitAuto) { child->marginTrailingValue(crossAxis).unit != YGUnitAuto) {
// If the child defines a definite size for its cross axis, there's // If the child defines a definite size for its cross axis, there's
// no need to stretch. // no need to stretch.
@@ -1955,7 +1957,7 @@ static void calculateLayoutImpl(
const float remainingCrossDim = containerCrossAxis - const float remainingCrossDim = containerCrossAxis -
dimensionWithMargin(child, crossAxis, availableInnerWidth); dimensionWithMargin(child, crossAxis, availableInnerWidth);
if (child->marginLeadingValue(crossAxis).unit == YGUnitAuto && if (child->getFlexStartMarginValue(crossAxis).unit == YGUnitAuto &&
child->marginTrailingValue(crossAxis).unit == YGUnitAuto) { child->marginTrailingValue(crossAxis).unit == YGUnitAuto) {
leadingCrossDim += leadingCrossDim +=
yoga::maxOrDefined(0.0f, remainingCrossDim / 2); yoga::maxOrDefined(0.0f, remainingCrossDim / 2);
@@ -1963,7 +1965,7 @@ static void calculateLayoutImpl(
child->marginTrailingValue(crossAxis).unit == YGUnitAuto) { child->marginTrailingValue(crossAxis).unit == YGUnitAuto) {
// No-Op // No-Op
} else if ( } else if (
child->marginLeadingValue(crossAxis).unit == YGUnitAuto) { child->getFlexStartMarginValue(crossAxis).unit == YGUnitAuto) {
leadingCrossDim += yoga::maxOrDefined(0.0f, remainingCrossDim); leadingCrossDim += yoga::maxOrDefined(0.0f, remainingCrossDim);
} else if (alignItem == Align::FlexStart) { } else if (alignItem == Align::FlexStart) {
// No-Op // No-Op
@@ -2059,7 +2061,7 @@ static void calculateLayoutImpl(
} }
if (resolveChildAlignment(node, child) == Align::Baseline) { if (resolveChildAlignment(node, child) == Align::Baseline) {
const float ascent = calculateBaseline(child) + const float ascent = calculateBaseline(child) +
child->getLeadingMargin( child->getInlineStartMargin(
FlexDirection::Column, direction, availableInnerWidth); FlexDirection::Column, direction, availableInnerWidth);
const float descent = const float descent =
child->getLayout().measuredDimension(Dimension::Height) + child->getLayout().measuredDimension(Dimension::Height) +
@@ -2090,7 +2092,7 @@ static void calculateLayoutImpl(
case Align::FlexStart: { case Align::FlexStart: {
child->setLayoutPosition( child->setLayoutPosition(
currentLead + currentLead +
child->getLeadingMargin( child->getInlineStartMargin(
crossAxis, direction, availableInnerWidth), crossAxis, direction, availableInnerWidth),
flexStartEdge(crossAxis)); flexStartEdge(crossAxis));
break; break;
@@ -2098,7 +2100,7 @@ static void calculateLayoutImpl(
case Align::FlexEnd: { case Align::FlexEnd: {
child->setLayoutPosition( child->setLayoutPosition(
currentLead + lineHeight - currentLead + lineHeight -
child->getTrailingMargin( child->getInlineEndMargin(
crossAxis, direction, availableInnerWidth) - crossAxis, direction, availableInnerWidth) -
child->getLayout().measuredDimension( child->getLayout().measuredDimension(
dimension(crossAxis)), dimension(crossAxis)),
@@ -2117,7 +2119,7 @@ static void calculateLayoutImpl(
case Align::Stretch: { case Align::Stretch: {
child->setLayoutPosition( child->setLayoutPosition(
currentLead + currentLead +
child->getLeadingMargin( child->getInlineStartMargin(
crossAxis, direction, availableInnerWidth), crossAxis, direction, availableInnerWidth),
flexStartEdge(crossAxis)); flexStartEdge(crossAxis));
@@ -2168,7 +2170,7 @@ static void calculateLayoutImpl(
child->setLayoutPosition( child->setLayoutPosition(
currentLead + maxAscentForCurrentLine - currentLead + maxAscentForCurrentLine -
calculateBaseline(child) + calculateBaseline(child) +
child->getLeadingPosition( child->getFlexStartPosition(
FlexDirection::Column, availableInnerCrossDim), FlexDirection::Column, availableInnerCrossDim),
YGEdgeTop); YGEdgeTop);

64
yoga/node/Node.cpp
View File

@@ -83,7 +83,7 @@ CompactValue Node::computeEdgeValueForColumn(
} }
} }
YGEdge Node::getLeadingLayoutEdgeUsingErrata( YGEdge Node::getInlineStartEdgeUsingErrata(
FlexDirection flexDirection, FlexDirection flexDirection,
Direction direction) const { Direction direction) const {
return hasErrata(Errata::StartingEndingEdgeFromFlexDirection) return hasErrata(Errata::StartingEndingEdgeFromFlexDirection)
@@ -91,7 +91,7 @@ YGEdge Node::getLeadingLayoutEdgeUsingErrata(
: inlineStartEdge(flexDirection, direction); : inlineStartEdge(flexDirection, direction);
} }
YGEdge Node::getTrailingLayoutEdgeUsingErrata( YGEdge Node::getInlineEndEdgeUsingErrata(
FlexDirection flexDirection, FlexDirection flexDirection,
Direction direction) const { Direction direction) const {
return hasErrata(Errata::StartingEndingEdgeFromFlexDirection) return hasErrata(Errata::StartingEndingEdgeFromFlexDirection)
@@ -99,7 +99,7 @@ YGEdge Node::getTrailingLayoutEdgeUsingErrata(
: inlineEndEdge(flexDirection, direction); : inlineEndEdge(flexDirection, direction);
} }
bool Node::isLeadingPositionDefined(FlexDirection axis) const { bool Node::isFlexStartPositionDefined(FlexDirection axis) const {
auto leadingPosition = isRow(axis) auto leadingPosition = isRow(axis)
? computeEdgeValueForRow( ? computeEdgeValueForRow(
style_.position(), YGEdgeStart, flexStartEdge(axis)) style_.position(), YGEdgeStart, flexStartEdge(axis))
@@ -108,7 +108,7 @@ bool Node::isLeadingPositionDefined(FlexDirection axis) const {
return !leadingPosition.isUndefined(); return !leadingPosition.isUndefined();
} }
bool Node::isTrailingPosDefined(FlexDirection axis) const { bool Node::isFlexEndPositionDefined(FlexDirection axis) const {
auto trailingPosition = isRow(axis) auto trailingPosition = isRow(axis)
? computeEdgeValueForRow(style_.position(), YGEdgeEnd, flexEndEdge(axis)) ? computeEdgeValueForRow(style_.position(), YGEdgeEnd, flexEndEdge(axis))
: computeEdgeValueForColumn(style_.position(), flexEndEdge(axis)); : computeEdgeValueForColumn(style_.position(), flexEndEdge(axis));
@@ -116,7 +116,7 @@ bool Node::isTrailingPosDefined(FlexDirection axis) const {
return !trailingPosition.isUndefined(); return !trailingPosition.isUndefined();
} }
float Node::getLeadingPosition(FlexDirection axis, float axisSize) const { float Node::getFlexStartPosition(FlexDirection axis, float axisSize) const {
auto leadingPosition = isRow(axis) auto leadingPosition = isRow(axis)
? computeEdgeValueForRow( ? computeEdgeValueForRow(
style_.position(), YGEdgeStart, flexStartEdge(axis)) style_.position(), YGEdgeStart, flexStartEdge(axis))
@@ -125,7 +125,7 @@ float Node::getLeadingPosition(FlexDirection axis, float axisSize) const {
return resolveValue(leadingPosition, axisSize).unwrapOrDefault(0.0f); return resolveValue(leadingPosition, axisSize).unwrapOrDefault(0.0f);
} }
float Node::getTrailingPosition(FlexDirection axis, float axisSize) const { float Node::getFlexEndPosition(FlexDirection axis, float axisSize) const {
auto trailingPosition = isRow(axis) auto trailingPosition = isRow(axis)
? computeEdgeValueForRow(style_.position(), YGEdgeEnd, flexEndEdge(axis)) ? computeEdgeValueForRow(style_.position(), YGEdgeEnd, flexEndEdge(axis))
: computeEdgeValueForColumn(style_.position(), flexEndEdge(axis)); : computeEdgeValueForColumn(style_.position(), flexEndEdge(axis));
@@ -133,11 +133,11 @@ float Node::getTrailingPosition(FlexDirection axis, float axisSize) const {
return resolveValue(trailingPosition, axisSize).unwrapOrDefault(0.0f); return resolveValue(trailingPosition, axisSize).unwrapOrDefault(0.0f);
} }
float Node::getLeadingMargin( float Node::getInlineStartMargin(
FlexDirection axis, FlexDirection axis,
Direction direction, Direction direction,
float widthSize) const { float widthSize) const {
const YGEdge startEdge = getLeadingLayoutEdgeUsingErrata(axis, direction); const YGEdge startEdge = getInlineStartEdgeUsingErrata(axis, direction);
auto leadingMargin = isRow(axis) auto leadingMargin = isRow(axis)
? computeEdgeValueForRow(style_.margin(), YGEdgeStart, startEdge) ? computeEdgeValueForRow(style_.margin(), YGEdgeStart, startEdge)
: computeEdgeValueForColumn(style_.margin(), startEdge); : computeEdgeValueForColumn(style_.margin(), startEdge);
@@ -145,11 +145,11 @@ float Node::getLeadingMargin(
return resolveValue(leadingMargin, widthSize).unwrapOrDefault(0.0f); return resolveValue(leadingMargin, widthSize).unwrapOrDefault(0.0f);
} }
float Node::getTrailingMargin( float Node::getInlineEndMargin(
FlexDirection axis, FlexDirection axis,
Direction direction, Direction direction,
float widthSize) const { float widthSize) const {
const YGEdge endEdge = getTrailingLayoutEdgeUsingErrata(axis, direction); const YGEdge endEdge = getInlineEndEdgeUsingErrata(axis, direction);
auto trailingMargin = isRow(axis) auto trailingMargin = isRow(axis)
? computeEdgeValueForRow(style_.margin(), YGEdgeEnd, endEdge) ? computeEdgeValueForRow(style_.margin(), YGEdgeEnd, endEdge)
: computeEdgeValueForColumn(style_.margin(), endEdge); : computeEdgeValueForColumn(style_.margin(), endEdge);
@@ -157,7 +157,7 @@ float Node::getTrailingMargin(
return resolveValue(trailingMargin, widthSize).unwrapOrDefault(0.0f); return resolveValue(trailingMargin, widthSize).unwrapOrDefault(0.0f);
} }
float Node::getLeadingBorder(FlexDirection axis) const { float Node::getFlexStartBorder(FlexDirection axis) const {
YGValue leadingBorder = isRow(axis) YGValue leadingBorder = isRow(axis)
? computeEdgeValueForRow( ? computeEdgeValueForRow(
style_.border(), YGEdgeStart, flexStartEdge(axis)) style_.border(), YGEdgeStart, flexStartEdge(axis))
@@ -166,7 +166,7 @@ float Node::getLeadingBorder(FlexDirection axis) const {
return maxOrDefined(leadingBorder.value, 0.0f); return maxOrDefined(leadingBorder.value, 0.0f);
} }
float Node::getTrailingBorder(FlexDirection axis) const { float Node::getFlexEndBorder(FlexDirection axis) const {
YGValue trailingBorder = isRow(axis) YGValue trailingBorder = isRow(axis)
? computeEdgeValueForRow(style_.border(), YGEdgeEnd, flexEndEdge(axis)) ? computeEdgeValueForRow(style_.border(), YGEdgeEnd, flexEndEdge(axis))
: computeEdgeValueForColumn(style_.border(), flexEndEdge(axis)); : computeEdgeValueForColumn(style_.border(), flexEndEdge(axis));
@@ -174,7 +174,7 @@ float Node::getTrailingBorder(FlexDirection axis) const {
return maxOrDefined(trailingBorder.value, 0.0f); return maxOrDefined(trailingBorder.value, 0.0f);
} }
float Node::getLeadingPadding(FlexDirection axis, float widthSize) const { float Node::getFlexStartPadding(FlexDirection axis, float widthSize) const {
auto leadingPadding = isRow(axis) auto leadingPadding = isRow(axis)
? computeEdgeValueForRow( ? computeEdgeValueForRow(
style_.padding(), YGEdgeStart, flexStartEdge(axis)) style_.padding(), YGEdgeStart, flexStartEdge(axis))
@@ -183,7 +183,7 @@ float Node::getLeadingPadding(FlexDirection axis, float widthSize) const {
return maxOrDefined(resolveValue(leadingPadding, widthSize).unwrap(), 0.0f); return maxOrDefined(resolveValue(leadingPadding, widthSize).unwrap(), 0.0f);
} }
float Node::getTrailingPadding(FlexDirection axis, float widthSize) const { float Node::getFlexEndPadding(FlexDirection axis, float widthSize) const {
auto trailingPadding = isRow(axis) auto trailingPadding = isRow(axis)
? computeEdgeValueForRow(style_.padding(), YGEdgeEnd, flexEndEdge(axis)) ? computeEdgeValueForRow(style_.padding(), YGEdgeEnd, flexEndEdge(axis))
: computeEdgeValueForColumn(style_.padding(), flexEndEdge(axis)); : computeEdgeValueForColumn(style_.padding(), flexEndEdge(axis));
@@ -191,21 +191,21 @@ float Node::getTrailingPadding(FlexDirection axis, float widthSize) const {
return maxOrDefined(resolveValue(trailingPadding, widthSize).unwrap(), 0.0f); return maxOrDefined(resolveValue(trailingPadding, widthSize).unwrap(), 0.0f);
} }
float Node::getLeadingPaddingAndBorder(FlexDirection axis, float widthSize) float Node::getFlexStartPaddingAndBorder(FlexDirection axis, float widthSize)
const { const {
return getLeadingPadding(axis, widthSize) + getLeadingBorder(axis); return getFlexStartPadding(axis, widthSize) + getFlexStartBorder(axis);
} }
float Node::getTrailingPaddingAndBorder(FlexDirection axis, float widthSize) float Node::getFlexEndPaddingAndBorder(FlexDirection axis, float widthSize)
const { const {
return getTrailingPadding(axis, widthSize) + getTrailingBorder(axis); return getFlexEndPadding(axis, widthSize) + getFlexEndBorder(axis);
} }
float Node::getMarginForAxis(FlexDirection axis, float widthSize) const { float Node::getMarginForAxis(FlexDirection axis, float widthSize) const {
// The total margin for a given axis does not depend on the direction // The total margin for a given axis does not depend on the direction
// so hardcoding LTR here to avoid piping direction to this function // so hardcoding LTR here to avoid piping direction to this function
return getLeadingMargin(axis, Direction::LTR, widthSize) + return getInlineStartMargin(axis, Direction::LTR, widthSize) +
getTrailingMargin(axis, Direction::LTR, widthSize); getInlineEndMargin(axis, Direction::LTR, widthSize);
} }
float Node::getGapForAxis(FlexDirection axis) const { float Node::getGapForAxis(FlexDirection axis) const {
@@ -362,11 +362,11 @@ void Node::setLayoutDimension(float dimensionValue, Dimension dimension) {
// If both left and right are defined, then use left. Otherwise return +left or // If both left and right are defined, then use left. Otherwise return +left or
// -right depending on which is defined. // -right depending on which is defined.
float Node::relativePosition(FlexDirection axis, float axisSize) const { float Node::relativePosition(FlexDirection axis, float axisSize) const {
if (isLeadingPositionDefined(axis)) { if (isFlexStartPositionDefined(axis)) {
return getLeadingPosition(axis, axisSize); return getFlexStartPosition(axis, axisSize);
} }
return -1 * getTrailingPosition(axis, axisSize); return -1 * getFlexEndPosition(axis, axisSize);
} }
void Node::setPosition( void Node::setPosition(
@@ -390,33 +390,33 @@ void Node::setPosition(
const float relativePositionCross = relativePosition(crossAxis, crossSize); const float relativePositionCross = relativePosition(crossAxis, crossSize);
const YGEdge mainAxisLeadingEdge = const YGEdge mainAxisLeadingEdge =
getLeadingLayoutEdgeUsingErrata(mainAxis, direction); getInlineStartEdgeUsingErrata(mainAxis, direction);
const YGEdge mainAxisTrailingEdge = const YGEdge mainAxisTrailingEdge =
getTrailingLayoutEdgeUsingErrata(mainAxis, direction); getInlineEndEdgeUsingErrata(mainAxis, direction);
const YGEdge crossAxisLeadingEdge = const YGEdge crossAxisLeadingEdge =
getLeadingLayoutEdgeUsingErrata(crossAxis, direction); getInlineStartEdgeUsingErrata(crossAxis, direction);
const YGEdge crossAxisTrailingEdge = const YGEdge crossAxisTrailingEdge =
getTrailingLayoutEdgeUsingErrata(crossAxis, direction); getInlineEndEdgeUsingErrata(crossAxis, direction);
setLayoutPosition( setLayoutPosition(
(getLeadingMargin(mainAxis, direction, ownerWidth) + (getInlineStartMargin(mainAxis, direction, ownerWidth) +
relativePositionMain), relativePositionMain),
mainAxisLeadingEdge); mainAxisLeadingEdge);
setLayoutPosition( setLayoutPosition(
(getTrailingMargin(mainAxis, direction, ownerWidth) + (getInlineEndMargin(mainAxis, direction, ownerWidth) +
relativePositionMain), relativePositionMain),
mainAxisTrailingEdge); mainAxisTrailingEdge);
setLayoutPosition( setLayoutPosition(
(getLeadingMargin(crossAxis, direction, ownerWidth) + (getInlineStartMargin(crossAxis, direction, ownerWidth) +
relativePositionCross), relativePositionCross),
crossAxisLeadingEdge); crossAxisLeadingEdge);
setLayoutPosition( setLayoutPosition(
(getTrailingMargin(crossAxis, direction, ownerWidth) + (getInlineEndMargin(crossAxis, direction, ownerWidth) +
relativePositionCross), relativePositionCross),
crossAxisTrailingEdge); crossAxisTrailingEdge);
} }
YGValue Node::marginLeadingValue(FlexDirection axis) const { YGValue Node::getFlexStartMarginValue(FlexDirection axis) const {
if (isRow(axis) && !style_.margin()[YGEdgeStart].isUndefined()) { if (isRow(axis) && !style_.margin()[YGEdgeStart].isUndefined()) {
return style_.margin()[YGEdgeStart]; return style_.margin()[YGEdgeStart];
} else { } else {

30
yoga/node/Node.h
View File

@@ -50,10 +50,10 @@ class YG_EXPORT Node : public ::YGNode {
float relativePosition(FlexDirection axis, const float axisSize) const; float relativePosition(FlexDirection axis, const float axisSize) const;
YGEdge getLeadingLayoutEdgeUsingErrata( YGEdge getInlineStartEdgeUsingErrata(
FlexDirection flexDirection, FlexDirection flexDirection,
Direction direction) const; Direction direction) const;
YGEdge getTrailingLayoutEdgeUsingErrata( YGEdge getInlineEndEdgeUsingErrata(
FlexDirection flexDirection, FlexDirection flexDirection,
Direction direction) const; Direction direction) const;
@@ -196,24 +196,24 @@ class YG_EXPORT Node : public ::YGNode {
YGEdge edge); YGEdge edge);
// Methods related to positions, margin, padding and border // Methods related to positions, margin, padding and border
bool isLeadingPositionDefined(FlexDirection axis) const; bool isFlexStartPositionDefined(FlexDirection axis) const;
bool isTrailingPosDefined(FlexDirection axis) const; bool isFlexEndPositionDefined(FlexDirection axis) const;
float getLeadingPosition(FlexDirection axis, float axisSize) const; float getFlexStartPosition(FlexDirection axis, float axisSize) const;
float getTrailingPosition(FlexDirection axis, float axisSize) const; float getFlexEndPosition(FlexDirection axis, float axisSize) const;
float getLeadingMargin( float getInlineStartMargin(
FlexDirection axis, FlexDirection axis,
Direction direction, Direction direction,
float widthSize) const; float widthSize) const;
float getTrailingMargin( float getInlineEndMargin(
FlexDirection axis, FlexDirection axis,
Direction direction, Direction direction,
float widthSize) const; float widthSize) const;
float getLeadingBorder(FlexDirection flexDirection) const; float getFlexStartBorder(FlexDirection flexDirection) const;
float getTrailingBorder(FlexDirection flexDirection) const; float getFlexEndBorder(FlexDirection flexDirection) const;
float getLeadingPadding(FlexDirection axis, float widthSize) const; float getFlexStartPadding(FlexDirection axis, float widthSize) const;
float getTrailingPadding(FlexDirection axis, float widthSize) const; float getFlexEndPadding(FlexDirection axis, float widthSize) const;
float getLeadingPaddingAndBorder(FlexDirection axis, float widthSize) const; float getFlexStartPaddingAndBorder(FlexDirection axis, float widthSize) const;
float getTrailingPaddingAndBorder(FlexDirection axis, float widthSize) const; float getFlexEndPaddingAndBorder(FlexDirection axis, float widthSize) const;
float getMarginForAxis(FlexDirection axis, float widthSize) const; float getMarginForAxis(FlexDirection axis, float widthSize) const;
float getGapForAxis(FlexDirection axis) const; float getGapForAxis(FlexDirection axis) const;
// Setters // Setters
@@ -293,7 +293,7 @@ class YG_EXPORT Node : public ::YGNode {
void markDirtyAndPropagateDownwards(); void markDirtyAndPropagateDownwards();
// Other methods // Other methods
YGValue marginLeadingValue(FlexDirection axis) const; YGValue getFlexStartMarginValue(FlexDirection axis) const;
YGValue marginTrailingValue(FlexDirection axis) const; YGValue marginTrailingValue(FlexDirection axis) const;
YGValue resolveFlexBasisPtr() const; YGValue resolveFlexBasisPtr() const;
void resolveDimension(); void resolveDimension();