Facebook/react-native
1
0
Fork 0
mirror of https://github.com/facebook/react-native.git synced 2025-11-01 09:14:26 +00:00
Code Issues Packages Projects Releases Wiki Activity

C++ style enums 11/N: Align (#39497)

Browse Source 
Summary:
Pull Request resolved: https://github.com/facebook/react-native/pull/39497

X-link: https://github.com/facebook/yoga/pull/1395

Moves internal usages of YGAlign to Align

bypass-github-export-checks

Changelog: [Internal]

Reviewed By: rshest

Differential Revision: D49337511

fbshipit-source-id: bb9906fcd22780d2cfd8d1360ef69f66b9701bb6
This commit is contained in:
Nick Gerleman
2023-09-19 16:30:02 -07:00
committed by Facebook GitHub Bot
parent e767b21855
commit 1000afccaa
9 changed files with 84 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files
packages/react-native/ReactCommon/react/renderer/components/view/conversions.h
+20 -20
View File
@@ -261,46 +261,46 @@ inline void fromRawValue(
inline void fromRawValue(
const PropsParserContext& context,
const RawValue& value,
YGAlign& result) {
result = YGAlignStretch;
yoga::Align& result) {
result = yoga::Align::Stretch;
react_native_expect(value.hasType<std::string>());
if (!value.hasType<std::string>()) {
return;
}
auto stringValue = (std::string)value;
if (stringValue == "auto") {
result = YGAlignAuto;
result = yoga::Align::Auto;
return;
}
if (stringValue == "flex-start") {
result = YGAlignFlexStart;
result = yoga::Align::FlexStart;
return;
}
if (stringValue == "center") {
result = YGAlignCenter;
result = yoga::Align::Center;
return;
}
if (stringValue == "flex-end") {
result = YGAlignFlexEnd;
result = yoga::Align::FlexEnd;
return;
}
if (stringValue == "stretch") {
result = YGAlignStretch;
result = yoga::Align::Stretch;
return;
}
if (stringValue == "baseline") {
result = YGAlignBaseline;
result = yoga::Align::Baseline;
return;
}
if (stringValue == "space-between") {
result = YGAlignSpaceBetween;
result = yoga::Align::SpaceBetween;
return;
}
if (stringValue == "space-around") {
result = YGAlignSpaceAround;
result = yoga::Align::SpaceAround;
return;
}
LOG(ERROR) << "Could not parse YGAlign:" << stringValue;
LOG(ERROR) << "Could not parse yoga::Align:" << stringValue;
react_native_expect(false);
}
@@ -779,23 +779,23 @@ inline std::string toString(const yoga::Justify& value) {
}
}
inline std::string toString(const YGAlign& value) {
inline std::string toString(const yoga::Align& value) {
switch (value) {
case YGAlignAuto:
case yoga::Align::Auto:
return "auto";
case YGAlignFlexStart:
case yoga::Align::FlexStart:
return "flex-start";
case YGAlignCenter:
case yoga::Align::Center:
return "center";
case YGAlignFlexEnd:
case yoga::Align::FlexEnd:
return "flex-end";
case YGAlignStretch:
case yoga::Align::Stretch:
return "stretch";
case YGAlignBaseline:
case yoga::Align::Baseline:
return "baseline";
case YGAlignSpaceBetween:
case yoga::Align::SpaceBetween:
return "space-between";
case YGAlignSpaceAround:
case yoga::Align::SpaceAround:
return "space-around";
}
}
packages/react-native/ReactCommon/react/renderer/components/view/tests/ViewTest.cpp
+2 -2
View File
@@ -52,7 +52,7 @@ class YogaDirtyFlagTest : public ::testing::Test {
auto &props = *mutableViewProps;
props.nativeId = "native Id";
props.opacity = 0.5;
props.yogaStyle.alignContent() = YGAlignBaseline;
props.yogaStyle.alignContent() = yoga::Align::Baseline;
props.yogaStyle.flexDirection() = yoga::FlexDirection::RowReverse;
return mutableViewProps;
}),
@@ -136,7 +136,7 @@ TEST_F(YogaDirtyFlagTest, changingLayoutSubPropsMustDirtyYogaNode) {
auto viewProps = std::make_shared<ViewShadowNodeProps>();
auto& props = *viewProps;
props.yogaStyle.alignContent() = YGAlignBaseline;
props.yogaStyle.alignContent() = yoga::Align::Baseline;
props.yogaStyle.display() = YGDisplayNone;
return oldShadowNode.clone(ShadowNodeFragment{viewProps});
packages/react-native/ReactCommon/yoga/yoga/Yoga.cpp
+8 -6
View File
@@ -459,24 +459,26 @@ void YGNodeStyleSetAlignContent(
const YGNodeRef node,
const YGAlign alignContent) {
updateStyle<MSVC_HINT(alignContent)>(
node, &Style::alignContent, alignContent);
node, &Style::alignContent, scopedEnum(alignContent));
}
YGAlign YGNodeStyleGetAlignContent(const YGNodeConstRef node) {
return resolveRef(node)->getStyle().alignContent();
return unscopedEnum(resolveRef(node)->getStyle().alignContent());
}
void YGNodeStyleSetAlignItems(const YGNodeRef node, const YGAlign alignItems) {
updateStyle<MSVC_HINT(alignItems)>(node, &Style::alignItems, alignItems);
updateStyle<MSVC_HINT(alignItems)>(
node, &Style::alignItems, scopedEnum(alignItems));
}
YGAlign YGNodeStyleGetAlignItems(const YGNodeConstRef node) {
return resolveRef(node)->getStyle().alignItems();
return unscopedEnum(resolveRef(node)->getStyle().alignItems());
}
void YGNodeStyleSetAlignSelf(const YGNodeRef node, const YGAlign alignSelf) {
updateStyle<MSVC_HINT(alignSelf)>(node, &Style::alignSelf, alignSelf);
updateStyle<MSVC_HINT(alignSelf)>(
node, &Style::alignSelf, scopedEnum(alignSelf));
}
YGAlign YGNodeStyleGetAlignSelf(const YGNodeConstRef node) {
return resolveRef(node)->getStyle().alignSelf();
return unscopedEnum(resolveRef(node)->getStyle().alignSelf());
}
void YGNodeStyleSetPositionType(
packages/react-native/ReactCommon/yoga/yoga/algorithm/Align.h
+4 -4
View File
@@ -14,14 +14,14 @@
namespace facebook::yoga {
inline YGAlign resolveChildAlignment(
inline Align resolveChildAlignment(
const yoga::Node* node,
const yoga::Node* child) {
const YGAlign align = child->getStyle().alignSelf() == YGAlignAuto
const Align align = child->getStyle().alignSelf() == Align::Auto
? node->getStyle().alignItems()
: child->getStyle().alignSelf();
if (align == YGAlignBaseline && isColumn(node->getStyle().flexDirection())) {
return YGAlignFlexStart;
if (align == Align::Baseline && isColumn(node->getStyle().flexDirection())) {
return Align::FlexStart;
}
return align;
}
packages/react-native/ReactCommon/yoga/yoga/algorithm/Baseline.cpp
+3 -3
View File
@@ -41,7 +41,7 @@ float calculateBaseline(const yoga::Node* node) {
if (child->getStyle().positionType() == YGPositionTypeAbsolute) {
continue;
}
if (resolveChildAlignment(node, child) == YGAlignBaseline ||
if (resolveChildAlignment(node, child) == Align::Baseline ||
child->isReferenceBaseline()) {
baselineChild = child;
break;
@@ -64,14 +64,14 @@ bool isBaselineLayout(const yoga::Node* node) {
if (isColumn(node->getStyle().flexDirection())) {
return false;
}
if (node->getStyle().alignItems() == YGAlignBaseline) {
if (node->getStyle().alignItems() == Align::Baseline) {
return true;
}
const auto childCount = node->getChildCount();
for (size_t i = 0; i < childCount; i++) {
auto child = node->getChild(i);
if (child->getStyle().positionType() != YGPositionTypeAbsolute &&
child->getStyle().alignSelf() == YGAlignBaseline) {
child->getStyle().alignSelf() == Align::Baseline) {
return true;
}
}
packages/react-native/ReactCommon/yoga/yoga/algorithm/CalculateLayout.cpp
+28 -28
View File
@@ -247,7 +247,7 @@ static void computeFlexBasisForChild(
const bool hasExactWidth =
!yoga::isUndefined(width) && widthMode == MeasureMode::Exactly;
const bool childWidthStretch =
resolveChildAlignment(node, child) == YGAlignStretch &&
resolveChildAlignment(node, child) == Align::Stretch &&
childWidthMeasureMode != MeasureMode::Exactly;
if (!isMainAxisRow && !isRowStyleDimDefined && hasExactWidth &&
childWidthStretch) {
@@ -263,7 +263,7 @@ static void computeFlexBasisForChild(
const bool hasExactHeight =
!yoga::isUndefined(height) && heightMode == MeasureMode::Exactly;
const bool childHeightStretch =
resolveChildAlignment(node, child) == YGAlignStretch &&
resolveChildAlignment(node, child) == Align::Stretch &&
childHeightMeasureMode != MeasureMode::Exactly;
if (isMainAxisRow && !isColumnStyleDimDefined && hasExactHeight &&
childHeightStretch) {
@@ -511,7 +511,7 @@ static void layoutAbsoluteChild(
} else if (
!child->isLeadingPositionDefined(crossAxis) &&
resolveChildAlignment(node, child) == YGAlignCenter) {
resolveChildAlignment(node, child) == Align::Center) {
child->setLayoutPosition(
(node->getLayout().measuredDimensions[dimension(crossAxis)] -
child->getLayout().measuredDimensions[dimension(crossAxis)]) /
@@ -519,7 +519,7 @@ static void layoutAbsoluteChild(
leadingEdge(crossAxis));
} else if (
!child->isLeadingPositionDefined(crossAxis) &&
((resolveChildAlignment(node, child) == YGAlignFlexEnd) ^
((resolveChildAlignment(node, child) == Align::FlexEnd) ^
(node->getStyle().flexWrap() == YGWrapWrapReverse))) {
child->setLayoutPosition(
(node->getLayout().measuredDimensions[dimension(crossAxis)] -
@@ -959,7 +959,7 @@ static float distributeFreeSpaceSecondPass(
currentLineChild, crossAxis, availableInnerCrossDim) &&
measureModeCrossDim == MeasureMode::Exactly &&
!(isNodeFlexWrap && mainAxisOverflows) &&
resolveChildAlignment(node, currentLineChild) == YGAlignStretch &&
resolveChildAlignment(node, currentLineChild) == Align::Stretch &&
currentLineChild->marginLeadingValue(crossAxis).unit != YGUnitAuto &&
currentLineChild->marginTrailingValue(crossAxis).unit != YGUnitAuto) {
childCrossSize = availableInnerCrossDim;
@@ -1005,7 +1005,7 @@ static float distributeFreeSpaceSecondPass(
const bool requiresStretchLayout =
!styleDefinesDimension(
currentLineChild, crossAxis, availableInnerCrossDim) &&
resolveChildAlignment(node, currentLineChild) == YGAlignStretch &&
resolveChildAlignment(node, currentLineChild) == Align::Stretch &&
currentLineChild->marginLeadingValue(crossAxis).unit != YGUnitAuto &&
currentLineChild->marginTrailingValue(crossAxis).unit != YGUnitAuto;
@@ -1898,12 +1898,12 @@ static void calculateLayoutImpl(
// For a relative children, we're either using alignItems (owner) or
// alignSelf (child) in order to determine the position in the cross
// axis
const YGAlign alignItem = resolveChildAlignment(node, child);
const Align alignItem = resolveChildAlignment(node, child);
// If the child uses align stretch, we need to lay it out one more
// time, this time forcing the cross-axis size to be the computed
// cross size for the current line.
if (alignItem == YGAlignStretch &&
if (alignItem == Align::Stretch &&
child->marginLeadingValue(crossAxis).unit != YGUnitAuto &&
child->marginTrailingValue(crossAxis).unit != YGUnitAuto) {
// If the child defines a definite size for its cross axis, there's
@@ -1949,7 +1949,7 @@ static void calculateLayoutImpl(
auto alignContent = node->getStyle().alignContent();
auto crossAxisDoesNotGrow =
alignContent != YGAlignStretch && isNodeFlexWrap;
alignContent != Align::Stretch && isNodeFlexWrap;
const MeasureMode childWidthMeasureMode =
yoga::isUndefined(childWidth) ||
(!isMainAxisRow && crossAxisDoesNotGrow)
@@ -1990,9 +1990,9 @@ static void calculateLayoutImpl(
} else if (
child->marginLeadingValue(crossAxis).unit == YGUnitAuto) {
leadingCrossDim += yoga::maxOrDefined(0.0f, remainingCrossDim);
} else if (alignItem == YGAlignFlexStart) {
} else if (alignItem == Align::FlexStart) {
// No-Op
} else if (alignItem == YGAlignCenter) {
} else if (alignItem == Align::Center) {
leadingCrossDim += remainingCrossDim / 2;
} else {
leadingCrossDim += remainingCrossDim;
@@ -2022,19 +2022,19 @@ static void calculateLayoutImpl(
const float remainingAlignContentDim =
availableInnerCrossDim - totalLineCrossDim;
switch (node->getStyle().alignContent()) {
case YGAlignFlexEnd:
case Align::FlexEnd:
currentLead += remainingAlignContentDim;
break;
case YGAlignCenter:
case Align::Center:
currentLead += remainingAlignContentDim / 2;
break;
case YGAlignStretch:
case Align::Stretch:
if (availableInnerCrossDim > totalLineCrossDim) {
crossDimLead =
remainingAlignContentDim / static_cast<float>(lineCount);
}
break;
case YGAlignSpaceAround:
case Align::SpaceAround:
if (availableInnerCrossDim > totalLineCrossDim) {
currentLead +=
remainingAlignContentDim / (2 * static_cast<float>(lineCount));
@@ -2046,15 +2046,15 @@ static void calculateLayoutImpl(
currentLead += remainingAlignContentDim / 2;
}
break;
case YGAlignSpaceBetween:
case Align::SpaceBetween:
if (availableInnerCrossDim > totalLineCrossDim && lineCount > 1) {
crossDimLead =
remainingAlignContentDim / static_cast<float>(lineCount - 1);
}
break;
case YGAlignAuto:
case YGAlignFlexStart:
case YGAlignBaseline:
case Align::Auto:
case Align::FlexStart:
case Align::Baseline:
break;
}
}
@@ -2083,7 +2083,7 @@ static void calculateLayoutImpl(
child->getMarginForAxis(crossAxis, availableInnerWidth)
.unwrap());
}
if (resolveChildAlignment(node, child) == YGAlignBaseline) {
if (resolveChildAlignment(node, child) == Align::Baseline) {
const float ascent = calculateBaseline(child) +
child
->getLeadingMargin(
@@ -2117,7 +2117,7 @@ static void calculateLayoutImpl(
}
if (child->getStyle().positionType() != YGPositionTypeAbsolute) {
switch (resolveChildAlignment(node, child)) {
case YGAlignFlexStart: {
case Align::FlexStart: {
child->setLayoutPosition(
currentLead +
child->getLeadingMargin(crossAxis, availableInnerWidth)
@@ -2125,7 +2125,7 @@ static void calculateLayoutImpl(
leadingEdge(crossAxis));
break;
}
case YGAlignFlexEnd: {
case Align::FlexEnd: {
child->setLayoutPosition(
currentLead + lineHeight -
child->getTrailingMargin(crossAxis, availableInnerWidth)
@@ -2135,7 +2135,7 @@ static void calculateLayoutImpl(
leadingEdge(crossAxis));
break;
}
case YGAlignCenter: {
case Align::Center: {
float childHeight =
child->getLayout().measuredDimensions[dimension(crossAxis)];
@@ -2144,7 +2144,7 @@ static void calculateLayoutImpl(
leadingEdge(crossAxis));
break;
}
case YGAlignStretch: {
case Align::Stretch: {
child->setLayoutPosition(
currentLead +
child->getLeadingMargin(crossAxis, availableInnerWidth)
@@ -2195,7 +2195,7 @@ static void calculateLayoutImpl(
}
break;
}
case YGAlignBaseline: {
case Align::Baseline: {
child->setLayoutPosition(
currentLead + maxAscentForCurrentLine -
calculateBaseline(child) +
@@ -2207,9 +2207,9 @@ static void calculateLayoutImpl(
break;
}
case YGAlignAuto:
case YGAlignSpaceBetween:
case YGAlignSpaceAround:
case Align::Auto:
case Align::SpaceBetween:
case Align::SpaceAround:
break;
}
}
packages/react-native/ReactCommon/yoga/yoga/debug/NodeToString.cpp
+3 -3
View File
@@ -150,15 +150,15 @@ void nodeToString(
}
if (style.alignItems() != yoga::Node{}.getStyle().alignItems()) {
appendFormattedString(
str, "align-items: %s; ", YGAlignToString(style.alignItems()));
str, "align-items: %s; ", toString(style.alignItems()));
}
if (style.alignContent() != yoga::Node{}.getStyle().alignContent()) {
appendFormattedString(
str, "align-content: %s; ", YGAlignToString(style.alignContent()));
str, "align-content: %s; ", toString(style.alignContent()));
}
if (style.alignSelf() != yoga::Node{}.getStyle().alignSelf()) {
appendFormattedString(
str, "align-self: %s; ", YGAlignToString(style.alignSelf()));
str, "align-self: %s; ", toString(style.alignSelf()));
}
appendFloatOptionalIfDefined(str, "flex-grow", style.flexGrow());
appendFloatOptionalIfDefined(str, "flex-shrink", style.flexShrink());
packages/react-native/ReactCommon/yoga/yoga/node/Node.h
+1 -1
View File
@@ -52,7 +52,7 @@ class YG_EXPORT Node : public ::YGNode {
void useWebDefaults() {
style_.flexDirection() = FlexDirection::Row;
style_.alignContent() = YGAlignStretch;
style_.alignContent() = Align::Stretch;
}
// DANGER DANGER DANGER!
packages/react-native/ReactCommon/yoga/yoga/style/Style.h
+15 -14
View File
@@ -15,6 +15,7 @@
#include <yoga/Yoga.h>
#include <yoga/bits/NumericBitfield.h>
#include <yoga/enums/Align.h>
#include <yoga/enums/Direction.h>
#include <yoga/enums/FlexDirection.h>
#include <yoga/enums/Justify.h>
@@ -95,8 +96,8 @@ class YG_EXPORT Style {
};
Style() {
alignContent() = YGAlignFlexStart;
alignItems() = YGAlignStretch;
alignContent() = Align::FlexStart;
alignItems() = Align::Stretch;
}
~Style() = default;
@@ -109,11 +110,11 @@ class YG_EXPORT Style {
static constexpr uint8_t alignContentOffset =
justifyContentOffset + minimumBitCount<Justify>();
static constexpr uint8_t alignItemsOffset =
alignContentOffset + minimumBitCount<YGAlign>();
alignContentOffset + minimumBitCount<Align>();
static constexpr uint8_t alignSelfOffset =
alignItemsOffset + minimumBitCount<YGAlign>();
alignItemsOffset + minimumBitCount<Align>();
static constexpr uint8_t positionTypeOffset =
alignSelfOffset + minimumBitCount<YGAlign>();
alignSelfOffset + minimumBitCount<Align>();
static constexpr uint8_t flexWrapOffset =
positionTypeOffset + minimumBitCount<YGPositionType>();
static constexpr uint8_t overflowOffset =
@@ -163,24 +164,24 @@ class YG_EXPORT Style {
return {*this, justifyContentOffset};
}
YGAlign alignContent() const {
return getEnumData<YGAlign>(flags, alignContentOffset);
Align alignContent() const {
return getEnumData<Align>(flags, alignContentOffset);
}
BitfieldRef<YGAlign> alignContent() {
BitfieldRef<Align> alignContent() {
return {*this, alignContentOffset};
}
YGAlign alignItems() const {
return getEnumData<YGAlign>(flags, alignItemsOffset);
Align alignItems() const {
return getEnumData<Align>(flags, alignItemsOffset);
}
BitfieldRef<YGAlign> alignItems() {
BitfieldRef<Align> alignItems() {
return {*this, alignItemsOffset};
}
YGAlign alignSelf() const {
return getEnumData<YGAlign>(flags, alignSelfOffset);
Align alignSelf() const {
return getEnumData<Align>(flags, alignSelfOffset);
}
BitfieldRef<YGAlign> alignSelf() {
BitfieldRef<Align> alignSelf() {
return {*this, alignSelfOffset};
}