From 029b877d2ef46cf4c5c8307d6c8911b185f41527 Mon Sep 17 00:00:00 2001 From: vvveiii Date: Sat, 15 Aug 2020 14:52:10 +0800 Subject: [PATCH] [Yoga] replace float with YGFloat - pass all unit tests --- YogaKit/Source/YGLayout.m | 23 +- YogaKit/Tests/YogaKitTests.m | 12 + yoga/Utils.cpp | 12 +- yoga/Utils.h | 36 +-- yoga/YGConfig.h | 2 +- yoga/YGFloatOptional.h | 14 +- yoga/YGLayout.h | 12 +- yoga/YGMacros.h | 15 ++ yoga/YGNode.cpp | 52 ++-- yoga/YGNode.h | 54 ++-- yoga/YGValue.h | 2 +- yoga/Yoga-internal.h | 22 +- yoga/Yoga.cpp | 492 +++++++++++++++++------------------ yoga/Yoga.h | 114 ++++---- yoga/event/event.h | 8 +- 15 files changed, 446 insertions(+), 424 deletions(-) diff --git a/YogaKit/Source/YGLayout.m b/YogaKit/Source/YGLayout.m index 7acdc64a..b3baa8f5 100644 --- a/YogaKit/Source/YGLayout.m +++ b/YogaKit/Source/YGLayout.m @@ -375,9 +375,9 @@ YG_PROPERTY(CGFloat, aspectRatio, AspectRatio) static YGSize YGMeasureView( YGNodeRef node, - float width, + YGFloat width, YGMeasureMode widthMode, - float height, + YGFloat height, YGMeasureMode heightMode) { const CGFloat constrainedWidth = (widthMode == YGMeasureModeUndefined) ? CGFLOAT_MAX : width; @@ -409,9 +409,9 @@ static YGSize YGMeasureView( } return (YGSize){ - .width = (float)YGSanitizeMeasurement( + .width = (YGFloat)YGSanitizeMeasurement( constrainedWidth, sizeThatFits.width, widthMode), - .height = (float)YGSanitizeMeasurement( + .height = (YGFloat)YGSanitizeMeasurement( constrainedHeight, sizeThatFits.height, heightMode), }; } @@ -488,11 +488,6 @@ static void YGRemoveAllChildren(const YGNodeRef node) { YGNodeRemoveAllChildren(node); } -static inline CGPoint YGRoundPixelPosition(CGPoint p) { - CGFloat scale = YGScaleFactor(); - return (CGPoint) { .x = round(p.x * scale) / scale, .y = round(p.y * scale) / scale }; -} - static inline CGSize YGAlignPixelSize(CGSize s) { CGFloat scale = YGScaleFactor(); return (CGSize) { .width = ceil(s.width * scale) / scale, .height = ceil(s.height * scale) / scale }; @@ -553,7 +548,7 @@ static void YGApplyLayoutToViewHierarchy(UIView* view, BOOL preserveOrigin) { } view.frame = (CGRect) { - .origin = YGRoundPixelPosition(frame.origin), + .origin = frame.origin, .size = YGAlignPixelSize(frame.size) }; #else @@ -562,10 +557,10 @@ static void YGApplyLayoutToViewHierarchy(UIView* view, BOOL preserveOrigin) { .size = YGAlignPixelSize(frame.size) }; - view.center = YGRoundPixelPosition((CGPoint) { - .x = CGRectGetMinX(frame) + CGRectGetWidth(frame) * 0.5, - .y = CGRectGetMinY(frame) + CGRectGetHeight(frame) * 0.5 - }); + view.center = (CGPoint) { + .x = CGRectGetMidX(frame), + .y = CGRectGetMidY(frame) + }; #endif if (!yoga.isLeaf) { diff --git a/YogaKit/Tests/YogaKitTests.m b/YogaKit/Tests/YogaKitTests.m index 29b02be6..11724826 100644 --- a/YogaKit/Tests/YogaKitTests.m +++ b/YogaKit/Tests/YogaKitTests.m @@ -265,16 +265,28 @@ subview1.yoga.flexGrow = 1; [container addSubview:subview1]; + UIView *leafView = [[UIView alloc] init]; + leafView.yoga.isEnabled = YES; + [subview1 addSubview:leafView]; + UIView* subview2 = [[UIView alloc] initWithFrame:CGRectZero]; subview2.yoga.isEnabled = YES; subview2.yoga.flexGrow = 1; [container addSubview:subview2]; + leafView = [[UIView alloc] init]; + leafView.yoga.isEnabled = YES; + [subview2 addSubview:leafView]; + UIView* subview3 = [[UIView alloc] initWithFrame:CGRectZero]; subview3.yoga.isEnabled = YES; subview3.yoga.flexGrow = 1; [container addSubview:subview3]; + leafView = [[UIView alloc] init]; + leafView.yoga.isEnabled = YES; + [subview3 addSubview:leafView]; + [container.yoga applyLayoutPreservingOrigin:YES]; XCTAssertEqualWithAccuracy( diff --git a/yoga/Utils.cpp b/yoga/Utils.cpp index edb198d2..f9c1dc6b 100644 --- a/yoga/Utils.cpp +++ b/yoga/Utils.cpp @@ -18,16 +18,16 @@ YGFlexDirection YGFlexDirectionCross( : YGFlexDirectionColumn; } -float YGFloatMax(const float a, const float b) { +YGFloat YGFloatMax(const YGFloat a, const YGFloat b) { if (!yoga::isUndefined(a) && !yoga::isUndefined(b)) { - return fmaxf(a, b); + return fmax(a, b); } return yoga::isUndefined(a) ? b : a; } -float YGFloatMin(const float a, const float b) { +YGFloat YGFloatMin(const YGFloat a, const YGFloat b) { if (!yoga::isUndefined(a) && !yoga::isUndefined(b)) { - return fminf(a, b); + return fmin(a, b); } return yoga::isUndefined(a) ? b : a; @@ -46,7 +46,7 @@ bool YGValueEqual(const YGValue& a, const YGValue& b) { return fabs(a.value - b.value) < 0.0001f; } -bool YGFloatsEqual(const float a, const float b) { +bool YGFloatsEqual(const YGFloat a, const YGFloat b) { if (!yoga::isUndefined(a) && !yoga::isUndefined(b)) { return fabs(a - b) < 0.0001f; } @@ -60,7 +60,7 @@ bool YGDoubleEqual(const double a, const double b) { return yoga::isUndefined(a) && yoga::isUndefined(b); } -float YGFloatSanitize(const float val) { +YGFloat YGFloatSanitize(const YGFloat val) { return yoga::isUndefined(val) ? 0 : val; } diff --git a/yoga/Utils.h b/yoga/Utils.h index 57e1d45d..3cc4f181 100644 --- a/yoga/Utils.h +++ b/yoga/Utils.h @@ -38,19 +38,19 @@ struct YGCollectFlexItemsRowValues { uint32_t itemsOnLine; - float sizeConsumedOnCurrentLine; - float totalFlexGrowFactors; - float totalFlexShrinkScaledFactors; + YGFloat sizeConsumedOnCurrentLine; + YGFloat totalFlexGrowFactors; + YGFloat totalFlexShrinkScaledFactors; uint32_t endOfLineIndex; std::vector relativeChildren; - float remainingFreeSpace; + YGFloat remainingFreeSpace; // The size of the mainDim for the row after considering size, padding, margin // and border of flex items. This is used to calculate maxLineDim after going // through all the rows to decide on the main axis size of owner. - float mainDim; + YGFloat mainDim; // The size of the crossDim for the row after considering size, padding, // margin and border of flex items. Used for calculating containers crossSize. - float crossDim; + YGFloat crossDim; }; bool YGValueEqual(const YGValue& a, const YGValue& b); @@ -60,27 +60,27 @@ inline bool YGValueEqual( return YGValueEqual((YGValue) a, (YGValue) b); } -// This custom float equality function returns true if either absolute +// This custom YGFloat equality function returns true if either absolute // difference between two floats is less than 0.0001f or both are undefined. -bool YGFloatsEqual(const float a, const float b); +bool YGFloatsEqual(const YGFloat a, const YGFloat b); bool YGDoubleEqual(const double a, const double b); -float YGFloatMax(const float a, const float b); +YGFloat YGFloatMax(const YGFloat a, const YGFloat b); YGFloatOptional YGFloatOptionalMax( const YGFloatOptional op1, const YGFloatOptional op2); -float YGFloatMin(const float a, const float b); +YGFloat YGFloatMin(const YGFloat a, const YGFloat b); -// This custom float comparison function compares the array of float with -// YGFloatsEqual, as the default float comparison operator will not work(Look +// This custom YGFloat comparison function compares the array of YGFloat with +// YGFloatsEqual, as the default YGFloat comparison operator will not work(Look // at the comments of YGFloatsEqual function). template bool YGFloatArrayEqual( - const std::array& val1, - const std::array& val2) { + const std::array& val1, + const std::array& val2) { bool areEqual = true; for (std::size_t i = 0; i < size && areEqual; ++i) { areEqual = YGFloatsEqual(val1[i], val2[i]); @@ -89,7 +89,7 @@ bool YGFloatArrayEqual( } // This function returns 0 if YGFloatIsUndefined(val) is true and val otherwise -float YGFloatSanitize(const float val); +YGFloat YGFloatSanitize(const YGFloat val); YGFlexDirection YGFlexDirectionCross( const YGFlexDirection flexDirection, @@ -102,7 +102,7 @@ inline bool YGFlexDirectionIsRow(const YGFlexDirection flexDirection) { inline YGFloatOptional YGResolveValue( const YGValue value, - const float ownerSize) { + const YGFloat ownerSize) { switch (value.unit) { case YGUnitPoint: return YGFloatOptional{value.value}; @@ -115,7 +115,7 @@ inline YGFloatOptional YGResolveValue( inline YGFloatOptional YGResolveValue( yoga::detail::CompactValue value, - float ownerSize) { + YGFloat ownerSize) { return YGResolveValue((YGValue) value, ownerSize); } @@ -140,7 +140,7 @@ inline YGFlexDirection YGResolveFlexDirection( inline YGFloatOptional YGResolveValueMargin( yoga::detail::CompactValue value, - const float ownerSize) { + const YGFloat ownerSize) { return value.isAuto() ? YGFloatOptional{0} : YGResolveValue(value, ownerSize); } diff --git a/yoga/YGConfig.h b/yoga/YGConfig.h index e87d6758..1154a002 100644 --- a/yoga/YGConfig.h +++ b/yoga/YGConfig.h @@ -40,7 +40,7 @@ public: bool useLegacyStretchBehaviour = false; bool shouldDiffLayoutWithoutLegacyStretchBehaviour = false; bool printTree = false; - float pointScaleFactor = 1.0f; + YGFloat pointScaleFactor = 1.0f; std::array()> experimentalFeatures = {}; void* context = nullptr; diff --git a/yoga/YGFloatOptional.h b/yoga/YGFloatOptional.h index e4cf0284..f7dfed5a 100644 --- a/yoga/YGFloatOptional.h +++ b/yoga/YGFloatOptional.h @@ -13,14 +13,14 @@ struct YGFloatOptional { private: - float value_ = std::numeric_limits::quiet_NaN(); + YGFloat value_ = std::numeric_limits::quiet_NaN(); public: - explicit constexpr YGFloatOptional(float value) : value_(value) {} + explicit constexpr YGFloatOptional(YGFloat value) : value_(value) {} constexpr YGFloatOptional() = default; // returns the wrapped value, or a value x with YGIsUndefined(x) == true - constexpr float unwrap() const { return value_; } + constexpr YGFloat unwrap() const { return value_; } bool isUndefined() const { return std::isnan(value_); } }; @@ -35,17 +35,17 @@ inline bool operator!=(YGFloatOptional lhs, YGFloatOptional rhs) { return !(lhs == rhs); } -inline bool operator==(YGFloatOptional lhs, float rhs) { +inline bool operator==(YGFloatOptional lhs, YGFloat rhs) { return lhs == YGFloatOptional{rhs}; } -inline bool operator!=(YGFloatOptional lhs, float rhs) { +inline bool operator!=(YGFloatOptional lhs, YGFloat rhs) { return !(lhs == rhs); } -inline bool operator==(float lhs, YGFloatOptional rhs) { +inline bool operator==(YGFloat lhs, YGFloatOptional rhs) { return rhs == lhs; } -inline bool operator!=(float lhs, YGFloatOptional rhs) { +inline bool operator!=(YGFloat lhs, YGFloatOptional rhs) { return !(lhs == rhs); } diff --git a/yoga/YGLayout.h b/yoga/YGLayout.h index b7604d8e..1311cf3a 100644 --- a/yoga/YGLayout.h +++ b/yoga/YGLayout.h @@ -13,11 +13,11 @@ using namespace facebook::yoga; struct YGLayout { - std::array position = {}; - std::array dimensions = {{YGUndefined, YGUndefined}}; - std::array margin = {}; - std::array border = {}; - std::array padding = {}; + std::array position = {}; + std::array dimensions = {{YGUndefined, YGUndefined}}; + std::array margin = {}; + std::array border = {}; + std::array padding = {}; private: static constexpr size_t directionOffset = 0; @@ -41,7 +41,7 @@ public: uint32_t nextCachedMeasurementsIndex = 0; std::array cachedMeasurements = {}; - std::array measuredDimensions = {{YGUndefined, YGUndefined}}; + std::array measuredDimensions = {{YGUndefined, YGUndefined}}; YGCachedMeasurement cachedLayout = YGCachedMeasurement(); diff --git a/yoga/YGMacros.h b/yoga/YGMacros.h index 7c102ab4..81ce8142 100644 --- a/yoga/YGMacros.h +++ b/yoga/YGMacros.h @@ -7,6 +7,21 @@ #pragma once +#if defined(__LP64__) && __LP64__ +# define YGFLOAT_TYPE double +# define YGFLOAT_IS_DOUBLE 1 +# define YGFLOAT_MIN DBL_MIN +# define YGFLOAT_MAX DBL_MAX +#else +# define YGFLOAT_TYPE float +# define YGFLOAT_IS_DOUBLE 0 +# define YGFLOAT_MIN FLT_MIN +# define YGFLOAT_MAX FLT_MAX +#endif + +typedef YGFLOAT_TYPE YGFloat; +#define YGFLOAT_DEFINED 1 + #ifdef __cplusplus #define YG_EXTERN_CXX_BEGIN extern "C++" { #define YG_EXTERN_C_BEGIN extern "C" { diff --git a/yoga/YGNode.cpp b/yoga/YGNode.cpp index 1ee1bde6..b4fa4947 100644 --- a/yoga/YGNode.cpp +++ b/yoga/YGNode.cpp @@ -52,7 +52,7 @@ void YGNode::print(void* printContext) { YGFloatOptional YGNode::getLeadingPosition( const YGFlexDirection axis, - const float axisSize) const { + const YGFloat axisSize) const { if (YGFlexDirectionIsRow(axis)) { auto leadingPosition = YGComputedEdgeValue( style_.position(), YGEdgeStart, CompactValue::ofUndefined()); @@ -71,7 +71,7 @@ YGFloatOptional YGNode::getLeadingPosition( YGFloatOptional YGNode::getTrailingPosition( const YGFlexDirection axis, - const float axisSize) const { + const YGFloat axisSize) const { if (YGFlexDirectionIsRow(axis)) { auto trailingPosition = YGComputedEdgeValue( style_.position(), YGEdgeEnd, CompactValue::ofUndefined()); @@ -110,7 +110,7 @@ bool YGNode::isTrailingPosDefined(const YGFlexDirection axis) const { YGFloatOptional YGNode::getLeadingMargin( const YGFlexDirection axis, - const float widthSize) const { + const YGFloat widthSize) const { if (YGFlexDirectionIsRow(axis) && !style_.margin()[YGEdgeStart].isUndefined()) { return YGResolveValueMargin(style_.margin()[YGEdgeStart], widthSize); @@ -124,7 +124,7 @@ YGFloatOptional YGNode::getLeadingMargin( YGFloatOptional YGNode::getTrailingMargin( const YGFlexDirection axis, - const float widthSize) const { + const YGFloat widthSize) const { if (YGFlexDirectionIsRow(axis) && !style_.margin()[YGEdgeEnd].isUndefined()) { return YGResolveValueMargin(style_.margin()[YGEdgeEnd], widthSize); } @@ -137,14 +137,14 @@ YGFloatOptional YGNode::getTrailingMargin( YGFloatOptional YGNode::getMarginForAxis( const YGFlexDirection axis, - const float widthSize) const { + const YGFloat widthSize) const { return getLeadingMargin(axis, widthSize) + getTrailingMargin(axis, widthSize); } YGSize YGNode::measure( - float width, + YGFloat width, YGMeasureMode widthMode, - float height, + YGFloat height, YGMeasureMode heightMode, void* layoutContext) { @@ -154,7 +154,7 @@ YGSize YGNode::measure( : measure_.noContext(this, width, widthMode, height, heightMode); } -float YGNode::baseline(float width, float height, void* layoutContext) { +YGFloat YGNode::baseline(YGFloat width, YGFloat height, void* layoutContext) { return facebook::yoga::detail::getBooleanData(flags, baselineUsesContext_) ? baseline_.withContext(this, width, height, layoutContext) : baseline_.noContext(this, width, height); @@ -235,15 +235,15 @@ void YGNode::setLayoutDirection(YGDirection direction) { layout_.setDirection(direction); } -void YGNode::setLayoutMargin(float margin, int index) { +void YGNode::setLayoutMargin(YGFloat margin, int index) { layout_.margin[index] = margin; } -void YGNode::setLayoutBorder(float border, int index) { +void YGNode::setLayoutBorder(YGFloat border, int index) { layout_.border[index] = border; } -void YGNode::setLayoutPadding(float padding, int index) { +void YGNode::setLayoutPadding(YGFloat padding, int index) { layout_.padding[index] = padding; } @@ -256,7 +256,7 @@ void YGNode::setLayoutComputedFlexBasis( layout_.computedFlexBasis = computedFlexBasis; } -void YGNode::setLayoutPosition(float position, int index) { +void YGNode::setLayoutPosition(YGFloat position, int index) { layout_.position[index] = position; } @@ -265,7 +265,7 @@ void YGNode::setLayoutComputedFlexBasisGeneration( layout_.computedFlexBasisGeneration = computedFlexBasisGeneration; } -void YGNode::setLayoutMeasuredDimension(float measuredDimension, int index) { +void YGNode::setLayoutMeasuredDimension(YGFloat measuredDimension, int index) { layout_.measuredDimensions[index] = measuredDimension; } @@ -273,7 +273,7 @@ void YGNode::setLayoutHadOverflow(bool hadOverflow) { layout_.setHadOverflow(hadOverflow); } -void YGNode::setLayoutDimension(float dimension, int index) { +void YGNode::setLayoutDimension(YGFloat dimension, int index) { layout_.dimensions[index] = dimension; } @@ -281,7 +281,7 @@ void YGNode::setLayoutDimension(float dimension, int index) { // -right depending on which is defined. YGFloatOptional YGNode::relativePosition( const YGFlexDirection axis, - const float axisSize) const { + const YGFloat axisSize) const { if (isLeadingPositionDefined(axis)) { return getLeadingPosition(axis, axisSize); } @@ -295,9 +295,9 @@ YGFloatOptional YGNode::relativePosition( void YGNode::setPosition( const YGDirection direction, - const float mainSize, - const float crossSize, - const float ownerWidth) { + const YGFloat mainSize, + const YGFloat crossSize, + const YGFloat ownerWidth) { /* Root nodes should be always layouted as LTR, so we don't return negative * values. */ const YGDirection directionRespectingRoot = @@ -411,7 +411,7 @@ void YGNode::markDirtyAndPropogateDownwards() { }); } -float YGNode::resolveFlexGrow() const { +YGFloat YGNode::resolveFlexGrow() const { // Root nodes flexGrow should always be 0 if (owner_ == nullptr) { return 0.0; @@ -425,7 +425,7 @@ float YGNode::resolveFlexGrow() const { return kDefaultFlexGrow; } -float YGNode::resolveFlexShrink() const { +YGFloat YGNode::resolveFlexShrink() const { if (owner_ == nullptr) { return 0.0; } @@ -447,7 +447,7 @@ bool YGNode::isNodeFlexible() { (resolveFlexGrow() != 0 || resolveFlexShrink() != 0)); } -float YGNode::getLeadingBorder(const YGFlexDirection axis) const { +YGFloat YGNode::getLeadingBorder(const YGFlexDirection axis) const { YGValue leadingBorder; if (YGFlexDirectionIsRow(axis) && !style_.border()[YGEdgeStart].isUndefined()) { @@ -462,7 +462,7 @@ float YGNode::getLeadingBorder(const YGFlexDirection axis) const { return YGFloatMax(leadingBorder.value, 0.0f); } -float YGNode::getTrailingBorder(const YGFlexDirection flexDirection) const { +YGFloat YGNode::getTrailingBorder(const YGFlexDirection flexDirection) const { YGValue trailingBorder; if (YGFlexDirectionIsRow(flexDirection) && !style_.border()[YGEdgeEnd].isUndefined()) { @@ -479,7 +479,7 @@ float YGNode::getTrailingBorder(const YGFlexDirection flexDirection) const { YGFloatOptional YGNode::getLeadingPadding( const YGFlexDirection axis, - const float widthSize) const { + const YGFloat widthSize) const { const YGFloatOptional paddingEdgeStart = YGResolveValue(style_.padding()[YGEdgeStart], widthSize); if (YGFlexDirectionIsRow(axis) && @@ -497,7 +497,7 @@ YGFloatOptional YGNode::getLeadingPadding( YGFloatOptional YGNode::getTrailingPadding( const YGFlexDirection axis, - const float widthSize) const { + const YGFloat widthSize) const { const YGFloatOptional paddingEdgeEnd = YGResolveValue(style_.padding()[YGEdgeEnd], widthSize); if (YGFlexDirectionIsRow(axis) && paddingEdgeEnd >= YGFloatOptional{0.0f}) { @@ -514,14 +514,14 @@ YGFloatOptional YGNode::getTrailingPadding( YGFloatOptional YGNode::getLeadingPaddingAndBorder( const YGFlexDirection axis, - const float widthSize) const { + const YGFloat widthSize) const { return getLeadingPadding(axis, widthSize) + YGFloatOptional(getLeadingBorder(axis)); } YGFloatOptional YGNode::getTrailingPaddingAndBorder( const YGFlexDirection axis, - const float widthSize) const { + const YGFloat widthSize) const { return getTrailingPadding(axis, widthSize) + YGFloatOptional(getTrailingBorder(axis)); } diff --git a/yoga/YGNode.h b/yoga/YGNode.h index 63d98fe3..b2fb9347 100644 --- a/yoga/YGNode.h +++ b/yoga/YGNode.h @@ -23,8 +23,8 @@ YGConfigRef YGConfigGetDefault(); struct YOGA_EXPORT YGNode { using MeasureWithContextFn = - YGSize (*)(YGNode*, float, YGMeasureMode, float, YGMeasureMode, void*); - using BaselineWithContextFn = float (*)(YGNode*, float, float, void*); + YGSize (*)(YGNode*, YGFloat, YGMeasureMode, YGFloat, YGMeasureMode, void*); + using BaselineWithContextFn = YGFloat (*)(YGNode*, YGFloat, YGFloat, void*); using PrintWithContextFn = void (*)(YGNode*, void*); private: @@ -64,7 +64,7 @@ private: YGFloatOptional relativePosition( const YGFlexDirection axis, - const float axisSize) const; + const YGFloat axisSize) const; void setMeasureFunc(decltype(measure_)); void setBaselineFunc(decltype(baseline_)); @@ -124,13 +124,13 @@ public: bool hasMeasureFunc() const noexcept { return measure_.noContext != nullptr; } - YGSize measure(float, YGMeasureMode, float, YGMeasureMode, void*); + YGSize measure(YGFloat, YGMeasureMode, YGFloat, YGMeasureMode, void*); bool hasBaselineFunc() const noexcept { return baseline_.noContext != nullptr; } - float baseline(float width, float height, void* layoutContext); + YGFloat baseline(YGFloat width, YGFloat height, void* layoutContext); YGDirtiedFunc getDirtied() const { return dirtied_; } @@ -196,35 +196,35 @@ public: // Methods related to positions, margin, padding and border YGFloatOptional getLeadingPosition( const YGFlexDirection axis, - const float axisSize) const; + const YGFloat axisSize) const; bool isLeadingPositionDefined(const YGFlexDirection axis) const; bool isTrailingPosDefined(const YGFlexDirection axis) const; YGFloatOptional getTrailingPosition( const YGFlexDirection axis, - const float axisSize) const; + const YGFloat axisSize) const; YGFloatOptional getLeadingMargin( const YGFlexDirection axis, - const float widthSize) const; + const YGFloat widthSize) const; YGFloatOptional getTrailingMargin( const YGFlexDirection axis, - const float widthSize) const; - float getLeadingBorder(const YGFlexDirection flexDirection) const; - float getTrailingBorder(const YGFlexDirection flexDirection) const; + const YGFloat widthSize) const; + YGFloat getLeadingBorder(const YGFlexDirection flexDirection) const; + YGFloat getTrailingBorder(const YGFlexDirection flexDirection) const; YGFloatOptional getLeadingPadding( const YGFlexDirection axis, - const float widthSize) const; + const YGFloat widthSize) const; YGFloatOptional getTrailingPadding( const YGFlexDirection axis, - const float widthSize) const; + const YGFloat widthSize) const; YGFloatOptional getLeadingPaddingAndBorder( const YGFlexDirection axis, - const float widthSize) const; + const YGFloat widthSize) const; YGFloatOptional getTrailingPaddingAndBorder( const YGFlexDirection axis, - const float widthSize) const; + const YGFloat widthSize) const; YGFloatOptional getMarginForAxis( const YGFlexDirection axis, - const float widthSize) const; + const YGFloat widthSize) const; // Setters void setContext(void* context) { context_ = context; } @@ -292,19 +292,19 @@ public: void setLayoutComputedFlexBasis(const YGFloatOptional computedFlexBasis); void setLayoutComputedFlexBasisGeneration( uint32_t computedFlexBasisGeneration); - void setLayoutMeasuredDimension(float measuredDimension, int index); + void setLayoutMeasuredDimension(YGFloat measuredDimension, int index); void setLayoutHadOverflow(bool hadOverflow); - void setLayoutDimension(float dimension, int index); + void setLayoutDimension(YGFloat dimension, int index); void setLayoutDirection(YGDirection direction); - void setLayoutMargin(float margin, int index); - void setLayoutBorder(float border, int index); - void setLayoutPadding(float padding, int index); - void setLayoutPosition(float position, int index); + void setLayoutMargin(YGFloat margin, int index); + void setLayoutBorder(YGFloat border, int index); + void setLayoutPadding(YGFloat padding, int index); + void setLayoutPosition(YGFloat position, int index); void setPosition( const YGDirection direction, - const float mainSize, - const float crossSize, - const float ownerWidth); + const YGFloat mainSize, + const YGFloat crossSize, + const YGFloat ownerWidth); void setLayoutDoesLegacyFlagAffectsLayout(bool doesLegacyFlagAffectsLayout); void setLayoutDidUseLegacyFlag(bool didUseLegacyFlag); void markDirtyAndPropogateDownwards(); @@ -326,8 +326,8 @@ public: void cloneChildrenIfNeeded(void*); void markDirtyAndPropogate(); - float resolveFlexGrow() const; - float resolveFlexShrink() const; + YGFloat resolveFlexGrow() const; + YGFloat resolveFlexShrink() const; bool isNodeFlexible(); bool didUseLegacyFlag(); bool isLayoutTreeEqualToNode(const YGNode& node) const; diff --git a/yoga/YGValue.h b/yoga/YGValue.h index 93865ac4..32659678 100644 --- a/yoga/YGValue.h +++ b/yoga/YGValue.h @@ -25,7 +25,7 @@ YG_EXTERN_C_BEGIN // Not defined in MSVC++ #ifndef NAN static const uint32_t __nan = 0x7fc00000; -#define NAN (*(const float*) __nan) +#define NAN (*(const YGFloat*) __nan) #endif #define YGUndefined NAN diff --git a/yoga/Yoga-internal.h b/yoga/Yoga-internal.h index 1a22f24c..067fa965 100644 --- a/yoga/Yoga-internal.h +++ b/yoga/Yoga-internal.h @@ -19,8 +19,8 @@ YG_EXTERN_C_BEGIN void YGNodeCalculateLayoutWithContext( YGNodeRef node, - float availableWidth, - float availableHeight, + YGFloat availableWidth, + YGFloat availableHeight, YGDirection ownerDirection, void* layoutContext); @@ -29,7 +29,7 @@ YG_EXTERN_C_END namespace facebook { namespace yoga { -inline bool isUndefined(float value) { +inline bool isUndefined(YGFloat value) { return std::isnan(value); } @@ -45,13 +45,13 @@ extern const YGValue YGValueAuto; extern const YGValue YGValueZero; struct YGCachedMeasurement { - float availableWidth; - float availableHeight; + YGFloat availableWidth; + YGFloat availableHeight; YGMeasureMode widthMeasureMode; YGMeasureMode heightMeasureMode; - float computedWidth; - float computedHeight; + YGFloat computedWidth; + YGFloat computedHeight; YGCachedMeasurement() : availableWidth(-1), @@ -139,11 +139,11 @@ public: } // namespace yoga } // namespace facebook -static const float kDefaultFlexGrow = 0.0f; -static const float kDefaultFlexShrink = 0.0f; -static const float kWebDefaultFlexShrink = 1.0f; +static const YGFloat kDefaultFlexGrow = 0.0f; +static const YGFloat kDefaultFlexShrink = 0.0f; +static const YGFloat kWebDefaultFlexShrink = 1.0f; -extern bool YGFloatsEqual(const float a, const float b); +extern bool YGFloatsEqual(const YGFloat a, const YGFloat b); extern facebook::yoga::detail::CompactValue YGComputedEdgeValue( const facebook::yoga::detail::Values< facebook::yoga::enums::count()>& edges, diff --git a/yoga/Yoga.cpp b/yoga/Yoga.cpp index 97e64075..21cc1e57 100644 --- a/yoga/Yoga.cpp +++ b/yoga/Yoga.cpp @@ -22,7 +22,7 @@ /* define fmaxf if < VC12 */ #if _MSC_VER < 1800 -__forceinline const float fmaxf(const float a, const float b) { +__forceinline const YGFloat fmax(const YGFloat a, const YGFloat b) { return (a > b) ? a : b; } #endif @@ -106,7 +106,7 @@ static int YGDefaultLog( #undef YG_UNUSED #endif -YOGA_EXPORT bool YGFloatIsUndefined(const float value) { +YOGA_EXPORT bool YGFloatIsUndefined(const YGFloat value) { return facebook::yoga::isUndefined(value); } @@ -525,13 +525,13 @@ YOGA_EXPORT void YGNodeCopyStyle( } } -YOGA_EXPORT float YGNodeStyleGetFlexGrow(const YGNodeConstRef node) { +YOGA_EXPORT YGFloat YGNodeStyleGetFlexGrow(const YGNodeConstRef node) { return node->getStyle().flexGrow().isUndefined() ? kDefaultFlexGrow : node->getStyle().flexGrow().unwrap(); } -YOGA_EXPORT float YGNodeStyleGetFlexShrink(const YGNodeConstRef node) { +YOGA_EXPORT YGFloat YGNodeStyleGetFlexShrink(const YGNodeConstRef node) { return node->getStyle().flexShrink().isUndefined() ? (node->getConfig()->useWebDefaults ? kWebDefaultFlexShrink : kDefaultFlexShrink) @@ -681,12 +681,12 @@ YOGA_EXPORT YGDisplay YGNodeStyleGetDisplay(const YGNodeConstRef node) { } // TODO(T26792433): Change the API to accept YGFloatOptional. -YOGA_EXPORT void YGNodeStyleSetFlex(const YGNodeRef node, const float flex) { +YOGA_EXPORT void YGNodeStyleSetFlex(const YGNodeRef node, const YGFloat flex) { updateStyle(node, &YGStyle::flex, YGFloatOptional{flex}); } // TODO(T26792433): Change the API to accept YGFloatOptional. -YOGA_EXPORT float YGNodeStyleGetFlex(const YGNodeConstRef node) { +YOGA_EXPORT YGFloat YGNodeStyleGetFlex(const YGNodeConstRef node) { return node->getStyle().flex().isUndefined() ? YGUndefined : node->getStyle().flex().unwrap(); @@ -695,7 +695,7 @@ YOGA_EXPORT float YGNodeStyleGetFlex(const YGNodeConstRef node) { // TODO(T26792433): Change the API to accept YGFloatOptional. YOGA_EXPORT void YGNodeStyleSetFlexGrow( const YGNodeRef node, - const float flexGrow) { + const YGFloat flexGrow) { updateStyle( node, &YGStyle::flexGrow, YGFloatOptional{flexGrow}); } @@ -703,7 +703,7 @@ YOGA_EXPORT void YGNodeStyleSetFlexGrow( // TODO(T26792433): Change the API to accept YGFloatOptional. YOGA_EXPORT void YGNodeStyleSetFlexShrink( const YGNodeRef node, - const float flexShrink) { + const YGFloat flexShrink) { updateStyle( node, &YGStyle::flexShrink, YGFloatOptional{flexShrink}); } @@ -719,14 +719,14 @@ YOGA_EXPORT YGValue YGNodeStyleGetFlexBasis(const YGNodeConstRef node) { YOGA_EXPORT void YGNodeStyleSetFlexBasis( const YGNodeRef node, - const float flexBasis) { + const YGFloat flexBasis) { auto value = detail::CompactValue::ofMaybe(flexBasis); updateStyle(node, &YGStyle::flexBasis, value); } YOGA_EXPORT void YGNodeStyleSetFlexBasisPercent( const YGNodeRef node, - const float flexBasisPercent) { + const YGFloat flexBasisPercent) { auto value = detail::CompactValue::ofMaybe(flexBasisPercent); updateStyle(node, &YGStyle::flexBasis, value); } @@ -739,7 +739,7 @@ YOGA_EXPORT void YGNodeStyleSetFlexBasisAuto(const YGNodeRef node) { YOGA_EXPORT void YGNodeStyleSetPosition( YGNodeRef node, YGEdge edge, - float points) { + YGFloat points) { auto value = detail::CompactValue::ofMaybe(points); updateIndexedStyleProp( node, &YGStyle::position, edge, value); @@ -747,7 +747,7 @@ YOGA_EXPORT void YGNodeStyleSetPosition( YOGA_EXPORT void YGNodeStyleSetPositionPercent( YGNodeRef node, YGEdge edge, - float percent) { + YGFloat percent) { auto value = detail::CompactValue::ofMaybe(percent); updateIndexedStyleProp( node, &YGStyle::position, edge, value); @@ -759,7 +759,7 @@ YOGA_EXPORT YGValue YGNodeStyleGetPosition(YGNodeConstRef node, YGEdge edge) { YOGA_EXPORT void YGNodeStyleSetMargin( YGNodeRef node, YGEdge edge, - float points) { + YGFloat points) { auto value = detail::CompactValue::ofMaybe(points); updateIndexedStyleProp( node, &YGStyle::margin, edge, value); @@ -767,7 +767,7 @@ YOGA_EXPORT void YGNodeStyleSetMargin( YOGA_EXPORT void YGNodeStyleSetMarginPercent( YGNodeRef node, YGEdge edge, - float percent) { + YGFloat percent) { auto value = detail::CompactValue::ofMaybe(percent); updateIndexedStyleProp( node, &YGStyle::margin, edge, value); @@ -783,7 +783,7 @@ YOGA_EXPORT YGValue YGNodeStyleGetMargin(YGNodeConstRef node, YGEdge edge) { YOGA_EXPORT void YGNodeStyleSetPadding( YGNodeRef node, YGEdge edge, - float points) { + YGFloat points) { auto value = detail::CompactValue::ofMaybe(points); updateIndexedStyleProp( node, &YGStyle::padding, edge, value); @@ -791,7 +791,7 @@ YOGA_EXPORT void YGNodeStyleSetPadding( YOGA_EXPORT void YGNodeStyleSetPaddingPercent( YGNodeRef node, YGEdge edge, - float percent) { + YGFloat percent) { auto value = detail::CompactValue::ofMaybe(percent); updateIndexedStyleProp( node, &YGStyle::padding, edge, value); @@ -804,13 +804,13 @@ YOGA_EXPORT YGValue YGNodeStyleGetPadding(YGNodeConstRef node, YGEdge edge) { YOGA_EXPORT void YGNodeStyleSetBorder( const YGNodeRef node, const YGEdge edge, - const float border) { + const YGFloat border) { auto value = detail::CompactValue::ofMaybe(border); updateIndexedStyleProp( node, &YGStyle::border, edge, value); } -YOGA_EXPORT float YGNodeStyleGetBorder( +YOGA_EXPORT YGFloat YGNodeStyleGetBorder( const YGNodeConstRef node, const YGEdge edge) { auto border = node->getStyle().border()[edge]; @@ -826,7 +826,7 @@ YOGA_EXPORT float YGNodeStyleGetBorder( // Yoga specific properties, not compatible with flexbox specification // TODO(T26792433): Change the API to accept YGFloatOptional. -YOGA_EXPORT float YGNodeStyleGetAspectRatio(const YGNodeConstRef node) { +YOGA_EXPORT YGFloat YGNodeStyleGetAspectRatio(const YGNodeConstRef node) { const YGFloatOptional op = node->getStyle().aspectRatio(); return op.isUndefined() ? YGUndefined : op.unwrap(); } @@ -834,17 +834,17 @@ YOGA_EXPORT float YGNodeStyleGetAspectRatio(const YGNodeConstRef node) { // TODO(T26792433): Change the API to accept YGFloatOptional. YOGA_EXPORT void YGNodeStyleSetAspectRatio( const YGNodeRef node, - const float aspectRatio) { + const YGFloat aspectRatio) { updateStyle( node, &YGStyle::aspectRatio, YGFloatOptional{aspectRatio}); } -YOGA_EXPORT void YGNodeStyleSetWidth(YGNodeRef node, float points) { +YOGA_EXPORT void YGNodeStyleSetWidth(YGNodeRef node, YGFloat points) { auto value = detail::CompactValue::ofMaybe(points); updateIndexedStyleProp( node, &YGStyle::dimensions, YGDimensionWidth, value); } -YOGA_EXPORT void YGNodeStyleSetWidthPercent(YGNodeRef node, float percent) { +YOGA_EXPORT void YGNodeStyleSetWidthPercent(YGNodeRef node, YGFloat percent) { auto value = detail::CompactValue::ofMaybe(percent); updateIndexedStyleProp( node, &YGStyle::dimensions, YGDimensionWidth, value); @@ -860,12 +860,12 @@ YOGA_EXPORT YGValue YGNodeStyleGetWidth(YGNodeConstRef node) { return node->getStyle().dimensions()[YGDimensionWidth]; } -YOGA_EXPORT void YGNodeStyleSetHeight(YGNodeRef node, float points) { +YOGA_EXPORT void YGNodeStyleSetHeight(YGNodeRef node, YGFloat points) { auto value = detail::CompactValue::ofMaybe(points); updateIndexedStyleProp( node, &YGStyle::dimensions, YGDimensionHeight, value); } -YOGA_EXPORT void YGNodeStyleSetHeightPercent(YGNodeRef node, float percent) { +YOGA_EXPORT void YGNodeStyleSetHeightPercent(YGNodeRef node, YGFloat percent) { auto value = detail::CompactValue::ofMaybe(percent); updateIndexedStyleProp( node, &YGStyle::dimensions, YGDimensionHeight, value); @@ -883,14 +883,14 @@ YOGA_EXPORT YGValue YGNodeStyleGetHeight(YGNodeConstRef node) { YOGA_EXPORT void YGNodeStyleSetMinWidth( const YGNodeRef node, - const float minWidth) { + const YGFloat minWidth) { auto value = detail::CompactValue::ofMaybe(minWidth); updateIndexedStyleProp( node, &YGStyle::minDimensions, YGDimensionWidth, value); } YOGA_EXPORT void YGNodeStyleSetMinWidthPercent( const YGNodeRef node, - const float minWidth) { + const YGFloat minWidth) { auto value = detail::CompactValue::ofMaybe(minWidth); updateIndexedStyleProp( node, &YGStyle::minDimensions, YGDimensionWidth, value); @@ -901,14 +901,14 @@ YOGA_EXPORT YGValue YGNodeStyleGetMinWidth(const YGNodeConstRef node) { YOGA_EXPORT void YGNodeStyleSetMinHeight( const YGNodeRef node, - const float minHeight) { + const YGFloat minHeight) { auto value = detail::CompactValue::ofMaybe(minHeight); updateIndexedStyleProp( node, &YGStyle::minDimensions, YGDimensionHeight, value); } YOGA_EXPORT void YGNodeStyleSetMinHeightPercent( const YGNodeRef node, - const float minHeight) { + const YGFloat minHeight) { auto value = detail::CompactValue::ofMaybe(minHeight); updateIndexedStyleProp( node, &YGStyle::minDimensions, YGDimensionHeight, value); @@ -919,14 +919,14 @@ YOGA_EXPORT YGValue YGNodeStyleGetMinHeight(const YGNodeConstRef node) { YOGA_EXPORT void YGNodeStyleSetMaxWidth( const YGNodeRef node, - const float maxWidth) { + const YGFloat maxWidth) { auto value = detail::CompactValue::ofMaybe(maxWidth); updateIndexedStyleProp( node, &YGStyle::maxDimensions, YGDimensionWidth, value); } YOGA_EXPORT void YGNodeStyleSetMaxWidthPercent( const YGNodeRef node, - const float maxWidth) { + const YGFloat maxWidth) { auto value = detail::CompactValue::ofMaybe(maxWidth); updateIndexedStyleProp( node, &YGStyle::maxDimensions, YGDimensionWidth, value); @@ -937,14 +937,14 @@ YOGA_EXPORT YGValue YGNodeStyleGetMaxWidth(const YGNodeConstRef node) { YOGA_EXPORT void YGNodeStyleSetMaxHeight( const YGNodeRef node, - const float maxHeight) { + const YGFloat maxHeight) { auto value = detail::CompactValue::ofMaybe(maxHeight); updateIndexedStyleProp( node, &YGStyle::maxDimensions, YGDimensionHeight, value); } YOGA_EXPORT void YGNodeStyleSetMaxHeightPercent( const YGNodeRef node, - const float maxHeight) { + const YGFloat maxHeight) { auto value = detail::CompactValue::ofMaybe(maxHeight); updateIndexedStyleProp( node, &YGStyle::maxDimensions, YGDimensionHeight, value); @@ -985,18 +985,18 @@ YOGA_EXPORT YGValue YGNodeStyleGetMaxHeight(const YGNodeConstRef node) { return node->getLayout().instanceName[edge]; \ } -YG_NODE_LAYOUT_PROPERTY_IMPL(float, Left, position[YGEdgeLeft]); -YG_NODE_LAYOUT_PROPERTY_IMPL(float, Top, position[YGEdgeTop]); -YG_NODE_LAYOUT_PROPERTY_IMPL(float, Right, position[YGEdgeRight]); -YG_NODE_LAYOUT_PROPERTY_IMPL(float, Bottom, position[YGEdgeBottom]); -YG_NODE_LAYOUT_PROPERTY_IMPL(float, Width, dimensions[YGDimensionWidth]); -YG_NODE_LAYOUT_PROPERTY_IMPL(float, Height, dimensions[YGDimensionHeight]); +YG_NODE_LAYOUT_PROPERTY_IMPL(YGFloat, Left, position[YGEdgeLeft]); +YG_NODE_LAYOUT_PROPERTY_IMPL(YGFloat, Top, position[YGEdgeTop]); +YG_NODE_LAYOUT_PROPERTY_IMPL(YGFloat, Right, position[YGEdgeRight]); +YG_NODE_LAYOUT_PROPERTY_IMPL(YGFloat, Bottom, position[YGEdgeBottom]); +YG_NODE_LAYOUT_PROPERTY_IMPL(YGFloat, Width, dimensions[YGDimensionWidth]); +YG_NODE_LAYOUT_PROPERTY_IMPL(YGFloat, Height, dimensions[YGDimensionHeight]); YG_NODE_LAYOUT_PROPERTY_IMPL(YGDirection, Direction, direction()); YG_NODE_LAYOUT_PROPERTY_IMPL(bool, HadOverflow, hadOverflow()); -YG_NODE_LAYOUT_RESOLVED_PROPERTY_IMPL(float, Margin, margin); -YG_NODE_LAYOUT_RESOLVED_PROPERTY_IMPL(float, Border, border); -YG_NODE_LAYOUT_RESOLVED_PROPERTY_IMPL(float, Padding, padding); +YG_NODE_LAYOUT_RESOLVED_PROPERTY_IMPL(YGFloat, Margin, margin); +YG_NODE_LAYOUT_RESOLVED_PROPERTY_IMPL(YGFloat, Border, border); +YG_NODE_LAYOUT_RESOLVED_PROPERTY_IMPL(YGFloat, Padding, padding); YOGA_EXPORT bool YGNodeLayoutGetDidLegacyStretchFlagAffectLayout( const YGNodeRef node) { @@ -1007,13 +1007,13 @@ std::atomic gCurrentGenerationCount(0); bool YGLayoutNodeInternal( const YGNodeRef node, - const float availableWidth, - const float availableHeight, + const YGFloat availableWidth, + const YGFloat availableHeight, const YGDirection ownerDirection, const YGMeasureMode widthMeasureMode, const YGMeasureMode heightMeasureMode, - const float ownerWidth, - const float ownerHeight, + const YGFloat ownerWidth, + const YGFloat ownerHeight, const bool performLayout, const LayoutPassReason reason, const YGConfigRef config, @@ -1053,10 +1053,10 @@ static const std::array pos = {{ static const std::array dim = { {YGDimensionHeight, YGDimensionHeight, YGDimensionWidth, YGDimensionWidth}}; -static inline float YGNodePaddingAndBorderForAxis( +static inline YGFloat YGNodePaddingAndBorderForAxis( const YGNodeConstRef node, const YGFlexDirection axis, - const float widthSize) { + const YGFloat widthSize) { return (node->getLeadingPaddingAndBorder(axis, widthSize) + node->getTrailingPaddingAndBorder(axis, widthSize)) .unwrap(); @@ -1073,12 +1073,12 @@ static inline YGAlign YGNodeAlignItem(const YGNode* node, const YGNode* child) { return align; } -static float YGBaseline(const YGNodeRef node, void* layoutContext) { +static YGFloat YGBaseline(const YGNodeRef node, void* layoutContext) { if (node->hasBaselineFunc()) { Event::publish(node); - const float baseline = node->baseline( + const YGFloat baseline = node->baseline( node->getLayout().measuredDimensions[YGDimensionWidth], node->getLayout().measuredDimensions[YGDimensionHeight], layoutContext); @@ -1117,7 +1117,7 @@ static float YGBaseline(const YGNodeRef node, void* layoutContext) { return node->getLayout().measuredDimensions[YGDimensionHeight]; } - const float baseline = YGBaseline(baselineChild, layoutContext); + const YGFloat baseline = YGBaseline(baselineChild, layoutContext); return baseline + baselineChild->getLayout().position[YGEdgeTop]; } @@ -1140,10 +1140,10 @@ static bool YGIsBaselineLayout(const YGNodeRef node) { return false; } -static inline float YGNodeDimWithMargin( +static inline YGFloat YGNodeDimWithMargin( const YGNodeRef node, const YGFlexDirection axis, - const float widthSize) { + const YGFloat widthSize) { return node->getLayout().measuredDimensions[dim[axis]] + (node->getLeadingMargin(axis, widthSize) + node->getTrailingMargin(axis, widthSize)) @@ -1153,7 +1153,7 @@ static inline float YGNodeDimWithMargin( static inline bool YGNodeIsStyleDimDefined( const YGNodeRef node, const YGFlexDirection axis, - const float ownerSize) { + const YGFloat ownerSize) { bool isUndefined = YGFloatIsUndefined(node->getResolvedDimension(dim[axis]).value); return !( @@ -1170,7 +1170,7 @@ static inline bool YGNodeIsStyleDimDefined( static inline bool YGNodeIsLayoutDimDefined( const YGNodeRef node, const YGFlexDirection axis) { - const float value = node->getLayout().measuredDimensions[dim[axis]]; + const YGFloat value = node->getLayout().measuredDimensions[dim[axis]]; return !YGFloatIsUndefined(value) && value >= 0.0f; } @@ -1178,7 +1178,7 @@ static YGFloatOptional YGNodeBoundAxisWithinMinAndMax( const YGNodeConstRef node, const YGFlexDirection axis, const YGFloatOptional value, - const float axisSize) { + const YGFloat axisSize) { YGFloatOptional min; YGFloatOptional max; @@ -1207,12 +1207,12 @@ static YGFloatOptional YGNodeBoundAxisWithinMinAndMax( // Like YGNodeBoundAxisWithinMinAndMax but also ensures that the value doesn't // go below the padding and border amount. -static inline float YGNodeBoundAxis( +static inline YGFloat YGNodeBoundAxis( const YGNodeRef node, const YGFlexDirection axis, - const float value, - const float axisSize, - const float widthSize) { + const YGFloat value, + const YGFloat axisSize, + const YGFloat widthSize) { return YGFloatMax( YGNodeBoundAxisWithinMinAndMax( node, axis, YGFloatOptional{value}, axisSize) @@ -1224,7 +1224,7 @@ static void YGNodeSetChildTrailingPosition( const YGNodeRef node, const YGNodeRef child, const YGFlexDirection axis) { - const float size = child->getLayout().measuredDimensions[dim[axis]]; + const YGFloat size = child->getLayout().measuredDimensions[dim[axis]]; child->setLayoutPosition( node->getLayout().measuredDimensions[dim[axis]] - size - child->getLayout().position[pos[axis]], @@ -1234,10 +1234,10 @@ static void YGNodeSetChildTrailingPosition( static void YGConstrainMaxSizeForMode( const YGNodeConstRef node, const enum YGFlexDirection axis, - const float ownerAxisSize, - const float ownerWidth, + const YGFloat ownerAxisSize, + const YGFloat ownerWidth, YGMeasureMode* mode, - float* size) { + YGFloat* size) { const YGFloatOptional maxSize = YGResolveValue( node->getStyle().maxDimensions()[dim[axis]], ownerAxisSize) + @@ -1261,11 +1261,11 @@ static void YGConstrainMaxSizeForMode( static void YGNodeComputeFlexBasisForChild( const YGNodeRef node, const YGNodeRef child, - const float width, + const YGFloat width, const YGMeasureMode widthMode, - const float height, - const float ownerWidth, - const float ownerHeight, + const YGFloat height, + const YGFloat ownerWidth, + const YGFloat ownerHeight, const YGMeasureMode heightMode, const YGDirection direction, const YGConfigRef config, @@ -1276,11 +1276,11 @@ static void YGNodeComputeFlexBasisForChild( const YGFlexDirection mainAxis = YGResolveFlexDirection(node->getStyle().flexDirection(), direction); const bool isMainAxisRow = YGFlexDirectionIsRow(mainAxis); - const float mainAxisSize = isMainAxisRow ? width : height; - const float mainAxisownerSize = isMainAxisRow ? ownerWidth : ownerHeight; + const YGFloat mainAxisSize = isMainAxisRow ? width : height; + const YGFloat mainAxisownerSize = isMainAxisRow ? ownerWidth : ownerHeight; - float childWidth; - float childHeight; + YGFloat childWidth; + YGFloat childHeight; YGMeasureMode childWidthMeasureMode; YGMeasureMode childHeightMeasureMode; @@ -1460,9 +1460,9 @@ static void YGNodeComputeFlexBasisForChild( static void YGNodeAbsoluteLayoutChild( const YGNodeRef node, const YGNodeRef child, - const float width, + const YGFloat width, const YGMeasureMode widthMode, - const float height, + const YGFloat height, const YGDirection direction, const YGConfigRef config, LayoutData& layoutMarkerData, @@ -1474,8 +1474,8 @@ static void YGNodeAbsoluteLayoutChild( const YGFlexDirection crossAxis = YGFlexDirectionCross(mainAxis, direction); const bool isMainAxisRow = YGFlexDirectionIsRow(mainAxis); - float childWidth = YGUndefined; - float childHeight = YGUndefined; + YGFloat childWidth = YGUndefined; + YGFloat childHeight = YGUndefined; YGMeasureMode childWidthMeasureMode = YGMeasureModeUndefined; YGMeasureMode childHeightMeasureMode = YGMeasureModeUndefined; @@ -1660,12 +1660,12 @@ static void YGNodeAbsoluteLayoutChild( static void YGNodeWithMeasureFuncSetMeasuredDimensions( const YGNodeRef node, - float availableWidth, - float availableHeight, + YGFloat availableWidth, + YGFloat availableHeight, const YGMeasureMode widthMeasureMode, const YGMeasureMode heightMeasureMode, - const float ownerWidth, - const float ownerHeight, + const YGFloat ownerWidth, + const YGFloat ownerHeight, LayoutData& layoutMarkerData, void* const layoutContext, const LayoutPassReason reason) { @@ -1681,20 +1681,20 @@ static void YGNodeWithMeasureFuncSetMeasuredDimensions( availableHeight = YGUndefined; } - const float paddingAndBorderAxisRow = + const YGFloat paddingAndBorderAxisRow = YGNodePaddingAndBorderForAxis(node, YGFlexDirectionRow, ownerWidth); - const float paddingAndBorderAxisColumn = + const YGFloat paddingAndBorderAxisColumn = YGNodePaddingAndBorderForAxis(node, YGFlexDirectionColumn, ownerWidth); - const float marginAxisRow = + const YGFloat marginAxisRow = node->getMarginForAxis(YGFlexDirectionRow, ownerWidth).unwrap(); - const float marginAxisColumn = + const YGFloat marginAxisColumn = node->getMarginForAxis(YGFlexDirectionColumn, ownerWidth).unwrap(); // We want to make sure we don't call measure with negative size - const float innerWidth = YGFloatIsUndefined(availableWidth) + const YGFloat innerWidth = YGFloatIsUndefined(availableWidth) ? availableWidth : YGFloatMax(0, availableWidth - marginAxisRow - paddingAndBorderAxisRow); - const float innerHeight = YGFloatIsUndefined(availableHeight) + const YGFloat innerHeight = YGFloatIsUndefined(availableHeight) ? availableHeight : YGFloatMax( 0, availableHeight - marginAxisColumn - paddingAndBorderAxisColumn); @@ -1774,19 +1774,19 @@ static void YGNodeWithMeasureFuncSetMeasuredDimensions( // or the minimum size as indicated by the padding and border sizes. static void YGNodeEmptyContainerSetMeasuredDimensions( const YGNodeRef node, - const float availableWidth, - const float availableHeight, + const YGFloat availableWidth, + const YGFloat availableHeight, const YGMeasureMode widthMeasureMode, const YGMeasureMode heightMeasureMode, - const float ownerWidth, - const float ownerHeight) { - const float paddingAndBorderAxisRow = + const YGFloat ownerWidth, + const YGFloat ownerHeight) { + const YGFloat paddingAndBorderAxisRow = YGNodePaddingAndBorderForAxis(node, YGFlexDirectionRow, ownerWidth); - const float paddingAndBorderAxisColumn = + const YGFloat paddingAndBorderAxisColumn = YGNodePaddingAndBorderForAxis(node, YGFlexDirectionColumn, ownerWidth); - const float marginAxisRow = + const YGFloat marginAxisRow = node->getMarginForAxis(YGFlexDirectionRow, ownerWidth).unwrap(); - const float marginAxisColumn = + const YGFloat marginAxisColumn = node->getMarginForAxis(YGFlexDirectionColumn, ownerWidth).unwrap(); node->setLayoutMeasuredDimension( @@ -1816,12 +1816,12 @@ static void YGNodeEmptyContainerSetMeasuredDimensions( static bool YGNodeFixedSizeSetMeasuredDimensions( const YGNodeRef node, - const float availableWidth, - const float availableHeight, + const YGFloat availableWidth, + const YGFloat availableHeight, const YGMeasureMode widthMeasureMode, const YGMeasureMode heightMeasureMode, - const float ownerWidth, - const float ownerHeight) { + const YGFloat ownerWidth, + const YGFloat ownerHeight) { if ((!YGFloatIsUndefined(availableWidth) && widthMeasureMode == YGMeasureModeAtMost && availableWidth <= 0.0f) || (!YGFloatIsUndefined(availableHeight) && @@ -1876,23 +1876,23 @@ static void YGZeroOutLayoutRecursivly( YGZeroOutLayoutRecursivly, layoutContext); } -static float YGNodeCalculateAvailableInnerDim( +static YGFloat YGNodeCalculateAvailableInnerDim( const YGNodeConstRef node, YGFlexDirection axis, - float availableDim, - float ownerDim, - float ownerDimForMarginPadding) { + YGFloat availableDim, + YGFloat ownerDim, + YGFloat ownerDimForMarginPadding) { YGFlexDirection direction = YGFlexDirectionIsRow(axis) ? YGFlexDirectionRow : YGFlexDirectionColumn; YGDimension dimension = YGFlexDirectionIsRow(axis) ? YGDimensionWidth : YGDimensionHeight; - const float margin = + const YGFloat margin = node->getMarginForAxis(direction, ownerDimForMarginPadding).unwrap(); - const float paddingAndBorder = + const YGFloat paddingAndBorder = YGNodePaddingAndBorderForAxis(node, direction, ownerDimForMarginPadding); - float availableInnerDim = availableDim - margin - paddingAndBorder; + YGFloat availableInnerDim = availableDim - margin - paddingAndBorder; // Max dimension overrides predefined dimension value; Min dimension in turn // overrides both of the above if (!YGFloatIsUndefined(availableInnerDim)) { @@ -1900,14 +1900,14 @@ static float YGNodeCalculateAvailableInnerDim( // constraints const YGFloatOptional minDimensionOptional = YGResolveValue(node->getStyle().minDimensions()[dimension], ownerDim); - const float minInnerDim = minDimensionOptional.isUndefined() + const YGFloat minInnerDim = minDimensionOptional.isUndefined() ? 0.0f : minDimensionOptional.unwrap() - paddingAndBorder; const YGFloatOptional maxDimensionOptional = YGResolveValue(node->getStyle().maxDimensions()[dimension], ownerDim); - const float maxInnerDim = maxDimensionOptional.isUndefined() + const YGFloat maxInnerDim = maxDimensionOptional.isUndefined() ? FLT_MAX : maxDimensionOptional.unwrap() - paddingAndBorder; availableInnerDim = @@ -1917,10 +1917,10 @@ static float YGNodeCalculateAvailableInnerDim( return availableInnerDim; } -static float YGNodeComputeFlexBasisForChildren( +static YGFloat YGNodeComputeFlexBasisForChildren( const YGNodeRef node, - const float availableInnerWidth, - const float availableInnerHeight, + const YGFloat availableInnerWidth, + const YGFloat availableInnerHeight, YGMeasureMode widthMeasureMode, YGMeasureMode heightMeasureMode, YGDirection direction, @@ -1931,7 +1931,7 @@ static float YGNodeComputeFlexBasisForChildren( void* const layoutContext, const uint32_t depth, const uint32_t generationCount) { - float totalOuterFlexBasis = 0.0f; + YGFloat totalOuterFlexBasis = 0.0f; YGNodeRef singleFlexChild = nullptr; const YGVector& children = node->getChildren(); YGMeasureMode measureModeMainDim = @@ -1967,10 +1967,10 @@ static float YGNodeComputeFlexBasisForChildren( if (performLayout) { // Set the initial position (relative to the owner). const YGDirection childDirection = child->resolveDirection(direction); - const float mainDim = YGFlexDirectionIsRow(mainAxis) + const YGFloat mainDim = YGFlexDirectionIsRow(mainAxis) ? availableInnerWidth : availableInnerHeight; - const float crossDim = YGFlexDirectionIsRow(mainAxis) + const YGFloat crossDim = YGFlexDirectionIsRow(mainAxis) ? availableInnerHeight : availableInnerWidth; child->setPosition( @@ -2017,15 +2017,15 @@ static float YGNodeComputeFlexBasisForChildren( static YGCollectFlexItemsRowValues YGCalculateCollectFlexItemsRowValues( const YGNodeRef& node, const YGDirection ownerDirection, - const float mainAxisownerSize, - const float availableInnerWidth, - const float availableInnerMainDim, + const YGFloat mainAxisownerSize, + const YGFloat availableInnerWidth, + const YGFloat availableInnerMainDim, const uint32_t startOfLineIndex, const uint32_t lineCount) { YGCollectFlexItemsRowValues flexAlgoRowMeasurement = {}; flexAlgoRowMeasurement.relativeChildren.reserve(node->getChildren().size()); - float sizeConsumedOnCurrentLineIncludingMinConstraint = 0; + YGFloat sizeConsumedOnCurrentLineIncludingMinConstraint = 0; const YGFlexDirection mainAxis = YGResolveFlexDirection( node->getStyle().flexDirection(), node->resolveDirection(ownerDirection)); const bool isNodeFlexWrap = node->getStyle().flexWrap() != YGWrapNoWrap; @@ -2039,9 +2039,9 @@ static YGCollectFlexItemsRowValues YGCalculateCollectFlexItemsRowValues( continue; } child->setLineIndex(lineCount); - const float childMarginMainAxis = + const YGFloat childMarginMainAxis = child->getMarginForAxis(mainAxis, availableInnerWidth).unwrap(); - const float flexBasisWithMinAndMaxConstraints = + const YGFloat flexBasisWithMinAndMaxConstraints = YGNodeBoundAxisWithinMinAndMax( child, mainAxis, @@ -2097,16 +2097,16 @@ static YGCollectFlexItemsRowValues YGCalculateCollectFlexItemsRowValues( // of the flex items abide the min and max constraints. At the end of this // function the child nodes would have proper size. Prior using this function // please ensure that YGDistributeFreeSpaceFirstPass is called. -static float YGDistributeFreeSpaceSecondPass( +static YGFloat YGDistributeFreeSpaceSecondPass( YGCollectFlexItemsRowValues& collectedFlexItemsValues, const YGNodeRef node, const YGFlexDirection mainAxis, const YGFlexDirection crossAxis, - const float mainAxisownerSize, - const float availableInnerMainDim, - const float availableInnerCrossDim, - const float availableInnerWidth, - const float availableInnerHeight, + const YGFloat mainAxisownerSize, + const YGFloat availableInnerMainDim, + const YGFloat availableInnerCrossDim, + const YGFloat availableInnerWidth, + const YGFloat availableInnerHeight, const bool flexBasisOverflows, const YGMeasureMode measureModeCrossDim, const bool performLayout, @@ -2115,10 +2115,10 @@ static float YGDistributeFreeSpaceSecondPass( void* const layoutContext, const uint32_t depth, const uint32_t generationCount) { - float childFlexBasis = 0; - float flexShrinkScaledFactor = 0; - float flexGrowFactor = 0; - float deltaFreeSpace = 0; + YGFloat childFlexBasis = 0; + YGFloat flexShrinkScaledFactor = 0; + YGFloat flexGrowFactor = 0; + YGFloat deltaFreeSpace = 0; const bool isMainAxisRow = YGFlexDirectionIsRow(mainAxis); const bool isNodeFlexWrap = node->getStyle().flexWrap() != YGWrapNoWrap; @@ -2129,7 +2129,7 @@ static float YGDistributeFreeSpaceSecondPass( currentRelativeChild->getLayout().computedFlexBasis, mainAxisownerSize) .unwrap(); - float updatedMainSize = childFlexBasis; + YGFloat updatedMainSize = childFlexBasis; if (!YGFloatIsUndefined(collectedFlexItemsValues.remainingFreeSpace) && collectedFlexItemsValues.remainingFreeSpace < 0) { @@ -2137,7 +2137,7 @@ static float YGDistributeFreeSpaceSecondPass( -currentRelativeChild->resolveFlexShrink() * childFlexBasis; // Is this child able to shrink? if (flexShrinkScaledFactor != 0) { - float childSize; + YGFloat childSize; if (!YGFloatIsUndefined( collectedFlexItemsValues.totalFlexShrinkScaledFactors) && @@ -2178,15 +2178,15 @@ static float YGDistributeFreeSpaceSecondPass( deltaFreeSpace += updatedMainSize - childFlexBasis; - const float marginMain = + const YGFloat marginMain = currentRelativeChild->getMarginForAxis(mainAxis, availableInnerWidth) .unwrap(); - const float marginCross = + const YGFloat marginCross = currentRelativeChild->getMarginForAxis(crossAxis, availableInnerWidth) .unwrap(); - float childCrossSize; - float childMainSize = updatedMainSize + marginMain; + YGFloat childCrossSize; + YGFloat childMainSize = updatedMainSize + marginMain; YGMeasureMode childCrossMeasureMode; YGMeasureMode childMainMeasureMode = YGMeasureModeExactly; @@ -2257,8 +2257,8 @@ static float YGDistributeFreeSpaceSecondPass( YGUnitAuto && currentRelativeChild->marginTrailingValue(crossAxis).unit != YGUnitAuto; - const float childWidth = isMainAxisRow ? childMainSize : childCrossSize; - const float childHeight = !isMainAxisRow ? childMainSize : childCrossSize; + const YGFloat childWidth = isMainAxisRow ? childMainSize : childCrossSize; + const YGFloat childHeight = !isMainAxisRow ? childMainSize : childCrossSize; const YGMeasureMode childWidthMeasureMode = isMainAxisRow ? childMainMeasureMode : childCrossMeasureMode; @@ -2298,17 +2298,17 @@ static float YGDistributeFreeSpaceSecondPass( static void YGDistributeFreeSpaceFirstPass( YGCollectFlexItemsRowValues& collectedFlexItemsValues, const YGFlexDirection mainAxis, - const float mainAxisownerSize, - const float availableInnerMainDim, - const float availableInnerWidth) { - float flexShrinkScaledFactor = 0; - float flexGrowFactor = 0; - float baseMainSize = 0; - float boundMainSize = 0; - float deltaFreeSpace = 0; + const YGFloat mainAxisownerSize, + const YGFloat availableInnerMainDim, + const YGFloat availableInnerWidth) { + YGFloat flexShrinkScaledFactor = 0; + YGFloat flexGrowFactor = 0; + YGFloat baseMainSize = 0; + YGFloat boundMainSize = 0; + YGFloat deltaFreeSpace = 0; for (auto currentRelativeChild : collectedFlexItemsValues.relativeChildren) { - float childFlexBasis = + YGFloat childFlexBasis = YGNodeBoundAxisWithinMinAndMax( currentRelativeChild, mainAxis, @@ -2406,11 +2406,11 @@ static void YGResolveFlexibleLength( YGCollectFlexItemsRowValues& collectedFlexItemsValues, const YGFlexDirection mainAxis, const YGFlexDirection crossAxis, - const float mainAxisownerSize, - const float availableInnerMainDim, - const float availableInnerCrossDim, - const float availableInnerWidth, - const float availableInnerHeight, + const YGFloat mainAxisownerSize, + const YGFloat availableInnerMainDim, + const YGFloat availableInnerCrossDim, + const YGFloat availableInnerWidth, + const YGFloat availableInnerHeight, const bool flexBasisOverflows, const YGMeasureMode measureModeCrossDim, const bool performLayout, @@ -2419,7 +2419,7 @@ static void YGResolveFlexibleLength( void* const layoutContext, const uint32_t depth, const uint32_t generationCount) { - const float originalFreeSpace = collectedFlexItemsValues.remainingFreeSpace; + const YGFloat originalFreeSpace = collectedFlexItemsValues.remainingFreeSpace; // First pass: detect the flex items whose min/max constraints trigger YGDistributeFreeSpaceFirstPass( collectedFlexItemsValues, @@ -2429,7 +2429,7 @@ static void YGResolveFlexibleLength( availableInnerWidth); // Second pass: resolve the sizes of the flexible items - const float distributedFreeSpace = YGDistributeFreeSpaceSecondPass( + const YGFloat distributedFreeSpace = YGDistributeFreeSpaceSecondPass( collectedFlexItemsValues, node, mainAxis, @@ -2460,17 +2460,17 @@ static void YGJustifyMainAxis( const YGFlexDirection crossAxis, const YGMeasureMode measureModeMainDim, const YGMeasureMode measureModeCrossDim, - const float mainAxisownerSize, - const float ownerWidth, - const float availableInnerMainDim, - const float availableInnerCrossDim, - const float availableInnerWidth, + const YGFloat mainAxisownerSize, + const YGFloat ownerWidth, + const YGFloat availableInnerMainDim, + const YGFloat availableInnerCrossDim, + const YGFloat availableInnerWidth, const bool performLayout, void* const layoutContext) { const auto& style = node->getStyle(); - const float leadingPaddingAndBorderMain = + const YGFloat leadingPaddingAndBorderMain = node->getLeadingPaddingAndBorder(mainAxis, ownerWidth).unwrap(); - const float trailingPaddingAndBorderMain = + const YGFloat trailingPaddingAndBorderMain = node->getTrailingPaddingAndBorder(mainAxis, ownerWidth).unwrap(); // If we are using "at most" rules in the main axis, make sure that // remainingFreeSpace is 0 when min main dimension is not given @@ -2486,12 +2486,12 @@ static void YGJustifyMainAxis( // `minAvailableMainDim` denotes minimum available space in which child // can be laid out, it will exclude space consumed by padding and border. - const float minAvailableMainDim = + const YGFloat minAvailableMainDim = YGResolveValue( style.minDimensions()[dim[mainAxis]], mainAxisownerSize) .unwrap() - leadingPaddingAndBorderMain - trailingPaddingAndBorderMain; - const float occupiedSpaceByChildNodes = + const YGFloat occupiedSpaceByChildNodes = availableInnerMainDim - collectedFlexItemsValues.remainingFreeSpace; collectedFlexItemsValues.remainingFreeSpace = YGFloatMax(0, minAvailableMainDim - occupiedSpaceByChildNodes); @@ -2518,8 +2518,8 @@ static void YGJustifyMainAxis( // In order to position the elements in the main axis, we have two controls. // The space between the beginning and the first element and the space between // each two elements. - float leadingMainDim = 0; - float betweenMainDim = 0; + YGFloat leadingMainDim = 0; + YGFloat betweenMainDim = 0; const YGJustify justifyContent = node->getStyle().justifyContent(); if (numberOfAutoMarginsOnCurrentLine == 0) { @@ -2560,8 +2560,8 @@ static void YGJustifyMainAxis( leadingPaddingAndBorderMain + leadingMainDim; collectedFlexItemsValues.crossDim = 0; - float maxAscentForCurrentLine = 0; - float maxDescentForCurrentLine = 0; + YGFloat maxAscentForCurrentLine = 0; + YGFloat maxDescentForCurrentLine = 0; bool isNodeBaselineLayout = YGIsBaselineLayout(node); for (uint32_t i = startOfLineIndex; i < collectedFlexItemsValues.endOfLineIndex; @@ -2627,12 +2627,12 @@ static void YGJustifyMainAxis( if (isNodeBaselineLayout) { // If the child is baseline aligned then the cross dimension is // calculated by adding maxAscent and maxDescent from the baseline. - const float ascent = YGBaseline(child, layoutContext) + + const YGFloat ascent = YGBaseline(child, layoutContext) + child ->getLeadingMargin( YGFlexDirectionColumn, availableInnerWidth) .unwrap(); - const float descent = + const YGFloat descent = child->getLayout().measuredDimensions[YGDimensionHeight] + child ->getMarginForAxis( @@ -2736,13 +2736,13 @@ static void YGJustifyMainAxis( // static void YGNodelayoutImpl( const YGNodeRef node, - const float availableWidth, - const float availableHeight, + const YGFloat availableWidth, + const YGFloat availableHeight, const YGDirection ownerDirection, const YGMeasureMode widthMeasureMode, const YGMeasureMode heightMeasureMode, - const float ownerWidth, - const float ownerHeight, + const YGFloat ownerWidth, + const YGFloat ownerHeight, const bool performLayout, const YGConfigRef config, LayoutData& layoutMarkerData, @@ -2863,14 +2863,14 @@ static void YGNodelayoutImpl( const bool isMainAxisRow = YGFlexDirectionIsRow(mainAxis); const bool isNodeFlexWrap = node->getStyle().flexWrap() != YGWrapNoWrap; - const float mainAxisownerSize = isMainAxisRow ? ownerWidth : ownerHeight; - const float crossAxisownerSize = isMainAxisRow ? ownerHeight : ownerWidth; + const YGFloat mainAxisownerSize = isMainAxisRow ? ownerWidth : ownerHeight; + const YGFloat crossAxisownerSize = isMainAxisRow ? ownerHeight : ownerWidth; - const float leadingPaddingAndBorderCross = + const YGFloat leadingPaddingAndBorderCross = node->getLeadingPaddingAndBorder(crossAxis, ownerWidth).unwrap(); - const float paddingAndBorderAxisMain = + const YGFloat paddingAndBorderAxisMain = YGNodePaddingAndBorderForAxis(node, mainAxis, ownerWidth); - const float paddingAndBorderAxisCross = + const YGFloat paddingAndBorderAxisCross = YGNodePaddingAndBorderForAxis(node, crossAxis, ownerWidth); YGMeasureMode measureModeMainDim = @@ -2878,49 +2878,49 @@ static void YGNodelayoutImpl( YGMeasureMode measureModeCrossDim = isMainAxisRow ? heightMeasureMode : widthMeasureMode; - const float paddingAndBorderAxisRow = + const YGFloat paddingAndBorderAxisRow = isMainAxisRow ? paddingAndBorderAxisMain : paddingAndBorderAxisCross; - const float paddingAndBorderAxisColumn = + const YGFloat paddingAndBorderAxisColumn = isMainAxisRow ? paddingAndBorderAxisCross : paddingAndBorderAxisMain; - const float marginAxisRow = + const YGFloat marginAxisRow = node->getMarginForAxis(YGFlexDirectionRow, ownerWidth).unwrap(); - const float marginAxisColumn = + const YGFloat marginAxisColumn = node->getMarginForAxis(YGFlexDirectionColumn, ownerWidth).unwrap(); const auto& minDimensions = node->getStyle().minDimensions(); const auto& maxDimensions = node->getStyle().maxDimensions(); - const float minInnerWidth = + const YGFloat minInnerWidth = YGResolveValue(minDimensions[YGDimensionWidth], ownerWidth).unwrap() - paddingAndBorderAxisRow; - const float maxInnerWidth = + const YGFloat maxInnerWidth = YGResolveValue(maxDimensions[YGDimensionWidth], ownerWidth).unwrap() - paddingAndBorderAxisRow; - const float minInnerHeight = + const YGFloat minInnerHeight = YGResolveValue(minDimensions[YGDimensionHeight], ownerHeight).unwrap() - paddingAndBorderAxisColumn; - const float maxInnerHeight = + const YGFloat maxInnerHeight = YGResolveValue(maxDimensions[YGDimensionHeight], ownerHeight).unwrap() - paddingAndBorderAxisColumn; - const float minInnerMainDim = isMainAxisRow ? minInnerWidth : minInnerHeight; - const float maxInnerMainDim = isMainAxisRow ? maxInnerWidth : maxInnerHeight; + const YGFloat minInnerMainDim = isMainAxisRow ? minInnerWidth : minInnerHeight; + const YGFloat maxInnerMainDim = isMainAxisRow ? maxInnerWidth : maxInnerHeight; // STEP 2: DETERMINE AVAILABLE SIZE IN MAIN AND CROSS DIRECTIONS - float availableInnerWidth = YGNodeCalculateAvailableInnerDim( + YGFloat availableInnerWidth = YGNodeCalculateAvailableInnerDim( node, YGFlexDirectionRow, availableWidth, ownerWidth, ownerWidth); - float availableInnerHeight = YGNodeCalculateAvailableInnerDim( + YGFloat availableInnerHeight = YGNodeCalculateAvailableInnerDim( node, YGFlexDirectionColumn, availableHeight, ownerHeight, ownerWidth); - float availableInnerMainDim = + YGFloat availableInnerMainDim = isMainAxisRow ? availableInnerWidth : availableInnerHeight; - const float availableInnerCrossDim = + const YGFloat availableInnerCrossDim = isMainAxisRow ? availableInnerHeight : availableInnerWidth; // STEP 3: DETERMINE FLEX BASIS FOR EACH ITEM - float totalOuterFlexBasis = YGNodeComputeFlexBasisForChildren( + YGFloat totalOuterFlexBasis = YGNodeComputeFlexBasisForChildren( node, availableInnerWidth, availableInnerHeight, @@ -2952,10 +2952,10 @@ static void YGNodelayoutImpl( uint32_t lineCount = 0; // Accumulated cross dimensions of all lines so far. - float totalLineCrossDim = 0; + YGFloat totalLineCrossDim = 0; // Max main dimension of all the lines. - float maxLineMainDim = 0; + YGFloat maxLineMainDim = 0; YGCollectFlexItemsRowValues collectedFlexItemsValues; for (; endOfLineIndex < childCount; lineCount++, startOfLineIndex = endOfLineIndex) { @@ -3073,7 +3073,7 @@ static void YGNodelayoutImpl( performLayout, layoutContext); - float containerCrossAxis = availableInnerCrossDim; + YGFloat containerCrossAxis = availableInnerCrossDim; if (measureModeCrossDim == YGMeasureModeUndefined || measureModeCrossDim == YGMeasureModeAtMost) { // Compute the cross axis from the max cross dimension of the children. @@ -3136,7 +3136,7 @@ static void YGNodelayoutImpl( pos[crossAxis]); } } else { - float leadingCrossDim = leadingPaddingAndBorderCross; + YGFloat leadingCrossDim = leadingPaddingAndBorderCross; // For a relative children, we're either using alignItems (owner) or // alignSelf (child) in order to determine the position in the cross @@ -3153,10 +3153,10 @@ static void YGNodelayoutImpl( // no need to stretch. if (!YGNodeIsStyleDimDefined( child, crossAxis, availableInnerCrossDim)) { - float childMainSize = + YGFloat childMainSize = child->getLayout().measuredDimensions[dim[mainAxis]]; const auto& childStyle = child->getStyle(); - float childCrossSize = !childStyle.aspectRatio().isUndefined() + YGFloat childCrossSize = !childStyle.aspectRatio().isUndefined() ? child->getMarginForAxis(crossAxis, availableInnerWidth) .unwrap() + (isMainAxisRow @@ -3185,9 +3185,9 @@ static void YGNodelayoutImpl( &childCrossMeasureMode, &childCrossSize); - const float childWidth = + const YGFloat childWidth = isMainAxisRow ? childMainSize : childCrossSize; - const float childHeight = + const YGFloat childHeight = !isMainAxisRow ? childMainSize : childCrossSize; auto alignContent = node->getStyle().alignContent(); @@ -3222,7 +3222,7 @@ static void YGNodelayoutImpl( generationCount); } } else { - const float remainingCrossDim = containerCrossAxis - + const YGFloat remainingCrossDim = containerCrossAxis - YGNodeDimWithMargin(child, crossAxis, availableInnerWidth); if (child->marginLeadingValue(crossAxis).unit == YGUnitAuto && @@ -3259,10 +3259,10 @@ static void YGNodelayoutImpl( // STEP 8: MULTI-LINE CONTENT ALIGNMENT // currentLead stores the size of the cross dim if (performLayout && (isNodeFlexWrap || YGIsBaselineLayout(node))) { - float crossDimLead = 0; - float currentLead = leadingPaddingAndBorderCross; + YGFloat crossDimLead = 0; + YGFloat currentLead = leadingPaddingAndBorderCross; if (!YGFloatIsUndefined(availableInnerCrossDim)) { - const float remainingAlignContentDim = + const YGFloat remainingAlignContentDim = availableInnerCrossDim - totalLineCrossDim; switch (node->getStyle().alignContent()) { case YGAlignFlexEnd: @@ -3303,9 +3303,9 @@ static void YGNodelayoutImpl( uint32_t ii; // compute the line's height and find the endIndex - float lineHeight = 0; - float maxAscentForCurrentLine = 0; - float maxDescentForCurrentLine = 0; + YGFloat lineHeight = 0; + YGFloat maxAscentForCurrentLine = 0; + YGFloat maxDescentForCurrentLine = 0; for (ii = startIndex; ii < childCount; ii++) { const YGNodeRef child = node->getChild(ii); if (child->getStyle().display() == YGDisplayNone) { @@ -3323,12 +3323,12 @@ static void YGNodelayoutImpl( .unwrap()); } if (YGNodeAlignItem(node, child) == YGAlignBaseline) { - const float ascent = YGBaseline(child, layoutContext) + + const YGFloat ascent = YGBaseline(child, layoutContext) + child ->getLeadingMargin( YGFlexDirectionColumn, availableInnerWidth) .unwrap(); - const float descent = + const YGFloat descent = child->getLayout().measuredDimensions[YGDimensionHeight] + child ->getMarginForAxis( @@ -3373,7 +3373,7 @@ static void YGNodelayoutImpl( break; } case YGAlignCenter: { - float childHeight = + YGFloat childHeight = child->getLayout().measuredDimensions[dim[crossAxis]]; child->setLayoutPosition( @@ -3392,14 +3392,14 @@ static void YGNodelayoutImpl( // measured with the owners height yet. if (!YGNodeIsStyleDimDefined( child, crossAxis, availableInnerCrossDim)) { - const float childWidth = isMainAxisRow + const YGFloat childWidth = isMainAxisRow ? (child->getLayout() .measuredDimensions[YGDimensionWidth] + child->getMarginForAxis(mainAxis, availableInnerWidth) .unwrap()) : lineHeight; - const float childHeight = !isMainAxisRow + const YGFloat childHeight = !isMainAxisRow ? (child->getLayout() .measuredDimensions[YGDimensionHeight] + child->getMarginForAxis(crossAxis, availableInnerWidth) @@ -3631,17 +3631,17 @@ static const char* YGMeasureModeName( static inline bool YGMeasureModeSizeIsExactAndMatchesOldMeasuredSize( YGMeasureMode sizeMode, - float size, - float lastComputedSize) { + YGFloat size, + YGFloat lastComputedSize) { return sizeMode == YGMeasureModeExactly && YGFloatsEqual(size, lastComputedSize); } static inline bool YGMeasureModeOldSizeIsUnspecifiedAndStillFits( YGMeasureMode sizeMode, - float size, + YGFloat size, YGMeasureMode lastSizeMode, - float lastComputedSize) { + YGFloat lastComputedSize) { return sizeMode == YGMeasureModeAtMost && lastSizeMode == YGMeasureModeUndefined && (size >= lastComputedSize || YGFloatsEqual(size, lastComputedSize)); @@ -3649,10 +3649,10 @@ static inline bool YGMeasureModeOldSizeIsUnspecifiedAndStillFits( static inline bool YGMeasureModeNewMeasureSizeIsStricterAndStillValid( YGMeasureMode sizeMode, - float size, + YGFloat size, YGMeasureMode lastSizeMode, - float lastSize, - float lastComputedSize) { + YGFloat lastSize, + YGFloat lastComputedSize) { return lastSizeMode == YGMeasureModeAtMost && sizeMode == YGMeasureModeAtMost && !YGFloatIsUndefined(lastSize) && !YGFloatIsUndefined(size) && !YGFloatIsUndefined(lastComputedSize) && @@ -3660,7 +3660,7 @@ static inline bool YGMeasureModeNewMeasureSizeIsStricterAndStillValid( (lastComputedSize <= size || YGFloatsEqual(size, lastComputedSize)); } -YOGA_EXPORT float YGRoundValueToPixelGrid( +YOGA_EXPORT YGFloat YGRoundValueToPixelGrid( const double value, const double pointScaleFactor, const bool forceCeil, @@ -3681,8 +3681,8 @@ YOGA_EXPORT float YGRoundValueToPixelGrid( // negative number. For example, `fmodf(-2.2) = -0.2`. However, we want // `fractial` to be the number such that subtracting it from `value` will // give us `floor(value)`. In the case of negative numbers, adding 1 to - // `fmodf(value)` gives us this. Let's continue the example from above: - // - fractial = fmodf(-2.2) = -0.2 + // `fmod(value)` gives us this. Let's continue the example from above: + // - fractial = fmod(-2.2) = -0.2 // - Add 1 to the fraction: fractial2 = fractial + 1 = -0.2 + 1 = 0.8 // - Finding the `floor`: -2.2 - fractial2 = -2.2 - 0.8 = -3 ++fractial; @@ -3713,17 +3713,17 @@ YOGA_EXPORT float YGRoundValueToPixelGrid( YOGA_EXPORT bool YGNodeCanUseCachedMeasurement( const YGMeasureMode widthMode, - const float width, + const YGFloat width, const YGMeasureMode heightMode, - const float height, + const YGFloat height, const YGMeasureMode lastWidthMode, - const float lastWidth, + const YGFloat lastWidth, const YGMeasureMode lastHeightMode, - const float lastHeight, - const float lastComputedWidth, - const float lastComputedHeight, - const float marginRow, - const float marginColumn, + const YGFloat lastHeight, + const YGFloat lastComputedWidth, + const YGFloat lastComputedHeight, + const YGFloat marginRow, + const YGFloat marginColumn, const YGConfigRef config) { if ((!YGFloatIsUndefined(lastComputedHeight) && lastComputedHeight < 0) || (!YGFloatIsUndefined(lastComputedWidth) && lastComputedWidth < 0)) { @@ -3731,17 +3731,17 @@ YOGA_EXPORT bool YGNodeCanUseCachedMeasurement( } bool useRoundedComparison = config != nullptr && config->pointScaleFactor != 0; - const float effectiveWidth = useRoundedComparison + const YGFloat effectiveWidth = useRoundedComparison ? YGRoundValueToPixelGrid(width, config->pointScaleFactor, false, false) : width; - const float effectiveHeight = useRoundedComparison + const YGFloat effectiveHeight = useRoundedComparison ? YGRoundValueToPixelGrid(height, config->pointScaleFactor, false, false) : height; - const float effectiveLastWidth = useRoundedComparison + const YGFloat effectiveLastWidth = useRoundedComparison ? YGRoundValueToPixelGrid( lastWidth, config->pointScaleFactor, false, false) : lastWidth; - const float effectiveLastHeight = useRoundedComparison + const YGFloat effectiveLastHeight = useRoundedComparison ? YGRoundValueToPixelGrid( lastHeight, config->pointScaleFactor, false, false) : lastHeight; @@ -3793,13 +3793,13 @@ YOGA_EXPORT bool YGNodeCanUseCachedMeasurement( // bool YGLayoutNodeInternal( const YGNodeRef node, - const float availableWidth, - const float availableHeight, + const YGFloat availableWidth, + const YGFloat availableHeight, const YGDirection ownerDirection, const YGMeasureMode widthMeasureMode, const YGMeasureMode heightMeasureMode, - const float ownerWidth, - const float ownerHeight, + const YGFloat ownerWidth, + const YGFloat ownerHeight, const bool performLayout, const LayoutPassReason reason, const YGConfigRef config, @@ -3837,9 +3837,9 @@ bool YGLayoutNodeInternal( // they are the most expensive to measure, so it's worth avoiding redundant // measurements if at all possible. if (node->hasMeasureFunc()) { - const float marginAxisRow = + const YGFloat marginAxisRow = node->getMarginForAxis(YGFlexDirectionRow, ownerWidth).unwrap(); - const float marginAxisColumn = + const YGFloat marginAxisColumn = node->getMarginForAxis(YGFlexDirectionColumn, ownerWidth).unwrap(); // First, try to use the layout cache. @@ -4061,7 +4061,7 @@ bool YGLayoutNodeInternal( YOGA_EXPORT void YGConfigSetPointScaleFactor( const YGConfigRef config, - const float pixelsInPoint) { + const YGFloat pixelsInPoint) { YGAssertWithConfig( config, pixelsInPoint >= 0.0f, @@ -4158,8 +4158,8 @@ static void unsetUseLegacyFlagRecursively(YGNodeRef node) { YOGA_EXPORT void YGNodeCalculateLayoutWithContext( const YGNodeRef node, - const float ownerWidth, - const float ownerHeight, + const YGFloat ownerWidth, + const YGFloat ownerHeight, const YGDirection ownerDirection, void* layoutContext) { @@ -4171,7 +4171,7 @@ YOGA_EXPORT void YGNodeCalculateLayoutWithContext( // the input parameters don't change. gCurrentGenerationCount.fetch_add(1, std::memory_order_relaxed); node->resolveDimension(); - float width = YGUndefined; + YGFloat width = YGUndefined; YGMeasureMode widthMeasureMode = YGMeasureModeUndefined; const auto& maxDimensions = node->getStyle().maxDimensions(); if (YGNodeIsStyleDimDefined(node, YGFlexDirectionRow, ownerWidth)) { @@ -4192,7 +4192,7 @@ YOGA_EXPORT void YGNodeCalculateLayoutWithContext( : YGMeasureModeExactly; } - float height = YGUndefined; + YGFloat height = YGUndefined; YGMeasureMode heightMeasureMode = YGMeasureModeUndefined; if (YGNodeIsStyleDimDefined(node, YGFlexDirectionColumn, ownerHeight)) { height = (YGResolveValue( @@ -4310,8 +4310,8 @@ YOGA_EXPORT void YGNodeCalculateLayoutWithContext( YOGA_EXPORT void YGNodeCalculateLayout( const YGNodeRef node, - const float ownerWidth, - const float ownerHeight, + const YGFloat ownerWidth, + const YGFloat ownerHeight, const YGDirection ownerDirection) { YGNodeCalculateLayoutWithContext( node, ownerWidth, ownerHeight, ownerDirection, nullptr); diff --git a/yoga/Yoga.h b/yoga/Yoga.h index 36331622..c4d5cf8f 100644 --- a/yoga/Yoga.h +++ b/yoga/Yoga.h @@ -25,8 +25,8 @@ YG_EXTERN_C_BEGIN typedef struct YGSize { - float width; - float height; + YGFloat width; + YGFloat height; } YGSize; typedef struct YGConfig* YGConfigRef; @@ -36,11 +36,11 @@ typedef const struct YGNode* YGNodeConstRef; typedef YGSize (*YGMeasureFunc)( YGNodeRef node, - float width, + YGFloat width, YGMeasureMode widthMode, - float height, + YGFloat height, YGMeasureMode heightMode); -typedef float (*YGBaselineFunc)(YGNodeRef node, float width, float height); +typedef YGFloat (*YGBaselineFunc)(YGNodeRef node, YGFloat width, YGFloat height); typedef void (*YGDirtiedFunc)(YGNodeRef node); typedef void (*YGPrintFunc)(YGNodeRef node); typedef void (*YGNodeCleanupFunc)(YGNodeRef node); @@ -93,8 +93,8 @@ WIN_EXPORT bool YGNodeIsReferenceBaseline(YGNodeRef node); WIN_EXPORT void YGNodeCalculateLayout( YGNodeRef node, - float availableWidth, - float availableHeight, + YGFloat availableWidth, + YGFloat availableHeight, YGDirection ownerDirection); // Mark a node as dirty. Only valid for nodes with a custom measure function @@ -113,21 +113,21 @@ WIN_EXPORT void YGNodeMarkDirtyAndPropogateToDescendants(YGNodeRef node); WIN_EXPORT void YGNodePrint(YGNodeRef node, YGPrintOptions options); -WIN_EXPORT bool YGFloatIsUndefined(float value); +WIN_EXPORT bool YGFloatIsUndefined(YGFloat value); WIN_EXPORT bool YGNodeCanUseCachedMeasurement( YGMeasureMode widthMode, - float width, + YGFloat width, YGMeasureMode heightMode, - float height, + YGFloat height, YGMeasureMode lastWidthMode, - float lastWidth, + YGFloat lastWidth, YGMeasureMode lastHeightMode, - float lastHeight, - float lastComputedWidth, - float lastComputedHeight, - float marginRow, - float marginColumn, + YGFloat lastHeight, + YGFloat lastComputedWidth, + YGFloat lastComputedHeight, + YGFloat marginRow, + YGFloat marginColumn, YGConfigRef config); WIN_EXPORT void YGNodeCopyStyle(YGNodeRef dstNode, YGNodeRef srcNode); @@ -187,75 +187,75 @@ WIN_EXPORT YGOverflow YGNodeStyleGetOverflow(YGNodeConstRef node); WIN_EXPORT void YGNodeStyleSetDisplay(YGNodeRef node, YGDisplay display); WIN_EXPORT YGDisplay YGNodeStyleGetDisplay(YGNodeConstRef node); -WIN_EXPORT void YGNodeStyleSetFlex(YGNodeRef node, float flex); -WIN_EXPORT float YGNodeStyleGetFlex(YGNodeConstRef node); +WIN_EXPORT void YGNodeStyleSetFlex(YGNodeRef node, YGFloat flex); +WIN_EXPORT YGFloat YGNodeStyleGetFlex(YGNodeConstRef node); -WIN_EXPORT void YGNodeStyleSetFlexGrow(YGNodeRef node, float flexGrow); -WIN_EXPORT float YGNodeStyleGetFlexGrow(YGNodeConstRef node); +WIN_EXPORT void YGNodeStyleSetFlexGrow(YGNodeRef node, YGFloat flexGrow); +WIN_EXPORT YGFloat YGNodeStyleGetFlexGrow(YGNodeConstRef node); -WIN_EXPORT void YGNodeStyleSetFlexShrink(YGNodeRef node, float flexShrink); -WIN_EXPORT float YGNodeStyleGetFlexShrink(YGNodeConstRef node); +WIN_EXPORT void YGNodeStyleSetFlexShrink(YGNodeRef node, YGFloat flexShrink); +WIN_EXPORT YGFloat YGNodeStyleGetFlexShrink(YGNodeConstRef node); -WIN_EXPORT void YGNodeStyleSetFlexBasis(YGNodeRef node, float flexBasis); -WIN_EXPORT void YGNodeStyleSetFlexBasisPercent(YGNodeRef node, float flexBasis); +WIN_EXPORT void YGNodeStyleSetFlexBasis(YGNodeRef node, YGFloat flexBasis); +WIN_EXPORT void YGNodeStyleSetFlexBasisPercent(YGNodeRef node, YGFloat flexBasis); WIN_EXPORT void YGNodeStyleSetFlexBasisAuto(YGNodeRef node); WIN_EXPORT YGValue YGNodeStyleGetFlexBasis(YGNodeConstRef node); WIN_EXPORT void YGNodeStyleSetPosition( YGNodeRef node, YGEdge edge, - float position); + YGFloat position); WIN_EXPORT void YGNodeStyleSetPositionPercent( YGNodeRef node, YGEdge edge, - float position); + YGFloat position); WIN_EXPORT YGValue YGNodeStyleGetPosition(YGNodeConstRef node, YGEdge edge); -WIN_EXPORT void YGNodeStyleSetMargin(YGNodeRef node, YGEdge edge, float margin); +WIN_EXPORT void YGNodeStyleSetMargin(YGNodeRef node, YGEdge edge, YGFloat margin); WIN_EXPORT void YGNodeStyleSetMarginPercent( YGNodeRef node, YGEdge edge, - float margin); + YGFloat margin); WIN_EXPORT void YGNodeStyleSetMarginAuto(YGNodeRef node, YGEdge edge); WIN_EXPORT YGValue YGNodeStyleGetMargin(YGNodeConstRef node, YGEdge edge); WIN_EXPORT void YGNodeStyleSetPadding( YGNodeRef node, YGEdge edge, - float padding); + YGFloat padding); WIN_EXPORT void YGNodeStyleSetPaddingPercent( YGNodeRef node, YGEdge edge, - float padding); + YGFloat padding); WIN_EXPORT YGValue YGNodeStyleGetPadding(YGNodeConstRef node, YGEdge edge); -WIN_EXPORT void YGNodeStyleSetBorder(YGNodeRef node, YGEdge edge, float border); -WIN_EXPORT float YGNodeStyleGetBorder(YGNodeConstRef node, YGEdge edge); +WIN_EXPORT void YGNodeStyleSetBorder(YGNodeRef node, YGEdge edge, YGFloat border); +WIN_EXPORT YGFloat YGNodeStyleGetBorder(YGNodeConstRef node, YGEdge edge); -WIN_EXPORT void YGNodeStyleSetWidth(YGNodeRef node, float width); -WIN_EXPORT void YGNodeStyleSetWidthPercent(YGNodeRef node, float width); +WIN_EXPORT void YGNodeStyleSetWidth(YGNodeRef node, YGFloat width); +WIN_EXPORT void YGNodeStyleSetWidthPercent(YGNodeRef node, YGFloat width); WIN_EXPORT void YGNodeStyleSetWidthAuto(YGNodeRef node); WIN_EXPORT YGValue YGNodeStyleGetWidth(YGNodeConstRef node); -WIN_EXPORT void YGNodeStyleSetHeight(YGNodeRef node, float height); -WIN_EXPORT void YGNodeStyleSetHeightPercent(YGNodeRef node, float height); +WIN_EXPORT void YGNodeStyleSetHeight(YGNodeRef node, YGFloat height); +WIN_EXPORT void YGNodeStyleSetHeightPercent(YGNodeRef node, YGFloat height); WIN_EXPORT void YGNodeStyleSetHeightAuto(YGNodeRef node); WIN_EXPORT YGValue YGNodeStyleGetHeight(YGNodeConstRef node); -WIN_EXPORT void YGNodeStyleSetMinWidth(YGNodeRef node, float minWidth); -WIN_EXPORT void YGNodeStyleSetMinWidthPercent(YGNodeRef node, float minWidth); +WIN_EXPORT void YGNodeStyleSetMinWidth(YGNodeRef node, YGFloat minWidth); +WIN_EXPORT void YGNodeStyleSetMinWidthPercent(YGNodeRef node, YGFloat minWidth); WIN_EXPORT YGValue YGNodeStyleGetMinWidth(YGNodeConstRef node); -WIN_EXPORT void YGNodeStyleSetMinHeight(YGNodeRef node, float minHeight); -WIN_EXPORT void YGNodeStyleSetMinHeightPercent(YGNodeRef node, float minHeight); +WIN_EXPORT void YGNodeStyleSetMinHeight(YGNodeRef node, YGFloat minHeight); +WIN_EXPORT void YGNodeStyleSetMinHeightPercent(YGNodeRef node, YGFloat minHeight); WIN_EXPORT YGValue YGNodeStyleGetMinHeight(YGNodeConstRef node); -WIN_EXPORT void YGNodeStyleSetMaxWidth(YGNodeRef node, float maxWidth); -WIN_EXPORT void YGNodeStyleSetMaxWidthPercent(YGNodeRef node, float maxWidth); +WIN_EXPORT void YGNodeStyleSetMaxWidth(YGNodeRef node, YGFloat maxWidth); +WIN_EXPORT void YGNodeStyleSetMaxWidthPercent(YGNodeRef node, YGFloat maxWidth); WIN_EXPORT YGValue YGNodeStyleGetMaxWidth(YGNodeConstRef node); -WIN_EXPORT void YGNodeStyleSetMaxHeight(YGNodeRef node, float maxHeight); -WIN_EXPORT void YGNodeStyleSetMaxHeightPercent(YGNodeRef node, float maxHeight); +WIN_EXPORT void YGNodeStyleSetMaxHeight(YGNodeRef node, YGFloat maxHeight); +WIN_EXPORT void YGNodeStyleSetMaxHeightPercent(YGNodeRef node, YGFloat maxHeight); WIN_EXPORT YGValue YGNodeStyleGetMaxHeight(YGNodeConstRef node); // Yoga specific properties, not compatible with flexbox specification Aspect @@ -273,15 +273,15 @@ WIN_EXPORT YGValue YGNodeStyleGetMaxHeight(YGNodeConstRef node); // - On a node with flex grow/shrink aspect ratio controls the size of the node // in the cross axis if unset // - Aspect ratio takes min/max dimensions into account -WIN_EXPORT void YGNodeStyleSetAspectRatio(YGNodeRef node, float aspectRatio); -WIN_EXPORT float YGNodeStyleGetAspectRatio(YGNodeConstRef node); +WIN_EXPORT void YGNodeStyleSetAspectRatio(YGNodeRef node, YGFloat aspectRatio); +WIN_EXPORT YGFloat YGNodeStyleGetAspectRatio(YGNodeConstRef node); -WIN_EXPORT float YGNodeLayoutGetLeft(YGNodeRef node); -WIN_EXPORT float YGNodeLayoutGetTop(YGNodeRef node); -WIN_EXPORT float YGNodeLayoutGetRight(YGNodeRef node); -WIN_EXPORT float YGNodeLayoutGetBottom(YGNodeRef node); -WIN_EXPORT float YGNodeLayoutGetWidth(YGNodeRef node); -WIN_EXPORT float YGNodeLayoutGetHeight(YGNodeRef node); +WIN_EXPORT YGFloat YGNodeLayoutGetLeft(YGNodeRef node); +WIN_EXPORT YGFloat YGNodeLayoutGetTop(YGNodeRef node); +WIN_EXPORT YGFloat YGNodeLayoutGetRight(YGNodeRef node); +WIN_EXPORT YGFloat YGNodeLayoutGetBottom(YGNodeRef node); +WIN_EXPORT YGFloat YGNodeLayoutGetWidth(YGNodeRef node); +WIN_EXPORT YGFloat YGNodeLayoutGetHeight(YGNodeRef node); WIN_EXPORT YGDirection YGNodeLayoutGetDirection(YGNodeRef node); WIN_EXPORT bool YGNodeLayoutGetHadOverflow(YGNodeRef node); bool YGNodeLayoutGetDidLegacyStretchFlagAffectLayout(YGNodeRef node); @@ -290,9 +290,9 @@ bool YGNodeLayoutGetDidLegacyStretchFlagAffectLayout(YGNodeRef node); // set using point values then the returned value will be the same as // YGNodeStyleGetXXX. However if they were set using a percentage value then the // returned value is the computed value used during layout. -WIN_EXPORT float YGNodeLayoutGetMargin(YGNodeRef node, YGEdge edge); -WIN_EXPORT float YGNodeLayoutGetBorder(YGNodeRef node, YGEdge edge); -WIN_EXPORT float YGNodeLayoutGetPadding(YGNodeRef node, YGEdge edge); +WIN_EXPORT YGFloat YGNodeLayoutGetMargin(YGNodeRef node, YGEdge edge); +WIN_EXPORT YGFloat YGNodeLayoutGetBorder(YGNodeRef node, YGEdge edge); +WIN_EXPORT YGFloat YGNodeLayoutGetPadding(YGNodeRef node, YGEdge edge); WIN_EXPORT void YGConfigSetLogger(YGConfigRef config, YGLogger logger); WIN_EXPORT void YGAssert(bool condition, const char* message); @@ -308,7 +308,7 @@ WIN_EXPORT void YGAssertWithConfig( // want to avoid rounding - set PointScaleFactor to 0 WIN_EXPORT void YGConfigSetPointScaleFactor( YGConfigRef config, - float pixelsInPoint); + YGFloat pixelsInPoint); void YGConfigSetShouldDiffLayoutWithoutLegacyStretchBehaviour( YGConfigRef config, bool shouldDiffLayout); @@ -351,7 +351,7 @@ WIN_EXPORT YGConfigRef YGConfigGetDefault(void); WIN_EXPORT void YGConfigSetContext(YGConfigRef config, void* context); WIN_EXPORT void* YGConfigGetContext(YGConfigRef config); -WIN_EXPORT float YGRoundValueToPixelGrid( +WIN_EXPORT YGFloat YGRoundValueToPixelGrid( double value, double pointScaleFactor, bool forceCeil, diff --git a/yoga/event/event.h b/yoga/event/event.h index 404ec376..c7ce6219 100644 --- a/yoga/event/event.h +++ b/yoga/event/event.h @@ -127,12 +127,12 @@ struct Event::TypedData { template <> struct Event::TypedData { void* layoutContext; - float width; + YGFloat width; YGMeasureMode widthMeasureMode; - float height; + YGFloat height; YGMeasureMode heightMeasureMode; - float measuredWidth; - float measuredHeight; + YGFloat measuredWidth; + YGFloat measuredHeight; const LayoutPassReason reason; };