Skip to content

Align resolve function names to have similiar namings #471

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
woehrl01 wants to merge 2 commits into from
Closed

Align resolve function names to have similiar namings #471

Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
8f3b98e
align resolve function names
woehrl01 Mar 9, 2017
2c231f1
resolve margin name
woehrl01 Mar 9, 2017
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
102 changes: 51 additions & 51 deletions yoga/Yoga.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -290,7 +290,7 @@ static inline const YGValue *YGComputedEdgeValue(const YGValue edges[YGEdgeCount
return defaultValue;
}

static inline float YGValueResolve(const YGValue *const value, const float parentSize) {
static inline float YGResolveValue(const YGValue *const value, const float parentSize) {
switch (value->unit) {
case YGUnitUndefined:
case YGUnitAuto:
Expand All @@ -303,8 +303,8 @@ static inline float YGValueResolve(const YGValue *const value, const float paren
return YGUndefined;
}

static inline float YGValueResolveMargin(const YGValue *const value, const float parentSize) {
return value->unit == YGUnitAuto ? 0 : YGValueResolve(value, parentSize);
static inline float YGResolveValueMargin(const YGValue *const value, const float parentSize) {
return value->unit == YGUnitAuto ? 0 : YGResolveValue(value, parentSize);
}

int32_t gNodeInstanceCount = 0;
Expand Down Expand Up @@ -1001,33 +1001,33 @@ static inline float YGNodeLeadingMargin(const YGNodeRef node,
const YGFlexDirection axis,
const float widthSize) {
if (YGFlexDirectionIsRow(axis) && node->style.margin[YGEdgeStart].unit != YGUnitUndefined) {
return YGValueResolveMargin(&node->style.margin[YGEdgeStart], widthSize);
return YGResolveValueMargin(&node->style.margin[YGEdgeStart], widthSize);
}

return YGValueResolveMargin(YGComputedEdgeValue(node->style.margin, leading[axis], &YGValueZero),
return YGResolveValueMargin(YGComputedEdgeValue(node->style.margin, leading[axis], &YGValueZero),
widthSize);
}

static float YGNodeTrailingMargin(const YGNodeRef node,
const YGFlexDirection axis,
const float widthSize) {
if (YGFlexDirectionIsRow(axis) && node->style.margin[YGEdgeEnd].unit != YGUnitUndefined) {
return YGValueResolveMargin(&node->style.margin[YGEdgeEnd], widthSize);
return YGResolveValueMargin(&node->style.margin[YGEdgeEnd], widthSize);
}

return YGValueResolveMargin(YGComputedEdgeValue(node->style.margin, trailing[axis], &YGValueZero),
return YGResolveValueMargin(YGComputedEdgeValue(node->style.margin, trailing[axis], &YGValueZero),
widthSize);
}

static float YGNodeLeadingPadding(const YGNodeRef node,
const YGFlexDirection axis,
const float widthSize) {
if (YGFlexDirectionIsRow(axis) && node->style.padding[YGEdgeStart].unit != YGUnitUndefined &&
YGValueResolve(&node->style.padding[YGEdgeStart], widthSize) >= 0.0f) {
return YGValueResolve(&node->style.padding[YGEdgeStart], widthSize);
YGResolveValue(&node->style.padding[YGEdgeStart], widthSize) >= 0.0f) {
return YGResolveValue(&node->style.padding[YGEdgeStart], widthSize);
}

return fmaxf(YGValueResolve(YGComputedEdgeValue(node->style.padding, leading[axis], &YGValueZero),
return fmaxf(YGResolveValue(YGComputedEdgeValue(node->style.padding, leading[axis], &YGValueZero),
widthSize),
0.0f);
}
Expand All @@ -1036,11 +1036,11 @@ static float YGNodeTrailingPadding(const YGNodeRef node,
const YGFlexDirection axis,
const float widthSize) {
if (YGFlexDirectionIsRow(axis) && node->style.padding[YGEdgeEnd].unit != YGUnitUndefined &&
YGValueResolve(&node->style.padding[YGEdgeEnd], widthSize) >= 0.0f) {
return YGValueResolve(&node->style.padding[YGEdgeEnd], widthSize);
YGResolveValue(&node->style.padding[YGEdgeEnd], widthSize) >= 0.0f) {
return YGResolveValue(&node->style.padding[YGEdgeEnd], widthSize);
}

return fmaxf(YGValueResolve(YGComputedEdgeValue(node->style.padding, trailing[axis], &YGValueZero),
return fmaxf(YGResolveValue(YGComputedEdgeValue(node->style.padding, trailing[axis], &YGValueZero),
widthSize),
0.0f);
}
Expand Down Expand Up @@ -1143,7 +1143,7 @@ static float YGBaseline(const YGNodeRef node) {
return baseline + baselineChild->layout.position[YGEdgeTop];
}

static inline YGFlexDirection YGFlexDirectionResolve(const YGFlexDirection flexDirection,
static inline YGFlexDirection YGResolveFlexDirection(const YGFlexDirection flexDirection,
const YGDirection direction) {
if (direction == YGDirectionRTL) {
if (flexDirection == YGFlexDirectionRow) {
Expand All @@ -1159,7 +1159,7 @@ static inline YGFlexDirection YGFlexDirectionResolve(const YGFlexDirection flexD
static YGFlexDirection YGFlexDirectionCross(const YGFlexDirection flexDirection,
const YGDirection direction) {
return YGFlexDirectionIsColumn(flexDirection)
? YGFlexDirectionResolve(YGFlexDirectionRow, direction)
? YGResolveFlexDirection(YGFlexDirectionRow, direction)
: YGFlexDirectionColumn;
}

Expand Down Expand Up @@ -1233,15 +1233,15 @@ static float YGNodeLeadingPosition(const YGNodeRef node,
const YGValue *leadingPosition =
YGComputedEdgeValue(node->style.position, YGEdgeStart, &YGValueUndefined);
if (leadingPosition->unit != YGUnitUndefined) {
return YGValueResolve(leadingPosition, axisSize);
return YGResolveValue(leadingPosition, axisSize);
}
}

const YGValue *leadingPosition =
YGComputedEdgeValue(node->style.position, leading[axis], &YGValueUndefined);

return leadingPosition->unit == YGUnitUndefined ? 0.0f
: YGValueResolve(leadingPosition, axisSize);
: YGResolveValue(leadingPosition, axisSize);
}

static float YGNodeTrailingPosition(const YGNodeRef node,
Expand All @@ -1251,15 +1251,15 @@ static float YGNodeTrailingPosition(const YGNodeRef node,
const YGValue *trailingPosition =
YGComputedEdgeValue(node->style.position, YGEdgeEnd, &YGValueUndefined);
if (trailingPosition->unit != YGUnitUndefined) {
return YGValueResolve(trailingPosition, axisSize);
return YGResolveValue(trailingPosition, axisSize);
}
}

const YGValue *trailingPosition =
YGComputedEdgeValue(node->style.position, trailing[axis], &YGValueUndefined);

return trailingPosition->unit == YGUnitUndefined ? 0.0f
: YGValueResolve(trailingPosition, axisSize);
: YGResolveValue(trailingPosition, axisSize);
}

static float YGNodeBoundAxisWithinMinAndMax(const YGNodeRef node,
Expand All @@ -1270,11 +1270,11 @@ static float YGNodeBoundAxisWithinMinAndMax(const YGNodeRef node,
float max = YGUndefined;

if (YGFlexDirectionIsColumn(axis)) {
min = YGValueResolve(&node->style.minDimensions[YGDimensionHeight], axisSize);
max = YGValueResolve(&node->style.maxDimensions[YGDimensionHeight], axisSize);
min = YGResolveValue(&node->style.minDimensions[YGDimensionHeight], axisSize);
max = YGResolveValue(&node->style.maxDimensions[YGDimensionHeight], axisSize);
} else if (YGFlexDirectionIsRow(axis)) {
min = YGValueResolve(&node->style.minDimensions[YGDimensionWidth], axisSize);
max = YGValueResolve(&node->style.maxDimensions[YGDimensionWidth], axisSize);
min = YGResolveValue(&node->style.minDimensions[YGDimensionWidth], axisSize);
max = YGResolveValue(&node->style.maxDimensions[YGDimensionWidth], axisSize);
}

float boundValue = value;
Expand Down Expand Up @@ -1341,7 +1341,7 @@ static void YGConstrainMaxSizeForMode(const YGNodeRef node,
const float parentWidth,
YGMeasureMode *mode,
float *size) {
const float maxSize = YGValueResolve(&node->style.maxDimensions[dim[axis]], parentAxisSize) +
const float maxSize = YGResolveValue(&node->style.maxDimensions[dim[axis]], parentAxisSize) +
YGNodeMarginForAxis(node, axis, parentWidth);
switch (*mode) {
case YGMeasureModeExactly:
Expand All @@ -1362,7 +1362,7 @@ static void YGNodeSetPosition(const YGNodeRef node,
const float mainSize,
const float crossSize,
const float parentWidth) {
const YGFlexDirection mainAxis = YGFlexDirectionResolve(node->style.flexDirection, direction);
const YGFlexDirection mainAxis = YGResolveFlexDirection(node->style.flexDirection, direction);
const YGFlexDirection crossAxis = YGFlexDirectionCross(mainAxis, direction);
const float relativePositionMain = YGNodeRelativePosition(node, mainAxis, mainSize);
const float relativePositionCross = YGNodeRelativePosition(node, crossAxis, crossSize);
Expand All @@ -1387,7 +1387,7 @@ static void YGNodeComputeFlexBasisForChild(const YGNodeRef node,
const YGMeasureMode heightMode,
const YGDirection direction,
const YGConfigRef config) {
const YGFlexDirection mainAxis = YGFlexDirectionResolve(node->style.flexDirection, direction);
const YGFlexDirection mainAxis = YGResolveFlexDirection(node->style.flexDirection, direction);
const bool isMainAxisRow = YGFlexDirectionIsRow(mainAxis);
const float mainAxisSize = isMainAxisRow ? width : height;
const float mainAxisParentSize = isMainAxisRow ? parentWidth : parentHeight;
Expand All @@ -1398,7 +1398,7 @@ static void YGNodeComputeFlexBasisForChild(const YGNodeRef node,
YGMeasureMode childHeightMeasureMode;

const float resolvedFlexBasis =
YGValueResolve(YGNodeResolveFlexBasisPtr(child), mainAxisParentSize);
YGResolveValue(YGNodeResolveFlexBasisPtr(child), mainAxisParentSize);
const bool isRowStyleDimDefined = YGNodeIsStyleDimDefined(child, YGFlexDirectionRow, parentWidth);
const bool isColumnStyleDimDefined =
YGNodeIsStyleDimDefined(child, YGFlexDirectionColumn, parentHeight);
Expand All @@ -1413,12 +1413,12 @@ static void YGNodeComputeFlexBasisForChild(const YGNodeRef node,
} else if (isMainAxisRow && isRowStyleDimDefined) {
// The width is definite, so use that as the flex basis.
child->layout.computedFlexBasis =
fmaxf(YGValueResolve(child->resolvedDimensions[YGDimensionWidth], parentWidth),
fmaxf(YGResolveValue(child->resolvedDimensions[YGDimensionWidth], parentWidth),
YGNodePaddingAndBorderForAxis(child, YGFlexDirectionRow, parentWidth));
} else if (!isMainAxisRow && isColumnStyleDimDefined) {
// The height is definite, so use that as the flex basis.
child->layout.computedFlexBasis =
fmaxf(YGValueResolve(child->resolvedDimensions[YGDimensionHeight], parentHeight),
fmaxf(YGResolveValue(child->resolvedDimensions[YGDimensionHeight], parentHeight),
YGNodePaddingAndBorderForAxis(child, YGFlexDirectionColumn, parentWidth));
} else {
// Compute the flex basis and hypothetical main size (i.e. the clamped
Expand All @@ -1433,12 +1433,12 @@ static void YGNodeComputeFlexBasisForChild(const YGNodeRef node,

if (isRowStyleDimDefined) {
childWidth =
YGValueResolve(child->resolvedDimensions[YGDimensionWidth], parentWidth) + marginRow;
YGResolveValue(child->resolvedDimensions[YGDimensionWidth], parentWidth) + marginRow;
childWidthMeasureMode = YGMeasureModeExactly;
}
if (isColumnStyleDimDefined) {
childHeight =
YGValueResolve(child->resolvedDimensions[YGDimensionHeight], parentHeight) + marginColumn;
YGResolveValue(child->resolvedDimensions[YGDimensionHeight], parentHeight) + marginColumn;
childHeightMeasureMode = YGMeasureModeExactly;
}

Expand Down Expand Up @@ -1521,7 +1521,7 @@ static void YGNodeAbsoluteLayoutChild(const YGNodeRef node,
const float height,
const YGDirection direction,
const YGConfigRef config) {
const YGFlexDirection mainAxis = YGFlexDirectionResolve(node->style.flexDirection, direction);
const YGFlexDirection mainAxis = YGResolveFlexDirection(node->style.flexDirection, direction);
const YGFlexDirection crossAxis = YGFlexDirectionCross(mainAxis, direction);
const bool isMainAxisRow = YGFlexDirectionIsRow(mainAxis);

Expand All @@ -1534,7 +1534,7 @@ static void YGNodeAbsoluteLayoutChild(const YGNodeRef node,
const float marginColumn = YGNodeMarginForAxis(child, YGFlexDirectionColumn, width);

if (YGNodeIsStyleDimDefined(child, YGFlexDirectionRow, width)) {
childWidth = YGValueResolve(child->resolvedDimensions[YGDimensionWidth], width) + marginRow;
childWidth = YGResolveValue(child->resolvedDimensions[YGDimensionWidth], width) + marginRow;
} else {
// If the child doesn't have a specified width, compute the width based
// on the left/right
Expand All @@ -1552,7 +1552,7 @@ static void YGNodeAbsoluteLayoutChild(const YGNodeRef node,

if (YGNodeIsStyleDimDefined(child, YGFlexDirectionColumn, height)) {
childHeight =
YGValueResolve(child->resolvedDimensions[YGDimensionHeight], height) + marginColumn;
YGResolveValue(child->resolvedDimensions[YGDimensionHeight], height) + marginColumn;
} else {
// If the child doesn't have a specified height, compute the height
// based on the top/bottom
Expand Down Expand Up @@ -1925,9 +1925,9 @@ static void YGNodelayoutImpl(const YGNodeRef node,
const YGDirection direction = YGNodeResolveDirection(node, parentDirection);
node->layout.direction = direction;

const YGFlexDirection flexRowDirection = YGFlexDirectionResolve(YGFlexDirectionRow, direction);
const YGFlexDirection flexRowDirection = YGResolveFlexDirection(YGFlexDirectionRow, direction);
const YGFlexDirection flexColumnDirection =
YGFlexDirectionResolve(YGFlexDirectionColumn, direction);
YGResolveFlexDirection(YGFlexDirectionColumn, direction);

node->layout.margin[YGEdgeStart] = YGNodeLeadingMargin(node, flexRowDirection, parentWidth);
node->layout.margin[YGEdgeEnd] = YGNodeTrailingMargin(node, flexRowDirection, parentWidth);
Expand Down Expand Up @@ -1981,7 +1981,7 @@ static void YGNodelayoutImpl(const YGNodeRef node,
}

// STEP 1: CALCULATE VALUES FOR REMAINDER OF ALGORITHM
const YGFlexDirection mainAxis = YGFlexDirectionResolve(node->style.flexDirection, direction);
const YGFlexDirection mainAxis = YGResolveFlexDirection(node->style.flexDirection, direction);
const YGFlexDirection crossAxis = YGFlexDirectionCross(mainAxis, direction);
const bool isMainAxisRow = YGFlexDirectionIsRow(mainAxis);
const YGJustify justifyContent = node->style.justifyContent;
Expand Down Expand Up @@ -2016,16 +2016,16 @@ static void YGNodelayoutImpl(const YGNodeRef node,

// STEP 2: DETERMINE AVAILABLE SIZE IN MAIN AND CROSS DIRECTIONS
const float minInnerWidth =
YGValueResolve(&node->style.minDimensions[YGDimensionWidth], parentWidth) - marginAxisRow -
YGResolveValue(&node->style.minDimensions[YGDimensionWidth], parentWidth) - marginAxisRow -
paddingAndBorderAxisRow;
const float maxInnerWidth =
YGValueResolve(&node->style.maxDimensions[YGDimensionWidth], parentWidth) - marginAxisRow -
YGResolveValue(&node->style.maxDimensions[YGDimensionWidth], parentWidth) - marginAxisRow -
paddingAndBorderAxisRow;
const float minInnerHeight =
YGValueResolve(&node->style.minDimensions[YGDimensionHeight], parentHeight) -
YGResolveValue(&node->style.minDimensions[YGDimensionHeight], parentHeight) -
marginAxisColumn - paddingAndBorderAxisColumn;
const float maxInnerHeight =
YGValueResolve(&node->style.maxDimensions[YGDimensionHeight], parentHeight) -
YGResolveValue(&node->style.maxDimensions[YGDimensionHeight], parentHeight) -
marginAxisColumn - paddingAndBorderAxisColumn;
const float minInnerMainDim = isMainAxisRow ? minInnerWidth : minInnerHeight;
const float maxInnerMainDim = isMainAxisRow ? maxInnerWidth : maxInnerHeight;
Expand Down Expand Up @@ -2173,7 +2173,7 @@ static void YGNodelayoutImpl(const YGNodeRef node,

if (child->style.positionType != YGPositionTypeAbsolute) {
const float outerFlexBasis =
fmaxf(YGValueResolve(&child->style.minDimensions[dim[mainAxis]], mainAxisParentSize),
fmaxf(YGResolveValue(&child->style.minDimensions[dim[mainAxis]], mainAxisParentSize),
child->layout.computedFlexBasis) +
YGNodeMarginForAxis(child, mainAxis, availableInnerWidth);

Expand Down Expand Up @@ -2416,7 +2416,7 @@ static void YGNodelayoutImpl(const YGNodeRef node,
childCrossMeasureMode =
YGFloatIsUndefined(childCrossSize) ? YGMeasureModeUndefined : YGMeasureModeAtMost;
} else {
childCrossSize = YGValueResolve(currentRelativeChild->resolvedDimensions[dim[crossAxis]],
childCrossSize = YGResolveValue(currentRelativeChild->resolvedDimensions[dim[crossAxis]],
availableInnerCrossDim) +
marginCross;
const bool isLoosePercentageMeasurement =
Expand Down Expand Up @@ -2506,10 +2506,10 @@ static void YGNodelayoutImpl(const YGNodeRef node,

if (measureModeMainDim == YGMeasureModeAtMost && remainingFreeSpace > 0) {
if (node->style.minDimensions[dim[mainAxis]].unit != YGUnitUndefined &&
YGValueResolve(&node->style.minDimensions[dim[mainAxis]], mainAxisParentSize) >= 0) {
YGResolveValue(&node->style.minDimensions[dim[mainAxis]], mainAxisParentSize) >= 0) {
remainingFreeSpace =
fmaxf(0,
YGValueResolve(&node->style.minDimensions[dim[mainAxis]], mainAxisParentSize) -
YGResolveValue(&node->style.minDimensions[dim[mainAxis]], mainAxisParentSize) -
(availableInnerMainDim - remainingFreeSpace));
} else {
remainingFreeSpace = 0;
Expand Down Expand Up @@ -3386,11 +3386,11 @@ void YGNodeCalculateLayout(const YGNodeRef node,
float width = YGUndefined;
YGMeasureMode widthMeasureMode = YGMeasureModeUndefined;
if (YGNodeIsStyleDimDefined(node, YGFlexDirectionRow, parentWidth)) {
width = YGValueResolve(node->resolvedDimensions[dim[YGFlexDirectionRow]], parentWidth) +
width = YGResolveValue(node->resolvedDimensions[dim[YGFlexDirectionRow]], parentWidth) +
YGNodeMarginForAxis(node, YGFlexDirectionRow, parentWidth);
widthMeasureMode = YGMeasureModeExactly;
} else if (YGValueResolve(&node->style.maxDimensions[YGDimensionWidth], parentWidth) >= 0.0f) {
width = YGValueResolve(&node->style.maxDimensions[YGDimensionWidth], parentWidth);
} else if (YGResolveValue(&node->style.maxDimensions[YGDimensionWidth], parentWidth) >= 0.0f) {
width = YGResolveValue(&node->style.maxDimensions[YGDimensionWidth], parentWidth);
widthMeasureMode = YGMeasureModeAtMost;
} else {
width = parentWidth;
Expand All @@ -3400,12 +3400,12 @@ void YGNodeCalculateLayout(const YGNodeRef node,
float height = YGUndefined;
YGMeasureMode heightMeasureMode = YGMeasureModeUndefined;
if (YGNodeIsStyleDimDefined(node, YGFlexDirectionColumn, parentHeight)) {
height = YGValueResolve(node->resolvedDimensions[dim[YGFlexDirectionColumn]], parentHeight) +
height = YGResolveValue(node->resolvedDimensions[dim[YGFlexDirectionColumn]], parentHeight) +
YGNodeMarginForAxis(node, YGFlexDirectionColumn, parentWidth);
heightMeasureMode = YGMeasureModeExactly;
} else if (YGValueResolve(&node->style.maxDimensions[YGDimensionHeight], parentHeight) >=
} else if (YGResolveValue(&node->style.maxDimensions[YGDimensionHeight], parentHeight) >=
0.0f) {
height = YGValueResolve(&node->style.maxDimensions[YGDimensionHeight], parentHeight);
height = YGResolveValue(&node->style.maxDimensions[YGDimensionHeight], parentHeight);
heightMeasureMode = YGMeasureModeAtMost;
} else {
height = parentHeight;
Expand Down